text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# ZFS: архитектура, особенности и отличия от других файловых систем
[*Frozen cells by arbebuk*](https://www.deviantart.com/arbebuk/art/frozen-cells-507629144)
Я, Георгий Меликов, являюсь контрибьютором проектов OpenZFS и ZFS on Linux. Также я занимаюсь разработкой IaaS в команде облачной платформы [Mail.ru Cloud Solutions](https://mcs.mail.ru/). Хотя в продакшене нашего подразделения мы и не используем ZFS, но хозяева подкаста [SDCast](https://sdcast.ksdaemon.ru/) пригласили меня рассказать именно о нём. Из выпуска и родилась эта статья, а [вот тут можно послушать аудиоверсию](https://sdcast.ksdaemon.ru/2020/09/sdcast-122/).
Итак, сегодня я рассказываю про ZFS. Как устроена файловая система ZFS, из каких компонентов она состоит и как работает, а также про новые фичи, которые появились или скоро появятся в последних релизах.
### ZFS и ее отличия от других решений на примере Linux
ZFS — это симбиоз файловой системы и менеджера томов, которая предоставляет инструменты для простого управления дисковым массивом.
Любая файловая система — это абстракция для удобного хранения данных. Каждая файловая система разрабатывалась под определенные требования: сколько у нее будет дисков, какая система хранения под капотом и так далее. Например, семейство EXT — очень простая система, вдохновлённая UFS, XFS — система с упором на параллельный доступ, а ZFS стремится быть системой, включающей в себя всё нужное для создания больших локальных хранилищ, в частности это отражается и на удобстве эксплуатации.
В Linux как де-факто стандарт используется менеджер логических томов (Logical Volume Manager, LVM), который также предлагает некоторые абстракции над нижележащим блочным устройством — можно создавать абстракции в виде Physical Volume, Logical Volume и так далее. По сути, можно делать то же самое, что с ZFS, но другими методами, добавив ещё кучу слоёв к LVM.
Плюсы ZFS в том, что он знает, что и где лежит, группирует это и дает некоторые другие фишки, в частности безопасное хранение данных — эта файловая система сделана с упором на целостность. Сейчас это (на мой скромный взгляд) лучшее из опенсорсных кроссплатформенных предложений на рынке. Конечно, можно собрать хранилище и без ZFS, но это будет хуже по производительности, т. к. для достижения хотя бы отдалённого паритета по функциональности придётся использовать много слоёв (LVM, mdadm, dm-integrity, что-то для дедупликации и компрессии). К сожалению, каждый слой даёт немалое пенальти.
### Основы ZFS
ZFS — это copy-on-write файловая система, она никогда не перезаписывает данные. Мы всегда оперируем новым блоком, для обеспечения консистентности данных не нужен журнал, как в большинстве других файловых систем.
У баз данных типа MySQL и PostgreSQL есть так называемый WAL-лог. По умолчанию все данные пишутся в виде лога, потом записываются в блок данных на диске, получается двойная запись. При этом надо ждать, когда файловая система подтвердит, что данные на диске.
Copy-on-write дает следующее преимущество: старые данные не меняются, можно не вести журнал и восстановить данные, записанные ранее. Мы не боимся повреждения данных, так как их нельзя повредить, новый вариант блока запишется в новое место, не затирая старый.
Сам copy-on-write процесс не гарантирует консистентность данных, но если рассматривать ZFS, то в основе его работы лежит [дерево Меркла, или Хэш-дерево](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D1%85%D0%B5%D1%88%D0%B5%D0%B9). У ZFS всегда консистентное состояние за счет того, что он использует атомарные транзакции. Есть дерево блоков, для каждого из них с самого нижнего блока подсчитывается хеш-сумма и так доходит до самого верхнего блока. Хеш-сумма верхнего блока (uberblock) позволяет валидировать состояние всей файловой системы на момент транзакции.
Визуализация дерева блоков. Источник: https://ritlug.com/talks/slides/2019-spring-w08-zfs.pdfОднако из-за того, что copy-on-write система никогда не пишет в одно и то же место появляется проблема фрагментации данных. Также надо решать вопрос чтения и его эффективности. С SSD эта проблема по большей части решается, но она ощутима при работе на жестких дисках.
ZFS, как и любой copy-on-write системе, нужно иметь на дисках запас свободного места, чтобы было куда записывать данные, которые всегда пишутся в новое место. К этому добавляется проблема порядка записи, следующие блоки одного файла будут записаны в другое место на диске, то есть в наличии непростая задача по эффективному аллоцированию данных. Однако и в классических файловых системах фрагментации можно избежать, только переалоцировав последовательно отрезок и работая только с ним. По факту мы так возвращаемся к прибиванию сущностей программы к конкретному диску, а это менее удобно (а любая ФС, как мы говорили раньше, стремится облегчить жизнь разработчику).
### Преимущества ZFS
Давайте же поговорим о плюсах, зачем вообще стоит выбирать ZFS:
**Целостность и консистентность** — ZFS сделан для максимальной надежности. По умолчанию на все данные подсчитываются контрольные суммы, а для метаданных записывается минимум по две копии в разных местах диска. Есть такой миф, что для ZFS нужна ЕСС-память, на самом деле — она нужна для любой файловой системы для исключения записи некорректных данных, просто в ZFS об этом честно говорят.
**Сжатие на лету**. К примеру, используя алгоритм сжатия LZ4 система без проблем выдает 800 Мбайт в секунду на одно ядро на запись и до 4.5 Гбайт в секунду — на чтение. Соответственно, если мы говорим про многопоточную нагрузку, то при наличии свободного процессорного времени его можно эффективно утилизировать. В таком случае можно сэкономить не только место на диске, но и IOPS жесткого диска взамен ресурсов процессора за счет меньшего количества операций к диску. Есть интересные кейсы, к примеру использование MySQL, когда при этом под нами не очень дорогой SSD или простой HDD — тогда, включив LZ4, можно хорошо выиграть по многопоточной производительности, немного увеличив latency каждого потока.
**Атомарность**. В ZFS все атомарно за счет того, что в основе лежит дерево Меркла. Если наша файловая система всегда атомарна, то можно отказаться от WAL-лога в приложениях, потому что целостность блоков гарантируется транзакционностью файловой системы. Тут есть нюансы: нужно уметь говорить с файловой системой на ее языке, манипулировать транзакциями. Отдельный вопрос, что эти логи некоторые базы данных используют для репликации. Но в целом — можно так экономить на ресурсах.
Этот нюанс может быть и минусом: работа через дерево Меркла не бесплатна — чтобы приобрести консистентное состояние, нужно провести все манипуляции по подсчету хеш-сумм. Это дорого в первую очередь относительно процессора. Со стороны доступа к данным — что-то требует больше ресурсов по сравнению с классическими файловыми системами, а что-то меньше, например, мы экономим на том же журнале.
**«Бесплатные» снапшоты**. Создание снапшота в ZFS по времени константно и не накладывает дополнительных расходов на работу с этими данными. Снапшоты удобно передавать, в том числе инкрементально, Те, кто пользуется бэкапами через Rsync или другие инструменты, сталкиваются с такой проблемой — нужно проверять, какая часть данных изменилась. А здесь можно отправить снапшот инкрементально, целостность будет проверена и подтверждена на другой стороне.
Снапшот, по сути, тег, то есть ссылка на некую версию, всех данных всех блоков, из которых она состоит, начиная от корневого блока. Это специально помеченный самый верхний корневой блок, с которого начинается дерево. За этот счёт получение инкрементального среза изменённых данных равнозначно получению блоков из транзакции, на которую и указывает снапшот, то есть не требуется проверка какие блоки изменились, у нас уже есть ссылка только на модифицированные. Как пример использования снапшотов можно привести быстрое развертывание разных версий для тестирования дампов баз данных, того же PostgreSQL.
### Архитектура ZFS
Посмотрим, как устроена ZFS изнутри. Есть набор дисков, над ним появляется абстракция в виде виртуального устройства (device). В терминологии ZFS — это Vdev, сокращение от virtual device. Есть разные реализации Vdev: Mirror (зеркало), который дублирует как есть информацию на два диска, RAID-Z, похожий по логике работы на классические RAID 5, 6 или 7. Также на подходе новый dRAID, о котором поговорим позже.
Составные части пула. Источник: https://forums.lawrencesystems.com/t/freenas-zfs-pools-raidz-raidz2-raidz3-capacity-integrity-and-performance/3569Как конкретно мы храним и резервируем данные — с упором на производительность или на объём полезного пространства — это ответственность Vdev. Из набора Vdev’ов мы составляем общий пул. Если перевернуть на классическое понимание того же mdadm, чтобы собрать RAID 10, то есть набор мирроров, нужно сделать несколько Vdev Mirror и объединить их в один пул. Каждый Vdev — это, по сути, stripe, то есть отдельная виртуальная единица хранения. В рамках пула каждый уникальный блок данных будет храниться только на одном Vdev.
Логически элементы ZFS делятся на 3 подсистемы:
1. SPA (Storage Pool Allocator) — отвечает непосредственно за нарезку на диски, хранение данных на диске. Этот элемент отвечает за то, куда кладется конкретный блок данных, но с абстракцией от диска. Когда мы к нему обращаемся, то видим единое пространство, вне зависимости от набора конкретных Vdev’ов.
2. DMU (Data Management Unit) — на этом уровне ZFS представляется обычным объектным хранилищем. Есть реализации, когда ее так и используют с некоторыми модификациями. К примеру, распределённая файловая система Lustre реализует свой слой поверх DMU ZFS.
3. Следующий уровень DSL (Data and Snapshot Layer) пользуется этим объектным хранилищем. Этот компонент занимается непосредственно файловыми системами, снапшотами, то есть логикой, которая реализует POSIX-совместимую файловую систему (в него входит слой ZPL — ZFS POSIX layer).
Сравнение интерфейсов классических ФС и ZFS. Источник: https://slideplayer.com/slide/11350106/ Также в ZFS есть другие подсистемы, которые нужны для эффективной совместной работы всех этих слоёв.
**ARC (Adaptive Replacement Cache)**. Его разработали, чтобы решить проблему с чтением. ARC примечателен тем, что делает упор не только на трекинг тех объектов, что были использованы последними (LRU-cache), но и на трекинг частоиспользуемых объектов, которые он и кэширует (MFU-cache).
У классического page cache Linux’а есть проблема вымывания: если прочесть файл, размер которого превышает объем оперативной памяти, то старые данные из кэша вымоются, так как по умолчанию файл будет загружен в page cache.
ARC — это умная замена page cache. Когда создавался ZFS, часто использовали жесткие диски, а у них маленькие IOPS. Чтение copy-on-write данных — по умолчанию случайная операция, чтобы её ускорить, используют разные ухищрения, например, аккумулируют данные, записывают большим блоком и так далее, но эти оптимизации не всегда срабатывают. На этот случай нужно умное кеширование. Нормально, если при штатной работе 99% запросов чтения попадает в кэш, если меньше, значит, что-то не так, стоит добавить оперативной памяти.
Если ARC не всегда полностью помещается в память, есть варианты вынести кэш на более быстрый отдельный SSD — это называется L2ARC (Layer 2 ARC).
**ZIL (ZFS intent log)**. Мы пишем данные в ZFS транзакциями, это набор дорогостоящих операций: подсчет хэш-сумм, построение дерева, запись метаданных, которые пишутся для безопасности несколько раз в разные места дисков. Поэтому мы стараемся набить каждую транзакцию максимальным количеством данных. Тут (сюрприз) появляется определенного вида журнал, без которого не обойтись, если нужна быстрая синхронная запись и критична задержка. Только здесь он вынесен как сущность, что позволяет использовать разные решения для персистентного хранения кусочка синхронной записи. Этот журнал обычно очень маленький, его записью и занимается ZIL (ZFS intent log).
ARC и ZIL — хотя это и необязательные с технической стороны компоненты, но они нужны для обеспечения высокой производительности хранилища, без них система будет работать медленнее. ZFS в продакшене чаще применяют для крупных инсталляций хранилища данных. Архитектура подразумевает эффективную утилизацию большого количества HDD, SSD, RAM, CPU.
### Паттерны использования ZFS и типовые конфигурации
ZFS — это локальное хранилище, когда мы говорим про него, то по умолчанию подразумеваем хранилище в рамках одного хоста. У него огромный спектр применения:
1. ZFS подходит для домашнего использования, где не самое дорогое оборудование и не самые быстрые диски, можно использовать процессор на дополнительные вычисления (т.к. он обычно простаивает). Плюсы ZFS в том, что это удобный конструктор. Необязательно задействовать отдельные SSD, можно создать пул даже прямо на файлике, что удобно для тестов.
2. Другой классический вариант — NFS-хранилище, там больше дисков, начинаем задумываться о синхронной записи, кэше и тут можно подставить дополнительные блоки в виде SSD.
3. Также ZFS можно использовать в качестве крупного хранилища, когда в рамках одного пула более ста дисков, все это должно работать и восстанавливаться, если диски вылетели, а это проблема любого большого хранилища.
Блоки типа ARC, ZIL и так далее — это не диски, которые мы можем использовать, это понятия виртуальные, они всегда есть в ZFS. У нас есть возможность вынести их на более быстрые отдельные носители.
ZIL можно вынести на так называемый Slog, которому не нужно быть большим, так как синхронная запись обычно идет мелким блоком и быстро сбрасывается на основное хранилище. То есть важно как можно быстрее записать конкретный блок данных и отрапортовать клиенту об успешной записи, а не записать как можно больше данных (*привет, СУБД!*). Slog нужен на чтение только при сбое питания.
ARC можно дополнить одним или более SSD и выгружать на него определенный вид данных, например, кэшировать только метаданные или данные, которые последовательно или случайно прочитались с основного хранилища.
Есть много вариаций настройки ZFS. Можно оптимизировать любой профиль нагрузки, начиная от размера блока, которым мы оперируем. Например, когда мы хотим оптимизировать copy-on-write, то можем писать бо́льшим блоком, чем в классических файловых системах, для ZFS по умолчанию принят объем в 128 КБайт на блок.
### Плюсы и минусы ZFS по сравнению с аппаратными решениями
У аппаратного решения есть плюсы: мы переносим определенную вычислительную нагрузку на его процессор, надеясь, что он с ней справится. Также можно использовать аппаратный RAID-контроллер с энергонезависимой памятью или кэшем, переложить ответственность за проблему с синхронной записью на него.
С ZFS мы используем процессор, нужно решать вопрос синхронной записи отдельно, однако, мы не завязаны на железо, можем работать где угодно. ZFS не надо указывать порядок дисков, достаточно указывать директорию, в которой они находятся, и система сама из них соберет пул.
Минусы аппаратного решения в том, что в случае выхода из строя нужно искать полный аналог. Аппаратный RAID ничего не знает про данные, только про блоки, следовательно, не может как-то оптимизироваться под конкретную ситуацию.
И есть еще момент, который редко упоминается: в случае аппаратных и других софтверных решений — мы настраиваем их единожды, то есть у нас есть общие настройки: один размер блока, такие-то страйпы и так далее. После настройки есть том, с которым можно эффективно работать только с заданными настройками. Отсюда еще один плюс ZFS — возможность настроить один пул под разные нагрузки через создание отдельных датасетов с различными настройками.
Датасет — отдельная файловая система в терминологии ZFS со своими настройками. К примеру, для СУБД можно создать отдельное пространство под основные данные с размером блока 8 Кбайт и отдельный датасет, оптимизированный под WAL-лог с размером блока 16 Кбайт. При этом все будет эффективно работать. Хочется сжимать одни данные — отлично, `zfs set compression=on`. Другие данные читаются очень редко и могут без надобности вымывать ARC — без проблем, `zfs set primarycache=metadata`.
Имея один пул, можно настраивать под конкретную операцию хоть каждый датасет. Мы максимально подстраиваемся под приложения. То есть ZFS — очень гибкое софтверное решение.
В случае ZFS все метаданные об ФС пишутся условно в заголовок диска. Если сломался сервер, можно просто вытащить диски и перенести на другой сервер. Если там совместимая версия ZFS, то система их просканирует и снова соберет тот же самый пул.
Любое софтверное решение позволяет так делать, так как рядом с данными хранится информация о строении этого массива. Но ZFS хранит эту информацию на каждом диске — даже не надо указывать порядок, достаточно указать, что где-то есть пул, его надо импортировать. Система либо соберет его, либо покажет, что пошло не так. Также состояние пула можно откатить на несколько транзакций назад, если в них была ошибка.
### Особенности работы ZFS
#### Фрагментация данных
В copy-on-write системе постоянно появляются новые блоки, а старые не всегда пригодны к удалению. Часто возникают ситуации, когда старый блок не полностью записан, какие-то блоки не нужны, появились «дырки» (пустые пространства небольшого размера) и так далее.
В ZFS пространство разрезано на так называемые metaslabs, которые ведут трекинг того, какие сектора свободны, а какие заняты. Это происходит на уровне SPA — слоя, который работает с дисками.
В рамках этих пространств мы при каждом аллоцировании пытаемся найти наиболее подходящее по определенному алгоритму. Когда в пуле много места, то выбираем пространство с самым большим объемом свободного места, куда будет лучше записать данные с точки зрения дальнейшей фрагментации. Например, если у нас 1 Мбайт данных, мы ищем свободный блок в 1 Мбайт и можем туда цельно записать данные.
Когда места становится мало, включается другой режим аллокации — он дороже с точки зрения производительности и приводит к росту фрагментации, в этом режиме просто ищется первое попавшееся подходящее место. В худшем случае, когда под блок уже нет безразрывного отрезка, он будет разбит и записан кусками (что тоже не идёт на пользу производительности).
По умолчанию на каждый Vdev создается ~200 meta-slabs. Если что-то изменилось, то надо метаданные по этим 200 meta-slabs записывать каждый раз для каждого Vdev. Сейчас это пишется постоянно на каждый Vdev, но уже перед релизом патч, который записывает информацию об изменениях в meta-slabs в виде лога на один из Vdev, а потом регулярно применяет этот лог. Это чем-то похоже на WAL-лог базы данных. Соответственно, уменьшается нагрузка на запись на диск информации о metaslabs.
Конечно, при заполнении всего места возникает проблема, но на эту ситуацию любая copy-on-write файловая система (да и традиционная тоже) закладывает какой-то процент зарезервированного места для работы, без этого с динамической аллокацией никак.
#### Запись данных
По умолчанию чтение данных в ZFS практически всегда является случайным, но так как мы пишем каждый раз в новое место, то можем превращать случайную запись в практически последовательную. Если нужна система хранения под запись и редкое чтение, то любая copy-on-write система, в том числе ZFS, будет отличным решением. Данные пишутся группами транзакций (txg, сокращённое от transaction groups), можно агрегировать информацию в рамках этой группы.
Тут есть особенность: существует [Write Throttling](https://openzfs.github.io/openzfs-docs/Performance%20and%20Tuning/ZFS%20Transaction%20Delay.html) — мы можем использовать неограниченное количество оперативной памяти для подготовки txg-группы и за счет этого переживать резкие скачки записи, буферизируя все в оперативную память. Естественно, речь про асинхронную запись, когда мы можем себе это позволить. Потом можно последовательно и очень эффективно сложить данные на диск.
Если синхронная запись и ее целостность не важна, например, у вас не большая и дорогостоящая PostgreSQL, а сервер на одного пользователя, то синхронную запись можно отключить одной настройкой, она станет равняться асинхронной (`zfs set sync=disabled`).
Таким образом, собрав пул из HDD, можно ими пользоваться как дешёвыми SSD с точки зрения IOPS. Сколько IOPS даст оперативная память, столько и будет. При этом целостность ZFS обеспечивает в любом случае — при потере питания произойдет откат на последнюю целую транзакцию и все будет хорошо. В худшем случае мы теряем последние несколько секунд записи, сколько у нас настроено в параметре `txg_timeout`, по умолчанию — это до 5 секунд, (до — т.к. ещё есть задаваемый лимит на размер буфера, при превышении данные запишутся раньше).
#### Зависимость скорости работы ZFS от количества дисков
Один блок данных всегда приходит на один Vdev. Если мы делим файл на небольшие блоки по 128 KB каждый, то такой блок будет на одном Vdev. Далее мы резервируем данные с помощью Mirror или как-то еще. Набив пул сотней Vdev, мы в один поток будем писать только на один из них.
Если дать многопоточную нагрузку, например в 1 000 клиентов, то они могут использовать сразу много Vdev параллельно, нагрузка распределится. При добавлении дисков мы, конечно, не получим полностью линейного роста, но параллельная нагрузка эффективно размажется по Vdev’ам.
#### Обработка запросов на запись
Когда много Vdev и идут запросы на запись, то они распределяются, есть диспетчеризация и приоритезация запросов. Можно посмотреть, на какой Vdev идет нагрузка, каким блоком данных, с какой задержкой. Есть команда `zpool iostat`, у неё куча ключей для просмотра различной статистики.
ZFS учитывает, какой Vdev был перегружен, где нагрузка меньше, где какая была задержка доступа к носителям. Если какой-то диск начинает умирать, у него высокая задержка, то система в итоге отреагирует на это, например выводом его из использования. Если мы используем Mirror, то ZFS пытается распределять нагрузку и параллельно считывать с обоих Vdev разные блоки.
### Как появились OpenZFS и ZFS on Linux и проблемы с версионированием
ZFS изначально создана в Sun Microsystems для проприетарной операционной системы Solaris. Она появилась в качестве замены UFS, которая должна была покрыть любые надобности от файловой системы на долгое время (характерно само название ZFS — Zettabyte File System, намёк на недостижимые объёмы). После продукт стал распространяться с открытым кодом под лицензией CDDL и названием OpenSolaris. Затем Oracle купили Sun Microsystems, и проект перевели обратно в разряд проприетарных. До этого FreeBSD успел притянуть к себе код, были наработки у Apple, они даже встроили реализацию в штатную поставку, но отказались от нее, в конечном итоге внедрив свой аналог AFS. Тогда же появился форк, который превратился в OpenZFS. Сначала желающие работали на OpenSolaris, а потом создали OpenZFS, под которым собрали все усилия в рамках Illumos (форк OpenSolaris).
Кстати, сейчас ZFS — одна из наиболее кроссплатформенных файловых систем, доступная почти на любой операционной системе (даже ведётся портирование под Windows).
У ZFS on Linux другая история. В Ливерморской национальной лаборатории США в качестве распределённой файловой системы для суперкомпьютеров использовали Lustre FS. Ее особенность в том, что на каждой ноде под ней используется еще одна локальная файловая система Ldiskfs — это патченный Ext3, наработки которой послужили основой для Ext4. У Ldiskfs был ряд недостатков, и ZFS должен был заменить эту файловую систему, так и появился проект ZFS on Linux.
В OpenZFS возникла проблема версионирования. Есть ZFS от Oracle и есть OpenZFS, последний не может повторять проприетарную версию, как и банально получать её исходный код. Изначально и у пула и у датасета в ZFS была версия, при обновлении Solaris можно было просто поднимать соответствующую версию. После обновления пул может не импортироваться в старом коде вообще или импортироваться в режиме только для чтения.
На тот момент в проекте OpenZFS уже было много реализаций: FreeBSD, Linux, Solaris, Macos, нужно было связать все наработки. Для этого придумали feature flags, т. н. функциональные флаги. Например, взводишь флажок, что пул поддерживает LZ4 сжатие и в дальнейшем смотришь на него из кода — поддерживается/не поддерживается фича (т. е. можно ли импортировать пул).
У каждого флага есть подпись — можно ли импортировать пул с ним в режиме только на чтение, так как многие вещи важны только при изменениях данных на носителях. Каждая реализация стала обрастать своими feature flags, и платформы переносили их между друг другом через backports.
ZFS не включен в ядро Linux, а другие файловые системы в Linux идут из коробки, т.е. есть в ядре. Вопрос включения в ядро — проблема лицензии, это вопрос сложный. Однако есть отдельный модуль ядра, его можно без проблем обновлять вне зависимости от версии ядра.
В Linux для этого есть два механизма:
1. DKMS — динамическая сборка из исходников. К новому ядру автоматически ставим headers, которые нужны для сборки модуля, он приезжает и автоматически собирается с нужными параметрами. В худшем случае, если не проверена совместимость, DKMS ничего не соберет и отрапортует об этом, но риск такого очень мал, к тому же сопровождающие репозитории пакетов конкретных дистрибутивов могут проверять совместимость пакетов с доступными версиями ядра.
2. KMOD — модуль ядра приезжает из репозитория в бинарном виде, конкретная сборка совместима с определённой версией ABI ядра. Отсутствует риск проблем при сборке модуля, характерные для DKMS, но сопровождающие пакета с модулем должны оперативно предоставлять новые версии при появлении свежих ядер.
Разница в том, что приедет из пакета: исходный код как в DKMS или сразу бинарный файл как в KMOD.
### Что нового в последних релизах
В версии 0.8 появилось нативное шифрование. Есть американская компания Datto, которая занимается бэкапами данных и базируется на ZFS. Они предложили реализацию нативного шифрования.
Ее плюс в том, что шифруются только данные и то, что связано с ними, а информация о датасетах и большая часть метаданных не шифруются. То есть информация на уровне DSL, о директориях и так далее, шифруется, а то, что ниже — DMU и SPA, нет. Что это дает? Можно зашифровать данные на стороне клиента и, не отдавая ключ, отправить их сначала полностью, потом регулярно обновлять инкрементально, принять на стороне сервера также инкрементально без расшифровки и проверить целостность.
Если шифрование идет на низком уровне (к примеру, LUKS) и у нас большие объемы данных, то теряется информация о том, что там есть, нужно передавать все целиком, так как изменение одного байта меняет весь блок. Чтобы проверить целостность данных в этом случае, нужно их расшифровать — это дорого и долго.
Еще одно обновление — это Special Allocation Class. Предположим, что есть большое количество медленных жестких дисков плюс используется реализация Vdev RAIDZ, особенность которого в том, что он не заточен на большие IOPS. Так обеспечивается целостность, он всегда атомарен (не страшна проблема потери массива при т. н. raid write hole), но у этого есть минусы в части производительности. Читать метаданные и мелкие блоки с RAIDZ дорого.
Special Allocation Class — это специальный Vdev, куда пишутся метаданные или блоки данных меньше 4 килобайт (запись данных конфигурируется). Получается, что под большие блоки данных можно использовать медленное, но дешевое HDD-хранилище, а рядом поставить SSD-диски, хранящие его по блоки метаданных и блоки данных небольших размеров.
### Планы по развитию ZFS
ZFS — файловая система, которая может работать с большинством операционных систем. Скоро появится [полнофункциональная версия даже под MS Windows](https://github.com/openzfsonwindows/ZFSin).
В настоящий момент в планах на развитие идет упор на производительность, к примеру на оптимизацию для NVMe. Они дорогие, хочется выжать из них максимум. ARC в данном случае не даёт сильного выигрыша, так как это дополнительные операции по копированию данных в ОЗУ. Сейчас, если поставить 5 — 10 NVMe, мы быстро упремся в производительность ОЗУ и ЦПУ. Специально для этого случая ведутся работы по поддержке direct io с целью исключения лишних операций в ARC.
Другие направления — больше удобства для конечных пользователей-частных лиц. При использовании ZFS дома есть проблема в том, что объем наращивается либо установкой нового Vdev, либо заменой всех дисков в Vdev на бо́льшие (ZFS видит, что диски увеличились и может использовать дополнительное пространство). То есть собрав один RAIDZ, мы не можем добавить к нему на ходу еще один диск. Уже в [альфе патч](https://github.com/openzfs/zfs/pull/8853), который позволяет это делать.
Еще одна интересная наработка, которая готовится к релизу, это новый тип Vdev — dRAID. В больших инсталляциях, где диски измеряются сотнями, а пространство — петабайтами, при вылете одного диска сложно быстро восстановить избыточность данных.
Проблема в том, что жесткие диски, наращивая объем в 20 ТБ и более, не сильно наращивают производительность с точки зрения пропускной способности. У любого диска есть количество ошибок на каждый терабайт чтения, официально заявленное производителем ([URE — unrecoverable read error rate](https://en.wikipedia.org/wiki/RAID#URE)). И любой RAID 5 и более с дисками больше 3 ТБ практически гарантированно развалится при пересборке, когда один диск вылетел и мы читаем с оставшихся. Риск ошибки чтения хотя бы одного не того байта с этих 3 ТБ каждого диска просто огромен (для «потребительских» HDD стандартом является одна ошибка чтения на каждые 1014 бит, т.е. на каждые ~11 ТиБ). Когда мы пересобираем RAIDZ, а это тот же RAID 5, 6 и так далее, есть та же проблема.
Конечно, можно увеличить количество дисков, которое мы можем потерять: поставить RAIDZ 2, RAIDZ 3 — сколько копий будет хранится, но мы не решаем вопрос производительности восстановления. Новый диск, который мы меняем, по-прежнему является узким горлышком. Эти 15 — 20 ТБ будут восстанавливаться в лучшем случае со скоростью 200 МБ/сек (а в реалистичном — около 100 МБ/сек, а то и меньше). Несколько суток на восстановление одного диска — это очень долго.
Пример расположения блоков на дисках, RAIDZ. Источник: https://itnext.io/backup-storage-for-thousands-of-virtual-machines-using-free-tools-b3909004bef2 dRAID решает проблему одновременного восстановления данных на большом количестве дисков. Вместо того чтобы работать в рамках «один диск — одна единица», мы как бы нарезаем каждый диск на мелкие сущности по количеству дисков. Так, если в dRAID 50 дисков, то каждый из них будет разделен на ~50 областей. Некоторые из этих областей будут зарезервированы как свободные (spare) области, на которые можно восстановиться.
Пример расположения блоков на дисках, dRAID. Источник: https://itnext.io/backup-storage-for-thousands-of-virtual-machines-using-free-tools-b3909004bef2По сути, это RAID 5 или RAIDZ, повернутый на 90 градусов. Мы в рамках физических дисков имеем виртуальные сущности. Если вылетает один диск, то на других зарезервировано свободное место, можно восстановить вылетевший диск со скоростью, которая зависит от количества элементов в массиве. То есть когда у нас десять блоков данных, можно восстанавливаться сразу на десять дисков. Такой подход увеличивает скорость восстановления.
Например, мы собрали dRAID, аналогичный RAIDZ2 с одним spare диском, который позволяет вылететь двум дискам, один вылетел, осталось девять. Пока мы не вставили новый диск, размазываем данные на пустое зарезервированное пространство других дисков в группе. И так восстанавливаем ситуацию: дисков по-прежнему девять, но вылететь может уже два, а не один, ведь блоки с вылетевшего диска уже разъехались по уцелевшим оставшимся. Таким образом снимается проблема узкого горлышка в виде производительности spare диска, технически он теперь размазан на другие диски массива.
По этой же причине теперь можно задействовать spare диск, в RAIDZ он бы стоял без дела, а в dRAID он является активным участником, т.к. размазан по всем дискам.
### Послесловие
В связи с тем, что ZFS пережил существование в разных компаниях и ОС, идёт активная централизация кода и документаций в проекте OpenZFS. Приглашаю желающих к созданию [единой документации по проекту](https://github.com/openzfs/openzfs-docs), буду рад вашим PR!
Полезные ссылки:
* [Проект openzfs на github](https://github.com/openzfs/).
* [Общая документация](https://openzfs.github.io/openzfs-docs/).
* [Newcomer Resources](https://openzfs.org/wiki/Newcomers).
* [Developer resources](https://openzfs.org/wiki/Developer_resources).
* [Неофициальный telegram-чат сообщества OpenZFS на русском](https://t.me/ru_zfs).
Также, как я уже говорил, в основном блочном и объектном хранилище Mail.ru Cloud Solutions, которое разрабатывают коллеги в моей команде, хранение устроено по-другому, об объектном хранилище недавно подробно рассказал наш архитектор Монс Андерсон: [Архитектура S3. 3 года эволюции Mail.ru Cloud Storage](https://habr.com/ru/company/mailru/blog/513356/).
Коллеги пишут про хранение данных:
1. [Главные принципы организации объектных хранилищ](https://mcs.mail.ru/blog/glavnye-printsipy-organizatsii-obektnyh-hranilisch).
2. [Как использовать объектное S3-хранилище Mail.ru Cloud Solutions для хранения бэкапов Veeam](https://mcs.mail.ru/blog/obektnoe-s3-hranilische-dlya-hraneniya-bekapov-veeam).
3. [Наш Телеграм-канал с новостями об обновлениях S3-хранилища и других продуктов](https://t.me/mcsnews).
P.S. Наш проект ищет разработчиков на Go в команду [Identity Access Management](https://team.mail.ru/vacancy/13453/). Из интересного — разработка на open source, highload, Kubernetes, распределенные системы. А полный список наших вакансий — [здесь](https://mcs.mail.ru/career/). | https://habr.com/ru/post/529516/ | null | ru | null |
# Разработка веб-приложений в PicoLisp
> Читатели предыдущей статьи [Радикальный подход к разработке приложений](http://habrahabr.ru/post/177791/) могли справедливо заметить, что статья слишком теоретическая. Поэтому спешу восстановить баланс ~~добра и зла~~ теории и практики.
>
>
>
> Эта статья раскрывает лишь верхушку айсберга под названием picoLisp. За бортом остались интересные моменты, касающиеся внутренностей базы данных, организация распределенной БД, отладка, функциональный I/O, объектная модель с множественным наследованием, PicoLisp Prolog…
>
>
>
> Я всё-таки надеюсь, что отечественные программисты присмотрятся к этому мощному инструменту.
>
>
>
> Осторожно, под катом много текста и скобок!
>
>
[abu@software-lab.de](mailto:abu@software-lab.de)
Разработка веб-приложений в PicoLisp
====================================
© Software Lab. Alexander Burger
Настоящий документ содержит введение в написание веб-приложений в PicoLisp.
Он концентрируется на XHTML/CSS фреймворке (в отличие от предыдущих Java-AWT, Java-Swing и plain-HTML фреймворков), который проще в использовании, более гибкий в дизайне и не зависит от плагинов, JavaScript, файлов cookie или CSS.
Простой графический интерфейс HTTP/HTML имеет ряд преимуществ: он работает в любом браузере и может полностью управляться скриптом («@lib/scrape.l»).
Точнее, CSS *может* быть использован для улучшения макета. И браузеры *с* JavaScript будет реагировать быстрее и более гладко. Но этот фреймворк работает отлично и в браузерах, которые не знают ничего о CSS или JavaScript. Все примеры также были протестированы в текстовом браузере w3m.
Основная информация о системе PicoLisp: [PicoLisp Reference](http://software-lab.de/doc/ref.html) и [PicoLisp Tutorial](http://software-lab.de/doc/tut.html). Предполагается знание HTML и немного CSS и HTTP.
В примерах предполагается, что PicoLisp был запущен из глобальной установки (см. [Установка](http://software-lab.de/doc/ref.html#inst)).
* [Статические страницы](#static)
+ [Hello World](#hello)
- [Запуск сервера приложений](#server)
- [Как это работает?](#how)
+ [Синтаксис URL](#urlSyntax)
+ [Безопасность](#security)
- [Файл «.pw»](#pw)
+ [Функция `html`](#htmlFoo)
+ [Атрибуты CSS](#cssAttr)
+ [Функции тегов](#tags)
- [Простые теги](#simple)
- [Списки](#lists)
- [Таблицы](#tables)
- [Меню и табы](#menus)
* [Интерактивные формы](#forms)
+ [Сессии](#sessions)
+ [Формы](#actionForms)
- [Функция `gui`](#guiFoo)
- [Поток управления](#ctlFlow)
- [Переключение URL](#switching)
- [Оповещения и диалоги](#dialogs)
- [Пример калькулятора](#calc)
+ [Таблицы (Charts)](#charts)
- [Прокрутка](#scrolling)
- [Функции Get и Put](#putGet)
* [GUI-классы](#guiClasses)
+ [Поля ввода](#inputFields)
- [Числовые поля ввода](#numberFields)
- [Время и Дата](#timeDateFields)
- [Телефонные номера](#telFields)
- [Чекбоксы](#checkboxes)
+ [Префикс-классы полей](#fieldPrefix)
- [Инициализация](#initPrefix)
- [Включение и отключение](#ablePrefix)
- [Форматирование](#formatPrefix)
- [Побочные эффекты](#sideEffects)
- [Валидация данных](#validPrefix)
- [Связь с БД](#linkage)
+ [Кнопки](#buttons)
- [Кнопки диалоговых окон](#dialogButtons)
- [JavaScript](#jsButtons)
* [Минимальное завершенное приложение](#minApp)
+ [Приступая к работе](#getStarted)
- [Локализация](#localization)
- [Навигация](#navigation)
- [Выбор объектов](#choosing)
- [Редактирование](#editing)
- [Кнопки vs ссылки](#btnLinks)
+ [Модель данных](#dataModel)
+ [Использование](#usage)
- [Клиент/поставщик](#cuSu)
- [Пункт](#item)
- [Заказ](#order)
- [Отчеты](#reports)
+ [Ошибки](#bugs)
---
Статические страницы
--------------------
PicoLisp можно использовать для создания статических HTML-страниц. Само по себе это не имеет особого смысла, так как с таким же успехом можно напрямую написать HTML-код, но это формирует базу для интерактивных приложений и позволяет нам познакомиться с сервером приложений и другими основными концепциями.
---
### Hello World
Чтобы начать с минимального приложения, создайте файл «project.l» в каталоге установки PicoLisp и введите следующие две строки.
```
########################################################################
(html 0 "Hello" "@lib.css" NIL
"Hello World!" )
########################################################################
```
(Мы будем использовать и изменять этот файл во всех следующих примерах. Всякий раз, когда вы встретите такой фрагмент программы между строками ('#####'), просто скопируйте и вставьте его в файл «project.l» и нажмите на кнопку «Обновить» вашего браузера для просмотра результата)
#### Запуск сервера приложений
Откройте окно терминала и запустите сервер приложений PicoLisp
```
$ pil @lib/http.l @lib/xhtml.l @lib/form.l --server 8080 project.l +
```
Приглашение командной строки не появится. Сервер запущен и ждет подключения. Вы можете остановить его позже, нажав `Ctrl-C` в этом терминале, или путем выполнения '`killall pil`' в другом окне терминала.
(В дальнейших примерах мы предполагаем, что этот HTTP-сервер продолжает работать)
Теперь откройте URL '[http://localhost:8080](http://localhost:8080/)' в браузере. Вы должны увидеть пустую страницу с единственной строкой текста.
#### Как это работает?
Строка выше загружает отладчик (опция «+»), код сервера HTTP («@lib/http.l»), XHTML функции («@lib/xhtml.l») и GUI-фреймворк («@lib/form.l», он потребуется позднее для [интерактивных форм](#forms)).
Затем вызывается функция `server` с номером порта и URL по умолчанию. Она будет слушать этот порт на предмет входящих HTTP-запросов в бесконечном цикле. Всякий раз, когда приходит GET-запрос на порт 8080, файл «project.l» будет загружен и исполнен с помощью [(load)](http://software-lab.de/doc/refL.html#load)
Во время исполнения этого файла все данные, записанные в текущий выходной канал (STDOUT), отправляются непосредственно в браузер. Код в «project.l» ответственен за генерацию HTML (либо другого формата, понятного для браузера).
---
### Синтаксис URL-адресов
Сервер приложений использует слегка специализированный синтаксис при обмене URL-адресами с клиентом. Часть URL-адреса — «путь» — то что остается после обрезки
* спецификации протокола, узла и порта,
* конечного вопросительного знака и аргументов,
интерпретируется согласно некоторым правилам. Наиболее значимые из них:
* Если путь начинается с восклицательного знака ('!'), остальная часть (без '!') воспринимается как имя Lisp-функции. Все аргументы после знака вопроса передаются этой функции.
* Если путь заканчивается «.l» (точка и «L» в нижнем регистре), он берется как имя Lisp-файла, который затем загружается с помощью [(load)](http://software-lab.de/doc/refL.html#load). Это наиболее распространенный случай, и мы используем его в нашем примере «project.l».
* Если расширение имени файла соответствует записи в глобальной таблице типов mime `*Mimes`, файл отправляется клиенту с mime-type и значением max-age, взятыми из этой таблицы.
* В противном случае файл отправляется клиенту с типом mime «application/octet-stream» и max-age в 1 секунду.
Приложение может без ограничений расширять или изменять таблицу `*Mimes` функцией `mime`. Например
```
(mime "doc" "application/msword" 60)
```
определяет новый тип mime с max-age в одну минуту.
Значения аргументов в URL, после пути и знак вопроса, кодируются таким образом, чтобы сохранить типы данных Lisp:
* Обычный символ (internal symbol) начинается с символа доллара («$»)
* Число начинается со знака плюс (+)
* Внешний символ (объект БД) начинается с тире ('-')
* Список (только одноуровневый) кодируется символами подчеркивания ('\_')
* В противном случае это транзитный символ (обычная строка)
Таким образом типы данных высокого уровня могут быть непосредственно переданы функции, закодированной в URL, или назначены глобальным переменным перед загрузкой файла.
---
### Безопасность
Конечно это огромная прореха в безопасности, если прямо из URL любой Lisp-файл может быть загружен, и любая функция может быть вызвана. По этой причине приложение должно позаботиться, чтобы точно указать, какие файлы и функции разрешены в URL. Сервер проверяет глобальную переменную [\*Allow](http://software-lab.de/doc/refA.html#*Allow), и когда его значение не равно `NIL`, запрещает доступ к тому, что не соответствует его содержимому.
Как правило `*Allow` не изменяют напрямую, а пользуются функциями [allowed](http://software-lab.de/doc/refA.html#allowed) и [allow](http://software-lab.de/doc/refA.html#allow)
```
(allowed ("app/")
"!start" "@lib.css" "customer.l" "article.l" )
```
Это обычно вызывается в начале приложения и разрешает доступ к каталогу «app/», функциям «start» и к файлам «@lib.css», «customer.l» и «article.l».
Позже, в программе, `*Allow` может быть динамически расширена с помощью `allow`
```
(allow "!foo")
(allow "newdir/" T)
```
Это добавляет в набор разрешенных элементов функцию «foo» и каталог «newdir/».
#### Файл «.pw»
Для использования в контроле безопасности (прежде всего для использования функции `psh`, как в некоторых более поздних примерах) необходимо создать файл с именем «.pw» в каталоге установки PicoLisp. Этот файл должен содержать одну строку произвольных данных для использования в качестве пароля.
Рекомендуемый способ для создания этого файла — вызов функции `pw`, определенной в «@lib/http.l»
```
$ pil @lib/http.l -'pw 12' -bye
```
Пожалуйста, выполните эту команду.
---
### Функция `html`
Теперь вернемся к нашему примеру «Hello World». В принципе вы могли бы написать «project.l» как последовательность операторов вывода
```
########################################################################
(prinl "HTTP/1.0 200 OK^M")
(prinl "Content-Type: text/html; charset=utf-8")
(prinl "^M")
(prinl "")
(prinl "Hello World!")
(prinl "")
########################################################################
```
но использование функции `html` является гораздо более удобным.
Кроме того, `html` — не более чем функция печати. Вы легко можете увидеть это, если вы подключите PicoLisp Shell (`psh`) к процессу сервера (вы должны были сгенерировать [«.pw»-файл](#pw) для этого) и введете функцию `html`
```
$ /usr/lib/picolisp/bin/psh 8080
: (html 0 "Hello" "@lib.css" NIL "Hello World!")
HTTP/1.0 200 OK
Server: PicoLisp
Date: Fri, 29 Dec 2006 07:28:58 GMT
Cache-Control: max-age=0
Cache-Control: no-cache
Content-Type: text/html; charset=utf-8
Hello
Hello World!
->
: # (type Ctrl-D here to terminate PicoLisp)
```
Аргументы для `html`:
1. `0`: Значение max-age для контроля кэша браузера (в секундах, ноль означает «no-cache»). Можно установить более высокое значение для страниц, которые изменяются редко, или `NIL` для отключения кэш-контроля.
2. `"Hello"`: название страницы.
3. `"@lib.css"`: имя файла CSS. Передайте `NIL`, если вы не хотите использовать CSS, или список имен файлов, если вы хотите использовать более одного CSS-файла.
4. `NIL`: Спецификация CSS-атрибутов для тега `body` (см. описание [атрибутов CSS](#cssAttr) ниже).
После этих четырех аргументов может следовать произвольное количество выражений. Они образуют тело страницы и вычисляются по специальным правилам. Это правила немного отличаются от обычных правил вычисления:
* Если аргумент является атомом (число или символ/строка), его значение будет напечатано немедленно.
* В противном случае (список), он вычисляется как Lisp-функции (обычно это некоторые формы оператора print).
Таким образом наш исходный файл также может быть записан как:
```
########################################################################
(html 0 "Hello" "@lib.css" NIL
(prinl "Hello World!") )
########################################################################
```
Наиболее типичные функции печати — это некоторые HTML-теги:
```
########################################################################
(html 0 "Hello" "@lib.css" NIL
( NIL "Hello World!")
( "This is some text.")
(ht:Prin "And this is a number: " (+ 1 2 3)) )
########################################################################
======================================================================================================================================================================
``` | https://habr.com/ru/post/178235/ | null | ru | null |
# Делаем сервис по распознаванию изображений с помощью TensorFlow Serving
Всегда наступает то самое время, когда обученную модель нужно выпускать в production. Для этого часто приходится писать велосипеды в виде оберток библиотек машинного обучения. Но если Ваша модель реализована на Tensorflow, то у меня для Вас хорошая новость — велосипед писать не придется, т.к. можно использовать Tensorflow Serving.
В данной статье мы рассмотрим как использовать Tensorflow Serving для быстрого создания производительного сервиса по распознаванию изображений.
**Tensorflow Serving** — система для развертывания Tensorflow-моделей с такими возможностями как:
* автоматический батчинг;
* горячая замена моделей и версионирование;
* возможность обработки параллельных запросов.
Дополнительным плюсом является возможность перегнать модель из Keras в Tensorflow-модель и задеплоить через Serving (если конечно в Keras используется Tensorflow бэкенд).
Как работает Tensorflow Serving
-------------------------------
Основной частью Tensorflow Serving является сервер моделей (Model Server).
Рассмотрим схему работы сервера моделей. После запуска сервер моделей загружает модель из пути, указанном при запуске, и начинает слушать указанный порт. Сервер общается с клиентами через вызовы удаленных процедур, используя библиотеку gRPC. Это позволяет создать клиентское приложение на любом языке, поддерживающем gRPC.
Если сервер моделей получает запрос, то он может выполнить следующие действия:
* Запустить выполнение модели для этого запроса.
* Объединить несколько запросов в батч и провести вычисление для всего батча, если соответствующая опция (флаг `--enable_batching`) активирована при запуске. Обработка батчами является более эффективной (особенно на GPU), поэтому эта функция позволяет увеличить количество обрабатываемых запросов на единицу времени.
* Поставить запрос в очередь, если на текущий момент вычислительные ресурсы заняты.
Как уже было упомянуто ранее Tensorflow Serving поддерживает горячую замену моделей. Сервер моделей постоянно сканирует указанный при запуске путь на наличии новых моделей и при нахождение новой версии автоматически загружает эту версию. Это позволяет выкладывать новые версии моделей без необходимости остановки сервера моделей.
Таким образом, Tensorflow Serving имеет достаточный функционал для полноценной работы в production. Поэтому использование таких подходов, как создание собственной обертки над моделью, выглядит неоправданно, т.к. Tensorflow Serving предлагает те же возможности и даже больше без необходимости писать и поддерживать самописные решения.
Установка
---------
Сборка Tensorflow Serving наверное самая сложная часть использования этого инструмента. В принципе ничего сложно нет, но есть несколько подводных граблей. Именно про них я и расскажу в этом разделе.
Для сборки используется система сборки [bazel](https://bazel.build/).
Установка Tensorflow Serving описана на официальном сайте <https://tensorflow.github.io/serving/setup>. Я не буду расписывать подробно каждый шаг, а расскажу о проблемах, которые могут возникнуть при выполнении установки.
Со всеми шагами до конфигурации Tensorflow (`./configure`) не должно возникнуть проблем.
При конфигурации Tensorflow почти для всех параметров можно оставлять дефолтные значения. Но если вы выберете установку с CUDA, то конфигуратор спросит версию cuDNN. Надо вводить полную версию cuDNN (в моем случае 5.1.5).
Доходим до сборки (`bazel build tensorflow_serving/...`).
Для начала надо определить какие оптимизации доступны вашему процессору и указать их при сборке, т.к. bazel не может распознать их автоматически.
Таким образом, команда сборки усложняется до следующей:
`bazel build -c opt --copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-mfpmath=both --copt=-msse4.2 tensorflow_serving/...`
*Проверьте, что все эти оптимизации доступны вашему процессору.* У меня процессор не поддерживает AVX2 и FMA поэтому я собирал следующей командой:
`bazel build -c opt --copt=-mavx --copt=-mfpmath=both --copt=-msse4.2 tensorflow_serving/...`
По дефолту сборка Tensorflow потребляет много памяти, поэтому если у Вас ее не слишком много, то надо ограничить потребление ресурсов. Сделать это можно следующим флагом `--local_resources availableRAM,availableCPU,availableIO` (RAM in MB, CPU in cores, available I/O (1.0 being average workstation), например, `--local_resources 2048,.5,1.0`).
Если вы хотите собрать Tensorflow Serving с поддержкой GPU, то надо добавить флаг `--config=cuda`. Получится примерно такая команда.
`bazel build -c opt --copt=-mavx --copt=-mfpmath=both --copt=-msse4.2 --config=cuda tensorflow_serving/...`
При сборке может возникнуть следующая ошибка.
**Текст ошибки**`ERROR: no such target '@org_tensorflow//third_party/gpus/crosstool:crosstool': target 'crosstool' not declared in package 'third_party/gpus/crosstool' defined by /home/movchan/.cache/bazel/_bazel_movchan/835a50f8a234772a7d7dac38871b88e9/external/org_tensorflow/third_party/gpus/crosstool/BUILD.`
Чтобы исправить эту ошибку, надо в файле `tools/bazel.rc` заменить `@org_tensorflow//third_party/gpus/crosstool` на `@local_config_cuda//crosstool:toolchain`
Еще может появиться следующая ошибка.
**Текст ошибки**`ERROR: /home/movchan/.cache/bazel/_bazel_movchan/835a50f8a234772a7d7dac38871b88e9/external/org_tensorflow/tensorflow/contrib/nccl/BUILD:23:1: C++ compilation of rule '@org_tensorflow//tensorflow/contrib/nccl:python/ops/_nccl_ops.so' failed: crosstool_wrapper_driver_is_not_gcc failed: error executing command external/local_config_cuda/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc -U_FORTIFY_SOURCE '-D_FORTIFY_SOURCE=1' -fstack-protector -fPIE -Wall -Wunused-but-set-parameter ... (remaining 80 argument(s) skipped): com.google.devtools.build.lib.shell.BadExitStatusException: Process exited with status 1. In file included from external/org_tensorflow/tensorflow/conERROR: /home/movchan/.cache/bazel/_bazel_movchan/835a50f8a234772a7d7dac38871b88e9/external/org_tensorflow/tensorflow/contrib/nccl/BUILD:23:1: C++ compilation of rule '@org_tensorflow//tensorflow/contrib/nccl:python/ops/_nccl_ops.so' failed: crosstool_wrapper_driver_is_not_gcc failed: error executing command external/local_config_cuda/crosstool/clang/bin/crosstool_wrapper_driver_is_not_gcc -U_FORTIFY_SOURCE '-D_FORTIFY_SOURCE=1' -fstack-protector -fPIE -Wall -Wunused-but-set-parameter ... (remaining 80 argument(s) skipped): com.google.devtools.build.lib.shell.BadExitStatusException: Process exited with status 1. In file included from external/org_tensorflow/tensorflow/contrib/nccl/kernels/nccl_manager.cc:15:0: external/org_tensorflow/tensorflow/contrib/nccl/kernels/nccl_manager.h:23:44: fatal error: external/nccl_archive/src/nccl.h: No such file or directory compilation terminated.`
Чтобы ее исправить надо удалить префикс `/external/nccl_archive` в строчке `#include "external/nccl_archive/src/nccl.h"` в следующих файлах:
`tensorflow/tensorflow/contrib/nccl/kernels/nccl_ops.cc tensorflow/tensorflow/contrib/nccl/kernels/nccl_manager.h`
Ура! Собрали наконец!
Экспорт модели
--------------
Экспорт модели из Tensorflow подробно описан на <https://tensorflow.github.io/serving/serving_basic> в разделе "Train And Export TensorFlow Model".
Для экспорта используется класс `SavedModelBuilder`. Я же использую Keras для тренировки Tensorflow-моделей, т.ч. я опишу процесс экспорта модели из Keras в Serving с помощью этого модуля.
Код экспорта ResNet-50, обученного на ImageNet.
```
import os
import tensorflow as tf
from keras.applications.resnet50 import ResNet50
from keras.preprocessing import image
from keras.applications.resnet50 import preprocess_input, decode_predictions
from tensorflow.contrib.session_bundle import exporter
import keras.backend as K
# устанавливаем режим в test time.
K.set_learning_phase(0)
# создаем модель и загружаем веса
model = ResNet50(weights='imagenet')
sess = K.get_session()
# задаем путь сохранения модели и версию модели
export_path_base = './model'
export_version = 1
export_path = os.path.join(
tf.compat.as_bytes(export_path_base),
tf.compat.as_bytes(str(export_version)))
print('Exporting trained model to', export_path)
builder = tf.saved_model.builder.SavedModelBuilder(export_path)
# создаем входы и выходы из тензоров
model_input = tf.saved_model.utils.build_tensor_info(model.input)
model_output = tf.saved_model.utils.build_tensor_info(model.output)
# создаем сигнатуру для предсказания, в которой устанавливаем входы и выходы модели
prediction_signature = (
tf.saved_model.signature_def_utils.build_signature_def(
inputs={'images': model_input},
outputs={'scores': model_output},
method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))
# добавляем сигнатуры к SavedModelBuilder
legacy_init_op = tf.group(tf.tables_initializer(), name='legacy_init_op')
builder.add_meta_graph_and_variables(
sess, [tf.saved_model.tag_constants.SERVING],
signature_def_map={
'predict':
prediction_signature,
},
legacy_init_op=legacy_init_op)
builder.save()
```
Вместо `'images'` и `'scores'` при установке входов и выходов можно указать любые названия. Эти названия будут использоваться далее.
Если модель имеет несколько входов и/или выходов, то нужно указать это в `tf.saved_model.signature_def_utils.build_signature_def`. Для этого нужно использовать `model.inputs` и `model.outputs`. Тогда код установки входов и выходов будет выглядеть следующим образом:
```
# создаем входы и выходы из тензоров
model_input = tf.saved_model.utils.build_tensor_info(model.inputs[0])
model_output = tf.saved_model.utils.build_tensor_info(model.outputs[0])
model_aux_input = tf.saved_model.utils.build_tensor_info(model.inputs[1])
model_aux_output = tf.saved_model.utils.build_tensor_info(model.outputs[1])
# создаем сигнатуру для предсказания
prediction_signature = (
tf.saved_model.signature_def_utils.build_signature_def(
inputs={'images': model_input, 'aux_input': model_aux_input},
outputs={'scores': model_output, 'aux_output': model_aux_output},
method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))
```
Еще стоит заметить, что в `signature_def_map` указываются все доступные методы (сигнатуры), которых может быть больше чем 1. В примере выше добавлен только один метод — `predict`. Название метода будет использоваться позже.
Запуск сервера моделей
----------------------
Запуск сервера моделей осуществляется следующей командой:
`./bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server --enable_batching --port=9001 --model_name=resnet50 --model_base_path=/home/movchan/ml/serving_post/model`
Рассмотрим, что означают флаги в данной команде.
* `enable_batching` — флаг активации автоматического батчинга, позволяет Tensorflow Serving объединять запросы в батчи для более эффективной обработки.
* `port` — порт, который модель будет прослушивать.
* `model_name` — имя модели (будет использоваться далее).
* `model_base_path` — путь до модели (туда, куда вы ее сохранили на предыдущем шаге).
Использование Tensorflow Serving из python
------------------------------------------
Для начала поставим пакет grpcio через pip.
`sudo pip3 install grpcio`
Вообще по туториалу на официальном сайте предлагается собирать python-скрипты через bazel. Но мне эта идея не нравится, т.ч. я нашел другой способ.
Для использования python API можно скопировать (сделать софтлинк) директорию `bazel-bin/tensorflow_serving/example/inception_client.runfiles/tf_serving/tensorflow_serving`. Там содержится все необходимое для работы python API. Я обычно просто копирую в директорию, в которой лежит скрипт, использующий это API.
Рассмотрим пример использования python API.
```
import numpy as np
from grpc.beta import implementations
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2
# Создаем канал и заглушку для запроса к Serving
host = '127.0.0.1'
port = 9001
channel = implementations.insecure_channel(host, port)
stub = prediction_service_pb2.beta_create_PredictionService_stub(channel)
# Создаем запрос
request = predict_pb2.PredictRequest()
# Указываем имя модели, которое было указано при запуске сервера (флаг model_name)
request.model_spec.name = 'resnet50'
# Указываем имя метода, которое было указано при экспорте модели (см. signature_def_map).
request.model_spec.signature_name = 'predict'
# Копируем входные данные. Названия входов такие же как при экспорте модели.
request.inputs['images'].CopyFrom(
tf.contrib.util.make_tensor_proto(image, shape=image.shape))
# Выполняем запрос. Второй параметр - timeout.
result = stub.Predict(request, 10.0)
# Извлекаем результаты. Названия выходов такие же как при экспорте модели.
prediction = np.array(result.outputs['scores'].float_val)
```
**Полный код примера использования python API**
```
import time
import sys
import tensorflow as tf
import numpy as np
from grpc.beta import implementations
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2
from keras.preprocessing import image
from keras.applications.resnet50 import preprocess_input, decode_predictions
def preprocess_image(img_path):
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def get_prediction(host, port, img_path):
image = preprocess_image(img_path)
start_time = time.time()
channel = implementations.insecure_channel(host, port)
stub = prediction_service_pb2.beta_create_PredictionService_stub(channel)
request = predict_pb2.PredictRequest()
request.model_spec.name = 'resnet50'
request.model_spec.signature_name = 'predict'
request.inputs['images'].CopyFrom(
tf.contrib.util.make_tensor_proto(image, shape=image.shape))
result = stub.Predict(request, 10.0)
prediction = np.array(result.outputs['scores'].float_val)
return prediction, (time.time()-start_time)*1000.
if __name__ == "__main__":
if len(sys.argv) != 4:
print ('usage: serving_test.py ')
print ('example: serving\_test.py 127.0.0.1 9001 ~/elephant.jpg')
exit()
host = sys.argv[1]
port = int(sys.argv[2])
img\_path = sys.argv[3]
for i in range(10):
prediction, elapsed\_time = get\_prediction(host, port, img\_path)
if i == 0:
print('Predicted:', decode\_predictions(np.atleast\_2d(prediction), top=3)[0])
print('Elapsed time:', elapsed\_time, 'ms')
```
Сравним скорость работы Tensorflow Serving c Keras-версией.
**Код на Keras**
```
import sys
import time
from keras.applications.resnet50 import ResNet50
from keras.preprocessing import image
from keras.applications.resnet50 import preprocess_input, decode_predictions
import numpy as np
def preprocess_image(img_path):
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def get_prediction(model, img_path):
image = preprocess_image(img_path)
start_time = time.time()
prediction = model.predict(image)
return prediction, (time.time()-start_time)*1000.
if __name__ == "__main__":
if len(sys.argv) != 2:
print ('usage: keras_test.py ')
print ('example: keras\_test.py ~/elephant.jpg')
exit()
img\_path = sys.argv[1]
model = ResNet50(weights='imagenet')
for i in range(10):
prediction, elapsed\_time = get\_prediction(model, img\_path)
if i == 0:
print('Predicted:', decode\_predictions(np.atleast\_2d(prediction), top=3)[0])
print('Elapsed time:', elapsed\_time, 'ms')
```
Все замеры производились на CPU.
Для тестирования возьмем эту фотографию кота с [Pexels.com](https://www.pexels.com/photo/animal-asian-cat-vintage-225932/), которую я нашел через <https://everypixel.com>.
Keras
```
Predicted: [('n02127052', 'lynx', 0.59509182), ('n02128385', 'leopard', 0.050437182), ('n02123159', 'tiger_cat', 0.049577814)]
Elapsed time: 419.47126388549805 ms
Elapsed time: 125.33354759216309 ms
Elapsed time: 122.70569801330566 ms
Elapsed time: 122.8172779083252 ms
Elapsed time: 122.3604679107666 ms
Elapsed time: 116.24360084533691 ms
Elapsed time: 116.51420593261719 ms
Elapsed time: 113.5416030883789 ms
Elapsed time: 112.34736442565918 ms
Elapsed time: 110.09907722473145 ms
```
Serving
```
Predicted: [('n02127052', 'lynx', 0.59509176015853882), ('n02128385', 'leopard', 0.050437178462743759), ('n02123159', 'tiger_cat', 0.049577809870243073)]
Elapsed time: 117.71702766418457 ms
Elapsed time: 75.67715644836426 ms
Elapsed time: 72.94225692749023 ms
Elapsed time: 71.62714004516602 ms
Elapsed time: 71.4271068572998 ms
Elapsed time: 74.54872131347656 ms
Elapsed time: 70.8014965057373 ms
Elapsed time: 70.94025611877441 ms
Elapsed time: 70.58024406433105 ms
Elapsed time: 68.82333755493164 ms
```
Как видно, Serving работает даже быстрее, чем версия на Keras. Это будет еще заметнее при большом количестве запросов.
Реализация REST API к Tensorflow Serving через Flask
----------------------------------------------------
Сначала установим Flask.
`sudo pip3 install flask`
**Полный код REST-сервиса**
```
from flask import Flask
from flask import request
from flask import jsonify
import tensorflow as tf
from grpc.beta import implementations
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2
from keras.preprocessing import image
from keras.applications.resnet50 import preprocess_input, decode_predictions
import numpy as np
application = Flask(__name__)
host = '127.0.0.1'
port = 9001
def preprocess_image(img):
img = image.load_img(img, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def get_prediction(img):
image = preprocess_image(img)
channel = implementations.insecure_channel(host, port)
stub = prediction_service_pb2.beta_create_PredictionService_stub(channel)
request = predict_pb2.PredictRequest()
request.model_spec.name = 'resnet50'
request.model_spec.signature_name = 'predict'
request.inputs['images'].CopyFrom(
tf.contrib.util.make_tensor_proto(image, shape=image.shape))
result = stub.Predict(request, 10.0)
prediction = np.array(result.outputs['scores'].float_val)
return decode_predictions(np.atleast_2d(prediction), top=3)[0]
@application.route('/predict', methods=['POST'])
def predict():
if request.files.get('data'):
img = request.files['data']
resp = get_prediction(img)
response = jsonify(resp)
return response
else:
return jsonify({'status': 'error'})
if __name__ == "__main__":
application.run()
```
Запустим сервис.
`python3 serving_service.py`
Протестируем сервис. Отправим запрос через curl.
`curl '127.0.0.1:5000/predict' -X POST -F "data=@./cat.jpeg"`
Получаем ответ следующего вида.
`[ [ "n02127052", "lynx", 0.5950918197631836 ], [ "n02128385", "leopard", 0.05043718218803406 ], [ "n02123159", "tiger_cat", 0.04957781359553337 ] ]`
Замечательно! Оно работает!
Заключение
----------
В данной статье мы рассмотрели как можно использовать Tensorflow Serving для деплоймента моделей в production. Также рассмотрели как можно реализовать простой REST-сервис на Flask, обращающийся к серверу моделей.
Ссылки
------
[Официальный сайт Tensorflow Serving](https://tensorflow.github.io/serving/)
[Код всех скриптов статьи](https://github.com/movchan74/tensorflow_serving_examples) | https://habr.com/ru/post/332584/ | null | ru | null |
# Фореве элон 2016/2017 (встреча Нового года в сети)
[](https://telegram.me/habragram)
Друзья, наверняка, многим приходится отмечать наступление Нового года в одиночестве или на работе!
С этим нужно что-то делать! Предлагаю встретиться в телеграм-чате. Кстати, нас уже 400 человек и мы отмечаем Новый год уже целый год!
Ссылка: [telegram.me/habragram](https://telegram.me/habragram) | https://habr.com/ru/post/400361/ | null | ru | null |
# Недокументированные изменения или PHP 5.4 и перегрузка функций
##### Как это было
Не так давно столкнулся с одной проблемой, возникшей при переезде на php 5.4. Задача состояла в тестировании функционала, который использовал родные функции. К слову, [Fumocker](http://github.com/formapro/Fumocker) отлично справляется с этой задачей, позволяя в тестах переопределять встроенные функции. Я написал пачку тестов и запустил их локально. Все тесты прошли успешно. Отлично! Задача была сделана и я был в полном счастье, пока не добавил проект в [travis-ci](https://travis-ci.org). И? [Сборка](https://travis-ci.org/#!/vatson/isolated-callback/builds/2593957) была сломана под php 5.4, когда под 5.3 всё светилось зелёным.
Именно этот факт навел меня на мысль, что между 5.3 и 5.4 должна быть разница в перегрузке функций.
Скажу честно, я никогда прежде не находил информации об этом различии в описании релизов php 5.4. Поэтому в первую очередь пошел пытать Гугл. Но Гугл не смог дать внятного ответа. Все что я нашел — касалось перегрузки методов, не более. Это и cподвигло меня начать эксперементировать с кодом.
##### Ну что, приступим?
Первым желанием возникло создать песочницу для воспроизведения ситуации. Для этого я написал простейший класс, который использовал встроенную функцию **range**:
```
php
// MyClass.php
namespace MyNamespace;
class MyClass
{
public function makeMeRange()
{
return range(1,3);
}
}
</code
```
и отдельный файл с переопределением этой функции в одноименной области видимости:
```
php
// MyNamespaceFunctions.php
namespace MyNamespace;
function range($low, $high, $step = null)
{
return 'Overridden';
}
</code
```
Затем мне стало интересно, что произойдет, если мы подключим файлы с определением класса и функции перед созданием первого объекта **MyClass**:
```
php
// main.php
include_once("MyClass.php");
include_once("MyNamespaceFunctions.php");
use MyNamespace\MyClass;
$my_obj = new MyClass();
echo $my_obj-makeMeRange();
```
В этом случае поведение одинаковое для двух версий:
```
$ php54 main.php
Overridden
```
```
$ php53 main.php
Overridden
```
Но что должно случиться, если подключить файл с функцией после создания первого экземпляра **MyClass**?
```
php
include_once("MyClass.php");
use MyNamespace\MyClass;
$my_obj = new MyClass();
include_once("MyNamespaceFunctions.php");
$other_obj = new MyClass();
echo $my_obj-makeMeRange();
```
По-прежнему никакой разницы:
```
$ php54 main.php
Overridden
```
```
$ php53 main.php
Overridden
```
Остается последний шанс найти причину двуликости поведения — попробовать вызвать функцию перед включением файла с переопределением этой же функции:
```
php
include_once("MyClass.php");
use MyNamespace\MyClass;
$my_obj = new MyClass();
$my_obj-makeMeRange();
include_once("MyNamespaceFunctions.php");
$other_obj = new MyClass();
echo $other_obj->makeMeRange();
```
**Ага! Попалась!**
```
$ php54 main.php
PHP Notice: Array to string conversion in /Volumes/Projects/php-experiments/
…
```
```
$ php53 main.php
Overridden
```
И последний-препоследний эксперимент (обещаю):
```
php
include_once("MyClass.php");
use MyNamespace\MyClass;
$my_obj = new MyClass();
$my_obj-makeMeRange();
include_once("MyNamespaceFunctions.php");
echo $my_obj->makeMeRange();
```
подтверждает разницу в перегрузке функции между 5.3 и 5.4:
```
$ php54 main.php
PHP Notice: Array to string conversion in /Volumes/Projects/php-experiments/
…
```
```
$ php53 main.php
Overridden
```
##### В итоге
Получается, что php 5.3 дает переопределить функцию в любой момент выполнения скрипта, если функция не была переопределена до этого. Когда в это же время php 5.4 будет использовать лишь ту версию функции, какая была впервые использована где-либо в коде.
Кроме описанной проблемы, эта статья подымает давний вопрос — «акутальность документации». Да, мы до сих пор вынуждены использовать неполноценную документацию на свой страх и риск. По-моему, это позор на наши головы.
*P.S.: Я создал [репозиторий](https://github.com/vatson/php-experiments) для тестирования описанного поведения. На случай если захотите самостоятельно проверить просто склонируйте репозиторий и запустите тесты с помощью phpunit*
*P.S.S: А еще есть открытый тиктет [#63201](http://bugs.php.net/bug.php?id=63201) на bugs.php.net. Любое участие в данном вопросе приветствуется!* | https://habr.com/ru/post/153689/ | null | ru | null |
# Kafka и Chronicle Queue
[](https://habr.com/ru/company/ruvds/blog/676804/)
Хотя облачные сервисы удобны и гибки, эксплуатационные затраты на приложения, развёрнутые в облаке, иногда могут быть существенными. В этой статье мы расскажем о способе существенного снижения эксплуатационных затрат в чувствительных к задержке Java-приложений с Event-Driven Architecture (EDA) при помощи миграции с Kafka на Chronicle Queue — опенсорсной, более эффективно использующей ресурсы реализации очереди с [пониженной задержкой](https://dzone.com/articles/kafka-vs-chronicle-for-microservices).
Что такое EDA?
--------------
[EDA-приложение](https://dzone.com/articles/event-driven-architecture-as-a-strategy) — это распределённое приложение, в котором выполняется создание, распознавание и потребление событий (в виде сообщений или DTO), а также реагирование на них. «Распределённое» означает, что приложение может выполняться на разных машинах или на одной машине, но в отдельных процессах или потоках. В этой статье используется последний вариант, а сообщения сохраняются в очередях.
Подготовка к работе
-------------------
Предположим, у нас есть EDA-приложение с цепочкой из пяти сервисов; при этом имеется требование, что 99,9% сообщений, отправленных от первого их создателя до последнего потребителя, должно иметь задержку менее 100 мс при частоте 1000 сообщений в минуту.
*Рисунок 1 — пять сервисов и бенчмарк, взаимосвязанные шестью топиками/очередями*
Иными словами, время между отправкой сообщения (например, при помощи топика 0) потоком Benchmark до получения конечного сообщения снова потоком Benchmark (например, при помощи топика 5) может быть больше 100 мс в среднем только для одного из 1000 сообщений, отправляемых каждую секунду.
Используемые в этой статье сообщения просты. Они содержат метку времени в наносекундах в формате long, в которой хранится изначальная метка времени первой публикации сообщения при помощи топика 0, и значение int, увеличивающееся каждый раз, когда сообщение передаётся от одного сервиса к следующему (на самом деле это значение не используется, однако оно иллюстрирует рудиментарную логику сервисов). Когда сообщение возвращается в поток Benchmark, текущее время в наносекундах сравнивается с исходным временем в первоначальном сообщении в топике 0, чтобы можно было вычислить общую задержку во всей цепочке сервисов. Затем сэмплы [задержки](https://dzone.com/articles/a-real-world-framework-for-calculating-database-la) последовательно передаются в гистограмму для дальнейшего анализа.
Как видно из Рисунка 1, количество топиков/очередей равно количеству сервисов плюс один. Следовательно, поскольку сервисов пять, топиков/очередей шесть.
Главный вопрос
--------------
Главный вопрос этой статьи таков: **сколько экземпляров таких цепочек мы можем создать на выделенном оборудовании, не нарушая требований к задержкам?**
Иными словами, сколько таких приложений мы можем запустить и платить ту же цену за используемое оборудование?
Стандартная настройка
---------------------
Для этой статьи я решил использовать Apache Kafka, потому что это один из самых распространённых типов очередей, используемых на рынке. Также я выбрал Chronicle Queue за возможность обеспечения низкой задержки и ресурсоэффективность.
И Kafka, и Chronicle Queue имеют множество настраиваемых опций, в том числе репликацию данных между несколькими серверами. В этой статье будет использоваться одна очередь без репликации. Из соображений производительности брокер Kafka будет работать на той же машине, что и серверы, что позволяет использовать локальный сетевой loopback-интерфейс.
Экземпляры Kafka Producer сконфигурированы так, чтобы быть [оптимизированными под низкую задержку](https://docs.confluent.io/cloud/current/client-apps/optimizing/latency.html) (например, «acks=1»), то же самое относится и к экземплярам KafkaConsumer.
Экземпляры Chronicle Queue созданы со стандартной настройкой без явных оптимизаций. Следовательно, расширенные функции производительности Chronicle Queue наподобие CPU-core pinning и busy spin-waiting не используются.
Kafka
-----
[Apache Kafka](https://kafka.apache.org/) — это опенсорсная распределённая платформа стриминга событий для высокопроизводительных конвейеров данных, стриминговой аналитики, интегрирования данных и критически важных приложений, активно используемых в различных EDA-приложениях, особенно в случаях, когда необходимо агрегировать и потреблять информацию от множества источников, расположенных в различных местах.
В этом бенчмарке каждый тестовый экземпляр создаст шесть отдельных топиков Kafka с названиями topicXXXX0, topicXXXX1, …, topicXXXX5, где XXXXX — случайное число.
Chronicle Queue
---------------
Опенсорсный [Chronicle Queue](https://chronicle.software/open-hft/queue/) — это фреймворк передачи сообщений с низкой задержкой для высокопроизводительных и критически важных приложений. Любопытно, что Chronicle Queue использует память вне кучи и распределение памяти для снижения влияния давления на память и сборки мусора, благодаря чему этот продукт популярен в сфере финтеха, где детерминированная передача сообщений с низкой задержкой критически важна.
В этом втором бенчмарке каждый тестовый экземпляр создаст шесть [экземпляров Chronicle Queue](https://dzone.com/articles/bit-by-bit) с названиями topicXXXX0, topicXXXX1, …, topicXXXX5, где XXXXX — случайное число.
Код
---
Ниже показаны внутренние циклы двух разных реализаций потоков сервисов. Оба они опрашивают свою очередь ввода, пока не получат команду завершения работы и, если сообщения отсутствуют, они будут ждать в течение одной восьмой от ожидаемого времени между сообщениями, а потом будут совершать повторную попытку.
Вот как выглядит код:
### ▍ Kafka
```
while (!shutDown.get()) {
ConsumerRecords records =
inQ.poll(Duration.ofNanos(INTER\_MESSAGE\_TIME\_NS / 8));
for (ConsumerRecord record : records) {
long beginTimeNs = record.value();
int value = record.key();
outQ.send(new ProducerRecord<>(topic, value + 1, beginTimeNs));
}
}
```
Использование записи `key()` для хранения значения int может показаться немного необычным шагом, однако он позволяет нам улучшить производительность и упростить код.
### ▍ Chronicle Queue
```
while (!shutDown.get()) {
try (final DocumentContext rdc = tailer.readingDocument()) {
if (rdc.isPresent()) {
ValueIn valueIn = rdc.wire().getValueIn();
long beginTime = valueIn.readLong();
int value = valueIn.readInt();
try (final DocumentContext wdc =
appender.writingDocument()) {
final ValueOut valueOut = wdc.wire().getValueOut();
valueOut.writeLong(beginTime);
valueOut.writeInt(value + 1);
}
} else {
LockSupport.parkNanos(INTER_MESSAGE_TIME_NS / 8);
}
}
}
```
Бенчмарки
---------
Бенчмарки прошли этап первоначального «разогрева», в течение которого — компилятор C2 JVM спрофилировал и скомпилировал для гораздо большей производительности. Результаты сэмплирования с этапа разогрева не учитывались.
В процессе тестирования вручную запускались новые тестовые экземпляры (каждый со своими пятью сервисами) до тех пор, пока система не переставала удовлетворять требованиям к задержке. При выполнении бенчмарков также при помощи команды «top» для всех экземпляров отслеживалось использование ЦП (центрального процессора) и показания нескольких секунд усреднялись.
В бенчмарках не учитывалось [coordinated omission](http://highscalability.com/blog/2015/10/5/your-load-generator-is-probably-lying-to-you-take-the-red-pi.html), тесты проводились на Ubuntu Linux (5.11.0-49-generic) с 16-ядерными процессорами AMD Ryzen 9 5950X (3,4 Ггц) и 64 ГБ ОЗУ, а приложения выполнялись на изолированных ядрах 2-8 (суммарно 7 ядер ЦП), а очереди сохранялись на флэш-устройстве NVMe объёмом 1 ТБ. Использовался OpenJDK 11 (11.0.14.1).
Все значения задержек указаны в мс, 99% означает 99 перцентиль, а 99,9% означает 99,9 перцентиль.
Kafka
-----
Брокер Kafka и бенчмарки запускались с префиксом «taskset -c 2-8», за которым следовала соответствующая команда (например, taskset -c 2-8 mvn exec:java@Kafka). Для Kafka были получены следующие результаты:
| | | | | |
| --- | --- | --- | --- | --- |
| Экземпляры | Медианная задержка | 99% | 99,9% | Использование ЦП |
| 1 | 0,9 | 19 | 30 | 670% |
| 2 | 16 | 72 | 106 (\*) | 700% (насыщение) |
*Таблица 1 — экземпляры Kafka, задержки и использование ЦП*
(\*) Более 100 мс в 99,9 перцентиле.
Как мы видим, одновременно может выполняться только один экземпляр системы EDA. Запуск двух экземпляров увеличил 99,9 перцентиль и он превысил ограничение в 100 мс. Экземпляры и брокер Kafka быстро пришли к насыщению доступных ресурсов ЦП.
Вот снэпшот результатов выполнения команды «top» при работе двух экземпляров и брокера (PID 3132946):
```
3134979 per.min+ 20 0 20.5g 1.6g 20508 S 319.6 2.6 60:27.40 java
3142126 per.min+ 20 0 20.5g 1.6g 20300 S 296.3 2.5 19:36.17 java
3132946 per.min+ 20 0 11.3g 1.0g 22056 S 73.8 1.6 9:22.42 java
```
Chronicle Queue
---------------
Бенчмарки выполнялись при помощи команды «taskset -c 2-8 mvn exec:java@ChronicleQueue», при этом были получены следующие результаты:
| | | | | |
| --- | --- | --- | --- | --- |
| Экземпляры | Медианная задержка | 99% | 99,9% | Использование ЦП |
| 1 | 0,5 | 0,8 | 0,9 | 5,2% |
| 10 | 0,5 | 0,9 | 0,9 | 79% |
| 25 | 0,5 | 0,9 | 3,6 | 180% |
| 50 | 0,5 | 0,9 | 5,0 | 425% |
| 100 | 1,0 | 5 | 20 | 700% (насыщение) |
| 150 | 2,0 | 7 | 53 | 700% (насыщение) |
| 200 | 3,1 | 9 | 59 | 700% (насыщение) |
| 250 | 4,8 | 12 | 62 | 700% (насыщение) |
| 375 | 8,7 | 23 | 75 | 700% (насыщение) |
| 500 | 11 | 36 | 96 | 700% (насыщение) |
*Таблица 2 — экземпляры Chronicle Queue, задержки и использование ЦП*
В этих бенчмарках становится очевидной эффективность Chronicle Queue — одновременно могут работать 500 экземпляров, то есть одновременно мы можем обрабатывать 3000 очередей и 3000000 сообщений в секунду всего на 7 ядрах с задержкой менее 100 мс в 99,9 перцентиле.
Сравнение
---------
Ниже показан график количества экземпляров и 99,9 перцентиля для двух типов очередей (чем меньше, тем лучше):
*График 1 — задержки экземпляров в мс для 99,9 перцентиля*
Как мы видим, кривая для Kafka поднимается с 30 мс до 106 мс всего за один шаг, поэтому рост задержки для Kafka на этом графике выглядит как стена.
Вывод
-----
В случае работы с [чувствительными к задержке EDA-приложениями](https://dzone.com/articles/designing-high-volume-transaction-systems-using-event-driven-architectures) при переходе с Kafka на Chronicle Queue на одном и том же оборудовании может работать примерно в четыреста раз больше приложений.
*График 2 — нормализованные затраты относительно типа очереди (чем меньше, тем лучше)*
Как видно из Графика 2, увеличение максимального количества приложений в примерно четыреста раз соответствует потенциалу снижения затрат на облако или оборудование приблизительно на 99,8%. На самом деле, при использованном масштабе затраты едва видны.
[](https://ruvds.com/drive/?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kafka_i_chronicle_queue) | https://habr.com/ru/post/677454/ | null | ru | null |
# Inversion of Control: Методы реализации с примерами на PHP
> О боже, ещё один пост о Inversion of Control
Каждый более-менее опытный программист встречал в своей практике словосочетание Инверсия управления (Inversion of Control). Но зачастую не все до конца понимают, что оно значит, не говоря уже о том, как правильно это реализовать. Надеюсь, пост будет полезен тем, кто начинает знакомится с инверсией управления и несколько запутался.
Итак, согласно Википедии Inversion of Control — принцип объектно-ориентированного программирования, используемый для уменьшения связанности в компьютерных программах, основанный на следующих 2 принципах
* Модули верхнего уровня не должны зависеть от модулей нижнего уровня. И те, и другие должны зависеть от абстракции.
* Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.
Другими словами, можно сказать, что все зависимости модулей должны строятся на абстракциях этих модулях, а не их конкретных реализациях.
Рассмотрим пример.
Пусть у нас есть 2 класса — OrderModel и MySQLOrderRepository. OrderModel вызывает MySQLOrderRepository для получения данных из MySQL хранилища. Очевидно, что модуль более высокого уровня (OrderModel) зависит от относительного низкоуровневого MySQLOrderRepository.
Пример плохого кода приведён ниже.
```
php
class OrderModel
{
public function getOrder($orderID)
{
$orderRepository = new MySQLOrderRepository();
$order = $orderRepository-load($orderID);
return $this->prepareOrder($order);
}
private function prepareOrder($order)
{
//some order preparing
}
}
class MySQLOrderRepository
{
public function load($orderID)
{
// makes query to DB to fetch order row from table
}
}
```
В общем и целом этот код будет отлично работать, выполнять возложенные на него обязанности. Можно было и остановиться на этом. Но вдруг у Вашего заказчика появляется гениальная идея хранить заказы не в MySQL, а в 1С. И тут Вы сталкиваетесь с проблемой — Вам приходится изменять код, который отлично работал, да и ещё и изменения вносить в каждый метод, использующий MySQLOrderRepository.
К тому же, Вы и не писали тесты для OrderModel…
Таким образом, можно выделить следующие проблемы кода, приведенного ранее.
* Такой код плохо тестируется. Мы не можем протестировать отдельно 2 модуля, когда они настолько сильно связаны
* Такой код плохо расширяется. Как показал пример выше, для изменения хранилища заказов, пришлось изменять и модель, обрабатывающую заказы
И что же со всем этим делать?
1. Фабричный метод / Абстрактная фабрика
========================================
Одним из самых простых способов реализации инверсии управления является **фабричный метод (может использоваться и абстрактная фабрика)**
Суть его заключается в том, что вместо непосредственного инстанцирования объекта класса через new, мы предоставляем классу-клиенту некоторый интерфейс для создания объектов. Поскольку такой интерфейс при правильном дизайне всегда может быть переопределён, мы получаем определённую гибкость при использовании низкоуровневых модулей в модулях высокого уровня.
Рассмотрим выше приведённый пример с заказами.
Вместо того, чтобы напрямую инстанцировать объект класса MySQLOrderRepository, мы вызовем фабричный метод build для класса OrderRepositoryFactory, который и будет решать, какой именно экземпляр и какого класса должен быть создан.
**Реализация инверсии управления с помощью Factory Method**
```
php
class OrderModel
{
public function getOrder($orderID)
{
$factory = new DBOrderRepositoryFactory();
$orderRepository = $factory-build();
$order = $orderRepository->load($orderID);
return $this->prepareOrder($order);
}
private function prepareOrder($order)
{
//some order preparing
}
}
abstract class OrderRepositoryFactory
{
/**
* @return IOrderRepository
*/
abstract public function build();
}
class DBOrderRepositoryFactory extends OrderRepositoryFactory
{
public function build()
{
return new MySQLOrderRepository();
}
}
class RemoteOrderRepositoryFactory extends OrderRepositoryFactory
{
public function build()
{
return new OneCOrderRepository();
}
}
interface IOrderRepository
{
public function load($orderID);
}
class MySQLOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to DB to fetch order row from table
}
}
class OneCOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to 1C to fetch order
}
}
```
**Что нам даёт такая реализация?**
1. Нам предоставляется гибкость в создании объектов-репозиториев — инстанцируемый класс может быть заменён на любой, который мы сами пожелаем. Например, MySQLOrderRepository для DBOrderRepositoryfactory может быть заменён на OracleOrderRepository. И это будет сделано в одном месте
2. Код становится более очевидным, поскольку объекты создаются в специализированных для этого классах
3. Также имеется возможность добавить для выполнения какой-либо код при создании-объектов. Код будет добавлен только в 1 месте
**Какие проблемы данная реализация не решает?**
1. Код перестал зависеть от низкоуровневых модулей, но тем не менее зависит от класса-фабрики, что всё равно несколько затрудняет тестирование
2. Service Locator
==================
Основная идея паттерна Service Locator заключается в том, чтобы иметь объект, который знает, как получить все сервисы, которые, возможно, потребуются. Главное отличие от фабрик в том, что Service Locator не создаёт объекты, а знает как получить тот или иной объект. Т.е. фактически уже содержит в себе инстанцированные объекты.
Объекты в Service Locator могут быть добавлены напрямую, через конфигурационный файл, да и вообще любым удобным программисту способом.
**Реализация инверсии управления с помощью Service Locator**
```
php
class OrderModel
{
public function getOrder($orderID)
{
$orderRepository = ServiceLocator::getInstance()-get('orderRepository');
$order = $orderRepository->load($orderID);
return $this->prepareOrder($order);
}
private function prepareOrder($order)
{
//some order preparing
}
}
class ServiceLocator
{
private $services = array();
private static $serviceLocatorInstance = null;
private function __construct(){}
public static function getInstance()
{
if(is_null(self::$serviceLocatorInstance)){
self::$serviceLocatorInstance = new ServiceLocator();
}
return self::$serviceLocatorInstance;
}
public function loadService($name, $service)
{
$this->services[$name] = $service;
}
public function getService($name)
{
if(!isset($this->services[$name])){
throw new InvalidArgumentException();
}
return $this->services[$name];
}
}
interface IOrderRepository
{
public function load($orderID);
}
class MySQLOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to DB to fetch order row from table
}
}
class OneCOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to 1C to fetch order
}
}
// somewhere at the entry point of application
ServiceLocator::getInstance()->loadService('orderRepository', new MySQLOrderRepository());
```
**Что нам даёт такая реализация?**
1. Нам предоставляется гибкость в создании объектов-репозиториев. Мы можем привязать к именованному сервису любой класс который мы пожелаем сами.
2. Появляется возможность конфигурирования сервисов через конфигурационный файл
3. При тестировании сервисы могут быть заменены Mock-классами, что позволяет без проблем протестировать любой класс, использующий Service Locator
**Какие проблемы данная реализация не решает?**
В целом, спор о том, является Service Locator паттерном или анти-паттерны уже очень старый и избитый. На мой взгляд, главная проблема Service Locator
1. Поскольку объект-локатор это глобальный объект, то он может быть доступен в любой части кода, что может привезти к его чрезмерному коду и соответственно свести на нет все попытки уменьшения связности модулей
3. Dependency Injection
=======================
В целом, Dependency Injection — это предоставление внешнего сервиса какому-то классу путём его внедрения.
Таких пути бывает 3
* Через метод класса (Setter injection)
* Через конструктор (Constructor injection)
* Через интерфейс внедрения (Interface injection)
Setter injection
----------------
При таком методе внедрения в классе, куда внедрятся зависимость, создаётся соответствутющий set-метод, который и устанавливает данную зависимость
**Реализация инверсии управления с помощью Setter injection**
```
php
class OrderModel
{
/**
* @var IOrderRepository
*/
private $repository;
public function getOrder($orderID)
{
$order = $this-repository->load($orderID);
return $this->prepareOrder($order);
}
public function setRepository(IOrderRepository $repository)
{
$this->repository = $repository;
}
private function prepareOrder($order)
{
//some order preparing
}
}
interface IOrderRepository
{
public function load($orderID);
}
class MySQLOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to DB to fetch order row from table
}
}
class OneCOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to 1C to fetch order
}
}
$orderModel = new OrderModel();
$orderModel->setRepository(new MySQLOrderRepository());
```
Constructor injection
---------------------
При таком методе внедрения в конструкторе класса, куда внедрятся зависимость, добавляется новый аргумент, который и является устанавливаемой зависимостью
**Реализация инверсии управления с помощью Constructor injection**
```
php
class OrderModel
{
/**
* @var IOrderRepository
*/
private $repository;
public function __construct(IOrderRepository $repository)
{
$this-repository = $repository;
}
public function getOrder($orderID)
{
$order = $this->repository->load($orderID);
return $this->prepareOrder($order);
}
private function prepareOrder($order)
{
//some order preparing
}
}
interface IOrderRepository
{
public function load($orderID);
}
class MySQLOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to DB to fetch order row from table
}
}
class OneCOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to 1C to fetch order
}
}
$orderModel = new OrderModel(new MySQLOrderRepository());
```
Interface injection
-------------------
Такой метод внедрения зависимостей очень похож на Setter Injection, затем исключением, что при таком методе внедрения класс, куда внедрятся зависимость, наследуется от интерфейса, который обязует класс реализовать данный set-метод.
**Реализация инверсии управления с помощью Interface injection**
```
php
class OrderModel implements IOrderRepositoryInject
{
/**
* @var IOrderRepository
*/
private $repository;
public function getOrder($orderID)
{
$order = $this-repository->load($orderID);
return $this->prepareOrder($order);
}
public function setRepository(IOrderRepository $repository)
{
$this->repository = $repository;
}
private function prepareOrder($order)
{
//some order preparing
}
}
interface IOrderRepositoryInject
{
public function setRepository(IOrderRepository $repository);
}
interface IOrderRepository
{
public function load($orderID);
}
class MySQLOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to DB to fetch order row from table
}
}
class OneCOrderRepository implements IOrderRepository
{
public function load($orderID)
{
// makes query to 1C to fetch order
}
}
$orderModel = new OrderModel();
$orderModel->setRepository(new MySQLOrderRepository());
```
**Что нам даёт реализация с помощью Dependency Injection?**
1. Код классов теперь зависит только от интерфейсов, не абстракций. Конкретная реализация уточняется на этапе выполнения
2. Такие классы очень легки в тестировании
**Какие проблемы данная реализация не решает?**
По правде говоря, я не вижу во внедрении зависимостей каких-то больших недостатков. Это хороший способ сделать класс гибким и максимально независимым от других классов. Возможно это ведёт к излишней абстракции, но это уже проблема конкретной реализации принципа программистом, а не самого принципа
4. IoC-контейнер
================
IoC-контейнер — это некий контейнер, который непосредственно занимается управлением зависимостями и их внедрениями (фактически реализует Dependency Injection)
IoC-контейнеры присутствует во многих современных PHP-фреймворках — Symfony 2, Yii 2, Laravel, даже в Joomla Framework :)
Главное его целью является автоматизация внедрения зарегистрированных зависимостей. Т.е. вам необходимо только лишь указать в конструкторе класса необходимый интерфейс, зарегистрировать конкретную реализацию данного интерфейса и вуаля — зависимость внедрена в Ваш класс
Работа таких контейнеров несколько отличается в различных фреймворках, поэтому предоставляю вам ссылки на официальные ресурсы фреймворков, где описано как работают их контейнеры
Symfony 2 — [symfony.com/doc/current/components/dependency\_injection/introduction.html](http://symfony.com/doc/current/components/dependency_injection/introduction.html)
Laravel — [laravel.com/docs/4.2/ioc](http://laravel.com/docs/4.2/ioc)
Yii 2 — [www.yiiframework.com/doc-2.0/guide-concept-di-container.html](http://www.yiiframework.com/doc-2.0/guide-concept-di-container.html)
Заключение
==========
Тема инверсии управления поднималась уже миллионы раз, сотни постов и тысячи комментариев на эту тему. Но тем не менее, всё также я встречаю людей, вижу код и понимаю, что данная тема ещё не очень популярна в PHP, несмотря на наличие отличных фреймворков, библиотек, позволяющих писать красивый, чистый, читаемый, гибкий код.
Надеюсь статья была кому-то полезная и чей-то код благодаря этому станет лучше.
Пишите свои замечания, пожелания, уточнения, вопросы — буду рад | https://habr.com/ru/post/244517/ | null | ru | null |
# Игры в OLTP
В последнее время на Хабре стала популярной тема реализации высокопроизводительных приложений. Решили тоже немножко поэкспериментировать в этом направлении и поделиться текущими результатами наших изысканий.
Подопытный *«Hello, world!»* представляет собой простейшую OLTP систему:
Требования к производительности и отказоустойчивости являются ключевыми для подобных систем. Поэтому поиск решения поставленной задачи осуществлялся в направлении: C, C++, fastcgi, nginx, lighttpd, oracle. В первую очередь нам было любопытно попробовать различные варианты построения OLTP на данных технологиях, а так же измерить производительность и пиковые нагрузки.
#### И так, условия задачи
Необходимо обрабатывать транзакции вида: перевести X у.е. (денег, а вы что подумали) со счета A на счет B. Чтобы не придумывать велосипед и обеспечить масштабируемость, для взаимодействия с клиентом был выбран протокол HTTP.
#### Запросы имеют вид
**server.com/paysys.request?account=123&operator=456&money=789**
что значит: перевести 789 денег со счета оператора 456 на счет пользователя 123.
В базе данных всего три таблички:
(Рис 1. Структура БД)
Процедура транзакции не намного сложнее структуры базы данных:
> `1. procedure PROCESS\_TRANS(p\_account\_id in number,
> 2. p\_operator\_id in number,
> 3. p\_sum in number,
> 4. o\_result out number) is
> 5.
> 6. l\_cnt number;
> 7.
> 8. cursor cur\_account is
> 9. select id
> 10. from pay\_account
> 11. where id = p\_account\_id
> 12. for update of balance;
> 13.
> 14. cursor cur\_operator is
> 15. select id
> 16. from pay\_operator
> 17. where id = p\_operator\_id
> 18. and total >= p\_sum
> 19. for update of total;
> 20.
> 21. begin
> 22.
> 23. o\_result := -1; -- tansaction begins
> 24.
> 25. select count(1) -- if such operator exist?
> 26. into l\_cnt
> 27. from pay\_operator opr
> 28. where opr.id = p\_operator\_id;
> 29.
> 30. if (l\_cnt != 1)
> 31. then
> 32. o\_result := -2; -- Operator not found!
> 33. return;
> 34. end if;
> 35.
> 36. open cur\_account;
> 37. open cur\_operator;
> 38.
> 39. fetch cur\_account into l\_cnt; -- need to fetch to update rows later
> 40. fetch cur\_operator into l\_cnt; -- 0/1 row in cursor as selected by prim\_key
> 41.
> 42. if cur\_account%notfound then
> 43.
> 44. o\_result := -3; -- Account not found!
> 45.
> 46. elsif cur\_operator%notfound then
> 47.
> 48. o\_result := -4; -- Operator has not enough money
> 49.
> 50. else
> 51.
> 52. update pay\_account
> 53. set balance = (balance + p\_sum)
> 54. where current of cur\_account;
> 55.
> 56. update pay\_operator
> 57. set total = (total - p\_sum)
> 58. where current of cur\_operator;
> 59.
> 60. insert
> 61. into pay\_transaction
> 62. (
> 63. id,
> 64. account\_id,
> 65. operator\_id,
> 66. money,
> 67. datetime
> 68. )
> 69. values
> 70. (
> 71. pay\_transaction\_seq.nextval,
> 72. p\_account\_id,
> 73. p\_operator\_id,
> 74. p\_sum,
> 75. sysdate
> 76. );
> 77.
> 78. commit;
> 79. o\_result := 1; -- transaction successfully finished!
> 80.
> 81. end if;
> 82.
> 83. close cur\_account;
> 84. close cur\_operator;
> 85.
> 86. end;
> \* This source code was highlighted with Source Code Highlighter.`
Наиболее идеологически и практически правильным подходом к построению высоконагруженного серверного приложения с большим количеством одновременных подключений является реализация мультиплексора ([The C10K problem](http://www.kegel.com/c10k.html)).
В качестве БД решили взять «нетрадиционный» *Oracle 10.2 Express Edition*. Транзакции (update) в БД у нас выполнялись за *~2 ms*. Временами, когда Oracle сбрасывал данные на диск (видимо *dbwr* записывал из буферного кэша измененные блоки данных), выполнение транзакции затягивалось до *~20 ms*.
Для соединения с базой данных мы решили использовать библиотеки от производителя. Таковых, в рамках нашей задачи, набралось 2 шутки:* Oracle Call Interface ©
* Oracle C++ Call Interface (C++)
OCCI, в лучших традициях ООП, гораздо более нагляден и прост в использовании. Однако, его низкоуровневый собрат обладает неоспоримым преимуществом: OCI позволяет выполнять неблокирующие (асинхронные) запросы к БД, что необходимо для реализации мультиплексирующего сервера при нескольких запросах к БД в рамках обработки одного клиента. Многие недовольны тем, что ради возможности неблокирующих вызовов необходимо писать достаточно громоздкий код и просят Oracle открыть исходники OCCI, но, насколько я знаю, пока безрезультатно. По производительности 2 брата отличаются крайне незначительно, что вполне ожидаемо.
#### Ингредиенты:
* Oracle XE 10.2
* Nginx 0.7.62
* Lighttpd 1.4.23
обитали на *Ubuntu 9.04* под *VMWare* на ноутбуке *Acer 5920G*, за неимением пока другого железа :). Надеемся нехватка ресурсов (в обоих смыслах) не отразилась на объективности результатов сравнительных тестов, ведь все испытания проводились в одной и той же среде.
Сразу оговоримся, что в настройке Oracle нам далеко до Тома Кайта, поэтому с тюнингом БД и ОС сильно не заморачивались. Займемся, когда переедем на полноценный сервер.
Для чистоты эксперимента в каждую табличку было внесено по ~100к записей.
Опыты
-----
Как построить такую системку? Нам первым на ум пришло самое простое решение на базе протокола FastCGI. Думаю, не стоит в очередной раз объяснять, чем выгодно отличается FastCGI от своего прародителя CGI. Для высоконагруженного приложения эта разница приципиальна. Хотелось бы подробнее остановиться на другом нюансе, который мы выяснили далеко не сразу.
Спецификация FastCGI предусматривает сохранение пользовательского соединения для возможности реализации мультиплексированной обработки нескольких запросов одновременно. Говоря простым языком, в обработчике запроса можно вызвать асинхронную операцию и спокойно отдать процессорное время другим клиентам, а на следующей итерации цикла опроса получить результат вызванной операции и, передав ответ клиенту, закрыть соединение. К сожалению, nginx и lighttpd (а также библиотеки libfcgi и fastcgipp) пока не поддерживают подобное, требуя закрыть соединение перед обработкой следующего клиента.
Однако в данном примере мы ограничились лишь одним коротким запросом к БД, который вполне можно выполнить и синхронно, не опасаясь сколь либо значимых потерь в производительности.
Nginx и lighttpd позволяют взаимодействовать с FastCGI двумя методами: через TCP канал и Unix Domain Socket. Преимуществом первого подхода является возможность кластеризации FastCGI серверов, недостатком – относительно высокие накладные расходы на передачу данных (TCP-стек все же). UDS же работает только локально, за счет чего обеспечивается более высокая производительность.
О втором методе хочется сказать очень много «теплых» слов. После первых тестов обнаружилось, что до FastCGI приложения доходит едва ли десятая часть запросов при одновременных запросах более 200 клиентов (на нашей железяке). Загвоздка оказалась в переменной ядра net.unux.max\_dgram\_qlen, которая ограничивает размер очереди запросов при записи в сокет. По умолчанию данная опция равнялась 10, что и объяснило потери запросов. После установки значения в 10000, казалось бы, все должно было прийти в норму. Но не тут-то было. Гарантированно отваливалась почти десятая часть запросов, а nginx писал в логии страшные слова *“connect() to socket failed (11: Resource temporary unavailable)”*. Говоря русским языком, при большом количестве одновременных запросов сокет «захлебывался». Данную проблему нам пока решить не удалось. Хоть производительность и возросла, но кому она нужна такая, когда порядка 10% транзакций завершаются кодом *«502»*.
### FastCGI сервер:
> `1. const char \*bind\_address = ":9000";
> 2. const char \*db\_user\_name = "orauser";
> 3. const char \*db\_password = "pass";
> 4. const char \*db\_conn\_str = "comp:1521/xe";
> 5.
> 6. int main(int argc, char\* const argv[] )
> 7. {
> 8. using namespace oracle::occi;
> 9.
> 10. int listenQueueBacklog = 4000;
> 11. FCGX\_Request request;
> 12.
> 13. if(FCGX\_Init())
> 14. exit(1);
> 15.
> 16. int listen\_socket = FCGX\_OpenSocket(bind\_address, listenQueueBacklog);
> 17. if (listen\_socket < 0)
> 18. exit(1);
> 19.
> 20. if (fchmod(listen\_socket, S\_IROTH | S\_IWOTH))
> 21. exit(1);
> 22.
> 23. if(FCGX\_InitRequest(&request, listen\_socket, 0)) exit(1);
> 24.
> 25. Environment\*env = Environment::createEnvironment(Environment::DEFAULT);
> 26. Connection \*conn = env->createConnection(db\_user\_name, db\_password, db\_conn\_str);
> 27. Statement \*stmt = conn->createStatement(
> 28. "BEGIN PAY\_SYS.PROCESS\_TRANS(:v1,:v2,:v3,:v4); END;");
> 29.
> 30. while(FCGX\_Accept\_r(&request) == 0)
> 31. {
> 32. bool noException = false, succesful = false;
> 33.
> 34. long start = GetTickCount();
> 35. char \*params = FCGX\_GetParam("QUERY\_STRING", request.envp);
> 36. int operatorID,accountID,moneySum, result=-1;
> 37.
> 38. operatorID = GetIntParam(params, "operator=");
> 39. accountID = GetIntParam(params, "account=");
> 40. moneySum = GetIntParam(params, "money=");
> 41.
> 42. if (operatorID <= 0 || accountID <= 0 || moneySum <= 0)
> 43. {
> 44. FCGX\_FPrintF(request.out, "HTTP/1.0 503 Params Error\n");
> 45. FCGX\_FPrintF(request.out, "Content-type: text/html\r\n\r\n");
> 46. FCGX\_FPrintF(request.out, "wrong params
> \n");
> 47. FCGX\_Finish\_r(&request);
> 48. continue;
> 49. }
> 50.
> 51. try
> 52. {
> 53. stmt->setInt(1, accountID);
> 54. stmt->setInt(2, operatorID);
> 55. stmt->setInt(3, moneySum);
> 56. stmt->registerOutParam(4,OCCIINT,sizeof(result));
> 57. stmt->execute();
> 58. result = stmt->getInt(4);
> 59.
> 60. if (result == 1)
> 61. succesful = true;
> 62. }
> 63. catch(SQLException &sqlExcp)
> 64. {
> 65. error\_log(sqlExcp.getMessage().c\_str());
> 66. }
> 67.
> 68. if (succesful)
> 69. {
> 70. FCGX\_FPrintF(request.out, "HTTP/1.0 200 OK\n");
> 71. FCGX\_FPrintF(request.out, "Content-type: text/html\r\n\r\n");
> 72. FCGX\_FPrintF(request.out, "SQL result = %d", result);
> 73. }
> 74. else
> 75. {
> 76. FCGX\_FPrintF(request.out, "HTTP/1.0 503 DatabaseError\n");
> 77. FCGX\_FPrintF(request.out, "Content-type: text/html\r\n\r\n");
> 78. FCGX\_FPrintF(request.out, "Database error occured");
> 79. error\_log("db error");
> 80. }
> 81.
> 82. FCGX\_Finish\_r(&request);
> 83. }
> 84.
> 85. conn->terminateStatement(stmt);
> 86. env->terminateConnection(conn);
> 87. Environment::terminateEnvironment(env);
> 88.
> 89. return 0;
> 90. }
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/69974/ | null | ru | null |
# Сквозное и интеграционное тестирование просто, как юнит-тесты
Когда изменения затрагивают несколько микросервисов, возникает вопрос, как протестировать их в связке. Можно покрыть границы сервисов юнит тестами, а интеграцию проверить, развернув измененный код на тестовом окружении. У такого подхода две главные проблемы: цикл изменения-тестирование-исправления становится достаточно долгим и нужно много полноценных окружений, чтобы обеспечить параллельную работу нескольких разработчиков. Давайте попробуем решить проблему иначе.
Будем решать проблему последовательно, по шагам преодолевая возникающие трудности.
Код можно найти на [GitHub](https://github.com/Fuud/integration-tests-article). К каждой части будет ссылка на ревизию.
### 1. Постановка задачи
[rev:2b8fcd50](https://github.com/Fuud/integration-tests-article/commit/2b8fcd509151ebc83c24d2b4e9fd0b665eb82ded)
Для примера возьмем два микросервиса, написанных с использованием spring-boot. Для простоты у нас будет многомодульный мавен-проект с двумя севисами: client-service и worker-service. Допустим, что надо реализовать функционал:
client-service должен принимать http запросы с задачами и отправлять их на выполнение в worker-service, а worker-service возвращает идентификатор выполняемой задачи.
Получилось два эндпоинта:
ClientServiceEndpoint
```
@PostMapping("/task")
public String placeTask(@RequestBody ClientRequest request){
return restTemplate.postForObject(config.getWorkerUrl(),request,WorkerResponseDto.class).getJobId();
}
```
WorkerServiceEndpoint
```
@PostMapping("/task")
public WorkerResponseDto placeTask(@RequestBody ClientRequest request){
WorkerResponseDto workerResponseDto=new WorkerResponseDto();
workerResponseDto.setJobId(UUID.randomUUID().toString());
return workerResponseDto;
}
```
Оба проекта можно запустить локально (`ClientServiceApplication.main` и `WorkerServiceApplication.main`). Теперь можно к ним написать мануальные тесты (кодом или в какой-нибудь специализированной среде вроде Talend Api Tester).
Этот подход работает. Его даже можно автоматизировать, если отдельными шагами запускать приложения. Но при автоматизации можно столкнуться со следующими трудностями:
1. Сложно следить за запущенными приложениями (надо не забыть их остановить после тестов)
2. Если микросервисов много, то их придется все запускать руками при разработке (или прогонять всю сборку целиком мавеном/гредлом)
3. Если у приложений есть состояние, то тесты могут начать влиять друг на друга.
4. Сложно тестировать сценарии деградации при недоступности одного из микросервисов. Перекликается с пунктом 1 и 3: если остановить один из компонентов, могут упасть тесты, использующие этот компонент. Надо после каждого теста восстановить исходное состояние (и не запускать тесты одновременно).
Можно сформулировать требования к идеальным межкомпонентным тестам:
1. Должны запускаться одной кнопкой run test из IDE
2. Написание не должно представлять трудностей и не должно сильно отличаться от написания юнит-тестов.
3. Должны поддерживать отладку отдельных микросервисов
4. Должны быть изолированы друг от друга
5. Запуск теста должен быть достаточно быстрый, чтобы при разработке можно было пользоваться практикой TDD
6. Должны быть интегрированы c CI. Идеально, чтобы их можно было прогонять при проверке пул реквестов.
Давайте попробуем решить задачу тестирования с учетом этих требований.
### 2. Пробуем наивное решение: сделаем модуль, зависимый от модулей микросервисов и напишем тест в нем.
[rev:cfbebf68](https://github.com/Fuud/integration-tests-article/commit/cfbebf68c0876dc2bfaaca8cb3074d7c6275d414)
Первое, что приходит в голову, когда надо протестировать функциональность двух микросервисов в связке, это сделать третий модуль для тестов, зависимый от сервисных модулей. Попробуем написать тест в нем:
```
public class TaskIntegrationTest {
@Test
public void testTaskSubmission() throws Exception {
ClientServiceApplication.main(new String[0]);
WorkerServiceApplication.main(new String[0]);
HttpResponse response = HttpClient.newBuilder().build().send(
HttpRequest.newBuilder()
.method("POST", HttpRequest.BodyPublishers.ofString("{ \"data\":\"my-data\"}"))
.header("Content-Type", "application/json")
.uri(URI.create("http://localhost:8080/task"))
.build(),
HttpResponse.BodyHandlers.ofString()
);
assertEquals(response.statusCode(), 200);
assertFalse(response.body().isBlank());
}
}
```
Но такой тест не заработает. Причина: у нашего теста в класспассе оказалось два application.yml и Spring берет первый попавшийся. Исправим это, задав имена приложений. Например, для client-service назовем файл конфигурации application-client.yml и зададим имя так:
```
public static void main(String[]args){
SpringApplication.run(ClientServiceApplication.class,"--spring.config.name=application-client");
}
```
Если у всех наших приложений одинаковый набор зависимостей, то такой способ подойдет. Надо только доделать закрытие спрингового контекста и выбор свободных портов.
### 3. Добавление зависимостей в один из сервисов затрагивает другие сервисы в тестах
[rev:7c8abae7](https://github.com/Fuud/integration-tests-article/commit/7c8abae738f827b7601bc42704c3c1e657ae09fb)
Если у разных сервисов разный набор зависимостей, то тесты могут вести себя непредсказуемым образом. Например, если мы хотим защитить client-service и добавляем spring-boot-starter-security в зависимости, то неожиданно оказывается защищенным и worker-service. И тесты падают несмотря на то, что production build у worker-service не поменялся. Можно предположить и существование обратного случая: тесты проходят, а на реальном окружении что-то не работает.
Вывод: чтобы тестировать микросервисы надо запускать каждый из них с тем же класспасом, что будет использован в боевом окружении.
### 4. Используем maven-dependency-plugin, чтобы получить правильный класспасс
[rev:50d2802f](https://github.com/Fuud/integration-tests-article/commit/50d2802f9f4cbf710beb65fbd87850139b3131d6)
В этой части речь пойдет про maven. Для gradle можно сделать примерно так же.
Чтобы получить правильный список зависимостей в правильном порядке можно вызвать `mvn compile dependency:build-classpath`. Здесь включение фазы compile обязательно, потому что иначе мавен будет
считать внутрипроектные зависимости внешними и пытаться найти их в .m2 и внешних репозиториях. Подробности тут: [MNG-3283](https://issues.apache.org/jira/browse/MNG-3283).
Далее вопрос в том, кто будет вызывать dependency-plugin? Есть следующий варианты:
1. Прописываем в pom.xml, локально вызываем из командной строки, на CI вызовется автоматически.
2. Используем [maven-embedder](https://maven.apache.org/ref/3.8.4/maven-embedder/) и вызываем прямо из теста. Проблема в том, что у maven-embedder нет собранной версии с зависимостями, а тянет за собой он очень много. И это с легкостью ломает тесты. Но можно его собрать и положить в свой репозиторий.
Мне кажется, что достаточно первого варианта. Дописываем в pom.xml
```
org.apache.maven.plugins
maven-dependency-plugin
3.3.0
generate classpath file for IT
build-classpath
process-classes
runtime
${project.build.directory}/classpath\_${project.artifactId}.txt
```
Теперь после исполнения `mvn process-classes` в target окажутся файлы со списком зависимостей. Не составит труда их найти и прочитать, если знать, где находится корень проекта. Проблема тут в том, что текущая директория при запуске из IDE и при запуске maven-surefire-plugin может отличаться. Но в любом случае она находится внутри проекта. Поэтому можно положить файл-маркер рядом с самым верхним pom.xml, искать его вверх, а потом от него рекурсивно спускаться.
```
private static File findTopProjectDir() throws IOException {
File topProjectDir = new File(".").getCanonicalFile();
do {
if (new File(topProjectDir, ".top.project.dir").exists()) {
return topProjectDir;
}
topProjectDir = topProjectDir.getParentFile();
} while (topProjectDir != null);
throw new IllegalStateException("Cannot find marker file .top.project.dir starting from " + new File(".").getAbsolutePath());
}
```
И вычитать класспассы, складывая их в Map по ключу artifact\_id (если у вас artifact\_id не уникальный, можно использовать group\_id:artifact\_id). Особенность тут заключается в том, что build\_classpath не включает target/classes того модуля, для которого класспасс строится, эту директорию надо добавить дополнительно в начало classpath:
```
private static void searchForClassPathFiles(File topProjectDir, Map> results) throws IOException {
File pomXml = new File(topProjectDir, "pom.xml");
if (pomXml.exists()) {
File targetDir = new File(topProjectDir, "target");
File[] classPathFiles = targetDir.listFiles(pathname -> pathname.getName().startsWith("classpath\_") && pathname.getName().endsWith(".txt"));
if (classPathFiles != null) {
if (classPathFiles.length > 1) {
throw new IllegalStateException("Found more than one classpath file in dir " + targetDir.getAbsolutePath());
}
if (classPathFiles.length == 1) {
File classPathFile = classPathFiles[0];
List classPath = new ArrayList<>(Arrays.asList(Files.readString(classPathFile.toPath()).split(System.getProperty("path.separator"))));
// maven-dependency-plugin build-classpath does not include module classes, let's include them now
classPath.add(0, new File(targetDir, "classes").getAbsolutePath());
String artifactId = classPathFile.getName().replaceAll("^classpath\_", "").replaceAll(".txt$", "");
if (results.containsKey(artifactId)) {
throw new IllegalStateException("Duplicate artifact id: " + artifactId);
}
results.put(artifactId, classPath);
}
}
File[] probablySubmodules = topProjectDir.listFiles(File::isDirectory);
if (probablySubmodules != null) {
for (File probablySubmodule : probablySubmodules) {
searchForClassPathFiles(probablySubmodule, results);
}
}
}
}
```
На CI все пройдет хорошо - файлы со списком зависимостей будут актуальными. А вот в локальной разработке сложно не забыть обновить файлы после изменения зависимостей в pom.xml. Чтобы программно заметить изменения, я предлагаю все pom.xml при сборке скопировать в target. Именно все, потому что прослеживать внутремодульные зависимости сложно:
```
com.coderplus.maven.plugins
copy-rename-maven-plugin
1.0
copy-pom
process-classes
copy
pom.xml
target/pom-copy.xml
```
И сравнить их с оригиналами перед вычитыванием classpath files.
```
private static void checkPomChanges(File topProjectDir) throws IOException {
File pomXml = new File(topProjectDir, "pom.xml");
if (pomXml.exists()) {
File targetPomFile = new File(new File(topProjectDir, "target"), "pom-copy.xml");
if (!targetPomFile.exists()) {
throw new IllegalStateException(targetPomFile.getAbsolutePath() + " is not generated, run `mvn process-classes` first");
}
if (!Files.readString(pomXml.toPath()).equals(Files.readString(targetPomFile.toPath()))) {
throw new IllegalStateException(targetPomFile.getAbsolutePath() + " is not equal to " + pomXml.getAbsolutePath() + ", run `mvn process-classes` first");
}
File[] probablySubmodules = topProjectDir.listFiles(File::isDirectory);
if (probablySubmodules != null) {
for (File probablySubmodule : probablySubmodules) {
checkPomChanges(probablySubmodule);
}
}
}
}
```
### 5. Запускаем сервисы в отдельных процессах используя библиотеку nanocloud
[rev:f9118159](https://github.com/Fuud/integration-tests-article/commit/f9118159e514d15b9897104ec7b47e69b9e0c63d)
Теперь, зная classpath, можно запустить сервисы в отдельных процессах. Запуск в одном процессе, но разных класслоадерах скорее всего приведет к трудностям, так как разные библиотеки используют разных общий стейт: системные переменные, Service Providers и другие возможности, которые приходят с boot class loader.
Запуск в отдельной jvm можно сделать с помощью ProcessBuilder. А можно воспользоваться
библиотекой [nanocloud](https://github.com/gridkit/nanocloud). Вот так можно запустить сервис:
```
Cloud cloud = CloudFactory.createCloud();
ViNode clientNode = cloud.node("client"); // каждая нода - от
clientNode.x(VX.CLASSPATH).inheritClasspath(false);
ViProps.at(clientNode).setLocalType(); // будем запускать локально, в отдельной jvm
ClassPathHelper.getClasspathForArtifact("client-service")
.forEach(classPathElement -> clientNode.x(VX.CLASSPATH).add(classPathElement));
clientNode.exec(new Runnable() {
@Override
public void run() {
ClientServiceApplication.main(new String[0]);
}
});
```
### 6. Добавляем обертки для ViNode, заменяем анонимные классы на лямбды
[rev:f7e1724b](https://github.com/Fuud/integration-tests-article/commit/f7e1724b9e8c35d976c8912c07444f1228af16b5)
При запуске сервиса был использован анонимный класс, а не лямбда. Это было сделано потому, что nanocloud для пересылки объектов использует java-serialization с дополнением для сериализации анонимных классов. Это было удобно в java 1.6, но сейчас выглядит архаично. Но если просто заменить анонимный класс на лямбду, то произойдет ошибка сериализации. Поэтому удобно написать обертку (заодно научив ее различать callable и runnable):
```
public class Node implements ViConfigurable {
private final ViNode node;
public Node(Cloud cloud, String name) {
node = cloud.node(name);
}
public void exec(SerializableRunnable runnable) {
node.exec(runnable);
}
public T execAndReturn(SerializableCallable callable) {
return node.exec(callable);
}
...
и другие методы, делегирующие к ViNode
public interface SerializableRunnable extends Runnable, Serializable {
void run();
}
public interface SerializableCallable extends Callable, Serializable {
T call();
}
}
```
### 7. Выделяем свободные порты сервисам.
[rev:90080a1c](https://github.com/Fuud/integration-tests-article/commit/90080a1c51519a0bbf2126dda1b01fc69730db99)
Сейчас сервисы запускаются на портах, которые прописаны в файлах конфигурации. У этого есть два недостатка: порт может быть занят другим приложением и нельзя запускать тесты в параллель.
Самый простой способ получить свободный порт такой:
```
int freePort()throws Exception{
try(ServerSocket socket=new ServerSocket(0)){
return socket.getLocalPort();
}
}
```
Недостатки:
1. Один и тот же порт может быть выдан несколько раз (пока приложение не запустится и не заберет порт себе)
2. Порты будут разные от запуска к запуску, что усложняет отладку (например, при каждом перезапуске теста придется вводить новый адрес, если мы что-то тестируем в ручном режиме)
Можно поступить так: сперва найдем свободный базовый порт, займем его, а потому будем раздавать последовательно порты, начиная со следующего за базовым.
```
public class PortAllocator {
private static final int CHUNK_SIZE = 10_000;
// сохраняем ServerSocket в поле, чтобы он не был прибран ГЦ и
// другой запуск тестов не мог забрать базовый порт
private static ServerSocket basePortHolder;
private static int port;
public static synchronized int freePort() {
if (basePortHolder == null) {
for (int i = 1; i < 6; i++) {
try {
basePortHolder = new ServerSocket(i * CHUNK_SIZE);
break;
} catch (IOException e) {
// ignore
}
}
if (basePortHolder == null) {
throw new IllegalStateException("Cannot find port base, all ports are occupied");
}
port = basePortHolder.getLocalPort();
}
// ищем следующий свободный порт
while (port < basePortHolder.getLocalPort() + CHUNK_SIZE) {
port++;
if (portIsFree(port)) {
return port;
}
}
throw new IllegalStateException("Cannot find free port starting from " + basePortHolder.getLocalPort());
}
private static boolean portIsFree(int port) {
try {
// next line better than just new ServerSocket(port),
// check https://github.com/spring-projects/spring-framework/issues/17906 for discussion
try (ServerSocket ignored = new ServerSocket(port, 0, InetAddress.getByName("localhost"))) {
return true;
}
} catch (Exception e) {
return false;
}
}
}
```
Теперь нужно раздать порты сервисам, а client-service еще должен узнать порт worker-service. Можно выделить абстрактную обертку над сервисом.
```
public interface Component {
/**
* Этот метод будет запущен для старта компонента
* @param env список всех компонентов в текущем тесте
*/
void start(Cloud cloud, List env);
}
```
Тогда в тесте можно будет писать вот так:
```
Cloud cloud=CloudFactory.createCloud();
ClientComponent clientComponent=new ClientComponent();
// стартуем компоненты
env(
cloud,
clientComponent,
new WorkerComponent()
);
```
И метод env будет таким:
```
public static void env(Cloud cloud,Component...components){
for(Component component:components){
component.start(cloud,Arrays.asList(components));
}
}
```
Тогда компоненты смогут сами найти порты тех сервисов, которые им нужны. В нашем случае обертка для client-service будет выглядеть так:
```
public class ClientComponent implements Component {
public static class Config {
public final int restPort = PortAllocator.freePort();
}
public Config config = new Config();
@Override
public void start(Cloud cloud, List env) {
Node clientNode = new Node(cloud, "client");
clientNode.x(VX.CLASSPATH).inheritClasspath(false);
ViProps.at(clientNode).setLocalType();
ClassPathHelper.getClasspathForArtifact("client-service")
.forEach(classPathElement -> clientNode.x(VX.CLASSPATH).add(classPathElement));
// здесь мы используем порт
clientNode.x(VX.JVM).setEnv("server.port", config.restPort + "");
// здесь мы ищем WorkerService и передаем его порт в переменные окружения
WorkerComponent worker = findComponent(env, WorkerComponent.class);
clientNode.x(VX.JVM).setEnv("client-service.worker-url", "http://localhost:" + worker.config.restPort);
clientNode.exec(() -> ClientServiceApplication.main(new String[0]));
}
}
```
### 8. Распечатываем конфиги
[rev:a020e1f9](https://github.com/Fuud/integration-tests-article/commit/a020e1f92ea9e6fdce97671a598b3ecd32ffa93b)
У нас появился произвол в выборе портов, поэтому полезно их сразу распечатывать в консоль. Для http портов лучше распечатывать сразу вместе со ссылкой для быстрого запуска в браузере. Для этого параметризуем компоненты классом конфига, сложим все конфиги в словарь по имени компонента и распечатаем.
```
public abstract class Component {
protected final TConfig config;
public Component(TConfig config) {
this.config = config;
}
abstract public void start(Cloud cloud, List> env);
public TConfig getConfig() {
return config;
}
}
```
```
public class WorkerComponent extends Component {
public static class Config {
final int restPort = PortAllocator.freePort();
private final String link = "http://localhost:" + restPort;
}
...
}
```
```
public class EnvStarter {
public static void env(Cloud cloud, Component... components) {
printConfigsToConsole(components);
for (Component component : components) {
component.start(cloud, Arrays.asList(components));
}
}
private static void printConfigsToConsole(Component[] components) {
ObjectWriter objectWriter = new ObjectMapper()
.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY)
.writerWithDefaultPrettyPrinter();
Map configMap = new HashMap<>();
for (Component component : components) {
configMap.put(component.getClass().getSimpleName(), component.getConfig());
}
try {
System.out.println(objectWriter.writeValueAsString(configMap));
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
}
```
### 9. Останавливаем сервисы после теста
[rev:7b4e07f9](https://github.com/Fuud/integration-tests-article/commit/7b4e07f9f78a290adc1ffc64cfd4c953780e20c3)
Библиотека nanocloud следит, чтобы запущенные ею инстансы jvm были остановлены после остановки jvm, на которой был создан Cloud. Но если мы запустим много тестов в одной jvm (так делает, например, maven-surefire-plugin по умолчанию), то запущенные сервисы будут остановлены только после того, как все тесты пройдут. Надо их явно останавливать после теста. Можно это решить с помощью, например, [JUnit Rules](https://www.baeldung.com/junit-4-rules). А можно завернуть тест в лямбду:
```
@FunctionalInterface
public interface TestBlock {
void performTest(Cloud cloud) throws Exception;
}
public static void integrationTest(TestBlock block) {
Cloud cloud = CloudFactory.createCloud();
try {
block.performTest(cloud);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
cloud.shutdown();
}
}
```
И тест тогда будет выглядеть так:
```
@Test
public void testTaskSubmission(){
integrationTest((cloud)->{
ClientComponent clientComponent=new ClientComponent();
env(cloud,clientComponent,new WorkerComponent());
// do the test
});
}
```
### 10. Ускоряем тесты. Настаиваем параллелизацию и настраиваем jvm на быстрый старт
[rev:3cfefd2c](https://github.com/Fuud/integration-tests-article/commit/3cfefd2cebc9c9a75d93c15fcfe5d0671756340c)
Если запустить 100 таких тестов, то выполнение на моем ноутбуке займет примерно 8-9 минут.
Если выполнять тесты в два потока, то выполнение займет 4-5 минут. Дальнейшее увеличение количества потоков *на моем ноутбуке* прироста к скорости не дает. Так что настроим два потока:
```
org.apache.maven.plugins
maven-surefire-plugin
3.0.0-M7
--add-opens java.base/jdk.internal.loader=ALL-UNNAMED
classesAndMethods
2
```
Нам нужен быстрый старт. Похожую задачу решают те, кто пишет для serverless,
например, [Optimizing AWS Lambda function performance for Java](https://aws.amazon.com/ru/blogs/compute/optimizing-aws-lambda-function-performance-for-java/). Вроде бы лучше всего ускоряют следующие аргументы: `-XX:TieredStopAtLevel=1 -Xverify:none`. Задаем эти параметры для всех сервисов:
```
private static void applyCommonJvmArgs(Cloud cloud){
ViNode allNodes=cloud.node("**"); // ** значит все ноды
allNodes.x(VX.JVM).addJvmArg("-XX:TieredStopAtLevel=1");
allNodes.x(VX.JVM).addJvmArg("-Xverify:none");
}
```
Время выполнения становится 1-2 минуты.
### 11. Включаем отладку для сервисов rev:2b327516
Чтобы отлаживать сервисы из IDE, нам надо:
1. выбрать порт: делаем общего предка для всех конфигов и выбираем порт так же, как выбирали порт для http:
```
public static class BaseComponentConfig {
public final int debugPort = PortAllocator.freePort();
}
```
2. удобно подключаться к сервисам: если пользуемся IntelliJ Idea, то достаточно в консоль вывести `Listening for transport dt_socket at address: 8888` и рядом с надписью появится кнопочка Attach Debugger. Добавляем линку в конфиг (пробел в конце обязателен!).
```
public static class BaseComponentConfig {
public final int debugPort = PortAllocator.freePort();
public final String debugLink = "Listening for transport dt_socket at address: " + debugPort + " ";
}
```
3. включать дебаг только когда нужно. Я нашел вариант на [StackOverflow](https://stackoverflow.com/a/71375505). Спасибо Андрей[@apangin](/users/apangin).
```
private static boolean detectIsDebugEnabled() {
ThreadInfo[] infos = ManagementFactory.getThreadMXBean()
.dumpAllThreads(false, false, 0);
for (ThreadInfo info : infos) {
if ("JDWP Command Reader".equals(info.getThreadName())) {
return true;
}
}
return false;
}
```
4. настраивать дебаг для всех сервисов в одном месте. Заменим Cloud на наш интерфес NodeProvider и получим такой код для сетапа теста:
```
@FunctionalInterface
public interface NodeProvider {
Node getNode(String name, Component.BaseComponentConfig config);
}
@FunctionalInterface
public interface TestBlock {
void performTest(NodeProvider nodeProvider) throws Exception;
}
public static void integrationTest(TestBlock block) {
Cloud cloud = CloudFactory.createCloud();
applyCommonJvmArgs(cloud);
NodeProvider nodeProvider = (name, config) -> {
Node node = new Node(cloud, name);
if (isDebugEnabled) {
node.x(VX.JVM).addJvmArgs("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:" + config.debugPort);
}
return node;
};
try {
block.performTest(nodeProvider);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
cloud.shutdown();
}
}
```
### 12. Запускаем сервисы на удаленной машине по ssh
[rev:dcf68675](https://github.com/Fuud/integration-tests-article/commit/dcf6867527c32eb8c4d9c9119148e7be14216d00)
Если тесты долгие или потребляют много ресурсов, можно запускать сервисы на удаленной машине. Настроить nanocloud запускать сервисы по ssh очень просто. Можно авторизоваться по паролю, можно по ключу:
```
private static void configureRemoteExecution(ViNode allNodes){
RemoteNode remoteNodeConfig=allNodes.x(RemoteNode.REMOTE);
remoteNodeConfig.setRemoteNodeType();
// выключаем загрузку ключей/хостов из конфиг файла,
// все будем настраивать явно в коде
remoteNodeConfig.setHostsConfigFile("?na");
remoteNodeConfig.setRemoteAccount(System.getProperty("int.tests.remote.user"));
remoteNodeConfig.setPassword(System.getProperty("int.tests.remote.password"));
// remoteNodeConfig.setSshPrivateKey(System.getProperty("int.tests.remote.key.path"));
remoteNodeConfig.setRemoteHost(System.getProperty("int.tests.remote.host"));
remoteNodeConfig.setRemoteJarCachePath("nanocloud-cache"); // куда складывать jar файлы
remoteNodeConfig.setRemoteJavaExec(System.getProperty("int.tests.remote.java")); // где искать java
}
```
Теперь можно передать правильное имя хоста в тест и тест, скорее всего пройдет. "Скорее всего", потому что, свободные порты мы ищем локально с тестом, а http сервер запускаем удаленно.
Для того чтобы выделять порты правильно, надо выполнять `PortAllocator.freePort` удаленно. Удобно это сделать с помощью nanocloud transparent rmi. Работает он следующим образом: если класс реализует интерфейс, который наследуется от Remote, то при сериализации вместо класса будет отправлен прокси, реализующий этот интерфейс.
В нашем случае:
```
public interface PortAllocator extends Remote {
int freePort();
}
class PortAllocatorImpl implements PortAllocator {
@Override
public synchronized int freePort() { ...}
}
private static PortAllocator obtainPortAllocatorFromRemoteNode() {
Cloud serviceCloud = CloudFactory.createCloud();
Node serviceNode = new Node(serviceCloud, "service-node");
// настраиваем ноду на выполнение по ssh
configureRemoteExecution(serviceNode);
// создаем PortAllocatorImpl удаленно и получаем локальный прокси
return serviceNode.execAndReturn(PortAllocatorImpl::new);
}
```
При использовании transparent rmi надо быть осторожным с типами. Например, вот такой код упадет с ClassCastException,
потому что после сериализации-десериализации прилетит прокси, реализующее интерфейс, а не сам объект.
```
// java.lang.ClassCastException: class jdk.proxy2.$Proxy11 cannot be cast to class fuud.test.infra.PortAllocator$PortAllocatorImpl
PortAllocatorImpl portAllocator = serviceNode.execAndReturn(PortAllocator.PortAllocatorImpl::new);
```
Правильно так:
```
PortAllocator portAllocator = serviceNode.execAndReturn(PortAllocator.PortAllocatorImpl::new);
```
### 13. Заключение и советы по дальнейшему использованию и развитию
Я показал, как можно построить фреймворк для интеграционного тестирования. Если вы начнете его использовать, возможно,
вам будет не хватать каких-то возможностей. Все варианты использования описать сложно, предлагаю наметки по тем
сценариям, которые мне встречались:
1. Тестирование обратной совместимости: для проверки взаимодействия компонентов разных версий достаточно положить в classpath собранные в предыдущий релиз артефакты (вместо классов из target).
2. Если для сценариев нужна база, очередь сообщений или что-то разрабатываемое другой командой, рекомендую посмотреть на [TestContainers](https://www.testcontainers.org/).
3. Очередь сообщений можно так же эмулировать, найдя все бины с, например, [@KafkaListener](/users/KafkaListener) и дергая их через transparent rmi.
4. Для тестирования проблем с сетью можно использовать [Sniffy](https://www.sniffy.io/docs/latest/#_testing_bad_connectivity) или написать обертку для [netem](https://wiki.linuxfoundation.org/networking/netem).
Такой подход не заменит юнит-тесты хотя бы потому, что такие тесты занимают заметное время. С другой стороны, они могут обеспечить более стабильный мастер, отловив ошибки на ранних стадиях. А стабильный мастер - это спокойные нервы и крепкий сон по ночам. | https://habr.com/ru/post/682420/ | null | ru | null |
# Проверка ролей Ansible через делегированный драйвер Molecule
Molecule — отличный инструмент для тестирования ролей Ansible, он выполняет надежный и гибкий процесс проверки для обеспечения хорошего уровня качества ролей. Почти вся документация Molecule сосредоточена на драйвере докера, где тесты выполняются с контейнерным сервером, но, несмотря на то, что это хороший выбор в большинстве случаев использования, могут быть случаи, в которых полезно переключиться на внешний облачный бэкэнд с использованием [делегированного драйвера](https://molecule.readthedocs.io/en/latest/configuration.html#delegated).
К сожалению, документация по делегированному драйверу в основном состоит всего из нескольких строк в официальном документе, тогда как более четкое объяснение и несколько примеров могут оказать огромную помощь тем разработчикам, которые хотят использовать Molecule таким образом.
Этот пост основан на моем опыте разработки простой роли Ansible от 0 до galaxy и фокусирует внимание на использовании делегированного драйвера, интегрированного с Google Cloud Platform. В качестве отправной точки я взял следующие полезные ссылки для своего проекта:
* Официальный документ Molecule (<https://molecule.readthedocs.io/en/latest/>#)
* Хорошее введение в Molecule от Джеффа Герлинга (<https://www.jeffgeerling.com/blog/2018/testing-your-ansible-roles-molecule>)
* Редкий пример делегированного драйвера из проблемы, открытой для сообщества Molecule (<https://github.com/ansible-community/molecule/issues/1292>)
* Полное руководство по использованию ansible вместе с Google Cloud Platform от Гэри А. Стаффорда (<https://itnext.io/getting-started-with-red-hat-ansible-for-google-cloud-platform-fa666c42a00c>)
**Делегированный драйвер: что говорит документация Molecule?**
Одна из причин, которая заставила меня написать это руководство, — это заявление в официальной документации Molecule:
*Разработчик должен придерживаться instance-config API. Пособие по созданию разработчика должно содержать следующие данные instance-config, а руководство по уничтожению разработчика должно сбрасывать instance-config*.
Возникает вопрос: что такое instance-config и какие данные должен предоставить разработчик?
Instance-config — это факт Ansible, хранящийся в файле YAML в кэше Molecule ( `$HOME/.cache/molecule///instance\_config.yml`), который имеет следующую структуру:
```
- address: 10.10.15.17
identity_file: /home/fabio/.ssh/id_rsa # mutually exclusive with
# password
instance: millennium_falcon
port: 22
user: hansolo
# password: ssh_password # mutually exclusive with identity_file
become_method: sudo # optional
# become_pass: password_if_required # optional
```
Для тех, кому нужно иметь дело с узлами Windows, документация также предоставляет эквивалентную структуру для WinRM.
**Файл create.yml**
После того, как мы прояснили, что такое instance-config, мы можем переходить к следующему шагу. К счастью, Molecule также помогает нам сделать дополнительный шаг вперед, предоставляя файлы шаблонов сценариев с помощью команды `molecule init`, например:
```
molecule init scenario -driver-name=delegated
```
который создает следующую структуру каталогов:
```
.
├── INSTALL.rst
├── converge.yml
├── create.yml
├── destroy.yml
├── molecule.yml
└── verify.yml
```
* `molecule.yml` — это файл конфигурации Molecule, который определяет переменные, устанавливает фазовую последовательность и конфигурацию для каждой из них.
* `create.yml` — код Ansible для создания экземпляров на облачной платформе и хранения данных в instance-config.
* `destroy.yml` код Ansible для уничтожения экземпляров на облачной платформе и удаления их из instance-config
* `converge.yml` исполнение роли
* `verify.yml` набор проверочных тестов
* `INSTALL.rst` инструкции по установке необходимых зависимостей для запуска тестов Molecule
Теперь давайте сосредоточимся на файле `create.yml`, созданном Molecule:
```
---
- name: Create
hosts: localhost
connection: local
gather_facts: false
no_log: "{{ molecule_no_log }}"
tasks:
# Developer must implement.
# Developer must map instance config.
# Mandatory configuration for Molecule to function.
— name: Populate instance config dict
set_fact:
instance_conf_dict: {
'instance': "{{ }}",
'address': "{{ }}",
'user': "{{ }}",
'port': "{{ }}",
'identity_file': "{{ }}", }
with_items: "{{ server.results }}"
register: instance_config_dict
when: server.changed | bool
— name: Convert instance config dict to a list
set_fact:
instance_conf: {{ instance_config_dict.results | map(attribute='ansible_facts.instance_conf_dict') | list }}"
when: server.changed | bool
— name: Dump instance config
copy:
content: "{{ instance_conf | to_json | from_json | molecule_to_yaml | molecule_header }}"
dest: "{{ molecule_instance_config }}"
when: server.changed | bool
```
Три задачи: заполнение, преобразование и дамп, создание в конце файла `instance-config.yml`. Прокомментированный раздел является заполнителем для кода Ansible, который должен создавать облачные ресурсы и возвращать массив серверов (содержащий детали экземпляра) в качестве зарегистрированной переменной или факта. Следующий фрагмент кода, взятый из этой [проблемы с github](https://github.com/ansible-community/molecule/issues/1292), предоставляет пример того, что указано выше для контекста VMWare:
```
…
7 - name: Create molecule instance(s)
8 vmware_guest:
9 hostname: "{{ molecule_yml.driver.hostname }}"
10 esxi_hostname: "{{ molecule_yml.driver.esxi_hostname }}"
11 username: "{{ molecule_yml.driver.username }}"
12 password: "{{ molecule_yml.driver.password }}"
13 datacenter: "{{ molecule_yml.driver.datacenter }}"
14 validate_certs: "{{ molecule_yml.driver.validate_certs }}"
15 resource_pool: "{{ molecule_yml.driver.resource_pool }}"
16 folder: "{{ molecule_yml.driver.folder }}"
17 name: "{{ item.name }}"
18 template: "{{ item.template }}"
19 hardware:
20 memory_mb: "{{ item.memory | default(omit) }}"
21 num_cpus: "{{ item.cpu | default(omit) }}"
22 wait_for_ip_address: "yes"
23 state: poweredon
24 register: server
25 with_items: "{{ molecule_yml.platforms }}"
26
27 - name: Populate instance config dict
28 set_fact:
29 instance_conf_dict: {
30 'instance': "{{ item.instance.hw_name }}",
31 'address': "{{ item.instance.ipv4 }}",
32 'user': "vagrant",
33 'port': "22",
34 'identity_file': 'identity_file': "{{
molecule_yml.driver.ssh_identity_file }}"
35 }
36 with_items: "{{ server.results }}"
37 register: instance_config_dict
38 when: server is changed
…
```
Код вызывает модуль `vmware_guest` (строки 7–23) для создания виртуальной машины на сервере VMWare. Это делается для каждого элемента массива платформ, определенного в файле `molecule.yml` (строка 25). Как видите, переменные, определенные в файле `molecule.yml`, доступны через факт `molecule_yml`.
Значения, возвращаемые каждым вызовом `vmware_guest`, регистрируются как элементы массива сервера (строка 24), который, в свою очередь, используется для заполнения конфигурации экземпляра (`instance-config`) (строки 27 и далее). Обратите внимание, что обновление факта конфигурации экземпляра пропускается, если переменная сервера не изменяется.
**Работа с Google Cloud Platform (GCP)**
Теперь, когда я разъяснил, что и как должен делать разработчик при работе с делегированным драйвером, я собираюсь поделиться работой, проделанной для моей [роли docker-secured Ansible](https://galaxy.ansible.com/fabiomarinetti/fmarinetti_docker_secured). Для этой роли я решил использовать GCP в качестве облачного сервера для делегированного драйвера. Ansible предоставляет семейство модулей GCP для работы с таким облачным провайдером, и я надеюсь, что вы легко сможете адаптировать мой код, если вам нужно сменить семейство модулей и облачного провайдера.
Для этого проекта я использовал следующие версии инструментов:
* python 2.7
* ansible 2.9.6
* molecule 3.0.2
* ansible-lint 4.2.0
* yamllint 1.20.0
* flake8 3.7.9 (mccabe: 0.6.1, pycodestyle: 2.5.0, pyflakes: 2.1.1) CPython 2.7.17 на Linux
где yamllint, ansible-lint и flake8 — инструменты для проверки кода, которые включены в фазы молекулы.
**Роль docker-secured**
Роль для тестирования устанавливает докер на узел, предоставляет API-интерфейсы докеров и защищает их с помощью ssl. Процедура, которой я следовал, описана в этих двух ссылках из документации Docker:
* <https://success.docker.com/article/how-do-i-enable-the-remote-api-for-dockerd>
* <https://docs.docker.com/engine/security/https/>
Репозиторий содержит готовые к использованию файлы сертификатов ssl для целей тестирования, но есть также возможность предоставить свои собственные, если они у вас есть.
Вы можете посмотреть мой проект, клонировав репозиторий GitHub:
```
git clone https://github.com/fabiomarinetti/fmarinetti.docker-secured.git
```
**Предварительные шаги для GCP**
Прежде всего, мне нужно было создать проект GCP, учетную запись службы и загрузить связанный ключ. Эти шаги выходят за рамки этого руководства, и вы можете обратиться к [официальному документу GCP](https://cloud.google.com/docs) для получения общей процедуры. В качестве хорошей ссылки я также нашел эту [ссылку](https://itnext.io/getting-started-with-red-hat-ansible-for-google-cloud-platform-fa666c42a00c) полезной для всего, что связано с совместной работой Ansible и GCP.
Для этой роли я создал проект `ansible-272015` и службу учетной записи `service`, ее ключ хранится в файле `secret.json`.
**Файл molecule.yml**
В этом разделе я покажу и прокомментирую соответствующий раздел моего файла `molecule.yml`.
Проект, тип аутентификации и секретный ключ вставляются в файл `molecule.yml` в разделе `driver`. Кроме того, я также добавил в тот же раздел все другие параметры, которые остаются постоянными на этапах создания и уничтожения, например, регион и зона GCP, пользователь ssh и файл идентификатора, а также параметры сети, поскольку предполагается, что виртуальные машины находятся в той же сети, в которой создан ad-hoc на время теста. Ко всем этим значениям можно получить доступ из сценария через `molecule_yml` (например, `molecule_yml.driver.region` для доступа к региону).
```
20 driver:
21 name: delegated
22 gcp_service_account_key: ${GOOGLE_APPLICATION_CREDENTIALS}
23 gcp_project_id: ansible-272015
24 region: us-east1
25 zone: us-east1-c
26 ssh_user: ${SSH_USER}
27 ssh_pub_key_file: "${SSH_ID_FILE}.pub"
28 ssh_key_file: "${SSH_ID_FILE}"
29 network_name: ansible-network
30 subnet_name: ansible-subnet
31 firewall_name: ansible-firewall
32 ip_cidr_range: 172.16.0.0/28
```
Раздел платформы в файле `molecule.yml` содержит массив, содержащий параметры (имя, изображение, тип, размер…) для экземпляров, которые я хочу проверить. Мое тестовое покрытие включает CentOS 7, Ubuntu Xenial 16.04 и Ubuntu Bionic 18.04. Эти машины сгруппированы по типу ОС (например, CentOS или Ubuntu), чтобы использовать группы инвентаря при выполнении Ansible.
```
41 platforms:
42 - name: "ds-centos7-${TRAVIS_BUILD_ID}"
43 image_family: projects/centos-cloud/global/images/family
/centos-7
44 machine_type: n1-standard-1
45 size_gb: 200
46 groups:
47 - centos
48 - name: "ds-ubuntu-bionic-${TRAVIS_BUILD_ID}"
49 image_family: projects/ubuntu-os-cloud/global/images/family
/ubuntu-1804-lts
50 machine_type: n1-standard-1
51 size_gb: 200
52 groups:
53 - ubuntu
54 - name: "ds-ubuntu-xenial-${TRAVIS_BUILD_ID}"
55 image_family: projects/ubuntu-os-cloud/global/images/family
/ubuntu-1604-lts
56 machine_type: n1-standard-1
57 size_gb: 200
58 groups:
59 - ubuntu
```
В других разделах файла `molecule.yml` определяется тестовая последовательность и конфигурации для каждой фазы, хотя они не заданы по умолчанию.
**Фаза создания и файл create.yml**
Как уже говорилось ранее, `create.yml` — это сценарий, который управляет этапом создания. Здесь я широко использовал модули семейства gcp для управления ресурсами облачного провайдера (GCP). Модули GCP нуждаются в каком-то фиксированном параметре, таком как идентификатор проекта, тип аутентификации и путь к секретному ключу, и, чтобы избежать повторения этих значений в коде при каждом вызове модуля, я установил их как `module_defaults` для всего семейства gcp.
```
7 module_defaults:
8 group/gcp:
9 project: "{{ molecule_yml.driver.gcp_project_id }}"
10 auth_kind: serviceaccount
11 service_account_file: "{{
molecule_yml.driver.gcp_service_account_key }}"
```
В отличие от того, что мы видели ранее в случае VMWare, создание экземпляра в GCP — это не просто вопрос использования одного модуля, а процесс, состоящий из нескольких шагов: создание загрузочного диска, назначение IP-адреса и создание самого экземпляра. Это означает, что для цикла по платформам мне нужно было поместить задачи создания в отдельный файл и включить его в цикл:
```
16 — name: create instances
17 include_tasks: tasks/create_instance.yml
18 loop: "{{ molecule_yml.platforms }}"
```
Файл `create_instance.yml` содержит задачи по резервированию IP-адреса, созданию загрузочного диска и созданию экземпляра. То, как я вызвал связанные модули, довольно стандартно и их можно менять, если вы хотите переключиться на другого облачного провайдера, поэтому я не буду их обсуждать дальше, а лишь хочу сказать несколько слов о том, как возвращать данные экземпляра для подачи задач заполнения instance-config.
```
7 - name: initialize instance facts
8 set_fact:
9 instance_created:
10 instances: []
11 when: instance_created is not defined
... create the instance and return instance variable ...
56 - name: update instance facts
57 set_fact:
58 instance_created:
59 changed: instance.changed | bool
60 instances: "{{ instance_created.instances + [ instance ]}}"
```
Затем после цикла платформы для заполнения isntance-config используется факт `instance_create`:
```
20 - name: Populate instance config dict
21 set_fact:
22 instance_conf_dict: {
23 'instance': "{{ item.name }}",
24 'address': "{{
item.networkInterfaces[0].accessConfigs[0].natIP }}",
25 'user': "{{ molecule_yml.driver.ssh_user }}",
26 'port': "22",
27 'identity_file': "{{ molecule_yml.driver.ssh_key_file
}}", }
28 with_items: "{{ instance_created.instances }}"
29 register: instance_config_dict
30 when: instance_created.changed
```
Здесь эта задача выполняется, только если один из экземпляров был изменен, как это произошло в случае VMWare, когда было указано предложение `servers is changed`
Наконец, я протестировал этап создания, введя команду:
```
molecule create --scenario-name=gcp
```
Убедившись, что результаты созданы правильно, я перешел к конвейеру и выполнил / протестировал фазы:
* **lint**, которая выполняет проверку кода
* **prepare**, которая подготавливает экземпляр для применения роли. В данном случае это просто обновление исходных кодов пакетов для группы ubuntu.
* **converge**, которая просто применяет роль
* **idempotence**, которая применяет роль во второй раз для обеспечения ее идемпотентности
* **verify**, которая подтверждает, что результаты применения роли соответствуют ожиданиям
```
molecule --scenario-name=gcp
```
В этом случае, учитывая простоту роли и ограниченные требования, мне не пришлось так сильно менять Молекулу, генерируемую при инициализации сценария.
На последнем шаге я написал `destroy.yml` для удаления созданных ресурсов из проекта (а также моего счета ). Код для уничтожения ресурсов следует той же философии, что и тот, который их создает. Очевидно, проверка проводилась путем выдачи:
```
molecule destroy --scenario-name=gcp
```
Как только все этапы были правильными и не выдали ошибок, я мог протестировать весь процесс с помощью команды:
```
molecule test --scenario-test=gcp
```
**Выводы**
В этом посте я объяснил, как использовать делегированный драйвер Molecule, и показал, как я реализовал его с помощью GCP. Этот же код легко адаптировать к другому облачному провайдеру: AWS, Azure, Digital Ocean… и я надеюсь, что вы наверняка получите выгоду от использования Molecule. Пожалуйста, оставьте отзыв. | https://habr.com/ru/post/536892/ | null | ru | null |
# Быстрая математика с фиксированной точкой для финансовых приложений на Java
Не секрет, что финансовая информация (счета, проводки и прочая бухгалтерия) не очень дружит с числами с плавающей точкой, и множество статей рекомендует использовать фиксированную точку (fixed point arithmetic). В Java этот формат представлен, по сути, только классом BigDecimal, который не всегда можно использовать по соображениям производительности. Приходится искать альтернативы. Эта статья описывает самописную Java библиотеку для выполнения арифметических операций над числами с фиксированной точностью. Библиотека была создана для работы в высокопроизводительных финансовых приложениях и позволяет работать с точностью до 9 знаков после запятой при сохранении приемлемой производительности. Ссылка на исходники и бенчмарки приведены в конце статьи.
Арифметика с плавающей точкой
=============================
Cовременные компьютеры могут выполнять арифметические операции только с ограниченной точностью. Это дискретные устройства, которые могут работать не со всеми возможными числами, а только с некоторым их счетным подмножеством. Самым распространённым форматом работы с вещественными числами в памяти компьютера является плавающая (двоичная) точка — floating (binary) point, когда числа хранятся в виде M\*2^E, где M и E — целые мантисса и порядок числа. Но некоторые числа, например 0.1, невозможно точно представить в этом формате. Поэтому в ходе сложных вычислений неизбежно накапливается некоторая ошибка. То есть результат машинного вычисления, скажем 0.1 + 0.1 + 0.1, не совпадает с математически правильным 0.3. Учитывая вышесказанное, при программировании сложной арифметики можно придерживаться нескольких стратегий:
Стратегия 1 — игнорировать. Не обращать внимания на погрешность, считать все операции идеально-математическими и надеятся, что имеющейся точности хватит для приемлемых результатов. Самый распространённый вариант.
Стратегия 2 — скрупулёзно подсчитать. Формулы для подсчета машинных погрешностей известны не одно десятилетие. Они позволяют оценить сверху относительную погрешность любой арифметической операции. Наверное, так и приходится делать для серьёзного численного моделирования. Проблема в том, что это очень трудоемко. По сути, каждый символ + — \* / в коде должен сопровождаться вычислением погрешности. Нужно учесть все зависимости между вычислениями и повторять процедуру каждый раз при изменении кода.
Стратегия 3 — использовать десятичную точку (floating decimal point) вместо двоичной. То есть хранить числа в виде M\*10^E. Это не решает проблем с погрешностью (мантисса по-прежнему округляется до конечного числа значащих цифр), но по крайней мере все «простые» для человека числа (вроде 1.1) теперь представлены в памяти точно. Расплатой будет производительность. Любая нормализация чисел (то есть эквивалентное уменьшение мантиссы и увеличение порядка) требует деления на степень 10, что очень не быстро, в отличие от деления на степень 2. А нормализовывать приходится много — при каждом сложении или вычитании с разными порядками.
Стратегия 4 — использовать фиксированную точку (fixed decimal point). Упрощение стратегии 3, когда мы фиксируем порядок E. В этом случае для сложения/вычитания не нужна нормализация. Кроме того, все вычисления будут иметь одинаковую абсолютную погрешность. Именно этой стратегии посвящена статья.
Арифметика с фиксированной точкой
=================================
В отличие от физики, где важна относительная погрешность, в финансах нужна как раз абсолютная. Если после проведения сложной финансовой транзакции клиенту выставить счёт в $1000000.23 в то время как он ожидает $1000000.18, то могут возникнуть некоторые трудности. Объяснения типа «да зачем вам точность в 8 значащих цифр??» могут не прокатить. И дело тут не в 5 центах убытка (ошибиться наоборот, «в пользу» клиента, не сильно лучше), а в нестыковках бухгалтерского учёта. Поэтому правила вычислений и округлений четко оговариваются между сторонами, и артефакты от использования double и float переменных порой усложняют жизнь.
В Java есть стандартный класс для fixed point арифметики — BigDecimal. Проблемы с ним две: он медленный (из-за своей универсальности) и он немутабельный. Немутабельность означает что любая операция выделяет объект в куче. Выделение и освобождение в пересчете на объект занимает немного времени, но интенсивные вычисления в «горячем» коде создают приличную нагрузку на GC, неприемлемую в некоторых случаях. Можно понадеяться на escape-analysis и скаляризацию, но они очень нестабильны в том смысле, что даже незначительное изменение в коде или в JIT (типа ленивой загрузки новой реализации интерфейса) может перевернуть вверх ногами всю структуру инлайна, и метод, минуту назад нормально работавший, вдруг начнёт бешено выделять память.
UPD из-за вопросов в комментариях: **Основная причина** отказа от BigDecimal и BigInteger — вовсе не низкая производительность вычислений, а немутабельность и выделение объектов.
Описываемая библиотека — результат того, что мне надоело переписывать не выделяющую память fixed point арифметику с нуля для каждого нового работодателя, и я решил написать свою собственную библиотеку для последующего инсорсинга.
Сразу покажу пример использования, прежде чем переходить к деталям реализации:
```
public class Sample {
private final Decimal margin;
private final Quantity cumQuantity = new Quantity();
private final Quantity contraQuantity = new Quantity();
private final Quantity cumContraQuantity = new Quantity();
private final Price priceWithMargin = new Price();
private final Price avgPrice = new Price();
public Sample(int marginBp) {
// 1 + margin / 10000
this.margin = Decimal.create(marginBp).divRD(10000L).add(1);
}
public Price calculateAvgPrice(Quantity[] quantities, Price[] prices) {
cumQuantity.set(0);
contraQuantity.set(0);
// avg = sum(q * p * margin) / sum(q)
for (int i = 0; i < quantities.length; i++) {
cumQuantity.add(quantities[i]);
priceWithMargin.set(prices[i]).mulRD(margin);
contraQuantity.set(quantities[i]).mulRD(priceWithMargin);
cumContraQuantity.add(contraQuantity);
}
return avgPrice.quotientRD(cumContraQuantity, cumQuantity);
}
public static void main(String[] args) throws ParseException {
Price p1 = Price.create("1.5");
Price p2 = Price.create(1.6);
Quantity q1 = Quantity.create("100");
Quantity q2 = Quantity.create(200);
// apply 0.05% margin to the prices
Sample sample = new Sample(5);
System.out.println(sample.calculateAvgPrice(new Quantity[]{q1, q2}, new Price[]{p1, p2}));
}
}
```
Идея реализации
===============
Итак, нам нужна мутабельная обертка целочисленного примитива, если точнее — long’а, который даст нам почти 19 значащих цифр (хватит и на целую и на дробную часть). В long'е мы подразумеваем N десятичных знаков после запятой. Например, при N=2, число 2.56 хранится как 256 (двоичное 100000000). Отрицательные числа хранятся стандартно, в дополнительном коде:
*-2.56*
**-256**
(Здесь и далее *курсивом* обозначены «математические» числа и вычисления, а **жирным** – их внутреннее представление)
Также мне показалось полезным ввести NaN отдельным значением, которое возвращается в случае арифметических ошибок (вместо исключения или мусора). *NaN* представлен внутри как **Long.MIN\_VALUE**, «распространяется» (propagated) через все операции и позволяет определить инвертирование знака для всех оставшихся чисел.
Попробуем прикинуть алгоритмы арифметических операций для случая, когда N=2.
Сложение и вычитание не требуют никаких лишних телодвижений, просто используем значения как есть:
*1.20 + 2.30 = 3.50*
**120 + 230 = 350**
Умножение и деление требуют дополнительной нормализации, то есть умножения/деления на 10^N (на 100 в нашем примере)
*1.20 \* 2.00 = 2.40*
**120 \* 200 / 100 = 240**
*1.20 / 2.00 = 0.60*
**100 \* 120 / 200 = 60**
Дополнительное деление — не самая быстрая операция. Но в данном случае это деление на константу, ведь мы заранее зафиксировали N=2 и 10^N=100. Деление на константу, особенно на «красивую» (типа 10), интенсивно оптимизируется в CPU и сильно быстрее деления на случайное число. Мы делаем кучу делений на 10 каждый раз, когда преобразовываем любое число в строку (например в логах), и производители CPU об этом знают ([подробнее про оптимизации](https://en.wikipedia.org/wiki/Division_algorithm) см "Division by a constant").
Для закрепления понимания того, что мы делаем, приведу ещё одну операцию: унарное обращение числа, то есть 1/х. Это частный случай деления, нужно просто представить 1.00 в нашем формате и не забыть нормализовать:
*1.00 / 2.00 = 0.50*
**100 \* 100 / 200 = 50**
Ну что ж, пока все довольно просто, попробуем углубиться в детали.
Округление
==========
Попробуем обратить другое число:
*1.00 / 3.00 = 0.33*
**100 \* 100 / 300 = 33**
Честный математический результат лежит между 0.33 и 0.34, но мы не можем его точно представить. В какую сторону округлять? Обычно округляют к 0, и это самый быстрый способ (поддерживается аппаратно). Но, возвращаясь к реальным финансовым задачам, это не всегда так. Обычно при обработке транзакций с клиентом округление идёт «в пользу клиента». То есть цена округляется вверх, если клиент продаёт, и вниз, если клиент покупает. Но могут потребоваться и другие варианты, например арифметическое округление к ближайшему числу с подтипами (half-up, half-down, half-even) для минимизации бухгалтерских нестыковок. Или округление к ±бесконечности для отрицательных цен (у некоторых финансовых инструментов). Java BigDecimal уже содержит список стандартных режимов округления, и описываемая библиотека их все поддерживает. Режим UNNECESSARY возвращает NaN, если операция неожиданно потребует округления.
В режиме округления вверх наше вычисление должно давать:
*1.00 / 3.00 = 0.34*
**100 \* 100 / 300 + 1 = 34**
Как узнать, что нужно добавить единицу? Нужен остаток от деления 10000 % 300 = 100. Который такой же медленный, как и само деление. К счастью, если написать подряд в коде "a/b; a%b", то JIT сообразит что 2 деления не нужно, достаточно одной ассебмлерной команды div возвращающей 2 числа (частное и остаток).
Другие варианты округления чуть сложнее, но тоже могут быть вычислены на основе остатка и делителя.
В API я намеренно сделал упоминание округления везде, где оно происходит, либо в виде параметра, либо в виде суффикса **R**ound**D**own в методах, где оно по умолчанию происходит к нулю.
Переполнение
============
Мы подходим к самой сложной части. Вспомним ещё раз наше умножение:
*1.20 \* 2.00 = 2.40*
**120 \* 200 / 100 = 240**
Теперь представим, что мы в 1980-х и процессоры у нас 16-битные. То есть нам доступен только short с максимальным значением 65535. Первое умножение переполнится и будет равно 240000 & 0xFFFF = 44392 (это если без знака, со знаком оно будет ещё и отрицательным), что поломает нам результат.
Так не пойдёт. У нас 2 нормальных (влезающих в наш диапазон значений) аргумента, и такой же нормальный ожидаемый результат, но мы переполняемся на полдороге. Точно такая же ситуация возможна и с 64-битным long’ом, просто числа нужны побольше.
В 1980-х нам потребовалось бы умножение, дающее 32-битный результат. Сегодня нам требуется умножение с 128-битным результатом. Самое обидное то, что оба умножения доступны в ассемблерах 8086 и x86-64 соответственно, но мы не можем использовать их из Java! JNI, даже в случае хака с быстрым JavaCritical, даёт оверхед в десятки наносекунд, привносит сложности с деплоем и совместимостью, замораживает GC на время вызова. К тому же нам каким-то образом пришлось бы возвращать 128-битный результат из native метода, а запись по ссылке в массив (в память) — это дополнительная задержка.
В общем пришлось мне писать ручное умножение и деление. Столбиком. Мне требовались 2 вспомогательные операции:
1. A(64) \* B(64) = T(128); T(128) / N(32)= Q(64),R(32) — как часть fixed point умножения A\*B
2. N(32) \* A(64) = T(96); T(96) / B(64) = Q(64),R(64) — как часть fixed point деления A/B
(в скобках указана размерность данных в битах, T — временная переменная, которая не должна переполняться)
Обе операции возвращают частное и остаток (одно – как результат метода, второе — в поле объекта). Они тоже могут переполняться, но только на последнем шаге, когда это неизбежно. Вот пример (из 1980-х):
*500.00 / 0.50 = 1000.00*
**100 \* 50000 / 50 = 100000** — переполнение!
Деление столбиком а-ля Кнут — не самый простой алгоритм. Плюс это все должно быть ещё и относительно быстрым. Поэтому код обоих операций — сотни строк достаточно суровой битовой магии, у меня самого уйдет много времени, чтобы снова вспомнить что конкретно там происходит. Я вытащил их в отдельный класс и откомментировал подробно как мог.
Алгоритм умножения не исчерпывается вызовом операции 1, но оставшийся код не так сложен и просто добавляет поддержку отрицательных чисел, округления и NaN.
Обычно (за исключением особых случаев), обе операции содержат 4 умножения и 2 деления. Операция 1 существенно быстрее 2, так как в ней эти деления — на константу.
Кстати, если кто заметил, N(32) — это наша 10^N для нормализации. Она 32-битная, из чего следует, что N может быть максимум 9. В реальных виденных мной приложениях использовалось 2, 4 или 8 знаков после запятой. Больше 9 я не встречал, так что должно хватить. Если делать 10^N 64-битным, код усложняется (и замедляется) ещё сильнее.
Несколько разных точностей
==========================
Иногда необходимо выполнить операцию над аргументами с разным количеством знаков после запятой. Как минимум – ввести операции с участием обычного long.
К примеру:
*2.0000(N=4) + 3.00(N=2) = 5.0000(N=4)*
**20000 + 300 \* 100 = 50000**
*3.00 (N=2) + 2.0000(N=4) = 5.00(N=2)*
**300 + 20000 / 100 = 500**
В этом случае требуется дополнительная нормализация одного из аргументов. Обратите внимание, что математически обе операции эквивалентны, но из-за другой точности результата они вычисляются по разному. Также стоит отметить, что вторая операция в общем случае требует округления.
Количество знаков после запятой НЕ хранится в объекте. Вместо этого, предполагается наличие отдельного подкласса для каждой точности. Имена классов могут быть бизнес-ориентированными, например Price (N=8), Quantity (N=2). А могут быть обобщенными: Decimal1, Decimal2, Decimal3,… Чем больше точность, тем меньше диапазон хранимых значений, минимальный диапазон имеет Decimal9: ±9223372036. Предполагается, что одного-двух классов будет достаточно, чтобы покрыть необходимую функциональность, и в этом случае абстрактный метод getScale скорее всего будет девиртуализирован и заинлайнен. Подклассы (вместо дополнительного поля) позволяют строго типизировать точность аргументов и результата, а также сигнализировать о возможном округлении на этапе компиляции.
Библиотека позволяет производить операции в которых участвуют максимум 2 (но не 3) разных точности. То есть должны совпадать либо точности двух аргументов, либо точность одного из аргументов и результата. Опять-таки, поддержка 3-х разных точностей сильно замедлила бы код и усложнила бы API. В качестве аргументов можно передавать обычный long, для которого предполагается точность N=0.
*2.0000 / 3.0 = 0.6667* — ok (2 разных точности)
*2 / 3= 0.6667* — ok (long аргументы, decimal результат)
*2 / 3.0 = 0.6667* — невозможно! (3 разных точности)
Достоинства и недостатки
========================
Очевидно, вычисления повышенной разрядности, проводимые библиотекой, медленнее аппаратно поддерживаемых. Тем не менее, оверхед не настолько велик (см бенчмарки ниже).
Кроме того, из-за отсутствия перегрузки операторов в Java, использование методов вместо арифметических операторов усложняет восприятие кода.
Исходя из этого, библиотека обычно используется в местах, где потеря абсолютной точности критична. Например, вычисление точной финансовой статистики, учёт текущих финансовых показателей (торговых позиций, PnL, исполняющихся приказов). При сетевом обмене финансовой информацией между системами, также удобнее использовать форматы с десятичной точкой (вместо двоичной).
Сложные математические алгоритмы (моделирование, статистика, прогнозирование) обычно проще проводить стандартно в double, так как их результат в любом случае не абсолютно точен.
Код и бенчмарки
===============
[Код](https://github.com/maxtomin/decimal)
| Benchmark | Mode | Cnt | Score | Error | Units |
| --- | --- | --- | --- | --- | --- |
| DecimalBenchmark.control | avgt | 200 | 10.072 | ± 0.074 | ns/op |
| DecimalBenchmark.multiplyNative | avgt | 200 | 10.625 | ± 0.142 | ns/op |
| DecimalBenchmark.multiplyMyDecimal | avgt | 200 | 35.840 | ± 0.121 | ns/op |
| DecimalBenchmark.multiplyBigDecimal | avgt | 200 | 126.098 | ± 0.408 | ns/op |
| DecimalBenchmark.quotientNative | avgt | 200 | 70.728 | ± 0.230 | ns/op |
| DecimalBenchmark.quotientMyDecimal | avgt | 200 | 138.581 | ± 7.102 | ns/op |
| DecimalBenchmark.quotientBigDecimal | avgt | 200 | 179.650 | ± 0.849 | ns/op |
В целом, умножение получается в 4 раза быстрее BigDecimal, деление — в 1.5. Скорость деления *сильно* зависит от аргументов, отсюда такой разброс значений. | https://habr.com/ru/post/425565/ | null | ru | null |
# Как оптимизировать pandas при работе с большими datasetами (очерк)
Когда памяти вагоны и/или dataset небольшой можно смело закидывать его в pandas безо всяких оптимизаций. Однако, если данные большие, остро встает вопрос, как их обрабатывать или хотя бы считать.
Предлагается взглянуть на оптимизацию в миниатюре, дабы не вытаскивать из сети гигантские датасеты.
В качестве датасета будем использовать хабрастатистику с комментариями пользователей за 2019 г., которая является общедоступной благодаря одному трудолюбивому пользователю:
[dataset](http://www.dropbox.com/s/o84naeggpzak4b7/habr_2019_comments.txt?dl=0)
В качестве инфо-основы будет использоваться ранее переведенная [статья](https://habr.com/ru/company/ruvds/blog/442516/) с Хабра, в которой намешано много интересного.
### Вместо вступления
Датасет хабрастатистики считается небольшим, хотя и занимает 288 Мб и состоит из 448533 строк.
Разумеется, можно найти и побольше данных, но, чтобы не вешать машину, остановимся на нем.
Для удобства операций внесем (просто запишем в файл первую строку) названия столбцов:
```
a,b,c,d
```
Теперь, если напрямую загрузить dataset в pandas и проверить, сколько он использует памяти
```
import os
import time
import pandas as pd
import numpy as np
gl = pd.read_csv('habr_2019_comments.csv',encoding='UTF')
def mem_usage(pandas_obj):
if isinstance(pandas_obj,pd.DataFrame):
usage_b = pandas_obj.memory_usage(deep=True).sum()
else: # исходим из предположения о том, что если это не DataFrame, то это Series
usage_b = pandas_obj.memory_usage(deep=True)
usage_mb = usage_b / 1024 ** 2 # преобразуем байты в мегабайты
return "{:03.2f} MB".format(usage_mb)
print (gl.info(memory_usage='deep'))
```
увидим, что он «кушает» 436.1 MB:
```
RangeIndex: 448533 entries, 0 to 448532
Data columns (total 4 columns):
a 448533 non-null object
b 448533 non-null object
c 448533 non-null object
d 448528 non-null object
dtypes: object(4)
memory usage: 436.1 MB
```
Здесь также видно, что мы имеем дело со столбцами, в которых содержатся данные типа object.
Следовательно, согласно [статье](https://habr.com/ru/company/ruvds/blog/442516/), для столбцов, необходимо ориентироваться на оптимизацию, рассчитанную для object. Для всех столбцов, кроме одного.
В столбце b содержатся даты, и, для удобства дальнейших вычислений и наглядности лучше отправить их в index датасета. Для этого изменим код, используемый при считывании датасета:
```
gl = pd.read_csv('habr_2019_comments.csv', parse_dates=['b'], encoding='UTF')
```
Теперь даты считываются как index датасета и потребление памяти немного снизилось:
```
memory usage: 407.0 MB
```
### Теперь оптимизируем данные в самом датасете вне столбцов и индекса
Оптимизация называется: «Оптимизация хранения данных объектных типов с использованием категориальных переменных».
Если перевести на русский язык, то нам необходимо объединить данные в столбцах по категориям, где это эффективно.
Чтобы определить эффективность, необходимо узнать количество уникальных значений в столбцах и если оно будет меньше 50% от общего числа значений в столбце, то объединение значений в категории будет эффективно.
Посмотрим на датасет:
```
gl_obj=gl.select_dtypes(include=['object']).copy()
gl_obj.describe()
```
:
```
a c d
count 448533 448533 448528
unique 25100 185 447059
top VolCh 0 Спасибо!
freq 3377 260438 184
```
\*столбец с датами в индексе и не отображен
Как видно, из строки unique, в столбцах **a** и **с** эффективно объединение в категории. Для столбца а — это 25100 пользователей (явно меньше 448533), для с — 185 значений шкалы с "+" и "-" (тоже значительно меньше 448533).
Оптимизируем столбцы:
```
for col in gl_obj.columns:
num_unique_values = len(gl_obj[col].unique())
num_total_values = len(gl_obj[col])
if num_unique_values / num_total_values < 0.5:
converted_obj.loc[:,col] = gl_obj[col].astype('category')
else:
converted_obj.loc[:,col] = gl_obj[col]
```
Чтобы понять сколько памяти используется для удобства введем функцию:
```
def mem_usage(pandas_obj):
if isinstance(pandas_obj,pd.DataFrame):
usage_b = pandas_obj.memory_usage(deep=True).sum()
else: # исходим из предположения о том, что если это не DataFrame, то это Series
usage_b = pandas_obj.memory_usage(deep=True)
usage_mb = usage_b / 1024 ** 2 # преобразуем байты в мегабайты
return "{:03.2f} MB".format(usage_mb)
```
И проверим, была ли оптимизация эффективна:
```
>>> print('До оптимизации столбцов: '+mem_usage(gl_obj))
До оптимизации столбцов: 407.14 MB
>>> print('После оптимизации столбцов: '+mem_usage(converted_obj))
После оптимизации столбцов: 356.40 MB
>>>
```
Как видно, был получен выигрыш еще 50 МВ.
Теперь, поняв, что оптимизация пошла на пользу (бывает и наоборот), зададим параметры датасета при считывании, чтобы сразу учитывать данные, с которыми имеем дело:
```
gl = pd.read_csv('habr_2019_comments.csv', parse_dates=['b'],index_col='b',dtype ={'c':'category','a':'category','d':'object'}, encoding='UTF')
```
Желаем быстрой работы с датасетами!
Код для скачивания — [здесь](https://yadi.sk/d/ed3X-hgZKK9RkQ). | https://habr.com/ru/post/467785/ | null | ru | null |
# Сквозная Аналитика на Azure SQL + dbt + Github Actions + Metabase
Привет, Хабр! Меня зовут Артемий Козырь.
За последние годы у меня накопился довольно обширный опыт работы с данными и тем, что сейчас называют *Big Data*.
Не так давно также разгорелся интерес к сфере интернет-маркетинга и *Сквозной Аналитики*, и не на пустом месте. Мой друг из действующего агентства снабдил меня данными и кейсами реальных клиентов, и тут ~~засквозило~~ понеслось.
Получается довольно интересно: *Azure SQL + dbt + Github Actions + Metabase.*
Половина успеха в правильном понимании задачи
---------------------------------------------
Итак, постараемся без дифирамб и сразу к делу. Портрет Клиента (это тот, для кого мы делаем сервис): владелец интернет-магазина / розничной сети / мобильного приложения / образовательной платформы. Он преследует следующие цели:
* Позиционирование и продвижение своего продукта; рост бизнеса
* Оптимизация каналов продвижения: фокус на направлениях, которые дают лучший результат
* Контроль расходов и показателей возврата на каждый вложенный рубль
* Сегментация пользователей и выстраивание коммуникации с ними
В среднем он пользуется 4-мя группами сервисов:
* CRM (*AmoCRM*, *Bitrix24*) — лиды, воронки и продажи; жизненный цикл и фактические атрибуты сделок
* Счетчики посещаемости (*Yandex.Metrika*, *Google Analytics*) — просмотры, клики, интерес, вовлеченность аудитории
* Рекламные кабинеты (*Facebook*, *Google Adwords*, *Yandex.Direct*) — платный трафик, медиа-продвижение, контекстная реклама, промоушены и партнерки
* Call-tracking/Event tracking — сбор поведенческих факторов, оффлайн-событий
На помощь Клиенту приходит Агентство, которое оказывает комплексные услуги: разработка стратегии, создание креативов, настройка счетчиков и CRM, закупка рекламы. С Клиентом согласовывается объем работ и целевые показатели. Выглядеть это может примерно так:
[](https://habrastorage.org/webt/v3/g3/qw/v3g3qw8dyuggumzubta95ld9fo4.png)
*Согласованная форма отчетности Агентства перед Клиентом*
Самой интересной и сложной частью, на мой взгляд, является формирование сводной отчетности по результатам деятельности. С инженерной точки зрения задача сводится к следующему:
* Выгрузить данные из источников
* Собрать в одной базе данных (интеграция)
* Построить логическую модель *Хранилища Данных* и *Витрины* (вся соль здесь!)
* Визуализировать метрики на *дашбордах* (это тоже нетривиально)
* Обеспечить сопровождаемость и поддержку инфраструктуры (может быть очень нудно)
Пылесосинг данных сервисов (Интеграция)
---------------------------------------
Даже ниндзя-одиночке сложно собрать и поддерживать набор коннекторов в актуальном и работоспособном состоянии. Ранее я выступал с небольшим докладом на эту тему: *[Сквозная аналитика: коробочные решения или самостоятельная сборка?](https://youtu.be/KO3Zc-kJn8Q?t=193)* (с 3:13).
Для своего решения я выбрал сервис *[myBI Connect](https://bit.ly/2MppmJz)*. Алексей и его команда делают по-настоящему качественный сервис, который в состоянии удовлетворить даже самые изощренные требования инженеров и бизнес-пользователей. Давайте взглянем, что доступно из коробки:
1. Базовые выгрузки и модель детального слоя
Заботливо подготовлены и задокументированы модели детального слоя (те самые звездочки и снежинки), суррогатные ключи, метаданные обновлений и *ETL*-джобов.
Например, для Facebook доступны уровни детализации Кампаний (*Campaigns*), Групп Объявлений (*Adsets*) и Объявлений (*Ads*), включая невероятный набор метрик, таких как среднее количество просмотров на человека, охват, реакции на публикации, репосты и т.д.
[](https://habrastorage.org/webt/yo/vq/qn/yovqqno6uy2eywu8nnzmoxnrsia.png)
*[Схема детального слоя Facebook myBI Connect](https://support.mybi.ru/hc/ru/articles/360001972178)*
2. Кастомизированные отчеты/выгрузки/представления
Все работали с Яндекс.Метрикой? По сути это конструктор отчетов с ныне очень известным Яндекс.Clickhouse под капотом. Чтобы собрать отчет, необходимо выбрать ряд Измерений, Метрик, Фильтров (образующих Сегменты).
**Запрос по API к Яндекс.Метрика может выглядеть так**
```
https://api-metrika.yandex.net/stat/v1/data.csv
?ids=55254416
&dimensions=ym:s:date, ym:s:UTMSource, ym:s:UTMMedium, ym:s:UTMCampaign
&metrics=ym:s:visits, ym:s:ecommercePurchases, ym:s:ecommerceRevenue
&date1=2020-12-01
&date2=2020-12-31
&group=day
⟨=en
&accuracy=full
&sort=ym:s:date
&limit=100000
&pretty=true
```
А теперь вспомните о трансформации полученного в ответ *JSON*-документа, регулярность выгрузок (установка на расписание или *cron*), обработку статусов запросов (*requests*), удаление дубликатов и т.д. Не хотелось бы отягощать свое решение поддержкой всего этого.
С использованием myBI Connect я один раз декларативно задаю структуру результирующего набора данных и регулярно получаю свежую выгрузку в реляционную СУБД без всякой головной боли.
[](https://habrastorage.org/webt/lw/fe/vu/lwfevuykabaccf_rk1pxzjhewds.png)
*Пользовательская выгрузка из Яндекс.Метрика*
3. Webhook для данных, к которым пока нет коннектора
* Самописная CRM? Экзотический формат выгрузки?
* Нет проблем! Webhook в помощь.
И такие данные тоже можно довольно легко собирать. Так может выглядеть скрипт получения конверсий из inhouse-CRM, отдающей данные в формате XML:
```
# get data from XML endpoint with curl utility
curl "https://www.internal-crm.ru/order-list.xml?date-from=01-12-2020&date-to=31-12-2020" -o export.xml
# convert XML to JSON with xq utility
xq . export.xml > export.json
# parse JSON doc with jq utility
jq '[."order-list".date[] | .order[]]' export.json > parsed.json
# post to myBI Connect Webhook endpoint with curl utility
curl --header "Content-Type: application/json" \
--request POST \
--data @parsed.json \
https://app.mybi.ru/webhook/23576/xhsfcxmlyh/
```
В примере получаем выгрузку данных в формате XML, преобразуем в JSON, парсим данные, отсылаем структурированный набор в myBI Connect через Webhook. Один несложный *shell*-скрипт, и данные почти мгновенно оказываются в таблице с конверсиями в Хранилище.
4. Приятные дополнительные возможности
* [Конфигурирование периодичности и глубины выгрузок](https://support.mybi.ru/hc/ru/articles/360002066278-%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8-%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85). Хотел бы задать период с горизонтом 3 дня назад (late arriving data)? Супер, готово.
* [Проверка загруженных данных с помощью “коэффициента отклонения”](https://support.mybi.ru/hc/ru/articles/360001686998-%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0-%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B6%D0%B5%D0%BD%D0%BD%D1%8B%D1%85-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85).
* [Взаимодействие с сервисом через API](https://support.mybi.ru/hc/ru/articles/360001773218-%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5-API).
В итоге я имею исходные наборы данных в понятном и ожидаемом формате, с регулярным обновлением. И это основа решения.
Организация Хранилища Данных
----------------------------
В значительной мере работа над Хранилищем Данных заключается в Моделировании данных (*Data Modeling*), или построении логической модели. Формально это означает преобразование, обогащение, сведение разрозненных наборов данных с целью получить интересующий набор показателей (метрик) с соблюдением бизнес-правил и логики расчетов.
[](https://habrastorage.org/webt/va/ua/nt/vauantb7ggthywqd7h9xkbdtrz0.png)
*Основные блоки DWH: источники, детальный слой, витрины данных*
Концептуально DWH можно разделить на ряд областей:
* (*1*) Источники данных — исходные наборы из рекламных кабинетов, счетчиков посещаемости, CRM
* (*2*) Детальные данные — очищенные и унифицированные таблицы атомарной детализации (например, клик); имеют общую структуру для каждого Клиента
* (*3*) Витрины данных — ключевые бизнес-метрики, которые мы отслеживаем; индивидуальная структура для каждого Клиента
Для формирования логической модели я воспользовался *dbt*. В моем случае Хранилище Данных представляет из себя git-репозиторий, состоящий из набора файлов *.sql* (код витрин) и *.yaml* (конфигурация). На Хабре есть хороший обзор *dbt* на русском языке: *[Data Build Tool или что общего между Хранилищем Данных и Смузи](https://habr.com/ru/company/otus/blog/501380/)*.
В роли движка-СУБД может выступать любая из популярных сегодня аналитических баз данных: BigQuery, Redshift, Snowflake, Postgres, Spark, Presto. В моем случае это Azure SQL Database (managed SQL Server). По сути для меня не имеет значения, на какой инфраструктуре строить Хранилище; важна смысловая составляющая проекта, бизнес-логика, алгоритмы (читай код).
[](https://habrastorage.org/webt/yp/vo/uz/ypvouzul-xochozprfrkqsvsyic.png)
*Структура проекта: git-репо с кодом (.sql) и конфигурацией (.yaml)*
Для последовательности и структурированности я делю *DWH* на ряд слоев:
[](https://habrastorage.org/webt/8i/ri/0j/8iri0j1_t-bwewedwivizo0wwto.png)
*Цепочка зависимостей моделей: Источники -> Стейдж -> Вспомогательные -> Витрины*
1. Источники (*Sources*)
По сути это ссылки-указатели на таблицы, которые регулярно обновляются сервисом myBI Connect. Для моего решения это исходные данные.
2. Стейдж (*Staging*)
Чаще всего модели стейджинга это виртуальные таблицы (представления или *views*), однако иногда я материализую их в виде физических таблиц для ускорения доступа. На этом этапе я:
* Выполняю очистку полей, парсинг *UTM-меток* и значений
* Привожу типы данных и форматы: текст в числа, таймстемпы и т.д.
* Унифицирую наименования полей (при необходимости)
3. Вспомогательный (*Auxiliary*)
Модели слоя Aux предназначены для формирования срезов по отдельным предметным областям. Здесь появляются первые денормализованные (широкие) аналитические таблицы:
* Объединение фактов и измерений — клики, конверсии, продажи обретают контекст (алгоритмически это джоин таблиц)
* Формирование суррогатных ключей для соединения таблиц
* Применение коэффициентов: НДС, комиссии агентства и т.д.
4. Витрины (*Marts*)
Витрины данных — это то, на что смотрит конечный пользователь. Это семантический слой доступа, прослойка между бизнес-атрибутами и алгоритмами их формирования. Здесь я расположил максимально прилизанные и корректные данные. Именно здесь фокусируется внимание и интерес пользователей:
* Агрегация и объединение данных, например, суточные показатели из всех рекламных кабинетов
* Расчет бизнес-метрик: абсолютные и относительные показатели, их динамика
* Формирование *Сквозной Аналитики*: как раз тот самый кейс для **full join**, когда ни одна из составляющих уравнения не должна быть потеряна
Дашбординг и удобный доступ к данным
------------------------------------
> *— Что кроме дашборда можно показать клиенту?*
>
> *— Правильно, почти ничего.*
Поэтому с точки зрения клиента визуальная подача результатов — это самое основное. И неважно, сколько времени вы потратили на выгрузку по API, отладку функций и макросов, или создание *Github Action*, который регулярно обновляет витрины.
[](https://habrastorage.org/webt/ba/lr/rt/balrrtnspyflg0dsi27kiylkt7s.gif)
*Визуализация динамики основных показателей на интерактивном дашборде*
Дашборд это ни в коем случае не статический элемент. Здесь важен интерактив и динамика. Это портал к данным, откуда можно прыгнуть в детализацию или сфокусироваться на части данных (*сегменты*).
Приложение доступно как с компьютера, так и с мобильных устройств, планшетов. Дашборд можно спрятать за окно логина, им можно делиться публично с доступом по ссылке. Снимок дашборда можно регулярно получать по почте или в *Slack*.
Представленный дашборд — это моя разработка. Но у заинтересованного пользователя есть все инструменты, чтобы самостоятельно изучить доступные данные. Задать вопросы и собрать полученные ответы в собственные дашборды.
[](https://habrastorage.org/webt/xz/_k/6j/xz_k6jmvqcllpgcfqtofl5nbtjw.gif)
*Семантический слой доступа к метаданным витрин и детального слоя*
В удобном интерфейсе все метаданные как на ладони:
* Доступные витрины и их описание
* Атрибутный состав, типы данных
* Преднастроенные сегменты, метрики, вопросы созданные кем-то другим
* Приложение любезно предложит автоматический дашборд (*x-ray*) на данных витрины
Работу всей этой красоты обеспечивает Open Source BI решение *Metabase* (рекомендую!). Я разместил его на *Amazon Elastic Beanstalk*, и это уже полноценное продуктивное развертывание:
* Официальный *Docker*-образ и предсказуемое окружение
* Использование Postgres (*AWS RDS*) в качестве бэкенда метаданных
* Балансировщик нагрузки (*Load Balancing*) и постоянный пинг-*Healthcheck* сервиса
* Понятное и простое обновление версии приложения Metabase
[](https://habrastorage.org/webt/l5/kb/uu/l5kbuupmpjxy9ziffdygofjzhmi.png)
*Продуктивное развертывание BI Metabase в облаке AWS Elastic Beanstalk*
Рейтинг нетривиальных проблем
-----------------------------
Неужели всё так просто? Конечно нет! Если к текущему моменту сложилось ощущение, что всё выстраивается гладко и бесшовно, то это большое заблуждение. Ниже я системно опишу те болевые точки, с которыми столкнулся.
1. Кривая разметка и парсинг идентификаторов
> *Вся Сквозная Аналитика строится вокруг идентификаторов, по которым можно сопоставить данные из различных источников. Потому она и сквозная, т.е. проходящая сквозь ~~пространство и время~~ сервисы и учетные системы.*
Это ключевая фишка. Нет идентификаторов-якорей — нет сквозной аналитики. Важно следовать лучшим практикам и быть консистентным при запусках Кампаний во всех Рекламных Кабинетах.
(1) Легко допустить ошибку: поставить лишний символ, например, **{фигурные скобки}**, забыть указать UTM-метки (или указать дважды!), теги, ключевые слова. После запуска, к сожалению, это восстановлению уже не подлежит. *Здесь наши полномочия всё, окончены.*
(2) В другом случае мы теряли метки при обработке редиректа на веб-сервере. Веб-разработчик установил какой-то хитрый php-скрипт, назначение которого осталось для меня тайной.
(3) В третьих, это особенности разметки конкретных кабинетов. Я эмпирически выяснил, что Google Adwords к числовому идентификатору может подставлять буквенный префикс типа aud-, kwd-, pla-.
(4) Хорошая разметка, для примера. В ходе парсинга удалось достать все идентификаторы!
[](https://habrastorage.org/webt/fp/vf/7f/fpvf7f9run2fzknnesgfavut5b0.png)
*Примеры учета особенностей разметки для последующего парсинга идентификаторов*
Все эти и другие скрытые особенности необходимо неустанно контролировать и учитывать в алгоритмах парсинга, чтобы получать качественные результаты.
2. Хаотичный учет сделок и воронок в CRM
В большей части выгрузок из CRM, с которыми я работал, налицо отсутствие системного подхода. Это означает стихийное заполнение статусов сделок, их параметров, принадлежность к воронкам и каналам-источникам лидов. Я вовсе не придираюсь, ведь всё дело в том, что и аналитика будучи приемником данных приобретает те же черты.
> *— Нет желания поддерживать актуальность, полноту и достоверность в CRM-системе, но при этом хочется иметь красивый результат в отчетах?*
>
> *— Запомните: это так не работает.*
Каков мой ответ? Я вывел на дашборд таблицу со сделками, в которых с разметкой не всё в порядке.
[](https://habrastorage.org/webt/kg/q6/2t/kgq62tqoyncwfr51rc4lxlp767o.png)
*Проверочный дашборд по проблемным сделкам в CRM*
3. Правила матчинга (поиск совпадений) и суррогатные ключи
Хорошо, предположим, что метки есть. Давайте склеивать данные. Решение в лоб: сделать джоин таблиц с условием совпадения всех полей. Выглядит как-то так:
```
from costs c
full join conversions cv on
c.[Дата] = cv.[Дата]
and c.[Идентификатор кампании] = cv.[Идентификатор кампании]
and c.[Идентификатор группы объявлений] = cv.[Идентификатор группы объявлений]
and c.[Идентификатор условия показа] = cv.[Идентификатор условия показа]
```
Что если значение одного из столбцов *NULL*? Совпадения не случится (гуглим NULL = NULL).
Я поступил несколько иначе: прежде чем делать джоин, я готовлю конкатенированный ключ и хеш-ключ:
```
-- фиксируем список полей для составного ключа
{%- set key_field_list = [
'[Дата]',
'[Идентификатор кампании]',
'[Идентификатор группы объявлений]',
'[Идентификатор условия показа]'
]
-%}
-- собираем хеш-ключ и ключ конкатенации в макросах
select
{{ concat_key(key_field_list) }} as concat_key
, {{ surrogate_key(key_field_list) }} as hash_key
...
-- условие джоина приобретает вид:
from costs c
full join conversions cv on c.hash_key = cv.hash_key
```
Простое и элегантное решение. И при этом ключ конкатенации может быть однозначно интерпретирован человеком.
[](https://habrastorage.org/webt/qe/wy/zt/qewyzt1dkxtp7baqeu_cixg0b4w.png)
*Суррогатный хеш-ключ идеален для джоина; ключ конкатенации понятен человеку*
4. Механика формирования Сквозной Аналитики
Должно быть уже заметили, что я использую *full join*. Да, это как раз тот самый кейс, когда мне важно не потерять ни одну из частей уравнения в случае, если совпадения не произошло: ни лид из CRM, ни строку трат из РК, ни конверсию из Я.Метрики.
Во-первых, необходимо следить за тем, чтобы показатели не задваивались при склейке (очень запросто получается в таблицах с несколькими строками по одному ключу). Для этого я написал дата-тест, сверяющий суммы и количества с целью учета их один и только один раз.
Во-вторых, всем становится как-то досадно, когда для лида не находится источник трафика и сумма трат из РК. Для быстрого поиска причин я ввёл две мета-колонки:
* *meta\_is\_row\_match* (true/false) — случилось ли совпадение кусочков из разных систем?
* *meta\_row\_origin* — из какой системы пришла оригинальная строка (Я.Директ/Я.Метрика/AmoCRM)?
[](https://habrastorage.org/webt/kq/8i/at/kq8iatjczqgr9eurvtqdsi_xw8s.png)
*Мета-колонки is\_match, row\_origin помогают в поиске источников проблем*
В третьих, что если у владельца CRM всё схвачено и есть хитрый мастер-план по подсчету метрик? *Нужно только считать как задумано*. Нет проблем, сделать можно всё, что угодно. Даже так:
```
select
...
, sum(1) as [Сделки]
, sum(CASE WHEN [Теги] LIKE '%первич%' THEN 1 ELSE 0 END) as [Сделки - первичная коммуникация]
, sum(CASE WHEN [Статус сделки] LIKE '%успешн%' THEN 1 ELSE 0 END) as [Сделки - успешно реализовано]
, sum(CASE WHEN [Статус сделки] LIKE '%успешн%' THEN [Сумма] ELSE 0 END) as [Сумма - успешно реализовано]
...
```
5. Модель атрибуции может стать причиной расхождений в показателях
Несоответствие данных это моя самая большая боль. Непрекращающиеся итерации сверки данных и поиска причин расхождений. С одной из них я довольно долго промучился, пока не нашел способ явно задавать модель атрибуции для выгрузки по API из Яндекс.Метрики. В теле запрашиваемого измерения необходимо явно указать модель атрибуции, например *ym:s:UTMSource*:
```
ym:s:lastsignUTMSource -- последний значимый источник
ym:s:firstUTMSource -- первый источник
ym:s:lastUTMSource -- последний источник
ym:s:last_yandex_direct_clickUTMSource -- последний переход из Директа
```
6. Витрины необходимо регулярно актуализировать (обновлять)
Оказывается это не так-то просто. Я могу дергать запуски скриптов вручную, но в продуктивном решении хочется расчеты выполнять по заданному расписанию и делать это надежно.
[](https://habrastorage.org/webt/o4/ue/vl/o4uevlg-iqs4i1pbktm0ey2nyhw.gif)
*Автоматизация формирования витрин данных с помощью Github Action*
И тогда я создал *Github Action* [kzzzr / mybi-dbt-action](https://github.com/kzzzr/mybi-dbt-action) — действие, которое автоматически разворачивает Docker-контейнер, устанавливает зависимости, подключается к СУБД, выполняет расчеты витрин, прогоняет тесты. Потратил значительное количество времени, зато теперь витрины собираются в автономном режиме, пока я спокойно сплю.
Достигнуты значительные успехи
------------------------------
Абсолютный контроль над данными и результатами. Прозрачность и управляемость. Все алгоритмы, функции, парсинг и соединения как на ладони. Самодокументируемый код.
Да, порог входа для новичка довольно высок. Зато любые изменения — максимально быстро. Я могу слепить из данных всё, что угодно. Я не скован рамками и ограничениями других решений. И мне это нравится.
> — *Добавь новый аккаунт? Поменяй коэффициент?*
>
> — *1 минута на точечное редактирование кода и 5 минут на расчет витрин.*
>
> — *Что, так быстро?*
>
> — *Именно.*
Считайте, что к этим пунктам я уже поставил галочку в своём TODO:
* Выгрузки из источников: базовые, кастомные API, любые другие события через Webhook
* Детальный слой Хранилища Данных, импортируемый как модуль *dbt CORE* и используемый для всех проектов. Содержит код и тесты.
* Логика матчинга данных уровня Кампания + Группа Объявлений + Объявление + Ключевое слово (Хеш- и Конкат-ключи)
* Вариант визуализации (Дашборд + Фильтры), прошедший приемку клиента
* Регулярное обновление витрин (пока раз в сутки) через Github Actions
* Статический вебсайт с документацией, метаданными, графом зависимостей витрин (*DAG*)
* Условия для совместной работы над проектом: *Git*-репо, изолированные контуры *DEV* и *PROD*.
* *Бриф* на быстрый запуск для Клиента: аккаунты, бизнес-правила, метрики.
Вектор дальнейшего развития
---------------------------
Конечно, он у меня есть. Следующими шагами я хотел бы сделать:
* Покрытие тестами кода и данных — *Continuous Integration* & *Data Tests*. И мне уже приснилось, как это сделать.
* Пульс Качества данных (*Data Quality*): актуальность данных, выявление проблем в разметке. Кстати, подобный серьезный проект я реализую для Wheely и уже писал об этом: [Кто ответит за качество аналитики: QA для Хранилища Данных](https://habr.com/ru/company/otus/blog/526174/).
* Домен 1-го уровня для дашбордов. Чтобы солидно, а не <http://spasibo-metabase.eu-central-1.elasticbeanstalk.com/>
* Попробовать визуализацию с помощью *Apache Superset* вместо Metabase. Просто очень хочется, ищу повод.
* *Бизнес-документация* логики формирования витрин. Всё прозрачно: зашел и сам разобрался, откуда взялись эти числа.
* Движение в сторону *self-service BI*. Даю витрины и их описание. Далее строите те метрики, отчеты, дашборды и фильтры, какие пожелаете.
* Фишки для *Агентства*: сводный анализ по всем Клиентам, Рекламным Кабинетам, учет индивидуальных ставок НДС.
* Больше кейсов. Больше данных. Развитие! Хочется больше погрузиться в болевые точки и потребности клиентов.
Итак, зачем я здесь?
--------------------
Мне нравится мой *pet-project*, хотя я всё еще не дал ему легендарное название. Этой публикацией я преследую несколько целей:
* Помочь тем, кому моё решение принесет пользу. Есть здесь те, у кого болит?
* Найти единомышленников и неравнодушных контрибьюторов. Пока код в статусе Private, но высока вероятность вывести проект в public Open Source.
* Услышать экспертное мнение. Возможно, именно ты наступал на эти грабли и мог бы посоветовать что-то дельное.
* Просто пообщаться. Если возникли мысли после прочтения материала — поделитесь в комментариях.
Я буду публиковать новости, связанные с этим проектом в telegram-канале <https://t.me/enthusiastech>.
Следите за обновлениями и задавайте вопросы, я буду рад на них ответить.
Благодарю за внимание. | https://habr.com/ru/post/538106/ | null | ru | null |
# Метапрограммирование
[Метапрограммирование](http://en.wikipedia.org/wiki/Metaprogramming) — общее название класса средств автоматизации труда программиста. Под ним понимают и кодогенерацию, и макросы препроцессора в C, и шаблоны C++, и макросы LISP, и создание своих DSL, а так же использование динамических языков с генерацией кода на лету. [Nemerle](http://nemerle.org/Main_Page) поддерживает еще один вариант метапрограммирования.
Если и так существует так много вариантов, то кажется, что изобретать новый не имеет смысла, но каждый перечисленный вариант реализации идей метапрограммирования обладает своими недостатками, которые не совместимы с идей языка [Nemerle](http://nemerle.org/Main_Page).
Во-первых Nemerle компилируемый язык программирования, поэтому отпадают механизмы из Ruby, Tcl и LISP.
Макросы C наиболее маломощны из всех, так как существует большой класс задач, которые могут быть автоматизированы с помощью макросов из LISP, но не по зубам макросам C. Кроме того, макросы C не безопасны, так как часто аргумент макроса вычисляется несколько раз, а если это функция с побочным действием, то в программе появляется трудноуловимый баг.
Достоинством кодогенерации является то, что она не имеет отношения к языку, но из этого следует и её недостаток — усложняется сборка проекта.
Шаблоны C++ — хорошая технология, но у неё много родовых травм, например, она работает на уровне текста, есть проблемы с взаимодействием между библиотеками, а так же относительно простой код на шаблонах выглядит относительно просто, но сложный код на шаблонах выглядит очень сложно. Такой подход отличается от негласной истины, что сколь угодно сложный код должен иметь простой интерфейс.
Суммируя, можно описать какими свойствами обладает метапрограммрование в Nemerle:
* Мощная макросистема, аналогичная макросистеме в LISP.
* Макросы распространяются не в виде исходного текста, а в виде откомпилированных сборок — плагинов к компилятору.
* Использование макросов не сложнее использования библиотек.
**Так что же такое макрос в контексте Nemerle?**
Макрос является отображением (функцией) из синтаксического дерева в синтаксическое дерево. Упрощенно, компилятор по исходному тексту строит синтаксическое дерево, затем, части синтаксического дерева, описывающие классы, помеченные атрибутом макроса, изменяются под действием самого макроса и процесс компиляции продолжается.
Макросы могут изменять синтаксические деревья как конкретного класса, так и всей программы, таким образом, метапрограммирование в Nemerle достаточно мощно. Под мощностью я имею ввиду, что множество задач, которые могут быть автоматизированы в Nemerle достаточно шире, чем в других языках.
**Зачем?**
Сложно понять зачем и когда использовать метапрограммирование, поэтому лучше всего проанализировать задачи, его использующие. Задача сериализации объектов является задачей метапрограммирования. Предположим, что мы имеем классы, задающие деревъя объектов, например
> `class A
>
> {
>
> public Foo : int { get; set; }
>
> public Bar : string { get; set; }
>
> }
>
>
>
> class B
>
> {
>
> public Baz : A { get; set; }
>
> public Pub : byte { get; set; }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Добавим теперь код, отвечающий за сериализацию:
> `interface ISerializable
>
> {
>
> Serialize(stream : StreamWriter) : void;
>
> }
>
>
>
> class A : ISerializable
>
> {
>
> public Foo : int { get; set; }
>
> public Bar : string { get; set; }
>
>
>
> public Serialize(stream : StreamWriter) : void
>
> {
>
> stream.WriteLine("");
>
> stream.WriteLine($"$Foo");
>
> stream.WriteLine($"$Bar");
>
> stream.WriteLine("");
>
> }
>
> }
>
>
>
> class B : ISerializable
>
> {
>
> public Baz : A { get; set; }
>
> public Pub : byte { get; set; }
>
>
>
> public Serialize(stream : StreamWriter) : void
>
> {
>
> stream.WriteLine("**"**);
>
> stream.WriteLine("");
>
> when(Baz!=null) Baz.Serialize(stream);
>
> stream.WriteLine("");
>
> stream.WriteLine($"$Pub");
>
> stream.WriteLine("");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Очевидно, что существует формальный алгоритм, который переведет код из первого примера в код второго примера, если этот алгоритм оформить на языке Nemerle, то получим макрос. Тогда код с поддержкой сериализации можно будет переписать, например, так:
> `[MakeSerializable]
>
> class A
>
> {
>
> public Foo : int { get; set; }
>
> public Bar : string { get; set; }
>
> }
>
> [MakeSerializable]
>
> class B
>
> {
>
> public Baz : A { get; set; }
>
> public Pub : byte { get; set; }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Где MakeSerializable — вызов макроса.
На основе этого примера легко вывести признак того, что пора использовать метапрограммирование:
> Над кодом, который обеспечивает работу основного алгоритма, производяться повторяющиеся операции.
Забавно, что если бы Nemerle был бы mainstream, то многие продукты просто не появились бы, например, средство AOP [Postsharp](http://www.postsharp.org/) было бы не нужно, так как все его возможности легко и просто реализируются через макросы. Другим известным средством является [NUnit](http://www.nunit.org/), в последней версии добавились парамметризованные тесты, эту возможность опять же легко можно реализовать через макросы в Nemerle для перидущей версии [NUnit](http://www.nunit.org/), к тому же с более высоким контролем типов.
Для тех, кто любит числа, то использование метапрограммирования в моем проекте поиска формул сократило количества кода на 20%, способствовало улучшению дизайна системы, так как осознание того, что над кодом будут происходить преобразования, заставляет писать код более структурировано. Дополнительным плюсом стало то, что использование метапрограммирования облегчило рефакторинг системы.
В заключении, хочу еще раз отметить, что использование метапрограммирования нацелено на сокращение вспомогательного кода и, как следствие, связаных с ним ошибок. Ключевым словом здесь является слово «вспомогательного», поэтому польза от использования метапрограммирования в первую очередь будет заметна в больших проектах. | https://habr.com/ru/post/58801/ | null | ru | null |
# Исследуем прародителей Minecraft: Dungeon Keeper
[](http://www.youtube.com/watch?v=_rfU96z0dEw) Я думаю, что о Minecraft слышали почти все. Но, возможно, не все видели одну из замечательных игр, [из которой Нотч брал свои идеи](https://twitter.com/#!/notch/status/76378826137018369) — я говорю Dungeon Keeper. Я не собираюсь пересказывать [википедию](http://ru.wikipedia.org/wiki/Dungeon_Keeper) насчет того, что из себя представляет игра, ибо, как мне кажется, лучше [один раз увидеть](http://www.youtube.com/watch?v=_rfU96z0dEw), чем 100 раз услышать или прочитать ;). Если приведенный выше ролик вас немного заинтересовал, вы можете [купить игру](http://www.gog.com/en/gamecard/dungeon_keeper), попросить диск у друзей или попробовать найти образ Dungeon Keeper Gold в интернете (самая полная редакция игры). Поскольку игра вышла в 1997 году под Windows и под DOS, есть 2 варианта запуска: под Windows в режиме совместимости с Windows 95 или DOSBox. В целом, я бы не рекомендовал пытаться её запустить нативно под Windows, хотя есть, скажем, [KeeperFX](http://keeper.lubie.org/html/dk_keeperfx.php), который должен исправить некоторые проблемы с совместимостью.
### Убедитесь, что ваш образ диска содержит музыку
Интересно, что оригинальный CD представляет из себя так называемый [Mixed Mode CD](http://en.wikipedia.org/wiki/Mixed_Mode_CD), в котором первой дорожкой записаны данные (т.е. сама игра), а все оставшиеся дорожки представляют из себя музыкальное сопровождение. Если попытаться сделать ISO-образ от такого CD, у вас может либо получиться только первая дорожка, либо несколько .iso-файлов ([первая ссылка по запросу «iso mixed mode cd»](http://forums.vso-software.fr/iso-images-of-mixed-mode-cd-s-t7148.html)). В любом случае, для образа диска этот формат вам не подойдет (если вы хотите играть с музыкой): смонтировать несколько .iso-файлов, как один логический раздел, будет весьма проблематично. Поэтому, к примеру, образ диска должен быть в [формате .cue](http://ru.wikipedia.org/wiki/Cue_sheet), который лишен описанного выше недостатка и позволяет делать образы для Mixed Mode CD.
### Монтируем .cue в DOSBox
Если вы запускаете Dungeon Keeper через DOSBox, и у вас есть .cue-образ, то у меня для вас хорошие новости: DOSBox поддерживает монтирование таких файлов. Чтобы это сделать, нужно набрать следующую команду после запуска (или поместить в секцию [autoexec] в конфигурационном файле):
> `imgmount d /path/to/image/DKGOLD.cue -t cdrom`
### Настройка игры
После того, как вы установили игру, в папке C:\KEEPER должны появиться исполняемые файлы keeper.exe и deeper.exe (только в случае, если вы установили дополнение Deeper Dungeons, входящее в Dungeon Keeper Gold) — они оба требуют наличия вставленного диска D:\ для того, чтобы начать игру. В принципе, обычный Dungeon Keeper не проверяет директорию для установки слишком тщательно, поэтому вы можете, скопировав недостающие файлы с диска, указать в KEEPER.CFG путь до установки как «C:\KEEPER\». Но тогда вы лишаетесь музыкального оформления, а музыка в игре очень хороша.
Если вы ставили игру в DOSBox, то по умолчанию у вас будет включен режим с пониженным разрешением. В игре 2 разрешения — высокое (по умолчанию в windows-версии) и низкое (dos-версия). Между ними можно переключаться по нажатию Alt+R непосредственно во время игры. Ещё я вам рекомендую потратить некоторое количество времени настроить DOSBox таким образом, чтобы он выполнял aspect-коррекцию, поскольку игра рассчитана на режим 640x400, но с соотношением сторон 4:3 (большинство старых ЭЛТ-мониторов поддерживают такой режим). В противном случае игра будет выглядеть не так, как предполагали авторы :).
Если вы хотите поиграть в Deeper Dungeons (да и для некоторых фрагментов Dungeon Keeper это актуально), то вы можете заметить, что скроллинг привязан к частоте процессора, и поэтому некоторые уровни выбрать просто не удастся. Именно здесь приходит на помощь DOSBox: вы можете понизить скорость игры до нужной во время выбора уровня ([DOSBox keys](http://www.dosbox.com/wiki/Special_Keys)), а потом поставить обратно на максимум, чтобы игра шла более плавно.
### Прохождение игры на русском языке
Некоторое время назад я уже хотел написать топик на хабре об этой игре, но в тот момент решил поднакопить ещё немного информации и полезного материала на эту тему. Но я всё равно тогда выложил на Youtube [видео-ролик, который готовил для этой статьи](http://www.youtube.com/watch?v=0g8qhYy43Gw), и он уже набрал около 2 тыс. просмотров. Это заставило меня задуматься насчёт того, что, возможно, эта тема всё же будет интересна другим людям. Поэтому я решил сделать не просто обзор игры, а её полное прохождение, и я уже опубликовал [прохождение первых 16 из 20 обычных уровней](http://www.youtube.com/playlist?list=PL4A027AC98894C740&feature=view_all) и [прохождение 1 бонусного уровня](http://www.youtube.com/watch?v=x1TYpP2A96g), причём для этого бонусного уровня я не смог найти прохождение где-либо ещё (причём не только на YouTube, но и в текстовых прохождениях игры этот уровень отмечается, как невозможный для прохождения). Суммарная длительность выложенного мной видео — более 9 часов, так что за один вечер пройти игру вам вряд ли удастся ;). Если сюда включить прохождение оставшихся уровней, то может получиться около 15 часов геймплея (в довольно быстром темпе ;)). Если учесть, что есть ещё несколько бонусных уровней и целое дополнение Deeper Dungeons, состоящее из 20 дополнительных (и очень сложных) уровней, то можете сами себе представить, насколько огромна эта игра.
Я очень надеюсь, что, если вам нравится Minecraft, как и мне, то вам также очень понравится и Dungeon Keeper, поскольку эта игра, ИМХО, просто шедевральна и до сих пор выглядит не хуже, чем некоторые современные игры. Но всё это, конечно, в свободное от работы время. | https://habr.com/ru/post/136255/ | null | ru | null |
# JSX — подробности
Этой публикацией я открываю серию переводов раздела "Продвинутые руководства" (Advanced Guides) официальной документации библиотеки React.js.
JSX — подробности
-----------------
Фундаментально, JSX является синтаксическим сахаром для функции `React.createElement(component, props, ...children)`.
JSX код:
```
Click Me
```
компилируется в:
```
React.createElement(
MyButton,
{color: 'blue', shadowSize: 2},
'Click Me'
)
```
Также можно использовать самозакрывающую форму для тегов, у которых нет потомков. Например:
компилируется в:
```
React.createElement(
'div',
{className: 'sidebar'},
null
)
```
Протестировать, как различные конструкции JSX компилируются в JavaScript, можно в [онлайн компиляторе Babel](https://babeljs.io/repl/#?babili=false&evaluate=true&lineWrap=false&presets=es2015%2Creact%2Cstage-0&code=function%20hello()%20%7B%0A%20%20return%20%3Cdiv%3EHello%20world!%3C%2Fdiv%3E%3B%0A%7D)
Спецификация типов элементов React
----------------------------------
Начальная часть JSX тега определяет тип элемента React.
Типы, определенные с Прописной буквы, указывают на то, что тег ссылается на компонент React. Эти теги в процессе компиляции ссылаются на именованную переменную, содержащую компонент React. Поэтому, обратите внимание, — эта переменная должна находится в области видимости. Например: Если вы используете выражение JSX — , то переменная `Foo` должна находится в области видимости.
### React должен находиться в области видимости
Т.к. JSX компилируется в вызовы функции `React.createElement`, библиотека `React` всегда должна находиться в области видимости вашего кода JSX.
Например: обе строки import необходимы в данном коде, т.к. `React` и `CustomButton` не включены непосредственно в JavaScript:
```
import React from 'react';
import CustomButton from './CustomButton';
function WarningButton() {
// return React.createElement(CustomButton, {color: 'red'}, null);
return ;
}
```
Если вы не используете какой-либо упаковщик JavaScript и добавляете React непосредственно в тег | https://habr.com/ru/post/319270/ | null | ru | null |
# Интеграция Google Pay
Привет, Хабр!
Меня зовут Игорь, я Android-разработчик в команде Trinity Digital. Сегодня я хочу рассказать о классном инструменте — **Google Pay API**.
[](https://habrastorage.org/webt/zp/oz/tm/zpoztmk3kbzmwajqwi6hcaplwwe.png)
**Итак**, если в вашем приложении можно совершать покупки, и при этом вы используете не In-app Billing (за процессинг отвечает не Google Play), то скорее всего среди вариантов оплаты у вас есть и “Оплата картой”. А это значит, что вам каждый раз приходится отправлять пользователя вводить данные карты или на красиво сверстанные экраны с картой, или на веб-сайт вашего провайдера платежных сервисов (далее — payment processor). Уже посчитали сколько действий придется совершить пользователю, чтобы оплатить заветный заказ? Ага, а теперь представьте, что он сможет выполнить то же целевое действие всего в два тапа. Мы тоже представили и подумали, а почему бы не дать пользователям такую возможность? Основные условия успеха — продавец быть [зарегистрирован в Google](https://payments.developers.google.com/signup) и payment processor должен сотрудничать с Google.
Список банков России, которые сотрудничают с Android Pay:
АК Барс Банк
Альфа Банк
БИНБАНК
Промсвязьбанк
ВТБ24
Банк Открытие
МТС Банк
Райффайзен Банк
Рокетбанк
Россельхозбанк
Банк Русский Стандарт
Сбербанк
Тинькофф Банк
Точка
Яндекс Деньги
Как все будет выглядеть для **пользователя**: он попадает на экран выбора типов оплаты в вашем приложении, нажимает на кнопку “Оплатить через Google ”, выбирает нужную карту или оставляет ту, что указана по-умолчанию, нажимает кнопку подтверждения. Готово!
Помните, что Google Pay API позволяет пользователям выбрать любую карту, привязанную или к аккаунту Google, или добавленную в Google Pay.
Теперь перейдем непосредственно к **интеграции**.
Рассмотрим этапы:
1. Верстка
2. Код
3. Тестирование
4. Отправка на ручную проверку
5. Релиз
1. Верстка
----------
Первое, о чем стоит сказать — предупредите дизайнеров о [гайдлайнах](https://developers.google.com/payments/brand-guidelines). Если кратко по пунктам:
* на экранах **ДО ИЛИ** на экране, где будет расположена кнопка “Оплатить через Google” должна быть указана стоимость покупки;
* дайте пользователям возможность изменять данные заказа, выбирать тип оплаты [, менять адрес];
* никогда не показывайте данные для оплаты полностью (любые номера, даты и так далее);
* еще раз — “Оплатить через Google” — именно такая надпись должна быть на вашей кнопке, если делаете приложение с поддержкой русского языка;
* Google рекомендует использовать стандартные кнопки. Если вы хотите использовать темную тему или вообще кнопку со своим дизайном, то вам стоит написать в тех. поддержку по адресу [androidpay-api-support@google.com](mailto:androidpay-api-support@google.com). Но даже на кастомной кнопке должно быть лого Google и надпись … да, я надеюсь, вы поняли :) ;
* по ширине ограничений нет, минимальная высота кнопки — 40dp. Если делаете выше/шире, то помните, что текст должен быть отцентрирован.
Соблюдение данных пунктов позволит вам быстрее пройти все проверки и попасть в белый список.
2. Код
------
Чтобы оплата через Google работала, на телефоне пользователя должны быть установлены Google Play Services версии не ниже 11.4. Но не беспокойтесь, есть специальный метод, который подскажет, можно ли провести оплату или же стоит спрятать кнопку.
Для начала добавим нужные зависимости в build.gradle уровня приложения. Перед внедрением проверяйте актуальность версий!
```
dependencies {
compile 'com.google.android.gms:play-services-wallet:11.4.0'
compile 'com.android.support:support-v4:24.1.1'
compile 'com.android.support:appcompat-v7:24.1.1'
}
```
Далее следует обновить AndroidManifest:
```
...
```
Теперь осталось совсем чуть-чуть:
* Создаём PaymentsClient в вашей Activity или в Fragment. Чтобы не захламлять эти классы, можно вынести весь код в методы GooglePaymentUtils, например. Тогда:
```
class MainActivity : AppCompatActivity() {
private lateinit var googlePaymentsClient: PaymentsClient
...
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
...
googlePaymentsClient = GooglePaymentUtils.createGoogleApiClientForPay(context)
}
...
}
```
```
object GooglePaymentUtils {
fun createGoogleApiClientForPay(context: Context): PaymentsClient =
Wallet.getPaymentsClient(context,
Wallet.WalletOptions.Builder()
.setEnvironment(WalletConstants.ENVIRONMENT_TEST)
.setTheme(WalletConstants.THEME_LIGHT)
.build())
}
```
Обратите внимание на константы:
*WalletConstants.ENVIRONMENT\_TEST* — пока Google не разрешит выход в боевую среду, вы должны использовать именно её, чтобы самостоятельно протестировать флоу оплаты. Не пугайтесь, когда увидите предупреждение на диалоге Google Pay, что приложение не опознано.
*WalletConstants.THEME\_LIGHT* — светлая тема диалога, также есть темная.
* Отлично, у нас есть клиент, теперь мы готовы сделать запрос, можно ли вообще использовать оплату и показывать кнопку.
```
object GooglePaymentUtils {
fun checkIsReadyGooglePay(paymentsClient: PaymentsClient,
callback: (res: Boolean) -> Unit) {
val isReadyRequest = IsReadyToPayRequest.newBuilder()
.addAllowedPaymentMethod(WalletConstants.PAYMENT_METHOD_CARD)
.addAllowedPaymentMethod(WalletConstants.PAYMENT_METHOD_TOKENIZED_CARD)
.build()
val task = paymentsClient.isReadyToPay(isReadyRequest)
task.addOnCompleteListener {
try {
if (it.getResult(ApiException::class.java))
// можем показать кнопку оплаты, все хорошо
callback.invoke(true)
else
// должны спрятать кнопку оплаты
callback.invoke(false)
} catch (e: ApiException) {
e.printStackTrace()
callback.invoke(false)
}
}
}
}
```
*PAYMENT\_METHOD\_CARD*, *PAYMENT\_METHOD\_TOKENIZED\_CARD* — говорят, что мы хотим видеть карточки из Google аккаунта пользователя и карточки, привязанные к Android Pay.
* Если мы можем показать кнопку, значит, мы должны повесить на нее обработчик нажатий
```
btnPaymentByGoogle.setOnClickListener {
val request = GooglePaymentUtils.createPaymentDataRequest(price)
AutoResolveHelper.resolveTask(googlePaymentsClient.loadPaymentData(request),
context,
REQUEST\_CODE)
}
```
Тут запомните, что price — это строчка. И самое важное, даже если вы вызываете AutoResolveHelper.resolveTask из фрагмента, то результат все-равно придет в активити (об этом чуть позже) [на момент написания статьи работает именно так, AutoResolveHelper не умеет возвращать результат во фрагмент].
```
fun createPaymentDataRequest(price: String): PaymentDataRequest {
val transaction = createTransaction(price)
val request = generatePaymentRequest(transaction)
return request
}
fun createTransaction(price: String): TransactionInfo =
TransactionInfo.newBuilder()
.setTotalPriceStatus(WalletConstants.TOTAL_PRICE_STATUS_FINAL)
.setTotalPrice(price)
.setCurrencyCode(CURRENCY_CODE)
.build()
private fun generatePaymentRequest(transactionInfo: TransactionInfo): PaymentDataRequest {
val tokenParams = PaymentMethodTokenizationParameters
.newBuilder()
.setPaymentMethodTokenizationType
(WalletConstants.PAYMENT_METHOD_TOKENIZATION_TYPE_DIRECT)
.addParameter("publicKey", TOKENIZATION_PUBLIC_KEY)
build()
return PaymentDataRequest.newBuilder()
.setPhoneNumberRequired(false)
.setEmailRequired(true)
.setShippingAddressRequired(true)
.setTransactionInfo(transactionInfo)
.addAllowedPaymentMethods(SUPPORTED_METHODS)
.setCardRequirements(CardRequirements.newBuilder()
.addAllowedCardNetworks(SUPPORTED_NETWORKS)
.setAllowPrepaidCards(true)
.setBillingAddressRequired(true)
.setBillingAddressFormat(WalletConstants.BILLING_ADDRESS_FORMAT_FULL)
.build())
.setPaymentMethodTokenizationParameters(tokenParams)
.setUiRequired(true)
.build()
}
```
Тут *CURRENCY\_CODE* = “RUB”.
*WalletConstants.TOTAL\_PRICE\_STATUS\_FINAL* — говорим, что стоимость покупки окончательная и больше изменяться не будет.
Также есть варианты:
*WalletConstants.TOTAL\_PRICE\_STATUS\_ESTIMATED* — стоимость примерная, и может измениться, например, после уточнения адреса.
*WalletConstants.TOTAL\_PRICE\_STATUS\_NOT\_CURRENTLY\_KNOWN* — еще не знаем, какая стоимость.
Не могу сказать, как на практике поведут себя последние две константы, так как не проверял ¯\\_(ツ)\_/¯.
Остановимся на **PaymentMethodTokenizationParameters** и его методе setPaymentMethodTokenizationType:
1. *PAYMENT\_METHOD\_TOKENIZATION\_TYPE\_PAYMENT\_GATEWAY*
используется только если ваш payment processor в списке:
Adyen
Braintree
PaySafe
Stripe
Vantiv
WorldPay
Тогда вместо `.addParameter("publicKey", TOKENIZATION_PUBLIC_KEY)`
вы должны написать `.addParameter("gateway", "yourGateway")`
`.addParameter("gatewayMerchantId", "yourMerchantIdGivenFromYourGateway")`
2. Иначе используется вышеуказанный тип *PAYMENT\_METHOD\_TOKENIZATION\_TYPE\_DIRECT*.
Для этого вам необходимо запросить у провайдера платежных сервисов публичный ключ и передавать именно его в `.addParameter("publicKey", TOKENIZATION_PUBLIC_KEY)`
**Теперь остается создать запрос.**
*.setPhoneNumberRequired* — должен ли пользователь ввести номер.
*.setEmailRequired* — должен ли пользователь ввести email
*.setShippingAddressRequired* — должен ли пользователь выбрать страну. Тут можно ограничить число стран, для которых данная транзакция выполнится.
*.addAllowedPaymentMethods* — у нас это *WalletConstants.PAYMENT\_METHOD\_CARD* — карты из google аккаунта, *WalletConstants.PAYMENT\_METHOD\_TOKENIZED\_CARD* — карты, добавленные в Google Pay.
В CardRequirements мы указываем, что должны работать карточки систем Visa, Mastercard и других (МИР, например)
```
val SUPPORTED_NETWORKS = arrayListOf(WalletConstants.CARD_NETWORK_OTHER,
WalletConstants.CARD_NETWORK_VISA,
WalletConstants.CARD_NETWORK_MASTERCARD)
```
* Все, мы создали запрос, отправили его через клиента и ждем результат через AutoResolveHelper.
Как вы помните, результат придет в **активити**.
```
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
when (requestCode) {
LOAD_PAYMENT_DATA_REQUEST_CODE -> {
when (resultCode) {
Activity.RESULT_OK -> {
if (data == null)
return
val paymentData = PaymentData.getFromIntent(data)
}
Activity.RESULT_CANCELED -> {
// Пользователь нажал назад,
// когда был показан диалог google pay
// если показывали загрузку или что-то еще,
// можете отменить здесь
}
AutoResolveHelper.RESULT_ERROR -> {
if (data == null)
return
// Гугл сам покажет диалог ошибки.
// Можете вывести логи и спрятать загрузку,
// если показывали
val status = AutoResolveHelper.getStatusFromIntent(data)
Log.e("GOOGLE PAY", "Load payment data has failed with status: $status")
}
else -> { }
}
}
else -> { }
}
}
```
Вот и все, в paymentData у вас будет токен, который следует отдать вашему серверу. Дальнейшая логика зависит от вашего payment processor.
3. Тестирование
---------------
Ничего сложного, просто проверяете, что установлена константа *WalletConstants.ENVIRONMENT\_TEST*, и проходите весь флоу. Списание денег с карточки производиться не будет, вам будет отдаваться тестовый токен, поэтому payment processor должен отклонить оплату.
4. Отправка на ручную проверку
------------------------------
Поздравляю! Вы готовы отправить свой дебаг билд на ручную проверку в Google.
Несколько советов:
* Если ваше приложение поддерживает только русский язык, то подготовьте скриншоты с указаниями, куда нажимать.
* Если есть какая-то специфика в процессе заказа, то подробно опишите.
* Создайте тестовый аккаунт специально для Google и отправьте прямо с билдом.
Отправляете билд на [androidpay-api-support@google.com](mailto:androidpay-api-support@google.com) и ждете ответа.
5. Релиз
--------
Вам сказали, что все хорошо и можно выпускать приложение. Первым делом вас попросят [активировать приложение по адресу](https://payments.developers.google.com/signup) (с аккаунта продавца (merchant)).
Далее вас могут попросить прислать PCI Compliance. Эти документы подтверждают, что ваш payment processor соответствует стандартам безопасности по работе с картами. Запрашиваете у него и отправляете в поддержку.
Как только вы выполнили эти два пункта, вам скажут, что можно поменять *WalletConstants.ENVIRONMENT\_TEST* на *WalletConstants.ENVIRONMENT\_PRODUCTION*. Также может потребоваться поменять TOKENIZATION\_PUBLIC\_KEY, если вы использовали ключ с тестовой среды вашего payment processor.
Вот и все, теперь протестируйте реальную оплату и можете выпускать релиз в маркет!
Спасибо и удачи! | https://habr.com/ru/post/347460/ | null | ru | null |
# Смена SID при клонировании и массовом развёртывании
Привет, Хабр! Упомянутая в заголовке тема всё ещё порождает множественные дискуссии и недопонимание между системными администраторами. В своей статье я постараюсь ответить на следующие вопросы:
1. Что такое SID и каких он бывает типов?
2. Когда наличие двух и более машин с одинаковыми Machine SID будет порождать проблемы? Или, другими словами, когда всё-таки (не)нужно менять Machine SID?
3. Что такое Sysprep и нужен ли Sysprep для клонирования/развёртывания?
Эти вопросы будут рассмотрены в первую очередь в контексте задачи развёртывания/клонирования множества рабочих станций/серверов из одного мастер-образа в пределах одной компании.
[](http://habrahabr.ru/company/acronis/blog/273793/)
В основу рассуждений была взята популярная [статья](https://blogs.technet.microsoft.com/markrussinovich/2009/11/03/the-machine-sid-duplication-myth-and-why-sysprep-matters/) Марка Руссиновича (доступна также [на русском языке](http://www.infosecurity.ru/cgi-bin/mart/arts.pl?a=091209)), которую довольно часто неправильно интерпретируют (судя по комментариям и «статьям-ответам»), что приводит к неприятным последствиям. Добро пожаловать под кат.
**TL;DR**1. Менять SID машины само по себе бессмысленно и даже вредно для современных ОСей (пример последствий смены SID на Windows 10 ниже).
2. Для подготовки машины к клонированию/развёртыванию образа стоит использовать sysprep.
3. SID машины будет иметь значение, только если одну из склонированных машин промоутить до домен контроллера. Так делать не стоит.
4. Не стоит клонировать/развёртывать образ машины, которая УЖЕ добавлена в домен; добавление в домен нужно делать после клонирования/развертывания.
Что такое SID, его типы и чем отличается Machine SID от Domain SID?
-------------------------------------------------------------------
**Ликбез**“***SID** (Security Identifier), или Идентификатор безопасности – Это структура данных переменной длины, которая идентифицирует учетную запись пользователя, группы, домена или компьютера (в Windows на базе технологии NT (NT4, 2000, XP, 2003,Vista,7,8)). SID ставится в соответствие с каждой учетной записью в момент её создания. Система оперирует с SID'ами учетных записей, а не их именами. В контроле доступа пользователей к защищаемым объектам (файлам, ключам реестра и т.п.) участвуют также только SID'ы.*”
В первую очередь, важно различать SID компьютера (Machine SID) и SID домена (Domain SID), которые являются независимыми и используются в разных операциях.
Machine SID и Domain SID состоят из базового SID’а (base SID) и относительного SID’а (Relative SID = RID), который «приклеивается» в конец к базовому. Базовый SID можно рассматривать как сущность, в рамках которой можно определить группы и аккаунты. Машина (компьютер) является сущностью, в рамках которой определяются локальные группы и аккаунты. Каждой машине присваивается machine SID, и SID’ы всех локальных групп и аккаунтов включают в себя этот Machine SID с добавлением RID в конце. Для примера:
| | |
| --- | --- |
| Machine SID для машины с именем DEMOSYSTEM | S-1-5-21-3419697060-3810377854-678604692 |
| DEMOSYSTEM\Administrator | S-1-5-21-3419697060-3810377854-678604692-500 |
| DEMOSYSTEM\Guest | S-1-5-21-3419697060-3810377854-678604692-501 |
| DEMOSYSTEM\CustomAccount1 | S-1-5-21-3419697060-3810377854-678604692-1000 |
| DEMOSYSTEM\CustomAccount2 | S-1-5-21-3419697060-3810377854-678604692-1001 |
Именно SID’ы (а не имена) хранятся в токенах доступа (access tokens) и дескрипторах безопасности (security descriptors), и именно SID’ы используются при проверке возможности доступа к объектам системы Windows (в том числе, например, к файлам).
На машине вне домена используются локальные SID’ы, описанные выше. Соответственно, при соединении с машиной удалённо используется локальная аутентификация, поэтому даже имея 2 или более машин с одинаковым machine SID в одной сети вне домена, проблем с логином и работой внутри системы не будет, т.к. SID’ы в операциях удалённой аутентификации попросту не используются. Единственный случай, в котором возможны проблемы, это полное совпадение имени пользователя и пароля на двух машинах – тогда, например, RDP между ними может глючить.
Когда машина добавляется в домен, в игру вступает новый SID, который генерируется на этапе добавления. Machine SID никуда не девается, так же как и локальные группы, и пользователи. Этот новый SID используется для представления аккаунта машины в рамках домена. Для примера:
| | |
| --- | --- |
| Domain SID для домена BIGDOMAIN | S-1-5-21-124525095-708259637-1543119021 |
| BIGDOMAIN\DEMOSYSTEM$ (аккаунт машины (computer account)) | S-1-5-21-124525095-708259637-1543119021-937822 |
| BIGDOMAIN\JOHNSMITH (аккаунт пользователя (user account)) | S-1-5-21-124525095-708259637-1543119021-20937 |
Таким образом, машина DEMOSYSTEM теперь имеет два независимых SID’а:
• Machine SID, определяющая машину как сущность, в рамках которой заданы группы и аккаунты (первая строчка в первой таблице).
• SID аккаунта машины (computer account SID) в рамках домена BIGDOMAIN (вторая строчка во второй таблице).
Увидеть точное значение machine SID можно с помощью утилиты [PsGetSid](http://technet.microsoft.com/en-us/sysinternals/bb897417.aspx), запустив её без параметров. Второй SID, относящийся к домену, можно увидеть, запустив PsGetSid со следующими параметрами: `psgetsid %COMPUTERNAME%$`. Соответственно, для примера из таблиц это будет “`psgetsid DEMOSYSTEM$`".
Основная суть в том, что SID’ы должны быть уникальны в пределах окружения (authority), к которому они применимы. Другими словами, если машине DEMOSYSTEM присвоен machine SID S-1-5-21-3419697060-3810377854-678604692-1000, то неважно, что у другой машины в той же сети будет идентичный machine SID, т.к. этот SID используется только локально (в пределах машины DEMOSYSTEM). Но в пределах домена BIGDOMAIN computer SID у обоих машин должен быть уникальным для корректной работы в этом домене.
Смена SID при клонировании или развёртывании
--------------------------------------------
В применении к продукту [Acronis Snap Deploy 5](http://www.acronis.com/ru-ru/business/enterprise-solutions/image-deployment/) (основное предназначение — массовое развёртывание систем из мастер-образа), в котором функциональность смены SID-а присутствовала с самой первой версии, это означает, что мы, как и многие пользователи, ошибочно пошли на поводу у устоявшегося мнения, что менять SID нужно.
Однако исходя из вышесказанного, ничего страшного в развёртывании (или клонировании) машины без изменения Machine SID вовсе нет, в случае если это развёртывание происходит **до** добавления машины в домен. В противном случае — возникнут проблемы.
**Из этого правила есть одно исключение:** нельзя клонировать машину, если в дальнейшем роль этого клона планируется повышать (promote) до уровня домена контроллера. В этом случае Machine SID домен контроллера будет совпадать с computer SID в созданном домене, что вызовет проблемы при попытке добавления оригинальной машины (из которой производилось клонирование) в этот домен. Это, очевидно, относится только к серверному семейству Windows.
Проблемы, связанные со сменой SID
---------------------------------
Пересмотреть точку зрения на функциональность смены SID нас подтолкнул выпуск новой версии Windows. При первом тестовом развёртывании образа Windows 10 со сменой SID на получившейся машине обнаружилось, что кнопка Start перестала нажиматься (и это оказалось только вершиной «айсберга»). Если же развёртывать тот же образ без смены SID, то такой проблемы не возникает.
Основная причина в том, что эта опция вносит изменения практически во всю файловую систему развёртываемой машины. Изменения вносятся в реестр Windows, в разрешения NTFS (NTFS permissions) для каждого файла, в SID'ы локальных пользователей (так как SID пользователя включает в себя в том числе и machine SID; подробнее [тут](http://www.tenforums.com/tutorials/3443-user-account-details-view-windows-10-a.html)) и т.д.
В случае с Windows 10 большая часть ключей реестра не могла быть модифицирована («Error code = C0000005. Access violation» и другие ошибки) и, как следствие, наша функция смены SID'а отрабатывала не до конца, что и приводило к ~~трагической гибели~~ практически нерабочей копии Windows 10.
Было принято решение убрать эту опцию в случае, если в мастер-образе мы находим Windows 10 (или Windows Server 2016). Решение было принято на основе теоретических выкладок описанных выше плюс, естественно, было подтверждено практикой при тестировании недавно вышедшего обновления Acronis Snap Deploy 5 во множестве комбинаций: с и без переименования машин после развёртывания, с добавлением в домен и рабочую группу, развёртывание из мастер-образов снятых от разных состояний мастер-машины (она была добавлена в домен или рабочую группу в разных тестах) и т.д.
Использование Sysprep
---------------------
Начиная с Windows NT клонирование (развертывание) ОСи с использованием *только* NewSID никогда не рекомендовалось самим Microsoft. Вместо этого рекомендуется использовать родную утилиту [Sysprep](https://technet.microsoft.com/ru-ru/library/cc721940(v=ws.10).aspx) (см. [KB314828](https://support.microsoft.com/ru-ru/kb/314828)), которая, помимо смены SID'а, также вносит большое число других изменений, и с каждой новой версией Windows их становится только больше. Вот небольшой (неполный) список основных вносимых изменений:
* Удаляется имя машины
* Машина выводится из домена: это нужно для последующего успешного добавления в домен с новым именем
* Удаляются plug-and-play драйвера, что уменьшает риск возникновения проблем с совместимостью на новом «железе»
* Опционально удаляются Windows Event Logs (параметр 'reseal')
* Удаляются точки восстановления
* Удаляется профиль локального администратора и этот аккаунт отключается
* Обеспечивается загрузка целевой машины в [режим аудита](https://technet.microsoft.com/ru-ru/library/cc722413(v=ws.10).aspx), позволяющий устанавливать дополнительные приложения и драйверы
* Обеспечивается запуск [mini-setup](https://technet.microsoft.com/ru-ru/library/bb457075.aspx) при первом запуске для смены имени машины и другой дополнительной конфигурации
* Сбрасывается период активации Windows (сброс возможен до 3 раз)
Таким образом, клонирование/развертывание без использования Sysprep может повлиять (читай «скорее всего, сломает») на функциональность Windows Update, Network Load Balancing, MSDTC, Vista и выше Key Manager Activation (KMS), который завязан на CMID (не путать с Machine SID), также изменяемый Sysprep'ом, и т.д.
Итого
-----
Повторяя TL;DR из начала статьи, основной вывод можно сделать такой: для подготовки образа машины к клонированию/развёртыванию следует использовать sysprep в подавляющем большинстве случаев.
##### Линки
— [Как изменить SID в Windows 7 и Windows Server 2008 R2 с помощью sysprep](http://winitpro.ru/index.php/2011/01/20/kak-izmenit-sid-v-windows-7-i-windows-server-2008-r2-s-pomoshhyu-sysprep/)
— [How to View Full Details of All User Accounts in Windows 10](http://www.tenforums.com/tutorials/3443-user-account-details-view-windows-10-a.html)
— [Миф о дублировании SID компьютера](http://www.infosecurity.ru/cgi-bin/mart/arts.pl?a=091209)
— [Sysprep, Machine SIDs and Other Myths](http://blogs.technet.com/b/deploymentguys/archive/2009/12/03/sysprep-machine-sids-and-other-myths.aspx)
— [The Machine SID Duplication Myth (and Why Sysprep Matters)](https://blogs.technet.microsoft.com/markrussinovich/2009/11/03/the-machine-sid-duplication-myth-and-why-sysprep-matters/#pi137228=9)
— [Yes you do need to worry about SIDs when you clone virtual machines – reasserting the ‘myth’](https://rogerrelevant.wordpress.com/2014/01/08/yes-you-do-need-to-worry-about-sids-when-you-clone-virtual-machines-reasserting-the-myth/)
— [Why Sysprep is a necessary Windows deployment tool](https://4sysops.com/archives/why-sysprep-is-an-obligatory-windows-deployment-tool-part-1-all-the-important-sysprep-functions/)
Спасибо за внимание! | https://habr.com/ru/post/273793/ | null | ru | null |
# Конец эры глобального CSS
Все CSS-селекторы живут в глобальной области видимости.
Каждому, кто когда-либо имел дело с CSS, приходилось мириться с этой *глобальной* особенностью. Модель, некогда созданную для стилизации академических документов, сейчас едва ли можно назвать удобным инструментом для создания современных веб-приложений.
Абсолютно каждый селектор потенциально может вступить в борьбу с другим селектором или стилизовать «посторонний» элемент. В этой «глобальной» борьбе селектор может даже полностью проиграть, в итоге не применив к странице ни одного из своих правил.
Каждый раз модифицируя css-файл, необходимо хорошо подумать о глобальной среде, в которой будут существовать наши стили. Ни одна другая технология веб-разработки не требует столько усилий только для того, чтобы обеспечить коду минимальный уровень поддерживаемости.
Так *не должно* быть. Пора оставить позади эру глобальных стилей. Наступило время *закрытого* CSS.
> Во многих языках принято, что любая модификация глобальной области видимости происходит крайне редко, если происходит вообще.
Благодаря таким инструментам, как [Browserify](http://browserify.org/), [Webpack](https://webpack.github.io/) и [jspm](http://jspm.io/) фронтенд разработчики получили возможность писать код, состоящий из маленьких модулей, каждый из которых явно запрашивает другие модули, от которых он зависит.
А вот CSS безнаказанно продолжает жить сам по себе.
Многие из нас так привыкли к особенностям CSS, что до недавнего времени не видели других способов решить эту проблему, кроме как ждать поддержки от производителей браузеров. И даже после этого ещё не скоро наступит момент, когда большинство пользователей обзаведутся браузером, полностью поддерживающим [Shadow DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Shadow_DOM).
Разработчики обходили проблему глобальных классов, предлагая использовать определённую систему соглашений, диктующую, как именно стоит именовать классы. OOCSS, SMACSS, БЭМ, SUIT — все эти методики призваны помочь избежать столкновения пространств имён и сымитировать область видимости.
Несомненно, это было неплохой попыткой приручить CSS. Но ни одна из этих методик по сути не решает проблему, а только пытается обойти — какую из них ни выбери, селекторы так и останутся глобальными.
##### Всё изменилось 22 Апреля 2015
[Webpack](https://webpack.github.io/) позволяет импортировать CSS прямо внутри javascript-модуля. Если о таком «трюке» вы слышите впервые, можно почитать подробнее [здесь](https://webpack.github.io/docs/stylesheets.html) и [здесь](https://medium.com/seek-ui-engineering/block-element-modifying-your-javascript-components-d7f99fcab52b#.witgzfqv3).
В дело вступает вебпаковский [css-loader](https://github.com/webpack/css-loader), позволяющий написать такое:
```
require('./MyComponent.css');
```
На первый взгляд выглядит странно. Даже если закрыть глаза на тот факт, что импортируется `.css`, а не `javascript`.
Ведь обычно вызов *`require`* должен быть сохранён в переменную. Если этого не делают, то, как правило, это говорит о том, что была объявлена глобальная переменная. Явный признак плохой архитектуры.
Но это CSS — глобальной области видимости не избежать. Так считалось ранее.
22 Апреля 2015 года [Tobias Koppers](https://github.com/sokra) — автор Webpack'а — добавил новую фичу в `css-loader`, и назвал её *placeholders*. Сейчас она известна как [закрытая область видимости](https://github.com/webpack/css-loader#local-scope).
Эта функция позволяет экспортировать имена классов из CSS файла и запрашивать их внутри нашего javascript'а.
Короче говоря, вместо этого:
```
require('./MyComponent.css');
```
Можно написать это:
```
import styles from './MyComponent.css';
```
Чем же окажется значение переменной `styles`? Давайте сначала взглянем, как выглядит сам CSS:
```
:local(.foo) {
color: red;
}
:local(.bar) {
color: blue;
}
```
В этом примере использован синтаксис, распознаваемый css-loader'ом — *`:local(.identifier)`*. Такой код экспортирует два идентификатора [*назовем их «идентификаторами» в силу уникальности, которая будет обеспечена позже — прим. перев.*]: `foo` и `bar`.
Эти идентификаторы указывают на имена классов, которые мы и можем использовать в яваскрипте. Вот пример использования с [React](http://facebook.github.io/react/)'ом:
```
import styles from './MyComponent.css';
import React, { Component } from 'react';
export default class MyComponent extends Component {
render() {
return (
Foo
Bar
);
}
}
```
Самое важное здесь то, что идентификаторы указывают на гарантированно уникальные названия классов.
Больше нет необходимости лепить длинные префиксы для каждого селектора, пытаясь имитировать закрытую область видимости. Разные компоненты могут спокойно использовать свои собственные `foo` и `bar`, и это не приведёт к столкновению имён.
Только вдумайтесь, насколько серьёзная смена парадигмы здесь происходит.
Теперь можно делать изменения в CSS файлах в полной уверенности, что случайным образом не будут «задеты» посторонние элементы страницы. Так мы ввели адекватную модель построения закрытой области видимости в CSS.
При этом все преимущества, которые были у «глобальных» классов, нам по-прежнему доступны. Разница только в том, что теперь, как и в других областях разработки, требуется явно импортировать нужные классы. Наш код не должен полагаться на глобальные переменные.
> Написание поддерживаемого CSS кода стало возможным не при помощи набора правил по придумыванию названий, а благодаря инкапсуляции стилей на этапе разработки.
При таком раскладе весь контроль над *настоящими* именами класса мы возложили на webpack. А это что-то, что поддаётся полной настройке.
По умолчанию, css-loader переводит наши классы в хэши.
Например, такая запись:
```
:local(.foo) { … }
```
Будет скомпилирована в такую:
```
._1rJwx92-gmbvaLiDdzgXiJ { … }
```
Это не особо удобно во время разработки и отладки. Чтобы генерируемые классы было легче читать, можно задать желаемый формат в конфигурации webpack'а в качестве параметра, передаваемого css-loader'у:
```
loaders: [
...
{
test: /\.css$/,
loader: 'css?localIdentName=[name]__[local]___[hash:base64:5]'
}
]
```
И в таком случае наш класс будет скомпилирован вот так:
```
.MyComponent__foo___1rJwx { … }
```
Теперь сразу видны и идентификатор, и имя компонента, к которому этот код относится.
А при помощи переменной среды *NODE\_ENV* (*environment variable*) мы можем разделить логику компиляции для разработки и продакшена:
```
loader: 'css?localIdentName=' + (
process.env.NODE_ENV === 'development' ?
'[name]__[local]___[hash:base64:5]' :
'[hash:base64:5]'
)
```
> Поскольку управление нашими стилями мы возложили на webpack, добавить минификацию имен классов теперь проще простого.
Если вы уже придерживаетесь какой-либо методики по созданию пространства имён, например, БЭМом, то перевести весь css код на изолированные стили будет простым и логичным действием.
Вскоре можно будет обнаружить, что большинство CSS файлов использует исключительно закрытые идентификаторы:
```
:local(.backdrop) { … }
:local(.root_isCollapsed .backdrop) { … }
:local(.field) { … }
:local(.field):focus { … }
etc.…
```
Потребность же в глобальных классах возникает лишь иногда. Отсюда напрашивается мысль:
> Что если все наши селекторы будут закрытыми по умолчанию, а специальный синтаксис будет использоваться только при желании ввести глобальный селектор?
Что если наш код будет всё-таки выглядеть так:
```
.backdrop { … }
.root_isCollapsed .backdrop { … }
.field { … }
.field:focus { … }
```
В обычной ситуации такие названия были бы слишком общими, но css-loader решает эту проблему и делает так, чтобы они были видны только в пределах области видимости нашего модуля.
А для тех случаев, когда потребности в глобальных классах не избежать, мы можем просто воспользоваться специальным `:global` синтаксисом.
Так, например, будет выглядеть запись, использующая стандартные классы, добавляемые аддоном [ReactCSSTransitionGroup](https://facebook.github.io/react/docs/animation.html#high-level-api-reactcsstransitiongroup):
```
.panel :global .transition-active-enter { … }
```
Этот код создаёт приватный идентификатор `.panel`, который опирается на глобальный класс `.transition-active-enter`
Как только мы задумались о том, как же именно обеспечить такой синтаксис, в котором идентификаторы будут закрытыми по умолчанию, стало понятно, что это не так уж и сложно.
На помощь пришёл [PostCSS](https://github.com/postcss/postcss) — прекрасный инструмент для написания собственных CSS преобразователей в виде плагинов. Например, популярнейший [Autoprefixer](https://github.com/postcss/autoprefixer) — изначально как раз является PostCSS плагином, сейчас используемый многими как самостоятельный инструмент.
*Далее автор оригинальной статьи кратко описывает свою [экспериментальную библиотеку](https://github.com/markdalgleish/postcss-local-scope), осуществляющую задумку. Вот [пример её использования](https://github.com/markdalgleish/postcss-local-scope-example). Идеи автора позже были были приняты сообществом и интегрированы в сам webpack. Технологию назвали **CSS Modules**, которая стала частью css-loader'а. Экспериментальный проект больше не актуален. Итоговый пример использования CSS Modules [здесь](https://github.com/markdalgleish/css-modules-example)*
Изолированные css классы — это только начало.
> Эй, ты починил css, — [tweet](https://twitter.com/ncreen_same/status/598265946642329600?ref_src=twsrc%5Etfw)
Идея передать контроль над названиями классов автоматической системе сборки имеет огромный потенциал. Больше не нужен будет *человек-компилятор*, вручную объединяющий классы в целях оптимизации. Система сборки справится гораздо лучше.
> Общие классы, стилизующие разные компоненты, могут быть сгенерированы автоматически. Подобная оптимизация может стать просто галочкой в настройках компилятора.
Начав использовать закрытый CSS, вы поймете, что обратного пути уже нет. От методики, которая полностью изолирует css классы и работает во *всех* браузерах не так просто отказаться.
Закрытый CSS сильно меняет общепринятые представления о том, как надо организовывать и именовать стили в больших проектах. Мы пока стоим в самом начале пути. Эра закрытого CSS только начинается.
[Попробуйте сами поиграть](https://github.com/css-modules/webpack-demo) с CSS Modules. Как только вы увидите их в действии, уверен, согласитесь, что это не преувеличение — дни глобального CSS подходят к концу. Будущее за *модульностью*.
---
[*Публикация — перевод. Автор статьи [Mark Dalgleish](https://medium.com/@markdalgleish). Ссылка на [оригинальную статью](https://medium.com/seek-ui-engineering/the-end-of-global-css-90d2a4a06284#.rx1co7cd0)*] | https://habr.com/ru/post/276417/ | null | ru | null |
# Action и BindingTarget в ReactiveSwift
Привет, Хабр!
Меня зовут Игорь, я руковожу отделом мобайла в AGIMA. Еще не все перешли с ReactiveSwift/Rxswift на Combine? Тогда сегодня я расскажу про опыт использования таких концептов из ReactiveSwift как `Action` и `BindingTarget` и какие задачи можно решить с их помощью. Сразу отмечу, что для RxSwift эти же концепции существует в виде `RxAction` и `Binder`. В статье рассмотрим, примеры на ReactiveSwift и в конце я покажу, как все то же самое выглядит на RxSwift.
Рассчитываю на то, что вы уже представляете, что такое реактивное программирование и имели опыт с ReactiveSwift или RxSwift.
Представим, что у нас есть страница продукта и кнопка добавления в избранное. Когда мы нажимаем ее, вместо нее начинает крутиться лоадер, и по результатам кнопка становится либо залитой, либо нет. Скорее всего, у нас будет что-то подобное во ViewController (используем MVVM архитектуру).
```
let favoriteButton = UIButton()
let favoriteLoader = UIActivityIndicatorView()
let viewModel: ProductViewModel
func viewDidLoad() {
...
favoriteButton.reactive.image <~ viewModel.isFavorite.map(mapToImage)
favoriteLoader.reactive.isAnimating <~ viewModel.isLoading
// Скрыть кнопку во время выполнения запрос
favoriteButton.reactive.isHidden <~ viewModel.isLoading
favoriteButton.reactive.controlEvents(.touchUpInside)
.take(duringLifetimeOf: self)
.observeValues { [viewModel] _ in
viewModel.toggleFavorite()
}
}
```
И во viewModel:
```
lazy var isFavorite = Property(_isFavorite)
private let _isFavorite: MutableProperty
lazy var isLoading = Property(\_isLoading)
private let \_isLoading: MutableProperty
func toggleFavorite() {
\_isLoading.value = true
service.toggleFavorite(product).startWithResult { [weak self] result in
self.\_isLoading.value = false
switch result {
case .success(let isFav):
self?.isFavorite.value = isFav
case .failure(let error):
// do somtething with error
}
}
}
```
Все бы ничего, но немного смущает количество `MutableProperty` и количество «ручного» управления состоянием, что создает дополнительное пространство для ошибок. Вот тут нам и поможет `Action` . Благодаря ему мы можем сделать наш код более реактивным и избавиться от «лишнего» кода. Запустить `Action` можно 2-мя способами: запустить `SignalProducer` из метода `apply` напрямую и с помощью `BindingTarget`(об этом чуть позже). Рассмотрим первый вариант, теперь код по viewModel будет выглядеть так:
```
let isFavorite: Property
let isLoading: Property
private let toggleAction: Action
init(product: Product, service: FavoritesService = FavoriteServiceImpl()) {
toggleAction = Action {
service.toggleFavorite(productId: product.id)
.map { $0.isFavorite }
}
isFavorite = Property(initial: product.isFavorite, then: toggleAction.values)
isLoading = toggleAction.isExecuting
}
func toggleFavorite() {
favoriteAction.apply().start()
}
```
Лучше? На мой взгляд, да. Теперь давайте разбираться, что такое `Action`
`Action` представляет собой фабрику для `SignalProducer`с возможностью наблюдать за всеми его событиями (для адептов RxSwift: SignalProducer — это холодный сигнал, Signal — горячий). `Action` принимает на вход значение, передает его в в execute блок, который возвращает SignalProducer.
Основной (но не весь!) функционал представлен на листинге ниже.
```
final class Action {
let values: Signal
let errors: Signal
let isExecuting: Property
let isEnabled: Property
var bindingTarget: BindingTarget
func apply(\_ input: Input) -> SignalProducer {...}
init(execute: @escaping (T, Input) -> SignalProducer)
}
```
Зачем все это может понадобиться? `values`представляет собой поток всех значений из `Action` `errors`— все ошибки. `isExecuting`показывает нам, выполняется ли сейчас действие (идеально подходит для лоадеров). Самое ценное тут то, что `values` и `errors` имеют тип ошибки `Never` то есть они никогда не завершатся «аварийно», что позволяет нам безопасно использовать их в реактивных цепочках. `isEnabled`- Action имеет включенные/выключенные состояния, что дает нам защиту от одновременного выполнения. Может быть полезно, когда нам надо защититься от 10 нажатий кнопки подряд. Вообще, управлять «включенностью» Action довольно гибко, но, сказать по правде, так и не пришлось этим пользоваться, поэтому этого в статье не будет :)
**Важный момент 1:** метод `apply`возвращает каждый раз новый `SignalProducer` однако `values` , `errors`, `isExecuting`от этого не зависят и получают события от всех продюсеров, созданных внутри своего `Action`
**Важный момент 2:** `Action`выполняется последовательно. Мы не можем запустить `Action` несколько раз подряд, не дождавшись выполнения предыдущего действия. В этом случае мы получим ошибку, говорящую о том, что `Action` недоступен (справедливо и для RxSwift).
Теперь не обязательно обрабатывать результаты `SignalProducer`, поскольку их мы получаем в сигнале `favoriteAction.values` Если нужно обрабатывать ошибки, для этого можно использовать сигнал `favoriteAction.errors`
Теперь рассмотрим 2-й способ запуска Action с помощью `BindingTarget` Во viewModel нам теперь не нужен метод `toggleFavorite` он трансформируется таким образом в такое:
```
let toggleFavorite: BindingTarget = favoriteAction.bindingTarget
```
Код во вьюконтроллере станет таким
```
viewModel.toggleFavorite <~ button.reactive.controlEvents(.touchUpInside)
```
Выглядит до боли знакомо. Это наш любимый оператор биндинга. Левая его часть и есть `BindingTarget.`
Eсть, правда, один нюанс: иногда нам бы хотелось отменить выполнение SignalProducer, например, мы скачиваем какой-то файл и нажали на кнопку отмены. Обычно, запустив SignalProducer либо подписавшись на Signal мы бы сохранили `Disposable`и вызвали у него метод dispose(). Если мы поставляем input значения через оператор биндинга, то SignalProducer запускается внутри Action и доступа к disposable у нас нет.
Что же такое `BindingTarget`? `BindingTarget` представляет собой структуру, содержащую
блок, который будет вызываться при получении нового значения и так называемый `Lifetime`(объект, отражающий время жизни объекта). Кстати, `Observer`и `MutableProperty`тоже можно использовать как `BindingTarget`.
Получатся довольно элегантно. Вообще, `BindingTarget`— это очень полезная штука для того, чтобы «учить» объекты обрабатывать потоки данных внутри себя и не писать в очередной раз:
```
isLoadingSignal
.take(duringLifetimeOf: self)
.observe { [weak self] isLoading in
isLoading ? self?.showLoadingView() : self?.hideLoadingView()
}
```
а вместо этого писать:
```
self.reactive.isLoading <~ isLoadingSignal
```
Хорошая новость — завершение подписки берет на себя фреймворк, и нам можно об этом не беспокоиться.
Объявление `isLoading`будет выглядеть следующим образом (все существующие биндинги выглядят точно также):
```
extension Reactive where Base: ViewController {
var isLoading: BindingTarget {
makeBindingTarget { (vc, isLoading) in
isLoading ? vc.showLoadingView() : vc.hideLoadingView()
}
}
}
```
Отмечу, что в методе `makeBindingTarget`можно указывать, на каком потоке будет вызываться биндинг. Есть еще вариант с использованиями KeyPath (только на главном потоке):
```
var isLoading = false
...
reactive[\.isLoading] <~ isLoadingSignal
```
Вышеперечисленные способы использования `BindingTarget` доступны только для классов и являются частью `ReactiveCocoa` Вообще, это не все возможности, но, на мой взгляд, в 99% случаев этого будет достаточно.
`Action`выступает отличным помощником для выстраивания «вечных» реактивных цепочек и отлично себя чувствует на ViewModel слое. `BindingTarget` в свою очередь, позволяет инкапсулировать код, отвечающий за биндинг и вместе эти концепции делают код более элегантным, читаемым и надежным, чего все мы пытаемся достичь :)
И обещанный перевод на RxSwift
ViewController:
```
viewModel.isFavorite
.map(mapToImage)
.drive(favoriteButton.rx.image())
.disposed(by: disposeBag)
viewModel.isLoading
.drive(favoriteLoader.rx.isAnimating)
.disposed(by: disposeBag)
viewModel.isLoading
.drive(favoriteButton.rx.isHidden)
.disposed(by: disposeBag)
favoriteButton.rx.tap
.bind(to: viewModel.toggleFavorite)
.disposed(by: disposeBag)
```
ViewModel
```
let isFavorite: Driver
let isLoading: Driver
let toggleFavorite: AnyObserver
private let toggleAction = Action
init(product: Product, service: FavoritesService = FavoriteServiceImpl()) {
toggleAction = Action {
service.toggleFavorite(productId: product.id)
.map { $0.isFavorite }
}
isFavorite = toggleAction.elements.asDriver(onErrorJustReturn: false)
isLoading = toggleAction.executing.asDriver(onErrorJustReturn: false)
toggleFavorite = toggleAction.inputs
}
```
Binder
```
extension Reactive where Base: UIViewController {
var isLoading: Binder {
Binder(self.base) { vc, value in
value ? vc.showLoadingView() : vc.hideLoadingView()
}
}
}
```
Ссылочки:
[Action](https://reactivecocoa.io/reactiveswift/docs/latest/Classes/Action.html)
[RxSwiftCommunity/Action](https://github.com/RxSwiftCommunity/Action) | https://habr.com/ru/post/523222/ | null | ru | null |
# angular-ngrx-data — state management и CRUD за пять минут
На сегодняшний день ни одно большое **SPA** приложение не обходится без **state management (управления состоянием)**. Для [**Angular**](https://angular.io/) по данному направлению есть несколько решений. Самым популярным из них является [**NgRx**](https://github.com/ngrx/platform). Он реализует **Redux** паттерн с использованием библиотеки **RxJs** и обладает хорошим инструментарием.
В данной статье мы кратко пройдемся по основным модулям [**NgRx**](https://github.com/ngrx/platform) и более детально сосредоточимся на библиотеке [**angular-ngrx-data**](https://github.com/johnpapa/angular-ngrx-data), которая позволяет сделать полноценный [**CRUD**](https://ru.wikipedia.org/wiki/CRUD) со **state management** за пять минут.
Обзор NgRx
----------
Детально про **NgRx** можно почитать в следующих статьях:
— [Реактивные приложения на Angular/NGRX. Часть 1. Введение](https://medium.com/@demyanyuk/%D1%80%D0%B5%D0%B0%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%BD%D0%B0-angular-ngrx-%D1%87%D0%B0%D1%81%D1%82%D1%8C-1-cb7b4f2852dc)
— [Реактивные приложения на Angular/NGRX. Часть 2. Store](https://medium.com/@demyanyuk/%D1%80%D0%B5%D0%B0%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%BD%D0%B0-angular-ngrx-%D1%87%D0%B0%D1%81%D1%82%D1%8C-2-1412bc9adf17)
— [Реактивные приложения на Angular/NGRX. Часть 3. Effects](https://medium.com/@demyanyuk/%D1%80%D0%B5%D0%B0%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%BD%D0%B0-angular-ngrx-%D1%87%D0%B0%D1%81%D1%82%D1%8C-3-effects-6f4b34dfa289)
Кратко рассмотрим основные модули [NgRx](https://github.com/ngrx/platform), его плюсы и минусы.
**[NgRx/store](https://github.com/ngrx/platform/blob/master/docs/store/README.md)** — реализует Redux паттерн.
**Простая реализация store**
counter.actions.ts
```
export const INCREMENT = 'INCREMENT';
export const DECREMENT = 'DECREMENT';
export const RESET = 'RESET';
```
counter.reducer.ts
```
import { Action } from '@ngrx/store';
const initialState = 0;
export function counterReducer(state: number = initialState, action: Action) {
switch (action.type) {
case INCREMENT:
return state + 1;
case DECREMENT:
return state - 1;
case RESET:
return 0;
default:
return state;
}
}
```
.
Подключение в модуль
```
import { NgModule } from '@angular/core';
import { StoreModule } from '@ngrx/store';
import { counterReducer } from './counter';
@NgModule({
imports: [StoreModule.forRoot({ count: counterReducer })],
})
export class AppModule {}
```
Использование в компоненте
```
import { Component } from '@angular/core';
import { Store, select } from '@ngrx/store';
import { Observable } from 'rxjs';
import { INCREMENT, DECREMENT, RESET } from './counter';
interface AppState {
count: number;
}
@Component({
selector: 'app-my-counter',
template: `
Increment
Current Count: {{ count$ | async }}
Decrement
Reset Counter
`,
})
export class MyCounterComponent {
count$: Observable;
constructor(private store: Store) {
this.count$ = store.pipe(select('count'));
}
increment() {
this.store.dispatch({ type: INCREMENT });
}
decrement() {
this.store.dispatch({ type: DECREMENT });
}
reset() {
this.store.dispatch({ type: RESET });
}
}
```
**[NgRx/store-devtools](https://github.com/ngrx/platform/blob/master/docs/store-devtools/README.md)** — позволяет отслеживать изменения в приложении через [redux-devtools](https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd).
**Пример подключения**
```
import { StoreDevtoolsModule } from '@ngrx/store-devtools';
@NgModule({
imports: [
StoreModule.forRoot(reducers),
// Модуль должен быть подключен после StoreModule
StoreDevtoolsModule.instrument({
maxAge: 25, // Хранятся последние 25 состояний
}),
],
})
export class AppModule {}
```
**[NgRx/effects](https://github.com/ngrx/platform/blob/master/docs/effects/README.md)** — позволяет добавлять в хранилище данные, приходящие в приложение, такие как http запросы.
**Пример**
./effects/auth.effects.ts
```
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Action } from '@ngrx/store';
import { Actions, Effect, ofType } from '@ngrx/effects';
import { Observable, of } from 'rxjs';
import { catchError, map, mergeMap } from 'rxjs/operators';
@Injectable()
export class AuthEffects {
// Listen for the 'LOGIN' action
@Effect()
login$: Observable = this.actions$.pipe(
ofType('LOGIN'),
mergeMap(action =>
this.http.post('/auth', action.payload).pipe(
// If successful, dispatch success action with result
map(data => ({ type: 'LOGIN\_SUCCESS', payload: data })),
// If request fails, dispatch failed action
catchError(() => of({ type: 'LOGIN\_FAILED' }))
)
)
);
constructor(private http: HttpClient, private actions$: Actions) {}
}
```
Подключение эффекта в модуль
```
import { EffectsModule } from '@ngrx/effects';
import { AuthEffects } from './effects/auth.effects';
@NgModule({
imports: [EffectsModule.forRoot([AuthEffects])],
})
export class AppModule {}
```
**[NgRx/entity](https://github.com/ngrx/platform/blob/master/docs/entity/README.md)** — предоставляет возможность работать с массивами данных.
**Пример**
user.model.ts
```
export interface User {
id: string;
name: string;
}
```
user.actions.ts
```
import { Action } from '@ngrx/store';
import { Update } from '@ngrx/entity';
import { User } from './user.model';
export enum UserActionTypes {
LOAD_USERS = '[User] Load Users',
ADD_USER = '[User] Add User',
UPSERT_USER = '[User] Upsert User',
ADD_USERS = '[User] Add Users',
UPSERT_USERS = '[User] Upsert Users',
UPDATE_USER = '[User] Update User',
UPDATE_USERS = '[User] Update Users',
DELETE_USER = '[User] Delete User',
DELETE_USERS = '[User] Delete Users',
CLEAR_USERS = '[User] Clear Users',
}
export class LoadUsers implements Action {
readonly type = UserActionTypes.LOAD_USERS;
constructor(public payload: { users: User[] }) {}
}
export class AddUser implements Action {
readonly type = UserActionTypes.ADD_USER;
constructor(public payload: { user: User }) {}
}
export class UpsertUser implements Action {
readonly type = UserActionTypes.UPSERT_USER;
constructor(public payload: { user: User }) {}
}
export class AddUsers implements Action {
readonly type = UserActionTypes.ADD_USERS;
constructor(public payload: { users: User[] }) {}
}
export class UpsertUsers implements Action {
readonly type = UserActionTypes.UPSERT_USERS;
constructor(public payload: { users: User[] }) {}
}
export class UpdateUser implements Action {
readonly type = UserActionTypes.UPDATE_USER;
constructor(public payload: { user: Update }) {}
}
export class UpdateUsers implements Action {
readonly type = UserActionTypes.UPDATE\_USERS;
constructor(public payload: { users: Update[] }) {}
}
export class DeleteUser implements Action {
readonly type = UserActionTypes.DELETE\_USER;
constructor(public payload: { id: string }) {}
}
export class DeleteUsers implements Action {
readonly type = UserActionTypes.DELETE\_USERS;
constructor(public payload: { ids: string[] }) {}
}
export class ClearUsers implements Action {
readonly type = UserActionTypes.CLEAR\_USERS;
}
export type UserActionsUnion =
| LoadUsers
| AddUser
| UpsertUser
| AddUsers
| UpsertUsers
| UpdateUser
| UpdateUsers
| DeleteUser
| DeleteUsers
| ClearUsers;
```
user.reducer.ts
```
import { EntityState, EntityAdapter, createEntityAdapter } from '@ngrx/entity';
import { User } from './user.model';
import { UserActionsUnion, UserActionTypes } from './user.actions';
export interface State extends EntityState {
// additional entities state properties
selectedUserId: number | null;
}
export const adapter: EntityAdapter = createEntityAdapter();
export const initialState: State = adapter.getInitialState({
// additional entity state properties
selectedUserId: null,
});
export function reducer(state = initialState, action: UserActionsUnion): State {
switch (action.type) {
case UserActionTypes.ADD\_USER: {
return adapter.addOne(action.payload.user, state);
}
case UserActionTypes.UPSERT\_USER: {
return adapter.upsertOne(action.payload.user, state);
}
case UserActionTypes.ADD\_USERS: {
return adapter.addMany(action.payload.users, state);
}
case UserActionTypes.UPSERT\_USERS: {
return adapter.upsertMany(action.payload.users, state);
}
case UserActionTypes.UPDATE\_USER: {
return adapter.updateOne(action.payload.user, state);
}
case UserActionTypes.UPDATE\_USERS: {
return adapter.updateMany(action.payload.users, state);
}
case UserActionTypes.DELETE\_USER: {
return adapter.removeOne(action.payload.id, state);
}
case UserActionTypes.DELETE\_USERS: {
return adapter.removeMany(action.payload.ids, state);
}
case UserActionTypes.LOAD\_USERS: {
return adapter.addAll(action.payload.users, state);
}
case UserActionTypes.CLEAR\_USERS: {
return adapter.removeAll({ ...state, selectedUserId: null });
}
default: {
return state;
}
}
}
export const getSelectedUserId = (state: State) => state.selectedUserId;
// get the selectors
const { selectIds, selectEntities, selectAll, selectTotal } = adapter.getSelectors();
// select the array of user ids
export const selectUserIds = selectIds;
// select the dictionary of user entities
export const selectUserEntities = selectEntities;
// select the array of users
export const selectAllUsers = selectAll;
// select the total user count
export const selectUserTotal = selectTotal;
```
reducers/index.ts
```
import {
createSelector,
createFeatureSelector,
ActionReducerMap,
} from '@ngrx/store';
import * as fromUser from './user.reducer';
export interface State {
users: fromUser.State;
}
export const reducers: ActionReducerMap = {
users: fromUser.reducer,
};
export const selectUserState = createFeatureSelector('users');
export const selectUserIds = createSelector(
selectUserState,
fromUser.selectUserIds
);
export const selectUserEntities = createSelector(
selectUserState,
fromUser.selectUserEntities
);
export const selectAllUsers = createSelector(
selectUserState,
fromUser.selectAllUsers
);
export const selectUserTotal = createSelector(
selectUserState,
fromUser.selectUserTotal
);
export const selectCurrentUserId = createSelector(
selectUserState,
fromUser.getSelectedUserId
);
export const selectCurrentUser = createSelector(
selectUserEntities,
selectCurrentUserId,
(userEntities, userId) => userEntities[userId]
);
```
Что в итоге?
------------
Мы получаем полноценный **state management** с кучей плюсов:
— единый источник данных для приложения,
— состояние хранится отдельно от приложения,
— единый стиль написания для всех разработчиков в проекте,
— **changeDetectionStrategy.OnPush** во всех компонентах приложения,
— удобная отладка через **redux-devtools**,
— легкость тестирования, т.к. **reducers** являются “чистыми” функциями.
**Но есть и минусы:**
— большое количество непонятных на первый взгляд модулей,
— много однотипного кода, на который без грусти не взглянешь,
— сложность в освоении из-за всего выше перечисленного.
CRUD
----
Как правило, значительную часть приложения занимает работа с объектами (создание, чтение, обновление, удаление), поэтому для удобства работы была придумана концепция **CRUD** (Create, Read, Update, Delete). Таким образом, базовые операции для работы со всеми типами объектов стандартизированы. На бэкенде это уже давно процветает. Многие библиотеки помогают реализовать данную функциональность и избавиться от рутинной работы.
В [NgRx](https://github.com/ngrx/platform) за **CRUD** отвечает модуль [entity](https://github.com/ngrx/platform/blob/master/docs/entity/README.md), и если посмотреть пример его реализации, сразу видно, что это самая большая и наиболее сложная часть [NgRx](https://github.com/ngrx/platform). Именно поэтому [John Papa](http://twitter.com/John_Papa) и [Ward Bell](http://twitter.com/wardbell) создали **angular-ngrx-data**.
angular-ngrx-data
-----------------
**[angular-ngrx-data](https://github.com/johnpapa/angular-ngrx-data)** — это библиотека-надстройка над [NgRx](https://github.com/ngrx/platform), которая позволяет работать с массивами данных без написания лишнего кода.
Помимо создания полноценного **state management**, она берет на себя создание сервисов с **http** для взаимодействия с сервером.
Рассмотрим на примере
---------------------
**Установка**
```
npm install --save @ngrx/store @ngrx/effects @ngrx/entity @ngrx/store-devtools ngrx-data
```
**Модуль angular-ngrx-data**
```
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import {
EntityMetadataMap,
NgrxDataModule,
DefaultDataServiceConfig
} from 'ngrx-data';
const defaultDataServiceConfig: DefaultDataServiceConfig = {
root: 'crud'
};
export const entityMetadata: EntityMetadataMap = {
Hero: {},
User:{}
};
export const pluralNames = { Hero: 'heroes' };
@NgModule({
imports: [
CommonModule,
NgrxDataModule.forRoot({ entityMetadata, pluralNames })
],
declarations: [],
providers: [
{ provide: DefaultDataServiceConfig, useValue: defaultDataServiceConfig }
]
})
export class EntityStoreModule {}
```
**Подключение в приложение**
```
@NgModule({
imports: [
BrowserModule,
HttpClientModule,
StoreModule.forRoot({}),
EffectsModule.forRoot([]),
EntityStoreModule,
StoreDevtoolsModule.instrument({
maxAge: 25,
}),
],
declarations: [
AppComponent
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule {}
```
*Только что мы получили сгенерированное **API** для работы с бэком и интеграцию **API** с **NgRx**, **не написав при этом ни одного effect, reducer и action и selector.***
Разберем более подробно то, что тут происходит
----------------------------------------------
Константа **defaultDataServiceConfig** задает конфигурацию для нашего API и подключается в **providers** модуля. Свойство **root** указывает, куда обращаться за запросами. Если его не задать, то по умолчанию будет «api».
```
const defaultDataServiceConfig: DefaultDataServiceConfig = {
root: 'crud'
};
```
Константа **entityMetadata** определяет названия сторов, которые будут созданы при подключении **NgrxDataModule.forRoot**.
```
export const entityMetadata: EntityMetadataMap = {
Hero: {},
User:{}
};
...
NgrxDataModule.forRoot({ entityMetadata, pluralNames })
```
Путь к API состоит из базового пути (в нашем случае «crud») и имени стора.
Например, для получения пользователя с определенным номером путь будет такой — «crud/user/{userId}».
Для получения полного списка пользователелей в конце имени стора по умолчанию добавляется буква «s» — «crud/user**s**».
Если для получения полного списка нужен другой роут (например, «heroes», а не «heros»), его можно изменить, задав **pluralNames** и подключив их в **NgrxDataModule.forRoot**.
```
export const pluralNames = { Hero: 'heroes' };
...
NgrxDataModule.forRoot({ entityMetadata, pluralNames })
```
Подключение в компоненте
------------------------
Для подключения в компоненте необходимо передать в конструктор **entityServices** и через метод **getEntityCollectionService** выбрать сервис нужного хранилища
```
import { Component, OnInit, ChangeDetectionStrategy } from '@angular/core';
import { Observable } from 'rxjs';
import { Hero } from '@appModels/hero';
import { EntityServices, EntityCollectionService } from 'ngrx-data';
@Component({
selector: 'app-heroes',
templateUrl: './heroes.component.html',
styleUrls: ['./heroes.component.css'],
changeDetection: ChangeDetectionStrategy.OnPush
})
export class HeroesComponent implements OnInit {
heroes$: Observable;
heroesService: EntityCollectionService;
constructor(entityServices: EntityServices) {
this.heroesService = entityServices.getEntityCollectionService('Hero');
}
...
}
```
Для привязки списка к компоненту достаточно взять из сервиса свойство **entities$**, а для получения данных с сервера вызвать метод **getAll()**.
```
ngOnInit() {
this.heroes$ = this.heroesService.entities$;
this.heroesService.getAll();
}
```
Также, помимо основных данных, можно получить:
— **loaded$**, **loading$** — получение статуса загрузки данных,
— **errors$** — ошибки при работе сервиса,
— **count$** — общее колличество записей в хранилище.
Основные методы взаимодействия с сервером:
— **getAll()** — получение всего списка данных,
— **getWithQuery(query)** — получение списка, отфильтрованного с помощью query-параметров,
— **getByKey(id)** — получение одной записи по идентификатору,
— **add(entity)** — добавление новой сущности с запросом на бэк,
— **delete(entity)** — удаление сущности с запросом на бэк,
— **update(entity)** — обновление сущности с запросом на бэк.
Методы локальной работы с хранилищем:
— **addManyToCache(entity)** — добавление массива новых сущностей в хранилище,
— **addOneToCache(entity)** — добавление новой сущности только в хранилище,
— **removeOneFromCache(id)** — удаление одной сущности из хранилища,
— **updateOneInCache(entity)** — обновление сущности в хранилище,
— **upsertOneInCache(entity)** — если сущность с указанным id существует, она обновляется, если нет — создается новая,
— и др.
**Пример использования в компоненте**
```
import { EntityCollectionService, EntityServices } from 'ngrx-data';
import { Hero } from '../../core';
@Component({
selector: 'app-heroes',
templateUrl: './heroes.component.html',
changeDetection: ChangeDetectionStrategy.OnPush
})
export class HeroesComponent implements OnInit {
heroes$: Observable;
heroesService: EntityCollectionService;
constructor(entityServices: EntityServices) {
this.heroesService = entityServices.getEntityCollectionService('Hero');
}
ngOnInit() {
this.heroes$ = this.heroesService.entities$;
this.getHeroes();
}
getHeroes() {
this.heroesService.getAll();
}
addHero(hero: Hero) {
this.heroesService.add(hero);
}
deleteHero(hero: Hero) {
this.heroesService.delete(hero.id);
}
updateHero(hero: Hero) {
this.heroesService.update(hero);
}
}
```
Все методы **angular-ngrx-data** делятся на работающие локально и взаимодействующие с сервером. Это позволяет использовать библиотеку при манипуляциях с данными как на клиенте, так и с использованием сервера.
Логирование
-----------
Для логирования необходимо заинжектить [EntityServices](https://github.com/johnpapa/angular-ngrx-data/blob/master/docs/entity-services.md) в компонент или сервис и использовать свойства:
— **reducedActions$** — для логирования действий,
— **entityActionErrors$** — для логирования ошибок.
```
import { Component, OnInit } from '@angular/core';
import { MessageService } from '@appServices/message.service';
import { EntityServices } from 'ngrx-data';
@Component({
selector: 'app-messages',
templateUrl: './messages.component.html',
styleUrls: ['./messages.component.css']
})
export class MessagesComponent implements OnInit {
constructor(
public messageService: MessageService,
private entityServices: EntityServices
) {}
ngOnInit() {
this.entityServices.reducedActions$.subscribe(res => {
if (res && res.type) {
this.messageService.add(res.type);
}
});
}
}
```
Переезд в основной репозиторий NgRx
-----------------------------------
Как было объявлено на [ng-conf 2018](https://nitayneeman.com/posts/all-talks-from-ng-conf-2018/), **angular-ngrx-data** в ближайшее время будет перенесен в основной репозиторий **NgRx**.
**Видео с докладом Reducing the Boilerplate with NgRx - Brandon Roberts & Mike Ryan**
Ссылки
------
**Создатели anguar-ngrx-data:**
— John Papa [twitter.com/John\_Papa](https://twitter.com/John_Papa)
— Ward Bell [twitter.com/wardbell](https://twitter.com/wardbell)
**Оффициальные репозитории:**
— [NgRx](https://github.com/ngrx/platform)
— [angular-ngrx-data](https://github.com/johnpapa/angular-ngrx-data)
**Пример приложения:**
— [с NgRx без angular-ngrx-data](https://github.com/Angular-RU/angular-ngrx-starter)
— [c NgRx и angular-ngrx-data](https://github.com/Angular-RU/angular-ngrx-starter/tree/ngrx-data)
[**Русскоговорящее Angular сообщество в Telegram**](https://t.me/angular_ru) | https://habr.com/ru/post/418369/ | null | ru | null |
# Книга «Командная строка Linux. Полное руководство. 2-е межд. изд.»
[](https://habr.com/ru/company/piter/blog/465899/) Привет, Хаброжители! Международный бестселлер «Командная строка Linux» поможет преодолеть путь от первых робких щелчков по клавишам до уверенного создания полноценных программ для последней версии bash — наиболее популярной командной оболочки Linux. Второе издание рассказывает о новых возможностях bash 4.x, таких как новые операторы перенаправления и операции подстановки. Вы освоите неустаревающие навыки владения командной строкой: навигацию по файловой системе, настройку окружения, объединение команд в цепочки и сопоставление с регулярными выражениями. Вы постигнете философию, лежащую в основе многих инструментов командной строки, разберетесь с богатым наследием, полученным от суперкомпьютеров с Unix, и приобщитесь к знаниям, накопленным поколениями гуру, исключивших мышь из своего арсенала инструментов. Преодолев первый «шок командной оболочки», вы поймете, насколько естественным и логичным является этот способ взаимодействия с компьютером.
Отрывок. Глава 25. Начало проекта
---------------------------------
В этой главе мы приступаем к созданию программы. Цель данного проекта — показать, как можно использовать разные возможности командной оболочки для создания программ и, что особенно важно, для создания *хороших* программ.
Далее мы напишем *генератор отчетов*. Он будет выводить разнообразную информацию о системе и ее состоянии в формате HTML, благодаря чему ее можно будет просматривать в веб-браузере.
Обычно создание программ выполняется в несколько этапов, на каждом из которых добавляются новые функции и возможности. По окончании первого этапа наша программа будет воспроизводить минимальную HTML-страницу без какой-либо информации. Эту информацию мы добавим на следующих этапах.
### Этап первый: минимальный документ
Прежде всего, определим, как выглядит формат правильно сформированного HTML-документа. Он имеет следующий вид:
```
Заголовок страницы
Тело страницы.
```
Если ввести этот текст в текстовом редакторе и сохранить в файле с именем *foo.html*, мы сможем открыть его, введя следующий адрес URL в Firefox: *file:///home/username/foo.html*.
На первом этапе создадим программу, которая будет выводить эту разметку HTML в стандартный вывод. Написать такую программу очень просто. Откройте текстовый редактор и создайте файл с именем ~/bin/sys\_info\_page:
```
[me@linuxbox ~]$ vim ~/bin/sys_info_page
```
А затем введите следующую программу:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
echo ""
echo " "
echo " Page Title"
echo " "
echo " "
echo " Page body."
echo " "
echo ""
```
Наша первая версия содержит строку-шебанг (shebang), комментарий (можно только приветствовать) и последовательность команд echo, по одной для вывода каждой строки. После сохранения файла сделайте его выполняемым и попробуйте запустить:
```
[me@linuxbox ~]$ chmod 755 ~/bin/sys_info_page
[me@linuxbox ~]$ sys_info_page
```
После запуска на экране должен появиться текст HTML-документа, потому что команды echo в сценарии посылают свои строки в стандартный вывод. Запустите программу снова и перенаправьте вывод программы в файл *sys\_info\_page.html*, чтобы затем посмотреть результат в веб-браузере:
```
[me@linuxbox ~]$ sys_info_page > sys_info_page.html
[me@linuxbox ~]$ firefox sys_info_page.html
```
Пока все идет неплохо.
Разрабатывая программы, всегда следует помнить о простоте и ясности. Сопровождение дается проще, когда программа легко читается и доступна для понимания, не говоря уже о том, что программу легче писать, когда есть возможность уменьшить объем ручного ввода. Текущая версия программы работает замечательно, но ее можно упростить. Если объединить все команды echo в одну, это определенно упростит в будущем добавление новых строк в вывод программы. Поэтому изменим программу, как показано ниже:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
echo "
Page Title
Page body.
"
```
Строки в кавычках могут включать символы перевода строки и, соответственно, содержать несколько строк текста. Командная оболочка будет продолжать читать текст, пока не встретит закрывающую кавычку. Это правило действует также в командной строке:
```
[me@linuxbox ~]$ echo "
>
> Page Title
>
>
> Page body.
>
> "
```
Символ > в начале каждой строки — это приглашение к вводу командной оболочки, определяемое ее переменной PS2. Оно появляется всякий раз, когда происходит ввод многострочной инструкции. Эта особенность пока малопонятна, но потом, когда мы познакомимся с многострочными программными инструкциями, ее преимущества станут очевидными.
### Этап второй: добавление некоторых данных
Теперь, когда программа способна сгенерировать минимальный документ, добавим в отчет немного данных. Для этого внесите следующие изменения:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
echo "
System Information Report
System Information Report
=========================
"
```
Здесь добавлено название страницы и заголовок в теле отчета.
### Переменные и константы
В нашем сценарии возникла проблема. Обратили внимание, что строка System Information Report повторяется дважды? Вообще, для такого крохотного сценария это не такая большая проблема, но представьте по-настоящему длинный сценарий, в котором эта строка повторяется много раз. Если в таком сценарии понадобится изменить название, придется внести изменения во множестве мест, а это масса ручной работы. Можно ли изменить сценарий так, чтобы строка определялась в нем только один раз? Это существенно упростило бы сопровождение сценария в будущем. Да, это возможно, например, так:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
title="System Information Report"
echo "
$title
$title
======
"
```
Создав *переменную* с именем title и присвоив ей значение System Information Report, мы воспользовались преимуществами подстановки параметров и поместили строку во множество мест.
Но как создать переменную? Просто — достаточно использовать ее. Когда командная оболочка встречает переменную, она автоматически создает ее. Этим она отличается от многих языков программирования, в которых переменные должны явно объявляться или определяться до ее использования. Командная оболочка слишком либеральна в этом отношении, что в итоге приводит к некоторым проблемам. Например, рассмотрим следующий сценарий, выполненный в командной строке:
```
[me@linuxbox ~]$ foo="yes"
[me@linuxbox ~]$ echo $foo
yes
[me@linuxbox ~]$ echo $fool
[me@linuxbox ~]$
```
Мы сначала присвоили значение yes переменной foo и затем вывели ее значение командой echo. Далее, мы попробовали вновь вывести значение переменной, но допустили опечатку, указав имя fool, и получили пустую строку. Такой результат объясняется тем, что командная оболочка благополучно создала переменную fool, встретив ее, и присвоила ей пустое значение по умолчанию. Из этого примера следует, что нужно внимательно следить за правописанием! Также важно понять, что в действительности произошло в этом примере. Из предыдущего знакомства с особенностями работы механизма подстановки мы знаем, что команда
```
[me@linuxbox ~]$ echo $foo
```
подвергается действию механизма подстановки параметров, в результате чего приобретает вид
```
[me@linuxbox ~]$ echo yes
```
С другой стороны, команда
```
[me@linuxbox ~]$ echo $fool
```
превращается в
```
[me@linuxbox ~]$ echo
```
На место пустой переменной ничего не подставляется! Это может вызвать ошибку в командах, требующих наличия аргументов. Например:
```
[me@linuxbox ~]$ foo=foo.txt
[me@linuxbox ~]$ foo1=foo1.txt
[me@linuxbox ~]$ cp $foo $fool
cp: после 'foo.txt' пропущен операнд, задающий целевой файл
По команде "cp --help" можно получить дополнительную информацию.
```
Мы присвоили значения двум переменным, foo и foo1. А затем попытались выполнить команду cp, но допустили опечатку в имени второго аргумента. После обработки механизмом подстановки команда cp получила только один аргумент, хотя требует двух.
Ниже приводятся несколько правил именования переменных:
* Имена переменных могут состоять из алфавитно-цифровых символов (букв и цифр) и символов подчеркивания.
* Первый символ в имени переменной может быть только буквой или символом подчеркивания.
* Присутствие пробелов и знаков препинания в именах переменных не допускается.
Название *переменная* подразумевает значение, которое может изменяться, и во многих приложениях переменные именно так и используются. Однако переменная title в нашем приложении используется как *константа*. Константа, так же как переменная, имеет имя и содержит значение. Отличие лишь в том, что значение константы не изменяется. В приложении, осуществляющем геометрические расчеты, можно определить константу PI со значением 3.1415, вместо того, чтобы использовать это число по всей программе. Командная оболочка не различает константы и переменные; эти термины используются в основном для удобства программиста. Типичное соглашение — использовать буквы верхнего регистра для обозначения констант и буквы нижнего регистра для истинных переменных. Давайте изменим сценарий, приведя его в соответствие с этим соглашением:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
TITLE="System Information Report For $HOSTNAME"
echo "
$TITLE
$TITLE
======
"
```
Попутно мы дополнили название, добавив в конец значение переменной командной оболочки HOSTNAME. Это — сетевое имя машины.
> #### ПРИМЕЧАНИЕ
>
>
>
> В действительности командная оболочка имеет механизм, гарантирующий неизменяемость констант, в виде встроенной команды declare с параметром -r (read-only — только для чтения). Если переменной TITLE присвоить значение, как показано ниже:
>
>
>
>
> ```
> declare -r TITLE="Page Title"
> ```
>
>
> командная оболочка не допустит повторного присваивания значения переменной TITLE. Этот механизм редко используется на практике, но он имеется и его можно применять в особенно строгих сценариях.
### Присваивание значений переменным и константам
Мы подошли к моменту, когда наше знание особенностей работы механизма подстановки начинает приносить свои плоды. Как мы видели, присваивание значений переменным производится так:
```
переменная=значение
```
где *переменная* — это имя переменной, а *значение* — строка. В отличие от некоторых других языков программирования, командная оболочка не заботится о типах значений, присваиваемых переменным; она все значения интерпретирует как строки. Существует возможность заставить командную оболочку ограничить круг присваиваемых значений целыми числами, задействовав команду declare с параметром -i, но, как и объявление переменных, доступных только для чтения, эта возможность редко используется на практике.
Обратите внимание на отсутствие пробелов в операторе присваивания между именем переменной, знаком «равно» и значением. А из чего может состоять значение? Из всего что угодно, что можно развернуть в строку.
```
a=z # Присвоит переменной a строку "z".
b="a string" # Внутренние пробелы должны находиться в кавычках.
c="a string and $b" # При присваивании допускается выполнять подстановку,
# например, значений других переменных.
d=$(ls -l foo.txt) # Результат выполнения команды.
e=$((5 * 7)) # Подстановка результата арифметического выражения.
f="\t\ta string\n" # Экранированные последовательности, такие как
# символы табуляции и перевода строки.
```
В одной строке можно выполнить присваивание сразу нескольким переменным:
```
a=5 b="a string"
```
При использовании подстановки имена переменных можно заключать в необязательные фигурные скобки {}. Это пригодится в том случае, когда имя переменной становится неоднозначным в окружающем контексте. В следующем примере выполняется попытка переименовать файл *myfile* в *myfile1* с использованием переменной:
```
[me@linuxbox ~]$ filename="myfile"
[me@linuxbox ~]$ touch $filename
[me@linuxbox ~]$ mv $filename $filename1
mv: после 'myfile' пропущен операнд, задающий целевой файл
По команде "mv --help" можно получить дополнительную информацию.
```
Эта попытка не увенчалась успехом, потому что командная оболочка интерпретировала второй аргумент команды mv как имя новой (и пустой) переменной. Ниже показано, как решается подобная проблема:
```
[me@linuxbox ~]$ mv $filename ${filename}1
```
Добавив фигурные скобки, мы гарантировали, что командная оболочка не будет интерпретировать последний символ 1 как часть имени переменной.
> #### Примечание
>
>
>
> Выполняя подстановку, имена переменных и команды рекомендуется заключать в двойные кавычки, чтобы исключить разбиение строк на слова оболочкой. Особенно важно использовать кавычки, когда переменная может содержать имя файла.
Воспользуемся этой возможностью, чтобы добавить в отчет дополнительные данные, а именно дату и время составления отчета, а также имя пользователя, составившего отчет:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
TITLE="System Information Report For $HOSTNAME"
CURRENT_TIME=$(date +"%x %r %Z")
TIME_STAMP="Generated $CURRENT_TIME, by $USER"
echo "
$TITLE
$TITLE
======
$TIME\_STAMP
"
```
### Встроенные документы
Мы рассмотрели два разных метода вывода текста, и оба используют команду echo. Однако существует еще один, третий метод, который называется *встроенным документом* (here document), или *встроенным сценарием* (here script). Встроенный документ — это дополнительная форма перенаправления ввода/вывода, которая передает текст, встроенный в сценарий, на стандартный ввод команды. Действует это перенаправление так:
```
команда << индикатор
текст
индикатор
```
где *команда* — это имя команды, принимающей указанный текст через стандартный ввод, а *индикатор* — это строка, отмечающая конец встроенного текста. Изменим сценарий, задействовав в нем встроенный документ:
```
#!/bin/bash
# Программа вывода страницы с информацией о системе
TITLE="System Information Report For $HOSTNAME"
CURRENT_TIME=$(date +"%x %r %Z")
TIME_STAMP="Generated $CURRENT_TIME, by $USER"
cat << _EOF_
$TITLE
$TITLE
======
$TIME\_STAMP
_EOF_
```
Теперь вместо команды echo в сценарии используются команда cat и встроенный документ. На роль индикатора была выбрана строка \_EOF\_ (означает *end-of-file* — *конец файла*, распространенное соглашение), и она отмечает конец встроенного текста. Обратите внимание, что строка-индикатор должна находиться в отдельной строке, одна, и за ней не должно следовать никаких пробелов.
Но какие преимущества дало использование встроенного документа здесь? Практически никаких, кроме того, что кавычки внутри встроенных документов теряют свое специальное значение для командной оболочки. Ниже приводится пример использования встроенного документа в командной строке:
```
[me@linuxbox ~]$ foo="some text"
[me@linuxbox ~]$ cat << _EOF_
> $foo
> "$foo"
> '$foo'
> \$foo
> _EOF_
some text
"some text"
'some text'
$foo
```
Как видите, командная оболочка не обращает никакого внимания на кавычки. Она интерпретирует их как обычные символы. Благодаря этому мы свободно вставляем кавычки во встроенные документы. Этим обстоятельством можно воспользоваться при разработке программ составления отчетов.
Встроенные документы можно использовать с любыми командами, принимающими данные со стандартного ввода. В следующем примере встроенный документ используется для передачи последовательности команд программе ftp, чтобы загрузить файл с удаленного FTP-сервера:
```
#!/bin/bash
# Сценарий загрузки файла через FTP
FTP_SERVER=ftp.nl.debian.org
FTP_PATH=/debian/dists/stretch/main/installer-amd64/current/images/cdrom
REMOTE_FILE=debian-cd_info.tar.gz
ftp -n << _EOF_
open $FTP_SERVER
user anonymous me@linuxbox
cd $FTP_PATH
hash
get $REMOTE_FILE
bye
_EOF_
ls -l $REMOTE_FILE
```
Если заменить оператор перенаправления << на <<-, командная оболочка будет игнорировать начальные символы табуляции во встроенном документе. Благодаря этому во встроенный документ можно добавить отступы для большей удобочитаемости:
```
#!/bin/bash
# Сценарий загрузки файла через FTP
FTP_SERVER=ftp.nl.debian.org
FTP_PATH=/debian/dists/stretch/main/installer-amd64/current/images/cdrom
REMOTE_FILE=debian-cd_info.tar.gz
ftp -n <<- _EOF_
open $FTP_SERVER
user anonymous me@linuxbox
cd $FTP_PATH
hash
get $REMOTE_FILE
bye
_EOF_
ls -l $REMOTE_FILE
```
Однако пользоваться этой особенностью не всегда удобно, потому что для оформления отступов многие текстовые редакторы (и сами программисты) предпочитают использовать символы пробела вместо символов табуляции.
### Заключение
В этой главе мы приступили к разработке проекта, при помощи которого пройдем через все этапы создания сценария. Мы познакомились с переменными и константами и особенностями их использования. Они чаще других программных компонентов применяются для подстановки. Мы также увидели, как организовать вывод информации в сценарии, и познакомились с разными методами встраивания блоков текста.
### Об авторе
*Уильям Шоттс* (William Shotts) — профессиональный разработчик программного обеспечения с более чем 30-летним стажем, который уже больше 20 лет активно пользуется операционной системой Linux. Имеет богатый опыт разработки программного обеспечения, технической поддержки, контроля качества и написания документации. Также является создателем LinuxCommand.org, образовательного и информационно-просветительского сайта, посвященного Linux, где публикуются новости, обзоры и оказывается поддержка пользующимся командной строкой Linux.
### О научном редакторе
*Жорди Гутьеррес Эрмосо* (Jordi Gutiérrez Hermoso) — программист, математик и сторонник этичного хакерства. С 2002 года пользуется исключительно Debian GNU/Linux не только дома, но и на работе. Жорди участвует в разработке GNU Octave, бесплатной вычислительной среды, во многом совместимой с Matlab, а также Mercurial, распределенной системы управления версиями. Увлекается чистой и прикладной математикой, катанием на коньках, плаванием и вязанием. В последнее время много думает о проблемах выброса парниковых газов и участвует в акциях по спасению носорогов.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/all/product/komandnaya-stroka-linux-polnoe-rukovodstvo-2-e-mezhd-izd)
» [Оглавление](https://storage.piter.com/upload/contents/978544611430/978544611430_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611430/978544611430_p.pdf)
Для Хаброжителей скидка 25% по купону — **Linux**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга. | https://habr.com/ru/post/465899/ | null | ru | null |
# Играем в Haskell
Я замечательно провел время изучая Haskell в последние месяцы, и мне кажется, что сделать первые шаги в этом занятии сложнее, чем это могло бы быть на самом деле. Мне повезло работать в нужное время и в нужном месте, и в Facebook я прошел курс по Haskell от [Bryan O'Sullivan](http://www.serpentine.com/), но Вы определенно сможете влиться в тему и без чужой помощи. Для этого можно поиграть в Haskell на сайте [Try Haskell](http://tryhaskell.org/), а в конечном счете установить себе GHC.
#### Устанавливаем Haskell Platform (GHC)
The Haskell Platform — это Glasgow Haskell Compiler (GHC) и стандартная библиотека «в полной комплектации». GHC не единственный компилятор Хаскеля, но Вам нужен именно он. Другая реализация, достойная внимания, [Hugs](http://www.haskell.org/hugs/), подходит больше в академических целях, чем в практических.
Инструкция написана для пользователей Mac OS X 10.8 с установленным [Homebrew](http://mxcl.github.com/homebrew/) (и свежей версией Xcode), но разобраться с тем, как сделать то же самое на других платформах с помощью [Haskell Platform](http://www.haskell.org/platform/) должно быть просто. Текущая версия Haskell Platform на данный момент 2012.4.0.0.
```
$ brew install haskell-platform
```
#### Устанавливаем Cabal
[Cabal](http://www.haskell.org/cabal/) — это Общая Архитектура Сборки Приложений и Библиотек (*Common Architecture for Building Applications and Libraries*) для Хаскеля. В паре с [Hackage](http://hackage.haskell.org/), Cabal похож по смыслу на такие инструменты, как CPAN для Perl, pip для Python или же gem для Ruby. Вероятно, Вы будете разочарованы, но всё же он не так уж и плох.
Cabal устанавливает свои пакеты в `~/.cabal/`, а скрипты уходят в `~/.cabal/bin/`. Вам нужно добавить эти пути в переменную окружения PATH. Достаточно чего-то подобного, но все зависит от Ваших предпочтений (лично я для этих целей пользую `~/.profile` — прим. переводчика):
```
$ echo 'export PATH=$HOME/.cabal/bin:$PATH' >> ~/.bashrc
```
Прежде чем начать пользоваться cabal, нужно развернуть список доступных пакетов. Иногда Вам придется запускать эту команду, в частности перед установкой или обновлением пакетов.
```
$ cabal update
```
На данный момент мы имеем `~/.cabal/config` без включенного профилирования библиотек. Вы наверняка позже захотите им воспользоваться, и если не включить его сейчас, то в будущем придется все пересобирать заново. Чтобы включить его, измените строчку `-- library-profiling: False` на `library-profiling: True` в файле `~/.cabal/config`.
```
$ for f in ~/.cabal/config; do \
cp $f $f.old && \
sed -E 's/(-- )?(library-profiling: )False/\2True/' < $f.old > $f; \
done
```
Самым первым Вашим пакетом должен стать инсталлятор Cabal:
```
$ cabal install cabal-install
```
#### Устанавливаем ghc-mod (улучшенная поддержка Emacs/Vim)
[ghc-mod](http://www.mew.org/~kazu/proj/ghc-mod/en/) пригодится Вам для интеграции GHC с Emacs или Vim. Того же самого эффекта можно достичь в Sublime Text 2 и ghc-mod с помощью [SublimeHaskell](https://github.com/SublimeHaskell/SublimeHaskell). Я пока что пользовался только интеграцией с Emacs. Пользователи Vim могут воспользоваться [hdevtools](https://github.com/bitc/hdevtools), т.к. он гораздо быстрее, и настолько же точен (см. [комментарий kamatsu](http://www.reddit.com/r/haskell/comments/16fegr/getting_started_with_haskell/c7viysx))
```
$ cabal install ghc-mod
```
Настройку Вашего собственного Emacs я освещать не стану (но можете воспользоваться моим текущим [~/.emacs.d](https://github.com/etrepum/emacs.d) для примера).
#### Устанавливаем Cabal-dev (песочница для сборки)
[Cabal-dev](https://github.com/creswick/cabal-dev) — это инструмент, который упростит Вам установку приложений на Хаскеле. Он похож на virtualenv для Python и rvm для Ruby, но подход к использованию различается. Он спасет Вас от «кабальского ада», в котором ни у кого не получается устанавливать одни пакеты из-за конфликтов с зависимостями других.
Используйте `cabal-dev` вместо простого `cabal` для сборки везде, где это возможно. Главный компромисс состоит в том, что Вам придется тратить (гораздо) больше времени на компиляцию пакетов, которые уже и так были установлены где-то в другом месте (и забивать дисковое пространство), но это безусловно справедливая плата.
Нормальная установка cabal-dev должна выглядеть как `cabal install cabal-dev`, но пока никто не закрыл [баг #74](https://github.com/creswick/cabal-dev/issues/74), Вам придется собирать и устанавливать его из исходников:
```
$ git clone https://github.com/creswick/cabal-dev.git /tmp/cabal-dev-src && \
(cd /tmp/cabal-dev-src; cabal install) && \
rm -rf /tmp/cabal-dev-src
```
В данный момент ведутся некоторые работы над влючением поддержки [Сборок в Песочнице и Изолированных Окружений](http://hackage.haskell.org/trac/hackage/wiki/SandboxedBuildsAndIsolatedEnvironments) в cabal-install, так что информация о cabal-dev, которая есть в этом посте, потеряет актуальность через несколько месяцев (лет?).
#### Установка инструментов при помощи cabal-dev
Если Вам хочется попробовать какой-нибудь инструмент, но желание загрязнять свою инсталляцию Хаскеля отсутствует, в таком случае нужно просто использовать cabal-dev. По умолчанию, песочница cabal-dev находится в `./cabal-dev`, но Вы можете держать ее где угодно. В этом примере я установлю [darcs](http://darcs.net/) 2.8.2 (распределенная система контроля версий, написанная на Хаскеле) в папку `/usr/local/Cellar/darcs/2.8.2`, и попрошу Homebrew сделать для меня симлинки. На других платформах Вам скорее всего придется использовать собственную структуру директорий, а также вручную редактировать PATH.
```
$ cabal-dev install -s /usr/local/Cellar/darcs/2.8.2 darcs-2.8.2
$ brew link --overwrite darcs
```
Тыдыж! Теперь darcs лежит в Вашем PATH, и больше не придется беспокоиться о конфликтующих версиях. Ну, к сожалению, конфликты все еще будут происходить, но теперь не так часто. В частности, cabal-dev устанавливает пакеты таким образом, что они выходят на самую верхушку выбранной песочницы. Это значит, что если два пакета обладают общими зависимостями (ОЧЕНЬ общими), то они спляшут джигу на симлинках друг друга, вплоть до таких вещей как файлы лицензионных соглашений и документации зависимостей. В таком случае использовать `--overwrite` можно почти безболезненно, но я рекомендую сначала прогонять с ключом `--overwrite --dry-run`. Это надоедает, но наверняка не испортит Вам целый день.
Если хочется увидеть доступные версии darcs, используйте `use cabal info darcs` и найдите секцию `Versions available:`.
Остальные веселые штуки, с которыми можно поиграть (порядок не имеет значения):
* [pandoc](http://johnmacfarlane.net/pandoc/) — швейцарский нож в контексте форматов разметки (markdown, reStructuredText, org-mode, LaTeX и т.д.)
* [gitit](http://gitit.net/) — wiki, работающая под управлением git, darcs или mercurical
* [pronk](https://github.com/bos/pronk) — инструмент для тестирования HTTP нагрузки, подобный ab и httperf, только более современный и простой
Для таких пакетов, как pronk, которые в данный момент отсутствуют в Hackage, установка через cabal-dev должна выглядеть примерно так:
```
$ git clone https://github.com/bos/pronk.git /tmp/pronk-src && \
(cd /tmp/pronk-src; \
cabal-dev install -s /usr/local/Cellar/pronk/$(git rev-parse --short HEAD)) && \
rm -rf /tmp/pronk-src
```
#### Настройка GHCi
ghci — это интерактивный интерпретатор GHC (REPL, схожий с python или irb в терминале). За подробной документацией рекомендую обратиться к [GHC Users Guide](http://www.haskell.org/ghc/docs/7.4.2/html/users_guide/index.html) ([Chapter 2. Using GHCi](http://www.haskell.org/ghc/docs/7.4.2/html/users_guide/ghci.html)). Вы будете проводить там много времени, играя с кодом, так что предлагаю для начала укоротить приветствие. Оно выглядит так:
```
Prelude>
```
Когда Вы начнете импортировать модули, приветствие разрастется, и на самом деле это никому не нужно.
```
Prelude> :m + Data.List
Prelude Data.List> :m + Data.Maybe
Prelude Data.List Data.Maybe>
```
Это можно исправить при помощи файла [.ghci](http://www.haskell.org/ghc/docs/7.4.2/html/users_guide/ghci-dot-files.html). Я использую очень простой ASCII символ, хотя некоторые любят что-то вроде λ>.
```
echo ':set prompt "h> "' >> ~/.ghci
```
Можно также использовать команду `:set prompt "h> "` при каждом запуске GHCi, но это тоже лишнее.
```
$ ghci
h> putStrLn "Hello World!"
Hello World!
h>
```
#### Hackage хрупкий, но существуют (неофициальные) зеркала
К сожалению, Hackage не славится своей надежностью. Я не знаю в чем проблема, но надеюсь, что они с этим что-то сделают в ближайшее время. Есть обходной путь ([Обходные пути в случае падения Hackage](http://comonad.com/reader/2012/hackage-mirror/)), нужно всего-лишь использовать репозиторий из hdiff на [hdiff.luite.com](http://hdiff.luite.com) или с [hackage.csc.stanford.edu](http://hackage.csc.stanford.edu).
Для этого нужно поменять строчку в ~/.cabal/config:
```
remote-repo: hackage.haskell.org:http://hackage.haskell.org/packages/archive
```
На что-то вроде:
```
-- TODO When hackage is back up, set back to hackage.haskell.org!
-- remote-repo: hackage.haskell.org:http://hackage.haskell.org/packages/archive
remote-repo: hdiff.luite.com:http://hdiff.luite.com/packages/archive
-- remote-repo: hackage.csc.stanford.edu:http://hackage.scs.stanford.edu/packages/archive
```
После изменений, нужно обновить список пакетов
```
$ cabal update
```
И не забудьте вернуть все обратно спустя некоторое время!
#### Создаем проект (с помощью cabal-dev)
В конечном счете Вы бы и сами это осознали, но самый быстрый способ начать проект — начать его с cabal-dev. Вот что нужно сделать для простенькой программы.
Для собственных проектов, нужно убрать опцию `-n`, чтобы задать список необходимых опций вручную. Опция `-n` использует все настройки по умолчанию и ни о чем Вас не спрашивает.
```
$ mkdir -p ~/src/hs-hello-world
$ cd ~/src/hs-hello-world
$ touch LICENSE
$ cabal init -n --is-executable
```
Это сгенерирует файлы `Setup.hs` и `hs-hello-world.cabal`. Следующим шагом нужно изменить строчку `main-is:`, чтобы кабал знал, из какого исходника собирать исполняемый файл. Конечный результат должен получиться таким:
##### hs-hello-world.cabal
```
-- Initial hs-hello-world.cabal generated by cabal init. For further
-- documentation, see http://haskell.org/cabal/users-guide/
name: hs-hello-world
version: 0.1.0.0
-- synopsis:
-- description:
license: AllRightsReserved
license-file: LICENSE
-- author:
-- maintainer:
-- copyright:
-- category:
build-type: Simple
cabal-version: >=1.8
executable hs-hello-world
main-is: HelloWorld.hs
-- other-modules:
build-depends: base ==4.5.*
```
Затем создайте `HelloWorld.hs`, с таким содержимым:
##### HelloWorld.hs
```
main :: IO ()
main = putStrLn "Hello, world!"
```
Вот что нужно, чтобы собрать и «установить» программу в текущей песочнице:
```
$ cabal-dev install
Resolving dependencies...
Configuring hs-hello-world-0.1.0.0...
Building hs-hello-world-0.1.0.0...
Preprocessing executable 'hs-hello-world' for hs-hello-world-0.1.0.0...
Installing executable(s) in /Users/bob/src/hs-hello-world/cabal-dev//bin
Installed hs-hello-world-0.1.0.0
$ ./cabal-dev/bin/hs-hello-world
Hello, world!
```
Исполняемый файл получается великоват, но также он статически линкован. Можно скопировать его на любую машину с такой же операционной системой и архитектурой, и он просто будет работать.
Можно сэкономить немного времени, пропустив шаг установки:
```
$ cabal-dev configure
Resolving dependencies...
Configuring hs-hello-world-0.1.0.0...
$ cabal-dev build
Building hs-hello-world-0.1.0.0...
Preprocessing executable 'hs-hello-world' for hs-hello-world-0.1.0.0...
[1 of 1] Compiling Main ( HelloWorld.hs, dist/build/hs-hello-world/hs-hello-world-tmp/Main.o )
Linking dist/build/hs-hello-world/hs-hello-world ...
$ ./dist/build/hs-hello-world/hs-hello-world
Hello, world!
```
Так как у проекта нет зависимостей, которые нужно устанавливать, можно немного срезать углы.
Например, запустить с помощью интерпретатора, без компиляции:
```
$ runghc HelloWorld.hs
Hello, world!
```
```
$ ghci
GHCi, version 7.4.2: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> :load HelloWorld
[1 of 1] Compiling Main ( HelloWorld.hs, interpreted )
Ok, modules loaded: Main.
*Main> main
Hello, world!
```
Да и вовсе можно собрать его без `cabal-dev` (или `cabal`):
```
$ runghc Setup.hs configure
Configuring hs-hello-world-0.1.0.0...
$ runghc Setup.hs build
Building hs-hello-world-0.1.0.0...
Preprocessing executable 'hs-hello-world' for hs-hello-world-0.1.0.0...
[1 of 1] Compiling Main ( HelloWorld.hs, dist/build/hs-hello-world/hs-hello-world-tmp/Main.o )
Linking dist/build/hs-hello-world/hs-hello-world ...
```
Но для более сложного проекта, можно использовать `cabal-dev ghci` (после `cabal-dev configure && cabal-dev build`). Прошу заметить, что в этом случае код будет загружен в интерпретатор автоматически:
```
$ cabal-dev ghci
on the commandline:
Warning: -O conflicts with --interactive; -O ignored.
GHCi, version 7.4.2: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Ok, modules loaded: Main.
h> main
Hello, world!
```
#### Основы GHCi
Некоторые базовые трюки GHC которые хорошо бы знать. Помимо тех, которые я указал здесь, советую изучить [Chapter 2. Using GHCi](http://www.haskell.org/ghc/docs/7.4.1/html/users_guide/ghci.html).
##### :t показывает тип выражения
```
h> :t main
main :: IO ()
h> :t map
map :: (a -> b) -> [a] -> [b]
h> :t map (+1)
map (+1) :: Num b => [b] -> [b]
```
##### :i показывает информацию о названии (function, typeclass, type, ...)
```
h> :i Num
class Num a where
(+) :: a -> a -> a
(*) :: a -> a -> a
(-) :: a -> a -> a
negate :: a -> a
abs :: a -> a
signum :: a -> a
fromInteger :: Integer -> a
-- Defined in `GHC.Num'
instance Num Integer -- Defined in `GHC.Num'
instance Num Int -- Defined in `GHC.Num'
instance Num Float -- Defined in `GHC.Float'
instance Num Double -- Defined in `GHC.Float'
h> :info map
map :: (a -> b) -> [a] -> [b] -- Defined in `GHC.Base'
h> :info Int
data Int = ghc-prim:GHC.Types.I# ghc-prim:GHC.Prim.Int#
-- Defined in `ghc-prim:GHC.Types'
instance Bounded Int -- Defined in `GHC.Enum'
instance Enum Int -- Defined in `GHC.Enum'
instance Eq Int -- Defined in `ghc-prim:GHC.Classes'
instance Integral Int -- Defined in `GHC.Real'
instance Num Int -- Defined in `GHC.Num'
instance Ord Int -- Defined in `ghc-prim:GHC.Classes'
instance Read Int -- Defined in `GHC.Read'
instance Real Int -- Defined in `GHC.Real'
instance Show Int -- Defined in `GHC.Show'
```
##### :m добавляет модуль в текущую область видимости
```
h> :m + Data.List
h> sort [10,9..1]
[1,2,3,4,5,6,7,8,9,10]
```
##### :l подгружает модуль, :r перезагружает
```
h> :! echo 'hello = print "hello"' > Hello.hs
h> :l Hello
[1 of 1] Compiling Main ( Hello.hs, interpreted )
Ok, modules loaded: Main.
h> hello
"hello"
h> :! echo 'hello = print "HELLO"' > Hello.hs
h> :r
[1 of 1] Compiling Main ( Hello.hs, interpreted )
Ok, modules loaded: Main.
h> hello
"HELLO"
```
#### Рекомендованное чтение
Я отметил для себя следующие книги и сайты полезными, пока учил Хаскель самостоятельно.
##### Книги
* [Изучай Хаскель во имя добра!](http://www.ozon.ru/context/detail/id/8696277/)
Эта книга оказалась для меня великолепной стартовой точкой, я рекомендую ее первой к прочтению. Она не заходит слишком глубоко, чтобы дать Вам ощущение ДЕЙСТВИТЕЛЬНО полного понимания GHC, но после ее прочтения я стал чувствовать себя комфорно в написании и понимании кода на Хаскеле.
* [Real World Haskell](http://book.realworldhaskell.org/)
Это увесистая книга и по размерам, и по глубине, но это не мешает ей быть доступной даже новичку. Она охватывает множество вещей из Реального Мира: написание теста, профилирование, IO, параллелизм и т.д. Я до сих пор ее изучаю, но эта книга обязательна к прочтению.
##### Сайты
* [CS240h: Functional Systems in Haskell](http://www.scs.stanford.edu/11au-cs240h/) — был такой курс по Haskell в Стенфорде, который преподавали [David Mazières](http://www.scs.stanford.edu/%7Edm/) и [Bryan O'Sullivan](http://www.serpentine.com/). Он похож (но его охват шире) на тот курс, который я прошел в Facebook. Конспекты лекций и программа — просто фантастические, читайте их все!
* [Real World Haskell](http://book.realworldhaskell.org/)
* [Learn You a Haskell](http://learnyouahaskell.com/)
* [haskell.org](http://www.haskell.org/) отличная вещь для погружения, там Вы найдете все эти ссылки + ГОРАЗДО больше. Рассчитывайте потратить там много времени!
* [H-99](http://www.haskell.org/haskellwiki/H-99:_Ninety-Nine_Haskell_Problems) содержит некоторые маленькие задачки, над которыми можно поработать. Он во многом похож на [Euler project](http://projecteuler.net/). Их довольно просто решить после прочтения LYAH.
* [Typeclassopedia](http://www.haskell.org/haskellwiki/Typeclassopedia) отличный ресурс для изучения множества тайпклассов Haskell Platform
* [Hoogle](http://www.haskell.org/hoogle/) — это поисковик по Haskell API, поддерживающий поиск по сигнатурам типов! Я провел за ним очень много времени.
* [Hayoo!](http://holumbus.fh-wedel.de/hayoo/hayoo.html) еще один поисковик, подходит для случаев, когда невозможно найти необходимую информацию с помощью Hoogle
* [HWN](http://www.haskell.org/haskellwiki/HWN) — еженедельная рассылка Хаскеля, которая собирает в себе ключевые моменты из мэйл листов, вопросы со stackoverflow, реддит и т.п..
* [Haskell :: Reddit](http://www.reddit.com/r/haskell/) — сабреддит по Haskell
* [stackoverflow — haskell](http://stackoverflow.com/questions/tagged/haskell) — вопросы по Haskell на stackoverflow, частенько достойны прочтения (если честно, очень часто там засиживаюсь после HWN)
* [C9 Lectures: FP Fundamentals](http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Functional-Programming-Fundamentals/Lecture-Series-Erik-Meijer-Functional-Programming-Fundamentals-Chapter-1) 13 лекций по Основам Функционального Программирования (на Хаскеле), рассказанные Dr. Erik Meijer (я еще их не посмотрел, но их [советовал Adam Breen](https://www.facebook.com/etrepum/posts/10151380112306253?comment_id=26337628&offset=0&total_comments=1)).
##### IRC
#haskell на Freenode — то место, где Вы в любое время найдете несколько сотен человек, заинтересованных в Хаскеле. Отличное место для поиска помощи.
#### Предложения?
Я планирую пытаться поддерживать все это в актуальном состоянии, в зависимости от предложений. Если я пропустил что-то важное, дайте мне знать! Я не претендую на cоздание полной картины, мне кажется Haskell wiki с этим справляется гораздо лучше. Но основные моменты хотелось бы захватить. | https://habr.com/ru/post/165559/ | null | ru | null |
# Как связать два asterisk-сервера (часть первая. SIP)
Итак, имеем два астериска.
Задача — организовать прямой дозвон через префикс туда и обратно.
Исходные данные:
Астериск 1.4 на обеих концах
kazan.asterisk.ru — имя первого астериска.
volgograd.asterisk.ru — имя второго астериска.
Предполагается, что оба астериска имеют прямой выход в интернет (в ином случае тоже проблем быть не должно, нужно настроить NAT и использовать параметр nat=yes)
Пусть 1-й астериск у нас находится в Казани, другой в Волгограде. Обратимся к автомобильным кодам регионов.
Тогда дозвон из Волгограда будет 9-16-<номер>.
Из Казани 9-34-<номер>.
**sip.conf 1-го астериска:**
`[general]
context=default
allowguest=no
bindport=5060
bindaddr=0.0.0.0
; настройки для регистрации на другом астериск-сервере
register => kazan:kazan_password@volgograd.asterisk.ru:5060
[volgograd]
; логин и пароль для подключения
username=volgograd
secret=volgograd_password
; разрешать входящие и исходящие вызовы
type=friend
; не отсылать повторные сообщения INVITE
canreinvite=no
; Не требовать доп. аутентификации
insecure=very
; периодическая проверка доступности устройства
qualify=yes
; разрешаем регистрацию
; (www.voip-info.org): If you want the phone to register itself, use the keyword dynamic instead of Host IP.
; ограничить подключения можно через deny,permit
host=dynamic
;DTMF
dtmfmode=rfc2833
; настройка кодеков
disallow=all
allow=alaw
allow=ulaw
; в какой контект будут попадать входящие звонки
context=office_rules`
**extension.conf 1-го астериска:**
`; контекст для пользователей
[office]
exten => _934.,1,Set(CALLERID(all)="Kazan <16>")
exten => _934.,n,Dial(SIP/${EXTEN:3}@volgograd,60,r)
exten => _934.,n,HangUp
..
include => office_rules
; контекст для входящих вызовов
; внутренние номера имеют вид 1XX или 2XX
[office_rules]
exten => _[12]XX,1,Dial(SIP/${EXTEN},60,tTr)
exten => _[12]XX,n,HangUp()`
**sip.conf 2-го астериска:**
`[general]
context=default
allowguest=no
bindport=5060
bindaddr=0.0.0.0
; настройки для регистрации на другом астериск-сервере
register => volgograd:volgograd_password@kazan.asterisk.ru:5060
[kazan]
type=friend
; credentials for registration
username=kazan
secret=kazan_password
; разрешаем регистрацию
; (www.voip-info.org): If you want the phone to register itself, use the keyword dynamic instead of Host IP.
; ограничить подключения можно через deny,permit
host=dynamic
; не отсылать повторные сообщения INVITE
canreinvite=no
; Не требовать доп. аутентификации
insecure=very
; периодическая проверка доступности устройства
qualify=yes
; DTMF
dtmfmode=rfc2833
; разрешенные кодеки (только G711)
disallow=all
allow=ulaw
allow=alaw
; в какой контекст принимать звонки
context=office_rules`
**extension.conf 2-го астериска:**
`; контекст для пользователей
[office]
exten => _916.,1,Set(CALLERID(all)="Volgograd <34>")
exten => _916.,n,Dial(SIP/${EXTEN:3}@kazan,60,r)
exten => _916.,n,HangUp
..
include => office_rules
; контекст для входящих вызовов
; внутренние номера имеют вид 1XX или 2XX
[office_rules]
exten => _[12]XX,1,Dial(SIP/${EXTEN},60,tTr)
exten => _[12]XX,n,HangUp()`
PS. Буду признателен советам по расширению функциональности и безопасности.
upd: В любом случае, в плане аспекта безопасности, нужно глянуть [это](http://blogs.digium.com/2009/03/28/sip-security/).
Несколько комментариев.
Если у вас есть определенный опыт при работе с астериском, то у вас должен был возникнуть вопрос.
Как определяется контекст при исходящих звонках?
Запись
`context=office_rules`
работает только на входящие звонки. Так вот, в данном случае на принимающей стороне астериск видит, что в системе есть peer, который имеет тот же IP-адрес, что и клиент, который совершает звонок. И берет его context.
И еще. Никто не мешает вам указать несколько register, если у вас используется несколько провайдеров. Суть register заключается в том, чтобы сказать, где именно вы находитесь. Если вы 2 или более раз скажите, что «вы здесь», никаких проблем не возникнет и более того, вы будете застрахованы от перебоев одного из провайдеров. | https://habr.com/ru/post/107668/ | null | ru | null |
# Заговор или совпадение: СПО в школах
В продолжение топика [про внедрение СПО](http://habrahabr.ru/blogs/linux/70765/). Вчера в блогах мелькнуло рассуждение по итогам этого тендера.
Цитирую (заголовок, оформление и орфография сохранены):
`**СПО-распил**
Многие наверняка слышали о проекте внедрения СПО в российских школах (http://slon.ru/articles/143164/). Хочу обратить внимание, что против СПО зреет заговор, за которым стоит Microsoft.
Есть ряд фактов, на которые советую обратить внимание всем заинтересванным деятелям:
1. Майкософт, по некоторым данным, запрещала АйТи принимать участие в школьном конкурсе, угрожая санкциями. Но АйТи все же принял участие и победил. Вероятно, договорились.
2. ФАО откладывает конкурс до середины августа. По некоторым сведениям, его вообще хотели замотать, но по сигналу сверху выпустили.
3. Документация конкурса составлена так, что через ФАС ее можно опротестовать на раз. Но если ФАС отменит конкурс, то деньги вернутся в бюджет и СПО будет похоронено.
4. В итоге лоты отдают крупной фирме-прокладке АйТи, которая, по собственным словам, привлекает для выполнения проекта "всех лучших". Но на деле загоняет себя в заранее невыполнимые рамки.
Результат: при любых раскладах выигрывают противники СПО.
Впрочем, в этой комбинации есть риски как у ФАО, так и у АйТи:
В случае отмены результатов ФАСом ФАО сдает Лазутина (отвечает в ФАО за СПО), ему компенсируют запасным аэродромом (по некоторым сведениям об этом уже есть договоренности). Компенсации АйТи в случае сноса ФАС также должны быть предусмотрены заранее.
А вот в случае исполнения лотов они рискуют и прикрытие в ФАО может не сработать. АйТи в этом случае весьма уязвима.`
[Источник](http://community.livejournal.com/ru_cio/150825.html) | https://habr.com/ru/post/71189/ | null | ru | null |
# Шрифт с помощью CSS
Дэвид Дисандро разработал CSS, который рисует шрифт. Шрифт он назвал Curtis.
Оформление каждой буквы выглядит несколько грамоздко:
> `<span class="css\_char r">
>
> R
>
> <span class="inside split\_vert">span>
>
> <span class="outside split\_vert">span>
>
> <span class="stroke">span>
>
> <span class="fill">span>
>
> span>
>
> \* This source code was highlighted with Source Code Highlighter.`
Безумно и весело, или безумно весело ;-)
[Оригинальная статья](http://desandro.com/resources/curtis-css-typeface/) Весь CSS относящийся к статье в файле [curtis\_css.css](http://desandro.com/content/2.resources/3.curtis-css-typeface/curtis_css.css) | https://habr.com/ru/post/87904/ | null | ru | null |
# Реверс черного тессеракта. Начало
Система с известной спецификацией реакций на входные воздействия и неизвестным содержимым характеризуется как черный ящик. Когда внутренняя структура, устройство и архитектура системы известны, - ящик белый. Есть и промежуточное понятие - серый ящик, частичное знание внутреннего устройства и ожидаемое поведение.
Как охарактеризовать систему, выходные реакции которой очевидны, но нет информации о входных данных, вызывавших эти реакции? Я сейчас про компьютеры, а не о психологии или медицине. Строго говоря, входные данные не просто есть, они присутствуют в полном спектре возможных вариантов, но целиком, глыбой, блобом, а реакция происходит на отдельную неизвестную часть (части) входных данных.
По аналогии с ящиками для этого рассказа я отважно назвал такую систему именем четырехмерного ящика - черным тессерактом. Ну, во-первых, это красиво(с). Черный - за неизвестные входные спецификации. Четвертое измерение - из-за того, что конечные данные устройства автомобильной навигации выдают в виде изображений, попытка компьютеризированного анализа результатов вывода бессмысленна и беспощадна. А процесс реверс-исследований затягивает, как наблюдение за проекцией тесерракта на 2D: только стало понятно, как всё устроено, но потом он чуть поворачивается....
### Давным-давно, в одной далекой галактике...
Началась история, когда в 2012 купил Citroen C5 2002 года выпуска. В комплектации штатное устройство навигации (оно же CD-player) Сlarion RD3 2295 с большим цветным экраном на торпеде и отдельным считывателем CD с навигационной информацией, запрятанном в бардачке. В считывателе - CD с картой Франции пяти- семилетней давности. Но там, где находился я, навигатор отображал карту Великого Ничего или некоторый кусок неизвестной пустыни.
Предыдущий опыт использования широкого спектра навигаторов - Garmin, WinCE, Nokia, различного специализированного ГеоПО с поддержкой NMEA приемников меня не готовил к тому, что навигатор не показывает местоположения на экране. Требовалось решение мучительной дилеммы: с картой я мог быть во Франции, но когда я был вне Франции, я был без карты.
Поиски информации по сети дали следующие результаты:
* Навигационная система - [Siemens VDO Dayton and Carin Navigation](https://www.navmapstore.com/category/104/VDO_Dayton_Navigation_Update/VDO_Dayton_and_Carin_Navigation_Update). Устанавливалась, как штатная, широким рядом производителей на многие модели (BMW, Citroen, Land Rover rank Rover, Discovery, Freelander - Ford Lincoln, OPEL/Vauxhall Astra, Corsa, Omega, Vectra, Zafira, Peugeot, Renault Laguna, Megane, Clio, Scenic, Safrane, Vel Satis, Avantime, Espace, Trafic, Rover/mg 75, Volkswagen phaeton)
* Официальных карт РФ для этой навигационной системы - Siemens/VDO Dayton Carminat - в природе не существует от слова вообще.
* Ежегодно, и, похоже, до сих пор, выпускаются в продажу актуализированные карты Европы, цена за комплект в районе [150€-200€](https://www.navigation.com/models/Catalog/Catalog_Citroen_C5_2003_VDO/en_GB/CitroenEMEA/EUR), но СНГ в ихнюю Европу не входит.
* Отыскать на торрентах европейские карты можно.
* На разных торрентах [присутствует](https://rutracker.org/forum/viewtopic.php?t=894615) единственный образ с картой РФ и СНГ весьма печального качества - основные города и дороги, скомпилированный в 2005 году.
* Формат карт пропириетарный, доступных редакторов, просмотрщиков, или инструментов для конвертации из/в этот формат - нет. Следы попыток энтузиастов французов расковырять формат уходили в глубины [web.archive.org](http://web.archive.org), и быстро и бесплодно (почти) там оканчивались.
Нет, конечно, навигация на телефоне полностью перекрывает штатную по функциональности, то же отображение пробок и перекрытий, получаемых по интернету - ультимативный козырь. Но, покатавшись по Польше с штатной автомобильной навигацией, не могу не признать, что при наличии CD с картами в ридере, вождение заметно комфортнее. Просто обидно же, при существовании в природе доступных топооснов в лице OpenStreetMap, Публичной карты Росреестра, <https://github.com/nvkelso/natural-earth-vector>, не иметь возможности хотя бы просто видеть местонахождение автомобиля на карте на штатном экране.
Всего-то нужно разобраться в закрытом и недокументированном формате хранения информации. Без возможности схитрить и "подглядеть" с IDA или radare2 процесс обращения к этим данным - данные читаются автомобильным устройством. Без пути декомпилировать это навигационное приложение - прошивку навблока. Без спецификаций, документации, справочников и советов сообщества, за отсутствием такого. Да неизвестна даже архитектура процессора, на котором работает приложение, читающее эти данные. Без варианта посмотреть "а что будет, если вот этот байт изменить?" даже не от того, что запись образа CD занимает время, а от того, что этих данных - почти компакт-диск, и попытка скормить "видоизмененные данные" со значительной вероятностью приводит к тому, что информация с диска распознается, как непригодная.
Вообще мы стали сильно избалованы ростом мощностей процессоров и объёмов систем хранения данных. Сейчас на один CD помещается не каждый десяток RAW фотоснимков, но в нави-системах в тот же размер впихивалась территория нескольких стран с точностью до пары сантиметров, с поиском адресов до дома, маршрутами, сотнями тысяч географических объектов в нескольких масштабах. А то и нескольких десятков стран, если чуть поступиться качеством, как в упомянутом русском образе.
Так что да, текст - не просто лонгрид, а серия больших статей.
С другой стороны, согласитесь, какой красивый вызов: расковырять практически абсолютный черный ящик, у которого есть только вход. У Жан-Франсуа Шампольона был хотя бы розеттский камень, у меня - только понимание, что данные используются компьютером, и там внутре у неё карта.
Что человек ни построил бы, другой завсегда разобрать сможет. В цикле статей постараюсь рассказать наглядно и пошагово, как можно колупать такие орехи: провести реверс-инжиниринг данных известного назначения, но неизвестного формата, на основе проанализированных данных восстановить алгоритмы работы программы. И рассказать о великолепном 010Editor - на Habr он всего пяток раз упоминался мимоходом - в виде понятного Tutorial на реальном примере.
Уровень изложения - максимально доступный для знающих любой язык программирования (не гарантируется для 1с, ДРАКОН, [Перфолента.NET](http://xn--r0a8aoa3anepwp.NET)), основы операций с [типами данных C](https://wiki2.org/ru/%D0%A2%D0%B8%D0%BF%D1%8B_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85_%D0%B2_C) и готовых смириться с постулатом шарообразности Земли и вытекающим из него понятием географических координат.
### Данные
Под анализ попали три варианта карты, 3 CD:
* Вышеупомянутый давно ходящий по сети образ диска с картой восточной Европы, в т.ч. и РФ и Белоруссии, далее carindb\_rus или "русский вариант" - потому как иных вариантов с РФ мне найти не удалось. Только основные дороги, нет лесов, карта достаточно неряшливая, и масштаб практически без улиц в городах. Вероятно кто-то когда то на официальном инструменте попробовал сформировать тестовый файл европейской части РФ и прилегающих стран - и результат ушел в народ.
* CARiN- and VDODayton navigation 2013, CD3 EastEurope\_13\_14, официальный выпуск навигации, подробные отличные карты Болгарии, Чехии, Эстонии, Хорватии, Латвии, Венгрии, Польши, Румынии и Словении, далее carindb\_ee
* CARiN- and VDODayton navigation 2013, CD1 Benilux\_13\_14, официальный выпуск навигации, подробные отличные карты Бельгии, Люксембурга и Нидерландов, далее carindb\_bnl
Навигационные CD содержат несколько файлов: небольшие текстовые ABSTRACT, BIBLIOGR, COPYRIGH, содержимое которых описывается их названием, и занимающий основное пространство бинарный carindb, (на официальных дисках есть еще файл CARINET размером примерно 1/10 от carindb, содержащий расшифровку сообщений системы радиооповещения RDS CARINET, но не буду забегать вперед, этот файл не так важен для собственно навигации).
Картографические и навигационные данные находятся в carindb.
Если я говорю carindb, понимать, как carindb\_rus, экономлю 4 байта.
### 010 Editor
Для анализа формата данных самый удобный, на мой взгляд, инструмент - программа [010 Editor](https://www.sweetscape.com/). Платная, под win, linux, macos, с месячным триальным периодом. Не самый восхитительный редактор скриптов и темплейтов, недружелюбный к русскому даже в комментариях, довольно тяжелый, не сравнить с молниеносным HxD, порой подвисающий и подбагивающими float окнами. Но зато возможности задавать С-подобным синтаксисом структуры данных и логику, расцвечивать в отображении bin, ввод-вывод при "распознании", поддерживаются размеры файлов за 50Гб, наглядный вывод значений каждой единицы данных, и прочее и прочее - невыразимо восхитительна. Своих $50 за домашнюю лицензию (и $130 за коммерческую) безусловно стоит. В него еще встроено использование репозитория с шаблонами описания различных форматов - и чего там только нет. Разве что VDO Dayton navsystem data нет. Разработчики редактор позиционируют, как World's Best Hex Editor, и я соглашусь с этим мнением.
В 010Editor файл для анализа отображается в hex - окне, его можно разметить созданным пользователем (или загруженным из облачного репозитория) темплейтом.
Темплейты - это пользовательские описания структуры данных на С-подобном интерпретируемом языке 010Editor, хранимые в файлах с расширением .bt. Декларация "переменной" после исполнения (F5) темплейта на открытом бинарнике приводит к её появлению на закладке Variables. Если имя переменной используется неоднократно, то во вкладке Variables, результатах выполнения темплейта, оно будет представлено, как элемент массива. При клике мышкой на переменные в этой вкладке, фокус в окне просмотра hex сместится на соответствующее место, выделив выбранные данные. Внутренний курсор разметки после объявления переменной переместится на следующий после неё байт, и следующая переменная будет начинаться с этого места. При объявлении переменных в темплейте можно к ним объявить дополнительные свойства-атрибуты, например, bgcolor или fgcolor (выделят в hex окне визуально местоположение соответствующей переменной). Если в описании переменной предварительно указано ключевое слово local, то переменная будет присутствовать в Variables, но не будет воспринята, как часть разметки данных в hex.
### Структура данных в carindb, блоки
#### BigEndian
Просматривая в hex carindb, бросается в глаза, что данные расположены порциями - начинаются с адреса, кратного 0x800, затем заканчиваются и до следующего кратного, идут 00.
Темплейтом вывожу DWORD через каждые 0x800, первые 5 значений:
```
0x00000000 : 01000000
0x00000800 : 01010000
0x00001000 : 01020000
0x00001800 : 01030000
0x00002000 : 02040000
```
Сильно похоже (если продолжить дальше по hex), тут [BigEndian](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA_%D0%B1%D0%B0%D0%B9%D1%82%D0%BE%D0%B2) (привет, Motorolla?), порядок байт, не обратный, как у Intel, а прямой. Добавляю в начале темплейта директиву обработки значений, как BigEndian().
#### Структура BL\_ADDR - адрес блока
Для тех размеченных как DWORD записей, что расположены после нулевой информации, первые 3 байта равны смещению / 0x800, 4й байт - размер информационного блока в 0x800 байт.
Язык темплейтов позволяет описывать пользовательские структуры, и даже, как битовые поля. Первые 24 бита 32битной структуры нарекаю адресом, последние 8 - размером. В темплейте размечаю этой структурой BL\_ADDR - переменной begin\_block только те места, где begin\_block.addr == смещению от начала hex, деленного на 0x800 (деление заменил правым смещением на 11 бит).
#### include и самодиагностика валидности структур
Можно вынести описания структур данных в отдельный файл, а в темплейте подключить его стандартной для препроцессора С `#include "inc_common.bt"`
Кое-что в структуре изменил. При объявлении addr и size, задаю оранжевый фон и контрастный цвет. Добавились три локальных, рассчитываемых, не отображаемых на hex переменных структуры - raw, offset и is\_valid. Их значения используются в том числе и для того, чтобы on-fly проверять - а являются ли размеченные структурой BL\_ADDR данные в hex действительно адресом начала блока? У объявленной структуры появился атрибут read со значением Read\_BL\_ADDR - это имя автоматически вызываемой при каждом BL\_ADDR функции, которая должна возвратить строковое значение, которое будет отображаться в колонке Value во вкладке Variables. Параметр этой функции - конкретный экземпляр структуры BL\_ADDR a. И если данные не валидны, это будет отображено в колонке Value.
В основном темплейте добавил атрибуты скрытия из вкладки Variables у локальных переменных i и data, и после вызова цикла пару раз разметил данные в hex, как BL\_ADDR non\_val\_begin - рассчитывая на заведомо невалидные значения для иллюстрирования, как работает добавленная проверка валидности данных.
И неожиданный результат - значение по смещению 0x9804 внезапно оказывается валидным BL\_ADDR, расположенным где-то по адресу 0x00981000. Запомним.
#### Что после адреса, структура BL\_HEAD
Увеличиваю максимальный адрес i до 0x400000, и пробегаю в поисках валидных BL\_ADDR, Printf-ом вывожу смещение, размер блока и следующий за BL\_ADDR DWORD something (в hex - на салатовом фоне).
У something везде первый, третий и четвертый байт - нули, а у второго - ненулевое значение. И это значение меняется как 12h - 13h - 7h - bh - ah - 3 раза dh - далее все ch (h - hex - шестнадцатеричные).
Более того, если везде всё так одинаково после BL\_ADDR блока, то заведу новую структуру BL\_HEAD для начала блока в include файле. Сначала в этой структуре идёт BL\_ADDR addr, затем четыре байта с именами эмммм... Ну, пусть zero\_aligment, type, is\_compressed и uncompressed\_size. Локальные переменные структуры - аналогичный BL\_ADDR признак is\_valid, и временный пойнтер tmp\_ptr. Обработка is\_valid очевидна и откомментирована. В tmp\_ptr хранится адрес, куда возвращаться после определения самой последней переменной блока here\_last\_byte. Атрибутивная функция string Read\_BL\_HEAD(BL\_HEAD &a) аналогична той, что и для структуры BL\_ADDR.
Цикл темплейта завершается на середине блока данных, если прописать несколько BL\_ADDR или BL\_HEAD, они будут находиться заведомо не в положенных местах, и самопроверка должна окрасить фон красным.
Невалидный BL\_HEAD отрабатывает верно, и в Value предупреждение, и цвет красный, но неожиданно BL\_ADDR non\_valid\_begin[1] с raw = 0x004d130d - проходит проверку, по адресу `0x004d13*0x800` записаны ровно те же цифры, что и в raw.
#### enum, EnumToString, статистика и распределение типов в carindb
Добавлю локальную переменную type в BL\_ADDR, которая будет читать значение +2 байта за BL\_ADDR - т.е. быть равной type соответствующего BL\_HEADER. И заведу перечисление en\_BL\_TYPE для этих type c элементом ABSTRACT, равным 12h, типу самого первого блока и элементом Invalid, со значением 0xFF, которое в BL\_ADDR у type по умолчанию. Изменяю Read\_BL\_ADDR и Read\_BL\_HEAD , используя EnumToString (замечательная функция, возвращающая строковое название числа из перечисления).
И переписываю основной темплейт, задача - посмотреть, как распределяются блоки во всём файле (верхний предел i - FileSize), и сколько каких типов блоков.
Чуть отредактировал руками для хабра результат вывода в консоль - перенес колонки информации о количестве блоков правее.
```
File size=1EA2E000 Max block size = 16*0x800
Offset Type Qty Type Qty
0x00000000 12 1 0x00 15329
0x00000800 13 1 0x01 5279
0x00001000 07 1 0x02 5809
0x00001800 0B 1 0x03 5867
0x00002000 0A 1 0x04 --
0x00003000 0D 3 0x05 --
0x00010800 0C 692 0x06 5198
0x011F6000 0F 31 0x07 1
0x012EA000 0E 1114 0x08 26
0x02401800 11 145 0x09 7712
0x02763800 10 1524 0x0A 1
0x048A2000 08 1 0x0B 1
0x048A2800 09 9 0x0C 692
0x048BC800 06 5198 0x0D 3
0x055E0000 08 17 0x0E 1114
0x05620800 09 7192 0x0F 31
0x0643F800 00 15329 0x10 1524
0x127BF800 08 1 0x11 145
0x127C1000 09 169 0x12 1
0x1281C000 03 5867 0x13 1
0x13C2F000 08 1 0x14 324
0x13C30800 09 169 0x15 4097
0x13C8A800 02 5809 0x16 15817
0x15070800 08 1 0x17 --
0x15071000 09 54 0x18 --
0x1509C800 01 5279 0x19 --
0x16335000 08 1 0x1A --
0x16335800 09 86 0x1B --
0x16365800 16 15817 0x1C 1095
0x1C36A000 08 1 0x1D 114
0x1C36A800 09 26 0x1E --
0x1C37A000 15 4097 0x1F --
0x1E00A800 08 1
0x1E00B000 09 3
0x1E010000 1C 1095
0x1E6E5800 08 1
0x1E6E6000 09 3
0x1E6EA000 14 324
0x1E90D800 08 1
0x1E90E000 09 1
0x1E910800 1D 114
```
Капитан очевидность:
* Присутствует логика группировки типов в теле carindb.
* Явно просматривается последовательность типов 08h -> 09h -> XXh.
* Максимальное значение номера типа 0x1D.
* В последовательности нумерации типов некоторые (0x04, 0x05, 0x17, 0x18, 0x19, 0x1A, 0x1B) отсутствуют.
* Больше всего типов 0x16 и 0x00
* Но есть и присутствующие в единичных экземплярах (0x12, 0x13, 0x07, 0x0B, 0x0A), в основном вначале файла.
Темплейт отрабатывает аналогично на carindb\_ee или carindb\_bnl. Почти так же - у официальных карт появляются дополнительные типы, которых не было в carindb\_rus. На будущее сохраняю темплейт под именем "util\_vdo\_stat.bt"
### Итак
Выяснено, что числовые данные в файле carindb сгруппированы в блоки различных типов.
Созданы две симулятивно-интеллектуалных (притворяющихся типа умными) типа структур данных, характерных для файла carindb.
* BL\_ADDR проверяет, что данные по адресу, который несет его значение, являются началом блока, и читает тип этого блока.
* BL\_HEADER проверяет, что он сам располагается по адресу, на который указывают значения его данных.
Написана утилита-темплейт, выводящая информации о распределении блоков внутри carindb, максимальный размер блока и информации о количестве каждого типа.
Попутно даны начальные сведения для работы с 010Editor.
Слона, к которому непонятно было, как подступиться, нарезал на более мелкие куски.
Дальнейший анализ - [в следующей статье](https://habr.com/ru/post/597851/). | https://habr.com/ru/post/597625/ | null | ru | null |
# Печатаем книги-брошюры в *nix
Наверняка у многих из тех, кто читает этот пост, возникало желание распечатать некую книгу на бумаге и сделать это так, чтобы книга была по удобству близка к типографской. Конечно, в роли книги может выступать как какой-нибудь pdf-документ, так и какая-нибудь tex'овая научная работа.
Ну а что же такое брошюра? По сути — это такая тетрадка, каждый лист которой является половиной большого листа, а общее количество страниц легко рассчитать по формуле **<кол-во «больших» листов>\*2<сколько «маленьких листов» на «большом»>\*2<два оборота у листа=2 страницы>**.
Конспект по матану, каталог avon — это брошюра. Больш**а**я часть книг представляет из себя несколько брошюр, наверняка вы встречались с ситуацией, когда из старых потрёпанных книг выпадает одновременно несколько страниц, сложенных «в тетрадку»; так же часто такие тетрадки специально вырываются из учебников, чтобы использовать в качестве шпаргалок, но это не тема нашей беседы.
В этой статье я постараюсь объяснить как просто и быстро распечатать любой документ в виде брошюры.
#### Получаем PostScript документ
Итак, у нас имеется некий документ. Первым делом, откройте его в каком-нибудь просмотрщике (н-р в **evince**) и "**распечатайте в файл**". На выходе мы должны получить PostScript файл, с которым мы и будем далее работать.
Назовём этот файл, например, *book.ps*.
#### Обрабатываем PostScript файл
Итак, определимся с целью: на выходе мы должны получить файл, распечатав который, мы получим брошюру.
1)`psbook book.ps 1.ps`
Эта команда дополнит документ пустыми страницами в нужных местах для того, чтобы количество страниц стало кратным 4м.
2)Теперь нам необходимо «склеить» каждые 2 страницы A4 в одну страницу A4, иными словами, мы должны получить документ, на каждой странице которого будет по 2 страницы A5.
`psnup -la4 -2 1.ps > result.ps`
3)Теперь удалим рудементарный файл 1.ps
`rm 1.ps`
и приступим к печати получившейся брошюры
*В качестве альтернативы, все три шага можно объеденить в один, используя конвейры: psbook book.ps | psnup -la4 -2 > result.ps*
#### Распечатываем брошюру
Самый интересный момент, с которым мне пришлось повозиться из-за моей природной лени.
1) Откройте получившийся файл result.ps в просмотрщике и распечатайте **нечётные** страницы.
2) Теперь пересортируйте листы так, чтобы первая страница стала последней, а последняя — угадайте — первой. Вставьте отсортированные листы в принтер так, чтобы печать проводилась с обратной стороны **конца** распечатанной страницы.
*На моём HP Photosmart последний шаг делается простой вставкой страниц «как есть», то есть после сортировки, не переворачивая страницы, вставляем в лоток листы так, чтобы верх распечатанных до этого страниц был спереди и видим.*
3) А теперь распечатайте **чётные** страницы.
4)После распечатки достаточно сложить распечатанные страницы слева направо
##### Hints
1) Не следует использовать «обратный порядок печати» в совокупности с указанием чётности/нечётности страниц, с целью пропустить шаг с пересортировкой страниц. Это не допустит неверного порядка распечатки и неверных страниц для распечатки.
2)Если бумага — тонкая, то следует перед первой печатью «перелестать» листы. Пересортировка перед второй печатью (см. пункт выше) так же поможет не допустить слипания страниц.
#### Скрепление страниц
Нам потребуется иголка/шило, скобки от степлера, ручка/карандаш, 2 скрепки.
1)Распечатанные листы укладываем ровной стопкой, закрепляем верхний левый и правый нижний углы скрепками, теперь складываем листы слева направо.
2)В центре намечаем 2 точки: на сантиметр ниже верха и на сантиметр выше низа. Берём скобку и прикладываем в первой точке верхом, отмечаем точку в месте, где скобка кончается. Аналогично прикладываем к нижней точке низом скобки и ставим точку в месте, где скобка начинается.
*Давайте опустим, что скобки не имеют ни ничала ни конца :)*
3)В намеченных точках делаем шилом/иголкой дырки и вставляем в них скобки, закрывая их с внутренней стороны пальцем/чем нибудь твёрдым.
4)Убираем скрепки, радуемся :)
#### Я не художник, но попытался
Мои художественные способности ниже плинтуса, но я таки попытался руками на бумаге зарисовать как нужно ложить бумагу и расписал основные шаги: [img148.imageshack.us/img148/4875/brove.jpg](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg148.imageshack.us%2Fimg148%2F4875%2Fbrove.jpg%22)
#### Ссылки по теме
\*) [Использование psutils — пакета для работы с PostScript файлами](http://www.opennet.ru/base/sys/psutils.txt.html)
\*) [Making booklets with psbook and psnup](http://209.85.229.132/search?q=cache:d_ukDC8KyIsJ:www.pjls16812.pwp.blueyonder.co.uk/psbook/index.html) (гугло-кеш)
**P.S.**Отлично понимаю что статья описывает достаточно тривиальную задачу, но я уверен тем, кто хочет распечатать статью брошюркой, не сделав при этом 3-4 «корявые» распечатки, она поможет.
**P.S.S.**Метался между блогом «принтеры» и «Linux для всех», перенёс в последний, думаю, так правильней. | https://habr.com/ru/post/79921/ | null | ru | null |
# Установка и запуск Android-приложений на Linux
Как известно, многие Android-приложения можно нативно запускать на Chrome OS благодаря библиотеке [Chrome App Runtime](https://developer.chrome.com/apps/app_runtime).
С помощью расширений [chromeos-apk](https://github.com/vladikoff/chromeos-apk) и [ARChon](https://github.com/vladikoff/chromeos-apk/blob/master/archon.md) запуск Android APK стал возможен и на других ОС.
В этой публикации я расскажу, как установить произвольное Android-приложение на Ubuntu 14.04.
Исходные инструменты:
* Ubuntu 14.04 LTS;
* Chrome 39.0 (подойдет и другая версия 37+).
**Устанавливаем ARChon Runtime**
1) [Скачиваем](http://archon-runtime.github.io/#downloads) и распаковываем ARChon в произвольную дирректорию;
2) Открываем Chrome и включаем Developer mode в *chrome://extensions/*;
3) Кликаем «Load unpacked extension» и устанавливаем распакованный ARChon.
Далее необходимо подготовить архив APK для установки.
**Устанавливаем chromeos-apk**
1) Для Ubuntu прежде всего нужно установить библиотеку lib32stdc++6:
```
sudo apt-get install lib32stdc++6
```
2) chromeos-apk можно установить с помощью менеджера пакетов npm (поставляется вместе с [node.js](http://nodejs.org/)).
3) Сейчас можно установить непосредственно chromeos-apk:
```
npm install chromeos-apk -g
```
Теперь все готово к распаковке APK.
**Подготавливаем APK с помощью chromeos-apk**
1) Для распаковки APK-архива выполняем:
```
chromeos-apk path/to/file.apk
```
2) Теперь у нас есть Chrome-APK расширение, и все что нужно — загрузить (*chrome://extensions/*) и запустить его.
UPD: полезные ссылки от [sequence](http://habrahabr.ru/users/sequence/)
[ARChon Packager](https://play.google.com/store/apps/details?id=me.bpear.archonpackager): создает архивы для archon из установленных в телефоне приложений.
[twerk](https://chrome.google.com/webstore/detail/twerk/jhdnjmjhmfihbfjdgmnappnoaehnhiaf): расширение хром, сильно облегчает конвертацию apk. | https://habr.com/ru/post/253238/ | null | ru | null |
# Захват видео с камеры и передача его по сети
#### Предисловие
Не так давно, возникла необходимость захвата видео с web камеры и передавать его по сети используя .Net.
Так как с подобной задачей я столкнулся впервые, то первым делом начал искать информацию по этому вопросу.
Как выяснилось, что в чистом .Net нет поддержки работы с web камерами. Перебрав несколько различных библиотек, свой выбор остановил на Aforge.net.
Aforge.net — это фреймворк для решения целого ряда задач, из которого нам понадобится библиотеки AForge.Video.
#### Захват изображения
Для захвата видео с устройства видео ввода существует класс `AForge.Video.DirectShow.VideoCaptureDevice`. Ему необходимо задать моникер устройства с которого будет происходить захват. Так же необходимо задать обработчик события `NewFrame`. Это событие возникает каждый раз, когда с устройства будет получен новый кадр, который и передается в обработчик в виде объекта `Bitmap`, где его уже можно обработать:
```
private void VideoSourceNewFrame(object sender, AForge.Video.NewFrameEventArgs eventArgs)
{
var img = (Image) eventArgs.Frame;
using (var ms=new MemoryStream())
{
img.Save(ms,ImageFormat.Jpeg);
//Сохраняем изображение в массив байт, для последующего формирования mjpeg
_bufImage = ms.ToArray();
}
}
```
Запуск видеозахвата осуществляется вызовом метода `Start()`.
Список доступных видеокамер, установленных в системе, можно получить с помощью класса `FilterInfoCollection`, передав ему, в качестве параметра, необходимую категорию устройств:
```
var videoDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
```
Это класс представляет из себя коллекцию элементов FilterInfo, которые содержат в себе два поля:
* Name — название устройства
* MonikerString — моникер устройства.
Таким образом, получив моникер устройства мы можем передать его в класс `VideoCaptureDevice`.
#### Формирование видео-потока MJPEG
MJPEG (Motion JPEG) является простейшим алгоритмом видеосжатия, поэтому свой выбор я остановил именно на нем.
Поток видео MJPEG представляет из себя последовательно идущие кадры в JPEG формате дополненные http заголовком:
```
HTTP/1.1 200 OK
Cache-Control: no-cache
Pragma: no-cache
Transfer-Encoding: chunked
Content-Type: multipart/x-mixed-replace; boundary=--myboundary
Expires: -1
--myboundary
Content-Type: image/jpeg
Content-Length:96719
.....image.......
--myboundary
Content-Type: image/jpeg
Content-Length:96720
.....next image.......
```
Пример реализации:
```
public ActionResult Video()
{
Response.Clear();
//Устанавливает тип передаваемых данных и разделитель кадров
Response.ContentType = "multipart/x-mixed-replace; boundary=--myboundary";
//Отключаем кеширование
Response.Expires = 0;
Response.Cache.SetCacheability(HttpCacheability.NoCache);
var ae = new ASCIIEncoding();
//Передаем поток пока клиент не отключится
while (Response.IsClientConnected)
{
try
{
//_bufImage - переменная, в которой хранится новый кадр в формате jpeg
var buf = _bufImage;
//Формируем заголовок разделителя
var boundary = ae.GetBytes("\r\n--myboundary\r\nContent-Type: image/jpeg\r\nContent-Length:"
+ buf.Length + "\r\n\r\n");
Response.OutputStream.Write(boundary, 0, boundary.Length);
Response.OutputStream.Write(buf, 0, buf.Length);
Response.Flush();
//Усыпляем поток, для поддержки частоты кадров 20 кадров/с
Thread.Sleep(50);
}
catch (Exception)
{
}
}
Response.End();
return null;
}
```
[Aforge.net](http://www.aforgenet.com/)
[MJPEG](http://ru.wikipedia.org/wiki/MJPEG)
[Ссылка на исходник в Google Docs](https://docs.google.com/file/d/0B88gxMJybTlxV1k5eXQ4ZU5yZXc/edit) | https://habr.com/ru/post/177793/ | null | ru | null |
# Создание сложных приложений в ExtJS.
Автор: [Jozef Sakalos, aka Saki](http://extjs.eu/)
Статья в оригинале: [Создание сложного приложение в Ext](http://blog.extjs.eu/know-how/writing-a-big-application-in-ext/) на blog.extjs.eu
Предисловие
===========
Я решил написать эту статью для тех пользователей [Ext](http://extjs.com/) 2.x, которые уже переросли одну единственную HTML-страницу со встроенными скриптом, создающим простое окно или форму, для тех, которые уже решили, что Ext — это их путь и для тех, которые превозмогая трудности связанные с большими объемами кода, понимают, что нуждаются в его структурировании.
Сколько людей, столько и мнений. И поэтому способ, который я опишу ниже, не является одним единственным возможным. Также хотелось бы отметить, что не каждое приложение, написанное с применением этого подхода, является гарантированно хорошим. Ничего подобного.
Замечу, что описываемый подход является работоспособным, четко структурированным, без труда поддерживаемым и, одним словом: рабочим!
Что значит сложное приложение?
==============================
Когда вы оперируете объектом Viewport с BorderLayout, grid-таблицей и формой в одном файле, это, конечно же, не сложное приложение, правда? Если же у вас десятки окон, в каждом из которых grid-таблицы, формы или BorderLayout и все это добро раскидано по десяткам файлов, то это уже сложное и большое приложение, верно?
*В немецком языке имеется одно милое словечко: Jein = Ja + Nein*
Ответом на оба приведенных утверждения будет **Jein**. Вопрос заключается в следующем: когда приложение становится большим и сложным? Ответ прост: в тот самый момент как вы начинаете его таковым ощущать. Это момент когда становится сложно ориентироваться в большом количестве файлов или начинаются проблемы при поиске определенного места в случае попытки понять отношение компонентов, например, и так далее.
Можно с уверенностью говорить, что каждое приложение сложно столь же насколько простое достойно быть хорошо написанным и может стать по-настоящему большим, как только мы начнем добавлять новый функционал, наращивать объем кода, добавлять правила CSS и т.д.
Лучшей и самой безопасной установкой при создании нового приложения является — «Я начинаю сложное приложение!»
Файлы и директории
==================
То, что необходимо организовать в первую очередь. В нашем распоряжении всегда имеется каталог DocumentRoot так что все подкаталоги, затронутые ниже, будут приводиться относительно него.
Рекомендуемая структура каталогов:
* ./css (опциональная link)
* ./ext (ссылка)
* ./img (ссылка)
* ./js
* index.html
Слово «ссылка» означает, что каталог является мягкой ссылкой на реальный каталог, где лежат файлы. Преимущество этого приема в том, что, например, вы можете загрузить новую версию Ext в любой реальный каталог и заставить ссылку указывать на него, что избавит от редактирования путей в вашем коде. Можно проводить тестирование новой версии и если все в порядке, оставить ссылку указывать на новую версию, а если нет, то просто вернуть ее назад.
* **css** — хранилище всех ваших стилей. Если у вас имеются глобальные стили, вроде цветов компании или оформления шрифтов, то вы также можете создать этот каталог как ссылку;
* **ext** — ссылка на используемую вами версию Ext, как это было описано ранее;
* **img** — каталог с вашими изображениями. Также может содержать подкаталоги для иконок и т.п.;
* **js** — будет содержать все JavaScript файлы приложения, а также их скомпонованную версию;
* **index.html** — HTML-файл являющийся входной точкой вашего приложения. Вы можете назвать его как угодно, да и быть html-файлов может несколько, например, для операции аутентификации. Но в любом случае файл входной точки (с обработчиком onReady) должен быть один;
* *дополнительно* вы можете создать директорию или ссылку на серверную часть приложения (./classes в моем случае). Можно дать ей какое угодно имя, но следует выбрать согласующееся со всеми приложениями, которые вы разрабатываете (имена ./server, ./php будут неплохими вариантами).
### index.html
Минимальное содержимое *index.html* может быть следующим:
>
> ```
>
>
>
>
>
>
>
>
> A Big Application
>
>
>
> ```
>
Хотя вы и можете работать с файлом подобным приведенному выше, я рекомендую добавлять заголовочную информацию как к этому типу файлов, так и ко всем иным. Маркер конца файла также имеет значение. См. [примеры](http://blog.extjs.eu/category/patterns/file-patters) такого рода заголовков.
### js/application.js
Нам понадобится файл, где мы сможем поместить onReady обработчик. Пусть его имя будет *application.js*. Минимальное содержимое такого файла приведено ниже:
>
> ```
> // vim: sw=4:ts=4:nu:nospell:fdc=4
> /**
> * An Application
> *
> * @author Ing. Jozef Sakalos
> * @copyright (c) 2008, by Ing. Jozef Sakalos
> * @date 2. April 2008
> * @version $Id$
> *
> * @license application.js is licensed under the terms of the Open Source
> * LGPL 3.0 license. Commercial use is permitted to the extent that the
> * code/component(s) do NOT become part of another Open Source or Commercially
> * licensed development library or toolkit without explicit permission.
> *
> * License details: http://www.gnu.org/licenses/lgpl.html
> */
>
> /*global Ext, Application */
>
> Ext.BLANK_IMAGE_URL = './ext/resources/images/default/s.gif';
> Ext.ns('Application');
>
> // application main entry point
> Ext.onReady(function() {
>
> Ext.QuickTips.init();
>
> // code here
>
> }); // eo function onReady
>
> // eof
> ```
>
Ваши код может иным, но обязательным шагом будет установка *Ext.BLANK\_IMAGE\_URL* в значение, ссылающееся на ваш сервер. Это путь к прозрачному 1х1 изображению, которое используется Ext в качестве плэйсхолдера и если он ведет в пустоту, вы можете столкнуться с различными проблемами отрисовки такими как: отсутствие изображения стрелки в *Ext.form.ComboBox*, иконок и т.п.
Возможно, что вам также понадобится создать глобальную переменную для вашего приложения (в данном случае это *Application*).
В чем вы должны быть уверенны, так это в том, что onReady обработчик наличествует у вас лишь однажды — в точке входа в приложение.
### css/application.css
Поместите в этот файл все свои стили, если они у вас есть. В случае если вам необходимо лишь малое число таковых, то, возможно, не имеет смысла создавать для них отдельный файл. Можно записать их непосредственно в документ, используя `.`
Наоборот, помните, что вы создаете сложное приложение, стало быть, всему свое место. Если вы будете писать стили в заголовок документа, то вам рано или поздно придется решать проблемы с отрисовкой и вы не будете знать какие стили побудили их.
Как делать не надо
==================
Что обычно следует за тем как был получен некий базис, такой, какой имеется у нас на данном этапе? Начинаем писать код. Итак, мы погрузились в кресло и начали творить:
>
> ```
> var vp = new Ext.Viewport({
> layout:'border'
> ,items:[
> new Ext.grid.GridPanel({
> store:new Ext.data.Store({
> proxy:new Ext.data.HttpProxy({ ...
> ```
>
Одну минуточку. Развивая подобное, мы очень скоро будем иметь все 10000 строк кода в *application.js*, а это последнее что нам необходимо. Очевидно, был пропущен какой-то этап. Если мы создали такой огромный файл, почему бы нам не вставить его код непосредственно в *index.html*?
Правильный путь: разделяй и властвуй
====================================
Любое целое, вне зависимости от его размера, состоит из более малых систем, которые, в свою очередь, состоят из еще более малых частей, содержащих некоторые элементы. Ваше разрабатываемое сложное приложение не исключение. И вот сейчас как раз время чтобы определить для себя эти части, компоненты и связи между ними.
Итак, еще более удобно усядьтесь, хорошо подумайте, нарисуйте эскиз, составьте список, не принципиально, что вы будете именно делать, главное чтобы в результате у вас на руках был перечень компонент, из которых будет состоять ваше приложение. По крайней мере, главных из них.
Преднастроенные классы
======================
Ну вот, как только вы покончили с анализом и определением составных частей своего приложения можно приступить к написанию одного из них. Как лучше всего это сделать? Наилучшим решением будет написание классов расширяющих стандартные компоненты Ext, ввиду того, что последние уже имеют все настройки, перезаписываемые переданными в их конструкторы значениями. Я называю такие расширения преднастроенными классами т.к. они редко вносят новый функционал и служат в основном для конфигурирования. Примером может служить grid-таблица «Персонал» со своею моделью колонок, хранилищем, настройками сортировки, редакторами и т.д.
В таком случае конфигурация нашего окна могла бы выглядеть следующим образом:
>
> ```
> var win = new Ext.Window({
> title:'Personnel'
> ,widht:600
> ,height:400
> ,items:{xtype:'personnelgrid'}
> });
> win.show();
> ```
>
Написание преднастроенного класса
=================================
Разберемся на примере:
>
> ```
> Application.PersonnelGrid = Ext.extend(Ext.grid.GridPanel, {
> border:false
> ,initComponent:function() {
> Ext.apply(this, {
> store:new Ext.data.Store({...})
> ,columns:[{...}, {...}]
> ,plugins:[...]
> ,viewConfig:{forceFit:true}
> ,tbar:[...]
> ,bbar:[...]
> });
>
> Application.PersonnelGrid.superclass.initComponent.apply(this, arguments);
> } // eo function initComponent
>
> ,onRender:function() {
> this.store.load();
>
> Application.PersonnelGrid.superclass.onRender.apply(this, arguments);
> } // eo function onRender
> });
> Ext.reg('personnelgrid', Application.PersonnelGrid);
> ```
>
Что у нас тут происходит? Мы расширяем *Ext.grid.GridPanel*, создавая новый класс-расширение *Application.PersonnelGrid* и регистрируем для него новый xtype с именем *personnelgrid*.
По сути, мы передаем обычной grid-таблице все настройки достаточные для превращения ее в специализированную grid-таблицу «Персонала». Начиная с этого момента, у нас имеется новый компонент, строительный блок нашего приложения, который мы можем использовать где угодно (в окне, на панели, самостоятельно) для отображения списка сотрудников. Создать его можно следующим образом:
>
> ```
> var pg = new Application.PersonnelGrid();
> ```
>
или используя xtype (т.н. ленивое создание):
>
> ```
> var win = new Ext.Window({
> items:{xtype:'personnelgrid'}
> ,....
> });
> ```
>
Организация и хранение преднастроенных классов
==============================================
Код приведенный выше не нуждается, да и не будет запускаться в обработчике onReady — он не оперирует DOM, а просто создает JavaScript объект. Следовательно, он может и должен быть помещен в отдельный файл (*js/Application.PersonnelGrid.js*) и будет включаться в хедер *index.html*.
Что ж, пока все идет хорошо — у нас почти все готово и все (почти), что нам нужно так это продолжать описывать преднастроенный классы, класть их в ./js, включать в *index.html* и собирать наше приложение из их экземпляров как кусочки головоломки.
Выглядит неплохо, а?
Межкомпонентное сообщение
=========================
Представьте себе, что вам необходимо рамочный макет (border layout) со списком ссылок слева (west region) и панелью закладок посередине (center region). Щелчок по ссылке должен создавать новую закладку в центре. Где вы поместите логику всего происходящего, обработчик события и код создания? Слева или в центре?
Нигде. Почему? Если у нас есть преднастроенный класс, который создает и отображает список слева, а мы помещаем логику туда, то его существование теряет смысл без центрального региона. Мы просто не сможем использовать список без панели закладок.
Если же мы поместим логику в центральную область, итог будет схожим: панель закладок не может существовать без списка ссылок.
Есть только один компонент осознающий существование левой и центральной панелей — это их контейнер с рамочным макетированием, единственное правильное место для размещения логики межкомпонентного сообщения.
Производственная система
========================
Ввиду соглашения об организации нашего приложения очень рано мы столкнемся с большим числом JavaScript файлов (в моем случае порядка 80 и их число растет с каждым днем), что может негативно сказаться на производительности реально работающей, не тестовой, системы.
Наилучшим решением является слияние (конкатенация) всех JavaScript файлов в нужном порядке следования итогом чего станет один большой файл, который затем необходимо сжать одним из инструментов минификации или сжатия.
Производственная система будет подключать:
* ext-all.js
* app-all.js
* application.js
Дополнительная информация по сжатию вашего кода, а также созданию файлов билдов может быть найдена в [другом руководстве](http://extjs.com/learn/Tutorial:Building_Ext_From_Source).
Заключение
==========
В общем-то это все… Существуют специализированные техники для некоторых классов Ext, много иных серверных и клиентских фишек, но то, что было изложено выше — общая концепция.
Счастливого кодинга!
---
На правах переводчика: * Статья зацепила меня тем, что описывает общую концепцию работы со сложным приложением в конкретном случае разработки в ExtJS;
* далее перевод планируется поместить в [официальный мануал](http://extjs.com/learn/) проекта рядом с [оригиналом](http://extjs.com/learn/Tutorial:Writing_a_Big_Application_in_Ext), поэтому просьба реагировать не только плюсами и минусами, но и в текстовом виде, пожалуйста;
* кажущийся странным танец вокруг ссылок при описании файловой организации обусловлен тем, что сами разработчики ExtJS интенсивно используют построение собранных из множества файлов билдов. В таком случае новая версия того же ExtJS это как все исходное дерево, так и билд фреймворка. Гораздо удобнее, конечно, изменить ссылку, чем копировать туда-сюда много файлов. | https://habr.com/ru/post/31589/ | null | ru | null |
# Прокси хранилища 1С (IIS, OneScript)
**В этом посте мы поговорим о том, как избавиться от версионной зависимости, проверять комментарии, вызывать веб-хуки и делать красивые пути. И все это на привычном IIS и понятном OneScript.**
### Для чего, зачем и почему
Во всех командах разработки рано или поздно возникает потребность привязки изменений кода к номерам задач. В итоге команды приходят к решению в виде комментариев в хранилище 1С. Но часто ли разработчики соблюдают это правило? Также может срабатывать человеческий фактор: можно ошибиться буквой, цифрой, задачей, ее статусом, исполнителем, системой, местом работы. Приходится перевыкладывать хранилище через gitsync, переделывать связи, тратить лишнее время и силы.
А ещё хочется в работу добавить эстетики. Например, при подключении к хранилищу через HTTP — почему бы не убрать уродливые \***.1ccr** и не сделать красивый адрес хранилища?
При подключении через tcp на разных версиях 1С надоело угадывать, на каком порту какая версия находится.
Плюс есть, например, у меня потребность начать синхронизацию с git-репозиторием по факту помещения очередной версии в хранилище. Прилепим вызов синхронизации? Запросто!
Появилась еще одна возможность встроиться в механизм транспорта между конфигуратором и хранилищем 1С, а по пути проверять комментарии, вызывать сторонние сервисы и делать прочие полезности. И все это на знакомом нам, одинэсникам, языке программирования и веб-сервере.
Если совсем коротко
-------------------
На Windows-сервере располагаются файловые хранилища конфигураций 1С. Для доступа к ним на том же сервере настроен tcp-сервер хранилища 1С (crserver.exe). Также настроен доступ к хранилищу по HTTP на IIS. Предполагаем, что после внедрения доступ к хранилищам остается только по HTTP. Хранилища более не будут доступны по tcp или файловым шарам.
В IIS добавляется расширение от Microsoft "URL Rewrite" для запрета доступа к оригинальной публикации хранилища (чтобы нельзя было действовать в обход "прокси"), а также для красивых адресов хранилищ.
На сервер устанавливается OneScript. Будем использовать его механизм HTTP-сервисов. В IIS добавляется публикация на OneScript. Внутри публикации создается файл `.os`, в нем на OneScript происходит обработка запросов конфигуратора. Запросы можно парсить, проверять комментарии, возвращать нативную для конфигуратора ошибку, во время запроса вызывать сторонние сервисы (например, gitsync), осуществлять маршрутизацию между версиями 1С и прочее.
Не все так страшно, как кажется!
А теперь подробности
--------------------
### Настройка доступа tcp
Справка на ИТС [тут](https://its.1c.ru/db/v8320doc#bookmark:dev:TI000001131), статья от WiseAdvice [здесь](https://wiseadvice-it.ru/o-kompanii/blog/articles/hranilishhe-konfiguracii-v-1s-8-3-ustanovka-i-nastroika/).
Допустим, все наши хранилища лежат на сервере в `D:\Confstores`
1С рекомендует настраивать следующим образом:
```
crserver.exe -instsrvc | -rmsrvc -usr <пользователь> -pwd <пароль>
-start | -stop
-port <порт> -d <каталог>
```
**Этот метод нам не подходит.**
При вызове с ключом -initsrvc старая служба заменяется новой. Нам же нужно запустить сразу несколько версий 1С. Поэтому лучше воспользоваться sc.exe, где в параметрах указывать нужные версии. Каждую версию вешаем на свободный tcp-порт:
```
sc.exe create <имя сервиса, например "1c_storage_8_3_21_1624"> binPath="C:\Program Files\1cv8\8.3.21.1624\bin\crserver.exe -srvc -port 1542 -d D:\ConfStores"
```
Например, так:
Отлично! Теперь мы можем подключаться из любой используемой версии 1С по соответствующему порту:
`tcp://<имя_сервера>:<порт>/<имя_хранилища>`
Например `tcp://server:1542/erp`
### Доступ по HTTP
[Справка ИТС](https://its.1c.ru/db/v8320doc#bookmark:dev:TI000001125).
Создадим несколько публикаций на IIS, каждая их которых смотрит на свои tcp-порты в соответствии с версиями.
Для каждой версии должно быть по 2 файла:
Содержание web.config:
```
xml version="1.0" encoding="UTF-8"?
```
**maxAllowedContentLength="4294967295"** — запросы конфигуратора и ответы ему могут быть довольно большими, поэтому увеличиваем допустимый размер передаваемых данных до максимального.
Каждый файл должен быть под "свою" версию. Внутри 2 места для исправления: `"add name="8_3_21_1484""` и путь к `wsisapi.dll`
Содержание storage.1ccr:
```
xml version="1.0" encoding="UTF-8"?
```
Ссылается на текущий сервер, на порт 2543. Не забудьте поменять порт на тот, который вы указали для текущей версии при настройке доступа по tcp.
Добавим под каждую версию свой пул приложения (Application pool) в IIS:
Далее в Sites —> Default Web Site надо найти папки, которые мы создавали ранее, через контекстное меню нажать "Convert to application". Не забудьте выбрать нужный Application pool, иначе по умолчанию установится DefaultAppPool:
Теперь можно пробовать подключаться к хранилищу по http:
`http://<имя_сервера>/<имя_публикации>/storage.1ccr/<имя_хранилища>`
Например <http://server/pool_8_3_21_1484/storage.1ccr/erp>
### Учим IIS понимать OneScript
Для начала его [нужно установить](https://oscript.io/downloads). Проверка: в `cmd` набрать слово `oscript`:
Для управления обменом с хранилищем будем использовать [механизм http-сервисов OneScript](https://oscript.io/docs/page/http).
Как это работает в двух словах: при обращении по адресу `http://<имя_сервера>/<имя_публикации>/<имя_файла>.os` после всех настроек будет вызываться указанный нами далее файл \*.os, в котором обязательно должна быть экспортная функция `ОбработкаВызоваHTTPСервиса(Запрос)`.
Эта функция должна возвращать ответ типа `HTTPСервисОтвет` (например, `Новый HTTPСервисОтвет(200)`, где 200 — код состояния HTTP).
Между запросом и ответом и будет выстроена вся наша деятельность: анализ тела запроса, вызов сервисов, подмена ответа либо отправка оригинального ответа конфигуратора.
Чтобы сделать публикацию HTTP-сервиса OneScript, нам понадобится сделать:
**1.** Новую папку в `C:\inetpub\wwwroot`. В нашем примере предлагаю называть ее `storage`. Внутри структура будет следующая:
**2.** В папку `bin` нужно поместить файлы, которые можно взять из `bin` установленного OneScript:
```
ASPNETHandler.dll
DotNetZip.dll
ICSharpCode.AvalonEdit.dll
Newtonsoft.Json.dll
OneScript.DebugProtocol.dll
OneScript.DebugServices.dll
OneScript.Language.dll
ScriptEngine.dll
ScriptEngine.HostedScript.dll
ScriptEngine.NativeApi.dll
ScriptEngine.NativeApi32.so
ScriptEngine.NativeApi64.dll
ScriptEngine.NativeApi64.so
```
**3.** Файл web.config:
```
xml version="1.0" encoding="UTF-8"?
```
Здесь, грубо говоря, описано, какими dll обрабатывать файлы с расширением .os, допустымые размеры данных, а также пара настроек для движка OneScript в конце.
**4.** *Под описание storage.os выделяю отдельный следующий раздел.*
**5.** В IIS конвертировать публикацию `storage` в приложение, определить для него отдельный Application pool с pipeline mode - classic и .NET CLR Version v4.0.
### Создание скрипта .os
В общем случае скрипт выглядит так:
```
Функция ОбработкаВызоваHTTPСервиса(Запрос) Экспорт
Возврат Новый HTTPСервисОтвет(200);
КонецФункции
```
При вызове http-сервиса, например, через браузер, IIS будет искать, какие dll запускать для файла с расширением .os, dll будут искать функцию `ОбработкаВызоваHTTPСервиса` и на возврате ожидать `HTTPСервисОтвет`.
Чтобы из файла сделать прокси хранилища 1С, допишем всего пару строк:
Самый простой прокси
```
Функция ОбработкаВызоваHTTPСервиса(ЗапросКонфигуратора) Экспорт
//наш файл 1ccr нужной версии 1С
АдресХранилища = "http://127.0.0.1/storage_8_3_20_1789/storage.1ccr";
//внутри запрос конфигуратора текстом; можно извлекать двоичные данные, но строку анализировать проще
ТелоЗапроса = ЗапросКонфигуратора.ПолучитьТелоКакСтроку();
//создаем запрос в хранилище
ЗапросВХранилище = Новый HTTPЗапрос;
ЗапросВХранилище.УстановитьТелоИзСтроки(ТелоЗапроса);
//соединение с хранилищем
Соединение = Новый HTTPСоединение(АдресХранилища);
ОтветХранилища = Соединение.ОтправитьДляОбработки(ЗапросВХранилище);
Ответ_ДвоичныеДанные = ОтветХранилища.ПолучитьТелоКакДвоичныеДанные();
//хранилище всегда отправляет 200 вне зависимости от успеха операции
ОтветКонфигуратору = Новый HTTPСервисОтвет(200);
ОтветКонфигуратору.УстановитьТелоИзДвоичныхДанных(Ответ_ДвоичныеДанные);
//встроенная функция Onescript. Следует использовать, чтобы процесс нашего
//application pool IIS (w3wp.exe) не разрастался в памяти, т.к. запрос между конфигуратором
//и хранилищем может быть большого размера, а мы его еще и распаковываем в строку.
//Неизвестно когда сборщик мусора решит провести уборку, поэтому уберемся принудительно
ВыполнитьСборкуМусора();
Возврат ОтветКонфигуратору;
КонецФункции
```
Здесь все тривиально: получили запрос, отдали в хранилище, получили ответ, отправили конфигуратору.
Пространство для маневра открывается невообразимое :)
Моей изначальной целью был контроль комментариев. Конфигуратор при помещении версии в хранилище использует метод `DevDepot_commitObjects`, а при изменении старой версии `DevDepot_changeVersion`. Допишу функцию разбора запроса конфигуратора для извлечения интересующих меня атрибутов. Также сразу произведу задел на маршрутизацию по версиям 1С:
Прокси немного посложнее
```
Функция ОбработкаВызоваHTTPСервиса(ЗапросКонфигуратора) Экспорт
АдресХранилища = "";
ТелоЗапроса = ЗапросКонфигуратора.ПолучитьТелоКакСтроку();
ПараметрыЗапроса = ПолучитьПараметры(ТелоЗапроса);
Если ПараметрыЗапроса.ВерсияПлатформы = "8.3.21.1624" Тогда
АдресХранилища = "http://127.0.0.1/storage_8_3_21_1624/storage.1ccr";
ИначеЕсли ПараметрыЗапроса.ВерсияПлатформы = "8.3.21.1484" Тогда
АдресХранилища = "http://127.0.0.1/storage_8_3_21_1484/storage.1ccr";
ИначеЕсли ПараметрыЗапроса.ВерсияПлатформы = "8.3.20.1789" Тогда
АдресХранилища = "http://127.0.0.1/storage_8_3_20_1789/storage.1ccr";
Иначе
ОтветКонфигуратору = Новый HTTPСервисОтвет(200);
СтрокаОтвета =
"Версия платформы " + ПараметрыЗапроса.ВерсияПлатформы + " в настоящее время не поддерживается.
|Необходимо настроить работу версии на сервере <имя_сервера>";
ТекстОтвета = ОписаниеОтвета(СтрокаОтвета);
ОтветКонфигуратору.УстановитьТелоИзСтроки(ТекстОтвета);
ВыполнитьСборкуМусора(); //перед каждым возвратом
Возврат ОтветКонфигуратору;
КонецЕсли;
ЗапросВХранилище = Новый HTTPЗапрос;
ЗаполнитьЗаголовки(ЗапросВХранилище, ЗапросКонфигуратора);
ЗапросВХранилище.УстановитьТелоИзСтроки(ТелоЗапроса);
Соединение = Новый HTTPСоединение(АдресХранилища);
ОтветХранилища = Соединение.ОтправитьДляОбработки(ЗапросВХранилище);
Ответ_ДвоичныеДанные = ОтветХранилища.ПолучитьТелоКакДвоичныеДанные();
ОтветКонфигуратору = Новый HTTPСервисОтвет(200);
ЗаполнитьЗаголовки(ОтветКонфигуратору, ОтветХранилища);
ОтветКонфигуратору.УстановитьТелоИзДвоичныхДанных(Ответ_ДвоичныеДанные);
ВыполнитьСборкуМусора();
Возврат ОтветКонфигуратору;
КонецФункции
Функция ПолучитьПараметры(ТелоЗапроса)
ПроверяемыеМетоды = Новый Массив;
ПроверяемыеМетоды.Добавить("DevDepot_commitObjects"); //помещение в хранилище
ПроверяемыеМетоды.Добавить("DevDepot_changeVersion"); //изменение версии
СтруктураОтвета = Новый Структура("ИмяСистемы,ИмяМетода,ВерсияПлатформы,Комментарий,Проверять");
Чтение = Новый ЧтениеXML;
Чтение.УстановитьСтроку(Сред(ТелоЗапроса, 2)); //удалить BOM
Пока Чтение.Прочитать() Цикл
Если Чтение.ТипУзла <> ТипУзлаXML.НачалоЭлемента Тогда
Продолжить;
КонецЕсли;
Если Чтение.ЛокальноеИмя = "call" Тогда
СтруктураОтвета.Вставить("ИмяСистемы", Нрег(Чтение.ЗначениеАтрибута("alias")));
СтруктураОтвета.Вставить("ВерсияПлатформы", Чтение.ЗначениеАтрибута("version"));
СтруктураОтвета.Вставить("ИмяМетода", Чтение.ЗначениеАтрибута("name"));
Если ПроверяемыеМетоды.Найти(СтруктураОтвета.ИмяМетода) = Неопределено Тогда
Прервать; //если метод не нужно проверять, не надо дочитывать весь XML до конца
Иначе
СтруктураОтвета.Вставить("Проверять", Истина);
КонецЕсли;
ИначеЕсли Чтение.ЛокальноеИмя = "comment" Тогда
Чтение.Прочитать();
СтруктураОтвета.Вставить("Комментарий", Чтение.Значение);
КонецЕсли;
КонецЦикла;
Чтение.Закрыть();
Чтение = неопределено;
Возврат СтруктураОтвета;
КонецФункции
Процедура ЗаполнитьЗаголовки(Приемник, Источник)
Для каждого Заголовок из Источник.Заголовки Цикл
Приемник.Заголовки.Вставить(Заголовок.Ключ, Заголовок.Значение);
КонецЦикла;
КонецПроцедуры
//функция для конвертации строки ответа в нативный ответ конфигуратора
Функция ОписаниеОтвета(Сообщение)
СтрОтвет =
"{
|{3ccb2518-9616-4445-aaa7-20048fead174,""" + Сообщение + """,
|{00000000-0000-0000-0000-000000000000},""core83.dll:0x0000000000085BA8 crcore.dll:0x0000000000035F7A crcore.dll:0x000000000010F02C VCRUNTIME140.dll:0x0000000000001030 VCRUNTIME140.dll:0x00000000000032E8 unknown:0x0000000000000000 crcore.dll:0x00000000000C133F crserver.exe:0x00000000000092F9 core83.dll:0x00000000002AC58B core83.dll:0x00000000002AC5BC core83.dll:0x000000000017413E ucrtbase.dll:0x0000000000000000 KERNEL32.DLL:0x0000000000000000 unknown:0x0000000000000000 "",""0000000000000000000"",00000000-0000-0000-0000-000000000000},4,
|{""file://D:\ConfStores\erp"",0},""""}";
ДД = ПолучитьДвоичныеДанныеИзСтроки(СтрОтвет, "UTF-8", Истина);
Б64 = ПолучитьBase64СтрокуИзДвоичныхДанных(ДД);
ХМЛ = "xml version=""1.0"" encoding=""UTF-8""?" + Б64 + "";
Возврат ХМЛ;
КонецФункции
```
Здесь чуть сложнее: запрос конфигуратора парсится на предмет вызываемого метода хранилища, версии платформы, комментария и имени хранилища. Если у нас настроена обрабатываемая версия 1С, отправим запрос конфигуратора по адресу именно этой версии. Можем, кстати, например, заблокировать помещение/изменение версий для всех версий 1С, кроме последней, а из прошлых версий 1С оставить только чтение. Это актуально, когда на dev-контуре последний релиз, а на prod еще старый (и мы не понимаем, как работает этот черный ящик хранилища, и пишем в него только последней версией 1С, а читаем любыми версиями, в конце концов, файловый доступ к хранилищу позволяет делать так).
По поводу нативного ответа. Понятия не имею, что означает вся эта требуха из гуидов и DLL. Я ее как-то распарсил, догадался как завернуть, и оно работает в таком виде на десятке хранилищ. Подозреваю, что от версии к версии может меняться.
Выглядит нативный ответ, например, так:
Итоговое решение со всеми проверками будет выглядеть примерно следующим образом:
Финальное решение
```
Функция ОбработкаВызоваHTTPСервиса(ЗапросКонфигуратора) Экспорт
АдресХранилища = "";
ТелоЗапроса = ЗапросКонфигуратора.ПолучитьТелоКакСтроку();
ПараметрыЗапроса = ПолучитьПараметры(ТелоЗапроса);
Если ПараметрыЗапроса.ВерсияПлатформы = "8.3.21.1624" Тогда
АдресХранилища = "http://127.0.0.1/storage_8_3_21_1624/storage.1ccr";
ИначеЕсли ПараметрыЗапроса.ВерсияПлатформы = "8.3.21.1484" Тогда
АдресХранилища = "http://127.0.0.1/storage_8_3_21_1484/storage.1ccr";
ИначеЕсли ПараметрыЗапроса.ВерсияПлатформы = "8.3.20.1789" Тогда
АдресХранилища = "http://127.0.0.1/storage_8_3_20_1789/storage.1ccr";
Иначе
ОтветКонфигуратору = Новый HTTPСервисОтвет(200);
ТекстОтвета = ОписаниеОтвета("Версия платформы " + ПараметрыЗапроса.ВерсияПлатформы + " в настоящее время не поддерживается. Необходимо настроить работу версии на сервере <имя_сервера>");
ОтветКонфигуратору.УстановитьТелоИзСтроки(ТекстОтвета);
ВыполнитьСборкуМусора();
Возврат ОтветКонфигуратору;
КонецЕсли;
Если ПараметрыЗапроса.Проверять = Истина Тогда
Сообщение = ПроверитьЗапрос(ПараметрыЗапроса);
Если Сообщение <> "" Тогда
ОтветКонфигуратору = Новый HTTPСервисОтвет(200);
ТекстОтвета = ОписаниеОтвета(Сообщение);
ОтветКонфигуратору.УстановитьТелоИзСтроки(ТекстОтвета);
ВыполнитьСборкуМусора();
Возврат ОтветКонфигуратору;
ИначеЕсли ПараметрыЗапроса.ИмяМетода = "DevDepot_commitObjects" Тогда
//вызвать старт gitsync только при помещении в хранилище
ВызватьСинхронизациюБамбу(ПараметрыЗапроса.ИмяСистемы);
КонецЕсли;
КонецЕсли;
ЗапросВХранилище = Новый HTTPЗапрос;
ЗаполнитьЗаголовки(ЗапросВХранилище, ЗапросКонфигуратора);
ЗапросВХранилище.УстановитьТелоИзСтроки(ТелоЗапроса);
Соединение = Новый HTTPСоединение(АдресХранилища);
ОтветХранилища = Соединение.ОтправитьДляОбработки(ЗапросВХранилище);
Ответ_ДвоичныеДанные = ОтветХранилища.ПолучитьТелоКакДвоичныеДанные();
ОтветКонфигуратору = Новый HTTPСервисОтвет(200);
ЗаполнитьЗаголовки(ОтветКонфигуратору, ОтветХранилища);
ОтветКонфигуратору.УстановитьТелоИзДвоичныхДанных(Ответ_ДвоичныеДанные);
ВыполнитьСборкуМусора();
Возврат ОтветКонфигуратору;
КонецФункции
//У меня gitsync работает на ферме bamboo. Можно быстро и просто переделать под свои родные костыли
Процедура ВызватьСинхронизациюБамбу(ИмяСистемы)
СтруктураВеток = Новый Структура;
СтруктураВеток.Вставить("erp", "PROJECT-BRANCH1");
СтруктураВеток.Вставить("buh", "PROJECT-BRANCH2");
СтруктураВеток.Вставить("ut", "PROJECT-BRANCH3");
Ветка = неопределено;
СтруктураВеток.Свойство(ИмяСистемы, Ветка);
Если Ветка <> неопределено Тогда
Соединение = Новый HTTPСоединение("https://bamboo.local.server", ,"login", "password");
Запрос = Новый HTTPЗапрос;
Запрос.АдресРесурса = "rest/api/latest/queue/" + СтруктураВеток[ИмяСистемы];
Результат = Соединение.ОтправитьДляОбработки(Запрос);
КонецЕсли;
КонецПроцедуры
Процедура ЗаполнитьЗаголовки(Приемник, Источник)
Для каждого Заголовок из Источник.Заголовки Цикл
Приемник.Заголовки.Вставить(Заголовок.Ключ, Заголовок.Значение);
КонецЦикла;
КонецПроцедуры
Функция ПроверитьЗапрос(Параметры)
Сообщение = "";
//иногда нужно быстро и без номера задачи
Если нрег(Параметры.Комментарий) = "hotfix" Тогда
Возврат Сообщение;
КонецЕсли;
Если Параметры.ИмяСистемы = "erp" Тогда
РВ = Новый РегулярноеВыражение("^ERP-[0-9]+$");
Если НЕ РВ.Совпадает(Параметры.Комментарий) Тогда
Сообщение = "Комментарий '" + Параметры.Комментарий + "' не является задачей Jira проекта ERP";
КонецЕсли;
ИначеЕсли Параметры.ИмяСистемы = "buh" Тогда
РВ = Новый РегулярноеВыражение("^BUH-[0-9]+$");
Если НЕ РВ.Совпадает(Параметры.Комментарий) Тогда
Сообщение = "Комментарий '" + Параметры.Комментарий + "' не является задачей Jira проекта BUH";
КонецЕсли;
ИначеЕсли Параметры.ИмяСистемы = "ut" Тогда
РВ = Новый РегулярноеВыражение("^UT-[0-9]+$");
Если НЕ РВ.Совпадает(Параметры.Комментарий) Тогда
Сообщение = "Комментарий '" + Параметры.Комментарий + "' не является задачей Jira проекта UT";
КонецЕсли;
КонецЕсли;
Возврат Сообщение;
КонецФункции
Функция ПолучитьПараметры(ТелоЗапроса)
ПроверяемыеМетоды = Новый Массив;
ПроверяемыеМетоды.Добавить("DevDepot_commitObjects");
ПроверяемыеМетоды.Добавить("DevDepot_changeVersion");
СтруктураОтвета = Новый Структура("ИмяСистемы,ИмяМетода,ВерсияПлатформы,Комментарий,Проверять");
Чтение = Новый ЧтениеXML;
Чтение.УстановитьСтроку(Сред(ТелоЗапроса, 2)); //удалить BOM
Пока Чтение.Прочитать() Цикл
Если Чтение.ТипУзла <> ТипУзлаXML.НачалоЭлемента Тогда
Продолжить;
КонецЕсли;
Если Чтение.ЛокальноеИмя = "call" Тогда
СтруктураОтвета.Вставить("ИмяСистемы", Нрег(Чтение.ЗначениеАтрибута("alias")));
СтруктураОтвета.Вставить("ВерсияПлатформы", Чтение.ЗначениеАтрибута("version"));
СтруктураОтвета.Вставить("ИмяМетода", Чтение.ЗначениеАтрибута("name"));
Если ПроверяемыеМетоды.Найти(СтруктураОтвета.ИмяМетода) = Неопределено Тогда
Прервать; //если метод не нужно проверять, не надо дочитывать весь XML до конца
Иначе
СтруктураОтвета.Вставить("Проверять", Истина);
КонецЕсли;
ИначеЕсли Чтение.ЛокальноеИмя = "comment" Тогда
Чтение.Прочитать();
СтруктураОтвета.Вставить("Комментарий", Чтение.Значение);
КонецЕсли;
КонецЦикла;
Чтение.Закрыть();
Чтение = неопределено;
Возврат СтруктураОтвета;
КонецФункции
Функция ОписаниеОтвета(Сообщение)
СтрОтвет =
"{
|{3ccb2518-9616-4445-aaa7-20048fead174,""" + Сообщение + """,
|{00000000-0000-0000-0000-000000000000},""core83.dll:0x0000000000085BA8 crcore.dll:0x0000000000035F7A crcore.dll:0x000000000010F02C VCRUNTIME140.dll:0x0000000000001030 VCRUNTIME140.dll:0x00000000000032E8 unknown:0x0000000000000000 crcore.dll:0x00000000000C133F crserver.exe:0x00000000000092F9 core83.dll:0x00000000002AC58B core83.dll:0x00000000002AC5BC core83.dll:0x000000000017413E ucrtbase.dll:0x0000000000000000 KERNEL32.DLL:0x0000000000000000 unknown:0x0000000000000000 "",""0000000000000000000"",00000000-0000-0000-0000-000000000000},4,
|{""file://D:\ConfStores\baza"",0},""""}";
ДД = ПолучитьДвоичныеДанныеИзСтроки(СтрОтвет, "UTF-8", Истина);
Б64 = ПолучитьBase64СтрокуИзДвоичныхДанных(ДД);
ХМЛ = "xml version=""1.0"" encoding=""UTF-8""?" + Б64 + "";
Возврат ХМЛ;
КонецФункции
```
Далее вы самостоятельно можете исправить/добавить код по вашим требованиям. Например, не только проверять номер задачи на принадлежность системе, а еще и статус задачи. Или исполнителя. При долгих операциях, не требующих их ожидания, можно воспользоваться механизмом фоновых заданий OneScript (мы же не хотим, чтобы разработчик ждал по 10 минут помещения в хранилище?).
**Но пока что вы не сможете этим воспользоваться, потому что надо сделать...**
### Перенаправление запросов
В чем проблема:
На этом этапе у нас уже есть несколько публикаций в IIS:
```
https://<имя_сервера>/storage_8_3_20_1789/storage.1ccr
https://<имя_сервера>/storage_8_3_21_1484/storage.1ccr
https://<имя_сервера>/storage_8_3_21_1624/storage.1ccr
https://<имя_сервера>/storage/storage.os
```
Первые три мы можем использовать в конфигураторе. В строке подключения к хранилищу надо указать
```
https://<имя_сервера>/storage_8_3_20_1789/storage.1ccr/<имя хранилища>
```
Они будут работать напрямую с хранилищем, а нам это не интересно. Мы хотим, чтобы запросы проходили через наш OneScript файл.
Но вот к скрипту мы пока что подключиться не сможем, конфигуратор не поймет такое:
```
https://<имя_сервера>/storage/storage.os/<имя_системы>
```
И выдаст ошибку "хранилище не вижу, работать не буду". Все дело в том, как конфигуратор парсит строки подключения. Например, если вы укажете через tcp:
```
tcp://server/base
```
То конфигуратор поймет, что нужно подключиться к хосту server и в XML-содержимое запроса поместить имя хранилища "base".
Для HTTP подключения конфигуратор ищет имя системы обязательно по паттерну ".1ccr". Поэтому попытка заменить ".1ccr" на ".os" не увенчается успехом. Конфигуратор не знает, что такое ".os". Однако же есть третий вариант:
```
http://server/base
```
Конфигуратор понимает, что подключаться нужно по протоколу http, а выясняет имя хранилища как для tcp.
Я решил сделать так, чтобы у меня были красивые имена
```
http://server/base
```
Которые транслировались бы в
```
https://server/storage/storage.os
```
И поможет нам в этом...
### URL rewrite
Официальное расширение от Microsoft для работы со строками запросов внутри веб-сервера IIS. [Загрузить можно здесь](https://www.iis.net/downloads/microsoft/url-rewrite). Установка "далее-далее-готово" на сервере, где расположен веб-сервер.
После установки оно появится тут:
Теперь можно зайти на свой Default web site и начать создавать правила:
На скриншоте их 4:
**1.** Красивые имена указанных хранилищ перенаправляются к файлу .os
**2. 3. 4.** Запрет прямого обращения к оригинальным публикациям.
Правило перенаправления выглядит следующим образом:
Дословно означает следующее: когда пришел запрос (например [***http://server/ERP***](http://server/ERP)), то:
* взять часть запроса после первого одиночного слэша;
* сравнить ее с регулярным выражением `^ERP|BAZA1|UT$`(^ - начало строки, слово ERP или слово BAZA1 или слово UT, $ - конец строки);
* **Ignore case** - no comment;
* **Action type - Rewrite**: подменить строку запроса на ту, которая указана в Rewrite URL (тело запроса при этом никуда не денется, просто поедет немного по другому пути).
Соответственно, под такое правило у нас попадут строки подключения:
<http://server/erp>, <http://server/baza1>, <http://server/ut> — то есть имена ваших хранилищ. После добавления этого правила можно указывать строку в таком формате в конфигураторе.
**Бинго!** Запросы к хранилищу обрабатываются с помощью OneScript.
Напоследок осталось запретить подключаться напрямую к "настоящим" публикациям хранилищ. Добавить 3 правила под каждую версию 1С:
Здесь, в отличие от предыдущего правила, в Conditions добавляется `{REMOTE_ADDR} Does not match the pattern 127.0.0.1.` То есть правило должно работать всегда, кроме случая, когда сам сервер обращается к себе (чем перенаправление и является). Также в Action type выбираем Custon Response со статусом кода 403 "Отказ доступа".
### Заключение
Весь этот "троллейбус из буханки" работает уже полгода. За время работы были только проблемы с памятью в процессе IIS "w3wp.exe", обслуживающем Application pool для публикации прокси. Это вылечили функциями очистки мусора в скрипте.
15 разработчиков, ферма Bamboo и много аналитиков каждый день обращаются через этот прокси к 10 хранилищам конфигураций. Разницы по скорости и ожиданиям запросов с tcp нет. В некоторых моментах даже быстрее tcp. Видимо, tcp-серверу легче держать подключение с одним хостом, чем со многими.
Обязательность указания комментариев очень помогает в сборке релизов. Огромный плюс от ухода с версионности: достаточно добавить версию на одном сервере, а работать будет у всех сразу. Вызов синхронизации с git - одно удовольствие :)
В этой статье я хотел описать не **как правильно** делать, а **как можно**.
Как правильно — вы решите для себя сами.
Буду рад обсудить материал в комментариях :) | https://habr.com/ru/post/710130/ | null | ru | null |
# Как я сделал электронную плату для телеметрии датчиков и для управления периферией
В ходе создания робота-официанта, робота телеприсутствия, селфибота появились некоторые разработки, которыми грех не поделиться с сообществом, то есть сделать open-source. Одной из рабочих версий стала электронная плата под кодовым названием SB version 4.0, использующая недорогую и сравнительно малофункциональную Arduino, а именно, Nano 3.0. Плата SB 4.0 достаточно проста и понятна, чтобы в процессе её сборки закрепить свои знания электроники и навыки пайки, достаточно функциональна, чтобы сделать собственные практичные проекты (например, включить лампочку по сигналам с датчика движения и датчика освещенности или по вашей команде по Bluetooth), а себестоимость комплектующих с доставкой при заказе у наших китайских друзей с таобао составила около $55 (включая сами датчики).
Основное назначение платы SB 4.0 — аппаратный интерфейс. Собрав, вы можете использовать её для получения и обработки данных от нескольких предустановленных датчиков и дальнейшего принятия решения и исполнения алгоритмов. Для удобства отладки создан интерфейс в OS Windows, в котором наглядно отображаются телеметрические показания с датчиков и источника питания, состояние кнопок и сервоприводов, можно отправлять команды на микроконтроллер.
В этой публикации я опишу характеристики платы и один из примеров её применения. Повторюсь, всё это open-source, под лицензией CC Attribution Non-Commercial Share Alike.
Да, уже есть подобные платы управления и KITы с датчиками (более дорогие платы Ардуино с шилдами, у Raspberry Pi, у амперки йодо), но SB 4.0 отличается от них наличием платы питания и удобной программы контроля, написанной с помощью среды разработки LabView. То есть SB 4.0 состоит из двух плат: управления + питания. Это будет видно на фотографиях и видео.
Фотография обеих плат, датчика движения, АКБ:
#### Программирование
Для программирования микроконтроллера как всегда используем C/C++. Разработку ведём в среде Arduino IDE.
На скриншоте представлен интерфейс программы Selfiebot Control Panel, где наглядно отображаются телеметрические показания с датчиков и источника питания, состояние кнопок и сервоприводов, можно отправлять команды на микроконтроллер.
Скриншот части интерфейса:
#### Производительность
SB 4.0 использует одну из самых недорогих платформ Arduino Nano 3.0 с 8-битным микроконтроллером ATmega328. Этого достаточно для обработки кода и решения задач: управление роботами, системой умного дома и др.
#### Совместимость
Логическое напряжение — 5 В, что обеспечивает электрическую совместимость с Arduino-периферией.
#### Порты ввода-вывода
Доступны управляющие пины микроконтроллера. В скобках указал предустановленные элементы, с которыми плата уже умеет работать.
* 2 пина, которые могут конфигурироваться как цифровой вход/выход и выход ШИМ (для двух цифровых сервоприводов);
* 1 пин, цифровой вход/выход (для датчика движения);
* 3 пина, цифровой вход/выход (для RGB-светодиода);
* 1 пин, цифровой вход/выход (для концевого датчика, кнопки);
* 1 пин, цифровой выход +5В/0В (для управления внешней нагрузкой).
Шина I2C и порт UART задействованы соответственно для платы расширителя портов и модуля Bluetooth.
Предусмотрена универсальность платы SB 4.0. Согласуйте уровни питания, сигнальные уровни, тип входа/выхода! Замените предустановленные датчики на свои датчики:
* температуры
* уровня шума
* влажности
* давления и др.
Входной пин работает по принципу замкнут / разомкнут. Т.е. на пине, идущему к МК или +5В, или 0. Эти значения входят в телеметрические данные, которые отправляются на ПО Selfiebot Control Panel.
Выходной пин либо выдаёт 5В с нагрузочной способностью 1А, либо отключен — 0В. Подавать напряжение или нет на этот разъём – возможно только по внешней команде или по команде алгоритма прошивки.
Не имеет смысла подключать аналоговые датчики к цифровым пинам.
#### Питание
Питание подается через гнездо питания 2,1 мм, либо с Li-Ion аккумуляторов с контроллером заряда. Источник определяется автоматически.
В случае питания через гнездо, рекомендуемое входное напряжение — 12-12.6 В. Преобразователи напряжения DC-DC выдают на сервоприводы – 7 В, на USB1, USB2 и остальные нагрузки – 5 В. В качестве источника питания можно использовать сетевой адаптер или аккумуляторы.
Для питания периферии используйте пины 5В. При использовании внешнего источника питания, с пина 5В можно суммарно получить до 1А.
Набор для силового электропитания включает в себя:
* Батарейный блок 3х18650, 1 шт.
* Аккумулятор 18650, 3.7 В, от 2200 мАч, 3 шт.
* Контроллер заряда, 1 шт.
* Разъем питания, 1 шт.
* DC-DC преобразователи, 4 шт.
* Датчик Холла, 1 шт.
* Транзисторы, 3 шт.
* Оптопары и резисторы.
#### Коммуникация
Микроконтроллер Arduino Nano программируется по USB стандартным бесплатным программным обеспечением с сайта производителя МК. Для передачи данных между SB 4.0 и компьютером я как всегда выбрал недорогой распространенный модуль Bluetooth HC-06, скорость передачи данных 9600 Кб/с. По этому беспроводному каналу идут телеметрические данные и команды управления.
#### Габариты
У меня получились размеры электронной платы силового питания — 100×70×40 мм. Размеры электронной платы управления — 90×70×45 мм. Но уверен, можно ещё пошаманить и уменьшить габариты.
Расстояние между контактами составляет 0,1″ (2,54 мм).
#### Характеристики микроконтроллера
* Микроконтроллер: 8-битный ATmega328.
* Тактовая частота: 16 МГц.
* Флеш-память: 32 кБ (2Кб используются для загрузчика, 30Кб — для хранения кода Вашей программы).
* ОЗУ 2 КБ.
* EEPROM 1 Кб.
* Номинальное рабочее напряжение: 5 В
#### Характеристики электронной платы SB 4.0
* Номинальное рабочее напряжение: 12,6 В
* Рекомендуемое входное напряжение: 12–12.6 В.
* Максимальный ток с шины 5 В: 1000 мА
* Портов ввода-вывода общего назначения: 2
* Портов с поддержкой ШИМ: 2
Плата управления включает в себя следующие элементы:
* Bluetooth модуль HC-06, 1 шт.
* Электронная плата расширителя портов микроконтроллера, 1 шт.
* Микроконтроллер Arduino Nano 3.0, 1шт.
* Электронная плата уровня освещенности, 1 шт.
* Сервоприводы TowerPro MG966R, 2 шт.
* Фоторезистор, 1 шт.
* Датчик движения, 1 шт.
* Светодиод RGB, 1 шт.
* Кнопка, 1 шт.
* Предохранитель, 1 шт.
* Джампер, 1 шт.
* Транзистор, 1 шт.
* Конденсатор, 1 шт.
#### Практическое использование
Варианты практического использования:
1. Открывать / закрывать окна при изменении температуры.
2. Включение / выключение вентилятора при изменении влажности в помещении.
3. Включение / выключение света при наличии движения в темное время суток.
4. Включение / выключение водоснабжения при изменении влажности почвы.
5. Включение ИК подсветки, в темное время суток.
6. Передача любых телеметрических данных на сервер через интернет соединение.
#### Пример применения платы SB 4.0
Цель: при условии нажатой кнопки, включать свет при обнаружении движения.
Для этого нам дополнительно понадобятся модуль реле, лампочка (220 ADC или до 12 VDC).
1. Чаще всего мы встречаем реле 12VDC и 05VDC. Число означает, какое значение постоянного напряжения необходимо подать на вход реле.
2. Рассмотрим работу распространенного для Ардуино реле SRD-05VDC от компании Songle.
3. При подаче питания на пин Vcc и замыкании с «землей» пина Gnd, загорается зеленый светодиод.
4. Т.к. у нас одноканальный модуль, то на плате вы увидите всего один сигнальный пин In1. Если на In1 установить уровень напряжения LOW, то красный светодиод на модуле реле загорается и реле срабатывает с характерным щелчком. На Ардуино за установку уровня напряжения на пине отвечает команда digitalWrite(pin, LOW); Чтобы вернуть реле в предыдущее состояние, используйте команду digitalWrite(pin, HIGH);
5. Подключим модуль реле к плате SB 4.0, у которой предустановлен датчик движения и пользовательская кнопка.
5.1. Сигнальный пин In1 модуля реле подключим к пину 13.
5.2. В программном коде Arduino Nano находим:
```
***********************************
// работа с датчиком движения - если движение было, то запоминаем этот факт в течение timeout_SnSM
if (var_Tlm_SnSM == 1) { time_Move_detect = millis(); }
if (millis() - time_Move_detect < timeout_Move_detect) { Move_detect = 1; } else { Move_detect = 0; }
***********************************
```
Ниже этих строк добавляем:
```
***********************************
// если пользовательская кнопка нажата (== 0), то при фиксации движения (== 1) подаем сигнал на пин 13 (== LOW), на время timeout_SnSM
if (var_Tlm_BUT == 0) {
if (Move_detect == 1) { digitalWrite(PIN_D13, LOW); } else { digitalWrite(PIN_D13, HIGH); }
} else {
digitalWrite(PIN_D13, HIGH);
}
***********************************
```
5.3. Загружаем новую прошивку и включаем питание платы.
Если датчик движения обнаружил движение, то благодаря нашему алгоритму на пине питания внешней нагрузки появляется уровень LOW, реле срабатывает, замыкая цепь, и лампочка загорается.
Таким образом, если человек проходит мимо датчика движения, то лампочка включается. | https://habr.com/ru/post/397493/ | null | ru | null |
# Интеграция Open vSwitch с Р-виртуализацией
Как-то понадобилось интегрировать [Open vSwitch](http://www.openvswitch.org/) (OVS) c [Р-виртуализацией плюс Р-хранилище](https://rosplatforma.ru/)(РП), может пригодится и не только с РП.
Текущая версия РП на момент статьи была [7.0.13-31](http://updates.rosplatforma.ru/r-virtualization/releases/7.0/x86_64/iso/), ядро в этой версии 3.10.0-1062.12.1.rv7.131.10.1, что соответствует версии RedHat 7.7, а версия OVS, который идет в составе репозитория РП была 2.0.0. Список функционала на OVS 2.0.0 можно посмотреть [тут](https://www.openvswitch.org/releases/NEWS-2.0.0.txt). Ключи для РП можно взять [тут](https://yadi.sk/d/YM3YnpYNx6iayA).
Цель была попробовать настроить VXLAN и виртуальный коммутатор в качестве альтернативы родным к технологии [kvm-qemu](https://www.linux-kvm.org/page/Networking) и [libvirt](https://wiki.libvirt.org/page/Networking) мостам. Если использовать голый OpenSource kvm-qemu, то там с OVS все в порядке, но захотелось это попробовать с РП, где не просто голый kvm-qemu+libvirt, а много патчей к этой связке и есть [vstorage](https://habr.com/ru/post/486392/).
### Железо
Для этого конечно нам понадобится железо. Минимальные требования РП это три сервера в каждом по три диска, можно конечно и два если все SSD, но в моем случае один SSD остальные HDD. Далее сеть не менее 10 гигабит два порта, в моем случае повезло было 20 гигабит два порта и дополнительный порт 5 гигабит для ввода в кластер тегированного трафика для OVS в обход классическим мостам или другими словами параллельное использование классических мостов Р-виртуализации с OVS. В общем в моем случае повезло в наличии был [Synergy](https://habr.com/ru/post/319590/) c 3 лезвиями, корзинами с JBOD дисками и встроенным коммутатором.
### Развертывание РП
Краткая инструкция по установке:
1. Устанавливаем первую ноду, в анаконде назначаем IP хосту и из этой же подсети виртуальный IP для управления Р-виртуализации, и IP для управления Р-хранилищем. Дисков как минимум должно быть 3, один для хоста (ОС/гипервизор) в моем случае HDD, второй и третий диск уже настроим через управление Р-хранилищем, где один SSD под кэш и другой под чанк сервер. На втором интерфейсе назначаем IP из другой подсети для сети хранения без шлюза.
2. После установки заходим через браузер хром по IP адресу управления Р-хранилищем, далее выбираем раздел серверы и нажимаем на вопросик с прямоугольником, и выбираем раздел сеть, в нем назначаем роли для интерфейса с адресом подсети управления(роли ssh, управление, web cp) и для интерфейса с подсетью для хранения назначаем роли (ssh, хранилище).
3. Далее нажимаем создать кластер вводим его имя автоматом должен подключится интерфейс с ролью хранения и выбрать подробные настройки, убедится что система правильно распределила роли на дисках, один должен быть системный, другой служба метаданных плюс кэш если это SSD и далее третий диск HDD в роли хранения (чанк сервер).
4. Параллельно с установкой первой ноды можно устанавливать две последующие, назначить каждой по два IP адреса один для подсети управления Р-виртуализации, на втором интерфейсе из подсети хранения. Если оставить поля регистрации на сервере управления Р-виртуализации и управления Р-хранилище пустыми то, можно продолжить установку без указания IP адресов управления, а регистрацию выполнить потом.
5. После того как последующие ноды установлены пройти по IP адресу этих хостов через ssh в cli и выполнить регистрацию, где IP это адрес управления Р-хранилищем и токен можно скопировать с веб управления р-хранилищем при нажатии добавить ноду.
6. После того как обе ноды появятся в веб управлениии Р-хранилище выполнить те же действия что в пункте 2-3 только вместо создания кластера выбрать присоединить.
7. Далее после создания кластера появится пункт сервисы в нем создать хранилище датастор в зависимости наличия дисков и узлов можно делать реплику 2 или 3 и т.д. если узла 3 то, реплика 2, остальное все по умолчанию.
8. Далее проходим по IP адресу управления Р-виртуализации нажимаем добавить если физ. сервер если не добавлен и добавляем остальные, далее устанавливаем триал лицензию, далее в настройках хоста выполнить “Изменение настроек хоста для виртуальных сред” выбрать вместо локальной папки по умолчанию можно для всех пунктов(для первого раза лучше так) выбираем наш датастор который создавали в Р-хранилище и ставим галочку применить на все хосты.
9. После это мигрируем vstorage-ui и va-nm на любой другой хост, время может занять некоторое потому что это миграция с локальных носителей на кластерные.
10. После этого открываем ssh консоли всех трех узлов и вводим команду включения HA на каждом узле, где IP адрес сети хранения, после этого необходимо проверить командой #shaman stat.
11. После этого можно приступать к созданию ВМ, где я в качестве гостевой установил CentOS 7.
команда регистрации ноды к выше описанному пункту 5:
```
#/usr/libexec/vstorage-ui-agent/bin/register-storage-node.sh -m 10.43.10.14 -t ec234873
```
комнда включения HA к пункту 10:
```
#hastart -c имя кластера -n 192.168.10.0/24
```
и проверка HA, где вывод должен быть примерно такой:
```
[root@n3 ~]# shaman stat
Cluster 'rptest'
Nodes: 3
Resources: 7
NODE_IP STATUS ROLES RESOURCES
192.168.10.10 Active VM:QEMU,CT:VZ7 0 CT, 0 VM
192.168.10.11 Active VM:QEMU,CT:VZ7 0 CT, 0 VM
*M 192.168.10.12 Active VM:QEMU,CT:VZ7 2 CT, 0 VM
```
### Установка и настройка OVS
На первой и третей ноде кластера были установлены OVS следующей командой:
```
#yum install openvswitch
```
После установки можно проверить командой
```
#ovs-vsctl show
```
Вывод будет примерно следующий:
```
[root@node1 ~]# ovs-vsctl show
180c5636-2d3d-4e08-9c95-fe5e47f1e5fa
ovs_version: "2.0.0"
[root@node1 ~]#
```
Далее необходимо создать мост виртуального коммутатора на который и будем вешать порты, интерфейсы или другие мосты.
```
# ovs-vsctl add-br ovsbr0
```
Имя моста назовем так чтобы было понятно, что это экземпляр одного виртуального коммутатора.
Далее можем создать тегированный мост для добавления к определенной ВМ.
```
#ovs-vsctl add-br brlv140 ovsbr0 140
```
Тег при этом может быть не привязан к какому-то реальному тегу с физического порта, это только в рамках виртуального коммутатора.
Далее назначаем его ВМ к виртуальной сети, где предварительно создаем xml файл:
```
ovsvl
```
К сожалению веб ui Р-управления пока не поддерживает настройки с OVS, но их можно сделать через cli. Для создания и добавления виртуальных сетевых адаптеров к ВМ я воспользовался веб ui, но далее уже через cli подменил привязку этих адаптеров к ovsvl и ovsvl2 вместо Bridged. Главное потом не забыть, что изменения в сетевые настройки оборудования ВМ уже вносить через cli иначе веб ui не зная про OVS вернет Bridged.
Для просмотра существующих сетей используем команду:
```
#virsh net-list --all
```
Для добавления нашей сети:
```
#virsh net-define ovsvl.xml
```
Далее необходимо ее запустить/активировать
```
#virsh net-start ovsvl
```
И прописать в автостарт
```
#virsh net-autostart ovsvl
```
Далее необходимо добавить эту сеть к ВМ
```
#virsh edit имяВМ
```
Находим необходимые строки с интерфейсами, редактируем их или добавляем свои по аналоги существующих меняя мак адрес и номер порта(слот):
```
```
```
```
Редактирование осуществляется командами редактора vi
Далее после редактирования необходимо выключить и запустить ВМ для применения текущих настроек:
```
#prlctl stop имя ВМ
```
```
#prlctl start имя ВМ
```
Для проверки можно ввести команду:
```
#virsh dumpxml имяВМ | grep имясети
```
После этого можно приступать к настройкам сети изнутри гостя ВМ или добавить сетевые порты в коммутатор для связи с другим кластером по VXLAN overlay:
```
#ovs-vsctl add-port ovsbr0 vxlan0 -- set Interface vxlan0 type=vxlan options:remote_ip=10.43.11.12
```
где IP адрес это адрес той ноды на которой произведены такие же настройки как показано выше. Прямая связь между этими адресами может быть, как через роутеры, так и через VPN, и из разных подсетей, главное, чтобы между ними был настроен маршрут. Но еще главнее, чтобы интерфейс физического порта на котором назначен это адрес, был настроен MTU больше чем 1500 для пропускания пакетов с большим размером, так как vxlan добавляет свои данные, заголовок в несколько байт, но я не стал заморачиваться считать все байты и просто назначил 2000.
Например:
```
#ip link set mtu 2000 dev ens3f0
```
сам мост зависящий от этого интерфейса тоже должен быть с mtu2000, но он может не сразу его наследовать и возможно понадобиться его перезапустить.
На стороне второго кластера выполнить на ноде с адресом 10.43.11.12 как описано выше те же настройки только в vxlan назначить адрес ноды первой настройки в моем случае
```
#ovs-vsctl add-port ovsbr0 vxlan0 -- set Interface vxlan0 type=vxlan options:remote_ip=10.43.11.10
```
Далее также настроить mtu.
Если у вас все правильно настроено то, пойдут пинги и возможно делать подключения по ssh, если предварительно например, изнутри ВМ задать адреса из одной подсети. Если выполнить анализ сети:
```
#tcpdump –i ens3f0 | grep 4789
``` то можно увидеть пакеты с vxlan или c тегами vlan
```bash
#tcpdump -ee -vvv -i ens3f0 | grep vlan
```
Далее можно настроить более удобный вариант настройки сети без мостов через функционал виртуального коммутатора portgroup.
Для этого необходимо создать xml сети со следующим:
```
ovsvl2
```
Можно создать новую сеть или отредактировать предыдущую с этими параметрами, но в моем случае добавляю еще одну сеть.
Как описано выше, а в ВМ уже следующим образом:
```
```
```
```
Далее сохранить и перезапустить ВМ как описано выше, а на одном из виртуальных коммутаторов можно добавить транковый порт с определенными тегами от физического порта, то есть предварительно с подключенным на один из физических портов сервера с транковым тегированным трафиком от физического коммутатора.
В моем случае:
```
#ovs-vsctl set port ens3f4 trunks=120,130
#ovs-vsctl add-port ovsbr0 ens3f4
```
И можно добавить порт с тегом 120 для ВМ:
```
#ovs-vsctl add-port ovsbr0 vlan120 tag=120 -- set interface vlan120 type=internal
```
На стороне другого виртуального коммутатора на другой ноде другого кластера, где нет транка от физического коммутатора добавить точно также этот порт то есть:
```
#ovs-vsctl add-port ovsbr0 vlan120 tag=120 -- set interface vlan120 type=internal
```
Плюс добавить сеть как описано выше.
### Пример вывода настроек OVS и ВМ
*Вывод команды #ovs-vsctl show на первой ноде. Порты и интерфейсы с именем начинающимся с vme являются виртуальными интерфейсами ВМ, которые автоматически попадают в конфиг при запуске ВМ подключенному к OVS.*
*Вывод команды #ovs-vsctl show на третей ноде*
Вывод команды virsh net-list содержит 4 вида сети, где Bridged и Host-Only это стандартные классические варианты от Р-виртуализации по дефолту, а ovsvl и ovsvl2 это то, что мы добавили по инструкции выше. Ovsvl получается для варианта с тегированным мостом tag 140 поверх моста OVS, а ovsvl2 это вариант с группой портов portgroup состоящей из одного порта с tag 120. Portgroup очень удобен и в него можно добавлять больше одного порта используя только одну сеть вместо большого количества сетей в классическом варианте Р-виртуализации с мостами под которыми разные VLAN интерфейсы. Далее вывод команды #virsh net-dumpxml ovsvl и ovsvl2 показывающие содержимое настроек этих сетей.
Здесь кусок конфига ВМ, где сетевые интерфейсы по команде:
```
#virsh dumpxml имяВМ
```
### Тесты
При тестировании OVS была проверена совместимость с запущенным networkmanager(NM), выше описанные сценарии работают нормально, но при автозапуске службы NM может выдавать сообщения по интерфейсам виртуального коммутатора, которыми не может управлять, NM можно выключить, но на функциональность сети это не влияет.
Еще имеются дополнения для управления OVS через NM, но в этом случае функционал OVS ограничен. Поэтому возможна параллельная работа, либо с отключением NM при необходимости.
Также были успешно проверены живые миграции ВМ с сетями от OVS, если на каждой ноде имеется экземпляр сети вместе с OVS то, проблем с миграцией нет, так же как и в стандартной конфигурации кластера Р-виртуализации с дополнительными сетями для ВМ.
На рисунке выше был запущен ping изнутри ВМ в сторону ВМ из внешней сети и выполнена живая миграция ВМ с одной ноды с установленным OVS на другую ноду с установленным OVS, красным помечена задержка во время этой миграции ВМ. Параметры ВМ были следующие 4 vCPU, 8GB RAM, 64GB disk.
Точно такая же задержка происходит и в классике с мостами, то есть для ВМ ничего не поменялось, а сетевой стек теперь работает через OVS.
По мимо этого производились успешные подключения по ssh с разными ВМ расположенными на разных нодах между туннелем vxlan и с ВМ за физическим коммутатором. Для проверки работы выключали туннель или анализировали пакеты через tcpdump как описано выше. Если не назначить MTU как описано выше то, будут проходить только ping, а через ssh не получится подключится.
### Описание сценариев
Ниже показан стандартный классический с мостами вариант настройки кластера из трех нод Р-виртуализация плюс Р-хранилища без OVS.
На схеме опущена и не показана сеть Р-хранилища, она обычно идет отдельным интерфейсом предназначенного только для блочного уровня и в этом тесте не участвует. Ее можно настраивать без мостов, и как вариант ее тоже можно задействовать через OVS. Например настроить на OVS агрегацию для Р-хранилища.
Далее схема с использованием вместе с мостами OVS.
Тут уже может быть одна сеть с OVS и одна с мостом. С OVS можно добавлять порты с разными тегами в portgroup и выводить уже на разные ВМ.
Если вернемся к тестируемому сценарию то, его можно увидеть на следующей картинке:
В моем случае было в рамках одного кластера, но это может быть и между разными кластерами за счет туннелей vxlan. Попытаемся представить себе, что это ноды двух разных кластеров.
Туннель поднят на специально выделенном порту одного из серверов каждого кластера. Через туннель выполняется проброс определенного vlan120 в котором определенное количество ВМ со всего кластера рассчитанное на ширину пропускного канала, где средствами OVS можно определить QoS для трафика каждой ВМ. Локальные ВМ этого узла видны через локальный OVS, а ВМ с других узлов видны через физический коммутатор каждого кластера.
Отказоустойчивость OVS обеспечивается за счет добавления в скрипт службы HA(shaman) команд по перебросу туннеля vxlan на другую ноду с OVS, которая будет выбрана по дефолтному алгоритму drs,round-robin за счет службы shaman от Р-Хранилища.
Отказоустойчивость и балансировку порта сервера можно обеспечить за счет агрегации bonding в режиме LACP(802.3ad) c хэшированием layer2+3 или layer3+4, которую также можно настроить средствами OVS.
Как работает классический br0 я описывать не буду, ovsbr0 работает со IP стеком ОС, который на этой картинке определен для br0, то есть экземпляр виртуального коммутатора в виде ovsbr0 работает в данном случае через br0. Другими словами статический IP адрес ноды назначен на классический br0 и весь трафик, который направлен в эту подсеть с виртуального коммутатора проходит через br0, так же как это работает для всех приложений этой ноды. С точки зрения настройки в этом случае никаких cli назначений на br0 со стороны виртуального коммутатора не производилось кроме настройки vxlan интерфейса с option, соответственно если у ноды есть второй классический br1 c другим IP адресом и подсетью висящий на другом физическом порту например eth2 или eth3 то, с виртуального коммутатора за счет стека ОС и его таблицы mac-ов можно направить пакеты в эти подсети назначив какой либо порт виртуального коммутатора в эту подсеть и подключить к ВМ, адрес подсети будет непосредственно назначаться внутри ВМ или в ее настройках.
Благодаря такому принципу виртуальный коммутатор работает как обычная программа на хосте через его сетевой стек не мешая классическим мостам, но конечно при условии что вы не сконфигурируете одинаковые настройки на обоих инструментах (на мостах и OVS).
*У виртуального коммутатора есть своя таблица маков*
У каждого созданного мною виртуального коммутатора есть какой-то набор интерфейсов (разрешая влан на каком-то интерфейсе мы добавляем порт в определенный виртуальный коммутатор), а также таблица соответствия mac адресов и портов (ее мы смотрим командой ovs-appctl fdb/show ovsbr0). Ручное назначение мак адресов внутри коммутатора не производилось. Portgoup это группа портов в которой на данный момент есть порт vlan120 к которому подключена ВМ.
Теоретически мы можем представить, что когда в какой-то порт коммутатора прилетает фрейм с VLAN тегом, то решение о дальнейшей отправке фрейма принимается на основании таблицы mac адресов соответствующего виртуального коммутатора. Если получен фрейм с тегом 120, то соответственно приниматься решение о форвардинге данного фрейма будет на основании mac таблицы виртуального коммутатора с тегом 120.
Что касаемо VXLAN то, в этом случае static (Unicast). Самый простой вариант — это статичное указание удаленных интерфейсов по типу vxlan. Все сводится к тому, что в конфигурации VNI(vlan vxlan) надо статически задать адреса всех удаленных интерфейсов vxlan, которые терминируют клиентов в указанном VNI. В таком сценарии vxlan будет указывать в IP заголовке как адреса назначения — адреса указанных вручную vxlan. Естественно, если vxlan-ов будет больше двух, то точек назначения пакета при флуде будет уже как минимум две. Указать в IP заголовке нескольких получателей не получится, поэтому самым простым решением будет репликация VxLAN пакета на исходящем интерфейсе vxlan и отправка их юникастом на удаленные интерфейсы vxlan, указанные в конфигурации. Получив данный пакет, удаленный vxlan его декапсулирует, определяет какому VNI данный пакет относится и далее рассылает его во все порты в данном VNI. Помимо этого, так как мы все в курсе, что mac адреса изучаются коммутаторами на основании поля source mac, то после декапсуляции VxLAN пакета интерфейс vxlan ассоциирует mac адрес, указанный как исходящий в оригинальном ethernet заголовке с тоннелем до интерфейса vxlan, от которого данный пакет получен. Как и было сказано ранее — VxLAN тоннель коммутатор воспринимает как простой транковый порт.
Минусы данного подхода очевидны — это увеличенная нагрузка на сеть, так как BUM трафик реплицируется на исходящем интерфейсе vxlan и юникастом рассылается всем указанным в конфигурации нейборам, плюс к этому при добавлении или удалении интерфейса vxlan придется править конфиги на всех остальных интерфейсах vxlan-ах и руками удалить или добавить нейбора (нейборов) или в авторежиме средствами скриптов шамана в случае аварии узла. В век автоматизации конечно как-то странно использовать статическое указание нейборов. Но все равно данный подход имеет право на жизнь, например OVS умеет работать только со статически заданным нейбором, во всяком случае на данный момент.
Для работы данного режима необходимо только наличие связности между лупбеками всех интерфейсов vxlan.
Static (Unicast) VxLAN — проста как валенок и безотказна, как автомат [Калашникова.](https://habr.com/ru/post/344326/) Ломаться тут нечему.
[здесь](https://tools.ietf.org/html/draft-mahalingam-dutt-dcops-vxlan-03#page-7) все более подробно описано по определению маков и flood&Learn в OVS.
### Заключение
При выполнении настроек OVS понравилась [простота, удобство,](https://habr.com/ru/post/242741/) сразу чувствуется что работаешь с коммутатором, а не просто с мостами))) В общем есть смысл его использовать хотя бы параллельно с классическими мостами в РП.
Перед выше описанной интеграцией по мимо использованных в ней ссылок изучал еще следующие статьи:
1. <https://www.sidorenko.io/post/2018/11/openstack-networking-open-vswitch-and-vxlan-introduction/>
2. <https://blog.remibergsma.com/2015/03/26/connecting-two-open-vswitches-to-create-a-l2-connection/>
3. <http://mx54.ru/nastrojka-setevyx-interfejsov-v-kvm-dlya-virtualnyx-mashin/>
4. <https://kamaok.org.ua/?p=2677>
5. <https://kashyapc.fedorapeople.org/virt/add-network-card-in-guest.txt>
6. <https://costiser.ro/2016/07/07/overlay-tunneling-with-openvswitch-gre-vxlan-geneve-greoipsec/#.XuZ960UzaM_> | https://habr.com/ru/post/508832/ | null | ru | null |
# Руководство по обработке ошибок в JavaScript
Ошибки — это хорошо. Автор материала, перевод которого мы сегодня публикуем, говорит, что уверен в том, что эта идея известна всем. На первый взгляд ошибки кажутся чем-то страшным. Им могут сопутствовать какие-то потери. Ошибка, сделанная на публике, вредит авторитету того, кто её совершил. Но, совершая ошибки, мы на них учимся, а значит, попадая в следующий раз в ситуацию, в которой раньше вели себя неправильно, делаем всё как нужно.
[](https://habr.com/company/ruvds/blog/431078/)
Выше мы говорили об ошибках, которые люди совершают в обычной жизни. Ошибки в программировании — это нечто иное. Сообщения об ошибках помогают нам улучшать код, они позволяют сообщать пользователям наших проектов о том, что что-то пошло не так, и, возможно, рассказывают пользователям о том, как нужно вести себя для того, чтобы ошибок больше не возникало.
Этот материал, посвящённый обработке ошибок в JavaScript, разбит на три части. Сначала мы сделаем общий обзор системы обработки ошибок в JavaScript и поговорим об объектах ошибок. После этого мы поищем ответ на вопрос о том, что делать с ошибками, возникающими в серверном коде (в частности, при использовании связки Node.js + Express.js). Далее — обсудим обработку ошибок в React.js. Фреймворки, которые будут здесь рассматриваться, выбраны по причине их огромной популярности. Однако рассматриваемые здесь принципы работы с ошибками универсальны, поэтому вы, даже если не пользуетесь Express и React, без труда сможете применить то, что узнали, к тем инструментам, с которыми работаете.
Код демонстрационного проекта, используемого в данном материале, можно найти в [этом](https://github.com/gisderdube/graceful-error-handling) репозитории.
1. Ошибки в JavaScript и универсальные способы работы с ними
------------------------------------------------------------
Если в вашем коде что-то пошло не так, вы можете воспользоваться следующей конструкцией.
```
throw new Error('something went wrong')
```
В ходе выполнения этой команды будет создан экземпляр объекта [Error](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Error) и будет сгенерировано (или, как говорят, «выброшено») исключение с этим объектом. Инструкция [throw](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Statements/throw) может генерировать исключения, содержащие произвольные выражения. При этом выполнение скрипта остановится в том случае, если не были предприняты меры по обработке ошибки.
Начинающие JS-программисты обычно не используют инструкцию `throw`. Они, как правило, сталкиваются с исключениями, выдаваемыми либо средой выполнения языка, либо сторонними библиотеками. Когда это происходит — в консоль попадает нечто вроде `ReferenceError: fs is not defined` и выполнение программы останавливается.
### ▍Объект Error
У экземпляров объекта `Error` есть несколько свойств, которыми мы можем пользоваться. Первое интересующее нас свойство — `message`. Именно сюда попадает та строка, которую можно передать конструктору ошибки в качестве аргумента. Например, ниже показано создание экземпляра объекта `Error` и вывод в консоль переданной конструктором строки через обращение к его свойству `message`.
```
const myError = new Error('please improve your code')
console.log(myError.message) // please improve your code
```
Второе свойство объекта, очень важное, представляет собой трассировку стека ошибки. Это — свойство `stack`. Обратившись к нему можно просмотреть стек вызовов (историю ошибки), который показывает последовательность операций, приведшую к неправильной работе программы. В частности, это позволяет понять — в каком именно файле содержится сбойный код, и увидеть, какая последовательность вызовов функций привела к ошибке. Вот пример того, что можно увидеть, обратившись к свойству `stack`.
```
Error: please improve your code
at Object. (/Users/gisderdube/Documents/\_projects/hacking.nosync/error-handling/src/general.js:1:79)
at Module.\_compile (internal/modules/cjs/loader.js:689:30)
at Object.Module.\_extensions..js (internal/modules/cjs/loader.js:700:10)
at Module.load (internal/modules/cjs/loader.js:599:32)
at tryModuleLoad (internal/modules/cjs/loader.js:538:12)
at Function.Module.\_load (internal/modules/cjs/loader.js:530:3)
at Function.Module.runMain (internal/modules/cjs/loader.js:742:12)
at startup (internal/bootstrap/node.js:266:19)
at bootstrapNodeJSCore (internal/bootstrap/node.js:596:3)
```
Здесь, в верхней части, находится сообщение об ошибке, затем следует указание на тот участок кода, выполнение которого вызвало ошибку, потом описывается то место, откуда был вызван этот сбойный участок. Это продолжается до самого «дальнего» по отношению к ошибке фрагмента кода.
### ▍Генерирование и обработка ошибок
Создание экземпляра объекта `Error`, то есть, выполнение команды вида `new Error()`, ни к каким особым последствиям не приводит. Интересные вещи начинают происходить после применения оператора `throw`, который генерирует ошибку. Как уже было сказано, если такую ошибку не обработать, выполнение скрипта остановится. При этом нет никакой разницы — был ли оператор `throw` использован самим программистом, произошла ли ошибка в некоей библиотеке или в среде выполнения языка (в браузере или в Node.js). Поговорим о различных сценариях обработки ошибок.
### ▍Конструкция try...catch
Блок `try...catch` представляет собой самый простой способ обработки ошибок, о котором часто забывают. В наши дни, правда, он используется гораздо интенсивнее чем раньше, благодаря тому, что его можно применять для обработки ошибок в конструкциях `async/await`.
Этот блок можно использовать для обработки любых ошибок, происходящих в синхронном коде. Рассмотрим пример.
```
const a = 5
try {
console.log(b) // переменная b не объявлена - возникает ошибка
} catch (err) {
console.error(err) // в консоль попадает сообщение об ошибке и стек ошибки
}
console.log(a) // выполнение скрипта не останавливается, данная команда выполняется
```
Если бы в этом примере мы не заключили бы сбойную команду `console.log(b)` в блок `try...catch`, то выполнение скрипта было бы остановлено.
### ▍Блок finally
Иногда случается так, что некий код нужно выполнить независимо от того, произошла ошибка или нет. Для этого можно, в конструкции `try...catch`, использовать третий, необязательный, блок — `finally`. Часто его использование эквивалентно некоему коду, который идёт сразу после `try...catch`, но в некоторых ситуациях он может пригодиться. Вот пример его использования.
```
const a = 5
try {
console.log(b) // переменная b не объявлена - возникает ошибка
} catch (err) {
console.error(err) // в консоль попадает сообщение об ошибке и стек ошибки
} finally {
console.log(a) // этот код будет выполнен в любом случае
}
```
### ▍Асинхронные механизмы — коллбэки
Программируя на JavaScript всегда стоит обращать внимание на участки кода, выполняющиеся асинхронно. Если у вас имеется асинхронная функция и в ней возникает ошибка, скрипт продолжит выполняться. Когда асинхронные механизмы в JS реализуются с использованием коллбэков (кстати, делать так не рекомендуется), соответствующий коллбэк (функция обратного вызова) обычно получает два параметра. Это нечто вроде параметра `err`, который может содержать ошибку, и `result` — с результатами выполнения асинхронной операции. Выглядит это примерно так:
```
myAsyncFunc(someInput, (err, result) => {
if(err) return console.error(err) // порядок работы с объектом ошибки мы рассмотрим позже
console.log(result)
})
```
Если в коллбэк попадает ошибка, она видна там в виде параметра `err`. В противном случае в этот параметр попадёт значение `undefined` или `null`. Если оказалось, что в `err` что-то есть, важно отреагировать на это, либо так как в нашем примере, воспользовавшись командой `return`, либо воспользовавшись конструкцией `if...else` и поместив в блок `else` команды для работы с результатом выполнения асинхронной операции. Речь идёт о том, чтобы, в том случае, если произошла ошибка, исключить возможность работы с результатом, параметром `result`, который в таком случае может иметь значение `undefined`. Работа с таким значением, если предполагается, например, что оно содержит объект, сама может вызвать ошибку. Скажем, это произойдёт при попытке использовать конструкцию `result.data` или подобную ей.
### ▍Асинхронные механизмы — промисы
Для выполнения асинхронных операций в JavaScript лучше использовать не коллбэки а промисы. Тут, в дополнение к улучшенной читабельности кода, имеются и более совершенные механизмы обработки ошибок. А именно, возиться с объектом ошибки, который может попасть в функцию обратного вызова, при использовании промисов не нужно. Здесь для этой цели предусмотрен специальный блок `catch`. Он перехватывает все ошибки, произошедшие в промисах, которые находятся до него, или все ошибки, которые произошли в коде после предыдущего блока `catch`. Обратите внимание на то, что если в промисе произошла ошибка, для обработки которой нет блока `catch`, это не остановит выполнение скрипта, но сообщение об ошибке будет не особенно удобочитаемым.
```
(node:7741) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): Error: something went wrong
(node:7741) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code. */
```
В результате можно порекомендовать всегда, при работе с промисами, использовать блок `catch`. Взглянем на пример.
```
Promise.resolve(1)
.then(res => {
console.log(res) // 1
throw new Error('something went wrong')
return Promise.resolve(2)
})
.then(res => {
console.log(res) // этот блок выполнен не будет
})
.catch(err => {
console.error(err) // о том, что делать с этой ошибкой, поговорим позже
return Promise.resolve(3)
})
.then(res => {
console.log(res) // 3
})
.catch(err => {
// этот блок тут на тот случай, если в предыдущем блоке возникнет какая-нибудь ошибка
console.error(err)
})
```
### ▍Асинхронные механизмы и try...catch
После того, как в JavaScript появилась конструкция `async/await`, мы вернулись к классическому способу обработки ошибок — к `try...catch...finally`. Обрабатывать ошибки при таком подходе оказывается очень легко и удобно. Рассмотрим пример.
```
;(async function() {
try {
await someFuncThatThrowsAnError()
} catch (err) {
console.error(err) // об этом поговорим позже
}
console.log('Easy!') // будет выполнено
})()
```
При таком подходе ошибки в асинхронном коде обрабатываются так же, как в синхронном. В результате теперь, при необходимости, в одном блоке `catch` можно обрабатывать более широкий диапазон ошибок.
2. Генерирование и обработка ошибок в серверном коде
----------------------------------------------------
Теперь, когда у нас есть инструменты для работы с ошибками, посмотрим на то, что мы можем с ними делать в реальных ситуациях. Генерирование и правильная обработка ошибок — это важнейший аспект серверного программирования. Существуют разные подходы к работе с ошибками. Здесь будет продемонстрирован подход с использованием собственного конструктора для экземпляров объекта `Error` и кодов ошибок, которые удобно передавать во фронтенд или любым механизмам, использующим серверные API. Как структурирован бэкенд конкретного проекта — особого значения не имеет, так как при любом подходе можно использовать одни и те же идеи, касающиеся работы с ошибками.
В качестве серверного фреймворка, отвечающего за маршрутизацию, мы будем использовать Express.js. Подумаем о том, какая структура нам нужна для организации эффективной системы обработки ошибок. Итак, вот что нам нужно:
1. Универсальная обработка ошибок — некий базовый механизм, подходящий для обработки любых ошибок, в ходе работы которого просто выдаётся сообщение наподобие `Something went wrong, please try again or contact us`, предлагающее пользователю попробовать выполнить операцию, давшую сбой, ещё раз или связаться с владельцем сервера. Эта система не отличается особой интеллектуальностью, но она, по крайней мере, способна сообщить пользователю о том, что что-то пошло не так. Подобное сообщение гораздо лучше, чем «бесконечная загрузка» или нечто подобное.
2. Обработка конкретных ошибок — механизм, позволяющий сообщить пользователю подробные сведения о причинах неправильного поведения системы и дать ему конкретные советы по борьбе с неполадкой. Например, это может касаться отсутствия неких важных данных в запросе, который пользователь отправляет на сервер, или в том, что в базе данных уже существует некая запись, которую он пытается добавить ещё раз, и так далее.
### ▍Разработка собственного конструктора объектов ошибок
Здесь мы воспользуемся стандартным классом `Error` и расширим его. Пользоваться механизмами наследования в JavaScript — дело рискованное, но в данном случае эти механизмы оказываются весьма полезными. Зачем нам наследование? Дело в том, что нам, для того, чтобы код удобно было бы отлаживать, нужны сведения о трассировке стека ошибки. Расширяя стандартный класс `Error`, мы, без дополнительных усилий, получаем возможности по трассировке стека. Мы добавляем в наш собственный объект ошибки два свойства. Первое — это свойство `code`, доступ к которому можно будет получить с помощью конструкции вида `err.code`. Второе — свойство `status`. В него будет записываться код состояния HTTP, который планируется передавать клиентской части приложения.
Вот как выглядит класс `CustomError`, код которого оформлен в виде модуля.
```
class CustomError extends Error {
constructor(code = 'GENERIC', status = 500, ...params) {
super(...params)
if (Error.captureStackTrace) {
Error.captureStackTrace(this, CustomError)
}
this.code = code
this.status = status
}
}
module.exports = CustomError
```
### ▍Маршрутизация
Теперь, когда наш объект ошибки готов к использованию, нужно настроить структуру маршрутов. Как было сказано выше, нам требуется реализовать унифицированный подход к обработке ошибок, позволяющий одинаково обрабатывать ошибки для всех маршрутов. По умолчанию фреймворк Express.js не вполне поддерживает такую схему работы. Дело в том, что все его маршруты инкапсулированы.
Для того чтобы справиться с этой проблемой, мы можем реализовать собственный обработчик маршрутов и определять логику маршрутов в виде обычных функций. Благодаря такому подходу, если функция маршрута (или любая другая функция) выбрасывает ошибку, она попадёт в обработчик маршрутов, который затем может передать её клиентской части приложения. При возникновении ошибки на сервере мы планируем передавать её во фронтенд в следующем формате, полагая, что для этого будет применяться JSON-API:
```
{
error: 'SOME_ERROR_CODE',
description: 'Something bad happened. Please try again or contact support.'
}
```
Если на данном этапе происходящие кажется вам непонятным — не беспокойтесь — просто продолжайте читать, пробуйте работать с тем, о чём идёт речь, и постепенно вы во всём разберётесь. На самом деле, если говорить о компьютерном обучении, здесь применяется подход «сверху-вниз», когда сначала обсуждаются общие идеи, а потом осуществляется переход к частностям.
Вот как выглядит код обработчика маршрутов.
```
const express = require('express')
const router = express.Router()
const CustomError = require('../CustomError')
router.use(async (req, res) => {
try {
const route = require(`.${req.path}`)[req.method]
try {
const result = route(req) // Передаём запрос функции route
res.send(result) // Передаём клиенту то, что получено от функции route
} catch (err) {
/*
Сюда мы попадаем в том случае, если в функции route произойдёт ошибка
*/
if (err instanceof CustomError) {
/*
Если ошибка уже обработана - трансформируем её в
возвращаемый объект
*/
return res.status(err.status).send({
error: err.code,
description: err.message,
})
} else {
console.error(err) // Для отладочных целей
// Общая ошибка - вернём универсальный объект ошибки
return res.status(500).send({
error: 'GENERIC',
description: 'Something went wrong. Please try again or contact support.',
})
}
}
} catch (err) {
/*
Сюда мы попадём, если запрос окажется неудачным, то есть,
либо не будет найдено файла, соответствующего пути, переданному
в запросе, либо не будет экспортированной функции с заданным
методом запроса
*/
res.status(404).send({
error: 'NOT_FOUND',
description: 'The resource you tried to access does not exist.',
})
}
})
module.exports = router
```
Полагаем, комментарии в коде достаточно хорошо его поясняют. Надеемся, читать их удобнее, чем объяснения подобного кода, данные после него.
Теперь взглянем на файл маршрутов.
```
const CustomError = require('../CustomError')
const GET = req => {
// пример успешного выполнения запроса
return { name: 'Rio de Janeiro' }
}
const POST = req => {
// пример ошибки общего характера
throw new Error('Some unexpected error, may also be thrown by a library or the runtime.')
}
const DELETE = req => {
// пример ошибки, обрабатываемой особым образом
throw new CustomError('CITY_NOT_FOUND', 404, 'The city you are trying to delete could not be found.')
}
const PATCH = req => {
// пример перехвата ошибок и использования CustomError
try {
// тут случилось что-то нехорошее
throw new Error('Some internal error')
} catch (err) {
console.error(err) // принимаем решение о том, что нам тут делать
throw new CustomError(
'CITY_NOT_EDITABLE',
400,
'The city you are trying to edit is not editable.'
)
}
}
module.exports = {
GET,
POST,
DELETE,
PATCH,
}
```
В этих примерах с самими запросами ничего не делается. Тут просто рассматриваются разные сценарии возникновения ошибок. Итак, например, запрос `GET /city` попадёт в функцию `const GET = req =>...`, запрос `POST /city` попадёт в функцию `const POST = req =>...` и так далее. Эта схема работает и при использовании параметров запросов. Например — для запроса вида `GET /city?startsWith=R`. В целом, здесь продемонстрировано, что при обработке ошибок, во фронтенд может попасть либо общая ошибка, содержащая лишь предложение попробовать снова или связаться с владельцем сервера, либо ошибка, сформированная с использованием конструктора `CustomError`, которая содержит подробные сведения о проблеме.
Данные общей ошибки придут в клиентскую часть приложения в таком виде:
```
{
error: 'GENERIC',
description: 'Something went wrong. Please try again or contact support.'
}
```
Конструктор `CustomError` используется так:
```
throw new CustomError('MY_CODE', 400, 'Error description')
```
Это даёт следующий JSON-код, передаваемый во фронтенд:
```
{
error: 'MY_CODE',
description: 'Error description'
}
```
Теперь, когда мы основательно потрудились над серверной частью приложения, в клиентскую часть больше не попадают бесполезные логи ошибок. Вместо этого клиент получает полезные сведения о том, что пошло не так.
Не забудьте о том, что [здесь](https://github.com/gisderdube/graceful-error-handling) лежит репозиторий с рассматриваемым здесь кодом. Можете его загрузить, поэкспериментировать с ним, и, если надо, адаптировать под нужды вашего проекта.
3. Работа с ошибками на клиенте
-------------------------------
Теперь пришла пора описать третью часть нашей системы обработки ошибок, касающуюся фронтенда. Тут нужно будет, во-первых, обрабатывать ошибки, возникающие в клиентской части приложения, а во-вторых, понадобится оповещать пользователя об ошибках, возникающих на сервере. Разберёмся сначала с показом сведений о серверных ошибках. Как уже было сказано, в этом примере будет использована библиотека React.
### ▍Сохранение сведений об ошибках в состоянии приложения
Как и любые другие данные, ошибки и сообщения об ошибках могут меняться, поэтому их имеет смысл помещать в состояние компонентов. При монтировании компонента данные об ошибке сбрасываются, поэтому, когда пользователь впервые видит страницу, там сообщений об ошибках не будет.
Следующее, с чем надо разобраться, заключается в том, что ошибки одного типа нужно показывать в одном стиле. По аналогии с сервером, здесь можно выделить 3 типа ошибок.
1. Глобальные ошибки — в эту категорию попадают сообщения об ошибках общего характера, приходящие с сервера, или ошибки, которые, например, возникают в том случае, если пользователь не вошёл в систему и в других подобных ситуациях.
2. Специфические ошибки, выдаваемые серверной частью приложения — сюда относятся ошибки, сведения о которых приходят с сервера. Например, подобная ошибка возникает, если пользователь попытался войти в систему и отправил на сервер имя и пароль, а сервер сообщил ему о том, что пароль неправильный. Подобные вещи в клиентской части приложения не проверяются, поэтому сообщения о таких ошибках должны приходить с сервера.
3. Специфические ошибки, выдаваемые клиентской частью приложения. Пример такой ошибки — сообщение о некорректном адресе электронной почты, введённом в соответствующее поле.
Ошибки второго и третьего типов очень похожи, работать с ними можно, используя хранилище состояния компонентов одного уровня. Их главное различие заключается в том, что они исходят из разных источников. Ниже, анализируя код, мы посмотрим на работу с ними.
Здесь будет использоваться встроенная в React система управления состоянием приложения, но, при необходимости, вы можете воспользоваться и специализированными решениями для управления состоянием — такими, как MobX или Redux.
### ▍Глобальные ошибки
Обычно сообщения о таких ошибках сохраняются в компоненте наиболее высокого уровня, имеющем состояние. Они выводятся в статическом элементе пользовательского интерфейса. Это может быть красное поле в верхней части экрана, модальное окно или что угодно другое. Реализация зависит от конкретного проекта. Вот как выглядит сообщение о такой ошибке.
*Сообщение о глобальной ошибке*
Теперь взглянем на код, который хранится в файле `Application.js`.
```
import React, { Component } from 'react'
import GlobalError from './GlobalError'
class Application extends Component {
constructor(props) {
super(props)
this.state = {
error: '',
}
this._resetError = this._resetError.bind(this)
this._setError = this._setError.bind(this)
}
render() {
return (
Handling Errors
===============
)
}
_resetError() {
this.setState({ error: '' })
}
_setError(newError) {
this.setState({ error: newError })
}
}
export default Application
```
Как видно, в состоянии, в `Application.js`, имеется место для хранения данных ошибки. Кроме того, тут предусмотрены методы для сброса этих данных и для их изменения.
Ошибка и метод для сброса ошибки передаётся компоненту `GlobalError`, который отвечает за вывод сообщения об ошибке на экран и за сброс ошибки после нажатия на значок `x` в поле, где выводится сообщение. Вот код компонента `GlobalError` (файл `GlobalError.js`).
```
import React, { Component } from 'react'
class GlobalError extends Component {
render() {
if (!this.props.error) return null
return (
{this.props.error}
*close*
)
}
}
export default GlobalError
```
Обратите внимание на строку `if (!this.props.error) return null`. Она указывает на то, что при отсутствии ошибки компонент ничего не выводит. Это предотвращает постоянный показ красного прямоугольника на странице. Конечно, вы, при желании, можете поменять внешний вид и поведение этого компонента. Например, вместо того, чтобы сбрасывать ошибку по нажатию на `x`, можно задать тайм-аут в пару секунд, по истечении которого состояние ошибки сбрасывается автоматически.
Теперь, когда всё готово для работы с глобальными ошибками, для задания глобальной ошибки достаточно воспользоваться `_setError` из `Application.js`. Например, это можно сделать в том случае, если сервер, после обращения к нему, вернул сообщение об общей ошибке (`error: 'GENERIC'`). Рассмотрим пример (файл `GenericErrorReq.js`).
```
import React, { Component } from 'react'
import axios from 'axios'
class GenericErrorReq extends Component {
constructor(props) {
super(props)
this._callBackend = this._callBackend.bind(this)
}
render() {
return (
Click me to call the backend
)
}
_callBackend() {
axios
.post('/api/city')
.then(result => {
// сделать что-нибудь с результатом в том случае, если запрос оказался успешным
})
.catch(err => {
if (err.response.data.error === 'GENERIC') {
this.props.setError(err.response.data.description)
}
})
}
}
export default GenericErrorReq
```
На самом деле, на этом наш разговор об обработке ошибок можно было бы и закончить. Даже если в проекте нужно оповещать пользователя о специфических ошибках, никто не мешает просто поменять глобальное состояние, хранящее ошибку и вывести соответствующее сообщение поверх страницы. Однако тут мы не остановимся и поговорим о специфических ошибках. Во-первых, это руководство по обработке ошибок иначе было бы неполным, а во-вторых, с точки зрения UX-специалистов, неправильно будет показывать сообщения обо всех ошибках так, будто все они — глобальные.
### ▍Обработка специфических ошибок, возникающих при выполнении запросов
Вот пример специфического сообщения об ошибке, выводимого в том случае, если пользователь пытается удалить из базы данных город, которого там нет.
*Сообщение о специфической ошибке*
Тут используется тот же принцип, который мы применяли при работе с глобальными ошибками. Только сведения о таких ошибках хранятся в локальном состоянии соответствующих компонентов. Работа с ними очень похожа на работу с глобальными ошибками. Вот код файла `SpecificErrorReq.js`.
```
import React, { Component } from 'react'
import axios from 'axios'
import InlineError from './InlineError'
class SpecificErrorRequest extends Component {
constructor(props) {
super(props)
this.state = {
error: '',
}
this._callBackend = this._callBackend.bind(this)
}
render() {
return (
Delete your city
)
}
_callBackend() {
this.setState({
error: '',
})
axios
.delete('/api/city')
.then(result => {
// сделать что-нибудь с результатом в том случае, если запрос оказался успешным
})
.catch(err => {
if (err.response.data.error === 'GENERIC') {
this.props.setError(err.response.data.description)
} else {
this.setState({
error: err.response.data.description,
})
}
})
}
}
export default SpecificErrorRequest
```
Тут стоит отметить, что для сброса специфических ошибок недостаточно, например, просто нажать на некую кнопку `x`. То, что пользователь прочёл сообщение об ошибке и закрыл его, не помогает такую ошибку исправить. Исправить её можно, правильно сформировав запрос к серверу, например — введя в ситуации, показанной на предыдущем рисунке, имя города, который есть в базе. В результате очищать сообщение об ошибке имеет смысл, например, после выполнения нового запроса. Сбросить ошибку можно и в том случае, если пользователь внёс изменения в то, что будет использоваться при формировании нового запроса, то есть — при изменении содержимого поля ввода.
### ▍Ошибки, возникающие в клиентской части приложения
Как уже было сказано, для хранения данных о таких ошибках можно использовать состояние тех же компонентов, которое используется для хранения данных по специфическим ошибкам, поступающим с сервера. Предположим, мы позволяем пользователю отправить на сервер запрос на удаление города из базы только в том случае, если в соответствующем поле ввода есть какой-то текст. Отсутствие или наличие текста в поле можно проверить средствами клиентской части приложения.
*В поле ничего нет, мы сообщаем об этом пользователю*
Вот код файла `SpecificErrorFrontend.js`, реализующий вышеописанный функционал.
```
import React, { Component } from 'react'
import axios from 'axios'
import InlineError from './InlineError'
class SpecificErrorRequest extends Component {
constructor(props) {
super(props)
this.state = {
error: '',
city: '',
}
this._callBackend = this._callBackend.bind(this)
this._changeCity = this._changeCity.bind(this)
}
render() {
return (
Delete your city
)
}
_changeCity(e) {
this.setState({
error: '',
city: e.target.value,
})
}
_validate() {
if (!this.state.city.length) throw new Error('Please provide a city name.')
}
_callBackend() {
this.setState({
error: '',
})
try {
this._validate()
} catch (err) {
return this.setState({ error: err.message })
}
axios
.delete('/api/city')
.then(result => {
// сделать что-нибудь с результатом в том случае, если запрос оказался успешным
})
.catch(err => {
if (err.response.data.error === 'GENERIC') {
this.props.setError(err.response.data.description)
} else {
this.setState({
error: err.response.data.description,
})
}
})
}
}
export default SpecificErrorRequest
```
### ▍Интернационализация сообщений об ошибках с использованием кодов ошибок
Возможно, сейчас вы задаётесь вопросом о том, зачем нам нужны коды ошибок (наподобие `GENERIC`), если мы показываем пользователю только сообщения об ошибках, полученных с сервера. Дело в том, что, по мере роста и развития приложения, оно, вполне возможно, выйдет на мировой рынок, а это означает, что настанет время, когда создателям приложения нужно будет задуматься о поддержке им нескольких языков. Коды ошибок позволяют отличать их друг от друга и выводить сообщения о них на языке пользователя сайта.
Итоги
-----
Надеемся, теперь у вас сформировалось понимание того, как можно работать с ошибками в веб-приложениях. Нечто вроде `console.error(err)` следует использовать только в отладочных целях, в продакшн подобные вещи, забытые программистом, проникать не должны. Упрощает решение задачи логирования использование какой-нибудь подходящей библиотеки наподобие [loglevel](https://www.npmjs.com/package/loglevel).
**Уважаемые читатели!** Как вы обрабатываете ошибки в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/431078/ | null | ru | null |
# 1С: Предприятие — Как напечатать адреса для конвертов
Всем, кто ведет свои дела официально, знакома такая рутинная операция, как отправка счетов и актов контрагентам. И с увеличением количества партнеров Вашего бизнеса, операция становится все неприятнее.
**Чтобы рутинный труд стал приятнее, нужно его автоматизировать!**
В этой статье я расскажу как делал обработку для «1С: Предприятие 8» для печати адресов для конвертов. В своей работе я использую конфигурацию «1С: Упрощенка 8», поэтому все рассказанное будет относится к ней. Для рассылки документов используются конверты формата С5 с окошком (адрес печатается на обычном листе А4, который вкладывается в конверт).
Для нетерпеливых в конце поста есть ссылка на загрузку готовой обработки.
Создаем печатную форму
----------------------
Запускаем 1С-ку в режиме конфигуратора и создаем новую **Внешнюю обработку**:
В открывшемся окне обработки кликаем правой кнопкой по **Реквизитам** и выбираем **Добавить**:
Вводим имя *«СсылкаНаОбъект»* и выбираем тип *«СправочникСсылка.Контрагенты»*:
Тут будет храниться ссылка на запись из справочника «Контрагенты», из которой будет извлекаться информация об адресе.
Следующий шаг — создание печатного макета. Правая кнопка мыши на **Макет** и выбираем **Добавить**. Нам нужен тип Табличный документ:
Вид макета зависит от вида и формата конверта, на котором вы будете печатать. Для С5 с окошком получается примерно так:
[](http://img-fotki.yandex.ru/get/3809/k-likhachev.0/0_3acc5_1fa71487_orig)
Закончив с макетом — выделяем строки для печати и делаем так:
Вводим имя «Адрес». Чтобы в ячейки созданного макета можно было записывать значения, нужно в свойствах ячейки, в разделе **Макет** в **Заполнении** выбрать *Параметр*, а в **Параметр** написать название. У меня это *НаименованиеПолучателя*, *АдресПолучателя* и *ИндексПолучателя* (см. скриншот с макетом).
Макет готов. Пишем код, который будет заполнять его данными.
Пишем код модуля
----------------
Для этого на форме обработки находим кнопку **Действия** (внизу) и выбираем **Открыть модуль объекта**
`Функция ПолучитьАдресКонтрагента(Объект)
Запрос = Новый Запрос;
Запрос.Текст = "
|ВЫБРАТЬ РАЗРЕШЕННЫЕ
| КонтактнаяИнформация.Представление КАК Представление
|ИЗ
| РегистрСведений.КонтактнаяИнформация КАК КонтактнаяИнформация
|
|ГДЕ
| КонтактнаяИнформация.Объект = &Объект
| И КонтактнаяИнформация.Вид = &Вид
| И КонтактнаяИнформация.Тип = &Тип";
Запрос.УстановитьПараметр("Объект", Объект);
Запрос.УстановитьПараметр("Вид", Справочники.ВидыКонтактнойИнформации.ФактАдресКонтрагента);
Запрос.УстановитьПараметр("Тип", Перечисления.ТипыКонтактнойИнформации.Адрес);
ДанныеЗапроса = Запрос.Выполнить().Выгрузить();
Возврат ?(ДанныеЗапроса.Количество() = 0, "", ДанныеЗапроса[0].Представление)
КонецФункции // ПолучитьАдресКонтрагента()
Функция ПолучитьАдресКонтакта(Объект)
Запрос = Новый Запрос;
Запрос.Текст = "
|ВЫБРАТЬ РАЗРЕШЕННЫЕ
| КонтактнаяИнформация.Представление КАК Представление
|ИЗ
| РегистрСведений.КонтактнаяИнформация КАК КонтактнаяИнформация
|
|ГДЕ
| КонтактнаяИнформация.Объект = &Объект
| И КонтактнаяИнформация.Тип = &Тип";
Запрос.УстановитьПараметр("Объект", Объект);
Запрос.УстановитьПараметр("Тип", Перечисления.ТипыКонтактнойИнформации.Адрес);
ДанныеЗапроса = Запрос.Выполнить().Выгрузить();
Возврат ?(ДанныеЗапроса.Количество() = 0, "", ДанныеЗапроса[0].Представление)
КонецФункции // ПолучитьАдресКонтакта()
Функция ПолучитьПредставлениеКонтактногоЛица(КонтактноеЛицо)
Запрос = Новый Запрос;
Запрос.Текст = "
|ВЫБРАТЬ РАЗРЕШЕННЫЕ
| КонтактныеЛица.Представление КАК Представление
|ИЗ
| Справочник.КонтактныеЛица КАК КонтактныеЛица
|
|ГДЕ
| КонтактныеЛица.Ссылка = &КонтактноеЛицо
|
|УПОРЯДОЧИТЬ ПО
| КонтактныеЛица.Наименование ВОЗР";
Запрос.УстановитьПараметр("КонтактноеЛицо", КонтактноеЛицо);
ДанныеЗапроса = Запрос.Выполнить().Выгрузить();
Возврат ?(ДанныеЗапроса.Количество() = 0, "", ДанныеЗапроса[0].Представление)
КонецФункции // ПолучитьПочтовыйАдрес()
Функция ПечатьДокумента()
Запрос = Новый Запрос;
Запрос.Текст =
"ВЫБРАТЬ
| Контрагенты.НаименованиеПолное,
| Контрагенты.ОсновноеКонтактноеЛицо
|ИЗ
| Справочник.Контрагенты КАК Контрагенты
|ГДЕ
| Контрагенты.Ссылка = &ТекущийКонтрагент";
Запрос.УстановитьПараметр("ТекущийКонтрагент", СсылкаНаОбъект);
Контрагент = Запрос.Выполнить().Выбрать();
Контрагент.Следующий();
ТабДокумент = Новый ТабличныйДокумент;
Макет = ПолучитьМакет("Макет");
ОбластьМакета = Макет.ПолучитьОбласть("Адрес");
Если Контрагент.ОсновноеКонтактноеЛицо <> Неопределено Тогда
КонтактПолучателя = ПолучитьПредставлениеКонтактногоЛица(Контрагент.ОсновноеКонтактноеЛицо);
Если КонтактПолучателя <> "" Тогда
ОбластьМакета.Параметры.НаименованиеПолучателя = КонтактПолучателя + " (" + Контрагент.НаименованиеПолное + ")";
Иначе
ОбластьМакета.Параметры.НаименованиеПолучателя = Контрагент.НаименованиеПолное;
КонецЕсли;
АдресКонтакта = ПолучитьАдресКонтакта(Контрагент.ОсновноеКонтактноеЛицо);
Адрес = ?(АдресКонтакта = "", ПолучитьАдресКонтрагента(СсылкаНаОбъект), АдресКонтакта);
ОбластьМакета.Параметры.ИндексПолучателя = Лев(Адрес, 6);
ОбластьМакета.Параметры.АдресПолучателя = Прав(Адрес, СтрДлина(Адрес) - 8);
Иначе
ОбластьМакета.Параметры.НаименованиеПолучателя = Контрагент.НаименованиеПолное;
Адрес = ПолучитьАдресКонтрагента(СсылкаНаОбъект);
ОбластьМакета.Параметры.ИндексПолучателя = Лев(Адрес, 6);
ОбластьМакета.Параметры.АдресПолучателя = Прав(Адрес, СтрДлина(Адрес) - 8);
КонецЕсли;
ТабДокумент.Вывести(ОбластьМакета);
Возврат ТабДокумент;
КонецФункции // ПечатьДокумента()
Функция Печать() Экспорт
ТабДокумент = ПечатьДокумента();
Возврат ТабДокумент;
КонецФункции // Печать`
При выполнении модуля выполняется функция **Печать()**, которая возвращает форму, готовую к печати. Внутри этой функции стоит единственный вызов функции **ПечатьДокумента()**, которая отвечает за заполнение макета данными.
Что происходит внутри этой функции:
* По ссылке на элемент из справочника **Контрагенты** выбираем полное наименование и контактное лицо
* Подгружаем наш макет
* Если у контрагента указано контактное лицо — выбираем его представление (ФИО). Если оно не пустое — в ячейку **НаименованиеПолучателя** запишется что-то типа *Пупкин Василий Харитонович (ООО «Рога и Копыта»)*, иначе просто — *ООО «Рога и копыта»*
* В **АдресПолучателя** записываем либо адрес контактного лица (если указан), либо фактический адрес контрагента, предварительно вырезав оттуда индекс, который записываем в **ИндексПолучателя**
На этом работа в конфигураторе закончена. Не забудьте сохранить нашу обработку.
Подключаем внешнюю печатную форму
---------------------------------
Запускаем 1С в обычном режиме. В меню **Сервис** выбираем **Дополнительные отчеты и обработки** — **Дополнительные внешние печатные формы**.
В **Исходном файле** кликаем по кнопке **Открыть** и выбираем наш файл с обработкой.
[](http://img-fotki.yandex.ru/get/3810/k-likhachev.0/0_3acc2_a07d667_orig)
В разделе **Принадлежность печатной формы** кликаем **Добавить** и в открывшемся окне на вкладке **Справочники** выбираем *Контрагенты*.
Жмем OK.
Все. Готово. Можно перевести дыхание. :)
Теперь, если открыть список контрагентов (**Предприятие** — **Контрагенты**) и зайти в любого из них, в правой нижней части окна появится кнопка для печати адресов. При клике на которую откроется окно, подобное этому:
Ее можно напечатать через меню **Файл** — **Печать**
Готовую обработку можно скачать тут: [АдресДляКонвертаФИО.zip](http://narod.ru/disk/18831928000/%D0%90%D0%B4%D1%80%D0%B5%D1%81%D0%94%D0%BB%D1%8F%D0%9A%D0%BE%D0%BD%D0%B2%D0%B5%D1%80%D1%82%D0%B0%D0%A4%D0%98%D0%9E.zip.html)
***Успешного Вам ведения дел!*** | https://habr.com/ru/post/87838/ | null | ru | null |
# Опыт написания рефакторинга
Недавно я столкнулся с проблемой коллизий имен из разных пространств имен. В C# есть возможность ввести синонимы для пространств имен, т.е. вместо использования полного имени класса ввести префикс, с помощью которого можно обращаться к данному пространству имен.
Я не нашел простого пути, как с помощью Visual Studio и ReSharperа ввести синоним в уже написанном классе. В связи с чем я решил реализовать свое дополнение к ReSharper которое позволило бы решить эту проблему. В этой статье я бы хотел рассказать о подводных камнях, с которыми пришлось столкнуться, реализуя, на первый взгляд, такой простой рефакторинг. (исходный код и реализация в конце статьи)
Итак. Я хотел получить код, который поможет сделать что-то такое:
| | |
| --- | --- |
|
```
using b.b2;
class Example
{
MyTest test;
}
```
|
```
using x = b.b2;
class Example
{
x.MyTest test;
}
```
|
К моей радости, объектная модель ReSharper-a позволила легко получить для каждого типа его FQN(fully qualified name), т.е. в примере мы точно можем сказать, что класс MyTest находится в пространстве имен b.b2 и его FQN b.b2.MyTest
Первая формулировка алгоритма может выглядеть следующим образом:
Если мы хотим ввести псевдоним x для пространства имен b.b2, то следует для всех используемых типов в части кода, на который распространяется данный using: если использование типа лежит в пространстве b.b2 и его запись в коде не использует FQN, то необходимо добавить префикс x.
Возникает проблема — мы забыли про Extension методы. Extension методы могут вызваны только в том случае, если в файл явно импортировано пространство имен. Когда мы заменяем прямой импорт на синоним, то компилятор не может узнать, какой метод ему нужно вызывать. Проблема легко решается — extension методы из классов, которые находятся в пространстве имен b.b2. необходимо вызывать как члены статического класса, в котором они лежат.
| было | будет | надо |
| --- | --- | --- |
|
```
using b.b2;
class Example
{
MyTest test;
Example()
{
test.Ext();
}
}
```
|
```
using x = b.b2;
class Example
{
x.MyTest test;
Example()
{
test.Ext();// Ext не найден
}
}
```
|
```
using x = b.b2;
class Example
{
x.MyTest test;
Example()
{
x.Extension.Ext(test);
}
}
```
|
Далее идут грабли, на которые я наткнулся, пытаясь запустить рефакторинг на тестовых файлах. Например, нельзя просто сравнивать на то, используется FQN или нет
| было | будет | надо |
| --- | --- | --- |
|
```
using r = b.b2;
using b.b2;
class Example
{
r.MyTest test;
}
```
|
```
using r = b.b2;
using x = b.b2;
class Example
{
x.r.MyTest test; // r лишнее
}
```
|
```
using r = b.b2;
using b.b2;
class Example
{
r.MyTest test;
}
```
|
Такая ошибка возникнет, т.к. FQN для MyTest это b.b2.MyTest. Наш рефакторинг, зная эту информацию, добавляет суффикс. Эту ошибку можно исправить, если вместо операции добавления префикса использовать полное замещение использование типа на x.[ShortTypeName].
Конфликты имен
---------------
Отдельно стоит проблема, когда значения x будет конфликтовать с уже определенным чем-либо
| | |
| --- | --- |
|
```
using b.b2;
class x
{
class MyTest{}
}
class Example
{
MyTest test;
}
```
|
```
using x = b.b2;
class x
{
class MyTest{}
}
class Example
{
x.MyTest test; // Error namespace contains a definition conflicting with alias 'x'
}
```
|
Правильный рефакторинг должен проверить свой результат на наличие таких ошибок. В реализации я игнорировал эту проблему, переложив это на плечи разработчика. К тому же, в случае конфликтов, компилятор об этом обязательно сообщит.
query-expression
----------------
Остается еще одна проблема. Что если пользователь захочет ввести синоним для пространства имен System.Linq (и ему подобных). В случае, если используются Extension методы, то наш алгоритм справится замечательно. Но если используется query-expression то ничего хорошего не выйдет
| было | будет |
| --- | --- |
|
```
using System.Linq;
...
var query =
from c in svcContext.ContactSet
join a in svcContext.AccountSet
on c.ContactId equals a.PrimaryContactId.Id
where a.Name.Contains("Contoso")
where c.LastName.Contains("Smith")
select new
{
account_name = a.Name,
contact_name = c.LastName
};
```
|
```
using aaa = System.Linq;
// Error Could not find an implementation of the query pattern for
// source type 'string[]'.
// 'Select' not found. Are you missing a reference to 'System.Core.dll'
// or a using directive for 'System.Linq'?
var query = //
from c in svcContext.ContactSet
join a in svcContext.AccountSet
on c.ContactId equals a.PrimaryContactId.Id
where a.Name.Contains("Contoso")
where c.LastName.Contains("Smith")
select new
{
account_name = a.Name,
contact_name = c.LastName
};
```
|
Правильный рефакторинг должен раскрыть query expression в цепочку вызовов статических методов (что, собственно и делает компилятор) и получить примерно такой результат.
```
var query =
aaa.Enumerable.Select(
aaa.Enumerable.Where(
aaa.Enumerable.Where(
aaa.Enumerable.Join(
svcContext.ContactSet,
svcContext.AccountSet,
c => c.ContactId,
a => a.PrimaryContactId.Id,
(c, a) => new { c, a }),
@t => @t.a.Name.Contains("Contoso")),
@t => @t.c.LastName.Contains("Smith")),
@t => new { account_name = @t.a.Name, contact_name = @t.c.LastName });
```
Не думаю, что разработчик будет рад, если рефакторинг так жестоко поиздевается над его кодом. Поэтому в своей реализации я просто не разрешаю вводить синоним для этих пространств имен.
Несколько слов о реализации
---------------------------
В сети достаточно немного информации о том, как писать плагины для решарпера. Основной источник информации — декомпилятор. Немногим помогает SDK, в котором имеется несколько примеров написания расширений (но на рефакторинг — только один).
Исходные коды доступны на GitHub, но я крайне не рекомендую использовать их для изучения внутренней кухни ReSharper-а.
Результат меня устроил. Надеюсь кому-нибудь пригодиться.
[resharper-plugins.jetbrains.com/packages/IntroduceNsAlias](https://resharper-plugins.jetbrains.com/packages/IntroduceNsAlias/)
[github.com/ulex/IntroduceNsAlias](https://github.com/ulex/IntroduceNsAlias)
Дополнительная информация для плагинописателей ReSharper-a:
• декомпилятор
• [confluence.jetbrains.com/display/NETCOM/ReSharper+Plugin+Development](http://confluence.jetbrains.com/display/NETCOM/ReSharper+Plugin+Development)
• [tv.jetbrains.net/videocontent/getting-started-with-resharper-sdk](http://tv.jetbrains.net/videocontent/getting-started-with-resharper-sdk) | https://habr.com/ru/post/191604/ | null | ru | null |
# Структуры данных в memcached/MemcacheDB. Часть 2
Продолжение [статьи](http://habrahabr.ru/blogs/webdev/50243/) про структуры данных в memcached. В этой завершающей части мы рассмотрим еще три структуры данных: лог событий, массив и таблицу.
Лог событий
-----------
### Задача
Задача этой структуры данных — хранение событий, произошедших в распределенной системе за последние T секунд. Каждое событие имеет момент времени, когда оно произошло, остальное содержимое события определяется логикой приложения.
Операции над логом событий:
* добавить сообщение в лог событий (должна быть максимально быстрой);
* получить события, произошедшие в период времени от Tmin до Tmax (должна быть эффективной, но вызывается реже, чем добавление);
### Решение
```
def time():
"""
Текущее время в секундах с любого момента времени (например, UNIX Epoch).
@return: текущее время в секундах
@rtype: C{int}
"""
class Event:
"""
Событие, помещаемое в лог событий.
"""
def when(self):
"""
Момент времени, когда произошло событие (секунды).
"""
def serialize(self):
"""
Сериализовать событие.
@return: сериализованное представление
@rtype: C{str}
"""
@static
def deserialize(serialized):
"""
Десериализовать набор событий.
@param serialized: сериализованное представление одного
или нескольких событий
@type serialized: C{str}
@return: массив десериализованных событий
@rtype: C{list(Event)}
"""
class MCEventLog(MemcacheObject):
def __init__(self, mc, name, timeChunk=10, numChunks=10):
"""
Конструктор.
@param name: имя лога событий
@type name: C{str}
@param timeChunk: емкость одного ключа лога в секундах
@type timeChunk: C{int}
@param numChunks: число выделяемых ключей под лог
@type numChunks: C{int}
"""
super(MCEventLog, self).__init__(mc)
self.keyTemplate = 'messagelog' + name + '_%d';
self.timeChunk = timeChunk
self.numChunks = numChunks
def put(self, event):
"""
Поместить событие в лог.
@param event: событие
@type event: L{Event}
"""
serialized = event.serialize()
key = self.keyTemplate % (event.when() // self.timeChunk % self.numChunks)
while True:
try:
self.mc.append(key, serialized)
return
except KeyError:
pass
try:
self.mc.add(key, serialized, self.timeChunk * (self.numChunks-1))
return
except KeyError:
pass
def fetch(self, first=None, last=None):
"""
Получить события из лога за указанный период (или все события).
@param first: минимальное время возвращаемого сообщения
@type first: C{int}
@param last: максимальное время возвращаемого сообщения
@type last: C{int}
@return: массив событий
@rtype: C{list(Event)}
"""
if last is None or last > time():
last = time()
if first is None or last < first or
(last-first) > self.timeChunk * (self.numChunks-1):
first = time() — self.timeChunk * (self.numChunks-1)
firstKey = first / self.timeChunk % self.numChunks
lastKey = last / self.timeChunk % self.numChunks
if firstKey < lastKey:
keyRange = range(firstKey, lastKey+1)
else:
keyRange = range(firstKey, self.numChunks) + range(0, lastKey+1)
keys = [self.keyTemplate % n for n in keyRange]
result = []
for key in keys:
try:
events = Event.deserialize(self.mc.get(key))
except KeyError:
continue
result.extend(filter(lambda e: e.when() >= first and
e.when() <= last, l))
return result
```
### Обсуждение
Основная идея лога событий — кольцевой буфер, состоящий из `numChunks` ключей в memcached. Каждый ключ активен (то есть дополняется значениями) в течение `timeChunk` секунд, после чего активным становится следующий ключ (если активным был последний ключ, эта роль переходит к первому ключу). Полный цикл буфера, т.е. период времени между двумя использованиями одного ключа составляет `numChunks * timeChunk` секунд, а время жизни каждого ключа — `(numChunks - 1) * timeChunk` секунд, таким образом при любом сдвиге времени создания ключа по модулю `timeChunk` к моменту времени следующего использования ключ гарантированно будет уничтожен. Таким образом, ёмкость лога событий (или период времени, за который сохраняются события) составляет `(numChunks - 1) * timeChunk` секунд. Такое разбиение лога на ключи позволяет при получении событий из лога вынимать лишь те ключи, которые соответствуют интересному нам временному отрезку.
Выбор параметров `timeChunk` и `numChunks` зависит от применения лога событий: сначала определяется желаемый срок хранения событий, затем по частоте событий выбирается такое значение `timeChunk`, чтобы размер каждого ключа лога событий был относительно небольшим (например, 10-20Кб). Из этих соображений можно найти значение и второго параметра, `numChunks`.
В примере используется некоторый класс `Event`, который обладает единственным интересным для нас свойством — временем, когда произошло событие. В методе `put` лога событий предполагается, что событие `event`, переданное в качестве параметра, произошло «недавно», то есть с момента `event.when()` прошло не более чем `(numChunks - 1) * timeChunk` секунд (емкость лога). При работе `put` вычисляется ключ, в который должна быть помещена информация о событии, в соответствие с его временной меткой. После этого с помощью уже знакомой по предыдущим примерам техники ключ либо создается, либо к значению уже существующего ключа дописывается сериализованное представление события.
Метод `fetch` вычисляет потенциальный набор ключей лога, в которых могут находиться события, произошедшие во временной интервал от `first` до `last`. Если временные рамки не заданы, `last` считается равным текущему моменту времени, а `first` — моменту времени, отстоящему от текущего на емкость лога. Набор ключей вычисляется с учетом кольцевой структуры метода, после чего выбираются соответствующие ключи, десериализуются последовательно записанные в них события и проводится дополнительная фильтрация на попадание в отрезок `[first, last]`.
Приведенная выше сигнатура метода позволяет последовательными обращениями выводить новые события из лога:
1. Первый раз вызывается `events = fetch()`. Вычисляется `lastSeen` как `max(events.when())`.
2. Все последующие обращения выглядят следующим образом: `events = fetch(first=lastSeen)`, при этом
`lastSeen` каждый раз перевычисляется.
Массив
------
### Задача 1
В массиве хранится список значений произвольного типа, относительно редко происходит обновление списка, гораздо чаще происходит получение списка целиком.
Операции над массивом:
* изменить массив (редкая операция);
* получить массив целиком (частая операция).
### Решение 1
```
def serializeArray(array):
"""
Сериализовать массив в бинарное представление.
"""
def deserializeArray(str):
"""
Десериализовать массив из бинарного представления.
"""
class MCArray1(MemcacheObject):
def __init__(self, mc, name):
"""
Конструктор.
@param name: имя массива
@type name: C{str}
"""
super(MCArray1, self).__init__(mc)
self.lock = MCLock(name)
self.key = 'array' + name
def fetch(self):
"""
Получить текущее значение массива.
@return: массив
@rtype: C{list}
"""
try:
return deserializeArray(self.mc.get(self.key))
except KeyError:
return []
def change(self, add_elems=[], delete_elems=[]):
"""
Изменить значение массива, добавив или удалив из него
элементы.
@param add_elems: элементы, которые надо добавить
@type add_elems: C{list}
@param delete_elems: элементы, которые надо удалить
@type delete_elems: C{list}
"""
while not self.lock.try_lock():
pass
try:
try:
array = deserializeArray(self.mc.get(self.key))
except KeyError:
array = []
array = filter(lambda e: e not in delete_elems, array) + add_elems
self.mc.set(self.key, serializeArray(array), 0)
finally:
self.lock.unlock()
```
### Обсуждение 1
Приведенный выше способ решения на самом деле не имеет никакого отношения к массивам, а может быть применен для любой структуры данных. Он основан на модели reader-writer, когда есть много читателей и относительно мало писателей. Читатели в любой момент с помощью метода `fetch` получают содержимое массива, при этом важно, что «писатель» `сhange` записывает содержимое одной командой memcached, то есть в силу внутренней атомарности операций `get` и `set` в memcached и несмотря на отсутствие синхронизации между методами `fetch` и `сhange`, результат `fetch` всегда будет консистентным: это будет значение до или после очередного изменения. Писатели блокируются от одновременного изменения массива с помощью блокировки `MCLock`, описанной выше.
В данной ситуации можно было бы избежать использования блокировки и воспользоваться командами `gets`, `cas` и `add` из протокола memcached для того, чтобы гарантировать атомарность изменений с помощью функции `change`.
### Задача 2
Массив хранит список значений некоторого типа, часто происходит операция вида «добавить значение в массив». Относительно редко массив запрашивается целиком. Для простоты реализации в дальнейшем будет рассматриваться массив целых чисел, хотя для решения задачи тип данных не имеет существенного значения.
Операции над массивом:
* добавить значение в массив (частая операция);
* получить массив целиком.
### Решение 2
```
def serializeInt(int):
"""
Сериализовать целое число в бинарное представление (str).
"""
def deserializeIntArray(str):
"""
Десериализовать массив целых чисел из бинарного представления.
"""
class MCArray2(MemcacheObject):
def __init__(self, mc, name):
"""
Конструктор.
@param name: имя массива
@type name: C{str}
"""
super(MCArray2, self).__init__(mc)
self.key = 'array' + name
def fetch(self):
"""
Получить текущее значение массива.
@return: массив
@rtype: C{list}
"""
try:
return deserializeIntArray(self.mc.get(self.key))
except KeyError:
return []
def add(self, element):
"""
Добавить элемент в массив.
@param element: элемент, который необходимо добавить в массив
@type element: C{int}
"""
element = serializeInt(element)
while True:
try:
self.mc.append(self.key, element)
except KeyError:
return
try:
self.mc.add(self.key, element, 0)
except KeyError:
return
```
### Обсуждение 2
Эта реализация практически повторяет аналогичный код для лога событий, только упрощенный в силу наличия всего одного ключа. По сравнению с первым вариантом реализации типа данных «массив» уменьшилось число операций memcached, все изменяющие массив процессы могут выполняться без задержек (отсутствие блокировок). Как и в первом варианте, не проверяется наличие дубликатов при добавлении элемента в массив (может быть и хорошо, и плохо, в зависимости от применения).
Возможны следующие улучшения (или расширения) описанного примера:
* использование нескольких ключей для хранения массива вместо одного, распределение элементов по ключам с использованием хэширования; такой вариант позволит ограничить размер каждого ключа, при условии что массив большой (содержит много элементов);
* реализация в том же стиле операции удаления элемента из массива, тогда массив можно представить
как последовательность операций «удалить» и «добавить», например сериализованное представление
`+1 +3 +4 -3 +5` будет после десериализации образовывать массив `[1, 4, 5]`; при этом как
операция добавления элемента, так и удаления, будет приводить к дописыванию байт в конец
сериализованного представления (атомарная операция `append`).
Таблица
-------
### Задача
Необходимо хранить множество строк. Операции над множеством:
* проверка принадлежности строки множеству (самая частая операция);
* получение множества целиком, добавление элемента, удаление элемента — редкие операции.
Можно рассматривать данную структуру данных как таблицу, в которой осуществляется быстрый поиск нужной строки. Или как хэш, хранящийся в распределенной памяти.
### Решение
```
def serializeArray(array):
"""
Сериализовать массив в бинарное представление.
"""
def deserializeArray(str):
"""
Десериализовать массив из бинарного представления.
"""
class MCTable(MemcacheObject):
def __init__(self, mc, name):
"""
Конструктор.
@param name: имя таблицы
@type name: C{str}
"""
super(MCTable, self).__init__(mc)
self.lock = MCLock(name)
self.key = 'table' + name
def has(self, key):
"""
Проверка наличия ключа в таблице.
@param key: ключ
@type key: C{str}
@rtype: C{bool}
"""
try:
self.mc.get(self.key + '_v_' + key)
return True
except KeyError:
return False
def fetch(self):
"""
Получить целиком значение элементов таблицы.
@return: значение таблицы
@rtype: C{list(str)}
"""
try:
return deserializeArray(self.mc.get(self.key + '_keys'))
except KeyError:
pass
def add(self, key):
"""
Добавить ключ в таблицу.
@param key: ключ
@type key: C{str}
"""
while not self.lock.try_lock():
pass
try:
try:
array = deserializeArray(self.mc.get(self.key + '_keys'))
except KeyError:
array = []
if key not in array:
array.append(key)
self.mc.set(self.key + '_v_' + key, 1, 0)
self.mc.set(self.key + '_keys', serializeArray(array), 0)
finally:
self.lock.unlock()
def delete(self, key):
"""
Удалить ключ из таблицы.
Реализация аналогична методу add().
"""
```
### Обсуждение
Вообще говоря memcached представляет собой огромную хэш-таблицу, правда в ней отсутствует одна операция, которая необходима для нашей структуры данных: получение списка ключей. Поэтому реализация таблицы использует отдельные ключи для хранения каждого элемента таблицы, и отдельно еще один ключ для хранения списка всех её элементов. Реализация хранения списка всех элементов фактически совпадает с реализацией «массива 1». Для сериализации доступа к списку всех элементов используется блокировка, при этом методы `fetch` и `add` не синхронизированы друг с другом, т.к. список всех элементов меняется атомарно и при чтении ключа мы всегда получим некоторое консистентное состояние.
Проверка наличия ключа в таблице выполняется максимально быстро: проверяется наличие соответствующего ключа в memcached. Любое изменение списка элементов всегда происходит одновременно и в ключе, хранящем весь список, и в отдельных ключах для каждого элемента (которые используются только для проверки).
На основе приведенной схемы можно реализовать полноценный хэш, когда для каждого элемента таблицы будет храниться связанное значение, это значение необходимо будет записывать только в отдельные ключи, соответствующие элементам, а список элементов не будет содержать значений.
Заключение
----------
Итак, приведем список «приемов» или «трюков», описанных в данной статье:
* атомарность операций с помощью memcached (пара `add`/`set` и т.п.);
* блокировки;
* теневые ключи;
* кольцевой буфер с автоматическим «отмиранием» ключей;
* блокировки и модель reader-writer.
В статье не рассматривались вопросы оптимизации, специфичной для memcached, например, использование multi-get запросов. Это делалось сознательно, чтобы не перегружать исходный код и рассказ. Во многих ситуациях приведенные выше примеры следует рассматривать скорее как псевдокод, чем как пример идеальной реализации на Python.
Если Вы нашли ошибку, хотите предложить более ясное, более оптимальное решение поставленным задачам, хотите предложить реализацию для какой-то еще структуры данных — буду рад комментариям и критике. | https://habr.com/ru/post/50247/ | null | ru | null |
# Ультимативный гайд по дизайн-токенам
##### Евгений Шевцов
Руководитель UX-направления в Usetech
На небе только и разговоров, что о дизайн-системах и дизайн-токенах. Но информация представленная здесь строится исключительно на собственном опыте.
Поводом для написания такого гайда стала практика и упорядочивание всей этой информации в голове. Когда я начинал этот путь, то в русскоязычном сегменте было минимум информации и приходилось по крупицам собирать общие практики.
Сегодня я подвожу итог этой темы и суммирую добытые знания, попробовав составить ультимативный гайд по теме. Хотя бы для общего понимания процесса и наводки, в какую сторону копать для таких же жаждущих знаний.
Меня зовут Женя, я руководитель UX-направления в компании [Usetech](https://usetech.ru/). На досуге веду [телеграм-канал «Мамкин Дизайнер»](https://t.me/uxrdesign), где рассказываю о вот таких штуках.
Я сам — дизайнер, но мне важно было понять, что такое дизайн-токены, как они работают, как компилируются из JSON и как помогают в работе.
Дисклеймер
----------
Друзья из frontend – я не разработчик и не претендую на единственно верный процесс. Буду очень рад, если вы дополните мою статью своими комментариями.
> *Я не призываю использовать токены везде и в каждом проекте. Вводить токены или нет — решать вам.*
>
>
Для кого статья
---------------
**Для дизайнеров**: которые слышали о токенах, но не понимают как они взаимодействуют с кодом, как устроены и что с ними можно делать.
**Для разработчиков**: которые шарят за код, но к которым пристают дизайнеры, чтобы ввели токены.
Забегая вперед: вариантов и процессов, через которые токены можно компилировать – множество. Это можно делать не только на фронте, но и на бэке. Я расскажу лишь о нескольких вариантах.
В качестве примера у нас:
* два плагина Figma;
* препроцессор SCSS (Sass);
* сервис zeroheight;
* библиотека Amazon Style Dictionary.
Что такое дизайн-токены?
------------------------
Концепцию дизайн-токенов представили ребята из Salesforce: Джина Болтон и Джон Левин. Они использовали их в своей [дизайн-системе Lightning](https://www.lightningdesignsystem.com/) и рассказывали о ней на презентации. На самом деле их использовали гораздо раньше, просто эти ребята стали первыми людьми, кто о них заговорил.
Они рассказали о своем подходе к проектированию, как токены переносят дизайн и как поддерживать кросс-платформенность. Даже разработали свой собственный продукт Theo, который компилирует JSON/XML в нужный формат.
Миссия дизайн токенов — сократить время на разработку и помочь держать несколько приложений в едином виде, оптимизируя стоимость и время на правки. А ещё они помогают дизайнеру и разработчику общаться на одном языке.
Если мы говорим про большие приложения, их массовость по количеству и платформам, то наверняка эти приложения стоят на каком-то фундаменте. Этот фундамент — дизайн-система.
> *Если вы занимаетесь лендингами или небольшими веб-сайтами, то дизайн-система и уж тем более дизайн-токены вам ни к чему.*
>
>
Дизайн системы строятся на основе атомарного дизайна, от меньшего к большему, переиспользованию компонентов и их вложенности.
Атомарный дизайн
----------------
Атомарный дизайн // Бред ФростЕсли следовать концепции [атомарного дизайна Бреда Фроста](https://medium.com/%D0%B0%D1%82%D0%BE%D0%BC%D0%B0%D1%80%D0%BD%D1%8B%D0%B9-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD/tagged/%D0%B0%D1%82%D0%BE%D0%BC%D0%B0%D1%80%D0%BD%D1%8B%D0%B9-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD-%D0%B3%D0%BB%D0%B0%D0%B2%D0%B0-1), то самой маленькой частицей он представляет атом, но у этих атомов есть ещё и свойства: цвет заливки, цвет текста, шрифт, размер и т.д.
Все эти параметры стиля можно указать в токенах и переиспользовать столько раз, сколько захочется, а универсальность решения позволит с минимальной болью внести правки во всём приложении. Нет, во всех приложениях разом, если их несколько.
> *Дизайн-токены должны стать переносчиком данных со стилями.*
>
>
Получается, что самыми мелкими частицами в атомарном дизайне являются дизайн-токены.
Атомарный дизайн с дизайн-токенамиС чего начать?
--------------
Прежде чем заниматься токенизацией, необходимо провести инвентаризацию интерфейса в Figma, иначе велик шанс навести бардак.
В качестве примера — цветовые стили.
В некоторых проектах я вижу название стилей по визуальному смыслу. Дизайнер придумал, что его приложение будет фиолетовое, а значит он будет как основной цвет. Создает один стиль **primary** и лепит его на все элементы, которые должны быть фиолетового цвета.
Ещё я замечаю, что некоторые стили названы по их значению. Так, например, значение зелёного цвета в hex **#44BE84** равняется названию самого стиля **green**.
Некорректно названные и сгруппированные стилиЗдесь я вижу несколько проблем.
**Проблема 1.** Как объяснить новому дизайнеру, который возьмётся за этот проект, какой стиль и для какого элемента должен быть использован?
**Проблема 2.** Если нет возможности / времени / ресурса отрисовать макет, то разработчик собирает его из готовых элементов прямо в коде — как ему понять какой цвет где использовать, если вдруг появляется новый, но возможно похожий элемент?
**Проблема 3.** Глобальные стили. Мы используем один **primary**-стиль для всего: кнопки, фоны, иконки. Как быть, если иконки нужно перекрасить?
И тут вариантов несколько: или перекрашивать **primary**, что незамедлительно приведет к перекрашиванию других элементов или разлинковывать стиль и придумывать что-то новое. И это касается не только ваших макетов в Figma, но и кода разработчика — перелинковывать переменные придется и там.
Хуже, когда стили называются не просто **primary**, а названием конкретного цвета: **green**, **orange**, **red**. А еще иногда **red-1**, **red-2**, **light-red**. Как понять, какой стиль где использовать?
Также, если стиль нужно будет перекрасить, то это повлечет еще большую путаницу в понимании. Например, для стиля **green**, который используется в уведомлениях, нам придется поменять значение с зеленого на синий. Тогда название стиля **green** будет, мягко говоря, не соответствовать цветовому значению.
Так как дизайн-токены подразумевают семантическое и понятное описание, для чего они используются, нам необходимо правильно называть стили.
Цвет можно разделить на несколько групп. Это решение не 100% универсальное, отталкивайтесь от своих целей и задач.
Расскажу на одном из примеров, как можно сгруппировать цвета.
* **Фоны.** Здесь я указываю общий фон, фон для подложек или островков, фон для подложек у островков (если требуется), границы (разделители, таблицы, обводки элементов), акцентный фон, фон для модальных окон с прозрачностью.
* **Текст.** Отдельный стиль для текста — темный для белых фонов, светлый для ярких фонов. Если надо, то добавляю стили с прозрачностью, для различных подписей и отдельно цвет под ссылку.
* **Иконки.** Цвет иконок для обычного фона и инвертный, если иконки используются на ярких фонах.
* **Кнопки.** Кнопки я разделяю на подгруппы и назначаю стили на различные состояния. Иногда я зашиваю в стиль ещё и цвет текста и подписываю стили по их назначению.
* **Статусы.** Если есть индикация статусов — назначаю отдельные стили для них.
Стили, имеющие семантикуНе бойтесь, если ваши основные цвета будут повторяться несколько раз из стиля в стиль. Это поможет вам более гибко управлять различными контролами и не завязываться на глобальных переменных.
Конструкция токенов
-------------------
Это обычная конструкция, которая помогает унифицировать ваши токены-переменные. Такая конструкция легко ложится на стили в Figma.
`[Category]-[Type]-[Item]-[SubItem]-[State]`
* **Category** – категория токена (color, font);
* **Type** – тип токена (text, background, border);
* **Item** – элемент (button, table, input);
* **SubItem** – тип элемента (primary, secondary);
* **State** – состояние элемента (default, hover, active).
Такая конструкция токена не обязательна, иногда она может выглядеть короче. Всё будет зависеть от ваших условий, фантазий и насколько вы заходите дробить переменные.
Структура дизайн-токенаСемантическое название токенов
------------------------------
На видео пример: разработчику не нужно вспоминать, а какая тень при наведении на карточку. Ему просто нужно ввести первые строчки переменной и выбрать переменную в состоянии **\*-hover**.
В дальнейшем, при использовании семантического описания переменной, разработчику проще оперировать ими при назначении свойств элементам. К тому же, разработчик всегда может напрямую назвать дизайнеру название токена, что позволит сторонам лучше понимать друг друга.
Дизайн-токен = переменная
-------------------------
В мире frontend-разработки (да и backend) токены явление так же не новое. К элементам в коде «прокидываются» переменные, которые содержат в себе значение и переиспользуются в компонентах.
> *Беря за основу опыт frontend — дизайн-токен и есть переменная в коде.*
>
>
**Цвет в коде:**
```
.button {
background-color: #00BFFF;
}
```
**Глобальная переменная цвета в коде:**
```
$frost-sky: #00BFFF;
.button {
background-color: $frost-sky;
}
```
**Дизайн-токен с цветом как переменная:**
```
$color-button-primary-default: #00BFFF;
.button {
background-color: $color-button-primary-default;
}
```
Таким образом, дизайн-токены дают больше гибкости, которые позволяют контролировать стили отдельных компонентов, а не влиять на них глобально.
Это полезно не только с точки зрения кода, но и с точки зрения компонентов в вашей дизайн-библиотеке Figma, где вы гибко используете палитру для разных элементов, а не назначаете одно глобальное свойство на всё.
Переменная называется не просто наугад, а несёт в себе семантический смысл, из которого и дизайнеру и разработчику легко понять, о чём эта переменная и что она определяет.
JSON
----
> ***JSON или JavaScript Object Notation*** *— текстовый формат обмена данными, основанный на JavaScript. Но при этом он может использоваться в любом языке программирования.*
>
>
Дизайн-токены хранятся в JSON-файле, в котором нет ничего хитрого: обычный текстовый файл, с расширением \*.json и специальной древовидной разметкой.
Такой файл генерируется с помощью плагинов в инструментах (Figma, Adobe XD, Sketch), любыми сторонними сервисами (zeroheigh, Specify) или просто пишется ручками.
Как работают дизайн токены в JSONРазметка файла JSON позволяет каталогизировать мета-информацию в древовидную структуру, которая в последующем будет обрабатываться компилятором. JSON становится единым хранилищем всех дизайн-стилей вашего приложения.
Если вы разрабатываете приложение для web и оно одно, то, возможно, завязываться на токенах не стоит. Синхронизировать дизайнера и пару разработчиков вполне можно.
Но что, если у вас есть веб-приложение, iOS приложение и android-приложение? А что, если у вас несколько приложений, которые выполняют разные функции, но выходят под одним брендом?
Тут и выясняется, что стоимость даже небольших правок может влететь в копейку.
> *Даже если вы сегодня делаете одно приложение — подстелите соломку, рынок может измениться, а приложений вашей компании может стать больше.*
>
>
Семантика JSON
--------------
**JSON-объект** — это неупорядоченное множество пар «ключ:значение», заключённых в фигурные скобки { } и взаимодействие с ним проходит, как со словарём.
**Ключ** — это название параметра (свойства), который мы передаём серверу. Он служит для того, чтобы сервер понял, какой параметр мы передаём.
**Например:**
Мы передаем значение "#ffffff" (белый цвет) с ключом "color" (цвет) и значение "16px" с ключом "font-size" (размер шрифта):
```
{
"color": "#ffffff",
"font-size": "16px"
}
```
Семантика дизайн-токена немного усложняется вложенностью и ключом является «value».
```
{
"category": {
"type": {
"item": {
"state": {
"value":
}
}
}
}
}
```
Пример токена с цветом кнопки в разных состояниях:
```
"buttons": {
"primary": {
"fill-border-default": {
"value": "rgb(87,89,206)"
},
"fill-border-hover": {
"value": "rgb(107,110,243)"
},
"fill-border-active": {
"value": "rgb(69,71,168)"
},
"fill-border-disabled": {
"value": "rgba(111,112,195,0.5)"
},
"text": {
"value": "rgb(255,255,255)"
}
}
```
После того, как мы подвергнем этот JSON компиляции для веб-платформы и пре-процессора SCSS, мы получим следующие переменные:
```
$color-button-primary-fill-border-default: rgb(87,89,206);
$color-button-primary-fill-border-hover: rgb(107,110,243);
$color-button-primary-fill-border-active: rgb(69,71,168);
$color-button-primary-fill-border-disabled: rgba(111,112,195,0.5);
$color-button-primary-text: rgb(255,255,255);
```
И далее, в коде можно назначать эти переменные нашим элементам и управлять стилями одним изменением.
Примечательно, что некоторые изменения можно делать напрямую от дизайна к продакшену, минуя этап разработки.
> *Если все правильно настроить, то дизайнеру достаточно будет изменить цвет стиля в Figma и нажать на кнопку, которая отправит JSON на сервер. Проект пересоберется и изменения выкатятся без боли.*
>
>
Компоненты из переменных
------------------------
Переменные сами по себе могут существовать и быть назначены на любой элемент html-страницы. Но я рекомендую некоторые стили оборачивать в так называемые **миксины** (примеси).
> ***Миксины*** *позволяют создавать группы деклараций CSS, которые вам придется использовать по несколько раз на сайте. Вы даже можете передавать переменные в миксины, чтобы сделать их более гибкими.*[*Sass документация*](https://sass-lang.su/documentation/at-rules/mixin)
>
>
За пример возьмем текстовый стиль заголовка, который мы создали в Figma. В нем содержатся:
* семейство шрифтов (font-family);
* размер шрифта (font-size);
* толщина шрифта (font-weight);
* межбуквенное расстояние (letter-spacing);
* высота строки (line-height).
Стиль заголовка в FigmaКак это выглядит в JSON?
------------------------
```
{
"font": {
"header1": {
"fontFamily": {
"value": "Gilroy",
},
"fontSize": {
"value": "48px"
},
"fontWeight": {
"value": 500
}
"letterSpacing": {
"value": "1%"
},
"lineHeight": {
"value": "72px"
}
}
}
}
```
Как это выглядит в переменных?
------------------------------
```
$font-header1-fontFamily: "Gilroy";
$font-header1-fontSize: 48px;
$font-header1-fontWeight: 500;
$font-header1-letterSpacing: 1%;
$font-header1-lineHeight: 72px;
```
Как это выглядит в миксине?
---------------------------
```
@mixin header-1 {
font-family: $font-header1-fontFamily;
font-size: $font-header1-fontSize;
font-weight: $font-header1-fontWeight;
letter-spacing: $font-header1-letterSpacing;
line-height: $font-header1-lineHeight;
}
```
Использование в SCSS:
---------------------
```
h1 {
@include header-1();
}
.banner {
@include header-1();
}
.widget {
@include header-1();
}
```
Что получается в итоговом CSS?
------------------------------
```
h1 {
font-family: "Gilroy";
font-size: 48px;
font-weight: 500;
letter-spacing: 1%;
line-height: 72px;
}
.banner {
font-family: "Gilroy";
font-size: 48px;
font-weight: 500;
letter-spacing: 1%;
line-height: 72px;
}
.widget {
font-family: "Gilroy";
font-size: 48px;
font-weight: 500;
letter-spacing: 1%;
line-height: 72px;
}
```
Мы создали конструкцию, которую сможем переиспользовать столько раз, сколько нам понадобится.
> *Если мы применили эту конструкцию* ***условно 200 раз****, то при изменении размера шрифта (или всего стиля текста) и пары кликов на выгрузку из Figma мы* ***безболезненно*** *заменим все 200 стилей.*
>
>
Но можно и использовать директиву **@extend**, чтобы наследовать свойства и не нагружать браузер для считывания одних и тех же свойств. Но об этом в другой раз.
Токены и дизайнер
-----------------
Давайте теперь вернёмся и посмотрим, как выглядит процесс выгрузки токенов со стороны дизайнера.
Всё, что дизайнер видит в инструменте (Figma, Sketch, Adobe XD) — это графическая составляющая: квадратики и кружочки, заливку цвета через удобный UI, и настройку стилей типографики.
Но если копнуть глубже, то всё это также состоит из кода. Под капотом у той же Figma есть определённые свойства.
Существуют плагины, которые помогают вытаскивать все эти свойства в токены JSON. Работают они по одному и тому же принципу, но отличаются в функционале.
В качестве примера, сегодня рассмотрим два самых популярных плагина:
* Design Tokens
* Figma Tokens
Design Tokens
-------------
Плагин [Design Tokens](https://www.figma.com/community/plugin/888356646278934516) позволяет выгружать:
* стили: цвет, текст, тени;
* физические значения: размеры, отступы, сетки, скругления.
В работе со стилями всё проще — плагин забирает значения из заготовленных стилей документа, а вот физические значения — это танцы с бубнами. Если кратко: нужно готовить фреймы со специальными названиями, чтобы плагин понял, что это токен.
Подробная информация есть в [документации](https://github.com/lukasoppermann/design-tokens#design-tokens) к плагину. Также у плагина есть настройки.
Настройки плагина Design Tokens для FigmaНазвание файла
--------------
Тут общее название, как будет на выходе и расширение. Я советую выбирать \*.json
* \*.tokens.json
* \*.tokens
* \*.json
Формат JSON
-----------
Здесь необходимо выбрать нужный формат нотации ([что это?](https://skillbox.ru/media/code/notatsii-v-programmirovanii/)). Тут выбираете как вам удобнее считывать названия:
* kebab-case (мой выбор);
* camelCase.
Формат токена советую выбирать Original (deprecated). Второй формат W3C удобен для группировки свойств, но может стать проблемой при преобразовании токенов в переменные из-за настроек компилятора.
Настройка префиксов
-------------------
* игнорирование токенов начинающихся с символов *#*, *.*, *@*
* идентификация названия токенов
Это раздел советую не трогать и оставить поля, которые заполнены по умолчанию.
Префиксы для типа токенов
-------------------------
Префиксы типов означают, как плагин будет искать совпадения по названию ваших компонентов/стилей/фреймов.
Если фрейм назван как **size/sizes**, то он автоматически подставит нужные числа, указанные в размерах этого элемента, а токен будет начинаться с **size-\***.
Работа с токенами плагина Design Tokens. Примеры
------------------------------------------------
Теперь, когда все настройки сделаны, перейдем к обозначению токенов в самой Figma. С цветом и типографикой, как я говорил выше, всё просто. Достаточно создать эти стили и при экспорте json поставить нужные чекбоксы.
А далее, чтобы выгрузить значения размеров / скругления / брейкпоинтов магическим движением рук, нам надо создать фрейм с названием **«\_token/\*\*\*»** и положить в него то, что хотим получить в токене. Ниже рассмотрим на примере размеров.
Размеры
-------
Чтобы выгрузить в токен размерную сетку, нам необходимо создать фрейм с названием **«\_token/sizes»**, а внутрь положить фреймы со всеми необходимыми размерами. Сами фреймы необходимо назвать **«sizes/значение»**.
При выгрузке токена он получит следующее название: **[size-\*\*]**, значение которого возьмётся из размерных свойств.
Дизайн-токены для параметра размера блоковДизайн-токены для параметра размера блоков
После выгрузки мы получим следующий код JSON:
```
{
"size": {
"80": {
"value": 80
},
"120": {
"value": 120
},
"160": {
"value": 160
}
}
}
```
Переменные в SCSS будут выглядеть так:
```
$size-80: 80px;
$size-120: 120px;
$size-160: 160px;
```
Все примеры выгрузки вы сможете посмотреть в документации к плагину и в Playground-файле.
Выгрузка токенов
----------------
Выгрузка JSON-файла может происходить в двух вариантах:
* ручная выгрузка на компьютер;
* выгрузка в репозиторий Github.
В случае с Github можно пойти двумя путями:
* просто выгружать файл и ответственный человек пересоберет проект и отправит изменения на продакшн;
* настроить автоматическую сборку проекта по изменению файла с токенами.
Figma Tokens
------------
Плагин [Figma Tokens](https://www.figma.com/community/plugin/843461159747178978) хорош всем. Не требует дополнительных настроек и дизайн-токены можно как выгружать из него, так и загружать, если вы изменили что-то вручную.
Большим плюсом является линковка и поддержка документации. Если что-то поменялось в токене: цвет заливки, бордера или описание этого токена, то он автоматически поменяет значение и в вашей документации в Figma.
Стили можно как импортировать из документа Figma, так и создать прямо в плагине.
Плагин Figma Tokens для работы с дизайн-токенамиПлагин имеет два вида работы с токенами: в виде UI интерфейса и размеченным JSON-файлом. Значения для цвета могут быть в hex, rgb, hsl.
Название и ссылки
-----------------
Название токена именуется через точку и обозначает вложенность. Так, например, если нам нужно получить переменную $color-button-primary-default, необходимо в имени переменной написать: button.primary.default. Категория токена подтянется из родительской группы при выгрузке.
Родительская категория токенаВ параметр токена мы можем передавать не только прямое значение, но и ссылаться на ранее созданный токен. Это называется **alias**. Ссылаться на токен нужно через **{alias}**.
**Например.** Мы хотим считать цвет через HSL, меняя только параметры *saturation* и *lightness*, а *hue* оставить отдельной переменной.
Создаем токен с наименованием **button.base** и присваиваем значение 313. Оттенок цвета (hue).
Далее создаем токен **button.primary.default** и вместо прямого значения HSL делаем его гибридным, ссылаемся на базовый токен и крутим *saturation* и *lightness*.
Alias в плагине пишется как **{alias}**, а значит запись для **button.primary.default** будет выглядеть как:
```
hsl({button.base},71,55)
```
А после обработки, вот так:
```
hsl(313,71,55)
```
Создаем такие же токены для hover, active. Только не забываем покрутить saturation и lightness.
Создание дизайн-токенов с использованием alias в Figma TokensНа примере ниже, переменные сделаны именно таким образом. Если нам необходимо перекрасить основной цвет и его оттенки для разных состояний, нам будет достаточно поменять базовое число в **button.base.**
Обновление документации
-----------------------
Плагин позволяет линковать к слоям Figma параметры стилей. Например, для цвета можно линковать заливку, границы, имя токена, значение токена и его описание.
Достаточно открыть плагин, выбрать нужные фреймы и слои и в контекстном меню токена выбрать, к какому типу линкуется слой.
Загрузка токенов
----------------
Как уже упоминалось выше, JSON можно не только выгружать, но и загружать. Если по какой-то причине разработчик изменил значения в JSON файле и сменил несколько параметров, то достаточно скопировать содержимое всего JSON-файла и просто вставить в плагин.
Загрузка JSON-файла с токенами в плагин Figma TokensВыгрузка
--------
У плагина есть несколько способов выгрузки JSON-файла, которые прячутся на вкладке Settings:
* локальный файл;
* на сервер по URL;
* в GitHub или GitLab
Также у плагина есть более расширенная платная версия, о которой мы поговорим в другой раз.
Преобразование из JSON
----------------------
Мы разобрались, что дизайн-токены хранятся в JSON, что их можно или выгрузить через плагин или написать ручками, но как получить из JSON преобразованные переменные в SCSS-файле?
Преобразователей несколько:
* сервис для документации [zeroheight](https://zeroheight.com/) (только цвет и текст);
* продукт [Specify](https://specifyapp.com/), для хранения документации проекта и токенов;
* библиотека [Theo от Salesforce](https://github.com/salesforce-ux/theo);
* библиотека из npm [«JSON to SCSS»](https://www.npmjs.com/package/json-to-scss) (только SCSS);
* библиотека [Amazon Style Dictionary](https://amzn.github.io/style-dictionary/#/README).
Сегодня посмотрим на сервис и библиотеку.
Zeroheight
----------
Этот сервис очень похож на популярный у разработчиков [storybook](https://storybook.js.org/) – программное обеспечение для документации кода.
Но zeroheight более дружественный по отношению к дизайнеру и обладает приятным бонусом: все стили и компоненты можно грузить непосредственно из Figma в пару кликов.
Zeroheight поддерживает дизайн-токены, но в ограниченном виде: только типографика и цвет. Никаких танцев с кодом и установкой дополнительных библиотек. Если вам этого хватает, то смело используйте его.
С чего начать?
--------------
Необходимо зарегистрироваться в сервисе, подключить свой Figma-файл и добавить стили на страницу. Я подробно рассказывал о сервисе [zeroheight в своем обзоре](https://uxrdsgn.ru/zeroheight/).
Загрузка дизайна
----------------
Далее необходимо выбрать нужную страницу в документации и подгрузить туда необходимые стили. Например, цвет.
Цветовая палитра в zeroheightДизайн-токены
-------------
У сервиса есть блоки форматирования и вставки. Вы можете добавлять текст, элементы из Figma, сниппеты, живой код, таблицы и дизайн-токены. Разметка токенов делится на 2 версии.
Первая версия сразу собирает необходимые форматы:
* Sass
* CSS
* JSON
* iOS
* Android
Необходимо только добавить префиксы к токенам, если это необходимо. Файл с преобразованными переменными можно или скачать, или подключить в свой проект по адресу, который предлагает zeroheight.
Дизайн-токены в zeroheight // Версия 1Вторая версия отдает JSON файл и предлагает подключить его в свой проект, где компилятором выступает библиотека Amazon Style Dictionary.
Дизайн-токены в zeroheight // Версия 2Таким образом возникает процесс изменения стилей для приложения минуя разработчика. Дизайнер меняет что-то в Figma, загружает по кнопке в zeroheight и на проекте в реальном времени применяются изменения.
> *Будьте осторожны. Данный способ на бесплатных тарифах не подразумевает какую-то историю изменений или версионность. Если дизайнер что-то поменял в макете и обновил это в сервисе — изменения применятся в проекте.*
>
>
Amazon Style Dictionary
-----------------------
Если пойти по пути выгрузки JSON, то просто положить его на сервер и радоваться не получится. Необходимо установить специальную библиотеку, которая распознает JSON и конвертирует в нужный формат.
Команда Amazon в 2017 году представила собственную библиотеку, которая помогает преобразовать JSON-файл в переменные для web (css, scss, less), iOS и Android-форматы.
> *У сервиса есть «*[*песочница*](https://www.style-dictionary-play.dev/)*», в которой можно поиграться и посмотреть на изменения в демо-карточке.*
>
>
Сейчас постараюсь простыми словами объяснить, как установить и настроить данный компилятор.
Установка
---------
Дальше мы будем действовать в интерфейсе CLI (command line interface), проще говоря из командной строки.
Для MacOS это встроенное приложение «Терминал», для Windows это «Командная строка» (cmd). Но можно и в любом редакторе кода, который поддерживает данный интерфейс.
Шаг 1. Установка программной платформы npm
------------------------------------------
Нам необходимо установить глобальную программную платформу npm (Node Package Manager) ([что это?](https://proglib.io/p/chto-takoe-npm-gayd-po-node-package-manager-dlya-nachinayushchih-2020-07-21)) и node.js. Это репозиторий для различных пакетов с приложениями. Если говорить на обывательском языке — магазин, где можно скачать приложение.
> *Установить node.js можно* [*скачав с сайта*](https://nodejs.org/en/download/)*, выбрав нужную операционную систему.*
>
>
Чтобы проверить, установлены ли у вас node.js и npm можно воспользоваться следующими командами в CLI:
`node -v` и `npm -v`
Когда мы убедились, что платформа установлена, переходим к установке Style Dictionary.
Шаг 2. Установка Style Dictionary
---------------------------------
Введите в командной строке:
`npm install -g style-dictionary`
После этого дождитесь завершения установки.
Шаг 3. Создание проекта
-----------------------
Нам необходимо перейти в нужную папку, где у вас лежит проект и где будет дополнительно развернут Style Dictionary ([**как указать путь к папке в CLI?**](https://ru.wikihow.com/%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%89%D0%B0%D1%82%D1%8C%D1%81%D1%8F-%D0%BF%D0%BE-%D0%BA%D0%B0%D1%82%D0%B0%D0%BB%D0%BE%D0%B3%D0%B0%D0%BC-%D0%BF%D0%BE%D1%81%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%BE%D0%BC-%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D0%BD%D0%BE%D0%B9-%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8)).
`cd путь к папке`
Теперь инициируем базовый проект, он создаст все необходимые директории и файлы:
`style-dictionary init basic`
После этой команды вы должны увидеть такое:
Посмотреть`Copying starter files...`
`Source style dictionary starter files created!`
`Running `style-dictionary build` for the first time to generate build artifacts.`
`scss`
`✔︎ build/scss/_variables.scss`
`android`
`✔︎ build/android/font_dimens.xml`
`✔︎ build/android/colors.xml`
`compose`
`✔︎ build/compose/StyleDictionaryColor.kt`
`✔︎ build/compose/StyleDictionarySize.kt`
`ios`
`✔︎ build/ios/StyleDictionaryColor.h`
`✔︎ build/ios/StyleDictionaryColor.m`
`✔︎ build/ios/StyleDictionarySize.h`
`✔︎ build/ios/StyleDictionarySize.m`
`ios-swift`
`✔︎ build/ios-swift/StyleDictionary.swift`
`ios-swift-separate-enums`
`✔︎ build/ios-swift/StyleDictionaryColor.swift`
`✔︎ build/ios-swift/StyleDictionarySize.swift`
Это сообщение говорит о том, что созданы файлы для SCSS, Android, compose, iOS, iOS-swift.
В структуре вы обнаружите папки и файлы:
* **tokens** — в ней содержатся JSON с демо-токенами;
* **build** — все артефакты, скомпилированные из JSON
* **config.json** — файл с настройками.
Шаг 4. Проверка
---------------
Вы можете пробежаться по файлам и посмотреть, как они сгенерированы и соответствуют ли они данным в JSON. Предлагаю здесь зайти в файл JSON и в ручную поменять несколько значений.
После того как измените, необходимо пересобрать проект командой:
`style-dictionary build`
> *Это главная команда, которую необходимо вызывать после того, как вносите изменения в JSON.*
>
>
Шаг 5. Настройка
----------------
Все настройки, которые отвечают за компиляцию ваших токенов находятся здесь.
* **source** — отвечает за то, из каких папок и какие файлы необходимо конвертировать;
* **platforms** — массив настроек, отвечающий за платформу, в которую компилируем;
* **scss (ios, android, css)** — название платформы и внутри неё локальные настройки этой платформы;
* **transforms** — дополнительные настройки преобразования величин и значений;
* **transformGroup** — в какой формат файла преобразовываем;
* **buildPath** — папка, куда будут складываться преобразованные файлы;
* **destinations** — название файла;
* **format** — формат, в который будет преобразован JSON.
```
const StyleDictionary = require('style-dictionary').extend({
source: ['tokens/**/*.json'],
platforms: {
scss: {
transforms: ["attribute/cti", "name/cti/kebab", "color/hex", "size/rem"],
transformGroup: 'scss',
buildPath: 'build/',
files: [{
destination: 'variables.scss',
format: 'scss/variables'
}]
}
// ...
}
});
StyleDictionary.buildAllPlatforms();
```
В этом файле настройки объединяются по платформам и гибко настраиваются форматы и пути. Также есть ряд дополнительных настроек.
Из дополнительных настроек, на которые стоит обратить внимание, это transforms. В этой строчке можно задать конвертацию значений из px в sp/dp/pt/rem, из hex в rgb/hsl, и форматы названия переменных kebab-case и camelCase.
По сути, вся базовая настройка сделана. Нам остается только подкладывать JSON файлы в нужную папку и собирать проект.
Токены для компонентов
----------------------
В основном токены хранят в себе базовые стили, такие как цвет, типографика, тени и некоторые значения типа размеров и скруглений.
Но токены имеют гибкую конструкцию, и их можно использовать в описании конкретных компонентов. Подробную историю рассказал Кристиано Растелли, который делал [дизайн-систему Cosmos для Badoo](https://habr.com/ru/company/badoo/blog/491948/).
Собранные на дизайн-токенах кнопки // Опыт BadooСобранный на дизайн-токенах Action Sheet // Опыт Badoo При таком подходе мы можем гибко управлять не только глобальными стилями, но и конкретными компонентами.
> *Но запомните, что чем больше переменных — тем сложнее их поддерживать. Будьте аккуратнее и разумны.*
>
> *Если вы уже проделывали такое или собираетесь — напишите мне, пожалуйста, поделитесь опытом.*
>
>
Немного советов
---------------
При выгрузке токенов, я выгружаю всегда базовые значения и стили, редко пользуюсь размерами, отступами в самой Figma, а пишу JSON руками.
Делюсь несколькими советами, надеюсь, они будут ценны.
Размеры
-------
Я видел несколько неймингов по размерной сетке: и в градации сотых чисел, и в так называемых «майках».
```
$size-100: 4px;
$size-200: 8px;
...
$size-s: 4px;
$size-m: 8px;
```
Но на мой взгляд, такой нейминг неудобен с точки зрения логического понимая и коммуникации. Представим, что разработчик отложил проект на неделю. Вернувшись к нему, необходимо заново вспомнить, какие переменные используются в размерной сетке и какие значения несут. Ещё хуже, если на проект пришел новенький и заучивать все переменные — это плохая история.
Я предлагаю вводить базовую величину, которая будет умножаться на определённое число, а в нейминге так и указать, на какое число мы множим.
```
$size-base: 4px;
$size-x1: $size-base;
$size-x2: $size-base*2;
...
$size-x10: $size-base*10;
```
Таким образом участникам команды не придётся держать в голове всю размерную сетку, а всего лишь её базовое значение в 4px, а глядя на название переменной можно понять, какое значение будет на выходе. Если мы захотим поставить отступы в 16px, то необходимо использовать переменную $size-x4.
К тому же, если вы захотите изменить базовый шаг, скажем на 2px, то размерная сетка автоматически пересчитается.
Цвет
----
Цвет можно считать автоматически, подставляя необходимые переменные и используя усилители цвета в SCSS.
Цвет можно считать в HEX, забивая в переменную базовый цвет, осветлять (lighten) или затемнять (darken) его. Как только базовый цвет изменится — палитра автоматически пересчитается. Важно то, что непрозрачность остается 100%, меняется само цветовое значение.
```
$color-base: #ffcc00;
$color-base-primary: $color-base;
$color-base-hover: darken($color-base,10%);
$color-base-active: lighten($color-base,10%);
```
Или можно посчитать в HSL, взяв за основу оттенок (*hue*), изменяя только насыщение (*saturation*) и яркость (*lightness*):
```
$color-accent: 72;
$color-accent-default: hsla($color-accent, 100%, 36%, 1);
$color-accent-hover: hsla($color-accent, 100%, 29%, 1);
$color-accent-active: hsla($color-accent, 53%, 44%, 1);
```
«A» — в модели hsla это альфа-канал непрозрачности.
Итоги
-----
Как я уже говорил, если вы делаете сайтики и лендинги — вам не нужны дизайн токены.
Но они нужны, если:
1. Вы делаете несколько приложений и сервисов, которые должны быть консистентны, иметь единый вид;
2. Если вы планируете темезацию, будь – то светлая и темная тема одного приложения;
3. Проектируете какое-то white label решение, которое кастомизируется под каждого заказчика.
> *Подстелить себе соломку — лишним уж точно не будет.*
>
>
Решение использовать дизайн-токены — не панацея от проблем, и я не призываю вас бежать и внедрять их прямо сейчас, это такой же долгий и порой непростой путь.
Но если вы понимаете, что вам это необходимо сделать и это точно закроет ваши проблемы, то следуйте простым правилам:
* Заручитесь поддержкой разработки и узнайте, насколько они готовы вкладываться в это;
* Проведите инвентаризацию текущих макетов в Figma;
* Определитесь с категориями, что вы будете подвергать токенизации;
* Разложите по смысловым группам стили и приведите в порядок семантические названия. И здесь важно договориться с разработкой о том, как будет понятнее всем;
* Выберите необходимый инструмент — простой сервис zeroheight или выгрузка через плагины;
* Если через плагины, то определитесь, какая библиотека будет компилировать ваши файлы;
* Выстройте максимально прозрачный путь с разработкой, чтобы вы говорили на одном языке;
* И последний, немаловажный пункт — наслаждайтесь!
Полезные материалы
------------------
#### Видео
* [Токены в дизайн-системах / Юрий Ветров (Mail.Ru Group)](https://www.youtube.com/watch?v=X3ciRPwzEMs&feature=emb_imp_woyt)
* [Friends of Figma: Design Tokens](https://www.youtube.com/watch?v=uveDXPRLk9c&feature=emb_imp_woyt)
* [Design Tokens in Figma: How to get started, today. Jan Six — Live & Q&A- Into Design Systems](https://www.youtube.com/watch?v=Ka1I5TphDb0&feature=emb_imp_woyt)
#### Статьи
* [Что такое дизайн-токены? Давайте разбираться вместе](https://ux.pub/editorial/chto-takoie-dizain-tokienydavaitie-razbiratsia-vmiestie-4bhb)
* [Дизайн-токены способны на большее: создаем единый источник информации о компонентах UI](https://habr.com/ru/company/badoo/blog/491948/)
* [Как использовать дизайн-токены в React — опыт команды Bit](https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD-%D1%82%D0%BE%D0%BA%D0%B5%D0%BD%D1%8B-%D0%B2-react-%D0%BE%D0%BF%D1%8B%D1%82-%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D1%8B-bit-a562ab141444)
* [Что такое Design токены?](https://dev.to/balaevarif/design-844) | https://habr.com/ru/post/673196/ | null | ru | null |
# Расширенная настройка Exim и Dovecot с привязкой к OpenLDAP
В этой статье рассматривается расширенная настройка Exim, Dovecot и OpenLDAP для совместной работы на основе моего опыта с этими приложениями. Быть может, кто-то найдет для себя что-либо интересное и новое — в этом и была цель написания очередного howto на данную тему.
Почему Exim и OpenLDAP, а не Postfix и MySQL, например? Postfix отлично работает «из коробки», но если нужно что-то неординарное, то очень скоро Postfix превращается в неповоротливого монстра, обвешанного перл-скриптами, Exim же обладает чудовищным по силе мета-языком конфигурации и позволяет обойтись без сторонних скриптов и костылей. MySQL я посчитал избыточным для моих задач и заменил стандартным OpenLDAP, тем более для работы адресной книги используется LDAP. Dovecot очень шустрый и легкий в настройке плюс отлично интегрируется как с Exim, так и с OpenLDAP.
Итак, устанавливаем необходимый софт, тут все стандартно (apt-get, yum и тд). Я использовал Gentoo, поэтому emerge openldap dovecot exim (exim и dovecot должны иметь поддержку ldap).
Используемые USE флаги при сборке:
```
net-nds/openldap-2.4.40-r3::x-overlay USE="berkdb crypt gnutls overlays samba sasl ssl syslog
mail-mta/exim-4.85::gentoo USE="dkim dnsdb dovecot-sasl dsn exiscan-acl gnutls ldap lmtp maildir pam pkcs11 prdr spf ssl syslog
net-mail/dovecot-2.2.18::gentoo USE="bzip2 caps ldap maildir managesieve pam sieve ssl zlib
```
Первым в очереди будет OpenLDAP, в его базе будут храниться все почтовые аккаунты, группы и альясы, также OpenLDAP будет использоваться в качестве адресной книги для почтовых клиентов. Для простоты и удобства я не использую slapd-config, а храню все настройки в текстовом slapd.conf.
Так как стандартный OpenLDAP не имеет в наличии подходящей схемы для работы с почтой, то я использовал свою модифицированную версию [phamm.schema](http://pastebin.com/cYZ3mgx5) и дефолтную [phamm-vacation.schema](http://open.rhx.it/phamm/schema/phamm-vacation.schema).
#### Настройка OpenLDAP
Опускаю первичную настройку, создание basedn dc=domain,dc=com и ssl сертификатов для OpenLDAP, поскольку тут все стандартно.
**Конфиг slapd.conf**
```
include /etc/openldap/schema/core.schema
include /etc/openldap/schema/cosine.schema
include /etc/openldap/schema/corba.schema
include /etc/openldap/schema/inetorgperson.schema
include /etc/openldap/schema/nis.schema
include /etc/openldap/schema/misc.schema
# подключаем нужные схемы
include /etc/openldap/schema/phamm.schema
include /etc/openldap/schema/phamm-vacation.schema
pidfile /run/openldap/slapd.pid
argsfile /run/openldap/slapd.args
# Указываем путь к сертификатам для работы через TLS
TLSCACertificateFile /etc/openldap/ssl/cacert.pem
TLSCertificateFile /etc/openldap/ssl/newcert.pem
TLSCertificateKeyFile /etc/openldap/ssl/newkey.pem
TLSProtocolMin 3.1
TLSVerifyClient allow
database bdb # Используется стандартная bdb база, небыстрая, но надежная.
cachesize 100000
suffix "dc=domain,dc=com"
rootdn "uid=manager,dc=domain,dc=com" # Учетка админа
rootpw ****
directory /var/lib/openldap-data
checkpoint 32 30
idletimeout 120
writetimeout 120
loglevel none
overlay syncprov # Используется модуль репликации syncprov
syncprov-checkpoint 100 10
syncprov-sessionlog 100
# Определяем индексы
index uid,accountActive,vacationActive,createMaildir eq
index cn,givenName,sn,mail pres,eq,sub
index uidNumber,gidNumber,memberUid eq
index entryCSN,entryUUID eq
index objectClass,member,uniqueMember eq
# Определяем права доступа к базе
# Учетка, используемая для репликации
limits dn="uid=replicator,ou=services,dc=domain,dc=com"
size=unlimited
time=unlimited
# Учетка, используемая phpldapadmin
limits dn="uid=ldapadmin,ou=services,dc=domain,dc=com"
size=unlimited
time=unlimited
# Учетка exim
limits dn="uid=exim,ou=services,dc=domain,dc=com"
size=unlimited
time=unlimited
# Учетка nsswitch
limits dn="uid=proxyagent,ou=services,dc=domain,dc=com"
size=unlimited
time=unlimited
# Самое ценное в базе это пароли
access to attrs=userPassword
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by dn.base="uid=replicator,ou=services,dc=domain,dc=com" read
by dn.base="uid=proxyagent,ou=services,dc=domain,dc=com" read
by anonymous auth
by self write
by * none
access to attrs=mail
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by * read
access to *
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by users read
by anonymous auth
```
Обязательно настраиваем репликацию для OpenLDAP (опять же тут все стандартно, поэтому опускаю детали). Единственно, что мне пришлось собирать OpenLDAP руками для поддержки sssvlv (Server Side Sorting and Virtual List View) в адресной книге (./configure --enable-ipv6=no --enable-syncprov=yes --enable-sssvlv=yes --with-tls=yes).
Также для корректной работы sssvlv в аутлюке, пришлось патчить исходники OpenLDAP.
**Патч**
```
--- servers/slapd/schema_prep.c 2011-11-25 20:52:29.000000000 +0200
+++ servers/slapd/schema_prep.c 2011-11-29 13:46:57.000000000 +0200
@@ -915,6 +915,7 @@
offsetof(struct slap_internal_schema, si_ad_name) },
{ "cn", "( 2.5.4.3 NAME ( 'cn' 'commonName' ) "
"DESC 'RFC4519: common name(s) for which the entity is known by' "
+ "ORDERING caseIgnoreOrderingMatch "
"SUP name )",
NULL, 0,
NULL, NULL,
@@ -924,6 +925,7 @@
"DESC 'RFC4519: user identifier' "
"EQUALITY caseIgnoreMatch "
"SUBSTR caseIgnoreSubstringsMatch "
+ "ORDERING caseIgnoreOrderingMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{256} )",
NULL, 0,
NULL, NULL,
(END)
```
Второй сервер будет работать как адресная книга в режиме только для чтения.
**Конфиг slapd.conf для второго LDAP сервера**
```
include /etc/ldap/schema/corba.schema
include /etc/ldap/schema/core.schema
include /etc/ldap/schema/cosine.schema
include /etc/ldap/schema/inetorgperson.schema
include /etc/ldap/schema/misc.schema
include /etc/ldap/schema/nis.schema
# Все slapd сервера при репликации обязательно должны иметь идентичные схемы
include /etc/ldap/schema/phamm-vacation.schema
include /etc/ldap/schema/phamm.schema
# Load dynamic backend modules:
#modulepath /usr/lib/ldap
#moduleload back_hdb.so
#moduleload sssvlv.so #подключаем sssvlv модуль для адресной книги Outlook
idletimeout 120
threads 8
sizelimit 1000
pidfile /var/run/slapd/slapd.pid
argsfile /var/run/slapd/slapd.args
loglevel 0
# Указываем путь к сертификатам для работы через TLS
TLSCACertificateFile /etc/ldap/ssl/ca.pem
TLSCertificateFile /etc/ldap/ssl/ab.domain.com_crt.pem
TLSCertificateKeyFile /etc/ldap/ssl/ab.domain.com_key.pem
TLSProtocolMin 3.1
TLSVerifyClient allow
database hdb # Тут уже используется легковесная hdb
cachesize 100000
suffix "dc=domain,dc=com"
rootdn "cn=replicator,ou=services,dc=domain,dc=com"
rootpw *****
directory /var/lib/ldap
checkpoint 32 30
idletimeout 120
writetimeout 120
overlay sssvlv
# Настройка репликации через TLS, используя syncrepl
syncrepl rid=001 # ID репликации
provider=ldaps://domain.com # Используется ldaps:// , так как через starttls репликация работает нестабильно с self-signed сертификатами
type=refreshOnly
interval=00:00:10:00
searchbase="dc=domain,dc=com"
scope=sub
schemachecking=off
bindmethod=simple
binddn="uid=replicator,ou=services,dc=domain,dc=com" # Предварительно созданный posix аккаунт в ou=services, указанный в slapd.conf
credentials=****
tls_cacertdir=/etc/ssl/certs
tls_cacert=/etc/ldap/ssl/ca.pem
tls_cert=/etc/ldap/ssl/ab.domain.com_crt.pem
tls_key=/etc/ldap/ssl/ab.domain.com_key.pem
tls_reqcert=allow
index uid,accountActive,vacationActive eq
index cn,givenName,sn,mail pres,eq,sub
index uidNumber,gidNumber,memberUid eq
index entryCSN,entryUUID eq
index objectClass,member,uniqueMember eq
# Убираем ограничения для нормальной работы репликации
limits dn="uid=replicator,ou=services,dc=domain,dc=com"
size=unlimited
time=unlimited
# Убираем ограничения для нормальной работы адресной книги
limits users
size=unlimited
time=unlimited
# Определяем права доступа
access to attrs=userPassword
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by dn.base="uid=replicator,ou=services,dc=domain,dc=com" write
by dn.base="uid=proxyagent,ou=services,dc=domain,dc=com" read
by anonymous auth
by self write
by * none
access to attrs=mail
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by dn.base="uid=replicator,ou=services,dc=domain,dc=com" write
by * read
access to attrs=cn
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by dn.base="uid=replicator,ou=services,dc=domain,dc=com" write
by * read
access to *
by dn.base="uid=ldapadmin,ou=services,dc=domain,dc=com" write
by dn.base="uid=replicator,ou=services,dc=domain,dc=com" write
by users read
by anonymous auth
```
Для администрирования LDAP базы я использую phpldapadmin, так как он легкий, удобный и имеет поддержку XML шаблонов, что позволяет гибко настраивать необходимые шаблоны для создания аккаунтов. К сожалению, проект давно заброшен автором и больше не развивается.
Например, пример шаблона для создания почтового аккаунта.
**Код**
```
# Базовый posix аккаунт
# Указываем класс из нашей почтовой phamm схемы
# Указываем класс из phamm-vacation схемы
First Name
ldap-uid.png
1
1
Last Name
=autoFill(cn;%givenName% %sn%)
=autoFill(uid;%givenName|0-1/l%%sn/l%)
=autoFill(loginShell;/sbin/nologin)
=autoFill(FTPStatus;enabled)
2
1
Common Name
3
UID
=autoFill(homeDirectory;/home/%uid%)
=autoFill(mailbox;/home/%uid%/Maildir)
=autoFill(mail;%uid%@domain.com)
=autoFill(company;My Company)
4
1
```
При создании я использую следующую схему LDAP базы:
ou=people,dc=domain,dc=com — контейнер для хранения почтовых аккаунтов;
ou=groups,dc=domain,dc=com — контейнер для хранения posix групп;
ou=services,dc=domain,dc=com — контейнер для хранения аккаунтов системных сервисов (posix аккаунты);
ou=aliases,dc=domain,dc=com — контейнер для хранения почтовых альясов.
При создании почтового аккаунта используются множество атрибутов модифицированной мною phamm схемы, применение которых выходит за рамки это статьи (например, createMaildir или Backup). Отмечу только те, которые используются в фильтрах поиска.
accountActive = TRUE|FALSE — позволяет временно включать/отключать аккаунт или альяс;
vacationInfo — содержит текст Out of Office сообщения;
vacationActive — позволяет включать/отключать OoO сообщение;
quota — тут и так понятно (например: quota = 4G)
Итак, OpenLDAP настроен и запущен, репликация работает и при помощи phpldapadmin создан первый тестовый аккаунт ipupkin c адресом почты ipupkin@domain.com. В дальнейшем будет использоваться только один домен domain.com, поэтому создаем в нашем контейнере ou=groups posix группу domain и добавляем ipupkin в эту группу.
В данном примере все сервисы работают на одном линукс сервере и логично использовать лдап базу для идентификации пользователя в системе, поэтому перекладываем это процедуру на плечи Name Service Switch (nss) или System Security Services Daemon (sssd). Также плюсом данного решения является легкая адаптация с Samba доменом, при необходимости.
Предварительно нужно убедиться что в системе установлен пакет nss\_ldap (или libnss-ldapd).
В /etc/nsswitch.conf меняем строки с compat на ldap (или winbind в случае Samba домена):
passwd: files ldap
shadow: files ldap
group: files ldap
Создаем файл /etc/ldap.conf следующего содержания:
**ldap.conf**uri ldap://127.0.0.1
uri ldap://192.168.0.1 # Второй fallback лдап-сервер
base dc=domain,dc=com
binddn uid=proxyagent,ou=services,dc=domain,dc=com # Предварительно созданный в ou=services posix аккаунт, указанный в slapd.conf
bindpw \*\*\*\*\*
pam\_filter objectclass=posixAccount
pam\_login\_attribute uid
pam\_check\_host\_attr no
pam\_lookup\_policy no
pam\_member\_attribute memberUid
pam\_min\_uid 1000
pam\_max\_uid 65535
ssl start\_tls #используем TLS вместо SSL
# Указываем пути к сертификатам
tls\_cacert /etc/openldap/ssl/ca.pem
tls\_key /etc/openldap/ssl/mail\_crt\_new.pem
tls\_cert /etc/openldap/ssl/mail\_key\_new.pem
tls\_reqcert allow
tls\_checkpeer no
tls\_ciphers TLSv1
scope sub
timelimit 5
bind\_timelimit 5
bind\_policy soft
nss\_reconnect\_tries 4
nss\_reconnect\_sleeptime 1
nss\_reconnect\_maxsleeptime 16
nss\_reconnect\_maxconntries 2
Проверяем, что nss работает и создана домашная директория (mkdir -m 700 /home ipupkin && chown ipupkin:domain /home/ipupkin).
>id ipupkin
uid=1057(ipupkin) gid=1000(domain) groups=1000(domain)
> ls -ld /home/ipupkin
drwx------ 3 ipupkin domain 4096 Jun 22 15:50 /home/ipupkin
Теперь, когда пользователь ipupkin распознается системой, нужно чтобы ipupkin смог получать и отсылать почту.
#### Настройка Dovecot
При настройке Dovecot я удалил все вложенные монструозные дефолтные конфиги и для удобства создал только два — dovecot.conf и dovecot-ldap.conf.
**dovecot.conf**auth\_cache\_negative\_ttl = 10 mins
auth\_debug = no
auth\_debug\_passwords = no
auth\_mechanisms = plain login # Используется TLS, поэтому разрешаем plain
base\_dir = /var/run/dovecot/
default\_vsz\_limit = 1024 M
disable\_plaintext\_auth = no
dotlock\_use\_excl = yes
lda\_mailbox\_autocreate = yes # Обязательно
lda\_mailbox\_autosubscribe = yes # Обязательно
listen = \*
mmap\_disable = yes
mail\_fsync = always
mail\_nfs\_storage = no
mail\_nfs\_index = no
mail\_debug = no
mail\_location = maildir:~/Maildir # Где искать почтовый ящик, значение maildir берется из атрибута homeDirectory (в нашем случае это /home/ipupkin), соответственно полный путь будет /home/ipupkin/Maildir.
mail\_plugins = $mail\_plugins quota notify expire
managesieve\_notify\_capability = mailto
managesieve\_sieve\_capability = fileinto reject envelope encoded-character vacation subaddress comparator-i;ascii-numeric relational regex imap4flags copy include variables body enotify environment mailbox date
ssl\_ca =
ssl\_cert =
ssl\_key =
ssl\_verify\_client\_cert = no
verbose\_ssl = no
protocols = imap pop3 sieve
userdb {
args = /etc/dovecot/dovecot-ldap.conf # Подключаем наш ldap конфиг
driver = ldap
}
passdb {
args = /etc/dovecot/dovecot-ldap-pass.conf #По рекомендации авторов dovecot символическая ссылка на dovecot-ldap.conf
driver = ldap
}
service auth {
unix\_listener auth-userdb {
mode = 0666
}
}
service imap-login {
process\_min\_avail = 6
service\_count = 0
}
service pop3-login {
process\_min\_avail = 6
service\_count = 0
}
# Используется managesieve плагином вебпочты roundcube
service managesieve-login {
process\_min\_avail = 6
service\_count = 0
inet\_listener sieve {
port = 4190
}
}
service managesieve {
}
service dict {
unix\_listener dict {
mode = 0666
}
}
# При заполнении почтового ящика на 90%, выполняется следующий скрипт
service quota-warning {
executable = script /etc/dovecot/quota-warning.sh # Сам скрипт выглядит так
**Скрипт**
```
#!/bin/sh
PERCENT=$1
USER=$2
cat << EOF | /usr/libexec/dovecot/dovecot-lda -d $USER -o "plugin/quota=maildir:User quota:noenforcing"
From: postmaster@domain.com
Subject: Your mailbox is $PERCENT% full
Content-Type: text/plain; charset="UTF-8"
X-Priority: 2
Warning! Your mailbox is now $PERCENT% full.
EOF
```
unix\_listener quota-warning {
mode = 0666
}
}
protocol imap {
imap\_client\_workarounds = delay-newmail # Хак для Аутлука
mail\_plugins = quota imap\_quota mail\_log notify
}
protocol pop {
pop3\_client\_workarounds = outlook-no-nuls oe-ns-eoh # Различные хаки для Аутлука
#pop3\_uidl\_format = %08Xu%08Xv # Используется при хранении Аутлуком почты на сервере, этот формат имеет проблемы с Аутлуком 2013
pop3\_uidl\_format = %g
pop3\_fast\_size\_lookups=yes # Подробнее [здесь](http://wiki2.dovecot.org/POP3Server) раздел Maildir perfomance.
mail\_plugins =
}
# Logical Delivery Agent (LDA) сервис, используемый Exim для доставки почты.
protocol lda {
hostname = domain.com
mail\_fsync = optimized
mail\_plugins = sieve quota
postmaster\_address = postmaster@domain.com
log\_path =
info\_log\_path =
}
protocol sieve {
}
# Различные опциональные добавки
plugin {
quota = maildir:User quota
quota\_rule = \*:storage=1M
quota\_rule2 = Trash:ignore
quota\_rule3 = Deleted Items:ignore
quota\_rule4 = Junk E-mail:ignore
quota\_rule5 = Archive:ignore
quota\_rule6 = archive:ignore
quota\_warning = storage=90%% quota-warning 90 %u # Указываем процент заполнения почтового ящика, при котором срабатывает скрипт quota-warning.sh
sieve = ~/Maildir/.dovecot.sieve
sieve\_dir = ~/Maildir/sieve
expire\_dict = proxy::expire
expire = Trash
expire2 = Deleted Items
expire3 = Junk E-mail
expire\_cache = yes
}
**dovecot-ldap.conf**hosts = 127.0.0.1
dn = uid=proxyagent,ou=services,dc=domain,dc=com
dnpass = \*\*\*\*\*
tls = no
auth\_bind = no
auth\_bind\_userdn = uid=%u,ou=people,dc=domain,dc=com
ldap\_version = 3
base = dc=domain,dc=com
deref = never
scope = subtree
user\_attrs = homeDirectory=home,uidNumber=uid,gidNumber=gid,quota=quota\_rule=\*:storage=%$
user\_filter = (&(objectClass=VirtualMailAccount)(accountActive=TRUE)(uid=%n)(mail=\*))
pass\_attrs = uid=user,userPassword=password
pass\_filter = (&(objectClass=VirtualMailAccount)(accountActive=TRUE)(uid=%u)(mail=\*))
default\_pass\_scheme = SSHA
Проверяем что ошибок нет (dovecot -a) и запускаем dovecot.
#### Финал: Настройка Exim
Основной целью при настройке Exim был максимальный отказ от любых скриптов и реализация всего функционала только средствами Exim. Только как исключение используются дебиановский greylistd на питоне и перловый amavisd-new.
При настройке Exim также будут использоваться два файла — основной exim.conf и acl\_smtp для ACL правил.
Также опционально в конфиге присутствует роутер и транспорт для mailman.
**exim.conf**CONFIG\_PREFIX=/etc/exim
ACL\_PREFIX=CONFIG\_PREFIX/acls #здесь хранятся все ACL конфиги
DB\_PREFIX=/var/spool/exim/db #для увеличения быстродействия желательно использовать tmpfs
# Шаблоны являются сильной стороной Exim и позволяют легко заменить длинную строку коротким словом.
# Определяем шаблоны для mailman
MM\_HOME=/var/lib/mailman
MM\_UID=mailman
MM\_GID=mailman
MM\_WRAP=/usr/lib/mailman/mail/mailman
MM\_LISTCHK=MM\_HOME/lists/${lc::$local\_part}/config.pck
ldap\_default\_servers = /var/run/openldap/slapd.sock: 192.168.0.1 # Указываем как соединяться к лдап-серверам, второй сервер будет использоваться как fallback.
INTERFACE = your\_external\_ip # Указываем внешний айпи, на котором будет висеть exim
BASEDN = dc=domain,dc=com # basedn лдап сервера
# В этой секции указаны самые важные темплейты, задающие логику работы Exim
# Проверка альяса, соответствует ли адрес альяса значению атрибута mail в контейнере aliases, альяс также должен принадлежать классу VirtualMailAlias и иметь значение TRUE для атрибута accountActive
CHECK\_1 = ${lookup ldap {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=aliases,dc=domain,dc=com?mail?sub?(&(objectClass=VirtualMailAlias)(accountActive=TRUE)(mail=${quote\_ldap:$local\_part@$domain}))} }
# Проверка аккаунта, соответствует ли адрес получателя значению атрибута mail в контейнере people, аккаунт также должен принадлежать к классу VirtualMailAccount и иметь значение TRUE для атрибута accountActive
CHECK\_2 = ${lookup ldap {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=people,dc=domain,dc=com?mail?sub?(&(objectClass=VirtualMailAccount)(accountActive=TRUE)(mail=${quote\_ldap:$local\_part@$domain}))} }
#Проверка suspended аккаунта, аккаунт не может получать почту, но остается в системе (актуально для сотрудниц в материнском отпуске)
CHECK\_3 = ${lookup ldap {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=people,dc=domain,dc=com?mail?sub?(&(objectClass=VirtualMailAccount)(accountActive=TRUE)(accountSuspend=TRUE)(mail=${quote\_ldap:$local\_part@$domain}))} }
# Список участников альяса, кому пересылать почту, значение аттрибута maildrop
CHECK\_DATA = ${lookup ldapm {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=aliases,dc=domain,dc=com?maildrop?sub?(&(objectClass=VirtualMailAlias)(mail=${quote\_ldap:$local\_part@$domain}))}}
# Путь к почтовому ящику, значение аттрибута mailbox
CHECK\_MAILDIR = ${lookup ldap {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=people,dc=domain,dc=com?mailbox?sub?(&(objectClass=VirtualMailAccount)(accountActive=TRUE)(mail=${quote\_ldap:$local\_part@$domain}))} }
# Текст OoO сообщения, значение аттрибута vacationInfo
CHECK\_VACATION = ${lookup ldap {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=people,dc=domain,dc=com?vacationInfo?sub?(&(objectClass=VirtualMailAccount)(vacationActive=TRUE)(mail=${quote\_ldap:$local\_part@$domain}))}}
#Hack for double commas in OoO message, exim's bug 660 — кажется так и не исправили
VACATION = ${sg{ ${lookup ldap {user=«uid=exim,ou=services,dc=domain,dc=com» pass=\*\*\* ldap:///ou=people,dc=domain,dc=com?vacationInfo?sub?(&(objectClass=VirtualMailAccount)(vacationActive=TRUE)(mail=${quote\_ldap:$local\_part@$domain}))}} }{,,}{,}}
domainlist\_cache virt\_domains = domain.com # Так как у нас только один домен, то указываем его. Если используется множество доменов, то нужно создать темплейт выборки доменов из лдап базы.
domainlist\_cache local\_domains = localhost: mail.domain.com
hostlist relay\_from\_hosts = 127.0.0.1: 192.168.0.0/16
addresslist noautoreply\_senders = DB\_PREFIX/autoreply.noanswer.db
sender\_unqualified\_hosts = 127.0.0.1: 192.168.0.0/16
recipient\_unqualified\_hosts = 127.0.0.1: 192.168.0.0/16
local\_interfaces = 0.0.0.0.25: 0.0.0.0.26: 0.0.0.0.465: 0.0.0.0.587: 127.0.0.1.10025
tls\_on\_connect\_ports = 465
acl\_smtp\_connect = acl\_check\_connect
acl\_smtp\_helo = acl\_check\_helo
acl\_smtp\_mail = acl\_check\_mail
acl\_smtp\_rcpt = acl\_check\_rcpt
acl\_smtp\_data = acl\_check\_data
acl\_smtp\_dkim = acl\_check\_dkim
accept\_8bitmime
auth\_advertise\_hosts = !127.0.0.1 # Не предлагать SMTP AUTH локалхосту
bounce\_message\_file = CONFIG\_PREFIX/bounce.msg # Указываем формат bounce сообщения, у меня так:
**bounce msg**Subject: Mail delivery failed ${if eq{$sender\_address}{$bounce\_recipient}{: returning message to sender}}
\*\*\*\*
This message was created automatically by mail delivery software.
A message ${if eq{$sender\_address}{$bounce\_recipient}{that you sent }{sent by
<$sender\_address>
}}could not be delivered to all of its recipients.
The following address(es) failed:
\*\*\*\*
The following text was generated during the delivery attempt(s):
\*\*\*\*
— This is a copy of the message, including all the headers. — \*\*\*\*
— The body of the message is $message\_size characters long; only the first
— $return\_size\_limit or so are included here.
\*\*\*\*
bounce\_return\_size\_limit = 100K
delay\_warning = 15m:1h:99d
deliver\_queue\_load\_max = 40
disable\_ipv6
exim\_group = vmail # Желательно чтобы все почтовые сервисы (dovecot, spamassassin, clamav и тд) работали под одним gid
exim\_user = vmail # Желательно чтобы все почтовые сервисы (dovecot, spamassassin, clamav и тд) работали под одним uid
headers\_charset = UTF-8 # Желательно включить
ignore\_bounce\_errors\_after = 0s
local\_scan\_timeout = 0s
message\_size\_limit = 50M
never\_users = root
no\_message\_logs
no\_smtp\_enforce\_sync
no\_syslog\_duplication
primary\_hostname = mail.domain.com
qualify\_domain = domain.com
queue\_only\_load = 12
queue\_run\_max = 5
recipients\_max = 500
recipients\_max\_reject
remote\_max\_parallel = 2
return\_size\_limit = 10000
rfc1413\_query\_timeout = 0s
smtp\_accept\_max = 500
smtp\_accept\_max\_per\_host = 500
smtp\_accept\_queue = 500
smtp\_accept\_queue\_per\_connection = 1000
smtp\_accept\_reserve = 15
smtp\_banner = $primary\_hostname ESMTP ready $tod\_full
smtp\_connect\_backlog = 40
smtp\_load\_reserve = 20
smtp\_return\_error\_details
split\_spool\_directory
strip\_excess\_angle\_brackets
strip\_trailing\_dot
syslog\_facility = mail # Логи отсылаются syslog сервису
syslog\_processname = exim
system\_filter = DB\_PREFIX/exim.filter # Глобальный exim фильтер, у меня в основном не используется
timeout\_frozen\_after = 7d
tls\_advertise\_hosts = !127.0.0.1 # Не предлагать TLS локалхосту
# Указываем пути к сертификатам
tls\_certificate = /etc/exim/ssl/mail\_crt\_new.pem
tls\_privatekey = /etc/exim/ssl/mail\_key\_new.pem
tls\_verify\_certificates = /etc/exim/ssl/ca.pem
# Определяем формат заголовка письма
received\_header\_text = «Received:\
${if def:sender\_rcvhost {from INTERFACE\n\t}\
{${if def:sender\_ident {from relay }}\
${if def:sender\_helo\_name {(helo=${sender\_helo\_name})\n\t}}}}\
by ${qualify\_domain}\
id ${message\_id}\
${if def:received\_for {\n\tfor <$received\_for>}}»
# Подключаем антивирус и антиспам напрямую, так как LDAP здесь не используется, то все стандартно, поэтому опускаем настройку.
# av\_scanner = clamd:/tmp/clamd
# spamd\_address = 127.0.0.1 783
begin acl
# Подключаем наш ACL конфиг (см ниже)
.include ACL\_PREFIX/acl\_smtp
# Создаем роутеры
begin routers
# Роутер для исходящей почты
dnslookup:
driver = dnslookup
domains = !+local\_domains: !+virt\_domains
transport = remote\_smtp
ignore\_target\_hosts = 0.0.0.0: 127.0.0.0/8
no\_more
# Роутеры для входящей почты
#Опицональный транспорт для amavis (сделаем одно исключение перлу :) )
#amavis:
# driver = manualroute
# condition = ${if or {\
# {eq{$interface\_port}{10025}} \
# {eq{$received\_protocol}{spam-scanned}}\
# {eq{$sender\_address}{}}\
# {eq{$sender\_address\_domain}{domain.com}}\
# {eq{$sender\_address\_domain}{kaspersky.com}}\
# {eq{${lc:$dkim\_verify\_status}}{pass}}\
# {match{$sender\_address\_local\_part}{-bounces}}\
# }{0}{1}}
# domains = +virt\_domains
# senders =!: !postmaster@\*: !mailer-daemon@\*: !nagios@\*: !monit@\*
# no\_verify
# no\_expn
# transport = amavis
# route\_list = "\* localhost byname"
# self = send
autorespond:
driver = accept
domains = +virt\_domains
senders =!: !+noautoreply\_senders # Не отвечать локалхосту и отправителям, указанным в autoreply.noanswer.db
condition = ${if and {\
{!eq{CHECK\_VACATION}{}}\ # Наш шаблон
{!match{$h\_precedence:}{junk|bulk|list}}\ # Не отвечать рассылкам
{!def:header\_Auto-Submitted:}\
{!def:header\_List-Id:}\
}}
no\_verify
no\_expn
unseen
transport = auto\_responder
# Приостановленные аккаунты, вся приходящая почта для suspended аккаунта отправляется в «черную дыру»
suspended:
driver = redirect
domains = +virt\_domains
condition = CHECK\_3
forbid\_file
forbid\_pipe
forbid\_filter\_reply = true
data = :blackhole:
no\_more
# Виртуальные альясы
aliases:
driver = redirect
domains = !+local\_domains
condition = CHECK\_1 # Тут происходит двойная проверка (первая в acl\_smtp), если действующий аккаунт имеет еще и альяс, ничего лучше не придумал
forbid\_file
forbid\_pipe
forbid\_filter\_reply = true
data = CHECK\_DATA # Кому пересылать письма
allow\_fail
allow\_defer
mailman\_router:
driver = accept
domains = domain.com
require\_files = MM\_LISTCHK # Вместо проверки по файлу, можно сделать поверку по значению атрибута aliasType=DL, например
local\_part\_suffix\_optional
local\_part\_suffix = -admin: \
-bounces: -bounces+\*: \
-confirm: -confirm+\*: \
-join: -leave: \
-owner: -request: \
-subscribe: -unsubscribe
transport = mailman\_transport
system\_aliases:
driver = redirect
domains = +local\_domains
errors\_to =
no\_verify
data = ${lookup{$local\_part}partial0-dbm{DB\_PREFIX/aliases.db}{$value}fail}
file\_transport = address\_file
pipe\_transport = address\_pipe
allow\_fail
allow\_defer
localuser:
driver = accept
domains = +local\_domains: +virt\_domains
check\_local\_user
transport = dovecot\_lda # Перекладываем доставку письма в почтовый ящик на плечи dovecot lda
cannot\_route\_message = Unknown account # Dovecot ответил нет, сдаемся
no\_more
###############################################################
begin transports
###############################################################
remote\_smtp:
driver = smtp
helo\_data = mail.domain.com
max\_rcpt = 500
#подключаем DKIM
dkim\_domain = domain.com
dkim\_selector = dkim
dkim\_private\_key = DB\_PREFIX/dkim.private.key
dkim\_canon = relaxed
auto\_responder:
driver = autoreply
from = "${local\_part}@${domain}"
to = "${reply\_address}"
once = "/var/spool/exim/autoreply/${local\_part}@${domain}"
once\_repeat = 1d # Отвечать отправителю один раз в день, хотя можно логику перенести также в LDAP (см. phamm-vacation.schema)
headers = «Content-Type: text/plain; charset=utf-8\nContent-Transfer-Encoding: 8bit»
subject = ${rfc2047:Auto-Reply: $h\_subject:}
text = VACATION # Наш шаблон с текстом OoO сообщения
body\_only
no\_return\_message
# Тот самый транспорт для dovecot
dovecot\_lda:
driver = pipe
command = /usr/libexec/dovecot/dovecot-lda -f "$sender\_address" -d "$local\_part@$domain"
home\_directory = /home/$local\_part
delivery\_date\_add
envelope\_to\_add
return\_path\_add
log\_output
log\_defer\_output
return\_fail\_output
freeze\_exec\_fail
temp\_errors = 64: 69: 70: 71: 72: 73: 74: 75: 78
address\_pipe:
driver = pipe
return\_output
address\_file:
driver = appendfile
current\_directory = SPOOL
home\_directory = SPOOL
create\_directory
directory\_mode = 0700
maildir\_format
user = vmail
group = vmail
mode = 0600
no\_check\_owner
no\_mode\_fail\_narrower
address\_reply:
driver = autoreply
maillist\_pipe:
driver = pipe
group = mail
return\_fail\_output
user = vmail
mailman\_transport:
driver = pipe
command = MM\_WRAP \
'${if def:local\_part\_suffix \
{${sg{$local\_part\_suffix}{-(\\w+)(\\+.\*)?}{\$1}}} \
{post}}' \
$local\_part
current\_directory = MM\_HOME
home\_directory = MM\_HOME
user = MM\_UID
group = MM\_GID
#amavis:
# driver = smtp
# port = 10024
# allow\_localhost
begin retry
\* quota
\* rcpt\_4xx senders=: F,1h,10m
\* \* F,2h,10m; G,16h,1h,1.5; F,4d,6h
# Все системные сообщения рутов отправляем на один ящик
begin rewrite
root@\* collector@domain.com Ttbcr
# Аутенфикаторы SMTP AUTH
begin authenticators
plain:
driver = plaintext
public\_name = PLAIN
server\_prompts =:
server\_condition = "${lookup ldap{user=uid=${quote\_ldap\_dn:$auth2},ou=people,BASEDN pass=${quote:$auth3} \
ldap:///ou=people,BASEDN?uid?sub?(&(uid=$auth2)(objectClass=VirtualMailAccount)(accountActive=TRUE))}{yes}fail}"
server\_set\_id = $auth2
login:
driver = plaintext
public\_name = LOGIN
server\_prompts = «Username::: Password::»
server\_condition = "${lookup ldap{user=uid=${quote\_ldap\_dn:$auth1},ou=people,BASEDN pass=${quote:$auth2} \
ldap:///ou=people,BASEDN?uid?sub?(&(uid=$auth1)(objectClass=VirtualMailAccount)(accountActive=TRUE))}{yes}fail}"
server\_set\_id = $auth1
Орудие главного калибра Exim — это Access Control Lists.
Собственно, вся статья затевалась ради одной стройки в секции smtp\_rcpt.
**acl\_smtp**acl\_check\_connect:
accept hosts =: +relay\_from\_hosts: net-dbm;DB\_PREFIX/whitelist\_hosts.db
deny message = $sender\_host\_address is listed in $dnslist\_domain ${if def:dnslist\_text {($dnslist\_text)}}
dnslists = sbl.spamhaus.org: xbl.spamhaus.org: bl.spamcop.net
accept
acl\_check\_dkim:
warn log\_message = DKIM: Sender without DKIM signature
sender\_domains = gmail.com: autodesk.com: paypal.com
dkim\_signers = gmail.com: autodesk.com: paypal.com
dkim\_status = none:invalid:fail
accept
acl\_check\_helo:
accept hosts =: +relay\_from\_hosts
#HELO is an open proxy
deny condition = ${if and {\
{isip{$sender\_helo\_name}}\
{eq{$sender\_helo\_name}{$sender\_host\_address}}\
}}
message = Open Proxy in HELO/EHLO (HELO was $sender\_helo\_name)
delay = 10s
#HELO is my hostname
deny condition = ${if match{$sender\_helo\_name}{$primary\_hostname}}
message = Bad HELO — Host impersonating [$sender\_helo\_name]
#HELO is my address
deny condition = ${if eq{$interface\_address}{$sender\_helo\_name}}
message = $interface\_address is my address
accept
acl\_check\_mail:
accept hosts =: +relay\_from\_hosts
discard senders = dbm;DB\_PREFIX/banned\_senders.db: dbm;DB\_PREFIX/scammers.db
#HELO required before MAIL
deny condition = ${if eq{$sender\_helo\_name}{}}
message = HELO/EHLO required before MAIL
accept
acl\_check\_rcpt:
#stub address
discard condition = ${if match{$local\_part@$domain}{blackhole@domain.com}} # blackhole аккаунт
deny message = Restricted characters in address
local\_parts = ^[.]: ^.\*[@%!/|]
#Reverse DNS check
warn condition = ${if and{{def:sender\_host\_address}{!def:sender\_host\_name}}{yes}{no}}
!hosts =: +relay\_from\_hosts: net-dbm;DB\_PREFIX/whitelist\_hosts.db
control = no\_pipelining
delay = 10s # Делаем задержку в 10 секунд из вредности, если хост не имеет обратки
log\_message = X-Host-Lookup-Failed: Reverse DNS lookup failed for $sender\_host\_address
# RATELIMIT SECTION
#Keep authenticated users under control
warn authenticated = \*
ratelimit = 100 / 5m / strict / $authenticated\_id
set acl\_m100 = ${eval: ${sg{$sender\_rate}{[.].\*}{}} — $sender\_rate\_limit + 10}s
delay = $acl\_m100
log\_message = Ratelimit: Delay $acl\_m100 for $authenticated\_id. Rate limit $sender\_rate / $sender\_rate\_period
#Limit local senders, exclude mailing-list agent
warn condition = ${if !match{$sender\_address\_local\_part}{bounces}}
hosts =: 127.0.0.1
ratelimit = 1000 / 1h / per\_rcpt / strict / $sender\_host\_address
set acl\_m101 = ${eval: ${sg{$sender\_rate}{[.].\*}{}} — $sender\_rate\_limit}s
delay = $acl\_m101
log\_message = Ratelimit: Delay $acl\_m101 for $sender\_address ($sender\_host\_address). Rate $sender\_rate / limit $sender\_rate\_limit
#Limit fast senders
hosts = !127.0.0.1: +relay\_from\_hosts
ratelimit = 100 / 5m / per\_rcpt / strict
set acl\_m102 = ${eval: ${sg{$sender\_rate}{[.].\*}{}} — $sender\_rate\_limit + 5}s
delay = $acl\_m102
log\_message = Ratelimit: Delay $acl\_m102 for $sender\_address ($sender\_host\_address). Rate $sender\_rate / limit $sender\_rate\_limit
#Limit DSNs
warn condition = ${if and{\
{<{$recipients\_count}{0}}\
{!eq{$sender\_address\_domain}{domain.com}}\
}}
senders =: postmaster@\*: mailer-daemon@\*
delay = 10s
log\_message = Ratelimit: DSN delay 10s for $sender\_address ($sender\_host\_address)
# END RATELIMIT SECTION
#Predefined acl variables for smtp\_data level
warn set acl\_m0 = $sender\_address\_domain
warn set acl\_m1 = $domain
warn set acl\_m2 = $sender\_host\_address
warn set acl\_m3 = $sender\_address
warn set acl\_m4 = $local\_part@$domain
#Verify recipient for our domains.
deny message = Unknown or disabled account
domains = +virt\_domains
!local\_parts = postmaster: \*-admin: \*-bounces: \*-bounces+\*: \*-confirm: \*-confirm+\* :\
\*-join: \*-leave: \*-owner: \*-request: \*-subscribe: \*-unsubscribe
# Вот эта та самая строчка, проверка валидности аккаунтов и альясов на этапе check\_rcpt, исключение только для служебных адресов рассылок.
!recipients = CHECK\_1: CHECK\_2
accept hosts =: +relay\_from\_hosts
control = dkim\_disable\_verify
# Разрешаем аутенфицированным отправителям дальше делать что угодно
accept authenticated = \*
control = dkim\_disable\_verify
# Кому можно релеить почту, если нельзя, то 10 секунд задержки сессии.
deny message = relay not permitted
!domains = +local\_domains: +virt\_domains
delay = 10s
# Тут мы запрещаем отсылать почту с чужих хостов, используя наше доменное имя, опционально
#Deny non-authorized senders with our own domain prefix
deny condition = ${if match{$sender\_address\_domain}{domain.com}}
!hosts =: +relay\_from\_hosts: +adobe\_hosts: +microsoft\_hosts: net-dbm;DB\_PREFIX/whitelist\_hosts.db
message = Sender domain is not allowed here
log\_message = Sender $sender\_address is not authenticated
#Dictionary attack protection
#Start
warn condition = ${if > {${eval:$rcpt\_fail\_count}}{4}{yes}{no}}
log\_message = Ratelimit: Detected Dictionary Attack (Let $rcpt\_fail\_count bad recipients though before engaging)
set acl\_m7 = 1
warn condition = ${if eq {${acl\_m7}}{1}{1}{0}}
ratelimit = 0 / 1h / strict / per\_conn
log\_message = Ratelimit: Increment Connection Ratelimit — $sender\_fullhost because of Dictionary Attack
drop condition = ${if eq {${acl\_m7}}{1}{1}{0}}
log\_message = Ratelimit: Number of failed recipients exceeded
#End
# Здесь я реализовал проверку альясов на активность, раз в сутки парсер выбирает из лога exim записи и обновляет значение атрибута lastchange в формате "%Y%m%d" для данного альяса. Потом по значению этого атрибута можно проверять, пользуются ли альясом или нет.
Тоже самое сделано для аккаунтов, но дополнительного log\_message, как для альяса, не требуется.
#Alias statistic
warn
domains = +virt\_domains
log\_message = ALIAS: $local\_part@$domain
recipients = CHECK\_1
# Отсылаем письмо в грейлист
#Greylist section
defer message = $sender\_host\_address is not yet authorized to deliver \
mail from <$sender\_address> to <$local\_part@$domain>. Please try later
log\_message = Sender $sender\_address greylisted
domains = +virt\_domains
!sender\_domains = partial1()dbm;DB\_PREFIX/whitelist\_grey\_domains.db
!authenticated = \*
condition = ${readsocket{/var/run/greylistd/socket}\
{--grey %s $sender\_address $local\_part@$domain}{5s}{}{false}}
accept
acl\_check\_vrfy\_expn\_etrn:
accept hosts = 127.0.0.1
deny
acl\_check\_data:
# Кого отправлять spamassassinу, опционально. В данном примере помещением тэга SPAM в заголовок письма занимается сам Exim.
Глобальный exim.filter тогда будет выглядеть так:
**exim.filter**if first\_delivery then
headers remove X-Spam-Score:X-Spam-Report:X-Spam-Checker-Version:X-Spam-Status:X-Spam-Level
if "${if def:header\_X-New-Subject: {there}}" is there
then
headers remove Subject
headers add «Subject: $rh\_X-New-Subject:»
headers remove X-New-Subject
endif
endif
#
# no antispam check for relay hosts and authenticated users
# accept hosts =: +relay\_from\_hosts
# accept authenticated = \*
#
# Antispam scan
# warn
# condition = ${if and {\
# {<{$message\_size}{50k}}\
## {!eq{${mask:$acl\_m2/16}}{192.168.0.0/16}}\
# {!eq{$sender\_address}{}}\
## {!match\_address{$sender\_address}{dbm;DB\_PREFIX/whitelist\_spam\_senders.db}}\
# {!match\_domain{$acl\_m0}{partial1()dbm;DB\_PREFIX/whitelist\_grey\_domains.db}}\
## {match\_domain{$acl\_m1}{dbm;DB\_PREFIX/domains\_spam.db}}\
# }}
# spam = nobody:true/defer\_ok
# set acl\_m6 = $spam\_score\_int
# add new subj for global exim filter
# message = X-New-Subject: SPAM[$spam\_score\_int/80]: $rh\_subject:
# condition = ${if and {\
# {def:spam\_score\_int}\
# {>{$spam\_score\_int}{80}}\
# }}
accept
Вот, собственно, и все.
Запускаем Exim, отсылаем письмо ipupkin-у, смотрим логи… | https://habr.com/ru/post/262101/ | null | ru | null |
# Как я сделал игру для Блокнота
Пока читал про необычные решения от инди-разработчиков, наткнулся на золото. Вот вам статья про игру в текстовом редакторе. Арт, анимация, сюжет — все как положено.
Я создал игру And yet it hurt (*возможно, автор хотел сказать it hurts, но мог использовать такой вариант намеренно, — прим.*).
Проект можно [скачать тут](https://sheepolution.itch.io/and-yet-it-hurt), а код [посмотреть на Github](https://github.com/Sheepolution/and-yet-it-hurt).
Все началось в 2017 году с вопроса: «Реально ли сделать игру в Блокноте?» Тогда я только усмехнулся. Прошло три года. Обдумав, как все будет работать, и убедившись, что это реально, я решил сделать эту игру.
Обычно вы жмете на кнопку, и в игре что-то происходит. Жмете А, и Марио прыгает. Все завязано на получении информации и отклике. Игра получает входные данные и выводит свои.
В игре для Блокнота на входе будут изменения, которые вносит пользователь в файл, а на выходе изменения, которые вносит в файл сама игра. Для этого приложение отслеживает время последнего сохранения файла. Если оно изменилось, игра считывает содержимое файла и вносит в него новые данные.
Возникает проблема: Блокнот от Microsoft не проверяет, был ли файл изменен. Пришлось бы сохранять файл, закрывать и открывать его заново. Создать такую игру возможно, но звучит не очень весело. Пришлось искать альтернативу.
Могу понять ваше разочарование из-за того, что игра в итоге сделана не в самом обычном Блокноте. Мой тайтл можно запустить в нем — просто процесс немного замороченный. Я решил пожертвовать крутостью проекта, чтобы сделать игру более приятной.
Альтернатива
------------
Пришлось искать другой текстовый редактор. Единственным требованием было — автоматическое обновление файла. Хотя чуть позже вы увидите, что я использовал еще одну фичу.
Сначала на ум пришли Notepad++ и Sublime Text. Но они совсем не похожи на Блокнот внешне, очарование проекта развеялось бы окончательно. Плюс, они спрашивают игрока, хотел бы он обновить файл. Это куда лучше, чем закрывать и открывать файл, но все равно отвлекает от геймплея. Я хотел, чтобы файл обновлялся автоматически. Тогда мне на глаза попался Notepad2. Он был почти идеален.
Редактор можно настроить, чтобы он был похож на MS Блокнот, а главное — он проверяет изменения, внесенные в файл. Но также как Notepad++ и Sublime Text, Notepad2 спрашивает игрока, нужно ли изменить файл. К счастью, у редактора открытый код, и я мог отполировать его до совершенства.
Notepad2 написан на C. Я немного знаком с этим языком, пусть меня и нельзя назвать экспертом. Опытный программист Javascript сможет прочитать и уловить общую суть кода, но понять исходный код Notepad2, чтобы внести необходимые изменения, оказалось не так просто.
Для начала я решил поискать текст из диалогового окна: «Файл был изменен внешней программой. Перезагрузить файл?». Это значение переменной, которая используется в качестве аргумента в функции диалогового окна. И я ее нашел.
```
if ((iFileWatchingMode == 2 && !bModified && iEncoding == iOriginalEncoding) ||
MsgBox(MBYESNO,IDS_FILECHANGENOTIFY) == IDYES) {
```
Этот код проверяет, не изменилось ли содержимое файла. Если оно изменилось, открывается окно, и программа проверяет, выбрал ли пользователь ответ «Да». Мне нужно было лишь заменить кусок
```
MsgBox(MBYESNO,IDS_FILECHANGENOTIFY) == IDYES
```
на TRUE, и программа начала автоматически обновлять файл. Таким образом, я создал рендер на базе ASCII. Осталось создать подходящий движок.
Отрисовка
---------
Игра создана с любовью: [LÖVE](https://love2d.org/) — фреймворк с открытым исходным кодом для 2D-игр, написанных на Lua. Я много лет пользовался этой платформой и даже собрал [туториал](https://sheepolution.com/learn/book/contents). Для этого проекта в основном использовался LÖVE-модуль файловой системы, потому что он предоставляет все необходимые возможности. Обычно с помощью LÖVE создают изображение, которое затем выводится на экран.
Мне нужно было почти то же самое: вывод ASCII-арта в текстовом файле. Я начал с домика и птички, причем птичка должна была лететь через файл. Взял арт, который нашел на [ASCII Art](https://asciiart.website/), но в игре используются только оригинальные работы (за исключением шрифтов).
И:
Загрузка арта — это просто чтение файла.
```
house = love.filesystem.read("art_house.txt")
bird = love.filesystem.read("art_bird.txt")
```
Дом используется в качестве фона, поэтому я начал с прорисовки этого изображения на «экране». Экран в данном случае — это home.txt.
```
love.filesystem.write("home.txt", house)
```
Я хотел, чтобы с птичкой можно было работать в таком ключе:
```
local x, y = 20, 40
drawArt(bird, x, y)
```
х — номер столбца, y — номер строки. Поэтому разбил экран и птицу на списки строк.
```
-- Get the current canvas
screen = love.filesystem.read("home.txt")
-- Create a table. A table is like an array.
screen_lines = {}
-- The lua pattern (.-)\n says capture everything until the \n (newline).
-- We add an \n to the end of the file so that it captures the last line as well.
for line in (screen .. "\n"):gmatch("(.-)\n") do
table.insert(screen_lines, line)
end
```
С птицей сделал то же самое. Теперь код, описывающий птицу, должен был перекрывать код про дом. Вот, что мне было нужно:
1. Найти строку, в которой должна быть отрисована птица.
2. Вывести всю строку до x.
3. Вывести оставшуюся часть строки, начиная с x + длина арта с птицей.
4. Создать новую строку с первой частью, птицей и оставшейся частью.
5. Повторить то же самое для всех остальных строк.
В коде это выглядит так:
```
function drawArt(art, x, y)
art_lines = getLines(art)
-- In Lua, you can get the length of a table and string with #
for i=1, #screen_lines do
if i == y then
for j=1 ,#art_lines do
-- With string:sub(start, end) we can get part of a string
local first_part = screen_lines[i]:sub(1, x - 1)
local second_part = screen_lines[i]
:sub(x + #art_lines[j], #screen_lines[i])
screen_lines[i] = first_part .. art_lines[i] .. second_part
end
end
end
end
```
Что получилось:
Наверное, вы заметили, что птица представляет собой прямоугольник — в ее арте используются пробелы. Чтобы исправить ситуацию, я посчитал количество пробелов в начале каждой строки и добавил это число к координатам, чтобы отрисовывался только арт.
```
-- (%s) gets all the whitespace characters.
local spaces = art_lines[j]:match("(%s*)")
-- Remove the spaces from the line.
art_lines[i] = art_lines[i]:sub(#spaces + 1, #art_lines[i])
local first_part = screen_lines[i]:sub(1, x + #spaces - 1)
local second_part = screen_lines[i]:sub(x + #spaces + #art_lines[j], #screen_lines[i])
screen_lines[i] = first_part .. art_lines[i] .. second_part
```
Стало намного лучше:
Анимация
--------
Я начал добавлять больше фишек, например, анимацию:
Все кадры расположены в одном файле и разделены тегом {{F}}. Тег определяется при чтении и позволяет задать последовательность кадров. Благодаря этому мы получаем классическую анимацию. Создаем таймер и отрисовываем кадры в соответствии с ним.
```
{{F}}
_ _
'v'
{{F}}
--v--
{{F}}
_/v\_
```
Также я реализовал вывод печатаемого текста и отобразил отдельно экран, инвентарь и окно для ввода решения. Оставалась одна проблема. Как игра узнает, что был открыт файл? Это и есть вторая фича, о которой я говорил ранее.
В исходном коде Notepad2 я прописал, что файл должен сохраняться сразу после открытия. Затем игра проверяет, не изменилось ли время последнего сохранения. Так она узнает, что файл был открыт, и может его менять.
```
// At the end of the FileLoad function.
// If the file is not new, and the file has not been reloaded, save it.
if (!bNew && !bReload) {
FileSave(TRUE,FALSE,FALSE,FALSE);
}
```
В итоге я получил фреймворк, в котором можно работать. Самое время создавать игру.
За девять дней разработки (судя по дате создания gif-файлов) я сделал это:
Если вы запускали игру, то знаете, что в ней нет печатаемого текста и анимации. На то было несколько причин:
* Я опасался, что порчу свой HDD/SSD постоянной перезаписью файла. Тестирование игры с этими функциями сделало из меня параноика. Не хочу, чтобы игроки испытывали это чувство.
* Вы не можете ничего делать во время анимации. Если вы попытаетесь выбрать ответ и напечатаете символ в окошке, вы не успеете сохраниться до того, как следующий кадр загрузится и удалит ваш символ. Так что поначалу анимации кажутся классными, но в итоге только мешают.
* Анимация — это здорово, но она не вписывается в стиль Блокнота. В текстовых файлах не должно быть анимации. По той же причине в игре нет музыки. Конечно, я мог сделать так, чтобы игра создавала аудио-файл, который вы открыли бы в медиаплеере. Но такие действия отвлекали бы от Блокнота. Я оставил несколько анимаций, чтобы показать, как круто они выглядят. Плюс, во время сражения врага лучше бить, когда он моргает, — хороший сигнал к действию.
Программа по умолчанию
----------------------
Меня бесило, что пользователю приходилось перетаскивать файл в окно Notepad2 для запуска игры. При двойном щелчке по файлу, открывался Блокнот или другая программа по умолчанию для чтения .txt. Можно было прописать команду, которая меняла приложение для таких файлов на Notepad2, но лично мне не понравится, если какая-то игра проделает такой финт на моем компьютере.
Может, возвращать исходные настройки при закрытии игры? Это возможно, но возникнет проблема, если игра вылетит или неожиданно закроется.
Все решения казались недостаточно обоснованными, пока я не догадался, что вместо обычных .txt можно использовать файлы с другим «x». Если быть точным — Unicode-символ U+0445 (Cyrillic Small Letter Ha). Чтобы не запутаться, я назвал файл \*.tXt. В итоге, все файлы игры были с разрешением \*.tXt, и по дефолту открывались в Notepad2.
```
assoc .tXt=tXt
ftype tXt=[directory]/.notepad/Notepad2.exe "%1"
```
Программу по умолчанию можно назначить только от имени администратора. Если вы открываете игру под другой учетной записью, будут использоваться txt-файлы. Если вы открываете файл в обычном Блокноте, игра сообщит, что нужно перетащить файл в открытое окно Блокнота. Либо запустить ее от имени администратора, чтобы она открылась по дабл-клику.
Мотивация
---------
На самом деле всё было сделано три года назад. Что я делал все остальное время? Классический пример отсутствия мотивации.
Изначально сюжет был немного длиннее, чем сейчас. Твоих родителей убил дракон, ты должен пойти к кузнецу Фердану, чтобы он выковал меч. Задумывалось, что меч делается из трех материалов, которые нужно собрать. Это сильно увеличивало объем игры и отодвигало конец разработки. Игра получалась не очень-то развлекательной, и я забросил проект через два месяца.
Но я все время держал его в голове. Я отладил целый фреймворк, который позволял создать игру в Блокноте, а проект не двигался с мертвой точки. Нужно было доделать его. В 2019 году я не завершил почти ни одного проекта. Разочарование подтолкнуло меня к решению: закончить незаконченное в 2020-м.
И вот она. Я сократил сюжет, дал себе месяц на все (получилось на неделю дольше) и бросился в бой. Еще подал заявку на A MAZE. Awards, соответственно, дедлайн был назначен на 2 февраля. Так появилась мотивация.
Заключение
----------
Я рад, что доделал игру. Удивительно, сколько времени проект просто собирал цифровую пыль, а в итоге хватило месяца. Игру не стоило делать настолько объемной, как я хотел сначала — такой нестандартный проект должен лишь показывать особенности, которые можно в нем реализовать.
Что дальше? Игра в Paint? Игра в Калькуляторе? Вряд ли я их сделаю. Но мне нравится думать об играх, которые используют нетрадиционные платформы. | https://habr.com/ru/post/488222/ | null | ru | null |
# Osquery выставляет ОС как реляционную СУБД
Facebook выложил на гитхабе фреймворк [OSquery](https://github.com/facebook/osquery), он осуществляет низкоуровневый мониторинг процессов в OS X и Linux и хранит их в виде SQL-таблиц. Такой способ по-своему удобен, ведь в запросе можно объединять разные таблицы.
Например, если мы хотим посмотреть названия, pid и порты всех процессов, которые прослушивают порты во всех интерфейсах, то составляем запросик
```
SELECT DISTINCT
process.name,
listening.port,
process.pid
FROM processes AS process
JOIN listening_ports AS listening
ON process.pid = listening.pid
WHERE listening.address = '0.0.0.0';
```
Или другой запрос, он выводит список всех демонов OS X, которые запускаются вместе с операционной системой и продолжают выполняться после этого. Возвращается название демона и путь к исполняемому файлу.
```
SELECT
name,
program || program_arguments AS executable
FROM launchd
WHERE
(run_at_load = 'true' AND keep_alive = 'true')
AND
(program != '' OR program_arguments != '');
```
Подобными запросами отслеживаются работающие процессы, загруженные модули ядра и сетевые соединения.
Новые SQL-таблицы для OSquery довольно просто [сделать самому](https://github.com/facebook/osquery/wiki/creating-a-new-table). По желанию пополните [общий каталог таблиц](https://github.com/facebook/osquery/tree/master/osquery/tables). | https://habr.com/ru/post/242205/ | null | ru | null |
# Рейт-лимитинг ваших Symfony API
В процессе разработке у вас может возникнуть необходимость наложить на ваши API какой-нибудь кастомный рейт-лимит (т.е. ограничить количество запросов для пользователей вашего API). В этой статье я покажу вам, как можно объединить компонент symfony/rate-limiter со стандартными контроллерами.
#### Рейт-лимит конфигурация
Наша конечная цель заключается в том, чтобы следующая рейт-лимит конфигурация работала на любом маршруте, на котором вы захотите, - благодаря атрибутам PHP8:
```
framework:
rate_limiter:
account_create:
policy: 'fixed_window'
limit: 5
interval: '60 minutes'
account_modify: # активация аккаунта, редактирование профиля
policy: 'fixed_window'
limit: 30
interval: '60 minutes'
```
В этой статье опущен разбор самого компонента, поэтому я рекомендую вам прочитать [документацию Symfony по RateLimiter](https://symfony.com/doc/current/rate_limiter.html), если вы хотите разобраться, как он работает, и как его настраивать.
#### Атрибут
Прежде всего, нам нужен атрибут, который мы будем использовать в объявлении маршрутов, количество запросов по которым должно быть ограничено. Здесь нам дополнительно потребуется ключ конфигурации ($configuration), чтобы определить, какую именно рейт-лимит конфигурацию мы собираемся применить:
```
#[Attribute(Attribute::TARGET_METHOD)]
class RateLimiting
{
public function __construct(
public string $configuration,
) {
}
}
```
#### Контроллер
Теперь давайте применим наш атрибут к каком-нибудь контроллеру:
```
#[RateLimiting('account_create')]
#[Route('/create', methods: ['POST'])]
public function createAccount(): JsonResponse
{
// логика вашего контроллера ...
}
```
И это все, что нам нужно сделать, чтобы применить рейт-лимит к маршруту.
#### CompilerPass
Но для того, чтобы это заработало, нам нужно заставить Symfony понимать эти атрибуты. То есть нам нужен `CompilerPass` для хранения всех маршрутов с нашим атрибутом, чтобы избежать рефлексии в рантайме:
```
class RateLimitingPass implements CompilerPassInterface
{
public function process(ContainerBuilder $container): void
{
if (!$container->hasDefinition(ApplyRateLimitingListener::class)) {
throw new \LogicException(sprintf('Can not configure non-existent service %s', ApplyRateLimitingListener::class));
}
$taggedServices = $container->findTaggedServiceIds('controller.service_arguments');
/** @var Definition[] $serviceDefinitions */
$serviceDefinitions = array_map(fn (string $id) => $container->getDefinition($id), array_keys($taggedServices));
$rateLimiterClassMap = [];
foreach ($serviceDefinitions as $serviceDefinition) {
$controllerClass = $serviceDefinition->getClass();
$reflClass = $container->getReflectionClass($controllerClass);
foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC | ~\ReflectionMethod::IS_STATIC) as $reflMethod) {
$attributes = $reflMethod->getAttributes(RateLimiting::class);
if (\count($attributes) > 0) {
[$attribute] = $attributes;
$serviceKey = sprintf('limiter.%s', $attribute->newInstance()->configuration);
if (!$container->hasDefinition($serviceKey)) {
throw new \RuntimeException(sprintf(‘Service %s not found’, $serviceKey));
}
$classMapKey = sprintf('%s::%s', $serviceDefinition->getClass(), $reflMethod->getName());
$rateLimiterClassMap[$classMapKey] = $container->getDefinition($serviceKey);
}
}
}
$container->getDefinition(ApplyRateLimitingListener::class)->setArgument('$rateLimiterClassMap', $rateLimiterClassMap);
}
}
```
Здесь мы получаем все контроллеры и проверяем для каждого метода, есть ли у них наш атрибут, после чего связываем маршрут с соответствующей службой ограничения количества запросов и добавляем его в наш кэш.
#### Слушатель
Теперь, когда Symfony понимает наш атрибут и кэширует его, нам понадобится слушатель событий, чтобы подключиться к событию `kernel.controller` и проверить, в порядке ли наш рейт-лимит или нет.
```
class ApplyRateLimitingListener implements EventSubscriberInterface
{
public function __construct(
private TokenStorageInterface $tokenStorage,
/** @var RateLimiterFactory[] */
private array $rateLimiterClassMap,
private bool $isRateLimiterEnabled,
private RequestStack $requestStack,
private RoleHierarchyInterface $roleHierarchy,
) {
}
public function onKernelController(KernelEvent $event): void
{
if (!$this->isRateLimiterEnabled || !$event->isMainRequest()) {
return;
}
$request = $event->getRequest();
/** @var string $controllerClass */
$controllerClass = $request->attributes->get('_controller');
$rateLimiter = $this->rateLimiterClassMap[$controllerClass] ?? null;
if (null === $rateLimiter) {
return; // этому контроллеру не назначена служба ограничения количества запросов
}
$token = $this->tokenStorage->getToken();
if ($token instanceof TokenInterface && in_array('ROLE_GLOBAL_MODERATOR', $this->roleHierarchy->getReachableRoleNames(($token->getRoleNames())))) {
return; // игнорируем ограничение количества запросов для модератора сайта и привилегированных ролей
}
$this->ensureRateLimiting($request, $rateLimiter, $request->getClientIp());
}
private function ensureRateLimiting(Request $request, RateLimiterFactory $rateLimiter, string $clientIp): void
{
$limit = $rateLimiter->create(sprintf('rate_limit_ip_%s', $clientIp))->consume();
$request->attributes->set('rate_limit', $limit);
$limit->ensureAccepted();
$user = $this->tokenStorage->getToken()?->getUser();
if ($user instanceof User) {
$limit = $rateLimiter->create(sprintf('rate_limit_user_%s', $user->getId()))->consume();
$request->attributes->set('rate_limit', $limit);
$limit->ensureAccepted();
}
}
public static function getSubscribedEvents(): array
{
return [KernelEvents::CONTROLLER => ['onKernelController', 1024]];
}
}
```
В этом примере я решил игнорировать ограничения количества запросов для наших глобальных модераторских ролей. Для всех остальных пользователей я проверяю рейт-лимит на двух уровнях: IP, а затем User, если они залогинены. Таким образом мы можем избежать рассылки спама пользователями с разных IP-адресов. Мне нравится использовать такие бизнес-правила, но вы можете настроить все по своему усмотрению.
Также вы можете заметить, что мы указываем службу ограничения количества запросов перед каждой проверкой: если у нас будет превышение рейт-лимита, будет выброшено исключение (благодаря методу `ensureAccepted`), и вторая проверка не произойдет, у нас будет указана правильная служба ограничения количества запросов.
#### Заголовки
Наконец, чтобы получишь больше информации от службы ограничения количества запросов, мы можем сгенерировать несколько заголовков, чтобы указать, как прошел рейт-лимитинг, и какие-нибудь другие показатели:
```
final class RateLimitingResponseHeadersListener
{
public function onKernelResponse(ResponseEvent $event): void
{
if (($rateLimit = $event->getRequest()->attributes->get('rate_limit')) instanceof RateLimit) {
$event->getResponse()->headers->add([
'RateLimit-Remaining' => $rateLimit->getRemainingTokens(),
'RateLimit-Reset' => time() - $rateLimit->getRetryAfter()->getTimestamp(),
'RateLimit-Limit' => $rateLimit->getLimit(),
]);
}
}
}
```
Я взял имена заголовков из [RFC заголовков RateLimit](https://tools.ietf.org/id/draft-polli-ratelimit-headers-00.html). Хоть это все еще черновик, но эти заголовки уже широко используются.
Вот и все - с помощью всего нескольких строк кода вы можете реализовать рейт-лимит для любого маршрута, просто добавив свой новый атрибут `RateLimiting`!
---
> Материал подготовлен в рамках курса [«Symfony Framework»](https://otus.pw/BA7w/).
>
> Всех желающих приглашаем на бесплатное demo-занятие **«Инвалидация кэша в распределённой системе»**. На demo-уроке будем заниматься по следующему плану:
>
> 1. Поднимаем инстанс хранилища + 4 инстанса раздающего API в докере
> 2. В хранилище заливаем картинку
> 3. С раздающего API получаем её и кэшируем в инстансе (обсудим, зачем мы должны ее кэшировать)
> 4. Дальше удаляем картинку в хранилище.
> 5. Показываем, что раздающее API продолжает её получать
> 6. Исправляем флоу, добавляя producer/consumer с оповещением об удалении.
> 7. Проверяем, что теперь всё работает ok.
>
> Регистрация на занятие [здесь.](https://otus.pw/I95K/)
>
> | https://habr.com/ru/post/645261/ | null | ru | null |
# Задачи компьютерного зрения — поиск объектов нужного цвета
### Введение
Сегодня я расскажу о том как распознать контур нужного цвета с помощью python/ opencv такая задача часто встречается в робототехнике, и всяких автоматизациях.
С помощью предложенного решения можно например различать контур линии за которую не должен выезжать робот, или обьект для коптера. Такая задача может возникнуть если нужно например ~~увидеть что в корзину положили апельсин~~.
Чему научимся
=============
Изначально я предполагаю что у человека есть python ide(подойдет практически любое) и базовое знание питона.
Установим библиотеку OpenCV с помощью следующей команды:
```
pip install opencv-python
```
И numpy:
```
pip install numpy
```
### Код
Добавим необходимые библиотеки:
```
import cv2
import numpy as np
```
Создадим обьект cup куда будет идти видео. 0 — камера дефолтная, 1 — кастомная.
```
cap = cv2.VideoCapture(0)
```
```
_, frame = cap.read()
```
считывает кадр. вместо \_ может быть rate — туда пойдет fps камеры, но в данном случае я этим не пользуюсь.
А теперь давайте обработаем кадр для дальнейшего удобства. Уменьшим:
```
frameresized = cv2.resize(frame, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # первеод в цветовой формат BGR2HSV
hsv = cv2.blur(hsv, (5, 5)) # наложение маски
mask = cv2.inRange(hsv, (89, 124, 73), (255, 255, 255))
#кадр уже с маской
lower_blue = np.array([38, 86, 0])
#нижняя граница необходимого цвета (в нашем случае голубого)
```
Рассмотрим подробнее функцию resize:
```
frame - кадр которой передается
fx - фактор размера по оси Х
fy - фактор размера по оси Y
interpolation - INTER_NEAREST - интерполяция до ближайшего соседа
INTER_LINEAR - билинейная интерполяция (используется по дефолту)
INTER_AREA - повторная выборка с использованием отношения площади пикселя. Это может быть предпочтительный метод для прореживания изображений а когда изображение увеличина дает результат похожий на INTER_NEAREST method.
INTER_CUBIC - бикубическая интерполяция 4x4 клеток пикселей
INTER_LANCZOS4 - интерполяция Ланкоза 8x8 клеток пикселей
```
А теперь давайте на обработанном кадре распознаем контуры и отсортируем их:
```
contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
counturs = sorted(contours, key=cv2.contourArea, reverse=True)
```
А теперь давайте рассмотрим findContours подробнее:
```
cv.CHAIN_APPROX_NONE - найдет все точки границы контура(если контур сложный может неплохо так нагрузить комп)
cv.CHAIN_APPROX_SIMPLE - найдет точки границ линии - хорошо для распознования геометрии(знаков и тд)
cv.RETR_TREE - по сути просто извлекает точки и не строит между ними никаких отношений
cv.RETR_EXTERNAL - возвращает только самые старшие контуры в иерахии
cv.RETR_CCOMP - сторит 2 уровневую иерархию, те если у нас контур в контуре то он покажет то стариший будет на 1 , а младший на втором
cv2.RETR_TREE - вернет дерево всех конутуров
```
Визуализация RETR\_CCOMP:
Визуализация RETR\_TREE:
И теперь нарисуем контуры которые нашли:
```
or contour in counturs:
cv2.drawContours(frame, counturs[0], -1, (255, 0, 255), 3)
cv2.imshow("Counturs", frame) # рисует рокно с конурами
#cv2.imshow("Mask", mask)
# cv2.imshow("ret",ret)
#cv2.imshow("blur",blurred_frame)
key = cv2.waitKey(1) #ждем нажатия ESC
if key == 27:
break
```
И по нажатию кнопки останавливаем чтение камеры и закрываем все окна:
```
cap.release()
cv2.destroyAllWindows()
```
[Репозиторий](https://github.com/AlexWortega/Copterhack2019HidenSeek/blob/master/bot.py "Title")
Спасибо за прочтение статьи.
Буду признателен если вы подпишитесь на мой канал в
[телеграм](https://t.me/response1000000 "Title")
[моя игра](https://play.google.com/store/apps/details?id=com.PixelDream.Andriod_Game_2 "Title")
Upd — забавно что статья набрала примерно в 8 раз меньше просмотров чем ожидалось, но при этом примерно расчетное количество " добавлено в закладки" всего в два раза больше. Так и живем. | https://habr.com/ru/post/498774/ | null | ru | null |
# Инициализация и работа интерпретатора байткода в JVM HotSpot под x86
Почти каждый Java разработчик знает, что программы, написанные на языке Java изначально компилируются в JVM-байткод и хранятся в виде class-файлов [стандартизованного формата](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1). После попадания таких class-файлов внутрь виртуальной машины и пока до них еще не успел добраться компилятор, JVM интерпретирует байткод, содержащийся в этих class-файлах. Данная статься содержит обзор принципов работы интерпретатора применительно к OpenJDK JVM HotSpot.
Содержание статьи:
* Окружение
* Запуск java приложения
* Инициализация интепретатора и перадача управления java-коду
* Пример
#### Окружение
Для экспериментов используется сборка [крайней доступной ревизии](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f) OpenJDK JDK12 с [autoconf конфигурацией](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/doc/building.md#l634)
```
--enable-debug --with-native-debug-symbols=internal
```
на Ubuntu 18.04/gcc 7.4.0.
`--with-native-debug-symbols=internal` означает, что, при сборке JDK, дебажные символы будут содержаться в самих бинарях.
`--enable-debug` — то, что в бинарнике будет содержаться дополнительный дебажный код.
Сборка JDK 12 в таком окружении — это не сложный процесс. Все, что мне потребовалось проделать это поставить JDK11 ([для сборки JDK n требуется JDK n-1](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/doc/building.md#l404)) и доставить руками необходимые библиотеки о которых сигналил autoconf. Далее выполнив команду
```
bash configure --enable-debug --with-native-debug-symbols=internal && make CONF=fastdebug images
```
и немного подождав (на моем ноуте порядка 10 минут), получаем fastdebug сборку JDK 12.
В принципе вполне достаточно было бы просто установить jdk из публичных репозиториев и дополнительно доставить пакет openjdk-xx-dbg с дебажными символами, где xx- версия jdk, но fastdebug сборка предоставляет функции для отладки из gdb, которые могут облегчить жизнь в некоторых случаях. На данный момент я активно использую [ps()](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/utilities/debug.cpp#l457) — функция для просмотра Java-стектрейсов из gdb и [pfl()](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/utilities/debug.cpp#l489) — функция для анализа стек фреймов (очень удобно при отладке интерпретатора в gdb).
**Пример ps() и pfl()**Для примера рассмотрим следующий gdb-скрипт
```
#путь к исполняемому java
file /home/dmitrii/jdk12/build/linux-x86_64-server-fastdebug/images/jdk/bin/java
#не останавливаемся при SEGV-ах, HotSpot
#искусственно генерирует SEGV для проверок.
#например, https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/cpu/x86/vm_version_x86.cpp#l361
handle SIGSEGV nostop noprint
set breakpoint pending on
set pagination off
#Брейкпоинт на методе, который вызывается
#непосредственно перед передачей управления
#в java-метод public static void main(String args[])
b PostJVMInit thread 2
commands
#Буффер для имен методов,
#иначе падаем в корку
set $buf = (char *) malloc(1000)
#Ставим брейкпоинт на точке входа в интерпретируемые функции
#(Подробнее об этом ниже)
b *AbstractInterpreter::_entry_table[0] thread 2
commands
#Указатель на метод хранится в регистре rbx.
#Кастуем его к Method*
set $mthd = ((Method *) $rbx)
#Читаем сигнатуру метода в $buf
call $mthd->name_and_sig_as_C_string($buf, 1000)
#пропускаем все, кроме public static void main(String args)
if strcmp()("Main.main([Ljava/lang/String;)V", $buf) == 0
#ставим брейкпоинт на функции, которая вызывается из шаблона интерпретатора
#вызов ps/pfl напрямую из интерпретатора валит процесс в корку
#(скорее всего это ограничение ps/pfl)
b InterpreterRuntime::build_method_counters(JavaThread*, Method*)
commands
#удаляем все брейкпоинты, чтобы завершиться после
#вызова функций ниже
delete breakpoints
call ps()
call pfl()
c
end
end
c
end
c
end
r -cp /home/dmitrii/jdk12/ Main
```
Результат запуска такого скрипта имеет вид:
```
"Executing ps"
for thread: "main" #1 prio=5 os_prio=0 cpu=468,61ms elapsed=58,65s tid=0x00007ffff001b800 nid=0x5bfa runnable [0x00007ffff7fd9000]
java.lang.Thread.State: RUNNABLE
Thread: 0x00007ffff001b800 [0x5bfa] State: _running _has_called_back 0 _at_poll_safepoint 0
JavaThread state: _thread_in_Java
1 - frame( sp=0x00007ffff7fd9920, unextended_sp=0x00007ffff7fd9920, fp=0x00007ffff7fd9968, pc=0x00007fffd828748b)
Main.main(Main.java:10)
"Executing pfl"
for thread: "main" #1 prio=5 os_prio=0 cpu=468,83ms elapsed=58,71s tid=0x00007ffff001b800 nid=0x5bfa runnable [0x00007ffff7fd9000]
java.lang.Thread.State: RUNNABLE
Thread: 0x00007ffff001b800 [0x5bfa] State: _running _has_called_back 0 _at_poll_safepoint 0
JavaThread state: _thread_in_Java
[Describe stack layout]
0x00007ffff7fd99e0: 0x00007ffff7fd9b00 #2 entry frame
call_stub word fp - 0
0x00007ffff7fd99d8: 0x00007ffff7fd9c10 call_stub word fp - 1
0x00007ffff7fd99d0: 0x00007fffd8287160 call_stub word fp - 2
0x00007ffff7fd99c8: 0x00007fffbf1fb3e0 call_stub word fp - 3
0x00007ffff7fd99c0: 0x000000000000000a call_stub word fp - 4
0x00007ffff7fd99b8: 0x00007ffff7fd9ce8 call_stub word fp - 5
0x00007ffff7fd99b0: 0x00007ffff7fd9a80 call_stub word fp - 6
0x00007ffff7fd99a8: 0x00007ffff001b800 call_stub word fp - 7
0x00007ffff7fd99a0: 0x00007ffff7fd9b40 call_stub word fp - 8
0x00007ffff7fd9998: 0x00007ffff7fd9c00 call_stub word fp - 9
0x00007ffff7fd9990: 0x00007ffff7fd9a80 call_stub word fp - 10
0x00007ffff7fd9988: 0x00007ffff7fd9ce0 call_stub word fp - 11
0x00007ffff7fd9980: 0x00007fff00001fa0 call_stub word fp - 12
0x00007ffff7fd9978: 0x0000000716a122b8 sp for #2
locals for #1
unextended_sp for #2
local 0
0x00007ffff7fd9970: 0x00007fffd82719f3
0x00007ffff7fd9968: 0x00007ffff7fd99e0 #1 method Main.main([Ljava/lang/String;)V @ 0
- 1 locals 1 max stack
0x00007ffff7fd9960: 0x00007ffff7fd9978 interpreter_frame_sender_sp
0x00007ffff7fd9958: 0x0000000000000000 interpreter_frame_last_sp
0x00007ffff7fd9950: 0x00007fffbf1fb3e0 interpreter_frame_method
0x00007ffff7fd9948: 0x0000000716a11c40 interpreter_frame_mirror
0x00007ffff7fd9940: 0x0000000000000000 interpreter_frame_mdp
0x00007ffff7fd9938: 0x00007fffbf1fb5e8 interpreter_frame_cache
0x00007ffff7fd9930: 0x00007ffff7fd9978 interpreter_frame_locals
0x00007ffff7fd9928: 0x00007fffbf1fb3d0 interpreter_frame_bcp
0x00007ffff7fd9920: 0x00007ffff7fd9920 sp for #1
interpreter_frame_initial_sp
unextended_sp for #1
```
Как можно видеть, в случае `ps()` мы просто получаем стек вызовов, в случае `pfl()` — полную организацию стека.
#### Запуск java приложения
Прежде чем перейти к рассмотрению непосредственно интерпретатора, сделаем краткий обзор действий, выполняющихся до передачи управления java-коду. Для примера возьмем программу на языке Java, которая "не делает вообще ничего":
```
public class Main {
public static void main(String args[]){ }
}
```
и попробуем разобраться в том, что происходит при запуске такого приложения:
`javac Main.java && java Main`
Первое что нужно сделать, чтобы ответить на этот вопрос, это найти и посмотреть на бинарник java — тот самый, который мы используем для запуска все наших JVM-приложений. В моем случае он располагается по пути
`/home/dmitrii/jdk12/build/linux-x86_64-server-fastdebug/images/jdk/bin/java`.
Но смотреть в итоге тут особо не на что. Это бинарник который вместе с дебажными символами занимает всего 20КБ и скомпилирован только из одного исходного файла [launcher/main.c](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/launcher/main.c#l97).
Все, что он делает это получает аргументы командной строки (char \*argv[]), [читает аргументы из переменной среды JDK\_JAVA\_OPTIONS](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/launcher/main.c#l174), делает базовый препроцессинг и валидацию (например, нельзя добавить [терминальную опцию](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/libjli/args.c#l446) или имя Main-класса в эту переменну среды) и [вызывает функцию JLI\_Launch](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/launcher/main.c#l206) с полученным списком аргументов.
Опреление функции [JLI\_Launch](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/libjli/java.c#l220) не содержится в бинарнике java и, если посмотреть на его прямые зависимости:
```
$ ldd java
linux-vdso.so.1 (0x00007ffcc97ec000)
libjli.so => /home/dmitrii/jdk12/build/linux-x86_64-server-fastdebug/images/jdk/bin/./../lib/libjli.so (0x00007ff27518d000) // <--------- Вот эта либа
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007ff274d9c000)
libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007ff274b7f000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007ff27497b000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007ff27475c000)
/lib64/ld-linux-x86-64.so.2 (0x00007ff27559f000)
```
то можно заметить **libjli.so** которая к нему прилинкована. Данная библиотека содержит launcher interface — набор функций, которые используются java для инициализации и запуска виртуальной машины, среди которых присутствует и JLI\_Launch.
**Полный список функций интерфейса**
```
$ objdump -T -j .text libjli.so
libjli.so: file format elf64-x86-64
DYNAMIC SYMBOL TABLE:
0000000000009280 g DF .text 0000000000000038 Base JLI_List_add
0000000000003330 g DF .text 00000000000001c3 Base JLI_PreprocessArg
0000000000008180 g DF .text 0000000000000008 Base JLI_GetStdArgs
0000000000008190 g DF .text 0000000000000008 Base JLI_GetStdArgc
0000000000007e50 g DF .text 00000000000000b8 Base JLI_ReportErrorMessage
000000000000a400 g DF .text 00000000000000df Base JLI_ManifestIterate
0000000000002e70 g DF .text 0000000000000049 Base JLI_InitArgProcessing
0000000000008000 g DF .text 0000000000000011 Base JLI_ReportExceptionDescription
0000000000003500 g DF .text 0000000000000074 Base JLI_AddArgsFromEnvVar
0000000000007f10 g DF .text 00000000000000e9 Base JLI_ReportErrorMessageSys
0000000000005840 g DF .text 00000000000000b8 Base JLI_ReportMessage
0000000000009140 g DF .text 000000000000003a Base JLI_SetTraceLauncher
0000000000009020 g DF .text 000000000000000a Base JLI_MemFree
0000000000008f90 g DF .text 0000000000000026 Base JLI_MemAlloc
00000000000059c0 g DF .text 0000000000002013 Base JLI_Launch
00000000000091c0 g DF .text 000000000000003b Base JLI_List_new
0000000000008ff0 g DF .text 0000000000000026 Base JLI_StringDup
0000000000002ec0 g DF .text 000000000000000c Base JLI_GetAppArgIndex
```
После передачи управления JLI\_Launch происходит ряд действий необходимых для запуска JVM такие как:
**I**. Загрузка символов JVM HotSpot в память и получение указателя на функцию для создания VM.
Весь код JVM HotSpot располагается в библиотеке libjvm.so. После определения абсолютного пути к libjvm.so происходит [загрузка библиотеки в память](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/unix/native/libjli/java_md_solinux.c#l550) и [выдирание из нее указателя на функцию JNI\_CreateJavaVM](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/unix/native/libjli/java_md_solinux.c#l602). Этот указатель на функцию сохраняется и в дальнейшем используется для создания и инициализации виртуальной машины.
Очевидно, что libjvm.so не прилинкована к libjli.so
**II**. Парсинг аргументов, переданных после препроцессинга.
Функция с говорящим названием [ParseArguments](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/libjli/java.c#l1278) разбирает аргументы, переданные из командной строки. Этот парсер аргументов определяет [режим запуска приложения](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/libjli/java.h#l229)
```
enum LaunchMode { // cf. sun.launcher.LauncherHelper
LM_UNKNOWN = 0,
LM_CLASS,
LM_JAR,
LM_MODULE,
LM_SOURCE
};
```
Также он преобразует часть аргументов в формат `-DpropertyName=propertyValue`, например `-cp=/path` приводится к виду `-Djava.class.path=/path`. Далее такие `SystemProperty` сохраняются в [глобальном массиве](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/arguments.hpp#l286) в JVM HotSpot и пробрасываются в `java.lang.System::props` в [первой фазе инициализации](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/classes/java/lang/System.java#l1992) (В JDK12 механизм инициализации java.lang.System.props был модифицирован, подробнее в [этом коммите](https://hg.openjdk.java.net/jdk/jdk12/rev/0bdbf854472f)).
Парсинг аргументов также отбрасывает часть опций, которые не обрабатываются JVM (например `--list-modules`, обработка данной опции происходит непосредственно в launcher'e в [этом месте](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/libjli/java.c#l431)).
**III**. Форк primordial потока и создание в нем VM
Но если что-то пошло не так, то делается попытка [запустить JVM в main-треде](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/unix/native/libjli/java_md_solinux.c#l758) "just give it a try".
Поизучав вопрос, я нашел одну из возможных причин, по которой JVM запускается не в main-треде. Дело в том, что (по крайней мере в Linux) pthread'ы и main-тред работают со стеком по разному. Размер main-thread'a ограничен значением `ulimit -s`, т.е. при выставлении сколь угодно большого значения мы получим сколь угодно большой стек. Main-тред использует нечто похожее на [MAP\_GROWSDOWN](http://man7.org/linux/man-pages/man2/mmap.2.html), но не `MAP_GROWSDOWN`. Использование `MAP_GROWSDOWN` в чистом виде не безопасно и, если мне не изменяет память, задепрекейчено. На моей машине `MAP_GROWSDOWN` не добавляет никакого эффекта. Отличие маппинга main-треда от `MAP_GROWSDOWN` в том, что никакой другой `mmap`, за исключением `MAP_FIXED`, не сможет сделать коллизию с областью возможного расширения стека. Все что нужно от софта — это выставить соответствующее значение `rsp` и дальше ОС сама разберется: И page-fault обработает и [guard выставит](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/mm/mmap.c?h=v5.1#n2498). Такое различие пораждает некоторое количество граблей: [При определении размера стека текущего потока](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/os/linux/os_linux.cpp#l5899), [при создании guard-pages](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/thread.cpp#l2540)
Итак, будем считать, что на данный момент у нас успешно распарсились опции и создался поток для VM. После этого, только что форкнутый поток начинает создание виртуальной машины и попадает в функцию [Threads::create\_vm](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/thread.cpp#l3588)
В этой функции делается довольно большое количество ~~черной магии~~ инициализаций, нам интересны будут лишь некоторые из них.
#### Инициализация интепретатора и передача управления java-коду
Для каждой инструкции в JVM HotSpot существует определенный шаблон машинного кода под конкретную архитектуру. Когда интерпретатор приступает к выполнению какой-либо инструкции, первым делом ищется адрес ее шаблона в специальной таблице [DispatchTable](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreter.hpp#l129). Далее происходит [jump](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/cpu/x86/interp_masm_x86.cpp#l844) по адресу данного шаблона и после того как выполнение инструкции завершено, jvm достает адрес [следующей по порядку инструкции](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l401)) и начинает выполнять ее аналогичным образом, и так далее. Такое поведение наблюдается у интерепретатора только для инструкций, которые не "делают dispatch", например, арифметические инструкции (`xsub`, `xdiv`, etc, где `x` — `i`, `l`, `f`, `d`). Все, что они делают — это выполняют арифметические операции.
В случае инструкций вызова процедур (`invokestatic`, `invokevirtual`, и т.д.) следующей к выполнению инструкцей будет первая по порядку инструкция вызываемой процедуры. Такие инструкции самостоятельно проставляют адрес следующей bytecode-инструкции к выполнению в своем шаблоне.
Чтобы обеспечить работу данной машинерии в [`Threads::create_vm`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/thread.cpp#l3588) выполняется ряд инициализаций, от которых зависит интерпретатор:
**I**. Инициализация таблицы доступных байткодов
Прежде чем приступить к инициализации интерпретатора, необходимо проинициализировать таблицу используемых байткодов. Она выполняется в функции [Bytecodes::initialize](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/bytecodes.cpp#l268) и представлена в виде очень удобочитаемой таблички. Ее фрагмент выглядит следующим образом:
```
// Java bytecodes
// bytecode bytecode name format wide f. result tp stk traps
def(_nop , "nop" , "b" , NULL , T_VOID , 0, false);
def(_aconst_null , "aconst_null" , "b" , NULL , T_OBJECT , 1, false);
def(_iconst_m1 , "iconst_m1" , "b" , NULL , T_INT , 1, false);
def(_iconst_0 , "iconst_0" , "b" , NULL , T_INT , 1, false);
def(_iconst_1 , "iconst_1" , "b" , NULL , T_INT , 1, false);
def(_iconst_2 , "iconst_2" , "b" , NULL , T_INT , 1, false);
def(_iconst_3 , "iconst_3" , "b" , NULL , T_INT , 1, false);
def(_iconst_4 , "iconst_4" , "b" , NULL , T_INT , 1, false);
def(_iconst_5 , "iconst_5" , "b" , NULL , T_INT , 1, false);
def(_lconst_0 , "lconst_0" , "b" , NULL , T_LONG , 2, false);
def(_lconst_1 , "lconst_1" , "b" , NULL , T_LONG , 2, false);
def(_fconst_0 , "fconst_0" , "b" , NULL , T_FLOAT , 1, false);
def(_fconst_1 , "fconst_1" , "b" , NULL , T_FLOAT , 1, false);
def(_fconst_2 , "fconst_2" , "b" , NULL , T_FLOAT , 1, false);
def(_dconst_0 , "dconst_0" , "b" , NULL , T_DOUBLE , 2, false);
def(_dconst_1 , "dconst_1" , "b" , NULL , T_DOUBLE , 2, false);
def(_bipush , "bipush" , "bc" , NULL , T_INT , 1, false);
def(_sipush , "sipush" , "bcc" , NULL , T_INT , 1, false);
def(_ldc , "ldc" , "bk" , NULL , T_ILLEGAL, 1, true );
def(_ldc_w , "ldc_w" , "bkk" , NULL , T_ILLEGAL, 1, true );
def(_ldc2_w , "ldc2_w" , "bkk" , NULL , T_ILLEGAL, 2, true );
```
В соответствии с данной таблицей, для каждого байткода выставляются его длина (размер всегда 1 байт, но может быть еще индекс в `ConstantPool`, а также широкие байткоды), имя, байткод и флаги:
```
bool Bytecodes::_is_initialized = false;
const char* Bytecodes::_name [Bytecodes::number_of_codes];
BasicType Bytecodes::_result_type [Bytecodes::number_of_codes];
s_char Bytecodes::_depth [Bytecodes::number_of_codes];
u_char Bytecodes::_lengths [Bytecodes::number_of_codes];
Bytecodes::Code Bytecodes::_java_code [Bytecodes::number_of_codes];
unsigned short Bytecodes::_flags [(1<
```
Эти параметры в дальнейшем нужны для генерации кода шаблонов интерпретатора
**II**. Инициализация код кэша
Для того, чтобы сгенерить код шаблонов интерпретатора, необходимо сперва выделить под это дело память. Резервация памяти под код кэш реализована в функции с одноименным названием [CodeCache::initialize()](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/code/codeCache.cpp#l1094). Как можно видеть из следущего участка кода данной функции
```
CodeCacheExpansionSize = align_up(CodeCacheExpansionSize, os::vm_page_size());
if (SegmentedCodeCache) {
// Use multiple code heaps
initialize_heaps();
} else {
// Use a single code heap
FLAG_SET_ERGO(uintx, NonNMethodCodeHeapSize, 0);
FLAG_SET_ERGO(uintx, ProfiledCodeHeapSize, 0);
FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, 0);
ReservedCodeSpace rs = reserve_heap_memory(ReservedCodeCacheSize);
add_heap(rs, "CodeCache", CodeBlobType::All);
}
```
код кэш контролируется опциями [`-XX:ReservedCodeCacheSize`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/globals.hpp#l1881), [`-XX:SegmentedCodeCache`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/globals.hpp#l1878), [`-XX:CodeCacheExpansionSize`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/globals.hpp#l1897), [`-XX:NonNMethodCodeHeapSize`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/globals.hpp#l1893), [`-XX:ProfiledCodeHeapSize`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/globals.hpp#l1889), [`-XX:NonProfiledCodeHeapSize`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/globals.hpp#l1885). Краткое описание данных опций можно посмотреть по ссылкам на которые они ведут. Помимо коммандной строки, значения некоторых из этих опций подстраивается эргономикой, например, если используется значение `SegmentedCodeCache` по умолчанию (выключен), то при размере кода `>= 240Mb`, `SegmentedCodeCache` будет включен в [CompilerConfig::set\_tiered\_flags](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/compiler/compilerDefinitions.cpp#l208).
После выполнения проверок резервируется область размером в `ReservedCodeCacheSize` байт. В случае, если `SegmentedCodeCache` оказалась выставленной, то данная область разбивается на части: JIT-скомпилированные методы, стаб рутины, и т.д.
**III**. Инициализация шаблонов интерпретатора
После того, как таблица байткодов и код кэш проинициализированы, можно приступать к кодогенерации шаблонов интерпретатора. Для этого интерепретатор резервирует буффер из ранее проинициализированного код кэша. На каждый этап кодогенерации из буффера будут отрезаться [кодлеты](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/interpreter.hpp#l44) — небольшие участки кода. После завершению текущей генерации, неиспользуемая под код часть кодлета освобождается и становится доступной для последующих кодогенераций.
Рассмотрим каждый из этих этапов по отдельности:
* [slow\_signature\_handler](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l59)
```
{ CodeletMark cm(_masm, "slow signature handler");
AbstractInterpreter::_slow_signature_handler = generate_slow_signature_handler();
}
```
signature handler используется для подготовки аргументов для вызовов нативных методов. В данном случае генерится обощенный хэндлер, если, например у нативного метода больше 13 аргументов (В дебаггере не проверял, но судя по [коду](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/interpreterRuntime.cpp#l1383) должны быть так)
* [обработка невалидного байткода](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l63)
```
{ CodeletMark cm(_masm, "error exits");
_unimplemented_bytecode = generate_error_exit("unimplemented bytecode");
_illegal_bytecode_sequence = generate_error_exit("illegal bytecode sequence - method not verified");
}
```
VM валидирует классфайлы при инициализации, но это на случай, если аргументы на стеке не того формата который нужен или байткод о котором VM не знает. Эти стабы используются при генерации кода шаблонов для каждого из байткодов.
* [return из функции](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l87)
После вызова процедур необходимо восстановить данные стек фрейма, который был до вызова процедуры из которой делается return.
* [earlyret](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l125)
Используется при вызовах рантайма из интерепретатора.
* [Бросание исключений](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l171)
* [Точки входа в методы](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l187)
```
#define method_entry(kind) \
{ CodeletMark cm(_masm, "method entry point (kind = " #kind ")"); \
Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind); \
Interpreter::update_cds_entry_table(Interpreter::kind); \
}
```
Представлен в виде макроса в зависимости от типа метода. В общем случае выполняется подготовка [интерпретируемого стек-фрейма](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/cpu/x86/frame_x86.hpp#l30), проверка StackOverflow, stack-banging. Для нативных методов определяется signature handler.
* [Генерация шаблонов для байткодов](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateInterpreterGenerator.cpp#l233)
```
// Bytecodes
set_entry_points_for_all_bytes();
// installation of code in other places in the runtime
// (ExcutableCodeManager calls not needed to copy the entries)
set_safepoints_for_all_bytes();
```
Для выполнения инструкции спецификация VM требует чтобы операнды находились в [Operand Stack](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-2.html#jvms-2.6.2), но это не запрещает HotSpot кэшировать их в регистре. Для определения текущего состояния вершины стека используется [перечисление](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/utilities/globalDefinitions.hpp#l738)
```
enum TosState { // describes the tos cache contents
btos = 0, // byte, bool tos cached
ztos = 1, // byte, bool tos cached
ctos = 2, // char tos cached
stos = 3, // short tos cached
itos = 4, // int tos cached
ltos = 5, // long tos cached
ftos = 6, // float tos cached
dtos = 7, // double tos cached
atos = 8, // object cached
vtos = 9, // tos not cached
number_of_states,
ilgl // illegal state: should not occur
};
```
Каждая инструкция определяет входные и выходные состояния `TosState` вершины стека, и генерация шаблонов происходит в зависимости от этого состояния. Данные шаблоны инициализируются в удобочитаемой [таблице шаблонов](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/interpreter/templateTable.cpp#l252). Фрагмент этой таблицы выглядит следующим образом:
```
// interpr. templates
// Java spec bytecodes ubcp|disp|clvm|iswd in out generator argument
def(Bytecodes::_nop , ____|____|____|____, vtos, vtos, nop , _ );
def(Bytecodes::_aconst_null , ____|____|____|____, vtos, atos, aconst_null , _ );
def(Bytecodes::_iconst_m1 , ____|____|____|____, vtos, itos, iconst , -1 );
def(Bytecodes::_iconst_0 , ____|____|____|____, vtos, itos, iconst , 0 );
def(Bytecodes::_iconst_1 , ____|____|____|____, vtos, itos, iconst , 1 );
def(Bytecodes::_iconst_2 , ____|____|____|____, vtos, itos, iconst , 2 );
def(Bytecodes::_iconst_3 , ____|____|____|____, vtos, itos, iconst , 3 );
def(Bytecodes::_iconst_4 , ____|____|____|____, vtos, itos, iconst , 4 );
def(Bytecodes::_iconst_5 , ____|____|____|____, vtos, itos, iconst , 5 );
def(Bytecodes::_lconst_0 , ____|____|____|____, vtos, ltos, lconst , 0 );
def(Bytecodes::_lconst_1 , ____|____|____|____, vtos, ltos, lconst , 1 );
def(Bytecodes::_fconst_0 , ____|____|____|____, vtos, ftos, fconst , 0 );
def(Bytecodes::_fconst_1 , ____|____|____|____, vtos, ftos, fconst , 1 );
def(Bytecodes::_fconst_2 , ____|____|____|____, vtos, ftos, fconst , 2 );
def(Bytecodes::_dconst_0 , ____|____|____|____, vtos, dtos, dconst , 0 );
def(Bytecodes::_dconst_1 , ____|____|____|____, vtos, dtos, dconst , 1 );
def(Bytecodes::_bipush , ubcp|____|____|____, vtos, itos, bipush , _ );
def(Bytecodes::_sipush , ubcp|____|____|____, vtos, itos, sipush , _ );
```
Нам будут особенно интересны столбцы `in`, `out` и `generator`.
`in` — состояние вершины стека на момент начала исполнения инструкции
`out` — состояния вершины стека на момент завершения исполнения инструкции
`generator` — генератор шаблона машинного кода инструкции
Общий вид шаблона для всех байткодов можно описать в виде:
1. Если для инструкции не выставлен dispatch bit, то выполняется пролог инструкции (no-op на x86)
2. Используя `generator`, генерится машинный код
3. Если для инструкции не выставлен dispatch bit, то выполняется переход к следующей по порядку инструкции в зависимости от `out` состояния вершины стека, которое будет являтся `in` для следующей инструкции
Адрес точки входа для полученного шаблона сохраняется в глобальной таблице и его можно использовать при отладке.
В HotSpot за это отвечает следущий, относительно стремный кусок кода:
**Кодогенератор инструкций**
```
void TemplateInterpreterGenerator::set_entry_points(Bytecodes::Code code) {
CodeletMark cm(_masm, Bytecodes::name(code), code);
// initialize entry points
assert(_unimplemented_bytecode != NULL, "should have been generated before");
assert(_illegal_bytecode_sequence != NULL, "should have been generated before");
address bep = _illegal_bytecode_sequence;
address zep = _illegal_bytecode_sequence;
address cep = _illegal_bytecode_sequence;
address sep = _illegal_bytecode_sequence;
address aep = _illegal_bytecode_sequence;
address iep = _illegal_bytecode_sequence;
address lep = _illegal_bytecode_sequence;
address fep = _illegal_bytecode_sequence;
address dep = _illegal_bytecode_sequence;
address vep = _unimplemented_bytecode;
address wep = _unimplemented_bytecode;
// code for short & wide version of bytecode
if (Bytecodes::is_defined(code)) {
Template* t = TemplateTable::template_for(code);
assert(t->is_valid(), "just checking");
set_short_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep);
}
if (Bytecodes::wide_is_defined(code)) {
Template* t = TemplateTable::template_for_wide(code);
assert(t->is_valid(), "just checking");
set_wide_entry_point(t, wep);
}
// set entry points
EntryPoint entry(bep, zep, cep, sep, aep, iep, lep, fep, dep, vep);
Interpreter::_normal_table.set_entry(code, entry);
Interpreter::_wentry_point[code] = wep;
}
//...
void TemplateInterpreterGenerator::set_short_entry_points(Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) {
assert(t->is_valid(), "template must exist");
switch (t->tos_in()) {
case btos:
case ztos:
case ctos:
case stos:
ShouldNotReachHere(); // btos/ctos/stos should use itos.
break;
case atos: vep = __ pc(); __ pop(atos); aep = __ pc(); generate_and_dispatch(t); break;
case itos: vep = __ pc(); __ pop(itos); iep = __ pc(); generate_and_dispatch(t); break;
case ltos: vep = __ pc(); __ pop(ltos); lep = __ pc(); generate_and_dispatch(t); break;
case ftos: vep = __ pc(); __ pop(ftos); fep = __ pc(); generate_and_dispatch(t); break;
case dtos: vep = __ pc(); __ pop(dtos); dep = __ pc(); generate_and_dispatch(t); break;
case vtos: set_vtos_entry_points(t, bep, cep, sep, aep, iep, lep, fep, dep, vep); break;
default : ShouldNotReachHere(); break;
}
}
//...
void TemplateInterpreterGenerator::generate_and_dispatch(Template* t, TosState tos_out) {
if (PrintBytecodeHistogram) histogram_bytecode(t);
#ifndef PRODUCT
// debugging code
if (CountBytecodes || TraceBytecodes || StopInterpreterAt > 0) count_bytecode();
if (PrintBytecodePairHistogram) histogram_bytecode_pair(t);
if (TraceBytecodes) trace_bytecode(t);
if (StopInterpreterAt > 0) stop_interpreter_at();
__ verify_FPU(1, t->tos_in());
#endif // !PRODUCT
int step = 0;
if (!t->does_dispatch()) {
step = t->is_wide() ? Bytecodes::wide_length_for(t->bytecode()) : Bytecodes::length_for(t->bytecode());
if (tos_out == ilgl) tos_out = t->tos_out();
// compute bytecode size
assert(step > 0, "just checkin'");
// setup stuff for dispatching next bytecode
if (ProfileInterpreter && VerifyDataPointer
&& MethodData::bytecode_has_profile(t->bytecode())) {
__ verify_method_data_pointer();
}
__ dispatch_prolog(tos_out, step);
}
// generate template
t->generate(_masm);
// advance
if (t->does_dispatch()) {
#ifdef ASSERT
// make sure execution doesn't go beyond this point if code is broken
__ should_not_reach_here();
#endif // ASSERT
} else {
// dispatch to next bytecode
__ dispatch_epilog(tos_out, step);
}
}
```
Как только данная кодогенерация завершена, интепретатор можно считать полностью проинициализированным. После интерпретатора выполняется еще много инициализаций различных подсистем JVM. Для некоторых из них требуется вызывать Java-код из кода виртуальной машины. Это реализовано с помощью стандартного механизма [JavaCalls](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/runtime/javaCalls.hpp#l229). После того как инициализация JVM полностью завершена, этот механизм используется для [вызова метода main](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/java.base/share/native/libjli/java.c#l549).
#### Пример
Для того, чтобы представлять как это все работает на практике, рассмотрим следующий относительно простой пример:
```
public class Sum{
public static void sum(int a, int b){
return a + b;
}
}
public class Main {
public static void main(String args[]){
Sum.sum(2, 3);
}
}
```
и попытаемся понять что происходит при вызове метода `Sum.sum(II)`.
Скомпилируем эти 2 класса `javac -c *.java` и убедимся в том, что компилятор не сделал никаких оптимизаций.
Байткод `Sum.sum`:
```
descriptor: (II)I
flags: (0x0009) ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=2
0: iload_0
1: iload_1
2: iadd
3: ireturn
LineNumberTable:
line 3: 0
```
Байткод Main.main
```
descriptor: ([Ljava/lang/String;)V
flags: (0x0009) ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: iconst_2
1: iconst_3
2: invokestatic #2 // Method Sum.sum:(II)I
5: pop
6: return
LineNumberTable:
line 13: 0
line 14: 6
```
Байткод ровно такой, какой нам нужен и первое с чего придется начать — это с анализа вызова статического метода.
Генератор шаблона `invokestatic`'а для x86 находится в архитектурно-зависимой секции кода HotSpot и представлен в [виде](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/cpu/x86/templateTable_x86.cpp#l3766)
```
void TemplateTable::invokestatic(int byte_no) {
transition(vtos, vtos);
assert(byte_no == f1_byte, "use this argument");
prepare_invoke(byte_no, rbx); // get f1 Method*
// do the call
__ profile_call(rax);
__ profile_arguments_type(rax, rbx, rbcp, false);
__ jump_from_interpreted(rbx, rax);
}
```
`byte_no == f1_byte` — это секция `ConstantPoolCache`, относящаяся к статическим методам, `rbx` — регистр, в котором будет храниться указатель `Method *`. В остальном все в принципе понятно: Подготовка вызова, профайлинг, переход на точку входа метода (`method_entry` при генерации шаблонов интерпретатора).
Рассмотрим подронее `prepare_invoke`. Как известно, следом за байткодом инструкции `invokestatic` идет индекс в `ConstantPool` на [`Constant_Methodref_Info`](https://docs.oracle.com/javase/specs/jvms/se12/html/jvms-4.html#jvms-4.4.2). В случае HotSpot это не совсем так. Следущие 2 байта указывают на индекс в т.н. [`ConstantPoolCache`](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/oops/cpCache.hpp#l410). `ConstantPoolCache` это структура данных в которой хранится информация, нужная для интерпретатора (например, было ли зарезолвено `ConstantPoolCacheEntry` по данному индексу, реализуя таким образом ленивость загрузки классов). После того как это `ConstantPoolCacheEntry` зарезолвено, в него записывается номер байткода (изначально там был 0) и этот номер используется при дальнейшем определении зарезолвено/не зарезолвено. Несмотря на то, что при загрузке класса индексы изначально указывают в `ConstantPool`, при линковке класса они будут перезаписаны на `ConstantPoolCache` индексы в нативном байт ордере (на x86 Little Endian).
Итак, первое, что HotSpot пытается сделать в `prepare_invoke` — это достать индекс на `ConstantPoolCache`. После того, как индекс получен, делается проверка на зарезолвенность `ConstantPoolCacheEntry` по данному индексу
```
__ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, temp, byte_no, 1, index_size);
__ cmpl(temp, code); // have we resolved this bytecode?
__ jcc(Assembler::equal, resolved);
// resolve first time through
address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
__ movl(temp, code);
__ call_VM(noreg, entry, temp);
// Update registers with resolved info
__ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
__ bind(resolved);
```
Если нет, значит нужно вызывать `InterpreterRuntime::resolve_from_cache`.
В данной функции выполняется загрузка класса receiver'a вызываемого статического метода, если на данный момент класс еще не был загружен. После загрузки выполняется инициализация (линковка, валидация, перезаписывание байткода, создание `ConstantPoolCache` и вызов , если такой метод присутствует в байткоде). [Не ленивая инициализация](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/share/oops/instanceKlass.cpp#l607) может выполняться и сразу после define class, если выставлен флаг `EagerInitialization` (флаг девелоперский, поэтому из коммандной строки не доступен, но кто нам запретит у себя его поменять на продакшн :)). Вообще загрузка классов в HotSpot в общем (и CDS в частности) имеет относительно не тривиальную реализацию.
После того, как класс инициализирован и нужный метод в классе найден, инициализируется соответветствующее `ConstantPoolCacheEntry` этими байткодом и методом. После этого интерпретатор загружает указатель `Method *` в `rbx`, достает адрес возврата, делает профайлинг и переходит на точку входа вызовав метода.
Исследуем теперь точку входа при вызове `Sum.sum(2, 3)`. Для этого нам потребуется следующий gdb-script `sum.gdb`:
```
#Путь к исполняемому файлу java
file /home/dmitrii/jdk12/build/linux-x86_64-server-fastdebug/images/jdk/bin/java
#Говорим gdb не останавливаться на SEGV'ах
#таких, как этот https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/cpu/x86/vm_version_x86.cpp#l361
handle SIGSEGV nostop noprint
#Символы на данный момент еще не загружены
set breakpoint pending on
#Чтобы быстро проскипать статические методы,
#не относящиеся к эксперименту
set pagination off
#Ставим брейк сразу перед вызовом метода main
b PostJVMInit
commands
#Буффер для сигнатур методов,
#иначе упадем в корку
set $buffer = malloc(1000)
#Точка входа в метод.
#jmp по этому адресу делается в генерируемом
#шаблоне invokestatic
b *AbstractInterpreter::_entry_table[0] thread 2
commands
#В соответсвии с кодом шаблона invokestatic,
#указатель Method* хранится в rbx
set $mthd = (Method *) $rbx
#Получаем сигнатуру метода в $buffer
call $mthd->name_and_sig_as_C_string($buffer, 1000)
if strcmp()($buffer, "Sum.sum(II)I") == 0
#Брейкпоинт на iload_0, вершина стека не закеширована
b *TemplateInterpreter::_normal_table._table[vtos][26] thread 2
#Брейкпоинт на iload_1, вершина стека - int, закеширована
#после выполнения iload_0
b *TemplateInterpreter::_normal_table._table[itos][27] thread 2
#Брейкпоинт на инструкции iadd
b *TemplateInterpreter::_normal_table._table[itos][96] thread 2
end
c
end
c
end
r -cp . Main
```
Запустив данный скрипт `gdb -x sum.gdb`, останавливаемся на точке входа в метод `Sum.sum`
```
$453 = 0x7ffff7fdcdd0 "Sum.sum(II)I"
```
Если открыть `layout asm`, то мы увидим код, сгенеренный методом [generate\_normal\_entry](https://hg.openjdk.java.net/jdk/jdk12/file/06222165c35f/src/hotspot/cpu/x86/templateInterpreterGenerator_x86.cpp#l1327). В данном шаблоне делается создание стек-фрейма, проверка StackOverflow, stack-banging и далее делается dispatch на первую инструкцию `iload_0` при незакешированной вершине стека. В этом случае код интерпретатора имеет вид:
```
0x7fffd828fa1f mov eax,DWORD PTR [r14] ;собственно, iload_0 0x7fffd828fa22 movzx ebx,BYTE PTR [r13+0x1] ;загружаем следующий байткод 0x7fffd828fa27 inc r13 ;инкремент bcp (byte code pointer) 0x7fffd828fa2a movabs r10,0x7ffff717e8a0 ;загрузка DispatchTable 0x7fffd828fa34 jmp QWORD PTR [r10+rbx*8] ;jump в зависимости от вершины стека
```
После этого вершина стека оказалась закешированной в `rax`, а значит интерпретатор переходит в следующий шаблон
```
0x7fffd828fabe push rax ;кладем кешированную вершину на стек
;далее все тоже самое, что и в предыдущем примере
0x7fffd828fabf mov eax,DWORD PTR [r14-0x8] 0x7fffd828fac3 movzx ebx,BYTE PTR [r13+0x1] 0x7fffd828fac8 inc r13 0x7fffd828facb movabs r10,0x7ffff717e8a0 0x7fffd828fad5 jmp QWORD PTR [r10+rbx*8]
```
Ну а теперь и сама инструкция `iadd`:
```
0x7fffd8292ba7 mov edx,DWORD PTR [rsp] ;загружаем то, что ранее запушили в iload_1 0x7fffd8292baa add rsp,0x8 ;поправляем rsp руками после загрузки 0x7fffd8292bae add eax,edx ;сложение двух интов 0x7fffd8292bb0 movzx ebx,BYTE PTR [r13+0x1] 0x7fffd8292bb5 inc r13 0x7fffd8292bb8 movabs r10,0x7ffff717e8a0 0x7fffd8292bc2 jmp QWORD PTR [r10+rbx*8]
```
Если посмотреть в `gdb` на `eax` и `edx` сразу перед выполнением сложения, то можно заметить
```
(gdb) p $eax
$457 = 3
(gdb) p $edx
$458 = 2
```
А это и есть те самые операнды, которые мы передали функции `Sum.sum`. | https://habr.com/ru/post/469291/ | null | ru | null |
# C++ Russia: как это было
*Если в начале пьесы вы говорите, что на стене висит код на С++, то к концу он должен непременно выстрелить вам в ногу.
Бьярне Строуструп*
С 31-го октября по 1-е ноября в Петербурге прошла конференция C++ Russia Piter – одна из масштабных конференций по программированию в России, организуемая JUG Ru Group. Среди приглашённых спикеров – члены комитета по стандартизации C++, докладчики с CppCon, авторы книг издательства O'Reilly, а также мейнтейнеры таких проектов, как LLVM, libc++ и Boost. Конференция ориентирована на опытных разработчиков на C++, желающих углубить свою экспертизу и обменяться опытом в живом общении. Студентам, аспирантам и преподавателям университетов предоставляются очень приятные скидки.
Московское издание конференции можно будет посетить уже в апреле следующего года, а пока наши студенты расскажут, что интересного они узнали на прошедшем мероприятии.
*Фото из [альбома конференции](https://vk.com/album-77278886_270140987)*
О нас
-----
Над этим постом работали двое студентов НИУ ВШЭ — Санкт-Петербург:
* Лиза Василенко – студентка 4-го курса бакалавриата, изучающая направление «Языки программирования» в рамках программы «Прикладная математика и информатика». Познакомившись с языком C++ на первом курсе университета, впоследствии приобрела опыт работы с ним на стажировках в индустрии. Увлечение языками программирования в целом и функциональным программированием в частности наложило отпечаток на выбор докладов на конференции.
* Даня Смирнов – студент 1-го курса магистратуры «Программирование и анализ данных». Ещё в школе писал на C++ олимпиадные задачи, а дальше как-то так вышло, что язык постоянно всплывал в учебной деятельности и в итоге стал основным рабочим. В конференции решил участвовать, чтобы подтянуть свои знания, а также узнать о новых возможностях.
В рассылке руководство факультета часто делится информацией об образовательных событиях, связанных с нашей специальностью. В сентябре мы увидели информацию о C++ Russia и решили зарегистрироваться в качестве слушателей. Это – наш первый опыт участия в подобных конференциях.
Структура конференции
---------------------
* ### Доклады
В течение двух дней эксперты прочитали 30 докладов, осветив много горячих топиков: остроумные применения фичей языка для решения прикладных задач, грядущие обновления языка в связи с новым стандартом, компромиссы при дизайне C++ и меры предосторожности при работе с их последствиями, примеры интересной архитектуры проектов, а также некоторые подкапотные детали инфраструктуры языка. Одновременно проходило по 3 выступления, чаще всего два на русском и одно на английском языке.
* ### Discussion zones
После выступления все незаданные вопросы и незавершённые обсуждения переносились в специально выделенные зоны общения с докладчиками, оснащённые маркерными досками. Хороший способ скоротать перерыв между выступлениями за приятной беседой.
* ### Lightning Talks и неформальные дискуссии
Если захотелось сделать короткий доклад — можно записаться на маркерной доске на вечерний Lightning Talk и получить пять минут времени на рассказ о чём угодно по теме конференции. Например, быстрое введение в sanitizers для C++ (для некоторых оказалось в новинку) или история про баг в генерации синусоиды, который можно только услышать, но не увидеть.
Другой формат — панельная дискуссия «С комитетом по душам». На сцене — некоторые члены комитета по стандартизации, на проекторе — камин (официально — для создания душевной атмосферы, но причина «потому что ВСЁ В ОГНЕ» кажется забавнее), вопросы — про стандарт и общее видение C++, без бурных технических обсуждений и холиваров. Оказалось, что в комитете тоже сидят живые люди, которые могут быть в чём-то не до конца уверены или чего-то не знать.
Для любителей холиваров по делу оставалось третье мероприятие — BOF-сессия «Go против C++». Берём любителя Go, любителя C++, перед началом сессии они вместе готовят 100500 слайдов на тему (вроде проблем с пакетами в C++ или отсутствием дженериков в Go), а затем они оживлённо дискутируют между собой и с залом, а зал пытается понять сразу две точки зрения. Если начинается холивар не по делу — вмешивается модератор и примиряет стороны. Такой формат затягивает: через несколько часов после начала была пройдена только половина слайдов. Конец пришлось сильно ускорять.
* ### Стенды партнёров
В холлах были представлены партнеры конференции — на стендах рассказывали о текущих проектах, предлагали стажировки и трудоустройство, проводили квизы и небольшие соревнования, а также разыгрывали приятные призы. При этом некоторые компании даже предлагали пройти начальные этапы собеседований, что может быть полезно для тех, кто приехал не только слушать доклады.
Технические подробности докладов
--------------------------------
Мы слушали доклады оба дня. Порой было трудно выбрать один доклад из параллельно идущих – мы договорились разделяться и обмениваться полученными знаниями в перерывах. И даже так, кажется, что многое осталось упущено. Здесь мы хотели бы рассказать о содержании некоторых докладов, которые показались нам самыми интересными
### Исключения в C++ через призму компиляторных оптимизаций, Роман Русяев
*Слайд из [презентации](https://assets.ctfassets.net/oxjq45e8ilak/3zTOtMpTyFdmP3vxsQ9xoc/40e5a0892609b16f822120813f5f0823/100554_1921552449_Adi_Shavit_Generators_coroutines_and_other_brain-unrolling_sweetness.pdf)*
Как понятно из названия, Роман рассмотрел работу с исключениями на примере LLVM. При этом для не использующих в своей работе Clang доклад всё равно может дать некоторое представление о том, как код потенциально может быть оптимизирован. Это так, потому что разработчики компиляторов и соответствующих стандартных библиотек общаются между собой и многие удачные решения могут совпадать.
Итак, для обработки исключения требуется сделать множество действий: вызвать код обработки (если есть) или освободить ресурсы на текущем уровне и раскрутить стек выше. Всё это ведёт к тому, что для потенциально выдающих исключения вызовов компилятор добавляет дополнительные инструкции. Поэтому если исключение по факту не будет вызвано, программа все равно станет выполнять ненужные действия. Для того, чтобы как-то снизить накладные расходы, в LLVM есть несколько эвристик определения ситуаций, где код обработки исключений добавлять не нужно или можно снизить количество «лишних» инструкций.
Докладчик рассматривает около десятка из них и показывает как ситуации, где они помогают ускорить исполнение программы, так и те, где данные методы не применимы.
Таким образом, Роман Русяев подводит слушателей к выводу, что код, содержащий работу с исключениями, далеко не всегда можно исполнять с нулевыми накладными расходами, и даёт следующие советы:
* при разработке библиотек стоит отказаться от исключений в принципе;
* если исключения всё же нужны, то по возможности везде стоит добавлять модификаторы noexcept (и const), чтобы компилятор мог соптимизировать как можно больше.
В целом, докладчик подтвердил мнение, что исключения лучше всего использовать по минимуму или вообще от них отказаться.
Слайды доклада доступны по ссылке: [[«Исключения C++ через призму компиляторных оптимизаций LLVM»]](https://assets.ctfassets.net/oxjq45e8ilak/6Q09SPvX2Rsveiayc1VkcC/ce9e2b8eb22d6693eb4c3b06968bedc0/100693_477384438_Roman_Rusyayev_Isklyucheniya_C_cherez_prizmu_kompilyatornykh_optimizatsiy.pdf)
### Generators, coroutines and other brain-unrolling sweetness, Adi Shavit
*Слайд из [презентации](https://assets.ctfassets.net/oxjq45e8ilak/3zTOtMpTyFdmP3vxsQ9xoc/40e5a0892609b16f822120813f5f0823/100554_1921552449_Adi_Shavit_Generators_coroutines_and_other_brain-unrolling_sweetness.pdf)*
Один из многих докладов этой конференции, посвящённых нововведениям C++20, запомнился не только красочно оформленной презентацией, но и чётким обозначением имеющихся проблем с логикой обработки коллекций (цикл for, callback-и).
Adi Shavit выделяет следующие: имеющиеся на данный момент методы проходят коллекцию целиком и при этом не дают доступа к некоторому внутреннему промежуточному состоянию (либо дают в случае callback-ов, но с большим количеством неприятных побочных эффектов, типа того же Callback Hell). Казалось бы, есть итераторы, но и с ними всё не так гладко: нет общих точки входа и выхода (begin → end против rbegin → rend и так далее), непонятно, сколько вообще мы будем итерироваться? Начиная с C++20 данные проблемы решаются!
Первый вариант: ranges. За счёт обёртки поверх итераторов мы получаем общий интерфейс для начала и конца итерации, а также получаем возможность композиции. Всё это позволяет легко строить полноценные конвейеры обработки данных. Но не всё так гладко: часть логики вычислений находится внутри реализации конкретного итератора, что может усложнить код для восприятия и отладки.
*Слайд из [презентации](https://assets.ctfassets.net/oxjq45e8ilak/3zTOtMpTyFdmP3vxsQ9xoc/40e5a0892609b16f822120813f5f0823/100554_1921552449_Adi_Shavit_Generators_coroutines_and_other_brain-unrolling_sweetness.pdf)*
Что же, на этот случай в C++20 добавлены корутины (функции, поведение которых похоже на генераторы в языке Python): исполнение можно отложить, вернув некоторое текущее значение с сохранением при этом промежуточного состояния. Таким образом, мы достигаем не только работы с данными по мере их появления, но и инкапсулируем всю логику внутри конкретной корутины.
Но есть ложка дёгтя: на данный момент они лишь частично поддерживаются имеющимися компиляторами, а также реализованы не так аккуратно, как хотелось бы: например, пока не стоит использовать в корутинах ссылки и временные объекты. Плюс, есть некоторые ограничения по тому, что может быть корутинами, и constexpr-функции, конструкторы/деструкторы, а также main в этот список не входят.
Таким образом, корутины решают заметную часть проблем с простотой логики обработки данных, но их текущие реализации требуют доработки.
Материалы:
* Слайды с C++ Russia — [[«Generators, coroutines and other brain-unrolling sweetness»]](https://assets.ctfassets.net/oxjq45e8ilak/3zTOtMpTyFdmP3vxsQ9xoc/40e5a0892609b16f822120813f5f0823/100554_1921552449_Adi_Shavit_Generators_coroutines_and_other_brain-unrolling_sweetness.pdf)
* [Видеозапись доклада с CppCon 2019](https://youtu.be/qYHDERleSL8)
### C++ трюки из Яндекс.Такси, Антон Полухин
В своей профессиональной деятельности иногда приходится реализовывать чисто вспомогательные штуки: обёртку между внутренним интерфейсом и API какой-то библиотеки, логирование или парсинг. При этом обычно нет необходимости в какой-то дополнительной оптимизации. Но что, если эти компоненты используются в одних из самых популярных в Рунете сервисах? В такой ситуации придётся обрабатывать терабайты в час одних только логов! Тогда каждая миллисекунда на счету и поэтому приходится прибегать к различным трюкам — о них и рассказывал Антон Полухин.
Пожалуй, самым интересным примером была реализация паттерна pointer-to-implementation (pimpl).
```
#include //PROBLEMS!
struct Value {
Value() = default;
Value(Value&& other) = default;
Value& operator=(Value&& other) = default;
~Value() = default;
std::size\_t Size() const { return data\_.size(); }
private:
third\_party::Json data\_;
};
```
В данном примере сначала хочется избавиться от заголовочных файлов внешних библиотек — так и компилироваться будет быстрее, и можно обезопасить себя от возможных конфликтов имён и других подобных ошибок.
Хорошо, перенесли #include в .cpp-файл: нужен forward-declaration обёрнутого API, а также std::unique\_ptr. Теперь у нас динамические аллокации и другие неприятные вещи вроде раскиданных по куче данных и сниженных гарантий. Со всем этим может помочь std::aligned\_storage.
```
struct Value {
// ...
private:
using JsonNative = third_party::Json;
const JsonNative* Ptr() const noexcept;
JsonNative* Ptr() noexcept;
constexpr std::size_t kImplSize = 32;
constexpr std::size_t kImplAlign = 8;
std::aligned_storage_t data\_;
};
```
Единственная проблема: нужно для каждой обёртки прописывать размер и выравнивание — сделаем наш pimpl шаблонным с параметрами , используем с какими-нибудь произвольными значения и добавим в деструктор проверку, что мы всё угадали:
```
~FastPimpl() noexcept {
validate();
Ptr()->~T();
}
template
static void validate() noexcept {
static\_assert(
Size == ActualSize,
"Size and sizeof(T) mismatch"
);
static\_assert(
Alignment == ActualAlignment,
"Alignment and alignof(T) mismatch"
);
}
```
Так как при обработке деструктора T уже определён, данный код будет разбираться корректно и на стадии компиляции в виде ошибок выведет нужные значения размера и выравнивания, которые нужно вписать. Таким образом, ценой одного дополнительного запуска компиляции мы избавляемся от динамической аллокации оборачиваемых классов, прячем API в .cpp-файл с реализацией, а также получаем более пригодную для кеширования процессором конструкцию.
Логирование и парсинг показались менее впечатляющими, а поэтому в данном обзоре упомянуты не будут.
Слайды доклада доступны по ссылке: [[«C++ трюки из Такси»]](https://assets.ctfassets.net/oxjq45e8ilak/4rkoaQV6ancsfvzYx1fOCF/087dda7d63101cc225d706d03d7c5075/100566_2093066332_Anton_Polukhin_C_tryuki_iz_Taksi.pdf)
### Modern techniques for keeping your code DRY, Björn Fahller
В этом докладе Björn Fahller показывает несколько различных способов борьбы с таким стилистическим недочётом, как повторяющиеся проверки условий:
```
assert(a == IDLE || a == CONNECTED || a == DISCONNECTED);
```
Знакомо? Используя несколько мощных техник С++, появившихся в недавних стандартах, можно изящно реализовать ту же функциональность без малейших потерь производительности. Сравните:
```
assert(a == any_of(IDLE, CONNECTED, DISCONNECTED));
```
Для обработки нефиксированного числа проверок сразу просится использовать variadic templates и fold expressions. Предположим, что мы хотим проверить равенство нескольких переменных элементу enum’a state\_type. Первое, что приходит на ум – написать вспомогательную функцию is\_any\_of:
```
enum state_type { IDLE, CONNECTED, DISCONNECTED };
template
bool is\_any\_of(state\_type s, const Ts& ... ts) {
return ((s == ts) || ...);
}
```
Такой промежуточный результат вызывает разочарование. Пока что код читаемее не становится:
```
assert(is_any_of(state, IDLE, DISCONNECTING, DISCONNECTED));
```
Немного поправить ситуацию помогут non-type template parameters. С их помощью перенесём перечисляемые элементы enum’a в список параметров шаблона:
```
template
bool is\_any\_of(state\_type t) {
return ((t == states) | ...);
}
assert(is\_any\_of(state));
```
С использованием auto в не типовом параметре шаблона (C++17), подход просто обобщается на сравнения не только с элементами state\_type, но и с примитивными типами, которые можно использовать в качестве non-type template parameters:
```
template
bool is\_any\_of(const T& t) {
return ((t == alternatives) | ...);
}
```
Путём таких последовательных улучшений достигается желаемый беглый синтаксис для проверок:
```
template
struct any\_of : private std::tuple {
// поленимся и унаследуем конструкторы от tuple
using std::tuple::tuple;
template
bool operator ==(const T& t) const {
return std::apply(
[&t](const auto& ... ts) {
return ((ts == t) || ...);
},
static\_cast&>(\*this));
}
};
template
any\_of(Ts ...) -> any\_of;
assert(any\_of(IDLE, DISCONNECTING, DISCONNECTED) == state);
```
В этом примере deduction guide служит для подсказки желаемых шаблонных параметров структуры компилятору, знающему типы аргументов конструктора.
Дальше – интереснее. Бьорн учит обобщать получившийся код для операторов сравнения помимо ==, а затем и для произвольных операций. Попутно на примере использования объясняются такие фичи как no\_unique\_address attribute (C++20) и шаблонные параметры в лямбда-функциях (C++20). (Да, теперь синтакс лямбд ещё легче запомнить – это четыре последовательные пары скобок всех сортов.) Итоговое решение с использованием функций как деталек конструктора лично мне очень греет душу, не говоря уже о выражении tuple в лучших традициях лямбда-исчисления.
В конце не забываем навести лоск:
* Вспомним, что лямбды – constexpr за бесплатно;
* Добавим perfect forwarding и посмотрим на его уродливый синтакс применительно к parameter pack в замыкании лямбд;
* Дадим компилятору больше возможностей для оптимизаций с conditional noexcept;
* Позаботимся о более понятном выводе ошибок в шаблонах благодаря явным возвращаемым значениям лямбд. Это заставит компилятор делать больше проверок до собственно вызова шаблонной функции – на стадии проверки типов.
За подробностями обращайтесь к материалам лекции:
* Слайды доклада: [[Modern Techniques for Keeping Your Code DRY]](https://assets.ctfassets.net/oxjq45e8ilak/7lP3ueTFEJnmdVjGGjrgHI/e30dfcbff0630fb63389f3f3e734a1a3/100644_2039674689_Bjrn_Fahller_Modern_techniques_for_keeping_your_code_dry.pdf)
* [Исходный код на github](https://github.com/rollbear/dry-comparisons)
* [Авторская статья в блоге](https://playfulprogramming.blogspot.com/2018/07/dry-multicomparisons.html)
Наши впечатления
----------------
Наше первое участие в C++ Russia запомнилось своей насыщенностью. Сложилось впечатление о С++ Russia как о душевном мероприятии, где грань между обучением и живым общением почти не ощутима. Всё, от настроя докладчиков до конкурсов от партнёров мероприятия, располагает к бурным обсуждениям. Содержательная часть конференции, заключающаяся в докладах, охватывает довольно широкий спектр тем включая нововведения С++, примеры из практики крупных проектов и идеологические архитектурные соображения. Но было бы несправедливо обделить вниманием и социальную составляющую мероприятия, способствующую преодолению языковых барьеров в отношении не только С++.
Благодарим организаторов конференции за возможность поучаствовать в таком событии!
Пост организаторов о прошлом, настоящем и будущем C++ Russia вы могли видеть [в блоге JUG Ru](https://habr.com/ru/company/jugru/blog/480584/).
Спасибо за прочтение, и надеемся, что наш пересказ событий оказался полезным! | https://habr.com/ru/post/481358/ | null | ru | null |
# Пишем свои монады на Scala на примере CSV-парсера
За последнее время мы очень многое узнали о монадах. Мы уже разобрались [что это такое](https://habrahabr.ru/post/209510/) и даже знаем [как их можно нарисовать](https://habrahabr.ru/post/183150/), видели [доклады](https://www.youtube.com/watch?v=YCOSAazIi2Q), объясняющие их предназначение. Вот и я решил заскочить в уходящий монадный поезд и написать по этой теме, пока это окончательно не стало мейнстримом. Но я зайду с немного другой стороны: здесь не будет выкладок из теории категорий, не будет вставок на *самом-лучшем-языке*, и даже не будет scalaz/shapeless и библиотеки parser-combinators. Как известно, лучший способ разобраться как что-то устроено — сделать это самому. Сегодня мы с вами будем писать свою монаду.
Задача
======
Возьмем для примера банальную задачу: парсинг CSV-файла. Допустим нам требуется распарсить строки файла в case classes, чтобы потом отправить их в базу, сериализовать в json/protobuf и так далее. Забудем про escaping и кавычки, для еще большей простоты, считаем что символ разделителя в полях встречаться не может. Думаю, если кто-то решит затащить это решение в свой проект, докрутить эту фичу будет не трудно.
Допустим у нас есть следующий CSV файл:
```
1997;Ford;E350;ac, abs, moon;3000.00
1996; Jeep; Grand Cherokee; MUST SELL! air, moon roof, loaded; 4799.00
1999;Chevy;Venture "Extended Edition"; ; 4900.00
```
Нам нужно десериализовать его в набор объектов следующего типа:
```
case class Car(year: Int, mark: String, model: String, comment: String, price: BigDecimal)
```
Очевидный подход
================
Чтобы было с чем сравнивать, я должен привести пример из жизни, который использование монад делает нагляднее, приятнее, надежнее и т.п.
Допустим файл строкой уже загружен в переменную `content`:
```
val lines = content.split('\n')
val entities =
lines.map { line =>
line.split(';').map(_.trim) match {
case Array(year, mark, model, comment, price) =>
Car(year.toInt, mark, model, comment, BigDecimal(price))
}
}.toSeq
```
Минусы подхода:
---------------
* Смешивание логики конвертации типов полей и конструирования самой сущности.
* Boilerplate case matching: при росте числа полей код будет стремительно утрачивать читаемость.
* Нужно явно обрабатывать случаи когда число полей не соответствует ожидаемому, когда строка слишком длинная и т.п.
Плюсы:
------
* Straight-forward: отсутствие дополнительных слоев абстракции.
Монадический парсер
===================
Я предлагаю взглянуть на задачу с другой стороны.
* Представим что в начале мы имеем один фрагмент сырых данных — в частном случае — строку из файла, хотя на самом деле нам это не важно: это может быть byte array, список слов, итератор, все что угодно, из чего мы можем получать данные.
* Допустим что каждую запись мы парсим в несколько этапов, каждый из которых — это парсинг конкретного поля в записи. Тогда для каждого этапа мы можем зафиксировать результат: значение этого поля (далее **слово**) + остаток сырых данных (далее **остаток**), которые мы будем рассматривать на последующих этапах парсинга, извлекая из него следующие поля записи. Или не будем, если поле последнее.
Далее, для краткости будем называть эту функцию "**обработчик**".
* Тогда в итоге нам останется только совместить результаты этих этапов в конечную сущность.
Возвращаясь к коду, обработчик каждого этапа иметь объявление вроде:
```
def parse[T, Src]: Src => (T, Src)
```
Теперь немного о самих монадах.
В двух словах монаду можно описать как контейнер, содержащий значение + некий контекст.
Синтаксически, в случае со Скалой, это значит что монада должна иметь метод flatMap, в общем случае объявляемый как:
```
def flatMap[T](f: T => M[T]): M[T]
```
Если f — значение, хранимое в контейнере, то что же такое контекст? А вот что: хотя у f только один аргумент, но, поскольку мы можем вызывать изнутри одного flatMap'a другой flatMap, то из внутреннего flatMap нам будут доступны все значения, объявленные внутри внешнего, то есть в том числе и все предыдущие слова.
Обратите внимание, что реализовывать метод map от монады не требуется, но мы его все-таки определим, он пригодится нам для создания модифицированных парсеров из уже определенных.
Также нужно определить операцию заворачивания чистого значения в монаду. Это не метод класса, но это может быть вызов конструктора, либо метод apply у companion object'а, никакого строгого требования к этому нет, и я предлагаю для удобства определить метод apply.
Реализуем монаду, содержащую в себе функцию parse, такого вида как мы определили выше и посмотрим, как мы сможем с ее помощью комбинировать разные парсеры.
Итак нам нужно написать класс, инкапсулирующий парсинг поля конкретного типа, который:
1. Реализует метод flatMap
2. Реализует метод map
3. Также нужно определить операцию apply у companion object'a.
4. Нужно определить интерфейсный метод, который будет вызываться конечным клиентским кодом и не будет содержать лишних деталей в объявлении.
```
class Parser[T, Src](private val p: Src => (T, Src)) {
def flatMap[M](f: T => Parser[M, Src]): Parser[M, Src] =
Parser { src =>
val (word, rest) = p(src)
f(word).p(rest)
}
def map[M](f: T => M): Parser[M, Src] =
Parser { src =>
val (word, rest) = p(src)
(f(word), rest)
}
def parse(src: Src): T = p(src)._1
}
```
Так что-же происходит в методе **flatMap**?
Мы применяем обработчик текущего парсера к входному значению, затем с помощью функции — аргумента метода добавляем его в контекст, видимый всем последующим парсерам по цепочке.
С методом **map** же все намного понятнее, мы просто применяем его аргумент — функцию f на текущее слово, а все остальное оставляем неизменным.
И companion object, содержащий операцию point, она же — метод apply, он же — вызов объекта с круглыми скобками:
```
object Parser {
def apply[T, Src](f: Src => (T, Src)) =
new Parser[T, Src](f)
}
```
Применение
==========
И что? Какие преимущества нам предоставляет этот подход, кроме несомненного повышения вашего авторитета у незнакомых с монадами коллег? Сейчас увидим.
Используя предложенную выше абстракцию, наконец напишем наш инновационный, функциональный, типобезопасный CSV-парсер.
Пишем парсеры типов полей
-------------------------
Для начала реализуем парсер одного поля типа String.
```
def StringField =
Parser[String, String] { str =>
val idx = str.indexOf(separator)
if (idx > -1)
(str.substring(0, idx), str.substring(idx + 1))
else
(str, "")
}
```
Ничего сложного, правда?
А теперь посмотрим, как можно на базе StringField определить парсер типа Int.
Еще проще!
```
def IntField = StringField.map(_.toInt)
```
Аналогично для всего остального:
```
def BigDecimalField = StringField.map(BigDecimal(_))
def IntField = StringField.map(_.toInt)
def BooleanField = StringField.map(_.toBoolean)
// все что еще вам нужно
```
Собираем все воедино
--------------------
До сих пор мы рассмотрели только парсеры отдельных полей, но как нам собрать эти поля в единую сущность? Вот тут нам и придет на помощь тот самый *контекст*. Благодаря ему, мы можем использовать в нижележащих парсерах значения, полученные в вышележащих.
Итак, конструирование конечного парсер сущностей будет выглядеть так:
```
val parser =
for {
year <- IntField
mark <- StringField
model <- StringField
comment <- StringField
price <- BigDecimalField
} yield Car(year, mark, model, comment, price)
```
По моему выглядит очень круто.
Если вы вдруг не полностью уверенно себя чувствуете с синтаксическим сахаром for comprehension, то вот примерно так это бы выглядело в виде цепочки flatMap'ов:
```
IntField.flatMap { year =>
StringField.flatMap { mark =>
StringField.flatMap { model =>
StringField.flatMap { comment =>
BigDecimalField.map { price =>
Car(year, mark, model, comment, price)
}
}
}
}
}
```
Выглядит, конечно, это немного хуже, зато становится очевидно о каких контекстах идет речь, это области видимости, ограниченные фигурными скобками.
Мы получили парсер parser, теперь все что нам нужно, это построчно скормить исходный файл его методу parse и получить результат. Например так:
```
val result = str.split('\n').map(parser.parse)
```
Результат:
```
Array(Car(1997,Ford,E350,ac, abs, moon,3000.00), Car(1996,Jeep,Grand Cherokee,MUST SELL! air, moon roof, loaded,4799.00), Car(1999,Chevy,Venture "Extended Edition",,4900.00))
```
Плюсы
-----
* Конечный парсер описывается красиво и лаконично, из его объявления легко понять типы и последовательность полей в файле, его легко изменять и тестировать.
* Вы крутой специалист, знающий толк в ФП, могущий в монады и вообще самый модный ~~на районе~~ в опенспейсе.
Минусы
------
* Наличие генерализованной сущности с не самой очевидной логикой, особенно для тех, кто не очень хорош в этих ваших монадах, либо недавно перешедших с джавы.
Резюме
======
Монады и прочие категории в Скале — не что-то такое без чего нельзя жить. Более того, они практически никак не навязываются самим языком. По сути, монадность в Скале — это небольшой ad-hoc контракт, выполняя который вы получаете возможность использовать свои классы в for-comprehension. И на этом все.
Тем не менее гибкость языка и возможность довольно легко реализовывать на нем довольно хитрые конструкции — это безусловный плюс языка, развязывающий руки для экспериментов.
Насчет того, стоит ли использовать такого рода конструкции в продакшн коде: я не знаю, это выбор каждой отдельной команды. Наверное, я бы сначала постарался выделять их в отдельные библиотеки, покрывать тестами и всячески обкатывать (хотя мы конечно знаем, что у настоящих функциональщиков все работает и без тестов). А для логики, которая нужна здесь и сейчас, скорее использовал бы более straight-forward реализации. | https://habr.com/ru/post/326002/ | null | ru | null |
# Назад в будущее – Декапсуляция
При работе программных модулей, хранящих в оперативной памяти большое количество данных, способ их хранения оказывает сильное влияние на потребление памяти и быстродействие. Один из способов ускорения системы и экономии ресурсов может заключаться в использовании более примитивных структур данных – структур вместо классов и примитивных типов вместо структур. Конечно, такой подход ломает ООП и возвращает к использованию «старых» методов программирования. Однако, в некоторых случаях такая примитизация может решить множество проблем. Простой тест показал возможность сокращения потребляемой памяти более чем в три раза.
Затрагиваемые вопросы:
* Влияние программной архитектуры на потребление памяти и производительность;
* Различия при работе в 32 и 64 битных режимах;
* Различия между указателями и индексами массива;
* Влияние выравнивания данных внутри классов/структур;
* Влияние кеша процессора на производительность;
* Оценка стоимости поддержки ООП в языках высокого уровня;
* Признание факта необходимости учитывать низкоуровневые особенности платформы даже при разработке на языках высокого уровня.
Практическая задача
===================
Впервые данную методику я применил при разработке поиска оптимального пути для портала [www.GoMap.Az](http://www.GoMap.Az). Новый алгоритм использовал больше оперативной памяти и при установке на тестовый сервер приложение начинало серьезно заедать. Обновление железа в данном случае требовало нескольких дней, а ее решение оптимизацией структур данных позволило быстро решить проблему. Чтобы поделиться полученным опытом я решил в простой форме описать что было сделано и какие преимущества были получены.
Организация хранения большого количества структур данных и доступа к ним является неотъемлемой задачей для информационных систем работающих с картографическими данными. Подобные проблемы все чаще возникают также при создании других типов современных информационных систем.
Рассмотрим хранение данных и доступ к ним на примере дорог – рёбер графа. В упрощенном виде дорога может быть представлена классом Road, тогда как хранилище дорог классом RoadsContainer. Кроме того, имеется класс узла сети Node. Касательно Node – нам нужно просто знать что это — класс. Примем во внимание, что наши структуры данных не содержат методов и не участвуют в наследовании и т.п., то есть используются только для хранения и манипуляции с данными.
Мы будем рассматривать реальзацию метода на языке C#, хотя изначально она была применена на С++. Строго говоря проблема и ее решение находится несколько в области системного программирования. Однако, данное исследование также показывает насколько высокими могут быть затраты на поддержку ООП в высокоуровневом программировании. C# может лучшим способом показать эти скрытые затраты, не являясь языком системного программирования.
```
// Основная структура данных – класс Road
public class Road
{
public float Length;
public byte Lines ;
// Где-то описан класс Node и Road ссылается
// на два объекта этого класса
public Node NodeFrom;
public Node NodeTo;
// Другие члены класса
}
// Контейнер структур данных дорог
public class RoadsContainer
{
// Другие члены класса
// Выдача дорог, находящихся в указанном прямоугольнике
public Road[] getRoads(float X1, float Y1, float X1, float Y1)
{
// Реализация
}
// Другие члены класса
}
```
Память и производительность
===========================
При оценке потребляемой памяти и производительности следует учесть влияние особенностей архитектуры платформы, включая:
* ***Выравнивание данных***. Выравнивание данных производится для правильного и быстрого доступа центрального процессора к ячейкам памяти. В зависимости от разрядности системы расположение классов/структур в памяти может начинаться с адресов кратных 32 или 64 битам. Внутри самих классов/структур поля также могут выравниваться по границе 32, 16 или 8 бит (например, поле Lines класса Road может занять в памяти не 1 байт, а 4). При этом возникают неиспользуемые пространства памяти, что увеличивает ее потери.;
* ***Кеш процессора***. Как известно задача кеша – ускорить доступ к наиболее часто используемым ячейкам памяти. Размер кеша очень мал, так как это самая дорогая память. При обработке классов/структур неиспользуемые пространства памяти, возникшие в результате выравнивания данных также попадают в кеш процессора и засоряют его, так как не несут полезной информации. Как результат – снижение эффективности кеширования.;
* ***Размер указателей***. В 32-битных системах указатель на объект в памяти также обычно 32-битный, что ограничивает возможности работы с оперативной памятью более 4Гб. 64- разрядные системы позволяют адресовать существенно большие объемы памяти, но используют 64-битные указатели. Объекты всегда имеют указатели на них (в противном случае это будет потеряная память или объект для удаления сборщиком мусора). В нашем примере поля NodeFrom и NodeTo в классе Road будут занимать по 8 байт каждый в 64-битной системе и по 4 байта в 32-битной.
Обычно компиляторы стараются создать наиболее эффективный код, однако достичь существенной эффективности выполнения можно только программно-архитектурными решениями.
Массивы объектов
================
Данные могут храниться в различных контейнерах – списках, хеш таблицах, и т.п. Хранение в виде массива возможно самый простой и понятный способ, поэтому остановимся на рассмотрении этого способа. Другие контейнеры могут быть анализированы аналогично.
В C# массивы объектов в реальности хранят ссылки на объекты, в то время как каждый объект занимает свое отдельное адресное пространство в куче. В этом случае, очень удобно манипулировать наборами объектов, так как в действительности приходится работать с указателями, а не с объектами целиком. Например, в нашеи примере функция getRoads класса RoadsContainer передает набор определенных объектов класса Road – не копиями объектов, а ссылками. Такое поведение возникает ввиду того что объекты в C# — это ссылочные типы данных.
Недостатки хранения данных в виде массивов объектов – это прежде всего затраты на хранение самих указателей и выравнивание объектов в куче. В 64-разрядных системах каждый указатель забирает 8 байт памяти и каждый объект выравнивается по адресу кратному 8 байтам.
Массивы структур
================
Классы хранения дорог и узлов сети могут быть преобразованы в структуры (как было упомянуто в нашем примере на это нет ограничений со стороны ООП). Вместо указателей на них могут быть использованы целочисленные индексы. Код, который при этом получится может иметь вид:
```
public struct Road
{
public float Length;
byte Lines ;
Int32 NodeFrom;
Int32 NodeTo;
// Другие поля
}
public class RoadsContainer
{
// Другие члены класса
// Дороги будем хранить в массиве, а не в куче
Road[] Roads;
// Выдача дорог, находящихся в указанном прямоугольнике
public Int32[] getRoads(float X1, float Y1, float X1, float Y1)
{
// Реализация
}
// Выдача дороги по индексу
public Road getRoad(Int32 Index)
{
return Roads[Index];
}
// Другие члены класса
}
// По аналогии с хранилищем дорог
// устроено хранилище узлов
public class NodesContainer
{
// Другие члены класса
Node []Nodes;
// Выдача узла по индексу
public Node getNode (Int32 Index)
{
return Nodes[Index];
}
// Другие члены класса
}
```
Что нам это дало? Рассмотрим подробно.
Структуры данных дорог хранятся уже как программные структуры ( structs в C# ), а не как объекты. Для их хранения использован массив Roads в классе RoadsContainer. Для доступа к отдельным структурам используется функция getRoad того же класса. 32-битный целочисленный индекс принимает на себя роль указателя на структуру данных определенной дороги. Таким же образом преобразованы узлы и представлен фрагмент класса-хранилища узлов NodesContainer.
Использование 32-разрядного индекса вместо 64-разрядного указателя облегчает как используемую им память так и операции манипулирования им. Использование индексов для ссылки на узлы NodeFrom и NodeTo в структуре Road сокращает размер потребляемой ею памяти на 8 байт ( при выравнивании в 32, 16, или 8 бит ).
Выделение памяти ( посредством вызова оператора new ) для хранения дорог происходит за один раз. При этом резервируется только массив структур Road в котором все структуры создаются за раз. В случае хранения ссылок на объекты каждый объект должен создаваться отдельно. На создание отдельного объекта не только уходит время, но также расходуется некоторый объем служебной памяти на выравнивание, регистрирование объекта в куче и системе сбора мусора.
Недостаток использования структур вместо объектов — это строго говоря невозможность использования указателей на структуру ( структура – это тип «по значению», а класс тип «по ссылке» ). Данный факт приводит к ограничению возможности манипулировать наборами объектов. Ввиду этого, функция getRoads класса RoadsContainer теперь возвращает индексы соответствющих структур в массиве. При этом получить саму структуру можно функцией getRoad. Однако, данная функция приведет к копированию возвращаемой структуры целиком, что приведет к расходу памяти и времени процессора.
Массивы данных примитивных типов
================================
Массивы структур могут быть преобразованы в отдельные массивы полей этой структуры. Иными словами, структуры могут быть декапсулированы и упразднены. К примеру после декапсуляции и упразднения структуры Road мы получим следующий код:
```
public class RoadsContainer
{
// Другие члены класса
// Поля структуры данных Road
float[] Lengths;
byte[] Lines;
Int32[] NodesFrom;
Int32[] NodesTo;
// Другие члены класса
// Выдача дорог, находящихся в указанном прямоугольнике
public Int32[] getRoads(float X1, float Y1, float X1, float Y1)
{
// Реализация
}
// Выдача длины дороги по индексу
public float getRoadLengt(Int32 Index)
{
return Lengths[Index];
}
// Выдача количества полос дороги по индексу
public byte getRoadLines(Int32 Index)
{
return Lines[Index];
}
// Выдача начального узла дороги по индексу
public Int32 getRoadNodeFrom(Int32 Index)
{
return NodesFrom[Index];
}
// Выдача конечного узла дороги по индексу
public Int32 getRoadNodeTo(Int32 Index)
{
return NodesTo[Index];
}
// Другие члены класса
}
```
Что мы получили? Рассмотрим подробно.
Вместо хранения программных структур в одном массиве, поля этой структуры хранятся по отдельности в разных массивах. Доступ к полям также производится раздельно по индексу.
Пустой расход памяти на выравнивание полей внутри структуры устраняется, так как поля структуры примитивных типов хранятся вплотную друг к другу. Память запрашивается у системы не одним большим куском для хранения всех структур сразу, а несколькими кусками для хранения массивов полей соответственно. В некотором смысле такое разбиение полезно, так как системе часто легче предоставить несколько относительно небольших непрерывных участков памяти, чем один большой непрерывный участок.
Доступ к каждому полю каждый раз требует использование индекса, в то время как для доступа к струтуре целиком требуется использование индекса только один раз. В реальности данная особенность может рассматриваться и как недостаток и как преимущество. Дело в том, что при обращении только к части полей, например только трем полям Lengths, NodesFrom и NodesTo структуры Road в случае их расположения в отдельных массивах можно получить более оптимальное использование кеша процессора. Использование всех преимуществ кеша зависит от алгоритма доступа к данным, но в любом случае выигрыш может быть заметным.
Сборка мусора и управление памятью
==================================
Рассматриваемая проблема относится к технологиям управления памятью. Ведь именно от расположения объектов в памяти в первую очередь зависит скорость доступа к ним. В настоящее время имеется огромное количество способов организации управления памятью, включая системы автоматической сборки мусора. Эти автоматические системы не только следят за чисткой памяти, но и проводят дефрагментацию ( подобно файловой системе ).
Системы управления памяти в основном работают с указателями на объекты, расположенные в куче. В случае использования массивов структур или полей системы управления памяти не смогут работать с элементами этих массивов и вся работа по их созданию и уничтожению ляжет на плечи программиста. Таким образом, использование массивов структур или полей в определенном смысле деактивирует сборщика мусора для них. Это ограничение в зависимости от задачи может рассматриваться как преимущество (если требуется экономия ресурсов) или как недостаток (если требуется упрощение кола и труда программиста).
Замеры
======
Как видно наиболее расточительным для хранения является массив объектов. При этом на 64-битной системе издержки на хранение резко возрастают. Хранение в виде массивов структур или полей в целом одинаково затратно для 32 и 64-битного режима. Хранение в виде полей имеет некоторый выигрыш в размере занимаемой памяти, однако этот выигрыш не критический. Этот выигрыш включает издержки выравнивания данных внутри структур.
Память
------
Занимаемая память, 32 битный режим
Занимаемая память, 64 битный режим
Как видно наиболее расточительным для хранения является массив объектов. При этом на 64-битной системе издержки на хранение резко возрастают. Хранение в виде массивов структур или полей в целом одинаково затратно для 32 и 64-битного режима. Хранение в виде полей имеет некоторый выигрыш в размере занимаемой памяти, однако этот выигрыш не критический. Этот выигрыш включает издержки выравнивания данных внутри структур.
Время доступа
-------------
Примечания:
\* — число слишком мало в сравнении с точностью теста.
Время доступа к структурам данных при хранении в массиве объектов показывает самые высокие затраты времени. Также наблюдается более быстрый доступ к полям в случае их расположения в отдельных массивах. Это ускорение является результатом более эффективного использования кеша процессора. Следует упомянуть что в тесте доступ осуществляется последовательным перебором элементов массива и в этом случае использование кеша близко к оптимальному.
Итоги
=====
Этот небольшой обзор позволяет создать представление о проблеме и сделать первые выводы:
* Отказ от использования ООП в работе с большими объемами данных может привести к 3-х кратной экономии оперативной памяти на 64-битных системах и 2-х кратной экономии на 32-битных системах. Данная проблема возникает из-за особенностей аппаратной архитектуры, поэтому в той или иной степени она актуальна для всех языков программирования.
* Время доступа в С# к структурам данных посредством индекса массива существенно меньше времени доступа посредством указателя.
* Повышение уровня технологии программирования требует затрат ресурсов. Низкий уровень ( системный ) и работа с примитивными данными ( получаемыми после декапсуляции классов/структур ) использует меньше всего ресурсов, но требуют больше строк исходного кода и времени программиста.
* Переход к работе с примитивными типами является этапом оптимизации кода. Поэтому такая архитектура может быть использована не как начальный дизайн, а как меры в случае необходимости сокращать потребление ресурсов.
* В C++ многие описанные проблемы могут быть решены прозрачно, в то время как в C# многое скрыто в ниже-лежащей реализации. Помимо того при изучении C# влияние платформы рассматривается далеко не на первых порах.
* При разработке в C# там где это возможно, нужно использовать структуры, а не классы.
Ссылки:
=======
[Исходники тестов на GitHub](https://github.com/dgakh/Studies/tree/master/CSharp/Decapsulation)
[Пример успешного коммерческого использования методики — портал GoMap.Az](http://www.GoMap.Az)
[Разница между структурами и объектами (MSDN)](https://msdn.microsoft.com/en-us/library/aa664655%28v=vs.71%29.aspx)
[Хорошая статья о структурах «Mastering C# structs»](http://www.developerfusion.com/article/84519/mastering-structs-in-c/)
[Статья на похожую проблематику «Храним 300 миллионов объектов в CLR процессе»](http://habrahabr.ru/post/257091/) | https://habr.com/ru/post/264063/ | null | ru | null |
# Разработка на ассемблере в Linux
Вообще программирование на ассемблере в Linux мало распространено и занимаются им, разве что, фанаты ассемблера. Сегодня мы и поговорим о программировании на ассемблере и инструментарий.Что нам понадобится:
* FASM. Берем на flatassembler.net версию для Linux
* ald. Берем на ald.sourceforge.net
* shed. Берем на shed.sourceforge.net
* ld. Есть в большинстве дистрибутивов
Собственно каждый для себя выбирает инструменты сам. Я выбрал для себя эти.
#### Установка FASM
После загрузки архива с офф. сайта распакуем его:
`tar zxvf fasm-1.69.11.tgz`
В папке у нас будет бинарный файл fasm, который мы можем использовать для компиляции. Для удобства вы можете создать симлинк на него:
`sudo ln -s /home/username/fasm/fasm /usr/local/bin`
ald и shed устанавливаются не сложнее:
`$ ./configure
$ make
# make install`
В итоге у нас будет 3 полезных инструмента для программирования на ассемблере.
#### Системные вызовы
Как и большинство других операционных систем, Linux предоставляет т.н. API — набор полезных для программиста функций. В большинстве случаев вызов системной функции производится с помощью прерывания 80h. Следует отметить, что Linux используется fastcall-конвенция передачи параметров. Согласно ей параметры передаются через регистры (в windows, например, используется stdcall, где параметры передаются через стек). Номер вызываемой функции кладется в eax, а параметры в регистры:
Номер параметра / Регистр
1 / ebx
2 / ecx
3 / edx
4 / esi
5 / edi
6 / ebp
Как видите все не так сложно. Узнать номер системной функции, ее описание и параметры можно, хотя бы [здесь](http://www.unusedino.de/linuxassembly/syscall.html). Возьмем, к примеру `sys_exit`. Как можно увидеть на той странице у нее есть один параметр — код возврата и она имеет порядковый номер 1. Таким образом мы можем вызвать ее следующим кодом:
`mov eax, 1 ; 1 - номер системной функции
sub ebx, ebx ; Обнуляем регистр (можно было записать mov ebx, 0)
int 80h ; Вызываем прерывание 80h`
Надеюсь, что все понятно.
#### Hello, World!
Ну что же. Писать мы ничего не будем, т.к. за нас все написано :) В папке `fasm/examples/elfexe` есть файл hello.asm, в котором находится следующий код:
`; fasm demonstration of writing simple ELF executable
format ELF executable 3
entry start
segment readable executable
start:
mov eax,4
mov ebx,1
mov ecx,msg
mov edx,msg_size
int 0x80
mov eax,1
xor ebx,ebx
int 0x80
segment readable writeable
msg db 'Hello world!',0xA
msg_size = $-msg`
Как видите здесь вызываются 2 системных функции — `sys_write` (с порядковым номером 4) и `sys_exit`. `sys_write` принимает 3 параметра — дескриптор потока вывода (1 — stdout), указатель на строку и размер строки. Сам номер функции, как уже говорилось, мы должны положить в eax. Функцию `sys_exit` мы уже разобрали. Скомпилировать это чудо можно так: `fasm hello.asm` (но не обязательно, т.к. там же, где лежит исходник, есть и бинарник).
#### Посмотрим, что внутри
Думаю, что самое время заглянуть в наш бинарник. Для начала воспользуемся шестнадцатеричным редактором, чтобы посмотреть что у нас получилось. Выполним команду:
`shed hello`
Мы видим всю нашу программу, данные, elf-заголовок. Неплохо? Теперь мы посмотрим на нашу программу в отладчике. Наберем в консоли:
`ald hello`
Нас должна поприветствовать строка с предложением ввести команду. Список команд вы можете узнать, набрав `help` или получить помощь по отдельной команде, набрав `help command`. Дизассемблировать нашу программу можно командой `disassemble` (или ее алиас — "`d`"). Вы увидете дизассемблированный листинг вашей программы. Слева — адрес, справа — сама команда, а посередине — опкод команды.
Получить дамп можно командой `dump` (странно, но ее нет в выводе команды `help`).
Теперь попробуем поработать с командой `next`. Выполните ее и в ответ вам покажут значения регистров, установленные флаги, а так же адрес, опкод и дизассемблированную команду, которая должна выполниться следующей. Попробуйте выполнять команды и следите за изменением флагов и регистров. После вызова первого прерывания у вас на экране должна появиться надпись «Hello world!».
Целью данной статьи было показать основы программирования на ассемблере в linux, а не программирования на ассемблере в общем. Надеюсь, что вы подчерпнули для себя что-то полезное от сюда.
PS. Первая статья на хабре.
#### Полезные ссылки
[asm.sourceforge.net](http://asm.sourceforge.net/)
[www.int80h.org](http://www.int80h.org/) | https://habr.com/ru/post/79454/ | null | ru | null |
# Учебник по симулятору сети ns-3. Глава 6
[главы 1,2](https://habr.com/ru/post/497106/)
[глава 3](https://habr.com/ru/post/497318/)
[глава 4](https://habr.com/ru/post/497478/)
[глава 5](https://habr.com/ru/post/498372/)
Глава 6 Строим топологии
6.1 Построение топологии шинной сети
6.2 Модели, атрибуты и реальность
6.3 Построение топологии беспроводной сети
6.4 Очереди в ns-3
6.4.1 Модели очередей доступные в ns-3
6.4.2 Изменение настроек по умолчанию
Глава 6
-------
Строим топологии
----------------
### 6.1 Построение топологии шинной сети
В этом разделе мы собираемся расширить наши знания по сетевым устройствам и каналам ns‑3, чтобы охватить пример шинной сети. Ns‑3 предоставляет сетевое устройство и канал, который мы называем CSMA (множественный доступ с контролем несущей).
Устройство CSMA в ns‑3 моделирует простую сеть в духе Ethernet. Настоящий Ethernet использует CSMA/CD (множественный доступ с контролем несущей и обнаружением коллизий) с экспоненциально нарастающей конкуренцией за общую среду передачи. Устройство и канал CSMA ns‑3 моделируют это только отчасти.
Подобно тому, как мы использовали вспомогательные объекты при построении топологий точка-точка, в этом разделе мы увидим аналогичных помощников для топологии CSMA. Внешний вид и работа этих помощников должны выглядеть вам вполне знакомо.
В нашей директории examples/tutorial мы предоставляем пример сценария. Этот скрипт основан на сценарии first.cc и добавляет сеть CSMA к симуляции точка-точка, которую мы уже рассмотрели. Откройте *examples/tutorial/second.cc* в вашем любимом редакторе. Вы уже видели достаточно кода ns‑3, чтобы понять большую часть того, что происходит в этом примере, но мы пройдемся по всему сценарию и рассмотрим некоторые из результатов.
Как и в примере first.cc (и во всех примерах ns‑3), файл начинается со строки режима emacs и строк о GPL лицензии.
Фактический код начинается с загрузки подключаемых файлов модуля так же, как это было сделано в примере first.cc.
```
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
#include "ns3/ipv4-global-routing-helper.h"
```
Одной вещью, которая может быть удивительно полезной, является небольшой ASCII рисунок, которое показывает схему топологии сети, которая строится в примере. Вы найдете похожий «рисунок» в большинстве наших примеров.
В этом случае вы можете видеть, что мы собираемся расширить наш двухточечный пример (связь между узлами n0 и n1 ниже), прицепив шинную сеть с правой стороны. Обратите внимание, что это топология сети по умолчанию, вы можете варьировать количество узлов, создаваемых в локальной сети. Если вы установите nCsma в единицу, в локальной сети (канал CSMA) будет всего два узла — один обязательный узел и один «дополнительный» узел. По умолчанию есть три «дополнительных» узла, как показано ниже:
```
// Default Network Topology
//
// 10.1.1.0
// n0 -------------- n1 n2 n3 n4
// point-to-point | | | |
// ================
// LAN 10.1.2.0
```
Затем используется пространство имен ns‑3 и определяется компонент журналирования. Все так же, как это было в first.cc, поэтому пока ничего нового.
```
using namespace ns3;
NS_LOG_COMPONENT_DEFINE ("SecondScriptExample");
```
Основная программа начинается немного по-другому. Мы используем флаг verbose для подробного вывода, чтобы знать наверняка включены ли компоненты журналирования в *UdpEchoClientApplication* и *UdpEchoServerApplication*. Этот флаг по умолчанию имеет значение true (компоненты журналирования включены), но позволяет отключить журналирование во время регрессионного тестирования этого примера.
Мы видим знакомый подход, который позволит вам изменять количество устройств в сети CSMA через аргумент командной строки. Мы делали нечто похожее в разделе об аргументах командной строки 5.2.2, когда управляли количеством отправленных пакетов. Последняя строка гарантирует, что у вас будет хотя бы один «лишний» узел.
Код состоит из варианта ранее описанного API, поэтому вам он должен быть понятен.
```
bool verbose = true;
uint32_t nCsma = 3;
CommandLine cmd;
cmd.AddValue ("nCsma", "Number of \"extra\" CSMA nodes/devices", nCsma);
cmd.AddValue ("verbose", "Tell echo applications to log if true", verbose);
cmd.Parse (argc, argv);
if (verbose)
{
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
}
nCsma = nCsma == 0 ? 1 : nCsma;
```
На следующем шаге создаются два узла, которые мы будем связывать через соединение точка-точка. Контейнер NodeContainer используется так же, как это было сделано в *first.cc*.
```
NodeContainer p2pNodes;
p2pNodes.Create (2);
```
Затем мы объявляем еще один NodeContainer для хранения узлов, которые будут частью шинной сети (CSMA). Сначала мы просто создаем экземпляр самого объекта-контейнера.
```
NodeContainer csmaNodes;
csmaNodes.Add (p2pNodes.Get (1));
csmaNodes.Create (nCsma);
```
Следующая строка кода получает первый узел (например, имеющий индекс один) из контейнера двухточечного узла и добавляет его в контейнер узлов, которые станут CSMA устройствами. Рассматриваемый узел в конечном итоге станет одновременно устройством точка-точка и CSMA устройством. Затем мы создаем несколько «дополнительных» узлов, которые образуют оставшуюся часть CSMA сети. Так как у нас уже есть один узел в сети CSMA — тот, что будет выступать как устройство точка-точка и CSMA устройство, количество «лишних» узлов определяется как желаемое число узлов сегменте CSMA минус один.
Следующий фрагмент кода должен быть уже знаком. Мы создаем экземпляр *PointToPointHelper* и устанавливаем связанные атрибуты по умолчанию так, чтобы на устройствах, созданных с помощью помощника получить передачу со скоростью пять мегабит в секунду и задержкой две миллисекунды в канале.
```
PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);
```
Затем мы создаем экземпляр NetDeviceContainer для отслеживания сетевых устройств «точка-точка» и устанавливаем устройства на узлах точка-точка.
Выше мы упоминали, что в следующих строках появится помощник для CSMA устройств и каналов. *CsmaHelper* работает так же, как *PointToPointHelper*, но он создает и подключает CSMA устройства и каналы. Обратите внимание, что в случае CSMA для пары устройство — канал, скорость передачи данных указана атрибутом channelAttribute вместо deviceAttribute. Это потому, что настоящая сеть CSMA не позволяет смешивать, устройства 10Base-T и 100Base-T в одном канале. Сначала мы устанавливаем скорость передачи данных до 100 мегабит в секунду, и затем задержку в 6560 наносекунд на распространение по каналу со скоростью света (выбрана произвольно как 1 наносекунда на фут, соответствует отрезку кабеля длиной 100 метров). Обратите внимание, что вы можете установить атрибут, используя его собственный тип данных.
```
CsmaHelper csma;
csma.SetChannelAttribute ("DataRate", StringValue ("100Mbps"));
csma.SetChannelAttribute ("Delay", TimeValue (NanoSeconds (6560)));
NetDeviceContainer csmaDevices;
csmaDevices = csma.Install (csmaNodes);
```
Так же, как мы создали NetDeviceContainer для хранения устройств, созданных PointToPointHelper, мы создаем NetDeviceContainer для хранения устройств, созданных нашим CsmaHelper. Мы вызываем метод *Install* *CsmaHelper* для установки устройств в узлы csmaNodes *NodeContainer*.
Теперь у нас есть созданные узлы, устройства и каналы, но у нас нет стеков протоколов. Как в *first.cc* скрипте, мы будем использовать *InternetStackHelper* для установки этих стеков.
```
InternetStackHelper stack;
stack.Install (p2pNodes.Get (0));
stack.Install (csmaNodes);
```
Напомним, что мы взяли один из узлов контейнера p2pNodes и добавили его в контейнер csmaNodes. таким образом чтобы охватить все узлы симуляции, нам нужно только установить стеки на оставшийся узел *p2pNodes* и узлы в контейнере csmaNodes. Как и в примере сценария first.cc, для назначения IP-адресов интерфейсов наших устройств мы будем использовать Ipv4AddressHelper. Сначала мы используем сеть `10.1.1.0`для создания двух адресов, необходимых для соединения наших устройств точка-точка.
```
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = address.Assign (p2pDevices);
```
Напомним, что мы сохраняем созданные интерфейсы в контейнере, чтобы впоследствии было проще извлекать адресную информацию для использования в настройке приложений. Теперь нам нужно назначить IP-адреса интерфейсам нашего CSMA устройства. Операция работает так же, как и для случая точка-точка, за исключением того, что мы сейчас выполняем операцию над контейнером с переменным числом CSMA устройств — помните, что мы сделали количество CSMA устройств управляемым от аргумента командной строки. Устройства CSMA в этом случае будут привязаны к IP-адресам сети`10.1.2.0`, как показано ниже.
```
address.SetBase ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = address.Assign (csmaDevices);
```
Теперь у нас построена топология, но нам нужны приложения. Этот раздел будет в основном похож на раздел приложений файла *first.cc*, но мы собираемся создать экземпляр сервера на одном из узлов с CSMA устройством и клиент на узле, имеющем только двухточечное устройство. Сначала мы настроим эхо-сервер. Мы создаем *UdpEchoServerHelper* и предоставляем конструктору требуемое значение атрибута, который является номером порта сервера. Напомним, что этот порт, при желании, можно изменить позже, используя метод *SetAttribute*, но сейчас нам требуется подставить в конструктор конкретное значение.
```
UdpEchoServerHelper echoServer (9);
ApplicationContainer serverApps = echoServer.Install (csmaNodes.Get (nCsma));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
```
Напомним, что контейнер csmaNodes содержит один из узлов, созданных для двухточечной сети, и nCsma «дополнительных» узлов. Предположим, мы хотим получить последний из «дополнительных» узлов. Нулевая запись в контейнере csmaNodes будет точка-точка. Самый простой способ это понять, так это представить, что если мы создадим один «дополнительный» CSMA узел, тогда в контейнере csmaNodes он окажется под индексом 1. Тогда, по математической индукции, если мы создадим *nCsma* «дополнительных» узлов, то последний узел будет с индексом *nCsma*. Вы это и видите в первой строке кода в *Get*.
Клиентское приложение настроено также, как мы это делали в примере скрипта *first.cc*. Опять же, мы передаем необходимые атрибуты в конструктор *UdpEchoClientHelper* (в данном случае это удаленный адрес и порт). Мы говорим клиенту отправлять пакеты на сервер, который мы только что установили на последнем «дополнительном» CSMA узле. Мы устанавливаем клиент на самом левом двухточечном узле, показанном на иллюстрации топологии.
```
UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
ApplicationContainer clientApps = echoClient.Install (p2pNodes.Get (0));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));
```
Поскольку мы фактически соединили здесь две разные сети, нам нужна некоторая форма межсетевой маршрутизации. Ns‑3, чтобы помочь вам, предоставляет вам то, что мы называем глобальной маршрутизацией. Глобальная маршрутизация использует тот факт, что вся внутренняя сеть доступна в симуляции и проходит через все узлы, созданные для симуляции — она выполняет тяжелую работу по настройке маршрутизация для вас без необходимости настройки маршрутизаторов. По сути, каждый узел ведет себя так, как если бы он был маршрутизатором OSPF1, который за кулисами обменивается данными со всеми другими роутерами мгновенно и волшебно. Каждый узел генерирует объявления о состоянии канала и передает их непосредственно к глобальному диспетчеру маршрутов, который использует эту глобальную информацию для построения таблиц маршрутизации для каждого узла. Настройка этой формы маршрутизации выполняется одно строкой:
```
Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
```
Далее мы включаем трассировку pcap. Первая строка кода для включения трассировки pcap в двухточечном помощнике должна быть вам сейчас знакома. Вторая строка включает трассировку pcap в помощнике CSMA, и есть дополнительный параметр, с которым мы еще не встречались.
```
pointToPoint.EnablePcapAll ("second");
csma.EnablePcap ("second", csmaDevices.Get (1), true);
```
Сеть CSMA является многоточечной сетью. Это означает, что в общей среде передачи могут существовать несколько конечных точек (как раз наш случай). С каждой из этих конечных точек связано сетевое устройство. Есть две основных альтернативы сбору трассировочной информации в такой сети. Один из способов — создать файл трассировки для каждого сетевого устройства и хранить только пакеты, которые испускаются или получаются этим устройством. Другой способ — выбрать одно из устройств. и поместить его в неразборчивый режим (Promiscuous mode). Это единственное устройство затем «прослушивает» все пакеты в сети и сохраняет их в один pcap файл. Так работает, например, tcpdump. Последний параметр включает в CSMA помощнике захват пакетов в неразборчивом режиме.
В этом примере мы собираемся выбрать в CSMA сети одно из устройств и попросить его выполнить неразборчивый захват пакетов сети, тем самым подражая тому, как сделает *tcpdump*. Чтобы получить трассировку на компьютере с Linux, вы могли бы сделать что-то вроде `tcpdump -i eth0`. В данном случае мы указываем устройство с помощью *csmaDevices.Get(1)*, который выбирает первое устройство в контейнере. Установка конечного параметра в значение true разрешает неразборчивый захват. Последний раздел кода просто запускает и очищает симуляцию, как в примере first.cc.
```
Simulator::Run ();
Simulator::Destroy ();
return 0;
}
```
Чтобы запустить этот пример, скопируйте скрипт-пример second.cc в рабочую директорию и используйте waf для сборки, как это вы делали с примером *first.cc*. Если вы находитесь в директории верхнего уровня репозитория, то просто наберите,
```
$ cp examples/tutorial/second.cc scratch/mysecond.cc
$ ./waf
```
Предупреждение: файл *second.cc* в качестве одного из наших регрессионных тестов, для проверки данного руководства. Т.е. исполняемый файл с именем second уже существует в проекте. Чтобы избежать путаницы, в показанном выше примере мы копируем файл second.cc с изменением имени на *mysecond.cc*.
Если вы неукоснительно следовали руководству (не так ли), у вас все равно будет установлена переменная NS\_LOG, так, что двигаемся вперед и очищаем эту переменную и запускаем программу.
```
$ export NS_LOG=
$ ./waf --run scratch/mysecond
```
Так как мы в UDP эхо-приложениях настроили журналирование, также как мы делали в first.cc, когда вы запустите скрипт, вы увидите похожий вывод.
```
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.415s)
Sent 1024 bytes to 10.1.2.4
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.2.4
Напомним, что первое сообщение «
Sent 1024 bytes to 10.1.2.4
```
» от UDP эхо-клиента, отправляющего пакет серверу. В этом случае сервер находится в другой сети (10.1.2.0). Второе сообщение «`Received 1024 bytes from 10.1.1.1`
» от UDP эхо-сервера, генерируемое при получении эхо-пакета. Финальное сообщение «`Received 1024 bytes from 10.1.2.4`» от эхо-клиента, указывающее, что он получило свое эхо от сервера обратно.
Если вы сейчас зайдете в директорию верхнего уровня, вы найдете три файла трассировки:
```
second-0-0.pcap second-1-0.pcap second-2-0.pcap
```
Давайте взглянем на именование этих файлов. Для всех оно имеет одинаковую форму,`<Имя> - <узел> - <устройство> .pcap`. Например, первый файл в списке — *second-0-0.pcap* это pcap трассировка от узла 0, устройства 0. Это двухточечное сетевое устройство на нулевом узле. Файл *second-1-0.pcap* — pcap трассировка для нулевого устройства на первом узле, также являющегося сетевым устройством точка-точка; и файл *second-2-0.pcap* — это pcap трассировка для нулевого устройства на втором узле. Если вы вернетесь к иллюстрации топологии в начале раздела, то увидите, что нулевой узел является самым левым узлом соединения точка-точка, а узел 1 — это узел, который выступает как устройство точка-точка, так и как CSMA устройство. Мы также видим, что узел 2 является первым «дополнительным» узлом в CSMA сети, и его устройство 0 было выбрано в качестве устройства для трассировки в неразборчивом режиме.
Теперь давайте проследим за движением эхо-пакета по сети. Сначала выполните tcpdump файла трассировки для самого левого узла точка-точка — 0.
```
$ tcpdump -nn -tt -r second-0-0.pcap
```
Вы должны увидеть содержимое файла *pcap*:
```
reading from file second-0-0.pcap, link-type PPP (PPP)
2.000000 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, length 1024
2.017607 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, length 1024
```
Первая строка дампа ожидаемо указывает, что тип связи — PPP (точка-точка)3. Затем вы видите эхо-пакет, покидающий узел 0 и через устройство, связанное с IP-адресом
`10.1.1.1`, направляется на IP-адрес 10.1.2.4 (самый правый CSMA узел). Этот пакет будет перемещаться по каналу «точка-точка» и приниматься устройством сети «точка-точка» на первом узле. Давайте взглянем:
`$ tcpdump -nn -tt -r second-1-0.pcap`
Теперь вы должны увидеть вывод *pcap* трассировки на другой стороне двухточечного линка:
```
reading from file second-1-0.pcap, link-type PPP (PPP)
2.003686 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, length 1024
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, length 1024
```
Здесь мы видим, что тип линка также PPP, как и следовало ожидать. Вы видите пакет с IP-адреса `10.1.1.1` (который был отправлено в 2.000000 секунд) в направлении IP-адреса `10.1.2.4` на этом интерфейсе. Теперь внутри этого узла пакет будет переадресован на интерфейс CSMA, и мы должны увидеть, что он выскочил на это устройство, направляясь к его конечному пункту назначения.
Вспомним, что мы выбрали узел 2 в качестве неразборчивого анализатора для CSMA сети, поэтому давайте взглянем на `second-2-0.pcap`и посмотрим пакет там.
```
$ tcpdump -nn -tt -r second-2-0.pcap
```
Теперь вы должны увидеть неразборчивый дамп устройства 0 на узле 2:
```
reading from file second-2-0.pcap, link-type EN10MB (Ethernet)
2.007698 ARP, Request who-has 10.1.2.4 (ff:ff:ff:ff:ff:ff) tell 10.1.2.1, length 50
2.007710 ARP, Reply 10.1.2.4 is-at 00:00:00:00:00:06, length 50
2.007803 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, length 1024
2.013815 ARP, Request who-has 10.1.2.1 (ff:ff:ff:ff:ff:ff) tell 10.1.2.4, length 50
2.013828 ARP, Reply 10.1.2.1 is-at 00:00:00:00:00:03, length 50
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, length 1024
```
Как видите, тип соединения теперь «Ethernet». Однако появилось что-то новое. Шинная сеть нуждается в ARP, протоколе разрешения адресов. Узел знает, что ему нужно отправить пакет на IP-адрес `10.1.2.4`, но он не знает MAC-адрес соответствующего узла. Он вещает в CSMA сети (`ff: ff: ff: ff: ff: ff`), запрашивая устройство которое имеет IP-адрес `10.1.2.4`. В этом случае самый правый узел отвечает, что он находится по MAC-адресу `00: 00: 00: 00: 00: 06`. Обратите внимание, что второй узел напрямую не участвует в этом обмене, но отслеживает сеть и сообщает обо всем трафике что видит. Этот обмен виден в следующих строках,
```
2.007698 ARP, Request who-has 10.1.2.4 (ff:ff:ff:ff:ff:ff) tell 10.1.2.1, length 50
2.007710 ARP, Reply 10.1.2.4 is-at 00:00:00:00:00:06, length 50
```
Затем, устройство 1 узла 1 идет дальше и отправляет эхо-пакет на UDP эхо-сервер по IP-адресу `10.1.2.4`.
```
2.007803 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, length 1024
```
Сервер получает эхо-запрос и переворачивает пакет, пытаясь отправить его обратно источнику. Сервер знает, что этот адрес находится в другой сети, которую он может достичь через IP-адрес `10.1.2.1`. Это ему известно потому, что мы инициализировали глобальную маршрутизацию, и она выяснила все это для нас. Но узел эхо-сервера не знает MAC-адрес первого CSMA узла, поэтому он должен выполнить ARP запрос, как и первый CSMA узел.
```
2.013815 ARP, Request who-has 10.1.2.1 (ff:ff:ff:ff:ff:ff) tell 10.1.2.4, length 50
2.013828 ARP, Reply 10.1.2.1 is-at 00:00:00:00:00:03, length 50
```
Затем сервер отправляет эхо-сигнал обратно на узел пересылки.
```
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, length 1024
```
Оглядываясь назад, на самый правый узел двухточечного линка,
```
$ tcpdump -nn -tt -r second-1-0.pcap
```
в последней строке дампа трассировки вы можете видеть отраженный пакет, возвращаемый по двухточечному линку.
```
reading from file second-1-0.pcap, link-type PPP (PPP)
2.003686 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, length 1024
2.013921 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, length 1024
```
Наконец, вы можете снова взглянуть на узел, который вызвал эхо
```
$ tcpdump -nn -tt -r second-0-0.pcap
```
и увидеть, что отраженный пакет возвращается обратно к источнику за 2,017607 секунд,
```
reading from file second-0-0.pcap, link-type PPP (PPP)
2.000000 IP 10.1.1.1.49153 > 10.1.2.4.9: UDP, length 1024
2.017607 IP 10.1.2.4.9 > 10.1.1.1.49153: UDP, length 1024
```
Напоследок напомним, что мы добавили возможность управления количеством CSMA устройств в симуляции с помощью аргумента командной строки. Вы можете изменить этот аргумент так же, как мы меняли количество пакетов в примере *first.cc*. Попробуйте запустить программу с четырьмя дополнительными устройствами:
```
$ ./waf --run "scratch/mysecond --nCsma=4"
```
Теперь вы должны увидеть,
```
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.405s)
At time 2s client sent 1024 bytes to 10.1.2.5 port 9
At time 2.0118s server received 1024 bytes from 10.1.1.1 port 49153
At time 2.0118s server sent 1024 bytes to 10.1.1.1 port 49153
At time 2.02461s client received 1024 bytes from 10.1.2.5 port 9
```
Обратите внимание, что теперь эхо-сервер перенесен на последний из CSMA узлов, адрес которого `10.1.2.5` вместо случая по умолчанию, `10.1.2.4`.
Вполне возможно, что вы не будете удовлетворены файлом трассировки, созданным наблюдателем в сети CSMA. Если вас не интересует трафик с других устройств сети, вы можете получить трассировку с одного устройства. Это делается довольно легко.
Чтобы быть более конкретными, давайте посмотрим на scratch/mysecond.cc и добавим этот код. Помощники ns‑3 предоставляют методы, которые в качестве параметров принимают номер узла и номер устройства. Идем дальше и заменим вызовы EnablePcap вызовами ниже.
```
pointToPoint.EnablePcap ("second", p2pNodes.Get (0)->GetId (), 0);
csma.EnablePcap ("second", csmaNodes.Get (nCsma)->GetId (), 0, false);
csma.EnablePcap ("second", csmaNodes.Get (nCsma-1)->GetId (), 0, false);
```
Мы знаем, что хотим создать файл pcap с базовым именем «second», и мы также знаем, что в обоих случаях нас интересует устройство 0, поэтому эти параметры не очень интересны.
Чтобы получить номер узла, у вас есть два варианта: первый, узлы нумеруются монотонно в возрастающем порядке начиная с нуля в том порядке, в котором вы их создаете. Один из способов получить номер узла — выяснить это число «вручную», опираясь на знание того, в каком порядке вы создавали узлы. Если вы посмотрите на иллюстрацию топологии сети в начале файла, которую мы сделали для вас, то сможете увидеть, что последний CSMA узел будет иметь номер узла равный
`nCsma + 1`. Такой подход может стать раздражающе сложным в больших симуляциях.
Альтернативный способ, который мы здесь применим, состоит в том, чтобы использовать указатели на объекты *Node* ns‑3, которые содержатся в *NodeContainer*. Объект *Node* имеет метод *GetId*, который возвращает идентификатор этого узла, который является номером узла, который мы ищем. Давайте посмотрим на Doxygen для Node и найдем этот метод, который в коде ядра *ns‑3* находится глубже, чем мы заглядывали до сих пор. Но иногда вы должны усердно искать полезные вещи.
Перейдите к документации *Doxygen* для вашего релиза (напомним, что вы можете найти ее на веб-сайте проекта). Вы можете добраться до документации по *Node*, просматривая вкладку «Классы» и прокручивая «Список классов», пока не найдете *ns3::Node*. Выберите *ns3::Node*, и вы попадете в документацию по классу *Node*. Если вы прокрутите до метода *GetId* и выберете его, то попадете в подробную документацию по методу. С помощью метода *GetId* может значительно облегчить определение номеров узлов в сложных топологиях.
Давайте удалим старые файлы трассировки из директории верхнего уровня, чтобы избежать путаницы в том, что происходит,
```
$ rm *.pcap
$ rm *.tr
```
Если вы создадите новый скрипт и запустите симуляцию с аргументом
nCsma=100,
```
$ ./waf --run "scratch/mysecond --nCsma=100"
```
вы увидите следующий вывод:
```
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.407s)
At time 2s client sent 1024 bytes to 10.1.2.101 port 9
At time 2.0068s server received 1024 bytes from 10.1.1.1 port 49153
At time 2.0068s server sent 1024 bytes to 10.1.1.1 port 49153
At time 2.01761s client received 1024 bytes from 10.1.2.101 port 9
```
Обратите внимание, что теперь эхо-сервер расположен по адресу `10.1.2.101`
, что соответствует наличию 100 «дополнительных» узлов CSMA с эхо-сервером на последнем. Если вы запросите список файлов pcap в директории верхнего уровня, то увидите,
```
second-0-0.pcap second-100-0.pcap second-101-0.pcap
```
Файл трассировки *second-0-0.pcap* относится к «самому левому» двухточечному устройству, которое является источником эхо-пакетов. Файл *second-101-0.pcap* соответствует крайнему правому устройству CSMA, в котором находится эхо-сервер. Вы возможно, заметили, что последний параметр вызова для включения трассировки pcap на узле эхо-сервера был *false*. Этот означает, что трассировка, собранная на этом узле, была в неразборчивом режиме.
Чтобы проиллюстрировать разницу между неразборчивыми и разборчивыми трассировками, мы также попросили разборчивую трассировку для ближайшего к последнему узла. Продолжим и посмотрим на tcpdump для *second-100-0.pcap*.
```
$ tcpdump -nn -tt -r second-100-0.pcap
```
Теперь вы можете видеть, что узел 100 действительно является наблюдателем в эхо-обмене. Единственные пакеты, которые он получает, это ARP-запросы, которые передаются по всей CSMA сети.
```
reading from file second-100-0.pcap, link-type EN10MB (Ethernet)
2.006698 ARP, Request who-has 10.1.2.101 (ff:ff:ff:ff:ff:ff) tell 10.1.2.1, length 50
2.013815 ARP, Request who-has 10.1.2.1 (ff:ff:ff:ff:ff:ff) tell 10.1.2.101, length 50
```
Теперь взгляните на *tcpdump* для *second-101-0.pcap*.
```
$ tcpdump -nn -tt -r second-101-0.pcap
```
Теперь вы можете видеть, что узел 101 действительно является участником эхо-обмена.
```
reading from file second-101-0.pcap, link-type EN10MB (Ethernet)
2.006698 ARP, Request who-has 10.1.2.101 (ff:ff:ff:ff:ff:ff) tell 10.1.2.1, length 50
2.006698 ARP, Reply 10.1.2.101 is-at 00:00:00:00:00:67, length 50
2.006803 IP 10.1.1.1.49153 > 10.1.2.101.9: UDP, length 1024
2.013803 ARP, Request who-has 10.1.2.1 (ff:ff:ff:ff:ff:ff) tell 10.1.2.101, length 50
2.013828 ARP, Reply 10.1.2.1 is-at 00:00:00:00:00:03, length 50
2.013828 IP 10.1.2.101.9 > 10.1.1.1.49153: UDP, length 1024
```
#### 6.2 Модели, атрибуты и реальность
Это удобный момент, чтобы сделать небольшое отступление и сделать важное замечание. Это может быть. а может и не быть очевидным для вас, но всякий раз, когда кто-то использует симуляцию, важно точно понимать, что моделируется, а что нет. Например, заманчиво думать об устройствах и каналах CSMA, использованных в предыдущем разделе, как будто они были настоящими Ethernet устройствами; и ожидать, что результат моделирования напрямую отразит то, что произойдет в реальном Ethernet. Это не так.
Модель, по определению, является абстракцией реальности. В конечном счете ответственность в определении так называемого «степень точности» и «области применимости» моделирования в целом и его составных частей лежит на авторе сценария симуляции.
В некоторых случаях, например, в *Csma*, довольно просто определить, что не моделируется. Читая описание модели (*csma.h*) вы можете обнаружить, что в модели CSMA нет обнаружения коллизий, и решить, насколько допустимо её использование или какие оговорки вам придется включить в ваши результаты моделирования.
В других случаях может быть довольно легко настроить поведение таким образом, что оно не будет совпадать с реальным устройством, которое вы можете пойти и купить. Полезно потратить некоторое время на исследование нескольких таких случаев, где ваша симуляция легко может выйти за пределы реальности.
Как вы видели, ns‑3 предоставляет атрибуты, которые пользователь может легко установить для изменения поведения модели. Рассмотрим два атрибута *CsmaNetDevice*: *Mtu* и *EncapsulationMode*. Атрибут *Mtu* указывает устройству максимальный размер передаваемого пакета (Maximum Transmission Unit). Это размер самого большого протокольного блока данных ( PDU), который устройство может отправить.
В *CsmaNetDevice* значение MTU по умолчанию составляет 1500 байт. Это значение по умолчанию соответствует числу, устанавливаемому в RFC 894, «Стандарт для передачи IP-дейтаграмм по сетям Ethernet». Фактически число получено из максимального размера пакета для сетей 10Base5 (полная спецификация Ethernet) — 1518 байт. Если вы вычтете накладные расходы на инкапсуляцию в пакетах Ethernet DIX4 (18 байт), в результате получите максимально возможный размер данных (MTU) 1500 байт. Также можно обнаружить, что MTU для сетей IEEE 802.3 составляет 1492 байта. Это потому, что инкапсуляция LLC/SNAP добавляет в пакет дополнительные восемь байтов служебной информации. В обоих случаях базовое оборудование может отправлять только 1518 байт, но размер данных отличается.
Чтобы установить режим инкапсуляции, CsmaNetDevice предоставляет атрибут, называемый EncapsulationMode, который может принимать значения Dix или Llc. Они соответствуют кадру Ethernet или LLC/SNAP соответственно.
Если оставить Mtu в 1500 байт и изменить режим инкапсуляции на Llc, результатом будет сеть, которая инкапсулирует 1500-байтовые PDU с кадрами LLC/SNAP, что приводит к пакетам по 1526 байтов. Для многих сетей это будет недопустимо, поскольку они могут передавать в пакете максимум 1518 байт. Это приведет к моделированию, которое вопреки вашим ожиданиям скорее всего не достаточно точно отразит реальность.
Теперь, еще усложним картину, существуют jumbo (гигантские) кадры (1500 < MTU ≤ 9000 байт) и super-jumbo (супер-гигантские) (MTU > 9000) байт) кадры, которые официально не разрешены IEEE, но доступны в некоторых высокоскоростных (гигабитных) сетях и сетевых адаптерах. Можно оставить режим инкапсуляции установленным на Dix и установить атрибут *Mtu* на *CsmaNetDevice* до 64000 байт — даже несмотря на то, что у связанного с ним CsmaChannel DataRate был установлен на 10 мегабит в секунду. По существу, это будет модель Ethernet коммутатора сети 10Base5 с отводами «зуб вампира» в стиле 1980-х годов, который поддерживает супер-гигантские дейтаграммы. Это, конечно, не то, что когда-либо могло быть сделано, и вряд ли когда-либо будет осуществлено, но вам легко будет «наконфигурировать» такое.
В предыдущем примере для создания симуляции вы использовали командную строку, в которой было 100 узлов *Csma*. Вы могли бы так же легко создать симуляцию с 500 узлами. Если бы вы на самом деле моделировали сеть 10Base5 с отводами, где максимальная длина полнофункционального Ethernet-кабеля составляет 500 метров, а минимальное расстояние между ответвлениями — 2,5 метра. То это бы означало, что в реальной сети могло бы быть не более 200 подключений. Таким образом, вам довольно легко построить и смоделировать нереализуемую сеть. Это означает, что ценность результатов проводимого вами моделирования зависит от того, насколько реальные вещи вы пытаетесь моделировать.
Подобные ситуации могут возникнуть во многих местах ns‑3 и в любом другом симуляторе. Например, вы можете расположить узлы таким образом, что они в одно и тоже врем будут занимать одну и ту же точку пространства или настроить усилители или уровни шума, таким образом, что будут нарушены основные законы физики.
Ns‑3 обычно поддерживает гибкость, и многие модели позволяют свободно менять атрибуты, не пытаясь заставить вас следовать каким-то ограничениям или конкретным спецификациям. Из этого следует вывод, что ns‑3 предоставляет вам сверхгибкую базу для экспериментов. От вас зависит, что вы просите систему сделать, насколько создаваемые вами симуляции и результаты имеют связь с реальностью.
#### 6.3 Построение топологии беспроводной сети
В этом разделе, для расширения наших познаний в сетевых устройствах и каналах ns‑3, мы охватим пример беспроводной сети. Ns‑3 предоставляет набор моделей 802.11, которые стремятся обеспечить точную реализацию MAC уровня спецификации 802.11 и «не очень медленная» модель PHY-уровня спецификации 802.11a.
В этом разделе мы увидим топологических помощников для Wi-Fi эквивалентных тем, что мы использовали при построении топологий точка-точка и CSMA. Применение и работа этих помощников должны выглядеть для вас знакомо.
Мы предоставляем пример сценария в нашей директории *examples/tutorial*. Этот пример основан на скрипте *second.cc* с добавлением сети Wi-Fi. Чтобы продолжить, открываем *examples/tutorial/third.cc* в вашем любимом редакторе. Вы уже видели достаточное количество кода ns‑3, чтобы понять большую часть того, что происходит в этом примере, но есть несколько новых вещей, поэтому мы пройдемся по всему сценарию и рассмотрим некоторые результаты.
Как и в примере second.cc (и во всех примерах ns‑3), файл начинается со строки режима emacs и слов лицензии GPL.
Взгляните на ASCII иллюстрацию (показанную ниже), она показывает топологию сети по умолчанию, построенную в примере. Вы можете видеть, что мы собираемся расширить наш пример, подключив беспроводную сеть с левой стороны. Напоминаем, что это топология сети по умолчанию, но вы можете изменять количество узлов, создаваемых в проводной и беспроводной сетях. Также как в сценарии *second.cc*, если вы измените *nCsma*, это даст вам ряд «лишних» CSMA узлов. Точно так же вы можете поступить и с *nWifi*, для указания нужного в симуляции количества STA узлов (станций). В беспроводной сети всегда будет один узел AP (точка доступа). По умолчанию есть три «дополнительных» CSMA узла и три беспроводных STA узла.
Код начинается с загрузки подключаемых файлов модулей так же, как это делается в примере *second.cc*. Есть пара новых, подключающих соответственно модуль Wi-Fi и модуль мобильности, которые мы обсудим ниже.
```
#include "ns3/core-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/wifi-module.h"
#include "ns3/mobility-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"
```
Иллюстрация топологии сети выглядит следующим образом:
```
// Default Network Topology
//
// Wifi 10.1.3.0
// AP
// * * * *
// | | | | 10.1.1.0
// n5 n6 n7 n0 -------------- n1 n2 n3 n4
// point-to-point | | | |
// ================
// LAN 10.1.2.0
```
Вы можете видеть, что мы добавляем новое сетевое устройство к узлу с левой стороны двухточечного линка, который становится точкой доступа к беспроводной сети. Ряд беспроводных узлов STA создан для наполнения новой сети
`10.1.3.0`, как показано на левой стороне иллюстрации. После иллюстрации задействуется пространство имен ns‑3 и определяется компонент журналирования. Это все должно уже быть знакомо.
```
using namespace ns3;
NS_LOG_COMPONENT_DEFINE ("ThirdScriptExample");
```
Основная программа начинается так же, как *second.cc*, с добавления некоторых параметров командной строки для включения или отключения компонентов журналирования и для изменения количества создаваемых устройств.
```
bool verbose = true;
uint32_t nCsma = 3;
uint32_t nWifi = 3;
CommandLine cmd;
cmd.AddValue ("nCsma", "Number of \"extra\" CSMA nodes/devices", nCsma);
cmd.AddValue ("nWifi", "Number of wifi STA devices", nWifi);
cmd.AddValue ("verbose", "Tell echo applications to log if true", verbose);
cmd.Parse (argc,argv);
if (verbose)
{
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_INFO);
}
```
Как и во всех предыдущих примерах, следующим шагом является создание двух узлов, которые мы будем соединять линком точка-точка.
```
NodeContainer p2pNodes;
p2pNodes.Create (2);
```
Далее мы видим старого друга. Создается экземпляр *PointToPointHelper* и устанавливаются соответствующие атрибуты по умолчанию таким образом, чтобы на создаваемых помощником устройствах передатчики имели скорость пять мегабит в секунду, а у создаваемых каналов задержка была две миллисекунды. Затем мы устанавливаем устройства на узлы и канал между ними.
```
PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));
NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);
```
Затем мы объявляем еще один NodeContainer для хранения узлов, которые будут частью шинной сети (CSMA).
```
NodeContainer csmaNodes;
csmaNodes.Add (p2pNodes.Get (1));
csmaNodes.Create (nCsma);
```
Следующая строка кода получает первый узел (например, имеющий индекс один) из контейнера двухточечного узла и добавляет его в контейнер узлов, которые получат устройства CSMA. Рассматриваемый узел будет содержать устройство точка-точка и CSMA устройство. Затем мы создаем несколько «дополнительных» узлов, которые образуют оставшуюся часть CSMA сети.
Затем, мы создаем экземпляр CsmaHelper и устанавливаем его атрибуты, также как мы это делали в предыдущем примере. Мы создаем NetDeviceContainer для отслеживания созданных сетевых CSMA устройств, а затем инсталлируем CSMA устройства на выбранные узлы.
```
CsmaHelper csma;
csma.SetChannelAttribute ("DataRate", StringValue ("100Mbps"));
csma.SetChannelAttribute ("Delay", TimeValue (NanoSeconds (6560)));
NetDeviceContainer csmaDevices;
csmaDevices = csma.Install (csmaNodes);
```
Далее мы собираемся создать узлы, которые будут частью сети Wi-Fi. Мы создадим то количество узлов «станций», какое указано в аргументе командной строки, и мы будем использовать «самый левый» узел двухточечного линка как узел для точки доступа.
```
NodeContainer wifiStaNodes;
wifiStaNodes.Create (nWifi);
NodeContainer wifiApNode = p2pNodes.Get (0);
```
Следующий фрагмент кода создает Wi-Fi устройства и канал связи Wi-Fi между этими узлами. Сначала мы настраиваем помощников PHY и канала:
```
YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
```
Для простоты, этот код для PHY-уровня и модели канала использует конфигурирование по умолчанию, с помощью методов
*YansWifiChannelHelper::Default* и *YansWifiPhyHelper::Default*, которые описаны в документации Doxygen API. Как только эти объекты будут созданы, мы создаем объект канала и связываем его с нашим менеджером объектов PHY уровня, гарантируя тем самым, что все объекты PHY уровня, созданные *YansWifiPhyHelper* используют один и тот же базовый канал, а значит и общую беспроводную среду, где они могут коммуницировать и интерферировать:
```
phy.SetChannel (channel.Create ());
```
Как только PHY помощник настроен, мы можем сосредоточиться на MAC уровне. Здесь мы решили работать с non-Qos MAC. Для установки параметров MAC используется объект WifiMacHelper.
```
WifiHelper wifi;
wifi.SetRemoteStationManager ("ns3::AarfWifiManager");
WifiMacHelper mac;
```
Метод *SetRemoteStationManager* сообщает помощнику тип используемого алгоритма управления скоростью. Он просит помощника использовать алгоритм AARF (Adaptive AutoRate Fallback) — подробности, конечно, доступны в *Doxygen*.
Затем мы настраиваем тип MAC, SSID (Service Set Identification)сети, которую мы хотим настроить, и отключаем активное зондирование:
```
Ssid ssid = Ssid ("ns-3-ssid");
mac.SetType ("ns3::StaWifiMac",
"Ssid", SsidValue (ssid),
"ActiveProbing", BooleanValue (false));
```
Этот код сначала создает объект идентификатора набора служб (SSID) 802.11, который будет использоваться для установки значения «*Ssid*», атрибута реализации MAC уровня. Атрибут «*ns3::StaWifiMac*» определяет особый тип MAC уровня, который будет создан помощником. Атрибут «QosSupported» для объектов *WifiMacHelper* по умолчанию имеет значение false. Сочетание этих двух конфигураций означает, что следующий созданный экземпляр MAC будет соответствовать станции (STA) без QoS и без AP в инфраструктуре BSS (то есть в BSS с AP). Наконец, Атрибут «*ActiveProbing*» имеет значение false. Это означает, что MAC, созданные этим помощником не будут отправлять тестовые запросы. После того, как все параметры станции полностью настроены, как на MAC уровне, так и на PHY уровне, мы теперь можем вызвать знакомый нам метод установки для создания устройств Wi-Fi этих станций:
```
NetDeviceContainer staDevices;
staDevices = wifi.Install (phy, mac, wifiStaNodes);
```
Мы настроили Wi-Fi для всех наших STA узлов, и теперь нам нужно настроить AP узел (точку доступа). Чтобы отразить требования AP, мы начнем этот процесс, с изменения атрибутов по умолчанию для *WifiMacHelper*.
```
mac.SetType ("ns3::ApWifiMac",
"Ssid", SsidValue (ssid));
```
В этом случае WifiMacHelper будет создавать MAC уровень
«*ns3::ApWifiMac*», причем последний указывает, что должен быть создан экземпляр MAC, настроенный как AP. Мы не меняем настройки по умолчанию у атрибута «*QosSupported*», поэтому он остается false — отключение поддержки QoS на созданных точках доступа в стиле 802.11e/WMM. Следующие строки создают одну точку доступа, которая использует тот же набор атрибутов PHY уровня (и канал), что и для станций:
```
NetDeviceContainer apDevices;
apDevices = wifi.Install (phy, mac, wifiApNode);
```
Теперь мы добавим модель мобильности. Мы хотим, чтобы STA узлы были подвижными и бродили внутри ограничивающего поля, а узел AP мы хотим сделать стационарным. Чтобы облегчить работу, мы используем *MobilityHelper*. Сначала создаем экземпляр объекта *MobilityHelper* и устанавливаем некоторые атрибуты, управляющие функциональностью «распределителя положений».
```
MobilityHelper mobility;
mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
"MinX", DoubleValue (0.0),
"MinY", DoubleValue (0.0),
"DeltaX", DoubleValue (5.0),
"DeltaY", DoubleValue (10.0),
"GridWidth", UintegerValue (3),
"LayoutType", StringValue ("RowFirst"));
```
Этот код указывает помощнику мобильности использовать для первоначального размещения STA узлов двумерную сетку. Не стесняйтесь исследовать Doxygen для класса *ns3::GridPositionAllocator*, чтобы точно понять, что происходит. Мы разместили наши узлы на начальной сетке, но теперь нам нужно рассказать им, как двигаться. Мы выбираем модель *RandomWalk2dMobilityModel*, в которой узлы перемещаются в случайном направлении со случайной скоростью внутри ограничительной рамки.
```
mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
"Bounds", RectangleValue (Rectangle (-50, 50, -50, 50)));
```
Теперь мы говорим *MobilityHelper* установить модель мобильности на STA узлах.
```
mobility.Install (wifiStaNodes);
```
Мы хотим, чтобы точка доступа во время симуляции оставалась в фиксированном положении. Мы получаем это, устанавливая для её узла модель мобильности
```
ns3::ConstantPositionMobilityModel:
mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
mobility.Install (wifiApNode);
```
Теперь у нас есть созданные узлы, устройства, каналы и модели мобильности, выбранные для узлов Wi-Fi. Но у нас отсутствуют стеки протоколов. Как и ранее, для их установки мы воспользуемся *InternetStackHelper*.
```
InternetStackHelper stack;
stack.Install (csmaNodes);
stack.Install (wifiApNode);
stack.Install (wifiStaNodes);
```
Как и в примере сценария *second.cc*, мы будем использовать *Ipv4AddressHelper* для назначения IP-адресов интерфейсов наших устройств. Сначала мы используем сеть
`10.1.1.0` для создания двух адресов, необходимых для соединения наших устройства точка-точка. Затем мы используем сеть `10.1.2.0` для назначения адресов CSMA сети, а затем мы назначаем адреса из сети `10.1.3.0` для STA устройств и точки доступа в беспроводной сети.
```
Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = address.Assign (p2pDevices);
address.SetBase ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = address.Assign (csmaDevices);
address.SetBase ("10.1.3.0", "255.255.255.0");
address.Assign (staDevices);
address.Assign (apDevices);
```
Мы помещаем эхо-сервер в «самый правый» узел на иллюстрации в начале файла. Мы делали так ранее.
```
UdpEchoServerHelper echoServer (9);
ApplicationContainer serverApps = echoServer.Install (csmaNodes.Get (nCsma));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
```
И мы помещаем эхо-клиент на последний созданный нами STA узел, нацеливая его на сервер в CSMA сети. Мы уже видели подобные действия раньше.
```
UdpEchoClientHelper echoClient (csmaInterfaces.GetAddress (nCsma), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
ApplicationContainer clientApps =
echoClient.Install (wifiStaNodes.Get (nWifi - 1));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));
```
Поскольку мы построили здесь объединение сетей, то нам нужно включить межсетевую маршрутизацию, как мы это делали в примере сценария second.cc.
```
Ipv4GlobalRoutingHelper::PopulateRoutingTables ();
```
Некоторых пользователей может удивить то, что созданная нами симуляция никогда не остановится «естественным образом». Этот потому, что мы попросили беспроводную точку доступа генерировать биконы ( beacon пакеты). Она будет генерировать биконы постоянно, и это приведет к тому, что в симуляторе будут непрерывно планироваться новые события. Поэтому мы должны сказать симулятору остановиться, даже если им могут быть запланированы события для генерации очередного бикона. Следующая строка кода говорит симулятору остановиться, чтобы бы мы не симулировали биконы в бесконечном цикле.
```
Simulator::Stop (Seconds (10.0));
```
Мы создаем трассировку, достаточную для охвата всех трех сетей:
```
pointToPoint.EnablePcapAll ("third");
phy.EnablePcap ("third", apDevices.Get (0));
csma.EnablePcap ("third", csmaDevices.Get (0), true);
```
Эти три строки кода начнут трассировку pcap на обоих точечных узлах, которые служат нашей магистралью, запустят случайную трассировку (мониторинг) в Wi-Fi и в CSMA сетях. Это позволит нам увидеть весь трафик с минимальным количеством файлов трассировки.
Наконец, мы на самом деле запускаем симуляцию, очищаем и затем выходим из программы.
```
Simulator::Run ();
Simulator::Destroy ();
return 0;
}
```
Для запуска этого примера необходимо скопировать пример сценария *third.cc* в рабочую директорию и использовать для сборки *Waf*, как мы это делали с примером second.cc. Если вы находитесь в директории верхнего уровня репозитория, то напечатайте,
```
$ cp examples/tutorial/third.cc scratch/mythird.cc
$ ./waf
$ ./waf --run scratch/mythird
```
Опять же, поскольку мы настроили UDP эхо-приложения так же, как и в сценарии *second.cc*, вы увидите похожий вывод.
```
Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.407s)
At time 2s client sent 1024 bytes to 10.1.2.4 port 9
At time 2.01796s server received 1024 bytes from 10.1.3.3 port 49153
At time 2.01796s server sent 1024 bytes to 10.1.3.3 port 49153
At time 2.03364s client received 1024 bytes from 10.1.2.4 port 9
```
Напомним, что первое сообщение «`sent 1024 bytes to 10.1.2.4`» — это UDP эхо-клиент, отправляющий пакет сервер. В этом случае клиент находится в беспроводной сети (10.1.3.0). Второе сообщение «`received 1024 bytes from 10.1.3.3`» от UDP эхо-сервера, генерируемое при получении эхо-пакета. Наконец сообщение «`received 1024 bytes from 10.1.2.4`» от эхо-клиента, указывающее, что он получил своё эхо обратно с сервера. Если вы сейчас зайдете в директорию верхнего уровня, вы найдете четыре файла трассировки этой симуляции, два для узла 0 и два для узла 1:
```
third-0-0.pcap third-0-1.pcap third-1-0.pcap third-1-1.pcap
```
Файл «third-0-0.pcap» соответствует устройству «точка-точка» на нулевом узле — левой стороне опорной сети («backborn»). Файл «*third-1-0.pcap*» соответствует устройству точка-точка на первом узле — правой стороне опорной сети сети. Файл «*Third-0-1.pcap*» — это неразборчивая трассировка (в режиме монитора) из сети Wi-Fi и файл «*third-1-1.pcap*» будет неразборчивая трассировка CSMA сети. Можете ли вы проверить это, инспектируя код?
Поскольку эхо-клиент находится в сети Wi-Fi, начнем с него. Давайте посмотрим на неразборчивую трассировку (режим монитора), которую мы захватили в этой сети.
```
$ tcpdump -nn -tt -r third-0-1.pcap
```
Вы должны увидеть wifi-подобное содержимое, которое вы не видели здесь ранее:
```
reading from file third-0-1.pcap, link-type IEEE802_11 (802.11)
0.000025 Beacon (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
0.000308 Assoc Request (ns-3-ssid) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit]
0.000324 Acknowledgment RA:00:00:00:00:00:08
0.000402 Assoc Response AID(0) :: Successful
0.000546 Acknowledgment RA:00:00:00:00:00:0a
0.000721 Assoc Request (ns-3-ssid) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit]
0.000737 Acknowledgment RA:00:00:00:00:00:07
0.000824 Assoc Response AID(0) :: Successful
0.000968 Acknowledgment RA:00:00:00:00:00:0a
0.001134 Assoc Request (ns-3-ssid) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit]
0.001150 Acknowledgment RA:00:00:00:00:00:09
0.001273 Assoc Response AID(0) :: Successful
0.001417 Acknowledgment RA:00:00:00:00:00:0a
0.102400 Beacon (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
0.204800 Beacon (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
0.307200 Beacon (ns-3-ssid) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 Mbit] IBSS
```
Теперь видно, что тип связи теперь 802.11, как и следовало ожидать. Вы уже сможете понять, что происходит в этой трассировке, и найти IP-пакеты эхо-запросов и ответов. Мы оставляем вам полный разбор дампа трассировки как упражнение. Теперь посмотрите на файл pcap для левой части линка «точка-точка»,
```
$ tcpdump -nn -tt -r third-0-0.pcap
```
Опять же, вы должны увидеть отчасти знакомое содержимое:
```
reading from file third-0-0.pcap, link-type PPP (PPP)
2.008151 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, length 1024
2.026758 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, length 1024
```
Это эхо-пакет, идущий слева направо (от Wi-Fi до CSMA) и обратно через линию «точка-точка». Теперь посмотрите на файл pcap с правой стороны линка «точка-точка»,
```
$ tcpdump -nn -tt -r third-1-0.pcap
```
Опять же, вы должны увидеть знакомое содержимое:
```
reading from file third-1-0.pcap, link-type PPP (PPP)
2.011837 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, length 1024
2.023072 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, length 1024
```
Это также эхо-пакет, идущий слева направо (от Wi-Fi до CSMA) и обратно через линк точка-точка с немного другими временами, чем вы могли ожидать.
Эхо-сервер находится в CSMA сети, давайте посмотрим на неразборчивую трассировку там:
```
$ tcpdump -nn -tt -r third-1-1.pcap
```
Вы должны увидеть знакомое содержимое:
```
reading from file third-1-1.pcap, link-type EN10MB (Ethernet)
2.017837 ARP, Request who-has 10.1.2.4 (ff:ff:ff:ff:ff:ff) tell 10.1.2.1, length 50
2.017861 ARP, Reply 10.1.2.4 is-at 00:00:00:00:00:06, length 50
2.017861 IP 10.1.3.3.49153 > 10.1.2.4.9: UDP, length 1024
2.022966 ARP, Request who-has 10.1.2.1 (ff:ff:ff:ff:ff:ff) tell 10.1.2.4, length 50
2.022966 ARP, Reply 10.1.2.1 is-at 00:00:00:00:00:03, length 50
2.023072 IP 10.1.2.4.9 > 10.1.3.3.49153: UDP, length 1024
```
Оно должно быть понятным. Если вы забыли, то вернитесь и посмотрите обсуждение примера *second.cc*. Это та же последовательность.
Поскольку мы потратили много времени на настройку моделей мобильности для беспроводной сети, было бы стыдно закончить не показав, как STA узлы фактически перемещаются во время симуляции. Давайте сделаем это, подключив источник трассировки изменения курса в *MobilityModel*. Для этого просто нужно заглянуть в следующую главу 7, но тем не менее хороший момент, чтобы привести пример именно сейчас.
Как упоминалось в главе 5, система трассировки ns‑3 разделена на источники трассировки и приемники трассировки, и мы предоставляем функции для их соединения. Для инициации событий трассировки мы будем использовать дефолтный источник трассировки изменений модели мобильности. Нам нужно написать трассировщик для подключения к этому источнику, который будет отображать информация для нас. Несмотря на сложное описание, все довольно просто. Прямо перед основной программой в сценарий *scratch/mythird.cc* (т.е. сразу после оператора
NS\_LOG\_COMPONENT\_DEFINE), добавьте следующую функцию:
```
void
CourseChange (std::string context, Ptr model)
{
Vector position = model->GetPosition ();
NS\_LOG\_UNCOND (context <<
" x = " << position.x << ", y = " << position.y);
}
```
Этот код просто извлекает информацию о положении из модели мобильности и записывает x и y положения узла. Мы организуем программу таким образом, чтобы эта функция вызывалась каждый раз, когда беспроводной узел с эхо-клиентом меняет свою позицию. Мы сделаем это с помощью функции *Config::Connect*. Добавьте в скрипт следующие строки кода перед вызовом *Simulator::Run*.
```
std::ostringstream oss;
oss <<
"/NodeList/" << wifiStaNodes.Get (nWifi - 1)->GetId () <<
"/$ns3::MobilityModel/CourseChange";
Config::Connect (oss.str (), MakeCallback (&CourseChange));
```
Здесь мы создаем строку, содержащую путь трассировки пространства имен события, к которому мы хотим подключиться. Во-первых, используя как описано ранее метод GetId, мы должны выяснить, какой узел нам нужен. Если использовано число CSMA и беспроводных узлов заданное по умолчанию, это будет седьмой узел и путь пространства имен трассировки к модели мобильности будет выглядеть,
`/NodeList/7/$ns3::MobilityModel/CourseChange`.
Основываясь на обсуждении в разделе трассировки, вы можете сделать вывод, что этот путь трассировки ссылается на седьмой узел в глобальном *NodeList*. Он определяет то, что называется агрегированным объектом типа *ns3::MobilityModel*. Префикс в виде знака доллара подразумевает, что MobilityModel агрегируется на седьмом узле. Последний элемент пути означает, что мы подключились к событию «CourseChange» этой модели.
Мы устанавливаем связь между источником трассировки в узле 7 и нашим приемником трассировки, вызывая *Config::Connect* и предавая путь пространства имен. Как только это будет сделано, каждое событие изменения курса на седьмом узле будет подключено к нашему приемнику трассировки, который в свою очередь распечатает новую позицию.
Если вы сейчас запустите симуляцию, вы увидите изменения курса, отображаемые по мере их появления.
```
'build' finished successfully (5.989s)
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10, y = 0
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10.3841, y = 0.923277
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10.2049, y = 1.90708
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10.8136, y = 1.11368
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10.8452, y = 2.11318
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10.9797, y = 3.10409
At time 2s client sent 1024 bytes to 10.1.2.4 port 9
At time 2.01796s server received 1024 bytes from 10.1.3.3 port 49153
At time 2.01796s server sent 1024 bytes to 10.1.3.3 port 49153
At time 2.03364s client received 1024 bytes from 10.1.2.4 port 9
/NodeList/7/$ns3::MobilityModel/CourseChange x = 11.3273, y = 4.04175
/NodeList/7/$ns3::MobilityModel/CourseChange x = 12.013, y = 4.76955
/NodeList/7/$ns3::MobilityModel/CourseChange x = 12.4317, y = 5.67771
/NodeList/7/$ns3::MobilityModel/CourseChange x = 11.4607, y = 5.91681
/NodeList/7/$ns3::MobilityModel/CourseChange x = 12.0155, y = 6.74878
/NodeList/7/$ns3::MobilityModel/CourseChange x = 13.0076, y = 6.62336
/NodeList/7/$ns3::MobilityModel/CourseChange x = 12.6285, y = 5.698
/NodeList/7/$ns3::MobilityModel/CourseChange x = 13.32, y = 4.97559
/NodeList/7/$ns3::MobilityModel/CourseChange x = 13.1134, y = 3.99715
/NodeList/7/$ns3::MobilityModel/CourseChange x = 13.8359, y = 4.68851
/NodeList/7/$ns3::MobilityModel/CourseChange x = 13.5953, y = 3.71789
/NodeList/7/$ns3::MobilityModel/CourseChange x = 12.7595, y = 4.26688
/NodeList/7/$ns3::MobilityModel/CourseChange x = 11.7629, y = 4.34913
/NodeList/7/$ns3::MobilityModel/CourseChange x = 11.2292, y = 5.19485
/NodeList/7/$ns3::MobilityModel/CourseChange x = 10.2344, y = 5.09394
/NodeList/7/$ns3::MobilityModel/CourseChange x = 9.3601, y = 4.60846
/NodeList/7/$ns3::MobilityModel/CourseChange x = 8.40025, y = 4.32795
/NodeList/7/$ns3::MobilityModel/CourseChange x = 9.14292, y = 4.99761
/NodeList/7/$ns3::MobilityModel/CourseChange x = 9.08299, y = 5.99581
/NodeList/7/$ns3::MobilityModel/CourseChange x = 8.26068, y = 5.42677
/NodeList/7/$ns3::MobilityModel/CourseChange x = 8.35917, y = 6.42191
/NodeList/7/$ns3::MobilityModel/CourseChange x = 7.66805, y = 7.14466
/NodeList/7/$ns3::MobilityModel/CourseChange x = 6.71414, y = 6.84456
/NodeList/7/$ns3::MobilityModel/CourseChange x = 6.42489, y = 7.80181
```
#### 6.4 Очереди в ns-3
Выбор дисциплин очередей в ns‑3 может оказать большое влияние на производительность, и для пользователей важно понимать, что установлено по умолчанию, как эти настройки изменить и как наблюдать за производительностью.
Архитектурно, ns‑3 отделяет уровень устройства от уровней IP или уровней управления трафиком Интернет хоста. Начиная с недавних релизов ns‑3, исходящие пакеты, прежде чем достичь объекта канала, пересекают два уровня очередей. Первый встреченный уровень очередей — это тот, что в ns‑3 называется «уровнем управления трафиком»; здесь активное управление очередью (RFC7567) и расстановка приоритетов из-за качества обслуживания (QoS) осуществляется независимо от устройства посредством использования дисциплин очередей. Второй уровень очередей обычно находится в объектах *NetDevice*. Разные устройства (например, LTE, Wi-Fi) имеют разные реализации этих очередей. Этот двухслойный подход отражает то, что происходит на практике, (программные очереди, обеспечивающие приоритеты, и аппаратные очереди, определенные типом линка). На практике, это может быть еще сложнее. Например, протоколы разрешения адресов имеют небольшую очередь. Wi-Fi в Linux имеет четыре слоя очередей (*<https://lwn.net/Articles/705884/>*).
Уровень управления трафиком эффективен только в том случае, если *NetDevice* уведомляет его о том, что очередь устройства заполнена, чтобы уровень управления трафиком мог прекратить отправку пакетов в *NetDevice*. В противном случае отставание дисциплин очередей всегда нулевое, и они неэффективны. В настоящее время, управление потоком, то есть возможность уведомления уровня управления трафиком, поддерживается следующими *NetDevices*, они используют для хранения пакетов объекты Queue (или объекты подклассов *Queue*):
* Точка-точка
* Csma
* Wi-Fi
* SimpleNetDevice
На производительность дисциплин очередей, используемых NetDevices, сильно влияет их размер. В настоящее время, в ns‑3 очереди по умолчанию не подстраиваются автоматически под настроенные свойства линка (пропускная способность, задержка) и обычно, это самые простые варианты (например, FIFO с отбрасыванием новых пакетов (drop tail), для которых не хватает места в очереди). Тем не менее, размер очередей может динамически настраиваться путем включения BQL (Byte Queue Limits), алгоритм реализован в ядре Linux для регулирования размера очередей устройств в целях борьбы с переполнением буферов, и в то же время без их «голодания». В настоящее время BQL используется в *NetDevices*, которые поддерживают управление потоком. Анализ влияния размера очереди устройства на эффективность дисциплин массового обслуживания, проводимый с помощью моделирования ns‑3 и реальных экспериментов, приводится в:
> П. Импутато и С. Аваллоне. «Анализ влияния буферов сетевых устройств на планировщики пакетов с помощью эксперимента и симуляции». Практика и теория имитационного моделирования, 80 (Приложение C): 1–18, январь 2018 года. DOI: 10.1016 / j.simpat.2017.09.008
>
>
>
> P. Imputato and S. Avallone. An analysis of the impact of network device buffers on packet schedulers through experiments and simulations. Simulation Modelling Practice and Theory, 80(Supplement C):1–18, January 2018. DOI: 10.1016/j.simpat.2017.09.008
>
>
#### 6.4.1 Модели очередей доступные в ns-3
Для уровня управления трафиком существуют опции:
* PFifoFastQueueDisc: максимальный размер по умолчанию — 1000 пакетов.
* FifoQueueDisc: максимальный размер по умолчанию — 1000 пакетов.
* RedQueueDisc: максимальный размер по умолчанию — 25 пакетов.
* CoDelQueueDisc: максимальный размер по умолчанию составляет 1500 килобайт.
* FqCoDelQueueDisc: максимальный размер по умолчанию — 10024 пакета.
* PieQueueDisc: максимальный размер по умолчанию составляет 25 пакетов.
* MqQueueDisc: эта дисциплина очереди не имеет ограничений по объему.
* TbfQueueDisc: максимальный размер по умолчанию — 1000 пакетов.
Если интерфейсу назначается IPv4 или IPv6-адрес, связанный с NetDevice, и если дисциплина очереди еще не была установлена, то по умолчанию, на NetDevice устанавливается дисциплина *pfifo\_fast*.
На уровне устройств существуют очереди для конкретных устройств:
* *PointToPointNetDevice*. Конфигурация по умолчанию (заданная помощником) состоит в установке очереди DropTail по умолчанию. размер (100 пакетов).
* *CsmaNetDevice*. Конфигурация по умолчанию (заданная помощником) состоит в установке очереди DropTail размера по умолчанию (100 пакетов).
* *WiFiNetDevice*: настройка по умолчанию — установит очередь DropTail с размером по умолчанию (100 пакетов) для non-QoS станций и четыре очереди DropTail с размером по умолчанию (100 пакетов) для станций QoS.
* *SimpleNetDevice*: настройка по умолчанию — установка очереди DropTail c размером по умолчанию (100 пакетов).
* *LTENetDevice*: организация очереди происходит на RLC уровне ( RLC UM буфер по умолчанию составляет 10 \* 1024 байт, RLC AM не имеет ограничения буфера).
* *UanNetDevice*: по умолчанию на MAC уровне имеет очередь из 10 пакетов.
#### 6.4.2 Изменение настроек по умолчанию
* Тип очереди, используемой NetDevice, обычно можно изменить с помощью помощника устройства:
```
NodeContainer nodes;
nodes.Create (2);
PointToPointHelper p2p;
p2p.SetQueue ("ns3::DropTailQueue", "MaxSize", StringValue ("50p"));
NetDeviceContainer devices = p2p.Install (nodes);
```
* Тип дисциплины очереди, установленной на NetDevice, можно изменить с помощью помощника управления трафиком:
```
InternetStackHelper stack;
stack.Install (nodes);
TrafficControlHelper tch;
tch.SetRootQueueDisc ("ns3::CoDelQueueDisc", "MaxSize", StringValue ("1000p"));
tch.Install (devices);
```
* Если BQL поддерживается устройством, то оно может быть включено через помощника управления трафиком:
```
InternetStackHelper stack;
stack.Install (nodes);
TrafficControlHelper tch;
tch.SetRootQueueDisc ("ns3::CoDelQueueDisc", "MaxSize", StringValue ("1000p"));
tch.SetQueueLimits ("ns3::DynamicQueueLimits", "HoldTime", StringValue ("4ms"));
tch.Install (devices);
``` | https://habr.com/ru/post/500170/ | null | ru | null |
# Препарируем электрическое перо Wacom
Недавно ~~впервые в истории~~ автором была осуществлена разборка и слесарная доработка пера графического планшета [Wacom Volito2](http://www.my-volito.com/) с целью корректировки порога чувствительности к нажиму. После обратной сборки изделие чувствует себя хорошо. Подробности ~~письмом~~ под катом.
На всякий случай предупреждаю, что описываемый девайс давно снят с производства и тем, кто испытывает отвращение к старью, лучше дальше не читать (может, минусовать лишний раз не станете). У меня таких предрассудков нет, старые вещи хороши тем, что с ними можно проделывать такое, на что с новыми рука ни в жизнь не поднимется.
Несколько лет назад я купил себе планшет **Wacom Volito2** в рассуждении, что рисовать (чертить, ретушировать) карандашом много удобнее, чем мышью. Надо сказать, я был изрядно разочарован результатами испытаний. Позиционирование курсора было выше всяких похвал, но все портила необходимость нажимать на перо со страшной силой, чтобы что-нибудь нарисовать. Думаю, приходилось прилагать силу не менее 10 граммов, чтобы поставить точку (эх, надо было померить с помощью электронных весов, а теперь уже не выйдет). Регулировка кривой чувствительности с помощью прилагаемого софта не привела ни к чему хорошему: в рабочем диапазоне давлений что-то меняется, но чтобы хоть то-то нарисовать, необходимо приличное статическое давление. Может, софт кривой, подумал я и начал искать, где эта собака хранит настройки, чтобы отредактировать их вручную. Настройки нашлись в файле **%APPDATA%\WTablet\Pen\_Tablet.dat**
За кривую чувствительности отвечают строчки
`PressureResolution 511
PressureCurve 9
UpperPressureThreshold 30
LowerPressureThreshold 8
PressureCurveControlPoint 0 0 255 255 511 511
PressureSafteyMargin 1`
Игры с этими настройками дали не сильно больше, чем регулировка штатной софтиной: характеристика по-всякому изгибается, но порог остается на месте.
Это наводило на мысль, что проблема в железе. На тот момент разобрать девайс я не решился, и попробовал его юзать «as is». Без большого успеха: из-за напряжения кисти вся точность терялась. Идея обратиться по гарантии пришла мне поздновато, и то было непонятно, является ли наблюдаемое поведение багом или фичей, сравнить мне было не с чем, характеристик чувствительности я нигде не нашел.
Планшет валялся в столе, иногда доставаемый для очередной попытки использования, и вновь отправлялся назад, посрамленный суровой логитековской мышью. Пару раз попробовал развинтить перо, не получилось. Авторучки вот имеют такую же форму и развинчиваются. А этот нет. Ну что же, его право иметь другую конструкцию. Прилагать более серьезные физические усилия было стремно, не иначе, меня еще сдерживал негативный опыт разборки одного электронного термометра, который назад не собрался.
Как-то с утра подумалось: а пропади оно все. Толку с такого девайса все равно с гулькин нос, а так хоть узнаю, что у него внутри.
Разобрать корпус получилось с помощью ножа.
Из трех кольцевых стыков на корпусе пера два (отмечены на рисунке маркерами) оказались настоящими, и после аккуратного раздвигания лезвием разошлись.
После этого осторожно вытащил из средней части в направлении хвоста плату с катушкой, стараясь не оторвать последнюю (подталкивая ее пальцем с носовой стороны, пришлось приложить небольшое усилие). Катушка оказалась добротной, намотанной литцендратом и припаянной прямыми руками, поэтому не отвалилась. Конструктив боеголовки пера окзазался такой:
Катушка намотана на трубчатом ферритовом сердечнике. Она обеспечивает взаимодействие пера с планшетом, в том числе позиционирование курсора, и, очевидно, питание схемы. Белый пластиковый стержень, кончик которого торчит из пера и обеспечивает чувствительность к давлению, проходит сквозь сердечник и хвостовиком уходит в основание резиновой фиговины, нацепленной на торец платы. Легким движением руки я отцепил всю переднюю часть внутренностей от платы, и увидел, что оттуда вывалилась прозрачная прокладка диаметром миллиметра 4. На торце платы оказалась площадочка с двумя спиральными контактами, выполненными печатным способом.
Принцип действия датчика оказался прост: давление наконечника передается на проводящую шайбу, которая прижимается к контактам и модулирует сопротивление этого бутерброда. Работает, стало быть, наподобие угольного микрофона. Тут я понял, что проводящей шайбы в комплекте не вижу и, скорее всего, я ее ~~проср~~ потерял в пылу разборки. Перспектива искать 4-миллиметровый пятачок по всему столу и, возможно, полу, ни на секунду не обрадовала, но тут удача улыбнулась, и я нашел черный кружок ожидаемого размера прямо на рабочей поверхности планшета. Кружок оказался той самой прокладкой из проводящей резины.
В разобранном виде перо продолжало работать, курсор весело бегал следом за катушкой. При замыкании контактов датчика давления кончиком простого карандаша перо начинало рисовать (я открыл Paint на весь экран и возил болтающимися кишками пера по планшету). Итак, я по крайней мере ничего не сломал.
Далее был реализован комплекс мероприятий для устранения мертвого хода датчика.
* Подложил бумажную шайбу под пластиковую, добавив ее в бутерброд из резинового основания наконечника, пластиковой прокладки и проводящей резиновой шайбы.
* Натер контактую площадку и проводящую шайбу простым карандашом. Из попавшихся под руку наилучшую проводимость продемонстрировал карандаш из Икеи.
Эксперимент получился не чистым, я так и не понял, какое из этих действий дало желаемый результат, а может, оба вместе. Тем не менее, все сложилось удачно. После натирания контактной площадки грифелем перо постоянно думало, что нажим есть, и оттереть его дочиста не удалось. Это смещение я компенсировал настройкой
`PressureCurveControlPoint 20 0 255 255 511 511`
После корректировки файла я перезапускаю сервис **Pen\_Tablet**, чтобы новые настройки вступили в силу. Paint после этого продолжает работать, а вот **Gimp** (в котором я проверял градации нажима) перестает видеть перо и его (Gimp) приходится передергивать.
Сборка пера прошла без существенных проблем. Пришлось только приложить небольшое усилие, чтобы пропихнуть в корпус резиновое основание наконечника.
Результат превзошел все ожидания. Теперь легчайшее прикосновение пера к планшету оставляет пятышко, сила нажатия модулирует толщину линии или прозрачность, что скажешь. В общем, как положено. Похоже на мягкий карандаш. Никакого статического усилия прилагать не нужно, кисть не напрягается. На радостях слегка подретушировал прилагаемые фотографии, работать оказалось сплошное удовольствие. Все, мышкой больше рисовать не буду.
Наверно все-таки мой экземпляр пера был дефектный, потому что жалоб на Volito я в инете не обнаружил (на гениус да, а на ваком — нет).
P.S. После ручной корректировки файла настроек не стоит запускать родную утилиту настройки пера, она затрет наши изменения дефолтами, особенно жалко порог. Я на такой случай держу рядом с файлом его бэкапную копию. | https://habr.com/ru/post/85639/ | null | ru | null |
# Захвати и визуализируй! Или гистограмма с микрофона средствами Web Audio API
[](https://habrahabr.ru/company/devexpress/blog/278823/)
Я очень люблю «живые» графики. Смертельная скука — смотреть на статичные картинки с цифрами. Мне хочется, чтобы график завораживал, чтобы заставлял человека, который смотрит на него, взаимодействовать и открывать для себя новые грани всех данных на нем. Поэтому любой пример, что попадает мне в руки, и любая библиотека визуализации, которой не повезло оказаться на моей машине, проходит испытание “оживлением”. Вот и в очередной раз, раздумывая, как же еще я могу раскорячить визуализационные виджеты из [DevExtreme](http://js.devexpress.com/WebDevelopment/Charts/) библиотеки, я задумалась об отображении звука. «Интересно и живо» — подумала я в тот день, запаслась чаем с печеньками и засела за эту задачу. Что у меня в итоге вышло — узнаете под катом.
Первое, что мне предстояло выбрать — это какой же звук визуализировать. Просто мелодия показалась слишком банальной, к тому же, я нашла [замечательную статью](http://habrahabr.ru/post/210422/) на Хабре, полностью описывающую весь процесс от создания звука до визуализации на Canvas. Но, почитав комментарии к этой статье, я заметила некий интерес к захвату аудио с микрофона. Потыкав гугл на предмет наличия подобных статей, я выяснила, что их на эту тему немного. Появилась цель — появился и план действий:
**Захват аудио с микрофона**. Один из самых простых способов получить данные с микрофона в браузере — использовать [getUserMedia](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/getUserMedia) метод, что находится в объекте общедоступных браузерных методов — в navigator. Принимает он три аргумента:
1. Настройки захвата аудио и видео:
```
{ audio: true/false, video: true/false }
```
2. Функцию, выполняющуюся в случае успеха
3. Функцию, выполняющуюся в случае ошибки
То есть, в общем случае вызов этого метода выглядит вот так:
```
navigator.getUserMedia(
{ audio: true, video: true },
function (stream) {
//stream processing
},
function (error) {
//error processing
}
);
```
Но! Нужно помнить, что метод в разных браузерах различен, поэтому будет не лишним перед вызовом getUserMedia провернуть следующую штуку, и обеспечить поддержку метода во всех распространенных браузерах:
```
navigator.getUserMedia = (navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia);
```
**Анализ захваченного аудио**. В случае успеха выполнения метода getUserMedia, мы получаем объект типа MediaStream, который уже можно использовать для создания источника аудио с помощью Web Audio API. Но чтобы воспользоваться этим способом, для начала нужно создать [AudioContext](https://developer.mozilla.org/en-US/docs/Web/API/AudioContext) — наш проводник в мир Web Audio API. Создание очень простое:
```
var ctx = new AudioContext();
```
Опять же, нужно не забывать про кроссбраузерность:
```
var AudioContext = window.AudioContext || window.webkitAudioContext;
```
Теперь, с помощью аудио контекста ctx, есть возможность создать все необходимые элементы для анализа нашего звука. Что же это за элементы?
Элемент [Destination](https://developer.mozilla.org/en-US/docs/Web/API/AudioDestinationNode) нам доступен по-умолчанию, уже после создания аудио контекста. По сути, это то, куда будет уходить наш звук, а использование конструкции ctx.destination дает нам доступ к стандартному выводу звука для системы, например, к колонкам или наушникам. Остальные же элементы из этой схемы требуется создать и настроить.
* [Source](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamAudioSourceNode) — это источник звука, наше пойманное аудио с микрофона. Необходимо лишь преобразовать поток MediaStream в элемент, с которым мы сможем работать, и для этого подойдет метод аудио контекста createMediaStreamSource:
```
var source = ctx.createMediaStreamSource(stream);
```
* [Analyser](https://developer.mozilla.org/en-US/docs/Web/API/AnalyserNode) — это узел для анализа аудио, многие параметры звука можно вытянуть именно с его помощью. Создается он незатейливым методом аудио контекста createAnalyser:
```
var analyser = ctx.createAnalyser();
```
* [ScriptProcessor](https://developer.mozilla.org/ru/docs/Web/API/ScriptProcessorNode) — это модуль обработки аудио. Он необходим для отслеживания момента изменения звука с помощью события onaudioprocess. Создать его можно, используя метод аудио контекста createScriptProcessor с параметрами размера буфера, количеством входов и выходов:
```
var processor = ctx.createScriptProcessor(2048, 1, 1);
```
Все созданные элементы необходимо соединить между собой, как показано на схеме. Web Audio API предоставляет пару методов connect/disconnect для связывания и развязывания узлов:
```
source.connect(analyser);
source.connect(processor);
analyser.connect(ctx.destination);
processor.connect(ctx.destination);
```
При запуске всего этого кода ([вот пример](https://jsfiddle.net/jdxnmgkq/5/)) и при малой толике удачи можно услышать из колонок/наушников звук с микрофона. Слушать свой голос весьма раздражает, поэтому с чистой совестью можно не создавать связи анализатора с аудио выходом, на конечный результат это никак не повлияет. Конечная схема работы будет выглядеть так:
Последние штрихи — разбор звука по кирпичикам. Для анализатора есть возможность задать размерность преобразования Фурье — опцию fftSize. Зачем она сдалась? А затем, что в итоге получится количество элементов данных равное fftSize/2, то есть количество точек для графика:
```
analyser.fftSize = 128;
```
Осталось лишь получать данные о частотах звука от анализатора, сохраняя их в специально созданную для этого переменную data. Изменение звука отслеживается благодаря уже знакомому нам событию onaudioprocess:
```
var data = new Uint8Array(analyser.frequencyBinCount);
processor.onaudioprocess = function (){
analyser.getByteFrequencyData(data);
console.log(data);
}
```
Та-дам! И вот они, заветные циферки с микрофона в консоли ([пример](https://jsfiddle.net/vsj05jr2/1/)):
**Визуализация полученных данных**. Непосредственно “оживляющая” часть, превращение циферок в график, для которого понадобится библиотека [DevExtreme](http://js.devexpress.com/). Первым делом, конечно же, требуется создать график:
```
```
```
var chart = chart = $("#chart").dxChart({
//chart options
}).dxChart("instance");
```
Такой созданный график будет пустым, потому что для него нужны данные — опция dataSource, и серия, которую нужно отобразить — опция series. При этом данные — динамические, и их нужно менять при срабатывания события onaudioprocess:
```
var dataSource = $.map(data, function (item, index) {
return { arg: index, val: item };
});
chart.option("dataSource", dataSource);
```
Добавив пару настроек для графика, типа цвета и вида серии, можно в итоге получить вот такую замечательную вещь:
[](https://jsfiddle.net/tatyanaRyzh/e2b62xwj/2/)
А итоговый код будет выглядеть вот так, просто и лаконично:
**Итоговый код**
```
navigator.getUserMedia = (navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia);
navigator.getUserMedia(
{ audio: true, video: false },
function (stream) {
var AudioContext = window.AudioContext || window.webkitAudioContext,
ctx = new AudioContext(),
source = ctx.createMediaStreamSource(stream),
analyser = ctx.createAnalyser(),
processor = ctx.createScriptProcessor(2048, 1, 1),
data,
chart,
dataSource;
source.connect(analyser);
source.connect(processor);
//analyser.connect(ctx.destination);
processor.connect(ctx.destination);
chart = $("#chart").dxChart({
dataSource: [],
legend: {
visible: false
},
argumentAxis: {
label: {
visible: false
}
},
valueAxis: {
grid: {
visible: false
},
label: {
visible: false
}
},
series: {
hoverMode: "none",
type: "bar",
color: "#1E90FF"
}
}).dxChart("instance");
data = new Uint8Array(analyser.frequencyBinCount);
processor.onaudioprocess = function (){
analyser.getByteFrequencyData(data);
dataSource = $.map(data, function (item, index) {
return { arg: index, val: item };
});
chart.option("dataSource", dataSource);
}
},
function (error) {
//error processing
}
);
```
Вот здесь можно найти [готовый пример](https://jsfiddle.net/tatyanaRyzh/e2b62xwj/2/). При желании можно собрать пример локально, или даже заменить визуализацию на любую другую понравившуюся. Главное — это насколько быстро и просто с помощью Web Audio API и библиотеки DevExtreme собирается подобный пример.
Как всегда, жду ваши замечания и предложения в комментариях к статье. Всем хорошего дня! | https://habr.com/ru/post/278823/ | null | ru | null |
# ABBYY NeoML 2.0: Python и многое другое
Прошел почти год с тех пор, как мы опубликовали на [GitHub](https://github.com/neoml-lib/neoml) библиотеку для машинного обучения NeoML. О чем, конечно же, была статья на [Хабре](https://habr.com/ru/company/abbyy/blog/506808/). Мы обещали поддерживать и развивать ее. Свое обещание мы сдержали, и на днях свет увидела вторая версия библиотеки!
С первой версии в жизни проекта произошло много интересного: мы продолжили разработку на GitHub, освоили Azure DevOps для регулярных сборок, поддержали новые платформы, добавили немало новых и не столь новых, но очень нужных алгоритмов, добавили производительности и — самое главное — сделали для библиотеки Python интерфейс! Собственно, после окончания работ над Python оберткой библиотека и получила номер версии 2.0.
Ниже я подробнее расскажу о том, как это все происходило.
Open source/GitHub/Azure DevOps
===============================
Перенос разработки на GitHub был для нас смелым шагом, так как внутри компании уже устоялся процесс ведения проектов с помощью Azure DevOps: репозитории, пайплайны, багтрекер, менеджер задач и т. д. – все это пришлось так или иначе менять.
Прежде всего мы переживали за доступность кода. В компании ежедневно идут сотни автоматических сборок, так или иначе использующих код NeoML. Как поведет себя GitHub понимания не было. Поначалу мы даже сделали “зеркало” для внутренних сборок, из которого и предлагалось брать код. Но как-то сами собой все начали брать код напрямую с GitHub. Причем за это время нам не известно ни об одной сборке, упавшей по вине GitHub. Так что полет нормальный!
Сборка самой библиотеки тоже изменилась. Поднимает версии, ставит теги и собирает внутреннюю версию библиотеки по-прежнему локальный пул серверов. Однако проверка собираемости мастера, оберток и pull request’ов происходит в облаке. С этим пришлось изрядно повозиться, но наши DevOps’ы справились, и теперь для регуляных сборок и проверки собираемости pull reguest’ов мы используем Azure, а именно – его бесплатную функциональность для сборки opensource-проектов. О чем на главной странице репозитория на GitHub говорят (чаще всего зеленые) бейджи:
Остальное уже было не так существенно. Но некоторые неудобства все-таки были. Например, просмотрщик pull request'ов в GitHub, на наш взгляд, уступает аналогу из Azure DevOps, ревью делать в нем не так удобно. Багтрекер с GitHub так и не прижился, так как на локальном в компании построено много процессов, и интегрировать в них другой сервис непросто. Возможно, в будущем мы исправим это и сделаем процесс разработки более открытым, но пока менеджерские задачи ведутся локально.
В целом можно сказать, что процесс идет успешно и связка GitHub + Azure DevOps работает хорошо. Сама же идея сделать библиотеку открытой себя более чем оправдала! Мы получили много отзывов и интересных предложений, которые помогли нам стать лучше. И, что особенно приятно, мы нашли единомышленников, которые в итоге помогли нам создать Python обертку.
Python
======
Тема создания Python обертки бесспорно достойна отдельной статьи, и очень может быть, что она скоро появится. Сейчас же постараюсь кратко рассказать, как мы это делали и с какими проблемами столкнулись.
На вопрос, зачем нужен Python интерфейс для современной ML-библиотеки, сейчас уже отвечать не нужно. Python уже давно стал стандартом в этой области. Скорее интересно, почему у нас он появился только сейчас. Развернутый ответ на этот вопрос можно найти в первой [статье](https://habr.com/ru/company/abbyy/blog/506808/) про библиотеку.
В итоге, сэкономленные на развитии механизмов конвертации моделей из форматов других Python библиотек ресурсы было решено направить на создание собственного Python решения. И таким образом перенести все обучение моделей в ABBYY на NeoML. Использование других фреймворков сохранилось только на этапе экспериментов.
Способы создания обертки
------------------------
Как же правильно делать Python обертку для C/C++ кода? В этом направлении существует немало решений: можно использовать ctype и сделать С-обертку для С++ интерфейса написать свой модуль, используя “чистый” Python/C API, или использовать «помощников» типа cffi, cython или pybind11. Мы выбрали последнее.
Cffi отмели сразу, так как он только для C. Pybind11 же показался проще и гибче cython из-за использования C++ при написании модуля расширения. Также в пользу pybind11 сыграло то, что он использовался в других крупных ML-проектах. В итоге мы ни разу не разочаровались в pybind11. Библиотека оказалась простой, понятной и удобной, с нормальной документацией и примерами.
Pybind11
--------
Pybind11 — это легковесная header-only библиотека, позволяющая использовать С++ в Python и наоборот. Главным образом она используется для создания Python оберток существующего C++ кода. Прародителем pybind11 был Boost.Python, но pybind11 проще и не имеет зависимостей. Вообще, про pybind11 и то, почему она хороша, написано много статей в том числе и на Хабре, например, [тут](https://habr.com/ru/company/oleg-bunin/blog/518464/). Поэтому я просто расскажу, что именно мы из нее использовали.
Pybind11 создает модуль расширения для Python и в нем оборачивает существующий С++ код. Мы описали такой модуль и в нем экспортировали необходимые функции и классы из наших С++ библиотек. Наш код сообщает об ошибках через STL исключения и использует STL типы, соответственно, пригодилась встроенная поддержка STL. Также пригодилась встроенная поддержка типов библиотеки NumPy, поддержка buffer protocol и pickle. Неожиданным оказалось то, что для удобной и функциональной обертки понадобятся еще и вызовы Python из C++, но и это тоже в библиотеке тоже имелось. В общем, все, что нам было нужно для реализации идей и представлений об обертке в pybind11, было в наличии.
Идея обертки
------------
Для нас было важно, чтобы обертка оставалась именно оберткой. Это значит, что в Python не должно быть никакой ML-логики, только то, что необходимо для реализации адекватного Python интерфейса. Также крайне желательно, чтобы С++ часть ничего «не знала» о существовании Python интерфейса! Это наш основной сценарий использования библиотеки, и очень не хотелось бы, чтобы на него что-то повлияло.
В итоге наша обертка получилась двухуровневой.
Первый уровень — это сгенерированный pybind11 код. Здесь почти для каждой экспортируемой из С++ библиотек сущности существует pybind11 обертка. Цель обертки — владеть С++ сущностью и разбирать/создавать «упрощенные» Python/pybind11 объекты, типа py::list, py::dict, py::array и т. д., передаваемые на вход и выдаваемые на выход.
Пример функции первого уровня:
```
class CPyBlob {
public:
...
private:
CPtr mathEngineOwner;
CPtr blob; // C++ сущность.
};
py::class\_(m, "Blob", py::buffer\_protocol())
.def( py::init([]( const CPyBlob& blob )
{
return CPyBlob( blob.MathEngineOwner(), blob.Blob() );
}) )
...
;
m.def("tensor", []( const CPyMathEngine& mathEngine, const py::array& shape,
const std::string& blobTypeStr )
{
const int\* shapePtr = reinterpret\_cast( shape.data() );
TBlobType blobType = CT\_Invalid;
if( blobTypeStr == "int32" ) {
blobType = CT\_Int;
} else if( blobTypeStr == "float32" ) {
blobType = CT\_Float;
}
return CPyBlob( mathEngine, blobType, shapePtr );
});
```
Оказалось, что для создания удобного и функционального Python интерфейса этого мало. Так появился уровень два.
Второй уровень — это чисто Python код, классы, агрегирующие сущности первого уровня. Цель этого уровня — разбирать Python параметры в «упрощенные», принимаемые на вход уровнем 1, проверять их правильность и выдавать адекватную диагностику. Дело в том, что в С++ библиотеке правильность входных параметров проверяется ассертами, а такую диагностику использовать в Python крайне неудобно. Также на втором уровне написаны комментарии ко всем доступным в Python сущностям. В принципе, все это можно было бы сделать и на уровне pybind11, но нам показалось, что написать это на Python проще и «правильнее», чем на С++.
Пример функции второго уровня:
```
def tensor(math_engine, shape, dtype="float32"):
"""Creates a blob of the specified shape.
...
"""
if dtype != "float32" and dtype != "int32":
raise ValueError('The `dtype` must be one of {`float32`, `int32`}.')
shape = numpy.array(shape, dtype=numpy.int32, copy=False)
...
return Blob(PythonWrapper.tensor(math_engine._internal, shape, dtype))
```
В итоге, данную функцию можно вызвать из Python кода пользователя, например, так:
```
math_engine = neoml.MathEngine.CpuMathEngine(4)
shape = (10, 1, 1, 1, 32, 32, 3)
float_blob = neoml.Blob.tensor(math_engine, shape, "int32")
```
Что получилось
--------------
В результате у нас получилась полнофункциональная Python обертка. Все классы и функции, за исключением тех, для которых мы решили, что в Python они не нужны или для которых в Python существуют общепринятые аналоги, доступны через новый интерфейс. Python обертка использует ту же версию бинарников, что и C++. Для нее не требуется какая-либо условная компиляция или специальные настройки в рантайме.
Разумеется, интерфейс поддерживает различные сущности библиотеки NumPy, без которых в современном ML уже никуда. С помощью них мы заменили самописные примитивы, которые использовали в C++, например, CSparseFloatVector, CSparseFloatMatrix и т.д. Также наши блобы поддерживают buffer protocol, благодаря чему преобразования из NumPy и обратно происходят без потери данных. Приятно, что pybind11 обеспечивает простую поддержку и NumPy типов, и buffer protocol.
Как уже оговаривалось выше, обработка корректности входных параметров происходит в Python части. Однако ошибки, которые выявляются во время исполнения сети, диагностируются с помощью STL исключений, что благодаря pybind11 дает вполне адекватный вид диагностики. К тому же оказалось не лишним проанализировать все такие ошибки и сделать их описания более подробными.
Python версия библиотеки полностью совместима с C++ версией. Любая модель, использующая стандартные сущности библиотеки, может быть загружена и использована в С++ версии, и наоборот. Для этого в Python части доступны методы сериализации во внутренний формат библиотеки. Существует только ограничение, касающееся самописных слоев. Пока общего механизма их использования в обоих интерфейсах мы не предоставляем. В Python же создание собственных слоев, за исключением слоев, реализующих функции потерь, пока недоступно. Мы продолжаем изучать этот вопрос, но в наших текущих сценариях такой необходимости пока нет.
Что касается реализации собственных функций потерь, во второй версии появился механизм autodiff, заметно упрощающий их реализацию. Раньше вычисление градиентов для каждой функции потерь приходилось писать вручную, используя возможности вычислительного движка, теперь же это делается автоматически. Пока список функций не такой большой, но по мере надобности будет расширяться.
Помимо сериализации во внутренний формат, доступна и стандартная для Python pickle сериализация. Обученная модель сохраняется и загружается через pickle, даже если она использует самописные функции потерь. Тут опять помогают макросы из pybind11.
Отдельным вопросом стало написание документации для нового интерфейса. Мы решили использовать сервис readthedocs.org, предоставляющий бесплатную функциональность по автогенерации и хостингу справки для опенсорс-проектов. Сервис оказался довольно удобным: наша справка из мастера автоматически подтянулась сюда [neoml.readthedocs.io](https://neoml.readthedocs.io), а на GitHub появился бейдж о статусе ее сборки.
Выводы
------
Появление Python интерфейса для NeoML позволило расширить область применения библиотеки. Благодаря этому закрылись многие сценарии использования сторонних ML-фреймворков в компании, тем самым упростив и оптимизировав работу наших инженеров. На Python проще осваивать библиотеку и ставить эксперименты.
Создание нового интерфейса к библиотеке вынудило нас по-новому, более критично, посмотреть на существующий и исправить много огрехов, таких как недостаточная диагностика или нехватка функциональности. Да и в целом это был интересный творческий процесс, от которого мы все получили немало удовольствия.
Как я уже сказал, обертку мы делали не одни. Незаменимую помощь в ее создании оказали разработчики из некоммерческой организации [DuckStax](https://duckstax.com/) и лично Александр Боргардт, за что им огромное спасибо!
Пакет нашей библиотеки можно найти в [PyPi](https://pypi.org/project/neoml/). Доступны версии для Python 3.6-3.9, работающие на Windows, Linux и macOS.
Новые платформы
===============
За время, прошедшее с выхода первой версии, изменились сценарии и целевые платформы библиотеки. Для нас все важнее становится Linux. Поэтому теперь поддержка Windows и Linux равноправная. В частности, было поддержано обучение на GPU под Linux. Что касается GPU, мы подняли версию CUDA до 11.2, так как в версии 10.2 была ограничена поддержка новых карт серии 30. Замедление доходило до 5 раз.
Вот некоторая выдержка из тех замеров. Здесь представлено время умножения матриц библиотекой cuBlas на различных картах и версиях CUDA:
Без обновлений не обошлась и работа на CPU. Компания Apple начала использовать новые процессоры архитектуры ARM. А значит, в срочном порядке понадобилась реализация вычислительного движка для новой платформы. К счастью, наша реализация для Android CPU с незначительными изменениями отлично подошла, и мы получили работающее решение всего за несколько дней, которые главным образом ушли на настройку сборки.
Новая функциональность
======================
Не только новые платформы, но и новые методы машинного обучения появились в нашем арсенале.
Классические методы
-------------------
Наконец-то дошли руки пересмотреть реализацию кластеризации. В KMeans, помимо наивного Lloyd алгоритма, появился Elkan, добавлены новые методы инициализации кластеров и, конечно, поддержка многопоточности, а некоторые вычисления теперь выполняются функциями вычислительного движка. Также все алгоритмы кластеризации теперь принимают данные в dense формате, а не только в sparse, как раньше. Все это привело к ускорению кластеризации на порядок.
Алгоритмы классификации и регрессии практически не изменились, однако все методы по аналогии с кластеризацией принимают dense-данные. Плюс, методы классификации теперь поддерживают внутри себя мультиклассовую классификацию. Причем не только методом «один против всех», но и новым методом «каждый против каждого».
Для мультиклассовой классификации в градиентном бустинге деревьев появился новый алгоритм! Для выполнения классификации он использует один ансамбль, а не N, как в классическом случае. Только в листах деревьев этого ансамбля лежат векторы ответов для N классов. Такой ансамбль, очевидно, дает ниже качество, но при увеличении количества деревьев в некоторых задачах можно выйти на исходные показатели. Главный же плюс этого метода в ускорении предсказания, так как теперь вместо N деревьев нужно найти лист только в одном. И если количество деревьев для получения нужного качества не сильно больше исходного, можно получить солидный прирост производительности! Еще для градиентого бустинга было добавлено компактное представление модели, которое сократило размеры модели в памяти до двух раз.
Новое в нейронных сетях
-----------------------
В нейронных сетях появилось около десятка новых слоев. В основном это развитие идеи рекуррентных слоев или альтернатива им. Так в библиотеке появились следующие слои:
· Quasi-recurrent neural network (CQrnnLayer);
· Identity recurrent neural network (CIRnnLayer);
· Independently recurrent neural network (CIndRnnLayer).
Основной идеей этих методов является сокращение вычислений, производимых в рекуррентной части, для повышения производительности на GPU. Также расширена поддержка трансформеров добавлением реализации Multihead Attention (CMultiheadAttentionLayer).
Добавилось несколько разноплановых слоев: активация (GELULayer), пулинг (CProjectionPoolingLayer) и работа с эмбеддингами (CTiedEmbeddingsLayer, CPositionalEmbeddingLayer) — все это для решения современных NLP-задач.
У нас даже появился один новый солвер — [LAMB](https://arxiv.org/pdf/1904.00962.pdf), который также дал положительные результаты в NLP.
Оптимизация
===========
Python, новые платформы и новые алгоритмы — это хорошо, но не стоит забывать и об улучшении производительности существующего кода. И мы стараемся не забывать, потому дальше я расскажу, что было сделано на этом поприще со времен первой версии. Разумеется, с графиками и таблицами.
Ускорение k-means
-----------------
Как уже было сказано, за счет использования функций вычислительного движка при реализации алгоритма k-means было получено значительное ускорение. Реализация этого алгоритма в первой версии библиотеки была достаточно наивной, и сравнивать производительность с ней не имеет большого смысла. Поэтому здесь приведем сравнения с реализацией этого метода из библиотеки scikit-learn на различных датасетах. Благо, теперь у нас есть Python интерфейс, чтобы сделать это в одинаковых условиях.
Время работы k-means из scikit-learn и NeoML:
AVX2 модуль
-----------
В библиотеке появился отдельный подмодуль вычислительного движка, реализующий вычисления с использованием инструкций из набора AVX2. В него вынесены реализации специфических операций свертки. Отдельный модуль позволяет не требовать от библиотеки сборки под конкретную платформу, а использовать общую сборку, «на лету» определять возможности процессора и использовать для него наиболее подходящий код. Благодаря созданию этого модуля нам удалось ускорить инференс некоторых сверточных архитектур до 30%!
Оптимизация для AMD
-------------------
Библиотека MKL (Intel Math Kernel Library) не оптимально работает на процессорах компании AMD. Судя по всему, такой процессор определяется как обладающий минимальным набором команд, и далее все вычисления идут с использованием максимум SSE. Хотя он, конечно, может гораздо больше.
Мы адаптировали нашу реализацию матричного умножения для ARM, написав ядра на AVX2. И теперь используем ее при работе на процессорах AMD. В результате получилось ускорить некоторые сети до двух раз!
Сравнение времени матричного умножения в NeoML и MKL на процессоре AMD Zen 2:
Замеры производительности NN с другими фреймворками
---------------------------------------------------
Ну и, конечно, мы держим руку на пульсе относительно производительности в сравнении с аналогами. Ниже предоставлены сравнительные замеры обучения и прямого прохода сетей на различных библиотеках:
Архитектура [CAN](https://github.com/fyu/dilation/blob/master/network.py):
Архитектура [MobileNetV2](https://github.com/ShuangXieIrene/mobilenet-v2/blob/master/benchmark-net/mobilenet_v2.py):
Для тестов использовались следующие версии библиотек:
— torch версии 1.8.1 + cuda11;
— tensorflow версии 2.5.0 (если указано \*, то tensorflow был скомпилирован вручную с более широкой поддержкой AVX и AVX2, иначе — взят из PyPI).
Что дальше
==========
Дальше продолжаем работать в том же темпе! Из существенных задумок в ближайшее время мы хотим заняться распределенным обучением и JIT-компиляцией. Конечно, продолжим дорабатывать Python интерфейс, чтобы сделать его более функциональным и удобным. Вероятно, добавим реализации новых методов и точно будем оптимизировать старые. В оптимизации еще много интересных задач. Например, AVX512 вычисления, которые особенно актуальны при работе в облаках.
В общем, работы еще много. Надеемся, что у нас все получится, и следующие версии библиотеки будут еще удобнее и быстрее! Скачивайте библиотеку NeoML 2.0 из [PyPi](https://pypi.org/project/neoml/) и заходите к нам на [GitHub](https://github.com/neoml-lib/neoml). Будем рады любым отзывам и предложениям! | https://habr.com/ru/post/563876/ | null | ru | null |
# phpBBex — добавляем автозагрузку классов и обработчики AJAX запросов
phpBBex — это расширенная версия phpBB 3, которая была [анонсирована ранее](http://habrahabr.ru/post/129990/) на Хабре. Проект постепенно развивается, появляются новые полезные возможности. Сегодня у нас появился официальный [форум](http://phpbbex.com/) и вышла [новая версия](http://phpbbex.com/forum/viewtopic.php?f=2&t=9) нашего форка.
Как известно, код phpBB 3 был заложен в далёком 2002 году. Здесь всё по-старому. Нет никаких сложных абстракций, код простой и линейный. Для небольших проектов это не проблема. Но движок оброс функциональностью, и огромную массу кода сейчас не всегда просто изменить для достижения необходимого результата. Игнорирование современных паттернов мешает дальнейшему развитию. Понятно, что разработчикам phpBB важно следить за совместимостью кода со старыми модами, поэтому никаких серьёзных архитектурных улучшений ожидать не приходится. Выходом из ситуации должен быть phpBB 4 на основе Symfony 2, но за его разработку ещё не взялись. Очевидно, переписать такого монстра не так просто, так что в ближайшее время чуда не будет.
Поскольку в phpBBex планируется множество изменений, связанных с переводом интерфейса на AJAX, логичным было бы реализовать удобный механизм для добавления новых обработчиков AJAX запросов. Стандартным способом для phpBB сегодня является создание php файла в корне со своей логикой для каждой модификации. Это не дело. Мы попробовали добавить нечто вроде контроллеров. Обработчики сгруппированы в «классы-контроллеры», имеется единая точка входа, которая создаёт экземпляр необходимого «контроллера» и вызывает соответствующий обработчик. На основе этого мы создали систему анонимной оценки комментариев (почти как на Хабре).
#### Автозагрузка классов
А начнём мы — с начала. Автозагрузка классов — одна из тех приятных вещей, которую мы можем совершенно безболезненно добавить. Что мы и сделали. Класс autoloader ([исходный код](http://code.google.com/p/phpbbex/source/browse/classes/autoloader.php)) очень прост и переносим, его можно использовать в любом другом проекте. Требуется PHP 5.2+.
Пример использования:
```
require('./classes/autoloader.php'); // Подключаем файл с классом автозагрузчика
autoloader::init('./classes/'); // Инициализация, указываем основной путь поиска файлов классов
autoloader::add_path('./modules/', 'module'); // Добавляем дополнительный путь для классов с префиксом module_
```
Схема поиска файлов классов достаточно типична, с некоторыми нововведениями. Поиск ведётся в общем каталоге с классами, либо в специальном (если у имени класса есть какой-то особый префикс, например, module\_). Общих и специальных каталогов для одного префикса может быть много. Они обходятся в порядке добавления путей статичным методом add\_path.
Разыменование имени класса в путь к файлу происходит следующим образом. Имя загружаемого класса разбивается по «\_» (при этом проверяемый префикс отбрасывается). Затем пока находятся каталоги с именами, совпадающими с полученными частями имени класса, путь генерируется следующим образом: part1/part2/part3/. Если вложенные каталоги закончились, оставшаяся часть используется как имя файла (например, класс db\_select\_query может соответствовать файлу /classes/db/select/query.php). Причём в отличие от других автозагрузчиков, там вполне может остаться несколько частей, которые будут объединены через «\_» (в предыдущем примере, если каталога select не существует, будет использован файл /classes/db/select\_query.php, если же не будет и каталога db, то и вовсе получится /classes/db\_select\_query.php). Если же все части были использованы в качестве имён каталогов, в качестве имени файла используется последняя часть, совпадающая с именем последнего каталога (например, класс db при наличии каталога db будет соответствовать файлу /classes/db/db.php).
#### Служебные классы
Раз уж появился автозагрузчик, глупо было бы не создать небольшую библиотеку классов с полезными функциями. Были [реализованы классы](http://code.google.com/p/phpbbex/source/browse/#hg%2Fclasses) arr (работа с массивами), str (работа со строками), request (работа с данными запроса), response (формирование ответа), cookie (работа с печеньками). Был реализован даже собственный роутер (класс route) — для создания и настройки человеческих урлов в phpBB. К сожалению, пока что он не задействован. Но в будущем, надеемся, всё будет. Подробная документация по этим классам также планируется. При именовании классов, методов и переменных используется стандарт кодирования phpBB (всюду нижний регистр, знак подчёркивания в качестве разделителя).
#### Реализация обработчиков AJAX запросов
То, что обычно в современных системах называют «контроллерами», мы назвали «модулями», потому что у phpBB нет модели, и наши обработчики напрямую работают с данными. Пожалуй, это уже никак из phpBB 3 не искоренить.
Все модули находятся в каталоге modules, имена классов модулей имеют вид module\_something. Каждое действие, что может совершить модуль — это метод, который имеет префикс «action\_». На данный момент это используется только для обработки AJAX запросов, поэтому точкой входа для запросов к модулям сделан файл [ajax.php](http://code.google.com/p/phpbbex/source/browse/ajax.php), который принимает параметры module и action, и передаёт управление классу [core](http://code.google.com/p/phpbbex/source/browse/classes/core.php), который загружает запрошенный модуль и выполняет необходимое действие.
#### Оценка сообщений
Новые классы очень хотелось попробовать в деле. Реализация функции оценки сообщений — отличная возможность сделать это. Один [класс](http://code.google.com/p/phpbbex/source/browse/modules/rating.php), пара методов — и вот он, результат!
Внешний вид:
Настройки:
Статистика кто сколько плюсов получил, кто сколько поставил и т.д. подсчитывается, и доступна в шаблонных переменных, но по умолчанию нигде не выводится. Это сделано намеренно, чтобы оценки оказывали нейтральное влияние на атмосферу форума, и пользователи не пытались «накрутить» этот показатель. Но если кто-то не согласен — при желании все цифры легко вывести.
#### Что дальше?
К полученной системе модулей будет прикручен разработанный роутер, точкой входа станет единственный файл index.php. Все существующие скрипты типа viewtopic.php и др. будут оформлены в виде action-ов соответсвующих модулей. В результате получится гибкая система для настройки вида красивых URL на форуме. | https://habr.com/ru/post/142373/ | null | ru | null |
# Параллакс на чистом CSS
В этой статье показывается, как с помощью CSS трансформаций и махинаций с 3d сделать параллакс-эффект на сайте на чистом CSS.
Параллакс почти всегда создаётся с помощью JavaScript и, чаще всего, получается ресурсоёмким, из-за вешания листенеров на событие скролла, модификации DOM напрямую и срабатывания ненужных перерисовок и перестановок. Всё это происходит асинхронно с потоком, в котором браузер рендерит страницу, из-за чего скролл начинает подтормаживать, а картинка рваться на части. Более правильные реализации параллакса отслеживают скролл и используют отложенные обновления DOM с помощью `requestAnimationFrame`. Получается качественной другой результат, но почему бы вообще не избавиться от JavaScript?
Перенос параллакс эффекта в CSS спасает от проблем с производительностью и лишних манипуляций, позволяя браузеру самому всё регулировать за счёт аппаратного ускорения. В результате, почти все ресурсоёмкие процессы обрабатываются напрямую браузерным движком. Частота кадров (FPS) остаётся стабильной, а картинка становится плавной. Плюс, можно сразу комбинировать параллакс с другими CSS фишками — media queries или supports. Отзывчивый параллакс — каково?
[Смотреть демо](http://keithclark.co.uk/articles/pure-css-parallax-websites/demo3/)
#### Теория
Прежде, чем погрузиться в понимание работы этого механизма, создадим необходимую разметку:
```
...
...
...
```
И базовые стили:
```
.parallax {
perspective: 1px;
height: 100vh;
overflow-x: hidden;
overflow-y: auto;
}
.parallax__layer {
position: absolute;
top: 0;
right: 0;
bottom: 0;
left: 0;
}
.parallax__layer--base {
transform: translateZ(0);
}
.parallax__layer--back {
transform: translateZ(-1px);
}
```
Вся магия происходит в классе `parallax`. Определение свойств стилей `height` и `perspective` установит перспективу элемента в его центре, создав фиксированный 3D вьюпорт. `overflow-y: auto` позволит контенту внутри элемента нормально скроллиться, при этом потомки элемента будут отрисовываться относительно фиксированной перспективы. В этом и заключается ключ к созданию параллакс эффекта.
Далее, класс `parallax__layer`. Как и следует из имени, он определяет слой контента, к которому будет применен параллакс эффект. Элемент с этим классом выдирается из общего потока контента и позиционируется так, чтобы заполнить свой контейнер.
Наконец, у нас есть классы-модификаторы `parallax__layer--base` и `parallax__layer--back`. Они нужны, чтобы регулировать скорость скролла параллакс элементов, смещая их по оси Z (удаляя или приближая к вьюпорту). Для краткости я сделал всего две скорости скролла — позже мы добавим еще несколько.
[Смотреть демо](http://keithclark.co.uk/articles/pure-css-parallax-websites/demo1/)
#### Коррекция глубины
Так как параллакс эффект создаётся за счёт 3D преобразований, смещение элемента по оси Z имеет побочный эффект — размеры элемента меняются, в зависимости от того, ближе или дальше он к вьюпорту. Чтобы исправить это, нам нужно применять `scale()` трансформацию, чтобы элемент отрисовывался в своём изначальном размере:
```
.parallax__layer--back {
transform: translateZ(-1px) scale(2);
}
```
Коэффицент скейла можно посчитать по формуле `1 + (translateZ * -1) / perspective)`. Например, если перспектива вьюпорта задана как `1px` и мы смещаем элемент на `-2px` по оси Z, то коэффицентом будет `scale(3)`.
```
.parallax__layer--deep {
transform: translateZ(-2px) scale(3);
}
```
[Смотреть демо с скорректированной глубиной](http://keithclark.co.uk/articles/pure-css-parallax-websites/demo2/)
#### Регулирование скорости слоя
Скорость слоя регулируется комбинацией значений перспективы и смещения по Z. Элементы с отрицательными значениями Z будут скроллиться медленнее, чем элементы с положительными значениями. Чем больше разность значения от 0, тем явнее параллакс эффект
( т.е. `translateZ(-10px)` будет скроллиться медленнее, чем `translateZ(-1px)`).
#### Создание разных участков параллакс эффекта
Предыдущие примеры демонстрировали базовую технику использования простого контента, но ведь большинство параллакс сайтов делят страницу на разные участки с разными эффектами. Вот как можно реализовать это в нашем методе.
Во-первых, нам нужен элемент `parallax__group`, чтобы сгруппировать наши слои вместе:
```
...
...
...
```
для него CSS будет выглядеть так:
```
.parallax__group {
position: relative;
height: 100vh;
transform-style: preserve-3d;
}
```
В этом примере я хочу, чтобы каждая группа заполнила вьюпорт, поэтому я задаю `height: 100vh`, хотя, если нужно, число для каждой группы может быть разным. `transform-style: preserve-3d` не даёт браузеру сделать плоскими элементы с `parallax__layer`, а `position: relative` позволяет дочерним `parallax__layer` элементам позиционироваться относительно их группы.
Важное правило, которое нужно помнить — при группировке элементов мы не можем обрезать контент внутри группы, тк `overflow: hidden` у элемента `parallax__group` сломает весь параллакс эффект. Необрезанный контент приведёт к тому, что дочерние элементы будут выступать за рамки. Поэтому нужно пошаманить с значением `z-index` у группы, чтобы быть уверенным, что контент будет корректно прятаться и показываться по мере того, как пользователь будет скроллить сайт.
Нет никаких жестких или быстрых правил по поводу работы со слоями и разные методы подразумевают разную реализацию. Но, чтобы упростить отладку позиционирования слоёв, можно применить простую трансформацию групповых элементов:
```
.parallax__group {
transform: translate3d(700px, 0, -800px) rotateY(30deg);
}
```
Взгляните на следующий пример и обратите внимание на галочку `debug`!
[Смотреть демо с группами](http://keithclark.co.uk/articles/pure-css-parallax-websites/demo3/).
#### Поддержка браузеров
* Firefox, Safari, Opera и Chrome — все поддерживают эти эффекты
* Firefox работает, но у него есть небольшая проблема с выравниванием.
* IE пока не поддерживает `preserve-3d` (на подходе), поэтому параллакс работать не будет. Но это нормально, тк всё равно нужно дизайнить так, чтобы контент был адекватным и без параллакса – Ну, progressive enhancement и всё такое!
Статья — перевод (оригинал на blog.keithclark.co.uk — [«Pure CSS parallax scrolling websites»](http://keithclark.co.uk/articles/pure-css-parallax-websites/)) | https://habr.com/ru/post/235531/ | null | ru | null |
# Создание игр для Windows Store c использованием WebGL
 Windows Store на текущий момент, возможно, самая открытая платформа для игровых студий. Для создания приложений вы можете использовать [DirectX 11](http://msdn.microsoft.com/en-us/library/windows/apps/ee663274.aspx), [HTML5 2d-Canvas](http://blogs.msdn.com/b/davrous/archive/2012/07/27/everything-you-need-to-know-to-build-html5-games-with-canvas-amp-svg.aspx), [Cocos2D-X](http://msopentech.com/blog/2013/09/27/easily-port-your-cocos2d-x-game-to-windows-8-and-windows-phone-8/), [Unity3D](http://unity3d.com/pages/windows) и с выходом Windows 8.1 даже для **WebGL**!
Если у вас есть интерес к некоторым из этих технологий, вы можете посмотреть статью [How to develop a game for Windows 8 modern UI](http://blogs.msdn.com/b/eternalcoding/archive/2012/10/08/how-to-develop-a-game-for-windows-8-modern-ui.aspx) в которой перечислены ссылки на ресурсы по технологиям DirectX, HTML5 canvas 2d и MonoGame.
Так же хотелось бы отметить что аддон для Unity который позволяет публиковать приложения в Windows Store бесплатен: <http://unity3d.com/pages/windows>: *“**So* *any* *Unity* *developers* *can* *port* *their* *2**D* *and* *3**D* *content* *to* *Windows* *Store* *and* *Windows* *Phone* *8* *for* *free**”*. Начать изучение разработки Unity для Windows Store можно с цикла видео [Building Windows Games with Unity](http://channel9.msdn.com/Events/Windows-Camp/Building-Windows-Games-with-Unity).
В дополнение к этому, так же хотелось бы отметить что Cocos2D-X был недавно обновлен для более лучшей поддержки Windows 8 и Windows Phone 8: [Easily port your Cocos2D-X game to Windows 8 and Windows Phone 8](http://msopentech.com/blog/2013/09/27/easily-port-your-cocos2d-x-game-to-windows-8-and-windows-phone-8/).
Но давайте вернемся к **WebGL**.
На мой взгляд, WebGL предоставляет отличные новые возможности для индустрии игровых приложений. Теперь в можете создавать кроссплатформенные игры для веб и использовать этот же код для создания приложений Windows Store. При этом у вас появляется возможность добавлять в игру механизмы монетизации и другие возможности платформы Windows 8.
Насколько я понимаю, сейчас мы предлагаем одну из первых платформ которая поддерживает WebGL на персональных компьютерах и планшетах, **включенная по умолчанию в браузере и внутри приложений** **Windows** **Store**.
Мне хотелось бы предоставить вам обзор создания игр на базе WebGL для Windows Store и небольшой курс о том как это делать. Давайте начнем с того, что необходимо для создания таких приложений.
После прочтения этого материала, вы узнаете, как создавать WebGL игру для Windows Store как это показано на этом коротком видео:
Уже сейчас вы можете установить это приложение на свой компьютер или планшет из магазина Windows Store: [Espilit BabylonJS demo.](http://apps.microsoft.com/windows/en-us/app/espilit-babylonjs-demo/0723eb15-0373-4b13-8d91-184887973c99)
Это приложение **было создано всего за несколько часов**. Хотите узнать, как? Давайте проведем обзор необходимых шагов которые мне пришлось проделать для создания этого приложения.
#### Валидация в IE11, выбор движка WebGL и инсталляция VS2013
Моя первая рекомендация — это обязательная **проверка вашего кода в** **Internet** **Explorer** **11**. Еще лучше убедится в том что ваша игра работает во всех браузерах поддерживающих WebGL. Это поможет сэкономить некоторые усилия в будущем и увеличить доступность вашего приложения. В любом случае, если вы хороший веб-разработчик, вы так или иначе знакомы с принципами создания веб-приложений которые работают на различных браузерах. Так что это не должно быть особой проблемой.
IE11 включает в себя JS & рендер движки (Chakra & Trident) которые так же используются при выполнении приложений Windows Store. Поэтому, когда вы создаете код HTML5 для Windows 8.1 Store, так или иначе вы создаете и код который будет работать в IE11. Вот почему вы должны обязательно проверить что ваше существующее веб приложение работает в IE11 если вы затем не хотите потерять время на интеграцию с Windows Store.
Для тестирования необходим компьютер с установленным Windows 8.1. Так же IE11 доступен и для Windows 7. Так же тесты можно провести в виртуальной машине или с использованием [BrowserStack](http://www.browserstack.com/). Вы можете найти бесплатные виртуальные машины для тестирования на сайте <http://www.modern.ie/en-us> и триальную версию BrowserStack.
Несомненно, при создании игры вам необходимо реальное устройство, на котором будут проводится тесты производительности и игрового процесса.
Моя вторая рекомендация — **выбор движка** **WebGL** а не создание кода для вашего приложения с нуля.
Некоторые из существующих движков WebGL отлично работают в IE11. Давайте проведем краткий обзор двух из них. Оба доступны в виде исходных кодов на сайте Github.
#### ThreeJS
Одним из самых знаменитых движков WebGL является ThreeJs: <http://threejs.org/>. Он создан и поддерживается замечательным [Mr Doob](https://twitter.com/mrdoob). Вы найдете множество отличных обучающих ресурсов в интернете по ThreeJS. Тем не менее, будьте внимательны к специфичным демо которые созданы на основе возможностей присутствующих только в Chrome. Еще раз хотелось бы напомнить, если игра или демо не работают в IE11 значит они не будут работать и в Windows Store.
Одни из последних игр и демо “[Hello Run](http://hellorun.helloenjoy.com/)” и “[HexGL](http://hexgl.bkcore.com/)”:
Эти приложения могут быть портированы в Windows Store буквально за несколько часов, так как они замечательно работают в IE11.
#### BabylonJS
[David Catuhe](http://blogs.msdn.com/eternalcoding), [Pierre Lagarde](http://twitter.com/pierlag), [Michel Rousseau](http://blogs.msdn.com/b/designmichel/archive/2013/06/27/real-time-3d-making-a-demo-for-webgl-purposes-basics.aspx) и я, создали свой открытый движок WebGL специально для создания игр. Он называется [Babylon.JS](http://www.babylonjs.com/). Основные архитектурные решения, которые были сделаны при создании этого движка, направлены в первую очередь на применение в игровых приложениях и новом поколении мобильных устройств.
Во первых, **BabylonJS** **базируется на сценах и имеет отличную поддержку экспорта из** **Blender**. Теперь значительно легче получить отличные результаты буквально из нескольких строчек кода. Попробуйте посмотреть сцену в вашем WebGL браузере: [Esplit](http://www.babylonjs.com/index.html?ESPILIT). [Вам нужно всего 10 строк JavaScript чтобы загрузить ее](http://blogs.msdn.com/b/eternalcoding/archive/2013/06/28/babylon-js-how-to-load-a-babylon-file-produced-with-blender.aspx)!
Babylon.JS включает в себя **движок коллизий** (для того чтобы не допустить хождения сквозь стены), камера и источники света загружаются из нашего формата файла, и поддерживается гравитация.
Благодаря этому, используя всего 10 строчек кода JavaScript, вы можете перемещаться внутри сцены с помощью классической комбинации мышь+клавиатура, или используя прикосновения и клавиатуру как это обычно бывает в FPS. Вся работа по моделированию была проделана Michel в инструментах подобных Blender. К тому же, 3D дизайнерам нет необходимости изучать 3D движок. Наши форматы экспорта включают в себя все необходимое.
Наш **экспорт из** **Blender** **включает множество возможностей**. Сцена, свет, камеры, материалы, текстуры, анимации и кости. Полный список находится здесь: [Entities exported from Blender](https://github.com/BabylonJS/Babylon.js/wiki/Entities-exported-from-Blender). Но наш [онлайн конвертер](http://www.babylonjs.com/converter.html) работает так же с .FBX, .OBJ и .MBX.
Мы потратили много времени на оптимизацию производительности с помощью различных подходов:
* [Снижение нагрузки на сборщик мусора](http://blogs.msdn.com/b/eternalcoding/archive/2013/09/04/reducing-the-pressure-on-the-garbage-collector-by-using-the-f12-developer-bar-of-internet-explorer-11.aspx)
* Оптимизация шейдеров и их проверка на ARM устройствах
* Имплементация таких механизмов как octree
* Поддержка инкрементальной загрузки при работе с большими сценами
* [Имплементация индексированной базы для хранения сцены и поддержка оффлайн сценариев](http://blogs.msdn.com/b/davrous/archive/2013/09/24/using-indexeddb-to-handle-your-3d-webgl-assets-sharing-feedbacks-amp-tips-of-babylon-js.aspx)
**Так же мы поддерживаем сенсорный ввод на всех браузерах**! Поскольку мобильные устройства становятся все более важными целевыми платформами для игр, мы поддерживаем сенсорный ввод прямо «из коробки». Для этого используются [событийные указатели](http://blogs.msdn.com/b/davrous/archive/2013/10/21/handling-touch-in-your-html5-apps-thanks-to-the-pointer-events-of-ie10-and-windows-8.aspx) с помощью [handjs polyfill](http://blogs.msdn.com/b/eternalcoding/archive/2013/01/16/hand-js-a-polyfill-for-supporting-pointer-events-on-every-browser.aspx). Сенсорный ввод работает на IE11, Chrome, Firefox и устройствах Android и Firefox OS.
Если у вас есть устройство с поддержкой WebGL и сенсорным вводом, обязательно попробуйте вот это демо:
И наконец, наш движок отлично работает на всех браузерах. Что более интересно для приложений Windows Store: **IE****11** **поддерживается** **прямо** **«****из коробки****»**. Наши пользователи не будут заниматься вопросами кросс-браузерной совместимости, исправлять ошибки в шейдерах WebGL. Все это мы взяли на себя.
Благодаря всем этим возможностям, мы считаем, что **Babylon****JS это отличный кандидат для создания** **WebGL** **игр для** **Windows** **Store**. Но при этом мы пока далеки от поставленных целей, так как это только начало нашей разработки.
Если мне удалось вас заинтересовать, посмотрите на наши примеры и документацию по адресу <https://github.com/BabylonJS/Babylon.js>.
Существует так же большое количество других движков HTML5 для создания игр. TechSlides провел большую работу и консолидировал основную информацию по адресу <http://techslides.com/html5-game-engines-and-frameworks/>. Посмотрите на раздел 3D.
#### Установка Visual Studio 2013
Для создания приложений Windows Store вам необходимо установить на Windows 8.1 Visual Studio 2013. Вы можете скачать бесплатную версию [Visual Studio 2013 Express для Windows 8](http://www.microsoft.com/visualstudio/eng/downloads). Этого набора инструментов достаточно для создания WebGL игр.
#### Шаг 1. Миграция WebGL игры «как есть» из браузера в приложение
В этом пошаговом руководстве мы будем использовать Babylon.js как WebGL движок. Но основные концепции остаются теми же если вы будете использовать другие библиотеки.
##### Создаем первое приложение на Babylon.js
Следуйте этим шагам чтобы создать классный пример буквально за 5 минут:
1. Скачайте BabylonJS с Github: <https://github.com/BabylonJS/Babylon.js>. Выберите пакет в который включен пример сцены Espilit.
2. Скачайте Hand.js polyfill: <http://handjs.codeplex.com/>
3. Создайте веб-проект используя ваши привычные инструменты. Скопируйте babylon.js и hand.js в папку “scripts” folder и скопируйте сцену “Espilit” в такую же папку “Espilit”.
Добавьте в вашем веб-сервере поддержку дополнителных mime типов. Это необходимо для корректной работы Babylon.JS. Если вы используйте asp.net то для этого достаточно отредактировать файл web.config вашего веб-проекта.
```
```
Создайте главную страницу:
```
BabylonJS - Espilit demo
html, body {
width: 100%; height: 100%;
padding: 0; margin: 0;
overflow: hidden;
}
#renderCanvas {
width: 100%; height: 100%;
touch-action: none; -ms-touch-action: none;
}
```
Создайте скрипт «main.js» в каталоге «scripts»:
```
document.addEventListener("DOMContentLoaded", startGame, false);
function startGame() {
if (BABYLON.Engine.isSupported()) {
var canvas = document.getElementById("renderCanvas");
var engine = new BABYLON.Engine(canvas, true);
BABYLON.SceneLoader.Load("Espilit/", "Espilit.babylon", engine, function (newScene) {
// Wait for textures and shaders to be ready
newScene.executeWhenReady(function () {
// Attach camera to canvas inputs
newScene.activeCamera.attachControl(canvas);
// Once the scene is loaded, just register a render loop to render it
engine.runRenderLoop(function () {
newScene.render();
});
});
}, function (progress) {
// To do: give progress feedback to user
});
}
}
```
На этом все! Буквально в несколько строк мы повторили демо которое расположено по адресу <http://www.babylonjs.com/index.html?ESPILIT>. Пока у вас еще нет контрольной панели и экрана загрузки. Но у вас уже есть возможность перемещаться по сцене используя мышь и клавиатуру.
Поскольку этот пример работает в Chrome, Firefox, Opera и что важно для нас, в IE11 мы готовы к тому чтобы создать приложение для Windows Store.
#### Копирование в проект Windows Store.
Коль скоро приложение работает в IE11, позвольте мне показать как вы можете конвертировать его в приложение для Windows Store в течении примерно 60 секунд.
Откройте Visual Studio 2013 и создайте новый проект *“**JavaScript**” –> “Windows* *Store**”*. Назовите его *“**WebGLStoreGame**”*:
Скопируйте – файл index.html, папку “Espilit” и “scripts” в проект Windows Store App:
По умолчанию, приложение Windows Store запускается загружая страницу “default.html”. Давайте изменим это. Откройте файл “package.appxmanifest” и измените стартовую страницу на “index.html”:
Это все! Вы закончили миграцию вашего веб-приложения, и теперь оно запускается как приложение Windows Store!
#### Шаг 2. Подключаем в игру возможности Windows 8
Приложения Windows Store основанные на технологии HTML5 и Jscript предлагают значительно больше возможностей нежели веб представление. Для того чтобы создать действительно хорошую игру для Windows Store, вы должны использовать эти возможности в вашем приложении.
Обязательно прочтите статью [Designing a great game for Windows](http://msdn.microsoft.com/en-us/library/windows/apps/hh868271.aspx). В этом материале поясняется как вы можете использовать возможности платформы Windows 8.1. Живые плитки и нотификации, контракты, панели, поддержка разных форм факторов и размеров экрана и многое другое.
Для JavaScript интересным будет изучить пример готового приложения: [JavaScript and HTML5 touch game sample](http://code.msdn.microsoft.com/windowsapps/JavaScript-and-HTML5-touch-d96f6031). В этом примере вы найдете заготовки для создания панели приложения, настроек, и других важных элементов.
Для того чтобы в этом приложении была поддержка разных представлений существует две опции:
1. Cохранять пропорции рендера и добавлять сверху и снизу черные полосы. Существует простое решение на основе CSS3 Grid. Я о нем уже рассказывал в одной из своих статей: [Modernizing your HTML5 Canvas games Part 1: hardware scaling & CSS3](http://blogs.msdn.com/b/davrous/archive/2012/04/06/modernizing-your-html5-canvas-games-with-offline-apis-file-apis-css3-amp-hardware-scaling.aspx)
2. Просто поменять то на что в текущий момент смотрит камера. Для этого вам достаточно подписаться на событие onresize и поменять размер canvas. Движок BabylonJS проделает все остальные действия.
Для того чтобы более детально понять этот механизм, посмотрите на пример ссылка на который указана в конце стати.
Теперь наша игра готова к публикации в Windows Store! Мы уже поддерживаем сенсорный ввод, клавиатуру и мышь. Это необходимый обязательный минимум для игры Windows Store.
#### Шаг 3. Расширяем возможности игры подключая компоненты C++ WinRT
Поскольку наше приложение теперь запущено в мире WinRT мы не ограничены возможностями только лишь JavaScript, WebGL и браузера. Мы можем так же использовать буквально все возможности платформы Windows 8.1. Если в вашей студии есть разработчики С++ вы можете использовать их знания для того чтобы расширить логику вашей игры.
Давайте попробуем подключить в нашу игру поддержку геймпада Xbox 360. На текущий момент для IE11 нет поддержки контроллеров, но нам это не помешает. Мы создадим компонент WinRT на языке C++, который будет использовать возможности DirectX Input и подключим этот компонент в наше приложение.
Скачайте пример [XInput and JavaScript controller sketch sample](http://code.msdn.microsoft.com/windowsapps/XInput-and-JavaScript-c72fe535) и скопируйте C++ проект в “WebGLStoreGame”:
Добавьте новый референс в проекте «WebGLStoreGame»:
И выберите проект «GameController»:
После этого у вас появится возможность вызова С++ логики прямо из JavaScript.
```
// babylon.xboxControllerCamera.js
var BABYLON = BABYLON || {};
(function () {
BABYLON.XboxControllerCamera = function (name, position, scene) {
BABYLON.FreeCamera.call(this, name, position, scene);
// You need first to referance the WinRT C++ component from the Windows SDK samples
if (GameController) {
// Although the API supports up to 4 controllers per machine,
// this sample only works with a single controller.
this.controller = new GameController.Controller(0);
}
};
// We're mainly based on the logic defined into the FreeCamera code
BABYLON.XboxControllerCamera.prototype = Object.create(BABYLON.FreeCamera.prototype);
BABYLON.XboxControllerCamera.prototype.angularSensibility = 8000000.0;
BABYLON.XboxControllerCamera.prototype.moveSensibility = 20000.0;
BABYLON.XboxControllerCamera.prototype._checkInputs = function () {
var offsetLeftX, offsetLeftY, offsetRightX, offsetRightY;
var state = this.controller.getState();
if (!state.connected) {
return;
}
// Gamepad thumbstick values are between -32768 and 32767.
// Drawing position is moved incrementally if
// the thumbstick value exceeds a deadzone value of 6500.
offsetLeftX = Math.abs(state.leftThumbX) > 6500 ? 0 + state.leftThumbX : 0;
offsetLeftY = -(Math.abs(state.leftThumbY) > 6500 ? 0 - state.leftThumbY : 0);
offsetRightX = Math.abs(state.rightThumbX) > 6500 ? 0 + state.rightThumbX : 0;
offsetRightY = -(Math.abs(state.rightThumbY) > 6500 ? 0 - state.rightThumbY : 0);
this.cameraRotation.y += offsetRightX / this.angularSensibility;
this.cameraRotation.x += -offsetRightY / this.angularSensibility;
var speed = this._computeLocalCameraSpeed();
var direction = new BABYLON.Vector3(speed * offsetLeftX / this.moveSensibility, 0,
speed * offsetLeftY / this.moveSensibility);
BABYLON.Matrix.RotationYawPitchRollToRef(this.rotation.y, this.rotation.x, 0,
this._cameraRotationMatrix);
this.cameraDirection.addInPlace(BABYLON.Vector3.TransformCoordinates(direction,
this._cameraRotationMatrix));
};
})();
```
Это достаточно очевидный пример. X ось левого аналогового джойстика это стрейф влево/вправо, а Y ось это перемещение вперед и назад в направлении взгляда камеры. Правый аналоговый джойстик контролирует ориентацию камеры.
#### Шаг 4. Публикуем игру в магазине
Первое что вам необходимо проделать перед публикацией вашего приложения это пройти тесты [WACK (Windows App Certification Kit).](http://msdn.microsoft.com/en-us/library/windows/apps/jj657973.aspx) Этот инструмент автоматически проводит тесты и проверяет приложение, чтобы убедиться что оно соответствует минимальным требованиям качества (время запуска, отсутствие запрещенных вызовов API, краши и тому подобное).
Проверка проводится после того как вы сформируете пакет вашего приложения:
После того как будут проведены все тесты, вы получите отчет и рекомендации по фиксации найденных ошибок.
#### Скачайте готовый пример
Если вы хотите посмотреть на готовый проект, его можно скачать по адресу <http://david.blob.core.windows.net/babylonjs/WebGLStoreGame.zip>. Он проходит тесты WACK и полностью готов к публикации в магазине приложений Windows Store. Так же вы можете загрузить готовое приложение прямо из магазина: [Espilit BabylonJS demo](http://apps.microsoft.com/windows/en-us/app/espilit-babylonjs-demo/0723eb15-0373-4b13-8d91-184887973c99) | https://habr.com/ru/post/203550/ | null | ru | null |
# Как мы делали олимпиаду по SQL (окончание)
Продолжаю рассказ о том, [как мы делали олимпиаду по SQL](https://habrahabr.ru/post/349560/). Это продолжение предыдущей статьи, в которую всё просто не уместилось.
Краткое содержание предыдущей серии: прошло два заочных тура олимпиады в декабре 2016 и марте 2017 соответственно, где претенденты на победу прошли жёсткий отбор как с теорией, так и с практикой применения SQL в базах данных Oracle. Далее про третий тур — очный финал олимпиады в Сочи в начале июня 2017 г.
**Дисклаймер**. На всякий случай повторюсь в чём была моя роль, а то после первой части статьи она оказалась некоторым не столь очевидна. Я сам не являюсь организатором этой олимпиады: анонсы и реклама мероприятия, поиск спонсоров, работа с вузами, организация событий в офлайне — всё это делали другие люди. Наша компания была спонсором и готовила несколько конкурсов на олимпиаде, а лично я готовил техническую (и только техническую!) часть конкурса по SQL. То есть готовил правила проведения этапов, готовил и проверял задачи. Казалось бы не так много, но зато это самое-самое, ради чего собственно и делается всё остальное. Так что излишне скромничать тоже не буду.
Чтобы было понятно, о чём вообще тут идёт речь, вот отчёт о финале нашей олимпиады 2016/17 [на официальном сайте](http://world-it-planet.org/press/news/detail.php?ID=323774).
[Ссылка на фотоальбом](https://vk.com/album-10938444_244392182) с сайта олимпиады, а то найти его там как-то неочевидно.
Третий тур, он же очный финал, Сочи июнь 2017
---------------------------------------------
На финал организаторы созвали нас и участников в Сочи. Не самое плохое место. Изначально планировался конец мая, но массовое празднование выпускных вечеров в школах привело к сложностям в организации наших мероприятий. Пришлось сдвинуться на недельку на первые числа июня.
Но обо всём по порядку. Сперва про подготовку.
### Подготовка заданий
Повторюсь, что изначальная раскладка по турам была такой: первый тур — жёсткий тест-фильтр по теории, второй — практика магического решения задач, третий — блиц. Так как в очном режиме участникам предстоит решать задачи в реальном и весьма ограниченном времени, то это как ни крути будет блиц. А блиц — это конечно не самый лучший способ определять лучшего программиста. И "не лучший" — это ещё мягко сказано. Но ничего более справедливого придумать не удалось.
Я какое-то время пытался придумать какую-нибудь идею-фикс, которой был бы посвящён весь финал, чтобы каждая решённая задача продвигала участника вперёд, открывая новые задачи, и количество этих задач было бы увеличивающимся с каждой уже решённой, но идея так и не оформилась ни во что реальное. Не удалось за хвост поймать.
Время поджимало и остановились на такой схеме. Все задачи лежат в базе зашифрованными. Решение каждой задачи позволяет расшифровать следующую задачу и так далее по цепочке. Дальше всё просто: кто дальше всех продвинется, тот и победил. Если двое продвинулись одинаково далеко по задачам, то выиграл тот, кто был первым. Расшифровку задач сделали хранимой функцией, которая заодно логгировала обращение к ней. Это позволило следить за ситуацией в реальном масштабе времени. Также функцию расшифровки специально сделали вычислимо сложной, чтобы один её запуск работал пару секунд. Это чтобы исключить возможность решать задачи перебором. Мы также позаботились о том, чтобы в подготовленных данных этих самых вариантов перебора, если что, было более чем достаточно.
Такая схема проведения финала имеет ряд неоспоримых достоинств. Во-первых, за результатами можно следить в реальном времени. Во-вторых, все участники находятся в абсолютно равных условиях, нет никаких поводов для апелляций. Основной же недостаток следует ровно из этих самых достоинств — если вдруг мозг "заклинило" и решение застопорилось, то дальше не пройти. Для блица это конечно не совсем здорово, потому что раздражает, а столкнутся с этим в том или ином виде предстоит всем участникам. Не могу себе даже представить такого человека, который бы на подобных задачах ни разу "не застрял".
Но очень хотелось попробовать именно такой формат. Альтернатива понятна: задачи, баллы за каждую, автоматизированная проверка результатов — кто больше баллов набрал, тот победил. Не нравится в таком подходе тоже понятно что — балансировка весов задач (баллов) в финальном результате. Очень легко промахнуться и результаты внезапно могут оказаться несправедливыми. А возможности отладить эти веса нет, финал один единственный. Если ещё раз доведётся проводить олимпиады, буду ещё думать, как лучше. Теперь уже с имеющимся опытом.
Так, с подходом определились, нужно готовить задачи. Опять же задачи хотелось иметь, как бы это выразить словами, неолимпиадные. То есть для их решения не должно требоваться специальных знаний по теории чисел, специальных алгоритмов или ещё чего такого подобного. Хотелось, чтобы для решения каждой задачи нужно было осознать условие, представить себе декларативный способ выражения решения и реализацию без особых заморочек. Ну, чтобы похоже на задачи второго тура, только попроще. На второй тур целевое время решения задачи было день, а для третьего — полчаса. В результате задачи придумывать было довольно тяжело. Как раз из-за этого баланса, чтобы не слишком тяжело решалась, но и была при этом нетривиальной. Не забываем также про такую особенность, что в задачах нужно получить правильный результат, а способ решения может быть сколь угодно витиеватый, хоть с потолка ответ записать. Способ решения мы нигде не контролировали, только задачи так составили, что проще всего их решать было именно на SQL.
Чтобы не было скучно, в задачах походу мы ещё знакомили участников с интересными словарными объектами оракловой базы. Для тех, кто не знает, в современных базах есть словарь, в котором есть вся метаинформация по содержимому базы: какие в ней есть таблицы, с какими полями, какие есть процедуры-функции и масса другой полезной информации вплоть до того что и как прямо сейчас в базе происходит. По той же причине, чтобы повеселее было, тексты оформили в стиле Григория Остера.
Вот что получилось. Указание тем в конце каждой задачи не входило в условие, это наши рабочие пометки, тут они уместны.
### Задачи финала
**Задача 0. (заглушка)**Ответ на самый главный вопрос о жизни, вселенной и всего такого является ключом для расшифровки следующей задачи.
Ответ: 42
Решение: решение этой задачи занимает слишком длительное время (ок. 7,5 млн. лет), просто нужно знать ответ.
**Задача 1.**Админ Василий создал в базе таблицу. Ему понравилось, и он создал ещё одну. И так ещё 400 раз. Как он потом заметил, таблицы оказались все разные, но две из них были похожи чуть менее, чем полностью, отличаясь только названием одного поля. Найдите и Вы две таблицы, созданные Васей, которые отличаются ровно одним названием поля. Имена таблиц, записанные друг за другом в лексикографическом порядке, являются ключом для расшифровки следующей задачи.
Подсказка: используйте системное представление DBA\_TAB\_COLUMNS, Васины таблицы находятся в схеме VPOUPKINE.
Темы: Словарь (DBA\_TAB\_COLUMNS), подзапросы, агрегация
**Задача 2.**После создания Васей таблиц, пользователь Клава приступила к их заполнению. И заполнила одну таблицу из предыдущей задачи какими-то Очень Важными Данными. Но, в какой-то момент она отвлеклась на разговоры с коллегой и, машинально закрыв окно программы, потеряла запись, в которую заносила данные. Последнее, что она помнила, это то, что в этой записи одно из полей было заполнено строкой, совпадающей с названием поля. Админ Вася сумел найти Клаве эту запись и помочь ей продолжить её нелёгкий труд.
Надо найти в таблице из ответа на предыдущую задачу строку, у которой значение одного из полей (неизвестно какого) совпадает с именем поля. Имя этого поля и ROWID этой записи, записанные друг за другом, являются ключом для расшифровки следующей задачи. Подсказка: используйте представление DBA\_TAB\_COLUMNS.
Темы: Словарь (DBA\_TAB\_COLUMNS), умение генерировать запросы другими запросами
**Задача 3.**Решив предыдущую задачу, Вася задумался. Через два часа он осознал мысль, что теперь он умеет ментальное кугнг-фу и ему ничего не стоит искать произвольные значения в произвольных полях произвольных таблиц. И даже больше. Например, по ходу дела числовые поля можно складывать. Это его так взволновало, что он даже вспотел. И Вася решил поискать среди своих таблиц такую, в которой сумма всех числовых полей равна, скажем, 12345. И такая таблица нашлась! ROWID этой строчки является ключом для расшифровки следующего задания.
Темы: Словарь (DBA\_TAB\_COLUMNS), умение генерировать запросы другими запросами
**Задача 4.**Пока Василий рылся в таблицах, его коллега Женя Смит тайно решил сделать свою базу с абаком и шехерезадами. Для начала он, по следам Васи, помедитировал на создание таблиц тысячу и один раз. Потом задумался, что бы такого сделать дальше. Из транса его вывел Васин голос:
— А названия вот этих двух твоих таблиц получаются друг из друга циклическим сдвигом букв!
— Что?
— Ну смотри, если начало названия вот этой таблицы перенести в конец, то получится точь-в-точь название вон той таблицы.
— Где?
Вася показал. Таблицы находятся в схеме JSMITH. Имена двух этих таблиц, выписанные друг за другом в лексикографическом порядке являются ключом к следующей задаче. Пример циклического сдвига на две буквы: ABCDEF -> CDEFAB. Можно воспользоваться представлением DBA\_TABLES.
Темы: работа со словарём и строковыми функциями, DBA\_TABLES
**Задача 5.**Наконец, Вася снизошёл до потребностей руководства и согласился сделать отчёт, о котором его просили уже два месяца. В отчёте требовалось вывести структуру организации из таблицы SQL2017.ORG\_STRUCTURE следующим образом. Вывести фамилии всех сотрудников по алфавиту. Если у кого-то из сотрудников есть подчинённые, то сделать отступ под руководителем и вывести с отступом всех его подчинённых опять же в алфавитном порядке. Если кто-то из подчинённых имеет своих подчинённых, то опять же сделать отступ и вывести подчинённых по алфавиту и так далее. Вот пример:
```
Имя Отдел ...
------------------------ -------- ----
Иванов
Анискин
Никифоров
Галкина
Кирюхин
Тарасов
Петров
Бекасов
Носова
Сидоров
```
Подчинение сотрудников задаётся полем MANAGER\_ID, ссылающимся на ID руководителя, имена сотрудников находятся в поле NAME.
Сделав отчёт, Вася заметил, что если его запустить для Шарлотты Петровны (ID = 716), дамы, к которой сам Вася был явно неравнодушен, и посмотреть в поле HINT, то это поле открывает ключ к следующей задаче.
Темы: иерархические запросы, сортировка с SIBLINGS
**Задача 6.**Однажды Вася и Женя затеяли спор о независимости. И Вася даже было вынес одно независимое суждение, но на проходной у него попросили накладную на вынос и пришлось принести суждение обратно и положить в угол комнаты. А спор продолжился с новой силой, но теперь уже о зависимости. Зависимости искали где надо и где не надо, и в конце концов нашли в любимой базе, и в довольно большом количестве.
Быстро стало ясно, что если объект базы зависим от другого, то в DBA\_DEPENDENCIES об этом есть запись: OWNER.NAME зависит от REFERENCED\_OWNER.REFERENCED\_NAME. Цепочка зависимостей может продолжаться и дальше, если от следующего объекта в цепочке тоже кто-то зависит.
Независимые объекты не представляют никакого интереса, от них всё равно ничего не зависит. А вот найти самый зависимый оказалось интересным делом. А ещё интереснее — найти самый “влиятельный”, от которого зависят все остальные. Имя объекта, от которого зависит наибольшее количество других объектов и количество этих объектов, написанные друг за другом, являются ключом к расшифровке следующей задачи.
Чтобы обезопасить результат от действий Васи и его коллег, сидящих рядом с Вами в аудитории, ограничьтесь в этой задаче только схемой LOL. Считается, что объект зависит в том числе и от самого себя. Имена всех объектов в схеме уникальны. Тело и спецификацию пакета нужно считать за один объект.
Темы: DBA\_DEPENDENCIES, рекурсивные запросы.
**Задача 7. (бонусная)**Коля Ёк тоже иногда работал на нужды компании, хотя многие считали, что лучше бы
он ничего не делал. Например, он написал небезызвестный отчёт EJEKP.JMACCXBXUK,
который постоянно ломался, и по данным этого отчёта лунный гидрометцентр давно
уже делал свой прогноз погоды. Вот и в очередной раз отчёт перестал показывать
нужные данные, и был объявлен всеобщий аврал: никто с рабочего места не расходится
до тех пор, пока отчёт не заработает. В отличие от Коли, который судорожно пытался
анализировать работу отчёта, Василий решил пойти другим путём. И вместо того, чтобы
искать кто сломал процедуру EJEKP.JMACCXBXUK, Вася решил доказать собственную
невиновность, продемонстрировав, что лично он не изменял в базе ничего такого,
что могло бы повлиять. Для этого он нашёл список процедур и функций (далее
подпрограмм), от которых EJEKP.JMACCXBXUK не зависит. А все Васины исправления
кода попадают в этот список.
Допущения:
Зависимости в DBA\_DEPENDENCIES детализированы до уровня объектов. В данной же
задаче нас будут интересовать зависимости между подпрограммами пакетов. Пусть
подпрограмма S1 пакета P1 вызывает подпрограмму S2 пакета P2. Тогда мы скажем,
что P1.S1 зависит от P2.S2. Нас интересует наличие вызова в коде, а не возможность
выполнения данного вызова. Например
`IF FALSE THEN P2.S2; END IF;`
будем рассматривать как вызов P2.S2.
Найдите все подпрограммы пакетов схемы KEK, от которых не зависит EJEKP.JMACCXBXUK.
Для этого требуется проанализировать исходные коды пакетов, используя таблицу
DBA\_SOURCE. Будем считать, что все зависимости можно найти из исходных кодов
пакетов этой схемы и что подпрограммы других схем не вызываются. В пакетах нет
комментариев. Имена пакета и подпрограммы при вызове всегда будут располагаться
на одной строке без пробелов между ними. Ключевые слова PROCEDURE и FUNCTION и
их имена тоже будут располагаться на одной строке. Имена пакетов и подпрограмм
будут отличаться от имен всех остальных объектов. В пакетах объявляются только
подпрограммы и есть forward declaration.
Ответом будет строка из имён найденных процедур и функций, упорядоченных
лексикографически и склеенных в одну строку через запятую. Не забудьте локальные
подпрограммы, объявленные в теле пакета, но не в спецификации!
Темы: DBA\_SOURCE, рекурсивные запросы.
**Задача 8. (бонусная последняя)**Пока Вася работал на нужды компании, Женя что-то увлечённо делал, изредка бросая на Васю загадочные взгляды. Наконец, не выдержав, Вася спросил:
— Ну, что у тебя там такое?
Женя объяснил:
— Абак делаю. Смотри, в моей табличке JSMITH.ABACUS есть числа. Я выбираю одно число, потом произвольно второе (может даже из той же самой записи) и складываю их. Теперь я беру третье число (тоже может быть из уже взятых записей) и так же четвёртое, и эти два я умножаю друг на друга. И иногда попадаются такие наборы из четырёх чисел, что сумма первой пары равна произведению второй пары. И знаешь сколько всего нашлось таких наборов?
— Пока не знаю, но сейчас выясню. Это же элементарно! — сказал Вася, вспоминая свои былые подвиги для Клавы К.
Но написав запрос и повтыкав с полчаса на надпись "Please wait", Вася заглянул в V$SESSION\_LONGOPS и другие подобные места и понял, что так он до окончания рабочего дня получить ответ не успеет. Выполнение запроса было остановлено. Прикинув что-то в уме, Вася поступил по-другому. И уже спустя пару минут он знал ответ. Найдите этот ответ.
Количество комбинаций четырёх чисел из таблицы JSMITH.ABACUS, где сумма первой пары равна произведению второй пары, является ключом к расшифровке следующей Задачи. Все возможные наборы определены так: на первом месте — каждое из чисел в таблице, на втором месте — каждое из чисел в таблице, на третьем и четвёртом — так же. Например, если бы в таблице было 10 чисел и все они были равны нулю, то ответ на задачу был бы 10\*10\*10\*10 = 10000.
Темы: создание дополнительных таблиц, оптимизация (отличие nested loops и hash join).
**Задача 9. (бонусная самая последняя)**Вася постучал по плечу Женю и сказал:
— А я сделал свой абак! И знаешь, что я на нём посчитал?
— Так же как и я в предыдущей задаче, количество сумм, совпадающих с произведениями?
— Нет, — усмехнулся Вася, — я поступил проще. Я посчитал сколько есть наборов из четырёх чисел, где сумма первых двух равна сумме двух последних.
— Так это ж даже проще!.. — воскликнул Женя.
— А ты попробуй, — усмехнулся Вася.
И как в воду глядел, не так всё оказалось просто.
Количество комбинаций из четырёх чисел, взятых из таблицы VPOUPKINE.ABACUS, где сумма первой пары равна сумме второй пары, является ключом к следующей задаче.
Темы: логика, оптимизация (переписывание запроса).
**Задача 10. (для сверхчеловеков)**В отделе, где работает Вася, есть много открытых задач, к которым еще никто не
приступал. Вася очень хочет поскорее уйти в отпуск, но для этого он должен решить
хотя бы K из этих задач, чтобы KPI не просел. Вася представляет примерное время
решения каждой задачи и хочет взять в разработку K задач, а остальные задачи отдать
другим программистам. Оценив время, требуемое для решения этих K задач, Вася решает согласовать начало своего отпуска, чтобы уже сейчас купить билеты. Начальник Васи был очень предусмотрительным и посчитал, что Вася может не успеть завершить последнюю из выбранных им задач, и тогда придется передать эту частично решенную задачу другому разработчику, на что уйдет дополнительное время. Отпуск Васи был передвинут вперед, чтобы обеспечить данный запас по времени. Задачи имеют приоритет и должны выполняться разработчиком в порядке убывания приоритета. В таблице TASKS содержатся данные по задачам. Для каждой задачи указано название NAME, номер отдела DEPARTMENT\_NUMBER, приоритет PRIORITY (чем больше число, тем приоритетнее задача), оценочная длительность EXPECTED\_TIME и оценочное время передачи недорешенной задачи другому разработчику ADDITIONAL\_TIME. Вася выбрал ровно K из этих задач так, чтобы уйти в отпуск как можно раньше. Т.е. сумма оценочных длительностей этих K задач и оценочного времени передачи последней (по приоритету) из этих K задач была минимально возможной.
В организации есть не один отдел, и в каждом отделе есть свой "Вася". В таблице
DEPARTMENTS приведены данные по отделам: номер отдела DEPARTMENT\_NUMBER и
количество задач K, которые должен решить "Вася" из данного отдела. Заметьте, что
отделы полностью независимы в том смысле, что каждый "Вася" может выбирать задачи
только своего отдела.
Требуется определить, когда начинается отпуск каждого из "Вась", учитывая, что
они выбирали задачи оптимально. Другими словами, Вася из отдела DEPARTMENT\_NUMBER уйдет в отпуск через S дней, где S равно сумме длительностей выбранных Васей задач плюс время передачи последней задачи другому разработчику. В качестве ключа используйте найденные числа S, перечисленные через запятую без пробелов в порядке возрастания номеров отделов DEPARTMENT\_NUMBER. Таблицы находятся в схеме VACATIONS.
Темы: сортировка, логика.
**Задача 11. (для сверх-сверхчеловеков)**Прошло много лет. За это время человечество перешагнуло через технологическую сингулярность, а Вася по-прежнему работал в той же компании. Но теперь Вася мог решать тысячи задач за миллисекунды, так как его мозг уже был подключен к суперкомпьютеру с искусственным интеллектом. Несмотря на все новшества, проблема с “уйти пораньше в отпуск” у Васи осталась. За прошедшее время было накоплено много статистики, и было выяснено, что чем ниже приоритет задачи, тем меньше требуется дополнительного времени на передачу ее другому разработчику. Также было выяснено, что ничтожно низка вероятность того, что в рамках одного отдела могут быть две задачи с одинаковым временем выполнения.
Вам требуется сделать то же самое, что и в предыдущей задаче, с тем изменением,
что данные теперь лежат в схеме MEGAVACATIONS, в таблицах DEPARTMENTS и TASKS.
Учтите, что Вася теперь может решать миллионы задач.Так же учтите, что входные
данные удовлетворяют условию: для задач `TASK_i != TASK_j` из одного отдела
`TASK_i.EXPECTED_TIME != TASK_j.EXPECTED_TIME` и из `TASK_i.PRIORITY <= TASK_j.PRIORITY` следует `TASK_i.ADDITIONAL_TIME <= TASK_j.ADDITIONAL_TIME`.
Темы: сортировка, логика.
**Задача 12. (финишная ленточка)**Упс!.. А это уже не задача. Это, собственно, финиш. Поздравляем!
Можно откинуться на спинку табуретки, улыбнуться и тихонько помахать рукой организаторам, чтобы они тоже порадовались. Но, чур, не отвлекая других участников!
### Комментарии к задачам
Пара комментариев к задачам. На самом деле финалистских задач было подготовлено шесть штук плюс две бонусных повышенной сложности, если кто-то решит основные шесть. Задачи были расположены в порядке увеличения сложности. Как эту сложность измерить непонятно, так что может где и промахнулись слегка. Плюс ещё одна вариация второй бонусной задачи с ещё более повышенной сложностью, если вдруг найдётся монстр, который решит все предыдущие задачи вместе с бонусными.
То есть в первых шести задачах совершенно точно нет никаких подвохов, их способен решить каждый, кто пишет на SQL, хватило бы только времени. Да, некоторые дополнительные знания и навыки позволяют решить какие-то из этих задач быстрее. В бонусных задачах уже пошли извраты. В первой это изрядный объём творчески анализируемых данных, во второй это оптимизация. Причём сложность именно в том, что нужно догадаться, что тут нужна оптимизация, потому что решение "в лоб" не работает, так было специально подобрано. В дополнительной бонусной задаче нужна уже алгоритмическая оптимизация, потому что в ней уже не сработает тот же метод, что в предыдущей задаче.
Дальше мы, чтобы гарантировать, что точно никто за отведённое время не пройдёт до конца, поставили две истинно олимпиадных задачи, потому что они были придуманы и выкидывать их в корзину было жаль. И заглушка под номером 12 — это действительно поздравление для сверхчеловеков, если вдруг таковые найдутся. В это мы конечно не верили, но как математики в душе и программисты по профессии, мы должны были рассмотреть и такой случай.
Итого ожидалось, что участники решат максимум шесть задач и застрянут на 7-8-9. Или раньше. Самое страшное было бы, если бы вдруг все застряли на самой первой задаче. Им то (участникам) что — "три часа позора, потом как обычно", а мы бы судорожно метались по какому критерию определять победителей. Наверное надо было себя обезопасить и первым пунктом поставить задачу на какой-нибудь `SELECT ROWID FROM DUAL`, чтобы уж одну задачу точно решили. Впрочем, расчёты оказались верными, первую задачу и так все решили.
Расшифровка задачи делается следующим образом:
```
SELECT sql2017.decrypt('ответ-на-предыдущую-задачу', encrypted_text)
FROM sql2017_tasks
WHERE task_number = 2;
```
В процессе подготовки задач для служебных целей были написаны генератор таблиц, генераторы лабиринтов и корректных арифметических выражений (эти ко второму туру), генератор пакетов с кодом и требуемыми параметрами взаимных вызовов, простой генератор человеческих ФИО.
Кое-что как водится не успели. Например, я так и не смог придумать, как в выбранном формате дать задачу на [quine](https://ru.wikipedia.org/wiki/%D0%9A%D1%83%D0%B0%D0%B9%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)).
### Подготовка на местности, Сочи июнь 2017
Теперь из лабиринтов "чистого разума" вернёмся на бренную землю.
Сочи встретил нас летним теплом и зеленью. Заезд был в четверг, в пятницу сами финалы во всех номинациях. Затем выходные с культурной программой и в понедельник награждение и вручение призов.
Сервер мы привезли свой, с заранее подготовленной базой. Места участников тоже привезли с собой (правда не сами, но наши коллеги). Было решено, что для создания одинаковых условий у всех будут одинаковые преднастроенные рабочие места. Лично я опасался возможных проблем с подключением всякого экзотического зоопарка, если разрешить участникам использовать свои компьютеры. Найдётся кто-нибудь криворукий и настырный — хлопот будет выше крыши. Так что привезли своих одинаковых ноутов. Поставили на них благоверные SQL\*PLUS для фанатов (на самом деле SQLcl) и SQL Developer, как бесплатное средство разработки с GUI от производителя. Не припомню, чтобы кто-то из моих знакомых в реальной жизни активно пользовался SQL Developer, но зато все оказались в одинаковых условиях. Ну и не надо драматизировать, собрать нужный SQL запрос можно в чём угодно, хоть в Notepad-е, а выполнить вполне сгодится и SQL Developer.
Всё это хозяйство мы и притащили с собой в четверг в Олимпийский Университет на улице Орджоникидзе, где и происходила олимпиада. Тут случилась организационная засада. Нам для проведения финала по SQL выделили две маленьких комнатки. В одну мы бы никак не поместились по количеству. Местные сетевики как раз опутывали витой парой столы. Так как других возможностей разместиться не было, нам пришлось провести по сути два одновременных финала в соседних аудиториях. Единственное, что можно было сделать и что я поменял — это рассадку. Нам совсем не с руки было бы, если участники имели возможность видеть мониторы друг друга. Подглядывать специально вряд ли, но блуждающим взглядом наткнуться и не начать разглядывать написанное — это черезчур для человека, который зашёл в тупик при решении задачи. Поэтому я посетовал на уже произведённые старания сетевиков и решительно расставил столы по кругу. На фотографиях кое-где мелькают наши характерно расставленные кружком столы.
Провода, розетки, загрузка и проверка ноутов, настройка подключения к базе — ничего сложного, но долго, так как постоянно возникают всякие мелкие вопросы. То витая пара кончилась, то все дырки в хабе заняты и нужен ещё один, куда спрятать сервер, чтобы никто на него не наступил. Сеть получилась изолированная, соответственно нужно DHCP, чтобы раздать IP-адреса. Легче настроить один DHCP-сервер, чем постоянно бегать и вводить вручную адреса на любой чих изменений в конфигурации сети. Нужен шлюз в интернет для доступа к документации — настроили, заработало. Короче мелких хлопот хватило до самого позднего вечера.
А утром нас ждал...
### Финал
Про официальное открытие я ничего не скажу, к нашей номинации по SQL это хоть и имеет некоторое отношение, но мы в этом никак не были задействованы. Скажу только, что народу на олимпиаду набралось много. На регистрации в холле было не протолкнуться. Хорошо, что мы зарегистрировались и получили пропуска накануне.
После тожественного открытия мы собрали в зале своих участников финала и, как пионервожатые, повели их в подготовленные для финала аудитории. Инструктаж, раздача логинов, проверка подключений к базе, объяснение правил проведения финала, проверка всеми расшифровки тестовой задачи на примере задачи №0. На месте первой задачи пока стоит заглушка. По логам расшифровщика заранее написаным запросом следим, кто ещё не смог правильно расшифровать тестовую задачку. О, оно работает!
Все готовы? Меняем первую задачу с заглушки на настоящую, обнуляем логи. Поехали!..
Мы следим за порядком и за ситуацией. За ситуаций следить удобно, делаем выборку из таблицы логов расшифровщика, сортируем по номеру решённой задачи и времени расшифровки — и лидеры у нас перед глазами (осторожно, "живой" код):
```
select l.oracle_user, name, task
, (select min(sent_date)
from sql2017_log l2
where l.oracle_user=l2.oracle_user
and l.task = task_number)+3/24 solve_time
, tries
from (select oracle_user
, max(task_number) task
, count(1) tries
from sql2017_log
group by oracle_user) l
, sql2017_users u
where u.oracle_user = l.oracle_user
order by task desc, solve_time asc
```
Вопросов нам задают немного. Всего несколько за всё время финала. Начали мы после торжественной части открытия и инструктажа в 12:15, закончили в 15:30. Время окончания в сущности было не слишком важно, главное было обозначить его заранее. Мы исходили из того что с 15 до 16 был обед. На полчаса задержать участников — это нормально, совсем не пустить на обед — жестоко.
Несколько фактов по ходу финала. Первая задача была решена уже через 4 (sic!) минуты после старта. У нас три раза за время финала менялся лидер, а тройка лидеров и вообще менялась очень динамично. Несколько человек запускали в фоне подбор решения брутфорсом, ни одному не удалось достичь в этом успеха (не зря мы на это закладывались). Один раз база так тормозила (не хватило памяти, сервер ушёл в своп), что мы боялись, что придётся её перезапускать, но постепенно ситуация выровнялась. Лидеры смогли решить все шесть штатных задач и застряли на седьмой. Дошедших до седьмой задачи было четверо.
Последний факт примечателен вот чем. На оргсобрании накануне финала организаторы попросили нас, тех кто проводил финалы, скрыть в тайне победителей, чтобы до понедельника, до самого вручения призов сохранить интригу. Нас это застало врасплох, так как с нашим подходом победителя не заметить можно с теми же шансами, что и не увидеть, кто прибежал первым в масс-старте — только если понадобился фотофиниш. И в нашем случае именно это и произошло. Участники довольно быстро установили между собой, кто насколько далеко прошёл, и четыре кандидата на победу самоопределились. Но вот понять, кто был первым, а кто последним — без логов это было проблематично.
Благодаря выбранной схеме проведения финала протокол соревнований я заполнил буквально с экрана своего компьютера, на котором как раз работал запрос, которым мы следили за ходом соревнований. Вот с последнего его запуска и переписаны были места участников, их баллы (количество решённых задач) и время (решения последней задачи).
### Культурная программа
Наш вклад в культурную программу ограничился только тем, что в субботу мы провели семинар, на котором привели свои референсные решения задач второго тура и сделали их краткий разбор. Разбор получился действительно кратким, потому что времени было мало, а аудитория была не совсем та, кому это было интересно. Поэтому получилось галопом по Европам и без интерактива, мне самому не понравилось.
В остальном я не участвовал, до награждения тоже не стал задерживаться — дела знаете ли.
### Пара слов напоследок
И напоследок. Не могу не восхититься участниками. Сам я, хоть и готовил эту олимпиаду и решал походу самостоятельно почти все задачи, точно не смог бы показать такие же результаты в тех условиях ограниченного времени, в которые мы специально поставили участников.
Финалисты! Пара слов вам лично. Вы — мегакруты! Причём все, даже те, кому по каким-либо причинам не удалось показать себя с лучшей стороны. Извините, если что-то было не так, мы старались, но не всё от нас зависело, а что-то просто не получилось. А Земля, она имеет форму чемодана, и в одном из его тёмных углов мы когда-нибудь обязательно встретимся. Только теперь может оказаться, что уже вы будете устраивать это шоу. Наверное будет интересно, если вы оставите в комментариях свои впечатления, как эти же события смотрелись с вашей стороны. | https://habr.com/ru/post/350528/ | null | ru | null |
# Эти забавные BroadcastReceiver'ы
Небольшое наблюдение о различном поведении `BroadcastReceiver`'ов при регистрации через `AndroidManifest.xml` и непосредственно в коде. Данная заметка не является пошаговым руководством для новичков, а всего лишь призвана сэкономить время тем, кому еще не довелось наступить на похожие грабли.
Так уж вышло, волею ~~project manager~~ судьбы, довелось мне писать программу, блокирующую все и вся во благо беззащитных деток. Оставим в стороне этическую составляющую вопроса и психическую адекватность родителей, которые выкидывают сотни три-четыре евро на смартфон для дитяти, а потом с завидным упорством ищут софт, который превратит это высокотехнологичное устройство в кирпич десятилетней давности: без интернета, без смс, без звонков, без приложений… без надежды на будущее. Попытка заменить воспитание тотальным контролем – верный способ вырастить безвольного имбецила, но чукча здесь не решатель, чукча кодо-писатель, так что предлагаю сосредоточиться на технической стороне дела.
Конкретная подзадача такого рода программ: получать уведомления о смене состояний мобильного интернета, Wi-Fi, Bluetooth и блокировать их в зависимости от степени параноидальности опекающего. Как известно, такого рода оповещения в андроиде реализованны через `BroadcastReceiver`'ы. Также, не секрет, что зарегистрировать *receiver* можно двумя способами: в файле `AndroidManifest.xml` и непосредственно в `Activity`(или `Service`, как вариант). Рассмотрим оба способа.
##### AndroidManifest.xml
`/* тут демонстрируется знание народного фольклора и производится сравнение с паренной репой*/`. Не мудрствуя лукаво, подпишемся на нужные нам события. В данном случае, это *action*'ы так или иначе содержащие в себе *change*.
```
```
Соответствующие им классы выглядят не намного сложнее и в общем виде соответствуют следующему шаблону:
```
public class MyReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Log.d("MyReceiver", "onReceive");
}
}
```
Нас интересует хронология вызовов, поэтому будем вести лог наступления основных событий.
Результат ~~на лицо~~ в ***LogCat***:
| | | |
| --- | --- | --- |
| **Application** | **Tag** | **Text** |
| com.habr | MyActivity | onCreate |
и при каждом вкл/выкл соответсвующей опции получим к примеру:
| | | |
| --- | --- | --- |
| **Application** | **Tag** | **Text** |
| com.habr | WiFiReceiver | onReceive |
Все довольно предсказуемо.
##### Программно.
Сначала проделаем этот нехитрый трюк на примере *Bluetooth*.
```
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.d("MyActivity", "onCreate");
}
@Override
protected void onResume() {
super.onResume();
receiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.e("BluetoothReceiver", "onReceive");
}
};
registerReceiver(receiver, new IntentFilter(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED));
}
@Override
protected void onPause() {
super.onPause();
unregisterReceiver(receiver);
}
```
Поведение будет идентично предыдущим запускам и у многих в голове уже наверняка не первый раз пронеслась мысль «зачем, таки, он делает нам доктора и кого он здесь вообще лечит?», но попробуйте запустить тот же код, изменив *action* на `WifiManager.WIFI_STATE_CHANGED_ACTION` или `ConnectivityManager.CONNECTIVITY_ACTION` и тут, привет ребятам из андроид, вы обнаружите, что ***LogCat*** показывает следующее:
| | | |
| --- | --- | --- |
| **Application** | **Tag** | **Text** |
| com.habr | MyActivity | onCreate |
| com.habr | WiFiReceiver | onReceive |
| com.habr | DataReceiver | onReceive |
Фактически, это означает, что `onReceive` обоих *receiver*'ов вызвался сразу, вообще вне зависимости от состояния соответствующих опций и только *Bluetooth* повел себя корректно.
##### Вывод
Представьте себе простую ситуацию: задача приложения оборвать интернет. В момент установки приложения, он может быть как включенным так и выключенным. Если он уже включен, и вы регистрируетесь через `AndroidManifest.xml`, то вам, just to be sure, придется вызвать код блокировки из *receiver*'a самостоятельно, т.к. системой вы оповещены не будете и это правильно, потому что вы опоздали на обед, соответствующее оповещение пробросилось, когда вас с вашим приложением в системе еще не было. Если же вы все сделали программно, то делать отдельный вызов не придется. Опять же, при условии, что дело не касается *Bluetooth*. Если задаться вопросом «А, собсна, ~~какого~~ почему?», то ответ скорее всего будет «Потому что могем!». Как по мне, так это чистой воды баг и логики никакой не просматривается. Надеюсь эта статья сэкономит кому-то тот день, который я убил, чтобы понять в чем причина непослушания адской машины.
Все вышеописанное воспроизводится на всех версиях *Android*, начиная с *Gingerbread* и выше(ниже просто не тестировал).
Что касается непосредственно методов фильтрации звонков, смс, интернета и т.д., то, если не ошибаюсь, тема уже частично освещалась, например [здесь](http://habrahabr.ru/post/149555/). Но, если это интересно, то я мог бы попробовать внести свою лепту так, чтобы никого не дублировать. | https://habr.com/ru/post/149875/ | null | ru | null |
# Один день из жизни DBA Microsoft SQL Server
В арсенале Microsoft SQL Server есть одна интересная штука – **service broker**. По сути своей это очередь сообщений, встроенная в СУБД, способная обеспечить транзакционную целостность данных. Вещь удобная и, в грамотных руках, способная выстроить систему обмена между SQL Server’ами без применения дополнительных внешних сервисов – прямо из коробки.
С одной стороны service broker удобен, но с другой – от него не мало сюрпризов, способных поломать голову нюансами своей работы. О решении одного из таких сюрпризов поговорим прямо сейчас.
Обнаружили, что логи MS SQL Server, одной из наших, систем жутко забиты сообщениями от service broker типа :
```
An error occurred in dialog transmission: Error: 601, State: 3.
Could not continue scan with NOLOCK due to data movement.
```
Не долгие поиски на просторах всемирной сети так или иначе выводили на информацию о том, что какие то данные в БД закораптились и требуется их обнаружение (для дальнейшего восстановления) при помощи инструкции **DBCC CHECKDB**. Счастье было не долгим, ибо данный подход не выявил ни одной проблемы – ни в пользовательских БД, ни в системных.
Так как логи продолжали ужасать своим натиском (пару десятков записей за несколько секунд), а первый план по выявлению причин этого “наводнения” провалился – было решено вести поиски на стороне service broker, ибо читался след от брокера – как минимум по словам “dialog transmission ”.
Подобные поиски в системах начинаются с просмотра очереди на отправку **sys.transmission\_queue** – не стал исключением и наш случай. Первый же select из sys.transmission\_queue вывалил на экран тот самый “*Could not continue scan with NOLOCK due to data movement*”, что с одной стороны вселило уверенности, что копаем в правильную сторону, но с другой – как выявить проблему, если select заканчивается таким сообщением?
Лезем в данные по конечным точкам диалогов **sys.conversation\_endpoints**. С ужасом обнаруживаю, что там висит около 12 миллионов не закрытых диалогов. Первые 10 минут зачистки ненужных накоплений показали, что впереди нас ждет целая неделя ожиданий – ибо чистка протекала крайне медленно. Само закрытие диалога было долгим. У нас был главный подозреваемый — куча не закрытых диалогов service broker'а и надо было его “расколоть”.
Так как сидеть целую неделю, и закрывать диалоги не хотелось, был накидан такой план:
1. через sqlcmd пачками вычитываем хендлеры подвисших диалогов
2. формируем sql batch на завершение полученых диалогов
3. через sqlcmd выполняем сформированный sql batch и гоняем это по циклу, пока не закроем все подвисшие диалоги
```
set nocount on;
select 'set nocount on;'
union all
select 'set xact_abort off;'
union all
select top 900 'end conversation ''' + cast(conversation_handle as varchar(100)) + ''' with cleanup;' from sys.conversation_endpoints where far_service = '//far_db.far_host/far_service'
```
batch.sql (пример sql batch – для пункта 2)
```
@echo off
for /L %%B in (0,1,13000) do (
sqlcmd -i c:\usr\sql_cd.sql -o c:\usr\res.sql -S server_name -d db_name -r1
sqlcmd -i c:\usr\res.sql -S server_name -d db_name -r1
del c:\usr\res.sql
)
```
end\_conversation.bat (батник для пунктов 1 и 3)
Этот товарищ отработал чуть менее двух суток и закрыл все подвисшие диалоги. Как видно из примера – все эти диалоги были открыты для одного конкретного сервиса. С самим удаленным сервисом брокера разобрались до начала массового закрытия диалогов.
К счастью или сожалению, но после закрытия всех не нужных диалогов брокера – ошибки в логах так и не прекратились массово появляться.
Следующей мыслью было потушить **service broker end point** на СУБД в целом и отключить брокер на основной БД в частности, но и это, увы, не спасло от продолжающихся ошибок в логах.
В какой то из дней решения вопроса возникла необходимость переключиться на зеркало от основной БД. Именно в момент переключения на зеркало нашей БД и вылезла в логах информация о проблеме:
*16:42:40.41 spid41s SQL Server detected a logical consistency-based I/O error: incorrect pageid (expected 6:260707; actual 559:-641654744). It occurred during a read of page (6:260707) in database ID 2 at offset 0x0000007f4c6000 in file 'D:\TempDB\tempdb\_mssql\_5.ndf'. Additional messages in the SQL Server error log or operating system error log may provide more detail. This is a severe error condition that threatens database integrity and must be corrected immediately. Complete a full database consistency check (DBCC CHECKDB). This error can be caused by many factors; for more information, see SQL Server Books Online.*
Глядя на неё и стало понятно, что виновником торжества выступает **tempdb** нашей СУБД.
Как известно, у **tempdb** одно лекарство – рестарт службы sql. Выбиваем окно у бизнеса для простоя сервиса и перезагружаем основную ноду. После рестарта сервера логи перестало заваливать.
Как оказалось – проблема на самом деле крылась в закорапченных данных. Так, что применяя **DBCC CHECKDB** – не забывайте применять его и к **tempdb** и следите за диалогами. | https://habr.com/ru/post/569008/ | null | ru | null |
# Интуитивное программирование
За свой относительно небольшой опыт работы (порядка 6 лет) я довольно часто слышал фразы опытных и начинающих программистов — «Я чувствую, что это должно работать», «У меня есть ощущение, что этот метод работать не будет», «Давайте сделаем интуитивно-понятный интерфейс» и так далее. Всё это — проявление интуиции в процессе разработки и программировании.
О ней и пойдёт дальше разговор.
*Взято с сайта oprah.com*
Для начала хотелось бы определить само понятие «интуиция».
> Интуи́ция (позднелат. intuitio — «созерцание», от глагола intueor — пристально смотрю) — метод решения задач посредством единомоментного подсознательного вывода, **основанный на воображении, эмпатии и предшествующем опыте, «чутьё», проницательность**.
>
>
>
> «Википедия»
> Интуиция (от лат. intueri – пристально, внимательно смотреть) — мыслительный процесс, состоящий в практически моментальном нахождении решения задачи при недостаточной осознанности логических связей.
> Интуиция (от лат. intueri — пристально, внимательно смотреть) — знание, возникающее без осознания путей и условий его получения, в силу чего субъект имеет его как результат «непосредственного усмотрения»
Основой данных определений является то, что интуиция — это некий способ принятия решения. Оснований у этого способа может быть несколько: это и предшествующий опыт, и воображение, и иррациональное «чутьё», и т.д.
И каждый из этих способов находит отражение в процессе программирования, причём может оказывать как позитивное, так и негативное влияние.
Поэтому, прежде всего, хотелось бы разделить «интуитивное» программирование на 2 составляющих: - **оптимистическое и пессимистическое**
Оптимистическое интуитивное программирование
--------------------------------------------
Суть его заключается в оптимистическом или позитивном влиянии интуиции на процесс создания кода. В данном случае интуиция является помощником, «добрым другом», инструментом в руках разработчика.
### Интуиция, основанная на опыте
Основная идея здесь заключается в том, что в процессе накопления опыта разработки у нас складываются определённые стереотипы, ассоциации, связанные с кодом, которые мы способны определять без углубления в мыслительный процесс.
Большое количество примеров использования такой интуиции в процессы работы описал Дмитрий Чепель из Acronis в своей [статье на Хабре](https://habrahabr.ru/company/acronis/blog/213271/). Если Вы ещё не читали, обязательно прочитайте.
Я бы хотел предложить вам другой пример-эксперимент. Ниже приведён пример кода на языке Sidef (я надеюсь не многие из Вас знают его). Попробуйте не особо вникая в детали, догадаться о чём он:
```
loop {
var swapped = false
{ |i|
if (arr[i-1] > arr[i]) {
arr[i-1, i] = arr[i, i-1]
swapped = true
}
} * arr.end
swapped || break
}
return arr
```
**Ответ**Это классическая сортировка «пузырьком»
Возможно, часть из Вас догадалась о чём идёт речь, увидев в коде знакомые части, возможно некоторые нет. Я попробовал провести этот эксперимент на небольшой группе своих знакомых программистов и результат таков — больше половины (порядка 65%) человек смогли за очень короткое время понять о чём идёт речь.
Я уточнил у них, каким образом они смогли догадаться — и самым популярным ответом было:
«Мы увидели знакомые куски кода и сразу предположили что это такое».
Таким образом, накапливая опыт, наш мозг способен очень быстро без дополнительных умственных усилий принимать решения касательно кода, с которым мы работаем.
Именно из-за этого нам кажется, что более опытные программисты обладают неким «чутьём» касательно проекта или какого-либо языка программирования.
### Интуиция, основанная на логике
Попроуйте продолжить следующий ряд:
> 1, 3, 5, 7, 9, 11, ...
Наверняка Вы ни на секунду не задумались, какое число будет дальше.
Это простой пример закономерности, которую мы можем продолжить буквально не задумываюсь.
Но что, если взять для примера следующий кусок кода на Python:
```
def sum(a, b):
...
def mult(a, b):
...
def subtract(a, b):
...
def divide(a, b):
...
def calculate(a, b, strategy):
...
calculate(4, 2, sum) #6
calculate(4, 2, mult) #8
calculate(4, 2, subtract) #2
calculate(4, 2, divide) #??
```
Даже не видя исходного кода, мы «интуитивно» чувствуем, каким будет результат выполнения последней функции в списке.
Это происходит благодаря тому, что мы анализируем названия функций, сопоставляем их с получаемым результатом и таким образом строим некоторые закономерности, предположения насчёт анализируемого кода. Таким образом, мы подключаем нашу интуицию, подкреплённую логикой, для чтения такого кода.
Здесь хотелось бы отметить, что код, который соответсвует нашим предположениям, нашей интуиции, мы обычно называем «удобочитаемым», «понятным» кодом. Это связано с тем, что мы задействуем не только ресурс нашего мозга, но и нашу интуицию, тем самым упрощая чтение и понимание кода.
### Интуитивно-понятный интерфейс
И сейчас хотелось бы перейти к такому часто используемому выражению как «интуитивно-понятный интерфейс». Это касается как и программного, так и пользовательского интерфейса.
Учитывая вышеизложенные пункты, можно сказать, что интуитивно-понятный интерфейс — это интерфейс, которые соответсвует ожиданиям пользователя, будь то программист или конечный пользователь.
Ожидания же эти формируются на основе 2 составляющих — нашего предыдущего опыта и логических закономерностей и предположений.
Если на всех страницах вашего веб-сайта меню было сверху, но на странице Обратной связи меню слева, то конечный пользователь может прийти в некоторое замешательство, поскольку «его интуиция» подсказывает ему, что меню должно быть сверху.
Но почему же иногда, когда мы заходим на какой-то веб-сайт с оригинальным дизайном или новое мобильное приложение, у нас складывается ощущение, что этот сайт выглядит круто или ужасно?
### Интуиция как иррациональное
Основой такого суждения, является то, что часто интуиция рождается как просто ощущение чего-то, неподкреплённое какими-либо выводами, логикой или опытом.
Такой вид интуиции является самым опасным в разработке, но и в тоже время он является способом быстрого решения сложных проблем.
Это как раз то, что называется «магией» в программировании — мы меняем значение одной переменной или флага и чудесным образом наш код начинает работать, хотя это решение было принято абсолютно инстинктивно. И как раз такой вид интуиции является истинным её проявлением.
Пессимистическое инстинктивное программирование
-----------------------------------------------
Но интуиция может нести и негативный характер при разработке.
Как упоминалось выше «иррациональная» интуиция является одновременно и палочкой-выручалочкой и опасным инструментом в руках программиста.
Опираясь на такие инстинктивные решения мы теряем уверенность в написанном нами коде, в котором начинает происходить «магия».
Что немаловажно, такие решения формируют некоторый уровень беспокойства при принятии последующих решений. Преобладание чувств, ощущений, иррационального при разработке приводит к невозможности обоснования всего с помощью логики, и как результат — усложнению понимания кода, потери читабельности.
### В качестве заключения
В целом вопрос интуиции при разработке программного обеспечения поднимается не впервые.
Это связано с тем, что проблема влияния процессов, несвязанных с логикой и мышлением, на процесс написания кода будет оставаться актуальным, поскольку этим процессом занят человек, обладающий чувствами, предрассудками, «иррациональным».
P.S. Для тех, же кому интересна тема интуции в разработке ПО, советую почитать [доклад Питера Науэра «Интуиция в разработке программного обеспечения»](http://elib.ict.nsc.ru/jspui/bitstream/ICT/1343/1/peter_naur_1985r.pdf)
Спасибо! | https://habr.com/ru/post/318502/ | null | ru | null |
# Архитектура фронтенда и какой она должна быть
Все мы знаем про, или слышали про практики и паттерны проектирования ***SOLID, GRASP, MVC, MV\*\**** *и даже применяем их с переменным успехом, стараясь нащупать эффективный подход к построению приложений. Но это лишь приводит к разнообразию реализаций наших приложений и частей функционала.*
И поэтому я уже долгое время пытаюсь понять по каким правилам должно строиться фронтенд приложение чтобы оно удовлетворяло следующим критериям:
* легкое расширение функционала приложения;
* безболезненное внесение изменений в существующий функционал;
* унифицированная структура приложения;
* быстрый onboarding новых разработчиков на проект;
* понятный и прозрачный код;
* всегда понятно где в структуре файлов расположить ту или иную функциональность.
Какие у нас есть варианты?
---
«Организация файловой структуры это все что нам нужно»
------------------------------------------------------
Каждый лид или сеньор сами для себя выбирают варианты компоновки структуры приложения и выделения сущностей приложения. По итогу каждая система становится уникальной и неповторимой. И для того, чтобы разобраться в ней, нужны время и усилия, которые нужно будет тратить каждый раз при смене проекта. Плюс никто не отменял "[бас фактор](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BA%D1%82%D0%BE%D1%80_%D0%B0%D0%B2%D1%82%D0%BE%D0%B1%D1%83%D1%81%D0%B0#:~:text=bus%20factor%2C%20%D0%BB%D0%B8%D0%B1%D0%BE%20truck%20factor,%D1%83%20%D0%BD%D0%B8%D1%85%20%D1%80%D0%B5%D0%B1%D1%91%D0%BD%D0%BA%D0%B0%2C%20%D0%BD%D0%B0%D1%81%D1%82%D1%83%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F%20%D0%BD%D0%B5%D1%81%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%BE%D0%B3%D0%BE)".
Существует большое кол-во статей, описывающих «оптимальные», по мению авторов, варианты таких подходов. [Пример](https://clck.ru/hnGZh).
Но это, в основном, про структуру файлов и частные случаи использования какого-то функционала. Такой подход только частично унифицирует структуру приложения, но этого мало для того, чтобы называться архитектурой. Может есть что-то лучше?
Domain Driven Design
--------------------
Много умных дядек, таких как Мартин Фаулер и дядюшка Боб, написали много статей про него. На бэкенде в больших и сложных проектах он неплохо себя зарекомендовал. Но есть и много изъянов: туча абстракций, для простых действий нужно писать много кода, ну и разобраться, как готовить DDD та еще задача.
[Есть примеры](https://habr.com/ru/post/654629) как готовить это на фронте, но, как видно, проблемы никуда не уходят и кол-во абстракций удручают. Простой onboarding тут невозможен, без прочтения "[The Big Blue Book](https://www.domainlanguage.com/ddd/blue-book/)" и пары недель общения с ментором.
Есть переосмысленные подходы к архитектуре, которые больше похожи на правду и наверняка могут где-то успешно применены.
[Основательная статья от Кхалила Стеммлера](https://khalilstemmler.com/articles/client-side-architecture/introduction/) о возможной архитектуре клиентских приложений частично полагается на DDD подход, но при этом сильно его упрощает, освобождая нас от ненужных абстракций и смещая понятия в сторону фронт приложений.
Но бизнес логика в таких приложениях немного размывается и подход больше сфокусирован на функциональных слоях приложения, что отдаляет нас от требования к прозрачному коду и явной бизнес логики.
Джимми Богарт[в своей статье](https://jimmybogard.com/vertical-slice-architecture/) пишет что DDD подход не совершенен и избыточен, и, как следствие, он предлагает переработанный подход **vertical slices**. И это отличный подход, о котором стоит почитать отдельно. Эта идея довольно простая и мы можем адаптировать ее к фронтенд приложениям.
Если DDD не удалось применить для наших нужд, то можно попробовать построить его на более общих правилах, которые предоставляет нам "Clear architecture", ведь DDD основывается именно на них.
Clear architecture
------------------
Также есть попытки следовать всем постулатам чистой архитектуры и абстрагироваться от представления совсем. В этом случае мы сможем подменять view на любой фреймворк или вообще отказаться от его использования. Интересный подход и в некоторых случаях вполне обоснован и может оказаться отличным решением. Самый частый кейс, это использование одной и той же логики в браузере и на мобильном приложении.
Подробнее об этом можно [почитать тут](https://dev.to/xurxodev/moving-away-from-reactjs-and-vuejs-on-front-end-using-clean-architecture-3olk).
Разработчики Flutter тоже столкнулись с проблемой сложности переиспользования логики между различными представлениями, и предложили подход - [Business Logic Component (BLoC)](https://pub.dev/packages/flutter_bloc). Он позволяет снизить нагрузку на компоненты пользовательского интерфейса, отделив от них бизнес-логику.
[Тут пример одной из реализаций BLoC в React](https://blog.bitsrc.io/using-bloc-pattern-with-react-cb6fdcfa623b).
Вроде неплохо, но все же есть много вопросов. И почти нет сообщества, которое бы могло помочь с возникающими вопросами.
FSD - Feature Sliced Design
---------------------------
И недавно для меня стало открытием методология FSD - Feature Sliced Design. На мой взгляд лучшем решением будет обратить внимание именно на эту методологию.
[Ссылка на офф сайт](https://feature-sliced.design/).
Методология не привязана к конкретному стеку технологий и применима к большинству frontend-приложений. Документация содержит примеры реализации на JavaScript + React, но FSD успешно адаптируется и к другим комбинациям инструментов.
Для проектирования архитектуры методология предлагает следующие архитектурные абстракциями на основе которых строиться наше приложение.
#### Ниже приведу описание терминов из документации:Layers
Первый уровень абстрагирования - **согласно скоупу влияния.**
* `app` - инициализация приложения *(init, styles, providers, ...);*
* `processes` - бизнес-процессы приложения управляющие страницами *(payment, auth, ...);*
* `pages` - страницы приложения *(user-page, ...);*
* `features` - части функциональности приложения *(auth-by-oauth, ...);*
* `entities` - бизнес-сущности *(viewer, order, ...);*
* `shared` - переиспользуемый инфраструктурный код *(UIKit, libs, API, ...).*
#### Slices
Второй уровень абстрагирования - **согласно бизнес-домену.**
Правила, по которым код разделяется на слайсы, *зависят от конкретного проекта и его бизнес-правил* и не определяются методологией
#### Segments
Третий уровень абстрагирования - **согласно назначению в реализации.**
* `ui` - UI-представление модуля *(components, widgets, canvas, ...);*
* `model` - бизнес-логика модуля *(store, effects/actions, hooks/contracts, ...);*
* `lib` - вспомогательные библиотеки;
* `api` - логика взаимодействия с API;
* `config` - модуль конфигурации приложения и его окружения.
Ниже приведу пример описания фичи авторизации.
```
# Сегменты могут быть как файлами, так и директориями
|
├── features/auth # Layer: Бизнес-фичи
| | # Slice Group: Структурная группа "Авторизация пользователя"
| ├── by-phone/ # Slice: Фича "Авторизация по телефону"
| | ├── ui/ # Segment: UI-логика (компоненты)
| | ├── lib/ # Segment: Инфраструктурная-логика (helpers/utils)
| | ├── model/ # Segment: Бизнес-логика
| | └── index.ts # [Декларация Public API]
| |
| ├── by-oauth/ # Slice: Фича "Авторизация по внешнему ресурсу"
| ...
```
Помимо унификации структуры, мы получаем наглядную бизнес логику, отличное описание слоев приложения с примерами на популярных ЯП. Также есть ответы на вопросы о расположении функционала и понятные правила уменьшения зависимостей в коде.
Эта методология только развивается и есть хорошее комьюнити, которое так же как и мы задается вопросами архитектуры фронтенда.
Заключение
----------
У каждого из подходов есть свои плюсы и минусы. Учитывая что каждый проект имеет разный размер, сложность и специфику и цели, то что подойдет многим не факт что подойдет вам. Надеюсь что после прочтения статьи вы откроете для себя что то новое и сможете улучшить ваши собственные проекты.
Также если вам интересно в [своем Telegram](https://t.me/devreverza) я время от времени выкладываю интересные находки по фронтенду. И всем чистой архитектуры. | https://habr.com/ru/post/667214/ | null | ru | null |
# Локальные файлы при переносе приложения в Kubernetes
При построении процесса CI/CD с использованием Kubernetes порой возникает проблема несовместимости требований новой инфраструктуры и переносимого в неё приложения. В частности, на этапе сборки приложения важно получить *один* образ, который будет использоваться во *всех* окружениях и кластерах проекта. Такой принцип лежит в основе правильного [по мнению Google](https://habr.com/ru/company/flant/blog/425085/) управления контейнерами (не раз об этом [говорил](https://habr.com/ru/company/flant/blog/322686/) и наш техдир).
Однако никого не удивишь ситуациями, когда в коде сайта используется готовый фреймворк, использование которого накладывает ограничения на его дальнейшую эксплуатацию. И если в «обычной среде» с этим легко справиться, в Kubernetes подобное поведение может стать проблемой, особенно когда вы сталкиваетесь с этим впервые. Хотя изобретательный ум и способен предложить инфраструктурные решения, кажущиеся очевидными и даже неплохими на первый взгляд… важно помнить, что большинство ситуаций могут и должны **решаться архитектурно**.
Разберем популярные workaround-решения для хранения файлов, которые могут привести к неприятным последствиям при эксплуатации кластера, а также укажем на более правильный путь.
Хранение статики
----------------
Для иллюстрации рассмотрим веб-приложение, которое использует некий генератор статики для получения набора картинок, стилей и прочего. Например, в PHP-фреймворке Yii есть встроенный менеджер ассетов, который генерирует уникальные названия директорий. Соответственно, на выходе получается набор заведомо не пересекающихся между собой путей для статики сайта (сделано это по нескольким причинам — например, для исключения дубликатов при использовании одного и того же ресурса множеством компонентов). Так, из коробки, при первом обращении к модулю веб-ресурса происходит формирование и раскладывание статики (на самом деле — зачастую симлинков, но об этом позже) с уникальным для данного деплоя общим корневым каталогом:
* `webroot/assets/2072c2df/css/…`
* `webroot/assets/2072c2df/images/…`
* `webroot/assets/2072c2df/js/…`
Чем это чревато в разрезе кластера?
### Простейший пример
Возьмем довольно распространенный кейс, когда перед PHP стоит nginx для раздачи статики и обработки простых запросов. Самый простой способ — *Deployment* с двумя контейнерами:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: site
spec:
selector:
matchLabels:
component: backend
template:
metadata:
labels:
component: backend
spec:
volumes:
- name: nginx-config
configMap:
name: nginx-configmap
containers:
- name: php
image: own-image-with-php-backend:v1.0
command: ["/usr/local/sbin/php-fpm","-F"]
workingDir: /var/www
- name: nginx
image: nginx:1.16.0
command: ["/usr/sbin/nginx", "-g", "daemon off;"]
volumeMounts:
- name: nginx-config
mountPath: /etc/nginx/conf.d/default.conf
subPath: nginx.conf
```
В упрощенном виде конфиг nginx сводится к следующему:
```
apiVersion: v1
kind: ConfigMap
metadata:
name: "nginx-configmap"
data:
nginx.conf: |
server {
listen 80;
server_name _;
charset utf-8;
root /var/www;
access_log /dev/stdout;
error_log /dev/stderr;
location / {
index index.php;
try_files $uri $uri/ /index.php?$args;
}
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
include fastcgi_params;
}
}
```
При первом обращении к сайту в контейнере с PHP появляются ассеты. Но в случае с двумя контейнерами в рамках одного pod’а — nginx ничего не знает об этих файлах статики, которые (согласно конфигурации) должны отдаваться именно им. В результате, на все запросы к CSS- и JS-файлам клиент увидит ошибку 404. Самым простым решением тут будет организовать общую директорию к контейнерам. Примитивный вариант — общий `emptyDir`:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: site
spec:
selector:
matchLabels:
component: backend
template:
metadata:
labels:
component: backend
spec:
volumes:
- name: assets
emptyDir: {}
- name: nginx-config
configMap:
name: nginx-configmap
containers:
- name: php
image: own-image-with-php-backend:v1.0
command: ["/usr/local/sbin/php-fpm","-F"]
workingDir: /var/www
volumeMounts:
- name: assets
mountPath: /var/www/assets
- name: nginx
image: nginx:1.16.0
command: ["/usr/sbin/nginx", "-g", "daemon off;"]
volumeMounts:
- name: assets
mountPath: /var/www/assets
- name: nginx-config
mountPath: /etc/nginx/conf.d/default.conf
subPath: nginx.conf
```
Теперь генерируемые в контейнере файлы статики отдаются nginx’ом корректно. Но напомню, что это примитивное решение, а значит — оно далеко от идеала и имеет свои нюансы и недоработки, о которых ниже.
### Более продвинутое хранилище
Теперь представим ситуацию, когда пользователь зашёл на сайт, подгрузил страницу с имеющимися в контейнере стилями, а пока он читал эту страницу, мы повторно задеплоили контейнер. В каталоге ассетов стало пусто и требуется запрос к PHP, чтобы запустить генерацию новых. Однако даже после этого ссылки на старую статику будут неактуальными, что приведет к ошибкам отображения статики.
Кроме того, у нас скорее всего более-менее нагруженный проект, а значит — одной копии приложения не будет достаточно:
* Отмасштабируем *Deployment* до двух реплик.
* При первом обращении к сайту в одной реплике создались ассеты.
* В какой-то момент ingress решил (в целях балансировки нагрузки) отправить запрос на вторую реплику, и там этих ассетов еще нет. А может быть, их там уже нет, потому что мы используем `RollingUpdate` и в данный момент делаем деплой.
В общем, итог — снова ошибки.
Чтобы не терять старые ассеты, можно изменить `emptyDir` на `hostPath`, складывая статику физически на узел кластера. Данный подход плох тем, что мы фактически должны **привязаться к конкретному узлу кластера** своим приложением, потому что — в случае переезда на другие узлы — директория не будет содержать необходимых файлов. Либо же требуется некая фоновая синхронизация директории между узлами.
Какие есть пути решения?
1. Если железо и ресурсы позволяют, можно воспользоваться [cephfs](https://github.com/kubernetes/examples/blob/master/volumes/cephfs/cephfs.yaml) для организации равнодоступной директории под нужды статики. [Официальная документация](https://docs.ceph.com/docs/jewel/start/hardware-recommendations/) рекомендует SSD-диски, как минимум трёхкратную репликацию и устойчивое «толстое» подключение между узлами кластера.
2. Менее требовательным вариантом будет организация NFS-сервера. Однако тогда нужно учитывать возможное повышение времени отклика на обработку запросов веб-сервером, да и отказоустойчивость оставит желать лучшего. Последствия же отказа катастрофичны: потеря mount’а обрекает кластер на гибель под натиском нагрузки LA, устремляющейся в небо.
Помимо всего прочего, для всех вариантов создания постоянного хранилища потребуется **фоновая очистка** устаревших наборов файлов, накопленных за некий промежуток времени. Перед контейнерами с PHP можно поставить *DaemonSet* из кэширующих nginx, которые будут хранить копии ассетов ограниченное время. Это поведение легко настраивается с помощью `proxy_cache` с глубиной хранения в днях или гигабайтах дискового пространства.
Объединение этого метода с упомянутыми выше распределенными файловыми системами даёт огромное поле для фантазий, ограничение лишь в бюджете и техническом потенциале тех, кто это будет реализовать и поддерживать. По опыту же скажем, что чем проще система, тем стабильнее она работает. При добавлении подобных слоёв поддерживать инфраструктуру становится гораздо сложнее, а вместе с этим увеличивается и время, затрачиваемое на диагностику и восстановление при любых отказах.
### Рекомендация
Если реализация предлагаемых вариантов хранилищ вам тоже кажется неоправданной (сложной, дорогой…), то стоит посмотреть на ситуацию с другой стороны. А именно — копнуть в архитектуру проекта и **искоренить проблему в коде**, привязавшись к какой-то статической структуре данных в образе, обеспечить однозначное определение содержимого или процедуры «прогрева» и/или прекомпиляции ассетов на этапе сборки образа. Так мы получаем абсолютно предсказуемое поведение и одинаковый набор файлов для всех окружений и реплик запущенного приложения.
Если вернуться к конкретному примеру с фреймворком Yii и не углубляться в его устройство (что не является целью статьи), достаточно указать на два популярных подхода:
1. Изменить процесс сборки образа с тем, чтобы размещать ассеты в предсказуемом месте. Так предлагают/реализуют в расширениях вроде [yii2-static-assets](https://www.yiiframework.com/extension/sam-it/yii2-static-assets).
2. Определять конкретные хэши для каталогов ассетов, как рассказывается, например, в [этой презентации](https://www.slideshare.net/petrabarus/scaling-yii2-app) (начиная со слайда №35). Кстати, автор доклада в конечном счёте (и не без оснований!) советует после сборки ассетов на build-сервере загружать их в центральное хранилище (вроде S3), перед которым поставить CDN.
Загружаемые файлы
-----------------
Другой кейс, который обязательно выстрелит при переносе приложения в кластер Kubernetes, — хранение пользовательских файлов в файловой системе. Например, у нас снова приложение на PHP, которое принимает файлы через форму загрузки, что-то делает с ними в процессе работы и отдаёт обратно.
Место, куда эти файлы должны помещаться, в реалиях Kubernetes должно быть общим для всех реплик приложения. В зависимости от сложности приложения и необходимости организации персистивности этих файлов, таким местом могут быть упомянутые выше варианты shared-устройств, но, как мы видим, у них есть свои минусы.
### Рекомендация
Одним из вариантов решения является **использование S3-совместимого хранилища** (пусть даже какую-то разновидность категории self-hosted вроде minio). Переход на работу с S3 потребует изменений *на уровне кода*, а как будет происходить отдача контента на фронтенде, мы уже [писали](https://habr.com/ru/company/flant/blog/426739/).
Пользовательские сессии
-----------------------
Отдельно стоит отметить организацию хранения пользовательских сессий. Нередко это тоже файлы на диске, что в разрезе Kubernetes приведёт к постоянным запросам авторизации у пользователя, если его запрос попадёт в другой контейнер.
Отчасти проблема решается включением `stickySessions` на ingress *(фича поддерживается во всех популярных контроллерах ingress — подробнее см. в [нашем обзоре](https://habr.com/ru/company/flant/blog/447180/))*, чтобы привязать пользователя к конкретному pod’у с приложением:
```
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
name: nginx-test
annotations:
nginx.ingress.kubernetes.io/affinity: "cookie"
nginx.ingress.kubernetes.io/session-cookie-name: "route"
nginx.ingress.kubernetes.io/session-cookie-expires: "172800"
nginx.ingress.kubernetes.io/session-cookie-max-age: "172800"
spec:
rules:
- host: stickyingress.example.com
http:
paths:
- backend:
serviceName: http-svc
servicePort: 80
path: /
```
Но это не избавит от проблем при повторных деплоях.
### Рекомендация
Более правильным способом будет перевод приложения на **хранение сессий в memcached, Redis и подобных решениях** — в общем, полностью отказаться от файловых вариантов.
Заключение
----------
Рассматриваемые в тексте инфраструктурные решения достойны применения только в формате временных «костылей» (что более красиво звучит на английском как workaround). Они могут быть актуальны на первых этапах миграции приложения в Kubernetes, но не должны «пустить корни».
Общий же рекомендуемый путь сводится к тому, чтобы избавиться от них в пользу архитектурной доработки приложения в соответствии с уже хорошо многим известным [12-Factor App](https://12factor.net/ru/). Однако это — приведение приложения к stateless-виду — неизбежно означает, что потребуются изменения в коде, и тут важно найти баланс между возможностями/требованиями бизнеса и перспективами реализации и обслуживания выбранного пути.
P.S.
----
Читайте также в нашем блоге:
* «[Проксируем файлы из AWS S3 средствами nginx](https://habr.com/ru/company/flant/blog/426739/)»;
* «[7 лучших практик по эксплуатации контейнеров по версии Google](https://habr.com/ru/company/flant/blog/425085/)»;
* «[7 принципов проектирования приложений, основанных на контейнерах](https://habr.com/ru/company/flant/blog/353272/)» *(от Red Hat)*;
* «[7 недостающих факторов в подходе 12 Factor App](https://habr.com/ru/company/flant/blog/460363/)». | https://habr.com/ru/post/471582/ | null | ru | null |
# Уменьшение операций чтения/записи на Raspberry Pi
**Введение**
Итак, в интернете можно найти статьи о том что в Raspberry флешки «живут» 2-3 месяца, после чего приходят в негодность. Предложенные решения — заменить стандартную microSD карточку на USB HDD. Решение простое, надёжное, плюс повышается скорость чтения/записи. Но почему флешки так быстро «умирают»? Могут ли те же факторы навредить жёсткому диску? И так приступим!
**Матчасть** У флеш-накопителей есть ограниченное количество циклов записи. Значит если linux будет постоянно что то на неё писать — она может выйти из строя раньше времени. Жёсткие диски работают по другому принципу. Но для них мелкие операции чтения/записи тоже не особо полезны. Головка жёсткого диска может парковаться если он не используется определённый промежуток времени, это может делать система, а так же может быть заложенно в железе. В случае мелких операций чтения/записи, жёсткий диск постоянно не может запарковать головку (не критично) или паркует головку, и тут же начаинает что то читать/писать (вот это уже хуже).
Информация пишется страницами. Обычный размер страниы 4 кБ. Так что если мы хотим записать один байт, то или он поместится в буфер, или будет записанно 4 кБ. Если буфер заполнен, то страница записывается и дальнейшая запись идёт в следующую страницу, которая находится в ОЗУ.
Запись маленьких порций информации используется при журналировании файловой системы (даёт возможность не потерять информацию при сбое, например выключении питания), а так же функции логирования (сохрняют информацию о тех или иных системных событиях, или событиях программ). В raspberry логирование выполняет rsyslog[[1](https://losst.ru/nastrojka-rsyslog-v-linux)]
В Raspbian есть два демона, которые можно отключить для уменьшения нагрузки на корневой носитель информации. Отключив их можно выиграть в операциях записи, но проиграть в надёжности и возможности востановления. Это демон журналирования файловой системы и rsyslog. Так что если есть ценные данные которые будут храниться в корневом диске, то службу журналирования лучше не отключать. Если же raspberry используется как игрушка или есть возможность быстро заменить основной диск, то журналирование файловой системы можно отключить. Насчёт логирования аналогично, если вы не знаете зачем оно нужно, то достаточно сказать что если что то не работает, то неисправность нужно искать изначально в логах. Если захотите задать вопрос кому то на форуме, то скорее всего попросят скинуть логи. Так что если всё работает или вам проще переустановить систему чем разбираться что «посыпалось» — можете смело отключать логи.
Для просмотра обращений к накопителям можно использовать утилиту iotop. Для этого нужно запустить её с параметрами:
```
sudo iotop -o -a
```
**Установка iotop**
```
sudo apt-get install iotop
```
**Отключение логирования**
Для отключения логирования открываем:
```
sudo nano /etc/rsyslog.conf
```
и комментируем в нём две сткроки в секции MODULES:
```
$ModLoad imuxsock # provides support for local system logging
$ModLoad imklog # provides kernel logging support
```
**Должно получиться так:**
```
# /etc/rsyslog.conf Configuration file for rsyslog.
#
# For more information see
# /usr/share/doc/rsyslog-doc/html/rsyslog_conf.html
#################
#### MODULES ####
#################
#$ModLoad imuxsock # provides support for local system logging
#$ModLoad imklog # provides kernel logging support
#$ModLoad immark # provides --MARK-- message capability
# provides UDP syslog reception
#$ModLoad imudp
#$UDPServerRun 514
# provides TCP syslog reception
#$ModLoad imtcp
#$InputTCPServerRun 514
###########################
#### GLOBAL DIRECTIVES ####
###########################
#
# Use traditional timestamp format.
# To enable high precision timestamps, comment out the following line.
#
$ActionFileDefaultTemplate RSYSLOG_TraditionalFileFormat
#
# Set the default permissions for all log files.
#
$FileOwner root
$FileGroup adm
$FileCreateMode 0640
$DirCreateMode 0755
$Umask 0022
#
# Where to place spool and state files
#
$WorkDirectory /var/spool/rsyslog
#
# Include all config files in /etc/rsyslog.d/
#
$IncludeConfig /etc/rsyslog.d/*.conf
###############
#### RULES ####
###############
#
# First some standard log files. Log by facility.
#
auth,authpriv.* /var/log/auth.log
*.*;auth,authpriv.none -/var/log/syslog
#cron.* /var/log/cron.log
daemon.* -/var/log/daemon.log
kern.* -/var/log/kern.log
lpr.* -/var/log/lpr.log
mail.* -/var/log/mail.log
user.* -/var/log/user.log
#
# Logging for the mail system. Split it up so that
# it is easy to write scripts to parse these files.
#
mail.info -/var/log/mail.info
mail.warn -/var/log/mail.warn
mail.err /var/log/mail.err
#
# Logging for INN news system.
#
news.crit /var/log/news/news.crit
news.err /var/log/news/news.err
news.notice -/var/log/news/news.notice
#
# Some "catch-all" log files.
#
*.=debug;\
auth,authpriv.none;\
news.none;mail.none -/var/log/debug
*.=info;*.=notice;*.=warn;\
auth,authpriv.none;\
cron,daemon.none;\
mail,news.none -/var/log/messages
#
# Emergencies are sent to everybody logged in.
#
*.emerg :omusrmsg:*
#
# I like to have messages displayed on the console, but only on a virtual
# console I usually leave idle.
#
#daemon,mail.*;\
# news.=crit;news.=err;news.=notice;\
# *.=debug;*.=info;\
# *.=notice;*.=warn /dev/tty8
# The named pipe /dev/xconsole is for the `xconsole' utility. To use it,
# you must invoke `xconsole' with the `-file' option:
#
# $ xconsole -file /dev/xconsole [...]
#
# NOTE: adjust the list below, or you'll go crazy if you have a reasonably
# busy site..
#
daemon.*;mail.*;\
news.err;\
*.=debug;*.=info;\
*.=notice;*.=warn |/dev/xconsole
```
После перезагрузки система прекратит логирование. Проверяем:
```
sudo iotop -o -a
```
В выводе больше нет rsyslog.
**Отключение журналирования**
Тут есть небольшая сложность — раздел должен быть отмонтирован. Для этого можно использовать:
* другой компьютер с линуксом
* другой накопитель в качестве основного (например обычную флешку)
* другой компьютер + LifeCD с линуксом
В случае когда у вас microSD карта — раздел на котором стоит система будет определятся как mmcblk0p2.
Тут mmcblk0 — это сама карточка, а p2 — второй раздел на ней (первый по умолчанию boot). Eсли же вы используете USB накопитель, то раздел определиться как sda2. Если вы загружаетесь с другого компьютера то скорее всего он определиться как sdb2.
Далее выполняем:
```
sudo umount /dev/sdb2
sudo tune2fs -O ^has_journal /dev/sdb2
sudo e2fsck -f /dev/sdb2
```
После этого проверяем:
```
dmesg | grep EXT4
```
Выдаёт:
```
[ 5890.967580] EXT4-fs (sdb2): mounted filesystem without journal. Opts: (null)
```
Загружаемся с нашего накопителя, вводим:
```
sudo iotop -o -a
```
И видим что к жёсткому диску только изредка обращается LXDE. В виду того что эти обращения не систематичны (понаблюдаем минут 5-10) можно сказать что нагрузка на накопитель уменьшилась практически до нуля. | https://habr.com/ru/post/330160/ | null | ru | null |
# Уведомление о скачанных торрентах по SMS
Как то вечером, ожидая загрузку любимых LOST и Breaking Bad, захотелось прогуляться по теплому вечернему Минску в сторону парка Горького. Но вот незадача, примерное время скачивания торрента прыгает то вверх, то вниз, объективный прогноз дождаться явно не получится.
Тут и пришла в голову, на мой взгляд, неплохая идея — почему бы не сделать уведомление о скачавшемся торренте по смске? Можно тогда вообще не заморачиваться томительным ожиданием и делать свои дела. :)
Вот что из этого получилось...
Так как я пользуюсь торрент-клиентом uTorrent, в моем распоряжении оказался [Web API](http://www.utorrent.com/developers/webapi), через который можно получать информацию и управлять всеми параметрами клиента. Важно поставить галку Использовать Web-интерфейс и вторую галку для разрешения гостевого доступа.
Web API выдает все в формате json, так что проблем с разбором словаря практически не возникло. Меня интересовали торренты, которые, разумеется, еще не закачаны. Из всего, что передается — берем оставшееся время или процент выполнения (кому как нравится), проверяем его периодически, довольно просто:
> `ss := TStringStream.Create('');
>
> idhttp1.get('http://localhost:' + port +'/gui/token.html', ss);
>
> token := ss.DataString;
>
> token := copy(token, pos(';''>', token) + 3, length(token));
>
> token := copy(token, 1, pos('<', token) - 1);
>
> url := 'http://localhost:' + port + '/gui/?token=' + token +
>
> '&list=1';
>
> idhttp1.Get(url, ss);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее парсим, что выдает торрент:
`"torrents": [
[
ХЭШ (строка),
STATUS* (целое число),
ИМЯ (строка),
РАЗМЕР (целое число в байтах),
ПРОЦЕНТ ВЫПОЛНЕНИЯ (целое число на тысячу),
ЗАГРУЖЕНО (целое число в байтах),
РОЗДАНО (целое число в байтах),
...и так далее, смотрите лучше документацию, тут только кусочек.`
Что в реальности выглядит как:
`{"build":19648,"label": ['#$A']'#$A',"torrents": ['#$A#$A'["08FAC4E006CBEB094D637849EC89023778BE7B55",201,"Patch",19257463,0,0,0,0,0,0,-1,"",0,11,0,0,0,1,19257463]]'#$A',"torrentc": "1014060939"}'#$A`
Ладно, список торрентов получили, надо теперь еще сделать отправку смски. Взял для этого готовую библиотеку AvisoSMS, к слову сказать, довольно просто ее оказалось прикрутить, не ожидал. [Ссылка на DLL](http://avisosms.ru/solutions/dll/)
> `login := Edit1.Text;
>
> pass := Edit2.Text;
>
> sAdress := Edit3.Text;
>
> dAdress := Edit4.Text;
>
> if (dAdress = '') then
>
> dAdress := 'AvisoSMS';
>
> SendMessage(Pchar(login), PChar(pass), PChar(dAdress), PChar(sAdress), PChar('Торрент ' + torName + ' закачан'));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тестим на чем-нибудь легковесном…
Ура-ура.
Позже решил доработать программу, чтобы она могла прятаться в трей, иметь достойное GUI, работать на отслеживание не только одного торрента. Вывел в отдельный поток проверку. Правда не смог победить кракозябры кириллических названий загрузок. Видимо сказывается WebUI самого торрент-клиента.
Результируя: Удивила хитрая система маркеров для безопасности, но, надо сказать, по делу. Авторизация — стандартная… 401, так что проблем не возникло ни с API торрента, ни с смсками. Написано в CodeGear Rad Studio 2007. Интерфейс, конечно, не ахти, но для первого раза сойдет. Готов развивать программу совместно со всеми желающими, исходники и работающая версия ниже.
Исходники: [Скачать с Яндекс.Диска](http://narod.ru/disk/21416585000/TorWatchingSouce.rar.html)
Работающая версия в XP/Vista/7: [Скачать с Яндекс.Диска](http://narod.ru/disk/21416584000/TorWatchingFinal.rar.html)
P.S. Буду признателен за инвайт автору статьи и этой программы — Олегу Танасюку. Написана специально для хабра. | https://habr.com/ru/post/95149/ | null | ru | null |
# Новый GitLab 12.0 с визуальными ревью и списком зависимостей
### Dev, Sec и Ops
GitLab 12.0 — это ключевой выпуск на пути к реализации подхода, который будет охватывать все элементы DevSecOps и позволит всем вносить свой вклад.
У нас был очень увлекательный год — мы много работали над решением, которое объединило бы все команды. Сообщество внесло тысячи дополнений, чтобы GitLab стал еще круче.
Мы верим, что каждый может внести свой вклад, поэтому добавили функции для сотрудничества между разными командами, быстрой поставки отличного кода и объединения Dev, Sec и Ops.
### Визуальные ревью кода
Приложения для ревью GitLab — это удобные инструменты, с помощью которых кто угодно (от команды по обслуживанию и специалистов по контролю качества до владельцев компании) могут оценивать и одобрять изменения в приложениях до выпуска в продакшен.
В GitLab 12.0 можно [запросто предоставить визуальный фидбэк](https://about.gitlab.com/2019/06/22/gitlab-12-0-released/?utm_medium=social&utm_source=facebook#visual-reviews) прямо в приложении для ревью. Никаких лишних усилий, вроде переключения между вкладками и ввода текста, что позволяет сократить время на ревью и ускорить поставку.
### Список зависимостей проекта
Обычно проекты состоят из десятков отдельных компонентов, а это чревато уязвимостями. Специалисты по безопасности и соответствию требованиям должны знать обо всех компонентах проекта.
Теперь можно [легко просмотреть зависимости проекта](https://about.gitlab.com/2019/06/22/gitlab-12-0-released/?utm_medium=social&utm_source=facebook#project-dependency-list) в одном месте.
### Ограничение доступа по IP-адресу
Некоторые компании предпочитает ограничивать доступ к репозиториям по IP-адресам.
В GitLab 12.0 [можно запретить](https://about.gitlab.com/2019/06/22/gitlab-12-0-released/?utm_medium=social&utm_source=facebook#restrict-access-by-ip-address) доступ к данным на GitLab для трафика с внешних IP-адресов.
> Самый ценный сотрудник этого месяца ([MVP](https://about.gitlab.com/community/mvp/)) — [Wolphin](https://gitlab.com/q_wolphin).
>
>
>
> [Благодаря ему](https://about.gitlab.com/2019/06/22/gitlab-12-0-released/?utm_medium=social&utm_source=facebook#multiple-extends-support-in-gitlab-ciyml) теперь в GitLab CI поддерживается несколько extends, что заметно украсило и без того красивый примитив.
>
> Спасибо, Wolphin!
Главные фичи GitLab 12.0
------------------------
### Визуальные ревью кода
*STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD*
GitLab позволяет пользователям автоматически создавать [приложения для ревью](https://docs.gitlab.com/ee/ci/review_apps/) для каждого мердж-реквеста. Любой может посмотреть изменение проекта или пользовательского интерфейса.
В GitLab 12.0 обсуждать эти изменения еще удобнее благодаря [инструментам визуального ревью](https://gitlab.com/gitlab-org/gitlab-ee/issues/10761), доступным прямо в приложении для ревью. Один небольшой фрагмент кода — и дизайнеры, менеджеры продуктов и все, кого это касается, могут быстро оставлять фидбэк по мердж-реквесту, не выходя из приложения.
### Список зависимостей проекта
*ULTIMATE, GOLD*
Теперь из левого меню можно открыть список зависимостей проекта (иногда их называют спецификации или BOM (Bill of Materials)).
В BOM видно, какие компоненты входят в проект, а это важно для специалистов по безопасности или соответствию требованиям. Отчет можно не только посмотреть, но и экспортировать как JSON.
[](https://habrastorage.org/webt/jl/sv/w2/jlsvw2h52tyqz1k9qdswuh-1clq.png)
### Ограничение доступа по IP-адресу
*ULTIMATE, GOLD*
Если в компании строгий контроль, она может запретить доступ к своим ресурсам с внешних IP-адресов. Особенно эта фича полезна для компаний, которые используют VPN, потому что теперь можно запретить трафику за пределами указанной подсети доступ к ресурсам в пользовательском интерфейсе GitLab.
Строгий контроль над самым ценным кодом компании теперь можно настраивать на уровне группы в самоуправляемых экземплярах или на GitLab.com, и это очень просто.
[](https://habrastorage.org/webt/zb/n2/j2/zbn2j2g3x_5y5lb2k8krzx1zyxc.png)
### Синхронизация файлов с веб-терминалом
*ULTIMATE, GOLD*
В GitLab 12.0 изменения, внесенные в Web IDE, теперь можно синхронизировать с веб-терминалом. Изменения в Web IDE можно тестировать в веб-терминале до отправки в проект.
Эта фича также упрощает приход новых участников, которые теперь смогут просматривать, редактировать и тестировать код без установки локальных зависимостей для проекта.
Примечание: GitLab.com поддерживает интерактивные веб-терминалы только через приватные раннеры.
### Интеграция Git для JupyterHub
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Деплой JupyterHub через интеграцию Gitlab с Kubernetes позволяет без лишних усилий приступить к работе с записными книжками Jupyter, с помощью которых можно создавать и отправлять документы с живым кодом, диаграммами и даже инструкциями.
Начиная с GitLab 12.0 расширение Git для JupyterLab автоматически настраивается при установке JupyterHub на кластер Kubernetes. Эта интеграция позволяет полностью контролировать записные книжки и выполнять команды Git в Jupyter. Команды Git можно выполнять на вкладке Git на левой панели или в командной строке Jupyter.
[](https://habrastorage.org/webt/mz/xo/vn/mzxovncy6g0eo1ukr7eypb7mzvw.png)
Другие улучшения в GitLab 12.0
------------------------------
### Поддержка нескольких extends в .gitlab-ci.yml
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Ключевое слово `extends` позволяет пользователям сохранять [лаконичность](https://dev.to/michalbryxi/how-to-dry-your-gitlab-ciyml-16pc) кода GitLab CI/CD. Продвинутые пользователи GitLab CI/CD уже вовсю используют extends, чтобы сжимать распространенные части кода. Мы сами используем их для [сборки GitLab](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/.gitlab/ci/rails.gitlab-ci.yml) и своих фич [Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/).
В GitLab 12.0 мы рады представить дополнение от [Wolphin](https://gitlab.com/q_wolphin), благодаря которому можно включать несколько фрагментов `extends` в одно задание, чтобы оптимизировать и сократить конфигурацию CI.
Спасибо, Wolphin!
### Последовательные цепочки мерджей
*PREMIUM, ULTIMATE, SILVER, GOLD*
В выпуске 12.0 мы представляем новый способ поддерживать `master` или ветки выпуска зелеными: цепочка мерджей. Цепочки мерджей основаны на нашей фиче [пайплайнов для мердж-реквестов/результатов](https://docs.gitlab.com/ee/ci/merge_request_pipelines/#pipelines-for-merged-results-premium) и позволяют ставить пайплайны в очередь по порядку.
> Сейчас пайплайны цепочек мерджей идут последовательно (по одному), поэтому, возможно, вам пока лучше не включать эту фичу — в зависимости от частоты и продолжительности ваших пайплайнов.
В будущем мы планируем включить эту фичу по умолчанию, но сначала нам нужна [поддержка параллельного выполнения](https://gitlab.com/gitlab-org/gitlab-ee/issues/11222) для большего удобства.
[](https://habrastorage.org/webt/rl/y6/-h/rly6-hsuhe8-r7eahv2xhd5e62k.png)
### Сворачиваемые логи заданий
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
В GitLab 12.0 мы добавляем возможность разворачивать и сворачивать логи в заданиях GitLab CI/CD. Так будет проще отлаживать некоторые шаги заданий и просматривать общие сведения о шагах — или подробности, если вам нужно увидеть все выходные данные.
Изначально это было дополнение от Маттиаса ван де Мента ([Matthias van de Meent](https://gitlab.com/matthias.vandemeent)). Спасибо, Маттиас!
[](https://habrastorage.org/webt/_w/2f/15/_w2f15xcbbcxp-i6cfr7rlw2yjg.png)
### Электронные адреса для уведомлений по конкретным группам
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
В 12.0 мы добавили возможность выбирать отдельные адреса для групповых уведомлений. Теперь пользователи могут получать групповые уведомления на другие адреса. Например, рабочий адрес для рабочей группы и личный адрес для личной группы.
[](https://habrastorage.org/webt/ni/wt/dw/niwtdwqf2mz6hai71lxgwhyuiba.png)
### База данных уязвимостей для просмотра и принятия дополнений
*ULTIMATE, GOLD*
Наш проект базы данных уязвимостей можно посмотреть [здесь](https://gitlab.com/gitlab-org/security-products/gemnasium-db). Изучите, что в ней есть, и проверьте самые актуальные для вас уязвимости.
А еще [ознакомьтесь с рекомендациями](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/index.html#contributing-to-the-vulnerability-database) по внесению вклада, чтобы улучшить базу данных уязвимостей.
### Указание причины при пропуске уязвимости
*ULTIMATE, GOLD*
Если вы игнорируете найденную уязвимость, теперь можно объяснить причину в специальном поле.
Специалисты по безопасности и разработчики смогут просмотреть историю и понять, почему нет исправлений.
[](https://habrastorage.org/webt/yj/m6/5m/yjm65mcc_eqc7nalhclbej8qfhq.png)
### Управление разрешениями только в LDAP
*PREMIUM, ULTIMATE*
Компании, которые используют LDAP, обычно [синхронизируют](https://docs.gitlab.com/ee/administration/auth/ldap-ee.html#group-sync) его с GitLab, чтобы управлять разрешениями.
В GitLab 12.0 теперь можно запретить всем, кроме администратора, изменять разрешения для экземпляра за пределами LDAP. При таком подходе компании со строгим контролем могут гарантировать, что разрешения в LDAP соответствуют разрешениям в экземпляре и их не может менять никто, кроме администраторов экземпляра.
### Удалять проекты могут только администраторы
*PREMIUM, ULTIMATE*
Компании со строгим контролем могут разрешать только архивирование проектов, которые могут содержать важный код в репозитории, чтобы не потерять его навсегда.
Администраторы экземпляра могут на уровне экземпляра запретить обычным пользователям удалять проекты и будут точно знать, что проекты будут только [заархивированы](https://docs.gitlab.com/ee/user/project/settings/#archiving-a-project) и никуда не денутся.
[](https://habrastorage.org/webt/oa/wx/zl/oawxzl3z_lfzxz96rwzxhvb-um0.png)
### GitLab Insights
*ULTIMATE, GOLD*
GitLab Insights, представленный в GitLab Ultimate 11.9 (параметр фичи), теперь общедоступен в GitLab Ultimate 12.0.
Настройте отображение самых актуальных сведений, таких как чистота сортировки, количество созданных и закрытых задач за определенный период, среднее время для слияния мердж-реквестов и многое другое.
[](https://habrastorage.org/webt/75/az/y6/75azy6zsrdwtr0uaqd6_7yhp4ts.png)
### Уведомления о сбоях сборок на master-ветке
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Сервис [уведомления о пайплайнах](https://gitlab.com/gitlab-org/gitlab-ce/issues/61721) на GitLab позволяет пользователям настраивать оповещения о завершении или сбое сборок для списка получателей. Раньше можно было подписываться только на все проблемы со сборками.
В GitLab 12.0 мы добавили возможность подписаться на уведомления о сбое только в ветке проекта по умолчанию (например, `master`).
Спасибо за работу, Питер Марко ([Peter Marko](https://gitlab.com/petermarko))!
[](https://habrastorage.org/webt/ef/f1/jh/eff1jhdoifejogwbb6q-rfaknpa.png)
### Улучшенная поддержка для передачи переменных в нижестоящие пайплайны
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
В GitLab 11.8 мы представили возможность [запускать](https://docs.gitlab.com/ee/ci/multi_project_pipelines.html#triggering-a-downstream-pipeline-using-a-bridge-job) нижестоящий пайплайн из промежуточного задания в upstream. Мы также представили базовую поддержку передачи переменных в нижестоящий пайплайн.
GitLab 12.0 поддерживает передачу текущих переменных среды в нижестоящий пайплайн. Это позволяет пользователям предоставлять контекст для нижестоящего пайплайна и для коммитов, мердж-реквестов или других элементов из пайплайна, который его запустил.
### Ускоренные поверхностные клоны по умолчанию для новых проектов в GitLab CI/CD
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
С выпуска GitLab 8.9 GitLab CI/CD поддерживает поверхностные [git-клоны](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---depthltdepthgt) с помощью переменной `GIT_DEPTH` в определении задания.
В GitLab 12.0 мы добавили возможность задавать эту глубину на уровне проекта, чтобы мейнтейнеры проекта могли выбрать поверхностное колнирование по умолчанию. Создавать поверхностные Git-клоны быстрее, чем каждый раз клонировать весь репозиторий Git, и если ваши задания CI/CD настроены на сборку последних изменений, поверхностных клонов будет достаточно.
Кроме того, в GitLab 12.0 у новых проектов, созданных в GitLab, параметр `GIT_DEPTH` будет по умолчанию получать значение `50` при создании. Эта разумная величина поможет пользователям быстрее клонировать и выполнять сборки в GitLab CI/CD, а продвинутые пользователи смогут изменить этот параметр для других сценариев CI/CD.
### Прокси зависимостей включен для групп по умолчанию
*PREMIUM, ULTIMATE*
В GitLab 11.11 мы запустили [прокси зависимостей](https://docs.gitlab.com/ee/user/group/dependency_proxy/), чтобы пользователи могли загружать и кэшировать образы Docker для более быстрой и надежной загрузки.
В GitLab 12.0 мы включили эту фичу по умолчанию на уровне групп.
[](https://habrastorage.org/webt/kc/8k/fl/kc8kflrddgdg-0bomyy3t32noae.png)
### Шаблон Maven теперь автоматически отправляет код в репозиторий Maven
*PREMIUM, ULTIMATE, SILVER, GOLD*
Разработчикам Java нужен простой способ собирать зависимости и управлять ими в пайплайнах GitLab CI/CD.
В GitLab 12.0 мы изменили прилагаемый шаблон `Maven.gitlab-ci.yml`, чтобы пользователи отправляли зависимости Java в репозиторий GitLab Maven из своих пайплайнов CI/CD и управляли ими.
### Удаление тегов из реестра контейнеров через API
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
С Container Registry API пользователи GitLab могут легко управлять своими реестрами с помощью кода.
В GitLab 12.0 мы обновили [модель разрешений](https://docs.gitlab.com/ee/user/permissions.html#project-members-permissions), чтобы разработчики могли удалять теги.
### Дедупликация объектов Git (бета)
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Ветвление рабочих процессов упрощает совместную работу над проектом: вы создаете копию upstream-проекта, работаете с ней, а затем открываете мердж-реквест, чтобы добавить свои изменения в upstream-проект. Для популярных проектов требования к хранилищу на стороне сервера для тысяч копий быстро возрастают — вместе с расходами.
В GitLab 12.0 администраторы экземпляров могут включить дедупликацию объектов с помощью параметра фичи `object_pools`. Если она включена, при ветвлении общедоступного проекта будет создаваться пул объектов и использоваться [`objects/info/alternates`](https://git-scm.com/docs/gitrepository-layout#Documentation/gitrepository-layout.txt-objectsinfoalternates), чтобы ветки занимали меньше места.
Для дедупликации объектов нужно включить хэшированное хранилище, и родительский проект должен использовать хэшированное хранилище. Существующие ветки пока не переносятся в пул объектов автоматически. Следите за новостями: [gitaly#1560](https://gitlab.com/gitlab-org/gitaly/issues/1560).
В следующем выпуске мы реализуем [быстрое ветвление](https://gitlab.com/groups/gitlab-org/-/epics/607), чтобы ветки создавались сразу с дедупликацией. Сейчас они сначала создаются, а потом дедуплицируются.
> Дедупликация объектов работает на GitLab.com с 30 мая 2019 года, но она выключена по умолчанию для самоуправляемых экземпляров, потому что при вызове отображается [предупреждение о повторяющемся битмапе](https://gitlab.com/gitlab-org/gitaly/issues/1728). Проблема исправлена в 12.0, но мы не успели удалить параметр фичи в этом выпуске.
### Включен хэш-кэш битмапа Git для ускоренной переупаковки
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
В GitLab 12.0 при переупаковке репозиториев Git хэш-кэш битмапа сохраняется в индексе битмапа. Кэш повышает производительность переупаковки, особенно при использовании дельта-участков.
> Версии JGit до 3.5.0 несовместимы с хэш-кэшем битмапа.
### Проверка учетных данных Kubernetes, предоставленных при создании кластера
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Если вы добавляете кластер Kubernetes вручную, нужно вводить много данных, и не исключены ошибки. Для выявления проблем с доступом и разрешениями теперь при добавлении кластера вручную интеграция Kubernetes будет проверять доступность API URL, а также допустимость токена кластера и сертификата CA.
Если возникнет проблема, вы получите оповещение.
[](https://habrastorage.org/webt/dn/jb/yz/dnjbyzryw3ircsbcdaevosuc0k4.png)
### Использование GitLab Serverless с текущими установками Knative
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
До этого выпуска фичи GitLab Serverless можно было использовать только при установке Knative через GitLab. В GitLab 12.0 существующие установки Knative также смогут использовать преимущества GitLab Serverless. Просто [добавьте существующий кластер вручную](https://docs.gitlab.com/ee/user/project/clusters/#adding-an-existing-kubernetes-cluster), добавьте нужные шаблоны Serverless в проект, а GitLab сделает все остальное.
Это значит, что теперь можно использовать GitLab Serverless со сторонними решениями Knative, например [Cloud Run on GKE](https://cloud.google.com/run/) от Google или [Knative, размещенный в](https://cloud.ibm.com/docs/containers?topic=containers-serverless-apps-knative) IBM.
### Ссылки и доступ к конференции Zoom из задачи
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
В GitLab 12.0 мы упростили совместную работу над задачами с помощью конференций Zoom. Вставьте ссылку на конференцию Zoom в описание задачи. GitLab распознает ссылку и покажет кнопку «Join Zoom meeting» («Участвовать в конференции Zoom») под заголовком.
[](https://habrastorage.org/webt/l7/ad/8j/l7ad8j1uhickq2m4lxmbq6cxvgu.png)
### Ссылка на внешние панели мониторинга из панелей мониторинга среды
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Команды по обслуживанию часто используют более сложные панели мониторинга с метриками для визуализации состояния своих сред.
Начиная с GitLab 12.0 вы можете предоставлять и открывать сторонние панели мониторинга напрямую из панелей сред на GitLab.
[](https://habrastorage.org/webt/qi/cg/0e/qicg0ezvp1hcscyohy79fcxxyhs.png)
### Уведомления об общих лимитах CI Runner на GitLab.com
*FREE, BRONZE, SILVER, GOLD*
Владельцы групп на GitLab.com теперь будут получать по электронной почте уведомления о том, что квота минут CI закончилась, и инструкции по покупке дополнительных минут CI.
### Возможность запрашивать эпики в GraphQL
*ULTIMATE, GOLD*
С помощью API GraphQL пользователи могут точно указывать, какие данные им нужны, и получать все необходимые данные за несколько запросов.
В этом выпуске GitLab поддерживает возможность запрашивать эпики в GraphQL API.
### API задач теперь предоставляет статистику выполнения действий
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Пользователи могут определять действия в задачах, и эта информация отображается в разных местах приложения.
В GitLab 12.0 пользователи могут получать информацию о прогрессе действия через API.
### Новый дизайн обсуждений с тредами
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Существующий дизайн для обсуждений мердж-реквестов и задач включал в себя много полей и границ, так что иногда было сложно следить за разговором.
В GitLab 12.0 мы представляем более удобный дизайн.
[](https://habrastorage.org/webt/fm/5a/v0/fm5av0fo2je46dims6zin1lwmuu.png)
### Дополнительная статистика задач из API задач
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Пользователи не получали подробную статистику по задачам из API задач.
В GitLab 12.0 мы добавляем возможность просматривать количество всех задач, открытых и закрытых задач.
### Улучшение системных заметок при добавлении или удалении связей между эпиками
*ULTIMATE, GOLD*
Изменения связей между эпиками не записывались в системных заметках в ленте обсуждения эпика.
В GitLab 12.0 в системных заметках записывается, когда добавляются или удаляются связи между родительскими и дочерними эпиками.
### Добавление и удаление дочерних эпиков через быстрые действия
*ULTIMATE, GOLD*
Сейчас дочерние эпики нельзя добавлять или удалять из родительских через быстрые действия.
В GitLab 12.0 мы добавили возможность добавлять и удалять дочерние эпики с помощью команд `/child_epic` и `/remove_child_epic`.
### Docker in Docker больше не нужен для DAST
*ULTIMATE, GOLD*
Для динамического тестирования защищенности приложений (Dynamic Application Security Testing, DAST) больше не нужен Docker in Docker. Поэтому образ DAST Docker (3 ГБ) будет кэширован в раннерах.
> Образ обновляется еженедельно, так что кэш становится недействительным каждый понедельник.
### GitLab Runner 12.0
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Сегодня мы выпустили GitLab Runner 12.0! GitLab Runner — это проект с открытым исходным кодом, который используется для запуска заданий CI/CD и отправки результатов обратно в GitLab.
**Самые интересные изменения:**
* [Поддержка Docker Credentials Helper](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1386)
* [Добавление конфигурации access\_level для раннеров при регистрации](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1323)
* [Разрешение настройки контекста безопасности pod’ов в Kubernetes Executor](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1036)
* [PowerShell устанавливается по умолчанию для новых зарегистрированных исполняющих программ Windows](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1406)
* [Поддержка конфигурации томов Windows Docker](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1269)
Как мы уже говорили в предыдущих постах, в GitLab Runner 12.0 мы удаляем устаревшие функции:
* [Удалена устаревшая команда clone/fetch](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1372)
* [Удалена устаревшая стратегия git clean](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1370)
* [Удалена поддержка устаревшего параметра metrics\_server](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1368)
* [Удалена поддержка устаревшей конфигурации точки входа для K8S](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1369)
* [Удалена поддержка устаревшей конфигурации кэша S3](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1367)
* [Удалена поддержка устаревших дистрибутивов](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1130)
* [Удалена поддержка старых команд docker helper image](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1373)
Полный список изменений можно найти в журнале изменений GitLab Runner: [CHANGELOG](https://gitlab.com/gitlab-org/gitlab-runner/blob/v12.0.0/CHANGELOG.md).
### Улучшения Omnibus
*CORE, STARTER, PREMIUM, ULTIMATE*
Мы продолжаем улучшать GitLab Omnibus с каждым выпуском.
Некоторые улучшения в GitLab 12.0:
* GitLab 12.0 включает [Mattermost 5.11](https://mattermost.com/blog/mattermost-5-11/) — [альтернативу Slack с открытым кодом](https://mattermost.com/), в новый выпуск которого входит удаленный инструмент CLI и многое другое. Эта версия включает [обновления безопасности](https://mattermost.com/security-updates/), и мы советуем выполнить обновление.
* [Включение логов JSON по умолчанию](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/4102).
* Сервис Grafana теперь включен по умолчанию в пакетах omnibus-gitlab. А еще [аутентификация OAuth](https://docs.gitlab.com/omnibus/settings/grafana.html#using-gitlab-as-an-oauth-provider) теперь включена автоматически между Grafana и GitLab.
* [Улучшенные метрики GitLab с метриками ruby, инструментированными напрямую](https://gitlab.com/gitlab-org/gitlab-ce/issues/60303)
### Улучшения производительности
*CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD*
Мы продолжаем улучшать производительность GitLab с каждым выпуском для экземпляров GitLab любого размера.
Некоторые улучшения в GitLab 12.0:
* [Страница списка эпиков стала более эффективной.](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/13904)
* [База данных не учитывается в результатах Elasticsearch.](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/12691)
* [Не нужно вызывать Elasticsearch дважды для получения результатов.](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/13120)
* [Документы можно отправлять в индекс Elasticsearch пакетом.](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/13917)
* [Кэшированный Markdown в сообщениях коммита для повышения производительности вывода коммитов.](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/29054)
* [Улучшена производительность проверки ограничения размера репозитория при каждой отправке.](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/13460)
* [Улучшена производительность при загрузке задачи или мердж-реквеста с длинным описанием.](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/28597)
* [Улучшена производительность мердж-реквестов с предложенными изменениями.](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/29027)
* [Улучшена производительность и снижено потребление процессорных ресурсов клонами с помощью дельта-участков при переупаковке репозиториев Git.](https://gitlab.com/gitlab-org/gitaly/merge_requests/1267)
* [Улучшена производительность диаграмм мониторинга.](https://gitlab.com/gitlab-org/gitlab-ce/issues/58516)
* [Исправлен Git N + 1 в ListLastCommit RPC.](https://gitlab.com/gitlab-org/gitaly/merge_requests/1253)
* [Улучшена производительность поиска по коду Git с помощью --perl-regexp](https://gitlab.com/gitlab-org/gitaly/merge_requests/1241)
* [Улучшена производительность JobsController благодаря исправлению Git N + 1.](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/28093)
Устаревшие фичи
---------------
### GitLab 9.x больше не поддерживается
Мы представляем новую основную версию GitLab, поэтому GitLab 9.x [больше не поддерживается](https://about.gitlab.com/support/statement-of-support.html#out-of-scope). Рекомендуем выполнить обновление как минимум до GitLab 10.0, чтобы получать помощь от нашей [службы поддержки](https://about.gitlab.com/support/).
Дата удаления: **22 июня 2019 г.**
### GitLab Geo требует хэшированное хранение в GitLab 12.0
В GitLab 12.0 GitLab Geo требуется [хэшированное хранилище](https://gitlab.com/gitlab-org/gitlab-ee/issues/8690) для смягчения конкуренции на вторичных узлах. Используйте `sudo gitlab-rake gitlab:geo:check`, чтобы проверить, включено ли [хэшированное хранилище](https://docs.gitlab.com/ee/administration/repository_storage_types.html#hashed-storage) и все ли проекты переносятся. См. документацию о том, [как перейти на хэшированное хранилище](https://docs.gitlab.com/ee/administration/repository_storage_types.html#how-to-migrate-to-hashed-storage).
Мы уже говорили об этом [раньше](https://gitlab.com/gitlab-org/gitlab-ce/issues/40970).
В GitLab [11.5](https://gitlab.com/groups/gitlab-org/-/milestones/20) мы добавили [это требование в документацию Geo](https://gitlab.com/gitlab-org/gitlab-ee/issues/8053).
В GitLab [11.6](https://gitlab.com/groups/gitlab-org/-/milestones/21), `sudo gitlab-rake gitlab:geo:check` проверяет, [включено ли хэшированное хранилище и все ли проекты переносятся](https://gitlab.com/gitlab-org/gitlab-ee/issues/8289). Если вы используете Geo, пожалуйста, запустите эту проверку и мигрируйте как можно скорее.
В GitLab [11.8](https://gitlab.com/groups/gitlab-org/-/milestones/23) [постоянно отключаемое предупреждение](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/8433) будет отображаться на странице Admin Area › Geo › Nodes, если вышеупомянутые проверки не разрешены.
Дата удаления: **22 июня 2019 г.**
### GitLab Geo требует PostgreSQL Foreign Data Wrapper в GitLab 12.0
В GitLab 12.0 Geo требует PostgreSQL [Foreign Data Wrapper](https://docs.gitlab.com/ee/development/geo.html#foreign-data-wrapper), поэтому версия PostgreSQL должна быть не ниже 9.6. GitLab Geo использует PostgreSQL Foreign Data Wrapper для запроса данных из разных экземпляров PostgreSQL. Это необходимо для [Geo Log Cursor](https://docs.gitlab.com/ee/development/geo.html#geo-log-cursor), так как значительно повышает производительность некоторых операций синхронизации. Foreign Data Wrapper также повышает производительность запросов статуса узлов Geo. Предыдущие запросы имели слишком низкую производительность в крупных проектах.
Узнайте, как настроить PostgreSQL Foreign Data Wrapper, в [документации по репликации баз данных Geo](https://docs.gitlab.com/ee/administration/geo/replication/database.html).
Дата удаления: **22 июня 2019 г.**
### Отказ от сопоставления по ярлыку app на панелях деплоя Kubernetes
В GitLab 12.1 мы удалим сопоставление по ярлыку `app` в селекторе деплоев Kubernetes (изначально удаление было запланировано на выпуск 12.0). В GitLab 11.10 мы ввели [новый механизм сопоставления](https://gitlab.com/gitlab-org/gitlab-ee/issues/9221), который ищет совпадения по `app.gitlab.com/app` и `app.gitlab.com/env`, чтобы выводить деплои на панель.
Чтобы эти деплои отображались на панелях деплоев, нужно просто отправить новый денлой, и GitLab применит новые ярлыки.
Дата удаления: **22 июня 2019 г.**
### Удаление переменной среды AUTO\_DEVOPS\_DOMAIN
Новая переменная среды `KUBE_INGRESS_BASE_DOMAIN` была [представлена в GitLab 11.8](https://gitlab.com/gitlab-org/gitlab-ce/issues/52363). Больше не нужно использовать `AUTO_DEVOPS_DOMAIN`, чтобы определить несколько доменов, так как теперь они определяются индивидуально на странице кластера.
Дата удаления: **22 июня 2019 г.**
### Удаление шаблона сервиса Kubernetes
В GitLab 12.1 мы планируем отказаться от шаблона сервиса Kubernetes на уровне экземпляра в пользу конфигурации кластера [на уровне экземпляра](https://gitlab.com/gitlab-org/gitlab-ce/issues/39840), представленной в GitLab 11.11.
Все самоуправляемые экземпляры, где используется шаблон сервиса, будут перенесены в кластер на уровне экземпляра при апгрейде до GitLab 12.0.
Дата удаления: **22 июня 2019 г.**
### Удаление поддержки файла skip\_auto\_migrations
В GitLab 12.0 мы полностью [`удаляем поддержку файла skip_auto_migrations`](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/3787). Он был объявлен устаревшим в GitLab 10.6.
Дата удаления: **22 июня 2019 г.**
### Удаление поддержки Prometheus 1.x
В GitLab 12.0 мы полностью [удаляем поддержку Prometheus 1.x](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/3797).
Дата удаления: **22 июня 2019 г.**
### Устаревший openSUSE 42.3
EOL openSUSE 42.3 наступает 30 июня 2019 года. Мы продолжим [собирать пакеты](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/4395) для этой версии до GitLab 12.1, но прекратим поддержку в GitLab 12.2.
Дата удаления: **22 июня 2019 г.**
### Устаревшие пути legacy кода GitLab Runner
Начиная с Gitlab 11.9 GitLab Runner использует [новый метод](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1203) клонирования/вызова репозитория. В настоящее время GitLab Runner будет использовать старый метод, если новый не поддерживается. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4069).
В GitLab 11.0 мы изменили вид конфигурации сервера метрик для GitLab Runner. `metrics_server` будет удален в пользу `listen_address` в GitLab 12.0. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4072).
В выпуске 11.3 GitLab Runner начал поддерживать [несколько кэш-провайдеров](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/968). Это привело к новым настройкам для [конфигурации S3](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnerscaches3-section). В [документации](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnerscache-section) приведена таблица изменений и инструкции по переходу к новой конфигурации. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4070).
Эти пути недоступны в GitLab 12.0. Как пользователю, вам не нужно ничего менять, только убедиться, что экземпляр GitLab работает с версией 11.9+ при обновлении до GitLab Runner 12.0.
Дата удаления: **22 июня 2019 г.**
### Устаревший параметр для фичи точки входа для GitLab Runner
В выпуске 11.4 GitLab Runner представлен параметр фичи.
[`FF_K8S_USE_ENTRYPOINT_OVER_COMMAND`](https://docs.gitlab.com/runner/configuration/feature-flags.html#available-feature-flags) для исправления таких проблем, как [#2338](https://gitlab.com/gitlab-org/gitlab-runner/issues/2338) и [#3536](https://gitlab.com/gitlab-org/gitlab-runner/issues/3536).
В GitLab 12.0 мы переключились на правильное поведение, как если бы параметр фичи был отключен. Подробнее смотрите в [этой задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/4073).
Дата удаления: **22 июня 2019 г.**
### Устаревшая поддержка дистрибутивов Linux, достигших EOL, для GitLab Runner
Некоторые дистрибутивы Linux, в которые можно установить GitLab Runner, свое отслужили.
В GitLab 12.0 GitLab Runner больше не распределяет пакеты в такие дистрибутивы Linux. Полный список дистрибутивов, которые больше не поддерживаются, можно найти в нашей [документации](https://docs.gitlab.com/runner/install/linux-repository.html).
Спасибо, Хавьер Ардо ([Javier Jardón](https://gitlab.com/jjardon)), за твой [вклад](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1130)!
Дата удаления: **22 июня 2019 г.**
### Удаление старых команд GitLab Runner Helper
В рамках добавления поддержки [Windows Docker executor](https://gitlab.com/groups/gitlab-org/-/epics/535) пришлось отказаться от некоторых старых команд, которые используются для [helper image](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#helper-image).
В GitLab 12.0 GitLab Runner запускается с помощью новых команд. Это касается только пользователей, которые переопределяют helper image. Подробнее смотрите в этой задаче.
Дата удаления: **22 июня 2019 г.**
### Удаление legacy механизма git clean из GitLab Runner
В GitLab Runner 11.10 [мы предоставили возможность](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1281) настроить, как Runner выполняет команду `git clean`. Коме того, новая стратегия очистки удаляет использование `git reset` и помещает команду `git clean` после шага выгрузки.
В GitLab 12.0 GitLab Runner больше не поддерживает устаревшую стратегию очистки и возможность восстанавливать ее с помощью параметра фичи. См. [эту задачу](https://gitlab.com/gitlab-org/gitlab-runner/issues/4175).
Дата удаления: **22 июня 2019 г.**
### Secure License Management переименован в License Compliance в GitLab 12.0
License Management переименован, чтобы лучше соответствовать формулировкам отрасли, начиная с GitLab 12.0. Задача License Compliance — анализировать приложение и отслеживать лицензии, используемые сторонним компонентами, например библиотеками или сторонними зависимостями, и проверять, что они совместимы с моделью лицензирования вашего проекта.
License Compliance входит в нашу [группу анализа безопасного состава ПО](https://about.gitlab.com/handbook/product/categories/#software-composition-analysis-group).
Дата удаления: **22 июня 2019 г.**
### Устаревшие переменные и аргумент для конфигурации `.gitlab-ci.yml` вручную при использовании функций Secure
Если вы настроили файл конфигурации `.gitlab-ci.yml` вручную, чтобы использовать:
* аргумент командной строки `--auth-first-page`, удалите этот аргумент, он больше не поддерживается.
* переменную параметра `DEP_SCAN_DISABLE_REMOTE_CHECKS`, удалите ее, она больше не поддерживается.
* значение `sast_container` в переменной среды `GITLAB_FEATURES`, используйте вместо него `container_scanning`.
Если вы вручную настроили файл конфигурации `.gitlab-ci.yml`, убедитесь, что используете [новый синтаксис отчетов](https://docs.gitlab.com/ee/ci/yaml/README.html#artifactsreports). Все функции Secure зависят от доступности отчетов по ожидаемому адресу. Если вы не обновите [новый синтаксис отчетов](https://docs.gitlab.com/ee/ci/yaml/README.html#artifactsreports), все функции Secure перестанут работать.
Если вы используете [готовые шаблоны](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#including-the-provided-template) вместо конфигурации вручную, мы будем поддерживать актуальность вашей конфигурации с учетом изменений переменных и аргументов.
Дата удаления: **22 июня 2019 г.**
### Удаление поддержки [сниппета конфигурации](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#manual-job-definition-for-gitlab-115-and-later) вручную Secure из GitLab 12.0
Мы больше не обновляем сниппет конфигурации вручную Secure в документации. Он использовался при настройке функций Secure в пайплайне проекта.
Используйте готовый шаблон для Secure в файле [`.gitlab-ci.yml с помощью include: template: Dependency-Scanning.gitlab-ci.yml`](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#including-the-provided-template).
Дата удаления: **22 июня 2019 г.**
### 3DES отключен в GitLab.com Pages по умолчанию
GitLab.com Pages раньше разрешали 3DES, который [считается устаревшим](https://csrc.nist.gov/news/2017/update-to-current-use-and-deprecation-of-tdea).
Поэтому теперь 3DES отключен по умолчанию. Для пользователей современных браузеров ничего не изменится, но это могут заметить пользователи Internet Explorer 7 и 8 на Windows XP.
Дата удаления: **22 июня 2019 г.**
### Удаление поддержки MySQL в GitLab 12.1
GitLab 12.0 — это последняя версия [с поддержкой MySQL (и MariaDB)](https://gitlab.com/gitlab-org/gitlab-ce/issues/52442). Пользователи должны [перейти](https://docs.gitlab.com/ee/update/mysql_to_postgresql.html) на PostgreSQL, чтобы использовать последующие версии. MySQL считается устаревшим, и его поддержка уже была ограничена в Enterprise Edition Starter и Premium.
Если вы клиент GitLab и используете MySQL, [свяжитесь с нашей службой поддержки](https://support.gitlab.com/), чтобы получить помощь по миграции.
Дата удаления: **22 июля 2019 г.**
### Параметры Sentry для отчетов об ошибках и логирования будут удалены из пользовательского интерфейса в GitLab 12.1
Эти параметры будут удалены из пользовательского интерфейса в GitLab 12.1 и доступны в `gitlab.yml` с GitLab 11.11. Кроме того, вы сможете определить среду Sentry, чтобы различать несколько деплоев (разработка, стейджинг, продакшен). Подробности см. в [gitlab-ce#49771](https://gitlab.com/gitlab-org/gitlab-ce/issues/49771).
Дата удаления: **22 июля 2019 г.**
### Шаблоны групповых проектов доступны только для планов Silver/Premium
Когда мы представили [шаблоны проектов на уровне групп](https://docs.gitlab.com/ee/user/group/custom_project_templates.html#custom-group-level-project-templates-premium-only) в GitLab 11.6, мы случайно сделали эту фичу для Premium/Silver доступной для всех планов.
Мы [исправили этот баг](https://gitlab.com/gitlab-org/gitlab-ee/issues/10926) в GitLab 11.11, дав еще три месяца всем пользователям и экземплярам ниже уровня Silver/Premium.
С 22 августа 2019 года шаблоны групповых проектов будут доступны только для плана Silver/Premium и выше, как описано в документации.
Дата удаления: **22 августа 2019 г.**
### License Management будет использовать Python 3 по умолчанию в GitLab 12.2
Python 3 станет версией по умолчанию для Secure License Management.
Пользователи с Python 2 должны установить для переменной CI `LM_PYTHON_VERSION` значение «2», если они на самостоятельном управлении, когда начнут использовать GitLab 12.2. Пользователи с Python 3 могут установить для переменной CI `LM_PYTHON_VERSION` значение «3» сегодня.
Дата удаления: **22 августа 2019 г.**
### Прекращена поддержка пакетных заданий Windows
В GitLab 12.3 мы планируем отказаться от поддержки пакетных заданий в командной строке Windows в GitLab Runner (например, `cmd.exe`) в пользу расширенной поддержки Windows PowerShell.
Теперь наше видение корпоративного DevOps будет соответствовать позиции Microsoft, что PowerShell — это лучший вариант для автоматизации корпоративных приложений в средах Windows.
Если вы хотите и дальше использовать `cmd.exe`, эти команды можно вызывать из PowerShell, но мы не будем напрямую поддерживать пакетные задания Windows из-за нескольких несоответствий, которые приводят к высоким издержкам при обслуживании и разработке.
Дата удаления: **22 сентября 2019 г.**
### Устаревшее кэширование каталога заданий в GitLab Runner с Docker Executor
В GitLab Runner 11.10 мы изменили, какие каталоги заданий кэшируются в общем томе, когда используются исполняющие программы Docker и Docker Machine. Вместо кэширования только родительского каталога в каталоге задания GitLab Runner теперь кэширует весь базовый каталог, настроенный с `builds_dir`. Из-за этого изменения поведения мы добавили параметр фичи, который позволяет выбирать новое или старое поведение.
В GitLab Runner 12.3 мы удалим параметр фичи и старое поведение. См. [эту задачу](https://gitlab.com/gitlab-org/gitlab-runner/issues/4180).
Дата удаления: **22 сентября 2019 г.**
### Поддержка Python 2 в Secure License Management будет прекращена к концу года
Поддержка Python 2 будет прекращена в будущем выпуске GitLab, так как Python 2.7 достигает [EOL](https://pythonclock.org/) 1 января 2020 года.
Дата удаления: **22 декабря 2019 г.**
### Важные примечания об обновлении до GitLab 12.0
GitLab 12.0 объединяет изменения базы данных, внесенные в Enterprise Edition за несколько лет, в Community Edition. В рамках этого проекта мы удалили различные старые миграции. Пользователи, которые обновляют GitLab, должны сначала обновиться до последнего выпуска 11.11, а затем до 12.0.0. При переходе на следующие версии, например 12.3.0, сначала нужно обновиться до последнего выпуска 11.11 в соответствии с нашими [рекомендованными путями обновления](https://docs.gitlab.com/ee/policy/maintenance.html#upgrade-recommendations). В противном случае возникнут проблемы с миграцией и, соответственно, ошибки в приложении. Установки Omnibus уже требуют обновления до версии 12.0.0, и GitLab Helm Chart требует аналогичный [путь обновления](https://docs.gitlab.com/charts/releases/2_0.html). При установке из исходного кода это нужно будет сделать вручную.
* GitLab 12.0 будет использовать [хэшированное хранилище](https://docs.gitlab.com/ee/administration/repository_storage_types.html#hashed-storage) по умолчанию. Это повлияет только на новые установки.
GitLab 12.0 [автоматически обновит PostgreSQL до версии 10.0](https://docs.gitlab.com/omnibus/settings/database.html#upgrade-packaged-postgresql-server).
1. Пользователи могут пропустить автоматическое обновление PostreSQL 10.0, создав `/etc/gitlab/disable-postgresql-upgrade`.
2. Если вы используете [GitLab Geo](https://docs.gitlab.com/ee/administration/geo/replication/), автоматическое обновление PostgreSQL будет пропущено на узлах `primary` и всех `secondary`. Мы [предоставим путь обновления для пользователей Geo в выпуске 12.1](https://gitlab.com/gitlab-org/gitlab-ee/issues/12164).
* В GitLab 12.0 [включены логи JSON по умолчанию](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/4102). Мы также добавили документацию о том, как [сохранить настройки предыдущего формата логов](https://docs.gitlab.com/omnibus/settings/logs.html#text-logging), если JSON нежелателен.
* Читайте больше важной информации об обновлении Omnibus в [документации](https://docs.gitlab.com/omnibus/update/gitlab_12_changes.html).
### Журнал изменений
Ищите все эти изменения в журнале изменений:
* [GitLab Community Edition](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/CHANGELOG.md)
* [GitLab Enterprise Edition](https://gitlab.com/gitlab-org/gitlab-ee/blob/master/CHANGELOG-EE.md)
* [GitLab Runner](https://gitlab.com/gitlab-org/gitlab-runner/blob/master/CHANGELOG.md)
### Установка
Если вы настраиваете новую установку GitLab, посетите [страницу загрузки GitLab](https://about.gitlab.com/install/).
### Обновление
Загляните на [страницу обновлений](https://about.gitlab.com/update/). | https://habr.com/ru/post/458136/ | null | ru | null |
# Подборка @pythonetc, ноябрь 2019
Новая подборка советов про Python и программирование из моего авторского канала @pythonetc.
← [Previous publications](https://habr.com/en/search/?q=pythonetc#h)
`PATH` — это переменная окружения, в которой хранятся пути, по которым ищутся исполняемые файлы. Когда вы просите оболочку выполнить `ls`, она сначала ищет исполняемый файл `ls` по всем путям, указанным в `PATH`.
```
$ echo $PATH
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/v.pushtaev/.local/bin:/home/v.pushtaev/bin
$ which ls
/usr/bin/ls
```
В этом примере пути в `PATH` разделены с помощью `:`. Путаница не возникнет: если путь содержит `:`, то он не может использоваться в `PATH`.
Но это верно не для всех операционных систем. В Python вы можете узнать правильный разделитель для вашей ОС с помощью `os.pathsep`:
```
Python 3.5.0 [...] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.pathsep
';'
```
Не путайте `os.pathsep` с `os.path.sep`, которая является разделителем для путей к файлам:
```
>>> os.path.sep
'/'
```
Чтобы регулярные выражения легче было читать, можете использовать флаг `re.VERBOSE`. Он позволяет использовать дополнительные пробелы везде, где хотите, а также добавлять комментарии после символа `#`:
```
import re
URL_RE = re.compile(r'''
^
(https?)://
(www[.])?
(
(?: [^.]+[.] )+
( [^/]+ ) # TLD
)
(/.*)
$
''', re.VERBOSE)
m = URL_RE.match('https://www.pythonetc.com/about/')
schema, www, domain, tld, path = m.groups()
has_www: bool = bool(www)
print(f'schema={schema}, has_www={has_www}')
print(f'domain={domain}, tld={tld}')
print(f'path={path}')
```
`re.X` является псевдонимом для `re.VERBOSE`.
`complex` — это встроенный в Python тип для комплексных чисел:
```
>>> complex(1, 2).real
1.0
>>> abs(complex(3, 4))
5.0
>>> complex(1, 2) == complex(1, -2).conjugate()
True
>>> str(complex(2, -3))
'(2-3j)'
```
Однако не обязательно использовать его напрямую, потому что в Python есть литералы для комплексных чисел:
```
>>> (3 + 4j).imag
4.0
>>> not (3 + 4j)
False
>>> (-3 - 4j) + (2 - 2j)
(-1-6j)
```
Нотацию `a : b : c` можно использовать для определения `slice(a, b, c)` с помощью одних лишь скобок:
```
>>> [1, 2, 3, 4, 5][0:4:2]
[1, 3]
>>> [1, 2, 3, 4, 5][slice(0, 4, 2)]
[1, 3]
```
Если вы хотите передать функции slice-объект в качестве аргумента, то придётся определить его явным образом:
```
def multislice(slc, *iterables):
return [i[slc] for i in iterables]
print(multislice(
slice(2, 6, 2),
[1, 2, 3, 4, 5, 6, 7],
[2, 4, 2, 4, 2, 4, 2],
))
```
Вот так можно преобразовать подобную функцию в объект, который поддерживает `[a : b : c]`:
```
from functools import partial
class SliceArgDecorator:
def __init__(self, f):
self._f = f
def __getitem__(self, slc):
return partial(self._f, slc)
slice_arg = SliceArgDecorator
@slice_arg
def multislice(slc, *iterables):
return [i[slc] for i in iterables]
print(multislice[2:6:2](
[1, 2, 3, 4, 5, 6, 7],
[2, 4, 2, 4, 2, 4, 2],
))
```
`__getattribute__` — это мощный инструмент, позволяющий легко использовать паттерн делегирования, когда это уместно. Так можно добавить возможность сравнения с несравниваемым объектом:
```
class CustomEq:
def __init__(self, orig, *, key):
self._orig = orig
self._key = key
def __lt__(self, other):
return self._key(self) < self._key(other)
def __getattribute__(self, name):
if name in {'_key', '_orig', '__lt__'}:
return super().__getattribute__(name)
return getattr(self._orig, name)
class User:
def __init__(self, user_id):
self._user_id = user_id
def get_user_id(self):
return self._user_id
def comparable(obj, *, key):
return CustomEq(obj, key=key)
user1 = comparable(User(1), key=lambda u: u.get_user_id())
user2 = comparable(User(2), key=lambda u: u.get_user_id())
print(user2 > user1) # True
print(user2 < user1) # False
print(user2.get_user_id()) # 2
``` | https://habr.com/ru/post/480138/ | null | ru | null |
# Ассемблер/дизассемблер клавиатурных раскладок Windows с помощью flat assembler
Знакомый линуксоид упрекнул меня, мол, в винде ни переключения языка Caps Lock'ом нет, ни даже раскладку нельзя отредактировать. Посмотрел я, и правда, все раскладки содержатся в файлах C:\Windows\System32\kbd\*.dll, и редактировать такое hex-редактором ну никак не назвать удобным.
Как достичь удобства? Для переключения раскладок Caps Lock'ом можно использовать всякие навесные программы, тяжёлые вроде Punto Switcher, или простые вроде lswitch. Для редактирования раскладок есть MSKLC, но он малофункционален и неудобен, а аналоги вроде KbdEdit или KLM32 платные.
И тогда я решил написать на flat assembler'е код, собирающий DLL раскладки.
За основу была взята раскладка kbdusx.dll, в системе она называется "США Международная". Мне она понравилась тем, что в ней есть ряд комбинаций для дополнительных символов. Не нравилась она тем, что превращает клавиши <`~>, <6^>, <'"> в так называемые dead keys, «мёртвые клавиши». Их особенность — при нажатии ничего не печатается, но изменяется следующий набранный символ. Таким образом можно вводить латинские буквы с диакритикой, для которых нет отдельного сочетания клавиш. Но мне, как программисту, было очень неприятно «залипание» таких часто используемых клавиш, и изначально я просто обнулил поля в hex-редакторе, отвечающие за мёртвые клавиши.
Пришла пора разобраться с форматом раз и навсегда. Поначалу дело шло неспешно, потом я нашёл kbd.h и несколько примеров раскладок из Windows Driver Kit.
Внутри раскладки
================
Забавно, что Microsoft решили поместить раскладки в формат DLL, хотя за исключением корейской kbdkor.dll и японской kbdjpn.dll там кода нет совсем, если не считать экспортируемую функцию KbdLayerDescriptor, возвращающую указатель на главную таблицу с раскладкой.
Таблица имеет такой вид:
| | 32-bit Windows | 64-bit или WOW64 |
| --- | --- | --- |
| Название | Размер | Смещение | Размер | Смещение |
| modifiers | 4 | 0x00 | 8 | 0x00 |
| vk2wchar | 4 | 0x04 | 8 | 0x08 |
| deadkeys | 4 | 0x08 | 8 | 0x10 |
| keynames | 4 | 0x0C | 8 | 0x18 |
| keynamesExt | 4 | 0x10 | 8 | 0x20 |
| keynamesDead | 4 | 0x14 | 8 | 0x28 |
| scancode2vk | 4 | 0x18 | 8 | 0x30 |
| scancode2vk\_size | 1 | 0x1C | 1 | 0x38 |
| e0scancode2vk | 4 | 0x20 | 8 | 0x40 |
| e1scancode2vk | 4 | 0x24 | 8 | 0x48 |
| locale\_flags | 2 | 0x28 | 2 | 0x50 |
| version | 2 | 0x2A | 2 | 0x52 |
| ligature\_chars | 1 | 0x2C | 1 | 0x54 |
| ligature\_size | 1 | 0x2D | 1 | 0x55 |
| ligatures | 4 | 0x30 | 8 | 0x58 |
| type | 4 | 0x34 | 4 | 0x60 |
| subtype | 4 | 0x38 | 4 | 0x64 |
Таким образом, файл раскладки содержит в себе таблицы названия клавиш, конвертации скан-кодов в виртуальные (0x1C → VK\_RETURN), конвертации виртуальных кодов в символы, комбинации мёртвых клавиш, «лигатуры».
Судя по всему, названия клавиш используются редко, мне не удалось на своём компьютере найти программы, которая бы выводила их список из раскладки.
Изменяя таблицу скан-кодов, можно переназначить любую клавишу на другую. Если сразу захотелось переназначить кнопки питания (Power, Sleep, WakeUp), то это тоже можно, но это не отменит их оригинальной функции. Её можно отключить в настройках электропитания.
В таблице символов самый сок. Она решает, к чему приведёт нажатие клавиш K, Shift+K, AltGr+K, Shift+AltGr+K, влияет ли на неё Caps Lock, использует ли он тот же ряд символов, что и Shift+K или отдельный, влияет ли на неё Kana; будет ли символ напечатан сразу, или занесётся в очередь мёртвых клавиш, или напечатается ряд символов из «лигатуры», или или не произойдёт ничего.
AltGr — так называется правый Alt (если включён в раскладке флагом KLLF\_ALTGR), он генерирует сочетание клавиш Ctrl+Alt.
Список мёртвых клавиш содержит пары символов, которые должны преобразовываться в третий символ. Этот символ может печататься сразу, или снова проходить по списку для дальнейшего преобразования. Если пара символов не найдена в списке, то она просто напечатается как есть. С помощью цепочек мёртвых клавиш можно сымитировать поведение Compose Key, но некоторые программы, например, Firefox, не распознают преобразования дальше первого.
Список «лигатур», который по сути является набором макросов, может позволить набирать до четырёх символов WCHAR по нажатию клавиши. На самом деле, у меня в Windows 7 работает до 16 символов, но с крайне неприятным исключением: Firefox при натыкании на такую раскладку напрочь зависает, а если раскладка с длинными «лигатурами» системная, то и вовсе перестаёт запускаться.
Создание раскладки
==================
Сперва я хотел сделать две удобных раскладки, русскую и английскую, подходящую как для написания статей, так и программ. Типографская раскладка Ильи Бирмана хороша, но могло быть ещё лучше, тем более если делать лично для себя.
Потом я узнал про клавишу Kana. Kana — переключающаяся подобно Caps Lock'у кнопка на японской клавиатуре. И тут я решил объединить английскую и русскую раскладки в одну, и переключаться между ними клавишей Kana. Которую я переназначил на Caps Lock. Написал простую программу-индикатор для отображения состояния Kana лампочкой Caps Lock'а.
У такой объединённой раскладки возник один приятный сюрприз: раскладка теперь одна на всю систему, и остаётся при переключении между программами, а также «шибко умные» программы больше не могут переключать раскладку по своему желанию при редактировании текста или перемещении курсора.
И один неприятный сюрприз: Psi+ почему-то стал съедать первый символ, введённый после переключения раскладки нажатием Kana.
Тем не менее, я оставил эту раскладку в архиве вместе с индикатором Kana.
Потом я обнаружил, что Caps Lock'у можно назначить отдельный ряд символов и заменил Kana на Caps Lock. Программа-индикатор стала ненужной, неприятный сюрприз изчез. При переделке обнаружилось только одно ограничение: Caps Lock работает только с рядами K и Shift+K — на него нельзя повесить AltGr+K и т.п.
В попытках уместить все мёртвые клавиши в два ряда (с Kana было четыре), я наткнулся на идею перевернуть их порядок: так, чтоб набиралась AltGr+буква, а потом модификатор. Это позволило мне назначить гораздо больше символов, чем раньше. Я назвал это “undead keys”, «восставшие из мёртвых клавиши».
И вот идеальная раскладка была готова.
Преимущества раскладки kbdusru\_undead
======================================
1. Переключение между русским и английским одной клавишей Caps Lock.
2. Индикатор Caps Lock показывает текущий язык.
3. Глобальное состояние раскладки для всех приложений.
4. Невозможность «шибко умных» программ спонтанно менять раскладку.
5. Возможность вводить буквы с диакритикой и кучу других символов.
6. Возможность легко отредактировать раскладку по вкусу.
Пример ввода некоторых дополнительных символов
==============================================
| Комбинация клавиш | Результат |
| --- | --- |
| AltGr+5 | € |
| AltGr+9 | « |
| AltGr+0 | » |
| AltGr+- | — |
| AltGr+= | ≠ |
| AltGr+; | ° |
| AltGr+, | < |
| AltGr+. | > |
| AltGr+Shift+/ | /me |
| AltGr+a,' | á |
| AltGr+e,` | è |
| AltGr+o," | ő |
| AltGr+n,~ | ñ |
| AltGr+c,^ | ĉ |
| р, ы,AltGr+q,', б, а | ры́ба |
| AltGr+c,o | © |
| AltGr+r,o | ® |
| AltGr+t,m | (tm) |
| AltGr+m,u | µ |
| AltGr+h,s | ☭ |
| AltGr+f,2 | ½ |
| AltGr+b,f | █ |
Установка
=========
Я просто заменяю системный файл C:\Windows\System32\kbdru.dll на свою раскладку, ведь она во всех отношениях лучше. На Windows XP или 2000 в таком случае нужно не забыть удалить C:\Windows\System32\dllcache\kbdru.dll.
Но если вам не по душе такой насильный апгрейд винды, то раскладку можно скопировать в папку C:\Windows\System32\ и зарегистрировать в системе с помощью такого reg-файла:
```
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layouts\07430419]
"Layout Text"="US+RU"
"Layout Display Name"="United States-International + Russian + Extra"
"Layout File"="kbdusru_undead.dll"
"Layout Id"="00d0"
```
Первая часть кода, 0743 — произвольные цифры для уникальной идентификации раскладки, а 0419 — код языка «Русский», под которым должна появиться раскладка. От кода языка зависит поведение раскладки в неюникодных (ANSI) программах. Если при наборе букв появляются знаки вопроса, то это верный признак неверно указанного кода языка.
Дальше — больше
===============
Программировать на flat assembler'е мне доставляет одно удовольствие: мощный язык макросов, красивый и послушный синтаксис, ненужность всяких линковщиков и каши параметров в командной строке.
Поэтому я решил написать на нём программу, которая при ассемблировании читает DLL раскладки, а на выходе — исходный код. Странно, правда? Использовать ассемблер, как дизассемблер. Но мощь fasm'а это позволяет.
В результате у меня получились раскладки, которые позволяют переключаться между языками Caps Lock'ом без внешних программ глобально для всей системы, а также набор инструментов, который позволяет нам удобно редактировать раскладки клавиатуры Windows.
Всё выложено на <https://github.com/grompe/kbdasm> как общественное достояние.
Если у вас 64-битная Windows, можно [скачать архив](https://github.com/grompe/kbdasm/archive/master.zip), распаковать и запустить make.bat, а затем install.bat. Для 32-битной придётся сперва подправить файл kbdusru\_undead.asm.
Также в архиве есть программа get\_scancodes. Если у вас есть хитрая клавиатура с дополнительными клавишами, с помощью программы можно узнать скан-коды и задействовать эти клавиши в раскладке. | https://habr.com/ru/post/301882/ | null | ru | null |
# Не делайте лишних колонок в ваших таблицах, вам это не нужно
Всем привет.
Я люблю базы данных, люблю строить запросы, люблю проектировать БД. Раскладывать по полочка, систематизировать это моё любимое занятие. Конечно первые годы я проектировал таблицы БД как меня научили в ВУЗе - каждому свойству отдельная колонка.
Но этот подход отстал от жизни, то есть он удобен если ваша бизнес логика работает на хранимых процедурах. Тогда действительно, записи таблицы это готовые объекты вашей бизнес логики.
Но актуальных подход это разделение ответственности за обработку данных между сервером баз данных и сервером приложений. Сервер баз данных предоставляет данные, сервер приложений их обрабатывает.
Речь конечно об Online Transaction Processing (OLTP). Когда нам надо получить данные по одной сущности, например, показать профиль пользователя, или показать товарные позиции определённого заказа.
Ниже я расскажу о продвинутом способе хранения данных.
Продвинутый формат хранения данных
----------------------------------
Хотя и принято говорить о хранении данных, но на самом деле никому не надо хранить данные, всем надо читать данные, главное назначение сервера баз данных это предоставление данных по запросу.
То есть при проектировании БД мы должны исходить из требования быстрой выдачи необходимого объёма данных. Мы должны обеспечить быстрый поиск по заданным условиям.
Что помогает поиску ? Индексы. То есть наша таблица должна иметь индекс для быстрого поиска и собственно данные. Таблица должна состоять из колонок индекса и колонки с собственно данными. Для согласованности данных можно добавить колонки внешнего ключа.
Пример реализации
-----------------
Допустим перед нами стоит задача обрабатывать некие документы. В документе важен его статус, для быстрого поиска мы делаем колонку статуса, конечно статусы у нас могут быть не какие попало, возможные значения ограничены справочником, поэтому колонка будет внешним ключом на справочник статусов, создаём колонку status\_id.
Каждый документ имеет уникальный номер, создаём колонку doc\_num, делаем по ней уникальный индекс.
Для данных документа делаем колонку data, тип данных строка, можно использовать специализированны формат СУБД.
Что у нас получилось
```
create table document
(
id integer not null
constraint document_pk
primary key,
doc_num text not null,
status_id integer
constraint document_status_id_fk
references status,
data jsonb
);
create unique index document_doc_num_uindex
on public.document (doc_num);
create index document_status_index
on public.document (status);
```
Откуда растут уши
-----------------
К такой схеме хранения данных я пришёл не сам, эту идею я взял у Филиппа Дельгядо. Вы можете посмотреть его доклады на конференциях с тайм кодами: [раз](https://youtu.be/wJz_sjjf2aE?t=1372), [два](https://youtu.be/wMcWo2cT7Ck?t=634).
Или весь доклад целиком:
В видео идея подробно излагается со всеми нюансами граблей на которые вы можете наступить, я в своей статье излагаю только основные моменты.
Способ работы с СУБД
--------------------
Как правило, вам не надо делать выборки с условием отбора по языку интерфейса в профиле пользователя, вам надо только отобразить интерфейс с учётом настроек профиля. Или как правило, вам не надо делать поиск по заказам пользователя, что бы показать заказы в которых было определённое количество определённого товара, вам надо показать список заказов.
Запросы с выборками пользователей по языку интерфейса или со средним чеком по заказу делают для аналитики в системах Online Analytical Processing (OLAP), это их хлеб.
Как правило Online Transaction Processing (OLTP) занимается атомарной обработкой одной записи. Вам надо получить данные от пользователя, записать их в таблицу. На следующем этапе вы эти данные прочитаете, измените и снова запишите в эту же таблицу и скорей всего создадите связанные записи в других таблицах. Такая работа с записью будет продолжаться до тех пор пока бизнес процесс не будет полностью выполнен.
После этого вы ни когда к этой записи не вернётесь, вы выгрузите её в OLAP и забудете о ней навсегда.
При работе с СУБД через ORM происходит чтение всех колонок, ни кто не пишет в коде "дай мне колонку номер документа и дату документа", объект считывается целиком. Поэтому нет смысла разбивать свойства сущности по отдельным колонкам. Всё равно они будут прочитаны все. При разбиении информации на отдельные колонки и при записи в одну единственную колонку объем данных переданных от СУБД к приложению не измениться.
Получить JSON и превратить его в объект это элементарная задача. Обратная задача, получить JSON представление для объекта, это тоже элементарная задача.
Появляется нюанс с записью колонок индекса, когда мы сериализировали наш объект для записи в БД, мы также должны записать новые значения для колонок индекса, то есть если мы создали индекс со статусом документа, то при сохранении документа мы не только записываем новое значение в колонку data, но так же мы записываем новое значение в колонку status.
Всё это автоматизируется на уровне ORM.
Наследуемся от класса модели данных, добавляем абстрактные методы для сериализации и десериализации, теперь все классы наших моделей наследуем от нашего кастомного класса.
Для каждой нашей модели пишем реализацию сериализации с обновлением значений в колонках индекса. Это методы на несколько строк кода, ни чего сложного.
Преимущества
------------
Какие преимущества даёт подход с единой колонкой для всех данных ?
1. При добавлении нового свойства у сущности, вам не надо изменять схему данных, вам не надо писать миграцию.
2. Теперь миграции нужны только для создания таблицы, и этот код упрощается до пары колонок.
3. Меньше миграций - проще деплой.
4. Ни кому в голову не придёт строить аналитические отчёты на СУБД Приложения, для этого будет использоваться OLAP.
Недостатки
----------
1. Миграции по прежнему нужны для создания новых индексов и внешних ключей.
2. Для каждой модели надо писать код актуализации значений в колонках индекса.
Когда следует использовать такой подход ?
-----------------------------------------
Мой ответ - всегда.
Всё что для этого надо - это преодолеть инертность своего мышления. Упрощения деплоя и сокращение количества миграций это серьёзное преимущество для по настоящему промышленных систем.
Если вы пишите домашний проект или проверяете гипотезу, то конечно вам не надо тратить время на пляски с бубном вокруг ORM, пусть всё мапиться один в один.
Если вы используете автогенерацию фронт-энда из схемы БД (пример [Craftable — Laravel CRUD generator](https://habr.com/ru/post/496468/)), то такой вариант с записью данных в одну колонку вам помешает.
Во всех других случаях, когда вы ведёте разработку не один год и не одной командой разработчиков - такой подход к работе с данными - облегчит жизнь вам и вашим разработчикам.
Пользуйтесь с удовольствием.
PS
--
Проходит год, на Хабре публикуют перевод статьи: "[Пока-пока, MongoDB: почему компании переходят на PostgreSQL](https://habr.com/ru/company/southbridge/blog/714578/)"
Что и требовалось доказать.
Всем безмозглым истеричкам привет! Продолжайте минусить всех здравых людей, которые способны по новому взглянуть на старую проблему. | https://habr.com/ru/post/661699/ | null | ru | null |
# Готовим ORM, не отходя от плиты. Генерируем SQL — запрос на основе бинарных деревьев выражений
Статья является продолжением [первой части](https://habrahabr.ru/post/317860/). В посте рассмотрим построение SQL-запроса по объектной модели типа, в виде бинарного дерева выражений и сопутствующие темы параметризации SQL-запросов, оптимизации рефлексии. Темы этой статьи сами по себе весьма обособленны, поэтому можно читать особо не обращая внимание на первую часть. Еще раз отмечу, данное решение, является «дело было вечером — делать было нечего» и не претендует на лавры промышленного продукта.
### Немного лирики или о параметризации динамического SQL
В общем случае, динамическим SQL называют скрипт, отправляемый с клиента на исполнение СУБД, который не реализован в виде хранимой процедуры. СУБД исполняет такие скрипты при помощи инструкций EXEC() и sp\_executesql.
Может для кого-то покажется неожиданным, но после 6-й версии, SQL Server «умеет» кэшировать динамические запросы. Однако, не все так просто. Во время поиска в кэше хранимой процедуры, в качестве ключа SQL Server использует ее имя, в случае динамического SQL имени не может быть, поэтому SQL использует весь текст запроса, включая параметры, в виде ключа поиска. Да, абсолютно весь текст запроса, Карл! С пробелами, без учета регистра, с комментариями.
Кроме того, сервер ищет запрос в кэше, по его схеме. Поэтому так важно указывать полное имя таблиц, согласно схеме.
**Непараметризованный запрос**
```
//В кэше планы исполнения этих непараметризованных запросов SQL Server расценит как разные из-за регистра
cmd.CommandText = "SELECT mycol FROM product WHERE col = " + value.ToString();
cmd.CommandText = "SELECT mycol FROM Product WHERE col = " + value.ToString();
```
**Параметризованный запрос**
```
cmd.CommandText = "SELECT mycol FROM dbo.product WHERE col = @value";
cmd.Parameters.Add("@value", SqlDbType.Int);
cmd.Parameters["@value"].Value = value;
```
Если в проекте множество «разбросанных» по проекту непараметризованных запросов, следует задуматься о рефакторинге, с помощью инкапсуляции в одну функцию. Использование ORM решает подобные проблемы(в случае ORM с ручным SQL, нужно самостоятельно потрудиться над инкапсуляцией).
Не будем забывать, что непараметризованные запросы влекут за собой множество побочных эффектов, таких как SQL-инъекции и т.д. Подробнее о проблемах кэширования динамического SQL [тут](http://www.sommarskog.se/dynamic_sql.html).
### Что мы хотим?
Определим метод репозитория для получения данных, на основе деревьев выражений. Клиент должен получить что-то вроде:
```
var repo = new ProfileRepository();
var profiles = repo.Get(x => x.Id == id && x.Rating > rate)
```
Генерация SQL на основе деревьев выражений имеет следующие преимущества:
* Избавляет от необходимости пользователю самому вспоминать строковые названия колонок в бд
* Пользователь может задать неправильное название колонки, что повлечет исключение или название колонки с пробелом, в другом регистре, что повлечет проблемы кеширования на стороне SQL Server
* Условие для фильтрации может быть составным, что и позволяет реализовать класс .NET Expression
Недостатком может является сложность и производительность генерации SQL, с рекурсивным обходом бинарного дерева.
### Немного порефлексируем
Во время маппинга объектов, необходимо получать их свойства и атрибуты динамически, при этом, по возможности, избежав медленного механизма рефлексии. Как оптимизировать производительность получения значений и установки значений для свойств на основе делегатов, хорошо изложено у Рихтера, не будем тут подробно останавливаться, а сразу реализуем обертку класса PropertyInfo.
Для динамической работы со свойствами типа, нам будут нужны:
* Метод получения свойств
* Метод установки свойств
* Название свойства
* Тип свойства
* Атрибуты привязки свойств бизнес-объектов к полям в таблице
**Класс PropWrapper**
```
public class PropWrapper
{
private readonly PropertyInfo _property;
public Type Type
{
get { return _property.PropertyType; }
}
public string Name
{
get { return _property.Name; }
}
//атрибут связи бизнес-объекта с другими бизнес-объектами
public ICollection RelatedEntityAttributes
{
get { return \_property.GetCustomAttributes().ToList(); }
}
//атрибут связи бизнес-объекта с объектами из бд
public ICollection FieldNameAttributes
{
get { return \_property.GetCustomAttributes().ToList(); }
}
// свойство получающее Gettеr объекта. Аргумент делегата-экземляр конкретного объекта
public Func GetterMethod
{
get { return GetGetterMethod(); }
}
// свойство получающее Settеr объекта. Аргумент делегата-экземляр конкретного объекта
public Action SetterMethod
{
get { return GetSetterMethod(); }
}
public PropWrapper(PropertyInfo prop)
{
\_property = prop;
}
private Func GetGetterMethod()
{
if (\_property == null)
throw new ArgumentNullException("property");
var getter = \_property.GetGetMethod();
if (getter == null)
throw new ArgumentException("The specified property does not have a public accessor.");
var genericMethod = typeof (PropMethodsHelper).GetMethod("CreateGetterGeneric");
var r = \_property.GetCustomAttributes();
MethodInfo genericHelper = genericMethod.MakeGenericMethod(\_property.DeclaringType, \_property.PropertyType);
return (Func) genericHelper.Invoke(null, new object[] {getter});
}
private static Func CreateGetterGeneric(MethodInfo getter) where T : class
{
Func getterTypedDelegate = (Func) Delegate.CreateDelegate(typeof (Func), getter);
Func getterDelegate =
(Func) ((object instance) => getterTypedDelegate((T) instance));
return getterDelegate;
}
private Action GetSetterMethod()
{
if (\_property == null)
throw new ArgumentNullException("property");
var setter = \_property.GetSetMethod();
if (setter == null)
throw new ArgumentException("The specified property does not have a public setter.");
var genericMethod = typeof (PropMethodsHelper).GetMethod("CreateSetterGeneric");
MethodInfo genericHelper = genericMethod.MakeGenericMethod(\_property.DeclaringType, \_property.PropertyType);
return (Action) genericHelper.Invoke(null, new object[] {setter});
}
private static Action CreateSetterGeneric(MethodInfo setter) where T : class
{
Action setterTypedDelegate = (Action) Delegate.CreateDelegate(typeof (Action), setter);
Action setterDelegate =
(Action)
((object instance, object value) => { setterTypedDelegate((T) instance, (V) value); });
return setterDelegate;
}
}
```
Теперь реализуем класс инкапсулирующий весь тип целиком. Заметим, что такие вещи как атрибуты, имена свойств, типы свойств, зависят только от типа, а не от конкретного экземляра класса. Поэтому удобно сразу кэшировать структуру типов.
**Реализация класса CacheTypeReflectionWrapper**
```
internal static class CacheTypeReflectionWrapper
{
private static readonly Dictionary> TypesByProp =
new Dictionary>();
public static ICollection GetProps(Type type)
{
//проверяем есть ли тип к кэше
if (!TypesByProp.ContainsKey(type))
{
var props = type.GetProperties();
var propWrappers = props.Select(propertyInfo => new PropWrapper(propertyInfo)).ToList();
TypesByProp.Add(type, propWrappers);
}
return TypesByProp[type];
}
}
```
### Готовим основное блюдо
Наконец можно приступать к приготовлению маппера SQL из объектной модели. Сразу отмечу, что решение можно было реализовать с помощью LINQ провайдеров .NET, но я пока не стал.
Вычислим тело select-запроса по полям объекта. Для чего нам необходим тип бизнес-объекта и имя бд, дабы получить полное имя, согласно схемы бд.
**Метод CreateBody**
```
private static string CreateBody(string dbName, Type type)
{
//получаем имя таблицы в бд, согласно атрибутам в объявлении бизнес-объекта
var tableName = CommonCommandBuilder.GetTableName(type);
var cmdBulder = new StringBuilder();
//получаем все поля свойства объекта, у которых есть атрибуты привязки к таблицам в бд
foreach (var prop in CacheTypeReflectionWrapper.GetProps(type).Where(x => x.FieldNameAttributes.Any()))
{
var attrs = prop.FieldNameAttributes;
//в текущей реализации только один атрибут привязки к имени в бд является действительным
cmdBulder.Append(string.Format("[{0}].[{1}],", tableName, attrs.First().Value));
}
return string.Format("SELECT {0} FROM [{1}].[dbo].[{2}] ",
cmdBulder.ToString().Trim(','), dbName, tableName);
}
```
Теперь начинается самое веселое: — генерация SQL-условия после слова WHERE. Для удобного обхода деревьев выражений в .NET существует класс [ExpressionVisitor](https://msdn.microsoft.com/ru-ru/library/system.linq.expressions.expressionvisitor(v=vs.100).aspx). Но коль делать велосипеды, то по полной! Поэтому обойдемся без средств из коробки.
Разбор выражений будем осуществлять на основе [бинарных деревьев выражений](https://en.wikipedia.org/wiki/Binary_expression_tree).
Бинарное дерево выражения представляет собой специфический вид бинарного дерева, используемого для представления выражений. Бинарное дерево выражений может представлять из себя алгебраические и логические значения(унарные и бинарные операторы). Каждый узел бинарного дерева, и, следовательно, бинарного дерева выражения, имеет ноль, один или двое детей.
Дерево выражений может иметь вершины различного типа: непосредственно BinaryExpression,
MemberExpression, ConstantExpression, UnaryExpression и другие.
Нам важно добраться до листьев, которые в нашем случае, имеют типы MemberExpression, ConstantExpression. В вершинах типа MemberExpression содержатся поля, а по типу вершины можно получить условный операнд. Вершины типа ConstantExpression содержат непосредственно сами значения операндов.
Пусть наше выражение имеет следующий вид:
```
repo.Get(x => x.RoleId == 2 && x.UserInfoId > 4 && x.Id < 6)
```
Чтобы было понятнее, приведу схему бинарного дерева выражений, для данного случая. Значения вершин взяты из отладчика во время выполнения алгоритма обхода.
На картинке, поле {x.UserInfoId} является nullable типом, из-за этого такая вершина UnaryExpression. Вершины типа UnaryExpression не содержат двух детей Left и Right. Получить значение операнда в этом случае можно преобразованием к типу ConstantExpression.
Код функционала реализации построения SQL-условия по дереву выражений, с подробными комментариями:
```
//в метод необходимо передать экземпляр IDbCommand, в который будут сформируются параметры и значения, передаваемые в динамический SQL
public static string BuildClauseByExpression(IDbCommand command, Type type, BinaryExpression exp)
{
var strBuilder = new StringBuilder();
//точка входа в главный метод
return BuildClauseByNode(command, type, exp, strBuilder);
}
//рекурсивный метод обхода дерева выражений
private static string BuildClauseByNode(IDbCommand command, Type type, BinaryExpression left, StringBuilder strBuilder)
{
var tableName = GetTableName(type);
if (left != null)
{
var parameter = command.CreateParameter();
var fieldName = string.Empty;
var expField = left.Left as MemberExpression;
if (expField == null)
{
if (left.Left is BinaryExpression)
{
//если вершина типа Binary - рекурсивный вызов
BuildClauseByNode(command, type, left.Left as BinaryExpression, strBuilder);
//ExpressionTypeToDbClause содержит словарь, где ключ-значение ExpressionType, а значение строковое выражение SQL операции:_instance[ExpressionType.AndAlso] = " AND "
strBuilder.Append(ExpressionTypeToDbClause.Instance[left.NodeType]);
}
}
else
{
//если вершина типа Member - формируем значения названий полей и часть SQL условия
var name = expField.Member.Name;
var prop = CacheTypeReflectionWrapper.GetProps(type)
.Where(x => x.FieldNameAttributes.Any()).First(x => x.Name.Equals(name));
var attrs = prop.FieldNameAttributes;
fieldName = attrs.First().Value;
strBuilder.Append(string.Format("[{0}].[{1}]", tableName, fieldName));
//ExpressionTypeToDbClause содержит словарь, где ключ-значение ExpressionType, а значение строковое выражение SQL операции:_instance[ExpressionType.AndAlso] = " AND "
var action = ExpressionTypeToDbClause.Instance[left.NodeType];
strBuilder.Append(action);
//TypeMap содержит словарь для поиска соответствия c# типов и бд типов
parameter.DbType = TypeMap[prop.Type];
}
var expValue = left.Right as ConstantExpression;
if (expValue == null)
{
var unaryNode = left.Right as UnaryExpression;
if (unaryNode != null)
{
//если вершина типа UnaryExpression необходимо воспользоватся свойством Operand и привести к //ConstantExpression
expValue = unaryNode.Operand as ConstantExpression;
if (expValue != null)
{
//метод формирует параметры для динамического SQL-запроса
InitParams(command, strBuilder, fieldName, parameter, expValue);
}
}
if (expValue == null)
{
if (left.Right is BinaryExpression)
{
//если вершина типа Binary - рекурсивный вызов
BuildClauseByNode(command, type, left.Right as BinaryExpression, strBuilder);
}
}
}
else
{
InitParams(command, strBuilder, fieldName, parameter, expValue);
}
}
return strBuilder.ToString();
}
//метод формирования параметров динамического SQL-запроса
private static void InitParams(IDbCommand command, StringBuilder strBuilder, string fieldName,
IDataParameter parameter, ConstantExpression expValue)
{
var valueFormat = GetParamsFormat(fieldName);
strBuilder.Append(valueFormat);
parameter.ParameterName = valueFormat;
parameter.Value = expValue.Value;
if (!command.Parameters.Contains(parameter.ParameterName))
command.Parameters.Add(parameter);
}
//служебный метод форматирования строки параметра динамического SQL-запроса
public static string GetParamsFormat(string fieldName)
{
return string.Format("@{0}", fieldName);
}
```
В итоге, соединив тело и ~~душу~~ условие запроса, получим следующую функцию:
```
public static string Create(IDbCommand command, BinaryExpression exp)
where T : class, IEntity, new()
{
var type = typeof(T);
var selectBody = CreateBody(command.Connection.Database, type);
return string.Format("{0} WHERE {1}", selectBody, CommonCommandBuilder.BuildClauseByExpression(command, type, exp));
}
```
Все подробности реализации можно посмотреть на [гитхабе](https://github.com/lex1112/MapperOrm). | https://habr.com/ru/post/319422/ | null | ru | null |
# Использование двух редакторов анимаций в игровом проекте
Два редактора анимации в игровом проектеВ последнее время у меня появляется желание делиться своими знаниями с другими людьми. Возможно, это связано с возрастом, возможно с тем, что есть что-то, чем можно было бы поделиться. В связи с этим, хотел бы рассказать об опыте разработки текущей игры, в которой мы используем сразу два редактора анимации.
Мы – команда энтузиастов из двух человек. Занимаемся созданием игр под мобильные платформы около семи лет в свободное от основной работы время.
Подавляющее большинство наших проектов написано с использованием [cocos2d-x](https://github.com/cocos2d/cocos2d-x). Из них около 90% приходится на старую версию движка - [cocos2d-x-2.2.6](https://github.com/cocos2d/cocos2d-x/tree/cocos2d-x-2.2.6). Полтора года назад мы решили, создать новый проект - файтинг-платформер максимально возможного для нас качества под персональные компьютеры. И перейти уже на использование новой версии [cocos2d-x-3.17.2](https://github.com/cocos2d/cocos2d-x/tree/cocos2d-x-3.17.2).
Так как мы ограничены в ресурсах, будь то финансы или время, мы приняли решение, что будем использовать хорошо знакомые нам инструменты для разработки и дальше.
Мы понимаем, что важную роль в восприятии людьми картинки на экране играет плавность анимации и приятная графика. Поэтому игровые персонажи, у которых будут плащи и тому подобные элементы, нам необходимо будет анимировать с использованием mesh-анимации.
В своих проектах мы используем в качестве редактора скелетной анимации CocoStudio 1.2.0.1. Хотя этот программный продукт уже несколько лет не поддерживается, он позволяет создавать хорошие анимации, с использованием точек событий внутри. Данный редактор очень хорошо нам знаком, так как используется более пяти лет.
редактор анимаций CocoStudioНайти в сети его уже вряд ли получится, но если у кого-то есть желание, можно его скачать из [облака](https://cloud.mail.ru/public/7uEy/LH9cDpQju). Мы храним там все инструменты разработки, которые используем в своей работе.
Для себя мы решили, что бо́льшая часть объектов и персонажей у нас будет создаваться именно в этом редакторе анимации, так как скорость работы в нем и доступный функционал нас устраивает. А для персонажей, которым необходимы будут более продвинутые анимации, мы будем использовать другой редактор.
Редактор анимации [Spine](http://ru.esotericsoftware.com/) мы были вынуждены исключить. Тип лицензии Essential по функционалу ничем не отличается от используемого нами редактора анимации CocoStudio. Покупать лицензию Professional только ради использования mesh-анимации для нас пока дорогое удовольствие.
По этой причине выбор второго редактора анимации пал на [Dragonbones](https://docs.egret.com/dragonbones/en).
Он позволяет без проблем экспортировать анимации из CocoStudio. Нам только остается самостоятельно установить точки событий.
Приведу ссылку на [DragonBonesC++ RunTime](https://github.com/DragonBones/DragonBonesCPP) для добавления его в проект на cocos2d-x.
редактор анимаций DragonbonesПосле выбора второго редактора, дело осталось за малым. Необходимо было обеспечить в игре поддержку нескольких редакторов анимации. Изначально мы думали, что у нас будет поддержка трех редакторов анимации, но от использования Spine, как я написал чуть выше, мы отказались.
Добавлять поддержку редакторов анимации в игру необходимо сразу. Как бы вы не документировали свой код и не описывали функции, при работе с интеграцией нового редактора анимации для почти готового проекта, могут появиться неприятные моменты. Я считаю, что гораздо правильнее на начальном этапе проработать и реализовать весь необходимый функционал, чтобы потом заниматься более интересными для себя вещами.
Так как наш проект содержит элементы файтинга, обязательным для нас условием была возможность использования областей пересечений (hitbox`ов и hurtbox`ов) разных размеров. Кроме этого необходимо иметь точное время действия каждой области, отвечающей за взаимодействие при ударах персонажей.
режим debugПри этом дополнительным условием была возможность редактировать размеры и время действия областей пересечений в редакторе анимации. Видеть эти области в режиме отладки и отключать их в обычном режиме.
режим normalКогда мы только начинали разработку универсального класса поддержки нескольких редакторов, я был уверен, что логика работы кода с анимацией будет примерно одинаковая, но впоследствии пришло понимание, что мы немного ошиблись в наших предположениях.
Первое с чем мы столкнулись - разная работа с прозрачностью для bone у этих редакторов анимации. Если bone для анимации в CocoStudio достаточно было сделать прозрачными "на лету" для получения необходимого нам результата.
```
// функция устанвливает арматуру CocoStudio
void JCAnyArmature::setArmature(cocostudio::Armature *armature)
{
movementCCSJumpStart_ = armature->getAnimation()->getAnimationData()->getMovement("JUMPSTART");
boneCCSHitbox_ = armature->getBone("hitbox");
boneCCSHurtbox0_ = armature->getBone("hurtbox0");
boneCCSHurtbox1_ = armature->getBone("hurtbox1");
armature_ = armature;
armatureType_ = JCArmatureEditor::Type::COCOSTUDIO;
if (!JCGlobalSetting::getInstance()->isTestFunctions())
{
boneCCSHitbox_->setOpacity(0);
boneCCSHurtbox0_->setOpacity(0);
boneCCSHurtbox1_->setOpacity(0);
}
}
```
То для Dragonbones такой вариант не подошел. В этом редакторе прозрачность bone устанавливается в анимации не зависимо, меняли мы ее в редакторе или нет. По этой причине было приято решение, заменять картинки областей контактов пустыми, после создания персонажа в уровне.
```
// функция устанавливает арматуру Dragonbones
void JCAnyArmature::setArmature(dragonBones::CCArmatureDisplay *armature)
{
movementDGBJumpStart_ = armature->getAnimation()->getAnimations().find("JUMPSTART")->second;
boneDGBHitbox_ = armature->getArmature()->getBone("hitbox");
boneDGBHurtbox0_ = armature->getArmature()->getBone("hurtbox0");
boneDGBHurtbox1_ = armature->getArmature()->getBone("hurtbox1");
slotDGBHitbox_ = armature->getArmature()->getSlot("hitbox");
slotDGBHurtbox0_ = armature->getArmature()->getSlot("hurtbox0");
slotDGBHurtbox1_ = armature->getArmature()->getSlot("hurtbox1");
armature_ = armature;
armatureType_ = JCArmatureEditor::Type::DRAGONBONE;
if (!JCGlobalSetting::getInstance()->isTestFunctions())
{
dragonBones::CCFactory::getFactory()->replaceSlotDisplay("EmptyBox", "emptybox", "emptybox", "emptybox", slotDGBHitbox_);
dragonBones::CCFactory::getFactory()->replaceSlotDisplay("EmptyBox", "emptybox", "emptybox", "emptybox", slotDGBHurtbox0_);
dragonBones::CCFactory::getFactory()->replaceSlotDisplay("EmptyBox", "emptybox", "emptybox", "emptybox", slotDGBHurtbox1_);
}
}
```
Кроме этого, очередной особенностью работы с Dragonbones явилась необходимость дополнительной утилизации арматуры анимации из пула объектов.
```
// функция удаляет анимацию из родительской ноды
void JCAnyArmature::removeArmatureFromParent()
{
switch (armatureType_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
armature_->removeFromParent();
break;
case JCArmatureEditor::Type::DRAGONBONE:
static_cast(armature\_)->getEventDispatcher()->setEnabled(false);
armature\_->removeFromParent();
static\_cast(armature\_)->dispose();
break;
default:
armature\_->removeFromParent();
break;
}
}
```
Логика обработки обратных вызовов при завершении анимации обоих редакторов тоже немного отличается.
```
// функция устатавливает обработку обратного вызова на завершение анимаций
void JCAnyArmature::setAnimationEventCallFunc(std::function listener)
{
switch (armatureType\_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
static\_cast(armature\_)->getAnimation()->setMovementEventCallFunc(CC\_CALLBACK\_0(JCAnyArmature::\_onCCSAnimationEvent, this, std::placeholders::\_1, std::placeholders::\_2, std::placeholders::\_3));
break;
case JCArmatureEditor::Type::DRAGONBONE:
static\_cast(armature\_)->getEventDispatcher()->setEnabled(true);
static\_cast(armature\_)->getEventDispatcher()->addCustomEventListener(dragonBones::EventObject::COMPLETE, std::bind(&JCAnyArmature::\_onDGBAnimationEvent, this, std::placeholders::\_1));
static\_cast(armature\_)->getEventDispatcher()->addCustomEventListener(dragonBones::EventObject::LOOP\_COMPLETE, std::bind(&JCAnyArmature::\_onDGBAnimationEventLoop, this, std::placeholders::\_1));
break;
default:
static\_cast(armature\_)->getAnimation()->setMovementEventCallFunc(CC\_CALLBACK\_0(JCAnyArmature::\_onCCSAnimationEvent, this, std::placeholders::\_1, std::placeholders::\_2, std::placeholders::\_3));
break;
}
eventAnimation\_ = listener;
}
```
```
// функция обратного вызова при завершении анимации CocoStudio
void JCAnyArmature::_onCCSAnimationEvent(cocostudio::Armature *, cocostudio::MovementEventType movementType, const std::string& movementID)
{
this->_onAnimationEvent(movementType, movementID);
}
```
```
// функция обратного вызова при завершении конечной анимации Dragonbones
void JCAnyArmature::_onDGBAnimationEvent(cocos2d::EventCustom *event)
{
const auto eventObject = static_cast(event->getUserData());
this->\_onAnimationEvent(cocostudio::MovementEventType::COMPLETE, eventObject->animationState->name);
}
```
```
// функция обратного вызова при завершении круговой анимации Dragonbones
void JCAnyArmature::_onDGBAnimationEventLoop(cocos2d::EventCustom *event)
{
const auto eventObject = static_cast(event->getUserData());
this->\_onAnimationEvent(cocostudio::MovementEventType::LOOP\_COMPLETE, eventObject->animationState->name);
}
```
```
// функция обрабатывает события анимации и дергает функцию обратного вызова
void JCAnyArmature::_onAnimationEvent(cocostudio::MovementEventType movementType, const std::string &movementID)
{
if (eventAnimation_)
eventAnimation_(movementType, movementID);
}
```
Также есть отличия и в обработке точек событий у CocoStudio и Dragonbones, которые необходимо было учесть.
```
// функция устатавливает обработку обратного вызова на точки событий анимации
void JCAnyArmature::setFrameEventCallFunc(std::function listener)
{
switch (armatureType\_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
static\_cast(armature\_)->getAnimation()->setFrameEventCallFunc(CC\_CALLBACK\_0(JCAnyArmature::\_onCCSFrameEvent, this, std::placeholders::\_1, std::placeholders::\_2, std::placeholders::\_3, std::placeholders::\_4));
break;
case JCArmatureEditor::Type::DRAGONBONE:
static\_cast(armature\_)->getEventDispatcher()->setEnabled(true);
static\_cast(armature\_)->getEventDispatcher()->addCustomEventListener(dragonBones::EventObject::FRAME\_EVENT, std::bind(&JCAnyArmature::\_onDGBFrameEvent, this, std::placeholders::\_1));
break;
default:
static\_cast(armature\_)->getAnimation()->setFrameEventCallFunc(CC\_CALLBACK\_0(JCAnyArmature::\_onCCSFrameEvent, this, std::placeholders::\_1, std::placeholders::\_2, std::placeholders::\_3, std::placeholders::\_4));
break;
}
eventFrame\_ = listener;
}
```
```
// функция обратного вызова при обработке точек анимации CocoStudio
void JCAnyArmature::_onCCSFrameEvent(cocostudio::Bone *, const std::string &eventName, int, int)
{
this->_onFrameEvent(eventName);
}
```
```
// функция обратного вызова при обработке точек анимаций Dragonbones
void JCAnyArmature::_onDGBFrameEvent(cocos2d::EventCustom* event)
{
const auto eventObject = (dragonBones::EventObject*)event->getUserData();
this->_onFrameEvent(eventObject->name);
}
```
```
// функция обрабатывает события точек анимации и дергает функцию обратного вызова
void JCAnyArmature::_onFrameEvent(conststd::string&eventName)
{
if (eventFrame_)
eventFrame_(eventName, this->getCurrentMovementID());
}
```
Так как в нашей игре есть превращения одного персонажа в другого, нам необходимо было реализовать это максимально незаметно. Т.е. к примеру, крокодил - Crocco, анимация которого выполнена в CocoStudio, теоретически может превратиться в льва - King`a, анимация которого уже будет выполнена в Dragonbones.
превращение персонажаПри этом превращение может произойти в любой момент времени, независимо от того, наносит персонаж удар, отлетает в оглушенном состоянии или стоит задумавшись. Для этого нам необходимо запоминать текущую анимацию персонажа и кадр этой анимации.
```
// функция запоминает фрейм вопроизводимой анимации
void JCAnyArmature::rememberAnimationFrame()
{
switch (armatureType_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
currFrameIndex_ = static_cast(armature\_)->getAnimation()->getCurrentFrameIndex();
break;
case JCArmatureEditor::Type::DRAGONBONE:
{
dragonBones::AnimationState \*animationState = static\_cast(armature\_)->getAnimation()->getLastAnimationState();
const dragonBones::AnimationData \*animationData = animationState->getAnimationData();
currFrameIndex\_ = animationData->frameCount \* animationState->getCurrentTime() / animationData->duration;
}
break;
default:
currFrameIndex\_ = static\_cast(armature\_)->getAnimation()->getCurrentFrameIndex();
break;
}
}
```
А далее для нового персонажа, после его создания, запускать запомненную анимацию с нужного кадра.
```
// воспроизводит запомненную анимацию персонажа
void JCAnyArmature::playAnimationRemembered()
{
int currFrameIndex = currFrameIndex_;
switch (armatureType_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
static_cast(armature\_)->getAnimation()->play(currentMovementID\_);
static\_cast(armature\_)->getAnimation()->gotoAndPlay(currFrameIndex);
break;
case JCArmatureEditor::Type::DRAGONBONE:
static\_cast(armature\_)->getAnimation()->gotoAndPlayByFrame(currentMovementID\_, currFrameIndex\_);
break;
default:
static\_cast(armature\_)->getAnimation()->play(currentMovementID\_);
static\_cast(armature\_)->getAnimation()->gotoAndPlay(currFrameIndex);
break;
}
}
```
И, конечно, в игре необходимо корректно рассчитывать пересечения областей hitbox`ов и hurtbox`ов. Учитывать при этом нужно взаимодействие персонажей с анимациями, имеющих разный размер, а также масштаб уровня момент удара.
взаимодействи областей пересечения персонажейДля этого необходимо было создать следующие функции, которые возвращают результат, найдено ли пересечение областей при ударах персонажей друг по другу.
```
// функция возвращает результат пересечения области удара с областью контакта
bool JCAnyArmature::isIntersectsRectBone(const Rect ▭, int boneTag)
{
switch (armatureType_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
return this->_isCCSIntersectsRectBone(rect, boneTag);
break;
case JCArmatureEditor::Type::DRAGONBONE:
return this->_isDGBIntersectsRectBone(rect, boneTag);
break;
default:
return this->_isCCSIntersectsRectBone(rect, boneTag);
break;
}
}
```
```
// функция возвращает результат пересечения области удара с областью контакта CocoStudio
bool JCAnyArmature::_isCCSIntersectsRectBone(const Rect ▭, int boneTag)
{
bool result = false;
cocostudio::Bone *bone = nullptr;
switch (boneTag)
{
case HertboxTag::HURTBOX0:
bone = boneCCSHurtbox0_;
break;
case HertboxTag::HURTBOX1:
bone = boneCCSHurtbox1_;
break;
default:
bone = boneCCSHurtbox0_;
break;
}
if (!bone)
return result;
Node *node = bone->getDisplayRenderNode();
if (node)
{
Node *parallaxNode = armature_->getParent()->getParent();
float scale = fabs(armature_->getScaleX()) * parallaxNode->getScale();
Vec2 pos = node->convertToWorldSpaceAR(Vec2(0, 0));
Size size = node->getContentSize();
cocostudio::BaseData *baseData = bone->getWorldInfo();
size.width *= fabs(baseData->scaleX) * scale;
size.height *= fabs(baseData->scaleY) * scale;
Rect rectBone = Rect(pos - (size / 2), size);
if (rectBone.intersectsRect(rect))
{
result = true;
this->_calculateIntersectPoint(rectBone, rect);
}
}
return result;
}
```
```
// функция возвращает результат пересечения области удара с областью контакта Dragonbones
bool JCAnyArmature::_isDGBIntersectsRectBone(const Rect ▭, int boneTag)
{
bool result = false;
dragonBones::Bone *bone = nullptr;
dragonBones::Slot *slot = nullptr;
switch (boneTag)
{
case HertboxTag::HURTBOX0:
bone = boneDGBHurtbox0_;
slot = slotDGBHurtbox0_;
break;
case HertboxTag::HURTBOX1:
bone = boneDGBHurtbox1_;
slot = slotDGBHurtbox1_;
break;
default:
bone = boneDGBHurtbox0_;
slot = slotDGBHurtbox0_;
break;
}
if (slot->getDisplay())
{
int sign = (armature_->getScaleX() > 0) - (armature_->getScaleX() < 0);
dragonBones::Transform *transform = bone->getGlobal();
float scale = fabs(armature_->getScaleX());
Vec2 pos = Vec2(armature_->getPositionX() + transform->x * scale * sign, armature_->getPositionY() + transform->y * scale);
Node *parallaxNode = armature_->getParent()->getParent();
float parallaxScale = parallaxNode->getScale();
scale *= parallaxScale;
pos *= parallaxScale;
pos += parallaxNode->getPosition();
dragonBones::ImageDisplayData *imageDisplayData = static_cast(slot->getRawDisplayDatas()->at(0));
dragonBones::Rectangle\* region = imageDisplayData->getTexture()->getRegion();
Size size = Size(region->width, region->height);
size.width \*= fabs(transform->scaleX) \*scale;
size.height \*= fabs(transform->scaleY) \*scale;
Rect rectBone = Rect(pos - (size / 2), size);
if (rectBone.intersectsRect(rect))
{
result = true;
this->\_calculateIntersectPoint(rectBone, rect);
}
}
return result;
}
```
Дополнительно в нашей игре будут использоваться двигатели для осуществления полета персонажей, чтобы проходить отдельные участки уровней и реализации возможных сражений в воздухе. Для этого нам необходимо было решить вопрос добавления анимации двигателя к одной из костей внутри анимации персонажа.
EngineВ CocoStudio вопрос решался довольно просто, так как реализация нам давно знакома. Что касается Dragonbones, в [демонстрационных примерах](https://github.com/DragonBones/Demos) можно найти информацию, как заменить готовый слот. Но чтобы добавить новый пришлось разбираться и создать дополнительные функции класса.
```
// функция создает двигатель
void JCAnyArmature::createEngine(JCEngineInfo &engineInfo, PhysicsBody *physicsBody)
{
if (engineInfo.isNull())
return;
JCEngine *engine = JCEngine::create(engineInfo.fileId, armatureType_);
switch (armatureType_)
{
case JCArmatureEditor::Type::COCOSTUDIO:
this->_addCCSEngine(engine, engineInfo);
break;
case JCArmatureEditor::Type::DRAGONBONE:
this->_addDGBEngine(engine, engineInfo);
break;
default:
this->_addCCSEngine(engine, engineInfo);
break;
}
engine->setPhysicsBody(physicsBody);
}
```
```
// функция добавляет двигатель для анимации CocoStudio
void JCAnyArmature::_addCCSEngine(JCEngine *engine, const JCEngineInfo &engineInfo)
{
cocostudio::Armature *armature = static_cast(engine->getArmature());
cocostudio::Bone \*boneEngine = cocostudio::Bone::create("engine");
boneEngine->addDisplay(armature, 0);
boneEngine->changeDisplayWithIndex(0, true);
boneEngine->setLocalZOrder(engineInfo.zOrder);
boneEngine->setPosition(engineInfo.shift);
boneEngine->setRotation(engineInfo.angle);
boneEngine->setScale(engineInfo.scale);
boneEngine->setVisible(true);
boneEngine->setIgnoreMovementBoneData(true);
static\_cast(armature\_)->addBone(boneEngine, "body");
}
```
```
// функция добавляет двигатель для анимации Dragonbones
void JCAnyArmature::_addDGBEngine(JCEngine *engine, const JCEngineInfo &engineInfo)
{
dragonBones::CCArmatureDisplay* armatureEngine = static_cast(engine->getArmature());
dragonBones::SlotData \*slotData = dragonBones::BaseObject::borrowObject();
slotData->name = "engine";
slotData->color = dragonBones::SlotData::createColor();
slotData->zOrder = engineInfo.zOrder;
slotData->parent = static\_cast(armature\_)->getArmature()->getArmatureData()->getBone("body");
dragonBones::CCSlot \*slotEngine = dragonBones::BaseObject::borrowObject();
dragonBones::DBCCSprite \*rawDisplay = dragonBones::DBCCSprite::create();
rawDisplay->setCascadeOpacityEnabled(true);
rawDisplay->setCascadeColorEnabled(true);
rawDisplay->setAnchorPoint(cocos2d::Vec2::ZERO);
rawDisplay->setLocalZOrder(slotData->zOrder);
slotEngine->init(slotData, static\_cast(armature\_)->getArmature(), rawDisplay, rawDisplay);
slotEngine->offset.x = engineInfo.shift.x;
slotEngine->offset.y = -engineInfo.shift.y;
slotEngine->offset.rotation = CC\_DEGREES\_TO\_RADIANS(engineInfo.angle);
slotEngine->offset.scaleX = engineInfo.scale;
slotEngine->offset.scaleY = engineInfo.scale;
slotEngine->setChildArmature(armatureEngine->getArmature());
}
```
В результате проделанной работы, мы все также имеем возможность быстрого создания анимации различных объектов и персонажей привычным для нас инструментом.
На создание контента для игр уходит очень большое количество времени, которого у нас катастрофически не хватает. Но благодаря такому подходу, мы можем изучать возможности Dragonbones, не снижая при этом нашу продуктивность.
Безусловно, не всем данный подход покажется правильным.
В нашем случае, мы решили, что время, потраченное мной на создание кода, будет намного меньше, чем на изучение Dragonbones с нуля и полный переход на его использование.
Например, при создании прототипа какого-то игрового объекта (персонажа, оружия, бонуса или платформы) мы можем взять анимацию готового объекта, из выпущенной нами ранее игры. Использовать его для реализации необходимого функционала, а далее уже заменить этот объект новым. Другими словами, отказ от использования CocoStudio повлек бы за собой дополнительные затраты времени на конвертирование анимаций из существующей у нас базы, в анимации Dragonbones.
Не смотря на то, что в России и странах СНГ разработчиков игр, использующих cocos2d-x, очень мало, я все же надеюсь, что данная статья окажется полезной коллегам, использующим его в работе, или тем, кто собирает начать им пользоваться.
Я адекватно отношусь к конструктивной критике результатов своего труда. Поэтому обязательно прислушаюсь советам и замечаниям.
На текущий момент еще остались наработки, которые я не стал описывать в данной статье. Они не подходят под тему использования двух редакторв анимации. Если материал про разработку на cocos2d-x, указанный в статье окажется интересным, я могу дополнить его дополнительной статьей. На мой взгляд, у нас накопилось достаточно хорошего материала при разработке этого проекта.
В завершение приведу [ссылку](https://store.steampowered.com/app/1706740/Jaws__Claws) на страницу игры в Steam. В ролике можно увидеть геймплей с реализованным функционалом из статьи.
[Ссылка на продолжение](https://habr.com/ru/post/650279/) | https://habr.com/ru/post/600057/ | null | ru | null |
# Meteor — Node.js для гуманитариев
Введение
--------
На хабре уже несколько раз упоминали о проекте [Meteor](https://meteor.com/), основанном в 2011 году [семерыми энтузиастами](http://meteor.com/about/mission) web-технологий из Сан-Франциско. По сути Meteor является просто надстройкой над node.js, который сам ещё даже не дошёл до релизной версии. Тем не менее проект собрал более семи тысяч подписчиков на github и [получил 11 миллионов долларов](http://habrahabr.ru/post/148648/) инвестиций.
С чего такая популярность? Дело в заявлении авторов о том, что они хотят кардинально переосмыслить способ написания современных web-приложений в сторону его упрощения. Не секрет, что написание кода на чистом node.js довольно сильно выворачивает мозг и вынуждает использовать различные костыли  в виде control flow средств. На Meteor, говорят авторы, писать крутые приложения сможет даже гуманитарий.
Ну что же, проверим. Имеется: 1 гуманитарий-социолог, закрывший сессию и желающий после Парсонса и Зиммеля перейти на что-нибудь полегче, компьютер с Ubuntu 12.10 и установленный node.js (не спрашивайте, как он оказался у социолога).
Вдохновимся обещаниями разработчиков, прекрасной девушкой-членом команды и начнём.
Установка
---------
Установка элементарна – пишем в терминале
```
$ curl https://install.meteor.com | sh
```
Создание и запуск первого приложения
------------------------------------
Для того, чтобы создать первое приложение, напишем в терминале
```
$ meteor create <имя_приложения>
```
Для запуска необходимо прописать слово meteor в директории приложения
```
$ cd <имя_приложения>
$ meteor
```
Заходим на <http://localhost:3000/> и видим наш Hello world
Да, не врут ребята, ничего сложного, даже hello world за нас написали.
Простой блог
------------
Но нам же надо что-нибудь позабористей. Напишем, например, простенький блог.
`Disclaimer: вообще-то meteor (как и node.js) предназначен в первую очередь для создания сложных одностраничных приложений и в обычном блоге многие его возможности останутся неиспользованными.`
#### Структура
Meteor исповедует идеологию «Один код на сервере и клиенте». Это выражается в том, что код из всех .js-файлов в проекте (.coffee также допустим при установке соответствующего smart package) за исключением такового в поддиректориях `server`, `client` и `public` исполняются как на серверной стороне в node.js (через fiber), так и в браузере у пользователя.
Код из директории server может исполняться только на сервере, из `client` — на клиентской, а в `public`, где хранятся статичные файлы, его вообще не должно быть. Также в нашем распоряжении имеются логические переменные `Meteor.isClient` и `Meteor.isServer`, которые принимают различные значения в зависимости от того, где исполняется код.
То же самое относится к .css и .html файлам — они могут быть разбросаны по всему проекту. Meteor сам найдёт и соберёт их вместе.
Есть ещё одна особая директория test, из которой ничто никуда по умолчанию не загружается.
Так же необходимо понять, что meteor – это такая сборная солянка из многих технологий, так что чистого javascript'а может быть совсем немного. jQuery и Underscore здесь правят балом. Не надо ничего устанавливать, просто пишите как вы привыкли. В качестве шаблонизатора используется [Handlebars](http://handlebarsjs.com/) – продвинутая версия Mustache. Общение с базой данных MongoDB (обещается поддержка и других вариантов) осуществляется с помощью Minimongo ([minimongo.com](http://minimongo.com/) судя по всему обещает приятную работу с этой обёрткой).
В качестве css фреймворка в данном примере будет использован [Foundation](http://foundation.zurb.com/), который мне нравится больше аналогичного Twitter Bootstrap, но это дело вкуса.
#### Вывод записей
Начнём с обращения к базе данных. На сервере в .js файле создадим новую коллекцию, в которой будут храниться все наши записи.
```
Posts = new Meteor.Collection("posts");
```
Там же зададим начальные значения:
```
Meteor.startup(function () { // этот код исполняется сразу после запуска
if (Posts.find().count() === 0) {
var posts = [
{
title: "Title one",
text: "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Et iure porro sunt repudiandae amet saepe asperiores commodi repellendus hic accusamus obcaecati ipsum modi magnam nulla magni vitae ea voluptates dignissimos!",
published: (new Date()).toLocaleTimeString()
},
{
title: "Title two",
text: "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Culpa natus mollitia similique accusamus minus harum magnam eum pariatur rerum fugit ducimus sapiente asperiores quidem molestias repudiandae consequuntur repellendus dolorum placeat.",
published: (new Date()).toLocaleTimeString()
}
];
for (var i = 0; i < posts.length; i++) {
Posts.insert({
title: posts[i].title,
text: posts[i].text,
published: posts[i].published,
});
}
}
});
```
Затем создадим Handlebars шаблон отображения записей и назовём его stream:
```
Blog
{{> stream}}
{{#each posts}}
{{> post}}
{{/each}}
{{title}}
---------
{{{text}}}
{{published}}
```
… и выведем через него начальные значения.
```
Template.stream.posts = function () {
return Posts.find({}, {sort: {published: -1}});
};
```
Таким образом мы вывели все записи на главную страницу.
#### Добавление и удаление записей
Для того, чтобы добавить свои записи сначала создадим новый шаблон editor с соответствующей формой добавления:
```
Новая запись
============
Заголовок
Текст
Опубликовать
``` | https://habr.com/ru/post/166885/ | null | ru | null |
# Автоматическое увеличение номера сборки в Xcode
Пользователи и тестировщики могут найти ошибки, которые вы наверняка уже исправили. Иногда пользователи используют старую версию приложения, иногда ваши исправления не так хороши, как вы думали. В обоих случаях небольшой уникальный номер версии, отображаемый в приложении, может сэкономить часы вашей работы.
##### Это можно сделать
Существует дюжина способов это сделать, которые можно найти в Google. Но, к сожалению, не все они работают и в Xcode 3.2 и в Xcode 4, а другие требуют много «костылей», даже запуск внешних скриптов на Perl или Python. Использование же [avgtool](http://developer.apple.com/mac/library/documentation/Darwin/Reference/ManPages/man8/agvtool.8.html#//apple_ref/doc/man/Xcode-3.2.1/Xcode-2.5/8/agvtool) кажется излишним в большинстве случаев. Должен ведь быть более простой способ сделать это, и такой способ есть.
Все, что мы хотим, это иметь номер сборки в файле Info.plist, откуда мы сможем прочести его и отобразить в приложении. Еще мы хотим, чтобы этот номер автоматически увеличивался с каждой новой сборкой проекта.
Добавим ключ, названный *CWBuildNumber*, в наш файл Info.plist и установим ему некоторое стартовое значение, например «0». Вы можете прочитать это значение в приложении с помощью конструкции:
`NSString* buildNumber = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CWBuildNumber"];`
Xcode 3.2 и Xcode 4 позволяют нам запускать скрипты во время выполнения для любой цели. К сожалению, Xcode 3.2 и Xcode 4 запускают их с разными путями. Переменная окружения *PROJECT\_DIR* спасет положение! Нам надо получить номер сборки, увеличить его и перезаписать файл Info.plist нашей цели во время сборки. Просто вставим следующий код в Run Script нашей цели:
`buildNumber=$(/usr/libexec/PlistBuddy -c "Print CWBuildNumber" ${PROJECT_DIR}/TestIncrement/TestIncrement-Info.plist)
buildNumber=$(($buildNumber + 1))
/usr/libexec/PlistBuddy -c "Set :CWBuildNumber $buildNumber" ${PROJECT_DIR}/TestIncrement/TestIncrement-Info.plist`
\* **примечание переводчика**: *поменяйте путь к файлу Info.plist в упомянутом коде на свой путь.*
##### Заключение
Счасливы тестировщики, счастливы разработчики. Возможно, счастливы даже пользователи, если вы будете отображать полную версию, включая номер сборки, в конечном продукте. | https://habr.com/ru/post/132195/ | null | ru | null |
# Video rip. Часть 2-3. Избавление от обычной чересстрочности (deinterlace)
#### Содержание
1. Подготовка DVD
1. [vStrip](http://habrahabr.ru/blogs/video_processing/50256/)
2. [DGMPGDec](http://habrahabr.ru/blogs/video_processing/50611/)
2. Обработка видео
1. [Что такое interlace и с чем его едят](http://habrahabr.ru/blogs/video_processing/51201/)
2. [Как определить что у нас: progressive, interlaced или telecined?](http://habrahabr.ru/blogs/video_processing/61826/)
3. **Избавление от обычной чересстрочности (deinterlace)**
4. [IVTC](http://habrahabr.ru/blogs/video_processing/88654/)
3. [Сжимаем и запаковываем](http://habrahabr.ru/blogs/video_processing/88668/)
Первое, что надо сделать — выкинуть из головы идею воспользоваться фильтром deinterlace из VirtualDub. Я знаю, это непросто, но необходимо. Всё дело в том, что после обработки этим фильтром (с некоторыми настройками) на видео появляются паразитные изображения, например т.н. ghost effect. Выглядит он примерно [вот так](http://i42.tinypic.com/al5ekk.jpg) или [вот так](http://i28.tinypic.com/2eelhl2.jpg). Это ужасно.
Скриншоты для примеров я делал с видео, которым со мной поделился [madnut](https://habrahabr.ru/users/madnut/).
Избавляться от чересстрочности мы будем при помощи плагинов для AviSynth. Придумано их [много](http://avisynth.org/mediawiki/External_filters#Deinterlacing), поэтому все возможные упомянуты не будут. Если забыл ваш любимый — не сердитесь. Подчеркну, что в этой статье не рассматриваются плагины для удаления pulldown и IVTC. О них — потом.
Также, напомню, что в случае обычной чересстрочности сделать видео прогрессивным без потерь качества — не получится.
Для начала требуется установить правильный порядок появления полей. Top Field First (TFF) или Bottom Field First(BFF). Для этого в AviSynth существуют две команды AssumeTFF или AssumeBFF. Как это сделать хорошо написано [здесь](http://www.avisynth.org.ru/docs/russian/externalfilters/checkparity.htm). Также, это показывает DGMpgDec. Также, вам в этом может помочь MeGUI. Как? Читайте предыдущую часть, только вместо Source type смотрите на поле Field order.
В результате у вас будет нечто такое:
`DirectShowSource("00581.mts")
AssumeTFF()`
Перейдём непосредственно к фильтрам.
**Bob**
Это даже не название конкретного плагина, а название целой техники «Bob deinterlacing». Суть её в том, что частота кадров — удвояется, используя поля в качестве кадров. Одновременно с этим восстанавливаются недостающие строки в каждом поле при помощи интерполяции или дублирования. Минусы вытекают из удвоения частоты кадров — более ресурсоёмкое декодирование и увеличение размера видеопотока.
Считается лучшим методом, если судить только по выходному качеству.
Для применения «Bob deinterlacing» добавьте в конец скрипта команду Bob. В результате получится:
`DirectShowSource("00581.mts")
AssumeTFF()
Bob()`
[Скриншот](http://i31.tinypic.com/20a8207.jpg)
**YADIF**
Название — аббревиатура от **Y**et **A**nother **D**e**I**nterlacing **F**ilter. Этот фильтр был портирован для AviSynth Михаэлем Ниедермауэром (Michael Niedermayer). Он проверяет пикселы предыдущего, текущего и следующего кадра для восстановления полей посредством локального адаптивного метода (edge-directed interpolation) и использует spatial check для предотвращения появления большинства артефактов. Подробное объяснение алгоритма [здесь](http://trac.handbrake.fr/wiki/yadif).
Один из самых простых в использовании фильтров. У меня версия 0.9.
На вход принимает 4 параметра:
* 0 — производит temporal и spatial проверки, используется по умолчанию;
* 1 — то же что и 0, но удваивает частоту кадров (старый знакомый bob);
* 2 — не производит temporal и spatial проверки;
* 3 — удваивает частоту кадров, но не производит temporal и spatial проверки.
Скриншоты: [0,](http://i28.tinypic.com/335hbeo.jpg) [1](http://i25.tinypic.com/20jmtkx.jpg), [2](http://i29.tinypic.com/5bo97d.jpg), [3](http://i29.tinypic.com/30vj6dj.jpg).
Пример использования:
`LoadCplugin("yadif.dll")
DirectShowSource("00581.mts")
AssumeTFF()
Yadif(0)`
или, что тоже самое,
`LoadCplugin("yadif.dll")
DirectShowSource("00581.mts")
AssumeTFF()
Yadif()`
Какой из методов использовать? Используйте — 0, если вы не знаете, что вам нужны другие.
**SmoothDeinterlace**
Этот плагин посложнее. Имеет кучу всяких [параметров](http://avisynth.org/SmoothDeinterlacer) для тонкой подстройки. Использовать его, впрочем, достаточно просто.
`LoadPlugin("SmoothDeinterlacer.dll")
DirectShowSource("00581.mts")
AssumeTFF()
SmoothDeinterlace()`
Можно добавлять разные настройки, например, **doublerate** — удвоение частоты кадров.
`LoadPlugin("SmoothDeinterlacer.dll")
DirectShowSource("00581.mts")
AssumeTFF()
SmoothDeinterlace(doublerate=true)`
Скриншоты: [по умолчанию](http://i28.tinypic.com/16a1kko.jpg), [с удвоением](http://i31.tinypic.com/2vwsfao.jpg).
**TomsMoComp**
Процитирую [официальный](http://www.avisynth.org.ru/docs/russian/externalfilters/tomsmocomp.htm) источник.
> TomsMoComp.dll – это фильтр деинтерлейса, использующий компенсацию движения и адаптивную обработку. Он работает с различной скоростью в зависимости от параметра SearchEffort, который в данной версии варьируется от 0 (просто чуть более качественный BOB-деинтерлейс) до 30 (слишком большой объём вычислений для современных компьютеров). Из этого диапазона реально используется несколько значений (в данной версии 0,1,3,5,9,11,13,15,19,21,max), если задать другое значение, то используется ближайшее из перечисленных. Значения свыше 15 пока ещё не очень тщательно тестировались и, вероятно, их следует избегать.
Собственно, не добавить и не убавить.
Пример использования:
`LoadPlugin("TomsMoComp.dll")
DirectShowSource("00581.mts")
AssumeTFF()
TomsMoComp(-1, 1, 0)`
Параметр SearchEffort — второй.
Скриншоты для SearchEffort = [1](http://i31.tinypic.com/2s7x6bc.jpg), [30](http://i30.tinypic.com/2qtit1y.jpg).
На этом, пожалуй, остановлюсь. Какой фильтр использовать, спросите вы? А я отвечу — не знаю. Выбор фильтра сродни спорам о выборе кодека или операционной системы. Пробуйте. Какой вам кажется лучшим — тот и используйте. Если всё же вас раздирают сомнения, то пробуйте сначала YADIF, потом TomsMoComp и если ни один из этих не подошёл SmoothDeinterlace. Чистый Bob используйте в том случае, если вы точно уверены в необходимости его использования.
[Скачать TomsMoComp 0.0.1.7](http://www.avisynth.org.ru/docs/russian/externalfilters/tomsmocomp.htm)
[Скачать SmoothDeinterlace 1.5.5](http://www.guthspot.se/video/AVSPorts/SmoothDeinterlacer/)
[Скачать YADIF 0.9](http://avisynth.org.ru/yadif/yadif.html)
**Дополнения от читателей**
[Xitsa](https://habrahabr.ru/users/xitsa/)
> Разговор был бы неполным без легендарного скрипта **MVBob**, считается лучшим в своём роде. О нём лучше прочитать всё, что найдётся на doom9.
>
> Если кто-то хочет попробовать, то [вот](http://ifile.it/y0uqk7v) не очень свежая сборка (зато всё в комплекте).
>
>
[sabox](https://habrahabr.ru/users/sabox/)
> А как же TDeint? На мой взгляд, его можно в ряд с вышеперечисленными ставить.
>
>
>
> TDeint — это двунаправленый, компенсированный по движению (резкостный) удалитель чересстрочности (деинтерлейсер). Он также может адаптивно выбирать между использованием адаптации к движению по целым полям и по пикселам. Может использовать кубическую интерполяцию, ядерную (матричную) интерполяцию (с переключением временнОго направления), или одну из двух форм модифицированой краевой адаптивной (ELA) интерполяции, которая помогает уменьшить «зубчатые» края в движущихся областях, где интерполяция должна использоваться. TDeint также поддерживает ручную коррекцию пользователем через специальный входной файл и может работать как интеллектуальный преобразователь полей в полноформатный кадр (bobber) или удалитель черестрочности с сохранением исходной частоты кадров, а также как пост-обработчик обратного преобразования телекино (IVTC).
>
> | https://habr.com/ru/post/61822/ | null | ru | null |
# Исследуем .NET 6. Часть 1
В этой серии статей я собираюсь взглянуть на некоторые из новых функций, которые появились в .NET 6. Про .NET 6 уже написано много контента, в том числе множество постов непосредственно от команд .NET и ASP.NET. Я же собираюсь рассмотреть код некоторых из этих новых функций.
Заглянем в ConfigurationManager
-------------------------------
В этом первом посте я рассмотрю класс `ConfigurationManager`, почему он был добавлен, а также часть кода, использованного для его реализации.
Погодите-ка, что за `ConfigurationManager`?
Если у вас сразу возник этот вопрос, не волнуйтесь, вы не пропустили ничего важного!
ConfigurationManager был добавлен для поддержки новой модели `WebApplication` в ASP.NET Core\*, используемой для упрощения кода запуска приложений ASP.NET Core. Однако `ConfigurationManager` во многом является деталью реализации. Он был введён для оптимизации определённого сценария (который я вкратце опишу), но в большинстве случаев вы не будете (да это и не нужно) знать, что вы его используете.
Прежде чем мы перейдём, собственно, к `ConfigurationManager`, рассмотрим, что он заменяет и почему.
#### Конфигурация приложений в .NET 5
.NET 5 предоставляет несколько типов конфигурации, но два основных из них, которые вы используете непосредственно в своих приложениях, приведены ниже:
* `IConfigurationBuilder` — используется для добавления источников конфигурации. Вызов `Build()` в построителе считывает каждый из источников конфигурации и строит окончательную конфигурацию.
* `IConfigurationRoot` — представляет собой окончательную «построенную» конфигурацию.
Интерфейс `IConfigurationBuilder`, по сути, представляет собой обёртку для списка источников конфигурации. Поставщики конфигурации обычно включают методы расширения (например, `AddJsonFile()` и `AddAzureKeyVault()`), которые добавляют источник конфигурации в список источников.
`public interface IConfigurationBuilder
{
IDictionary Properties { get; }
IList Sources { get; }
IConfigurationBuilder Add(IConfigurationSource source);
IConfigurationRoot Build();
}`
`IConfigurationRoot` в свою очередь представляет окончательные «многоуровневые» значения конфигурации, объединяя все значения из каждого из источников конфигурации, чтобы дать окончательное «плоское» представление всех значений.
Более поздние поставщики конфигурации (переменные среды) перезаписывают значения, добавленные более ранними поставщиками конфигурации (appsettings.json, sharedsettings.json). Взято из моей книги ASP.NET в Действии (https://dmkpress.com/catalog/computer/web/978-5-97060-550-9/)В .NET 5 и ранее интерфейсы `IConfigurationBuilder` и `IConfigurationRoot` реализуются с помощью `ConfigurationBuilder` и `ConfigurationRoot` соответственно. Если бы вы использовали эти типы напрямую, вы могли бы сделать что-то вроде этого:
`var builder = new ConfigurationBuilder();
// добавляем статические значения builder.AddInMemoryCollection(new Dictionary
{
{ "MyKey", "MyValue" },
});
// добавляем значения из json файла
builder.AddJsonFile("appsettings.json");
// создаём экземпляр IConfigurationRoot
IConfigurationRoot config = builder.Build();
// получаем значение
string value = config["MyKey"];
// получаем секцию
IConfigurationSection section = config.GetSection("SubSection");`
В типичном приложении ASP.NET Core вы не создаёте `ConfigurationBuilder` самостоятельно или не вызываете `Build()`, однако это то, что происходит за кулисами. Между этими двумя типами существует чёткое разделение, и в большинстве случаев эта система конфигурации работает хорошо. Так зачем нам новый тип в .NET 6?
#### Проблема "частичной сборки конфигурации" в .NET 5
Основная проблема с этим подходом проявляется, когда вам нужно построить конфигурацию «частично». Это распространённая проблема, когда вы храните свою конфигурацию в таком сервисе, как Azure Key Vault, или даже в базе данных.
Например, ниже приведён [рекомендуемый способ чтения секретов из Azure Key Vault](https://docs.microsoft.com/en-us/aspnet/core/security/key-vault-configuration?view=aspnetcore-5.0#use-application-id-and-x509-certificate-for-non-azure-hosted-apps) внутри `ConfigureAppConfiguration()` в ASP.NET Core:
`.ConfigureAppConfiguration((context, config) =>
{
// "нормальная" конфигурация
config.AddJsonFile("appsettings.json");
config.AddEnvironmentVariables();
if (context.HostingEnvironment.IsProduction())
{
// построение частичной конфигурации
IConfigurationRoot partialConfig = config.Build();
// чтение значения из конфигурации
string keyVaultName = partialConfig["KeyVaultName"];
var secretClient = new SecretClient(
new Uri($"https://{keyVaultName}.vault.azure.net/"),
new DefaultAzureCredential());
// добавляем ещё один источник конфигурации
config.AddAzureKeyVault(secretClient, new KeyVaultSecretManager());
// Фреймворк СНОВА вызывает config.Build(),
// чтобы построить окончательный IConfigurationRoot
}
})`
Для настройки поставщика Azure Key Vault требуется значение конфигурации, поэтому вы столкнулись с проблемой курицы и яйца: вы не можете добавить источник конфигурации, пока не создадите конфигурацию!
Решение состоит в следующем:
* Добавить «начальные» значения конфигурации.
* Создать «частичный» результат конфигурации, вызвав `IConfigurationBuilder.Build()`
* Получить необходимые значения конфигурации из построенного `IConfigurationRoot`
* Использовать эти значения, чтобы добавить оставшиеся источники конфигурации.
* Фреймворк неявно вызывает `IConfigurationBuilder.Build()`, генерируя окончательный `IConfigurationRoot` и используя его для окончательной конфигурации приложения.
Этот танец с бубном немного странный, но формально в нём нет ничего неправильного. Тогда в чём же проблема?
Проблемой является то, что нам нужно вызвать `Build()` дважды: один раз для создания `IConfigurationRoot` с использованием только начальных источников, а затем ещё раз для создания `IConfiguartionRoot` с использованием всех источников, включая источник Azure Key Vault.
В реализации `ConfigurationBuilder` по умолчанию вызов `Build()` выполняет итерацию по всем источникам, загружает поставщиков и передаёт их новому экземпляру `ConfigurationRoot`:
`public IConfigurationRoot Build()
{
var providers = new List();
foreach (IConfigurationSource source in Sources)
{
IConfigurationProvider provider = source.Build(this);
providers.Add(provider);
}
return new ConfigurationRoot(providers);
}`
Затем `ConfigurationRoot` по очереди перебирает каждого из этих поставщиков и загружает значения конфигурации.
`public class ConfigurationRoot : IConfigurationRoot, IDisposable
{
private readonly IList \_providers;
private readonly IList \_changeTokenRegistrations;
public ConfigurationRoot(IList providers)
{
\_providers = providers;
\_changeTokenRegistrations = new List(providers.Count);
foreach (IConfigurationProvider p in providers)
{
p.Load();
\_changeTokenRegistrations.Add(ChangeToken.OnChange(() => p.GetReloadToken(), () => RaiseChanged()));
}
}
// ... остальная реализация
}`
Если вы вызовете `Build()` дважды во время запуска приложения, всё это выполнится дважды.
Строго говоря, нет ничего плохого в том, чтобы получить данные из источника конфигурации более одного раза, но это ненужная работа и часто включает (относительно медленное) чтение файлов и т. п.
Это настолько распространённый сценарий, что в .NET 6 был введён новый тип `ConfigurationManager`, позволяющий избежать этого «перепостроения».
#### Менеджер Конфигурации в .NET 6
В .NET 6 разработчики .NET добавили новый тип конфигурации, `ConfigurationManager`, как часть «упрощённой» модели приложения. Этот тип реализует как `IConfigurationBuilder`, так и `IConfigurationRoot`. Объединив обе реализации в одном типе, .NET 6 может оптимизировать этот распространённый сценарий, показанный в предыдущем разделе.
В `ConfigurationManager`, когда добавляется `IConfigurationSource` (например, когда вы вызываете `AddJsonFile()`), поставщик сразу загружается, и конфигурация обновляется. Это позволяет избежать загрузки источников конфигурации более одного раза в сценарии частичной сборки.
Реализовать это немного сложнее, чем кажется, из-за интерфейса `IConfigurationBuilder`, хранящего источники в виде `IList`:
`public interface IConfigurationBuilder
{
IList Sources { get; }
// … другие члены
}`
Проблема с этим с точки зрения ConfigurationManager заключается в том, что `IList<>` предоставляет методы `Add()` и `Remove()`. Если бы использовался простой `List<>`, потребители могли бы добавлять и удалять поставщиков конфигурации, а ConfigurationManager об этом бы не знал.
Чтобы обойти это, `ConfigurationManager` использует свою реализацию `IList<>`. Она содержит ссылку на экземпляр `ConfigurationManager`, чтобы любые изменения могли быть отражены в конфигурации:
`private class ConfigurationSources : IList
{
private readonly List \_sources = new();
private readonly ConfigurationManager \_config;
public ConfigurationSources(ConfigurationManager config)
{
\_config = config;
}
public void Add(IConfigurationSource source)
{
\_sources.Add(source);
// добавляет источник в ConfigurationManager
\_config.AddSource(source);
}
public bool Remove(IConfigurationSource source)
{
var removed = \_sources.Remove(source);
// перезагрузка источников в ConfigurationManager
\_config.ReloadSources();
return removed;
}
// ... остальная реализация
}`
Используя собственную реализацию `IList<>`, ConfigurationManager гарантирует, что `AddSource()` вызывается всякий раз, когда добавляется новый источник. В этом заключается преимущество `ConfigurationManager`: вызов `AddSource()` немедленно загружает источник.
`public class ConfigurationManager
{
private void AddSource(IConfigurationSource source)
{
lock (_providerLock)
{
IConfigurationProvider provider = source.Build(this);
_providers.Add(provider);
provider.Load();
_changeTokenRegistrations.Add(ChangeToken.OnChange(() => provider.GetReloadToken(), () => RaiseChanged()));
}
RaiseChanged();
}
}`
Этот метод немедленно вызывает `Build` на `IConfigurationSource` для создания `IConfigurationProvider` и добавляет его в список поставщиков.
Затем вызывается метод `IConfigurationProvider.Load()`. Он загружает данные в поставщик (например, из переменных среды, файла JSON или Azure Key Vault) и является «дорогостоящим» шагом, для которого всё это и затевалось! В «нормальном» случае, когда вы просто добавляете источники в `IConfigurationBuilder` и в случае, когда вам требуется построить его несколько раз, это более «оптимальный» подход: источники загружаются один раз, и только один раз.
Реализация `Build()` в `ConfigurationManager` теперь пустая, просто возвращает себя.
`IConfigurationRoot IConfigurationBuilder.Build () => this;`
Конечно, разработка программного обеспечения — это всегда компромиссы. Инкрементное создание источников при их добавлении хорошо работает, если вы только добавляете источники. Однако, если вы вызываете любую из других функций `IList<>`, таких как `Clear()`, `Remove()` или индексатор, `ConfigurationManager` должен вызвать `ReloadSources()`
`private void ReloadSources()
{
lock (_providerLock)
{
DisposeRegistrationsAndProvidersUnsynchronized();
_changeTokenRegistrations.Clear();
_providers.Clear();
foreach (var source in _sources)
{
_providers.Add(source.Build(this));
}
foreach (var p in _providers)
{
p.Load();
_changeTokenRegistrations.Add(ChangeToken.OnChange(() => p.GetReloadToken(), () => RaiseChanged()));
}
}
RaiseChanged();
}`
Как видите, если какой-либо из источников изменится, `ConfigurationManager` должен удалить всё и начать заново, перебирая каждый из источников и перезагружая их. Если вы много манипулируете источниками конфигурации, это может дорого вам обойтись, и полностью сведёт на нет первоначальное преимущество `ConfigurationManager`.
Конечно, удаление источников довольно странная операция: обычно нет причин делать что-либо, кроме добавления, — поэтому `ConfigurationManager` оптимизирован для наиболее распространенных случаев. Кто бы мог подумать? 😉
В следующей таблице приведены сводные данные об относительной стоимости различных операций при использовании `ConfigurationBuilder` и `ConfigurationManager`.
| | | |
| --- | --- | --- |
| **Операция** | **ConfigurationBuilder** | **ConfigurationManager** |
| Добавление источника | Дёшево | Относительно дорого |
| Частичное построение IConfigurationRoot | Дорого | Очень дёшево (пустая операция) |
| Полное построение IConfigurationRoot | Дорого | Очень дёшево (пустая операция) |
| Удаление источника | Дёшево | Дорого |
| Изменение источника | Дёшево | Дорого |
#### Стоит ли беспокоиться о ConfigurationManager?
Итак, после всего вышесказанного, стоит ли вам беспокоиться о том, используете ли вы `ConfigurationManager` или `ConfigurationBuilder`?
Скорее нет.
Новый `WebApplicationBuilder`, представленный в .NET 6, использует ConfigurationManager, оптимизированный для случая использования, который я описал выше, когда вам необходимо частично построить конфигурацию.
Однако `WebHostBuilder` или `HostBuilder`, представленные в более ранних версиях ASP.NET Core, по-прежнему поддерживаются в .NET 6, и они по-прежнему «за кулисами» используют типы `ConfigurationBuilder` и `ConfigurationRoot`.
Единственная ситуация, которую я могу представить, когда вам нужно быть осторожным, — это если вы где-то полагаетесь на то, что `IConfigurationBuilder` или `IConfigurationRoot` представлены в виде конкретных типов `ConfigurationBuilder` или `ConfigurationRoot`. Мне это кажется маловероятным, и, если вы полагаетесь на это, мне было бы интересно узнать, почему!
Но, помимо этого маловероятного исключения, «старые» типы никуда не денутся, так что не о чем беспокоиться. Просто порадуйтесь, зная, что, если вам нужно выполнить «частичную сборку» и вы используете новый `WebApplicationBuilder`, ваше приложение будет немного более производительным.
#### Итого
В этом посте я описал новый тип ConfigurationManager, представленный в .NET 6 и используемый новым `WebApplicationBuilder` в минимальных API. `ConfigurationManager` был введен для оптимизации распространённого сценария, когда вам необходимо «частично построить» конфигурацию. Обычно это происходит потому, что поставщику конфигурации требуется некоторая предварительная конфигурация. Например, для загрузки секретов из Azure Key Vault требуется конфигурация, указывающая, какое хранилище использовать.
`ConfigurationManager` оптимизирует этот сценарий, немедленно загружая источники по мере их добавления, а не дожидаясь вызова `Build()`. Это позволяет избежать необходимости «перестраивать» конфигурацию в сценарии «частичной сборки». Компромисс заключается в том, что другие операции (например, удаление источника) являются дорогостоящими.
[Оригинал](https://andrewlock.net/exploring-dotnet-6-part-1-looking-inside-configurationmanager-in-dotnet-6/)
### От переводчика
\* Несмотря на то, что, начиная с .NET 5, создатели больше не используют слово Core в названии, автор использует его, поэтому я решил сохранить авторский стиль в переводе.
PS: Это мой первый опыт переводов для Хабра, поэтому не судите строго. В дальнейшем планирую перевести и остальные статьи этой серии. | https://habr.com/ru/post/594423/ | null | ru | null |
# Правила хорошего тона для API
Перенос функциональности сайта, интернет-магазина или портала в мобильное приложение имеет ряд преимуществ как для владельца онлайн-сервиса, так и для его клиентов. Владелец получает дополнительный канал связи со своей целевой аудиторией и возможность персонализировать рекламные объявления, а пользователь – более удобный интерфейс, дополнительный функционал и возможность получения своевременных оповещений.
О том, какие принципы и инструменты мы используем для добавления REST API к проектам, читайте под катом.
Существует множество фреймворков, ориентированных на разработку API. Особенно их много на NodeJS, но и на других языках – достаточно. Тем не менее, когда задача состоит в использовании существующего функционала и данных проекта, то менять его архитектуру в корне, переписывать всё на другом языке или фреймворке – нерационально. Мы пишем на своём фреймворке ZeroEngine, который ориентирован на высоконагруженные проекты и работает по принципу plug-in’ов. Кратко принцип работы ZeroEngine можно описать так: новый «модуль» можно встроить в любой уже существующий, а также перехватить управление выдачей в нужный момент.
Резюмируем вводные данные
-------------------------
Требуется написать REST API для сайта. Архитектура позволяет внедрить роутер и использовать существующий функционал полностью или частично.
При разработке в целом и, в частности, API, мы стараемся следовать законам логики и придерживаться семантических названий, методов и параметров. Вот примерный перечень внутренних требований, принятых в команде ZeroTech:
ДЕЙСТВИЕ /объект/идентификатор/метод
------------------------------------
Метод и URL должны чётко описывать выполняемую методом API функцию. Строго говоря, при именовании метода API, метод запроса (GET, POST, PUT, DELETE) является в предложении «глаголом», а адрес представляет собой «путь» от общего к частному.
Например:
* GET /images («получить изображения») – вернёт список изображений;
* POST /image – опубликует изображение;
* PUT /image/123 – «положит» переданное значение в изображение номер 123.
Мы сознательно разделяем *image* и *images*, чтобы было сразу понятно, что именно придёт в ответ на запрос – массив или единичный объект.
Семантические ошибки
--------------------
Для сообщения об ошибке мы не назначаем свои коды, а пользуемся стандартным набором HTTP-кодов. Чтобы упростить обработку на стороне приложения, код дублируется в теле ответа и дополняется описанием. Мы убеждены, что снабжать разработчика приложения длинным описанием всех ошибок не стоит выгоды в трафике во время отладки.
Меньше методов — меньше запросов
--------------------------------
Когда вопрос касается читаемости кода и его повторного использования, лучше использовать большее количество независимых методов. Но при разработке API стоит минимизировать количество обращений к серверу, насколько это возможно. Проще говоря: данные, которые в приложении должны показываться вместе, отдавать нужно тоже вместе.
Не тестировать дважды
---------------------
Разумеется, речь идёт о дублировании функциональных тестов модульными. Как и в остальных случаях, мы стараемся использовать инструменты по их назначению: юнит-тестами мы покрываем модули сайта и роутера, а сам API тестируем с помощью dredd и API Blueprint.
Разработка через документацию
-----------------------------
Именно для этого мы используем API Blueprint и сервис apiary. Сначала мы описываем то, что хотим получить в итоге. Далее – продумываем структуру методов, их возвращаемые значения, варианты ошибок и прочее. Только после этого пишем API. Такой подход имеет множество преимуществ, и позволяет разработчикам API оперативно получать комментарии от разработчиков приложения, исключая двойную работу.
Версионность
------------
Когда дело касается мобильных приложений, следует помнить, что не все пользователи устанавливают новую версию сразу же по выходу. Следовательно, интерфейс должен быть совместим с приложениями, работающими на старых версиях API. В этом нет ничего сложного: приложение сообщает в заголовке нужную ему версию, а мы, меняя мажорную версию, переносим старую версию контроллера метода в подпапку с номером его (старой) версии.
Постоянная интеграция
---------------------
Мы используем TeamCity, но любой CI-сервис, в том числе облачный, поддерживает unit и dredd-тесты, а также интеграцию с Apiary. При успешном тестировании мы актуализируем внешние тестовые площадки и анализируем несколько метрик. Эти действия позволяют быстро отследить возникшие проблемы и обеспечивают постоянное наличие свежей документации.
Внедрение Unit-тестирования в существующий проект
-------------------------------------------------
Возможно, вы уже хотите опробовать используемые нами принципы. Значит, в сети станет ещё на один хороший проект больше. Тем не менее, в процессе вы неизбежно столкнетесь с трудностями по внедрению модульных тестов в ваш проект, если до этого тесты под него не писались.
Не торопитесь выбрасывать код и переписывать его с нуля. Если ваш проект позволяет внедрить модуль в архитектуру, то вы можете написать такой модуль, который позволит проводить выборочное тестирование. Вы сможете писать новые модули через TDD, а постепенно покроете тестами и старые.
Мы делаем это примерно так: в папке нашего модуля мы устанавливаем PHPunit и его зависимости, а в теле самого модуля вызываем модифицированный testRunner:
```
$out = '';
$module = "console";
$testRunner = new PHPUnit_TextUI_TestRunner();
$testPrinter = new ZeroTech_printer($out);
$testRunner->setPrinter($testPrinter);
$testSuite = new PHPUnit_Framework_TestSuite();
foreach (glob(U_PATH . "/tests/*test.php") as $filename)
{
$testSuite->addTestFile($filename);
}
$testRunner->doRun($testSuite, array("verbose" => true));
```
Результат выполнения будет в переменной *$out*. Останется только вывести результат на экран или в шаблон.
Модуль доступен через админку и выглядит так:
Функциональные тесты с помощью dredd
------------------------------------
Как уже было отмечено выше, для прототипирования, документирования и тестирования нашего API мы используем сервис apiary и его утилиту dredd:
* Описываем функционал в формате API Blueprint (своеобразный markdown на стероидах): Разделяем методы на группы, описываем, зачем он нужен; какие заголовки / формат данных / параметры / атрибуты метод принимает, какие из них обязательные; какие есть ограничения; что метод возвращает; на что отвечает ошибками; в каком именно формате.
* Сохраняем в файл и запускаем dredd *file*.apib.
* Чиним проваленные тесты, рефакторим.
* Выгружаем на apiary.
Выглядит APIB синтаксис примерно так:
```
FORMAT: 1A
# Group User
## /user
### GET - Получение данных профиля пользователя [GET]
+ Response 200 (application/json)
+ Attributes
+ first_name: Иван (required, string) - Имя пользователя (только русские символы)
+ last_name: Иванов (required, string) - Фамилия пользователя (только русские символы)
+ dob: 1988-10-01 (required, string) - Дата рождения
+ sex: 1 (required, number) - Пол (0 - женский, 1 - мужской)
+ city: Москва (required, string) - Город
### POST - Создание нового пользователя [POST]
+ Request (application/json)
+ Attributes
+ first_name: Иван (required, string) - Имя пользователя (только русские символы)
+ last_name: Иванов (required, string) - Фамилия пользователя (только русские символы)
+ dob: 1988-10-01 (required, string) - Дата рождения
+ sex: 1 (required, number) - Пол (0 - женский, 1 - мужской)
+ city: Москва (required, string) - Город
+ Response 201
{
message: “Successfully created”,
id: 123
}
```
Apiary преобразует всё это в удобный интерфейс с mock-сервером. Разработчики приложения могут использовать его даже в том случае, если «живой» API ещё не написан или работает некорректно. Можно также использовать mock-сервер в качестве песочницы.
Кроме того, можно смотреть историю тестов утилитой dredd, если у вас, например, нет интерфейса непрерывной интеграции.
Заключение
----------
В заключение хочется ещё раз заострить внимание на том, что не столь важно, какие инструменты и методики вы используете в разработке, главное, чтобы существовало понимание цели их использования. Наша задача как программистов, чтобы программы максимально точно и быстро делали то, что от них требуется. Всё остальное – вторично. | https://habr.com/ru/post/333884/ | null | ru | null |
# Docker: гибкая сеть без NAT на все случаи жизни
Время на месте не стоит, и у горячо любимого всеми Docker от версии к версии появляется новый функционал. Случается так, что когда читаешь Changelog для новой версии, видишь там то, что может пригодиться и сделать какие-то вещи лучше, чем есть на данный момент.
Так дело обстояло и в моем случае. Хочу заметить, что многие задачи, которые приходится делать, я делаю по принципу keep it simple. То есть почти всегда, если для решения задачи можно использовать простые инструменты и шаги, я выберу этот путь. Я понимаю, что простой или сложный шаг или инструмент — оценка субъективная, но т.к. работаем мы в команде, то вот такие критерии могут подходить при выборе инструментов:
* используется ли инструмент в инфраструктуре?
* если требуется что-то новое, то нельзя ли использовать то, что уже есть?
* насколько сильно обслуживание (обновление, перезапуск) сервиса будет отличаться от остальных сервисов?
* <...>
В этой статье речь пойдет о сетевом аспекте Docker. Расскажу обо всем по порядку, но хочу заметить, что на этот раз я не буду говорить «мы используем сеть хоста, всячески избегая применения NAT».
О том, как Docker работает с сетью, можно ознакомиться по [ссылке](https://docs.docker.com/engine/userguide/networking/dockernetworks/). Выделим основные моменты:
* default bridge network;
* host network;
* user defined network.
Как я говорил ранее в некоторых своих публичных выступлениях, нам нужна максимальная производительность сети для наших контейнеров. Если говорить о production, то NAT для контейнеров мы не используем.
Долгое время (да чего уж скрывать — и по сей день) для запуска контейнеров мы используем параметр **--net=host**, получая тем самым «нативный» eth внутри контейнера. Да, в этом случае одного бенефита — изоляции — мы, конечно, лишаемся… Но посмотрев на плюсы и минусы в нашем конкретном случае, мы намеренно пришли к такому решению, т.к. задачи изолировать сеть между запущенными приложениями в рамках одного хоста не стояло. Хочу напомнить, что пишу я о конкретном месте применения Docker — в Badoo.
Что мы знаем про наши сервисы:
* у нас есть карта размещения сервисов на серверах;
* у нас есть карта портов для каждого сервиса и его типа (или типов, если их много);
* у нас есть договоренность о том, что порты должны быть уникальными.
Исходя из вышесказанного, мы гарантируем следующее:
* если мы запускаем несколько сервисов на одной машине с **--net=host**, то пересечения портов мы не получим: все запустится и будет работать;
* если нам станет мало одного eth-интерфейса, то мы физически подключим еще один и посредством, например, DNS, раскидаем нагрузку между ними.
Все хорошо, тогда зачем мне пришлось что-то менять?
Дело было вечером, делать было нечего… Ранее говорилось о том, что мы продолжаем переносить наши сервисы в контейнеры. При следовании такому сценарию, как это обычно бывает, самые сложные остаются на потом. Причин для этого может быть масса:
* сервис критичен;
* отсутствие достаточного опыта, чтобы предложить максимально прозрачный и быстрый переезд сервиса в контейнер;
* можно «добавить что-то еще по вкусу».
Ну так вот. Был (и есть) у нас один такой сервис, который давно написан. Он и по сей день отлично работает, но есть у него несколько минусов:
* работает он на одном ядре (да, такое бывает);
* восполняя первый пробел, стоит отметить, что можно запустить несколько инстансов сервиса и использовать **taskset/--cpuset-cpus**;
* сервис «сильно» использует сеть, а также ему требуется большое количество портов для исходящих соединений.
Вот так сервис запускался ДО:
* на машине, где планировалось поднятие сервиса, нужно было добавить дополнительный IP-адрес (или даже несколько) — **ip a add** (тут можно сразу указать на много минусов данного подхода, о которых мы знаем);
* про вышесказанное стоит помнить, чтобы не получить, к примеру, 2 одинаковых адреса на разных машинах;
* в конфигурации демона стоило указать, на каком адресе он работает, как раз чтобы не «съесть» все порты соседа или хост-системы.
Как можно было решить задачу, если бы было лень изобретать новые методы:
* оставить все как есть, но обернуть в контейнер;
* поднимать на dockerhost все те же дополнительные IP-адреса;
* «биндить» приложение на конкретный адрес.
Как к задаче решил подойти я? Изначально, конечно, это все выглядело как эксперимент, да чего скрывать — это и было экспериментом. Мне показалось, что для этого сервиса как нельзя кстати подойдет MACVLAN-технология, которая на тот момент была отмечена в Docker как Experimental (версия 1.11.2), а вот в версии 1.12 всё уже доступно в основном функционале.
MACVLAN — это, по сути, Linux switch, который основан на статичном соответствии MAC и VLAN. Здесь используется unicast-фильтрация, не promiscuous-режим. MACVLAN может работать в режиме private, VEPA, bridge, passthru. MACVLAN — это reverse VLAN в Linux. Данная технология позволяет взять один реальный интерфейс и сделать на его основе несколько виртуальных с разными MAC-адресами.
Также сравнительно недавно появилась технология IPVLAN(<https://www.kernel.org/doc/Documentation/networking/ipvlan.txt>). Основное отличие от MACVLAN заключается в том, что IPVLAN может работать в L3 mode. В данной статье я буду рассматривать вариант использования MACVLAN (в режиме bridge), потому что:
* не стоит ограничение в 1 MAC-адрес с одного линка на активном сетевом оборудовании;
* количество контейнеров на хосте не будет таким большим, что может привести к превышению mac capacity. С течением времени этот момент у нас может, конечно, измениться;
* на данном этапе L3 не нужен.
Чуть подробнее про MACVLAN vs IPVLAN можно ознакомиться по ссылке <http://hicu.be/macvlan-vs-ipvlan>.
Вот здесь можно почитать теорию и как это работает в Docker: <https://github.com/docker/docker/blob/master/experimental/vlan-networks.md>.
Теория — это отлично, но даже там мы видим, что overhead имеет место быть. Можно и нужно посмотреть на сравнительные тесты пропускной способности MACVLAN в интернете (например, <http://comp.photo777.org/docker-network-performance/> и <http://delaat.net/rp/2014-2015/p92/report.pdf>), но также неотъемлемой частью эксперимента является проведение теста в своих лабораторных условиях. Поверить на слово — хорошо, но «потрогать руками» и сделать выводы самому — интересно и необходимо.
###### Итак, поехали!
Для того чтобы проверить, работает ли MACVLAN в Docker, нам нужно включить в последнем поддержку экспериментальных функций.
Если данный функционал при сборке не включен, то в логах можно будет видеть вот такие сообщения об ошибках:
```
# docker network create -d macvlan --subnet=1.1.1.0/24 --gateway=1.1.1.1 -o parent=eth0 cppbig_vlan
Error response from daemon: plugin not found
```
А в логах процесса будет следующее:
```
docker[2012]: time="2016-08-04T11:44:44.095241242Z" level=warning msg="Unable to locate plugin: macvlan, retrying in 1s"
docker[2012]: time="2016-08-04T11:44:45.095489283Z" level=warning msg="Unable to locate plugin: macvlan, retrying in 2s"
docker[2012]: time="2016-08-04T11:44:47.095750785Z" level=warning msg="Unable to locate plugin: macvlan, retrying in 4s"
docker[2012]: time="2016-08-04T11:44:51.095970433Z" level=warning msg="Unable to locate plugin: macvlan, retrying in 8s"
docker[2012]: time="2016-08-04T11:44:59.096197565Z" level=error msg="Handler for POST /v1.23/networks/create returned error: plugin not found"
```
Если вы видите такие сообщения — значит, поддержка MACVLAN в Docker не включена.
Тест был символическим, с использованием **iperf**. Для каждого варианта я запускал сначала 1 клиента, потом 8 в параллель. Вариантов было 2:
* **--net=host**;
* **--net=macvlan**.
**Посмотреть на тест подробнее**Запускаем сервер:
```
# docker run -it --net=host --name=iperf_w_host_net --entrypoint=/bin/bash dockerio.badoo.com/itops/sle_12_base:latest
# iperf3 -s -p 12345
-----------------------------------------------------------
Server listening on 12345
-----------------------------------------------------------
```
Запускаем клиента:
```
# iperf3 -c 1.1.1.2 -p 12345 -t 30
```
На сервере получаем результат:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth
[ 5] 0.00-30.04 sec 0.00 Bytes 0.00 bits/sec sender
[ 5] 0.00-30.04 sec 2.45 GBytes 702 Mbits/sec receiver`
На клиенте:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth Retr
[ 4] 0.00-30.00 sec 2.46 GBytes 703 Mbits/sec 0 sender
[ 4] 0.00-30.00 sec 2.45 GBytes 703 Mbits/sec receiver`
Запускаем в параллель 8 клиентов:
```
# iperf3 -c 1.1.1.2 -p 12345 -t 30 -P 8
```
На сервере получаем результат:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth
[ 5] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 5] 0.00-30.03 sec 314 MBytes 87.7 Mbits/sec receiver
[ 7] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 7] 0.00-30.03 sec 328 MBytes 91.5 Mbits/sec receiver
[ 9] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 9] 0.00-30.03 sec 305 MBytes 85.2 Mbits/sec receiver
[ 11] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 11] 0.00-30.03 sec 312 MBytes 87.3 Mbits/sec receiver
[ 13] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 13] 0.00-30.03 sec 316 MBytes 88.3 Mbits/sec receiver
[ 15] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 15] 0.00-30.03 sec 310 MBytes 86.7 Mbits/sec receiver
[ 17] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 17] 0.00-30.03 sec 313 MBytes 87.5 Mbits/sec receiver
[ 19] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 19] 0.00-30.03 sec 321 MBytes 89.7 Mbits/sec receiver
[SUM] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[SUM] 0.00-30.03 sec 2.46 GBytes 704 Mbits/sec receiver`
На клиенте:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth Retr
[ 4] 0.00-30.00 sec 315 MBytes 88.1 Mbits/sec 0 sender
[ 4] 0.00-30.00 sec 314 MBytes 87.8 Mbits/sec receiver
[ 6] 0.00-30.00 sec 330 MBytes 92.3 Mbits/sec 0 sender
[ 6] 0.00-30.00 sec 328 MBytes 91.6 Mbits/sec receiver
[ 8] 0.00-30.00 sec 306 MBytes 85.6 Mbits/sec 0 sender
[ 8] 0.00-30.00 sec 305 MBytes 85.3 Mbits/sec receiver
[ 10] 0.00-30.00 sec 313 MBytes 87.5 Mbits/sec 0 sender
[ 10] 0.00-30.00 sec 312 MBytes 87.4 Mbits/sec receiver
[ 12] 0.00-30.00 sec 317 MBytes 88.8 Mbits/sec 0 sender
[ 12] 0.00-30.00 sec 316 MBytes 88.4 Mbits/sec receiver
[ 14] 0.00-30.00 sec 312 MBytes 87.1 Mbits/sec 0 sender
[ 14] 0.00-30.00 sec 310 MBytes 86.8 Mbits/sec receiver
[ 16] 0.00-30.00 sec 314 MBytes 87.9 Mbits/sec 0 sender
[ 16] 0.00-30.00 sec 313 MBytes 87.6 Mbits/sec receiver
[ 18] 0.00-30.00 sec 322 MBytes 90.2 Mbits/sec 0 sender
[ 18] 0.00-30.00 sec 321 MBytes 89.8 Mbits/sec receiver
[SUM] 0.00-30.00 sec 2.47 GBytes 707 Mbits/sec 0 sender
[SUM] 0.00-30.00 sec 2.46 GBytes 705 Mbits/sec receiver`
2. Запускам сервер, используя MACVLAN:
```
# docker run -it --net=cppbig_vlan --name=iperf_w_macvlan_net --ip=1.1.1.202 --entrypoint=/bin/bash dockerio.badoo.com/itops/sle_12_base:latest
# iperf3 -s -p 12345
-----------------------------------------------------------
Server listening on 12345
-----------------------------------------------------------
```
Запускаем клиента:
```
# iperf3 -c 1.1.1.202 -p 12345 -t 30
```
На сервере получаем результат:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth
[ 5] 0.00-30.04 sec 0.00 Bytes 0.00 bits/sec sender
[ 5] 0.00-30.04 sec 2.45 GBytes 701 Mbits/sec receiver`
На клиенте:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth Retr
[ 4] 0.00-30.00 sec 2.46 GBytes 703 Mbits/sec 0 sender
[ 4] 0.00-30.00 sec 2.45 GBytes 702 Mbits/sec receiver`
Запускаем в параллель 8 клиентов:
```
# iperf3 -c 1.1.1.202 -p 12345 -t 30 -P 8
```
На сервере получаем результат:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth
[ 5] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 5] 0.00-30.03 sec 306 MBytes 85.4 Mbits/sec receiver
[ 7] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 7] 0.00-30.03 sec 319 MBytes 89.1 Mbits/sec receiver
[ 9] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 9] 0.00-30.03 sec 307 MBytes 85.8 Mbits/sec receiver
[ 11] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 11] 0.00-30.03 sec 311 MBytes 87.0 Mbits/sec receiver
[ 13] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 13] 0.00-30.03 sec 317 MBytes 88.6 Mbits/sec receiver
[ 15] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 15] 0.00-30.03 sec 322 MBytes 90.1 Mbits/sec receiver
[ 17] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 17] 0.00-30.03 sec 313 MBytes 87.5 Mbits/sec receiver
[ 19] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[ 19] 0.00-30.03 sec 310 MBytes 86.7 Mbits/sec receiver
[SUM] 0.00-30.03 sec 0.00 Bytes 0.00 bits/sec sender
[SUM] 0.00-30.03 sec 2.45 GBytes 700 Mbits/sec receiver`
На клиенте:
`- - - - - - - - - - - - - - - - - - - - - - - - -
[ ID] Interval Transfer Bandwidth Retr
[ 4] 0.00-30.00 sec 307 MBytes 85.8 Mbits/sec 0 sender
[ 4] 0.00-30.00 sec 306 MBytes 85.5 Mbits/sec receiver
[ 6] 0.00-30.00 sec 320 MBytes 89.6 Mbits/sec 0 sender
[ 6] 0.00-30.00 sec 319 MBytes 89.2 Mbits/sec receiver
[ 8] 0.00-30.00 sec 308 MBytes 86.2 Mbits/sec 0 sender
[ 8] 0.00-30.00 sec 307 MBytes 85.9 Mbits/sec receiver
[ 10] 0.00-30.00 sec 313 MBytes 87.5 Mbits/sec 0 sender
[ 10] 0.00-30.00 sec 311 MBytes 87.1 Mbits/sec receiver
[ 12] 0.00-30.00 sec 318 MBytes 89.0 Mbits/sec 0 sender
[ 12] 0.00-30.00 sec 317 MBytes 88.6 Mbits/sec receiver
[ 14] 0.00-30.00 sec 324 MBytes 90.5 Mbits/sec 0 sender
[ 14] 0.00-30.00 sec 322 MBytes 90.2 Mbits/sec receiver
[ 16] 0.00-30.00 sec 314 MBytes 87.9 Mbits/sec 0 sender
[ 16] 0.00-30.00 sec 313 MBytes 87.6 Mbits/sec receiver
[ 18] 0.00-30.00 sec 311 MBytes 87.1 Mbits/sec 0 sender
[ 18] 0.00-30.00 sec 310 MBytes 86.8 Mbits/sec receiver
[SUM] 0.00-30.00 sec 2.46 GBytes 704 Mbits/sec 0 sender
[SUM] 0.00-30.00 sec 2.45 GBytes 701 Mbits/sec receiver`
Как видно из результатов, overhead есть, но в данном случае можно считать его не критичным.
Ограничения технологии by design: доступность контейнера с хоста и доступность хоста из контейнера отсутствует. Нам такой функционал необходим, потому что:
* часть проверок доступности сервиса проверяется «хелперами» Zabbix, которые выполняются на том хосте, где работает сервис;
* есть необходимость использовать кеширующий DNS, который расположен на хост-системе. В нашем случае это Unbound;
* бывает необходимость использовать доступ к еще каким-то сервисам, запущенным на хост-системе.
* Это лишь часть причин, по которым доступ «хост <==> контейнер» нам необходим. Взять и переделать архитектуру подобных узлов в одночасье невозможно.
Варианты преодоления данного ограничения:
1. Использовать два и более физических линка на машине. Это дает возможность взаимодействия через соседний интерфейс. Например, взять eth1 и отдать его специально для MACVLAN, а на хост-системе продолжать использовать eth0. Вариант, безусловно, неплохой, но это влечет за собой необходимость держать одинаковое количество линков на всех машинах, где мы планируем запускать подобные сервисы. Реализовать это дорого, не быстро и не всегда возможно.
2. Использовать еще один дополнительный IP-адрес на хост-системе, повесить его на виртуальный MACVLAN-интерфейс, который нужно поднять на хост-системе. Это приблизительно так же сложно с точки зрения поддержки («не забыть/не забывать»), как предыдущее предложение — это раз. А, так как ранее я говорил о том, что наш сервис сам по себе требует дополнительного адреса, то в итоге для запуска такого сервиса нам потребуется:
* адрес для основного интерфейса хост-системы (1);
* адрес для сервиса (2);
* адрес для виртуального интерфейса, через который мы будем взаимодействовать с сервисом (3).
В данном случае получается, что нам нужно слишком много IP-адресов, которые, по большому счету, использоваться будут мало. Помимо излишнего расходования IP-адресов стоит также помнить, что нам нужно будет поддерживать статичные маршруты через этот самый виртуальный интерфейс до контейнера. Это не непреодолимая сложность, но усложнение системы в целом — факт.
Внимательный читатель задаст вопрос: «А зачем адрес на основной интерфейс и на MACVLAN-интерфейс, если можно адрес основного интерфейса отдать виртуальному?» В таком случае мы оставим нашу систему без адресов на реальных интерфейсах, а на такой шаг я пойти пока не готов.
В предыдущих двух вариантах предполагалось, что адреса всех интерфейсов принадлежат одной сети. Как несложно представить, даже при 100 серверах в такой подсети, если завести по три адреса, то в **/24** мы уже не попадаем.
3. Сервисный IP. Суть идеи заключается в том, что мы делаем отдельную подсеть для сервисов. Как это выглядит:
* на сервер начинаем подавать «тегированный» траффик;
* native VLAN оставляем в виде основной сети для dockerhost (eth0);
* поднимаем виртуальный интерфейс с 802q, без IP-адреса на хост системе;
* используем для сервиса IP-адрес из сервисной сети.
Рассматривать, как уже стало понятно, будем пункт три. Чтобы все у нас заработало, нужно проделать несколько действий:
* для того чтобы подать «тегированный» трафик на интерфейс, кто нам нужен? Правильно, сетевики! Просим их выполнить переключение access-порта в порт, на который подаем 2 VLAN;
* поднять дополнительный интерфейс на хосте:
```
# cat /etc/sysconfig/network/ifcfg-vlan8
BOOTPROTO='static'
STARTMODE='auto'
VLAN='yes'
ETHERDEVICE='eth0'
# ip -d link show vlan8
31: vlan8@eth0: mtu 1500 qdisc noqueue state UP mode DEFAULT group default qlen 1000
link/ether e4:11:5b:ea:b6:30 brd ff:ff:ff:ff:ff:ff promiscuity 1
vlan protocol 802.1Q id 8
```
* завести MACVLAN-сеть в Docker
```
# docker network create -d macvlan --subnet=1.1.2.0/24 --gateway=1.1.2.1 -o parent=vlan8 c_services
```
* убедиться, что сеть в Docker появилась:
```
# docker network ls | grep c_services
a791089219e0 c_services macvlan
```
Все сделал, все хорошо. Тут я решил посмотреть на общие графики по хосту (а если быть точнее, то на это обратил мое внимание коллега). Вот такую картину мы там увидели:
Да, здесь видно использование conntrack на хосте.
Как так? Ну не нужен же conntrack для МACVLAN?! Так как дело было уже вечером, я решил проверить даже самые невероятные теории. В подтверждение моих теоретических знаний, connection tracking был на самом деле не нужен. Без него все продолжало работать. Выгрузка модулей, так или иначе завязанных на conntrack, была невозможной только в момент запуска моего контейнера. Идеи меня покинули, и пошел я домой, решив, что утро вечера мудренее.
На следующий день я в очередной раз убедился в точности данного высказывания. Итак, я решил «топорным» методом сделать так, чтобы Docker не мог подгружать nf\_conntrack. Сначала я его просто переименовал (т.к. blacklist игнорируется при загрузке модуля через modprobe), после чего запустил свой контейнер снова. Контейнер, как и ожидалось, поднимался и отлично себя чувствовал, но в логе я увидел сообщения о том, что четыре правила не могут быть добавлены в iptables. Получается, что conntrack нужен? Вот правила, которые не хотели добавляться:
```
-t nat -A OUTPUT -d 127.0.0.11 -p udp --dport 53 -j DNAT --to-destination 127.0.0.11:35373
-t nat -A POSTROUTING -s 127.0.0.11 -p udp --sport 35373 -j SNAT --to-source :53
-t nat -A OUTPUT -d 127.0.0.11 -p tcp --dport 53 -j DNAT --to-destination 127.0.0.11:41214
-t nat -A POSTROUTING -s 127.0.0.11 -p tcp --sport 41214 -j SNAT --to-source :53
```
53 порт? Налицо работа, связанная с «резолвером». И тут я, к своему удивлению, узнаю про embedded DNS server. Ну хорошо, пусть и встроенный, но можно же как-то опциями выключить его? Нет, нельзя :)
Далее я попробовал вернуть модуль, запустить сервис, поправить правила из iptables и выгрузить модули… Но не тут то было. Путем ковыряния modinfo я выяснил, какой там модуль от какого зависит, и какой из них кого тянет за собой. При создании сети Docker принудительно делает **modprobe xt\_nat**, который, в свою очередь, зависит от **nf\_conntrack**, вот тому подтверждение:
```
# modinfo xt_nat
filename: /lib/modules/4.4.0-3.1-default/kernel/net/netfilter/xt_nat.ko
alias: ip6t_DNAT
alias: ip6t_SNAT
alias: ipt_DNAT
alias: ipt_SNAT
author: Patrick McHardy
license: GPL
srcversion: 9982FF46CE7467C8F2361B5
depends: x\_tables,nf\_nat
intree: Y
vermagic: 4.4.0-3.1-default SMP preempt mod\_unload modversions
```
Как я уже говорил, все работает и без этих модулей. Соответственно, мы можем сделать вывод, что в нашем случае они не нужны. Остается вопрос: зачем, все же, они нужны? Я не поленился и заглянул в 2 места:
* на Docker issues;
* в исходный код.
И что я там нашел? Верно: для любого user defined network Docker делает modprobe. Смотрим код и видим 2 интересных для нас пункта:
```
if out, err := exec.Command("modprobe", "-va", "nf_nat").CombinedOutput(); err != nil {
logrus.Warnf("Running modprobe nf_nat failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err)
}
if out, err := exec.Command("modprobe", "-va", "xt_conntrack").CombinedOutput(); err != nil {
logrus.Warnf("Running modprobe xt_conntrack failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err)
}
```
И вот такое еще:
```
if err := r.setupIPTable(); err != nil {
return fmt.Errorf("setting up IP table rules failed: %v", err)
}
```
Делаем патч, а точнее — выкидываем все ненужное :) Делаем новую сборку Docker.
Смотрим. Все ок, все работает.
На этом этапе можно считать, что вся наша схема в лабораторных условиях работает, осталось сделать самую малость — прицепить ее к нашему сервису. Хорошо, возвращаемся к сервису и смотрим на его общую архитектуру:
Пояснения о том, как оно работает:
* (1 и 6) мобильный клиент устанавливает соединение с неким урлом, за которым стоит балансировщик;
* (2) балансировщик выбирает нужный инстанс нашего сервиса и позволяет установить соединение клиент-сервис;
* (3 и 4) далее наш сервис проксирует запросы от клиента на кластер с кодом, но тоже через балансировщик в виде nginx. Вот тут мы и вернулись к нашему требованию о том, что nginx должен быть на той же машине, что и сервис. На данный момент также есть ограничение в том, что он должен быть именно на хосте, а не в контейнере (это, кстати, решило бы проблему сразу). Мы не будем в данной статье рассуждать о причинах этого требования, а примем это как условие.
* (5) у каждого инстанса нашего сервиса есть определенный id, который нужен коду, чтобы понимать, через какой именно инстанс отвечать клиенту.
В первом приближении нам ничто не мешает собрать образ с нашим сервисом и запустить его уже в контейнере, но есть одно НО. Так уж сложилось, что для тех сервисов, которым нужно взаимодействие с внешним балансировщиком, у нас присутствует определенный набор статических маршрутов, например, вот такой:
```
# ip r
default via 1.1.2.254 dev eth0
10.0.0.0/8 via 1.1.2.1 dev eth0
1.1.2.0/24 dev eth0 proto kernel scope link src 1.1.2.14
192.168.0.0/16 via 1.1.2.1 dev eth0
```
Т.е. все, что должно идти в или из наших внутренних сетей, идет через .1, а остальное — через .254.
Почему это проблема в нашем случае? Потому что при запуске контейнера в его маршрутах мы видим следующее:
```
# ip r
default via 1.1.2.1 dev eth0
1.1.2.0/24 dev eth0 proto kernel scope link src 1.1.2.14
```
Попытка поменять маршруты внутри контейнера ни к чему не приведет, т.к. он у нас не привилегированный (**--priveleged**). Остается менять маршруты руками после старта контейнера с хоста (тут кроется большое заблуждение, но про это — дальше). Здесь варианта два:
* делать это руками, используя namespace контейнера;
* взять pipework <https://github.com/jpetazzo/pipework> и сделать все то же самое, но с его помощью.
Скажу сразу, что с этим можно жить, но существуют опасности, как у студента: «можно забыть, забить или запить» :)
Стремясь к идеалу, мы сделали для этой сервисной сети все маршруты через default gw, а всю сложность маршрутизации переложили на сетевой отдел. Всё. Точнее, я думал, что всё…
Как мне показалось на тот момент — решение отличное. Если бы все работало именно так, как я рассчитывал, так бы оно и было, но на этом ничего не закончилось. Чуть позже стало понятно, что при такой схеме мы получаем асимметричный роутинг для тех сетей, в которых есть маршрут через наш LTM. Чтобы стало чуть более понятно, я попробую показать, какие подсети у нас могут быть.
1. Сеть, у которой есть только 1 default gw и нет внешнего балансировщика.
2. Сеть, у которой более одного GW: например, балансировщик внешних запросов. Сложность в том, что внутренний трафик мы через него не гоняем.
Поговорив с сетевиками, мы сделали следующие выводы:
* они не готовы брать на себя ответственность и следить за всеми сетями, в которых роутинг будет именно таким;
* мы, со своей стороны, не готовы поддерживать статичные маршруты для всех таких сетей на серверах
Получилось так, что при желании сделать что-то простое, мы получили проблему на ровном месте, и если бы не подумали сразу о возможных сложностях, это привело бы к довольно грустным последствиям.
Я всегда говорю, что не стоит забывать про идеи, которые приходили в голову раньше, но были отвергнуты. Мы вернулись к мысли использовать статические маршруты внутри контейнера.
Итак, вот те условия, которые гарантируют нам работу нашего сервиса в контейнере:
* сам сервис;
* выделенный IP для сервиса;
* доступность сервиса и адреса со всех наших подсетей;
* возможность использовать и менять маршруты при запуске контейнера (самое важное, потому что именно это можно забыть).
Запускать контейнеры в привилегированном режиме (**--privileged**) не хотелось и не хочется. Я изначально не подумал про Linux capabilities, которые можно добавлять и убирать при запуске контейнера. Подробнее про них можно почитать вот [тут](https://docs.docker.com/engine/reference/run/#/runtime-privilege-and-linux-capabilities). Для нашей задачи было достаточно добавить **NET\_ADMIN**.
Вот теперь картинка сложилась, и мы можем добавить все нужные нам штуки, связанные с маршрутизацией, в автозапуск.
Давайте посмотрим, как выглядит наш Dockerfile в близком к финальному результату.
Dockerfile:
```
FROM dockerio.badoo.com/itops/sle_12_base:latest
MAINTAINER #MAINTEINER#
RUN /usr/bin/zypper -q -n in iproute2
RUN groupadd -g 1001 wwwaccess
RUN mkdir -p /local/SERVICE/{var,conf}
COPY get_configs.sh /local/SERVICE/
COPY config.cfg /local/SERVICE/
ADD SERVICE-CERTS/ /local/SERVICE-CERTS/
ADD SERVICE/bin/SERVICE-BINARY-${DVERSION} /local/SERVICE/bin/
ADD SERVICE/conf/ /local/SERVICE/conf/
COPY routes.sh /etc/cont-init.d/00-routes.sh
COPY env.sh /etc/cont-init.d/01-env.sh
COPY finish.sh /etc/cont-finish.d/00-finish.sh
COPY run /etc/services.d/SERVICE/
COPY finish /etc/services.d/SERVICE/
RUN touch /tmp/fresh_container
ENTRYPOINT ["/init"]
```
На что тут стоит обратить внимание:
* мы используем s6 overlay как supervisor внутри контейнера;
* мы добавляем пакет iproute, чтобы можно было править маршруты;
* мы добавляем запуск нескольких скриптов, которые выполняются ДО старта нашего сервиса (директория /etc/cont-init.d/), а также добавляем скрипты, которые будут выполнены ПОСЛЕ завершения работы сервиса, но ДО того, как опустится контейнер (/etc/cont-finish.d/);
* мы добавляем файл /tmp/fresh\_container для того, чтобы понимать, первый ли раз стартует наш контейнер или нет. Чуть яснее про это будет, когда я покажу содержимое остальных скриптов;
Используемые скрипты:
1. **get\_configs.sh** — это скрипт, который смотрит, есть ли конфиг для сервиса в нашей системе хранения и генерации конфигов, доставляет их в контейнер, проверяет на валидность, и если все в порядке, то с ним и запускает. Подробнее про это мы рассказывали на [Docker Meetup](https://tech.badoo.com/ru/presentation/193/monitor-avtomatiziruj-docker/);
2. **routes.sh** — скрипт, который подготавливает маршруты внутри контейнера:
```
#!/usr/bin/with-contenv sh
if [ ! -x /usr/sbin/ip ];then
echo -e "\e[31mCan't execute /usr/sbin/ip\e[0m";
[ $(pgrep s6-svscan) ] && s6-svscanctl -t /var/run/s6/services
exit 1;
else
LTMGW=$(/usr/sbin/ip r show | /usr/bin/grep default | /usr/bin/awk {'print $3'} | /usr/bin/awk -F \. {'print $1"."$2"."$3".254"'})
DEFGW=$(/usr/sbin/ip r show | /usr/bin/grep default | /usr/bin/awk {'print $3'} | /usr/bin/awk -F \. {'print $1"."$2"."$3".1"'})
/usr/sbin/ip r replace default via ${LTMGW}
/usr/sbin/ip r add 192.168.0.0/16 via 10.10.8.1 dev eth0
/usr/sbin/ip r add 10.0.0.0/8 via 10.10.8.1 dev eth0
echo -e "\e[32mAll job with routes done:\e[0m\n$(/usr/sbin/ip r show)"
fi
```
3. **env.sh** — скрипт, который готовит окружение для нашего сервиса; зачастую именно он выполняется только 1 раз при первом старте контейнера:
```
#!/usr/bin/with-contenv sh
if [ ! -z "${ISTEST}" ];then exit 0;fi
if [ ! -n "${SERVICETYPE}" ];then
echo -e "\e[31mPlease set SERVICE type\e[0m";
[ $(pgrep s6-svscan) ] && s6-svscanctl -t /var/run/s6/services
exit 1;
fi
bash /local/SERVICE/get_configs.sh || exit 1
echo -e "\e[32mSERVICE ${SERVICETYPE} is running\e[0m"
```
4. **finish.sh** — скрипт, который просто чистит pid-файлы от нашего сервиса. Конкретный сервис настолько крут (как Чак Норрис), что сам этого не делает, но он не запустится, если обнаружит старые pid-файлы :)
5. **run** — это скрипт, который запускает наше приложение:
```
#!/usr/bin/with-contenv bash
exec /local/SERVICE/bin/SERVICE-${DVERSION} -l /local/SERVICE/var/mobile-${SERVICETYPE}.log -P /local/SERVICE/var/mobile-${SERVICETYPE}.pid -c /local/SERVICE/conf/SERVICE.conf -v ${VERBOSITY}
```
6. **finish** — скрипт, который тушит контейнер в случае, если сервис завершил свою работу:
```
#!/bin/sh
[ $(pgrep s6-svscan) ] && s6-svscanctl -t /var/run/s6/services
```
Строка для запуска нашего сервиса будет выглядеть так:
```
docker run -d --net=c_services --ip=1.1.2.17 --name=SERVICE-INSTANCE16 -h SERVICE-INSTANCE16.local --cap-add=NET_ADMIN --add-host='nginx.localhost:1.1.1.17' -e SERVICETYPE=INSTANCE16_eu1 -e HOST_IP=1.1.1.17 --volumes-from=badoo_loop dockerio.badoo.com/cteam/SERVICE:2.30.0_994
```
На этом перенос нашего сервиса в контейнер можно считать успешным. Забегая вперед, хочу заметить, что MACVLAN/IPVLAN мы используем в других наших сервисах, но примером послужил именно этот эксперимент.
Антон [banuchka](https://habrahabr.ru/users/banuchka/) Турецкий
Site Reliability Engineer, Badoo | https://habr.com/ru/post/308402/ | null | ru | null |
# 13 интересных моментов из руководства по стилям для JavaScript от Google
Для тех, кто еще не видел: Google опубликовал руководство по стилям для JavaScript, где изложены лучшие стилистические практики (по версии компании) для написания аккуратного, понятного кода.
Это не жесткий свод правил для грамотного программирования на JavaScript, а просто набор ограничений, чтобы выдерживать единую привлекательную стилистику во всех исходных файлах. Для JavaScript подобное руководство представляет особенный интерес — это очень гибкий и нетребовательный язык, который дает значительный простор для выбора.
Самые популярные руководства по стилю — те, которые предложили Google и Airbnb. Если вы много времени проводите за работой с JS, рекомендую ознакомиться с обоими. Ниже я приведу тринадцать правил из руководства Google, которые показались мне особенно интересными. Оно затрагивает все: и камни преткновения, которые вызывают больше всего споров (пробелы против табуляции, дискуссионный вопрос о том, как использовать точки с запятой), так и некоторые менее обсуждаемые моменты, которые меня удивили. Все это определенно повлияет на мои практики написания кода в будущем.
Для каждого правила я буду приводить краткое изложение требования, цитату из руководства, где оно формулируется более подробно, а также, по возможности, примеры его применения вместе с фрагментами, где оно нарушается, чтобы можно было сравнить.
#### Используйте пробелы, а не табуляцию
За исключением символов переноса строки, пробел в ASCII (0x20) — единственный символ, который должен появляться в исходных файлах для обозначения отступа. Это подразумевает, что… табуляция не применяется для форматирования.
Позже в руководстве также уточняется, что для отступа следует ставить два пробела, а не четыре.
```
// bad
function foo() {
∙∙∙∙let name;
}
// bad
function bar() {
∙let name;
}
// good
function baz() {
∙∙let name;
}
```
#### Точки с запятой необходимы
Каждый оператор должен оканчиваться точкой с запятой. Полагаться на автоматическое ее проставление запрещается.
Понятия не имею, чем объясняется такое сопротивление этой идее, но споры о том, нужно ли постоянно проставлять точку с запятой в JS коде, в последнее время выходят на уровень войны между сторонниками пробелов и табуляции. Google здесь занимает решительную позицию, высказываясь в пользу точек с запятой.
```
// bad
let luke = {}
let leia = {}
[luke, leia].forEach(jedi => jedi.father = 'vader')
// good
let luke = {};
let leia = {};
[luke, leia].forEach((jedi) => {
jedi.father = 'vader';
});
```
#### Не используйте модули ES6 (пока что)
В данный момент не стоит использовать модули ES6 (например, для экспорта и импорта ключевых слов), так как их семантика еще не приобрела окончательный вид. Отметим, что это правило будет пересмотрено, когда семантика будет окончательно приведена к стандарту.
```
// Don't do this kind of thing yet:
//------ lib.js ------
export function square(x) {
return x * x;
}
export function diag(x, y) {
return sqrt(square(x) + square(y));
}
//------ main.js ------
import { square, diag } from 'lib';
```
#### Горизонтальное выравнивание не рекомендуется (хотя и не запрещается)
Эта практика допускается, но не одобряется руководством по стилям от Google. Не требуется даже поддерживать горизонтальное выравнивание там, где оно уже применено.
Горизонтальное выравнивание — это практика, при которой в код добавляется произвольное количество дополнительных пробелов с тем расчетом, чтобы определенные значения располагались непосредственно под соответствующими значениями на верхней строке.
```
// bad
{
tiny: 42,
longer: 435,
};
// good
{
tiny: 42,
longer: 435,
};
```
#### Не используйте больше var
Объявляйте все локальные переменные при помощи const или let. Сделайте const вариантом по умолчанию, кроме тех случаев, когда переменной нужно присвоить новое значение. Ключевое слово var использовать нельзя.
В примерах кода на StackOverflow и других площадках мне до сих пор попадается var. Не знаю, есть ли у этих людей аргументы в пользу такого выбора или они просто не могут расстаться со старой привычкой.
```
// bad
var example = 42;
// good
let example = 42;
```
#### Предпочтение отдается стрелочным функциям
Стрелочные функции обеспечивают лаконичный синтаксис и тем самым разрешают ряд сложностей. Отдавайте предпочтение им, а не ключевым словам для функций, особенно если речь идет о вложенных функциях.
Скажу честно: мне стрелочные функции нравятся просто потому, что они смотрятся лучше и аккуратнее. Но, как выясняется, они еще и служат довольно важной цели.
```
// bad
[1, 2, 3].map(function (x) {
const y = x + 1;
return x * y;
});
// good
[1, 2, 3].map((x) => {
const y = x + 1;
return x * y;
});
```
#### Используйте шаблонные строки вместо конкатенации
Использование шаблонов, в которых строки разделяются символом `, предпочтительнее, чем сложная конкатенация строк, особенно в случаях, когда они содержат несколько строковых литералов. Шаблоны могут заключать в себе несколько строчек.
```
// bad
function sayHi(name) {
return 'How are you, ' + name + '?';
}
// bad
function sayHi(name) {
return ['How are you, ', name, '?'].join();
}
// bad
function sayHi(name) {
return `How are you, ${ name }?`;
}
// good
function sayHi(name) {
return `How are you, ${name}?`;
}
```
#### Не используйте продолжение строки для длинных строк
Не используйте продолжение строки (иными словами, не завершайте строку в составе строкового литерала символом бэкслэша) ни в обычных строковых литералах, ни в литералах шаблона.
Что интересно, здесь Google расходится во мнениях с Airbnb (их спецификации можно посмотреть здесь). Если Google рекомендует применять конкатенацию для длинных строк (как показано ниже), руководство по стилю от Airbnb предписывает, в общем-то, ничего не делать и просто продолжать строку столько, сколько потребуется.
```
// bad (sorry, this doesn't show up well on mobile)
const longString = 'This is a very long string that \
far exceeds the 80 column limit. It unfortunately \
contains long stretches of spaces due to how the \
continued lines are indented.';
// good
const longString = 'This is a very long string that ' +
'far exceeds the 80 column limit. It does not contain ' +
'long stretches of spaces since the concatenated ' +
'strings are cleaner.';
```
#### for… of — оптимальная разновидность циклов for
С выходом версии ES6 в языке сейчас существует три разных типа циклов for. Вы можете применять их все, однако по возможности циклам for-of следует отдавать приоритет.
На мой взгляд, это весьма странный совет, но я решил все же его включить — любопытно, что Google так выделяет для себя любимый тип цикла. Я вообще всегда пребывал под впечатлением, что циклы for… in больше подходят для объектов, а циклы for… of лучше для работы с массивами. То есть мы имеем ситуацию, когда инструмент подбираешь под задачу.
Не то чтобы спецификация от Google идет вразрез с этой мыслью, но все-таки занятно знать, что у них есть конкретный фаворит, причем именно этот.
#### Не используйте eval()
Никогда не используйте eval() или конструктор Function(...string) (исключение составляют загрузчики программ). Эти функции несут в себе потенциальную угрозу и просто не работают в средах с CSP.
У MDN на странице, посвященной eval(), даже есть особый раздел под названием «Никогда не используйте eval()!»
```
// bad
let obj = { a: 20, b: 30 };
let propName = getPropName(); // returns "a" or "b"
eval( 'var result = obj.' + propName );
// good
let obj = { a: 20, b: 30 };
let propName = getPropName(); // returns "a" or "b"
let result = obj[ propName ]; // obj[ "a" ] is the same as obj.a
```
#### Константы должны записывать КАПСЛОКОМ и разделяться нижними подчеркиваниями
Названия констант прописываются в особом формате: заглавными буквами и с нижними подчеркиваниями между отдельными словами.
Если вы совершенно уверены, что переменная должна оставаться неизменной, можно подчеркнуть это, прописывая ее название заглавными буквами. Так читающему код будет сразу понятно, что переменная неприкосновенна, в каком бы фрагменте она ему ни встретилась.
Важное исключение из этого правила составляют константы в пределах функции. В их случае следует использовать верблюжий регистр.
```
// bad
const number = 5;
// good
const NUMBER = 5;
```
#### Одна переменная — одно объявление
На каждую локальную переменную отводится отдельное объявление. Объявления вида let a = 1, b = 2 не допускаются.
```
// bad
let a = 1, b = 2, c = 3;
// good
let a = 1;
let b = 2;
let c = 3;
```
#### Используйте одинарные кавычки, а не двойные
Стандартные строковые литералы отделяются одинарными кавычками ('), двойные (") для этой цели не употребляются.
Совет: если строка уже содержит символ одинарной кавычки, подумайте о том, чтобы использовать шаблон с обратными кавычками — это позволит избежать проблем с форматированием.
```
// bad
let directive = "No identification of self or mission."
// bad
let saying = 'Say it ain\u0027t so.';
// good
let directive = 'No identification of self or mission.';
// good
let saying = `Say it ain't so`;
```
#### И напоследок
Как я говорил в начале, это не стоит считать все это непоколебимыми заповедями. Кроме Google, есть и другие IT гиганты, да и правила эти носят скорее рекомендательный характер.
Но даже с этой оговоркой, рекомендации по стилю от такой компании, как Google, у которой множество талантливых сотрудников, пишущих отличный код, вызывают немалый интерес. Вы можете придерживаться этих правил, если хотите писать «исходный код, совместимый с продуктами Google», а можете просто махнуть на них рукой.
Лично мне кажется, что спецификации Airbnb во многих отношениях привлекательнее, чем у Google. Но какую бы позицию вы не заняли по отношению к этим правилам, важно помнить одно: при работе над любым кодом в стилистике должно выдерживаться постоянство. | https://habr.com/ru/post/358698/ | null | ru | null |
# ICQ, новые функции — новые дыры
Здравствуй, дорогой друг, я сразу попрошу у тебя прощения, так как мне всегда сложно писать вступление и поэтому оно будет немного жидким.
Итак:
Как показывает время, в ICQ с введением какой-либо новой функции открывается новая брешь в безопасности, взять хотя бы эту статью:
[**«Html-инъекция на страницах icq.com»**](http://www.xakep.ru/magazine/xa/098/082/1.asp)
Взяв это за основу я начал свой research.
**Что же нового в ICQ?**
Внимательные пользователи с лёгкостью ответят на этот вопрос: «привязка номера ICQ к мобильному номеру своего телефона».
**А вот какие функции при этом появились:**
— Восстановление пароля через код высылаемый на мобильный.
— Логин(вход в ICQ) через код высылаемый на мобильный.
— Регистрация нового пользователя через код высылаемый на мобильный.
Начал я конечно же с восстановления пароля.
При вводе номера телефона привязанного к ICQ номеру на странице восстановления пароля [www.icq.com/password](https://www.icq.com/password/) мы видим страничку на которой нам будет предложено вести код который пришёл на мобильный, а также новый пароль.
При этом адрес данной страницы выглядит примерно так:
```
https://www.icq.com/password/resetcode/D5DCBDBAF629FE4A07FB8C790E9F9A6535A1FD2DCD78093E71C892844953EC82/ru
```
Данная ссылка живёт около 24 часов.
Самый важный кусок ссылки состоит из двух частей:
— Первый это или зашифрованная сессия или сам номер:
```
D5DCBDBAF629FE4A07FB8C790E9F9A65
```
— Второй вообще непонятно что, абсолютно ни на что не влияющее. Этот кусок можно заменить на любой набор букв и цифр или даже просто обрезать:
```
35A1FD2DCD78093E71C892844953EC82
```
А теперь вернёмся к тому что ссылка живёт около суток…
При восстановлении пароля через мобильный нам приходит код состоящий ИЗ ПЯТИ ЦИФР!
Первые тесты показали, что ограничений на ввод кода не было, но это было немного ошибочно. При вводе неверного кода страничка с ответом содержала картинку забавной улиточки и надпись «Ссылка, которую вы используете, уже устарела...»
При вводе верного кода страничка с ответом сообщала нам что пароль был успешно сменен:
Вводя код вручную в браузере, бана невозможно было добиться, но автоматизировав этот процесс я увидел что бан наступал после пяти попыток, это был бан именно на ввод кода с одного IP и ссылка при этом не умирала. При бане страничка с ответом содержала коровку и надпись «К сожалению, вы слишком часто повторяете однотипное действие. Попробуйте делать это реже.»
Недолго думая я обратился к своему товарищу и он реализовал данную уязвимость в софте, который он ласково назвал «**5digger**», далее узнаете почему… Софт работал через proxy и поэтому бан по IP нам был не страшен ;)
Итак, у нас есть довольно серьёзная дыра, но как же нам узнать номер телефона жертвы? Над этим нам немного пришлось поломать голову.
Помогла нам программа собирающая базы номеров и содержимого из их «инфо». Называется она «ICQ Search Info» автор **.fry** Данная программа каким-то непонятным мне образом видела номера телефонов владельцев, которые они указали в своей информации и которые по дефолту скрыты.
Мы сразу же принялись сканировать пятизнаки. В итоге у нас получилась небольшая база **uin;phone**. К нашему сожалению она содержала кучу мусора, а также реальные номера владельцев, но при этом не привязанные к их номеру ICQ.
Так как мы люди ленивые, я принялся искать форму через которую можно было проверить номер на регистрацию в ICQ. Как бы это не было банально, таковой оказалась форма регистрации: [www.icq.com/join/ru](http://www.icq.com/join/ru)
Простым запросом я смог быстро проверить свои номера:
```
GET http://icq.com/join/send_sms_code/ru?msisdn=
```
Ответ сервера если номер незарегистрирован в icq сожержал такой вот набор символов:
```
"status":200,"statusText":"Ok"
```
Получив валидную на 100% базу **uin;phone** я принялся за дело. Для начала я удалил все строки содержащие в себе русские номера, а именно начинающиеся на (+7)
Жертвами стали бывшие админы ICQ и их друзья с номерами телефонов начинающихся на (+9725), а также просто номера неизвестных иностранцев, хочу заметить, что первоначальная база содержала чуть меньше 10 строк…
Как только мы сменили пароль на первом админском номере которым оказался номер Avi Zrachya (это бывший админ ICQ из Израиля), а именно 34567, мы увидели что в его контакт-листе был просто невероятный порядок… В основном его контакт-лист состоял из его коллег и друзей. При этом все ники из «инфо» были заменены на реальные имена и фамилии, а также во многих номерах в «дополнительной информации» которую он самолично заполнил был виден номер телефона. Особенно меня порадовали группы «**Asechka.ru**», где были несколько моих товарищей, а также группа «**Hackers**», где был небезызвестный кроб **хТ**.
В итоге я вытащил все номера телефонов проверил их уже описанным выше способом и дополнил свою базу, на этом всё не закончилось. Оказалось что у всех админов контакт-лист был примерно в одинаковом состоянии и из каждого мы смогли вытащить новые уникальные номера телефонов. Думаю дальнейшие наши действия и результат не стоит вам описывать так как все могут и без этого догадаться. Хочу добавить только то, что все используемые номера быстро вернулись своим хозяевам и это составило довольно большой процент… Данную уязвимость очень забавно пофиксили. Для начала запретили смену пароля, а также восстановления пароля у номеров ниже 7 цифр (у шести и пяти знаков). А потом при вводе неверного кода стала появляться надпись «неверный код» и бан был уже не по IP, а по вводу кода от определённой ссылки.
**А теперь вернёмся к кое-какой забавной вещи которую я заметил**
Помните запрос, который я использовал для чека номеров на регистрацию? Так вот, лимита на отправку смс на один номер НЕ БЫЛО! Данная фича была сразу же реализована в флудер мобильных телефонов. Софт проработал около двух недель, а потом был введён лимит на отправку смс.
**Продолжим!**
На ввод кода подтверждения опять же не было лимита и при этом была возможность регистрировать огромные количества номеров без ввода капчи, и не имея при этом доступа к телефону указанному при регистрации. Для этого надо было собрать всего лишь переменную при отправке смс, которая называется **«transid»** т.е. собрать лист вида **phone;transid**, а дальше просто брутить (подбирать) коды по этому листу и постепенно регистрировать номера. Данная уязвимость возможно и сейчас есть, так как на момент написания статьи я её не проверял.
**Теперь расскажу вам о функции логина через код высылаемый на мобильный**
При вводе кода через сайт высылался или пяти или шести значный код подтверждения и пробовать подбирать его было немного геморно, учитывая то, что я уже нашёл такую же функцию только немного в другом месте. В клиентах ICQ 7M и ICQ 8 есть эта функция и при вводе мобильного там высылается 4 символьный код, подобрав который, вы получите все переменные для логина, точно уже не помню все их названия, помню только главную **«sessionid»**. Данную уязвимость не стали реализовывать, так как не смогли разобраться с подписью запросов, но было бы забавно, если бы в один день в инфо нескольких десятков «элитных» номеров появилась шуточная надпись: «**Hacked by Gay Nork Crew special for Asechka.ru**»
**Ну и напоследок ещё одна забавная фича**
Если попытаться зайти с мобильного номера незарегистрированного в ICQ, код будет отправлен и при этом произойдёт регистрация нового номера. Так к чему я всё это?
Как только эта функция была введена, она работала так: этот самый четырёхзначный код устанавливался как пароль. Но продлилось это не долго, примерно с декабря 2012 до конца января 2013 года, представляете сколько номеров было зарегистрировано таким способом?
Немного поразмыслив я составил такую логическую цепочку: если номер зарегистрирован данным способом и имеет такой пароль, значит он не используется с момента регистрации → если номер не используется с момента регистрации значит дата последней смены информации о номере была примерно той же, что и дата регистрации!
К счастью всё тот же комбайн «ICQ Search Info» собирал базы вида **uin;last profile update**, собрав базу таких номеров, я прошёлся на пароли из диапазона 0000-9999 и увидел довольно симпатичные номера…
В данный момент, если регистрация номера производится данным способом, то пароль на него не устанавливается. Зайти на такой номер можно используя всё те же одноразовые четырёхзначные коды или просто установив пароль, пройдя процедуру «восстановления пароля» через мобильный телефон.
Вот такие вот интересности открыли нововведения в ICQ и я думаю подобного рода уязвимости довольно распространены. Если вдруг ваш сервис имеет данные функции, то обязательно проверьте их на «вшивость». | https://habr.com/ru/post/183190/ | null | ru | null |
# Быстрый поиск источника нежелательных мутаций свойства объекта
**Привет! Cегодня расскажу, как можно с помощью отладчика решить, на мой взгляд, нетривиальную проблему JavaScript.**
В JavaScript объекты это составной тип данных, его значение передается по ссылке. Другими словами, когда мы передаем объект в функцию как параметр или где угодно можем поменять его свойства. Используя инструкцию состоящую из выражения переменной, хранящей ссылку, а также операторов точка и присваивания. После этого другие инструкции, которые работают или будут работать с этой переменной/параметром, по ссылке получат изменение свойства.
Часто такое поведение искажает данные пользователя, приводит к ошибкам и является нежелательным.
Поиск источника таких нежелательных изменений свойств может занять долгое время: так программа может быть уже большой и состоять из сотни тысяч инструкций.
Давайте рассмотрим простой пример.
```
Debug property mutation example
const user = {
firstName: 'Vasilij',
middleName: 'Alibabaevich',
lastName: 'Radner',
aka: 'Alibaba',
getFullName() {
return `${this.lastName} ${this.firstName.slice(0, 1)}. ${this.middleName.slice(0, 1)}.`
}
};
Promise.resolve(user).then(user.getFullName.bind(user)).then(console.log);
```
Сейчас веб программа не работает, так как в консоли есть ошибка и нет вывода ФИО.
Читаем самое верхнее сообщение в консоли:
```
Uncaught (in promise) TypeError: Cannot read property 'slice' of undefined
```
Не обработано (в промис) ошибка типа: не могу прочитать свойство slice от неопределено.
Нажимаем на ссылку и переходим к месту ошибки.
```
getFullName() {
return `${this.lastName} ${this.firstName.slice(0, 1)}. ${this.middleName.slice(0, 1)}.`
}
```
Видим, что ошибочное выражение
```
this.firstName.slice(0, 1)
```
состоит из четырех операторов:
1. два оператора точка
2. один оператор-разделитель запятая
3. один оператор группировки — пара круглых скобок
Давайте читать инструкцию. Первым вычисляется левое выражение
```
this.firstName
```
Оно состоит из оператора точка, слева первичное выражения this и идентификатора firstName справа. Результатом этого выражения будет undefined. Выполнение следующего оператора точка вызывает ошибку. Так как оператор точка работает только с объектными типами, его выполнение от undefined приводит к ошибке — не могу получить свойство slice от undefined.
Получается, что где-то этому свойству было присвоено значение undefined…
Чтобы решить эту проблему попробуем пойти от обратного. Воспользуемся инструментом отладки **остановка на исключении**. Двигаясь от места ошибки по стеку вызовов вниз, попробуем перейти к инструкции, которая изменила свойство.
#### Выбираем инструмент остановка на исключении
Видим, что в стеке всего два вызова. Переходим в предыдущий вызов.
Видим, что нет явной инструкции, которая изменяют свойство firstName.
Делаем вывод, что изменение не происходит в этом стеке вызовов.
#### Как вам такое?
И как найти негодяя который изменил свойство моего объекта?
Пожалуйста, напишите в комментах как бы вы нашли его?
Ребята, кто со мной работает и кому я это рассказал, напишите плиз звездочку в комменте.
Мне очень интересно узнать, как другие специалисты JavaScript решают подобные проблемы.
Знаете, когда я встретился с этим поведением JavaScript впервые, я потратил пару часов на расследование и выдрал клок волос с челки…
Отключаем инструмент пауза на исключении.
Итак, вот наш новый план мы определим в объекте user свойство firstName, используя геттер и сеттер.
В сеттер добавим инструкцию отладки, используя оператор debugger и оператор точка с запятой.
```
const user = {
_firstName: 'Vasilij',
set firstName(value) {
debugger;
this._firstName = value;
},
get firstName() {return this._firstName},
middleName: 'Alibabaevich',
lastName: 'Radner',
aka: 'Alibaba',
getFullName() {
return `${this.lastName} ${this.firstName.slice(0, 1)}. ${this.middleName.slice(0, 1)}.`;
}
};
```
Двигаясь дальше по стеку вызовов, найдем инструкцию, которая меняет свойство firstName.
Отладчик остановился в сеттере до того, как новое значение будет записано в объект.
Видим, что значение параметра value undefined.
Теперь, используя стек вызовов мы легко переходим в предыдущий вызов.
иииии, победааааа ура.
Есть еще более простой способ решить эту проблему, используя инструмент отладки **остановка на исключении**.
Вот наш новый план: сделаем объект user не объектом и, используя инструмент **остановку по исключению**, легко попадем к ошибочной инструкции.
Так как мы знаем, что при попытке получения свойства от undefined возникает ошибка.
Включаем инструмент остановка на исключении, присваиваем переменной user значение undefined.
```
const user = undefined;
```
Мы снова остановились в месте искажения свойства firstName.
Это все, что я хотел вам сегодня рассказать об отладке нежелательных изменений у объектов.
Спасибо за прочтение статьи. Ставьте лайки, подписывайтесь на канал, делитесь этим видео и статьей с друзьями, всего хорошего.
[github.com/NVBespalov/js-lessons/tree/error/property-mutation](https://github.com/NVBespalov/js-lessons/tree/error/property-mutation) | https://habr.com/ru/post/481824/ | null | ru | null |
# Работа с объектами СУБД Caché на примере Delphi
Несмотря на перманентные похороны Delphi, эта платформа построения Desktop приложений живёт и здравствует, а со сменой владельца даже [обретает второе дыхание](http://habrahabr.ru/post/142979/) и продолжает оставаться основным инструментом для тысяч разработчиков во всём мире.
Как и с любыми другими СУБД, Delphi прекрасно взаимодействует с СУБД Caché.
Из Delphi можно подключиться к Caché, используя следующие интерфейсы:
* [Caché Objects](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BLAX) (объектный, используя библиотеки CacheObject.dll/CacheActiveX.dll);
* [Caché SQL](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BGOD) (реляционный, используя драйвер ODBC);
* [Caché Direct](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GBCD) (прямой, используя библиотеку Vism.ocx);
* [Веб-сервисы](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GSOAP);
* [Сокеты](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GIOD).
В данной статье будут рассмотрены примеры использования объектного интерфейса при работе с СУБД Caché.
Но для начала приведу несколько коротких примеров на VBScript, которые вы можете запустить непосредственно из Windows Проводника.
Пример прямого доступа:
```
Set f = CreateObject("VISM.VisMCtrl.1")
f.Server="CN_IPTCP:localhost[1972]:_system:@ SYS"
f.NameSpace="SAMPLES"
f.Execute("=$zv") 'получение версии СУБД
WScript.Echo f.VALUE
```
Пример реляционного доступа:
```
Set cn=Createobject("ADODB.Connection")
cn.ConnectionString="DRIVER={InterSystems ODBC35}; SERVER=127.0.0.1; PORT=1972; DATABASE=SAMPLES; UID=_system; PWD=SYS"
cn.open
WScript.Echo "Succesfully!"
```
Пример объектного доступа:
```
Set f = CreateObject("CacheActiveX.Factory")
Set rs = CreateObject("CacheActiveX.ResultSet")
If Not f.IsConnected() Then
f.Connect("cn_iptcp:127.0.0.1[1972]:SAMPLES:_SYSTEM:SYS")
Set rs=f.DynamicSQL("select TOP 3 * from Sample.Person")
rs.Execute()
while rs.Next
WScript.Echo rs.Get("SSN") 'выводим поле SSN первых трёх записей из таблицы Sample.Person
wend
rs.Close()
Set person = f.Static("Sample.Person")
age=person.CurrentAge(45678) 'вызываем метод класса Sample.Person
WScript.Echo age
End If
```
Похожим образом вы можете работать с СУБД Caché, использя JScript, Visual Basic, C++ Builder, и т.д.
> Примечание: Для Java и .NET предусмотрено несколько нативных [интерфейсов](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=SETLangBind), которые обеспечивают гораздо больше возможностей.
#### Позднее и раннее связывание
Существует два подхода при работе с объектами Caché из Delphi:
* позднее связывание;
* [раннее связывание](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BLAX_config).
У каждого из этих подходов есть свои преимущества и недостатки, которые впрочем компенсируют друг друга.
При позднем связывании разработчику недоступен подсказчик кода, соответственно высока вероятность допустить ошибку в коде, которая будет обнаружена лишь во время выполнения программы. Скорость работы несколько ниже, чем при раннем связывании, так как код выполняется динамически.
Раннее связывание лишено этих недостатков, но за это приходится платить тем, что при изменении интерфейса пользовательских классов в БД или при [переходе на новую версию СУБД Caché](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=gcnv_introduction#GCNV_C113546) необходимо перегенерировать прокси-классы для клиентского приложения.
Комбинируя оба этих подхода можно добиться оптимальной производительности и удобства в работе.
В данной статье будет в основном использоваться раннее связывание, так как данный подход меньше описан по сравнению с поздним связыванием.
Для работы Caché Objects используются две библиотеки, которые по умолчанию устанавливаются в *C:\Program Files\Common Files\InterSystems\Cache\*:
* **CacheObject.dll** (устаревшая);
* **CacheActiveX.dll** (рекомендуемая).
Начиная с версии Caché 5.1, разработчики InterSystems настоятельно рекомендуют использовать новую библиотеку **CacheActiveX.dll**. Библиотека **CacheObject.dll** оставлена лишь для совместимости со старыми приложениями. Поэтому в данной статье я буду основываться на **CacheActiveX.dll**.
Об отличиях данных библиотек и нюансах, которые нужно учитывать при переходе на новую версию, можно почитать в [Upgrading from CacheObject.dll](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BLAX_elements#BLAX_elements_upgrade).
В каталоге выше можно найти и другие файлы, которые могут Вам пригодиться:
* **DelphiCallback.dll**;
* **CacheList.ocx**;
* **CacheQuery.ocx**;
* **VISM.ocx**.
#### Импорт и установка компонент Caché Objects ActiveX в Delphi
В данном разделе описывается установка основных классов и интерфейсов в среде Delphi для работы с объектами в СУБД Caché, используя раннее связывание. Для работы с поздним связыванием этот раздел можно пропустить.
Итак, по порядку:
1. выбираем пункт меню **Component > Import Component...**;
2. выбираем для начала библиотеку типов *CacheActiveX 2.0 Type Library*;
3. задаём имя нашей закладки, куда мы хотим установить наши компоненты, а также другие параметры;
4. создаём наш модуль, пока без установки;
5. повторяем пункты 2-4 для следующих библиотек:
* *CacheActiveX 2.0 Type Library*;
* *CacheList ActiveX Control module*;
* *CacheQuery ActiveX Control module*;
* *DelphiCallback 1.0 Type Library*;
* *VisM 7.2 ActiveX Control*;
* *TL 1.0 Type Library*.
> Примечание: Создать модули можно и с помощью утилиты **tlibimp.exe**, входящей в поставку Delphi.
6. создаём новый проект типа Package и добавляем в него все нами ранее созданные модули. Компилируем проект и инсталлируем наш пакет. Вот что в итоге у нас должно получиться:
> Примечание: Для более ранних версий Delphi процесс создания модулей отличается незначительно:
>
>
> * выбираем пункт меню **Project > Import Type Library...**;
>
>
>
> 
> * далее см. пункты выше.
#### Генерация пользовательских прокси-классов
В данном разделе описывается генерация пользовательских прокси-классов для работы с объектами в СУБД Caché, используя раннее связывание. Для работы с поздним связыванием этот раздел можно пропустить.
Для начала необходимо сгенерировать ODL-файл, содержащий все необходимые нам пользовательские классы. Для этого следует воспользоваться утилитой **odl\_generator.exe**, поставляемой с СУБД Caché.
ПРИМЕР:
```
odl_generator.exe -conn cn_iptcp:localhost[1972]:USER:_system:SYS -class-list test.txt -lib-name test -dir MIDL
```
В данном примере утилита подключается к области **USER**, генерирует прокси-классы для классов перечисленных в файле **test.txt**, и сохраняет результат в файл **MIDL\test.odl**
> Внимание: Полученный таким образом файл предназначен для использования с библиотекой **CacheActiveX.dll**. Чтобы сгенерировать ODL-файл, предназначенный для работы со старой библиотекой, следует воспользоваться методом [ExportODL](http://docs.intersystems.com/cache20121/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.OBJ#ExportODL) класса %SYSTEM.OBJ
>
>
>
> ПРИМЕР:
>
> `set list="%Library.Status,Sample.Person"
>
> do $system.OBJ.ExportODL(list,"c:\MIDL\test.odl","-d",.err)`
Итак, ODL-файл получен, теперь следует его скомпилировать, чтобы получить TLB-файл, а затем и PAS-файл. Для этого можно воспользоваться утилитами **midl.exe** или **mktypelib.exe**, входящими в комплект разработчика Visual C++.
ПРИМЕР:
```
midl /I . test.odl /tlb test.tlb
tlibimp.exe -C- -P+ -Hr- -Ha- -Hs- -XM- test.tlb
```
> Примечание: Все вышеперечисленные этапы вы можете автоматизировать с помощью MAC-программы СУБД Caché.
#### Подготовительные работы на сервере
Создадим в нашей тестовой базе следующие классы данных:
> `/// Встраиваемый класс
>
> Class pas.s Extends %SerialObject
>
> {
>
>
>
> /// Целое число (64-бит).
>
> Property aInteger As %Integer;
>
>
>
> /// Строка. Максимальная длина по умолчанию - 50 символов.
>
> Property aString As %String;
>
>
>
> }`
> `/// Вспомогательный хранимый класс.
>
> Class pas.a Extends %Persistent
>
> {
>
>
>
> /// Индекс на поле aA;
>
> Index aAIndex On aA;
>
>
>
> /// Отношение один-ко-многим, мощность "один". В SQL преобразуется в foreign key.
>
> Relationship aA As pas.test [ Cardinality = one, Inverse = aChilds ];
>
>
>
> Property aInteger As %Integer;
>
>
>
> Property aString As %String;
>
>
>
> }`
> `/// Подключение вспомогательного файла %occIO.inc с макросами.
>
> Include %occIO
>
>
>
> /// Основной хранимый класс.
>
> Class pas.test Extends %Persistent
>
> {
>
>
>
> /// Задаём поля, возвращаемые при выборке всех экземпляров данного класса;
>
> Parameter EXTENTQUERYSPEC As ROWSPEC [ Flags = LIST ] = aBoolean,aInteger,aString,aDate,aTimeStamp";
>
>
>
> /// Булево значение (true/false/null);
>
> Property aBoolean As %Boolean;
>
>
>
> Property aInteger As %Integer;
>
>
>
> Property aString As %String;
>
>
>
> /// Дата;
>
> Property aDate As %Date;
>
>
>
> /// Дата+время;
>
> Property aTimeStamp As %TimeStamp;
>
>
>
> /// Символьный поток (CLOB);
>
> Property aMemo As %GlobalCharacterStream;
>
>
>
> /// Двоичный поток (BLOB);
>
> Property aPhoto As %GlobalBinaryStream;
>
>
>
> /// Отношение один-ко-многим, мощность "много". В SQL отсутствует аналог.
>
> Relationship aChilds As pas.a [ Cardinality = many, Inverse = aA ];
>
>
>
> /// Свойство-объект встраиваемого класса;
>
> ///
> В SQL каждое свойство встраиваемого класса становится отдельным
> aS As pas.s;
>
>
>
> /// Коллекция-список строк;
>
> ///
> В SQL это поле содержит значения, разделённые заданным разделителем, например запятой.
> aListOfString As list Of %String;
>
>
>
> /// Коллекция-список объектов вспомогательного класса;
>
> ///
> В SQL это поле содержит значения первичных ключей объектов, разделённые заданным разделителем, например запятой.
> aListOfA As list Of pas.a;
>
>
>
> /// Коллекция-массив строк;
>
> ///
> В SQL формируется виртуальная таблица.
> aArrOfString As array Of %String;
>
>
>
> /// Коллекция-массив объектов вспомогательного класса;
>
> ///
> В SQL формируется виртуальная таблица.
> aArrOfA As array Of pas.a;
>
>
>
> /// Метод экземпляра класса.
>
> ///
> Переопределяем встроенное событие, возникающее перед сохранением объекта.
> %OnBeforeSave(insert As %Boolean) As %Status [ Private,ServerOnly = 1 ]
>
> {
>
> ; выводим имя класса и метода текущего контекста
>
> write "Hello from Cache! (",$$$CurrentClass,":",$$$CurrentMethod,")",!
>
>
>
> quit $$$OK
>
> }
>
>
>
> /// Запрос - хранимая процедура: демонстрация передачи простых типов данных.
>
> Query test1(ABoolean As %Boolean, AInteger As %Integer, AString As %String, ADate As %Date, ATimeStamp As %TimeStamp) As %SQLQuery(CONTAINID = 1, ROWSPEC = "ID:%String,aBoolean:%Boolean,aInteger:%Integer,aString:%String,aDate:%Date,aTimeStamp:%TimeStamp") [ SqlProc ]
>
> {
>
> SELECT %ID,aBoolean,aInteger,aString,aDate,aTimeStamp FROM pas.test WHERE
>
> (aBoolean=:ABoolean or :ABoolean is null)
>
> AND (aInteger=:AInteger or :AInteger is null)
>
> AND (aString=:AString or :AString is null)
>
> AND (aDate<:ADate or :ADate is null)
>
> AND (aTimeStamp<=:ATimeStamp or :ATimeStamp is null)
>
> }
>
>
>
> /// Запрос - хранимая процедура: демонстрация передачи параметра встроенного типа данных "список"
>
> ///
> и использование его в запросе совместно с конструкцией %INLIST.
> test2(AList As %List) As %SQLQuery(CONTAINID = 1, ROWSPEC = "ID:%String,aBoolean:%Boolean,aInteger:%Integer,aString:%String,aDate:%Date,aTimeStamp:%TimeStamp") [ SqlProc ]
>
> {
>
> SELECT %ID,aBoolean,aInteger,aString,aDate,aTimeStamp FROM pas.test WHERE ID %INLIST :AList
>
> }
>
>
>
> /// Метод класса.
>
> ClassMethod test3(AList As %List) As %Status
>
> {
>
> ; выводим на текущее устройство значение параметра AList
>
> write AList
>
>
>
> ; сохраняем значение в глобал
>
> set ^pastest=AList
>
>
>
> quit $$$OK
>
> }
>
>
>
> /// Демонстрация генерации ошибки.
>
> ClassMethod test4() As %Status
>
> {
>
> quit $$$ERROR($$$GeneralError,"My error!")
>
> }
>
>
>
> /// Демонстрация передачи заранее неизвестного количества параметров.
>
> ClassMethod test5(Arg1... As %List) As %Status
>
> {
>
> ; выводим общее количество переданных параметров и их значения
>
> write "Invocation has ",$get(Arg1, 0)," element",$select(($get(Arg1, 0)=1):"", 1:"s"),!
>
> for i = 1 : 1 : $get(Arg1, 0)
>
> {
>
> write:($data(Arg1(i))>0) "Argument[",i,"]:",?15,$get(Arg1(i),""),!
>
> }
>
> quit $$$OK
>
> }
>
>
>
> /// Демонстрация передачи параметров более сложных типов: объекта нашего класса и потоков.
>
> ///
> Также демонстрируется передача параметра по ссылке и выходных параметров.
> test6(
>
> ID As %String,
>
> ByRef A As pas.a,
>
> Output BLOB As %BinaryStream,
>
> Output RS1 As %CharacterStream,
>
> Output RS2 As %CharacterStream) As %Status
>
> {
>
> // меняем одно из свойств объекта, переданного по ссылке
>
> set A.aString=999
>
>
>
> // создаём объект двоичного потока
>
> set BLOB=##class(%GlobalBinaryStream).%New()
>
>
>
> // записываем в поток данные
>
> do BLOB.Write("123")
>
>
>
> // создаём объекты символьного потока
>
> set RS1=##class(%GlobalCharacterStream).%New()
>
> set RS2=##class(%GlobalCharacterStream).%New()
>
>
>
> // создаём объект пользовательского класса, позволяющего выгружать данные в формат XML для TClientDataSet
>
> set cds=##class(%XML.ZMyBaseDataSet).%New()
>
>
>
> // подготавливаем запрос
>
> do cds.Prepare("select \* from pas.a where id %inlist ?")
>
>
>
> // передаём данные в запрос
>
> do cds.SetArgs($listbuild(1,2,3,9))
>
>
>
> // выгружаем данные в символьный поток в формате XML
>
> do cds.XMLExportToStream(.RS1)
>
>
>
> // закрываем (инициализируем заново) объект для выполнения другого запроса
>
> do cds.Close()
>
> do cds.Prepare("select ID,aBoolean,aInteger,aString,aDate,aTimeStamp from pas.test")
>
> do cds.XMLExportToStream(.RS2)
>
> do cds.Close()
>
>
>
> // возвращаем статус "Успешно"
>
> quit $$$OK
>
> }
>
>
>
> }`
Сгенерируем для них прокси-классы, а также для следующих классов:
* %Library.ArrayOfDataTypes
* %Library.ArrayOfObjects
* %Library.ListOfObjects
* %Library.ListOfDataTypes
* %Library.RelationshipObject
Теперь, если подключить к проекту сгенерированный PAS-файл, становятся доступны наиболее важные методы и свойства наших классов:
[увеличить](https://habrastorage.org/getpro/habr/post_images/720/99e/fc8/72099efc8731113604031a54f5814742.png)
> Внимание: Классы по работе с потоками и некоторые другие не следует импортировать из СУБД Caché, так как они уже зашиты в библиотеку **CacheActiveX.dll** и несовместимы со сгенерированными прокси-классами.
#### Подключение к СУБД Caché
Позднее связывание (старая библиотека):
```
var _f:variant;
begin
_f:=CreateOleObject('CacheObject.Factory');
if _f.Connect(_f.ConnectDlg('+%up')) then ShowMessage('OK') else ShowMessage('ERROR');
```
Позднее связывание (новая библиотека):
```
var _f:variant;
begin
_f:=CreateOleObject('CacheActiveX.Factory');
if _f.Connect(_f.ConnectDlg('+%up')) then ShowMessage('OK') else ShowMessage('ERROR');
```
Раннее связывание (новая библиотека):
```
type
Tfm = class(TForm)
f: TFactory;
...
begin
...
if f.Connect1(f.ConnectDlg('+%up')) then ShowMessage('OK') else ShowMessage('ERROR');
...
```
> Внимание: Старая библиотека использует сервис **%Service\_CacheDirect** и только неаутентифицированный доступ, новая — **%Service\_Bindings** и другие методы доступа.
Подробное описание методов класса TFactobry, а также других классов, можно найти в [ActiveX API Reference](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BLAX_api)
#### Примеры вызова запросов и методов, используя раннее связывание
##### Использование функциональности CallBack
Для использования функциональности [CallBack](http://htnbsp;pas.testtp://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=BLAX_parts#BLAX_parts_callbackvb) из Delphi следует воспользоваться готовым классом TCallback из файла **DelphiCallback.dll**.
```
var f:TFactory;
Callback1: TCallback;
mm: TMemo;
...
f.SetOutput(Callback1.OleObject);
...
procedure Tfm.Callback1TextChanged(Sender: TObject; const p_bstrText: WideString);
begin
mm.Lines.Append(p_bstrText);
end;
```
##### Удаление всех данных
```
mm.Lines.Text:='KillExtent'#10#13;
// удаляем данные
test_(f.Static('pas.test')).SYS_KillExtent(1);
a(f.Static('pas.a')).SYS_KillExtent(1);
```
##### Пример создания, заполнения, сохранения и освобождения объектов различных типов
Про особенности закрытия объектов при работе через ActiveX можно почитать в статье Сергея Кудинова: [Особенности закрытия объектов при работе через ActiveX, CPP-binding](http://writeimagejournal.com/?p=256).
Пример кода:
```
...
uses test_TLB, AxCtrls, ComObj, ActiveX, Types;
...
const
N = 3;
var
i: integer;
_t: test_;
_a: A;
_s: s;
rel: RelationshipObject;
listStr: ListOfDataTypes;
listA: ListOfObjects;
arrStr: ArrayOfDataTypes;
arrA: ArrayOfObjects;
stream: IDispatch;
begin
Screen.Cursor := crSQLWait;
mm.Lines.Text:='Save'#10#13;
try
try
// создаём новый объект класса pas.test
_t := test_(f.New('pas.test'));
// далее заполняем его данными
_t.aBoolean := true;
_t.aInteger := 50;
_t.aString := 'Тестовая строка';
// так мы можем присвоить null скалярному типу данных
// (%Integer,%Boolean,%Date и т.д.)
Variant(_t).aDate := nil;
_t.aDate := _t.aDateDisplayToLogical('02.03.2001');
// или t.aDate:=StrToDate('02.03.2001');
_t.aTimeStamp := _t.aTimeStampDisplayToLogical('1900-01-02 12:34:55');
// или t.aTimeStamp:=StrToDateTime('02.01.1900 12:34:55');
// заполняем данными символьный поток
stream := _t.aMemo;
ICharStream(stream).Write('Символьный поток');
stream := nil;
// заполняем данными бинарный поток
stream := _t.aPhoto;
IBinaryStream(stream).FileRead('C:\test.jpg');
stream := nil;
// создаём N "дочерних" объектов класса pas.a
rel := RelationshipObject(_t.aChilds);
for i := 1 to N do
begin
_a := A(f.New('pas.a'));
_a.aInteger := i;
_a.aString := 'rel' + IntToStr(i);
rel.Insert(_a);
_a.SYS_Close;
end;
_t.aChilds := rel;
rel.SYS_Close;
// заполняем данными встраиваемый объект
_s := s(_t.aS_);
_s.aInteger := 1;
_s.aString := 's1';
_s.SYS_Close;
// заполняем данными список простых типов. В данном случае строк
listStr := ListOfDataTypes(f.New('%ListOfDataTypes'));
for i := 1 to N do
listStr.Insert('str' + IntToStr(i));
_t.aListOfString := listStr;
listStr.SYS_Close;
// создаём объекты класса pas.a и заполняем ими список
listA := ListOfObjects(f.New('%ListOfObjects'));
for i := 1 to N do
begin
_a := A(f.New('pas.a'));
_a.aInteger := i;
_a.aString := 'listA' + IntToStr(i);
listA.Insert(_a);
_a.SYS_Close;
end;
_t.aListOfA := listA;
listA.SYS_Close;
// заполняем данными массив простых типов. В данном случае строк
arrStr := ArrayOfDataTypes(f.New('%ArrayOfDataTypes'));
for i := 1 to N do
arrStr.SetAt('astr' + IntToStr(i), 'arraykey' + IntToStr(i));
_t.aArrOfString := arrStr;
arrStr.SYS_Close;
// создаём объекты класса pas.a и заполняем ими массив
arrA := ArrayOfObjects(f.New('%ArrayOfObjects'));
for i := 1 to N do
begin
_a := A(f.New('pas.a'));
_a.aInteger := i;
_a.aString := 'arrayA' + IntToStr(i);
arrA.SetAt(_a, 'arraykey' + IntToStr(i));
_a.SYS_Close;
end;
_t.aArrOfA := arrA;
arrA.SYS_Close;
// сохраняем наш объект в базу в рамках одной транзакции. До этого
// все изменения объекта производились в оперативной памяти на стороне
// клиента.
_t.SYS_Save(0);
// читаем данные бинарного потока для отображения на экране фотографии
stream := _t.aPhoto;
SetOlePicture(img.Picture, IBinaryStream(stream).GetPicture);
stream := nil;
// закрываем объект на сервере. Список незакрытых объектов вы можете
// просмотреть в Портале, меню "Процессы" (%sysOrefs).
// Незакрытые объекты в дальнейшем чреваты неприятностями в виде
// утечек памяти на сервере и заблокированности данных.
_t.SYS_Close;
// закрываем объект на клиенте
_t := nil;
mm.Lines.Append('OK');
except
on E: Exception do
begin
mm.Lines.Append(E.Message);
end;
end;
finally
Screen.Cursor := crDefault;
// принудительно синхронизируем состояние объектов на сервере,
// согласно их состоянию на клиенте
f.ForceSync;
end;
```
##### Запрос Extent (выборка всех экземпляров хранимого класса)
```
var mm: TMemo;
rs: TResultSet;
...
mm.Lines.Text:='Extent'#10#13;
rs.ConnectTo(IResultSet(f.ResultSet('pas.test', 'Extent')));
rs.Execute;
while rs.Next do
begin
mm.Lines.Append(Format('ID = %s',[rs.GetDataAsString(1)]));
mm.Lines.Append(Format('aBoolean = %s',[rs.Get('aBoolean')]));
mm.Lines.Append(Format('aInteger = %s',[rs.Get('aInteger')]));
mm.Lines.Append(Format('aString = %s',[rs.Get('aString')]));
mm.Lines.Append(Format('aDate = %s',[rs.Get('aDate')]));
mm.Lines.Append(Format('aTimeStamp = %s',[rs.Get('aTimeStamp')]));
mm.Lines.Append('-----');
end;
rs.Close;
rs.Disconnect;
```
##### Запрос test1
```
var
i: integer;
...
mm.Lines.Text:='test1'#10#13;
rs.ConnectTo(IResultSet(f.ResultSet('pas.test', 'test1')));
rs.SetParam(1, null);
rs.SetParam(2, 50);
rs.SetParam(3, null);
rs.SetParam(4, '03.03.2001');
rs.SetParam(5, '1900-01-02 12:34:55.0');
rs.Execute;
while rs.Next do
begin
for i := 1 to rs.GetColumnCount do
mm.Lines.Append(rs.GetColumnName(i)+' = '+rs.GetDataAsString(i));
mm.Lines.Append('-----');
end;
rs.Close;
rs.Disconnect;
```
##### Запрос test2
```
var
i: integer;
syslist: TSyslist;
...
mm.Lines.Text:='test2'#10#13;
// заполняем объект класса %List
syslist.Clear;
syslist.Add(1);
syslist.Add(2);
syslist.Add(3);
rs.ConnectTo(IResultSet(f.ResultSet('pas.test', 'test2')));
rs.Execute(syslist.DefaultInterface);
while rs.Next do
begin
for i := 1 to rs.GetColumnCount do
mm.Lines.Append(rs.GetColumnName(i)+' = '+rs.GetDataAsString(i));
mm.Lines.Append('-----');
end;
rs.Close;
rs.Disconnect;
```
##### Метод test3. Работа с объектом класса TSysList (тип %List в Caché)
```
mm.Lines.Text:='test3'#10#13;
// заполняем объект класса %List
syslist.Clear;
syslist.Add('16');
syslist.Add('42');
syslist.Add('35');
test_(f.Static('pas.test')).test3(syslist.DefaultInterface);
```
##### Метод test4. Обработка ошибок
```
mm.Lines.Text:='test4'#10#13;
try
test_(f.Static('pas.test')).test4();
except
on E: Exception do
begin
mm.Lines.Append(E.Message);
end;
end;
```
##### Метод test5
```
mm.Lines.Text:='test5'#10#13;
// заполняем объект класса %List
syslist.Clear;
syslist.Add('16');
syslist.Add('42');
syslist.Add('35');
test_(f.Static('pas.test')).test5(syslist.DefaultInterface);
```
##### Метод test6
В данном примере используется класс %XML.ZMyBaseDataSet, который можно найти [здесь](http://sourceforge.net/projects/m-pas/files/Delphi%20_%20Cache%20MIDAS/1.0/). С его помощью можно на сервере формировать данные в формате *Borland ® MyBase (DataSnap (TM)) XML DataSet*. В том числе и для веб-сервисов.
```
cds1,cds2:TClientDataSet;
...
var _a:a;
__a,blob,rs1,rs2:IDispatch;
cs1,cs2:ICharStream;
begin
mm.Lines.Text:='test6'#10#13;
try
_a:=a(f.OpenId('pas.a','1'));
__a:=_a;
test_(f.Static('pas.test')).test6('1',__a,blob,rs1,rs2);
cs1:=ICharStream(rs1);
cs2:=ICharStream(rs2);
mm.Lines.Append('A.aString = '+_a.aString);
mm.Lines.Append('BLOB.Size = '+IntToStr(IBinaryStream(blob).size));
mm.Lines.Append('RS1.Size = '+IntToStr(cs1.size));
mm.Lines.Append('RS2.Size = '+IntToStr(cs2.size));
cds1.XMLData:=cs1.Data;
cds2.XMLData:=cs2.Data;
finally
_a.SYS_Close;
_a:=nil;
__a:=nil;
blob:=nil;
rs1:=nil;
rs2:=nil;
cs1:=nil;
cs2:=nil;
f.ForceSync;
end;
```
Для поддержки классом %XML.ZMyBaseDataSet данных в Unicode, а также других нереализованных типов данных Вам необходимо будет его доработать самостоятельно.
##### Распространение приложения
Для установки с приложением всех необходимых драйверов на новый компьютер следует скопировать все (для простоты. Набор нужных файлов можно ограничить) файлы из каталога *C:\Program Files\Common Files\InterSystems\Cache\* и зарегистрировать в системе некоторые из них с помощью утилиты **regsvr32.exe**.
ПРИМЕР:
```
regsvr32.exe /s "C:\Program Files (x86)\Common Files\Intersystems\Cache\CacheQuery.ocx"
regsvr32.exe /s "C:\Program Files (x86)\Common Files\Intersystems\Cache\CacheFormWizard.dll"
regsvr32.exe /s "C:\Program Files (x86)\Common Files\Intersystems\Cache\CacheList.ocx"
regsvr32.exe /s "C:\Program Files (x86)\Common Files\Intersystems\Cache\CacheActiveX.dll"
regsvr32.exe /s "C:\Program Files (x86)\Common Files\Intersystems\Cache\vism.ocx"
regsvr32.exe /s "C:\Program Files (x86)\Common Files\Intersystems\Cache\TL.dll"
```
##### [Исходники](http://db.tt/nOwWu3NI)
* серверная часть
```
pas.xml
```
* клиентская часть
```
Unit1.dfm
test_TLB.pas
Unit1.pas
```
* сгенерированные прокси-классы
```
test.odl
``` | https://habr.com/ru/post/144306/ | null | ru | null |
# Как я скачивал онлайн трансляцию Comdi (Startup village)
Мы живем с вами в то время, когда видео с Youtube и других видеохостингов может скачать даже школьник с помощью огромного количества расширений для браузеров.
Что касается онлайн трасляций, то здесь уже не все так просто. В прошлом году еще задался целью скачать записи выступлений на Startup village в Сколково, но тогда ничего кроме захвата экрана не придумал. В этот раз решил пойти до конца и найти способ скачать онлайн трансляции. Готовых решений в интернете не видел, только многочисленные вопросы, как скачать с Comdi. Надеюсь кому-то мой опыт покажется полезным.
Startup village – самая крупная в Восточной Европе конференция для стартапов, которую проводит Фонд «Сколково». Во время проведения конференции ведется онлайн трасляция всех мероприятий, проводимых на многочисленных площадках. Трансляции потом доступны на сайте Startup village.
Сама страница с видео представляет собой фрейм, где отображается [broadcast.comdi.com](https://broadcast.comdi.com).
На странице можно выбрать зал и интересующее мероприятие.
Ни одно из популярных расширений для браузеров, таких как Save form и другие не находили ссылки на скачивание.
Как показал анализ, вся трансляция в рамках одной секции (например, конкурс стартапов в номинации «Разработка новых лекарственных препаратов» в Патио 4), состоит из файлов нескольких сотен файлов по 12-15 секунд формата MPEG-TS.
**Данные о видеопотоке**`Видео
Идентификатор : 256 (0x100)
Идентификатор меню : 1 (0x1)
Формат : AVC
Формат/Информация : Advanced Video Codec
Профиль формата : Baseline@L3.1
Параметр CABAC формата : Нет
Параметр ReFrames формата : 3 кадра
Идентификатор кодека : 27
Продолжительность : 14 с.
Вид битрейта : Постоянный
Номинальный битрейт : 2000 Кбит/сек
Ширина : 1280 пикселей
Высота : 720 пикселей
Соотношение сторон : 16:9
Частота кадров : 25,000 кадров/сек
Стандарт вещания : NTSC
Цветовое пространство : YUV
Субдискретизация насыщенности : 4:2:0
Битовая глубина : 8 бит
Тип развёртки : Прогрессивная
Бит/(Пиксели*Кадры) : 0.087
Цветовой диапазон : Limited
Аудио
Идентификатор : 257 (0x101)
Идентификатор меню : 1 (0x1)
Формат : AAC
Формат/Информация : Advanced Audio Codec
Версия формата : Version 4
Профиль формата : LC
Режим смешивания : ADTS
Идентификатор кодека : 15
Продолжительность : 14 с.
Вид битрейта : Переменный
Каналы : 2 канала
Расположение каналов : Front: L R
Частота : 44,1 КГц
Частота кадров : 43,066 кадра/сек (1024 spf)
Метод сжатия : С потерями`
Предлагаю готовый рецепт по скачиваю онлайн трансляций с Comdi.
1) Установить расширение Video Downloader Pro
2) Открыть страницу [startupvillage.ru/ru/page/video](https://startupvillage.ru/ru/page/video)
3) Через расширение Video Downloader Pro скачать файл chunklist.M3U8
В этом файле нам нужно посмотреть имя начального и имя конечного файла. В нашем случае начало трансляции – media\_0.ts, конец трансляции –media\_408.ts.
4) Скопировать ссылку на один из медиа файлов, например media\_0.ts.
У меня это `https://webinar-htvod.cdn.ngenix.net/vod/_definst_/mp4:webinar/nsvuapdnbvoes8et2ls0_2_11113.mp4/media_0.ts`
5) Далее зная, что все файлы одной сессии лежат в одной папке делаем 409 ссылок с инкрементов от 0 до 408.
6) Самый простой вариант Microsoft Excel.
Делаем три столбца
1-й столбец: `htvod.cdn.ngenix.net/vod/_definst_/mp4:webinar/nsvuapdnbvoes8et2ls0_2_11113.mp4/media_`
2-й столбец:
`номер по порядку`
3-й столбец:
`.ts`
7) Скопируйте полученную таблицу в Notepad++ и удалите пробелы.
8) Скопируйте полученные ссылки в буфер обмена.
9) Запустите download manager. У меня стоит Download Master. При запуске он подхватил все 409 ссылок и создал загрузки.
10) После завершения загрузки имеем 409 файлов, которые можно при необходимо склеить или смотреть последовательно через плеер.
Have a fun! | https://habr.com/ru/post/303682/ | null | ru | null |
# Используем TSQL для игры в «Судоку»
После того как при помощи TSQL была успешна решена [«Балда» (статья)](http://habrahabr.ru/post/271795/) я решил попробовать решить на нем «Судоку» (спасибо за идею [shavluk](http://habrahabr.ru/users/shavluk/)).
Решение судоку получилось на удивление достаточно простым.
**Базовая схема имеет следующий вид:**
**Описание таблиц:**
* SudokuCell – описание свойств (регион, строка, столбец) всех ячеек;
* SudokuValue – допустимые значения ячейки;
* SudokuField – поле, для задания известных цифр.
**Скрипт для создания таблиц:**
```
-- удаляем таблицы если они уже есть
IF EXISTS (SELECT * FROM sysobjects WHERE name='SudokuField') DROP TABLE SudokuField;
IF EXISTS (SELECT * FROM sysobjects WHERE name='SudokuCell') DROP TABLE SudokuCell;
IF EXISTS (SELECT * FROM sysobjects WHERE name='SudokuValue') DROP TABLE SudokuValue;
----------------------------------------------
-- описание ячеек и их свойств
----------------------------------------------
CREATE TABLE SudokuCell(
ID int NOT NULL, -- ID ячейки
RegionID int NOT NULL, -- регион
RowID int NOT NULL, -- строка
ColID int NOT NULL, -- столбец
CONSTRAINT PK_SudokuCell PRIMARY KEY(ID)
)
GO
-- заполняем таблицу
INSERT SudokuCell(ID,RegionID,RowID,ColID)
SELECT
reg.ID*100+r.i*10+c.j,
reg.ID,
(reg.ID/10-1)*3+r.i,
(reg.ID-1)%10*3+c.j
FROM (VALUES (11),(12),(13),(21),(22),(23),(31),(32),(33)) reg(ID)
CROSS JOIN (VALUES(1),(2),(3)) r(i)
CROSS JOIN (VALUES(1),(2),(3)) c(j)
GO
----------------------------------------------
-- цифры 1-9 (допустимые значения)
----------------------------------------------
CREATE TABLE SudokuValue(
Value char(1) NOT NULL,
CONSTRAINT PK_SudokuValue PRIMARY KEY(Value)
)
GO
-- заполняем таблицу
INSERT SudokuValue(Value) VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9)
GO
----------------------------------------------
-- поле
----------------------------------------------
CREATE TABLE SudokuField(
CellID int NOT NULL,
Value char(1) NOT NULL,
CONSTRAINT PK_SudokuField PRIMARY KEY(CellID),
CONSTRAINT FK_SudokuField_CellID FOREIGN KEY(CellID) REFERENCES SudokuCell(ID),
CONSTRAINT FK_SudokuField_Value FOREIGN KEY(Value) REFERENCES SudokuValue(Value)
)
GO
```
**Заполнение поля известными цифрами производим следующим образом:**
```
-- предварительная очистка поля, на тот случай если оно заполнено
TRUNCATE TABLE SudokuField
GO
-- заполнение поля известными цифрами
INSERT SudokuField(CellID,Value)VALUES
(1122,'3'),(1123,'4'),
(1211,'1'),(1212,'5'),
(1322,'8'),(1323,'9'),(1333,'3'),
(2112,'2'),(2122,'4'),(2123,'7'),(2133,'9'),
(2212,'6'),(2223,'9'),(2232,'2'),
(2311,'8'),(2333,'1'),
(3111,'1'),
(3213,'2'),(3221,'9'),
(3313,'5'),(3332,'7'),(3333,'4')
GO
```
Идентификатор ячейки (CellID) построен следующим образом:
* Первая и вторая цифра числа – указывают какой это регион (строка, столбец);
* Третья и четвертая цифра – номер строки и столбца в регионе.
Начальные варианты заполнения я брал со следующего сайта – [ссылка](http://japonskie.ru/index.php?place=sudoku&slev=5&lev=0&sort=0).
**Посмотрим, как выглядит поле:**
```
-- вид поля до заполнения
SELECT
ISNULL([1],'') [1],
ISNULL([2],'') [2],
ISNULL([3],'') [3],
ISNULL([4],'') [4],
ISNULL([5],'') [5],
ISNULL([6],'') [6],
ISNULL([7],'') [7],
ISNULL([8],'') [8],
ISNULL([9],'') [9]
FROM
(
SELECT c.RowID,c.ColID,f.Value
FROM SudokuCell c
LEFT JOIN SudokuField f ON f.CellID=c.ID
) q PIVOT(MAX(Value) FOR ColID IN([1],[2],[3],[4],[5],[6],[7],[8],[9])) p
ORDER BY RowID
```
**Дальше идет алгоритм поиска решения с комментариями:**
```
-- фиксируем время запуска поиска
DECLARE @StartTime datetime=SYSDATETIME();
-- получаем допустимые цифры в пустых ячейках
SELECT
-- формируем идентификатор варианта - укорачиваем его для более быстрого поиска
RIGHT(CONCAT('0',CAST(CellNo AS varchar(2)),CHAR(ASCII('a')+Value-1)),3) ID,
*
INTO #SudokuVariant
FROM
(
-- получаем все незаполненные ячейки
SELECT
ID CellID,RowID,ColID,RegionID,
-- нумеруем ячейки
CAST(DENSE_RANK()OVER(ORDER BY ID) AS int) CellNo
FROM SudokuCell
WHERE ID NOT IN(SELECT CellID FROM SudokuField)
) e
CROSS APPLY
(
-- получаем все цифры, которые могут быть вписаны в каждую пустую ячейку
SELECT v.Value
FROM SudokuCell c
JOIN SudokuField f ON f.CellID=c.ID AND (c.ColID=e.ColID OR c.RowID=e.RowID OR c.RegionID=e.RegionID)
RIGHT JOIN SudokuValue v ON v.Value=f.Value
WHERE c.ID IS NULL -- оставляем только цифры, которых нет в регионе/строке/столбце
) v
--SELECT * FROM #SudokuVariant
-- вспомогательная таблица для построения деревьев решений
CREATE TABLE #SudokuTree(
CellNo int NOT NULL,
VariantPath varchar(1000) NOT NULL
)
-- создаем корни деревьев из ячеек с CellNo=1
INSERT #SudokuTree(CellNo,VariantPath)
SELECT CellNo,ID
FROM #SudokuVariant
WHERE CellNo=1
--SELECT * FROM #SudokuTree
-- это максимальная длина цепочки
DECLARE @MaxCellNo int=(SELECT MAX(CellNo) FROM #SudokuVariant)
-- номера начальной и следующей ячеек
DECLARE @CurrCellNo int=1
DECLARE @NextCellNo int=@CurrCellNo+1
-- строим дерево
WHILE @CurrCellNo<@MaxCellNo
BEGIN
-- добавление отростков
INSERT #SudokuTree(CellNo,VariantPath)
SELECT
v.CellNo,
CONCAT(t.VariantPath,v.ID)
FROM #SudokuTree t
JOIN #SudokuVariant v ON t.CellNo=@CurrCellNo AND v.CellNo=@NextCellNo
/*
в следующий узел дерева будут входить только значения, которых нет в регионе/строке/столбце
по сути эта проверка является самодостаточной, т.к. мы уже отсекли недопустимые значения
при формировании таблицы #SudokuVariant
*/
WHERE NOT EXISTS(
SELECT *
FROM #SudokuVariant i
WHERE i.CellNo<@NextCellNo -- выше проверять нет смысла
--AND t.VariantPath LIKE '%'+i.ID+'%'
AND CHARINDEX(i.ID,t.VariantPath)>0 -- такой вариант в данном случае чуть-чуть быстрее
AND (i.RegionID=v.RegionID OR i.RowID=v.RowID OR i.ColID=v.ColID)
AND i.Value=v.Value
)
/*
т.к. полный путь у нас сохраняется в VariantPath,
то данные предыдущего уровня можно удалить
хотя по замерам, из-за дополнительной операции мы больше теряем по времени
*/
--DELETE #SudokuTree WHERE CellNo=@CurrCellNo
-- перемещаемся на уровень выше
SET @CurrCellNo+=1
SET @NextCellNo+=1
END
--SELECT * FROM #SudokuTree WHERE CellNo=@MaxCellNo
-- заполняем поле найдеными значениями
INSERT SudokuField(CellID,Value)
SELECT v.CellID,v.Value
FROM #SudokuVariant v
JOIN
(
-- если решений получилось несколько, берем самое первое
SELECT TOP 1 *
FROM #SudokuTree
WHERE CellNo=@MaxCellNo -- если промежуточные записи не удаляли
) r
ON r.VariantPath LIKE '%'+v.ID+'%'
-- удаляем временные таблицы
DROP TABLE #SudokuTree
DROP TABLE #SudokuVariant
-- выводим общее время выполнения поиска
PRINT 'Время выполнения - '+CONVERT(varchar(30),DATEADD(MS,DATEDIFF(MS,@StartTime,SYSDATETIME()),'19000101'),114);
```
**Посмотрим, на найденное решение:**
```
-- вид поля после заполнения
SELECT
ISNULL([1],'') [1],
ISNULL([2],'') [2],
ISNULL([3],'') [3],
ISNULL([4],'') [4],
ISNULL([5],'') [5],
ISNULL([6],'') [6],
ISNULL([7],'') [7],
ISNULL([8],'') [8],
ISNULL([9],'') [9]
FROM
(
SELECT c.RowID,c.ColID,f.Value
FROM SudokuCell c
LEFT JOIN SudokuField f ON f.CellID=c.ID
) q PIVOT(MAX(Value) FOR ColID IN([1],[2],[3],[4],[5],[6],[7],[8],[9])) p
ORDER BY RowID
```
**Другие примеры решения:**
Для задания начальных значений использовались следующие скрипты:
**Посмотреть скрипт...**Второй пример:
```
-- предварительная очистка поля, на тот случай если оно заполнено
TRUNCATE TABLE SudokuField
GO
-- заполнение поля известными цифрами
INSERT SudokuField(CellID,Value)VALUES
(1112,'7'),(1113,'1'),(1131,'4'),(1132,'9'),
(1212,'9'),(1221,'3'),(1223,'6'),
(1311,'8'),(1331,'7'),(1333,'5'),
(2112,'1'),(2121,'9'),(2123,'2'),
(2211,'9'),(2233,'8'),
(2321,'6'),(2323,'3'),(2332,'2'),
(3111,'8'),(3113,'5'),(3133,'7'),
(3221,'6'),(3223,'7'),(3232,'4'),
(3312,'7'),(3313,'6'),(3331,'3'),(3332,'5')
GO
```
Третий пример:
```
-- предварительная очистка поля, на тот случай если оно заполнено
TRUNCATE TABLE SudokuField
GO
-- заполнение поля известными цифрами
INSERT SudokuField(CellID,Value)VALUES
(1132,'4'),
(1221,'9'),(1223,'4'),(1231,'8'),(1233,'5'),
(1311,'7'),(1321,'2'),(1323,'3'),
(2113,'7'),(2121,'9'),(2133,'3'),
(2212,'1'),
(2311,'6'),(2332,'5'),(2333,'2'),
(3111,'6'),(3112,'2'),(3121,'7'),
(3223,'3'),(3233,'8'),
(3323,'9')
GO
```
**На моем компьютере решение находится в пределах 6 секунд (в зависимости от заданных начальных значений):**
* Пример 1: 4.547 сек.
* Пример 2: 5.317 сек.
* Пример 3: 3.690 сек.
**Собственно, все.**
Полный скрипт можно скачать по следующей ссылке – [скрипт](http://buhgalter-online.kz/files/sql/sudoku.sql).
Надеюсь, что статья была интересна.
Удачи и спасибо за внимание!
PS (04.12.2015)
===============
Переписал [Oracle-запрос](https://technology.amis.nl/2009/10/13/oracle-rdbms-11gr2-solving-a-sudoku-using-recursive-subquery-factoring/) на MS SQL:
```
WITH x AS(
SELECT
s,
CHARINDEX(' ',s) ind -- индекс первой пустой ячейки
--FROM (SELECT ' 15 34 89 3 2 6 8 47 9 9 2 11 2 5 9 74' s) q
--FROM (SELECT ' 71 9 8 3 6 49 7 5 1 9 9 2 6 3 8 2 8 5 76 6 7 7 4 35 ' s) q
FROM (SELECT ' 7 9 42 3 4 8 5 7 1 6 9 3 5262 7 3 9 8 ' s) q
UNION ALL
SELECT
CAST(STUFF(s,ind,1,z) AS varchar(81)), -- прописываем на место пустой ячейки подходящие цифры
CHARINDEX(' ',s,ind+1) -- индекс следующей пустой ячейки
FROM x
CROSS JOIN (VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9)) v(z)
WHERE ind>0
AND NOT EXISTS(
SELECT *
FROM (VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9)) v(lp)
WHERE z=SUBSTRING(s,(ind-1)/9*9+lp,1)
OR z=SUBSTRING(s,(ind-1)%9-8+lp*9,1)
OR z=SUBSTRING(s,((ind-1)/3)%3*3+(ind-1)/27*27+lp+(lp-1)/3*6,1)
)
)
SELECT s
FROM x
WHERE ind=0
```
**Посмотреть Oracle-запрос...**
```
with x( s, ind ) as
( select sud, instr( sud, ' ' )
--from ( select ' 15 34 89 3 2 6 8 47 9 9 2 11 2 5 9 74' sud from dual )
--from ( select ' 71 9 8 3 6 49 7 5 1 9 9 2 6 3 8 2 8 5 76 6 7 7 4 35 ' sud from dual )
from ( select ' 7 9 42 3 4 8 5 7 1 6 9 3 5262 7 3 9 8 ' sud from dual )
union all
select substr( s, 1, ind - 1 ) || z || substr( s, ind + 1 )
, instr( s, ' ', ind + 1 )
from x
, ( select to_char( rownum ) z
from dual
connect by rownum <= 9
) z
where ind > 0
and not exists ( select null
from ( select rownum lp
from dual
connect by rownum <= 9
)
where z = substr( s, trunc( ( ind - 1 ) / 9 ) * 9 + lp, 1 )
or z = substr( s, mod( ind - 1, 9 ) - 8 + lp * 9, 1 )
or z = substr( s, mod( trunc( ( ind - 1 ) / 3 ), 3 ) * 3
+ trunc( ( ind - 1 ) / 27 ) * 27 + lp
+ trunc( ( lp - 1 ) / 3 ) * 6
, 1 )
)
)
select s
from x
where ind = 0
```
**На моем компьютере по времени выполнения MS SQL намного обогнал Oracle:**
* Пример 1: Oracle — 1.079 сек., MS SQL — 0.303 сек.
* Пример 2: Oracle — 2.991 сек., MS SQL — 0.787 сек.
* Пример 3: Oracle — 3.037 сек., MS SQL — 0.773 сек.
Версия Oracle — 11g Enterprise Edition Release 11.2.0.1.0 — 64bit Production
Версия MS SQL — 2014 — 12.0.2269.0 (X64) Developer Edition (64-bit) | https://habr.com/ru/post/272373/ | null | ru | null |
# Карта средств защиты ядра Linux
Защита ядра Linux — очень сложная предметная область. Она включает большое количество сложно взаимосвязанных понятий, и было бы полезным иметь ее графическое представление. Поэтому я разработал [карту средств защиты ядра Linux](http://github.com/a13xp0p0v/linux-kernel-defence-map). Вот легенда:
Итак, карта содержит следующие объекты:
* классы уязвимостей;
* техники их эксплуатации для проведения атак;
* механизмы выявления ошибок;
* технологии защиты.
В свою очередь технологии защиты ядра разнородны. Одни входят в состав ванильного ядра Linux, другие поставляются отдельно по различным причинам (например, есть коммерческие средства обеспечения безопасности). Существуют механизмы защиты ядра, которые требуют поддержки аппаратного обеспечения.
Таким образом, тема безопасности ядра Linux достаточно обширна, и разработанная карта помогает в ее изучении и анализе. Каждая линия, соединяющая объекты на карте, обозначает их взаимное влияние, суть которого следует выяснять в документации. Данный принцип может быть проиллюстрирован на фрагменте общей карты. На схеме 1 представлены свойства безопасности технологии STACKLEAK.
*Схема 1. Свойства безопасности технологии STACKLEAK*
PAX\_MEMORY\_STACKLEAK — это коммерческая технология защиты ядра Linux, противодействующая эксплуатации следующих типов уязвимостей: переполнение стека в глубину, использование неинициализированных переменных и утечка информации в пользовательское пространство. Карта содержит идентификаторы данных классов уязвимостей (CWE, Common Weakness Enumeration).
Технология [STACKLEAK](https://habr.com/ru/company/pt/blog/424633/) была привнесена в ванильное ядро Linux, что отражено на схеме. Есть также механизм отладки KMSAN, позволяющий обнаружить при тестировании ядра использование неинициализированных переменных и утечку информации в пользовательское пространство.
Стоит отметить, что данная карта не затрагивает вопрос уменьшения периметра атаки для ядра. В сущности, отключение почти любого функционала, уменьшающее размер исполняемого файла, сокращает и периметр атаки. А в данном проекте основное внимание направлено на средства безопасности, обеспечивающие самозащиту ядра Linux против эксплуатации уязвимостей.
На схеме 2 представлена полная карта для ядра версии 5.1 (по клику изображение откроется в полном размере).
[](https://github.com/a13xp0p0v/linux-kernel-defence-map/blob/master/linux-kernel-defence-map.svg)
*Схема 2. Карта средств защиты ядра Linux v5.1*
Карта постоянно развивается, ее нужно обновлять как минимум каждый релиз ядра. Поэтому удобно иметь исходник в текстовом виде и вести его в системе контроля версий. Кроме того, чтобы не приходилось вручную расставлять объекты с минимальным количеством пересечений связей, для создания карты был выбран язык DOT, а схема автоматически генерируется пакетом GraphViz с помощью следующей команды:
```
dot -Tsvg linux-kernel-defence-map.dot -o linux-kernel-defence-map.svg
```
Карта средств защиты ядра Linux — это открытый проект, лицензированный согласно GPL v3.0. Репозиторий расположен [на GitHub](http://github.com/a13xp0p0v/linux-kernel-defence-map). Данный проект крайне полезен для:
* отслеживания актуального состояния безопасности ядра,
* разработки моделей угроз ИС на базе GNU/Linux,
* выбора соответствующих средств защиты.
Кроме того, карта средств защиты ядра Linux призвана помочь в изучении исходного кода, документации и других источников информации по данной теме:
* [Свойства безопасности grsecurity](https://grsecurity.net/features.php)
* [Документация по безопасности в исходниках ядра Linux](https://www.kernel.org/doc/html/latest/security/self-protection.html)
* [Документация Kernel Self Protection Project](http://www.kernsec.org/wiki/index.php/Kernel_Self_Protection_Project)
* [Текущий статус переноса функций grsecurity в Android Open Source Project](https://github.com/hardenedlinux/grsecurity-101-tutorials/blob/master/kernel_mitigation.md)
* [Обзор тенденций в безопасности ОС от исследовательского центра Microsoft (MSRC)](https://github.com/Microsoft/MSRC-Security-Research/tree/master/presentations/2019_02_BlueHatIL)
* [Модель угроз Linux Kernel Runtime Guard (LKRG)](https://openwall.info/wiki/p_lkrg/Threat_model)
А для автоматизации проверки опций безопасности в конфигурационном файле ядра Linux я создал проект [kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check), который активно развивается благодаря открытой коллективной работе. Утилита поддерживает архитектуры x86\_64, arm64, x86\_32 и arm.
Приглашаю к участию в разработке [карты средств защиты ядра Linux](http://github.com/a13xp0p0v/linux-kernel-defence-map) и утилиты [kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check). | https://habr.com/ru/post/457460/ | null | ru | null |
# Учимся готовить: Spring 3 MVC + Spring Security + Hibernate
Добрый день! Меня зовут Антон Щастный.
Это моя очередная статья, посвящённая разработке веб приложений на Java. Хочу предложить вам сделать небольшую систему учёта клиентов, написанную с использованием фреймворка Spring и библиотеки Hibernate.
### Что будет в приложении:
Будет простой менеджер контактов, позволяющий добавлять в базу новые записи, просматривать имеющиеся, удалять ненужные. Сведения будут храниться в базе данных. Доступ к приложению – через веб, с аутентификацией и авторизацией пользователей.
### Что будем использовать:
* веб фреймворк Spring MVC,
* фреймворк Spring Security,
* ORM библиотеку Hibernate,
* MySQL в качестве СУБД.
Инфраструктура:
* редактор SpringSource Tool Suite,
* сборщик проектов Maven,
* система логгирования Log4j,
* постоянное подключение к интернету.
В моей [предыдущей статье о Spring MVC](http://habrahabr.ru/blogs/java2ee/83860/) был упущен ряд моментов по использованию аннотаций в Java-коде и применению Maven для сборки проекта. В данной статье я попытался исправить упущение.
*Цель статьи – показать начинающим веб разработчикам совместное использование различных технологий платформы Java.*
Содержание
==========
1. Создание нового проекта в IDE.
2. Создание структуры пакетов.
3. Добавление класса сущности в модель домена.
4. Слой доступа к данным.
5. Сервис-слой.
6. Добавление веб.
7. Контроллер.
8. Вид.
9. Запуск приложения.
10. Безопасность.
11. Заключение.
Архитектура разрабатываемого приложения.
1. Создание нового проекта в IDE
================================
Проект будем разрабатывать в [SpringSource Tool Suite](http://www.springsource.com/developer/sts) (STS) – удобном редакторе, основанном на Eclipse IDE.
После установки STS создадим шаблонный проект:
*File > New > Spring Template Project > Spring MVC Project.*
Project name: *ContactManager*
Top level package: *net.schastny.contactmanager*
Редактор создаст шаблонный веб проект с базовыми настройками, имеющий следующую структуру:
| | |
| --- | --- |
| src/main/java | Java-классы приложения. |
| src/main/resources | Все остальные файлы (ресурсы), необходимые для работы: например файл настроек логгера *log4j.xml*, папка *META-INF*. |
| src/test/java | Папка для тестов JUnit. |
| src/test/resources | Папка ресурсов юнит-тестов. |
| src/main/webapp | Папка, в которой размещаются файлы веб составляющей менеджера контактов: дескриптор развёртывания приложения web.xml, xml-файлы с настройками фреймворка Spring, jsp-страницы.
*Внимание, статические ресурсы приложения: картинки, css, js-скрипты лежат в папке resources.* |
| pom.xml | Файл настроек проекта для Maven’а, содержит наименование проекта и перечень зависимостей проекта от сторонних библиотек. |
Поменяем в настройках проекта (pom.xml) версию Spring с *3.0.4.RELEASE* на *3.0.5.RELEASE*.
Примечание: как создавать Maven-проекты вне IDE читайте [здесь](http://habrahabr.ru/blogs/java/77382/).
2. Создание структуры пакетов
=============================
| | |
| --- | --- |
| net.schastny.contactmanager.dao | **Слой доступа к данным.**
В нём будем размещать Data Access Objects – объекты доступа к данным. |
| net.schastny.contactmanager.domain | **Доменный слой.**
Именно здесь лежат POJO-классы, описывающие объекты-сущности системы. В нашем случае это класс Contact. |
| net.schastny.contactmanager.service | **Сервис-слой приложения.**
Содержит интерфейсы, в которых описан функционал приложения. Также содержит одну или несколько практических реализаций этих интерфейсов. |
| net.schastny.contactmanager.web | **Веб-слой приложения.**
Здесь лежат классы-контроллеры, описывающие порядок взаимодействия пользователя с системой через веб. |
Примечание: класс-контроллер, созданный редактором, можно удалить.
3. Добавление класса сущности в модель домена
=============================================
```
package net.schastny.contactmanager.domain;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "CONTACTS")
public class Contact {
@Id
@Column(name = "ID")
@GeneratedValue
private Integer id;
@Column(name = "FIRSTNAME")
private String firstname;
@Column(name = "LASTNAME")
private String lastname;
@Column(name = "EMAIL")
private String email;
@Column(name = "TELEPHONE")
private String telephone;
// Getters and setters
}
```
Не забудьте добавить методы геттеры и сеттеры для свойств бина.
Добавим зависимости проекта в файл *pom.xml*. Обратите внимание, что класс из модели домена не будет зависить ни от Спринга, ни от Хибернейта.
```
javax.persistence
persistence-api
1.0
```
Пояснение к использованным аннотациям.
| | |
| --- | --- |
| `@Entity` | Класс представляет объект, который нужно долговременно хранить. |
| `@Table(name = "CONTACTS")` | Свойства класса будем хранить в таблице CONTACTS. |
| `@Column(name = "FIRSTNAME")` | Это свойство будет храниться в столбце firstname. |
| `@Id` | Это поле уникальное для объектов, то есть по нему будем искать объекты. |
| `@GeneratedValue` | Значение этого поля будет назначаться не нами, а генерироваться автоматически. |
4. Слой доступа к данным
========================
Интерфейс и практическая реализация объекта доступа к данным.
```
package net.schastny.contactmanager.dao;
import java.util.List;
import net.schastny.contactmanager.domain.Contact;
public interface ContactDAO {
public void addContact(Contact contact);
public List listContact();
public void removeContact(Integer id);
}
```
```
package net.schastny.contactmanager.dao;
import java.util.List;
import net.schastny.contactmanager.domain.Contact;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class ContactDAOImpl implements ContactDAO {
@Autowired
private SessionFactory sessionFactory;
public void addContact(Contact contact) {
sessionFactory.getCurrentSession().save(contact);
}
@SuppressWarnings("unchecked")
public List listContact() {
return sessionFactory.getCurrentSession().createQuery("from Contact")
.list();
}
public void removeContact(Integer id) {
Contact contact = (Contact) sessionFactory.getCurrentSession().load(
Contact.class, id);
if (null != contact) {
sessionFactory.getCurrentSession().delete(contact);
}
}
}
```
Обновим зависимости проекта в файле *pom.xml*. Добавим Хибернейт.
```
org.hibernate
hibernate-core
3.3.2.GA
org.hibernate
hibernate-annotations
3.3.1.GA
org.hibernate
hibernate-commons-annotations
3.3.0.ga
```
Пояснение к использованным аннотациям.
| | |
| --- | --- |
| `@Repository` | Аннотация показывает, что класс функционирует как репозиторий и требует наличия прозрачной трансляции исключений. Преимуществом трансляции исключений является то, что слой сервиса будет иметь дело с общей иерархией исключений от Спринга (DataAccessException) вне зависимости от используемых технологий доступа к данным в DAO слое. |
| `@Autowired` | Аннотация позволяет автоматически установить значение поля SessionFactory. |
5. Сервис-слой
==============
Опишем интерфейс взаимодействия пользователя с системой.
```
package net.schastny.contactmanager.service;
import java.util.List;
import net.schastny.contactmanager.domain.Contact;
public interface ContactService {
public void addContact(Contact contact);
public List listContact();
public void removeContact(Integer id);
}
```
Практическая реализация интерфейса сервиса – класс ContactServiceImpl.java.
```
package net.schastny.contactmanager.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import net.schastny.contactmanager.dao.ContactDAO;
import net.schastny.contactmanager.domain.Contact;
@Service
public class ContactServiceImpl implements ContactService {
@Autowired
private ContactDAO contactDAO;
@Transactional
public void addContact(Contact contact) {
contactDAO.addContact(contact);
}
@Transactional
public List listContact() {
return contactDAO.listContact();
}
@Transactional
public void removeContact(Integer id) {
contactDAO.removeContact(id);
}
}
```
Обновим зависимости проекта в файле *pom.xml*. Добавим поддержку транзакций.
```
org.springframework
spring-tx
${org.springframework-version}
org.springframework
spring-orm
${org.springframework-version}
```
Пояснение к использованным аннотациям.
| | |
| --- | --- |
| @Service | Мы используем данную аннотацию, чтобы объявить, что этот класс представляет сервис – компонент сервис-слоя. Сервис является подтипом класса @Component. Использование данной аннотации позволит искать бины-сервисы автоматически (смотрите далее в root-context.xml). |
| @Transactional | Перед исполнением метода помеченного данной аннотацией начинается транзакция, после выполнения метода транзакция коммитится, при выбрасывании RuntimeException откатывается. |
6. Добавление веб
=================
Настройку веб приложения начнём с самого главного – с тьмы xml-файлов. В большом приложении очень удобно хранить различные настройки в разных файлах.
После xml-портянок напишем простенький контроллер.
Файлы настроек вы можете найти по ссылкам ниже.
| | |
| --- | --- |
| [web.xml](https://raw.github.com/schastny/habraposts/master/111102/web.xml) | Это **дескриптор развертывания**. Файл, который описывает настройки развертывания приложения на сервере. |
| [spring/root-context.xml](https://raw.github.com/schastny/habraposts/master/111102/root-context.xml) | **Root Context**. Контекст всего приложения. Бины, описанные здесь, будут доступны всем сервлетам и фильтрам. Также здесь следует описывать бины безопасности и доступа к данным (в нашей конфигурации они вынесены в отдельные файлы). |
| [spring/data.xml](https://raw.github.com/schastny/habraposts/master/111102/data.xml) | Файл с настройками **ресурсов для работы с данными**. |
| spring/security.xml | Файл с **настройками безопасности**. |
| [spring/appServlet/servlet-context.xml](https://raw.github.com/schastny/habraposts/master/111102/servlet-context.xml) | **DispatcherServlet Context**. Определяет настройки одного сервлета и бины, которые доступны только этому сервлету. |
| [spring/appServlet/controllers.xml](https://raw.github.com/schastny/habraposts/master/111102/controllers.xml) | Файл с настройками **контроллеров** для данного сервлета. |
spring/security.xml
```
```
Пояснение к используемым бинам.
| | |
| --- | --- |
| messageSource | Бин для обеспечения интернациолизации приложения. Ниже мы создадим файлы **messages\_en.properties** и **messages\_ru.properties** с локализованными сообщениями на русском и английском. |
| propertyConfigurer | Для загрузки файла с настройками БД **jdbc.properties**. |
| dataSource | **Датасорс**, используется для подключения к БД. Мы предоставляем класс jdbc-драйвера, имя пользователя, пароль, другие настройки. |
| sessionFactory | Это бин конфигурации Хибернейта. В файле **hibernate.cfg.xml** будут содержаться маппинги на классы сущностей. |
| transactionManager | Бин настройки **менеджера транзакций**. Мы используем менеджер транзакций для управления транзакциями приложения. |
Файлы:
[/src/main/resources/messages\_en.properties](https://raw.github.com/schastny/habraposts/master/111102/messages_en.properties)
[/src/main/resources/messages\_ru.properties](https://raw.github.com/schastny/habraposts/master/111102/messages_ru.properties)
[/src/main/resources/hibernate.cfg.xml](https://raw.github.com/schastny/habraposts/master/111102/hibernate.cfg.xml)
[WEB-INF/jdbc.properties](https://raw.github.com/schastny/habraposts/master/111102/jdbc.properties)
7. Контроллер
=============
```
package net.schastny.contactmanager.web;
import java.util.Map;
import net.schastny.contactmanager.domain.Contact;
import net.schastny.contactmanager.service.ContactService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
@Controller
public class ContactController {
@Autowired
private ContactService contactService;
@RequestMapping("/index")
public String listContacts(Map map) {
map.put("contact", new Contact());
map.put("contactList", contactService.listContact());
return "contact";
}
@RequestMapping("/")
public String home() {
return "redirect:/index";
}
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String addContact(@ModelAttribute("contact") Contact contact,
BindingResult result) {
contactService.addContact(contact);
return "redirect:/index";
}
@RequestMapping("/delete/{contactId}")
public String deleteContact(@PathVariable("contactId") Integer contactId) {
contactService.removeContact(contactId);
return "redirect:/index";
}
}
```
Пояснение к использованным аннотациям.
| | |
| --- | --- |
| @Controller | Аннотация используется для магического превращения любого java класса в класс контроллера.
Данный класс представляет собой компонент, похожий на *обычный сервлет (HttpServlet)* (работающий с объектами HttpServletRequest и HttpServletResponse), но с расширенными возможностями по применению в MVC-приложениях. |
| @RequestMapping | Аннотация используется для маппинга урл-адреса запроса на указанный метод или класс. Запрос можно маппить как на метод класса, так и на целый класс. Допускается указывать конкретный HTTP-метод, который будет обрабатываться (GET/POST), передавать параметры запроса. |
| @ModelAttribute | Аннотация, связывающая параметр метода или возвращаемое значение метода с атрибутом модели, которая будет использоваться при выводе jsp-страницы. |
| @PathVariable | Аннотация, которая показывает, что параметр метода должен быть связан с переменной из урл-адреса. |
8. Вид
======
[/src/main/webapp/WEB-INF/views/contact.jsp](https://raw.github.com/schastny/habraposts/master/111102/contact.jsp)
9. Запуск приложения
====================
До запуска системы нам необходимо сделать ещё две вещи:
Во-первых, создать **базу данных для приложения** и пользователя под неё в соответствии с настройками файла *jdbc.properties*:
```
CREATE USER contactmanager@localhost identified BY '1234';
GRANT usage ON *.* TO contactmanager@localhost identified BY '1234';
CREATE DATABASE IF NOT EXISTS contactmanager;
GRANT ALL privileges ON contactmanager.* TO contactmanager@localhost;
USE contactmanager;
CREATE TABLE CONTACTS
(
id INT PRIMARY KEY AUTO_INCREMENT,
firstname VARCHAR(30),
lastname VARCHAR(30),
telephone VARCHAR(15),
email VARCHAR(30),
created TIMESTAMP DEFAULT NOW()
);
```
Во-вторых, обновить зависимости в *pom.xml*.
```
mysql
mysql-connector-java
5.1.6
```
Теперь запустим приложение на сервере: *ContactManager > Run As > Run on Server > SpringSource tc Server Developer Edition v2.0*.
Откройте адрес <http://localhost:8080/ContactManager> в браузере.
Примечание: Проверьте кодировку базы данных, таблиц в БД, соединения с БД, кодировку проекта в редакторе, так как вместо родных кириллических букв в браузере могут появиться кракозябры.
Для отладки работы Хибернейта можете в файл *src/main/resources/log4j.xml* добавить следующую строку:
```
```
10. Безопасность
================
Обновим зависимости проекта в файле *pom.xml*. Добавим модули Spring Security.
```
org.springframework.security
spring-security-web
${org.springframework-version}
org.springframework.security
spring-security-config
${org.springframework-version}
org.springframework.security
spring-security-core
${org.springframework-version}
```
Добавим в *web.xml* фильтр безопасности, действующий на всё приложение.
```
springSecurityFilterChain
org.springframework.web.filter.DelegatingFilterProxy
springSecurityFilterChain
/\*
```
В целях безопасности страницу логина *не следует помещать внутри папки WEB-INF*, так что разместим её в корне веб приложения – в папке webapp.
[webapp/login.jsp](https://raw.github.com/schastny/habraposts/master/111102/login.jsp)
Там же разместим страницу ошибки 403: [webapp/error403.jsp](https://raw.github.com/schastny/habraposts/master/111102/error403.jsp)
Подредактируем файл security.xml.
[security.xml](https://raw.github.com/schastny/habraposts/master/111102/security.xml)
#### Пояснение к сделанным настройкам в файле security.xml
Выделим в приложении три группы пользователей (роли пользователей):
* анонимный пользователь (ROLE\_ANONYMOUS),
* просто пользователь (ROLE\_USER),
* администратор (ROLE\_ADMIN).
Разграничим доступ к приложению:
* Сделаем возможность просматривать контакты доступной всем категориям пользователей.
* Добавлять новые контакты смогут только зарегистрированные пользователи.
* Удалять записи сможет только админ.
#### Где хранить данные о пользователях
Можно прямо в конфигурационном файле, если их немного. Можно в базе данных, можно в LDAP-хранилище.
Пример записи (*security.xml*) при использовании БД для хранения паролей.
```
```
Пояснения к некоторым элементам.
| | |
| --- | --- |
| | Поддержка мультисессии. После повторного запуска браузера не нужно заново логиниться. |
| | Определение анонимного пользователя и наделение его ролями, так чтобы с ним можно было работать, как с обыкновенным пользователем приложения. |
| | Хранение паролей в зашифрованном виде.
В нашем приложении не используется. |
11. Заключение
==============
Вот и всё! Осталось прикрутить дизайн, рюшечки на jQuery ([статья для начинающих](http://anton.shevchuk.name/javascript/jquery-for-beginners/)) и продавать поделку за деньги. Но это, дорогие мои читатели, уже совсем другая история.
После выполнения всех манипуляций у вас должна получиться следующая структура проекта:
Буду признателен за указанные ошибки и неточности в статье.
#### Использованные ресурсы:
1. Spring Recipes: A Problem-Solution Approach, Second Edition, Gary Mak, Ken Sipe, Josh Long, Daniel Rubio.
2. [Create Spring 3 MVC Hibernate 3 Example using Maven in Eclipse](http://viralpatel.net/blogs/2010/11/spring3-mvc-hibernate-maven-tutorial-eclipse-example.html),
3. The Spring Framework Reference Documentation,
4. [Mastering Spring MVC 3 by Keith Donald](https://src.springframework.org/svn/spring-samples/mvc-showcase/MasteringSpringMVC3.pdf).
Скачать готовый проект можно [здесь](https://raw.github.com/schastny/habraposts/master/111102/contactmanager.tar.gz), а базу данных для проекта — [здесь](https://raw.github.com/schastny/habraposts/master/111102/contactmanagerdb.tar.gz). | https://habr.com/ru/post/111102/ | null | ru | null |
# Combustion — альтернативный подход к тестированию Rails Engines
*Сегодня мы предоставим вашему вниманию перевод поста Пета Аллана (Pat Allan), известного разработчика, приверженца Ruby, одного из победителей Ruby Hero Award 2009 года. Что это за награда? Она присуждается победителями прошлого года тем участникам сообщества, которые наиболее проявили себя: создали значимый обучающий контент, разработали плагины и гемы, участвовали в проектах с открытым кодом. Такая награда была создана для того, чтобы отметить наиболее проявивших себя людей и дать им признание, которое они заслуживают.
Пообщаться со Петом можно будет на конференции [RubyC](http://rubyc.eu) в Киеве 5-6 ноября этого года.*
Значительную часть прошлого месяца я провел за написанием моего первого Rails engine — тем не менее я не закончил, да и сама работа была для клиента, так, что на деталях останавливаться я не могу.
В процессе разработки довольно быстро стало ясно, что необходим способ тестировать Rails engine. Не беря во внимание простейшие unit-тесты, довольно привычная практика для интеграционного тестирования — хранить копию приложения на рельсах внутри директории `spec` или `test`.
Такой подход показался мне тяжелым и ненадежным, поэтому я решил попробовать кое-что другое.
Целью было организовать всестороннее тестирование в простом и понятном виде: написание тестов внутри моей собственной spec директории, а не упаковка их в директорию spec, рядом с Rails-приложением, над которым проводится тестирование. Кроме того, было бы не плохо воспользоваться `Capybara DSL`.
Конечно, необходимо было настоящее приложение на Rails, на базе которого проводилось бы тестирование, но, как выяснилось, от большей части файлов приложения, генерируемого рельсами, можно избавиться. И действительно — единственный файл, который необходим Rails, это `config/database.yml` — и то только в том случае, если вам нужно использовать ActiveRecord.
Добро пожаловать в [Combustion](https://github.com/freelancing-god/combustion) — мое минимальное приложение-библиотека для тестирования engines, со всеми значениями по умолчанию, взятыми для типичного приложения на Rails.
##### Настраиваемся
Типичная настройка/установка выглядит следующим образом:
* добавте гем в ваш `Gemfile` (и выполните команду `bundle` — прим. пер.);
* запустите генератор в директории вашего Rails engine для того чтобы создать заглушку приложения Rails: `combust` (или `bundle exec combust`, если в гемфайле вы используете репозиторий гит);
* добавте `Combustion.initialize!` в `spec/spec_helper.rb` (пока поддерживается только `RSpec`, но если нужно для `TestUnit` — проблем с патчем возникнуть не должно).
Вот типичный `spec_helper.rb`, учитывая `Capybara`:
```
require 'rubygems'
require 'bundler'
Bundler.require :default, :development
require 'capybara/rspec'
Combustion.initialize!
require 'rspec/rails'
require 'capybara/rails'
RSpec.configure do |config|
config.use_transactional_fixtures = true
end
```
##### Заставляем всё работать
Прежде всего, вам нужно убедиться, что вы используете Rails engine внутри приложения Rails. Генератор должен был добавить нужные хуки, которые нам как-раз для этого понадобятся. Если вам нужно добавить роуты, отредактируйте `spec/internal/config/routes.rb`. Если вам нужны модели, убедитесь, что добавили их в `spec/internal/db/schema.rb`. Чуть более детально всё описано в [README](https://github.com/freelancing-god/combustion/blob/master/README.textile).
Всё, самое время приступить к написанию тестов! Вот небольшой пример:
```
# spec/controllers/users_controller_spec.rb
require 'spec_helper'
describe UsersController do
describe '#new' do
it "runs successfully" do
get :new
response.should be_success
end
end
end
```
Или используя `Capybara` для интеграционного теста:
```
# spec/acceptance/visitors_can_sign_up_spec.rb
require 'spec_helper'
describe 'authentication process' do
it 'allows a visitor to sign up' do
visit '/'
click_link 'Sign Up'
fill_in 'Name', :with => 'Pat Allan'
fill_in 'Email', :with => 'pat@no-spam-please.com'
fill_in 'Password', :with => 'chunkybacon'
click_button 'Sign Up'
page.should have_content('Sign Out')
end
end
```
##### Поворачиваем ключ
Ах да, а вот и один из моих самых любимых хелперов: генератор `Combustion` добавляет файл `config.ru` к вашему engine, что означает следующее: вы можете запустить ваше тестовое приложение в браузере — достаточно запустить `rackup` и перейти по адресу `localhost:9292`.
##### Некоторые оговорки
Как уже было сказано, `Combustion` создан для `RSpec`, но я с радостью приму патчи для `TestUnit`. Это же касается и `Cucumber`'а — в теории должно работать, но я не проверял.
Кроме того, гем написан для Rails 3.1 — он должен работать с Rails 3.0 после нескольких патчей, но я сильно сомневаюсь, что заработает с чем-то до 3.0. Тем не менее, не стесняйтесь исследовать.
Так же есть вероятность, что для гем пригодится для интеграционного тестирования библиотек, которые не являются engine'ами. Если вы захотите это проверить — я с радостью поинтересуюсь как продвигается процесс.
##### Заключение
Что ж, давайте посмотрим куда нас занесло.* вы можете тестировать ваши engines на минимально необходимом приложении Rails;
* в ваше Rails приложение вы добавляете только то, что нужно для тестирования;
* ваш тестировый код гораздо чище (привет, DRY!) и его проще поддерживать;
* вы можете использовать стандатные хелперы им. `RSpec` и `Capybara` для интеграционного тестирования;
* благодаря `Rack`, вы можете вживую просматривать ваше тестовое приложение.
Я не первый кому пришла подобная идея — после того как я окончил работу над Combustion, мне указали на тестовую оболочку для [Kaminari](https://github.com/amatsuda/kaminari), которая выполняет ту же функцию (просто она не была вынесена в отдельную библиотеку). Я не удивлюсь, если кто-то другой сделал то же самое — но когда я искал похожие, постоянно натыкался на известные библиотеки, которые шли вместе с полным приложением на рельсах внутри их директорий test или spec.
Если вам кажется что Combustion может украсить ваш engine, пробуйте — поиск ошибок и прибавление уверенности в том что гем работает на более широком спектре задач только приветствуется. Патчи и отзывы приветствуются однозначно. | https://habr.com/ru/post/128794/ | null | ru | null |
# Разбираемся что MySQL пишет на диск и зачем [часть 1]
### Оглавление
1. Double Write buffer и Binlogs [эта статья]
2. Redo logs и общая картина [<https://habr.com/ru/post/699342/>]
> **Disclaimer:** автор не является разработчиком MySQL, все нижеописанное может не совпадать с реальным положением дел.
>
>
Часть 0: Размышления о хранении данных
--------------------------------------
Разработчики предъявляют высокие требования к базам данных: максимальная надежность (ничего из того, что было записано не должно быть утеряно ни при каких обстоятельствах), и, одновременно, максимальная производительность при различных видах нагрузки (Запись/Чтение или OLTP/OLAP). Достичь этих требований может быть не просто. Давайте попробуем разобраться, как это делает MySQL.
Размышляя о базе данных, легко представить таблицу базы данных как HashMap/BinaryTree, отображающие первичный ключ (primary key) в структурированные записи с данными. Такое хранилище может работать in memory. Но, как только мы захотим записать данные на диск, придется использовать какие-то алгоритмы во внешней памяти. Просто положить наш HashMap на диск не получится, потому что память и диски слишком разные: чтение/запись диска производится блоками, latency диска больше чем у RAM, а еще нельзя будет воспользоваться обычными указателями и аллокаторами памяти — все это придется заменить самостоятельно.
> Почему MMAP не лучший выход: Are You Sure You Want to Use MMAP in Your Database Management System? <https://www.cidrdb.org/cidr2022/papers/p13-crotty.pdf>
>
>
К счастью, давно уже придуманы структуры данных и алгоритмы, такие как B+Tree и [LSM Tree](https://ru.wikipedia.org/wiki/LSM-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE), а также бесчисленное количество их вариаций (Подробнее можно прочитать в книге “Database Internals: A Deep Dive into How Distributed Data Systems Work” за авторством Alex Petrov). InnoDB - основной движок хранения MySQL, использует вариацию B+Tree. Данные хранятся в страницах (pages), которые загружаются с диска в buffer pool и при необходимости сохраняются на диск обратно.
Unix-like операционные системы поддерживают разные гарантии записи файла.
* Самым быстрым и заодно ненадежным способом является обычная запись в файл. Операционная система запишет данные в page cache (в память). И уже в фоне запишет данные на диск.
* Если при открытии файла указать флаг O\_DIRECT - то запись в файл будет идти мимо page cache - сразу во внутренний буфер диска. Но при отключении питания сервера - мы все еще можем потерять данные.
* `fsync` — это отдельный системный вызов для сброса данных на диск. На Linux системах `fsync` ожидает записи на физический носитель, а не только во внутренний буфер диска. Факт записи на диск дает гарантии сохранности данных.
* `fdatasync` — так же сбрасывает данные на диск, но не дожидается надежной записи обновленных метаданных файловой системы. Если метаданные изменились, но из-за отказов не были записаны на диск, то при следующем старте, Linux не узнает об этих изменениях (например, о том, что файл был увеличен в размере и туда были записаны данные) - данные будут поломаны.
Часть 1: Double Write Buffer
----------------------------
Страницы с данными в InnoDB по умолчанию занимают 16Кб. Размер страницы — это компромисс. С одной стороны, большие страницы с данными улучшают пропорцию полезных данных к служебным, с другой стороны, большие страницы приводят к бОльшему [write amplification](https://en.wikipedia.org/wiki/Write_amplification): Например, UPDATE одного числа (4 байта) в одной строке приводит к перезаписи всей страницы (килобайты). Разные базы данных выбирают различные размеры страниц: PostgreSQL использует страницы по 8Кб, а MySQL по-умолчанию по 16Кб, но администраторы баз данных при большом желании могут выбрать размер от 4Кб до 64Кб ([innodb\_page\_size](https://dev.mysql.com/doc/refman/8.0/en/innodb-parameters.html#sysvar_innodb_page_size)).
Уже на этом этапе мы сталкиваемся с проблемой атомарности записи данных на диск: современные Linux-based системы не гарантируют атомарность записи блоков размером больше 4Кб.
> Детальное описание состояние дел с атомарностью записи на диск можно найти на StackOverflow. [ <https://stackoverflow.com/a/61832882> ]. Там же героическая история как инженеры Google патчили ядро, драйвера и файловые системы, чтобы атомарно писать блоками по 16Кб.
>
>
Что делает InnoDB, чтобы страницы с данными не побились во время записи? InnoDB пишет их дважды: сначала в doublewrite buffer, и только потом страницы записываются в положенное им место.
Несмотря на название, сам doublewrite buffer не удваивает количество IO операций - страницы в doublewrite buffer пишутся большими блоками и выполняется всего один `fsync()` (да и то, если не используется `IO_DIRECT`). Если в процессе crash-recovery InnoDB найдет “битую” страницу - он сможет достать ее целый вариант из doublewrite buffer.
В старых версиях MySQL, doublewrite buffer занимал [фиксированные 128 страниц](https://blog.jcole.us/2013/01/03/the-basics-of-innodb-space-file-layout/#:~:text=data%20dictionary%20itself.-,Pages%2064%2D127,-%3A%20The%20first%20block) в начале system tablespace (файл `ibdata1`). Запись велась:
* Страницы копировались в doublewrite buffer в памяти.
* Большим блоком записывались в system tablespace. Если не использовался IO\_DIRECT - вызывался `fsync()`.
* Страницы пишутся в нужные места, если не используется IO\_DIRECT - вызывается `fsync()`.
* По завершению всех операций, doublewrite buffer считается пустым и готовым к следующей итерации.
Начиная с версии MySQL 8.0.20, алгоритм был изменен - теперь doublewrite buffer пишется в разные файлы (например, в файл `#ib_16384_0.dblwr` ). Новый подход должен лучше работать на SSD.
Часть 2: Binlogs
----------------
MySQL была спроектирована как база данных, которая может работать с различными движками (storage engines), поэтому MySQL можно разделить на два крупных “слоя” - непосредственно MySQL и различные Storage Engine (на практике это почти всегда InnoDB, реже Memory Engine, но изредка еще встречается MyISAM и MyRocksDB). Из-за этой “двухслойности” у нас есть и явное разделение обязанностей - MySQL занимается обработкой SQL запросов, репликацией (пишет binlogs), а InnoDB отвечает за надежное хранением данных на диске.
Для распространения изменений, записанных на мастере, MySQL использует подход Replicated State Machine (RSM)- все изменения записываются в binlog, и доставляются на реплики. Реплики применяют транзакции к своему текущему состоянию. Если транзакции полностью детерминированы - то в результате на мастере и на репликах получается одинаковое состояние (чего, собственно, мы и ожидаем от базы данных). Как побочный эффект детерминизма - к развернутой из бекапа базе данных можно проигрывать бинлоги и тем самым восстановить базу на любой момент времени (aka Point-in-Time Recovery).
MySQL может писать в binlog как SQL Statements (Statement-based replication), так и просто измененные данные (row-based replication). Для Statment-based replication сложнее гарантировать детерминированность транзакций и совпадение данных, хранящихся на разных хостах.
Binary Log в широком смысле слова - хранилище Binary Log Events (далее “события”). Эти события хранятся в binlog-файлах. Каждый файл начинается с заголовка, содержащего служебную информацию, потом идут события, и в конце пишется rotate event. Кроме этого, MySQL поддерживает Binlog Index, где хранится список всех имеющихся бинлогов.
#### Binlog cache
binlog — это файл, который пишется последовательно, целыми транзакциями. Пока одна транзакция не будет записана полностью, нельзя начинать писать вторую транзакцию. Для того, чтобы одни транзакции не блокировали запись других транзакций, все binlog events пишутся сначала в binlog cache (специальный буффер в памяти каждого потока, выполняющего транзакции) и только в момент коммита записываются уже на диск. В случае отката транзакции - binlog cache очищается, как будто ничего и не было записано в него.
> [**Fun Fact**](https://www.burnison.ca/notes/fun-mysql-fact-of-the-day-binlog-cache-overflow)**:** Если [binlog\_cache\_size](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#sysvar_binlog_cache_size) было недостаточно, MySQL начнет сбрасывать кэш на диск (в новый файл, который сразу после создания будет удален (`unlink`) с файловой системы - т.е. будет “невидим”). Максимальный размер binlog cache на диске настраивается с помощью [max\_binlog\_cache\_size](https://dev.mysql.com/doc/refman/5.6/en/replication-options-binary-log.html#sysvar_max_binlog_cache_size) (по-умолчанию 18 эксабайт!). Хотя, документация говорит, что MySQL не может работать с бинлогами больше 4 Гб: при достижении этого порога будет выброшена ошибка.
>
>
#### Group Commit
Вооружившись знанием о том, что такое binlog, для crash-safe recovery необходимо делать `fsync()` на каждую запись в бинлоге (настройка `sync_binlog = 1`). Ведь, с одной стороны, binlog-и не участвуют в непосредственной записи наших данных на диск, используются в репликации (не очень связанной с хранением ваших данных на диске!) и вообще, бинлоги можно отключить, и база продолжит работать!
Если не скидывать бинлоги на диск - велик шанс что упавший MySQL после восстановления будет неконсистентен с другими репликами (и вам повезет, если вы это заметите сразу). В целом жить с `sync_binlog` отличном от 1 [можно](http://yoshinorimatsunobu.blogspot.com/2014/04/semi-synchronous-replication-at-facebook.html), при условии отказа от crash-recovery и переналивкой упавших хостов. Вы же не ожидаете крэша всех хостов MySQL одной транзакцией или retry-ем одной транзакции по всем хостам :)
Допустим, мы все-таки хотим надежной записи на диск с помощью fsync. Как мы уже знаем, вызов fsync()-а это довольно медленная операция, где мы очень легко можем упереться в IOPS (особенно на HDD дисках). Очевидным решением бутылочного горлышка IOPS-ов является батчинг - на каждый `fsync()` писать не одну транзакцию, а сразу целую группу транзакций. В MySQL такой батчинг называется Group Commit.
> Интересно, что MySQL 5.0 не делал Group Commit, и транзакции ожидали своей очереди для сохранения бинлога на диск. Ни о какой высокой производительности здесь речи идти не может.
>
>
В **Percona Server 5.5.18-23** [добавили](https://github.com/percona/percona-server/blob/1b5dff5b9e5f8c797cfed966c73fbbf6d45cbd59/sql/log.cc#L5969) одну из первых версий group commit:
* Когда поток, выполняющий транзакцию, решит закоммитить транзакцию - он добавляет себя в group commit queue.
* После чего поток пытается понять - является ли он первым в group commit queue. Если он первый - то он становится “group commit leader”.
* Лидер [берет лок на весь бинлог целиком](https://github.com/percona/percona-server/blob/1b5dff5b9e5f8c797cfed966c73fbbf6d45cbd59/sql/log.cc#L6054) (Этот лок может быть занят предыдущим лидером, который все еще пишет на диск). Именно в это время другие потоки могут добавлять транзакции в group commit queue - тем самым собираясь в новую группу.
* Заполучив лок на весь бинлог, лидер [забирает себе всю group commit queue](https://github.com/percona/percona-server/blob/1b5dff5b9e5f8c797cfed966c73fbbf6d45cbd59/sql/log.cc#L6058) (следующий лидер создаст себе новую queue)
* Лидер записывает содержимое binlog cache каждого из потоков и делает fsync() (если надо). После чего он “[будит](https://github.com/percona/percona-server/blob/1b5dff5b9e5f8c797cfed966c73fbbf6d45cbd59/sql/log.cc#L6206)” пользовательские потоки, которые заблокировались на записи в бинлог.
**Чуть позже**, помимо группировки транзакций может быть настроен на небольшое ожидание перед записью в бинлог, пытаясь собрать побольше транзакций в group commit queue. По [бенчмаркам](https://www.percona.com/blog/a-dive-into-mysql-multi-threaded-replication/) ребят из Percona - количество транзакций в секунду увеличивается на 30%.
**В актуальных версиях MySQL** group commit сделан чуть по-другому: запись в бинлог разбита на этапы, которые управляются с помощью `Commit_stage_manager`. MySQL гарантирует, что порядок записи событий в бинлоге совпадает с порядком записи изменений в Storage Engines (Это значительно упрощает работу backup-тулам, таким как xtrabackup или MySQL Clone Plugin).
Все этапы (stages) образуют [pipeline](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/binlog.cc#L8806), в котором события берутся из очереди, обрабатываются и складываются в следующую очередь. Каждая очередь защищена своим мьютексом.
Всего используется [4 очереди](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/rpl_commit_stage_manager.h#L162):
* Binlog flush queue - очередь на запись на диск.
* Sync queue - очередь из транзакций, для которых надо вызвать `fsync()`.
* Commit queue - очередь транзакций, которая используется для упорядочивания коммитов транзакций в пределах group commit. (необходима при `binlog_order_commit=1`).
* Commit order flush queue - очередь из транзакций, которые не пишут в бинлог, но участвуют в group commit - [используется](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/handler.cc#L1419) для обновления gtid\_executed в экзотических ситуациях.
Все stage работают по похожему алгоритму:
1. Когда поток, выполняющий транзакцию, решит закоммитить транзакцию - он добавляет себя во flush queue.
2. После чего поток пытается понять - является ли он первым в очереди или нет. Если он первый - то он становится stage leader.
3. Stage Leader (после небольшого ожидания в `binlog_max_flush_queue_time` ms) забирает все транзакции из очереди и выполняет свою операцию
1. binlog flush stage - производит [запись](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/binlog.cc#L8424) в бинлог: данные из binlog cache (`binlog_cache_mngr`) [пишутся](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/binlog.cc#L7579) в файл
2. sync stage - [вызывает](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/binlog.cc#L8939) `fsync()`
3. commit stage - транзакция коммитится в storage engine
4. По завершению операции, Stage Leader добавляет транзакции, которыми он владел, в следующую очередь. Может так оказаться, что очередь, куда пишет stage leader не пуста - это означает что он [“нагнал” другого лидера](https://github.com/mysql/mysql-server/blob/mysql-cluster-8.0.30/sql/rpl_commit_stage_manager.cc#L168) (который ожидает чего-то: блокировки или таймаута). В этот момент наш stage leader теряет свое лидерство. Его события будет обрабатывать “нагнанный” лидер. Такое поведение адаптирует размер group commit-а к самой медленной операции (обычно это `fsync()`) - долгие операции работают с бОльшим количеством event-ов за раз.
#### Параллельная репликация
Дополнительным преимуществом group commit является параллельная репликация - в пределах group-commit-а репликам позволено параллельно выполнять транзакции используя [replica\_parallel\_workers](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html#sysvar_replica_parallel_workers) потоков, после чего они делают commit в том же порядке что и на мастере ([replica\_preserve\_commit\_order](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html#sysvar_replica_preserve_commit_order)), чтобы гарантировать что на реплике не будет состояния, которого никогда не было на мастере (Полезное свойство, если Вы читаете с реплик!).
Продолжение следует…
--------------------
В следующей части мы рассмотрим, как InnoDB пишет Redo Log, выполняет Checkpointing и попытаемся разобраться как все части базы данных работают вместе.
**UPD:** продолжение <https://habr.com/ru/post/699342/> | https://habr.com/ru/post/684474/ | null | ru | null |
# Правила умного дома
Очень часто в статьях про домашнюю автоматизацию на Хабре выкладывают всю техническую подноготную: на каких технологиях сделано, какие программные продукты применены. Но мало статей, которые показывают конкретные примеры правил автоматизации. И сегодня я хочу это исправить.
Картинка из брошюры застройщикаПричина, почему таких статей мало в общем-то понятна: правила фактически раскрывают всю частную жизнь владельца и его семьи. Посмотрим удастся ли соблюсти конфиденциальность в этой статье.
А ещё в этой статье не будет сложных правил - все они достаточно простые, но в то же время закрывающие практически все сферы автоматизации. Специально для этой статьи сделаны лакшери фоточки однокомнатной квартиры 46 квадратных метров.
Текущая планировка квартиры, расположенной в городе ПермиИсходные данные автоматизации: однокомнатная квартира 46 квадратных метров, в ней живут два человека: муж и жена. Детей нет. Домашних животных нет. Семья часто работает из дома удаленно и много времени проводит в квартире. Используется Home Assistant.
Mobile Dashboard - Home AssistantПравила по освещению
--------------------
Были сделаны несколько триггеров, по которым включается освещение, чтобы совсем не думать про освещение, но в то же время, чтобы иметь его именно в тот момент, когда необходимо. Триггеры включают в себя:
1. Активацию по движению. Были автоматизированы все проходные зоны, такие как прихожая, кухня, санузел.
Автоматизация сделана при помощи ZigBee датчика движения Xiaomi Mi Motion Sensor.
Вид на прихожую и дверь в ванную, за зеркалом виден электрический щиток
```
- alias: Включение света в прихожей по движению
trigger:
platform: state
entity_id: binary_sensor.prikhozhaia_dvizhenie_occupancy
from: 'off'
to: 'on'
action:
- service: light.turn_on
entity_id:
- light.prikhozhaia_l1
- alias: Выключение света в прихожей
trigger:
platform: state
entity_id: binary_sensor.prikhozhaia_dvizhenie_occupancy
to: 'off'
for:
minutes: 2
condition:
- condition: state
entity_id: light.prikhozhaia_l1
state: 'on'
action:
- service: light.turn_off
entity_id:
- light.prikhozhaia_l1
```
2. Активацию по открытию двери. Включение света в санузле при помощи накладного ZigBee датчика Xiaomi Mi Window and Door Sensor. Датчик просто наклеен на дверь и работает. Изначально задумывались о фрезеровке дверного проёма, но потом поняли, что это лишние затраты, потому что текущее положение и так не бросается в глаза.
Внутри ванной
```
- alias: Автовключение света в туалете
trigger:
- platform: state
entity_id: binary_sensor.tualet_dver_contact
from: 'off'
to: 'on'
- platform: state
entity_id: binary_sensor.tualet_dvizhenie_occupancy
from: 'off'
to: 'on'
action:
service: light.turn_on
data:
transition: 120
target:
entity_id: light.tualet_l1
```
3. А вот тут необычный пункт - зависит насколько удобно вы устроились на рабочем месте в кресле. Этот пункт включает в себя [китайский датчик давления](https://aliexpress.com/item/4000148923476.html) под пятой точкой человека, который подаёт сигнал на включения света за рабочим столом. Настройка этой пары уже описана в статье [Делаем «умное» Zigbee кресло за 15 долларов](https://www.inhomekit.ru/2020/12/18/delaem-umnoe-zigbee-kreslo-za-15-dollarov/). Работает в паре с датчиком движения рабочей зоны ZigBee датчика движения Xiaomi Mi Motion Sensor.
```
- alias: сел
trigger:
- platform: state
entity_id: binary_sensor.datchik_stula_contact
from: 'off'
to: 'on'
condition:
- condition: state
entity_id: binary_sensor.dvigenie-stol-occupancy
state: 'on'
action:
service: light.turn_on
entity_id:
- light.bra
- alias: встал
trigger:
- platform: state
entity_id: binary_sensor.datchik_stula_contact
from: 'on'
to: 'off'
condition:
- condition: state
entity_id: binary_sensor.dvigenie-stol-occupancy
to: 'off'
for:
minutes: 5
action:
- service: light.turn_off
entity_id:
- light.bra
```
Скриншот автоматизацииРабочий стол и кран за окном - неподалёку возводится вторая очередь ЖК4. При отключении от Wi-Fi сети обоих телефонов хозяев квартиры и отсутствии движения на всех датчиках, свет погаснет автоматически во всей квартире через 10 минут. Здесь больной вопрос - ведь телефоны Apple не пингуются всё время, а у жены именно iOS. Решилось тем что, у роутера Huawei, которые ставит Ростелеком, есть интеграция с Home Assistant, благодаря которой можно узнать находится ли конкретное устройство прямо сейчас в локальной сети. При этом дополнительно проверяется заряд батареи устройств через приложение Home Assistant, чтобы избежать того момента, когда оба устройства разряжены.
```
- alias: выключить весь свет
trigger:
platform: state
entity_id: group.semiya
to: 'off'
for:
minutes: 10
condition:
- condition: state
entity_id: group.dvighenie
to: 'off'
for:
minutes: 10
action:
service: homeassistant.turn_off
entity_id:
- group.all_lights
```
5. Плавное пробуждение как у [светового будильника от Philips](https://www.shop.philips.ru/personalnyy-ukhod/svetilniki-dlya-zdorovya/svetovyye-budilniki.html). В зимнее время с утра заводится будильник через приложении Home Assistant и за полчаса до этого времени прикроватные бра (с установленными [Lonsonho Tuya Smart Zigbee](https://www.aliexpress.com/item/4001279149071.html) в подрозетниках, которые не требуют нейтрали) постепенно начинают увеличивать яркость свечения, таким образом создавая комфортные условия для пробуждения. А в летнее время года шторы защищают от излишнего света после 23 часов вечера и к утру, к времени установленного будильника они открываются, пропуская солнечный свет в комнату.
Спальня
```
- alias: Будильник
trigger:
platform: template
value_template: '{% if states(''sensor.samsung_s8_sleduiushchii_budilnik'') !=
''unavailable'' %} {% set alarm_time = as_timestamp(states(''sensor.samsung_s8_sleduiushchii_budilnik''))
%} {{ as_timestamp(now()) >= ( alarm_time - 30*60 ) and as_timestamp(now())
< ( alarm_time - 29*60 ) }} {% endif %}
'
action:
- service: script.turn_on
entity_id:
- script.slowly_turn_on_lamp
```
Lonsonho Tuya Smart Zigbee в квадратном подрозетникеПравила по вентиляции и климату
-------------------------------
Поскольку квартира в новостройке, щелей в окнах нет, движения воздуха нет и очень сильно выручает бризер. Это приточный очиститель воздуха, для установки которого потребовалось просверлить отверстие в стене диаметром 10 см.
### Бризер Xiaomi Mijia Fan A1
Сейчас бризер работает днем и ночью в автоматическом режиме.
Автоматический режим всегда справляется со своими обязанностями по притоку свежего воздуха и одновременно штатный ночной режим исключает шумную работу, когда все спят.
Бризер, установленный на стене спальниА ещё при температуре воздуха на улице ниже +5°С градусов бризер сам включает подогрев воздуха.
Изначально бризер тоже был интегрирован в Home Assistant и управлялся по правилам, но со временем поняли, что автоматические правила работают не хуже и не надо тратить время на дополнительные настройки.
Отверстие выхода бризера на балкон квартиры### Управляющие головки на радиаторы Netatmo Smart Radiator Valves
В квартире поддерживается комфортная для хозяев температура воздуха:
* дневная температура: 24°C;
* вечерняя температура: 26°C;
* ночная температура: 21°C;
* утренняя температура: 26°C.
Радиатор на заднем плане, а управляющую головку закрывает дверьТемпература выбрана именно такой для комфортного сна и пробуждения: чтобы днем не мерзнуть, а ночью не было жарко.
Настроены через родное приложение Netatmo:
NetatmoСмарт-головка на батарее### Кондиционер Midea MSAG1-09N8C2-I/MSAG1-09N8C2-O + WiFi модуль
Во время бодрствования при повышении комнатной температуры, снимаемой датчиком кондиционера выше 26°C включается кондиционер на 25°C и работает 30 минут в своём автоматическом режиме. Площадь квартиры небольшая и это позволяет за полчаса охладить весь воздух до комфортной температуры. Также поэтому нет необходимости в его постоянной работы. Во время сна при температуре выше 26°C включается кондиционер на минимальной скорости обдува на 25°C.
Управляющий модуль на кондиционере### Теплый пол Moes BHT-002-GBLW
Тёплый пол сделан в ванной, прихожей, кухне и подоконной лавке. В ночное время в непроходных зонах теплый пол выключается. Если бы не удаленная работа из дома, то теплый пол во всех зонах бы еще выключался на время отсутствия.
Контроллер теплого пола у окнаПравила по безопасности
-----------------------
В безопасности только один пункт и он связан с входной дверью. В дверь врезан умный замок Xiaomi Aqara N100. Этот замок может запускать домой по отпечатку пальца и в его память добавлены отпечатки всех членов семьи. Это особенно удобно, когда обе руки заняты например пакетами с покупками.Также замок позволяет пускать в квартиру родственников, когда хозяев нет дома - без передачи ключей, просто сообщив код доступа в квартиру.
Входная дверь - вид с жилой части квартирыС его установкой была интересная история - дверь уже была установлена и первоначально устанавливать замок вызвали просто первого попавшегося мастера, телефон которого нашли на авито. После демонтажа обычного замка мастер буквально испарился с места установки и доделывал уже другой мастер, но на следующий день.
Родное приложение Xiaomi Aqara N100Дверь со стороны коридораУборка
------
В уборке тоже только один пункт - пылесос. Робот пылесос Xiaomi Mi Robot Vacuum Cleaner выезжает на уборку при условии что никого нет дома, и что сегодня уборка еще не проводилась.
Пылесос выглядывает из под ниши в шкафуУправление
----------
Помимо автоматизаций в квартире очень часто используется управление голосом через колонку Яндекс.Алиса Мини. Благодаря планировке квартиры хватает одной колонки, потому что из любой точки квартиры Алиса слышит голосовую команду, без повышения голоса.
Общее пространство квартирыЧто больше всего нравится жене
------------------------------
Кажется, что темы автоматизации интересны только мужской аудитории. Ведь у женщин немного другой взгляд на вещи. В этой квартире хозяйка чаще всего использует голосовые команды для управления светом, кондиционером, пылесосом и шторами. Остальные устройства уже работают по заранее прописанным правилам автоматизации и нет необходимости дополнительно вмешиваться в их работу.
Гостевая зона квартирыСтоимость
---------
Общая стоимость оборудования вышла примерно на 100 000 рублей, настройкой владелец занимался сам, поэтому 0 рублей, но потратил на это примерно 3 недели.
Итоги
-----
Семья из двух человек живёт в квартире 46 кв. метров уже год и постепенно дорабатывает правила для того, чтобы они были удобнее. Во-первых отнимали меньше времени на управление всем зоопарком устройств и поддерживали необходимые уровни освещенности, вентиляции, безопасности и удобства по возможности автоматически.
За помощь в подготовке статьи, фотографии и код хочу поблагодарить [Евгения и Екатерину](https://www.instagram.com/onsam.ru/), город Пермь, которые раскрыли все правила своей квартиры в этой статье.
Автор: [Михаил Шардин](https://shardin.name/),
10 сентября 2021 г. | https://habr.com/ru/post/577052/ | null | ru | null |
# Orange Pi 2G-IOT: карта минного поля
Некоторое время назад мне предложили немного поработать с одноплатным ПК Orange Pi 2G-IOT (встроенный 2G и цена выглядят очень привлекательно). Прочитав пост об [апельсиновом рае](https://habr.com/ru/post/357966/), я подумал, что без затруднений повторю этот путь, тем более, что с Linux я на «ты» (вернее, так я думал недели три назад) и уже имел опыт общения с Raspberry Pi 2 B+. На практике этот путь оказался намного длиннее. Создавалось ощущение, что наши китайские друзья намеренно создавали сложности (причём иногда с особым цинизмом). Если вы захотели сэкономить и купить эту плату, то сначала прочитайте этот пост и подумайте ещё раз.
По возможности, я постараюсь сдерживать эмоции или как минимум переводить их в юмор.
Итак, вот мне в руки попадает плата и SD карточка десятого класса. Поехали.
Всё ниже написанное относится к модели Orange Pi 2G-IOT, но в чате Телеграма (ищите «Orange Pi и не только») говорят, что модели 2G, 3G и 4G примерно одинаково себя ведут (одинаково плохо). Написанное НЕ относится к, например, Orange Pi PC и Orange Pi One, которые по отзывам ведут себя стабильно.
### Мина №1 (учебная): скачивание образа ОС
Казалось бы, что может быть проще? Идём на [сайт производителя](http://www.orangepi.org/downloadresources/) и качаем. Однако все ссылки ведут на mega.nz, который собирает его прямо в браузере. Мой дешёвый ноутбук с 4 Гб ОЗУ не потянул такую задачу и вкладка упала. Можно было бы воспользоваться фирменной программой для скачивания с Меги, но он у меня не вызвал доверия (тем более, что в Интернетах некоторые пишут, что программа распознаётся антивирусами как вредоносное ПО). **Варианты решения:** скачать с неофициального сайта (например, [здесь](https://orangepi.su/content.php?p=99&c)), развернуть виртуалку и поставить в ней клиент для скачивания с Меги, попросить кого-то с более современным ПК скачать образ.
**Ещё немного об операционках для апельсина**Для многих моделей Апельсинок пользователи рекомендуют Armbian, но на 2G-IOT он на меня впечатление не произвёл: выглядит как минималистичный Raspbian. Кстати, на сайте Армбиана образа для 2G-IOT нет, только на сайте Orange Pi. Также пробовал Ubuntu Server, но он у меня вообще не подавал признаков жизни. Встроенный в NAND Андроид по всей видимости рабочий, но я его никак не изучал, скорее всего, без сенсорного экрана он малополезен. Кстати, напоминаю, что устройство загрузки определяется положением перемычки в уголке платы, по умолчанию стоит загрузка со встроенной NAND памяти.
### Мина №2: выход в Интернет через модем
Дословно следуя настройке wvdial и pppd в Интернете, я внезапно обнаружил, что ping запросы проходят исправно, а вот обычные TCP пакеты ни в какую:
```
orangepi@OrangePi:~$ curl --interface ppp0 195.201.201.32
curl: (7) Failed to connect to 195.201.201.32 port 80: Connection timed out
orangepi@OrangePi:~$ curl --interface ppp0 195.201.201.32
curl: (7) Failed to connect to 195.201.201.32 port 80: Connection timed out
orangepi@OrangePi:~$ curl --interface ppp0 195.201.201.32
curl: (7) Failed to connect to 195.201.201.32 port 80: Connection timed out
orangepi@OrangePi:~$ curl --interface wlan0 195.201.201.32
46.0.208.54
orangepi@OrangePi:~$ ping 195.201.201.32 -I ppp0
PING 195.201.201.32 (195.201.201.32) from 10.33.64.21 ppp0: 56(84) bytes of data.
64 bytes from 195.201.201.32: icmp_seq=1 ttl=52 time=664 ms
64 bytes from 195.201.201.32: icmp_seq=2 ttl=52 time=240 ms
64 bytes from 195.201.201.32: icmp_seq=3 ttl=52 time=234 ms
64 bytes from 195.201.201.32: icmp_seq=4 ttl=52 time=246 ms
64 bytes from 195.201.201.32: icmp_seq=5 ttl=52 time=241 ms
64 bytes from 195.201.201.32: icmp_seq=6 ttl=52 time=237 ms
^C
--- 195.201.201.32 ping statistics ---
7 packets transmitted, 6 received, 14% packet loss, time 6032ms
rtt min/avg/max/mdev = 234.634/310.971/664.998/158.370 ms
orangepi@OrangePi:~$
```
**Решение** подсказал [edtun](https://habr.com/ru/users/edtun/): <https://www.linux.org.ru/forum/admin/12135523>, хотя допускаю, что можно было как-то проще.
Сразу насторожило, что IMEI модема забит нулями. Благо, красно-белый оператор связи не обращает на это внимание. (Кстати, у встроенного WiFi аналогично нет МАС-адреса: при каждом передёргивании питания он генерируется случайным образом.)
### Мина №3: USB порт
Втыкаем WiFi свисток в USB разъём и… Ничего не происходит. lsusb отобразил пустой USB порт. Небольшое копание показало, что в плате реально всего **один** USB. И по умолчанию он подключен к microUSB порту. Для переключения его на обычный USB HOST необходимо переключить на плате джамперы, которые находятся рядом с перемычкой для выбора загрузки. Их описание есть на 4pda: [](http://4pda.ru/forum/index.php?showtopic=813602&st=360#entry72203022)
**Решение:** переключить джамперы в положение: 1234 вниз, 5678 вверх.
Только потом я нашёл небольшое упоминание об этом нюансе в мануале к Orange Pi.
### Мина №4: Драйверы
Теперь устройство определяется в системе, lsusb отображает производителя и код продукта, но беспроводной сетевой интерфейс в системе не определяется. Потому что разработчики не завезли на апельсинку драйвера для WiFi адаптеров. Причём вообще никаких. Есть драйвер только для встроенного WiFi, не больше и не меньше. А что мы делаем, когда у нас нет драйвера под наше железо? Правильно, идём **собирать их из исходного кода**!
### Мина №5: Подготовка к сборке
В переписке [bad\_\_day](https://habr.com/ru/users/bad__day/) предложил сборку непосредственно на Orange Pi. Может быть, это возможно, но мне не удалось.
Для Orange Pi разработчики сделали специальную Orange Pi Build System, с помощью которой в теории для сборки ядра или модулей к нему достаточно просто следовать указаниям на экране. Подробная инструкция изложена в [мануале](http://mikrokontroler.pl/wp-content/uploads/2017/08/OrangePi-2G-IOT-User-Manual_v0.9.9.pdf) начиная с 61-й страницы. Казалось бы, просто следуй, и всё будет хорошо, но нет.
Во-первых, чтобы вручную не править все зависимости на своём компьютере (я регулярно обновляю ПО, это здорово, но не в этот раз), я развернул виртуалку с Ubuntu 16.04 и все действия проводил там. Во-вторых, в скриптах где-то вкралась ошибка, и Build System не ставила тулчейн для кроссплатформенной компиляции. **Решается это** таким костылём:
1. Вручную apt-get'ом ставим тулчейн для кросскомпиляции под ARM.
2. Делаем симлинки:
```
mkdir $HOME/OrangePiRDA/toolchain/bin
ln -s $(which arm-linux-gnueabi-ld) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-ld
ln -s $(which arm-linux-gnueabi-gcc-4.9) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-gcc
ln -s $(which arm-linux-gnueabi-g++-4.9) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-g++
ln -s $(which arm-linux-gnueabi-ar) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-ar
ln -s $(which arm-linux-gnueabi-nm) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-nm
ln -s $(which arm-linux-gnueabi-objcopy) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-objcopy
ln -s $(which arm-linux-gnueabi-size) $HOME/OrangePiRDA/toolchain/bin/arm-linux-gnueabi-size
```
Обратите внимание: компилятор берётся версии 4.9, на версиях выше ничего не соберётся.
3. Открываем OrangePiRDA/scripts/Prepare\_toolchain.sh и на всякий случай комментируем строки, упоминающие тулчейн.
На самом деле все эти скрипты просто вызывают apt-get install -y… и make. Скрипт не предлагает пользователю как-либо изменять конфигурацию (или я не нашёл?).
Но ведь нам ничего не мешает самим вызвать
```
make menuconfig
```
и отметить нужные драйверы. Делаем это и снова собираем (теперь можно только модули) и…
### Мина №6 (с прикрученным ИК датчиком движения и запасным детонатором): Сборка драйвера
… И тут скрипт приветливо стал задавать вопросы, как ему конфигурировать ядро. Он вызвал старомодный конфигуратор ядра, но почему?! Что не так?
Оказалось, что в Makefile прописано проверять ВРЕМЯ(!!!) изменения конфига!
В комментарии дословно написано «кто-то копался». (На скриншоте уже изменённый Makefile, я прописал menuconfig.) Пробовал вызывать make oldconfig, не заметил, чтобы это что-то где-то изменило. Ладно, теперь ведь при сборке вызовется menuconfig, это не страшно. Снова вызываю сборку, сборка замечает, что «кто-то копался в конфиге», вызывает menuconfig, я выхожу и жду завершения. А теперь представьте моё удивление, когда я не нашёл выбранный мною драйвер.
**Дисклеймер перед дальнейшим прочтением**На этом месте меня покинуло понимание происходящего, а также я окончательно потерял связь с реальностью, здравым смыслом и цивилизацией с планеты Ross 128 b. Я вышел за границы знаний своих, всех моих знакомых и TARDIS. Я начал творить полный бред, а единственной целью стало собрать этот [CENSORED] драйвер любой ценой. Если при прочтении текста выше Вы хватались за голову более двух раз, то текст ниже не читайте. Так будет спокойнее и вам, и мне. Если вы можете дать внятное объяснение происходящему и объяснить, где я не прав и как надо, то прошу рассказать. Пожалуйста.
Что ж, лезем разбираться. Оказывается, make создаёт файл modules.order, где описаны все модули, которые будут скомпилированы. И даже после всех изменений конфига и его сохранения этот файл заполняется одинаковым набором. Я не придумал ничего лучшего, чем вручную дописать в него строки (мой свисток собран на чипсете RTL8192CU):
```
kernel/driver/net/wireless/rtlwifi.ko
kernel/driver/net/wireless/rtlwifi/rtl8192cu.ko
```
Все упоминания этого файла в Makefile заменил на modules.order.fake. Запускаю сборку. На этот раз сборка пошла, но оборвалась, так как аналогичного файла нет в папке с исходным кодом rtlwifi. Я переименовал в этой папке и подпапках файлы modules.order.fake на modules.order, и это стало моим последним приключением при сборке драйвера. После этого система ещё два раза выводила мне menuconfig, как будто спрашивая меня «ты точно этого хочешь?», но всё же собрала дополнительно три заветных .ko файла, которые завелись как положено.
### Мина №7: Совместная работа внешнего WiFi и модема
Немного поигравшись с airodump'ом и убедившись, что как минимум ловить пакеты в режиме монитора устройство умеет, я решил проверить модем ещё раз. Выполняю
```
sudo wvdial
```
И светодиод на внешнем WiFi адаптере гаснет, а SSH отваливается. В логах потом прочитал, что адаптер был отключен. Первая мысль — проблема с питанием. До этого момента я использовал свой зарядник на 1,5 Ампера, а производитель рекомендует аж целых 3 (куда столько? Она и [одного Ампера даже не ест](http://znoxx.me/2016/08/20/orange_pi_power/)). Под рукой был зарядник на 2 Ампера, который годами исправно питал Raspberry Pi.
На данный момент я не нашёл какого-либо стабильного решения данной проблемы. Вот некоторые попытки решения:
* С вероятностью 80% можно отключить внешний WiFi с помощью:
```
chmod 777 /sys/bus/usb/drivers/usb/unbind
echo 1-1 > /sys/bus/usb/drivers/usb/unbind
```
а затем запустить wvdial, который с 1-3 попытки установит соединение и можно выйти в Интернет. В 20% разного рода зависания и глюки.
* Однажды случайно оказалась такая ситуация, что был убит wvdial, но pppd остался работать (как так может быть?), после которого поднялся внешний WiFi (см. выше, только вместо unbind пишем bind) и связь через модем была. Воспроизвести ситуацию не удалось.
* Оказалось, что можно без пересборки ядра отключать питание на USB с помощью [такой](https://github.com/codazoda/hub-ctrl.c) утилиты командой
```
./hub-ctrl -h 0 -P 1 -p 0
```
и включить питание
```
./hub-ctrl -h 0 -P 1 -p 1
```
На 2G-IOT поведение непредсказуемое: отключение питания может быть либо на одну секунду, либо до перезагрузки. При некоторых фазах Луны попытка вернуть питание приводит к зависанию платы.
* Переключить джамперы на OTG (1234 вверх, 5678 вниз), питание подать на ноги GPIO 2 и 6 (прозванивал, они напрямую соединены с питанием microUSB)
**Распиновка**
подключить WiFi адаптер через USB-OTG переходник от смартфона. Система не видит USB устройства вообще. Возможно, надо настойчивее поиграться с джамперами.
Не проверялось, но может сработать (в планах опробовать все эти варианты):
* Другой WiFi адаптер.
* Очень стабильный источник питания с максимальным током 3 Ампера.
* Дополнительное питание к ногам USB.
* Бензин и спички.
В общем, задача выглядит как натягивание треугольного одеяла на четырёхугольный апельсин.
На этом пока всё.
**Благодарности**Хотелось бы выразить свою благодарность [bad\_\_day](https://habr.com/ru/users/bad__day/), [edtun](https://habr.com/ru/users/edtun/), А. Репину, форумчанам с [4pda](http://4pda.ru/forum/index.php?showtopic=813602), старожилам в чате Телеграма и Коту, который терпеливо выслушивал меня всё это время и почти не пытался сбежать.
**UPD:** Сегодня мне привезли источник питания с выходом 5В 3А. С ним удалось одновременно запустить и модем, и USB WiFi адаптер. Модем сыплет ошибками, перестаёт отвечать, но в среднем с третьей попытки подключается. После этого можно использовать USB WiFi.
### Подводя итог.
Одноплатник Orange Pi 2G-IOT очень сырой и почти не поддерживается производителем. Даже на простых вещах, где казалось бы ничего не предвещает беды, что-то может пойти не так. Если необходимо использовать устройство с выходом в Интернет через мобильную сеть и вы не уверены, что сможете совладать с Orange Pi, то лучше доплатить и взять что-то более надёжное и отлаженное. Сбережёте время и нервы. | https://habr.com/ru/post/440960/ | null | ru | null |
# Производительность и рантаймы на конференции JPoint 2018
Все мы имеем какие-то ожидания от конференций. Обычно мы идём на вполне конкретную группу докладов, вполне конкретной тематики. Набор тем отличается от платформы к платформе. Вот что сейчас интересует джавистов:
* Производительность
* Виртуальные машины и особенности рантаймов
* JDK 9/10/...
* Фреймворки
* Архитектура
* Enterprise
* Большие данные и машинное обучение
* Базы данных
* JVM-языки (включая Kotlin)
* DevOps
* Разные мелкие темы
Программа конференции составляется так, что для каждой из тем стараются подобрать как минимум по одному хорошему докладу. JPoint проводится в течение двух дней, там будет около сорока докладов, поэтому все основные вопросы так или иначе будут освещены.
В этом небольшом посте расскажу о тех докладах, которые приглянулись мне как человеку, который ходит в основном на доклады по производительности и рантаймам.
Масштабирование, кластеры и всё такое рассматривать тут не будем, достаточно сказать, что оно есть (Christopher Batey из Lightbend [расскажет про Akka](https://jpoint.ru/talks/5qmjxxmz7gkkcuc0o864gq/), Виктор Гамов из Confluent [расскажет про Kafka](https://jpoint.ru/talks/6rzzmpfikoqa8uokcu0uas/), и так далее).
> Disclamer. Статья написана по впечатлeниям от содержимого [программы на официальном сайте](https://jpoint.ru/#schedule). Всё ниженаписанное — мои собственные мысли, а не цитаты из докладов. В тексте могут быть (и точно есть) неверные предположения и неточности.
Производительность
==================
Помните шуточную статью ["Java с ассемблерными вставками"](https://habrahabr.ru/company/jugru/blog/347200/)? В комментариях [apangin](https://habrahabr.ru/users/apangin/) сказал, что сделает доклад про VMStructs. Сказано — сделано, вот он: ["VMStructs: зачем приложению знать о внутренностях JVM"](https://jpoint.ru/talks/7lh7kkir1ye6uamik4w4cs/). Доклад посвящён использованию VMStructs — специального API виртуальной машины HotSpot, благодаря которому можно узнать о внутренних структурах JVM, включая TLAB, Code Cache, Constant Pool, Method, Symbol и т. д. Несмотря на свою «хакерскую» сущность, этот API может пригодиться и обычной программе. Андрей будет показывать примеры того, как VMStructs помогает в разработке реальных инструментов (которые они применяют в Одноклассниках).
Второй доклад, ["Аппаратная транзакционная память в Java"](https://jpoint.ru/talks/7ulbihlaqmk4iquimasikq/), делает Никита Коваль — инженер-исследователь в исследовательской группе dxLab компании Devexperts. Если вы были на JBreak в начале этого месяца, то можете заметить, что там он рассказывал о [совершенно других вещах](https://2018.jbreak.ru/talks/p8nmritp8gocayqok68cs/) (о написании быстрой многопоточной хэш-таблицы с использованием мощи современных многоядерных архитекур и специальных алгоритмов). В этом же докладе речь пойдёт про транзакционную память, которая понемногу появляется в современных процессорах, но которую пока непонятно как использовать обычному человеку. Никита должен рассказать про способы использования, какие оптимизации уже есть в OpenJDK, и как выполнять транзакции напрямую из Java-кода.
Ну и наконец, ["Enterprise без тормозов"](https://jpoint.ru/talks/1smez2ivjmiw0wskqimew0/). Куда же мы без кровавого энтерпрайза! Сергей Цыпанов занимается вопросами производительности в Luxoft, в домене Deutsche Bank. В докладе будут рассматриваться паттерны, убивающие производительность ваших приложений — достаточно легкие, чтобы найти на code review, но достаточно сложные, чтобы в IDE красным они не подчёркивались. Все примеры основаны на коде работающих в продакшнe приложений.
Профилирование
==============
По профилированию глаз зацепился за три доклада. Первый доклад — Саши Гольдштейна, ["Linux container performance tools for JVM applications"](https://jpoint.ru/talks/1bvhc9jbruimqwks4uqaeu/). Саша — серийный создатель перфомансного хардкора. В прошлом году на JPoint он делал отличный доклад про использование [Berkeley Packet Filter для JVM](https://www.youtube.com/watch?v=0qI31tdlV-k) (отчаянно рекомендую посмотреть запись на YouTube), и это был только вопрос времени, когда он доберётся до подробного разбора контейнеризации. Мир уходит в облака и докеры, что в свою очередь приносит нам множество новых проблем. Как вы могли заметить, большинство низкоуровневых систем отладки и профилирования, будучи применены к контейнерам, обрастают разными особенностями и косяками. Саша будет рассматривать основные сценарии (загрузку CPU, отзывчивость IO, доступ до расшаренных баз, итп) сквозь призму использования современных инструментов на платфомре GNU/Linux, включая BCC и perf.
["Профилируем с точностью до микросекунд и инструкций процессора"](https://jpoint.ru/talks/4kniewswg8eiqciayummmc/) — второй доклад по профилированию, который делает Сергей Мельников из Райффайзенбанка. Интересно, что до того, как заняться low-latency кодом на Java, он работал в Intel инженером по производительности компиляторов для языков C/C++/FORTRAN. В этом докладе тоже будет perf! :-) Ещё будет про аппаратные особенности процессоров и технологии Intel Processor Trace, которая позволяет сделать следующий шаг в точности профилирования и реконструировать выполнение участка программы. Таких докладов довольно мало (например, можно найти [доклад Andi Kleen](https://www.youtube.com/watch?v=R0AlpLqhwPQ) на Tracing Summit 2015), они обычно оставляют море вопросов и не блещут практичностью применительно к Java. Тут у нас не просто есть человек, побывавший в обоих мирах (и Intel, и Java в банке), ещё его можно будет найти в дискуссионной зоне и задать неудобные вопросы.
Третий доклад — ["Универсальные профилировщики и где они обитают"](https://jpoint.ru/talks/2ju2jfcff2i8ycs60emoig/). Его делает Иван Углянский — один из разработчиков Excelsior JET (сертифицированной реализации Java SE, основанной на оптимизирующей AOT-компиляции), занимющийся рантаймом: GC, загрузкой классов, поддержкой многопоточности, профилирования и т.д. Суть доклада в том, что недавно им понадобилось собирать профиль приложений, запускаемых на Excelsior JET. Делать это нужно на всех поддерживаемых системах и архитектурах, без перекомпиляции приложения, да еще и с приемлемой производительностью. Оказалось, что привычные способы профилирования одновременно под все эти пункты не подходят, поэтому пришлось придумать что-то своё. Иван расскажет, какие способы профилирования подходят для AOT, что можно себе позволить, если профилировать код изнутри JVM, и чем приходится платить за универсальность профилировщика.
Нестандартные рантаймы
======================
"Рантайм", если говорить коротко, это штука, которая берёт твой высокоуровневый код на JVM-языке, превращает в низкоуровневый (машкод, например) и контролирует процесс выполнения. Обычно там есть какой-то ассемблер, компилятор, интерпретатор, виртуальная машина. Особенности рантайма задают особенности перфоманса прикладных задач.
Первое, на что падает взгляд в программе — это доклад [Alibaba про их JDK](https://jpoint.ru/talks/2sc3v1jbv2y6eeoyiuisoc/). Кто не мечтал сделать собственный JDK с блэкджеком и корутинами? Но всем ясно, что это адский труд, боль и страдания. А вот в Alibaba получилось. Вот что у них есть:
* Некий механизм, который ползволяет без оверхеда на GC выделять объекты в скрытых регионах;
* Легкие треды (корутины), встроенные прямо в JVM, это нужно им для асинхронного программирования;
* Возможность профилирования на живую
* Разные приятные мелочи
Да, у нас (широкой общественности, использующей OpenJDK) скоро будет [Project Loom](http://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html). Но есть нюанс — разработка корутин является в Loom вторичной по отношению к главной цели — файберам. Файберы требуют *delimited continuations*, но совершенно необязательно, что они скоро, или когда-либо вообще, появятся в публичном API. Похоже, что в Alibaba всё это уже запилили самостоятельно.
Насколько понял, это не доклад из разряда "используйте нашу закрытую проприетарную JDK", а гид для людей, которые собираются осваивать разработку похожих фичей, или бороться с их отсутствием в OpenJDK. Например, инструменты для профилирования зависят от профилируемых областей и ворклоадов — для каждого продукта они будут свои. Докладчик от Alibaba будет не столько рассказывать о своих инструментах, сколько о процессе классификации ворклоадов, который ведёт разработку подобных инструментов в правильном направлении.
Кстати, раз уж мы заговорили про корутины. В Kotlin они появились, начиная с версии 1.1 ([в экспериментальном статусе](https://kotlinlang.org/docs/reference/coroutines.html)), и про них будет [доклад Романа Елизарова](https://jpoint.ru/talks/1pztl3mbmqswiyiqqg2ocu/) из JetBrains. Роман расскажет про эволюцию подходов к асинхронному программированию, про их отличия и схожести. Плюс мы услышим официальную позицию, почему то, что сейчас есть в Kotlin — лучше, чем знакомый всем `async/await`.
Чтобы не ходить далеко, Alibaba JDK — это не единственные представители необычных экосистем. Конечно же, присустствует доклад про Azul Zing, и целых два про OpenJ9 ([раз](https://jpoint.ru/talks/5vqeeeo89yk6q8qmm0y8sg/), [два](https://jpoint.ru/talks/brb8twjoluieiuuew8usu/)).
Все доклады про внутренности продуктов Azul обладают для меня неким оттенком грусти, т.к. ни разу в жизни не пришлось войти в круг избранных, использующих их крутые, но весьма недешёвые решения. Поэтому для меня этот [их свежий доклад](https://jpoint.ru/talks/63npsyjpokmukqsag80oia/) имеет скорей теоретическую значимость, как источник информации о технологиях, конкурирующих с нашим родным OpenJDK. Сейчас в OpenJDK активно развивается тема AOT — в OpenJDK JDK 9 уже был встроенный AOT (только для 64-битных линуксов), есть [SubstrateVM](https://github.com/oracle/graal/tree/master/substratevm), и дальше будет только лучше, вплоть до реализации проекта [Metropolis](http://cr.openjdk.java.net/~jrose/metropolis/Metropolis-Proposal.html). К сожалению, c AOT в Java не всё так просто, к части современной инфраструктуры очень неприятно всё это прикручивается (помните эпический [доклад Никиты Липского про криво спроектированный OSGi](https://www.youtube.com/watch?v=hEnvRXNyDgI)?). У Azul уже есть некое готовое AOT решение под названием *ReadyNow*, встроенное в их Zing, пытающееся сочетать лучшие качества JIT и AOT — вот о нём и будет этот доклад.
Как справедливо отметили в комментариях, нужно представить докладчика. Если коротко, Дуглас Хокинс — ведущий разработчик в Азуле, 15 лет занимается Java, поучаствовал в разнообразных областях: биоинформатика, финансы, ритейл. Чем больше он жил в джавамире, тем больше углублялся во внутренности JVM, и однажды просто ушёл в Azul работать над Zing, и стал главным разработчиком того самого ReadyNow. То есть, это человек, побывавший на обеих сторонах баррикады: и как прикладной разработчик, и как системный, и в результате имеющий весьма уникальный опыт.
С другой стороны, OpenJ9 [можно скачать прямо сейчас](https://www.eclipse.org/openj9/). С тех пор как IBM опенсорснула свою виртуалку в Eclipse Foundation, вокруг неё произошло очень много хайпа. В массовом сознании есть некий набор идей и фактов про то, что ей можно заменить HotSpot, что при этом библиотеки из OpenJDK можно спокойно переиспользовать, что должно снизиться количество расходуемой памяти, и даже что-то переложить на GPU… и в общем-то, всё. (Кстати, GPU вообще обычно представляется как чёрная магия — благо, на прошлом Joker Дмитрий Александров делал отличный доклад "Java и GPU: где мы сейчас?". Видео ещё нет, но можно глянуть [слайды](http://downloads.contentful.com/oxjq45e8ilak/4f7eARrH9CKEyc4AGcomqK/10944de9030c26780fba33e614206b39/GPU____Java____________________________.pdf)).
Первый доклад, ["The Eclipse OpenJ9 JVM: a deep dive!"](https://jpoint.ru/talks/5vqeeeo89yk6q8qmm0y8sg/) рассказывает Tobi Ajila — разработчик J9 из IBM, работающий над [Valhalla](http://openjdk.java.net/projects/valhalla/) и [Panama](http://openjdk.java.net/projects/panama/), с большим послужным списком вроде улучшений в интерпретаторе, JVMTI и лямбдах. Судя по всему, будет описание неких технических особенностей OpenJ9, благодаря которым можно разогнать свои облачные решения и прочие перфоманс-критичные штуки. Второй доклад, ["Deep dive into the Eclipse OpenJ9 GC technologies"](https://jpoint.ru/talks/brb8twjoluieiuuew8usu/) ведёт архитектор сборщика мусора в OpenJ9, тоже из IBM — там будет весьма прагматичный рассказ о четырех политиках сборки мусора, где их надо использовать, и как всё это работает под капотом. Надеюсь, что после прослушивания этих докладов, аура магии вокруг OpenJ9 слегка поуменьшится.
Заключение
==========
За эти два дня можно побывать на 12 докладах. Из них на 3 кейноута — общие для всех, поэтому нужно сделать выбор 9 раз. Если выбирать доклады только из этого списка, то можно сделать 7 решений из 9. Остальные два — по вкусу (надо же иметь кругозор и по "общечеловеческим" темам?). Некоторые доклады пересекаются между собой (самый тяжкий выбор в 13.45 первого дня — между профилированием контейнеров Саши Гольдштейна, аппаратной транзакционной памятью Никиты Коваля и корутинами Kotlin Романа Елизарова). Есть идея, что с точки зрения человека, интересующегося перфомансом и рантаймами, программа составлена достаточно хорошо, чтобы быть интересной с начала до конца. Встретимся на конференции!
Напоминаю, что до JPoint 2018 осталось меньше месяца. Билеты всё ещё можно приобрести [на официальном сайте](https://jpoint.ru/tickets/). | https://habr.com/ru/post/351078/ | null | ru | null |
# ATI Catalyst 8.7/8.8 + WINE OpenGL. Решение проблемы.
Как я уже писал в одном из своих [прошлых топиков](http://alinaki.habrahabr.ru/blog/28043/), новый проприетарный драйвер для видеокарт AMD ATI добавил много улучшений, но поломал совместимость с OpenGL в WINE. Из-за этого я откатился на драйвер 8.4, в котором мерцали нативные игры в OpenGL при включенном Compiz, зато работали игры через WINE. И вот недавно на [forum.ubuntu.ru](http://forum.ubuntu.ru) пользователь Flace подсказал решение. Итак.
`Под компизом не работает так как моргает, в остальных случаях делается очень просто правкой xorg.conf
В секции "Screen" добавляем
Код:
Virtual x y
где "x y" ваше разрешения экрана.
Мой пример
Код:
Section "Screen"
Identifier "aticonfig-Screen[0]-0"
Device "aticonfig-Device[0]-0"
Monitor "aticonfig-Monitor[0]-0"
DefaultDepth 24
SubSection "Display"
Viewport 0 0
Virtual 1024 768
Depth 24
EndSubSection
EndSection
В данном случае у меня все замечательно бегает
FPS в CS 50 - 90
WoW - в многонаселенных городах 7-15 fps, средний по миру 30-70 fps
Карточка HD2400 pro
Дрова ставил как обычно:
Код:
sh ati*
aticonfig -initial`
Если кому нужна справка, что это за команда Virtual такая — прошу пройти в поиск, я не собираюсь из каждого топика делать расширенный мануал, уж извините.
Топик написан непосредственно с разрешения уважаемого Flace с [forum.ubuntu.ru](http://forum.ubuntu.ru)
У меня на ATI X1300 работает. Повторюсь, что нативные OpenGL игры при включенном Compiz не мерцают, если их разрешение совпадает с системным.
**Важный UPD** А попробуйте выставить не 1280, а 1281, например. :-) У меня это дало ошеломительный эффект — игра при включенном компизе перестала мерцать. В общем, ширину виртуального разрешения чуть больше физической. | https://habr.com/ru/post/37942/ | null | ru | null |
# Трюки при линковке и загрузке файлов Mach-O
*Представляю вашему вниманию перевод моей статьи из блога Проекта Darling. Маленькая справка по используемым понятиям: Darwin – операционная система с открытым исходным кодом, лежащая в основе macOS, iOS и других ОС от Apple; Mach-O – бинарный формат исполняемых файлов и библиотек, использующийся в Darwin; dyld – динамический загрузчик, использующийся в Darwin для загрузки файлов Mach-O; dylib – динамически загружаемая библиотека (обычно имеет расширение `.dylib`).*
Цель Проекта Darling – сделать возможным запуск macOS-приложений под Linux, и умение загружать бинарные файлы в формате Mach-O – один из ключевых шагов к достижению этой цели.
Исходно, Darling был выстроен вокруг собственной реализации загрузчика Mach-O и идеи транслирования вызовов между высокоуровневым Darwin API и его Linux-аналогами. С тех пор наш фокус сместился на запуск кода во всё более и более изолированном Darwin-контейнере. С тех пор как мы [перешли на использование Mach-O для внутренних компонентов Darling](http://blog.darlinghq.org/2017/02/the-mach-o-transition-darling-in-past-5.html), у нас появилась возможность использовать исходный dyld от Apple, а также собирать многие другие компоненты Darwin с открытым исходным кодом. Нам всё ещё нужен простой загрузчик Mach-O, чтобы загружать сам dyld.
Mach-O, вместе с самим Mach, – наверно, самые заметные отличительные черты Darwin, и разнообразные библиотеки и фреймворки, поставляемые Apple, активно используют множество малоизвестных особенностей формата Mach-O. Это делает работу с Mach-O одной из самых важных и заметных задач при разработке Darling. От реализации собственных загрузчиков Mach-O до сборки компонентов Darwin (сначала в виде специальных ELF-файлов, а сейчас в виде настоящих Mach-O) – нам нужно понимать внутреннее устройство Mach-O на гораздо более глубоком уровне, чем это обычно требуется от обыкновенных разработчиков под Darwin-платформы.
Закончим на этом введение и перейдём к обсуждению некоторых из трюков, которые нам может предложить формат Mach-O.
Установочные имена
------------------
В Windows и Linux на динамические библиотеки ссылаются по их имени (например, `libc.so`), после чего задачей динамического линковщика является найти библиотеку с совпадающим именем в одной из стандартных директорий для библиотек. В Darwin вместо этого сразу используется (почти) полный путь к файлу библиотеки, который называют *установочным именем* [install name] этой библиотеки. Предположительно, так сделали, чтобы предотвратить *подмену dylib* [dylib hijacking] – атаку, при которой поддельная dylib помещается в директорию, в которой она будет найдена динамическим линковщиком раньше настоящей, что позволяет поддельной dylib выполнять произвольный код от имени программы, которую таким образом убедили эту dylib загрузить.
Не только исполняемые файлы и библиотеки хранят полные установочные имена своих зависимостей, но и Mach-O-зависимости сами «знают» свои собственные установочные имена. Собственно, именно так линковщик узнаёт, какие установочные имена использовать для зависимостей: он прочитывает их из самих зависимостей.
При линковке dylib вы указываете её установочное имя, используя опции ld `-install_name` или `-dylib_install_name`:
```
$ ld -o libfoo.dylib foo.o -install_name /usr/local/lib/libfoo.dylib
```
Теперь, когда вы будете линковать другой Mach-O-файл (скажем, `libbar.dylib`) к `libfoo.dylib`, ld запишет устаноночное имя `libfoo` – `/usr/local/lib/libfoo.dylib` – в списке зависимостей `libbar`, и именно там dyld будет искать `libfoo` во время выполнения.
Использование полного пути работает достаточно хорошо для системных библиотек, которые, действительно, устанавливаются в заранее известные места в файловой системе; но с библиотеками, которые поставляются как часть сборок приложений [app bundles], возникает проблема. Хотя каждое приложение могло бы предполагать, что оно будет установлено в `/Applications/AppName.app`, вообще говоря, имеется в виду, что сборки приложений переносимы и могут быть свободно перемещены по файловой системе, так что конкретный путь к библиотекам внутри таких сборок не может быть известен заранее.
В качестве решения этой проблемы Darwin разрешает установочным именами начинаться с `@executable_path`, `@loader_path`, или `@rpath` – то есть быть не абсолютными, а указывать путь к библиотеке относительно пути к основному исполняемому файлу, пути к «загружающему» (исполняемому файлу или библиотеке, которая напрямую зависит от этой библиотеки) или относительно списка путей, определяемого основным исполняемым файлом, соответственно. `@executable_path` и `@loader_path` работают без дополнительных сложностей, но если хотя бы одна из ваших зависимостей (или их транзитивных зависимостей) имеет установочное имя, использующее `@rpath`, вы должны явно задать `@rpath` при линковке вашего исполняемого файла, используя опцию ld `-rpath` столько раз, сколько вам нужно:
```
$ ld -o runme -rpath @executable_path/../Frameworks -rpath @executable_path/../bin/lib
```
(Концепция rpath в некоторой степени разрушает исходную идею заранее известных путей к библиотекам, и [открывает](https://www.virusbulletin.com/virusbulletin/2015/03/dylib-hijacking-os-x) возможность проведения атак по подмене dylib. Можно считать, что это делает всё, связанное с установочными именами, довольно-таки бесполезным.)
Циклические зависимости
-----------------------
Когда исходный код проекта занимает несколько файлов, совершенно нормально, если эти файлы взаимно зависят друг от друга. Это отлично работает, пока все эти файлы компилируются в один бинарник – исполняемый файл или библиотеку. Что не работает, так это когда несколько динамических библиотек зависят друг от друга.
Вы можете возразить, что вместо использования циклических зависимостей между динамическими библиотеками стоит перепроектировать архитектуру проекта, и я с вами соглашусь. Но если есть что-то типичное для Apple, так это то, что они никогда не останавливаются, чтобы всё обдумать и сделать правильно; вместо этого они наслаивают костыли и трюки один на другой. В этом случае нам для Darling нужно заставить циклические зависимости работать, поскольку разнообразные подбиблиотеки `libSystem`, такие как `libsystem_dyld`, `libsystem_kernel` и `libsystem_pthread`, все зависят друг от друга. (До недавнего времени нам также приходилось циклически линковать Cocoa-фреймворки, такие как AppKit, Core Graphics и Core OpenGL, из-за того, как реализован Core OpenGL в The Cocotron, но мы [перепроектировали](https://github.com/darlinghq/darling/issues/365) архитектуру нашей реализации Core OpenGL и смогли избавиться от этой циклической зависимости.)
В принципе, циклические зависимости должны работать нормально: динамический линковщик уже умеет загружать каждую библиотеку только один раз, так что у него не будет проблем с бесконечной рекурсией. Проблема в том, что такие библиотеки нельзя просто так *слинковать*, поскольку каждый вызов линковщика создаёт только одну библиотеку, и при линковке любого бинарника нужно передать линковщику все его зависимости, уже слинкованные. Мы должны линковать одну из наших библиотек первой, и в этот момент остальные ещё не готовы, поэтому мы не сможем передать их линковщику.
Трюк здесь состоит в том, чтобы линковать некоторые (или для простоты, все) из этих библиотек *дважды*. В первый раз скажите линковщику игнорировать недостающие зависимости, и действительно, не передавайте зависимостей:
```
$ ld -o libfoo.dylib foo.o -flat_namespace -undefined suppress
$ ld -o libbar.dylib bar.o -flat_namespace -undefined suppress
```
(Смотрите ниже насчёт `-flat_namespace`.)
Конечно, если вы попробуете напрямую использовать получившиеся dylib-ки, вы получите ошибки динамической линковки во время выполнения. Вместо этого перелинкуйте эти библиотеки во второй раз, передавая полученные dylib-ки в качестве зависимостей:
```
$ ld -o libfoo.dylib foo.o libbar.dylib
$ ld -o libbar.dylib bar.o libfoo.dylib
```
На этот раз линковщик видит все символы, поэтому мы не говорим ему игнорировать ошибки (и если каких-то символов действительно не хватает, вы получите ошибку).
Не смотря на то что некоторые, если не все, из библиотек слинковались к «неправильным» копиям своих зависимостей, во время выполнения dyld увидит правильные версии. Чтобы это сработало, удостоверьтесь, что у обеих копий каждой библиотеки одинаковое установочное имя.
Ещё одна деталь здесь – порядок инициализации. Любой код может объявить функции-инициализаторы используя магическую команду компилятора `__attribute__((constructor))` (список таких инициализаторов попадает в секцию `__mod_init_func` в Mach-O-файле). Эти функции вызываются dyld при загрузке бинарника, в котором они находятся, перед вызовом `main()`. Обычно, инициализаторы каждой библиотеки выполняются после инициализаторов её зависимостей, поэтому каждый инициализатор может рассчитывать на то, что библиотеки-зависимости уже инициализированы и готовы к работе. Конечно, этого нельзя гарантировать для циклических зависимостей; dyld выполнит их инициализаторы в *каком-то* порядке. Вы можете отмечать зависимости как *зависимости вверх* [upward dependencies], чтобы настроить этот порядок; dyld проинициализирует библиотеки, которые кто-нибудь отметил как свою зависимость вверх, последними. Так что, чтобы заставить `libfoo` проинициализироваться после `libbar`, слинкуйте их так:
```
$ ld -o libfoo.dylib foo.o libbar.dylib
$ ld -o libbar.dylib bar.o -upward_library libfoo.dylib
```
Чтобы сделать всё это удобнее, у нас в Darling есть CMake-функция под названием [`add_circular`](https://github.com/darlinghq/darling/blob/master/cmake/darling_lib.cmake#L54L124), которая берёт на себя все сложности и позволяет использовать её вот так просто и декларативно:
```
set(DYLIB_INSTALL_NAME "/usr/lib/system/libdispatch.dylib")
add_circular(libdispatch_shared FAT
SOURCES
${dispatch_SRCS}
SIBLINGS
system_c
system_kernel
system_malloc
system_blocks
system_pthread
system_dyld
system_duct
unwind
platform
compiler_rt
UPWARD
objc
)
```
Двухуровневое пространство имён символов
----------------------------------------
Таблицы символов в Mach-O не просто хранят имена символов, они ещё и «помнят», из какой библиотеки (или исполняемого файла) какой символ берётся. Другими словами, имена символов существуют в пространствах имён, задаваемых тем, какой бинарник их определяет; отсюда «двухуровневое пространство имён» [two-level namespace] (под ещё одним уровнем имеются в виду сами имена символов).
Двухуровневое пространство имён [ввели](http://mirror.informatimago.com/next/developer.apple.com/releasenotes/DeveloperTools/TwoLevelNamespaces.html) для предотвращения конфликтов имён символов. Обычно, если несколько библиотек определяют символы с одинаковым именем, вы получите ошибку во время линковки; но это может не сработать, если загружать библиотеки во время выполнения (например, плагины) или когда версии библиотек во время линковки и время выполнения различаются. Для библиотек, которые используют двухуровневое пространство имён, это не проблема – оно позволяет нескольким библиотекам определять символы с одинаковым именем, не создавая конфликтов.
Двухуровневое пространство имён можно отключить, вернувшись к использованию «плоского пространства имён» (одна из причин это сделать – то, что использование двухуровневого пространства имён подразумевает, что каждый символ должен быть разрешён во время линковки, поэтому для `-undefined_suppress` требуется плоское пространство имён, как мы видели выше). У ld есть два флага, позволяющие отключить двухуровневое пространство имён во время линковки: `-flat_namespace`, который влияет только на один Mach-O-файл, и `-force_flat_namespace`, который работает только с исполняемыми файлами, а не библиотеками, и заставляет весь процесс использовать плоское пространство имён. Кроме того, можно во время выполнения заставить dyld использовать плоское пространство имён, если установить переменную окружения `DYLD_FORCE_FLAT_NAMESPACE`.
Одна особенность использования двухуровневого пространства имён состоит в том, что вам всегда приходится явно линковать каждый Mach-O ко всем библиотекам и фреймворкам, от которых он зависит. Например, если вы линкуетесь к AppKit, вы не сможете просто так использовать Foundation; вам придётся прилинковаться явно и к ней. Другая особенность – в том, что, как автор библиотеки или фреймворка, вы не можете свободно перемещать реализацию символа «вниз» по цепочке зависимостей, как вы могли привыкнуть делать (например, нельзя просто так перемещать код из AppKit в Foundation). Чтобы позволить делать это, у Mach-O, ld и dyld есть несколько дополнительных возможностей, а именно *подбиблиотеки*, *переэкспортирование символов* и *мета-символы*.
Подбиблиотеки
-------------
Подбиблиотеки – механизм, позволяющий одной библиотеке (называемой *фасадной* библиотекой [facade library] или umbrella-библиотекой [umbrella library]) делегировать реализацию части своей функциональности другой библиотеке (называемой её *подбиблиотекой* [sub-library]); или, если на это посмотреть с другой стороны, позволяющий библиотеке публично переэкспортировать символы, предоставляемые другой библиотекой.
Основное место, где это используется – опять же, `libSystem` с её подбиблиотеками, которые лежат в `/usr/lib/system`; но это можно использовать с любой парой библиотек:
```
$ ld -o libfoo.dylib foo.o -lobjc -sub_library libobjc
# или:
$ ld -o libfoo.dylib foo.o -reexport-lobjc
```
Единственное, на что это влияет по сравнению с просто линковкой к той библиотеке – это что в результирующий файл записывается команда `LC_REEXPORT_DYLIB` вместо обычной `LC_LOAD_DYLIB` (в том числе, символы из подбиблиотеки во время линковки *не* копируются в umbrella-библиотеку, так что её даже не приходится перелинковывать, если в подбиблиотеку позднее добавляются новые символы). Во время выполнения `LC_REEXPORT_DYLIB` тоже работает похоже на `LC_LOAD_DYLIB`: dyld загрузит подбиблиотеку и сделает её символы доступными остальным (но в отличие от `LC_LOAD_DYLIB`, с точки зрения двухуровневого пространства имён символы будут происходить из umbrella-библиотеки).
Что действительно отличается насчёт `LC_REEXPORT_DYLIB` – это что ld делает, когда вы линкуете *ещё одну* библиотеку к `libfoo`: вместо того, чтобы просто искать символы во всех объектных и dylib-файлах, которые ему передали, ld также откроет и просмотрит и переэкспортированную подбиблиотеку (в этом примере `libobjc`).
Откуда он знает, где её искать? Единственное, что сохранено в `libfoo.dylib` – это установочное имя `libobjc.dylib`, поэтому именно там ld ожидает её найти. Это означает, что библиотека должна быть установлена на своё место, прежде чем её можно будет использовать в качестве подбиблиотеки для чего угодно ещё; это нормально работает для системных библиотек вроде `libobjc`, но может быть очень неудобно или совсем невозможно, если вы пытаетесь переэкспортировать собственную подбиблиотеку.
Чтобы решить эту проблему, ld предоставляет опцию `-dylib_file`, которая позволяет вам указать другой путь к dylib для использования во время линковки:
```
$ ld -o libfoo.dylib foo.o -reexport_library /path/to/libsubfoo.dylib
$ ld -o libbar.dylib bar.o libfoo.dylib -dylib_file @executable_path/lib/foo/libsubfoo.dylib:/path/to/libsubfoo.dylib
```
Хотя `libSystem` и некоторые другие системные библиотеки переэкспортируют свои подбиблиотеки, вам не приходится использовать `-dylib_file` при линковке каждого из исполняемых файлов на macOS; это потому, что системные библиотеки уже установлены в соответствии со своим установочным именем. Но при сборке Darling на Linux нам приходится передавать несколько опций `-dylib_file` (и других общих аргументов) каждому вызову ld. Мы делаем это при помощи [специальной функции](https://github.com/darlinghq/darling/blob/master/cmake/use_ld64.cmake), которая автоматически применяется при использовании `add_darling_library`, `add_darling_executable` и других.
Переэкспортирование символов
----------------------------
Иногда библиотеке может быть нужно переэкспортировать часть символов – но не сразу всё – из другой библиотеки. Например, Core Foundation переэкспортирует `NSObject`, который в последних версиях реализован внутри Objective-C runtime, ради совместимости.
(Если вас интересует, почему `NSObject` вообще когда-то был в Core Foundation вместо Foundation, то это из-за того, что то, как реализована *бесплатная конвертация* [toll-free bridging, возможность напрямую кастовать между соответствующими Core Foundation и Foundation-типами без дополнительной конвертации], требует, чтобы приватные классы-обёртки над типами из Core Foundation (например, `__NSCFString`) были реализованы в Core Foundation; а будучи Objective-C-объектами, они должны наследоваться от `NSObject`. Наверно, всё это можно было бы реализовать по-другому, оставив `NSObject` со всеми его наследниками в Foundation и циклически слинковав Core Foundation и Foundation, но Apple решили перенести эти вспомогательные приватные классы вместе с `NSObject` в Core Foundation, и в Darling мы делаем это точно так же, чтобы сохранить совместимость.)
Вы можете передать ld список символов, которые нужно переэкспортировать, используя его опцию `-reexported_symbols_list`:
```
$ echo .objc_class_name_NSObject > reexport_list.exp
$ ld -o CoreFoundation CFFiles.o -lobjc -reexported_symbols_list reexport_list.exp
```
Хотя переэкспортирование *некоторых* символов звучит очень похоже на переэкспортирование *всех* символов, механизм, с помощью которого это реализовано, сильно отличается от того, как работают подбиблиотеки. Не используется никакой специальной `LC_*_DYLIB`-команды; вместо этого, в таблицу имён вставляется специальный *косвенный символ* (обозначаемый флагом `N_INDIR`), и он ведёт себя как символ, определённый в этой библиотеке. Если сама библиотека использует этот символ, в таблице имён окажется *вторая*, «неопределённая» копия символа (как это происходит и без всякого переэкспортирования).
Одна важная мелочь, о которой стоит помнить при использовании явного переэкспортирования символов – вам, скорее всего, нужно переэкспортировать символы с разными именами для разных архитектур. Действительно, соглашение о преобразовании имён [name mangling convention] для Objective-C и бинарный интерфейс [ABI] Objective-C для архитектур i386 и x86-64 различаются, так что на i386 вам нужно переэкспортировать только `.objc_class_name_NSObject`, а на x86-64 – `_OBJC_CLASS_$_NSObject`, `_OBJC_IVAR_$_NSObject.isa` и `_OBJC_METACLASS_$_NSObject`. Об этом не приходится думать при использовании подбиблиотек, поскольку там автоматически переэкспортируются все доступные символы для каждой архитектуры.
Большинство инструментов для работы с Mach-O прозрачно разбираются с «толстыми», или универсальными, бинарниками (файлами Mach-O, содержащими несколько под-Mach-O для нескольких архитектур). Clang может собирать универсальные бинарники со всеми запрошенными архитектурами, dyld выбирает, какую архитектуру загружать из dylib, глядя на то, какие архитектуры поддерживает исполняемый файл, а такие инструменты, как ld, otool и nm работают с архитектурой, соответствующей архитектуре компьютера (т.е. x86-64), если явно не потребовать другую архитектуру специальным флагом. Единственное, что всё-таки напоминает о том, что обрабатываются несколько архитектур – это то, что при компиляции вы получаете ошибки и предупреждения дважды, по одному разу для каждой архитектуры.
Необходимость передавать два разных списка переэкспортирования разрушает эту иллюзию. У ld нет встроенной опции для использования разных списков для разных архитектур, что означает, что нам придётся линковать dylib-ки для каждой архитектуры отдельно и потом объединять их с помощью lipo:
```
$ ld -o CF_i386.dylib CFFiles.o -arch i386 -lobjc -reexported_symbols_list reexport_i386.exp
$ ld -o CF_x86-64.dylib CFFiles.o -arch x86_64 -lobjc -reexported_symbols_list reexport_x86_64.exp
$ lipo -arch i386 CF_i386.dylib -arch x86_64 CF_x86-64.dylib -create -output CoreFoundation
```
В Darling мы используем CMake-функцию под названием [`add_separated_framework`](https://github.com/darlinghq/darling/blob/master/cmake/darling_framework.cmake#L68-L145), абстрагирующую внутри себя раздельную линковку и вызов lipo, так что настоящий CMake-скрипт для сборки Core Foundation [выглядит примерно так](https://github.com/darlinghq/darling-corefoundation/blob/master/CMakeLists.txt):
```
add_separated_framework(CoreFoundation
CURRENT_VERSION
SOURCES
${cf_sources}
VERSION "A"
DEPENDENCIES
objc
system
icucore
LINK_FLAGS
# ...здесь остальные общие флаги
)
set_property(TARGET CoreFoundation_i386 APPEND_STRING PROPERTY
LINK_FLAGS " -Wl,-reexported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/reexport_i386.exp")
set_property(TARGET CoreFoundation_x86_64 APPEND_STRING PROPERTY
LINK_FLAGS " -Wl,-reexported_symbols_list,${CMAKE_CURRENT_SOURCE_DIR}/reexport_x86_64.exp")
```
Мета-символы
------------
Мета-символы – ещё одна особенность, добавленная, чтобы дать Apple возможность перемещать символы и библиотеки, не ломая старый код.
При сборке Mach-O-файла всегда стоит указывать самую раннюю версию macOS, которую он поддерживает, с помощью опции компилятора `-mmacosx-version-min=10.x` (или аналогичных опций для iOS, tvOS, watchOS и остальных названий ОС, которые Apple в будущем придумает для своих продуктов). Эта опция контролирует несколько вещей; в том числе, она включает и выключает разнообразные макросы доступности вроде `AVAILABLE_MAC_OS_X_VERSION_10_13_AND_LATER` и переключает реализацию стандартной библиотеки C++ между `libstdc++` (версия от GNU) и `libc++` (версия от LLVM). В этом посте нас интересует то, как она влияет на линковщик и получаемый Mach-O. Среди прочего, и у ld есть опция `-macosx_version_min` (обратите внимание на символы подчёркивания и отсутствие второй `m`), которая заставляет его выдать Mach-O-команду `LC_VERSION_MIN_MACOSX` (сообщающую dyld, что следует выбросить ошибку, если этот файл загружается на более ранней версии).
В дополнение к этому, передача ld опции `-macosx_version_min` влияет на то, какие мета-символы *других* Mach-O-файлов учитываются. Мета-символы – это символы, имена которых начинаются с `$ld$`, и ld, когда встречает такой символ, обрабатывает его особенным образом: он считает его дополнительной командой, а не символом. Его имя должно иметь форму `$ld$действие$условие$имя`. Здесь `условие` выглядит как `os10.5` и определяет, для какой версии ОС предназначен этот мета-символ – точнее говоря, этот символ будет учтён только если заявленная *минимальная* поддерживаемая линкуемым Mach-O-файлом версия ОС *равна* версии, указанной этим символом; `действие` может быть `add`, `hide`, `install_name` или `compatibility_version`, что заставляет ld притвориться, что он видит или не видит символ с именем `имя`, использовать `имя` в качестве установочного имени или в качестве версии совместимости (смотрите ниже) этой бибилиотеки, соответственно.
Поскольку `условие` не может описывать промежуток версий, вы, скорее всего, увидите одно и то же действие повторённым множество раз для разных версий ОС; например, вот список мета-символов, которые использует `libobjc`, чтобы спрятать `NSObject` от кода, рассчитанного на более ранние версии macOS:
```
$ld$hide$os10.0$_OBJC_CLASS_$_NSObject
$ld$hide$os10.0$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.0$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.1$_OBJC_CLASS_$_NSObject
$ld$hide$os10.1$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.1$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.2$_OBJC_CLASS_$_NSObject
$ld$hide$os10.2$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.2$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.3$_OBJC_CLASS_$_NSObject
$ld$hide$os10.3$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.3$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.4$_OBJC_CLASS_$_NSObject
$ld$hide$os10.4$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.4$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.5$_OBJC_CLASS_$_NSObject
$ld$hide$os10.5$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.5$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.6$_OBJC_CLASS_$_NSObject
$ld$hide$os10.6$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.6$_OBJC_METACLASS_$_NSObject
$ld$hide$os10.7$_OBJC_CLASS_$_NSObject
$ld$hide$os10.7$_OBJC_IVAR_$_NSObject.isa
$ld$hide$os10.7$_OBJC_METACLASS_$_NSObject
```
Вряд ли вы найдёте эту возможность полезной для вашего собственного кода, но понимание того, как она работает, может помочь вам расшифровывать те загадочные ошибки о недостающих символах, когда символы *очевидно* на своём месте.
Резолверы символов
------------------
Ещё одна довольно интересная особенность dyld – его поддержка *резолверов символов* [symbol resolvers], способа кастомизации процесса разрешения символов. Вы пишете резолвер символа, специальную функцию, которая может реализовывать любую кастомную логику для нахождения адреса символа, и dyld вызывает её во время выполнения, когда требуется разрешить этот символ.
Для использования резолверов символов не нужны хитрые флаги ld, это полностью делается в коде. На уровне ассемблера резолверы символов создаются путём использования специальной [псевдооперации](https://sourceware.org/binutils/docs/as/Pseudo-Ops.html) `.symbol_resolver`:
```
; две разных реализации foo
_foo1:
movl 1, %eax
ret
_foo2:
movl 2, %eax
ret
.symbol_resolver _foo
; проверяем какое-нибудь условие
call _condition
jz .ret_foo2
movq _foo1, %rax
ret
.ret_foo2:
movq _foo2, %rax
ret
; Нам также нужно, чтобы сам _foo присутствовал
; в таблице символов, но его значение не важно,
; поскольку его заменит результат резолвера.
.global _foo
_foo:
```
Поскольку на уровне C для резолверов символов нет никакой специальной поддержки со стороны компилятора, приходится использовать ассемблерные вставки, чтобы сделать это из C:
```
static int foo1() {
return 1;
}
static int foo2() {
return 2;
}
int foo() {
// тело этой функции ни на что не влияет
return 0;
}
static void *foo_resolver() {
__asm__(".symbol_resolver _foo");
return condition() ? &foo1 : &foo2
}
```
(В ассемблерном коде мы пишем `_foo` вместо просто `foo`, потому что под Darwin действует соглашение о преобразовании имён даже для C, состоящее в добавлении к каждому имени символа подчёркивания в начале. До того, как мы перешли на использование Mach-O для внутренних компонентов Darling, нам приходилось добавлять и отрезать назад это подчёркивание при работе с ELF-файлами, что принесло нам немало боли.)
Поскольку содержимое `_foo` ни на что не влияет, как ни на что не влияет и имя резолвера (а в ассемблерном листинге выше у него и вовсе не было имени), обычно `foo()` и `foo_resolver()` объединяют в одно определение функции, вот так:
```
void *foo() {
__asm__(".symbol_resolver _foo");
return condition() ? &foo1 : &foo2
}
```
Один недостаток того, чтобы так делать – вы можете получить ошибки из-за того, что прототип `foo()` отличается от того, что указан в заголовочном файле (здесь она возвращает обобщённый указатель вместо `int`-а). Кроме того, обратите внимание, что работающая здесь магия не особо надёжна: вызов `dlsym("_foo")` вернёт исходный адрес `_foo` – тот самый, про который мы только что решили, что он ни на что не влияет, – так что в этом случае это будет адрес резолвера. Наверно, если вам нужно заботиться об этом случае, более осмысленным будет сделать, чтобы одна из потенциальных реализаций `foo()` играла роль символа `_foo`.
Можно представить себе всевозможные креативные способы использования резолверов символов. Сами Apple используют их в `libplatform` для выбора наиболее эффективной реализации примитивов блокировки во время выполнения на основе обнаруженных количества ядер процессора и поддержки им наборов инструкций:
```
#define _OS_VARIANT_RESOLVER(s, v, ...) \
__attribute__((visibility(OS_STRINGIFY(v)))) extern void* s(void); \
void* s(void) { \
__asm__(".symbol_resolver _" OS_STRINGIFY(s)); \
__VA_ARGS__ \
}
#define _OS_VARIANT_UPMP_RESOLVER(s, v) \
_OS_VARIANT_RESOLVER(s, v, \
uint32_t *_c = (void*)(uintptr_t)_COMM_PAGE_CPU_CAPABILITIES; \
if (*_c & kUP) { \
extern void OS_VARIANT(s, up)(void); \
return &OS_VARIANT(s, up); \
} else { \
extern void OS_VARIANT(s, mp)(void); \
return &OS_VARIANT(s, mp); \
})
```
Эти макросы генерируют резолверы, проверяющие – во время выполнения – является ли машина однопроцессорной (по наличию флага `kUP` в дескрипторе возможностей процессора, расположенном на [commpage](https://wiki.darlinghq.org/documentation:commpage)), чтобы, например, использовать немного более эффективную реализацию спинлока [spinlock]. Эта проверка выполняется только один раз для каждого символа при его загрузке, после чего символ напрямую привязывается к выбранной реализации и последующие вызовы не требуют дополнительных накладных расходов.
В Darling мы дополнительно используем резолверы символов для ещё более амбициозной задачи: чтобы позволить нашим Mach-O-бинарникам прозрачно использовать ELF-библиотеки из Linux, установленного на хосте [host, что противопоставляется изолированному контейнеру, в котором собственно и работает Darling] – библиотеки, такие как `libX11` и `libcairo`.
Первый шаг к использованию ELF-библиотек – это [`libelfloader`](https://github.com/darlinghq/darling/tree/master/src/libelfloader), наша реализация простого загрузчика ELF, у которой как раз достаточно функциональности для того, чтобы загрузить ld-linux, аналог dyld из Linux, и прыгнуть в ld-linux для загрузки самих нужных нам ELF-библиотек. Мы собираем сам `libelfloader` в Mach-O и устанавливаем его как `/usr/lib/darling/libelfloader.dylib` внутри нашей Darwin-chroot-директории; таким образом, его можно напрямую использовать из нашего Darwin-кода.
Важная деталь здесь в том, что `libelfloader` намеренно *не* объединяет пространства имён символов Mach-O и ELF. Кроме одного указателя (`_elfcalls`), запрятанного [в глубине](https://github.com/darlinghq/darling/blob/master/src/kernel/emulation/linux/elfcalls_wrapper.c) `libSystem`, весь Darwin остаётся в блаженном неведении насчёт того, что в адресное пространство теперь отображены несколько ELF-библиотек для Linux. «Миры» Darwin и Linux на удивление мирно сосуществуют в рамках одного процесса – в том числе, каждый использует свою собственную библиотеку C (`libSystem_c` и `glibc`, соответственно).
Чтобы получить доступ к ELF-символам из мира Darwin, можно использовать заклинания-вызовы `libelfloader` API вроде `_elfcalls->dlsym_fatal(_elfcalls->dlopen_fatal("libX11.so"), "XOpenDisplay")`. Дальше, у нас есть инструмент под названием [wrapgen](https://github.com/darlinghq/darling/blob/master/src/libelfloader/wrapgen/wrapgen.cpp), делающий использование ELF-символов проще и гораздо прозрачнее, и позволяющий нам использовать код других проектов, таких как The Cocotron – которые могут ожидать иметь возможность напрямую вызывать библиотеки для Linux – без серьёзных изменений. Если передать wrapgen название ELF-библиотеки (например, `libX11.so`), он достаёт список её символов и автоматически генерерует код вроде такого:
```
#include
extern struct elf\_calls\* \_elfcalls;
static void\* lib\_handle;
\_\_attribute\_\_((constructor)) static void initializer() {
lib\_handle = \_elfcalls->dlopen\_fatal("libX11.so");
}
\_\_attribute\_\_((destructor)) static void destructor() {
\_elfcalls->dlclose\_fatal(lib\_handle);
}
void\* XOpenDisplay() {
\_\_asm\_\_(".symbol\_resolver \_XOpenDisplay");
return \_elfcalls->dlsym\_fatal(lib\_handle, "XOpenDisplay");
}
```
Дальше мы собираем этот код в Mach-O-библиотеку и устанавливаем её в `/usr/lib/native/libX11.dylib`, и другие Mach-O-библиотеки могут просто линковаться к ней, как будто она и *есть* `libX11.so`, магически превращённая в Mach-O. Само собой, у нас есть CMake-функция под названием [`wrap_elf`](https://github.com/darlinghq/darling/blob/master/cmake/wrap_elf.cmake), которая упрощает вызов wrapgen, сборку Mach-O-заглушки и установку её в `/usr/lib/native`: вы просто [вызываете](https://github.com/darlinghq/darling/blob/master/src/native/CMakeLists.txt) `wrap_elf(X11 libX11.so)` и линкуете другие библиотеки к `libX11`, как если бы это была просто ещё одна Mach-O-библиотека.
Возможность загружать и использовать библиотеки для Linux настолько просто и прозрачно ощущается как обладание *суперспособностью*. Как я уже упомянул, в прошлом Darling был тонкой прослойкой, почти напрямую отображавшей библиотечные функции Darwin на библиотечные функции Linux, но те дни давно прошли. Теперь Darling – это очень совместимая реализация Darwin (а точнее, порт Darwin); благодаря, отчасти, тому, что мы можем напрямую переиспользовать большие части оригинального исходного кода Darwin, такие как `libSystem`, dyld, XNU и launchd, а отчасти нашей готовности реализовывать множество недокументированных мелочей, которые нужны для этого кода, вроде вышеупомянутой commpage. И хотя некоторым очень низкоуровневым частям стека, таким как `libsystem_kernel`, приходится разбираться с тем, что на самом деле они запущены поверх ядра Linux, большинство кода «видит» только обычное Darwin-окружение – Linux и GNU/Linux нигде не найти. И именно поэтому прямой и лёгкий доступ к нативной Linux-библиотеке или подключение к сервису, запущенному под Linux на хосте (такому как X server) ощущается как вынимание кролика из шляпы, как наблюдение за фокусом [witnessing a magic trick] – чем эти трюки с `libelfloader`, резолверами символов и wrapgen, собственно, и являются. Но это фокус, который становится только более, а не менее, впечатляющим, когда узнаёшь, как он работает.
Порядок символов
----------------
Если вы зачем-то полагаетесь на порядок, в котором символы окажутся в Mach-O-файле, вы можете поручить ld расположить их именно в таком порядке. (Я считаю, что полагаться на это – *нездоровая* идея, но Apple, конечно же, думает иначе.)
Чтобы сделать это, запишите список символов, для которых требуется специальный порядок, в этом порядке в специальный файл, называемый *файлом порядка* [order file], и потом передайте его ld вот таким образом:
```
$ ld -o libfoo.dylib foo.o -order_file foo.order
```
В отличие от опции `-reexported_symbols_list`, про которую шла речь выше, `-order_file` поддерживает больше, чем просто список имён:
```
symbol1
symbol2
# Это комментарий.
#
# Вы можете явно указать, к какому файлу относится символ,
# иначе имена приватных (называемые статическими в C) символов
# могут встретиться несколько раз в разных объектных файлах.
foo.o: _static_function3
# Кроме того, вы можете сделать, чтобы строка с символом
# учитывалась только на указанной архитектуре; так что вам
# не придётся использовать раздельную линковку и вручную
# запускать lipo, как приходилось для переэкспортирования
# символов.
i386:symbol4
```
Переупорядочивание символов (а точнее, блоков кода и данных, отмеченных символами) осмысленно только если ничто не рассчитывает на возможность «провалиться» из содержимого одного символа напрямую в содержимое следующего. Такая техника часто используется во вручную написанном ассемблерном коде, но компиляторы предпочитают не полагаться но это, и чтобы явно обозначить, что код в файле не требует этой возможности, компиляторы обычно выдают специальную ассемблерную директиву `.subsections_via_symbols`, что отмечает генерируемый Mach-O-файл как содержащий символы, которые могут быть свободно переупорядочены, удалены, если не используются, и так далее.
Одно из мест, где сами Apple пользуются переупорядочиванием символов – реализация бесплатной конвертации в `libdispatch`. `libdispatch` реализует свою собственную объектную модель, «OS object», с помощью огромного количества макросов, разбросанных по нескольким файлам с исходным кодом. Эта модель в некоторой степени совместима с объектной моделью Objective-C, поэтому `libdispatch` также реализует *бесплатную конвертацию* (напоминающую бесплатную конвертацию из Core Foundation), возможность напрямую кастовать некоторые `libdispatch`-объекты в Objective-C-объекты и отправлять им сообщения, как и любым настоящим Objective-C-объектам. В частности, можно напрямую кастовать объекты типа `dispatch_data_t` к `NSData *` и использовать их с любыми API из Cocoa (но не в обратную сторону).
Бесплатная конвертация [реализована](https://github.com/darlinghq/darling-libdispatch/blob/master/src/object_internal.h) с помощью чудовищного количества костылей, некоторые из которых требуют, чтобы символы Objective-C-классов и соответствующие *OS object vtables* были расположены в фиксированном порядке. В том числе, там есть макрос [`DISPATCH_OBJECT_TFB`](https://github.com/darlinghq/darling-libdispatch/blob/master/src/object_internal.h#L509-L516), проверяющий, происходит ли Objective-C объект из бесплатно конвертируемого `libdispatch`-класса, путём сравнения его `isa` с `vtable`-ами `dispatch_object` и `object`:
```
#define DISPATCH_OBJECT_TFB(f, o, ...) \
if (slowpath((uintptr_t)((o)._os_obj->os_obj_isa) & 1) || \
slowpath((Class)((o)._os_obj->os_obj_isa) < \
(Class)OS_OBJECT_VTABLE(dispatch_object)) || \
slowpath((Class)((o)._os_obj->os_obj_isa) >= \
(Class)OS_OBJECT_VTABLE(object))) { \
return f((o), ##__VA_ARGS__); \
}
```
[Вот файл порядка](https://github.com/darlinghq/darling-libdispatch/blob/master/xcodeconfig/libdispatch.order), который они используют, чтобы так упорядочить символы `libdispatch`.
Подмена символов
----------------
Обычный способ принудительно подменить реализацию функции (или содержимое любого символа) – использовать переменную окружения `DYLD_INSERT_LIBRARIES`, заставляющую dyld загрузить в процесс переданные Mach-O-файлы и дать им более высокий приоритет при разрешении имён символов. Конечно, этот более высокий приоритет не будет работать с бинарниками, использующими двухуровневое пространство имён, так что этот приём наиболее полезен в сочетании с `DYLD_FORCE_FLAT_NAMESPACE`.
Большинство задач, для которых применяется подмена реализации функции, включают в себя *обёртывание* функцией-заменителем оригинальной реализации. Чтобы вызвать оригинальную реализацию (а не саму обёртку), обёртка обычно использует вызов `dlsym()` с флагом `RTLD_NEXT`, как здесь:
```
int open(const char* path, int flags, mode_t mode) {
printf("Вызвано open(%s)\n", path);
// "Виртуальная символьная ссылка"
if (strcmp(path, "foo") == 0) {
path = "bar";
}
int (*original_open)(const char *, int, mode_t);
original_open = dlsym(RTLD_NEXT, "open");
return original_open(path, flags, mode);
}
```
В дополнение к этому, dyld предоставляет другой способ подмены символов, называемый *dyld-подменой* [dyld iterposing]. Если в любом из загруженных Mach-O-файлов есть секция `__interpose`, dyld воспримет её содержимое как пары указателей, каждая из которых – команда подменить реализацию символа.
С одной стороны, этот метод не требует переменных окружения – достаточно, чтобы в любой из библиотек была секция `__interpose` – поэтому его называют *неявной подменой* [implicit interposing]. С другой стороны, секция `__interpose` явно выражает желание подменить реализации символов (а не просто загрузить дополнительные библиотеки), поэтому dyld может обрабатывать этот случай более умно. В частности, dyld-подмена *работает* с двухуровневым пространством имён и не требует, чтобы имена исходного символа и символа-замены совпадали. Больше того, dyld достаточно умён, чтобы заставить это имя символа по-прежнему указывать на исходную реализацию, если использовать его внутри функции-заменителя (и всего этого Mach-O-файла):
```
static int my_open(const char* path, int flags, mode_t mode) {
printf("Called open(%s)\n", path);
// "Виртуальная символьная ссылка"
if (strcmp(path, "foo") == 0) {
path = "bar";
}
// Это вызывает оригинальную реализацию, несмотря на то
// что open() в других местах теперь вызывает my_open().
return open(path, flags, mode);
}
// помещаем пару указателей в секции __interpose
__attribute__ ((section ("__DATA,__interpose")))
static struct {
void *replacement, *replacee;
} replace_pair = { my_open, open };
```
Обратите внимание, что указатель на заменяемый символ – как и любое обращение к символу из другого файла – на самом деле будет сохранено в Mach-O-файл как значение-заглушка и соответствующая ему запись в таблице перемещений [relocation table]. Запись о перемещении ссылается на символ по имени, и отсюда dyld и получает полное имя символа (с учётом двухуровневого пространства имён), к которому нужно применить подмену.
Альтернативно, существует приватная функция под названием `dyld_dynamic_interpose`, позволяющая произвольно подменять символы во время выполнения:
```
typedef struct {
void *replacement, *replacee;
} replacement_tuple;
extern const struct mach_header __dso_handle;
extern void dyld_dynamic_interpose(const struct mach_header*,
const replacement_tuple replacements[],
size_t count);
void interpose() {
replacement_tuple replace_pair = { my_open, open };
dyld_dynamic_interpose(&__dso_handle, &replace_pair, 1);
}
```
Конечно, любые указатели на заменяемый символ, которые код сохранит во время выполнения до проведения подмены, продолжат указывать на исходный символ.
`DYLD_INSERT_LIBRARIES` и dyld-подмена не настолько полезны при работе с кодом на Objective-C, как для C, частично из-за того, что сложно напрямую сослаться на реализацию Objective-C-метода (`IMP`), частично потому что Objective-C предоставляет свой собственный способ замены реализации методов, а именно *method swizzling* (и *isa swizzling*).
Мы используем подмену символов в Darling в качестве детали реализации xtrace, нашего инструмента для трассировки эмулированных системных вызовов.
Программы для Darwin используют системные вызовы Darwin (которые бывают двух видов – системные вызовы BSD и так называемые Mach-ловушки [Mach traps]). Для этого они вызывают специальные функции из `libsystem_kernel`, где реализован ABI системных вызовов со стороны userspace. Под Darling, наша специальная версия `libsystem_kernel` [переводит](https://github.com/darlinghq/darling/tree/master/src/kernel/emulation/linux) эти системные вызовы Darwin в обычные системные вызовы Linux и обращения к [Darling-Mach](https://github.com/darlinghq/darling-newlkm), нашему модулю ядра Linux, эмулирующему Mach со стороны ядра.
strace, популярный инструмент для трассировки процессов под Linux, может отображать системные вызовы, совершаемые Linux-процессом; использование strace с программой для Darwin, запущенной под Darling, выдаёт трассу системных вызовов Linux, совершаемых нашим кодом эмуляции системных вызовов Darwin (а также системных вызовов Linux, совершаемых любыми загруженными ELF-библиотеками напрямую). Это очень полезно, но системные вызовы Darwin и Linux не всегда прямо соответствуют друг другу, и часто видеть, какие системные вызовы Darwin делает программа – до того, как они проходят через слой эмуляции – может оказаться предпочтительнее.
Для этого у нас есть свой собственный трассировщик, [xtrace](https://github.com/darlinghq/darling/tree/master/src/xtrace). В отличие от strace, который не требует кооперации со стороны трассируемого процесса за счёт того, что использует `ptrace()` API, xtrace нужно подцепиться к слою эмуляции системных вызов внутри этого процесса. Для этого он [использует](https://github.com/darlinghq/darling/blob/master/src/xtrace/xtrace) `DYLD_INSERT_LIBRARIES=/usr/lib/darling/libxtrace.dylib`, подменяя несколько функций-трамплинов [trampoline functions] из слоя эмуляции системных вызовов на версии, которые логируют совершаемый системный вызов и его результат. Хотя xtrace не настолько продвинут, как strace, в плане форматирования аргументов и возвращаемых значений, он отображает достаточно базовой информации для того, чтобы быть полезным:
```
Darling [~]$ xtrace arch
<...обрезано...>
[223] mach_timebase_info_trap (...)
[223] mach_timebase_info_trap () -> KERN_SUCCESS
[223] issetugid (...)
[223] issetugid () -> 0
[223] host_self_trap ()
[223] host_self_trap () -> port right 2563
[223] mach_msg_trap (...)
[223] mach_msg_trap () -> KERN_SUCCESS
[223] _kernelrpc_mach_port_deallocate_trap (task=2563, name=-6)
[223] _kernelrpc_mach_port_deallocate_trap () -> KERN_SUCCESS
[223] ioctl (...)
[223] ioctl () -> 0
[223] fstat64 (...)
[223] fstat64 () -> 0
[223] ioctl (...)
[223] ioctl () -> 0
[223] write_nocancel (...)
i386
[223] write_nocancel () -> 5
[223] exit (...)
```
Здесь вы можете видеть, как процесс использует несколько системных вызовов BSD и Mach. Часть из них, такие как `write()` и `exit()`, просто отображаются на свои Linux-аналоги, а для других нужна более сложная трансляция. Например, все Mach-ловушки переводятся в `ioctl`-ы на устройстве `/dev/mach`, реализованном в нашем модуле ядра; а вызовы BSD-шного `ioctl()`, которые делаются stdio для определения того, к файлам какого типа относятся stdin и stdout (в этом случае это tty) [преобразуются](https://github.com/darlinghq/darling/blob/master/src/kernel/emulation/linux/ioctl/filio.c) в исследование результата вызова `readlink()` для файлов в `/proc/self/fd/`.
---
Я не могу рассказать о каждой из множества особенностей Mach-O, не рискуя сделать этот пост таким же длинным, как весь исходный код dyld. Кратко опишу ещё несколько из них:
* Если вы пишете плагин, который будет загружаться приложением во время выполнения, вам может потребоваться прилинковать dylib, содержащую плагин, к *исполняемому файлу* этого приложения. ld позволяет сделать это путём использования опции `-bundle_loader`.
* Кроме установочного имени, команды `LC_LOAD_DYLIB`, `LC_REEXPORT_DYLIB` и `LC_DYLIB_ID` содержат по паре чисел, так называемые *совместимую* и *текущую* версии [compatibility version, current version] библиотеки, где совместимая версия – самая ранняя из версий, с которой совместима текущая. При линковке библиотеки можно задать её текущую и совместимую версии с помощью опций ld `-current_version` и `-compatibility_version`, соответственно. Если во время выполнения dyld обнаружит, что текущая версия найденной копии библиотеки меньше, чем требуемая совместимая версия, он откажется загружать эту библиотеку.
* Независимо от совместимой и текущей версий, файлы Mach-O могут также опционально объявлять *версию исходного кода* [source version]. Для этого используется специальная команда, `LC_SOURCE_VERSION`. Саму версию можно установить с помощью опции ld `-source_version`, а повлиять на то, будет ли она включена в результирующий Mach-O-файл – с помощью опций `-add_source_version` и `-no_source_version`.
* Внедрение содержимого файла `Info.plist` в секцию `__info_plist` Mach-O-файла позволяет вам подписывать [codesign] программы, состоящие из одного исполняемого файла и не имеющие отдельного файла `Info.plist`. Это реализовано через [ad-hoc проверку](https://github.com/darlinghq/darling-security/blob/master/OSX/libsecurity_codesigning/lib/machorep.cpp#L254-L275) в Security.framework, что означает, что это не поддерживается обычными `CFBundle` / `NSBundle` API, так что использовать это для создания приложений, состоящих из одного исполняемого файла, не получится.
Наконец, стоит отметить, что в дополнение ко всем вышеупомянутым трюкам, ld и dyld также содержат разнообразные хаки, заставляющие их обрабатывать «системные библиотеки», в особенности `libSystem`, слегка по-другому. Они активируются путём сравнения установочного имени библиотеки с захардкоженными префиксами вроде `/usr/lib/`. | https://habr.com/ru/post/417507/ | null | ru | null |
# Виртуальный мир Intel. Практика
В данной статье я хочу рассмотреть практические аспекты создания простого гипервизора на основе технологии аппаратной виртуализации Intel VMX.
Аппаратная виртуализация достаточно узкоспециализированная область системного программирования и не имеет большого комьюнити, в России уж точно. Я надеюсь, что материал статьи поможет тем, кто захочет открыть для себя аппаратную виртуализацию и те возможности которые она предоставляет. Как было сказано в начале, я хочу рассмотреть именно практический аспект без погружения в теорию, поэтому предполагается что читатель знаком с архитектурой x86-64 и имеет хотя бы общее представление о механизмах VMX. [Исходники к статье](https://github.com/staticbear/simple_hypervisor).
Начнем с постановки задач для гипервизора:
1. Запуск до загрузки гостевой ОС
2. Поддержка одного логического процессора и 4 ГБ гостевой физической памяти
3. Обеспечение правильной работы гостевой ОС с устройствами, спроецированными в области физической памяти
4. Обработка VMexits
5. Гостевая ОС с первых команд должна выполняться в виртуальной среде.
6. Вывод отладочной информации через COM порт (универсальный способ, простой в реализации)
В качестве гостевой ОС я выбрал Windows 7 x32, в которой были заданы следующие ограничения:
* Задействовано только одно лог.ядро CPU
* Отключена опция PAE которая дает возможность 32-битной ОС использовать объем физической памяти, превышающей 4ГБ
* BIOS в legacy режиме, UEFI отключено
### Описание работы загрузчика
Для того чтобы гипервизор запускался при старте PC я выбрал самый простой путь, а именно записал свой загрузчик в MBR сектор диска на который установлена гостевая ОС. Так же нужно было где-то на диске разместить код гипервизора. В моем случае, оригинальная MBR считывает bootloader начиная с 2048 сектора, что дает условно свободную область для записи в (2047 \* 512) Кб. Этого более чем достаточно для размещения всех компонентов гипервизора.
Ниже приведена схема размещения гипервизора на диске, все значения заданы в секторах.
Процесс загрузки происходит следующим образом:
1. loader.mbr считывает c диска код загрузчика — loader.main и передает ему управление.
2. loader.main выполняет переход в long mode, а затем считывает таблицу загружаемых элементов loader.table, на основании которой выполняется дальнейшая загрузка компонентов гипервизора в память.
3. После завершения работы загрузчика в физической памяти по адресу 0x100000000 находится код гипервизора, такой адрес был выбран для того чтобы диапазон с 0 по 0xFFFFFFFF можно было использовать для прямого отображения в гостевую физическую память.
4. оригинальный Windows mbr загружается по физической адресу 0x7C00.
Хочу обратить внимание на то что загрузчик после перехода в long mode больше не может пользоваться сервисами BIOS для работы с физическими дисками, поэтому для чтения диска я использовал «Advance Host Controller Interface».
Более подробно о котором можно почитать [тут](https://wiki.osdev.org/AHCI).
### Описание работы гипервизора
После того как гипервизор получает управление его первая задача заключается в том, чтобы инициализировать окружение в котором ему предстоит работать, для этого последовательно вызываются функции:
* **InitLongModeGdt()** — создает и загружает таблицу из 4х дескрипторов: NULL, CS64, DS64, TSS64
* **InitLongModeIdt(isr\_vector)** — инициализирует первые 32 вектора прерываний общим обработчиком, а точнее его заглушкой
* **InitLongModeTSS()** – инициализируется сегмент состояния задачи
* **InitLongModePages()** — инициализация страничной адресации:
[0x00000000 – 0xFFFFFFFF] – page size 2MB,cache disable;
[0x100000000 – 0x13FFFFFFF] – page size 2 MB, cache write back, global pages;
[0x140000000 – n] – not present;
* **InitControlAndSegmenRegs()** – перезагрузка сегментных регистров
Далее необходимо убедиться что процессор поддерживает VMX, проверка выполняется функцией **CheckVMXConditions()**:
* CPUID.1:ECX.VMX[bit 5] должен быть установлен в 1
* В MSR регистре IA32\_FEATURE\_CONTROL должен быть установлен бит 2 — enables VMXON outside SMX operation и бит 0 – Lock (актуально при отладке в Bochs)
Если все в порядке и гипервизор работает на процессоре, поддерживающем аппаратную виртуализацию переходим к начальной инициализации VMX, смотрим функцию **InitVMX()**:
* Создаются области памяти VMXON и VMCS (virtual-machine control data structures) размером 4096 байт. В первые 31 бит каждой из областей записывается VMCS revision identifier взятый из MSR IA32\_VMX\_BASIC.
* Выполняется проверка что в системных регистрах CR0 и CR4 все биты установлены в соответствии с требованиями VMX.
* Логический процессор переводится в режим vmx root командой VMXON (в качестве аргумента физический адрес VMXON region’а).
* Команда VMCLEAR (VMCS) устанавливает launch state VMCS в Clear, так же команда устанавливает implementation-specific значения в VMCS.
* Команда VMPTRLD(VMCS) загружает в current-VMCS pointer адрес VMCS переданной в качестве аргумента.
Выполнение гостевой ОС начнется в реальном режиме с адреса 0x7C00 по которому, как мы помним, загрузчик loader.main размещает win7.mbr. Для того чтобы воссоздать виртуальную среду идентичную той в которой обычно выполняется mbr, вызывается функция **InitGuestRegisterState()** которая устанавливает регистры vmx non-root следующим образом:
```
CR0 = 0x10
CR3 = 0
CR4 = 0
DR7 = 0
RSP = 0xFFD6
RIP = 0x7C00
RFLAGS = 0x82
ES.base = 0
CS.base = 0
SS.base = 0
DS.base = 0
FS.base = 0
GS.base = 0
LDTR.base = 0
TR.base = 0
ES.limit = 0xFFFFFFFF
CS.limit = 0xFFFF
SS.limit = 0xFFFF
DS.limit = 0xFFFFFFFF
FS.limit = 0xFFFF
GS.limit = 0xFFFF
LDTR.limit = 0xFFFF
TR.limit = 0xFFFF
ES.access rights = 0xF093
CS.access rights = 0x93
SS.access rights = 0x93
DS.access rights = 0xF093
FS.access rights = 0x93
GS.access rights = 0x93
LDTR.access rights = 0x82
TR.access rights = 0x8B
ES.selector = 0
CS.selector = 0
SS.selector = 0
DS.selector = 0
FS.selector = 0
GS.selector = 0
LDTR.selector = 0
TR.selector = 0
GDTR.base = 0
IDTR.base = 0
GDTR.limit = 0
IDTR.limit = 0x3FF
```
Следует обратить внимание на то что поле limit дескрипторного кэша для сегментных регистров DS и ES равно 0xFFFFFFFF. Это пример использования unreal mode — особенности процессора x86 позволяющей обходить лимит сегментов в реальном режиме. Подробней об этом можно почитать [тут](https://wiki.osdev.org/Unreal_Mode).
Находясь в vmx not-root режиме гостевая ОС может столкнутся с ситуацией, когда необходимо вернуть управление хосту в режим vmx root. В таком случае происходит VM exit во время которого сохраняется текущее состояние vmx non-root и загружается vmx-root. Инициализация vmx-root выполняется функцией **InitHostStateArea()**, которая устанавливает следующее значение регистров:
```
CR0 = 0x80000039
CR3 = PML4_addr
CR4 = 0x420A1
RSP = адрес на начало фрейма STACK64
RIP = адрес обработчика VMEXIT_handler
ES.selector = 0x10
CS.selector = 0x08
SS.selector = 0x10
DS.selector = 0x10
FS.selector = 0x10
GS.selector = 0x10
TR.selector = 0x18
TR.base = адрес TSS
GDTR.base = адрес GDT64
IDTR.base = адрес IDTR
```
Далее выполняется создание гостевого физического адресного пространства (функция **InitEPT()**). Это один из самых важных моментов при создании гипервизора, потому что неправильно заданный размер или тип на каком-нибудь из участков памяти могут привести к ошибкам которые могут и не проявить себя сразу, но с большой вероятностью будут приводит к неожиданным тормозам или зависаниям гостевой ОС. В общем приятного тут мало и лучше уделить настройке памяти достаточно внимания.
На следующем изображении приведена модель гостевого физического адресного пространства:
Итак, что мы тут видим:
* [0 — 0xFFFFFFFF] весь диапазон гостевого адресного пространства. Тип по умолчания: write back
* [0xA0000 — 0xBFFFFF] – Video ram. Тип: uncacheable
* [0xBA647000 — 0xFFFFFFFF] – Devices ram. Тип: uncacheable
* [0xС0000000 — 0xCFFFFFFF] – Video ram. Тип: write combining
* [0xD0000000 — 0xD1FFFFFF] – Video ram. Тип: write combining
* [0xFA000000 — 0xFAFFFFFF] – Video ram. Тип: write combining
Информацию для создания таких областей я взял из утилиты RAMMap (вкладка Physical Ranges) так же я воспользовался данными из Windows Device Manager. Разумеется, на другом PC диапазоны адресов скорее всего будут отличаться. Что касается типа гостевой памяти, в моей реализации тип определяется только значением, указанным в таблицах EPT. Это просто, но не совсем корректно и вообще следует учитывать тот тип памяти который хочет установить гостевая ОС в своей страничной адресации.
После того как завершено создание гостевого адресного пространства, можно перейти к настройкам VM Execution control field (функция **InitExecutionControlFields()**). Это довольно большой набор опций, которые позволяют задать условия работы гостевой ОС в режиме vmx not-root. Можно, к примеру, отслеживать обращения к портам ввода вывода или контролировать изменение MSR регистров. Но нашем случае я использую только возможность контролировать установку определенных бит в регистре CR0. Дело в том, что 30(CD) и 29(NW) биты общие как для vmx non-root так и для vmx root режимов и если гостевая ОС установит эти биты в 1 это негативно скажется на производительности.
Процесс настройки гипервизора почти завершен, осталось только установить контроль за переходом в гостевой режим vmx non-root и возвращением в режим хоста vmx root. Настройки задаются в функциями:
**InitVMEntryControl()** настройки для перехода в vmx non-root:
* Load Guest IA32\_EFER
* Load Guest IA32\_PAT
* Load Guest MSRs (IA32\_MTRR\_PHYSBASE0, IA32\_MTRR\_PHYSMASK0, IA32\_MTRR\_DEF\_TYPE)
**InitVMExitControl()** настройки для перехода в vmx root:
* Load Host IA32\_EFER;
* Save Guest IA32\_EFER;
* Load Host IA32\_PAT;
* Save Guest IA32\_PAT;
* Host.CS.L = 1, Host.IA32\_EFER.LME = 1, Host.IA32\_EFER.LMA = 1;
* Save Guest MSRs (IA32\_MTRR\_PHYSBASE0, IA32\_MTRR\_PHYSMASK0, IA32\_MTRR\_DEF\_TYPE);
* Load Host MSRs (IA32\_MTRR\_PHYSBASE0, IA32\_MTRR\_PHYSMASK0, IA32\_MTRR\_DEF\_TYPE);
Теперь, когда все настройки выполнены, функция **VMLaunch()** переводит процессор в режим vmx non-root и начинает выполняться гостевая ОС. Как я упоминал ранее, в настройках vm execution control могут быть заданы условия, при возникновении которых гипервизор вернет себе управления в режиме vmx root. В моем простом примере, я предоставляю гостевой ОС полную свободу действий, однако в некоторых случаях гипервизор все же должен будет вмешаться и скорректировать работу ОС.
1. Если гостевая ОС пытается изменить биты CD и NW в регистре CR0 обработчик VM Exit
корректирует записываемые в CR0 данные. Так же модифицируется поле CR0 read shadow чтобы при чтении CR0 гостевая ОС получила записанное значение.
2. Выполнение команды xsetbv. Данная команда всегда вызывает VM Exit, независимо от настроек, поэтому я просто добавил ее выполнение в режиме vmx root.
3. Выполнение команды cupid. Эта команда так же вызывает безусловный VM Exit. Но в ее обработчик я внес небольшое изменение. Если в качестве аргумента в eax будут значения 0x80000002 – 0x80000004, cpuid вернет не название бренда процессора, а строку: *VMX Study Core: )* Результат можно увидеть на скриншоте:
### Итоги
Написанный в качестве примера к статье гипервизор вполне способен поддерживать стабильную работу гостевой ОС, хотя конечно и не является законченным решением. Не используется Intel VT-d, реализована поддержка только одного логического процессора, нет контроля за прерываниями и работой периферийных устройств. В общем я не использовал почти ничего из богатого набора средств, которые предоставляет Intel для аппаратной виртуализации. Впрочем, если сообщество заинтересуется я продолжу писать про Intel VMX, тем более что написать есть о чем.
Да, чуть не забыл, отладку гипервизора и его компонентов удобно проводить с помощью Bochs. На первое время это незаменимый инструмент. К сожалению, загрузка гипервизора в Bochs отличается от загрузки на физическом PC. В свое время я делал специальную сборку чтобы упростить этот процесс, постараюсь привести исходники в порядок и так же выложить вместе с проектом в ближайшее время.
На этом все. Спасибо за внимание. | https://habr.com/ru/post/419065/ | null | ru | null |
# На что стоит променять Cortex-M3?
ARM Cortex-M3 — это, пожалуй, самое популярное на сегодняшний день 32-разрядное процессорное ядро для встраиваемых систем. Микроконтроллеры на его базе выпускают десятки производителей. Причина этому — универсальная, хорошо сбалансированная архитектура, а следствие — непрерывно растущая база готовых программных и аппаратных решений.
Ругать Cortex-M3, в общем-то, не за что, но сегодня я предлагаю подробно рассмотреть Cortex-M4F — расширенную версию всеми любимого процессорного ядра. Перенести проект с микроконтроллера на базе Cortex-M3 на кристалл на базе Cortex-M4F довольно просто, а для ряда задач такой переход стоит затраченных усилий.
Под катом краткий обзор современных Cortex'ов, обстоятельное описание блоков и команд, отличающих Cortex-M4F от Cortex-M3, а также сравнение процессорных ядер на реальной задаче — будем измерять частоту мерцания лампы на микроконтроллерах с разными ядрами.
#### Часть обзорная
---
О том как сменяли друг-друга поколения процессорных ядер ARM написано огромное количество статей и обзоров. Не вижу смысла расписывать всё то, что есть в википедии, но напомню основные факты.
Компания ARM Ltd. разрабатывает микропроцессорные и микроконтроллерные ядра с RISC-архитектурой и продает производителям электронных компонентов лицензии на производство кристаллов по соответствующей технологии. Таких производителей по всему миру десятки и даже сотни, есть среди них и отечественные компании.
Современные ядра ARM объединены названием Cortex.
*Кстати говоря, слово «cortex» переводится как «кора головного мозга» — структура, отвечающая за согласованную работу органов, мышление, высшую нервную деятельность. По-моему, прекрасное название.*
Итак, процессорные ядра ARM Cortex разделены на три основные группы:
* Cortex-A — Application Processors — для приложений, требующих высокой производительности; чаще всего на них запускается linux, android и им подобные ОС
* Cortex-R — Embedded Real-time Processors — для приложений реального времени
* Cortex-M — Embedded Processors — для встраиваемых систем
Рассмотрим последнюю группу, постепенно приближаясь к паре Cortex-M3 / Cortex-M4F. Всего на конец 2015 года представлено шесть процессорных ядер: Cortex-M0, -M0+, -M1, -M3, -M4, -M7.
Из этого списка часто «выпадает» Cortex-M1, это оттого, что -M1 разработан и используется исключительно в приложениях связанных с FPGA. Остальные ядра не имеют столь специализированной области применения и отличаются по производительности — от самого простого -M0 до высокопроизводительного -M7.
По сравнению с Cortex-M0, Cortex-M0+ дополнительно оснащен блоком защиты памяти MPU, буфером Micro Trace Buffer для отладки программ, а также имеет двухступенчатый конвейер вместо трехступенчатого и упрощенный доступ к периферийным блоками и линиям ввода/вывода.
Cortex-M0 и Cortex-M0+ имеют одношинную фон-неймановскую архитектуру, а ядро Cortex-M3 — уже гарвардскую. Cortex-M3 довольно сильно отличается от «младших» представителей линейки и имеет гораздо более широкие возможности.
Cortex-M4 построен по абсолютно той же архитектуре и «структурно» не отличается от Cortex-M3. Разница заключается в поддерживаемой системе команд, но об этом позже. Cortex-M4F отличается от -M4 наличием блока вычислений с плавающей точкой FPU.
Архитектура Cortex-M7 представлена относительно недавно и отличается от Cortex-M3/M4 так же сильно, как Cortex-M3/M4 отличаются от Cortex-M0. 6-ступенчатый суперскалярный конвейер, отдельная кэш-память для данных и команд, конфигурируемая память TCM и другие отличительные функции этого ядра «заточены» для достижения максимальной производительности. И действительно, возможности контроллеров на базе Cortex-M7 сравнивают скорее с Cortex-A5 и -R5, чем с другими контроллерами группы Embedded Processors. Границы применения технологий продолжают размываться.
Несмотря на совершенно разные возможности ядер группы Cortex-M, набор команд каждого ядра включает в себя все команды, поддерживаемые в более младших ядрах. Так обеспечивается возможность разработки программно-совместимых микроконтроллеров на базе разных ядер, этим и занимается большинство производителей микроконтроллеров.
Ядра Cortex-M0 и Cortex-M0+ имеют одну и ту же систему команд. Набор инструкций Cortex-M3 включает все команды Cortex-M0 и около сотни дополнительных инструкций. Процессорные ядра Cortex-M4 и Cortex-M7 имеют, опять же, идентичный набор команд — набора команд Cortex-M3 плюс так называемые DSP-инструкции. Ядро Cortex-M4F дополнительно к набору Cortex-M4 / -M7 поддерживает команды вычислений с плавающей точкой, а система команд Cortex-M7F включает ещё 14 команд для операций над числами с плавающей точкой двойной точности.
#### Часть теоретическая
---
Итак, ближайшими «соседями» популярного процессорного ядра Cortex-M3 являются Cortex-M4, дополненный поддержкой DSP-инструкций, и Cortex-M4F, дополнительно содержащий блок FPU и поддерживающий соответствующие команды. Рассмотрим DSP- и FPU-команды.
#### DSP-инструкции
Аббревиатура DSP чаще всего расшифровывается как Digital Signal Processor, т.е. отдельный и вполне самостоятельный контроллер или сопроцессор, предназначенный для задач цифровой обработки сигналов. Не стоит путать специализированную DSP-микросхему и набор DSP-инструкций. DSP-команды (расшифровывается Digital Signal Process**ing** вместо Process**or**) — это набор команд, который поддерживается рядом процессорных ядрер ARM и соответствует некоторым типовым для цифровой обработки сигнала операциям.
Первая группа таких операций — это **умножение с накоплением** (Single-cycle Multiply Accumulate или просто MAC).
Для самых маленьких: умножение с накоплением описывается формулой S = S + A x B. Соответствующие команды описывают умножение двух регистров с суммированием результата в аккумулятор и смежные операции: умножение с вычитанием результата из аккумулятора, умножение без использования аккумулятора и т.д.
Операции предусмотрены для 16- и 32-разрядных переменных и играют важную роль во многих типовых алгоритмах цифровой обработки сигналов. Например, [КИХ-фильтр](https://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D1%81_%D0%BA%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%BE%D0%B9_%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%BE%D0%B9_%D1%85%D0%B0%D1%80%D0%B0%D0%BA%D1%82%D0%B5%D1%80%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%BE%D0%B9) (это классический, почти банальный «например») представляет собой последовательность операций умножения с накоплением, а значит скорость его работы напрямую зависит от скорости выполнения умножения с накоплением.
Все MAC-инструкции в микроконтроллерах с ядром Cortex-M4(F) выполняются за один машинный цикл.
Вторая группа DSP-инструкций — это операции **параллельной обработки данных** (Single Instruction Multiple Data, SIMD), позволяющие оптимизировать обработку данных за счет параллелизма вычислений. Пары независимых переменных попарно помещаются в один регистр большей размерности, а арифметические операции проводятся уже над «большими» регистрами.
Например, команда [SADD16](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0553a/CHDGJDJF.html) подразумевает одновременное сложение двух пар 16-разрядных знаковых чисел с записью результата в регистр, хранящий первый операнд.
```
SADD16 R1, R0
```
Поскольку регистры общего назначения имеют разрядность 32 бит, в каждый из них можно записать не только по две 16-разрядных переменных (полуслов), но и до четырех 8-разрядных переменных (байт). Теперь несложно прикинуть зачем нужна команда SADD8.
Вот более сложная операция: умножение старших полуслов, умножение младших полуслов и суммирование произведений между собой и с 64-разрядным накоплением. Команда SMLALD описывает все эти действия и выполняется Cortex-M4 за один машинный цикл. SMLALD, как и многие другие команды, совмещает умножение с накоплением и обработку данных по принципу SIMD.
```
SMLALD R6, R8, R5, R1
```
И простые SIMD-команды (знаковые и беззнаковые 8- и 16-разрядные сложение и вычитание и т.п.), и сложные команды, подобные SMLALD, выполняются за один машинный цикл.
Следующая группа DSP-инструкций — команды **операций с насыщением** (Saturating instructions). Они также известны как операции с отсечкой и представляют собой защиту от переполнений. При использовании стандартных команд, регистр, хранящий результат, при переполнении «перезагружается» с нуля, а команды, предусматривающие насыщение, при переполнении фиксируют результат на допустимом разрядностью максимуме. Таким образом с программиста снимается необходимость заботиться о флагах переполнения.
Среди команд процессорного ядра Cortex-M4 есть как «обычные» арифметические операции, так и те же операции с насыщением. Использование последних особенно востребовано в задачах, где точностью вычислений можно пожертвовать ради скорости. Таких задач в ЦОС немало.
#### FPU-инструкции
Аппаратная поддержка вычислений с плавающей запятой (или точкой, кому как больше нравится) — это особенность ядра Cortex-M4F и более старших представителей линейки Cortex-M.
Команды вычислений с плавающей точкой позволяют выполнять операции над вещественными числами с максимальной производительностью. Вообще, для представления вещественных чисел сегодня используется два формата — с фиксированной и плавающей точкой. В первом случае количество разрядов для записи целой и дробной частей зафиксировано и вычисления сводятся к операциям над целыми числами, во втором число представляется как совокупность знакового бита, нескольких разрядов порядка и мантиссы:
(-1)s \* m × be,
где s — знак, b-основание, e — порядок, а m — мантисса
Использование формата с плавающей точкой предпочтительно при обработке сигналов за счет гораздо более широкого диапазона значений переменных формата float. Использование операций FPU также избавляет разработчика от необходимости следить за разрядностью. Формат чисел с плавающей точкой одинарной точности описывается стандартом IEEE 754, это представление и используется в микроконтроллерах с ядром Cortex-M4F. Диапазон допустимых значений составляет (10–38… 1038) при приблизительном пересчете в десятичные числа.
К слову, для формата чисел с плавающей запятой двойной точности, который поддерживается в Cortex-M7F, используется тот же принцип, но вместо 32-разрядного представления используется 64-разрядное, т.е. на порядок приходится 11 бит, а на мантиссу 52.
О том как и зачем используется формат с плавающей точкой не раз написано на хабре ([вот](http://habrahabr.ru/post/112953/) , например, отличная статья). Мне, пожалуй, не написать лучше, поэтому идем дальше.
#### Список ассемблерных DSP- и FPU-команд
Чтобы прочувствовать масштаб — понять насколько может быть ускорена обработка данных с использованием Cortex-M4 — можно поизучать полный перечень DSP- и FPU-инструкций. У меня есть большие сомнения на счет практической ценности этих таблиц, это посмотреть интересно.
Все DSP- и большинство FPU-инструкций выполняются за один машинный цикл.
**DSP-инструкции ядра Cortex-M4**
| | |
| --- | --- |
| **Команда** | **Операция** |
| PKHTB, PKHBT | перезапись полуслова из одного регистра в другой, при необходимости сдвиг содержимого "принимающего" регистра |
| QADD | знаковое сложение с насыщением |
| QADD16 | знаковое сложение соответствующих полуслов двух операндов (с насыщением) |
| QADD8 | знаковое сложение соответствующих байт двух операндов (с насыщением) |
| QASX | знаковое сложение младшего полуслова второго операнда и старшего полуслова первого операнда, знаковое вычитание старшего полуслова второго операнда из младшего полуслова первого операнда (с насыщением) |
| QDADD | удвоение второго операнда, суммирование результата с первым операндом (знаковое, с насыщением) |
| QDSUB | удвоение второго операнда, вычитание результата из первого операнда (знаковое, с насыщением) |
| QSAX | знаковое вычитание младшего полуслова второго операнда из старшего полуслова первого операнда + знаковое сложение младшего полуслова первого операнда и старшего полуслова второго операнда (с насыщением) |
| QSUB | знаковое вычитание (с насыщением) |
| QSUB16 | знаковое вычитание соответствующих полуслов двух операндов (с насыщением) |
| QSUB8 | знаковое вычитание соответствующих байт двух операндов (с насыщением) |
| SADD16 | знаковое сложение соответствующих полуслов двух операндов |
| SADD8 | знаковое сложение соответствующих байт двух операндов |
| SASX | знаковое сложение старшего полуслова первого пперанда и младшего полуслова второго операнда с записью в старшее полуслово результата, знаковое вычитание младшего полуслова второго операнда из старшего полуслова первого с записью в младшее полуслово результата |
| SEL | выбор байтов из операндов в соответствии с битами GE[3:0] ("флаги", устанавливающиеся при выполнении различных условий типа «больше или равно» при выполнении арифметических операций) |
| SHADD16 | знаковое сложение соответствующих полуслов операндов, сдвиг двух результатов на один бит вправо |
| SHADD8 | знаковое сложение соответствующих байт операндов, сдвиг четырех результатов на один бит вправо |
| SHASX | знаковое сложение старшего полуслова первого операнда и младшего полуслова второго операнда, запись результата в старшее полуслово указанного регистра со сдвигом вправо на один бит, знаковое вычитание старшего полуслова второго операнда из младшего полуслова первого операнда, запись результата в младшее полуслово указанного регистра со сдвигом вправо на один бит |
| SHSAX | знаковое вычитание младшего полуслова второго операнда из старшего полуслова первого операнда, запись результата в младшее полуслово указанного регистра со сдвигом вправо на один бит, знаковое сложение старшего полуслова второго операнда и младшего полуслова первого операнда, запись результата в старшее полуслово указанного регистра со сдвигом вправо на один бит |
| SHSUB16 | знаковое вычитание старшего и младшего полуслов второго операнда из соответствующих полуслов первого операнда, сдвиг результат на бит вправо |
| SHSUB8 | знаковое вычитание старшего и младшего байт второго операнда из соответствующих байтов первого операнда, сдвиг результат на бит вправо |
| SMLABB, SMLABT, SMLATB, SMLATT | умножение верхних или нижних полуслов двух операндов с 32-разрядным накоплением |
| SMLAD, SMLADX | попарное умножение полуслов двух операндов, суммирование двух произведение с 32-разрядным накоплением |
| SMLALBB, SMLALBT, SMLALTB, SMLALTT | умножение знаковых полуслов двух операндов (старших или младших) с 64-разрядным накоплением и 64-разрядным результатом |
| SMLALD, SMLALDX | попарное умножение двух байт, взятых из первого операнда на два байта из второго операнда, суммирование двух полученных произведений с 64-разрядным накоплением и 64-разрядным результатом |
| SMLAWB, SMLAWT | умножение верхнего или нижнего полуслова первого операнда на второй операнд с 32-разрядным накоплением, в результирующий регистр записываюся первые 32 разряда 48-битного результата |
| SMLSD | вычитание произведения старших полуслов двух операндов из младших полуслов двух операндов с 32-разрядным накоплением |
| SMLSLD | вычитание произведения старших полуслов двух операндов из младших полуслов двух операндов с 64-разрядным накоплением |
| SMMLA | умножение двух операндов с 32-разрядным накоплением (берутся только 32 старших разряда произведения) |
| SMMLS, SMMLR | умножение двух операндов, вычитание результата из указанного регистра (берутся только 32 старших разряда произведения) |
| SMMUL, SMMULR | умножение операндов (результат — старшие 32-разрядна произведения) |
| SMUAD | умножение старших полуслов двух операндов, умножение младших полуслов двух операндов, сложение произведений |
| SMULBB, SMULBT SMULTB, SMULTT | умножение верхних или нижних полуслов двух оперндов |
| SMULWB, SMULWT | умножение первого операнда на верхнее или нижнее полуслово второго операнда, в результирующий регистр записываюся первые 32 разряда 48-битного результата |
| SMUSD, SMUSDX | умножение старших полуслов двух операндов, умножение младших полуслов двух операндов, вычитание первого произведения из второго |
| SSAT16 | знаковое насыщение полуслов до указанного значения |
| SSAX | знаковое вычитание младшего полуслова второго операнда из старшего полуслова первого операнда с записью в младшее полуслово результата, сложение старшего полуслова первого операнда и младшего полуслова второго операнда с записью в старшее полуслово результата |
| SSUB16 | знаковое вычитание соответствующих полуслов двух операндов |
| SSUB8 | знаковое вычитание соответствующих байт двух операндов |
| SXTAB | извлечение бит [7:0] из регистра и их преобразование в 32-разрядное слово с учетом знака, сложение результата со словом или полусловом |
| SXTAB16 | извлечение бит [7:0] и [23:16] из регистра, их преобразование в полуслова с учетом знака, сложение результата со словом или полусловом |
| SXTAH | извлечение бит [15:0] из регистра и их преобразование в 32-разрядное слово с учетом знака, сложение результата со словом или полусловом |
| SXTB16 | преобразование двух байт в два полуслова с учетом знака, сложение результата со словом или полусловом |
| UADD16 | беззнаковое сложение соответствующих полуслов двух операндов |
| UADD8 | беззнаковое сложение соответствующих байт двух операндов |
| USAX | сложение младшего полуслова первого операнда и старшего полуслова второго операнда с записью результата в младшее полуслово результата, беззнаковое вычитание младшего полуслова второго операнда из старшего полуслова первого операнда с записью в старшее полуслово результата |
| UHADD16 | беззнаковое сложение соответствующих полуслов двух операндов и сдвиг результатов на один бит вправо |
| UHADD8 | беззнаковое сложение соответствующих байт двух операндов и сдвиг результатов на один бит вправо |
| UHASX | беззнаковое сложение старшего полуслова первого операнда и младшего полуслова второго операнда со сдвигом результата сложения на один бит вправо и записью в старшее полуслово результата, беззнаковое вычитание старшего полуслова второго операнда из младшего полуслова первого операнда со сдвигом результата вычитания на один бит вправо и записью в младшее полуслово результата |
| UHSAX | беззнаковое вычитание млдашего полуслова второго операнда из старшего полуслова первого операнда со сдвигом результата вычитания на один бит вправо и записью в старшее полуслово результата, беззнаковое сложение младшего полуслова первого операнда и старшего полуслова второго операнда со сдвигом результата сложения на один бит вправо и записью в младшее полуслово результата, |
| UHSUB16 | беззнаковое вычитание соответствующих полуслов двух операндов, сдвиг результата на один бит вправо |
| UHSUB8 | беззнаковое вычитание соответствующих байт двух операндов, сдвиг результата на один бит вправо |
| UMAAL | беззнаковое умножение с двойным 32-разрядным накоплением и 64-разряжным результатом |
| UQADD16 | беззнаковое сложение 16-разрядных переменных (с насыщением) |
| UQADD8 | беззнаковое сложение 8-разрядных переменных (с насыщением) |
| UQASX | беззнаковое вычитание младшего полуслова второго операнда из старшего полуслова первого операнда, беззнаковое сложение младшего полуслова первого операнда и старшего полуслова второго операнда (с насыщением) |
| UQSAX | беззнаковое вычитание младшего полуслова второго операнда из старшего полуслова первого операнда, беззнаковое сложение младшего полуслова первого операнда и старшего полуслова второго операнда (с насыщением) |
| UQSUB16 | беззнаковое вычитание соответствующих полуслов двух операндов (с насыщением) |
| UQSUB8 | беззнаковое вычитание соответствующих байт двух операндов (с насыщением) |
| USAD8 | беззнаковое вычитание соответствующих байт двух операндов, сложение абсолютных разностей |
| USADA8 | беззнаковое вычитание соответствующих байт двух операндов, сложение абсолютных разностей, сложение результат операции с содержимым аккумулятора |
| USAT16 | беззнаковое насыщение полуслов до указанного значения |
| UASX | беззнаковое вычитание старшего полуслова второго операнда из младшего полуслова первого операнда с записью в младшее полуслово результата, сложение старшего полуслова первого операнда и младшего полуслова второго операнда с записью результата в старшее полуслова результата |
| USUB16 | беззнаковое вычитание соответствующих полуслов двух операндов |
| USUB8 | беззнаковое вычитание соответствующих байт двух операндов |
| UXTAB | извлечение бит [7:0] из регистра и их преобразование в 32-разрядное слово без учета знака, сложение результата со словом или полусловом |
| UXTAB16 | извлечение бит [7:0] и [23:16] из регистра, их преобразование в полуслова без учета знака, сложение результата со словом или полусловом |
| UXTAH | извлечение бит [15:0] из регистра и их преобразование в 32-разрядное слово без учета знака, сложение результата со словом или полусловом |
| UXTB16 | преобразование двух байт в два полуслова без учета знака, сложение результата со словом или полусловом |
**FPU-инструкции ядра Cortex-M4F**
| | |
| --- | --- |
| **Команда** | **Операция** |
| VABS.F32 | получение абсолютного значения операнда |
| VADD.F32 | сложение операндов |
| VCMP.F32 | сравнение двух операндов или операнда и нуля |
| VCMPE.F32 | сравнение двух операндов или операнда и нуля с проверкой на некорректный операнд (NaN) |
| VCVT.S32.F32 | преобразование между типами данных (с плавающей точкой / целые) |
| VCVT.S16.F32 | преобразование между типами данных (с плавающей точкой / с фиксированной точкой) |
| VCVTR.S32.F32 | преобразование между типами данных (с плавающей точкой / целые) с округлением |
| VCVT.F32.F16 | преобразование между типами данных (полуслово с плавающей точкой — оно же "число с половинной точностью" / с плавающей точкой) |
| VCVTT.F32.F16 | преобразование между типами данных (с плавающей точкой / полуслово с плавающей точкой ) |
| VDIV.F32 | деление операндов |
| VFMA.F32 | перемножение двух переменных, прибавление результата умножения к содержимому указанного регистра |
| VFNMA.F32 | инвертирование первого опренда, умножение результата на второй операнд, сложение произведения и инвертированного значения из указанного регистра |
| VFMS.F32 | инвертирование первого опренда, умножение результата на второй операнд, сложение произведения и значения из указанного регистра |
| VFNMS.F32 | умножение двух операндов, сложение произведения и инвертированного значения из указанного регистра |
| VLDM.F<32|64> | извлечение содержимого нескольких указанных регистров из памяти программ |
| VLDR.F<32|64> | извлечение содержимого указанного регистра из памяти программ |
| VLMA.F32 | умножение с накоплением |
| VLMS.F32 | вычитание произведения двух операндов из указанного регистра |
| VMOV | пересылки данных между "стандартными" регистрами ARM и регистрами FPSCR (Floating-Point Status and Control Register), пересылки данных между регистрами хранящими формата с плавающей точкой (регистры FPU), запись констант в регистры FPU и т.п. |
| VMOV, VMRS, VMSR | пересылки данных между "стандартными" регистрами ARM и регистрами FPSCR (Floating-Point Status and Control Register) |
| VMUL.F32 | умножение операндов |
| VNEG.F32 | инвертирование |
| VNMLA.F32 | умножение двух операндов, инвентирование результата, сложение инвертированого произведения и инвертированного значения из указанного регистра |
| VNMLS.F32 | умножение двух операндов, произведения и инвертированного значения из указанного регистра |
| VNMUL | умножение двух операндов, инвентирование результата |
| VPOP | таки pop |
| VPUSH | таки push |
| VSQRT.F32 | извлечение квадратного корня |
| VSTM | сохранение содержимого нескольких указанных регистров в память программ |
| VSTR.F<32|64> | сохранение содержимого указанного регистра в память программ |
| VSUB.F<32|64> | вычитание операндов |
Впрочем, на практике сами инструкции ядра используются не часто. Обычно при разработке достаточно разобраться с документацией на контроллер и сишными библиотеками от производителей ядра и кристалла. В частности, для ядер Cortex существует ARM-овский набор библиотек CMSIS, который используется для процессоров Cortex-M от разных производителей. В состав CMSIS входит и библиотека CMSIS-DSP, она включает в себя:
* базовые математические функции, операции над векторами
* быстрые тригонометрические и трансцендентные функции (sin, cos, sqrt и т.д.)
* линейную и билинейную интерполяции
* комплексную арифметику
* статистические функции
* алгоритмы фильтрации – БИХ-, КИХ- фильтры, алгоритм минимальной среднеквадратичной ошибки
* алгоритмы преобразования сигналов (БПФ и др.)
* матричную арифметику
* ПИД-регулятор
* функции для работы с массивами
#### Часть практическая
---
Как правило, сравнение ядер Cortex-M3 и Cortex-M4(F) заканчивается красивыми графиками — гистограммами, на которых показано значительное ускорение работы контроллера на базе Cortex-M4 при выполнении типовых для ЦОС операций (КИХ-фильтр, БПФ, матричные вычисления, ПИД-регулятор и т.п). Без указаний используемых контроллеров, методики вычислений и измерений.
Но мы не будем сравнивать Тайд и Обычный стиральный порошок, вместо этого возьмем реальную аппаратную и программную платформы.
> На этом месте есть смысл отвлечься и немного поразмышлять о задачах, для которых актуален математический аппарат Cortex-M4F. Понятно, что на работу с потоковыми данными и мультимедиа производительности ядра Cortex-M4 не хватит, речь идет скорее о системах управления и обработки данных.
>
> Например, идет сбор каких-то телеметрических данных. Узел опроса датчиков может либо просто управлять датчиками и передавать массивы данных на некий центральный вычислительный узел, либо самостоятельно обрабатывать и фильтровать результаты измерений, передавая «центру» только полезные данные. Второй подход имеет ряд очевидных преимуществ — уменьшаются затраты на коммуникации, за счет распределенных вычислений повышается надежность системы и упрощается её масштабирование.
>
> Я не имею в виду только большие и сложные распределенные системы. Представьте себе какой-нибудь модный фитнес-браслет. Будет он передавать всё что намерил на вашем пульсе через bluetooth смартфону? Конечно, нет. Браслет сам проанализирует данные и отправит только одну маленькую посылочку с результатом.
>
> И вот мы подошли к главному. Что чаще всего важно для контроллера, который осуществляет вычисления «на месте»? Энергопотребление! Чем меньше варемени занимает обработка данных, тем больше времени микроконтроллер проводит в режиме сна и тем дольше устройство работает без подзарядки.
Так мы вполне логично дошли до того чтобы рассмотреть микроконтроллеры серии EFM32 Wonder Gecko от SiLabs. Они классные и вы можете купить их в ЭФО по отличным ценам оптом и в розницу. Кхе-кхе.
[EFM32WG](http://www.silabs.com/products/mcu/32-bit/efm32-wonder-gecko/pages/efm32-wonder-gecko.aspx) — серия микроконтроллеров на базе ядра Cortex-M4F. Как и другие EFM32, они ориентированы на малопотребляющие устройства и предоставляют разные программные и аппаратные средства для контроля над энергопотреблением. Эти средства мы будем использовать для сравнения ядер Cortex-M3 и Cortex-M4F.
Аппаратная часть:
Плата EFM32WG-STK3800 — кит для работы с микроконтроллером на базе ядра Cortex-M4F
Плата EFM32GG-STK3700 — кит для работы с микроконтроллером на базе ядра Cortex-M3
Платы отличатся между собой только целевым микроконтроллером.
Программная часть
В описываемом эксперимента использовалась платформа Simplicity Studio. Это SiLabs-овская оболочка, которая объединяет все программы, утилиты, примеры и документы, доступные для микроконтроллеров от Silabs. Сейчас понадобится несколько её компонентов — IDE, утилита для контроля энергопотребления energy profiler, а также готовый проект из набора примеров и user guide на используемые платы.
Суть эксперимента
Одна из программ из набора готовых примеров использует Быстрое Преобразование Фурье для измерения частоты мерцания внешнего источника света. Если вкратце, то сигнал с датчика освещенности поступает на АЦП, результаты измерений буферизируются, и раз в 0,5 сек производятся вычисления: по выборке из 512 результатов измерений с использованием БПФ выделяется частота основной гармоники. На ЖКИ выводится результат вычислений и количество машинных циклов за которые была исполнена функция ProcessFFT().
Ресурсоемкой является только часть алгоритма, связанная с анализом измерений. Запустим одну и ту же программу на двух платах и сравним длительность вычислений и уровень энергопотребления.
Открываем Simplicity Studio, включаем Simplicity IDE, компилируем проект.
**Листинг программы**Мопед не мой, приведенный файл — один из дефолтных примеров, доступных как в Simplicity IDE, так и в IAR, Keil и некоторых других средах разработки.
```
/***************************************************************************//**
* @file lightsensefft.c
* @brief FFT transform example
* @details
* Use ADC in order to capture and analyse input from the
* light sensor on the STK. Runs floating point FFT algorithm from the CMSIS
* DSP Library, and estimate the frequency of the most luminous light source
* using sinc interpolation. The main point with this example is to show the
* use of the CMSIS DSP library and the floating point capability of the CPU.
*
* @par Usage
* Connect the light sensor output to the ADC input by shorting pins
* 15 and 14 on the EXP_HEADER of the STK.
* Direct various light sources to the light sensor. Expect no specific
* frequency from daylight or from a flashlight. Mains powered incandescent
* bulbs should give twice the mains frequency. Using another STK running the
* "blink" example modified to various blink rates is an excellent signal
* source. The frequency bandwidth is approximately 10-500 Hz.
* The frequency shows in the 4 digit numerical display upper right on
* the LCD. The LCD also displays the number of CPU cycles used to do
* the FFT transform.
*
* @author Silicon Labs
* @version 1.04
*******************************************************************************
* @section License
* **(C) Copyright 2014 Silicon Labs, http://www.silabs.com**
*******************************************************************************
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*
* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no
* obligation to support this Software. Silicon Labs is providing the
* Software "AS IS", with no express or implied warranties of any kind,
* including, but not limited to, any implied warranties of merchantability
* or fitness for any particular purpose or warranties against infringement
* of any proprietary rights of a third party.
*
* Silicon Labs will not be liable for any consequential, incidental, or
* special damages, or any other relief, or for any claim by any third party,
* arising from your use of this Software.
*
******************************************************************************/
#include "em_common.h"
#include "em_emu.h"
#include "em_cmu.h"
#include "em_chip.h"
#include "em_adc.h"
#include "em_gpio.h"
#include "em_rtc.h"
#include "em_acmp.h"
#include "em_lesense.h"
#include "segmentlcd.h"
#include "arm_math.h"
#include "math.h"
/**
* Number of samples processed at a time. This number has to be equal to one
* of the accepted input sizes of the rfft transform of the CMSIS DSP library.
* Increasing it gives better resolution in the frequency, but also a longer
* sampling time.
*/
#define BUFFER_SAMPLES 512
/** (Approximate) sample rate used for sampling data. */
#define SAMPLE_RATE (1024)
/** The GPIO pin used to power the light sensor. */
#define EXCITE_PIN gpioPortD,6
/* Default configuration for alternate excitation channel. */
#define LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF \
{ \
false, /* Alternate excitation enabled.*/ \
lesenseAltExPinIdleDis, /* Alternate excitation pin is disabled in idle. */ \
false /* Excite only for corresponding channel. */ \
}
/* ACMP */
#define ACMP_NEG_REF acmpChannelVDD
#define ACMP_THRESHOLD 0x38 /* Reference value for the lightsensor.
* Value works well in office light
* conditions. Might need adjustment
* for other conditions. */
/* LESENSE Pin config */
#define LIGHTSENSE_CH 6
#define LIGHTSENSE_EXCITE_PORT gpioPortD
#define LIGHTSENSE_EXCITE_PIN 6
#define LIGHTSENSE_SENSOR_PORT gpioPortC
#define LIGHTSENSE_SENSOR_PIN 6
#define LCSENSE_SCAN_FREQ 5
#define LIGHTSENSE_INTERRUPT LESENSE_IF_CH6
/** Buffer of uint16_t sample values ready to be FFT-ed. */
static uint16_t lightToFFTBuffer[BUFFER_SAMPLES];
/** Buffer of float samples ready for FFT. */
static float32_t floatBuf[BUFFER_SAMPLES];
/** Complex (interleaved) output from FFT. */
static float32_t fftOutputComplex[BUFFER_SAMPLES * 2];
/** Magnitude of complex numbers in FFT output. */
static float32_t fftOutputMag[BUFFER_SAMPLES];
/** Flag used to indicate whether data is ready for processing */
static volatile bool dataReadyForFFT;
/** Indicate whether we are currently processing data through FFT */
static volatile bool processingFFT;
/** Instance structures for float32_t RFFT */
static arm_rfft_instance_f32 rfft_instance;
/** Instance structure for float32_t CFFT used by the RFFT */
static arm_cfft_radix4_instance_f32 cfft_instance;
/**************************************************************************//**
* Interrupt handlers prototypes
*****************************************************************************/
void LESENSE_IRQHandler(void);
/**************************************************************************//**
* Functions prototypes
*****************************************************************************/
void setupCMU(void);
void setupACMP(void);
void setupLESENSE(void);
/**************************************************************************//**
* @brief LESENSE_IRQHandler
* Interrupt Service Routine for LESENSE Interrupt Line
*****************************************************************************/
void LESENSE_IRQHandler(void)
{
/* Clear interrupt flag */
LESENSE_IntClear(LIGHTSENSE_INTERRUPT);
}
/***************************************************************************//**
* @brief Enables LFACLK and selects osc as clock source for RTC
******************************************************************************/
void RTC_Setup(CMU_Select_TypeDef osc)
{
RTC_Init_TypeDef init;
/* Ensure LE modules are accessible */
CMU_ClockEnable(cmuClock_CORELE, true);
/* Enable osc as LFACLK in CMU (will also enable oscillator if not enabled) */
CMU_ClockSelectSet(cmuClock_LFA, osc);
/* Division prescaler to decrease consumption. */
CMU_ClockDivSet(cmuClock_RTC, cmuClkDiv_32);
/* Enable clock to RTC module */
CMU_ClockEnable(cmuClock_RTC, true);
init.enable = false;
init.debugRun = false;
init.comp0Top = true; /* Count only to top before wrapping */
RTC_Init(&init);
/* RTC clock divider is 32 which gives 1024 ticks per second. */
RTC_CompareSet(0, ((1024 * SAMPLE_RATE) / 1000000)-1);
/* Enable interrupt generation from RTC0, needed for WFE (wait for event). */
/* Notice that enabling the interrupt in the NVIC is not needed. */
RTC_IntEnable(RTC_IF_COMP0);
}
/**************************************************************************//**
* @brief Enable clocks for all the peripherals to be used
*****************************************************************************/
void setupCMU(void)
{
/* Ensure core frequency has been updated */
SystemCoreClockUpdate();
/* Set the clock frequency to 11MHz so the ADC can run on the undivided HFCLK */
CMU_HFRCOBandSet(cmuHFRCOBand_11MHz);
/* ACMP */
CMU_ClockEnable(cmuClock_ACMP0, true);
/* GPIO */
CMU_ClockEnable(cmuClock_GPIO, true);
/* ADC */
CMU_ClockEnable(cmuClock_ADC0, true);
/* Low energy peripherals
* LESENSE
* LFRCO clock must be enables prior to enabling
* clock for the low energy peripherals */
CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFRCO);
CMU_ClockEnable(cmuClock_CORELE, true);
CMU_ClockEnable(cmuClock_LESENSE, true);
/* RTC */
CMU_ClockEnable(cmuClock_RTC, true);
/* Disable clock source for LFB clock. */
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_Disabled);
}
/**************************************************************************//**
* @brief Sets up the ACMP
*****************************************************************************/
void setupACMP(void)
{
/* Configuration structure for ACMP */
static const ACMP_Init_TypeDef acmpInit =
{
.fullBias = false, /* The lightsensor is slow acting, */
.halfBias = true, /* comparator bias current can be set to lowest setting.*/
.biasProg = 0x0, /* Analog comparator will still be fast enough */
.interruptOnFallingEdge = false, /* No comparator interrupt, lesense will issue interrupts. */
.interruptOnRisingEdge = false,
.warmTime = acmpWarmTime512, /* Not applicable, lesense controls this. */
.hysteresisLevel = acmpHysteresisLevel5, /* Some hysteresis will prevent excessive toggling. */
.inactiveValue = false, /* Not applicable, lesense controls this. */
.lowPowerReferenceEnabled = false, /* Can be enabled for even lower power. */
.vddLevel = 0x00, /* Not applicable, lesense controls this through .acmpThres value. */
.enable = false /* Not applicable, lesense controls this. */
};
/* Initialize ACMP */
ACMP_Init(ACMP0, &acmpInit);
/* Disable ACMP0 out to a pin. */
ACMP_GPIOSetup(ACMP0, 0, false, false);
/* Set up ACMP negSel to VDD, posSel is controlled by LESENSE. */
ACMP_ChannelSet(ACMP0, acmpChannelVDD, acmpChannel0);
/* LESENSE controls ACMP thus ACMP_Enable(ACMP0) should NOT be called in order
* to ensure lower current consumption. */
}
/**************************************************************************//**
* @brief Sets up the LESENSE
*****************************************************************************/
void setupLESENSE(void)
{
/* LESENSE configuration structure */
static const LESENSE_Init_TypeDef initLesense =
{
.coreCtrl =
{ /* LESENSE configured for periodic scan. */
.scanStart = lesenseScanStartPeriodic,
.prsSel = lesensePRSCh0,
.scanConfSel = lesenseScanConfDirMap,
.invACMP0 = false,
.invACMP1 = false,
.dualSample = false,
.storeScanRes = false,
.bufOverWr = true,
.bufTrigLevel = lesenseBufTrigHalf,
.wakeupOnDMA = lesenseDMAWakeUpDisable,
.biasMode = lesenseBiasModeDutyCycle, /* Lesense should duty cycle comparator and related references etc. */
.debugRun = false
},
.timeCtrl =
{
.startDelay = 0 /* No start delay needed for this application. */
},
.perCtrl =
{ /* DAC is not needed for this application. */
.dacCh0Data = lesenseDACIfData,
.dacCh0ConvMode = lesenseDACConvModeDisable,
.dacCh0OutMode = lesenseDACOutModeDisable,
.dacCh1Data = lesenseDACIfData,
.dacCh1ConvMode = lesenseDACConvModeDisable,
.dacCh1OutMode = lesenseDACOutModeDisable,
.dacPresc = 0,
.dacRef = lesenseDACRefBandGap,
.acmp0Mode = lesenseACMPModeMuxThres, /* Allow LESENSE to control ACMP mux and reference threshold. */
.acmp1Mode = lesenseACMPModeMuxThres,
.warmupMode = lesenseWarmupModeNormal /* Normal mode means LESENSE is allowed to dutycycle comparator and reference. */
},
.decCtrl =
{ /* Decoder or statemachine not used in this code example. */
.decInput = lesenseDecInputSensorSt,
.initState = 0,
.chkState = false,
.intMap = true,
.hystPRS0 = false,
.hystPRS1 = false,
.hystPRS2 = false,
.hystIRQ = false,
.prsCount = true,
.prsChSel0 = lesensePRSCh0,
.prsChSel1 = lesensePRSCh1,
.prsChSel2 = lesensePRSCh2,
.prsChSel3 = lesensePRSCh3
}
};
/* Channel configuration */
/* Only one channel is configured for the lightsense application. */
static const LESENSE_ChDesc_TypeDef initLesenseCh =
{
.enaScanCh = true,
.enaPin = false, /* Pin is input, no enabling needed. Separate pin is exciting the sensor. */
.enaInt = true, /* Enable interrupt for this channel. */
.chPinExMode = lesenseChPinExHigh, /* Excite by pullin pin high. */
.chPinIdleMode = lesenseChPinIdleDis, /* During Idle, excite pin should be disabled (tri-stated). */
.useAltEx = true, /* Use alternate excite pin. */
.shiftRes = false, /* Not applicable, only for decoder operation. */
.invRes = false, /* No need to invert result. */
.storeCntRes = true, /* Not applicable, don't care really. */
.exClk = lesenseClkLF, /* Using low frequency clock for timing the excitation. */
.sampleClk = lesenseClkLF, /* Using low frequency clock for timing the sample instant. */
.exTime = 0x01, /* 1 LFclk cycle is enough excitation time, this depends on response time of light sensor. */
.sampleDelay = 0x01, /* Sampling should happen when excitation ends, it it happens earlier, excitation time might as well be reduced. */
.measDelay = 0x00, /* Not used here, basically only used for applications which uses the counting feature. */
.acmpThres = ACMP_THRESHOLD, /* This is the analog comparator threshold setting, determines when the acmp triggers. */
.sampleMode = lesenseSampleModeACMP, /* Sampling acmp, not counting. */
.intMode = lesenseSetIntLevel, /* Interrupt when voltage goes above threshold. */
.cntThres = 0x0000, /* Not applicable. */
.compMode = lesenseCompModeLess /* Not applicable. */
};
/* Alternate excitation channels configuration. */
/* The lightsensor is excited by alternate excite channel 0. */
static const LESENSE_ConfAltEx_TypeDef initAltEx =
{
.altExMap = lesenseAltExMapALTEX,
.AltEx[0] =
{
.enablePin = true,
.idleConf = lesenseAltExPinIdleDis,
.alwaysEx = true
},
.AltEx[1] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF,
.AltEx[2] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF,
.AltEx[3] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF,
.AltEx[4] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF,
.AltEx[5] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF,
.AltEx[6] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF,
.AltEx[7] = LESENSE_LIGHTSENSE_ALTEX_DIS_CH_CONF
};
/* Initialize LESENSE interface _with_ RESET. */
LESENSE_Init(&initLesense, true);
/* Configure LESENSE channel */
LESENSE_ChannelConfig(&initLesenseCh, LIGHTSENSE_CH);
/* Configure alternate excitation channels */
LESENSE_AltExConfig(&initAltEx);
/* Set scan frequency */
LESENSE_ScanFreqSet(0, LCSENSE_SCAN_FREQ);
/* Set clock divisor for LF clock. */
LESENSE_ClkDivSet(lesenseClkLF, lesenseClkDiv_2);
}
/**************************************************************************//**
* @brief Sets up the GPIO
*****************************************************************************/
void setupGPIO(void)
{
/* Configure the drive strength of the ports for the light sensor. */
GPIO_DriveModeSet(LIGHTSENSE_EXCITE_PORT, gpioDriveModeStandard);
GPIO_DriveModeSet(LIGHTSENSE_SENSOR_PORT, gpioDriveModeStandard);
/* Initialize the 2 GPIO pins of the light sensor setup. */
GPIO_PinModeSet(LIGHTSENSE_EXCITE_PORT, LIGHTSENSE_EXCITE_PIN, gpioModePushPull, 0);
GPIO_PinModeSet(LIGHTSENSE_SENSOR_PORT, LIGHTSENSE_SENSOR_PIN, gpioModeDisabled, 0);
}
/**************************************************************************//**
* @brief Configure ADC for 12 bit mode, sample channel 0 with Vdd as reference
* and use shortest acquisition time.
*****************************************************************************/
static void ADC_Config(void)
{
CMU_ClockEnable(cmuClock_ADC0, true);
ADC_Init_TypeDef init = ADC_INIT_DEFAULT;
ADC_InitSingle_TypeDef singleInit = ADC_INITSINGLE_DEFAULT;
/* Init common settings for both single conversion and scan mode- */
/* Set timebase to 10, this gives 11 cycles which equals 1us at 11 MHz. */
init.timebase = 10;
/* Set ADC clock prescaler to 0, we are using 11MHz HFRCO, which results in HFPERCLK < 13MHz- */
init.prescale = 0;
ADC_Init(ADC0, &init);
/* Init for single conversion use, measure channel 0 with Vdd as reference. */
/* Using Vdd as reference removes the 5us warmup time for the bandgap reference. */
singleInit.reference = adcRefVDD;
singleInit.input = adcSingleInpCh5;
/* Resolution can be set lower for even more energy efficient operation. */
singleInit.resolution = adcRes8Bit;
/* Assuming we are mesuring a low impedance source we can safely use the shortest */
/* acquisition time. */
singleInit.acqTime = adcAcqTime1;
ADC_InitSingle(ADC0, &singleInit);
/* Enable ADC Interrupt when Single Conversion Complete. */
/* This is necessary for WFE (wait for event) to work. */
/* Notice that enabling the interrupt in the NVIC is not needed. */
ADC0->IEN = ADC_IEN_SINGLE;
}
/**************************************************************************//**
* @brief A separate function for taking all the samples is preferred since
* the whole idea is to stay in EM2 between samples. If other code is added,
* it might be more energy efficient to configure the ADC to use DMA while
* the cpu can do other work.
*****************************************************************************/
void doAdcSampling(uint16_t* buffer)
{
uint16_t sample_count = 0;
/* Enable RTC, this can be enabled all the time as well if needed. */
RTC_Enable(true);
while(sample_count < BUFFER_SAMPLES)
{
/* Enable deep sleep to enter EM2 between samples. */
SCB->SCR = SCB_SCR_SEVONPEND_Msk | SCB_SCR_SLEEPDEEP_Msk;
/* Go to sleep while waiting for RTC event (set by RTC_IRQ pending bit) */
/* Since IRQ is not enabled in the NVIC, no ISR will be entered */
__WFE();
/* Start ADC conversion as soon as we wake up. */
ADC_Start(ADC0, adcStartSingle);
/* Clear the interrupt flag */
RTC_IntClear(RTC_IF_COMP0);
/* Clear pending RTC IRQ */
NVIC_ClearPendingIRQ(RTC_IRQn);
/* Wait while conversion is active in EM1, should be almost finished since it */
/* takes 13 cycles + warmup (1us), and it was started a while ago. */
/* Disable deep sleep so we wait in EM1 for conversion to finish. */
SCB->SCR = SCB_SCR_SEVONPEND_Msk;
__WFE();
/* Clear the interrupt flag */
ADC_IntClear(ADC0, ADC_IF_SINGLE);
/* Clear pending IRQ */
NVIC_ClearPendingIRQ(ADC0_IRQn);
/* Get ADC result */
buffer[sample_count++] = ADC_DataSingleGet(ADC0);
}
RTC_Enable(false);
}
/***************************************************************************//**
* @brief
* Process the sampled data through FFT.
*******************************************************************************/
void ProcessFFT(void)
{
uint16_t *inBuf;
int32_t value;
int i;
inBuf = lightToFFTBuffer;
/*
* Convert to float values.
*/
for (i = 0; i < BUFFER_SAMPLES; ++i)
{
value = (int32_t)*inBuf++;
floatBuf[i] = (float32_t)value;
}
/* Process the data through the RFFT module, resulting complex output is
* stored in fftOutputComplex
*/
arm_rfft_f32(&rfft_instance, floatBuf, fftOutputComplex);
/* Compute the magnitude of all the resulting complex numbers */
arm_cmplx_mag_f32(fftOutputComplex,
fftOutputMag,
BUFFER_SAMPLES);
}
/***************************************************************************//**
* @brief
* Find the maximal bin and estimate the frequency using sinc interpolation.
* @return
* Frequency of maximal peak
*******************************************************************************/
float32_t GetFreq(void)
{
float32_t maxVal;
uint32_t maxIndex;
/* Real and imag components of maximal bin and bins on each side */
float32_t rz_p, iz_p, rz_n, iz_n, rz_0, iz_0;
/* Small correction to the "index" of the maximal bin */
float32_t deltaIndex;
/* Real and imag components of the intermediate result */
float32_t a, b, c, d;
#define START_INDEX 4
/* Find the biggest bin, disregarding the first bins because of DC offset and
* low frequency noise.
*/
arm_max_f32(&fftOutputMag[START_INDEX],
BUFFER_SAMPLES / 2 - START_INDEX,
&maxVal,
&maxIndex);
maxIndex += START_INDEX;
/* Perform sinc() interpolation using the two bins on each side of the
* maximal bin. For more information see page 113 of
* http://tmo.jpl.nasa.gov/progress_report/42-118/118I.pdf
*/
/* z_{peak} */
rz_0 = fftOutputComplex[maxIndex * 2];
iz_0 = fftOutputComplex[maxIndex * 2 + 1];
/* z_{peak+1} */
rz_p = fftOutputComplex[maxIndex * 2 + 2];
iz_p = fftOutputComplex[maxIndex * 2 + 2 + 1];
/* z_{peak-1} */
rz_n = fftOutputComplex[maxIndex * 2 - 2];
iz_n = fftOutputComplex[maxIndex * 2 - 2 + 1];
/* z_{peak+1} - z_{peak-1} */
a = rz_p - rz_n;
b = iz_p - iz_n;
/* z_{peak+1} + z_{peak-1} - 2*z_{peak} */
c = rz_p + rz_n - (float32_t)2.0 * rz_0;
d = iz_p + iz_n - (float32_t)2.0 * iz_0;
/* Re (z_{peak+1} - z_{peak-1}) / (z_{peak+1} + z_{peak-1} - 2*z_{peak}) */
deltaIndex = (a*c + b*d) / (c*c + d*d);
return ((float32_t)maxIndex + deltaIndex)
* (float32_t)SAMPLE_RATE
/ (float32_t)BUFFER_SAMPLES;
}
/***************************************************************************//**
* @brief
* Main function. Setup ADC, FFT, clocks, PRS, DMA, Timer,
* and process FFT forever.
*******************************************************************************/
int main(void)
{
uint32_t time;
arm_status status;
/* Chip errata */
CHIP_Init();
/* Enable clocks for used peripherals */
setupCMU();
/* Setup the ACMP */
setupACMP();
/* Setup the GPIO */
setupGPIO();
/* setup lesense */
setupLESENSE();
/* Enable LCD without voltage boost */
SegmentLCD_Init(false);
SegmentLCD_Symbol(LCD_SYMBOL_GECKO, 1);
SegmentLCD_Symbol(LCD_SYMBOL_EFM32, 1);
/* Initialize the CFFT/CIFFT module */
status = arm_rfft_init_f32(&rfft_instance,
&cfft_instance,
BUFFER_SAMPLES,
0, /* forward transform */
1); /* normal, not bitreversed, order */
if (status != ARM_MATH_SUCCESS) {
/* Error initializing RFFT module. */
SegmentLCD_Write(" Error ");
while (1) ;
}
/* Configure RTC to use LFXO as clock source */
RTC_Setup(cmuSelect_LFXO);
/* Configure ADC */
ADC_Config();
/* Enable DWT */
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
/* Make sure CYCCNT is running */
DWT->CTRL |= 1;
while (1)
{
/* Power the light sensor with GPIO. */
GPIO_PinModeSet( EXCITE_PIN, gpioModePushPull, 1);
/* Do sampling. */
doAdcSampling(lightToFFTBuffer);
/* Power off the light sensor. */
GPIO_PinModeSet( EXCITE_PIN, gpioModeDisabled, 0);
/* Do FFT, measure number of cpu cycles used. */
time = DWT->CYCCNT;
ProcessFFT();
time = DWT->CYCCNT - time;
/* Display dominant frequency. */
SegmentLCD_Number( (int)GetFreq() );
/* Display cpu cycle count used to do FFT. */
SegmentLCD_LowerNumber( (int)time );
/* Check last ADC value to determine if lightlevel is too low. */
/* Go to sleep with lesense enabled if ADC reading is below 10. */
if(lightToFFTBuffer[BUFFER_SAMPLES-1] < 10)
{
/* Write to LCD that lightlevel is too low. */
SegmentLCD_NumberOff();
SegmentLCD_Write("DARK");
/* Set gpio in pushpull for lesense operation. */
GPIO_PinModeSet(LIGHTSENSE_EXCITE_PORT, LIGHTSENSE_EXCITE_PIN, gpioModePushPull, 0);
LESENSE->ROUTE = LESENSE_ROUTE_ALTEX0PEN;
/* Start scan. */
LESENSE_ScanStart();
/* Enable deep sleep to enter EM2. */
SCB->SCR = SCB_SCR_SEVONPEND_Msk | SCB_SCR_SLEEPDEEP_Msk;
/* Go to sleep while waiting for LESENSE event */
/* Since IRQ is not enabled in the NVIC, no ISR will be entered */
__WFE();
/* Clear interrupt flag */
LESENSE_IntClear(LIGHTSENSE_INTERRUPT);
/* Clear pending RTC IRQ */
NVIC_ClearPendingIRQ(LESENSE_IRQn);
LESENSE_ScanStop();
LESENSE->ROUTE &= ~LESENSE_ROUTE_ALTEX0PEN;
}
}
}
```
Поехали
Подключаем плату в режиме DBG, программируем микроконтроллер, подключаем вход АЦП к выходу интерфейса датчиков (через него опрашивается light sensor), запускаем.
Вывод первый: программа работает корректно. Когда работает лампа дневного света, результат работы вычислений — 100 Гц (в сети переменного тока частота 50 Гц, а «максимальная интенсивность» света включенной в сеть лампы достигается и на минимуме, и на максимуме синусоиды, т.е. дважды за период). Помещая датчик освещенности в тень получаем результат «DARK», а при естественном освещении — «прыгающие» цифры.
Теперь воспользуемся утилитой [energy profiler](http://geektimes.ru/post/254812/), которая предоставляет график изменения уровня энергопотребления, обновляющийся по ходу исполнения программы.
Запускаем профилирование для платы EFM32WG-STK3800.
На вычисления у микроконтроллера EFM32WG990F256 ушло около 49 мс, среднее энергопотребление — 411 мкА. Запомним этот результат и попробуем запустить ту же сишную программу на модуле с микроконтроллером на базе Cortex-M3, то есть без всяких DSP- и FPU-инструкций ядра.
В свойствах проекта для этого необходимо
**изменить целевой микроконтроллер с EFM32WG990F256 на EFM32GG990F1024,**
**объяснить компилятору, транслятору и линковщику что программа теперь собирается для кристалла на базе cortex-m3 вместо cortex-m4,**
**отключить опцию использования аппаратного fpu.**
Естественно, в других IDE процесс может проходить несколько иначе, для разных серий микроконтроллеров также возможны различные нюансы, однако принцип перехода на другое ядро будет тот же.
Итак, после сохранения новых настроек и подключения другой отладочной платы повторим эксперимент.
Результаты можно сравнивать с чистой совестью: оба кристалла работают с тактовой частотой 48 МГц, опрос датчиков и обработка данных идут с одинаковой периодичностью, результаты выводятся в одном и том же формате на одинаковые ЖКИ.
По графикам видно, что энергопотребление кристалла действительно почти полностью определяется уровнем потребления на этапах вычислений и вывода их результатов. Измерения же проводятся в режиме «сна» и практически не влияют на общее энергопотребление. Вычисления на ядре Cortex-M3 проводятся в 2.2 раза медленнее, в той же пропорции изменяется и среднее энергопотребление устройства.
С одной стороны, вся математика, необходимая для решения задачи может исполняться и на контроллере с ядром Cortex-M3, однако разница в скорости вычислений может быть существенной для многих устройств, критичных к энергопотреблению или скорости работы.
*На всякий случай прошу прощения за некоторые упрощения и допущения, сделанные в первой части статьи. Спасибо за внимание* | https://habr.com/ru/post/277491/ | null | ru | null |
# Multi-Master репликация в MySQL
В данной статье будет рассмотрен процесс развертывания отказоустойчивой подсистемы баз данных на базе MySQL сервера.
*Перед прочтением советую прочитать [эту статью](http://habrahabr.ru/blogs/mysql/56702/).*
На работе встал вопрос по созданию зеркала сайта для другого региона (Азия). Т.к. время прохождения пакетов туда довольно большое, сказывается географическая удалённость, да и Великий Китайский Файервол тоже еще не отменили, то было решено создать зеркало в азиатском регионе. С переносом движка проблем не предвиделось, файлы пользователей можно спокойно синхронизировать через rsync, а вот с базой данных наметилась проблема. Как быть если пользователь добавил объект в Азии? Надо, чтобы этот объект был виден не только пользователям локального зеркала, но и всем остальным.
Изучение вопроса я начал с кластеризации MySQL. Выяснилось много интересных подробностей. Например, то, что версия сервера входящая в дистрибьютив Ubuntu(её я использую на тестовом стенде) не поддерживает NDB(Network Data Base) Storage Engine. Необходимо поставить либо версию mysql-max, которая по слухам поддерживает NDB, либо mysql-cluster. Самое интересно что deb-пакетов для них нет, так что надо либо ставить из бинарников, либо из исходников. Установка из бинарноков у меня не получилась. Я никак не мог удалить старый сервер (пакет удаляется, а файлы все на месте). Честно прокулупавшись с этим два дня я бросил сию затею. Из исходников компилировать не пробовал, но думаю это самый лучший вариант.
#### Master-Master replication
Вообщем следующим этапом изысканий была репликация. Тут то я и понял, что это то, что мне нужно. Есть центральный сервер, и есть реплика в регионе, которая будет таскать с него обновления. Но надо сделать так, чтобы и обновления с реплики попадали в основную базу. Получается, необходимо сделать master-master репикацию. Т.е. первый сервер будет мастером для второго(второй подключапется к нему как слейв), а второй будет мастером для первого(первый подключается к нему как слейв). Испытания проводил на виртуалках на базе Ubuntu Server 9.10
Итак, сервер ubuntu1(192.168.0.21), конфиг mysql:
`[mysqld]
# номер сервера, у всех реплицируемых серверов они должны быть уникальными
server-id = 1
# конфигурация серера, как мастера
log-bin = /var/lib/mysql/mysql-bin
# конфигурация сервера, как слейва
relay-log = /var/lib/mysql/mysql-relay-bin
relay-log-index = /var/lib/mysql/mysql-relay-bin.index
replicate-do-db = test_db
master-host=192.168.0.22 #ubuntu2
master-user=replication
master-password=password_of_user_replication
master-port=3306`
Для второго аналогично, только другой ip мастера и номер сервера.
Теперь перезапускаем сервера. Потом создаем юзера replication, даем ему права на репликацию:
`mysql@ubuntu1> GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'replication'@'192.168.0.22' IDENTIFIED BY 'password';
mysql@ubuntu2> GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'replication'@'192.168.0.21' IDENTIFIED BY 'password';`
Дальше необходимо привязать слейвов к своим мастерам. Делается это так:
Привязка ubuntu1 как мастера к ubuntu2:
Сначала блокируем запись в базу.
`mysql@ubuntu1> SET GLOBAL read_only = OFF;`
Подробнее об этом можно прочитать [здесь](http://habrahabr.ru/blogs/mysql/56702/)
`mysql@ubuntu1> show master status;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000006 | 7984 | | |
+------------------+----------+--------------+------------------+
1 row in set (0,00 sec)`
Берем оттуда значение File и position и осуществляем подключение мастера.
`mysql@ubuntu2> slave stop; # на всякий случай
mysql@ubuntu2> CHANGE MASTER TO MASTER_HOST = "192.168.0.22", MASTER_USER = "replication", MASTER_PASSWORD = "password_of_user_replication", MASTER_LOG_FILE = "mysql-bin.000006", MASTER_LOG_POS = 7984;
mysql@ubuntu2> slave start;`
После этого проверить подключение можно либо через
`mysql@ubuntu2>load data from master;`
либо через
`mysql@ubuntu2> show slave status;`
Если ошибок нет, мастер подключен.
Теперь подключаем этот сервер в качестве мастера для первого (делается точно также).
В итоге мы имеем систему из двух серверов, вносим изменение на любой сервер и оно реплицируется на второй.
#### Multi-Master replication
Но этого мне показалось мало. А если захочется добавить третий сервер? Сначала я думал про линейную топологию
ubuntu1 <-> ubuntu2 <-> ubunt3 и даже топологию звезда. Но увы, это было далеко от реальности. MySQL не позволяет одному слейву иметь несколько мастеров. А в линейной топологии таким будет ubuntu2. Если кто-то знает, **как можно прявязать один слейв к нескольким мастерам** буду благодарен за информацию.
Звезда не подходит, линейная тоже, остается кольцо. А попробую, подумал я.
Получается что в данной схеме каждый сервер имеет только одного мастера, а благодаря тому, что кольцо замкнуто, обновления дойдут до всех серверов из любой точки кольца. Тут важно упомянуть, что чтобы мастер **передавал на слейв не только свои собственные обновления, но и обновления своего мастера** надо добавить в [mysqld] секцию my.cnf строку:
`log-slave-updates`
соответственно в конфиг каждого сервера.
Проверил, и был приятно удивлен, что схема заработала. Где бы не меняли базу, изменения реально реплицируются на остальные сервера.
#### Автоинкрементные поля
При одновременном добавлении новых строк, содержащих автоинкрементные поля, на разные мастер-сервера может возникнуть конфликт. Чтобы такого не происходило, надо изменить шаг последовательности автоинкрементов на серверах БД.
* auto\_increment\_increment определяет шаг изменения AUTO\_INCREMENT .
* auto\_increment\_offset определяет начальное значение инкремента
Подобрав правильные(не конфликтующие) значения этих параметров на разных мастерах, сервера, используемые в мульти-мастер конфигурации будут использовать неконфликтующие значения AUTO\_INCREMENT при вставки записей. Например для N мастер-серверов, установим такие значения:
* Установим auto\_increment\_increment в N на каждом мастере.
* На каждом из N мастеров ставим разные значения auto\_increment\_offset, используя 1, 2,…, N.
Например, используя auto\_increment\_increment = 10 и auto\_increment\_offset=3, будут сгенерированы следующие значения поля 3, 13, 23. А используя 10, 7, будут такие 7, 17, 27, и т.д.
#### Отказоусточивость
После всего этого не мог не попробовать уронить один из серверов. Выдергиваем питание из ubuntu2. Потом загружаем его. Что же получается?
При последующих изменениях на ubnutu2 они без проблем тиражируются на ubuntu3 и ubuntu1. Но изменения вносимые на ubuntu2 на остальные сервера не тиражируеются. Смотрим show slave status на ubuntu3 и видим, что он потерял своего мастера.
В качестве рецепта, могу предложить следующее:
После старта сервера БД выполнять отвязывание мастера от слейва текущего сервера, и привязывание его вновь. Т.к. в топологии кольцо слейв у любого сервера один, это упрощает задачу. Алгоритм будет примерно такой:
1. ubuntu2 выключился по питанию и загрузился вновь
2. ubuntu2 у себя:
— блокирует реплицируемую базу на запись: `mysql@ubuntu2> SET GLOBAL read_only = OFF;`
— смотрит название и позицию в логе: `mysql@ubuntu2> show master status;`
2. ubuntu2 через mysql клиент заходит на своего слейва (ubuntu3)
— отвязывает себя от слейва `mysql@ubuntu3> slave stop;`
— объявляет себя мастером: `mysql@ubuntu3> CHANGE MASTER TO MASTER_HOST = "192.168.0.22", MASTER_USER = "replication", MASTER_PASSWORD = "password_of_user_replication", MASTER_LOG_FILE = "mysql-bin.000006", MASTER_LOG_POS = 5161;` с полученными на предыдущем шаге названием лога и позицией.
— вновь привязывает слейва: `mysql@ubuntu3> slave start;`
Пока реализация данного скрипта не готова, думаю на чем его писать perl/php/python/bash…
Буду рад услышать мысли хабрасообщества на эту тему. Пишите если статья оказалась полезной, в планах всё-таки разобраться с кластеризацией и сделать репликацию кластеров. | https://habr.com/ru/post/87394/ | null | ru | null |
# Как создать telegram бот на C# быстро?
Добрый день, уважаемые друзья!
------------------------------
В этой статье мы рассмотрим заготовку для создания телеграм бота на C#. В связи с последними обновлениями TelegramBotAPI, большая часть удачных с моей точки зрения публикаций на эту тему несколько устарело. Потому я принял решение написать статью на эту тему.
Процесс создания и отладки бота был записан и освещен в видеоролике в статье ниже. В [телеграм группе](https://t.me/DevBotFriends) можно задать вопрос по данной тематике.
Чуть подробнее
--------------
Мы будем пользоваться библиотеками *Telegram.Bot и* *Telegram.Bot.Extentions.Polling*, обновления будем получать периодически опрашивая Telegram сервер на наличие новых обновлений. Webhook'и мы использовать не будем...Тпру, подождите меня забрасывать гнилыми помидорами, матерые кодеры! Да, метод получения обновлений основанный на Webhook'ах лучше, но Polling проще в реализации поскольку не нужно получать SSL-сертификат и бот можно запустить сразу после написания кода без дополнительных заморочек. На этом новичок может застопориться. К тому же есть ряд нюансов при использовании Webhook'ов на моем сервере. Если они есть у меня, значит они могут быть и у Вас. Потому используем метод периодического опроса сервера Телеграма на наличие новых обновлений. Ладно, уважаемый читатель, если Вы все еще со мной не согласны и желаете получить сертификат и работать на Webhook'ах, можешь почитать о получении сертификата в [этой статье](https://habr.com/ru/sandbox/103396/).
Существующие схемы работы telegram бота
---------------------------------------
Мне нравится схема работы telegram бота на C#, описанная в [этой статье](https://habr.com/ru/company/alfa/blog/343846/). Считаю ее хорошим примером. Вот код:
```
using Telegram.Bot;
using Telegram.Bot.Args;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;
class Program
{
private static TelegramBotClient client;
static void Main(string[] args)
{
// token, который вернул BotFather
client = new TelegramBotClient(token);
client.OnMessage += BotOnMessageReceived;
client.OnMessageEdited += BotOnMessageReceived;
client.StartReceiving();
Console.ReadLine();
client.StopReceiving();
}
private async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
if (message?.Type == MessageType.TextMessage)
{
await client.SendTextMessageAsync(message.Chat.Id, message.Text);
}
}
}
```
Там ничего лишнего. Создаем объект TelegramBotClient чтобы взаимодействовать с нашим ботом с помощью библиотеки, прописываем ему токен, который выдал нам BotFather. Далее создаем событие OnMessage, обрабатываем его методом BotOnMessageReceived и запускаем клиент.
Однако с выходом более новых версий TelegramBotAPI оказалось, что такая схема больше не работает. Более того, боты, написанные на более ранних версиях Telegram.Bot перестают работать после обновления библиотеки.
Нужно использовать другую схему. Давайте попробуем в этом разобраться.
Пошаговая инструкция
--------------------
Итак ниже я набросал следующий список шагов, которые приведут вас к рабочему telegram боту.
*1. Запускаем Visual Studio Community, создаем консольное приложение.*
Если у Вас отсутствует Visual Studio Community, Вы можете установить ее используя [статью](https://metanit.com/sharp/tutorial/1.2.php)или несколько устаревшее [видео](https://www.youtube.com/watch?v=y1OXLBDZT7k&list=PLL-k0Ff5RfqXGhAooRkUpzMLd6_Fpr13I&index=2&t=7s&ab_channel=EugenePopov). При этом желательно выбирать установку Visual Studio Community 2022 как наиболее актуальную версию на текущий момент.
Создаем проектНазываем проект как нам удобноВыбираем платформу .NET 3.1Проект создан!*2. Добавляем в консольное приложение библиотеку Telegram.Bot, Telegram.Bot.Extentions.Polling и Netonsoft.Json*
Открытие NuGetПоиск библиотекиУстановка пакетаПо завершению у Вас должны быть установлены и отображены названия пакетов, которые мы установили.
Netonsoft.Json применимо к нашей заготовке нужна для того, чтобы у нас была возможность вывести на консоль сообщение от пользователя.
*3. Создаем telegram бот в BotFather. Копируем его api key для работы.*
Находим в telegram BotFather, отправляем ему /newbot, название и логин бота
BotFather должен нам предоставить API key, который мы должны вставить в код-каркас в следующем шаге в строке
*static ITelegramBotClient bot = new TelegramBotClient("TOKEN");*
4. В файл Program.cs вставляем следующий код-каркас:
```
using System;
using System.Threading;
using System.Threading.Tasks;
using Telegram.Bot;
using Telegram.Bot.Extensions.Polling;
using Telegram.Bot.Types;
using Telegram.Bot.Exceptions;
namespace TelegramBotExperiments
{
class Program
{
static ITelegramBotClient bot = new TelegramBotClient("TOKEN");
public static async Task HandleUpdateAsync(ITelegramBotClient botClient, Update update, CancellationToken cancellationToken)
{
// Некоторые действия
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(update));
if(update.Type == Telegram.Bot.Types.Enums.UpdateType.Message)
{
var message = update.Message;
if (message.Text.ToLower() == "/start")
{
await botClient.SendTextMessageAsync(message.Chat, "Добро пожаловать на борт, добрый путник!");
return;
}
await botClient.SendTextMessageAsync(message.Chat, "Привет-привет!!");
}
}
public static async Task HandleErrorAsync(ITelegramBotClient botClient, Exception exception, CancellationToken cancellationToken)
{
// Некоторые действия
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(exception));
}
static void Main(string[] args)
{
Console.WriteLine("Запущен бот " + bot.GetMeAsync().Result.FirstName);
var cts = new CancellationTokenSource();
var cancellationToken = cts.Token;
var receiverOptions = new ReceiverOptions
{
AllowedUpdates = { }, // receive all update types
};
bot.StartReceiving(
HandleUpdateAsync,
HandleErrorAsync,
receiverOptions,
cancellationToken
);
Console.ReadLine();
}
}
}
```
*5. Редактируем код под свои нужды и задачи.*
Главное задачей, которую должен выполнять бот - это реагировать на сообщения, которые отправляет ему пользователь. Конечно, разработчики telegram'a заложили возможность отслеживания и реагирования на много других событий.
К важным я бы отнес еще нажатие кнопки inline клавиатуры пользователем, inline mode - когда пользователь вводит логин бота и поисковой запрос в текстовое поле и бот предоставляет список найденных объектов по этому запросу. Также интересно было бы рассмотреть событие публикации нового поста на канале. Получение от пользователя его номера телефона, файла или геолокации. Но это материал для следующих видеороликов и статей. Если Вам интересно увидеть этот материал на YouTube канале или в статье, ставьте лайки, делитесь статьей с друзьями. При достижении 200 лайков и 20 комментариев я буду знать, что вам нравится данная тема и напишу продолжение.
Итак что мы можем сделать когда пользователь отправил нашему боту сообщение?
Во-первых мы можем вывести ее на консоль. Для этого в Nuget установим либу Newtonsoft и пропишем в методе HandleUpdateAsync.
```
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(update));
```
Конечно, мы можем проверить что он нам прислал. И если текст сообщения будет тем, который мы ждем, выполнить определенные действия.Например если пользователь нажал кнопку Start и тем самым отправил боту текст "/start", мы можем отправить ему в ответ "Добро пожаловать на борт, добрый путник!".
```
if (update.Type == Telegram.Bot.Types.Enums.UpdateType.Message)
{
var message = update.Message;
if (message.Text.ToLower() == "/start")
{
await botClient.SendTextMessageAsync(message.Chat, "Добро пожаловать на борт, добрый путник!");
return;
}
await botClient.SendTextMessageAsync(message.Chat, "Здоров, братан! И тебе не хворать!");
}
```
*if (update.Type == Telegram.Bot.Types.Enums.UpdateType.Message)*
Здесь мы проверяем тип обновления. Если пользователь отправил нам сообщение, выполняем ниже описанные действия.
*var message = update.Message;*
Создаем новую переменную для удобства и записываем в нее всю информацию о пришедшем сообщении.
*if (message.Text.ToLower() == "/start")*
Проверяем какой текст отправил пользователь. Если текст сообщения в нижнем регистре (.ToLower()) является словом "/start", то пишем ему сообщение "Добро пожаловать на борт, добрый путник!". И останавливаем выполнение метода командой return.
Целесообразно также данные этого пользователя записать в какую-нибудь базу данных. Например MySQL, PostgreSQL или еще какую-то. Или просто в файл. Напишите в комментариях если Вам это интересно.
А если пользователь отправит боту другое сообщение, например "Здравствуй", мы можем написать боту, например, "Здоров, братан! И тебе не хворать"
*await botClient.SendTextMessageAsync(message.Chat, "Здоров, братан! И тебе не хворать!");*
Думаю принцип вы поняли.
Полный код ниже:
```
using System;
using System.Threading;
using System.Threading.Tasks;
using Telegram.Bot;
using Telegram.Bot.Extensions.Polling;
using Telegram.Bot.Types;
using Telegram.Bot.Exceptions;
namespace TelegramBotExperiments
{
class Program
{
static ITelegramBotClient bot = new TelegramBotClient("TOKEN");
public static async Task HandleUpdateAsync(ITelegramBotClient botClient, Update update, CancellationToken cancellationToken)
{
// Некоторые действия
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(update));
if(update.Type == Telegram.Bot.Types.Enums.UpdateType.Message)
{
var message = update.Message;
if (message.Text.ToLower() == "/start")
{
await botClient.SendTextMessageAsync(message.Chat, "Добро пожаловать на борт, добрый путник!");
return;
}
await botClient.SendTextMessageAsync(message.Chat, "Привет-привет!!");
}
}
public static async Task HandleErrorAsync(ITelegramBotClient botClient, Exception exception, CancellationToken cancellationToken)
{
// Некоторые действия
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(exception));
}
static void Main(string[] args)
{
Console.WriteLine("Запущен бот " + bot.GetMeAsync().Result.FirstName);
var cts = new CancellationTokenSource();
var cancellationToken = cts.Token;
var receiverOptions = new ReceiverOptions
{
AllowedUpdates = { }, // receive all update types
};
bot.StartReceiving(
HandleUpdateAsync,
HandleErrorAsync,
receiverOptions,
cancellationToken
);
Console.ReadLine();
}
}
}
```
Не забудьте вставить в код API key от Вашего бота там, где написано TOKEN.
Для удобства записал видео.
Заключение
----------
Итак в этой статье мы с вами создали telegram бот с нуля и протестировали его на работоспособность. Созданную заготовку можно будет использовать в дальнейшем для создания полномасштабных коммерческих проектов. | https://habr.com/ru/post/657583/ | null | ru | null |
# Система удалённого мониторинга рабочих мест на базе 360-градусной камеры и Raspberry Pi
Я создал прототип системы удалённого мониторинга рабочих мест. Эта система позволяет организациям, адаптирующимся к ограничениям, связанным с COVID-19, осуществлять наблюдение за сотрудниками и проводить виртуальные инспекции рабочих мест.
Система, о которой я хочу рассказать, представляет собой роботизированную панорамную камеру. Проект основан на Raspberry Pi. Здесь, ради простоты, используются панорамные фотографии, а не видеозаписи или потоковая передача сигнала. Опыт, полученный в ходе работы с сотнями компаний, использующих камеры с обзором в 360 градусов (эти компании, в целом, провели миллионы виртуальных проверок сотрудников), и анализ рынка, подсказывают мне, что сейчас, в начале 2021 года, чаще всего встречаются именно решения, основанные на панорамных фотографиях.
[](https://habr.com/ru/company/ruvds/blog/550192/)
Я, исследуя ситуацию, пользовался [материалами](https://community.theta360.guide/c/theta-api-usage/5) форума, посвящённого использованию API Ricoh Theta, и тем, что удалось узнать при личном общении с представителями бизнеса в ходе онлайн-встреч с ними.
Требования к проекту
--------------------
Я остановился на следующих требованиях к проекту, касающихся его аппаратной составляющей и инфраструктуры:
1. Гибкое позиционирование камеры с помощью робота.
2. Использование одноплатного компьютера Raspberry Pi 4 с 4 Гб памяти для управления камерой и роботом.
3. Ориентация системы на съёмку 360-градусных фотографий.
4. Применение прозрачного корпуса камеры.
5. Организация связи камеры с системой управления камерой по Wi-Fi.
Раскрою некоторые подробности, касающиеся вышеозначенных требований.
### ▍1. Гибкое позиционирование камеры
Использование робота для позиционирования камеры позволяет организовать удалённое наблюдение за рабочим местом сотрудников, что актуально во время эпидемии COVID-19. Это, кроме того, позволяет использовать камеру в составе систем, рассчитанных на работу в опасных для человека условиях, например — это могут быть системы для анализа радиационной обстановки. В моём проекте используется игрушечный гусеничный робот. Благодаря этому стоимость компонентов проекта невелика, поэтому создать соответствующий прототип смогут все, кому он может понадобиться. При этом те же механизмы управления камерой, которые используются в прототипе, легко можно адаптировать к применению в подобных системах, основанных на промышленных роботах.
### ▍2. Raspberry Pi 4
На Raspberry Pi 4 можно установить, кроме прочих ОС, специализированную операционную систему Robot Operating System (ROS). Я решил использовать в проекте стандартную ОС Raspberry Pi. Благодаря этому он будет доступнее для заинтересовавшихся им разработчиков и организаций.
### ▍3. 360-градусные фотографии
Самым популярным форматом выходных данных 360-градусных камер являются именно фотоснимки. Они, в сравнении с видео, дают более высокое разрешение изображения и хранятся в файлах гораздо меньшего размера. Работать с фотографиями значительно легче, чем с видео. В результате у проекта, который создаётся в расчёте на использование фотоснимков, больше шансов на успешное завершение.
### ▍4. Прозрачный корпус камеры
Прозрачный корпус защищает камеру от дождя, от пыли и промышленных загрязнителей. Имеется растущий тренд использования камер потребительского уровня, вроде Ricoh Theta, в крупномасштабных коммерческих проектах. В результате растёт потребность в защите таких камер от физических повреждений, от загрязнений, от плохой погоды. Одна из задач моего проекта заключается в исследовании воздействия прозрачного корпуса на качество изображений.
### ▍5. Wi-Fi-соединение между камерой и контроллером
Хотя надёжнее было бы организовать управление камерой по USB, используя Picture Transfer Protocol (PTP) и применяя библиотеку [libptp](https://dzone.com/articles/controlling-iot-cameras-with-libptp), я решил выбрать [API](https://developers.google.com/streetview/open-spherical-camera/reference) Google Open Spherical Camera (OSC) и связываться с камерой по Wi-Fi. API OSC, которое в документации Ricoh называется «Web API», легче реализовать, что позволяет быстрее перейти к практическим испытаниям проекта.
*Снимок, сделанный камерой, смонтированной на гусеничном роботе и заключённой в прозрачный корпус, отличается минимальными искажениями*
Преимущества фотоснимков перед потоковой передачей видео
--------------------------------------------------------
Я дополнил то, что можно найти о системах наблюдения в интернете, пообщавшись с людьми, которые работают с такими системами. В частности, поговорил с инженерами из компаний [fulldepth](https://fulldepth.co.jp/), и [Unusly](https://www.unusly.com). Первая компания занимается глубоководными системами наблюдения, вторая специализируется на системах, предназначенных для сферы недвижимости. Меня интересовал опыт инженеров, касающийся роботизированных систем.
Компания fulldepth тестировала потоковую передачу видео с 360-градусной камеры, смонтированной на роботе, который предназначен для работы на глубине в 300 метров.
*Продукция компании fulldepth*
Одна из моих ранее опубликованных [статей](https://dzone.com/articles/add-live-virtual-experiences-to-your-application) посвящена потоковой передаче 360-градусного видео. Хотя этот подход весьма популярен в сфере прототипирования систем наблюдения, и хотя он находит применение в определённых коммерческих проектах, в интернет-обсуждениях больше внимания приковано к панорамным снимкам, которые используются для целей мониторинга и для организации [виртуальных туров](https://dzone.com/articles/build-virtual-tours-of-houses-and-parks-with-open).
Изначально я хотел реализовать в описываемом тут проекте возможность потоковой передачи видео с Raspberry Pi на Windows 10-компьютер с применением RTP. Специалисты из fulldepth поделились со всеми желающими [методологией](https://community.theta360.guide/t/live-streaming-over-usb-on-ubuntu-and-linux-nvidia-jetson/4359/191?u=craig) потоковой передачи 360-градусного видео с Raspberry Pi. Используя их спецификации и программный код я, наверняка, смог бы реализовать нечто подобное и в своём проекте.
Но я, в итоге, остановился именно на фотоснимках. На моё решение сильнее всего повлияло то, что устройствами для получения подобных фотоматериалов очень сильно интересуются компании, занимающиеся продажей подержанных машин, фирмы, которые занимаются недвижимостью, строительные компании. Речь идёт о том, что таким организациям нужно воссоздать привычный порядок работы в условиях эпидемии COVID-19. Вот почему подобные компании отдают предпочтение фотографиям:
* Разрешение фотоснимков больше, чем разрешение видео. Фотографии лучше выглядят с точки зрения людей, а системы искусственного интеллекта могут использовать их для определения параметров объектов.
* При съёмке фотографий можно лучше контролировать параметры изображения — такие, как выдержка (изображение можно делать светлее или темнее) и цветность.
* Возможность создания HDR-изображений (High Dynamic Range, расширенный динамический диапазон), позволяющая корректировать неблагоприятные условия освещённости (нечто вроде слишком светлых фрагментов изображений, появление которых вызывает, например, яркий солнечный свет, проникающий в комнату через окно). При создании HDR-изображений делают несколько кадров одной и той же сцены, используя разную выдержку, после чего эти кадры объединяют, выбирая с каждого из них участки с наиболее удачной экспозицией.
Планируя проект я, кроме того, пообщался с представителем международной автомобильной компании, где потоковая передача видеоданных с 360-градусной камеры используется для контроля взаимодействия людей со встроенными в транспортное средство OLED-панелями. На картинке, которая получается при потоковой передаче видео, панели выходят слишком светлыми, а то, что на них выводится, оказывается невидимым.
Хотя будущее, конечно, за потоковой передачей видеоданных, и к этой теме я ещё вернусь, я решил, что те задачи, которые ставит перед нами 2021 год, нужно решать с привлечением фотографии и роботов.
Управление камерой
------------------
Для того чтобы упростить работу с камерой с робота, основанного на Raspberry Pi 4, я, на языке Dart, создал библиотеку и приложение, рассчитанное на работу в командной строке. Для написания библиотеки я выбрал именно Dart из-за того, что при таком подходе код библиотеки я мог бы многократно использовать во Flutter-приложениях, рассчитанных на Android и iOS. Dart-код компилируется в нативные бинарники, которые запускаются на Raspberry Pi без необходимости установки Dart SDK. Соответствующие инструменты командной строки, созданные для Raspberry Pi, можно использовать из bash-скриптов, что позволяет автоматизировать управление камерой.
Для того чтобы управлять камерой с Raspberry Pi, можно воспользоваться простым bash-скриптом. Ниже приведён пример такого скрипта, в котором выполняются следующие действия:
1. Настройка различных параметров камеры (отключение автоматического перевода камеры в режим сна или автоматического выключения камеры).
2. Деактивация встроенного таймера.
3. Вывод параметров камеры в консоль для их проверки.
4. Удаление из текущей директории, предназначенной для выгрузки изображений, всех старых изображений, снятых камерой Ricoh Theta, что приводит к тому, что в папке будут храниться только свежие изображения.
5. Запуск процесса съёмки 500 фотографий.
6. Передача изображений с камеры на Raspberry Pi с применением Wi-Fi-соединения.
7. Загрузка изображений на удалённый облачный сервер. Просмотр этих изображений организован с помощью веб-сервера Apache.
```
#!/usr/bin/bash
# отключение offDelay
./theta offDelay --off
# отключение sleepDelay
./theta sleepDelay --off
# выключение встроенного таймера
./theta exposureDelay --seconds=0
# уменьшение громкости звука срабатывания затвора
./theta shutterVolume --low
# подтверждение настроек
./theta getOptions
sleep 1s
# ЭТА КОМАНДА УДАЛИТ ВСЕ ИЗОБРАЖЕНИЯ, ХРАНЯЩИЕСЯ В ПАПКЕ СКРИПТА
rm R00*.JPG
echo start timelapse photography loop test
echo images will be viewable at http://45.xx.xx.xx/robot/
# Пример цикла, в котором делается 500 снимков, позволяющих
# наблюдать за развитием некоего процесса во времени.
# Для того чтобы снять другое количество фотографий, нужно изменить
# число, используемое ниже, например - так: {1..300}
for counter in {1..500}
do
./theta takeAndDownload
echo that was picture $counter
((counter++))
# если снимки нужно делать с интервалом в 30 секунд
# sleep 30s
echo 'waiting 10 seconds for the next shot'
sleep 10s
# если снимки нужно делать с интервалом в 5 минут
# sleep 5m
echo '*** Will Start Upload to Digital Ocean Hosting ***'
scp -r *.JPG craig@45.xx.xx.xx:/home/craig/robot/`date +"%Y%m%d%H%M"`.JPG
echo completed upload
echo deleting all RICOH THETA images from current directory
rm R001*.JPG
done
echo timelapse done
echo go to http://45.xx.xx.xx/robot/ to view images
```
Инструмент командной строки, используемый в этом bash-скрипте — это бесплатный опенсорсный проект. Я публикую подробности о нём [здесь](https://theta360developers.github.io/webapi/). Например, в [этом](https://theta360developers.github.io/webapi/tester/2021/02/27/raspberry-pi-robot.html) материале речь идёт о некоторых наблюдениях, сделанных в ходе использования описываемой в этой материале системы.
Проблемы проекта, выявленные в ходе «полевых» экспериментов
-----------------------------------------------------------
В этом разделе я хочу поделиться основными выводами, которые я сделал после того, как перенёс робота из офиса в «полевые» условия, оснастив автономной системой питания, и поэкспериментировал с ним.
*Офисные эксперименты*
### ▍Проблема электропитания автономного робота
Собственный источник питания робота слишком слаб для того чтобы эффективно обеспечивать энергией Raspberry Pi и всё сопутствующее оборудование. Подробности об энергопотреблении Raspberry Pi можно почитать в [этом](https://www.pidramble.com/wiki/benchmarks/power-consumption) материале.
Обычно я тестировал систему, подключив её к настенной электрической розетке. Перевод робота на автономное питание вызвал у меня, так сказать, «культурный шок». В результате я сделал вывод о том, что мне, когда робот питается от батарей, нужно внимательнее относиться к энергопотреблению дополнительного оборудования, вроде Wi-Fi-адаптера, подключённого к Raspberry Pi.
*В «полевых» условиях на первый план выходят вопросы автономного питания устройства*
### ▍Решение проблем мобильной связи
В офисе робот подключается к Wi-Fi-роутеру, а в «поле» — к мобильному хот-споту, выводящему устройство в интернет через LTE-сеть. Наладка работы системы в таких условиях вызвала неожиданные сложности. В качестве хот-спота я использовал не специализированное устройство, а телефон Pixel 2. Для того чтобы узнать IP-адрес Raspberry Pi, мне, на Pixel 2, пришлось воспользоваться Termux и командой `ip neigh`. Потом я воспользовался ноутбуком для того чтобы подключиться к Raspberry Pi по SSH и настроить скрипты, ответственные за управление камерой. Если интересно — [вот](https://dzone.com/articles/5-tips-for-effective-use-of-node-on-android-iot-de) моя статья о выполнении Linux-команд на Android-устройствах с использованием Termux.
### ▍Маршрутизация на Raspberry Pi
После загрузки Raspberry Pi с двумя Wi-Fi-интерфейсами автоматически были созданы два стандартных, конфликтующих друг с другом шлюза. Мне понадобилось вручную удалить стандартный маршрут к камере и перенаправить к камере трафик из подсети 192.168.1.0 Raspberry Pi.
*Настройка двойного Wi-Fi-подключения на роботе без пользовательского интерфейса*
Неожиданная польза, которую принёс этот проект моей компании
------------------------------------------------------------
Робот, о котором я рассказываю, это — экспериментальный проект, направленный на проверку различных идей. Я использую его в учебных целях. Отмечу, что не ожидал того, что работа над этим проектом хорошо отразится на оптимизации операций, которые в компании, где я работаю, выполняются вручную. Меня удивило то, что благодаря моему роботу ускорилась работа над проектами, которые даже с ним не связаны. Например, [инструмент](https://github.com/theta360developers/webapi) для тестирования API камеры, предназначенный для использования из командной строки на Raspberry Pi, стал широко применяться в компании для тестирования API камеры на Windows и Mac. Это стало возможным благодаря тому, что для разработки этого инструмента было решено использовать язык Dart (а так же — благодаря существованию команды [dart compile](https://dart.dev/tools/dart-compile)).
Ещё одной приятной неожиданностью стало то, что мы начали использовать при работе с этим инструментом [bash-скрипты](https://github.com/theta360developers/webapi/tree/master/script_examples), направленные на проведение автоматизированных тестов API камеры. Это благотворно сказалось на наших мобильных разработчиках. API камеры — это REST-подобное HTTP-API, в Dart-программах можно пользоваться JSON-данными. Это позволяет создавать тесты, которые подойдут тем разработчикам, которые пишут на Swift, Kotlin или Java. Я проверял робота, запуская тесты на Raspberry Pi. Однажды, отвечая на какой-то вопрос с форума, я просто показал свои результаты. В итоге оказалось, что то, что я сделал, заинтересовало разработчиков мобильного приложения. Теперь мы пользуемся WSL2 в Windows 10 для запуска bash-скриптов с соответствующих компьютеров.
Итоги
-----
Разработка собственного робота — это потрясающий способ превращения идей в нечто осязаемое. При этом исследование робота в разных условиях, например, в «поле», когда он питается от батарей и подключён к интернету через мобильный телефон, позволяет выявлять проблемы проекта, ранее незаметные, вроде слишком высокого энергопотребления и сложностей, связанных с дистанционной настройкой системы. Справляться с подобными проблемами очень интересно, а когда удаётся их решить, в награду нам достаётся не только работающее устройство, но и чувство глубокого удовлетворения.
Если вы решите сами сделать нечто подобное — примите во внимание то, что вам, помимо решения сетевых проблем и проблем электропитания робота-камеры, может понадобиться создать собственную библиотеку, учитывающую особенности датчиков, которые есть у робота. Возможно, вам понадобится построить серверную систему, поддерживающую работу проекта. Если вы, создавая своего робота, воспользуетесь универсальными технологиями, применимыми в компьютерных системах вашей организации, то подобный проект может оказать неожиданное положительное влияние на работу организации. И это — вдобавок ко всему тому интересному, что ждёт создателей роботов, погружённых в увлекательные эксперименты, позволяющие взглянуть на будущее робототехники.
Хотите создать собственную 360-градусную камеру, смонтированную на каком-нибудь роботе?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=sistema_udalyonnogo_monitoringa_rabochix_mest_na_baze_360_gradusnoj_kamery_i_raspberry_pi#order) | https://habr.com/ru/post/550192/ | null | ru | null |
# Умные выключатели на основе 8051 ядра, с управлением по Ethernet, Ч. 1
Доброго времени суток, уважаемые хабровчане!
Разрабатываемое устройство в чем-то повторяет [IRemo: Tap](http://habrahabr.ru/blogs/gadgets/118437/), а также некоторые другие аналоги, о которых писалось уже на хабрахабре. Мой же вариант будет более простым и дешевым. Для коммуникаций я выбрал обычную витую пару, а для управления у устройства будет своя вебстраничка.
В данной статье описан первый этап-создание «мозгов» для будущего проекта.
#### Итак этап номер ноль
Всегда проще разбивать разработку сложных вещей на простые «кирпичики». Это называется по научному принципом модульности. Так что для начала подумаем, и разобьем нашу идею на блоки. Глобально во всем приборе я выделил 3 основных модуля: блок управления, блок коммутации и блок питания.
Речь в данной статье пойдет о блоке управления, который и будет работать вебсервером, а также принимать и обрабатывать веб-формы с запросами. А теперь садимся и за чашечкой колы нарисуем блок-схему разрабатываемого модуля:
Расшифровка обозначений такая:
* БП Блок питания,
* БУ Блок управления,
* Кн н-й коммутационный узел(наше устройство реализует только выключение и включение света).
#### Первый кирпич.
##### Первый этап.
Разработку первого кирпичика начинаем с выбора элементной базы. После ознакомления с микросхемами доступными на территории Украины, мною был выбран мк C8051F340-GQR(64кб флеша, 4кб ОЗУ, 10-битный АЦП, кроссбар позволяющий конфигурировать UART, АЦП и SPI на любые порты процессора, USB, 48Мгц тактовой частоты от встроенного источника, датчик температуры) в качестве «мозгов» проекта и микросхема CP2200-GQR в качестве езернет контроллера, который обеспечит нас скоростью до 10 мбит\сек(чего нам с головой хватит). Обе микросхемы существуют в корпусах TQFP-48, предназначенных для поверхностного монтажа. Более подробные характеристики в даташитах [C8051F340](http://www.silabs.com/Support%20Documents/TechnicalDocs/C8051F340_short.pdf) и [CP2200](http://www.silabs.com/Support%20Documents/TechnicalDocs/CP2200.pdf).
Из остальных компонентов на первом этапе нам понадобиться Ethernet разъем с трансформатором 1:1, желательно интегрированным в сам разъем. Я выбрал HR911105A.
##### Второй этап.
Отлично микросхемы добыты(за езернет контроллером пришлось побегать, есть аналог CP2201 но он в корпусе QFN-28, а паять его немного трудновато). На данном этапе мы будем создавать принципиальную схему.
Вот что у меня получилось(изображение кликабельно):
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fi.piccy.info%2Fi5%2F07%2F06%2F1730607%2Fprinc.jpg%22)
Теперь некоторые пояснения:
1. Начнем с соеденения мк и CP2200. Ситуация очень упрощается из-за наличия на борту интерфейса EMIF(Интерфейс внешней памяти) у обоих микросхем, ведь по сути дела CP2200 и есть навороченная память. По байту Р3 передается адрес, по байту Р4-данные, также бита Р1.7\не WR при установки в 0 микросхема понимает что мы в нее пишем по заданному адресу, а при установки бита Р1.6\не RD соответственно происходит чтение. Подключение взято с даташита, также резисторы R1-8 низковатные имеют номинал 1 КОм, и подтягивают к пины к значению логической единицы. Наличие их не обязательно.
Остальные пины:
* Р0.2\INT-сигнал тактирования, после установки в 1 микросхема начнет обрабатывать наш запрос
* Р0.0\RES-сигнал сброса
* Р0.1\CS-выбор микросхем, как позже выяснилось тоже можно было не разводить.
2. Также обратите внимание на кварцевый резонатор Q2 он имеет номинал 20.000Мгц, его наличие обязательное(Q1 можно не устанавливать).
3. С подключение разъема ethernet тоже сложностей нету, все подключение взято тоже из даташита. R14,R14,C16,C17 фильтр НЧ(номиналы приведены внизу статьи).
4. Также я не забыл про юсб. Замыканием Х1.1 и Х1.2 Вы можете добиться питания от юсб, используя внутренний регулятор напряжения мк, но увы микросхему CP2200 Вы так не обеспечите питанием(ток на выходе мк до 100мА, требования CP2200 до 122мА при передачи).
5. К Х6 подключается светодиод, который просто светиться и сигнализирует о наличие питания, на Х8 выведен транзисторный ключ на основе транзистора BC847, управляющий пин Р2.7, Вы можете подключить сюда светодиод. Очень помогло при отладки прошивки.
6. На Х4 подается питание 3.3В. На Х2 можно также подать 5В для питания разных флешек и прочих юсб устройств в режиме когда мк ведущий. Х3 порты программатора С2. Остальные пины выведены на разъем Х5.
##### Третий этап.
Создана принципиальная схема разводим. Тут проблем быть не должно. Так как я печатал платы на заводе([ДНВП Електронмаш](http://www.elektronmash.kiev.ua/)), то я выбрал схему с 2х сторон(верхний правый угол оставался пустым, потому я насверлил там отверстий, получилась этакий кусок макетной платы).
[](http://habrastorage.org/storage1/80f3098f/afa6ada9/a7d591fb/2ecea5ed.jpg)
Ну, а дальше экспортируем все в формат Gerber(рисунок платы, каждая сторона в своем файле), отверстия сохраняем в формате NC drill.
~~Если у вас не лицензионный альтиум, не забываем удалить все ссылки на ПО из гербер файлов, иначе Вас разведут на штраф(прецеденты были).~~ По возможности пользуемся лицензионным ПО.
Получаем платы, собираем:
Верх:
[](http://habrastorage.org/storage1/898b9d54/9d3e3dc6/ef4065a3/8fd07109.jpg)
Низ:
[](http://habrastorage.org/storage1/251019b2/c3cb5514/8c8ebf38/4ae85265.jpg)
Обилие проводов связано с тем что я не знал какой будет использован программатор, предполагалось изначально подавать питание и данные с программатора, но увы я допустил пару ошибок при разводке программатора и он не заработал. Потому он был приведен к разъему используемого(заодно и макетная часть пригодилась).
##### Четвертый этап.
Без описания всех частей приводить пока код прошивки не буду, а прошьем туда стандартный пример от компании Silabs. Тут только одна проблема все примеры заточены под силабовский отладочный модуль, с приставкой CP2200DK. Отличия тут только в управляющих пинах, потому открываем файл main.c
Ищем функцию void PORT\_Init (void) меняем ее код на:
```
void PORT_Init (void)
{
IT01CF = 0x02; // Enable Interrupt 0 on P0.3
TCON &= ~0x01; // Make /INT0 level triggered
XBR1 = 0x40; // Enable crossbar and enable
// weak pull-ups
P0MDOUT |= 0x10 | 0x1F; // enable UTX as push-pull output
P1MDOUT |= 0xD8 | 0xFF; // /WR and /RD are push-pull
P2MDOUT |= 0xFF;
P3MDOUT |= 0xFF;
P4MDOUT |= 0xFF;
}
```
Находим функцию void ether\_reset\_low() меняем на:
```
void ether_reset_low()
{
P0 &= ~0x01; // Pull reset low
}
```
Проделіваем тоже с void ether\_reset\_high():
```
void ether_reset_high (void)
{
P0 |= 0x01; // Allow /RST to rise
while(!(P0 & 0x01)); // Wait for /RST to go high
}
```
Открываем mn\_userconst.h
устанавливаем айпи адресс:
```
#define IP_SRC_ADDR { 192, 168, 0, 6 }
```
в void main()
после port\_init();
добавить
```
P0 &= ~0x02;//Cs=0
```
Далее идем в VFILE\_DIR
правим index.html
Выполняем update.bat.
Таким образом из index.html сделается стандартный массив 16-ричных значений.
Компилим, собираем в hex файл, назначаем компу айпи-адрес в той же сети и прошиваем.
Пингуем:
Ну и заходим посмотреть на результат:
Если не пингуется-проверяем кабеля, код программы, а если совсем плохо-идем к знакомым, берем осцилограф и дебажим.
##### Ссылки:
1. Переделанный пример, а также чертежи платы формате альтиума(10й версии) и перечень элементов в формате пдф:
* [Материалы](http://depositfiles.com/files/b67s7tqng)
2. Даташиты(техническая документация):
* [C8051F34x полное описание](http://www.silabs.com/Support%20Documents/TechnicalDocs/C8051F34x.pdf)
* [CP2200](http://www.silabs.com/Support%20Documents/TechnicalDocs/CP2200.pdf)
* [Транзистор npn BC847](http://www.smd.ru/files/upload/1253/ru/bc846_bc847_bc848_4.pdf)
* [Описание библиотеки с закрытым исходным кодом реализующий TCP/IP стек от SiLabs](http://www.electrosnab.ru/silabs/pdf/RUS/An237rus.pdf)
Продолжение в следующих статьях.
Благодарю моих друзей за помощь в создании устройства и статьи. | https://habr.com/ru/post/124268/ | null | ru | null |
# Онлайн-трансляция ACM ICPC: Как это устроено
[](http://habrahabr.ru/company/spbifmo/blog/301098/)
#### Про чемпионат
Международная олимпиада ACM ICPC – крупнейшее мероприятие среди командных студенческих соревнований по программированию в мире. Проводится олимпиада с 70-х годов (тогда это было скорее соревнование между университетами США), с конца 90-х в ней активно участвуют и другие страны. Университет ИТМО в 2015 году стал шестикратным победителем ACM ICPC.
Естественно, интерес к олимпиаде проявляют не только сами вузы-участники, но и тысячи людей по всему миру. И для того, чтобы ACM ICPC было не «камерным» мероприятием для участников и их тренеров, существует онлайн-трансляция финала олимпиады, за которой можно наблюдать «в прямом эфире» и по окончании мероприятия (трансляцию финала 2015 года можно посмотреть [здесь](https://www.youtube.com/watch?v=xIvFJYo9928)). О том, как организована трансляция, какие интересные технические решения используются в процессе ее проведения, мы и расскажем сегодня «из первых уст» – от лица ее организаторов.
#### История трансляций ACM ICPC
В первый раз онлайн-трансляция финала чемпионата мира была представлена в 2009 году в Стокгольме. С 2009 по 2012 год трансляцией занималась команда Центра устойчивых коммуникаций Королевского технологического института (Швеция). Их специализацией был удаленный монтаж видео, однако съемка и передача велась традиционным видео способом: SDI-камеры и видеомонтаж.
*Так выглядела студия в 2011 году*
Однако, ACM ICPC – соревнование по программированию, и кроме стандартных камер на площадке, которые дают видео для трансляции, на каждом компьютере команды установлена вебкамера, которая стримит видео команды на протяжении всего соревнования. Кроме того, запущенный в фоне на компьютерах команд скрипт записывает и аналогично транслирует скринкаст каждой команды.
*Студия в 2012 году – работа все еще ведется традиционным способом*
Поэтому когда за онлайн-трансляцию чемпионата стала отвечать команда Университета ИТМО, было решено перейти от стандартных технологий видеопроизводства к более интересным решениям – стримингу трансляции на Youtube и twitch, использованию мощных компьютеров и VLC/ffmpeg для обработки и монтажа видео (в противовес ранее использовавшимся аппаратным решениям от Blackmagic).
Такое решение было принято в первую очередь из-за того, что финал ACM ICPC каждый год проводится в разных странах, поэтому перевозка купленного оборудования может стать существенной проблемой для организаторов. Кроме того, софт для трансляции может быть использован и на других соревнованиях.
#### Схема устройства трансляции: Этап получения контента
##### Tехнологии и аппаратное обеспечение
Система проведения соревнований предоставляет нам стримы вебкамер и экрана всех команд, которые участвуют в соревновании, фид посылок от участников (посылкой называется решение задачи, отправленное на проверку), в том числе вердикт жюри.
Для съемки общих видов зала используются две сетевые PTZ-камеры AXIS V5915. Такая камера позволяет снимать видео в разрешении 1080p и регулируется с помощью веб-интерфейса. Для того, чтобы запитать камеры, установленные в труднодоступных местах, мы используем PoE-инжекторы (это удобный способ подачи электропитания на сетевые устройства: к PoE-инжектору подключается штатный блок питания, сам инжектор подсоединяют к Ethernet-кабелю, после чего со второго переходника можно подключить камеру, при этом питание будет передаваться по Ethernet-кабелю).
Кроме перечисленного мы используем четыре портативные видеокамеры, сигнал с которых передается с помощью четырех [Teradek Clip](http://teradek.com/pages/clip), запитанных от аккумуляторов SWIT (на этих аккумуляторах они могут работать в течение всего контеста).
На базе одного из Clip’ов мы собрали мобильный комплекс. Он представляет собой рюкзак с аккумуляторами, на одной из лямок которого с помощью липучки прикреплен Clip и GoPro. Его мы планируем надеть на волонтера, который разносит шарики командам.
*Воздушные шарики командам разносят за правильно решенные задачи*
##### ICPC Analytics
Команда аналитиков постоянно развивает свое приложение Katalyzer, которое получает на вход не только лог посылок, но и регулярные бекапы с компьютеров участников. Их анализ позволяет понять, над какой задачей сейчас работает команда (например, если активно изменяется файл a.cpp – наверняка над задачей А). Кроме того, аналитики следят за экранами команд-лидеров, знают, кто в команде на каком языке программирования пишет, и регулярно дают оценку всего происходящего.
##### Команда
Видеогруппа, занятая во время онлайн-трансляции, состоит из десяти видеооператоров, которые посменно обеспечивают нам видео с площадки проведения чемпионата и флеш-зоны для интервью в прямом эфире, а также запись разборов заданий.
*Зал для проведения чемпионата*
Команда аналитиков обычно состоит из пятнадцати человек, которые (помимо подготовки и записи разборов) отсматривают интересные события от автоанализатора ([AutoAnalyst](https://github.com/icpc-live/autoanalyst) – приложение, разработанное специально для чемпионата ACM ICPC, отслеживающее список посылок, бэкапы компьютеров и экраны участников) и добавляют в лог событий интересные новости вручную. Кроме того, аналитики заранее готовят для каждой команды и для каждого участника профайл, который мы показываем при представлении команды.
*Команда Пекинского университета. Кадр с трансляции чемпионата*
Команда ICPCLive состоит из пятнадцати человек – директора, режиссера, дизайнера, программистов, видеоредакторов. Если все идет хорошо, во время соревнования остается только выбирать, экраны каких команд показывать в какой момент, добавлять в расписание новые видеоролики и вовремя подключать вид с наиболее интересной камеры.
##### Дополнительно: ролики медиаслужбы и видеоразборы
В онлайн-трансляции мы используем заранее записанные видео. Они включают в себя ролики медиаслужбы ICPCNews (эти видео далее [доступны](https://www.youtube.com/user/ICPCNews/videos) на их youtube-канале), интервью ключевых людей, фаворитов чемпионата и спонсоров. Большинство этих видео записывают заранее.
С видеоразборами задач дело обстоит иначе. Условия задач – объект повышенной секретности, поэтому запись видеоразборов начинается одновременно с началом соревнования, когда все команды уже надежно изолированы от окружающего мира на площадке. Аналитики готовят, записывают и вместе с ICPCNews монтируют разборы и передают их в эфир, режиссер принимает решение о том, когда поставить их в эфир.
#### Этап обработки контента
##### Tехнологии и аппаратное обеспечение
Наш видеопоток можно разбить на две совершенно разные части: картинку с камер и инфографику, которая накладывается сверху с помощью стандартного хромакея. Начнём с самого простого, а именно с камер. Для управления потоком информации с них самым простым и разумным решением для нас оказалось внешнее программное обеспечение [Wirecast](http://telestream.net/wirecast/).
Wirecast оказался на удивление удобен для загрузки предварительно записанных видео с помощью API, который мы задействовали и для составления расписания предстоящих видеороликов. При этом стоит Wirecast относительно недорого, особенно если сравнивать стоимость ПО с оплатой услуг подрядчиков во время трансляции.
Вся инфографика для проекта также создается in-house, силами команды. В качестве языка программирования был выбран Java. При этом самое простое решение в плане создания инфографики оказалось одновременно и самым элегантным – вся графика отрисовывается на canvas; виджеты перерисовываются каждые 1/25 секунды. Что касается небольших видеоблоков в углу экрана, то для их создания мы обошлись vlcj-библиотекой, которая является оболочкой на Java для нативного вызова функций vlc-плеера.
Основная сложность при работе с видеопотоком заключается не в создании той или иной его составляющей, а в управлении ими. В прошлом году управление велось через стандартные Java-формы, которые сообщали инфографике информацию по tcp. В этом же году мы пошли дальше и написали специальный http-сервер, который поддерживает изменения от нескольких пользователей одновременно и отдаёт всю информацию (что и как показывать) по tcp компьютеру, рисующему инфографику.
*Как это выглядит: видео плюс инфографика*
Изучив имеющиеся фреймворки для написания http-серверов на Java, мы выбрали [Vaadin](https://vaadin.com/home). Возможно, это решение не было оптимальным, так как в процессе работы с фреймворком периодически возникали проблемы с потоками и сетью. Однако в итоге нам удалось их решить и получить распределённую систему, которая позволяет кому угодно (при наличии логина и пароля) влиять на выходную картинку.
Для желающих получить аналогичный экзотический опыт в будущем имеет смысл осветить небольшие технические сложности, с которыми мы столкнулись:
* Потоковое видео по сети грузится не моментально, поэтому нам пришлось выставить от 3 до 10 секунд ожидания до показа зрителю.
* Инфографику в виде оверлея оказалось не так просто передать с достаточным числом кадров в секунду по причине нашего желания транслировать картинку в Full-HD. Поэтому для его передачи в Wirecast мы использовали не софтверное, а хардварное (при этом достаточно дорогостоящее) [решение](http://www.epiphan.com/products/dvi2usb-3-0/), которое просто забирает с монитора картинку по HDMI. Для домашних решений мы рекомендуем избавиться от анимаций появления оверлеев, генерировать их в меньшем разрешении и использовать для захвата видео vlc.
* Wirecast чрезвычайно требователен к ресурсам, а процесс кодирования видео для отправки на Wowza «ест» немало оперативки, поэтому его мы вынесли на еще один компьютер через аналогичный девайс.
##### Режим Split Screen
В прошлом году, так же как и в этом, у второго экрана есть два режима управления. Изначально в рамках прошлогоднего контеста мы запустили автоматический режим, работающий в соответствии со следующей логикой:
* Команда могла попасть на экран примерно на 10 секунд (это и есть та самая реакция после получения результата), если сдавала задачу.
* Когда отсутствовали посылки, на экране демонстрировались веб-камеры первых 12 команд по кругу, приблизительно по 20 секунд каждая. Эти 12 команд были отобраны в начале чемпионата как наиболее интересные.
В течение первого часа контеста стало ясно, что данный алгоритм совершенно не отвечает требованиям аудитории: большинство интересовалось не первыми 12 командами, при этом всем было намного интереснее смотреть на код, а не наблюдать за работой команд по веб-камере. Поэтому мы решили переключить Split Screen на ручной режим: мы сами отсматривали комментарии на youtube, twitch и twitter, и выбирали, какие же команды показывать.
Поэтому в нынешнем году именно это направление подверглось наибольшим изменениям. Во-первых, теперь зритель всегда видит два видеопотока – один с экрана и другой с веб-камеры; в большинстве случаев «большое» видео будет содержать код.
Во-вторых, в этом году мы тестируем автоматическую «голосовалку» за команды, которая будет работать по следующему алгоритму: она отслеживает в twitter сообщения с #ICPC2016, «выдёргивает» первый хештег, соответствующий команде на сайте [myicpc](http://myicpc.icpcnews.com/World-Finals-2016/teams) и увеличивает количество голосов за выбранную команду на единицу.
*Команда Университета ИТМО-2016: Адам Бардашевич, Антон Ковшаров, Андрей Станкевич (тренер) и Владимир Смыкалов*
Когда количество голосов у команды достигает 5, она добавляется в очередь на показ (команда никогда не добавляется в очередь дважды, и если команда в очереди, то количество голосов за неё не увеличивается). Чтобы снизить автоматическое набивание голосов, мы планируем учитывать только по одному твиту от пользователя в минуту. В-третьих, помимо пользовательской автоматики, мы всё равно планируем показывать в какие-то моменты первые 12 команд.
#### Этап вывода контента в сеть
Поскольку нам нужно было обеспечить трансляцию не только в интернет, но и во внутреннюю сеть на соревновании (из полутора тысяч участников олимпиады соревнуются только 384, остальные – тренеры, гости, организаторы – следят за соревнованием), мы решили использовать в качестве посредника сервер на Wowza, на который приходил видеопоток из Wirecast, передававшийся затем клиентам. Помимо прочего, это решило проблему с записью видео на диск и позволило без особых сложностей собрать комментаторскую студию.
Комментаторских студий в этом году планируется две: одна для англоязычных комментариев, другая для русскоязычных. При этом в рамках эксперимента мы решили собрать их с помощью разного оборудования: для «английской» студии мы закупили хорошие гарнитуры и аудиопульт, а «русскую» студию сделаем из самых дешевых подручных материалов. Главный смысл эксперимента в том, чтобы проверить, что действительно важно для обеспечения качественной трансляции, а что – нет. В дальнейшем мы планируем сделать больше локализованных комментаторских студий.
Для Wowza-сервера и двух основных стримов (главного стрима с Wirecast и второго со Split Screen) мы используем заряженные «под завязку» MSI GE 62 Apache pro. К каждому из них мы щедро добавили usb 3.0 и HDMI-сплиттеры.
С точки зрения софта, обе студии будут работать одинаково: на них будет запущен ffmpeg, который забирает видеопоток из Wowza, добавляет звук с микрофонов и передает полученный видеопоток с комментариями обратно в Wowza. Например, ниже приведена строка, которая добавляет к готовому стриму аудиокомментарии:
```
ffmpeg -re -i "rtmp://%ip%:1935/icpclive/main" -f dshow -i audio="Microphone" -filter_complex "[0:a][1:a]amerge,pan=stereo:c0
```
#### Что пришлось изменить
В 2015 году, когда наша команда разработки ICPCLive первый раз делала онлайн-трансляцию, работа с мобильными камерами и окончательный монтаж был реализован руками подрядчиков. Оказалось, что всего один дополнительный узел между режиссером и монтажом видео существенно ухудшает качество канала. Для управления звуком в 2015 использовалось приложение на iMac – как выяснилось, нажимать мышью для выбора канала звука оказалось неудобно и слишком медленно, поэтому в этом году мы используем аудиопульты.
Изначально в качестве HDMI2WiFi-трансмиттеров мы использовали не Teradek Clip, а их «аккумуляторных братьев» [Teradek Vidiu](http://teradek.com/pages/vidiu), но столкнулись с интересной особенностью. При стриминге видео в локальной сети можно использовать один из множества различных протоколов передачи данных. Компьютер, используя, например, команду ffmpeg может «поднять» на себе http-стрим, который будет доступен компьютерам локальной сети.
Однако достаточно сложно «запихнуть» в размер портативного передатчика возможности хостинга стрима, поэтому передатчики часто ограничиваются поддержкой протокола RTMP, который предназначен для передачи стрима на рестример.
В качестве рестримера отлично умеет выступать используемая нами Wowza, однако оказалось, что передача RTMP-потока через Wowza создает задержку в примерно десять секунд, на которую мы не готовы были пойти, а кроме того, два таких потока нагружают компьютер-монстр с Wowza-сервером до 70% CPU, что не оставляло такому варианту никаких шансов на выживание.
#### ICPCLive и новый формат трансляций
Обычно прямой эфир мероприятий состоит из километров SDI-проводов и готовых аппаратных решений, позволяющих коммутировать сигнал, делать встраивание картинки в картинку и правильным образом микшировать звук. Это делает услуги по онлайн-трансляции очень дорогими, доступными фактически только единицам компаний в каждой стране, у которых есть соответствующее оборудование.
Использование Wi-Fi и компьютеров для всей цепочки трансляции делает ее ультрапортативной – мы можем заглянуть с камерой туда, куда не дотягивались провода, автоматически показывать самое интересное по ходу соревнования, по хештегам в твиттере демонстрировать экраны и вебкамеры интересных зрителям команд и делать специальные трансляции для разных языков.
Код нашего замечательного проекта лежит [здесь](https://github.com/Aksenov239/icpc-live-v2).
Есть вопросы? Хотите помочь? Пишите нам на icpc-live-team@googlegroups.com!
Утром 19 мая подключайтесь к прямой трансляции финала студенческого командного чемпионата по программированию ACM ICPC 2016 на сайте [ICPCLive](http://icpclive.com), подписывайтесь на каналы на [youtube](https://www.youtube.com/icpclive) и twitch (английская трансляция [здесь](https://www.twitch.tv/icpclive1), русская – [здесь](https://www.twitch.tv/icpclive_ru), второй экран – [здесь](https://www.twitch.tv/icpclive2)) – обещаем спонтанные включения и самые интересные подробности.
И, разумеется, болеем за Университет ИТМО! | https://habr.com/ru/post/301098/ | null | ru | null |
# Нескучный Powershell
По работе мне периодически приходится править и дописывать скрипты для авто-тестов. И так исторически сложилось, что написаны они на Powershell. Но статья будет не об этом.
Обычно Powershell описывается как средство автоматизации для системных администраторов. И естественно, что к нему проявляют мало интереса. Поэтому я хочу рассказать, что его можно использовать не только для скучных рабочих задач.
Ради эксперимента и в качестве разнообразия у меня возникла идея написать небольшую игру с механикой скролшутера. Сначала захотелось ограничиться одной консолью, но потом разум возобладал. Так что для графического движка было решено использовать элементы Windows.Forms:
```
Add-Type -Assemblyname System.Windows.Forms
function Create-Form ([string]$name, $x, $y, $w, $h){
$win = New-Object System.Windows.Forms.Form
$win.StartPosition = "Manual"
$win.Location = New-Object System.Drawing.Size($x, $y)
$win.Width = $w
$win.Height = $h
$win.Text = $name
$win.Topmost = $True
$win
}
function Create-Label ([string]$name, $x, $y){
$label = New-Object System.Windows.Forms.Label
$label.Location = New-Object System.Drawing.Point($x, $y)
$label.Text = $name
$label.AutoSize = $true
$label
}
function Create-Button ([string]$name, $x, $y, $w, $h){
$button = New-Object System.Windows.Forms.Button
$button.Location = New-Object System.Drawing.Point($x, $y)
$button.Size = New-Object System.Drawing.Size($w, $h)
$button.Text = $name
$button.Enabled = $false
$button
}
function Start-Scroll (){
$form = Create-Form "Let's GO!" 200 150 300 400
$start = Create-Label "Press SPACE to run" 90 200
$info = Create-Label "<-- A D --> 'Esc' for exit" 80 340
$ship = Create-Label "/|\" 135 400
$form.Controls.Add($start)
$form.Controls.Add($info)
$form.Controls.Add($ship)
$form.ShowDialog()
}
```
В результате появился “стартовый экран”. Но при этом выполнение скрипта по сути заблокировалось, т.к. после запуска диалогового окна — он ожидает от этого окна ответа и дальше не выполняется. Конечно, можно было бы сделать многопоточный скрипт, но было найдено более простое решение проблемы: добавление таймера.
```
$timer = New-Object system.windows.forms.timer
$timer.Interval = 100
$timer.add_tick({Check})
$timer.start()
```
Каждые 100 миллисекунд таймер вызывает функцию Check независимо от того, что выполняется в самом скрипте. Временной интервал выбран на глаз. По моим ощущениям обновление игры происходит достаточно плавно, но при желании можно сделать обновление и чаще.
Как выяснилось в последствии, все переменные, указанные в «тике» таймера, сохраняют значение на момент активации таймера и Check каждый раз вызывается с одним и тем же набором данных. Поэтому чтобы функция имела доступ к актуальным данным, вся нужная информация была упакована в объект:
```
$Data = @{run = $false; hide = $false; pos = 135; shot = 0; spawn = 0; usb = 0; score = 0; fires = @(); enemies = @()}
```
Чтобы придать функции Start-Scroll законченный вид, осталось добавить хоткеи управления и контроллер звука:
```
$form.KeyPreview = $True
$form.Add_KeyDown({
if ($_.KeyCode -eq "A") {if ($Data.run -and -not $Data.hide -and $Data.pos -gt 0) {$Data.pos -= 5}}
})
$form.Add_KeyDown({
if ($_.KeyCode -eq "D") {if ($Data.run -and -not $Data.hide -and $Data.pos -lt 265) {$Data.pos += 5}}
})
$form.Add_KeyDown({
if ($_.KeyCode -eq "Escape") {$timer.stop(); $form.Close()}
})
$form.Add_KeyDown({
if ($_.KeyCode -eq "Space") {
if ($Data.run) { Set-Hide }
else { $start.Text = ""; $Data.run = $true }
}
})
$sound = new-Object System.Media.SoundPlayer;
$sound.SoundLocation = "$env:WINDIR\Media\Windows Information Bar.wav"
```
Итого в игре есть флажок $Data.run, который обозначает — запущена ли игра, есть флажок $Data.hide, который выполняет роль паузы, есть набор переменных, где хранятся координаты игрока (pos), количество очков (score), таймер до выстрела (shot) и таймер до добавления противника (spawn), а также два массива fires и enemies, в которых хранятся соответственно данные по снарядам и противникам.
Управление получилось достаточно простое: A и D для перемещения своего персонажа, Esc — для выхода, а пробел заменяет кнопку “Старт” запуская игру или ставя её на паузу. Чтобы на время паузы все игровые элементы скрывались, используется функция Set-Hide:
```
function Set-Hide (){
if ($Data.hide) {
$start.Text = ""
$start.Location=New-Object System.Drawing.Point(90, 200)
$Data.enemies | foreach {$_.obj.Visible = $true}
$Data.fires | foreach {$_.obj.Visible = $true}
$info.Visible = $true
$ship.Visible = $true
} else {
$start.Location=New-Object System.Drawing.Point(10, 10)
$Data.enemies | foreach {$_.obj.Visible = $false}
$Data.fires | foreach {$_.obj.Visible = $false}
$info.Visible = $false
$ship.Visible = $false
}
$Data.hide = -not $Data.hide
}
```
Основная логика игры описана в функции Check:
**function Check ()**
```
function Check () {
# Если игра не запущена - ничего не делаем
if (!$Data.run) {return}
# Если пауза - выводим сторонний текст
if ($Data.hide) {
if ($Data.usb -eq 0){
$start.Text = ""
gwmi Win32_USBControllerDevice | %{[wmi]($_.Dependent)} | where {$_.DeviceID -notlike '*ROOT_HUB*'} | Sort Description | foreach { $start.Text += $_.Description +"`n" }
$Data.usb = 500
} else { $Data.usb -= 1 }
return
}
# Обновляем положение игрока
$ship.Location=New-Object System.Drawing.Point($Data.pos, 300)
# Создаем снаряд, если пришло время
if ($Data.shot -eq 0) {
$Data.fires += @{ obj = Create-Label "*" ($Data.pos + 5) 290; x = $Data.pos + 5; y = 290 }
$form.Controls.Add($Data.fires[$Data.fires.Length - 1].obj)
$Data.shot = 4
} else { $Data.shot -= 1 }
# Создаем противника, если пришло время
if ($Data.spawn -eq 0) {
$hp = Get-Random -minimum 4 -maximum 6
$pos = Get-Random -minimum 0 -maximum 200
$Data.enemies += @{ obj = Create-Button "$hp" $pos -22 30 20; x = $pos; y = -22; health = $hp }
$form.Controls.Add($Data.enemies[$Data.enemies.Length - 1].obj)
$Data.spawn = 150 * $Data.enemies.Length
} else { $Data.spawn -= 1 }
# Проверяем снаряды
foreach ($fire in $Data.fires){
# Обновляем положение
$fire.obj.Location = New-Object System.Drawing.Point($fire.x, $fire.y)
$fire.y -= 5
# Проверяем для каждого снаряда/противника - нет ли столкновения
foreach ($enemy in $Data.enemies){
if ($fire.x + 5 -gt $enemy.x -and $fire.x -lt $enemy.x + 25 -and $fire.y -gt $enemy.y -and $fire.y -lt $enemy.y + 20){
$enemy.health -= 1
$enemy.obj.Text = $enemy.health
$fire.y = -20
$sound.Play()
}
}
}
# Если первый в списке снаряд вышел за экран - убираем его
if ($Data.fires[0].y -lt -10) {
$form.Controls.Remove($Data.fires[0].obj)
$Data.fires = $Data.fires[1..($Data.fires.Length - 1)]
}
# Проверяем противников
foreach ($enemy in $Data.enemies){
# Если убит - перезапускаем
if ($enemy.health -gt 0){ $enemy.y += 1 } else {
$Data.score += 1
$enemy.health = Get-Random -minimum 4 -maximum 6
$enemy.x = Get-Random -minimum 1 -maximum 200
$enemy.y = -22
$enemy.obj.Text = $enemy.health
}
# Обновляем положение
$enemy.obj.Location = New-Object System.Drawing.Point($enemy.x, $enemy.y)
# Если приземлился - останавливаем игру
if ($enemy.y -gt 300) {
$Data.run = $false
$start.Text = "Total score: " + $Data.score
}
}
}
```
Конечно, такая игра не претендует на “Лучшую игру года”. Но она может показать, что Powershell можно использовать не только, чтобы настраивать права доступа и контролировать работу локальной сети.
А ещё, в качестве бонуса, в режиме паузы отображается список подключенных USB-девайсов )
**P.S.** А те, кому лень собирать код по статье, могут [скачать](https://dl.dropboxusercontent.com/u/76010685/scroll.zip) архив со скриптом и bat-ником для запуска. | https://habr.com/ru/post/319872/ | null | ru | null |
# Парсим NFT транзакции на OpenSea
Примерно раз в год у меня появляется неутолимая жажда накопать много данных и что-то с ними сделать. В этот раз мой выбор пал на маркетплейс NFT OpenSea. Меня осенило что блокчейн - это про открытые данные, а учитывая 1.2 миллиона транзакций в сети ETH каждый день - то это ещё и много данных, так что точно должно быть интересно.
В этом туториале я расскажу откуда можно достать данные о транзакциях блокчейна ETH, и как эти данные анализировать, в частности, как находить самые дорогие транзакции. И самое главное - бонус, небольшая игра в сыщиков в конце статьи.
---
### Где достать данные?
Вопросов с тем, откуда доставать данные у меня практически не было. Наверняка, большинство из тех кто имел дело с ETH знает что такое [Etherscan](https://etherscan.io/). Если кратко, то это платформа, на которой можно посмотреть детальную информацию по каждой транзакции и в целом краткую статистику про Etherium. Оставалось надеяться на то, что у них есть [API](https://docs.etherscan.io/).
Регистрируемся и забираем 100 тысяч бесплатных обращений в день, достаточно щедро, вряд ли нам понадобится больше.
Тарифы использования API EtherscanДавайте разберёмся с тем, какие эндпоинты API нам понадобятся. Находим достаточно [удобный](https://docs.etherscan.io/api-endpoints/logs), возвращающий логи исполнения смарт контрактов. Находим адрес смарт контракта OpenSea и пишем достаточно простой запрос.
```
OPENSEA_CONTRACT = '0x7Be8076f4EA4A4AD08075C2508e481d6C946D12b'
url = ''
params = {
'module': 'logs',
'action': 'getLogs',
'fromBlock' : BLOCK\_START,
'toBlock': 'latest',
'address': OPENSEA\_CONTRACT,
'apikey': API\_KEY
}
r = requests.get(url, params=params)
json\_data = json.loads(r.text)["result"]
```
Данный эндпоинт в качестве входных данных также принимает номер блока, начиная с которого он собирает логи смарт контракта. Узнать номер текущего последнего сгенерированного блока можно либо на сайте Etherscan, либо можно обратиться к [ещё одному эндпоинту](https://docs.etherscan.io/api-endpoints/blocks#get-block-number-by-timestamp), который в качестве параметра принимает время, timestamp и возвращает номер блока ближайшего к этому времени. Передав текущее время получаем номер последнего сгенерированного блока.
```
url = ''
params = {
'module': 'block',
'action': 'getblocknobytime',
'timestamp' : int(time.time() // 1),
'closest': 'before',
'apikey': API\_KEY
}
r = requests.get(url, params=params)
json\_data = json.loads(r.text)["result"]
LATEST\_BLOCK = int(json\_data)
```
В силу того, что первый эндпоинт возвращает максимум 1000 транзакций получить сразу все транзакции с OpenSea за один запрос у нас не получится. Путём экспериментов я установил, что примерно в 40 блоках набирается 600-900 транзакций с OpenSea. Таким образом:
```
BLOCK_START = LATEST_BLOCK - 40
```
Давайте разберёмся с тем, какие данные отдаёт нам наш эндпоинт. А отдаёт он нам массив примерно таких вот структур.
```
{ 'address': '0x7be8076f4ea4a4ad08075c2508e481d6c946d12b',
'topics':
['0xc4109843e0b7d514e4c093114b863f8e7d8d9a458c372cd51bfe526b588006c9',
'0x000000000000000000000000c6ac8a42344b750b9de0e71289292b620c328131',
'0x0000000000000000000000007f61d795439562fa791c3d468e8738125f0a9866',
'0x0000000000000000000000000000000000000000000000000000000000000000'],
'data': '0x00000000000000000000000000000000000000000000000000000000000000007656e0665c6bdc38947d580d2e8c4c19ba8fa4019abb8fef31cfaa1b7645f00d000000000000000000000000000000000000000000000000027f7d0bdb920000',
'blockNumber': '0xd82788',
'timeStamp': '0x62027a71',
'gasPrice': '0xdb7c42e2a',
'gasUsed': '0x2f283',
'logIndex': '0x182',
'transactionHash': '0xcfff81e158623e66ab53be47f342e1cb170f05a1461c56b8c0523f96ea042409',
'transactionIndex': '0x116'}
```
Выглядит устрашающе, но давайте разбираться. Для начала отмечу, что все данные тут в hex формате, то есть в системе счисления с основанием 16. Самая вкуснятинка и нужные нам данные кроются в `topics` и `data`, но что это такое и как это понимать?
### Как устроены Логи транзакций
Во время своей работы смарт контракты создают события, таким образом они уведомляют о том что была вызвана какия-либо функция или метод. Лог транзакции состоит из событий, сгенерированных смарт контрактами, с которых было взаимодействие в рамках транзакции. В [случае смарт контракта OpenSea](https://etherscan.io/address/0x7be8076f4ea4a4ad08075c2508e481d6c946d12b#code) при продаже NFT от одного пользователя другому создаётся событие с названием `OrdersMatched`.
Элемент кода смарт контракта OpenSeaВот так вот выглядит это событие, при [просмотре](https://etherscan.io/tx/0xc4799a1224ded0716b62e6d4bed621c15d14966219c45a8bec20c60a74e94298#eventlog) деталей транзакции через Etherscan.
Событие OrdersMatchedДанные, передаваемые событием хранятся в объекте `topics` и `data`.
`topics` - это массив, который содержит в себе данные о событии и его параметрах. Максимальный размер массива `topics` - 4 элемента. `topics[0]`, нулевой элемент массива - это “подписанное” название метода. Остальные элементы массива `topics` и “кусок даных” `data` содержат в себе более детальные данные о транзакции - продавца, покупателя и цену сделки.
Более детально рассмотрим эти данные, на базе нашего метода и примера ответа API:
Событие OrdersMatched вместе со всеми своими параметрами.
```
OrdersMatched (bytes32 buyHash, bytes32 sellHash,
index_topic_1 address maker, index_topic_2 address taker,
uint256 price, index_topic_3 bytes32 metadata)
```
```
{'topics':
['0xc4109843e0b7d514e4c093114b863f8e7d8d9a458c372cd51bfe526b588006c9',
'0x000000000000000000000000c6ac8a42344b750b9de0e71289292b620c328131',
'0x0000000000000000000000007f61d795439562fa791c3d468e8738125f0a9866',
'0x0000000000000000000000000000000000000000000000000000000000000000'],
'data': '0x00000000000000000000000000000000000000000000000000000000000000007656e0665c6bdc38947d580d2e8c4c19ba8fa4019abb8fef31cfaa1b7645f00d000000000000000000000000000000000000000000000000027f7d0bdb920000'
}
```
* `topics[0]` - подписанное название метода и типов данных его параметров.
Таким образом подписывается название метода `OrdersMatched`, совместно с типами параметров метода:
```
from Crypto.Hash import keccak
method = b'OrdersMatched(bytes32,bytes32,address,address,uint256,bytes32)'
k = keccak.new(digest_bits=256)
k.update(method)
print('0x'+k.hexdigest())
```
```
Out[]: 0xc4109843e0b7d514e4c093114b863f8e7d8d9a458c372cd51bfe526b588006c9
```
* `topics[1]` - `index_topic_1 address maker` адрес продавца, 20 байтов, который дополнен нулями до 32.
```
topics[1] = '0x000000000000000000000000c6ac8a42344b750b9de0e71289292b620c328131'
address_maker = '0xc6ac8a42344b750b9de0e71289292b620c328131'
```
* `topics[2]` - `index_topic_2 address taker` адрес покупателя, также 20 байт, дополненные нулями до 32.
```
topics[2] = '0x0000000000000000000000007f61d795439562fa791c3d468e8738125f0a9866'
address_taker = '0x7f61d795439562fa791c3d468e8738125f0a9866'
```
* `topics[3]` - `index_topic_3 bytes32 metadata` метаданные, по опыту скарпинга транзакций в большей части случаев - нулевые данные.
Все те параметры функции, которые “не влезли” в `topics` передаются в `data`. В случае рассматриваемой функции это будут `bytes32 buyHash`, `bytes32 sellHash` и `uint256 price`. Все три этих параметра просто напросто конкатенированы в один кусок данных в порядке их указания в параметрах функции.
Наиболее интересный нам параметр, цена сделки, хранится в последних 256 битах куска данных (то есть 32 байта и 64 символа hex представления). Аккуратно взяв кусочек строки и конвертировав его в число мы сможем узнать цену:
```
data = "0x00000000000000000000000000000000000000000000000000000000000000007656e0665c6bdc38947d580d2e8c4c19ba8fa4019abb8fef31cfaa1b7645f00d000000000000000000000000000000000000000000000000027f7d0bdb920000"
price_wei = int("0x" + data[-64:], 16)
price_eth = price_wei / 10**18
```
Помним о том, что смарт контракты оперируют с wei - наименьшей делимой частью ETH.
Собирая всё вместе, получаем приблизительно такой код:
```
# Получаем последние транзакции как в прошлом разделе
transactions = get_latest_transactions()
# Подпись нужного нам метода
OrdersMatchedSig = "0xc4109843e0b7d514e4c093114b863f8e7d8d9a458c372cd51bfe526b588006c9"
# Для конвертации wei в ETH
DIVIDER = 10**18
# тут будут уже обработанные транзакции
transactions_refactored = []
for tr in transactions:
result = {}
if tr['topics'][0] == OrdersMatchedSig:
result['maker'] = '0x' + (sample['topics'][1])[26:]
result['taker'] = '0x' + (sample['topics'][2])[26:]
result['price'] = int('0x' + sample['data'][-32:], 16) / DIVIDER
# .... Также можно добавить в result любые нужные данные из tr
# .... По типу timeStamp, blockNumber, итд.
transactions_refactored.append(result)
```
### Более детально про транзакции - Определение валюты
У описанного выше метода есть один небольшой недостаток, с которым я столкнулся, проанализировав несколько тысяч транзакций. Недостаток этот заключается в том, что в параметрах события метода `OrdersMatched` не передаётся валюта, в которой была совершена покупка NFT. В большинстве случаев эта валюта, разумеется, ETH, однако иногда проскакивают и другие токены.
Давайте разберёмся с тем, как же определять валюту транзакции. Возьмём для примера две транзакции, одна была проведена в эфирах, другая в ASH. Транзакция [раз](https://etherscan.io/tx/0xc4799a1224ded0716b62e6d4bed621c15d14966219c45a8bec20c60a74e94298), транзакция [два](https://etherscan.io/tx/0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228).
150 ASH
Событие OrdersMatched для транзакции в 150 ASH115 ETH
Событие OrdersMatched для транзакции в 115 ETHВ рамках того эндпоинта, который возвращает нам логи событий транзакций, эти две выглядят практически одинаково, не считая цены. Однако 115 ETH это куда больше чем 150 ASH. Нам нужен метод, который позволит надёжно определять валюту транзакций.
Более детально покопавшись в API Etherscan можно найти метод `eth_getTransactionReceipt`, [который](https://docs.etherscan.io/api-endpoints/geth-parity-proxy#eth_gettransactionreceipt) по хэшу транзакции возвращает более детальную сводку событий смарт контрактов, связанную с этой транзакцией.
В контексте Python обратиться к этому эндпоинту можно вот так:
```
def get_transaction_receipt(txn):
url = ''
params = {
'module': 'proxy',
'action': 'eth\_getTransactionReceipt',
'apikey': API\_KEY,
'txhash' : txn
}
r = requests.get(url, params=params)
json\_data = json.loads(r.text)["result"]
return json\_data
```
Для транзакции в 150 ASH ответ будет выглядеть вот так:
json\_data
```
{'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'blockNumber': '0xd831b2',
'contractAddress': None,
'cumulativeGasUsed': '0x1321b40',
'effectiveGasPrice': '0x1343f99739',
'from': '0xd4fc759d1dd10936438a5d4c5dc711a85f086c8c',
'gasUsed': '0x31a43',
'logs': [{'address': '0x64d91f12ece7362f91a6f8e7940cd55f05060b92',
'topics': ['0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
'0x000000000000000000000000d4fc759d1dd10936438a5d4c5dc711a85f086c8c',
'0x00000000000000000000000041f33855fe7bff95a6d8204cf93e8905cefa0485'],
'data': '0x00000000000000000000000000000000000000000000000821ab0d4414980000',
'blockNumber': '0xd831b2',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'logIndex': '0x192',
'removed': False},
{'address': '0x64d91f12ece7362f91a6f8e7940cd55f05060b92',
'topics': ['0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
'0x000000000000000000000000d4fc759d1dd10936438a5d4c5dc711a85f086c8c',
'0x000000000000000000000000e5c783ee536cf5e63e792988335c4255169be4e1'],
'data': '0xfffffffffffffffffffffffffffffffffffffffffffffff3a3dd47feeaefffff',
'blockNumber': '0xd831b2',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'logIndex': '0x193',
'removed': False},
{'address': '0x64d91f12ece7362f91a6f8e7940cd55f05060b92',
'topics': ['0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
'0x00000000000000000000000041f33855fe7bff95a6d8204cf93e8905cefa0485',
'0x0000000000000000000000005b3256965e7c3cf26e11fcaf296dfc8807c01073'],
'data': '0x000000000000000000000000000000000000000000000001043561a882930000',
'blockNumber': '0xd831b2',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'logIndex': '0x194',
'removed': False},
{'address': '0x64d91f12ece7362f91a6f8e7940cd55f05060b92',
'topics': ['0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
'0x00000000000000000000000041f33855fe7bff95a6d8204cf93e8905cefa0485',
'0x000000000000000000000000e5c783ee536cf5e63e792988335c4255169be4e1'],
'data': '0xfffffffffffffffffffffffffffffffffffffffffffffffaa59186332e2cffff',
'blockNumber': '0xd831b2',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'logIndex': '0x195',
'removed': False},
{'address': '0x495f947276749ce646f68ac8c248420045cb7b5e',
'topics': ['0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62',
'0x0000000000000000000000000474e1cff596114577cf641d3bf41617c48c2042',
'0x00000000000000000000000041f33855fe7bff95a6d8204cf93e8905cefa0485',
'0x000000000000000000000000d4fc759d1dd10936438a5d4c5dc711a85f086c8c'],
'data': '0xbc307bdf50fe05db053c7217e904f9c77e9d51250000000000000b000000022b0000000000000000000000000000000000000000000000000000000000000001',
'blockNumber': '0xd831b2',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'logIndex': '0x196',
'removed': False},
{'address': '0x7be8076f4ea4a4ad08075c2508e481d6c946d12b',
'topics': ['0xc4109843e0b7d514e4c093114b863f8e7d8d9a458c372cd51bfe526b588006c9',
'0x00000000000000000000000041f33855fe7bff95a6d8204cf93e8905cefa0485',
'0x000000000000000000000000d4fc759d1dd10936438a5d4c5dc711a85f086c8c',
'0x0000000000000000000000000000000000000000000000000000000000000000'],
'data': '0x0000000000000000000000000000000000000000000000000000000000000000bcf6a0125547a86ac1fa18dc1e9e3fa2b3826bd95aacf93545d4b79dc5009e6b00000000000000000000000000000000000000000000000821ab0d4414980000',
'blockNumber': '0xd831b2',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'blockHash': '0x43cca3bae64e6d5dfaf9e682948349dfb66a1390c6f0d056007b30443912bbc9',
'logIndex': '0x197',
'removed': False}],
'logsBloom': '0x0000000000000000000000000000000100000000000000000000000400000000000000000000002000006080000000000200800000000000000000000020201000000000000001000000000800880000000000000000000000000000000000000000000002000000000000000000080000000000000000000000003000000010100000000000000000100000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000180000000000000240000000200000000000001000000000040a000000000000020020000010000000000000000400000000000000000000200000000000080000000000',
'status': '0x1',
'to': '0x7be8076f4ea4a4ad08075c2508e481d6c946d12b',
'transactionHash': '0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228',
'transactionIndex': '0xee',
'type': '0x2'}
```
Более читаемый вид[Ссылка на такой формат](https://etherscan.io/tx-decoder?tx=0xae0d18bec807c1968b501002502bd4a4494480de90b4caa027a84865713b8228)
Все события транзакции в 150 ASHСамая приятная часть ответа данного эндпоинта заключается в том, что в нём содержатся все события, сгенерированные смарт контрактами, с которыми было взаимодействие в рамках данной транзакции.
Это значит, что в случае покупки NFT за ERC-20 токен, в транзакции отобразится взаимодействие со смарт контрактом данного ERC-20 токена.
В контексте упомянутой выше транзакции на 150 ASH это будут методы `Approval` и `Transfer` [смарт контракта ASH](https://etherscan.io/address/0x64d91f12ece7362f91a6f8e7940cd55f05060b92#code).
 События транзакции в 150 ASHМожно заметить, что в методе Transfer в качестве одного из параметров присутствует цена транзакции в `150 * 10**18`. Этого инсайта нам хватит для того, чтобы написать парсер, который будет также понимать валюту транзакции.
Функция определения валюты транзакции, реализованная на Python
```
WETH_CONTRACT = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
OPENSEA_CONTRACT = '0x7be8076f4ea4a4ad08075c2508e481d6c946d12b'
TRANSFER_METHOD = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
# txn - хэш транзакции
def determine_currency(txn):
# описанная ранее функция
transaction_receipt = get_transaction_receipt(txn)
currency = 'ETH'
# Лог события OrdersMatched будет последним с списке событий
price_hex = transaction_receipt['logs'][-1]['data'][-64:]
for s in transaction_receipt['logs']:
if s['topics'][0] == TRANSFER_METHOD:
# Проверяем, есть ли цена сделки в логе события
if price_hex in s['data']:
# Дополнительная проверка на Wrapped ETH
if s['address'] == WETH_CONTRACT:
currency = 'WETH'
else:
currency = 'NONETH-' +s['address']
return currency
```
Логика работы этой функции заключается в том, что мы смотрим на все события смарт контрактов, связанные с нашей транзакцией. Если в данных одного из событий метода `Transfer` фигурирует цена сделки, то это будет обращение к смарт контракту ERC-20 токена. На базе адреса смарт контракта этого токена мы сможем установить, что это за валюта.
### Более детально про транзакции - смарт контракты коллекции
Смотреть на то, как кто-то продаёт кому-то токены ERC-721 - это конечно же интересно. Но куда более интересно ещё и знать что это за токены: как называется их коллекции и каков порядковый номер токена.
Упомянутый в первом разделе статьи эндпоинт также не возвращает данные касательно токена ERC-721, фигурирующего в транзакции. Однако эндпоинт `eth_getTransactionReceipt` возвращает все связанные с транзакцией события смарт контрактов, а значит там должны быть и детали касательно токенов ERC-721.
Действительно, при более детальном рассмотрении событий смарт контрактов можно понять что именно купили в транзакции. На примере [транзакции](https://etherscan.io/tx/0xc4799a1224ded0716b62e6d4bed621c15d14966219c45a8bec20c60a74e94298) в ETH можно заметить что помимо события OrdersMatched есть ещё два других события - `Approval` и `Transfer`. Так как в данной транзакции не было обращения к смарт контрактам ERC-20 токенов, можно предположить, что это события смарт контракта ERC-721 токена.
События транзакции покупки BoredApeYacthClub#8481[Более детально](https://etherscan.io/address/0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d) рассмотрев адрес смарт контракта можно понять, что это адрес коллекции BoredApeYachtClub (BAYC). А в методе `Transfer` фигурирует номер токена коллекции, который был переведён.
Таким образом, с помощью эндпоинта `eth_getTransactionReceipt` можно также получить более детальную информацию о токене NFT, который был куплен.
Оборачивая написанный текст в код, получим:
```
TRANSFER_METHOD = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
# txn - хэш транзакции
def determine_collection_contract(txn):
# описанная ранее функция
transaction_receipt = get_transaction_receipt(txn)
# Лог события OrdersMatched будет последним с списке событий
price_hex = transaction_receipt['logs'][-1]['data'][-64:]
collection_contract = ''
token_number = -1
for s in transaction_receipt['logs']:
if (s['topics'][0] == TRANSFER_METHOD):
# Исключаем ERC-20 контракты
if price_hex not in s['data']:
collection_contract = s['address']
token_number = int(s['topics'][3], 16)
return collection_contract, token_number
```
Логика работа функции похожая на логику функцию из предыдущего раздела, только в данном примере мы берём данные из метода `Transfer`, не связанного с ERC-20 смарт контрактами (где не фигурирует цена сделки).
Да, я знаю что тут есть редкий баг* В рамках данной функции может случиться такое, что номер токена коллекции совпадёт с ценой (это крайне маловероятно, но всё же). Данной проблемы можно избежать дополнительно проверяя параметры события `Approval`.
Так выглядит событие `Approval` для ERC-721 токена
Approval event для ERC-721 токена А вот так для ERC-20
Approval event для ERC-20 токенаС помощью такой дополнительной проверки можно исключить упомянутый выше баг.
Для того чтобы на базе адреса контракта коллекции можно было получить название мне пришлось воспользоваться [API BlockScout](https://blockscout.com/xdai/mainnet/). В целом API хорошее и удобное, даже есть GraphQL интерфейс, однако каким-то невероятным образом в базе данных этой системы нет части транзакций, причём целыми блоками, что делает этот сервис не самым надёжным основным источником данных.
Однако же данные касательно смарт контрактов в данном сервисе достаточно полноценны. Написанный ниже код на Python на базе адреса смарт контракта ERC-721 токена возвращает название коллекции.
```
def get_collection_name(contract_adress):
url = ''
params = {
'module' : 'token',
'action' : 'getToken',
'contractaddress' : contract\_adress
}
r = requests.get(url, params=params)
if r.status\_code == 200:
json\_data = json.loads(r.text)
if (json\_data != None) and (json\_data['message'] == 'OK'):
return json\_data['result']['name']
else:
return "None"
else:
return "None"
```
Весь же ответ данного эндпоинта выглядит вот так:
```
{'message': 'OK',
'result': {
'cataloged': True,
'contractAddress': '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d',
'decimals': '',
'name': 'BoredApeYachtClub',
'symbol': 'BAYC',
'totalSupply': '10000',
'type': 'ERC-721'},
'status': '1'}
```
Пример для коллекции BoredApeYachtClub.
### Упаковка по микросервисам
Разобрались с тем как данные получать и анализировать, давайте это всё дело автоматизируем и красиво упакуем. На базе ранее написанного кода можно собрать полноценный скарпер и парсер транзакций, остально только написать скрипт по его периодическому запуску и сохранять данные в базу данных.
В своих предыдущих проектах я зачастую прибегал к слегка костыльному подходу для запуска скриптов по расписанию - использовал crontab внутри докера. В этот раз захотелось сделать что-то понадёжнее и поинтереснее.
Не буду опускаться в детали касательно реализации системы в рамках данного поста, но приведу краткую сводку касательно выбранной архитектуры. После небольшого ресёрча мой выбор пал на Celery + RabbitMQ для запуска проектов по расписанию. Результаты скарпинга я решил сохранять в Redis и каждый час через Celery запускать процесс по их анализу и сохранению результатов в MongoDB. Ну и для полной красоты процесса я ещё использовал Mongo-Express и Redisinsight для того чтобы следить что с базами данных всё в порядке.
В рамках своего проекта я решил каждый час публиковать статистику по объёму торгов за час и несколько самых крупных транзакций с помощью [телеграм бота](https://t.me/NFTBrewBot) и [бота в твиттере](https://twitter.com/NFTBrew1). А сделал я это с помощью библиотек [telebot](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/telebot) и [tweepy](https://tweepy.readthedocs.io/). В целом, хочется сказать, что у Твиттера оказалось на удивление простое и приятное API.
### Бонус - немного игры в сыщиков
В какой-то момент финальных стадий разработки этого проекта столкнулся с тем, что все крупные транзакции за час - была перепродажа одного и того же экземпляра NFT. Сначала я подумал что это баг, перепроверил весь свой код, но так и ничего не нашёл, пришлось внимательно изучать транзакции вокруг [Auidioglyphs #1935](https://etherscan.io/token/0xfb3765e0e7ac73e736566af913fa58c3cfd686b7?a=1935). Предлагаю читателям включить режим сыщиков и разобраться что же не так с этими транзакциями.
Так в чём же подвохЕсли кратко, то кто-то сознательно или бессознательно накручивал объём продаж вокруг данной коллекции. В среднем цена на OpenSea за один экземпляр данной коллекции колеблется около 0.01 - 0.1 ETH за штуку, а каждая транзация с Auidiogluphs #1935 была примерно на 180 - 190 ETH.
Интересно отметить, что OpenSea достаточно быстро заметили данную накрутку и перестали регистрировать похожие транзакции в статистике объёма примерно на следующий день.
Более того, название коллекции подозрительно на коллекцию известной студии [Larva Labs - Autoglyphs](https://larvalabs.com/autoglyphs).
Таким образом, некий аноним, вывев с биржи FTX порядка 200ETH в второй трети января промотал порядка 30 из них на такие вот транзакции (и знатно поспамил моим ботам).
Поразбиравшись с транзакциями я решил в итоге забанить коллекцию в выдаче твиттер и телеграм ботов и побарагузил об этом в твиттере и [телеграм канале](https://t.me/rawoak).
P.S. Ещё одно интересное наблюдение, которое также можно сделать небольшим расследованием. На заставке данной статьи, как и на заставке моих ботов, изображения из коллекции Cryptopunks. Они торгуются на OpenSea, там же можно посмотреть статистику по их продажам, а вот на смарт контракте OpenSea это никак не отображается, разберётесь в чём загвоздка? | https://habr.com/ru/post/651771/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.