text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Сетевой морской бой на bash
Недавно с целью изучения bash написал на нем игру в «морской бой» для игры по сети. Игра получила название «Sink 'em all».
Из внешних программ используются только `nc` (для организации взаимодействия по TCP), `stty` (для выключения эха при нажатии клавиши) и `clear` (для очистки терминала).
Исходный код можно посмотреть [здесь](http://pastebay.com/80860), а вот скачать его лучше [тут](http://dl.dropbox.com/u/3857674/sink.sh) или [вот тут](http://narod.ru/disk/16642806000/sink.sh.html), потому что PasteBay вставляет переносы строк в стиле Windows, из-за чего в свою очередь перестает работать указание интерпретатора с помощью hashbang (`#!`).
#### Как поиграть
Скачайте исходный код, переименуйте файл в `sink.sh` и поставьте на него исполняемый бит. После этого игру можно смело запускать (или не смело — вдруг в ней вредоносный код?). Чтобы запустить сервер, используйте ключ `-serve`:
`./sink.sh -serve`
Чтобы присоединиться к серверу, передайте в качестве параметра его IP-адрес или доменное имя, например:
`./sink.sh localhost`
Дальнейшие подсказки об управлении вы получите в процессе игры. В какое место кода вписывать строки для обмана противника, предлагаю выяснить самостоятельно :)
#### Что полезного я узнал?
В процессе написания я открыл для себя некоторые неизвестные мне ранее возможности и особенности bash. Среди них, например, сопроцессы. С помощью встроенной команды `coproc` можно создать сопроцесс и общаться с ним через пару пайпов, чем я и воспользовался для общения с `nc`. Если интересуют подробности, наберите `help coproc`, или читайте раздел «Coprocesses» в `man bash`.
В bash есть встроенные средства для работы со строками. Необязательно использовать `sed` и т. п., чтобы заменить подстроку другой строкой, вычислить длину строки и т. д. Это тоже стало для меня полезным открытием. Если интересуют подробности, могу подсказать, как называется соответствующий раздел в `man bash`: «Parameter Expansion». | https://habr.com/ru/post/80122/ | null | ru | null |
# Автоматическая установка Citrix XenServer
Недавно и я стал обладателем сервера [HP ProLiant MicroServer N36L](http://h10010.www1.hp.com/wwpc/by/ru/sm/WF06b/15351-15351-4237916-4237917-4237917-4248009-5037570.html). То, что на нем будет стоять Citrix XenServer, было решено заранее, тем более положительный опыт установки на этот сервер имеет место быть. Задачу установки немного усложняло то, что я был в отпуске. Дома, кроме буков и пары мышек, больше компьютерной техники нет. А для установки хотелось бы иметь клавиатуру, которую можно было принести с работы, и монитор. Проблема с монитором решилась просто, на телевизоре оказался VGA-разъем, дома нашелся кабель для него. Решил попробовать установить XenServer в автоматическом режиме, наблюдая за установкой по телевизору. Так как на сервере отсутствует оптический привод, устанавливать будем с флэшки.
Сначала скачаем [XenServer](http://www.citrix.com/lang/English/lp/lp_1688615.asp). Если будут ставиться линуксовые виртуалки, то [качаем](http://www.citrix.com/lang/English/lp/lp_1688621.asp) поддержку для них. Также понадобится [набор загрузчиков ядра Linux](http://syslinux.zytor.com/wiki/index.php/The_Syslinux_Project), установленный в локальной сети DHCP сервер, у меня эту функцию выполняет ZyXEL P-330W EE. Очень поможет наличие установленного Linux'а. Ну и флэшка, отформатированная FAT32.
1. Распаковываем Syslinux. В командной строке, в папке syslinux\win32 выполняем
```
syslinux.exe X:
```
Х: — буква вашего съемного диска.
Это сделает флэшку загрузочной.
2. Распаковываем скаченный XenServer на флэшку, файлы из папки boot\isolinux копируем в корень.
3. Распаковываем образ поддержки линуксовых гостевых систем XenServer-ххх-linux-cd. Скопируем папку packages.linux на флэшку.
4. На флэшке переименуем *isolinux.cfg* в *syslinux.cfg*, *isolinux.bin* в *syslinux.bin*.
5. Теперь нам нужно создать файл ответов. Тут у нас есть пара вариантов. Либо файл будет загружаться откуда-нибудь по сети, либо расположится на флэшке. Для первого случая можно использовать Web сервер в локальной сети. У меня на виртуалке на буке стоит Ubuntu, в ней я поднял Apache. Файл назовем *xenserver.xml*. URL, по которому он будет скачиваться <http://192.168.1.60/xenserver.xml>.
Внутри файла будут следующие строки:
Сам файл лежит [тут](http://dl.dropbox.com/u/8908314/xenserver.xml). Про создание файла ответов можно посмотреть [тут](http://docs.vmd.citrix.com/XenServer/5.6.0sp2/1.0/en_gb/installation.html#pxe_boot_install-pxe_answerfile). Ходят слухи, что параметров, которые можно указать в файле ответов, больше, чем указано в базовой документации. Мне главное было, чтобы после установки я мог по сети достучаться до установленного XenServer'а и авторизоваться на нем.
6. Теперь нам нужно указать, чтобы установщик узнал, что у нас установка идет с использованием файла ответов и где его можно взять. Для этого внесем небольшое изменение в файл *syslinux.cfg*. Отредактируем его, чтобы следующие строки:
LABEL install
KERNEL mboot.c32
APPEND /boot/xen.gz dom0\_mem=752M com1=115200,8n1 console=com1,vga — /boot/vmlinuz xencons=hvc console=hvc0 console=tty0 — /install.img
выглядели так:
LABEL install
KERNEL mboot.c32
APPEND /boot/xen.gz dom0\_mem=752M com1=115200,8n1 console=com1,vga — /boot/vmlinuz xencons=hvc console=hvc0 console=tty0 **answerfile=http://192.168.1.60/xenserver.xml install** — /install.img
7. Если мы сейчас попробуем загрузиться с флэшки, то система выругается *mboot.c32: not a COM32R image*. Поэтому из папки syslinux\com32\mboot (см. п. 1) копируем с заменой файл mboot.c32.
8. Теперь все готово к установке, вставляем флэшдиск в сервер, ждем когда закончится установка и пробуем зайти на него, например, с помощью Putty по SSH, указав IP адрес из файла ответов, введя *root* и пароль из того же файла. Набрав команду xsconsole выполняем донастройку, смену пароля и др.
Вернемся к случаю, когда файл ответов будет находиться на флэшке. После распаковки дистрибутива у нас появится на диске *install.img*. Он то нам и понадобится, потому что наш файл ответов нужно поместить внутрь этого образа. Воспользуемся установленной Ubuntu, ну или «любым другим» Linux'ом. Распаковку и запаковку образа делал с правами администратора. Чтобы распаковать *install.img* выполним:
```
gunzip -c ./install.img | cpio -i
```
Добавим в к распакованным файлам наш *xenserver.xml* и обратно упакуем в образ:
```
find . | cpio -o -H newc | gzip > ./install.img
```
Положим образ назад на флэшку. В п. 6 мы редактировали *syslinux.cfg* путем добавления *answerfile=http://192.168.1.60/xenserver.xml install*. Вместо этой строки укажем *answerfile=file:///xenserver.xml install*. | https://habr.com/ru/post/123970/ | null | ru | null |
# Свой mapper или немного про ExpressionTrees
Сегодня мы поговорим про то, как написать свой [AutoMapper](https://automapper.org/). Да, мне бы очень хотелось рассказать вам об этом, но я не смогу. Дело в том, что подобные решения очень большие, имеют историю проб и ошибок, а также прошли долгий путь применения. Я лишь могу дать понимание того, как это работает, дать отправную точку для тех, кто хотел бы разобраться с самим механизмом работы «мапперов». Можно даже сказать, что мы напишем свой велосипед.
### Отказ от ответственности
Я ещё раз напоминаю: мы напишем примитивный mapper. Если вам вдруг вздумается его доработать и использовать в проде — не делайте этого. Возьмите готовое решение, которое знает стек проблем этой предметной области и *уже умеет* их решать. Есть несколько более-менее весомых причин писать и использовать свой вело-mapper:
* Нужна какая-то специальная кастомизация.
* Нужна максимальная производительность в ваших условиях и вы готовы набивать шишки.
* Вы хотите разобраться с тем, как работает mapper.
* Вам просто нравится велоспорт.
### Что называют словом «mapper»?
Это подсистема, которая отвечает за то, чтобы взять некий объект и преобразовать (скопировать его значения) его в другой. Типичная задача: преобразовать DTO в объект бизнес слоя. Самый примитивный mapper «бежит» по свойствам (property) источника данных и сопоставляет их со свойствами типа данных, который будет на выходе. После сопоставления происходит извлечение значений из источника и их запись в объект, который будет результатом преобразования. Где-то по пути, скорее всего, нужно будет ещё создать этот самый «результат».
Для потребителя mapper — это сервис, который предоставляет следующий интерфейс:
```
public interface IMapper
{
TOut Map(object source);
}
```
Подчеркиваю: это наиболее примитивный интерфейс, который, с моей точки зрения, удобен для объяснения. В реальности мы, скорее всего, будем иметь дело с более конкретным маппером (IMapper) или с более общим фасадом (IMapper), который сам подберет конкретный mapper под заданные типы объектов входа-выхода.
### Наивная реализация
Ремарка: даже наивная реализация mapper'a требует элементарных знаний в области [Reflection](https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/concepts/reflection) и [ExpressionTrees](https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/concepts/expression-trees/). Если вы ещё не прошли по ссылкам или ничего не слышали об этих технологиях — сделайте это, прочтите. Обещаю, мир уже никогда не будет прежним.
Впрочем, мы с вами пишем свой mapper. Для начала давайте получим все свойства ([PropertyInfo](https://docs.microsoft.com/ru-ru/dotnet/api/system.reflection.propertyinfo?view=netcore-2.0)) того типа данных, который будет на выходе (далее я буду называть его **TOut**). Это сделать достаточно просто: тип мы знаем, так как пишем имплементацию generic-класса, параметризированного типом TOut. Далее, используя экземпляр класса Type, мы получаем все его свойства.
```
Type outType = typeof(TOut);
PropertyInfo[] outProperties = outType.GetProperties();
```
При получении свойств я опускаю особенности. Например, некоторые из них могут быть без setter-функции, некоторые могут быть помечены аттрибутом как игнорируемые, некоторые могут быть со специальным доступом. Мы рассматриваем самый простой вариант.
Идём далее. Было бы неплохо уметь создавать экземпляр типа TOut, то есть того самого объекта, в который мы «мапим» входящий объект. В C# это можно сделать несколькими способами. Например, мы можем сделать так: System.Activator.CreateInstance(). Или даже просто new TOut(), но для этого вам нужно создать ограничение для TOut, чего в обобщенном интерфейсе делать не хотелось бы. Впрочем, мы с вами что-то знаем об ExpressionTrees, а значит можем сделать вот так:
```
ConstructorInfo outConstructor = outType.GetConstructor(Array.Empty());
Func activator = outConstructor == null
? throw new Exception($"Default constructor for {outType.Name} not found")
: Expression.Lambda>(Expression.New(outConstructor)).Compile();
```
Почему именно так? Потому что мы знаем, что экземпляр класса Type может дать информацию о том, какие у него есть конструкторы — это весьма удобно для случаев, когда мы решим развить свой mapper настолько, что будем передавать в конструктор какие-либо данные. Также, мы ещё немного узнали про ExpressionTrees, а именно — они позволяют налету создать и скомпилировать код, который потом можно будет многократно использовать. В данном случае это функция, которая на самом деле выглядит как () => new TOut().
Теперь нужно написать основной метод mapper'a, который будет копировать значения. Мы пойдем по самому простому пути: идём по свойствам объекта, который пришёл к нам на вход, и ищем среди свойств исходящего объекта свойство с таким же названием. Если нашли — копируем, если нет — идём дальше.
```
TOut outInstance = _activator();
PropertyInfo[] sourceProperties = source.GetType().GetProperties();
for (var i = 0; i < sourceProperties.Length; i++)
{
PropertyInfo sourceProperty = sourceProperties[i];
string propertyName = sourceProperty.Name;
if (_outProperties.TryGetValue(propertyName, out PropertyInfo outProperty))
{
object sourceValue = sourceProperty.GetValue(source);
outProperty.SetValue(outInstance, sourceValue);
}
}
return outInstance;
```
Таким образом у нас полностью сформировался класс [BasicMapper](https://github.com/teoadal/velo/blob/master/src/Velo/Mapping/BasicMapper.cs). С его тестами можно ознакомиться [вот тут](https://github.com/teoadal/velo/blob/master/src/Velo.Tests/Mapping/BasicMapperShould.cs). Обратите внимание, что источником может быть как объект какого-то конкретного типа, так и анонимный объект.
### Производительность и boxing
[Reflection](https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/concepts/reflection) отличная, но медленная штука. Более того, её частое использование увеличивает memory traffic, а значит нагружает GC, а значит ещё больше замедляет работу приложения. Например, только что мы использовали методы [PropertyInfo.SetValue](https://docs.microsoft.com/ru-ru/dotnet/api/system.reflection.propertyinfo.setvalue?view=netcore-2.0) и [PropertyInfo.GetValue](https://docs.microsoft.com/ru-ru/dotnet/api/system.reflection.propertyinfo.getvalue?view=netcore-2.0). Метод GetValue возвращает object, в которой завернуто (boxing) некое значение. Это значит, что мы получили аллокацию на пустом месте.
Mapper'ы обычно находятся там, где нужно превратить один объект в другой… Нет, не один, а множество объектов. Например, когда мы забираем что-то из базы данных. В этом месте хотелось бы видеть нормальную производительность и не терять память на элементарной операции.
Что мы можем сделать? Нам снова поможет [ExpressionTrees](https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/concepts/expression-trees/). Дело в том, что .NET позволяет создавать и компилировать код «на лету»: мы описываем его в объектном представлении, говорим что и где будем использовать… и компилируем. Почти никакой магии.
### Компилируемый mapper
На самом деле, всё относительно просто: мы уже делали new с помощью Expression.New(ConstructorInfo). Наверное вы заметили, что статический метод New называется точно так же, как и оператор. Дело в том, что почти у всего синтаксиса C# есть отражение в виде статических методов класса Expression. Если чего-то нет, то это значит, что вы ищите т.н. «синтаксический сахар».
Вот несколько операций, которые мы будем использовать в нашем mapper'e:
* Объявление переменной — Expression.Variable(Type, string). Аргумент Type говорит о том, какого типа переменная будет создана, а string — название переменной.
* Присваивание — Expression.Assign(Expression, Expression). Первый аргумент — это то, чему мы присваиваем, а второй аргумент — что присваиваем.
* Доступ к свойству объекта — Expression.Property(Expression, PropertyInfo). Expression — владелец свойства, а PropertyInfo — полученное через Reflection объектное представление свойства.
Имея эти знания, мы можем создавать переменные, получать доступ к свойствам объектов и присваивать значения свойствам объектов. Скорее всего, мы также понимаем, что ExpressionTree нужно скомпилировать в делегат вида **Func**. План такой: получаем переменную, которая содержит входные данные, создаем экземпляр типа TOut и создаем выражения (expression), которые присваивают одно свойство в другое.
К сожалению, код получается не очень компактный, поэтому предлагаю сразу взглянуть на имплементацию [CompiledMapper](https://github.com/teoadal/velo/blob/master/src/Velo/Mapping/CompiledMapper.cs). Я вынес сюда лишь узловые моменты.
Для начала мы создаем объектное представление параметра нашей функции. Так как она принимает на вход object, то и параметром будет объект типа object.
```
var parameter = Expression.Parameter(typeof(object), "source");
```
Далее мы создаем две переменные и список Expression, в который будем последовательно складывать выражения присваивания. Порядок важен, ведь именно так команды будут выполнены, когда мы вызовем скомпилированный метод. Например, мы не можем присвоить значение переменной, которая ещё не объявлена.
Далее мы точно также, как и в случае с наивной имплементацией, идём по списку свойств типов и пытаемся их сопоставить по имени. Однако, вместо того, чтобы немедленно присваивать значения — мы создаем выражения извлечения значений и присваивания значений для каждого сопоставленного свойства.
```
Expression sourceValue = Expression.Property(sourceInstance, sourceProperty);
Expression outValue = Expression.Property(outInstance, outProperty);
expressions.Add(Expression.Assign(outValue, sourceValue));
```
Важный момент: после того, как мы создали все операции присваивания нам нужно вернуть результат из функции. Для этого последним выражением в списке должно быть Expression, содержащее экземпляр класса, который мы создали. Я оставил комментарий рядом с этой строчкой. Почему поведение, соответствующее ключевому слову return в ExpressionTree выглядит именно так? Боюсь, что это отдельная тема. Сейчас я предлагаю это просто запомнить.
Ну и в самом конце мы должны скомпилировать все выражения, которые мы построили. Что нам тут интересно? Переменная body содержит «тело» функции. У «обычных функций» ведь есть тело, верно? Ну, которое мы заключаем в фигурные скобки. Так вот, Expression.Block — это именно оно. Так как фигурные скобки — это ещё и область видимости, то мы должны передать туда переменные, которые там будут использоваться — в нашем случае sourceInstance и outInstance.
```
var body = Expression.Block(new[] {sourceInstance, outInstance}, expressions);
return Expression.Lambda>(body, parameter).Compile();
```
На выходе мы получим Func, т.е. функцию, которая может сконвертировать данные из одного объекта в другой. К чему такие сложности, спросите вы? Я напомню, что во-первых, мы хотели избежать boxing'a при копировании ValueType-значений, а во-вторых, мы хотели отказаться от методов PropertyInfo.GetValue и PropertyInfo.SetValue, так как они несколько медленные.
Почему не будет boxing? Потому что скомпилированный ExpressionTree это настоящий IL и для runtime он выглядит также (почти), как и ваш код. Почему «скомпилированный mapper» работает быстрее? Снова: потому что это просто обычный IL. Кстати, скорость мы можем легко подтвердить с помощью библиотеки [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet), а сам бенчмарк можно посмотреть [тут](https://github.com/teoadal/velo/blob/master/src/Velo.Benchmark/MappersBenchmark.cs).
| Method | Mean | Error | StdDev | Ratio | Allocated |
| --- | --- | --- | --- | --- | --- |
| AutoMapper | 1,291.6 us | 3.3173 us | 3.1030 us | 1.00 | 312.5 KB |
| Velo\_BasicMapper | 11,987.0 us | 33.8389 us | 28.2570 us | 9.28 | 3437.5 KB |
| Velo\_CompiledMapper | 341.3 us | 2.8230 us | 2.6407 us | 0.26 | 312.5 KB |
В колонке Ratio «скомпилированный mapper» (CompiledMapper) показал очень неплохой результат, даже по сравнению с AutoMapper (он baseline, т.е. 1). Впрочем, давайте не будем радоваться: AutoMapper обладает значительно большими возможностями по сравнению с нашим велосипедом. Этой табличкой я лишь хотел показать, что ExpressionTrees значительно быстрее, чем «подход классического Reflection».
### Резюме
Надеюсь, мне удалось показать, что написать свой mapper достаточно просто. Reflection и ExpressionTrees — очень мощные средства, которые разработчики используют для решения множества различных задач. Dependency injection, Serialization/Deserialization, CRUD-репозитории, построение SQL запросов, использование других языков в качестве скриптов для .NET-приложений — всё это делается с использованием Reflection, Reflection.Emit и ExpressionTrees.
А что mapper? Mapper — отличный пример, на котором всему этому можно научиться.
P.S.: Если вам захотелось ещё немного ExpressionTrees, то предлагаю прочитать о том, как [сделать свой конвертер JSON](https://habr.com/ru/post/464525/) с помощью этой технологии. | https://habr.com/ru/post/463961/ | null | ru | null |
# Чиптюн-музыка на ATtiny4 и трехцентовом Padauk
[](https://habr.com/ru/company/ruvds/blog/556386/)
Когда я услышал [«Bitshift Variations in С Minor»](http://txti.es/bitshiftvariationsincminor) Роба Майлза – [16-минутный фрагмент 4-голосого полифонического аудио произведения](https://soundcloud.com/robertskmiles/bitshift-variations-in-c-minor) – мне очень захотелось воплотить такое аппаратно. Реализовать это на любом микроконтроллере слишком уж просто, поэтому я решил взять самый мелкий, какой смог найти – ATtiny4. Чуть позже я портировал эту программу на небезызвестный [трехцентовый микроконтроллер](https://www.eevblog.com/forum/blog/eevblog-1132-the-3-cent-microcontroller!/) [Padauk PMS150С](http://www.padauk.com.tw/upload/doc/PMS15A,PMS150C%20datasheet%20V108_EN_20200724.pdf).
Ах да – при этом он полностью уместился в RCA-штекер и автоматически обнаруживает подключение.
*Плата ATtiny4, внутренняя сборка и готовое устройство.*
* [Видео-демонстрация](https://gir.st/chiptunes.html#demo) воспроизведения музыки устройством.
* [Слайды с блиц-доклада](https://gir.st/img/chiptunes.pdf) на 35c3.
* Репозитории [ATtiny](https://git.gir.st/Chiptunes.git/shortlog) и [Padauk.](https://git.gir.st/Chiptunes-pms150c.git)
Как он работает
---------------
На внешнем уровне он воплощает две функции: воспроизводит музыку и проверяет наличие подключения, чтобы накапливать энергию для работы в автономном режиме.
### Генерация музыки
ATtiny имеет довольно мощный таймер/счетчик и выполняет двойную работу, генерируя как ШИМ-сигнал для аудио выхода, так и прерывания для генерации очередного PCM-сэмпла.
Говоря точнее, мы устанавливаем его в 8-битный не инвертированный ШИМ-режим без предварительного делителя и включаем прерывание переполнения. Это означает, что таймер отсчитывает от нуля до 255, используя ту же тактовую частоту 4МГц, что и ядро ЦПУ, ШИМ-выход поднимается от нуля до заданного коэффициента заполнения, и при достижении значения TOP сбрасывается к нулю, вызывая прерывание по переполнению.
Немного быстрых расчетов: самая высокая частота, на которой МК может работать, будучи запитанным от 3В «таблетки», равна 4МГц. Эти 4МГц, поделенные на 256 шагов, дают нам базовую частоту ШИМ в 15.625КГц. Слегка откалибровав внутренний генератор, мы можем добиться ее округления до 16КГц. Поскольку частота дискретизации исходного тона равна 8КГц, то новый сэмпл нужно генерировать только раз в два переполнения/прерывания. Это оказывается весьма удобно, так как генерация сэмплов в итоге занимает немногим более 400 циклов.
На этом графике я отразил счетчик, его значение для сопоставления, итоговый выход ШИМ, а также прерывание по переполнению и коэффициент заполнения/выполнение подпрограммы `sample`, запускаемой этим прерыванием.
Ниже вы видите коэффициент заполнения и выход ШИМ на реальной микросхеме. Здесь отчетливо отражено, что в течение одного прерывания генерируется два сэмпла. (И этот вывод коэффициента заполнения/отладки позднее тоже пригодился, так как позволил откалибровать генератор через отслеживание частоты на осциллографе Rigol).
*Канал 1 (нижний) показывает выход отладки, канал 2 (верхний) показывает сигнал ШИМ. Обратите также внимание на отображение частоты в верхнем правом углу.*
### Обнаружение подключения
Планируя механический дизайн, я понял, что физически кнопку выключения музыки встроить в корпус не смогу (не говоря уже о выключателе с фиксацией). Именно так и родилась идея автоматического обнаружения устройством подключения. В теории здесь все просто: когда оно подключено к приемнику аудио, возникает электрическая связь между аудио выходом и землей. Все что нужно, это регулярно подавать высокий сигнал на центральный контакт RCA-штекера и проверять его на понижение.
С программной стороны мы фиксируем, в каком месте произведения находимся, и входим в режим пониженного энергопотребления, который отключает таймер/счетчик и даже тактовый генератор. В этом состоянии мы ожидаем низкоуровневого (в смысле нулевого напряжения) внешнего прерывания, которое сработает при подключении устройства, после чего запускаем проигрывание.
На практике же все сложнее: типичное сопротивление линейного аудиовхода составляет 20-100кОм, что намного выше, чем у внутренних подтягивающих резисторов ATtiny, хотя это легко решается внешним подтягиванием. Кроме того, функциональность генерации прерывания при смене контактов недоступна на контакте выхода ШИМ, но и это легко обойти, просто закоротив их.
Согласно [спецификации](http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-8127-AVR-8-bit-Microcontroller-ATtiny4-ATtiny5-ATtiny9-ATtiny10_Datasheet.pdf#_OPENTOPIC_TOC_PROCESSING_d94e26009), потребление энергии в таком состоянии ниже 0.15мкВ. Примерно с той же скоростью происходит саморазряд «таблетки», так что хватить ее должно на годы.
### Фильтрация выхода
При использовании базовой частоты ШИМ 16кГц есть один недостаток: она слышима. Изначально я собирался просто это игнорировать, но один друг справедливо убедил меня добавить RC-фильтр нижних частот.
Быстрый и грубый [спектральный анализ](https://f-droid.org/en/packages/org.billthefarmer.scope/), сделанный с телефона, подтвердил, что эта частота действительно шумит. Границу среза и кривую отклика я выбрал довольно произвольно (глядя на коробку под SMD-компоненты) около 8кГц, тем не менее с задачей она справляется отлично, так что при заказе итогового списка материалов я придерживался именно ее.
*Соотношение сигнал-шум после добавления фильтра существенно улучшилось.*
Программное обеспечение
-----------------------
Разобравшись с теорией, осталось только прописать код. Я решил вручную воспроизвести Си программу Роба на ассемблере AVR, отчасти ради забавы, отчасти в качестве (поспешной?) стратегии по оптимизации. У ATtiny нет аппаратного mul/div/mod, и мне потребовалось лишь немного правосторонних множителей/делителей, для чего я написал несколько специальных оптимизированных вариантов.
Начал я с нетронутой программы Си и сначала просто ее упростил, после чего заменил каждую операцию на макрос Си, реализующий соответствующую инструкцию машинного кода. После каждого малейшего изменения я генерировал PCM-поток и сравнивал его с заведомо корректным образцом, чтобы избежать ошибок. Каждое изменение автоматически отправлялось в репозиторий, в результате чего получилось 136 коммитов под именем new version. Только затем я добавил код инициализации и произвел запуск на реальном микроконтроллере.
На этом этапе, сам того не ведая, я допустил ошибку при написании одного из псевдо-ASM макросов: я инвертировал условие ветвления в mod3, в результате чего оно переключалось, когда не должно было, и наоборот. Это привело к невозможности распознавания голосов 3 и 4 на микроконтроллере. Причину ошибки мне удалось обнаружить только год спустя, когда я вновь вернулся к проекту после того, как в [simavr](https://github.com/buserror/simavr), наконец-таки, появилась элементарная [поддержка](https://github.com/leg0/simavr/tree/add_tiny9) семейства ATtiny 10. Когда я запустил gdb(1), проблема тут же стала очевидной, и для [патча](https://git.gir.st/Chiptunes.git/commitdiff/26799babfc57e999f575a4b07f20d93f778600a0) потребовалась всего одна инструкция машинного кода.
Гибкие печатные платы
---------------------
*Гибкие печатные платы, которые можно обернуть вокруг батарейки*
Изначально я попробовал сделать двухточечную разводку эмалированным проводом. Затея эта с треском провалилась: припой не ложился на батарею, а альтернативный вариант с токопроводящим клеем получался грязным, и непрочным. При изоляции же батареи и компонентов с помощью нескольких слоев каптонового скотча изделие оказывалось слишком большим и в корпус штекера уже не входило.
Все эти проблемы на раз решила гибкая печатная плата. Я спроектировал ее так, чтобы она оборачивала «таблетку», при этом контакты батарейки находились внутри, а компоненты снаружи. Зажим, сделанный из скобы для бумаги, сдавливает этот «сэндвич», обеспечивая тем самым его питание. Сама плата также изолирует батарею, для чего достаточно одного оборота скотча по кругу, и делает этот мини комплект достаточно жестким.
И все же нужно было еще проложить два провода, идущих от платы к точкам пайки на внутренней стороне RCA-штекера. Задача оказалась непростой, и я не сразу додумался, как скрутить две части корпуса штекера, не прокручивая провода. Решением стало максимально глубоко задвинуть плату в корпус и слегка провернуть провода против часовой стрелки, чтобы при закрытии корпуса они, наоборот, развернулись.
*Стек слоев в KiCad. [PDF-схема](https://gir.st/img/schematic.pdf).*
Портирование на Padauk
----------------------
При использовании ATtiny меня не покидало ощущение, что я мухлюю: он снабжен сравнительно богатой периферией и содержит много очень гибких регистров (16), которыми можно управлять напрямую. К тому же у меня завалялся самодельный программатор для микроконтроллеров Padauk, который подогнал мне один из участников форумов EEVBlog, а также около 500 штук PMS150C.
Эти микроконтроллеры прославились своей невысокой стоимостью – около 3 американских центов за экземпляр при приобретении в сравнительно небольших количествах. За свою цену они неплохо оснащены: ПЗУ на 1024 слова (программируемых один раз), 64 байта статического ОЗУ, 8-битный таймер с ШИМ, (несколько странный) 16-битный таймер, внутренний компаратор и источник опорного напряжения. По мнению некоторых, набор инструкций Padauk во многом следует более старой модели PIC, и большинство его операций происходят в одном накапливающем регистре.
Недостаток же в том, что производитель поскупился на документацию: спецификация не описывает, как мнемоника ассемблера сопоставляется с реальными единицами и нулями, то есть вы должны использовать их проприетарные (и доступные только для Windows) IDE, программатор и внутрисхемный эмулятор. Эта IDE даже не имеет компилятора Си, а использует странный язык, который они зовут «мини Си»: по сути, это ассемблер с позаимствованным из Си синтаксическим сахаром.
Талантливая группа любителей во главе с *js\_12345678\_55AA*, *tim\_ (cpldcpu)* и *spth (pkk)*, невзирая на отсутствие вышестоящей поддержки, создала впечатляющую и полностью открытую цепочку инструментов Си, включая компилятор, ассемблер, компоновщик, дизассемблер, симулятор, программное и аппаратное обеспечение программатора, а также низкоуровневую документацию.
*Внутренняя сборка Padauk-версии*
Для портирования чиптюнов на PMS150С потребовалось полностью перевести исходный Си-код в ассемблер, чтобы наилучшим образом использовать сжатые требования к циклам (в рамках которых я оставался с трудом: в худшем случае использовалось 507 из 512 доступных циклов). После того, как в процессе поиска правильного способа инициализации периферии я сжег тестовыми программами 5 схем, потребовалось еще всего 2, чтобы добиться полноценной отладки программы.
Итого семь микросхем, но при этом гораздо больше попыток: на деле можно программировать одноразовую память несколько раз при условии изменения только единиц на нули. Так что я оставил немного пространства под векторами сброса и прерывания, подставил новую версию кода и исправил инструкции GOTO, заменив их на NOP и добавив новый переход сразу же после. Скажу честно, я не столь скуп, но на неоднократную возню с ZIF-разъемом ушло бы больше времени, чем на этот обходной вариант.
*Выделение некоторых отличий в версиях ассемблера: загрузка нот из памяти*
Версия Padauk имеет небольшие отличия в сравнении с версией ATtiny: во-первых, здесь я задействую оба таймера, что позволяет использовать более высокую базовую частоту ШИМ (64кГц) и обойтись без ФНЧ. Во-вторых, внутреннее подтягивание Padauk достаточно высокое, и внешнее уже не требуется. Это означает, что мне удалось добиться полного отсутствия внешних компонентов.
И все же без сложностей не обошлось: t1sn M.n (тест старшего бита в статической ОЗУ и пропуск следующей инструкции) и set1 M.n (установка бита в области статической ОЗУ) работают только для первых 16 адресов; по данному поводу в спецификации толком ничего не сказано (заметил я это лишь потому, что в документации по реконструированным наборам инструкций присутствовало 4-битное адресное поле). В симуляторе микроконтроллера ucism было несколько ошибок, связанных с этими (и аналогичными) инструкциями, что слегка сбило меня с пути (патчи я отправил в список рассылки).
При этом также наблюдалось странное поведение режимов прерывания и ожидания `timer16`, разобраться с которым мне помог JS. В остальном же весь процесс оказался достаточно плавным, и все благодаря качественной работе упомянутых выше ребят.
*Обратите внимание на повышенную частоту ШИМ и более интенсивное использование ЦПУ в сравнении с версией ATtiny.*
Я не стал озадачиваться созданием новых печатных плат; у меня оставались варианты без ФНЧ, и я просто оставил внешний подтягивающий резистор неподключенным.
Живое демо
----------
Видео одного полного проигрывания музыки. Начало несколько затяжное, но с 1:35 становится интереснее.
Примечания
----------
Считаю необходимым упомянуть проект [Noiseplug](https://vimeo.com/47380710) от DoJoe. На него я наткнулся при поиске информации по ATtiny и могу сказать, что по своей сути он похож на мой.
Я собрал себе макетную плату из платы-переходника, поскольку шаг ее контактных площадок в точности соответствует одной стороне форм фактора SOT23-6. Вторую сторону я после подключил проводами. В другом, более раннем, варианте макетной платы использовалась миниатюрная адаптерная ATtiny, которую я приклеил на общую панель плат-переходников, чтобы ее расширить. Последнюю из них я представил на 35C3.
*Макетные платы*
Гибкие платы я заказал с OSHPark.com, и обошлись они примерно по доллару за штуку. Заказ был обработан довольно быстро, правда некоторые из них пришли с дефектами травления.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=Bright_Translate&utm_campaign=chiptyun_muzyka_na_attiny4_i_trexcentovom_padauk) | https://habr.com/ru/post/556386/ | null | ru | null |
# Stripe: сервис вашей мечты для автоматизации денежных переводов
Имевшие дело с сервисом электронных платежей [Stripe](https://stripe.com/) знают, что он отлично заточен под разработчиков. Его документация написана людьми для людей; есть хороший тестовый режим — полная копия реального, и для перехода на live-режим нужно только заменить ключи, не трогая API и не получая никаких сюрпризов; админка тестового режима — тоже полная копия боевого. В общем, Stripe — это хорошо, и я хочу посвятить эту статью базовым вопросам интеграции сервиса в e-Commerce-проект, объяснив процессы на конкретных и абстрактных примерах. Надеюсь, что мой опыт поможет всем, кто хочет попробовать Stripe на своём проекте.
Однако перед тем, как использовать Stripe, задайте вопрос: «А где находится бизнес, который мы будем обслуживать?». Например, если бизнес российский, Stripe для нас бесполезен: принимать платежи можно из любой страны, но бизнес владельца аккаунта на Stripe должен быть юридически зарегистрирован в одной из доступных стран. Иначе создать и авторизовать аккаунт невозможно. Список стран можно посмотреть [здесь](https://support.stripe.com/questions/what-countries-does-stripe-support). Если вы хотите выводить деньги на другие счета, например, поставщикам (как это делать, я расскажу ниже), то юридически поставщики тоже должны находиться в странах, с которыми работает Stripe. Бизнес клиента, с которым работала я, зарегистрирован в Америке, что позволяло проводить платежи через Stripe.
Также нужно быть готовым, что Stripe не поддерживает xml-протокол 3-D-secure, который требует от клиента вводить код подтверждения, полученный в SMS-сообщении. Stripe просто пытается провести платеж без этой опции, и если банк принимает платежи без 3-D Secure — хорошо, если нет — всё закончится отказом, и с этой карты платить не получится.
Проведение платежа
==================
Чтобы перевести деньги с карточки клиента на наш Stripe-аккаунт, нам нужно сделать следующее. С помощью скрипта Stripe.js получим на фронтенде Stripe token. Дальше мы будем использовать token с серверной стороны, чтобы провести сам платёж.
Подключаем Stripe.js и указываем публичный ключ:
```
Stripe.setPublishableKey('your\_public\_key');
```
Делаем обычную HTML-форму, на input указываем атрибуты data-stripe для работы скрипта. Нам будет нужен номер карты клиента, год и месяц валидности карты и CVC. Имя и фамилию владельца Stripe не требует.
```
Card Number
Expiration (MM/YY)
CVC
```
Теперь получим token:
```
$(function() {
var $form = $('#payment-form');
$form.submit(function(event) {
// Отключим кнопку, чтобы предотвратить повторные клики
$form.find('.submit').prop('disabled', true);
// Запрашиваем token у Stripe
Stripe.card.createToken($form, stripeResponseHandler);
// Запретим форме submit
return false;
});
});
function stripeResponseHandler(status, response) {
// Получим форму:
var $form = $('#payment-form');
if (response.error) { // Problem!
// Показываем ошибки в форме:
$form.find('.payment-errors').text(response.error.message);
$form.find('.submit').prop('disabled', false); // Разрешим submit
} else { // Token был создан
// Получаем token id:
var token = response.id;
// Вставим token в форму, чтобы при submit он пришел на сервер:
$form.append($('').val(token));
// Сабмитим форму:
$form.get(0).submit();
}
};
```
На всякий случай: этот шаг описан в [официальной документации](https://stripe.com/docs/custom-form).
Теперь мы можем списать деньги с клиента через сервер. Примеры кода на PHP.
```
// Устанавливаем секретный ключ
\Stripe\Stripe::setApiKey("your_secret_key");
// Забираем token из формы
$token = $_POST['stripeToken'];
// Создаём оплату
try {
$charge = \Stripe\Charge::create(array(
"amount" => 1000, // сумма в центах
"currency" => "usd",
"source" => $token,
"description" => "Example charge"
));
} catch(\Stripe\Error\Card $e) {
// Платёж не прошёл
}
```
Это всё, что нужно сделать, чтобы перевести деньги с карты клиента на ваш Stripe-счёт.
Автоматические переводы денег вашим поставщикам
===============================================
Теперь рассмотрим перевод на рабочем примере. Представим, что вы пишете платформу, которая продаёт редкие книги из маленьких издательств по всему миру. Вам нужно переводить деньги вашим поставщикам-издательствам, чтобы они выслали книгу клиенту, и брать себе комиссию 10$ c каждой продажи. Вы не хотите париться с ежемесячными отчётами и выплатами, вы хотите просто переводить деньги каждый раз, когда платит клиент. Stripe это позволяет.
Как и прежде, обязательное условие для настройки автоматических переводов — это нахождение поставщика в одной из стран, поддерживаемых Stripe.
У Stripe есть замечательная штука [Managed Acсounts](https://stripe.com/docs/connect/managed-accounts). С помощью этой опции мы как бы создаем Stripe-аккаунт для нашего поставщика, но берём на себя все заботы по управлению аккаунтом, так что самому издательству не нужно будет регистрироваться в Stripe.
Сначала получим информацию о банковском счёте вашего издательства с помощью уже знакомого нам скрипта Stripe.js. Как и в случае списания денег с карты клиента, для операций над банковским счётом нам тоже нужен Stripe token.
```
Stripe.bankAccount.createToken({
country: $('.country').val(), // 2-хсимвольный код страны (US)
currency: $('.currency').val(), // 3-хсимвольный код валюты (USD)
routing_number: $('.routing-number').val(), // идентификационый номер банка
account_number: $('.account-number').val(), // номер банковского счёта
account_holder_name: $('.name').val(), // имя владельца бизнеса (в нашем примере — издательства)
account_holder_type: $('.account-holder-type').val() // тип аккаунта — идивидуальный предприниматель или компания (individual, company)
}, stripeResponseHandler);
```
Это тоже описано в [документации](https://stripe.com/docs/stripe.js?#collecting-bank-account-details).
*Ремарка*. Имейте в виду, что для каждой страны банковские данные (routing\_number, account\_number ) заполняются по-разному. Например, для европейских стран нужно получать IBAN-номер. Он кладётся в поле account\_number, а routing\_number не отпраляется вообще. Также для некоторых стран внутренние номера счетов склеиваются в одну строку и записываются в поля. Например, чтобы получить корректный идентификационный номер банка routing\_number для Канады, надо склеить transit number и institution number (transit number + institution number). Если transit number: 02345, а institution number: 987, то routing\_number будет ‘02345987’. Account number варьируется в зависимости от банка. А для Германии нужен будет только IBAN номер, он заполняется в поле routing\_number. Например, IBAN: DE89370400440532013000 (22 символа). Как заполнять эти поля для остальных стран, можно посмотреть [тут](https://support.stripe.com/questions/what-bank-account-information-should-platforms-provide-for-managed-accounts-in-different-countries).
Итак, теперь у нас есть token банковского счёта, куда мы можем выводить деньги поставщикам. Давайте создадим Managed Account. Пусть наше издательство находится в Америке, является компанией, а не ИП, и мы платим ему в американских долларах.
```
\Stripe\Stripe::setApiKey("your_secret_key");
$account = Account::create([
"country" => 'US',
"managed" => true,
]);
if (isset($account->id)) {
try {
$account->external_accounts->create(
["external_account" => $token] // наш token банковского счета
);
} catch (InvalidRequest $error) {
// произошла ошибка создания
}
}
```
Казалось бы, теперь у нас есть Managed Account, и можно переводить деньги, но нет: аккаунт нужно верифицировать. Для этого нужно предоставить Stripe определённую юридическую информацию о компании. Какая именно информация нужна и в каких странах, описано [здесь](https://stripe.com/docs/connect/required-verification-information).
Итак, для издательства в Америке нам нужно предоставить:
| Название | Описание |
| --- | --- |
| legal\_entity.address.city | Город, в котором расположена компания |
| legal\_entity.address.line1 | Адрес компании |
| legal\_entity.address.postal\_code | Почтовый индекс |
| legal\_entity.address.state | Штат |
| legal\_entity.business\_name | Название компании |
| legal\_entity.business\_tax\_id | Налоговый идентификационный номер |
| legal\_entity.dob.day | День рождения владельца компании |
| legal\_entity.dob.month | Месяц рождения владельца компании |
| legal\_entity.dob.year | Год рождения владельца компании |
| legal\_entity.first\_name | Имя владельца компании |
| legal\_entity.last\_name | Фамилия владельца компании |
| legal\_entity.ssn\_last\_4 | Четыре последние цифры номера социального страхования владельца компании |
| legal\_entity.type | individual/company |
| tos\_acceptance.date | Дата принятия условий использования Stripe |
| tos\_acceptance.ip | IP-адрес, с которого происходило принятие условий использования Stripe |
Условия использования Stripe [здесь](https://stripe.com/us/terms). Человек, от чьего имени будет создаваться Managed Account, должен их принять.
Также Stripe может потребовать дополнительную информацию. Для Америки это:
| Название | Описание |
| --- | --- |
| legal\_entity.personal\_id\_number | Личный идентификационный номер |
| legal\_entity.verification.document | Скан документа, подтверждающего личность |
Собираем необходимую информацию и редактируем аккаунт.
```
\Stripe\Stripe::setApiKey("your_secret_key");
$account = Account::retrieve($accountId);
$account->legal_entity->address->city = 'New-York';
$account->legal_entity->address->state = 'New-York';
$account->legal_entity->address->postal_code = '00501';
$account->legal_entity->address->line1 = 'Some address';
$account->legal_entity->business_name = 'US TEST';
$account->legal_entity->business_tax_id = '00000001';
$account->legal_entity->dob->day = 1;
$account->legal_entity->dob->month = 1;
$account->legal_entity->dob->year = 1980;
$account->legal_entity->first_name = 'Bob';
$account->legal_entity->last_name = 'Smith';
$account->legal_entity->type = 'company';
$account->legal_entity->ssn_last_4 = '0000';
$account->tos_acceptance->date = 1466074123; // timestamp
$account->tos_acceptance->ip = 123.123.123.123;
try {
$account->save();
} catch (InvalidRequest $error) {
// ошибка во время сохранения
}
```
Теперь команда Stripe всё проверит, и в админке мы увидим статус Verified.
<https://dashboard.stripe.com/test/applications/users/overview>
Но этого нам не будет достаточно. Также команда Stripe может указать ошибки в данных или потребовать дополнительной информации, например personal\_id\_number.
Когда команда проверит данные, аккаунт будет обновлён. На это событие можно настроить [webhook](https://stripe.com/docs/webhooks).
Необходимые поля будут описаны в объекте аккаунта:
```
$account->verification->fields_needed
```
Также Stripe может выставить дедлайн для предоставления данных. Если дата есть, она будет в свойстве $account->verification->due\_by.
Для тестирования верификации Stripe предоставляет хорошую тестовую среду. С помощью переводов с определённых тестовых карт мы можем симулировать разные сценарии поведения верификации аккуантов. Примеры таких сценариев:
* данные не заполнены, и мы вообще не можем совершать переводы;
* сработал лимит на размер платежа. Это происходит, если Stripe считает, что перевод слишком большой, и предоставленной информации ему недостаточно. В этом случае он отключает Managed Account;
* отключение аккаунта с требованием ввести данные к определенной дате;
* загрузка скана документа, подтверждающего личность владельца аккаунта;
* принятие и отклонение этого скана.
Как конкретно симулировать эти случаи, описано [здесь](https://stripe.com/docs/connect/testing-verification).
Обработать все ситуации придётся в любом случае. И по моему опыту, лучше сразу предоставить Stripe максимум информации, чтобы избежать сюрпризов с отключением аккаунта.
Когда все окей, и Stripe верифицировал ваш Managed Account, нужно включить переводы (transfers) с помощью API или отключить автоматические — это одно и то же.
<https://dashboard.stripe.com/account/transfers>
Итак, у нас есть верифициронный аккаунт, переводы включены, и теперь мы можем делать переводы денег напрямую поставщику.
Предположим, у нас есть книга. Поставщик хочет за неё 50$, мы хотим 10$ долларов комиссии себе, плюс нам надо заложить в цену комиссию Stripe на перевод. [Сейчас Stripe берёт за каждый перевод](https://stripe.com/us/pricing) 2,9% + 30¢. Мы решили, что оплатим комиссию из своей части. Тогда пользователю надо заплатить за книгу 60$. Из своей части мы отдадим 2,04$ комиссии Stripe.
Получаем token с помощью Stripe.js и проводим платёж со стороны сервера.
```
$charge = Charge::create([
"amount" => 6000, // в центах
"currency" => 'USD',
"source" => $token,
"application_fee" => 1000,
"destination" => $managedAccountId
]);
```
Свойство application\_fee позволяет указать, какую сумму от перевода оставить на нашем счету. Комиссия Stripe будет списываться в любом случае только с нашего счёта, даже если мы сделаем полный перевод поставщику.
На банковский счёт поставщика деньги сразу не придут, они выводятся раз в семь дней. Т.е. мы переводим деньги на Stripe-аккаунт нашего поставщика, и по истечении семи дней они переводятся аккаунту на привязанный банковский счёт.
Дополнительные фичи
===================
Кроме того, Stripe позволяет сохранять клиентов, добавлять произвольные метаданные при создании платежа, чтобы было проще ориентироваться в проведённых платежах, задавать description при платеже для его более информативного описания, и многое другое. Обо всём этом можно посмотреть в [документации к API платежей](https://stripe.com/docs/api#charges).
Желаю вам удачи в интеграции Stripe! Я буду рада вашим комментариям, вопросам и уточнениям, которые помогут дополнить статью.
Полезные ссылки:
================
[Страны, которые поддерживают Stripe](https://support.stripe.com/questions/what-countries-does-stripe-support)
[Custom HTML form для получения token](https://stripe.com/docs/custom-form)
[Managed Acсounts](https://stripe.com/docs/connect/managed-accounts)
[Получение token для банковского аккаунта](https://stripe.com/docs/stripe.js?#collecting-bank-account-details)
[Необходимая банковская информация по странам](https://support.stripe.com/questions/what-bank-account-information-should-platforms-provide-for-managed-accounts-in-different-countries)
[Необходимая юридическая информация для Managed Accounts по странам](https://support.stripe.com/questions/what-bank-account-information-should-platforms-provide-for-managed-accounts-in-different-countries)
[Условия использования Stripe](https://stripe.com/us/terms)
[Тестирование верификации аккуанта](https://stripe.com/docs/connect/testing-verification)
[Webhooks](https://stripe.com/docs/webhooks)
[Stripe Pricing](https://stripe.com/us/pricing)
[Stripe API Reference](https://stripe.com/docs/api) | https://habr.com/ru/post/306338/ | null | ru | null |
# Головоломки TCP
Говорят, что нельзя полностью понять систему, пока не поймёшь её сбои. Ещё будучи студентом я ради забавы написал реализацию TCP, а потом несколько лет проработал в IT, но до сих пор продолжаю глубже и глубже изучать работу TCP — и его ошибки. Самое удивительное, что некоторые из этих ошибок проявляются в базовых вещах. И они неочевидны. В этой статье я преподнесу их как головоломки, в стиле [Car Talk](http://www.cartalk.com/content/puzzlers) или [старых головоломок Java](https://www.youtube.com/watch?v=wbp-3BJWsU8). Как и любые другие хорошие головоломки, их очень просто воспроизвести, но решения обычно удивляют. И вместо того, чтобы фокусировать наше внимание на загадочных подробностях, эти головоломки помогают изучить некоторые глубинные принципы работы TCP.
Необходимые условия
===================
Эти головоломки подразумевают наличие базовых знаний о работе TCP на Unix-подобных системах. Но вам не нужно быть мастером, чтобы вникнуть в них. Например:
* Информацию о состояниях сеанса TCP, трёх этапах соединения и об этапах его завершения можно найти в [Википедии](https://ru.wikipedia.org/wiki/TCP#.D0.9C.D0.B5.D1.85.D0.B0.D0.BD.D0.B8.D0.B7.D0.BC_.D0.B4.D0.B5.D0.B9.D1.81.D1.82.D0.B2.D0.B8.D1.8F_.D0.BF.D1.80.D0.BE.D1.82.D0.BE.D0.BA.D0.BE.D0.BB.D0.B0).
* Программы, как правило, взаимодействуют с сокетами, используя `read`, `write`, `connect`, `bind`, `listen` и `accept`. Помимо этого, есть также `send` и `recv`, но в наших примерах они будут вести себя как `read` и `write`.
* Я буду использовать в этой статье `poll`. Хотя многие системы используют что-то более эффективное, например, `kqueue` или `epoll`, в рамках нашей задачи все эти инструменты будут эквивалентны. Что касается приложений, использующих операции блокирования, а не какой-либо из этих механизмов: один раз поняв, как ошибки TCP отражаются на `poll`, вам будет проще догадаться, какой эффект они окажут на любые операции блокирования.
Вы можете повторить все эти примеры самостоятельно. Я использовал две виртуальные машины, запущенные с помощью VMware Fusion. Результаты получились такие же, как на production-сервере. Для тестирования я использовал `nc(1)` на SmartOS, и не поверю, что любая из воспроизводимых неполадок будет специфична для конкретной ОС. Для отслеживания системных вызовов и сбора грубой информации о таймингах я использовал утилиту [truss(1)](http://illumos.org/man/truss) из проекта illumos. Вы можете получить подобную информацию с помощью [dtruss(1m)](https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man1/dtruss.1m.html) под OS X или [strace(1)](http://linux.die.net/man/1/strace) под GNU/Linux.
`nc(1)` очень простая программа. Мы будем использовать её в двух режимах:
* Как сервер. В этом режиме nc создаст сокет, будет прослушивать его, вызовет `accept` и заблокирует, пока не будет установлено соединение.
* Как клиент. В этом режиме `nc` создаст сокет и установит соединение с удалённым сервером.
В обоих режимах после установки соединения каждая из сторон использует `poll` для ожидания стандартного ввода или подключения сокета, имеющего готовые для чтения данные. Входящие данные выводятся в терминал. Данные, которые вы вводите в терминал, отправляются через сокет. При нажатии CTRL-C сокет закрывается и процесс останавливается.
В примерах мой клиент будет называться `kang`, а сервер — `kodos`.
Разминка: нормальный разрыв TCP
===============================
Начнём с базовой ситуации. Представим, что мы настроили сервер на `kodos`:
Сервер
```
[root@kodos ~]# truss -d -t bind,listen,accept,poll,read,write nc -l -p 8080
Base time stamp: 1464310423.7650 [ Fri May 27 00:53:43 UTC 2016 ]
0.0027 bind(3, 0x08065790, 32, SOV_SOCKBSD) = 0
0.0028 listen(3, 1, SOV_DEFAULT) = 0
accept(3, 0x08047B3C, 0x08047C3C, SOV_DEFAULT, 0) (sleeping...)
```
(Напоминаю, что в этих примерах я использую `truss` для вывода системных вызовов, которые делает `nc`. Информация о времени выводится с помощью флага -`d`, а `-t` позволяет выбрать, какие из вызовов мы хотим увидеть.)
Теперь я устанавливаю соединение на `kang`:
Клиент
```
[root@kang ~]# truss -d -t connect,pollsys,read,write,close nc 10.88.88.140 8080
Base time stamp: 1464310447.6295 [ Fri May 27 00:54:07 UTC 2016 ]
...
0.0062 connect(3, 0x08066DD8, 16, SOV_DEFAULT) = 0
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
```
На `kodos` мы видим:
Сервер
```
23.8934 accept(3, 0x08047B3C, 0x08047C3C, SOV_DEFAULT, 0) = 4
pollsys(0x08045680, 2, 0x00000000, 0x00000000) (sleeping...)
```
Подключение TCP находится в состоянии ESTABLISHED, а оба процесса в `poll`. Мы можем увидеть это на каждой системе с помощью `netstat`:
Сервер
```
[root@kodos ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.140.8080 10.88.88.139.33226 1049792 0 1049800 0 ESTABLISHED
...
```
Клиент
```
[root@kang ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.139.33226 10.88.88.140.8080 32806 0 1049800 0 ESTABLISHED
...
```
Вопрос: **когда мы завершим один из процессов, что случится с другим?** Поймёт ли он, что произошло? Как он это поймёт? Попробуем предугадать поведение конкретных системных вызовов и объяснить, почему каждый из них делает то, что делает.
Нажмём CTRL-C на `kodos`:
Сервер
```
pollsys(0x08045680, 2, 0x00000000, 0x00000000) (sleeping...)
^C127.6307 Received signal #2, SIGINT, in pollsys() [default]
```
А вот что мы видим на `kang`:
Клиент
```
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
126.1771 pollsys(0x08045670, 2, 0x00000000, 0x00000000) = 1
126.1774 read(3, 0x08043670, 1024) = 0
126.1776 close(3) = 0
[root@kang ~]#
```
Что случилось? Давайте разберемся:
1. Осуществляя выход из процесса, мы отправили SIGINT на сервер. После выхода закрылись дескрипторы файлов.
2. Когда закрывается последний дескриптор для сокета `ESTABLISHED`, стек TCP на `kodos` отправляет через соединение FIN и переходит в состояние `FIN_WAIT_1`.
3. Стек TCP на `kang` получает пакет FIN, переводит собственное соединение в состояние `CLOSE_WAIT` и отправляет в ответ ACK. Пока клиент `nc` блокирует сокет — он готов к чтению, ядро будит этот тред с помощью `POLLIN`.
4. Клиент `nc` видит `POLLIN` для сокета и вызывает `read`, который тут же возвращает 0. Это означает конец соединения. `nc` решает, что мы закончили работу с сокетом, и закрывает его.
5. Тем временем, стек TCP на `kodos` получает ACK и переходит в состояние `FIN_WAIT_2`.
6. Пока клиент `nc` на kang закрывает свой сокет, стек TCP на `kang` отправляет FIN на `kodos`. Соединение на `kang` переходит в состояние `LAST_ACK`.
7. Стек TCP на `kodos` получает FIN, соединение переходит в состояние `TIME_WAIT`, и стек на `kodos` подтверждает FIN.
8. Стек TCP на `kang` получает ACK для FIN и полностью удаляет соединение.
9. Спустя две минуты соединение TCP на `kodos` закрывается, и стек полностью удаляет соединение.
Очерёдность этапов может незначительно меняться. Также `kang` может вместо `FIN_WAIT_2` проходить через состояние `CLOSING`.
Вот так, согласно netstat, выглядит финальное состояние:
Сервер
```
[root@kodos ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.140.8080 10.88.88.139.33226 1049792 0 1049800 0 TIME_WAIT
```
На `kang` для этого соединения нет никаких исходящих данных.
Промежуточные состояния проходят очень быстро, но вы можете отследить их с помощью [DTrace TCP provider](http://dtracebook.com/index.php/Network_Lower_Level_Protocols:tcpstate.d). Поток пакетов можно посмотреть с помощью [snoop(1m)](http://illumos.org/man/snoop) или [tcpdump(1)](http://www.tcpdump.org/tcpdump_man.html).
**Выводы:** Мы увидели нормальный путь прохождения системных вызовов во время установки и закрытия соединения. Обратите внимание, что `kang` незамедлительно обнаружил факт закрытия соединения на `kodos` — он был разбужен из `poll`, а возвращение нуля `read` обозначило завершение потока передачи. В этот момент `kang` *решил* закрыть сокет, что привело к закрытию соединения с `kodos`. Мы вернёмся к этому позже и посмотрим, что будет, если `kang` не станет закрывать сокет в этой ситуации.
Головоломка 1: Перезапуск электропитания
========================================
**Что случится с установленным неактивным TCP подключением при перезапуске питания одной из систем?**
Поскольку в процессе запланированной перезагрузки многие процессы завершаются корректным образом (с использованием команды “reboot”), то результат будет такой же, если ввести в консоль `kodos` команду “reboot” вместо завершения работы сервера с помощью CTRL-C. Но что случится, если в предыдущем примере мы просто отключим электропитание для `kodos`? В конечном итоге `kang` об этом узнает, верно?
Давайте проверим. Устанавливаем подключение:
Сервер
```
[root@kodos ~]# truss -d -t bind,listen,accept,poll,read,write nc -l -p 8080
Base time stamp: 1464312528.4308 [ Fri May 27 01:28:48 UTC 2016 ]
0.0036 bind(3, 0x08065790, 32, SOV_SOCKBSD) = 0
0.0036 listen(3, 1, SOV_DEFAULT) = 0
0.2518 accept(3, 0x08047B3C, 0x08047C3C, SOV_DEFAULT, 0) = 4
pollsys(0x08045680, 2, 0x00000000, 0x00000000) (sleeping...)
```
Клиент
```
[root@kang ~]# truss -d -t open,connect,pollsys,read,write,close nc 10.88.88.140 8080
Base time stamp: 1464312535.7634 [ Fri May 27 01:28:55 UTC 2016 ]
...
0.0055 connect(3, 0x08066DD8, 16, SOV_DEFAULT) = 0
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
```
Для эмуляции перезапуска электропитания я воспользуюсь функцией «reboot» из VMware. Обратите внимание, что это будет настоящий перезапуск — всё, что приводит к постепенному выключению, больше похоже на первый пример.
Спустя 20 минут `kang` всё в том же состоянии:
Клиент
```
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
```
Мы склонны верить, что работа TCP заключается в постоянном поддержании абстракции (а именно, TCP-соединения) между несколькими системами, так что подобные случаи сломанной абстракции выглядят удивительно. И если вы считаете, что это какая-то проблема nc(1), то вы ошибаетесь. «netstat» на `kodos` не показывает никакого соединения с `kang`, но при этом `kang` покажет полностью рабочее подключение к `kodos`:
Клиент
```
[root@kang ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.139.50277 10.88.88.140.8080 32806 0 1049800 0 ESTABLISHED
...
```
Если оставить всё как есть, то `kang` никогда не узнает, что `kodos` был перезагружен.
**Теперь предположим, что `kang` пытается отправить данные `kodos`. Что произойдёт?**
Клиент
```
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
kodos, are you there?
3872.6918 pollsys(0x08045670, 2, 0x00000000, 0x00000000) = 1
3872.6920 read(0, " k o d o s , a r e y".., 1024) = 22
3872.6924 write(3, " k o d o s , a r e y".., 22) = 22
3872.6932 pollsys(0x08045670, 2, 0x00000000, 0x00000000) = 1
3872.6932 read(3, 0x08043670, 1024) Err#131 ECONNRESET
3872.6933 close(3) = 0
[root@kang ~]#
```
Когда я ввожу сообщение и жму Enter, `kodos` просыпается, читает сообщение из stdin и отправляет его через сокет. *Вызов* `write` *успешно завершён*! `nc` возвращается в `poll` в ожидании следующего события, и в конце концов приходит к выводу, что сокет не может быть прочитан без блокировки, после чего вызывает `read`. В этот раз `read` падает со статусом ECONNRESET. Что это значит? [Документация к read(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/read.html) говорит нам:
```
[ECONNRESET]
Была попытка чтения из сокета, то соединение было принудительно закрыто пиром.
```
[Другой источник](http://illumos.org/man/read.2) содержит чуть больше подробностей:
```
ECONNRESET
Аргумент filedes ссылается на сокет с установленным соединением. Оно было принудительно закрыто пиром и больше недействительно. Операции ввода/вывода больше не могут выполняться с filedes.
```
Эта ошибка не означает какую-то конкретную проблему с вызовом `read`. Она лишь говорит о том, что сокет был отключён. По этой причине большинство операций с сокетом приведут к ошибке.
Так что же случилось? В тот момент, когда `nc` на `kang` попытался отправить данные, стек TCP всё ещё не знал, что подключение уже мертво. `kang` отправил пакет данных на `kodos`, который ответил RST, потому что ничего не знал о подключении. `kang` увидел RST и прервал подключение. Файловый дескриптор сокета закрыть невозможно, — файловые дескрипторы работают не так, — но последующие операции будут неудачными со статусом ECONNRESET, пока `nc` не закроет файловый дескриптор.
**Выводы:**
1. Жесткое отключение энергии сильно отличается от аккуратного выключения. При тестировании распределённых систем нужно отдельно проверять и этот сценарий. Не ждите, что всё будет так же, как и при обычной остановке процесса (kill).
2. **Бывают ситуации, когда одна сторона уверена, что TCP-соединение установлено, а другая — не уверена, и эта ситуация никогда не будет решена автоматически.** Управлять решением таких проблем можно с использованием keep-alive для соединений на уровне приложения или TCP.
3. Единственная причина, по которой `kang` всё-таки узнал об исчезновении удалённой стороны, заключается в том, что он отправил данные и получил ответ, сигнализирующий об отсутствии подключения.
Возникает вопрос: а что если `kodos` по какой-то причине не отвечает на отправку данных?
Головоломка 2: Отключение электропитания
========================================
**Что случится, если конечная точка TCP соединения отключится от сети на какое-то время?** Узнают ли об этом остальные узлы? Если да, то как? И когда?
Вновь установим соединение с помощью `nc`:
Сервер
```
[root@kodos ~]# truss -d -t bind,listen,accept,poll,read,write nc -l -p 8080
Base time stamp: 1464385399.1661 [ Fri May 27 21:43:19 UTC 2016 ]
0.0030 bind(3, 0x08065790, 32, SOV_SOCKBSD) = 0
0.0031 listen(3, 1, SOV_DEFAULT) = 0
accept(3, 0x08047B3C, 0x08047C3C, SOV_DEFAULT, 0) (sleeping...)
6.5491 accept(3, 0x08047B3C, 0x08047C3C, SOV_DEFAULT, 0) = 4
pollsys(0x08045680, 2, 0x00000000, 0x00000000) (sleeping...)
```
Клиент
```
[root@kang ~]# truss -d -t open,connect,pollsys,read,write,close nc 10.88.88.140 8080
Base time stamp: 1464330881.0984 [ Fri May 27 06:34:41 UTC 2016 ]
...
0.0057 connect(3, 0x08066DD8, 16, SOV_DEFAULT) = 0
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
```
Теперь внезапно выключим питание `kodos` и попытаемся отправить данные с `kang`:
Клиент
```
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
114.4971 pollsys(0x08045670, 2, 0x00000000, 0x00000000) = 1
114.4974 read(0, "\n", 1024) = 1
114.4975 write(3, "\n", 1) = 1
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
```
Вызов `write` завершается нормально, и я долго ничего не вижу. Только через пять минут появляется:
Клиент
```
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
425.5664 pollsys(0x08045670, 2, 0x00000000, 0x00000000) = 1
425.5665 read(3, 0x08043670, 1024) Err#145 ETIMEDOUT
425.5666 close(3) = 0
```
Эта ситуация очень похожа на ту, когда мы перезапускали электропитание вместо полного отключения. Есть два отличия:
* системе потребовалось 5 минут на осознание ситуации,
* статус ошибки был ETIMEDOUT.
Снова обратите внимание — это истёкший тайм-аут `read`. Мы бы увидели ту же самую ошибку и при других операциях с сокетом. Это происходит потому, что *сокет* входит в состояние, когда истёк тайм-аут подключения. Причина этого в том, что удалённая сторона слишком долго не подтверждала пакет данных — 5 минут, в соответствии с настройками этой системы.
**Выводы:**
1. Когда удалённая система вместо перезапуска электропитания просто выключается, то первая система может узнать об этом, только отправив данные. В ином случае она никогда не узнает об обрыве соединения.
2. Когда система слишком долго пытается отправить данные и не получает ответа, TCP-соединение закрывается и все операции с сокетом будут завершаться с ошибкой ETIMEDOUT.
Головоломка 3: Нарушение соединения без его падения
===================================================
На этот раз вместо того, чтобы описывать вам специфическую ситуацию и спрашивать, что происходит, я поступлю наоборот: опишу некое наблюдение и посмотрю, сможете ли вы понять, как такое произошло. Мы обсуждали несколько ситуаций, в которых `kang` может верить, что он подключён к `kodos`, но `kodos` об этом не знает. **Возможно ли для `kang` быть подключённым к `kodos` так, чтобы `kodos` не знал об этом в течение неопределённого срока (т.е. проблема не решится сама собой), и при этом не было бы отключения или перезапуска электропитания, никакой другой ошибки операционной системы `kodos` или сетевого оборудования?**
Подсказка: рассмотрим вышеописанный случай, когда соединение застряло в статусе ESTABLISHED. Справедливо считать, что ответственность за решение этой проблемы несёт приложение, так как оно держит сокет открытым и может обнаружить посредством отправки данных, когда соединение было прервано. Но что если приложение уже не держит сокет открытым?
В разминке мы рассматривали ситуацию, когда nc на `kodos` закрыло сокет. Мы сказали, что nc на `kang` прочитало 0 (указатель окончания передачи) и закрыло сокет. Допустим, сокет остался открытым. Очевидно, что из него невозможно было бы читать. Но касательно TCP ничего не говорится о том, что вы не можете отправлять дополнительные данные той стороне, которая послала вам FIN. **FIN означает лишь закрытие потока данных в том направлении, по которому был послан FIN.**
Чтобы продемонстрировать это, мы не можем использовать `nc` на `kang`, потому что оно автоматически закрывает сокет после получения 0. Поэтому, я написал демо-версию `nc`, под названием [dnc](https://github.com/davepacheco/experiment-dnc), которая пропускает этот момент. Также [dnc](https://github.com/davepacheco/experiment-dnc) явным образом выводит системные вызовы, которые она совершает. Это даст нам шанс отследить состояния TCP.
Сперва настроим подключение:
Сервер
```
[root@kodos ~]# truss -d -t bind,listen,accept,poll,read,write nc -l -p 8080
Base time stamp: 1464392924.7841 [ Fri May 27 23:48:44 UTC 2016 ]
0.0028 bind(3, 0x08065790, 32, SOV_SOCKBSD) = 0
0.0028 listen(3, 1, SOV_DEFAULT) = 0
accept(3, 0x08047B2C, 0x08047C2C, SOV_DEFAULT, 0) (sleeping...)
1.9356 accept(3, 0x08047B2C, 0x08047C2C, SOV_DEFAULT, 0) = 4
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
```
Клиент
```
[root@kang ~]# dnc 10.88.88.140 8080
2016-05-27T08:40:02Z: establishing connection
2016-05-27T08:40:02Z: connected
2016-05-27T08:40:02Z: entering poll()
```
Теперь убедимся, что на обеих сторонах подключение находится в статусе ESTABLISHED:
Сервер
```
[root@kodos ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.140.8080 10.88.88.139.37259 1049792 0 1049800 0 ESTABLISHED
```
Клиент
```
[root@kang ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.139.37259 10.88.88.140.8080 32806 0 1049800 0 ESTABLISHED
```
На `kodos` применим CTRL-C для процесса `nc`:
Сервер
```
pollsys(0x08045670, 2, 0x00000000, 0x00000000) (sleeping...)
^C[root@kodos ~]#
```
На `kang` сразу увидим следующее:
Клиент
```
2016-05-27T08:40:12Z: poll returned events 0x0/0x1
2016-05-27T08:40:12Z: reading from socket
2016-05-27T08:40:12Z: read end-of-stream from socket
2016-05-27T08:40:12Z: read 0 bytes from socket
2016-05-27T08:40:12Z: entering poll()
```
Теперь посмотрим на статус подключений TCP:
Сервер
```
[root@kodos ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.140.8080 10.88.88.139.37259 1049792 0 1049800 0 FIN_WAIT_2
```
Клиент
```
[root@kang ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.139.37259 10.88.88.140.8080 1049792 0 1049800 0 CLOSE_WAIT
```
Это имеет смысл: kudos отправил FIN на `kang`. `FIN_WAIT_2` показывает, что `kodos` получил ACK от `kang` в ответ на посланный им FIN, а `CLOSE_WAIT` показывает, что `kang` получил FIN, *но не отправил FIN в ответ*. **Это вполне нормальное состояние TCP-подключения, которое может длится бесконечно.** Представьте, что `kodos` отправил запрос `kang` и не планировал отправлять ничего больше; `kang` может часами счастливо отправлять данные в ответ. Только в нашем случае `kodos` *фактически закрыл сокет*.
Давайте подождём минуту и вновь проверим статус TCP-подключений. Выяснилось, что на `kodos` подключение полностью пропадает, но всё ещё существует на `kang`:
Клиент
```
[root@kang ~]# netstat -f inet -P tcp -n
TCP: IPv4
Local Address Remote Address Swind Send-Q Rwind Recv-Q State
–––––––––––––––––––– –––––––––––––––––––– ––––– –––––- ––––– –––––- ––––––––––-
10.88.88.139.37259 10.88.88.140.8080 1049792 0 1049800 0 CLOSE_WAIT
```
Мы столкнулись с менее известной ситуацией, связанной со TCP-стеком: когда приложение закрыло сокет, стек отправил FIN, удалённый стек его распознал FIN, а локальный стек ожидает фиксированный период времени *и закрывает соединение*. Причина? Удалённая сторона была перезагружена. Этот случай аналогичен тому, когда подключение на одной стороне находится в статусе ESTABLISHED, а другая сторона об этом не знает. Разница заключается лишь в том, что приложение закрыло сокет, и нет никакого другого компонента, который мог бы разобраться с проблемой. В результате TCP-стек ждёт установленный период времени и закрывает соединение (ничего не посылая на другую сторону).
Вопрос вдогонку: **что случится, если в этой ситуации `kang` отправит данные к `kodos`?** Не забывайте, `kang` всё ещё считает, что соединение открыто, хотя на стороне `kodos` оно уже завершено.
Клиент
```
2016-05-27T08:40:12Z: entering poll()
kodos, are you there?
2016-05-27T08:41:34Z: poll returned events 0x1/0x0
2016-05-27T08:41:34Z: reading from stdin
2016-05-27T08:41:34Z: writing 22 bytes read from stdin to socket
2016-05-27T08:41:34Z: entering poll()
2016-05-27T08:41:34Z: poll returned events 0x0/0x10
2016-05-27T08:41:34Z: reading from socket
dnc: read: Connection reset by peer
```
Это то же самое, что мы видели в Головоломке 1: `write()` успешно выполняется, так как TCP-стек ещё не знает, что соединение закрыто. Но затем идёт RST, который пробуждает находящийся в `poll()` тред, и последующий запрос `read()` возвращает ECONNRESET.
**Выводы:**
* Возможна ситуация, когда обе стороны не сходятся во мнениях относительно статуса соединения, *хотя при этом не было ошибки операционной системы, сети или железа*.
* В описанном выше случае `kang` не имеет возможности узнать, ожидает ли `kodos` получения данных от `kang`, или же `kodos` закрыл сокет и не прослушивает его (по крайней мере, не без отправки пакета). Поэтому не стоит проектировать систему, которая при нормальных условиях эксплуатации в течение длительного времени будет использовать сокеты в подобных полуоткрытых состояниях.
Заключение
==========
TCP обычно представляется нам как протокол, который поддерживает абстракцию — «TCP-соединение» — между двумя системами. Мы знаем, что из-за некоторых программных или сетевых проблем соединение упадёт. Но не всегда очевидно, что бывают случаи возникновения сбоев самой *абстракции*, из-за чего системы расходятся во мнении по поводу состояния подключения. Например:
* Одна система может считать, что у неё есть рабочее соединение с удаленной системой, которая, в свою очередь, ничего не знает об этом соединении.
* Это может происходить без каких-либо ошибок операционной системы, сети или другого оборудования.
Такое поведение не говорит о недостатках TCP. Наоборот, в подобных случаях TCP ведёт себя наиболее разумно, с учетом ситуации. Если бы мы пытались реализовать свой собственный механизм передачи данных вместо TCP, то подобные случаи напомнили бы нам о том, насколько сложные проблемы могут возникнуть. Это внутренние проблемы, связанные с распределёнными системами, а TCP-подключение по сути является распределённой системой.
Тем не менее, наиболее важный урок, который можно вынести из всего этого, заключается в том, что **понятие «TCP-соединения, охватывающего несколько систем» — это удобная фикция**. Когда что-то идёт не так, очень важно, чтобы две разные машины одновременно пытались согласованное представление о соединении. Приложение начинает решать возникающие проблемы в тех случаях, когда машины действую по-разному (для этого часто используется механизм keep-alive).
Кроме того, дескриптор файла «оторван» от соответствующего TCP-соединения. Соединения существуют (в разных, связанных с закрытием состояниях) даже тогда, когда приложение закрыло дескриптор файла. А иногда дескриптор файла может быть открыт, хотя TCP-соединение было закрыто в результате ошибки.
Остальные уроки, о которых стоит помнить:
* Неаккуратная перезагрузка системы (когда падает операционная система) — это не то же самое, что обычный выход или закрытие процесса. Важно тестировать этот случай отдельно. Перезагрузка, когда удалённая система возвращается в онлайн — это не то же самое, что отключение удалённой машины.
* От ядра не поступает упреждающих сигналов, когда закрывается TCP-сокет. Вы можете узнать об этом, только вызывая `read()`, `write()`, или выполняя другие операции с дескриптором файла сокетом. Если ваша программа по какой-то причине этого не делает, то вы никогда не узнаете об ошибке соединения.
Некоторые малоизвестные моменты:
* ECONNRESET — это ошибка сокета, которую мы можем получить от `read()`, `write()` и других операций. Она означает, что удалённый компьютер послал RST.
* ETIMEDOUT — это ошибка сокета, которую можно получить от `read()`, `write()` и остальных операций. Она означает, что истёк некий таймаут, имеющий отношение к соединению. В большинстве случаев это происходит, когда удалённая сторона слишком долго не признаёт пакет. Обычно это пакеты данных, пакет FIN или сигнал KeepAlive.
Важно отметить, что эти ошибки не означают, будто что-то пошло не так с вашими операциями чтения или записи. Это лишь означает, что закрыт сам сокет. | https://habr.com/ru/post/316128/ | null | ru | null |
# Микроконтроллеры Megawin серии MG32F02: модуль интерфейса I2C
Продолжая цикл публикаций по микроконтроллерам на ядре Cortex-M0 компании Megawin (см. предыдущие статьи [1](https://habr.com/ru/post/674788/), [2](https://habr.com/ru/post/675776/), [3](https://habr.com/ru/post/681702/), [4](https://habr.com/ru/post/684778/), [5](https://habr.com/ru/post/686416/) и [6](https://habr.com/ru/post/690346/)), сегодня рассмотрим модуль интерфейса I2C.
### Функциональные возможности модуля I2C
Микроконтроллеры серии MG32F02 включают один (MG32F02A032) или два (остальные МК) модуля интерфейса I2C. Модули имеют следующие функциональные особенности:
* работа в режиме ведущего (master) или ведомого (slave);
* частота шины до 1 МГц;
* детальная настройка параметров сигнала SCL в режиме ведущего устройства;
* удержание сигнала SCL в состоянии низкого уровня в режиме ведомого устройства;
* схема активной подтяжки для линий SCL и SDA;
* поддержка до двух адресов в режиме ведомого, а также детектирования адреса по маске;
* поддержка адреса общего вызова;
* поддержка режима нескольких ведущих (multi-master);
* детектирование "нештатных" ситуаций на шине (некорректный NACK, переполнение буфера, потеря приоритета);
* низкоуровневый (Byte mode) и высокоуровневый (Buffer mode) режимы работы;
* буфер приема и передачи размером 4 байта;
* поддержка DMA;
* встроенный таймер таймаута, определения таймаута шины SMBus;
* пробуждение модуля из состояния STOP.
Функциональная схема модулей I2C0 и I2C1 приведена на рисунке.
Функциональная схема модуля I2CКаждый модуль I2Cx включает следующие основные узлы:
* схему тактирования,
* схему детектирования состояния пробуждения,
* блок контроля линии SCL,
* блок контроля линии SDA,
* блок управления буфером Buffer Control,
* блок управления режимами Master/Slave,
* блок детектирования ошибок Error Detector,
* таймер таймаута,
* схему управления флагами событий и формирования сигнала прерывания INT\_I2Cx.
### Тактирование
Модуль I2Cx тактируется сигналом CK\_I2Cx, источник которого выбирается в поле `I2Cx_CLK.I2Cx_CK_SEL` из числа следующих:
* сигнал CK\_I2Cx\_PR с выхода подсистемы тактирования МК, который, в свою очередь, определяется битом `CSC_CKS1.CSC_I2Cx_CKS` из сигналов CK\_APB (0) или CK\_AHB (1);
* выходной сигнал таймера TM00\_TRGO.
Сигнал CK\_I2Cx поступает на предделитель частоты Prescaler, на выходе которого формируется сигнал CK\_I2Cx\_PSC. Коэффициент предделителя из непрерывного диапазона 2-16 определяется в 4-битном поле `I2Cx_CLK.I2Cx_CK_PSC` значениями от 1 до 15 соответственно. Далее сигнал поступает на делитель частоты DIV, коэффициент которого задается в поле `I2Cx_CLK.I2Cx_CK_DIV` из ряда 2, 4, 8, ..., 128. На выходе делителя формируется основной тактовый сигнал модуля CK\_I2Cx\_INT. С другого выхода делителя с фиксированным коэффициентом 64 формируется сигнал CK\_I2Cx\_DIV64. Тактовый сигнал таймера таймаута CK\_I2Cx\_TMO в зависимости от значения поля `I2Cx_CLK.I2Cx_TMO_CKS` может формироваться из сигнала CK\_I2Cx\_DIV64 или общесистемного сигнала CK\_UT.
Частота внутреннего сигнала тактирования модуля CK\_I2Cx\_INT определяется выражением
FINT = F(CK\_I2Cx\_INT) = F(CK\_I2Cx) / [ (PSC + 1)·DIV ],
где F(CK\_I2Cx) частота сигнала CK\_I2Cx, PSC — значение поля `I2Cx_CLK.I2Cx_CK_PSC`, DIV — значение поля `I2Cx_CLK.I2Cx_CK_DIV`.
На следующем рисунке показана временная диаграмма сигналов SCL и SDA.
Временная диаграмма сигналов SCL и SDAВ модуле имеется возможность настраивать интервалы tHIGH и tLOW через поля `I2Cx_HT` и `I2Cx_LT` регистра `I2Cx_CR1` соответственно. Длительности состояния высокого уровня tHIGH и состояния низкого уровня tLOW сигнала SCL определяются выражениями
tHIGH = (1 + HT)·TINT,
tLOW = (1 + LT)·TINT,
где HT и LT — значения полей `I2Cx_HT` и `I2Cx_LT` соответственно, а TINT = 1 / FINT — период сигнала CK\_I2Cx\_INT.
В режиме мастера интервал tVD:DAT между задним фронтом сигнала SCL и моментом изменения состояния сигнала SDA составляет 2·TINT. Далее интервал до переднего фронта сигнала SCL составляет (LT-1)·TINT. Период сигнала SCL, формируемого мастером, будет определяться выражением
TSCL = tHIGH + tLOW = (2 + HT + LT)·TINT.
Итоговая номинальная частота шины I2C будет определяться выражением
FSCL = 1 / TSCL = FINT / (2 + HT + LT) = F(CK\_I2Cx) / [ (PSC + 1)·DIV·(2 + HT + LT) ].
Параметры HT и LT имеют значения по-умолчанию 5 и 4 соответственно. Минимальными "рабочими" значениями параметров являются 2 и 2.
### Режимы работы
#### Общие сведения
Модуль I2Cx включается установкой бита `I2Cx_CR0.I2Cx_EN`. С точки зрения *логики взаимодействия аппаратуры и программы* в модулях I2Cx реализованы три основных режима работы:
* I2C Byte mode — низкоуровневый (программно-аппаратный) режим с необходимостью реализации программного контроля приема и передачи на основе конечного автомата,
* I2C Buffer mode — высокоуровневый (аппаратный режим),
* Monitor (Buffer mode) — режим мониторинга (сниффер шины).
В первых двух режимах (I2C) модуль может играть роль ведущего (Master) или ведомого (Slave) устройства на шине I2C. Режим работы определяется битами `I2Cx_MDS` и `I2Cx_BUF_EN` регистра `I2Cx_CR0` согласно следующей таблице:
| `I2Cx_MDS` | `I2Cx_BUF_EN` | Режим работы |
| --- | --- | --- |
| 0 (I2C) | 0 (Disable) | I2C Byte mode (по-умолчанию) |
| 0 (I2C) | 1 (Enable) | I2C Buffer mode |
| 1 (Monitor) | 0 (Disable) | --- |
| 1 (Monitor) | 1 (Enable) | Monitor |
При дальнейшем рассмотрении работы модуля будем исходить из того, что читатель знаком с общим принципом функционирования шины I2C. Для изучения этого вопроса можно обратиться к официальной спецификации и ее переводу на русский язык:
* [The I2C-bus specification](https://www.nxp.com/docs/en/application-note/AN10216.pdf)
* [Шина I2C и как её использовать (включая спецификацию)](http://www.gaw.ru/html.cgi/txt/interface/iic/start.htm)
Далее будем использовать следующие обозначения:
| Обозначение | Описание |
| --- | --- |
| START | Состояние шины "Старт" (Start) |
| STOP | Состояние шины "Стоп" (Stop) |
| RSTART | Состояние шины "Повторный старт" (Repeated Start) |
| SLA | Адресный кадр, с которого начинается обмен данными (Slave Address) |
| SLA+W | Адресный кадр, в котором указывается, что ведущий далее будет передавать данные (SLA + Write) |
| SLA+R | Адресный кадр, в котором указывается, что ведущий далее будет принимать данные (SLA + Read) |
| ACK | Состояние шины "Подтверждено" (Acknowledgment) |
| NACK | Состояние шины "Не подтверждено" (No Acknowledgment) |
#### Адресация
С точки зрения *роли устройства* на шине I2C в модулях I2Cx реализованы режимы "ведущее устройство" (Master) и "ведомое устройство" (Slave). По-умолчанию включен *режим ведущего* устройства. Режим ведомого включается при разрешении детектирования адреса.
В режиме ведомого устройства могут быть заданы один или два собственных адреса, на которые будет отвечать модуль. Основной адрес ведомого задается в регистре `I2Cx_SADR` в битах 1-7, т.е. если записывать байт, то бит 0 можно оставить равным 0. Дополнительный адрес задается в битах 9-15 аналогично. Детектирование основного адреса разрешается установкой бита `I2Cx_SADR_EN`, а дополнительного — установкой бита `I2Cx_SADR2_EN` в регистре `I2Cx_CR0`. Установка хотя бы одного из этих битов переводит модуль в *режим ведомого* устройства. В режиме пониженного энергопотребления STOP, если один из этих битов установлен, при детектировании на шине кадра обращения к устройству модуль активирует флаг пробуждения **WUPF**.
Для *основного адреса* также можно задействовать маску `I2Cx_MASK.I2Cx_SA_MSK` (биты 1-7 регистра), расширяющую диапазон адресов, на которые будет отвечать модуль: в адресе будут проверяться только те разряды, которые установлены в 1 в маске. По-умолчанию, в маске установлено значение 0x7F, т.е. строгое соответствие заданному в поле `I2Cx_SADR` адресу. Кроме того, модуль будет отвечать на нулевой адрес (общий вызов), если установлен бит `I2Cx_CR0.I2Cx_GC_EN` (по-умолчанию сброшен).
#### Буфер данных
В модуле I2Cx программно доступен 8-разрядный сдвиговый регистр `I2Cx_SBUF`, выполняющий функцию буфера данных нижнего уровня. Программа же обычно взаимодействует с 32-разрядным регистром `I2Cx_DAT`, выполняющим функцию буфера верхнего уровня с возможностью 8-, 16- и 32-битного доступа. Буфер тесно связан с полем `I2Cx_CR2.I2Cx_BUF_CNT`, в котором в режиме Buffer mode задается фактическое число (1-4) принимаемых или передаваемых байт (в режиме Master) или сохраняется число уже принятых байт (в режиме Slave). Последовательность байт при приеме или передаче — от младшего к старшему.
В режиме Buffer mode при передаче данных разрядность операции записи в регистр `I2Cx_DAT` должна соответствовать объему передаваемых данных: для записи одного байта нужно использовать байтовую пересылку (`STRB`) в младший байт регистра, для двух байт — двухбайтовую (`STRH`), для 3-4 байт — пересылку слова (`STR`).
#### Команды управления состоянием
Для управления состоянием шины I2C в регистре `I2Cx_CR2` имеются биты, установка которых приводит к генерации нового состояния непосредственно в момент их установки или по завершению текущей операции приема или передачи данных. Биты команд приведены в следующей таблице.
| Разряд `I2Cx_CR2` | Название | Описание |
| --- | --- | --- |
| 0 | `I2Cx_STA` | Генерация состояния START |
| 1 | `I2Cx_STO` | Генерация состояния STOP |
| 2 | `I2Cx_AA` | Генерация состояния ACK |
| 3 | `I2Cx_CMD_TC` | Разрешение генерации состояний при установке битов PSTA, PSTO, PAA |
| 4 | `I2Cx_STA_LCK` | Разблокировка записи в разряды `I2Cx_STA` и `I2Cx_PSTA` |
| 5 | `I2Cx_STO_LCK` | Разблокировка записи в разряды `I2Cx_STO` и `I2Cx_PSTO` |
| 6 | `I2Cx_AA_LCK` | Разблокировка записи в разряды `I2Cx_AA` и `I2Cx_PAA` |
| 24 | `I2Cx_PSTA` | Генерация состояния START после завершения текущей операции |
| 25 | `I2Cx_PSTO` | Генерация состояния STOP после завершения текущей операции |
| 26 | `I2Cx_PAA` | Генерация состояния ACK после завершения текущей операции |
*Команда STA* (START) формируется при установке бита `I2Cx_STA` вместе с битом разблокировки `I2Cx_STA_LCK` и приводит в режиме Master к генерации состояния START, если шина была свободна. Если шина была занята, ожидается состояние STOP на шине, после чего генерируется состояние START. Если модуль уже находится в режиме ведущего после предыдущей команды STA в процессе приема или передачи, генерируется состояние RSTART.
*Команда STO* (STOP) формируется при установке бита `I2Cx_STO` вместе с битом разблокировки `I2Cx_STO_LCK` и приводит в режиме Master к генерации состояния STOP. Если одновременно с командой STO дается команда STA, то после генерации состояния STOP генерируется состояние START. В режиме Slave команда STO может использоваться для выхода из состояния какой-либо ошибки на шине.
*Команда AA* (ACK) формируется при установке бита `I2Cx_AA` вместе с битом разблокировки `I2Cx_AA_LCK` и приводит к генерации состояния ACK (низкий уровень сигнала SDA в течение передачи 9-го импульса сигнала SCL в текущем кадре) в следующих случаях:
* подтверждение адреса при совпадении в кадре SLA в режиме ведомого устройства,
* подтверждение принятия байта в режиме приема ведущим устройством,
* подтверждение принятия байта в режиме приема ведомым устройством.
Если устанавливается бит `I2Cx_AA_LCK` при *сброшенном* бите `I2Cx_AA`, генерируется состояние NACK (остается высокий уровень сигнала SDA в течение передачи 9-го импульса сигнала SCL в текущем кадре) в следующих случаях:
* принят байт в режиме приема ведущим устройством,
* принят байт в режиме приема ведомым устройством.
Команды STO и AA предназначены для применения, в первую очередь, в *программно-аппаратном режиме* (Byte mode). В *аппаратном режиме* (Buffer mode) большинство действий выполняется автоматически и в программе лишь требуется заранее установить поведение модуля с помощью команд PSTA, PSTO и PAA. Для их выполнения также *должен быть установлен бит* `I2Cx_CMD_TC`.
*Команда PSTA* формируется при установке бита `I2Cx_PSTA` вместе с битом `I2Cx_STA_LCK` и приводит в режиме Master к генерации состояния RSTART после завершения запланированной операции приема или передачи данных.
*Команда PSTO* формируется при установке бита `I2Cx_PSTO` вместе с битом `I2Cx_STO_LCK` и приводит в режиме Master к генерации состояния STOP после завершения запланированной операции приема или передачи данных.
*Команда PAA* формируется при установке бита `I2Cx_PAA` вместе с битом `I2Cx_STO_LCK` и приводит к формирования состояния подтверждения после завершения запланированной операции приема или передачи данных. Если бит `I2Cx_PAA` сброшен, а бит `I2Cx_STO_LCK` установлен, после завершения операции подтверждение генерироваться не будет.
### Программно-аппаратный режим (Byte mode)
В программно-аппаратном режиме Byte mode передача и прием каждого кадра шины I2C разбивается на несколько *этапов*, характеризующихся тем или иным состоянием шины и модуля. Завершение каждого этапа и переход в новое состояние представляет собой *событие*. Программа должна реагировать на каждое новое событие: формировать команды, считывать или записывать данные. Все возможные состояния пронумерованы и представлены в таблице. Отметим, что разработчики МК серии MG32F02 взяли схему кодирования состояний модуля I2C, применяемую в 8-разрядных МК на ядре C8051 (например, NXP, Silicon Labs) и МК серии ATmega.
| Код | Описание | MT | MR | SR | ST |
| --- | --- | --- | --- | --- | --- |
| 0x00 | Ошибка шины | v | v | v | v |
| 0x08 | Сформировано состояние START | v | v | | |
| 0x10 | Сформировано состояние RSTART | v | v | | |
| 0x18 | Передан кадр SLA+W и получено подтверждение (ACK) | v | | | |
| 0x20 | Передан кадр SLA+W, подтверждение не получено (NACK) | v | | | |
| 0x28 | Передан байт с данными и получено подтверждение (ACK) | v | | | |
| 0x30 | Передан байт с данными, подтверждение не получено (NACK) | v | | | |
| 0x38 | Потеря приоритета при передаче кадра SLA+R/W или данных | v | v | | |
| 0x40 | Передан кадр SLA+R и получено подтверждение (ACK) | | v | | |
| 0x48 | Передан кадр SLA+R, подтверждение не получено (NACK) | | v | | |
| 0x50 | Принят байт с данными и сформировано состояние ACK | | v | | |
| 0x58 | Принят байт с данными и сформировано состояние NACK | | v | | |
| 0x60 | Принят кадр SLA+W с собственным адресом и сформировано состояние ACK | | | v | |
| 0x68 | Принят кадр SLA+W с собственным адресом, потерян приоритет, сформировано состояние ACK | | | v | |
| 0x70 | Принят общий вызов и сформировано состояние ACK | | | v | |
| 0x78 | Принят общий вызов, потерян приоритет, сформировано состояние ACK | | | v | |
| 0x80 | Устройство уже адресовано, принят байт с данными и сформировано состояние ACK | | | v | |
| 0x88 | Устройство уже адресовано, принят байт с данными и сформировано состояние NACK | | | v | |
| 0x90 | Общий вызов, принят байт с данными и сформировано состояние ACK | | | v | |
| 0x98 | Общий вызов, принят байт с данными и сформировано состояние NACK | | | v | |
| 0xA0 | Устройство адресовано, обнаружено состояние START или RSTART | | | v | |
| 0xA8 | Принят кадр SLA+R с собственным адресом и сформировано состояние ACK | | | | v |
| 0xB0 | Принят кадр SLA+R с собственным адресом, потерян приоритет, сформировано состояние ACK | | | | v |
| 0xB8 | Передан байт с данными и получено подтверждение (ACK) | | | | v |
| 0xC0 | Передан байт с данными, подтверждение не получено (NACK) | | | | v |
| 0xC8 | Передан последний байт с данными и получено подтверждение (ACK) | | | | v |
| 0xF8 | Состояние шины STOP или шина свободна | v | v | v | v |
В колонках MT, MR, SR и ST указана применимость состояния в режимах "ведущий передает", "ведущий принимает", "ведомый принимает" и "ведомый передает" соответственно. Код последнего события (состояния) всегда отображается в поле `I2Cx_STA2.I2Cx_EVENT`, а появление нового события приводит к установке флага **EVENTF** и возможному прерыванию. В приеме и передаче данных в этом режиме используется только однобайтный буфер `I2Cx_SBUF`. Для формирования состояний на шине применяются вышеописанные команды STA, STO и AA.
В документации User Guide приводятся подробные блок-схемы алгоритмов работы модуля и таблицы переходов между состояниями для режимов: "ведущий передает", "ведущий принимает", "ведомый передает", "ведомый принимает" и "ведомый принимает общий вызов". Оптимальной является реализация рассматриваемых алгоритмов на основе прерываний и конечного автомата.
### Аппаратный режим (Buffer mode)
#### Общие сведения
Аппаратный режим (Buffer mode) позволяет максимально автоматизировать работу с модулем I2C и свести к минимуму программный код. Регистр `I2Cx_DAT` выполняет в этом режиме функцию 4-байтного буфера, а синхронизация действий с программой достигается с помощью основных флагов **RXF** и **TXF**. В данном режиме при приеме и передаче данных используется также 32-разрядный промежуточный буфер (Shadow Buffer). С буфером связан счетчик `I2Cx_ACNT`, который увеличивается на 1 в следующих случаях:
* в режиме приема данных — при передаче каждого байта из сдвигового регистра Shift Buffer в промежуточный буфер,
* в режиме передачи данных — при передаче каждого байта из промежуточного буфера в сдвиговый регистр.
#### Ведущее устройство (Master)
На следующем рисунке показан алгоритм работы модуля в данном режиме.
Алгоритм работы модуля I2C в режиме Buffer mode - MasterВедущее устройство начинает работу с формирования на шине адресного кадра SLA. Для этого дается команда STA с одновременным указанием в поле `I2Cx_CR2.I2Cx_BUF_CNT` числа передаваемых байт N от 1 до 4. Далее в регистр `I2Cx_DAT` записываются передаваемые данные. *Первым по порядку байтом должен быть адрес* ведомого устройства, к которому происходит обращение, сдвинутый на 1 разряд влево. Если младший бит байта сброшен, формируется кадр SLA+W, если установлен — кадр SLA+R. Если было указано N>1, то в случае ответа ведомого состоянием ACK в кадре SLA+W ведущий продолжает передачу данных в этом же кадре. В любом случае данные передаются только если было получено подтверждение на предыдущий байт. По завершению передачи устанавливается флаг **TXF**.
При указании в поле `I2Cx_BUF_CNT` числа передаваемых байт нужно одновременно сформировать команду PSTO или PSTA, чтобы по завершению передачи модуль сгенерировал состояние STOP или RSTART соответственно.
Если был сформирован кадр SLA+R, после подтверждения адреса со стороны ведомого устройства модуль переходит в режим приема данных. В поле `I2Cx_BUF_CNT` нужно указать число принимаемых байт N от 1 до 4. После передачи N байт из промежуточного буфера в регистр `I2Cx_DAT` активируется флаг **RXF**.
В завершающей операции приема данных следует также сформировать команду PSTO или PSTA. В этом случае после получения *последнего* байта модуль генерирует состояние NACK, сигнализируя тем самым ведомому устройству о завершении операции. Прием всех *предыдущих* байтов модулем подтверждается автоматически. Если требуется подтвердить и последний байт, вместе с командой PSTO (или PSTA) необходимо также дать команду PAA.
Если в программе перед приемом данных требуется сбросить флаг **RXF**, то необходимо выполнить "фиктивное" чтение регистра `I2Cx_DAT`, а не сбрасывать флаг явно записью 1 в регистр `I2Cx_STA`, что может привести к приему лишних данных.
Для ведущего устройства можно рекомендовать следующий *алгоритм отправки данных*:
1. Дать команду `STA` с одновременной записью 1 в поле `I2Cx_CR2.I2Cx_BUF_CNT`.
2. В регистр `I2Cx_DAT` записать адрес ведомого устройства, сдвинутый на 1 разряд влево. Младший бит адреса должен быть *нулевым*. Таким образом будет сформировано состояние SLA+W.
3. Ожидать установку флага **TXF**, т.е. готовность буфера принять новые данные.
4. В поле `I2Cx_CR2.I2Cx_BUF_CNT` указать число отправляемых байт (1-4), а также опционально установить бит `I2Cx_PSTO` или `I2Cx_PSTA` (вместе с битом `I2Cx_CMD_TC`), если после отправки требуется *автоматически* сгенерировать состояние STOP или RSTART соответственно.
5. Записать новые данные в регистр `I2Cx_DAT` (после чего начинается фактическая отправка).
6. Если требуется дальнейшая передача данных (более 4-х байт), повторить пункты 3-5.
7. При *"ручном" методе генерации* состояния STOP ожидать активацию флага **TSCF** (фактическое завершение передачи) и только после этого дать команду `STO`.
8. При *автоматической генерации* состояния STOP перед отправкой следующего кадра (очередной команды `STA`) необходимо ожидать активацию флага **STOPF**.
Кроме того, возможно потребуется программный сброс флага **TXF** перед пунктом 4 в случае отправки нескольких кадров с данными.
Для ведущего устройства можно рекомендовать следующий *алгоритм приема данных*:
1. Дать команду `STA` с одновременной записью 1 в поле `I2Cx_CR2.I2Cx_BUF_CNT`.
2. В регистр `I2Cx_DAT` записать адрес ведомого устройства, сдвинутый на 1 разряд влево. Младший бит адреса должен быть *установлен*. Таким образом будет сформировано состояние SLA+R.
3. Ожидать установку флага **SADRF**, т.е. завершение формирования состояния SLA+R.
4. В поле `I2Cx_CR2.I2Cx_BUF_CNT` указать число ожидаемых байт (1-4), а также опционально установить бит `I2Cx_PAA` и(или) `I2Cx_PSTO` (вместе с битом `I2Cx_CMD_TC`), если после приема последнего байта требуется *автоматически* сгенерировать подтверждение и(или) состояние STOP соответственно.
5. Ожидать установку флага **RXF**, т.е. готовность данных в буфере.
6. Прочитать данные из регистра `I2Cx_DAT`.
7. Если требуется дальнейший прием данных (более 4-х байт), повторить пункты 4-6.
8. При *"ручном" методе генерации* состояния STOP дать команду `STO`.
9. При *автоматической генерации* состояния STOP перед отправкой следующего кадра (очередной команды `STA`) необходимо ожидать активацию флага **STOPF**.
#### Ведомое устройство (Slave)
Модуль переходит в режим ведомого устройства (slave) после установки одного из битов включения механизма детектирования адреса `I2Cx_SADR_EN` или `I2Cx_SADR2_EN`. Алгоритм работы модуля показан на следующем рисунке.
Алгоритм работы модуля I2C в режиме Buffer mode - SlaveПри получении кадра SLA+R с подходящим адресом модуль подтверждает кадр и активирует флаг **SADRF**. Далее происходит передача данных из буфера `I2Cx_DAT` (режим Slave Transmitter) в промежуточный буфер. Счетчик в поле `I2Cx_CR2.I2Cx_ACNT` отображает число фактически отправленных байт из промежуточного буфера в сдвиговый регистр.
Если число N, указанное в поле `I2Cx_CR2.I2Cx_BUF_CNT`, было в интервале от 1 до 4, после передачи N байт в промежуточный буфер на отправку активируется флаг **TXF**. В этот момент в программе в регистр `I2Cx_DAT` нужно записать новые данные. После записи в регистр `I2Cx_DAT` счетчик `I2Cx_ACNT` *обнуляется*. Если новые данные не были записаны, будут отправляться существующие данные последовательно с нулевого по (N-1)-й байт. Данные в принципе будут передаваться на шину пока ведущее устройство генерирует тактовые импульсы сигнала SCL не зависимо от значения `I2Cx_BUF_CNT` до тех пор, пока на шине не будет cгенерировано состояние STOP или RSTART. Если значения `I2Cx_BUF_CNT` равно 0, флаг **TXF** сработает после отправки 8-го байта, при этом соответствия отправляемых данных каким-либо байтам буфера не гарантируется.
После получения и подтверждения кадра SLA+W также активируется флаг **SADRF** и затем начинается процесс приема данных. Каждый принятый байт из сдвигового регистра помещается в промежуточный буфер. Четырехбайтный промежуточный буфер заполняется начиная с младшего байта. Количество байт, записанных в этот буфер, доступно в поле `I2Cx_CR2.I2Cx_ACNT`. После записи 4-го байта или при определении на шине состояния STOP или RSTART выполняются следующие действия:
* принятые данные копируются в регистр `I2Cx_DAT`,
* число принятых байт записывается в поле `I2Cx_CR2.I2Cx_BUF_CNT`,
* значение поля `I2Cx_CR2.I2Cx_ACNT` *обнуляется*,
* активируется флаг **RXF**, после чего в программе можно прочитать и проанализировать данные.
Для ведомого устройства можно рекомендовать следующий *алгоритм работы*:
1. Установить адрес или адреса (при необходимости, и маску) ведомого устройства и переключиться в режим slave.
2. *Опционально:* ожидать срабатывание флага **SADRF** (очевидно, после получения кадра SLA+W с командой) для детектирования факта обращения к устройству и подготовки к выполнению запроса.
3. Ожидать срабатывание флага **RXF**, после чего прочитать данные из регистра `I2Cx_DAT`, количество принятых байт взять из поля `I2Cx_CR2.I2Cx_BUF_CNT`.
4. Проанализировать данные. Если требуется дальнейший прием данных, перейти на предыдущий пункт.
5. Если согласно полученному запросу требуется отправить данные в ответ, количество байт указать в поле `I2Cx_CR2.I2Cx_BUF_CNT`, затем поместить их в регистр `I2Cx_DAT`. Это нужно сделать *не дожидаясь* активации флага **SADRF** в следующем кадре SLA+R.
6. Если требуется дальнейшая отправка данных, ожидать срабатывание флага **TXF** и перейти на предыдущий пункт.
7. *Опционально:* ожидать срабатывание флагов **STOPF** или **RSTRF**.
### Дополнительные функции
#### Управление линией SCL для Slave
В режиме Buffer mode в процессе обработки запросов ведомому может потребоваться дополнительное время на формирование ответа, например, на получение данных, которые затребовал ведущий. В этом случае согласно спецификации интерфейса I2C ведомое устройство может задержать тактирование от ведущего путем удержания линии SCL в состоянии низкого уровня. Функция удержания линии SCL по-умолчанию *включена* и работает в следующих случая:
* *в режиме приема* буфер уже заполнен, но программа еще не прочитала из него данные;
* *в режиме передачи* буфер уже опустошен, но программа еще не записала в него новые данные.
Для *выключения* данной функции нужно *установить* бит `I2Cx_CR0.I2Cx_SCLS_DIS`.
#### Таймер таймаута
В состав модулей I2Cx входит 8-разрядный таймер таймаута TMO. Таймер тактируется сигналом CK\_I2Cx\_TMO (см. п. Тактирование). На рисунке показана функциональная схема таймера.
Таймер таймаута модуля I2CВ зависимости от значения поля `I2Cx_TMOUT.I2Cx_TMO_MDS` таймер работает в следующих режимах:
* 0 — ожидание низкого уровня на линии SCL (по-умолчанию),
* 1 — ожидание высокого уровня на линиях SCL и SDA,
* 2 — таймер общего назначения.
Для включения таймера необходимо установить бит `I2Cx_TMOUT.I2Cx_TMO_EN`. Для применения таймера в режиме общего назначения необязательно включать модуль I2Cx. Период счета таймера задается в поле `I2Cx_TMOUT.I2Cx_TMO_CNT`. После завершения полного периода (переполнения) активируется флаг **TMOUTF**. Если установлен бит `I2Cx_TMOUT.I2Cx_TMO_CTL`, то при этом происходит сброс всего модуля I2Cx. После срабатывания таймера TMO с настройкой на сброс перед началом каких-либо следующих действий необходимо сбросить флаг **TMOUTF**, иначе модуль не сможет корректно работать. Автоматический сброс модуля I2Cx при установленном бите `I2Cx_TMOUT.I2Cx_TMO_CTL` *не приводит* к сбросу этого флага.
### События и прерывания
Схема формирования общих (вторичных) флагов событий **BUFF**, **STPSTRF** и **ERRF**, генерирующих прерывание модуля INT\_I2Cx, приведена на следующем рисунке.
Схема формирования флагов событий модуля I2CФлаги событий собраны в регистре `I2Cx_STA`, а биты разрешения прерываний — в регистре `I2Cx_INT`. Перечень событий и соответствующих флагов прерываний приведен в следующей таблице.
| Разряд `I2Cx_STA` | Флаг события | Бит прерывания | Название события | Описание |
| --- | --- | --- | --- | --- |
| 0 | BUSYF | - | I2C control busy | Модуль занят выполнением операции |
| 1 | EVENTF | EVENT\_IE | Event code change | Изменилось состояние модуля |
| 2 | BUFF | BUF\_IE | Buffer mode event | Общий флаг событий в буфере |
| 3 | ERRF | ERR\_IE | Error detect | Общий флаг ошибок |
| 4 | TMOUTF | TMOUT\_IE | Timeout detect | Сработал таймер таймаута |
| 5 | WUPF | WUP\_IE | STOP mode wakeup by I2C event | Событие пробуждения в режиме питания STOP при получении адресного кадра в режиме Slave |
| 6 | RXF | BUF\_IE | Receive data register not empty | Принятые данные готовы к чтению (Buffer mode) |
| 7 | TXF | BUF\_IE | Transmit data register empty | Буфер передачи готов к записи новых данных (Buffer mode) |
| 8 | RSTRF | BUF\_IE | Repeat Start asserted | Обнаружено состояние шины RSTART |
| 9 | STOPF | BUF\_IE | Stop detection | Обнаружено состояние шины STOP |
| 10 | CNTF | - | BUF\_CNT register empty | Счетчик BUF\_CNT в значении 0 |
| 11 | ERRCF | - | I2C error | Не принято подтверждение в режиме Master в кадре SLA или при передаче данных |
| 12 | SADRF | BUF\_IE | Slave address asserted or match detect | В режиме Slave — получен кадр SLA с подходящим адресом, в режиме Master — ведомый подтвердил адрес в кадре SLA+R |
| 13 | SLAF | - | Slave mode detect | Включен режим ведомого |
| 14 | MSTF | - | Master mode detection | Включен режим ведущего |
| 15 | RWF | - | Read or write transfer direction | Состояние 8-го бита в кадре SLA: 0 - кадр SLA+W, 1 - кадр SLA+R |
| 16 | TSCF | - | Shadow Buffer Transfer complete | В режиме передачи байт из промежуточного буфера скопирован в сдвиговый регистр, в режиме приема — из сдвигового регистра в промежуточный буфер |
| 17 | STPSTRF | STPSTR\_IE | STOP or START detect | Обнаружено состояние STOP или START |
| 18 | TXRF | - | Slave mode transmit data register remained status | Флаг активен, если при отправке из-за ошибки в буфере остались непереданные данные |
| 19 | ROVRF | ERR\_IE | Data buffer RX overrun | Переполнение буфера приема (Buffer mode, задержка SCL отключена) |
| 20 | TOVRF | ERR\_IE | Data buffer TX Overrun | Буфер передачи не содержит данных (Buffer mode, задержка SCL отключена) |
| 21 | NACKF | ERR\_IE | Invalid NoACK received Error | Обнаружено состояние шины NACK |
| 22 | ALOSF | ERR\_IE | Arbitration lost error | Потеря приоритета |
| 23 | BERRF | ERR\_IE | Bus error | Ошибка шины |
В режиме Byte mode для работы ПО необходимо включить прерывание EVENT\_IE по флагу **EVENTF**. В режиме Buffer mode для работы ПО достаточно включить прерывание BUF\_IE по флагу **BUFF**. Если требуется анализ ошибок, необходимо также включить прерывание ERR\_IE по общему флагу **ERRF**. Прерывание TMOUT\_IE генерируется только при включении в работу модуля таймера таймаута TMO.
В процессе тестирования обнаружена *недокументированная функция*: в старшем байте регистра `I2Cx_STA` отображается код состояния модуля `I2Cx_EVENT`, в том числе, в режиме Buffer mode.
Для включения генерации прерывания необходимо:
1. Выбрать событие (или события) в регистре `I2Cx_INT`.
2. Разрешить прерывание самого модуля установкой бита `I2Cx_INT.I2Cx_IEA`.
3. Разрешить прерывание IRQ от модуля в контроллере прерываний NVIC в регистре `CPU_ISER`.
### Тестирование
#### Аппаратная часть
Целью тестирования является проверка работы МК в роли ведущего и ведомого устройства шины I2C. В роли ведущего будет применяться МК MG32F02A064AD48, в роли ведомого — (1) "эталонный" Slave — часы реального времени DS3231 и (2) МК MG32F02A032AT20. Схема подключения микроконтроллеров показана на следующем рисунке.
Схема подключения МК для тестирования модулей I2CВсе устройства запитываются от стабилизатора напряжением 3.3 В программатора J-Link/ST-Link. Для удобства переключения линий SWD-интерфейса между МК установлен переключатель S1. Для линий интерфейса I2C SCL и SDA установлены внешние резисторы подтяжки R3 и R4. При подключении модуля DS3231 МК U2 отключается от шины I2C перемычками (на схеме не показаны), а при работе U2 в качестве ведомого — отключается модуль DS3231, поскольку МК эмулирует его работу. Каждый МК также подключается к ПК через интерфейс UART (в обоих случаях используется модуль МК URT0).
#### Проектные файлы
В тестировании принимают участие одновременно два "подопытных" МК, поэтому в файлах конфигурации проекта есть изменения. Действия по настройке путей к библиотечным файлам от вендора перенесены в отдельную функцию `setup_paths()` в файле `premake5.lua`, поскольку пути зависят от типа МК. Для МК MG32F02A032 аргументом функции нужно указать строку `"MG32F02A032"`, для всех остальных МК семейства — строку `"MG32F02A128"`. В файле определены следующие цели сборки:
* `svr32` — базовая часть (supervisor) для МК MG32F02A032,
* `svr64` — базовая часть для МК MG32F02A064,
* `app` — прикладная часть (application) для ведущего устройства (MG32F02A064),
* `slave` — прикладная часть для ведомого устройства (MG32F02A032),
* `clock` — прикладная часть для создания часов на базе LED-дисплея на м/с TM1637 (MG32F02A064), в статье не рассматривается.
В каталог проекта также добавлены соответствующие скрипты shell для сборки, запуска и просмотра листинга дизассемблера. Библиотечные файлы драйверов внешних микросхем, подключаемых далее к МК, выделены в отдельный подкаталог `ic`.
Параметры и действия, связанные с конфигурацией выводов МК, вынесены в отдельный заголовочный файл `hwcf.h`. На данный момент заданы два набора параметров. В качестве примера приводим набор для MG32F02A032:
```
#ifdef HWCF_A032
#define HW_CLK_AHB 12000000 // MHz
#define HW_LED1_CRH0 PB_CR2_h0 // control register
#define HW_LED1_SCH0 PB_SC_h0 // set-clear register
#define HW_LED1_MASK (1 << 2) // bit mask
#define HW_LED2_CRH0 PB_CR3_h0 // control register
#define HW_LED2_SCH0 PB_SC_h0 // set-clear register
#define HW_LED2_MASK (1 << 3) // bit mask
// Настройка выводов URT0:
#define HW_URT0_SETTX RH(PC_CR0_h0) = (0xA << 12) | 2
#define HW_URT0_SETRX RH(PC_CR1_h0) = (0xA << 12) | (1 << 5) | 3
// Настройка выводов I2C0:
#define HW_I2C0_SETSCL RH(PB_CR10_h0) = (2 << 12) | (1 << 5) | 1
#define HW_I2C0_SETSDA RH(PB_CR11_h0) = (2 << 12) | (1 << 5) | 1
#endif // HWCF_A032
```
Настройки выводов светодиодов сделаны через константы. Настройки выводов интерфейсов UART и I2C заданы в виде полной операции конфигурации портов.
Напомню, что весь исходный код и сопутствующие файлы доступны в [репозитории GitHub](https://github.com/reug/mg32f02.git).
#### Библиотека для работы с модулем I2C
#### Общие функции
Для удобства тестирования разработана библиотека модуля I2C с минимальным набором функций (файлы `src/i2c.h` и `src/i2c.c`). Библиотека поддерживает только *аппаратный режим* Buffer mode. Каждая функция получает первым аргументом идентификатор конкретного модуля I2Cx в виде базового адреса его регистров:
```
#define I2C0_id I2C0_Base
#define I2C1_id I2C1_Base
```
Такой подход оказался очень эффективным, поскольку "заставил" компилятор gcc применять инструкции обращения к памяти с указанием константного смещения вида `str r1, [r0, #16]` (здесь `r0` — первый аргумент, который содержит базовый адрес), вместо того, чтобы для каждого обращения к регистру выделять в секции кода еще 4 байта для его адреса.
Работа с модулем начинается с функции инициализации `i2c_init()`:
```
/// Инициализация модуля I2C (включение тактирования)
void i2c_init(uint32_t id) {
RH(CSC_KEY_h0) = 0xA217; // unlock access to CSC regs
#ifdef MG32F02A032
RB(CSC_APB0_b1) |= CSC_APB0_I2C0_EN_enable_b1;
#endif
#ifdef MG32F02A128
RB(CSC_APB0_b1) |= (id & 0x00010000) ? CSC_APB0_I2C1_EN_enable_b1 : CSC_APB0_I2C0_EN_enable_b1;
#endif
RH(CSC_KEY_h0) = 0; // lock access to CSC regs
// Настройка тактирования
RH(id+( I2C0_CLK_h0 -I2C0_Base)) =
I2C_CLK_TMO_CKS_div64_h0 | // CK_TMO: F(CK_PSC)/64 = 37500 Hz
((5 -1) << I2C_CLK_CK_PSC_shift_h0) | // CK_PSC: 12 MHz /5 = 2400 kHz
I2C_CLK_CK_DIV_div4_h0 | // CK_I2Cx_INT: 600 kHz => F(SCL) = 100 kHz
I2C_CLK_CK_SEL_proc_h0; // I2Cx_CK_SEL: APB, 12 MHz
// Тайминг режима master
RH(I2C0_CR1_h0) = 0x0202; // (2+HT+LT) = 6
}
```
Здесь в зависимости от типа МК включается общее тактирование единственного модуля I2C0 или одного из двух доступных I2C0 или I2C1 в зависимости от `id`. Далее производится настройка тактирования внутри модуля. В данном примере показаны настройки на частоту шины 100 кГц. Расчет следующий: суммарный коэффициент деления k = F(CK\_I2Cx) / FSCL = 12 МГц / 100 кГц = 120. При HT=2 и LT=2 получаем
(PSC + 1)·DIV = k/ (2 + HT + LT) = 20.
Чтобы частота сигнала CK\_I2Cx\_TMO была как можно выше, выбираем PSC=4 (коэффициент предделителя 4+1=5) и DIV=4. Таким образом, получаем частоту сигнала I2Cx\_CK\_PSC 2400 кГц, сигнала I2Cx\_CK\_INT — 600 кГц, сигнала I2Cx\_CK\_TMO — 37.5 кГц.
Режим работы модуля устанавливается с помощью функции `i2c_setup_mode()`:
```
/// Установка режима работы модуля I2C по формату регистра CR0 (устанавливает I2Cx_EN)
inline
void i2c_setup_mode(uint32_t id, uint32_t mode) {
RW(id+( I2C0_CR0_w -I2C0_Base)) = mode | I2C_CR0_EN_enable_w; // включаем модуль
}
```
Для настройки прерывания имеется функция `i2c_setup_int()`:
```
/// Включение прерывания INT_I2Cx по флагам, указанным в flags согласно формату I2Cx_INT
void i2c_setup_int(uint32_t id, uint32_t flags) {
RW(id+( I2C0_INT_w -I2C0_Base)) = flags | I2C_INT_IEA_enable_w; // включаем прерывания в модуле
// включаем прерывание в модуле NVIC:
RW(CPU_ISER_w) = 1 << ((id & 0x00010000) ? 29 : 28); // SETENA
}
```
В функциях блокирующего опроса состояния модуля используется таймер таймаута, запуск которого с установкой интервала времени ~ 1 мс осуществляется функцией `i2c_setup_tmout()`:
```
/// Настройка таймера таймаута, режим работы mode определяется по формату младшего байта регистра I2Cx_TMOUT.
inline
void i2c_setup_tmout(uint32_t id, uint8_t mode) {
RH(id+( I2C0_TMOUT_h0 -I2C0_Base)) =
(38 << I2C_TMOUT_TMO_CNT_shift_h0) | // период счета ~1 мс для F(CK_TMO)=37.5 кГц
mode |
// I2C_TMOUT_TMO_MDS_scl_low_h0 |
// I2C_TMOUT_TMO_MDS_scl_sda_high_h0 |
I2C_TMOUT_TMO_CTL_enable_h0 |
I2C_TMOUT_TMO_EN_enable_h0;
}
```
Проверка срабатывания таймера осуществляется функцией `i2c_get_tmout()`:
```
/// Возвращает 1, если таймаут, иначе 0.
inline
uint32_t i2c_get_tmout(uint32_t id) {
return (RB(id+( I2C0_STA_b0 -I2C0_Base)) & I2C_STA_TMOUTF_happened_b0) != 0;
}
```
Все биты регистра статуса возвращает функция `i2c_get_status()`:
```
/// Возвращает I2Cx_STA
inline
uint32_t i2c_get_status(uint32_t id) {
return RW(id+( I2C0_STA_w -I2C0_Base));
}
```
Следующие две функции `i2c_wait_start()` и `i2c_wait_stop()` предназначены для ожидания состояний RSTART и STOP:
```
/// Ожидает состояние REPEAT START
void i2c_wait_start(uint32_t id) {
i2c_setup_tmout(id,0);
while (! (RW(id+( I2C0_STA_w -I2C0_Base)) & (I2C_STA_RSTRF_happened_w | I2C_STA_TMOUTF_happened_w) )) ;
}
/// Ожидает состояние STOP
void i2c_wait_stop(uint32_t id) {
i2c_setup_tmout(id,0);
while (! (RW(id+( I2C0_STA_w -I2C0_Base)) & (I2C_STA_STOPF_happened_w | I2C_STA_TMOUTF_happened_w) )) ;
}
```
#### Функции для ведущего устройства (Master)
В предлагаемых примерах работа ведущего устройства реализована на основе блокирующих функций с заданным временем ожидания без применения прерывания. Функция `i2c_master_startw()` генерирует кадр SLA+W и ожидает готовность модуля (перед отправкой данных или завершения кадра):
```
/// Генерирует состояние START + WRITE с указанным адресом (младший бит должен быть 0).
void i2c_master_startw(uint32_t id, uint8_t addr) {
RW(id+( I2C0_CR2_w -I2C0_Base)) =
(1 << 8) | // BUF_CNT
I2C_CR2_STA_LCK_un_locked_w | I2C_CR2_STA_mask_w; // STA
RB(id+( I2C0_DAT_b0 -I2C0_Base)) = addr;
i2c_setup_tmout(id,0);
while (! (RW(id+( I2C0_STA_w -I2C0_Base)) & (I2C_STA_TXF_happened_w | I2C_STA_TMOUTF_happened_w) )) ;
}
```
Функция `i2c_master_startr()` генерирует кадр SLA+R и ожидает его завершение:
```
/// Генерирует состояние START + READ с указанным адресом (младший бит должен быть 0).
void i2c_master_startr(uint32_t id, uint8_t addr) {
RW(id+( I2C0_CR2_w -I2C0_Base)) =
(1 << 8) | // BUF_CNT
I2C_CR2_STA_LCK_un_locked_w | I2C_CR2_STA_mask_w; // STA
RB(id+( I2C0_DAT_b0 -I2C0_Base)) = addr | 0x01;
i2c_setup_tmout(id,0);
while (! (RW(id+( I2C0_STA_w -I2C0_Base)) & (I2C_STA_SADRF_happened_w | I2C_STA_TMOUTF_happened_w) )) ;
}
```
Функция `i2c_master_send()` помещает в буфер передачи данные `data` длиной `len` от 1 до 4 байт и ожидает их передачу в промежуточный буфер:
```
/// Режим master: передача в режиме Buffer len байт (1-4) из data.
/// Генерирует состояние STOP, если указана опция I2C_STOP.
/// Блокирующая функция с таймаутом: ожидает флаг TXF.
void i2c_master_send(uint32_t id, uint32_t opts, uint8_t len, uint32_t data) {
RW(id+( I2C0_STA_w -I2C0_Base)) |= I2C_STA_TXF_mask_w; // сбрасываем TXF, иначе финальная проверка в конце функции может сработать сразу после старта
RW(id+( I2C0_CR2_w -I2C0_Base)) = opts | (len << 8); // BUF_CNT
RW(id+( I2C0_DAT_w -I2C0_Base)) = data;
i2c_setup_tmout(id,0);
while (! (RW(id+( I2C0_STA_w -I2C0_Base)) & (I2C_STA_TXF_happened_w | I2C_STA_TMOUTF_happened_w) )) ;
}
```
Функция `i2c_master_recv()` ожидает прием данных в количестве `len` байт и возвращает содержимое 32-битного буфера:
```
/// Режим master: прием в режиме Buffer len байт (1-4).
/// Генерирует ACK, если указана опция I2C_ACK.
/// Генерирует состояние STOP, если указана опция I2C_STOP.
/// Блокирующая функция с таймаутом: ожидает флаг RXF.
uint32_t i2c_master_recv(uint32_t id, uint32_t opts, uint8_t len) {
RW(id+( I2C0_CR2_w -I2C0_Base)) = opts | (len << 8); // BUF_CNT
i2c_setup_tmout(id,0);
while (! (RW(id+( I2C0_STA_w -I2C0_Base)) & (I2C_STA_RXF_happened_w | I2C_STA_TMOUTF_happened_w) )) ;
return RW(id+( I2C0_DAT_w -I2C0_Base));
}
```
Указанные две функции принимают вторым аргументом `opts` опции в виде двоичных флагов в соответствии с форматом регистра `I2Cx_CR2`. Используемые опции включают команды и собраны в перечислении:
```
/// Опции по формату регистра I2Cx_CR2
enum I2C_Options {
I2C_NOOPTS = 0,
I2C_NACK = I2C_CR2_CMD_TC_enable_w | I2C_CR2_AA_LCK_un_locked_w,
I2C_ACK = I2C_CR2_CMD_TC_enable_w | I2C_CR2_AA_LCK_un_locked_w | I2C_CR2_PAA_mask_w,
I2C_STOP = I2C_CR2_CMD_TC_enable_w | I2C_CR2_STO_LCK_un_locked_w | I2C_CR2_PSTO_mask_w,
I2C_START = I2C_CR2_CMD_TC_enable_w | I2C_CR2_STA_LCK_un_locked_w | I2C_CR2_PSTA_mask_w
};
```
#### Функции для ведомого устройства (Slave)
Работа ведомого устройства реализована на основе неблокирующих функций с применением простейшего конечного автомата и прерывания модуля I2Cx.
Функция `i2c_write()` записывает данные от 1 до 4 байт в буфер для отправки:
```
/// Запись данных в буфер отправки (1-4 байта)
inline
void i2c_write(uint32_t id, uint32_t data, uint8_t len) {
RB(id+( I2C0_CR2_b1 -I2C0_Base)) = (len & I2C_CR2_BUF_CNT_mask_b1); // BUF_CNT
RW(id+( I2C0_DAT_w -I2C0_Base)) = data;
}
```
Функция `i2c_read()` считывает данные (4 байта) из буфера после приема:
```
/// Чтение буфера приема (4 байта)
inline
uint32_t i2c_read(uint32_t id) {
return RW(id+( I2C0_DAT_w -I2C0_Base));
}
```
Для передачи данных объемом более 4 байт можно использовать функцию `i2c_writebuf()`:
```
/// Запись данных из буфера программы в буфер отправки.
/// На входе: *p - текущее положение в буфере (указывает на следующий байт после отправленного).
/// На выходе: *p - новое значение, увеличенное на число отправленных байт.
/// Возвращает оставшееся число байт.
uint32_t i2c_writebuf(uint32_t id, const void* buf, uint32_t* p, uint32_t len) {
uint8_t m;
int32_t n;
n = len - *p;
if (n > 0) {
m = n < 4 ? n : 4;
RB(id+( I2C0_CR2_b1 -I2C0_Base)) = (m & I2C_CR2_BUF_CNT_mask_b1); // BUF_CNT
switch (m) {
case 1: RB(id+( I2C0_DAT_b0 -I2C0_Base)) = *((uint8_t*)buf + *p); break;
case 2: RH(id+( I2C0_DAT_h0 -I2C0_Base)) = *(uint16_t*)((uint8_t*)buf + *p); break;
default:
RW(id+( I2C0_DAT_w -I2C0_Base)) = *(uint32_t*)((uint8_t*)buf + *p); break;
}
*p += m;
}
return len-*p;
}
```
Функция за один вызов может отправить не более 4 байт и предназначена для работы в подпрограмме обработки прерывания. Функция вызывается несколько раз до тех пор, пока весь буфер длиной `len` байт не будет передан на отправку. На входе также указывается адрес буфера `buf`, из которого нужно передать данные и адрес переменной `p`, хранящей текущую позицию в буфере. Содержимое буфера и значение `len` не должны изменяться пока все данные не будут отправлены. Перед первым вызовом по адресу `p` должен быть записан 0. Функция возвращается число оставшихся неотправленных байт.
Аналогично для приема данных объемом более 4 байт можно использовать функцию `i2c_readbuf()`:
```
/// Чтение принятых данных и их запись в указанный буфер.
/// На входе: *p - текущее положение в буфере (указывает на следующий байт после записанного).
/// На выходе: *p - новое значение, увеличенное на число считанных байт.
/// Возвращает фактическое число считанных байт.
uint8_t i2c_readbuf(uint32_t id, void* buf, uint32_t* p) {
uint8_t n = RB(id+( I2C0_CR2_b1 -I2C0_Base)) & I2C_CR2_BUF_CNT_mask_b1; // BUF_CNT
*(uint32_t*)((uint8_t*)buf + *p) = RW(id+( I2C0_DAT_w -I2C0_Base));
*p += n;
return n;
}
```
Функция за один вызов может принять не более 4 байт. Функция вызывается каждый раз после срабатывания флага **RXF** до тех пор, пока не будет принят весь объем данных. На входе также указывается адрес буфера `buf`, в который нужно записывать данные и адрес переменной `p`, хранящей текущую позицию в буфере. Перед первым вызовом по адресу `p` должен быть записан 0. Функция возвращается число байт, принятых за один вызов.
#### Библиотека для работы с часами DS3231
Функции для работы с м/с DS3231 помещены в файл `ic/ds3231.c`. В файле `ic/ds3231.h` объявлены идентификатор модуля `DS3231_PORT` и адрес ведомого `DS3231_ADDR`:
```
#define DS3231_PORT I2C0_id // I2C module base address
#define DS3231_ADDR 0xD0 // 0b1101000X, X - direction: 0 - write, 1 - read.
```
Для удобства проверки и обработки таймаута созданы макросы:
```
#define TMOUT_CHECK if (i2c_get_tmout(DS3231_PORT)) return;
#define TMOUT_CHECK2 if (i2c_get_tmout(DS3231_PORT)) goto failure;
```
В файле также объявлено перечисление `DS3231_Registers` с адресами регистров DS3231 и прототипы функций для работы с часами. Функция `ds3231_read()` выполняет запрос значения одного регистра `reg` (все регистры 8-разрядные):
```
uint8_t ds3231_read(uint8_t reg) {
uint32_t d;
i2c_master_startw(DS3231_PORT, DS3231_ADDR); TMOUT_CHECK2
i2c_master_send(DS3231_PORT, I2C_START, 1, reg); TMOUT_CHECK2
i2c_wait_start(DS3231_PORT); TMOUT_CHECK2
i2c_master_startr(DS3231_PORT, DS3231_ADDR); TMOUT_CHECK2
d=i2c_master_recv(DS3231_PORT, I2C_STOP, 1); TMOUT_CHECK2
i2c_wait_stop(DS3231_PORT); TMOUT_CHECK2
return d;
failure:
return 0;
```
Вначале формируется кадр SLA+W с одним байтом-адресом, затем отдельно передается байт с номером запрашиваемого регистра и автоматическим формированием RSTART по окончанию передачи. Перед дальнейшими действиями ожидается переход шины в это состояние. Далее формируется кадр SLA+R, в котором запрашивается 1 байт данных, после чего формируется состояние STOP и ожидается его фактическая генерация. На каждом шаге выполняется проверка таймаута.
Альтернативным методом чтения регистров DS3231 является мультибайтовый запрос (функция `ds3231_read_multi()`), в котором ведущий указывает номер первого регистра, а затем выполняет чтение данных первого и последующих по порядку регистров до тех пор, пока не сформирует состояние NACK:
```
uint32_t ds3231_read_multi(uint8_t first_reg, uint8_t len) {
uint32_t d;
i2c_master_startw(DS3231_PORT, DS3231_ADDR); TMOUT_CHECK2
i2c_master_send(DS3231_PORT, I2C_START, 1, first_reg); TMOUT_CHECK2
i2c_wait_start(DS3231_PORT); TMOUT_CHECK2
i2c_master_startr(DS3231_PORT, DS3231_ADDR); TMOUT_CHECK2
d=i2c_master_recv(DS3231_PORT, I2C_STOP, len & 0x07); TMOUT_CHECK2
i2c_wait_stop(DS3231_PORT); TMOUT_CHECK2
return d;
failure:
return 0;
}
```
В данной функции максимальное число регистров модуля DS3231, которые можно прочитать, ограничено числом 4 по размеру буфера приема (4 байта). Состояние NACK модуль I2C сгенерирует автоматически после приема указанного числа байт `len` перед формированием состояния STOP. Аналогично реализованы два вида функций записи данных в регистры DS3231:
```
void ds3231_write(uint8_t reg, uint8_t val) {
i2c_master_startw(DS3231_PORT, DS3231_ADDR); TMOUT_CHECK
i2c_master_send(DS3231_PORT, I2C_STOP, 2, ((uint32_t)val << 8) | reg ); TMOUT_CHECK
i2c_wait_stop(DS3231_PORT); TMOUT_CHECK
}
void ds3231_write_multi(uint8_t first_reg, uint8_t len, uint32_t vals) {
i2c_master_startw(DS3231_PORT, DS3231_ADDR); TMOUT_CHECK
i2c_master_send(DS3231_PORT, I2C_NOOPTS, 1, first_reg); TMOUT_CHECK
i2c_master_send(DS3231_PORT, I2C_STOP, len & 0x07, vals); TMOUT_CHECK
i2c_wait_stop(DS3231_PORT); TMOUT_CHECK
}
```
Запись реализуется проще, поскольку все данные можно передать одним пакетом после кадра SLA+W. Также реализованы две функции "верхнего" уровня для установки и запроса времени в двоично-десятичном формате (BCD) 0xHHMMSS:
```
/// Установка времени в формате BCD: 0xHHMMSS
void clock_set_bcd(uint32_t t) {
ds3231_write(REG_SEC, t);
ds3231_write(REG_MIN, t >> 8);
ds3231_write(REG_HOUR,t >> 16);
}
/// Считывание времени в формате BCD: 0xHHMMSS
uint32_t clock_get_bcd() {
uint8_t d[4];
d[0]=ds3231_read(REG_SEC);
d[1]=ds3231_read(REG_MIN);
d[2]=ds3231_read(REG_HOUR);
d[3]=0;
return *(uint32_t*)d;
}
```
Здесь для наглядности приведены версии функций с побайтовыми запросами, которые компилируются при определении макроса `DS3231_ONEBYTE_MODE`. Если макрос не определен, компилируются мультибайтовые версии этих двух функций.
#### Реализация ведущего устройства
Перейдем к реализации ведущего устройства в аппаратном режиме (Buffer mode). В качестве ведомого будем использовать модуль часов на основе м/с DS3231. Тестовые функции ведущего помещены в файл `src/i2c_test.c`, а вызываются они из прикладной части в функции `app()`.
Перед началом работы вызывается функция настройки модуля `i2c_test_master_setup()`:
```
void i2c_test_master_setup() {
i2c_init(DS3231_PORT);
HW_I2C0_SETSCL;
HW_I2C0_SETSDA;
// Настройка режима работы
i2c_setup_mode(DS3231_PORT,
I2C_CR0_PDRV_SEL_1t_w |
I2C_CR0_BUF_EN_enable_w | // Режим работы через буфер
I2C_CR0_MDS_i2c_w // I2C : Single/Multi-Master/ Slave mode
);
}
```
В ней происходит настройка тактирования, установка выводов SCL и SDA, а затем задается режим работы модуля I2C. Далее вызывается одна из трех функций, выполняющих запросы:
* `i2c_test_master_w1r_ds3231()` — запрос времени с DS3231;
* `i2c_test_master_wN()` — установка произвольного регистра в ведомом;
* `i2c_test_master_w1r()` — запрос произвольного количества байт в ведомом.
Рассмотрим первую функцию:
```
void i2c_test_master_w1r_ds3231() {
uint32_t d;
while (1) {
d=clock_get_bcd();
if (i2c_get_tmout(I2C_PORT)) {
d=i2c_get_status(I2C_PORT);
debug32hex('S',d); i2c_print_status(d);
led2_flash();
i2c_clr_status(I2C_PORT, I2C_STA_TMOUTF_mask_w);
}
else {
debug32hex('T',d);
}
delay_ms(1000);
}
}
```
В цикле примерно 1 раз в секунду опрашиваются регистры, содержащие секунды, минуты и часы. Если не происходит срабатывание таймера таймаута, полученное 24-битное число в формате 0xHHMMSS выводится в терминал. Если таймер срабатывает, в терминал выводится статус модуля I2C со всеми флагами в многострочном текстовом формате (по 8 флагов в строку). Для этого используется отладочная функция разработанной библиотеки `i2c_print_status()`, которая компилируется только при установленном макросе `I2C_DEBUG`. После срабатывания таймера флаг **TMOUTF** в программе сбрасывается. Для контроля также включается светодиод D2.
Подключаем часы DS3231 и смотрим результат работы в терминале. Через несколько секунд разрываем соединение с ведомым, затем вновь его восстанавливаем:
```
Hello
T 00180353
T 00180354
T 00180355
T 00180356
S F8000010
----- ----- ----- ----- ----- ----- ----- -----
----- ----- ----- ----- ----- ----- ----- -----
----- ----- ----- TMOUT ----- ----- ----- -----
S F8000010
----- ----- ----- ----- ----- ----- ----- -----
----- ----- ----- ----- ----- ----- ----- -----
----- ----- ----- TMOUT ----- ----- ----- -----
T 00180359
T 00180400
T 00180401
```
Видно, что ведущий работает и получает корректное значение всех трех байт времени. Также работает таймер TMO при нарушении связи: видно, что в слове статуса устанавливается флаг таймаута (бит 4), а старший байт отображает состояние модуля 0xF8 (недокументированная функция). С помощью цифрового анализатора Saleae Logic посмотрим временную диаграмму работы шины (канал 0 (белый) — сигнал SDA, канал 1 (коричневый) — сигнал SCL):
Временная диаграмма запроса времени с часов DS3231Запрос начинается с кадра SLA+W, адрес подтверждается (ACK), затем отправляется номер регистра секунд (0x00). Далее, после состояния RSTART (зеленый кружок) формируется кадр SLA+R, адрес подтверждается (ACK) и далее происходит считывание трех байт с подтверждением первых двух со стороны ведущего. Последний байт не подтверждается и ведущий генерирует состояние STOP (красный кружок).
Теперь посмотрим, что происходит в момент обрыва соединения с ведомым:
Временная диаграмма запроса времени с часов DS3231В результате обрыва ведущий не получил ACK в кадре SLA+W, прервал передачу данных и перешел в режим ожидания. Уменьшим масштаб и посмотрим длительность состояния низкого уровня на линии SCL:
Временная диаграмма запроса времени с часов DS3231Время ожидания составило установленную 1 мс, после чего модуль "сбросился" и перешел в начальное состояние. Тест пройден успешно.
### Реализация ведомого устройства
#### Общая функция
Перейдем к реализации ведомого устройства на МК MG32F02A032. Модуль I2C также будет работать в аппаратном режиме. Для ведомого устройства удобно использовать прерывания, поскольку события на шине I2C для него всегда будут асинхронными. В проекте сконфигурирована цель `slave` с отдельным главным файлом прикладной части `app_slave.c`, в котором собраны все функции тестирования и обработчики прерывания. В файле определены идентификатор порта `I2C_PORT` и глобальные переменные, отвечающие за буфер:
```
#define I2C_PORT I2C0_id
#define BUFLEN 16
/// Буфер данных слэйва
uint8_t buf[BUFLEN]; ///< данные буфера
uint32_t bufp; ///< указатель буфера
uint32_t bufn; ///< размер данных на отправку
```
Указатель `bufp` содержит текущую позицию в буфере `buf` для операций чтения или записи и должен быть обнулен перед началом работы. Рассмотрим основную функцию `i2c_test_slave()`:
```
/// Общая настройка режима слэйва
void i2c_test_slave() {
uint32_t i;
for (i=0; i< BUFLEN; i++) buf[i]=((i+1)<< 4) | (i+1); // инициализация буфера
// Настройка тактирования:
i2c_init(I2C_PORT);
// Настройка выводов I2C:
HW_I2C0_SETSCL; HW_I2C0_SETSDA;
// Настройка режима работы
i2c_setup_mode(I2C_PORT,
I2C_CR0_PDRV_SEL_1t_w |
I2C_CR0_BUF_EN_enable_w | // Режим работы через буфер
I2C_CR0_MDS_i2c_w | // I2C : Single/Multi-Master/ Slave mode
I2C_CR0_SADR_EN_enable_b0 // Включаем детектор адреса слэйва
);
// Адрес слэйва:
RB(I2C0_SADR_b0) = DS3231_ADDR; // установка адреса
RB(I2C0_MASK_b0) = 0xFE; // настройка маски
// Отключаем задержку сигнала SCL от слэйва
RB(I2C0_CR0_b1) |= I2C_CR0_SCLS_DIS_disable_b1;
// Устанавливаем обработчик прерываний:
SVC2(SVC_HANDLER_SET,28,i2c_hdl_w1rN);
// Включаем прерывания в модуле:
RW(I2C0_INT_w) =
I2C_INT_BUF_IE_enable_w | // flags: RXF, TXF, RSTRF, STOPF, SADRF
I2C_INT_IEA_enable_w;
// Включаем прерывание в модуле NVIC:
RW(CPU_ISER_w) = (1 << 28); // SETENA 28
while (1) {
// Проверка ACNT:
if (RB(I2C0_CR2_b2) & 0x07) led2_on(); else led2_off();
}
}
```
В начале функции инициализируется буфер значениями 0x11, 0x22, и т.д. Далее настраивается тактирование, назначаются выводы модуля и устанавливается собственный адрес устройства, такой же, как и у часов DS3231. Затем устанавливается обработчик прерывания и настраивается прерывание по флагу **BUFF**, включающее все события (кроме ошибок), которые могут произойти в режиме Buffer mode. С этого момента функция ведомого устройства будет целиком определяться обработчиком прерывания.
#### Передача данных по запросу ведущего
Начнем с обработчика `i2c_hdl_w1rN()`, реализующего отправку произвольного числа байт из своего буфера. Протокол обмена следующий: ведущий отправляет пакет SLA+W с одним байтом, в котором указывает число запрашиваемых байт. Ведомый после получения кадра SLA+R начинает отправку запрошенных данных. Ведущий подтверждает прием каждого байта, кроме последнего, после чего формирует состояние STOP. Рассмотрим код функции:
```
/// Обработчик прерывания I2C0
void i2c_hdl_w1rN() {
uint32_t d; // флаги
uint32_t n;
led1_on();
d=i2c_get_status(I2C_PORT);
if (d & I2C_STA_SADRF_mask_w) {
if (d & I2C_STA_RWF_read_w) {
// Мастер читает
}
else {
// Мастер пишет
}
}
if (d & I2C_STA_TXF_mask_w) {
//if (bufp==bufn) led2_on();
if (bufn > bufp) {i2c_writebuf(I2C_PORT,buf,&bufp,bufn); led1_on();}
}
if (d & I2C_STA_RXF_mask_w) {
n=i2c_read(I2C_PORT) & 0xFF;
bufn = (n <= BUFLEN) ? n : BUFLEN;
bufp=0;
i2c_writebuf(I2C_PORT,buf,&bufp,bufn); // Подготавливаем данные для отправки (копируем в буфер максимум байт (4))
}
if (d & I2C_STA_STOPF_mask_w) {
}
if (d & I2C_STA_RSTRF_mask_w) {
}
led1_off();
i2c_clr_status(I2C_PORT, 0x00ffffff);
}
```
Светодиодные выводы МК будем использовать для отладки и подключим к цифровому анализатору вместе с сигналами SCL и SDA. Сигнал со светодиода D1 будет показывать момент возникновения прерывания, а сигнал с D2 — срабатывание некоторых флагов. В зависимости от установленных флагов в функции выполняются те или иные действия. Одновременно могут быть установлены несколько флагов.
При установленном флаге **SADRF** далее определяется тип кадра SLA (чтение или запись) и выполняются какие-либо прикладные действия (показано в качестве шаблона). При установленном флаге **RXF** считывается младший байт буфера приема в переменную `n` — запрашиваемое число байт, которое затем проходит формальную проверку на непревышение `BUFLEN`. Далее в буфер на отправку передается первая порция данных через функцию `i2c_writebuf()`. При установленном флаге **TXF** вновь вызывается функция `i2c_writebuf()` для передачи оставшейся порции данных. В качестве шаблона также показан код для определения установки флагов **STOPF** и **RSTRF**. В конце функции сигнал D1 возвращается в 0 и сбрасываются все флаги.
На стороне ведущего устройства в файле `i2c_test.c` для данного теста будем использовать функцию `i2c_test_master_w1r()`, в которой раз в секунду запрашивается заданное число байт (9) с помощью вспомогательной функции `i2c_test_master_req()`. Полученные данные помещаются в глобальный буфер (аналогично ведомому) и после приема последнего байта выдаются в терминал через отладочную функцию `debugbuf()`. Состояние таймаута проверяется аналогично функции `i2c_test_master_w1r_ds3231()`. Код этих двух функций читатель может посмотреть в репозитории.
Подключаем вместо DS3231 МК MG32F02A032 и смотрим результат в терминале ведущего:
```
11 22 33 44 55 66 77 88 99
11 22 33 44 55 66 77 88 99
11 22 33 44 55 66 77 88 99
```
Теперь посмотрим временные диаграммы (канал 2 (красный) — сигнал D1, канал 3 (желтый) — сигнал D2):
Временная диаграмма запроса 9 байт с МКВ функции `i2c_test_slave()` после разрешения прерываний мы оставили циклический опрос счетчика `I2Cx_ACNT`: когда его значение становится отлично от нуля, сигнал D2 переходит в состояние высокого уровня. Проанализируем диаграммы. Прерывание сработало всего три раза: первый раз по флагу **RXF** после фиксирования состояния RSTART, что показывает та же диаграмма в большем масштабе:
Временная диаграмма запроса 9 байт с МКВ этот момент мы подготовили данные для отправки, не дожидаясь следующего прерывания. В противном случае ведущий получил бы некорректные данные (читатель может это проверить самостоятельно). Сразу после получения первого байта со значением 0x09 и подтверждением ACK значение ACNT стало равно 1, но после прочтения вернулось в 0.
Второй раз прерывание сработало по флагу **TXF** после кадра SLA+R и подтверждения ACK в момент начала передачи первого байта от ведомого:
Временная диаграмма запроса 9 байт с МКВ этот момент первые 4 байта уже были переданы в промежуточный буфер для отправки и основной буфер `I2Cx_DAT` освободился для новых данных, что привело к установке флага. Теперь мы записали в этот буфер следующие 4 байта. После фактической передачи одного байта (0x11) в сдвиговый регистр значение счетчика ACNT изменилось на 1 и дальше увеличивалось с отправкой каждого последующего байта.
Третий раз прерывание сработало также по флагу **TXF** после передачи очередных 4 байт в промежуточный буфер. Значение счетчика сбросилось в 0. Мы записали в буфер последний, 9-й байт. Следующие 4 байта 0x55-0x88 были отправлены из промежуточного буфера сразу. После этого, когда счетчик ACNT вновь сбросился, последний байт 0x99 был также скопирован в промежуточный буфер и отправлен.
#### Прием данных от ведущего
Теперь рассмотрим обработчик `i2c_hdl_wN()` со следующим алгоритмом: slave-устройство принимает один пакет с данными и подтверждает каждый байт до тех пор, пока ведомый их передает, после чего дамп буфера выводится в терминал:
```
/// Обработчик прерывания I2C0
void i2c_hdl_wN() {
uint32_t d;
led1_on();
d=i2c_get_status(I2C_PORT);
if (d & I2C_STA_SADRF_mask_w) {
if (d & I2C_STA_RWF_read_w) { // Master reads
}
else { // Master writes
bufp=0;
}
}
if (d & I2C_STA_RXF_mask_w) {
i2c_readbuf(I2C_PORT,buf,&bufp);
}
if (d & I2C_STA_STOPF_mask_w) {
debugbuf(buf,bufp);
}
led1_off();
i2c_clr_status(I2C_PORT, 0x00ffffff);
}
```
На стороне ведущего устройства в файле `i2c_test.c` для данного теста будем использовать функцию `i2c_test_master_wN()`, в которой раз в секунду ведущий передает сначала 1 байт с 0x01, затем последовательность из 4 байт 0xA1, 0xB2, 0xC3, 0xD4.
Смотрим результат в терминале ведомого:
```
01 A1 B2 C3 D4
01 A1 B2 C3 D4
01 A1 B2 C3 D4
```
Теперь посмотрим временные диаграммы:
Временная диаграмма отправки 5 байтПервый раз прерывание сработало по флагу **SADRF** после получения кадра SLA+W до генерации подтверждения ACK. После приема первого байта из сдвигового регистра счетчик ACNT принял значение 1. Второй раз прерывание сработало по флагу **RXF** после приема первых 4 байт, данные из буфера были прочитаны, после чего счетчик ACNT сбросился. После приема последнего байта счетчик ACNT вновь принял значение 1. Третий раз прерывание сработало по двум флагам **STOPF** и **RXF**. Мы прочитали из буфера последний байт и стали выполнять длительную процедуру по выводу буфера в терминал, на что потратили примерно 1,4 мс (диаграмма с таким масштабом не показана). Поэтому сигналы D1 и D2 сразу не вернулись в состояние 0.
### Заключение
Мы экспериментально проверили основные сценарии взаимодействия ведущего и ведомого устройств в максимально автоматизированном аппаратном режиме работы модулей I2C. Для более специфических задач можно использовать низкоуровневый режим Byte mode. Модуль показал полную работоспособность и высокую функциональность одновременно с относительной простой использования. Предложенные библиотеки могут быть взяты за основу для разработки собственных прошивок МК. За рамками статьи остались следующие вопросы, которые читатель может изучить по User Guide:
* управление активной подтяжкой для линий SCL и SDA (16.12.1),
* пробуждение модуля из состояния STOP (16.12.3),
* обработка ошибок (16.13),
* применение DMA (16.14),
* режим Monitor. | https://habr.com/ru/post/695670/ | null | ru | null |
# Новая жизнь старого синтезатора. Часть 2
Продолжение [истории](http://habrahabr.ru/post/214147/) про старый сгоревший синтезатор, в который я пытаюсь вдохнуть новую жизнь путем полной замены железа, отвечающего за генерацию звука, на программный синтезатор, построенный на базе мини-компьютера EmbedSky E8 с Linux на борту. Как это часто бывает, между публикацией первой и второй части статьи прошло гораздо больше времени, чем планировалось, но, тем не менее, продолжим.
В предыдущей части был изложен процесс выбора аппаратной платформы для нового «мозга» синтезатора с описанием технических характеристик решения, кратко освещен процесс сборки необходимых библиотек и проблем, с которыми пришлось столкнуться в процессе. Теперь же что касается железа, то мы посмотрим как устроена клавиатурная матрица синтезатора, а дальше будет больше деталей посвященных софтовой части.
##### Клавиатурная матрица
Клавиатурная матрица синтезатора очень похожа на обычную клавиатурную матрицу, которые многие любители микроконтроллеров уже наверняка подключали к своим Arduino. Для каждой клавиши синтезатора на ней предусмотрено от одного (в наиболее дешевых моделях) до двух (в основной массе моделей) переключателей. С помощью двух расположенных рядом переключателей, один из которых при нажатии клавиши замыкается немного раньше другого, микроконтроллер может определить условную силу, а точнее скорость, с которой клавиша была нажата, чтобы впоследствии был воспроизведен звук соответствующей громкости. Выглядит это так:
На обратной стороне платы размещены диоды, которые предотвращают «ложное» считывание нажатых клавиш при одновременном нажатии нескольких клавиш. Вот фрагмент принципиальной схемы клавиатурной матрицы, на которой видны эти два переключателя и подсоединенные к ним диоды:
Чтобы просканировать матрицу, микроконтроллер последовательно подтягивает столбцы (выводы, помеченные как N) к питанию, и проверяет уровень на строках (выводы, помеченные как B). Если уровень какой-либо строки окажется высоким, значит соответствующая активному в данный момент сочетанию «столбец-строка» клавиша нажата. На схеме показана лишь часть клавиатуры — всего на ней 76 клавиш (13 строк и 6 х 2 колонок, что дает в сумме 156 возможных вариантов при сканировании матрицы и 25 используемых выводов микроконтроллера). Сканирование всей клавиатуры осуществляется несколько десятков раз в секунду и незаметно для исполнителя.
В моем синтезаторе микроконтроллером, ответственным за сканирование клавиатуры, изначально был 8-битный однократно программируемый микроконтроллер Hitachi HD63B05V0, работающий на частоте 8 МГц и имеющий 4 КБ ROM и 192 байта RAM памяти. К сожалению, данный контроллер оказался нерабочим после инцидента с питанием, описанного в начале первой статьи. Зато, к счастью, он оказался почти совместим по выводам с имеющимся у меня контроллером ATmega162, на который я его и заменил, перерезав и перепаяв всего лишь 2 дорожки на плате, одна из которых — это вывод RESET, оказавшийся совсем не в том месте, как у HD63B05V0.
Поскольку такое включение контроллера не позволяло мне воспользоваться встроенным UART (так как он тоже был на других выводах), то для вывода информации о нажатых клавишах я воспользовался [этой](http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=58886) односторонней (только запись) реализацией последовательного порта. Также в микроконтроллер был залит загрузчик [TinySafeBoot](http://jtxp.org/tech/tinysafeboot_en.htm), также использующий программную реализацию последовательного порта, для возможности будущего обновления прошивки. Поскольку в качестве языка для быстрой разработки всего высокоуровневого ПО синтезатора я выбрал Python + Qt5, то для TinySafeBoot я также написал модуль на Python, который позволяет считывать и записывать прошивку в микроконтроллер AVR. Сам микроконтроллер AVR подключен к последовательному порту UART1 на плате EmbedSky E8 и питается от напряжения 3.3V, чтобы избежать необходимости в преобразовании уровней.
**Исходный код прошивки для AVR**
```
#include
#include
#include
#include
#include "dbg\_putchar.h"
#define MIDI\_BASE 18
#define ZERO\_BASE 28
#define KEYS\_COUNT 76
#define hiz(port, dir) do { \
(dir) = 0; \
(port) = 0; \
} while(0)
#define alow(port, dir) do { \
(dir) = 0xff; \
(port) = 0; \
} while(0)
uint8\_t keys[KEYS\_COUNT];
/\* Get state of a row by its index
\* starting from 1 to 13 \*/
uint8\_t getRow(uint8\_t idx)
{
if (idx <= 8) {
return (PINC & (1 << (8 - idx)));
} else if (idx >= 9 && idx <= 11) {
return (PINE & (1 << (11 - idx)));
} else if (idx == 12) {
return (PINA & (1 << PIN6));
} else if (idx == 13) {
return (PINA & (1 << PIN4));
}
return 0;
}
inline void activateColumn1(uint8\_t idx)
{
PORTD = 0x00 | (1 << (8 - idx));
PORTB = 0x00;
}
void activateColumn2(uint8\_t idx)
{
if (idx <= 3) {
PORTB = 0x00 | (1 << (idx + 4));
PORTD = 0x00;
} else if (idx == 4) {
PORTB = 0x00 | (1 << PIN4);
PORTD = 0x00;
} else if (idx == 5 || idx == 6) {
PORTD = 0x00 | (1 << (idx - 5));
PORTB = 0x00;
}
}
inline void deactivateColumns(void)
{
PORTD = 0x00;
PORTB = 0x00;
}
inline void initPorts(void)
{
hiz(PORTA, DDRA);
hiz(PORTC, DDRC);
hiz(PORTE, DDRE);
PORTB = 0x00;
DDRB = 0xfe;
DDRD = 0xff;
}
void resetRows(void)
{
/\* output low \*/
alow(PORTC, DDRC);
alow(PORTE, DDRE);
/\* don't touch PA7 & PA5 \*/
DDRA |= 0x5f;
PORTA &= ~0x5f;
\_delay\_us(10);
/\* back to floating input \*/
hiz(PORTC, DDRC);
hiz(PORTE, DDRE);
DDRA &= ~0x5f;
}
/\* base MIDI note number is 25: C#0 \*/
int main(void)
{
uint8\_t row, col, layer;
uint8\_t note, offset;
initPorts();
memset(keys, 0, sizeof(keys));
dbg\_tx\_init();
dbg\_putchar('O');
dbg\_putchar('K');
while(1)
{
for (layer = 0; layer < 2; layer++)
{
for (col = 1; col <= 6; col++)
{
if (!layer)
activateColumn1(col);
else
activateColumn2(col);
for (row = 1; row <= 13; row++)
{
note = 6 \* row + col + MIDI\_BASE;
offset = note - ZERO\_BASE;
if (getRow(row))
{
if (!layer)
{
/\* increase velocity counter \*/
if (keys[offset] < 254 && !(keys[offset] & 0x80))
keys[offset]++;
}
else
{
if (!(keys[offset] & 0x80))
{
/\* generate note-on event \*/
dbg\_putchar(0x90);
dbg\_putchar(note);
/\*dbg\_putchar(keys[offset]);\*/
dbg\_putchar(0x7f);
/\* stop counting \*/
keys[offset] |= 0x80;
}
}
}
else
{
if (layer)
continue;
if (keys[offset] & 0x80)
{
/\* generate note off event \*/
dbg\_putchar(0x90);
dbg\_putchar(note);
dbg\_putchar(0x00);
/\* reset key state \*/
keys[offset] = 0x00;
}
}
}
deactivateColumns();
resetRows();
}
}
}
return 0;
}
```
**Модуль на Python для TinySafeBoot**
```
import serial
import binascii
import struct
import intelhex
import sys
class TSB(object):
CONFIRM = '!'
REQUEST = '?'
def __init__(self, port):
self.port = serial.Serial(port, baudrate=9600, timeout=1)
self.flashsz = 0
def check(self):
if not self.flashsz:
raise Exception("Not activated")
def activate(self):
self.port.write("@@@")
(self.tsb, self.version, self.status, self.sign, self.pagesz, self.flashsz, self.eepsz) = \
struct.unpack("<3sHB3sBHH", self.port.read(14))
self.port.read(2)
self.pagesz *= 2
self.flashsz *= 2
self.eepsz += 1
assert(self.port.read() == self.CONFIRM)
def rflash(self, progress=None, size=0):
self.check()
self.port.write("f")
self.addr = 0
self.flash = ""
size = self.flashsz if not size else size
while self.addr < size:
if progress is not None:
progress("read", self.addr, size)
self.port.write(self.CONFIRM)
page = self.port.read(self.pagesz)
if len(page) != self.pagesz:
raise Exception("Received page too short: %d" % len(page))
self.addr += len(page)
self.flash += page
return self.flash.rstrip('\xff')
def wflash(self, data, progress=None):
if len(data) % self.pagesz != 0:
data = data + "\xff" * (self.pagesz - (len(data) % self.pagesz))
assert(len(data) % self.pagesz == 0)
self.check()
self.port.write("F")
self.addr = 0
assert(self.port.read() == self.REQUEST)
while self.addr < len(data):
if progress is not None:
progress("write", self.addr, len(data))
self.port.write(self.CONFIRM)
self.port.write(data[self.addr:self.addr + self.pagesz])
self.addr += self.pagesz
assert(self.port.read() == self.REQUEST)
self.port.write(self.REQUEST)
return self.port.read() == self.CONFIRM
def vflash(self, data, progress=None):
fw = self.rflash(progress, len(data))
return fw == data
def info(self):
print "Tiny Safe Bootloader: %s" % self.tsb
print "Page size: %d" % self.pagesz
print "Flash size: %d" % self.flashsz
print "EEPROM size: %d" % self.eepsz
if __name__ == "__main__":
import argparse
def progress(op, addr, total):
sys.stdout.write("\r%s address: $%0.4x/$%0.4x" % (op, addr, total))
sys.stdout.flush()
parser = argparse.ArgumentParser()
parser.add_argument("filename", help="firmware file in Intel HEX format")
parser.add_argument("--device", help="Serial port to use for programming", default="/dev/ttyUSB0")
args = parser.parse_args()
tsb = TSB(args.device)
tsb.activate()
tsb.info()
fw = intelhex.IntelHex(args.filename)
assert(tsb.wflash(fw.tobinstr(), progress))
assert(tsb.vflash(fw.tobinstr(), progress))
print "\nOK\n"
```
В качестве программатора для AVR я сначала использовал [программатор на базе Launchpad MSP430](http://gpio.kaltpost.de/?p=1148), коих у меня имеется в наличии несколько штук, а затем это самодельное чудо (неплохо работающее, кстати), уступило место прибывшему из Китая программатору TL866CS MiniPro. Ощущения от нового программатора крайне положительные.
Очень подробно про устройство клавиатуры синтезатора и способы ее сканирования, включая один очень оригинальный способ сканирования через интерфейс микроконтроллера AVR для подключения внешней микросхемы ОЗУ рассказывается на сайте [OpenMusicLabs](http://www.openmusiclabs.com/learning/digital/input-matrix-scanning/xmem/)
##### Приготовление ядра с поддержкой Realtime Preemption
Отчасти для получения большего контроля над планировщиком и снижения задержки (latency) при проигрывании звука, а отчасти из спортивного интереса, я решил использовать ядро с [патчем PREEPMT RT](https://rt.wiki.kernel.org/index.php/RT_PREEMPT_HOWTO), одной из основных особенностей которого является то, что прерывания также становятся «процессами», которые могут быть вытеснены планировщиком с учетом приоритета. Оригинальное ядро, поставляемое Samsung для процессора S5PV210, на базе которого построена система, базируется на ядре версии 3.0.8, судя по всему от Android. Ни один из патчей RT\_PREEMPT, имеющихся на сайте проекта, предназначенных для данной версии ядра (3.0.8), не хотел накладываться на исходники без конфликтов, но в конце концов, разрешив все конфликты вручную, удалось наложить патч версии 3.0.8-rt23.
Из-за того, что в модифицированном таким образом ядре модифицированными также оказались такие базовые структуры, как spinlock и mutex, с ним перестали линковаться поставляемые в виде скомпилированных объектных файлов проприетарные драйверы некоторых периферийных устройств: видеокамер, контроллера ёмкостного тачскрина, и, что самое ужасное, аудиокодека. Вернемся к ним позже, а сейчас отключим их и попытаемся первый раз запустить плату со свежесобранным ядром реального времени и… получим моментальный kernel panic. Происходил он еще до запуска отладчика kgdb (который, как выяснилось позже, все равно не работал бы, даже если бы запустился), так что для отладки пришлось вставлять printf-ы в файл `init/main.c`, функцию `start_kernel`, чтобы определить место, в котором все рушится. Таким образом выяснилось, что последнее, что успевало сделать ядро, это вызвать функцию `hrtimers_init()`, инициализирующую таймеры высокого разрешения и их прерывания. Этот код зависит от конкретной платформы, и в нашем случае находится в `arch/arm/plat-s5p/hr-time-rtc.c`. Как я уже говорил, одной из основных особенностей ядра с патчем PREEMPT RT является то, что прерывания становятся потоками. Это возможно и в обычном ядре, но ядро с PREEMPT RT по-умолчанию пытается сделать таковыми почти все прерывания. Дальнейший анализ кода показал, что для работы этих потоков используется задача kthreadd\_task, которая инициализируется в самом конце функции `start_kernel` — гораздо позже, чем происходит инициализация таймеров. Падение же происходило из-за того, что прерывание таймера ядро пыталось сделать потоковым, в то время как kthreadd\_task еще NULL. Решается это установкой для отдельных прерываний, которые не стоит делать потоковыми ни при каких обстоятельствах, флага IRQF\_NO\_THREAD который и был добавлен к флагам прерывания таймера в `hr-time-rtc.c`. Ура! Ядро загрузилось, но это еще только начало…
Как я уже упоминал выше, одним из побочных эффектов стало то, что модуль, отвечающий за аудио ввод/вывод, перестал линковаться с новым ядром. Отчасти это было тем, что ядро с PREEMPT RT поддерживает (в версии 3.0.8) только механизм управления памятью SLAB, а изначально модуль был скомпилирован с включенным механизмом SLUB, который не поддерживается новым ядром. Однако, мне посчастливилось работать в Лаборатории Касперского, и я уговорил коллегу декомпилировать для меня файлы драйвера и кодека с помощью декомпилятора Hex-Rays для ARM, после чего удалось практически полностью воссоздать их исходный код. Практически — потому что в результате с «новым» драйвером аудиоинтерфейс стал определяться, однако из-за каких-то различий в низкоуровневой процедуре инициализации регистров микросхемы WM8960 звук проигрывался с артефактами. Какое-то время я пытался подправить свой драйвер, но потом выбрал более легкий путь — я отправил в техподдержку китайской компании EmbedSky Tech, где покупал мини-компьютер, свой патч с PREEMPT\_RT, и попросил их скомпилировать для меня и выслать файлы аудиодрайвера. Ребята быстро откликнулись и прислали мне файлы, с которым звук, наконец, заработал как положено.
Кстати, пока я возился со своим декомпилированным драйвером, я обнаружил, что отладчик kgdb не работает ни с моим, ни с оригинальным ядром. Как выяснилось, для его работы требуется поддержка синхронного (polling) опроса последовательного порта, которая отсутствовала в драйвере последовательного порта Samsung (`drivers/tty/serial/samsung.c`). Я добавил в драйвер требуемую поддержку, основанную на [этом](https://lkml.org/lkml/2012/9/22/11) патче, после чего отладчик заработал.
Копаем дальше. Вторым побочным эффектом нового ядра оказалась крайне низкая, с большими «лагами», скорость работы всех четырех многострадальных последовательных портов системы на кристалле S5PV210, в результате чего была невозможна нормальная работа в терминале через последовательный порт, а также не работала как положено перепрошивка контроллера AVR, опрашивающего клавиатуру синтезатора. Я долго пытался понять в чем причина, но заметил лишь то, что ввод каждого символа в терминале приводил к генерации нескольких миллионов прерываний последовательного порта — ядро, похоже, не спешило их обрабатывать. В итоге я решил эту проблему тем, что с помощью вышеупомянутого флага IRQF\_NO\_THREAD сделал все прерывания последовательных портов непотоковыми. Это решение вышло не очень красивым, потому что помимо драйвера Samsung пришлось внести изменения в файлы `serial_core.c` и `serial_core.h`, затрагивающие вообще все последовательные порты. Потому что в ядре с PREEMPT RT нельзя использовать spin\_lock\_t в драйверах, которые NO\_THREAD, а нужно использовать raw\_spinlock\_t.
В оригинальном ядре, которое, как я говорил выше, поддерживает различные периферийные устройства, такие как видеокамеры, аппаратные кодеки, HDMI и т.д., из 512 МБ оперативной памяти было доступно лишь около 390 МБ, а остальное было зарезервировано для работы вышеуказанных устройств, причем всегда (даже если в процессе конфигурирования ядра они были отключены). Очень расточительно, особенно учитывая, что лишние 120 МБ оперативной памяти синтезатору очень даже не помешают для хранения сэмплов. Память резервировалась в файле `arch/arm/mach-s5pv210/mach-tq210.c`, который является главной точкой сбора всей информации о конфигурации и устройствах конкретной машины (в нашем случае — платы). Комментируем выделение памяти — вызов функции `s5p_reserve_bootmem`, и получаем 120 МБ дополнительной памяти для работы синтезатора.
Последнее изменение, которое было внесено в ядро, касалось минимального размера буфера для аудиоданных, который в оригинале был равен одной странице памяти, что при частоте дискретизации 44100 Гц, 2 канала по 16 бит давало примерно 20 мс — многовато. Это значение было изменено в файле `sound/soc/samsung/dma.c` на 128 байт, после чего минимальный размер буфера уменьшился до нескольких миллисекунд без ущерба стабильности и работоспособности.
[Исходный код ядра с PREEMPT RT и всеми модификациями на GitHub](https://github.com/madprogrammer/linux-e8-rt/tree/synth)
##### Как происходит общение микроконтроллера AVR с LinuxSampler
AVR подключен к последовательному порту платы мини-компьютера, и выплевывает в свой софтверный UART готовые MIDI-сообщения. Дабы избавить себя от необходимости писать драйверы, было принято решение использовать в качестве транспорта для всех аудио и MIDI-данных сервер JACK. Небольшое приложеньице на C подключается к последовательному порту, регистрирует себя в JACK как MIDI-OUT и начинает перенаправлять туда все полученные MIDI-сообщения, а JACK уже доставляет их в LinuxSampler. Дешево и сердито.
**Исходный код приложения-моста между последовательным портом и JACK**
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define UART\_SPEED B9600
jack\_port\_t \*output\_port;
jack\_client\_t \*jack\_client = NULL;
int input\_fd;
void init\_serial(int fd)
{
struct termios termios;
int res;
res = tcgetattr (fd, &termios);
if (res < 0) {
fprintf (stderr, "Termios get error: %s\n", strerror(errno));
exit (EXIT\_FAILURE);
}
cfsetispeed (&termios, UART\_SPEED);
cfsetospeed (&termios, UART\_SPEED);
termios.c\_iflag &= ~(IGNPAR | IXON | IXOFF);
termios.c\_iflag |= IGNPAR;
termios.c\_cflag &= ~(CSIZE | PARENB | CSTOPB | CREAD | CLOCAL);
termios.c\_cflag |= CS8;
termios.c\_cflag |= CREAD;
termios.c\_cflag |= CLOCAL;
termios.c\_lflag &= ~(ICANON | ECHO);
termios.c\_cc[VMIN] = 3;
termios.c\_cc[VTIME] = 0;
res = tcsetattr (fd, TCSANOW, &termios);
if (res < 0) {
fprintf (stderr, "Termios set error: %s\n", strerror(errno));
exit (EXIT\_FAILURE);
}
}
double
get\_time(void)
{
double seconds;
int ret;
struct timeval tv;
ret = gettimeofday(&tv, NULL);
if (ret) {
perror("gettimeofday");
exit(EX\_OSERR);
}
seconds = tv.tv\_sec + tv.tv\_usec / 1000000.0;
return seconds;
}
double
get\_delta\_time(void)
{
static double previously = -1.0;
double now;
double delta;
now = get\_time();
if (previously == -1.0) {
previously = now;
return 0;
}
delta = now - previously;
previously = now;
assert(delta >= 0.0);
return delta;
}
static double
nframes\_to\_ms(jack\_nframes\_t nframes)
{
jack\_nframes\_t sr;
sr = jack\_get\_sample\_rate(jack\_client);
assert(sr > 0);
return (nframes \* 1000.0) / (double)sr;
}
static double
nframes\_to\_seconds(jack\_nframes\_t nframes)
{
return nframes\_to\_ms(nframes) / 1000.0;
}
static jack\_nframes\_t
ms\_to\_nframes(double ms)
{
jack\_nframes\_t sr;
sr = jack\_get\_sample\_rate(jack\_client);
assert(sr > 0);
return ((double)sr \* ms) / 1000.0;
}
static jack\_nframes\_t
seconds\_to\_nframes(double seconds)
{
return ms\_to\_nframes(seconds \* 1000.0);
}
static void
process\_midi\_output(jack\_nframes\_t nframes)
{
int t, res;
void \*port\_buffer;
char midi\_buffer[3];
jack\_nframes\_t last\_frame\_time;
port\_buffer = jack\_port\_get\_buffer(output\_port, nframes);
if (port\_buffer == NULL) {
printf("jack\_port\_get\_buffer failed, cannot send anything.\n");
return;
}
jack\_midi\_clear\_buffer(port\_buffer);
last\_frame\_time = jack\_last\_frame\_time(jack\_client);
t = seconds\_to\_nframes(get\_delta\_time());
res = read(input\_fd, midi\_buffer, sizeof(midi\_buffer));
if (res < 0 && errno == EAGAIN)
return;
res = jack\_midi\_event\_write(port\_buffer, t, midi\_buffer, 3);
if (res != 0) {
printf("jack\_midi\_event\_write failed, NOTE LOST.");
}
}
static int
process\_callback(jack\_nframes\_t nframes, void \*notused)
{
if (nframes <= 0) {
printf("Process callback called with nframes = 0; bug in JACK?");
return 0;
}
process\_midi\_output(nframes);
return 0;
}
int
connect\_to\_input\_port(const char \*port)
{
int ret;
ret = jack\_port\_disconnect(jack\_client, output\_port);
if (ret) {
printf("Cannot disconnect MIDI port.");
return -3;
}
ret = jack\_connect(jack\_client, jack\_port\_name(output\_port), port);
if (ret) {
printf("Cannot connect to %s.", port);
return -4;
}
printf("Connected to %s.", port);
return 0;
}
static void
init\_jack(void)
{
int i, err;
jack\_client = jack\_client\_open("midibridge", JackNullOption, NULL);
if (jack\_client == NULL) {
printf("Could not connect to the JACK server; run jackd first?");
exit(EXIT\_FAILURE);
}
err = jack\_set\_process\_callback(jack\_client, process\_callback, 0);
if (err) {
printf("Could not register JACK process callback.");
exit(EXIT\_FAILURE);
}
char port\_name[32];
snprintf(port\_name, sizeof(port\_name), "midi\_out");
output\_port = jack\_port\_register(jack\_client, port\_name, JACK\_DEFAULT\_MIDI\_TYPE, JackPortIsOutput, 0);
if (output\_port == NULL) {
printf("Could not register JACK output port '%s'.", port\_name);
exit(EXIT\_FAILURE);
}
if (jack\_activate(jack\_client)) {
printf("Cannot activate JACK client.");
exit(EXIT\_FAILURE);
}
}
static void
usage(void)
{
fprintf(stderr, "usage: midibridge -a \n");
exit(EXIT\_FAILURE);
}
int
main(int argc, char \*argv[])
{
int ch;
char \*autoconnect\_port\_name = NULL;
while ((ch = getopt(argc, argv, "a:")) != -1) {
switch (ch) {
case 'a':
autoconnect\_port\_name = strdup(optarg);
break;
default:
usage();
}
}
input\_fd = open("/dev/ttySAC1", O\_RDWR | O\_NOCTTY | O\_NDELAY | O\_NONBLOCK);
if (input\_fd < 0) {
fprintf(stderr, "Cannot open serial port %s\n", strerror(errno));
return EXIT\_FAILURE;
}
init\_serial (input\_fd);
init\_jack();
if (autoconnect\_port\_name) {
if (connect\_to\_input\_port(autoconnect\_port\_name)) {
printf("Couldn't connect to '%s', exiting.", autoconnect\_port\_name);
exit(EXIT\_FAILURE);
}
}
getc(stdin);
return 0;
}
```
Такое решение также позволяет проигрывать MIDI-файлы через JACK с помощью `jack-smf-player`, который я скомпилировал для ARM и WAV/MP3 через mplayer с поддержкой вывода звука в JACK.
##### Бонус
Благодаря комментарию [nefelim4ag](https://habrahabr.ru/users/nefelim4ag/) к предыдущему посту, я узнал про существование libhybris — библиотеки, которая позволяет использовать Android-драйвера в обычной Linux-системе. После некоторых танцев с бубнами, всех подробностей которых я, к сожалению, уже не помню, мне удалось завести libhybris в своей системе и пересобрать Qt 5 и PyQt5 с поддержкой OpenGL ES 2.0, EGLFS и Qt Quick 2.0. Теперь мой пользовательский интерфейс использует Qt Quick и ~~выглядит в соответствии с последними модными тенденциями~~ косит под Android 4.0.
##### Напоследок
Небольшое [демо](https://soundcloud.com/sergey-anufrienko/linuxsampler-demo) — пока только аудио, так как синтезатор сейчас находится в наполовину разобранном состоянии. Видео же будет в следующем посте, который родится скорее всего в августе, после того как приедет заказанная в Китае плата, соединяющая воедино все части синтезатора. Кроме того, следующий пост будет, скорее всего, посвящен уже не таким низкоуровневым манипуляциям с ядром, а процессу доведения до ума пользовательской части софта на PyQt5 и QtQuick и, конечно, демонстрации получившегося
Если кому-то интересно:
**Список всего ПО, которое было кросс-компилировано для ARM*** alsa-lib-1.0.27.2
* alsa-utils-1.0.27.2
* libaudiofile-0.3.6
* dbus-1.8.0
* dropbear-2014.63
* fftw-3.3.3
* fluidsynth-1.1.6
* fontconfig-2.11.0
* freetype-2.5.3
* glib-2.34.3
* libicu-52.1
* jack-audio-connection-kit-0.121.3
* jack-smf-utils-1.0
* libffi-3.0.13
* libgig-3.3.0
* libgig-svn
* libhybris
* libsamplerate-0.1.8
* libsndfile-1.0.25
* linuxsampler-1.0.0
* linuxsampler-svn
* mplayer SVN-r36900-4.4.6
* openssl-1.0.0l
* psutil-1.2.1
* pyjack-0.5.2
* PyQt-gpl-5.2
* pyserial-2.7
* Python-2.7.6
* strace-4.8
* tslib-1.4.1
Если вам потребуется собрать что-то из этого списка и возникнут проблемы, я с удовольствием поделюсь опытом. Кроме того, многое из сказанного здесь справедливо для другой популярной платформы под названием FriendlyARM Tiny210, которая построена на базе того же самого процессора S5PV210 и, возможно, кому-то понадобится использовать с ней ядро реального времени. | https://habr.com/ru/post/224987/ | null | ru | null |
# Создание компонента Sidenav
*Приветствую. Представляю вашему вниманию перевод статьи* [*«Building a sidenav component*](https://web.dev/building-a-sidenav-component/)*», опубликованной 21 января 2021 года автором Adam Argyle*
В данной статье я хочу поделиться одним из способов создания адаптивной боковой панели навигации (sidenav), поддерживающей управление с клавиатуры, работающей как с JavaScript, так и без него, и поддерживаемой всеми браузерами. Посмотреть демонстрацию можно [здесь](https://gui-challenges.web.app/sidenav/dist)
Если Вы предпочитаете видео, ниже представлена YouTube-ролик по данной статье:
Обзор
-----
Создать адаптивную навигацию непросто. Некоторые пользователи могут работать с помощью клавиатуры, одни при входе на сайт будут использовать мощный компьютер, другие — маленькое мобильное устройство. Но каждый из посетителей должен иметь возможность открыть и закрыть меню.
Демонстрация адаптивности макета на десктопе и мобильных:
Светлая и тёмная тема на iOS и Android
Подходы
-------
При исследовании данного компонента я совместил несколько концепций веб-разработки**:**
1. CSS-псевдокласс `:target`
2. CSS Grid
3. CSS-трансформации
4. CSS-медиазапросы для области видимости и предпочтений пользователей
5. JS для увеличения удобства использования
В моём решении на больших экранах боковая панель статична, а "выезжающей" становится только когда ширина области видимости меньше `540px`. Данный размер будет контрольной точкой для переключения между интерактивной раскладкой для мобильных и статической для десктопов.
### CSS-псевдокласс :target
Ссылка , открывающая панель, устанавливает в URL-хэш значение `#sidenav-open`. У самого же элемента боковой панели имеется `id`, который соответствует этому значению. Закрывающая ссылка устанавливает в URL-хэш пустое значение (`''`)**:**
```
[…](#sidenav-open "Open Menu")
```
Нажатие на эти ссылки изменяет состояние (отображение или скрытие) боковой панели в зависимости от URL в адресной строке:
```
@media (max-width: 540px) {
#sidenav-open {
visibility: hidden;
}
#sidenav-open:target {
visibility: visible;
}
}
```
### CSS Grid
Раньше для компонента боковой панели я использовал только абсолютное или фиксированное позиционирование. Технология CSS Grid с её синтаксисом `grid-area`, открывает ещё один способ, позволяя нам на одну строку или колонку назначить несколько элементов.
#### Стопки
Основной элемент макета `#sidenav-container` является grid-элементом, который создаёт 1 строку и 2 колонки, а первая ячейка получает имя `stack`. Когда пространство ограничено, CSS назначает все элементы, дочерние по отношению к в одну и ту же grid-область, размещая все элементы в одну ячейку в виде стопки.
```
#sidenav-container {
display: grid;
grid: [stack] 1fr / min-content [stack] 1fr;
min-height: 100vh;
}
@media (max-width: 540px) {
#sidenav-container > * {
grid-area: stack;
}
}
```
#### Подложка
— это анимированный элемент, который содержит боковую навигацию. У него есть два дочерних элемента: контейнер , которому задано имя `[nav]` и подложка с именем `[escape]`, которая используется для закрытия меню.
```
#sidenav-open {
display: grid;
grid-template-columns: [nav] 2fr [escape] 1fr;
}
```
С помощью изменения значений `2fr` & `1fr` можно настроить соотношение между панелью и оставшимся пространством при открытом боковом меню.
Демонстрация результата изменения размера панели
### CSS трансформации и переходы
Теперь наш макет умещается и в небольшую область видимости мобильного устройства. Пока что боковая панель по умолчанию накладывается на основное содержимое. Вот функционал, который я хочу дополнить в следующем разделе:
* Анимированное открытие и закрытие
* Анимация только в том случае, если пользователь не предпочитает её отключать
* Анимирование `visibility`, чтобы фокус клавиатуры не выходил за пределы экрана
Так как дело дошло до реализации анимированного движения, прежде всего я бы хотел начать с доступности
#### Доступная анимация
Не все хотят видеть анимацию выезжающего меню. В нашем примере от предпочтения пользователя зависит значение CSS-переменной `--duration` , определяющей длительность анимации. Данная переменная находится внутри медиазапроса, который учитывает настройки операционной системы пользователя.
```
#sidenav-open {
--duration: .6s;
}
@media (prefers-reduced-motion: reduce) {
#sidenav-open {
--duration: 1ms;
}
}
```
*Демонстрация работы интерфейса с разными настройками анимирования*
Теперь, если пользователь предпочитает уменьшенное количество анимации, панель будет появляться мгновенно.
#### Переход, трансформация, смещение
**Скрытая панель (по умолчанию)**
Чтобы на мобильных по умолчанию панель находилась за пределами экрана, я смещаю её с помощью `transform: translateX(-110vw).`
Обратите внимание, что в дополнение к обычной ширине области видимости `-100vw` я дополнительно добавил `10vw`, чтобы быть уверенным, что в скрытом состоянии тень от боковой панели не будет видна на экране.
```
@media (max-width: 540px) {
#sidenav-open {
visibility: hidden;
transform: translateX(-110vw);
will-change: transform;
transition:
transform var(--duration) var(--easeOutExpo),
visibility 0s linear var(--duration);
}
}
```
**Открытая панель**
Когда элемент `#sidenav` соответствует псевдоклассу `:target`, установите позиционирование с помощью `translateX()` на стандартное значение `0` и посмотрите, как CSS в течение времени, установленного в переменной `var(--duration)`, сместит элемент с его исходной позиции "скрыто", равной `-110vw` в позицию "открыто", равную `0`.
```
@media (max-width: 540px) {
#sidenav-open:target {
visibility: visible;
transform: translateX(0);
transition:
transform var(--duration) var(--easeOutExpo);
}
}
```
**Переход для свойства visibility**
Теперь, когда панель находится за пределами области видимости, её нужно скрыть и от скринридеров, чтобы они не переводили фокус на её элементы. Я реализовал это с помощью перехода (transition) для свойства `visibility`, который выполняется при смене псевдокласса `:target`.
* При открытии переход применять не нужно, чтобы сразу видимая панель выезжала из-за пределов экрана
* При закрытии панели для свойства `visibility` нужно применить переход, но с задержкой, чтобы она становилась невидимой только после завершения перехода
### Улучшения доступности
#### Ссылки
Для управления состоянием панели, приведённое выше решение полагается на изменения URL-адреса. Естественно, здесь нужно использовать элемент , который имеет некоторые преимущества в плане доступности. Давайте дополним наши интерактивные элементы доступными подписями, отражающими их назначение.
```
[...](#sidenav-open "Open Menu")
```
*Демонстрация взаимодействия с помощью клавиатуры и скринридера*
Теперь наши основные кнопки взаимодействия содержат понятное обозначение для пользователей как мыши, так и клавиатуры.
#### :is(:hover, :focus)
Этот удобный псевдокласс позволяет нам задать стили одновременно для состояний `hover` и `focus`
```
.hamburger:is(:hover, :focus) svg > line {
stroke: hsl(var(--brandHSL));
}
```
#### Добавление JavaScript
**Escape для закрытия**
Кнопка `Escape` на клавиатуре должна закрывать меню, правильно? Давайте реализуем такую возможность
```
const sidenav = document.querySelector('#sidenav-open');
sidenav.addEventListener('keyup', event => {
if (event.code === 'Escape') document.location.hash = '';
});
```
**История браузера**
Чтобы каждое открытие и закрытие панели не создавало отдельную запись в истории браузера, для кнопки закрытия добавьте следующий код
При закрытии панели запись в истории будет удалена, как если бы панель никогда и не открывалась
**Фокус**
Следующий фрагмент кода помогает нам поместить фокус на кнопки открытия и закрытия при соответствующем действии панели. Я хочу сделать переключение простым
```
sidenav.addEventListener('transitionend', e => {
const isOpen = document.location.hash === '#sidenav-open';
isOpen
? document.querySelector('#sidenav-close').focus()
: document.querySelector('#sidenav-button').focus();
})
```
Когда боковая панель открывается, фокус попадает на кнопку закрытия. Когда же панель закрывается, фокус попадает на кнопку открытия. Я делаю это с помощью JavaScript, вызывая на элементе `focus()`.
Заключение
----------
Теперь вы знаете о моём подходе в реализации данного компонента. Как бы его реализовали Вы? | https://habr.com/ru/post/587864/ | null | ru | null |
# Опубликован закрытый ключ AirPort Express
Американский разработчик Джеймс Лейрд (James Laird), помогая своей девушке наладить связь между точкой доступа и базовой станцией AirPort Express, не нашёл другого выхода, как разобрать AirPort Express, считать ROM и провести обратный инжиниринг программы, после чего он смог извлечь закрытый ключ. Этот ключ используется для декодирования пакетов по закрытому протоколу [Apple AirPlay](http://www.apple.com/itunes/airplay/) ([RAOP](http://en.wikipedia.org/wiki/Remote_Audio_Output_Protocol)).
Наладив девушке систему, хакер [поделился с общественностью](http://www.mafipulation.org/blagoblig/2011/04/08#shairport) своим открытием. Фактически, теперь можно сделать эмулятор AirPort Express на чём угодно.
Технология AirPlay (и базовая станция AirPort Express WiFi) используются для беспроводной потоковой передачи данных с компьютера из среды медиа-проигрывателя iTunes на iPhone, iPod, iPad или на другие устройства, совместимые с AirPlay. Теперь AirPort Express, собственно говоря, становится необязательным, и этот поток можно пускать на любое устройство/программу, даже не получившее лицензию у Apple. Достаточно сделать эмулятор на базе декодера пакетов [ShairPort](http://mafipulation.org/static/shairport-0.01.tar.gz) (Perl/C). Джеймс опубликовал декодер под свободной лицензией ([копия на github](https://github.com/bbhoss/shairport)). Транслировать контент с iTunes отныне можно, например, с помощью обычного компьютера и программы XBMC.
На всякий случай, вот сам ключ [в ASCII](http://pastebin.com/raw.php?i=RFeUcdXd).
`-----BEGIN RSA PRIVATE KEY-----
MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt
wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U
wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf
/+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/
UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW
BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa
LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5
NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm
lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz
aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu
a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM
oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z
oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+
k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL
AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA
cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf
54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov
17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc
1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI
LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ
2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKaXTyY=
-----END RSA PRIVATE KEY-----` | https://habr.com/ru/post/117212/ | null | ru | null |
# Ранжирование по-байесовски от доктора Кюблера
[](https://habr.com/ru/company/skillfactory/blog/690560/)
Представьте, что в какой-то игре игроки соревнуются один на один. Возникает естественный вопрос: «Как их ранжировать?». За ответом приглашаем под кат — к старту нашего [флагманского курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_280922&utm_term=lead).
Посмотрим, как построить модель ранжирования множества игроков (рекомендаций, результатов поиска и т. д.). Сделаем это при помощи байесовской модели, где ранжирование выполняется даже без характеристик самих игроков, хотя их учёт можно добавить.
Теоретически задача не должна стать слишком сложной: пусть игроки сыграют несколько раз и посмотрят на соотношение побед. Но, к сожалению, этот естественный подход неидеален. Вот почему:
* нельзя определить, что именно значит близкое к 100% соотношение побед: или игрок исключительный, или ему проиграли только слабые соперники;
* если игрок сыграл всего несколько игр, то в оценке его силы высока неопределённость. При «сыром» соотношении побед этой проблемы нет.
Задачи, которые формулируются как игры «один на один», часто встречаются при ранжировании. Это касается:
* игроков в реальном соревновании: теннис, гонки, карточные игры, бои покемонов и т. д.
* результатов поиска: чем они релевантнее запросу пользователя, тем лучше;
* рекомендаций: чем они релевантнее тому, что пользователь захочет купить, тем лучше, и т. д.
Давайте при помощи PyMC создадим простую байесовскую модель, где решается эта задача ранжирования. Подробности о модели [смотрите](https://towardsdatascience.com/conducting-bayesian-inference-in-python-using-pymc3-d407f8d934a5) в моём введении в байесовский мир с PyMC — предшественником PyMC с почти таким же синтаксисом.
Модель Брэдли — Терри
---------------------
Придадим [этой модели](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) байесовское звучание. Пугающее, но на самом деле очень простое.
Что это за модель?
------------------
Вся эта модель сводится к двум допущениям:
1. У каждого игрока (человека, покемона) есть сила игры, у результата поиска и рекомендации — релевантность и так далее.
2. Если соревнуются игроки 1 и 2, сила которых *s₁* и *s₂* соответственно, игрок 1 выигрывает с такой вероятностью:
**σ* — наша старая добрая сигмоида*
Причём никаких признаков (характеристик) игроков вроде роста или веса человека здесь не используется. А значит, эта модель применима к разным задачам.
Если включить в неё характеристики игроков, то можно получить что-то вроде [RankNet от Microsoft](https://www.microsoft.com/en-us/research/wp-content/uploads/2005/08/icml_ranking.pdf). Чтобы из признаков `x` явным образом построить численные значения силы игроков `s = f(x)`, авторы RankNet используют нейросеть, а в байесовском подходе силы `s` напрямую работают как параметры.
Чтобы построить частотную версию модели Брэдли — Терри при помощи фреймворка глубокого обучения, можно использовать слой встраивания. Давайте проверим работоспособность такого построения модели. Итак, у каждого игрока есть сила. По ней и упорядочиваются игроки.
Допустим, у первого игрока сила намного больше, чем у второго, то есть *s₁ — s₂* — это большое число. Значит, *σ(s₁ — s₂)* близко к единице. Таким образом, с огромной вероятностью выиграет первый игрок. Именно это нам здесь и нужно. В обратной ситуации — аналогично. Если у игроков сила одинакова, вероятность выигрыша каждого из них равна σ(0) = 50%. Идеально.
Создание набора данных
----------------------
Прежде чем строить модель, создадим искусственный набор данных о результатах игр:
И теперь у нас есть преимущество: нам известны признаки, которые нужно искать в модели.
Вот код генерации искусственных данных:
```
import pandas as pd
import numpy as np
np.random.seed(0)
def determine_winner(player_1, player_2):
if player_1 == 0 and player_2 == 1:
return np.random.binomial(n=1, p=0.05)
if player_1 == 0 and player_2 == 2:
return np.random.binomial(n=1, p=0.05)
if player_1 == 1 and player_2 == 0:
return np.random.binomial(n=1, p=0.9)
if player_1 == 1 and player_2 == 2:
return np.random.binomial(n=1, p=0.1)
if player_1 == 2 and player_2 == 0:
return np.random.binomial(n=1, p=0.9)
if player_1 == 2 and player_2 == 1:
return np.random.binomial(n=1, p=0.85)
games = pd.DataFrame({
"Player 1": np.random.randint(0, 3, size=1000),
"Player 2": np.random.randint(0, 3, size=1000)
}).query("`Player 1` != `Player 2`")
games["Player 1 wins"] = games.apply(
lambda row: determine_winner(row["Player 1"], row["Player 2"]),
axis=1
)
```
Набор состоит из данных о трёх игроках, которые соревнуются друг с другом случайным образом. Именно это происходит в функции `determine_winner`: принимается два индекса игроков `(0, 1, 2)` и вывод показывается, если выигрывает `player_1`. Пример: в игре `(0, 1)` игрок 0 выигрывает с вероятностью `p=0.05` у игрока 1.
> Внимательно посмотрите на вероятности в коде: игрок 2 должен быть лучшим, 1 — средним, а 0 — слабейшим.
>
>
Для разнообразия введём четвёртого игрока, который сыграл всего две игры:
```
new_games = pd.DataFrame({
"Player 1": [3, 3],
"Player 2": [2, 2],
"Player 1 wins": [1, 1]
})
games = pd.concat(
[games, new_games],
ignore_index=True
)
```
Игрок 3 сыграл дважды против номера 2 и даже дважды выиграл. Значит, у номера 3 значение силы тоже должно быть высоким. Но нельзя сказать, действительно ли он лучше номера 2 или это была случайность.
Построение модели при помощи PуМС
---------------------------------
Теперь можно построить модель. Обратите внимание: силы игроков обозначаются априорными гауссовыми значениями. Кроме того, для пяти игроков в модели выводятся постериорные значения, хотя для последнего игрока с номером 4 данных нет. Посмотрим, как это происходит.
> Что ещё важно — я не использую сигмоиду явно. Если передать разницу сил игры у игроков через параметр `logit_p`, а не `p`, роль сигмоиды сыграет объект `pm. Bernoulli`.
>
>
```
import pymc as pm
with pm.Model() as model:
strength = pm.Normal("strength", 0, 1, shape=5)
diff = strength[games["Player 1"]] - strength[games["Player 2"]]
obs = pm.Bernoulli(
"wins",
logit_p=diff,
observed=games["Player 1 wins"]
)
trace = pm.sample()
```
Проверим, как распределяются постериорные значения. Выше — апостериорные распределения в виде графиков плотности, ниже — лесовидная диаграмма [forest plot], на которой легко сравнивать постериорные значения силы:
Смотрите: игрок с номером 0 действительно слабейший, за ним следует номер 1. Номера 2 и 3 — лучшие, как и ожидалось. Среднее апостериорного распределения у номера 3 чуть ниже, чем у номера 2. Зато интервал высокой плотности намного больше. То есть неопределённость в отношении силы номера 3 больше по сравнению с номером 2. Постериорное значение силы номера 4 такое же, как априорное. Оно нормально распределено со средним значением 0 и среднеквадратическим отклонением 1. Ничему новому модель здесь научить нельзя. Вот ещё цифры:
Похоже, в этом случае наблюдалось и хорошее схождение MCMC: все значения `r_hat` равны 1.
Кроме того, у некоторых игроков значение силы отрицательное, но это нормально, ведь мы всё равно используем разницу в силе только между двумя игроками. Если вам это по какой-то причине не нравится, замените априорные значения силы на полунормальное распределение `HalfNormal` или просто добавьте к постериорным значениям константу, например 5. Тогда все средние значения и интервалы высокой плотности окажутся в положительном диапазоне.
Заключение
----------
Модель начиналась с априорных представлений об уровнях силы игры, которые затем с помощью данных менялись. Чем больше сыграно игр, тем меньше неопределённость относительно силы игрока. В экстремальном случае, когда игроком не сыграно ни одной игры, апостериорное распределение его силы равно априорному, что логично.
Надеюсь, сегодня вы узнали что-то новое, интересное и полезное. Спасибо за внимание!
А мы поможем разобраться в программировании, чтобы вы прокачали карьеру или стали востребованным профессионалом в IT:
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_280922&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_280922&utm_term=conc)
Чтобы увидеть все курсы, кликните по баннеру:
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_280922&utm_term=banner)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_280922&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_280922&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_280922&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_280922&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_280922&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_280922&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_280922&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_280922&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_280922&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_280922&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_280922&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_280922&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_280922&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_280922&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_280922&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_280922&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_280922&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_280922&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_280922&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_280922&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_280922&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_280922&utm_term=cat) | https://habr.com/ru/post/690560/ | null | ru | null |
# Как приручить жесткий диск в ноутбуке и не дать парковаться за 8 секунд простоя
Итак, вы приобрели новый ноутбук, начинаете его настраивать, устанавливаете операционную систему, весь нужный софт, игрушки. Ничто не предвещает беды. И вот, наконец со всем разобравшись, можно расслабиться и почитать интересную статью в интернете. Но что-то нарушает ваш покой. Странные щелчки доносятся из недр устройства…
Начав прислушиваться, вы периодически улавливаете звук электродвигателя, такой, как у разгоняющегося электромобиля. Может быть оставить все как есть и не трогать, наверное это предусмотрено производителем? Эту прекрасную мысль, полезную во многих других ситуациях, полностью отобьет запуск любой игры или фильма. **Периодическое зависание изображения на 2-3 секунды** станет вашей головной болью и кошмаром на несколько ближайших дней.
В очередной такой «зависон» вы обратите внимание, что ему будет предшествовать щелчок, а в момент зависания услышите тот самый звук электродвигателя. И, немного разбираясь в компьютерном железе, вы зайдете в google с вопросом: «Жесткий диск не дает жить, что делать».
#### Все дело в APM (Advanced Power Management)
Если серьезно, проблема далеко не нова, но даже недавно я видел на хабре комментарии, где люди просили помощь по данному вопросу. Здесь речь идет о дисках WD и реализации функции APM в них, но думаю у других производителей будет та же причина. При беглом поиске google нам любезно предлагает утилиту **wdidle3**. Проблема лишь в том, что это DOS программа требующая создания загрузочной флешки. И, например, для моего диска она не помогла.
Решение, которое я предлагаю особенно полезно, если у вас в качестве основного накопителя установлен SSD, а HDD используется в качестве доп. накопителя. В обычном режиме он будет использовать свое стандартное поведение и отключаться через 8 секунд бездействия, не беспокоя вас своим шумом и не потребляя заряд батареи. При желании сыграть в игру или поработать с жесткого диска, вы нажимаете одну кнопку и он не паркуется заложенное в энергоплане Windows время (20 минут по дефолту). Утилита wdidle не даст вам такого выбора.
#### Используем HDDScan
Собственно к делу. Программа которую мы будем использовать называется **HDDScan**. Причем версии старше 3.2 у меня работали не совсем корректно, поэтому рекомендую остановиться на ней.
Скачиваем эту портабельную программу и распаковываем в удобное для нас место. Запускаем, и **если дисков больше одного, слева выбираем наш HDD**. Далее нажимаем «большую синюю кнопку» по центру и выбираем пункт «Build Command Line».
В открывшемся окне проделываем следующую процедуру: напротив раздела «Advanced Power Managment» выбираем Disable, нажимаем Save, и сохраняем bat-файл. Назовем его, к примеру, «Disable\_HDD\_APM.bat». Аналогично выбираем Enable и сохраняем еще один батник.
В результате у нас появляются два bat-файла примерно одинакового содержания:
```
"C:\Programs\HDDScan\HDDScan.exe" "\\?\scsi#disk&ven_wdc∏_wd7500bpvx-22jc3#4&103b6ba3&0&020000#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" -APM 0
```
и
```
"C:\Programs\HDDScan\HDDScan.exe" "\\?\scsi#disk&ven_wdc∏_wd7500bpvx-22jc3#4&103b6ba3&0&020000#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" -APM 1
```
На этом можно было бы и закончить, эти файлы позволяют отключать функцию APM передавая контроль над временем парковки Windows, и соответственно, включить для возврата исходного поведения. Но, во первых это не очень красиво и удобно, во вторых будет вызываться запрос UAC при запуске bat-файла. Для преодоления этих неудобств предлагаю воспользоваться Планировщиком Windows.
#### Обходим UAC
Запускаем (если что, вводим в пуске «планировщик» чтобы его найти), и создаем задачу.
Для начала отключение APM. Даем осмысленное имя, и главное не забываем выставить выполнение с наивысшими правами. Переходим на вкладку Действия, нажимаем Создать. Здесь указываем путь к нашей программе HDDScan, а в «добавить аргументы», все что идет в батнике после пути к программе. К примеру:
```
"\\?\scsi#disk&ven_wdc∏_wd7500bpvx-22jc3#4&103b6ba3&0&020000#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" -APM 0
```
И довершающий шаг, на вкладке Условия убираем галочку напротив «Запускать только при питании от электросети». Теперь OK.
Фух, создаем вторую задачу, и заполняем аналогично для включения APM (только используем аргумент из второго батника). В результате у нас в планировщике должно стать на две задачи больше, запоминаем их имена. Bat-файлы нам больше не понадобятся, можно будет от них избавиться. Последний этап наших изысканий это создание ярлыков на задачи планировщика.
#### Делаем красиво
Тут все просто, в укромном месте ПКМ -> Создать -> Ярлык. На предложение пути, вводим следующее:
```
C:\Windows\System32\schtasks.exe /run /tn ИмяВашейЗадачи
```
Создаем ярлык сначала для одной, потом для второй задачи. Получаем два ярлычка, которые кладем в надежное место, и, например, кидаем на панель задач. Для красоты можно применить к ним соответствующие иконки.
#### Дело сделано
Это всего лишь один из множества вариантов решений, можно использовать другой софт, по своему настроить планировщик. Но суть в том, что мы можем недостаток обернуть себе на пользу. В особенности, если системным диском стоит SSD: жесткий диск при использовании не будет парковаться и раздражать вас фризами, а в отсутствие активности может отключиться(в зависимости от модели), и избавить вас от побочных эффектов своей работы. | https://habr.com/ru/post/414271/ | null | ru | null |
# Внутренняя оптимизация для индексов в «широком» плане запроса
В [предыдущей статье](https://habr.com/ru/post/711902/) было показано как SQL Server выполняет изменения в некластерных индексах, но пока только в тех случаях, когда данные в индексе действительно изменяются. В примере из прошлой статьи использовался простой оператор UPDATE, который порождает построчный или «узкий» план запроса. В этой статье будет показано как оптимизируется план с изменениями данных с индексами в «[широком](https://learn.microsoft.com/en-us/archive/blogs/bartd/wide-vs-narrow-plans)» плане запроса.
Давайте воспользуемся той же схемой и оператором UPDATE, что и в прошлой статье. Чтобы получить план для каждого индекса мы можем обмануть оптимизатор, заставив его поверить в то, что таблица больше, чем она есть на самом деле. Для этого выполним несколько операций UPDATE STATISTICS с параметрами ROWCOUNT и PAGECOUNT. (Конечно, мы могли бы увеличить таблицу, вставив больше строк, но способ с UPDATE STATISTICS работает быстрее.)
```
CREATE TABLE T (PK INT, A INT, B INT, C INT, D INT, E INT)
CREATE UNIQUE CLUSTERED INDEX TPK ON T(PK)
CREATE INDEX TB ON T(B)
CREATE INDEX TCD ON T(C,D)
CREATE INDEX TE ON T(E)
INSERT T VALUES(0, 10, 20, 30, 40, 50)
UPDATE STATISTICS T WITH ROWCOUNT = 100000, PAGECOUNT = 10000
UPDATE STATISTICS T (TB) WITH ROWCOUNT = 100000, PAGECOUNT = 1000
UPDATE STATISTICS T (TCD) WITH ROWCOUNT = 100000, PAGECOUNT = 1000
UPDATE STATISTICS T (TE) WITH ROWCOUNT = 100000, PAGECOUNT = 1000
SET STATISTICS PROFILE ON
UPDATE T SET B = 29, C = 39, D = 49
```
Запустив оператор UPDATE с инструкцией SET STATISTICS PROFILE ON, мы можем увидеть точное количество строк, обработанных каждым оператором изменения индекса:
```
Rows Executes
2 1 |--Sequence
2 1 |--Index Update(OBJECT:([T].[TB]), SET:([PK1036] = [T].[PK],[B1037] = [T].[B]) WITH ORDERED PREFETCH)
2 1 | |--Sort(ORDER BY:([T].[B] ASC, [T].[PK] ASC, [Act1035] ASC))
2 1 | |--Filter(WHERE:(NOT [Expr1031]))
2 1 | |--Table Spool
2 1 | |--Split
1 1 | |--Clustered Index Update(OBJECT:([T].[TPK]), SET:([T].[B] = [Expr1025],[T].[C] = [Expr1026],[T].[D] = [Expr1027]))
1 1 | |--Compute Scalar(DEFINE:([Expr1031]=[Expr1031], [Expr1032]=[Expr1032]))
0 0 | |--Compute Scalar(DEFINE:([Expr1031]=CASE WHEN [Expr1003] THEN (1) ELSE (0) END, [Expr1032]=CASE WHEN [Expr1004] AND [Expr1005] THEN (1) ELSE (0) END))
0 0 | |--Compute Scalar(DEFINE:([Expr1025]=(29), [Expr1026]=(39), [Expr1027]=(49)))
0 0 | |--Compute Scalar(DEFINE:([Expr1003]=CASE WHEN [T].[B] = (29) THEN (1) ELSE (0) END, [Expr1004]=CASE WHEN [T].[C] = (39) THEN (1) ELSE (0) END, [Expr1005]=CASE WHEN [T].[D] = (49) THEN (1) ELSE (0) END))
1 1 | |--Top(ROWCOUNT est 10000)
1 1 | |--Clustered Index Scan(OBJECT:([T].[TPK]), ORDERED FORWARD)
2 1 |--Index Update(OBJECT:([T].[TCD]), SET:([PK1038] = [T].[PK],[C1039] = [T].[C],[D1040] = [T].[D]) WITH ORDERED PREFETCH)
2 1 |--Filter(WHERE:(NOT [Expr1032]))
2 1 |--Sort(ORDER BY:([T].[C] ASC, [T].[D] ASC, [T].[PK] ASC, [Act1035] ASC))
2 1 |--Table Spool
```
Давайте рассмотрим присутствующие в этом плане запроса операторы. Во-первых, обратите внимание, что часть между операторами просмотра кластерного индекса и операторами изменения кластерного индекса выглядит практически идентично построчному плану из [предыдущей статьи](https://habr.com/ru/post/711902/). В частности, обратите внимание, что тут есть похожие операторы «Compute Scalar» которые определяют, какие индексы затронуло и они нуждаются в изменении. [Expr1031] определяет, нужно ли обновлять индекс TB, а [Expr1032] - нужно ли обновлять индекс TCD. Единственная реальная разница между этой частью плана и построчным планом в том, что в этом плане изменение кластерного индекса затрагивает только кластерный индекс и не изменяет ни одного некластерного индекса. Некластерные индексы тут изменяются отдельными операторами.
Далее идёт оператор SPLIT, который преобразует изменение строки в удаление и последующую вставку. Вот почему одна строка на входе SPLIT превращается в две строки на выходе. В этом плане операторы SPLIT и SORT предназначены исключительно для повышения производительности и их обсуждение не входит в рамки нашей темы.
Table Spool — это обычное подвыражение, которое все свои строки на входе передаёт далее на выход несколько раз. В нашем примере Table Spool выдаёт строки дважды: один раз для изменения индекса TB, а другой раз для изменения индекса TCD. Обратите внимание, что Table Spool ниже изменения индекса TCD является вторичным. У него нет входного потока строк, а вместо этого он выдаёт строки из буфера, расположенного между изменениями индекса TB и кластерного индекса.
Оператор Sequence склеивает две части плана вместе. Как следует из названия, каждое дочернее поддерево выполняется последовательно.
Наконец, в SQL Server 2005 впервые появился оператор Filter. Этот оператор для каждой строки проверяют результаты скалярных вычислений и определяет нужны ли изменения в каком-либо некластерном индексе. В нашем примере изменение одной строки влечёт за собой изменение в обоих индексах, и поэтому, после прохождения строки через фильтр, каждый оператор изменения индекса получает две строки (вспомните, что SPLIT преобразовал изменение строки в удаление и вставку).
Если мы выполним тоже самое обновление ещё раз, то увидим, что фильтры отбросят строки, поскольку данные не изменяются, и некластерные индексы менять не нужно. Обратите внимание, что оба оператора изменения индекса не изменяют ни одной строки:
```
Rows Executes
0 1 |--Sequence
0 1 |--Index Update(OBJECT:([T].[TB]), SET:([PK1036] = [T].[PK],[B1037] = [T].[B]) WITH ORDERED PREFETCH)
0 1 | |--Sort(ORDER BY:([T].[B] ASC, [T].[PK] ASC, [Act1035] ASC))
0 1 | |--Filter(WHERE:(NOT [Expr1031]))
2 1 | |--Table Spool
2 1 | |--Split
1 1 | |--Clustered Index Update(OBJECT:([T].[TPK]), SET:([T].[B] = [Expr1025],[T].[C] = [Expr1026],[T].[D] = [Expr1027]))
1 1 | |--Compute Scalar(DEFINE:([Expr1031]=[Expr1031], [Expr1032]=[Expr1032]))
0 0 | |--Compute Scalar(DEFINE:([Expr1031]=CASE WHEN [Expr1003] THEN (1) ELSE (0) END, [Expr1032]=CASE WHEN [Expr1004] AND [Expr1005] THEN (1) ELSE (0) END))
0 0 | |--Compute Scalar(DEFINE:([Expr1025]=(29), [Expr1026]=(39), [Expr1027]=(49)))
0 0 | |--Compute Scalar(DEFINE:([Expr1003]=CASE WHEN [T].[B] = (29) THEN (1) ELSE (0) END, [Expr1004]=CASE WHEN [T].[C] = (39) THEN (1) ELSE (0) END, [Expr1005]=CASE WHEN [T].[D] = (49) THEN (1) ELSE (0) END))
1 1 | |--Top(ROWCOUNT est 10000)
1 1 | |--Clustered Index Scan(OBJECT:([T].[TPK]), ORDERED FORWARD)
0 1 |--Index Update(OBJECT:([T].[TCD]), SET:([PK1038] = [T].[PK],[C1039] = [T].[C],[D1040] = [T].[D]) WITH ORDERED PREFETCH)
0 1 |--Filter(WHERE:(NOT [Expr1032]))
2 1 |--Sort(ORDER BY:([T].[C] ASC, [T].[D] ASC, [T].[PK] ASC, [Act1035] ASC))
2 1 |--Table Spool
```
Мы тут тоже могли бы использовать другие способы отслеживания работы операторов, которые были продемонстрированы в [предыдущей статье](https://habr.com/ru/post/711902/) (то есть запросы к [sys.dm\_db\_index\_operational\_stats](https://learn.microsoft.com/ru-ru/sql/relational-databases/system-dynamic-management-views/sys-dm-db-index-operational-stats-transact-sql?view=sql-server-ver16), анализ удерживаемых блокировок или отслеживание числа операций логических чтений страниц из памяти), чтобы убедиться, что некластерные индексы в самом деле не обновлялись. Автор предлагает вам попрактиковаться в этом самостоятельно. | https://habr.com/ru/post/713310/ | null | ru | null |
# Новый чемпионат для backend-разработчиков: HighLoad Cup
Проведение конкурсов для IT-специалистов сейчас в моде: Kaggle с его задачами по Data Science, сплоченная тусовка олимпиадного программирования, набирающие популярность площадки для конкурсов по искусственному интеллекту, всевозможные хакатоны для мобильных разработчиков, олимпиады для админов, capture the flag для безопасников. Казалось бы, специалисту любой сферы несложно найти себе подходящую движуху, поучаствовать, прокачаться и что-нибудь выиграть.
Обделенными в этом плане остались лишь web-разработчики. Мы в Mail.Ru Group решили исправить это досадное недоразумение и теперь с радостью представляем вам [HighLoadCup](https://highloadcup.ru/main/) — конкурсную площадку на стыке backend-разработки и администрирования web-сервисов.
Если считаете себя хорошим web-разработчиком, умеете в deploy и highload — добро пожаловать!
### Сроки, призы
Сразу о главном — первый, пилотный чемпионат стартовал вчера, 10-го августа, и продлится вплоть до конца лета — 31-го августа мы подведем итоги и вручим призы. Призовой фонд включает Apple iPad Air 2 Cellular 16 GB за первое место, WD MyCloud 6 TB за второе и третье места, WD MyPassport Ultra 2 TB за места с 4 по 6 включительно. По традиции, ТОП-20 участников получат футболки с символикой чемпионата.
### Механика чемпионата
Участникам дается задание на написание небольшого web-сервиса, работающего с данными определенной структуры и реализующего API к этим данным. Контейнер с реализованным сервисом загружается к нам на сервера, там мы его стартуем и начинаем обстреливать HTTP-запросами. По результатам таких обстрелов мы подсчитываем количество правильных и неправильных ответов, RPS и скорость ответа, и по заранее определенной метрике формируется рейтинговая таблица. Автор наиболее быстрого и отказоустойчивого сервиса и оказывается победителем.
### Как это устроено
Решения отправляют с помощью локально установленного docker-клиента в специальное хранилище. Затем отправленный нам сервис проверяется автоматически системой CodeHub-CodeRunner, разработанной сотрудниками лаборатории Технопарка Mail.Ru Group.
При проектировании решения участник не ограничен ничем, можно использовать абсолютно любые языки и стеки технологий, от классических схем со скриптовым языком и СУБД до самописных велосипедов на C, держащих все нужные данные просто в памяти.
Итак, фактически нужно сделать следующее:
* создать автономное отзывчивое серверное приложение;
* собрать его в docker-контейнер и залить в хранилище;
* обстрелять приложение на выданных боевых данных;
* … победить.
Все решения запускаются как docker-контейнеры на одинаковых серверах с Intel Xeon x86\_64 2 GHz 4 ядра, 4 GB RAM, 10 GB HDD.
### Система обстрела
Система проверки изначально создавалась для другого чемпионата (который нам еще предстоит запустить ;) и была доработана для проведения Highload-соревнований. Внутри запускается yandex-танк с движком phantom, который ведет обстрел в несколько потоков с линейно растущим профилем нагрузки. Предварительно, до начала обстрела у пользовательского решения есть время порядка нескольких минут, чтобы обработать данные из подложенного нами в контейнер JSON-файла. Корректная работа с этими данными — необходимое условие победы. Существует два типа проверки — экспресс-проверка и рейтинговая проверка. Об этом ниже.
### Как проверяются решения
Типы проверки решения: экспресс-обстрел и рейтинговая проверка.
Экспресс-обстрел доступен неограниченное число раз в сутки, составляет по объему примерно 1/10 от рейтинговой проверки решения. Экспресс-проверка не отличается от рейтинговой по структуре, но использует другой набор данных и является способом узнать, готово ли решение для рейтинговой проверки. Предполагается, что экспресс-обстрел занимает не более 3 минут.
Рейтинговая проверка проводится так же, как и экспресс-проверка, просто на большем количестве данных и запросов. Примерно вот так:
* перед обстрелом запланировано 180 секунд ожидания для того, чтобы решение участника могло проанализировать переданные тестовые данные и подготовиться к обстрелу;
* 180 секунд длится первая фаза с линейным профилем от 1 до 200 RPS — будет выпущено: integral (199/180x + 1) dx from 0 to 180 = 18090 GET-запросов;
* 120 секунд длится вторая фаза с постоянным профилем в 100 RPS — будет выпущено: 100 \* 120 = 12 000 POST-запросов, меняющих данные;
* 120 секунд длится третья фаза с линейным профилем от 200 до 2 000 RPS — будет выпущено: integral (1800/120x + 200) dx from 0 to 120 = 132 000 GET-запросов;
* валидация ответов ~20 секунд — анализ результатов на сайте ~30 секунд.
Таким образом, сначала проверяется умение участника разложить данные в нужные ему структуры. В первой фазе обстрела проверяется работа сервиса с начальной небольшой нагрузкой. Во второй — корректность обновления сервисом данных и возможная инвалидация кешей (если они понадобятся решению). В третьей же фазе обстрела мы постепенно наращиваем нагрузку, чтобы пощупать решение на прочность.
По результатам рейтинговой проверки участник занимает определенные места в лидерборде текущего чемпионата. Всего обстрел длится порядка 15 минут (при отсутствии очереди). Всего запросов в обстреле: 162 090. Возможно, в ходе чемпионата это число будет увеличиваться.
Решение участника является контейнером docker, который получен с помощью команды docker build. Максимальный размер контейнера на диске не должен превышать 5 Гб. Система проверки выполнит сначала docker pull и затем docker run. В случае успеха, начнется обстрел решения. Участник может использовать любые серверные технологии, языки, фреймворки по своему усмотрению (C++, Java + Tomcat, Python + Django, Ruby + RoR, JavaScript + NodeJs, Haskell или что-то еще). Также и для хранения данных: MySQL, Redis, MongoDB, Memcached — всё, что получится запихнуть в docker.
В результате обстрела получаются логи и метрики, которые затем будут показываться участникам в виде графиков на странице решения. Отдельно отслеживаются следующие метрики:
* основные метрики;
* корректность ответа;
* время ответа на запрос;
* количество ответов в секунду.
Рейтинг решения считается следующим образом: мы берем время всех верных ответов, которые успел дать API во время обстрела. Прибавляем к этому штрафное время для каждого неправильного ответа или запроса, ответ на который мы не смогли получить (штрафное время всегда равно общему таймауту запроса). Участник, суммарное время которого окажется меньше прочих, оказывается выше в лидерборде и имеет шанс стать победителем чемпионата.
### Задача
В задаче первого чемпионата участникам нужно написать быстрый сервер, который будет предоставлять Web-API для сервиса путешественников. В начальных данных для сервера есть три вида сущностей: User (Путешественник), Location (Достопримечательность), Visit (Посещения). У каждой свой набор полей. Необходимо реализовать следующие запросы:
* `GET //` для получения данных о сущности;
* `GET /users//visits` для получения списка посещений;
* `GET /locations//avg` для получения агрегированных данных;
* `POST //` на обновление сущности;
* `POST //new` на создание сущности.
Максимальное штрафное время на запрос равно таймауту и составляет 2 секунды (2кк микросекунд). Сразу перед запуском мы подкладываем в контейнер с сервисом данные в формате JSON (они будут доступны в /tmp/data). Решению дается некоторое время для того, чтобы вычитать эти данные и разнести их по внутренним структурам (допустим, разложить в БД).
HTTP-запросы приходят в поднятый контейнер на 80 порт, с заголовком Host: travels.com по протоколу HTTP/1.1, один запрос — одно соединение. Сетевые потери полностью отсутствуют.
Более подробное описание задачи, мини-tutorial для быстрого старта и прочие вспомогательные материалы вы найдете на [сайте чемпионата](https://highloadcup.ru/). Кроме того, заходите к нам в [Telegram](https://t.me/highloadcup), там всегда рады ответить на вопросы.
Регистрируйтесь, выигрывайте! Удачи! | https://habr.com/ru/post/335384/ | null | ru | null |
# Другой ответ на вопрос «Нужен ли мне Dart?»
Если вы хотите создавать клиент-серверные веб-приложения, веб-сайты, скрипты, миниигры и вы еще не адепт JS, то ответ однозначно «Да». Если вы флэш разработчик и хочется вновь делать что-то, что запустится в браузере, я бы сказал «Да». Если вы просто хотите научиться программировать и еще не знаете ни одного языка, то Dart будет хорошим и приятным стартом. Под катом я постараюсь развернуть каждое утверждение.
**Я не знаю ни одного языка программирования, почему именно Dart?**
Потому, что можно начать с азов программирования без оглядки на окружение. Это сложно сделать, начиная свой путь с JS, кто-то должен подсказать, что нужно установить NodeJS, а потом придётся объяснить, чем JS из Node отличается от того, что в браузере.
Консольное приложение на Dart, оно же серверное, оно же скриптовое может выглядеть вот так:
```
main() {// Точка входа приложения, прямо как в С
var language = "Dart"; // Объявляем переменную
print('Я хочу изучить $language.'); // Выводим в консоль.
}
```
Начав с Dart, вы потом с лёгкостью сможете перейти на C# или Java. А немного освоившись вы сможете написать что-то, что можно разместить на веб-страничке и похвастаться перед кем-то своими успехами просто отправив ссылку.
**Я флэш-разработчик, с какой стороны подойти?**
У Dart есть такая библиотека как StageXL, это адаптация API из flash. И в целом Dart отличается не сильно от AS3 и в лучшую сторону. А с использованием Dart Toolkit for Flash можно делать арт и анимации прямо во Flash professional, а потом использовать их. Мне как бывшему AS3-программисту даже не пришлось привыкать к новому языку, всё пошло как по накатанной.
**Как делать миниигры?**
Как уже сказано немного выше, StageXL и Dart Toolkit for Flash это именно то, что нужно. Можно смотреть уроки по игрострою на флэш, а потом применять их в Dart.
**Как делать скрипты и что они могут?**
Вместе с SDK поставляется виртуальная машина, в этом плане у Dart те же возможности что у Python или любого другого подобного скриптового языка. Парсить сайты или грабить картинки, работать с локальными файлами, это всё в пределах возможностей.
**Всё-таки я хочу писать сайты, что может Dart?**
Во первых есть AngularDart, высокоуровневая абстракция, позволяет писать сайт модульно с использованием компонентов, использовать связывание переменных с UI. Доступна так же библиотека Angular2. Для тех, кто любит компоненты, но не любит монстров как Angular, есть Polymer. А если хотите что-то быстро сваять в стиле Material Design, то есть Material Design Lite for Dart.
**А что там с сервером, я хочу бэкенд писать уже сегодня?**
Для таких случаев есть Redstone.
```
import 'package:redstone/server.dart' as Server;
void main() {
Server.setupConsoleLog();
Server.start();
}
```
Всё, Карл, сервер запущен и работает. Больше ничего не нужно, ты понимаешь, Карл?
Вы скажете, что этот сервер ничего не умеет, а я скажу, что очень просто научить, добавив вот эти строки:
```
@Server.Route("/hello")
String hello() {
print("User soliciting greeting...");
return "Привет, браузер!";
}
```
И теперь, запустив сервер и открыв страничку по адресу «http:// localhost:8080/hello», мы увидим «Привет, браузер!».
**А смогу ли я на этом языке писать мобильные приложения как на JS с использованием Cordova?**
В этом направлении язык только начал двигаться, есть первые два проекта, которые решают эту задачу, но они совершенно не готовы к коммерческому использованию.
**Заключение.**
В заключении хочу сказать, что для меня основным преимуществом языка является наличие StageXL и интеграции с Flash Professional. Это позволяет так же легко писать простенькие игры и интерфейсы как это было раньше. Если сравнивать Dart с нынешним JS, то преимуществ много, но они очевидны только для тех, кто приходит из таких языков как Java, C#, C++. Если сравнивать с TypeScript, то выбор в пользу Dart становится менее очевидным и это скорее не выбор по каким-то объективным параметрам, а просто по принципу нравится/не нравится. Сравнить Dart с GWT или чем-то подобным я не могу, т. к. не имею опыта. Однако наличие в одном языке всех плюшек (Angular, Polymer, StageXl, Flash Toolkit, Redstone и красивого синтаксиса) делает его одним из лидеров, на которого точно стоит взглянуть тем, кто хочет начать веб-разработку. | https://habr.com/ru/post/269239/ | null | ru | null |
# Rekit Studio: IDE для React-приложений
Сегодня мы публикуем перевод материала Нейта Ванга, создателя Rekit. Здесь он рассказывает о новом стабильном релизе системы, [Rekit Studio](https://github.com/supnate/rekit). Это — полноценная IDE для разработки приложений, созданных с использованием технологий React, Redux и React Router. Он говорит, что его команда создаёт с помощью Rekit сложные веб-приложения уже больше года.
Предыдущая версия Rekit Studio называлась Rekit Portal. Она не поддерживала возможностей по редактированию кода. Теперь, благодаря редактору [Monaco Editor](https://microsoft.github.io/monaco-editor/), того, который используется в [VS Code](https://code.visualstudio.com/), и благодаря замечательному средству для форматирования кода [prettier](https://prettier.io/), Rekit Studio позволяет удобно работать с кодом. Именно поэтому в названии системы появилось слово «studio».
[](https://habrahabr.ru/company/ruvds/blog/349080/)*Rekit Studio*
Как и другие IDE, помимо редактирования текстов программ, Rekit Studio умеет генерировать шаблонный код, поддерживает возможность создания диаграмм зависимостей, помогает разработчику заниматься рефакторингом, сборкой, модульным тестированием проектов, содержит удобные средства для перемещения по коду. Rekit Studio берёт на себя такие задачи, как настройка проекта, конфигурирование webpack, организация структуры директорий. Rekit Studio — это среда, которая содержит в себе средства для управления проектами. Именно это отличает её от обычных редакторов кода, вроде Sublime Text или VS Code.
Прежде чем мы продолжим рассказ о Rekit Studio, предлагаем посмотреть это [демонстрационное видео](https://youtu.be/i53XffYtWMc), посвящённое практическому использованию данной IDE для управления действиями Redux.
Как можно видеть, задача разработчика при использовании Rekit Studio заключается в реализации основного функционала приложения, в то время, как выполнение рутинных операций эта среда разработки берёт на себя.
Установка и запуск Rekit Studio
-------------------------------
Продолжение материала лучше всего читать, параллельно испытывая самостоятельно то, о чём пойдёт речь, в Rekit Studio. Сделать это можно, воспользовавшись одним из двух следующих способов:
1. Подключитесь к интерактивной демонстрационной среде, доступной на <http://demo.rekit.org/>. Это — экземпляр Rekit Studio, запущенный в режиме только для чтения. Поэтому, работая с ним, нельзя внести изменения в проект, открытый в IDE (это — код Rekit).
2. Создайте приложение с помощью Rekit самостоятельно. Для этого нужно выполнить всего три шага:
*Установка Rekit, создание и запуск приложения*
После запуска приложения перейдите по адресу [http://localhost:6075](http://localhost:6075/). Этот адрес Rekit Studio использует по умолчанию.
Как вы можете видеть, Rekit Studio — это всего лишь один из npm-пакетов в вашем проекте, средой, в которой выполняется IDE, является браузер. Благодаря такому подходу у каждого приложения имеется собственный экземпляр Rekit Studio, в результате, вы никогда не столкнётесь с проблемами, касающимися совместимости версий.
Режимы просмотра файлов проекта и кода
--------------------------------------
Практически все IDE для фронтенд-разработчиков содержат простые средства для просмотра структуры папок и файлов. Как результат, навигация по проектам, организованная средствами этих IDE, не учитывает особенностей проектов, что не нравится программистам. Редакторы кода не осведомлены о роли файлов, то есть, они не знают о том, что один файл представляет собой компонент, другой — действие, у них нет сведений о том, какой файл стиля принадлежит некоему компоненту, где определены правила маршрутизации, и так далее. Без подобных сведений, к сожалению, нельзя организовать более удобную навигацию по проекту, нельзя улучшить ситуацию.
Rekit Studio, работая с проектами, следует шаблону организации масштабируемого веб-приложения. И, основываясь на этом, Rekit Studio понимает роль отдельных частей проекта. Подробнее об этом можно почитать [здесь](https://medium.com/@nate_wang/a-new-approach-for-managing-redux-actions-91c26ce8b5da) и [здесь](https://medium.com/@nate_wang/feature-oriented-architecture-for-web-applications-2b48e358afb0).
Основываясь на шаблоне, Rekit Studio знает, какие файлы являются компонентами, какие — действиями, где определены правила маршрутизации, и так далее. Поэтому обозреватель проекта может показать структуру проекта в осмысленном виде. Например, так, как показано ниже.
*Обозреватель проектов*
IDE Rekit Studio осведомлена об особенностях элементов проекта, например — о том, какие действия являются асинхронными (помечены синим значком A), какие компоненты подключены к хранилищу Redux (они отмечены зелёным значком C), какие компоненты управляются маршрутизатором React (у них есть оранжевый значок R), то есть, используются в каких-то правилах маршрутизации.
Благодаря мощному обозревателю, вы можете легко перемещаться между элементами проекта и получать немало информации об элементах, не открывая их и не читая их код.
Стоит сказать, что обозреватель проекта показывает только файлы из папки проекта `src`, поэтому он отличается хорошей производительностью. При этом, если вы хотите редактировать файлы, находящиеся за пределами папки `src`, такие, как `package.json` или `.gitignore`, вам может понадобиться обычный текстовый редактор.
Генерирование кода
------------------
Как и любые другие настоящие IDE, вроде Eclipse для Java или Visual Studio для платформы .Net, Rekit Studio помогает создавать шаблонный код средствами пользовательского интерфейса, работать с которыми предельно просто. Например, для того, чтобы создать компонент, щёлкните правой кнопкой мыши соответствующий узел в обозревателе проекта и выберите команду `Add Component`.
*Добавление компонента*
Помимо ввода имени компонента, тут можно указать, подключён ли он к хранилищу Redux, используется ли он в правиле маршрутизатора React. После щелчка по кнопке `OK` система сгенерирует весь необходимый код и произведёт нужные настройки. Результаты всего этого можно видеть в журнале операций. Например, тут могут быть записи о создании less/scss-файла для стилизации и файла с тестами, сведения о добавлении правила маршрутизатора React для доступа к компоненту по URL (если задана соответствующая настройка), и так далее. Тут, на самом деле, нет ничего сверхъестественного. Rekit Studio просто помогает разработчику делать то, что раньше приходилось делать вручную, а благодаря журналу программист точно знает о том, что именно было сделано.
Для создания асинхронных действий Redux, Rekit Studio использует, по умолчанию, `redux-thunk`.
*Добавление асинхронного действия*
Ещё один подход к созданию асинхронного действия подразумевает использование `redux-saga`. Для этого нужно установить плагин `rekit-plugin-redux-saga`. О плагинах мы поговорим ниже.
Все имена файлов, имена функций или переменных, следуют в Rekit Studio предопределённым правилам, описанным [здесь](http://rekit.js.org/docs/namings.html). Поэтому, даже если вы, при создании компонента, введёте имя вроде `my component` в поле ввода имени, Rekit конвертирует его в `MyComponent`. Благодаря такому подходу все имена в проекте всегда единообразны.
Шаблоны кода, о которых идёт речь, всегда создаются с использованием рекомендованных подходов к разработке. Вам нужно лишь внести в них рабочий код приложения, всё остальное будет сделано автоматически. Когда код сгенерирован, его можно свободно править.
Инструменты рефакторинга
------------------------
При создании большого приложения рефакторинг — это очень важно. Это позволяет сделать код чистым, читабельным и хорошо управляемым. Некоторые из важных аспектов рефакторинга — переименование, перемещение, удаление элементов проекта. При работе с современными средствами разработки фронтенда работы по рефакторингу чрезмерно усложняются. Например, если нам нужно переименовать асинхронное действие, обычно нужно отредактировать несколько файлов и модифицировать многие десятки строк кода в различных местах. Предположим, что мы хотим изменить имя асинхронного действия с `fetchTopics` на `fetchTopicList`. Для этого в проект придётся внести следующие изменения:
*Переименование асинхронного действия и изменения, внесённые в проект*
Выглядит это настолько безумно, что мало кому захочется делать всё это вручную. Те же неудобства сопровождают перемещение или удаление компонентов и действий. Без инструментальной поддержки все эти проблемы отбивают у многих из нас охоту заниматься рефакторингом кода. Это приводит к тому, что нашими проектами становится сложно управлять уже очень скоро после начала работы над ними.
Теперь, благодаря Rekit Studio, для переименования, перемещения или удаления компонента достаточно воспользоваться соответствующим пунктом меню, вызываемым правой кнопкой мыши. Rekit Studio сделает всё, что нужно, автоматически, а разработчик может взглянуть в журнал для того, чтобы увидеть перечень выполненных действий.
*Рефакторинг*
Анализ проекта с помощью диаграмм
---------------------------------
Когда проект растёт, взаимодействия и взаимозависимости его составных частей становятся сложными. Чрезмерное усложнение взаимоотношений частей проектов чревато проблемами, выливающимися в сложность поддержки кода. Помощь в анализе связей между частями проектов могут оказать соответствующие инструменты. В Rekit Studio такие инструменты имеются. Речь идёт о диаграммах зависимостей.
### ▍Обзорная диаграмма
Эта диаграмма отображается на странице с панелью управления (на домашней странице). С её помощью можно не только видеть зависимости между функциональными возможностями приложения (в терминологии Rekit они называются features и представляют собой высокоуровневые составные части приложений), но и анализировать взаимоотношения между обычными модулями вроде компонентов и действий. Благодаря обзорной диаграмме можно понять, например, сложность задачи по рефакторингу какого-либо компонента. Чем зависимостей больше — тем осторожнее следует обращаться с компонентом приложения.
*Поиск неиспользуемых компонентов*
Эта диаграмма также помогает в поиске неиспользуемых модулей. Например, на рисунке выше показана диаграмма для проекта, в котором, в функциональной возможности `Home`, имеются два неиспользуемых компонента. Обычно такие компоненты можно без проблем удалить. Удаление ненужного кода помогает снизить сложность проекта и уменьшить размер пакета приложения.
### ▍Диаграмма элемента
Если открыть элемент из обозревателя проекта, можно, в соответствующей панели, увидеть диаграмму элемента. С её помощью можно оценить взаимодействие элемента с другими частями проекта.
*Диаграмма элемента*
Например, на рисунке выше показана диаграмма для `SidePanel` — сложного компонента, который использует много других компонентов и действий. Кроме того, у него есть зависимости от других функциональных возможностей приложения. Возможно, этот компонент стоит подвергнуть рефакторингу для того, чтобы упростить его и повысить удобство работы с ним.
Сборка и тестирование
---------------------
Как и другие полноценные IDE, Rekit Studio может выполнять сборку и тестирование проектов. По умолчанию Rekit Studio попытается запустить команду `npm run build` для сборки проекта и команду вида `npm test — [test-file-pattern]` для запуска модульных тестов.
Для выполнения сборки проекта выберите пункт `Build` главного меню:
*Сборка проекта*
Затем вы увидите индикатор выполнения операции и сведения о результатах выполнения сборки. Прежде чем разворачивать продакшн-сервер, вы можете проверить результаты сборки, обратившись к серверу разработки, который доступен по адресу [http://localhost:6077](http://localhost:6077/).
Для запуска модульных тестов можно либо запустить их все, выбрав пункт `Run tests` из главного меню, либо выбрать конкретный тест для запуска.
*Запуск тестов и результаты тестирования*
Выше показаны результаты тестов функциональной возможности `diagram`. Если запустить все тесты проекта, будет создан отчёт о покрытии тестами кода. Посмотреть его можно из главного меню.
*Отчёт о проведении тестов*
Система поддержки плагинов
--------------------------
Выше мы уже говорили о том, что Rekit Studio может создавать шаблоны функциональных возможностей проектов, действий, компонентов. Если нужно создавать какие-то новые элементы, вроде селекторов, или требуется изменить стандартный код шаблона, например — использовать `redux-saga` вместо `redux-thunk` для создания асинхронных действий, сделать это можно посредством создания плагинов. [Здесь](http://rekit.js.org/docs/plugin.html) можно почитать подробности о системе плагинов Rekit Studio.
Интерфейс командной строки
--------------------------
Помимо вышеописанного графического интерфейса, Rekit Studio имеет [интерфейс](http://rekit.js.org/docs/cli.html) командной строки, с помощью которого можно управлять проектами. На самом деле, и Rekit Studio, и Rekit CLI используют `rekit-core` для управления элементами проектов. Система командной строки поддерживает больше видов плагинов, чем Rekit Studio. Если говорить о развитии системы, то планируется улучшить поддержку плагинов и создать унифицированный интерфейс для работы с ними.
Переход с Rekit Portal на Rekit Studio
--------------------------------------
Если ваш проект использует Rekit Portal, перейти на Rekit Studio очень просто, так как IDE Rekit Studio полностью совместима с проектами, созданными в Rekit Portal. Всё, что нужно — установить Rekit Studio и обновить скрипт для запуска системы в `server.js`. [Вот](https://github.com/supnate/rekit-boilerplate/commit/5186b5c3ec141b5306471c52a8955dfb288598bd) описание этого процесса.
Преобразование существующего проекта в проект Rekit
---------------------------------------------------
Если у вас уже есть проект, созданный на основе React, Redux и React Router, можно преобразовать его в проект Rekit, что даст вам возможность использовать Rekit Studio для работы с этим проектом. Обычно это не особенно сложно (хотя, для того, чтобы это объяснить, понадобится отдельная статья). Если в двух словах, то для переноса существующего проекта в Rekit Studio нужно реорганизовать файлы и код так, как это принято в Rekit.
О развитии Rekit
----------------
Надо отметить, что Rekit Studio всё ещё находится на раннем этапе развития, хотя мы используем его для создания веб-приложений уже довольно давно и нам нравится работать в этой IDE. Мы продолжаем работать над Rekit и пользоваться этой IDE для решения наших повседневных задач. Вот некоторые улучшения, которые планируется внести в Rekit:
* Улучшение подсветки синтаксиса.
* Поддержка собственных правил ESlint.
* Улучшение автозавершения кода, например, касающееся имён модулей.
* Быстрое открытие файлов с использованием горячих клавиш `Cmd + P`.
* Поддержка нескольких несохранённых файлов. Сейчас лишь один файл может пребывать в несохранённом состоянии, что направлено на защиту от потери изменений кода.
* Поддержка большего числа видов диаграмм.
* Поддержка возможности создавать, переименовывать и удалять обычные файлы, помимо файлов компонентов и действий.
* Интеграция со Storybook.
* Поддержка TypeScript.
* Поддержка серверного рендеринга.
На самом деле, этот список можно и расширить — всё зависит от потребностей пользователей Rekit.
Итоги
-----
Хотя технологии разработки фронтенда эволюционируют очень быстро, Rekit, представляющий собой лишь набор инструментов, а не фреймворк, уже около двух лет демонстрирует высокую стабильность. Те принципы, на которых основана IDE Rekit Studio, не зависят от технологий.
В итоге, хотелось бы отметить, что Rekit не предоставляет какие-либо SDK или npm-пакеты для вашего приложения. Это — лишь инструмент для создания проектов и для управления ими. И без Rekit вы можете использовать любые текстовые редакторы для того, чтобы писать код, можете использовать терминал для запуска скриптов для проекта, созданного в Rekit. Таким образом, использование Rekit не означает зависимости от него.
**Уважаемые читатели!** Планируете ли вы использовать Rekit Studio в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/349080/ | null | ru | null |
# Программная генерация PDF форм на ABAP или как избавиться от проблем со SPOOL
#### С чего все началось
Специфика компании, в которой я работаю, подразумевает тесный контакт и сотрудничество с нашими клиентами. Одним из таких бизнес-процессов является рассылка различной документации как по почте, так и на бумажных носителях по наше ~~не любимой~~ почте в конвертах. Стандартный функционал, который позволяет генерировать печатные формы PDF и выводить их на печать или публиковать куда-либо в бинарном виде использует фоновые задачи и SPOOL данных печати.
Поначалу все было прекрасно, данные формировались, клиенты были довольны. Но в один момент все накрылось «медным тазом», объемы генерируемых печатных форм значительно выросли, SPOOL стал сильно «засераться», что приводило к жутким тормозам всей серверной части. Об одном из способов решения этой проблемы я и хочу рассказать в данной статье.
#### Поехали
Как это обычно бывает, первым делом все бегут с подобными проблемами к базистам, которые отвечают за работу серверной части и оптимизацию кучи различных настроек в конфигурационных файлах. Что в результате: прочитана куча SAP Notes, проштудированы форумы, потом начались изменения параметров, что-то дало небольшой прирост производительности, где-то наоборот. Но в конечном результате нужного эффекта так и не получили. Само собой давление руководства и недовольных клиентов возрастало, так как формирование документов занимало все больше и больше времени и о какой либо клиентоориентированность не могло быть и речи, что пагубно влияло на престиж компании. В результате было принято решение попробовать разобраться с проблемой на программной уровне.
Хватит уже прелюдий, перейдем к технической стороне вопроса.
#### Анализ базисного кода
Поначалу я решил разобраться как же все таки работает стандартный функционал генерации PDF форм, в результате Drill down, я натолкнулся на пакет **SAFP**, который раскрыл мне глаза на все происходящее и кажется пол дела было уже решено. Проанализировав примеры программ я выяснил, что для меня встали следующие основные задачи:
1. Создать XFT файл формуляра;
2. Сгенерировать XFD файл, содержащий данные;
3. Получить бинарный файл и PDL файл, который понимает принтер;
#### Создать XFT файл формуляра
Тут для меня было два вариант решения, либо самому создать этот файл и хранить его где-то на сервере приложений, что было бы неразумно с точки зрения поддержки и актуализации, либо не придумывать велосипед и сразу же получать ссылку на готовый формуляр, который удобно редактировать и тестировать через транзакцию SFP. Пойдем по пути наименьшего сопротивления:
```
DATA:
l_xdp TYPE fpwbformname VALUE 'ZTEST', " Имя формуляра
l_xft TYPE string, " Путь к формуляру на сервере приложений
l_except TYPE REF TO cx_fp_api_repository. " Для обработки данных
TRY.
cl_fp_wb_helper=>form_layout_exists( i_name = l_xdp ).
CATCH cx_fp_api_usage. "#EC NO_HANDLER
CATCH cx_fp_api_repository INTO l_except.
IF l_except->textid = cx_fp_api_repository=>object_already_exists.
l_xft = cl_fp_wb_helper=>form_layout_url( i_name = l_xdp
i_dest_path = 'X' ).
ELSE.
MESSAGE ID 'FPRUNX' TYPE 'E' NUMBER '050' WITH sy-langu.
ENDIF.
ENDTRY.
```
Здесь мы проверяем существует ли формуляр в системе с заданным именем и если получаем положительный ответ, то считываем путь к этому формуляру.
#### Генерируем XFD файл, содержащий данные
Сформировать PDF файл — это еще пол дела. Нам необходимо наполнить его данными, чтобы это сделать нужно сгенерировать файл с данными XFD, который представляет из себя обычный xml файла. Лучшее для меня решения было — это использовать трансформации. Итак приступим.
Как нам узнать как должен выглядеть файл после трансформации, чтобы он успешно применился к нашему формуляру? Сделать это очень просто, заходим в транзакцию SFP, открываем нужный нам формуляр и включаем отладку, как показано на рисунках ниже:
**Режим отладки формуляра**Выбираем в формуляре Параметры настройки
Далее ставим режим отладки, это позволит нам после вывода печатной формы получить файлы во вложении
Запускаем печатную форму на тест и получаем необходимые файлы во вложении PDF, нас интересует XFD.xml
Итак, мы получили файл представления данных для печатной формы, теперь нам не составит труда создать трансформацию и вызывать ее в дальнейшем:
```
CALL TRANSFORMATION ztest_trans
SOURCE
is_data = it_data
RESULT XML xstr.
```
#### Получить бинарный файл и PDL файл, который понимает принтер
Итак, у нас есть все необходимое для того, чтобы сформировать печатную форму. Правда тут есть один нюанс. В природе как выяснилось существует различные типы принтеров, одни цветные, другие нет. Для определенной группы принтеров применяются так называемые шаблоны XSD, применяемые для генерации PDF файлов. Более подробно о их типах и классификации написано [тут](http://help.adobe.com/en_US/livecycle/9.0/workbenchHelp/help.htm?content=001154.html).
Мы будем использовать hppcl5c.xdc, так как он идеально подходит для нашей задачи, в том числе позволяет распечатывать на цветном принтере. Что мы получили:
**Немного кода**
```
DATA: l_fp TYPE REF TO if_fp,
l_pdfobj TYPE REF TO if_fp_pdf_object,
pdfresult TYPE xstring,
pdlresult TYPE xstring.
* получаем ADS-соединение
MOVE cl_fp=>get_ads_connection( ) TO l_dest.
* получаем FP reference
l_fp = cl_fp=>get_reference( ).
TRY.
* создаем объект PDF
l_pdfobj = l_fp->create_pdf_object( connection = l_dest ).
* указываем наш шаблон, который мы нашли ранее
l_pdfobj->set_template( xftfile = l_xft ).
* задам данные для шаблона
l_pdfobj->set_data( formdata = l_xfd ).
* говорим объекту PDF создать PDF
* так же в классе есть другие задачи, которые можно глянуть в описании класса
l_pdfobj->set_task_renderpdf( ).
* говорим объекту PDF создать PDL файл
CALL METHOD l_pdfobj->set_task_renderpdl
EXPORTING
pdltype = 'pcl'
pdlfile = ''
xdcname = 'hppcl5c.xdc'.
DATA: form TYPE string.
form = i_fpwbformname.
l_pdfobj->set_application_form_identity( application = 'SAFP'
form = form ).
* запускаем наши задачи, вызвав ADS
TRY.
l_pdfobj->execute( ).
CATCH cx_fp_runtime_internal
cx_fp_runtime_system
cx_fp_runtime_usage. "#EC NO_HANDLER
ENDTRY.
* получаем результат в формате XSTRING
l_pdfobj->get_pdf( IMPORTING pdfdata = pdfresult ).
CALL METHOD l_pdfobj->get_pdl
IMPORTING
pdldata = pdlresult.
ENDTRY.
```
#### Итоги
В результате после применения данного подхода, удалось вообще исключить SPOOL как таковой в цепочке. Это позволило нам создавать довольно крупные объемы печатных форм в фоновом режиме не загружая сервер, на текущий момент порядка 5000 документов за 3 часа. Стоит обратить внимание, что такой подход позволяет так же совершать другие операции с PDF, например цифровую подпись со стороны сервера. Более детально можно изучить примеры в пакете, о котором я говорил выше в статье **SAFP**. | https://habr.com/ru/post/201280/ | null | ru | null |
# Отчёты для NORD POS. Часть 2
### Берём jrxml шаблон и устанавливаем в приложение
В [первой части](http://habrahabr.ru/post/247515/) я рассказал о том, как подготовить в iReport шаблон отчёта для библиотеки JasperReports. А эта статья посвящена тому, как получившийся шаблон интегрировать непосредственно в приложение [NORD POS](http://www.nordpos.mobi). И если в первой части программа нужна была только, как источник данных для построения примера отчёта по справочнику товаров, то в данной статье она будет необходима для интеграции отчёта в интерфейс приложения, а также для демонстрации возможностей взаимодействия бизнес логики приложения и элементов шаблона библиотеки JasperReports.
Кроме этого, пришлось разделить статью на две части из-за того, что при подготовки материала я обнаружил ошибку печати отчёта в версии 3.0.1CE. Ошибка возникала из-за неправильного вызова диалога выбора принтера при использовании не стандартного оформления из Swing Look&Feel библиотеки [Insubstantial](http://insubstantial.github.io/insubstantial/). Ошибка не возникала при использовании темы Metal или оформления в стиле операционной системы. Но, так как в NORD POS по-умолчанию используется нестандартная тема CremeSkin, то для написания этой части необходимо было устранить данный баг и выпустить обновлённую версию [NORD POS 3.0.2CE](http://nordpos.mobi/#download). И именно эту версию мы будем использовать во второй части статьи.
#### Размещаем шаблон
Чтобы установить шаблон отчёта не обязательно скачивать исходники всего приложения, достаточно сохранить файл из iRepot в папке **reports** установленного приложения указав путь **./reports/io/example/reports/** для него. Кроме того, необходимо создать BeanShell скрипт для инициализации шаблона в NORD POS, а также ресурс Properties локализации текстовых полей шаблона.
#### Пишем скрипт
Код скрипта должен инициализировать наш шаблон отчёта в программе и передать значения из базы данных приложения в поля формы. И так в первой строке скрипта делаем инициализацию класса **PanelReportBean()**, отвечающего за взаимодействие с библиотекой JasperReports:
```
report = new com.openbravo.pos.reports.PanelReportBean();
```
Задаём для него основные параметры:
```
report.setTitleKey("Menu.ExtProducts"); // Задаём название панели
report.setReport("/io/example/reports/productsext"); // Указываем на файл формирующего отчёт
report.setResourceBundle("io/example/reports/productsext_messages"); // и на файл локализации
```
И строку SQL-запроса для получения значения из базы данных:
```
report.setSentence("SELECT"+
" PRODUCTS.NAME AS PRODUCT_NAME" +
", PRODUCTS.REFERENCE AS PRODUCT_REFERENCE" +
", PRODUCTS.PRICESELL AS PRODUCT_PRICESELL" +
", PRODUCTS.CATEGORY AS CATEGORY_ID" +
", CATEGORIES.NAME AS CATEGORY_NAME" +
", PRODUCTS.TAXCAT AS TAX_ID" +
" FROM PRODUCTS" +
" LEFT OUTER JOIN CATEGORIES ON PRODUCTS.CATEGORY = CATEGORIES.ID" +
" LEFT OUTER JOIN TAXCATEGORIES ON PRODUCTS.TAXCAT = TAXCATEGORIES.ID" +
" LEFT OUTER JOIN TAXES ON TAXCATEGORIES.ID = TAXES.CATEGORY" +
" WHERE ?(QBF_FILTER)" +
" ORDER BY CATEGORIES.NAME, PRODUCTS.NAME");
```
Здесь нужно обратить внимание на условие **WHERE ?(QBF\_FILTER)**, оно позволяет вставить в запрос фильтр из интерфейса приложения. Например для справочника товаров это **ProductFilter()** с следующими полями параметров:
```
report.addParameter("PRODUCTS.NAME");
report.addParameter("PRODUCTS.PRICEBUY");
report.addParameter("PRODUCTS.PRICESELL");
report.addParameter("PRODUCTS.CATEGORY");
report.addParameter("PRODUCTS.CODE");
report.addQBFFilter(new com.openbravo.pos.ticket.ProductFilter());
```
С помощью фильтра пользователь NORD POS сможете сделать выборку по цене товара, его категории или использую регулярное выражение SQL выбрать товар только с определённым названием. Например, выражение **А%**, даст нам список товаров начинающихся только на букву «А» из любой категории.
В конце нашего скрипта обязательно нужно указать поля, которые будут использоваться в jrxml-шаблоне для построения отчёта:
```
report.addField("PRODUCT_NAME", com.openbravo.data.loader.Datas.STRING);
report.addField("PRODUCT_REFERENCE", com.openbravo.data.loader.Datas.STRING);
report.addField("PRODUCT_PRICESELL", com.openbravo.data.loader.Datas.DOUBLE);
report.addField("CATEGORY_ID", com.openbravo.data.loader.Datas.STRING);
report.addField("CATEGORY_NAME", com.openbravo.data.loader.Datas.STRING);
report.addField("TAX_ID", com.openbravo.data.loader.Datas.STRING);
report;
```
И вызвать средствами BeanShell скрипта созданный нами отчёт.
**Полный готовый текст скрипта**report = new com.openbravo.pos.reports.PanelReportBean();
report.setTitleKey(«Menu.ProductList»); // Задаём название панели
report.setReport("/io/example/reports/productsext"); // Указываем на файл формирующего отчёт
report.setResourceBundle(«io/example/reports/productsext\_messages»); // и на файл локализации
report.setSentence(«SELECT»+
" PRODUCTS.NAME AS PRODUCT\_NAME" +
", PRODUCTS.REFERENCE AS PRODUCT\_REFERENCE" +
", PRODUCTS.PRICESELL AS PRODUCT\_PRICESELL" +
", PRODUCTS.CATEGORY AS CATEGORY\_ID" +
", CATEGORIES.NAME AS CATEGORY\_NAME" +
", PRODUCTS.TAXCAT AS TAX\_ID" +
" FROM PRODUCTS" +
" LEFT OUTER JOIN CATEGORIES ON PRODUCTS.CATEGORY = CATEGORIES.ID" +
" LEFT OUTER JOIN TAXCATEGORIES ON PRODUCTS.TAXCAT = TAXCATEGORIES.ID" +
" LEFT OUTER JOIN TAXES ON TAXCATEGORIES.ID = TAXES.CATEGORY" +
" WHERE ?(QBF\_FILTER)" +
" ORDER BY CATEGORIES.NAME, PRODUCTS.NAME");
report.addParameter(«PRODUCTS.NAME»);
report.addParameter(«PRODUCTS.PRICEBUY»);
report.addParameter(«PRODUCTS.PRICESELL»);
report.addParameter(«PRODUCTS.CATEGORY»);
report.addParameter(«PRODUCTS.CODE»);
report.addQBFFilter(new com.openbravo.pos.ticket.ProductFilter());
report.addField(«PRODUCT\_NAME», com.openbravo.data.loader.Datas.STRING);
report.addField(«PRODUCT\_REFERENCE», com.openbravo.data.loader.Datas.STRING);
report.addField(«PRODUCT\_PRICESELL», com.openbravo.data.loader.Datas.DOUBLE);
report.addField(«CATEGORY\_ID», com.openbravo.data.loader.Datas.STRING);
report.addField(«CATEGORY\_NAME», com.openbravo.data.loader.Datas.STRING);
report.addField(«TAX\_ID», com.openbravo.data.loader.Datas.STRING);
report;
#### Локализуем поля
Для этого нам необходимо вернутся в iReport и заменить поля подписей на текстовые, чтобы в выражение указать переменную вида **$R{label.key}** для локализации. Например для шапки отчёта задаём значение **$R{label.title}** в в текстовом поле jrxml-шаблона.
После чего добавляем для этого ключа значение в файл **productsext\_messages.properies**.
```
label.title=List of Products
label.line.number=N
label.product.reference=Reference
label.product.name=Name
label.product.price=Price
label.product.vat=VAT
label.product.TaxPrice=Price+Tax
label.report.summary=Summary
```
В качества базового языка лучше использовать английский добавив затем к нему перевод на другом языке. Например для русского языка это будет **productsext\_messages\_ru.properies** файл.
```
label.title=Список товаров
label.line.number=№
label.product.reference=Артикул
label.product.name=Название
label.product.price=Цена
label.product.vat=НДС
label.product.TaxPrice=Цена+Налог
label.report.summary=Всего позиций
```
#### Пересчитываем налоги
В первой части ставку налога мы брали непосредственно из базы данных, но формируя отчёт из приложения, лучше вести расчёт ставки и суммы налога использую специально для этого предназначенный метод **getTaxRate** класса **TaxesLogic**. Для этого в шаблоне надо создать параметр **TAXESLOGIC**.
**Тег параметров в XML-шаблоне**
```
```
Который вызывается при расчёте цены и получает ставку налогу непосредственно на дату составления отчёта, что позволяет использовать возможности NORD POS для расчёта НДС в случае изменения её ставки после определённой даты.
**Поле цены с налогом на дату отчёта**
```
com.openbravo.format.Formats.CURRENCY.formatValue(
new Double(
$F{PRODUCT\_PRICESELL}.doubleValue() \*
(1.0 + $P{TAXESLOGIC}.getTaxRate($F{TAX\_ID}, new Date()))
)
)
```
Также в данном примере вместо паттерна самого шаблона для денежных значений используется паттерн приложения, чтобы обеспечить единообразие вывода всех значений.
#### Добавляем логотип и QR-код
Также с помощью вызова методов внешних классов в отчёт можно добавить различные ресурсы родительского приложения. Например в базе данных NORD POS хранится изображение логотипа. Вставить его в отчёт с помощью SQL-запроса не получится, но можно воспользоваться методом **getResourceAsImage** класса **DataLogicSystem**, вызвав его запросом из выражения поля изображения.
```
com.openbravo.pos.forms.DataLogicSystem.getResourceAsImage("Window.SupportBy")
```
**Поле изображения логотипа**
```
com.openbravo.pos.forms.DataLogicSystem.getResourceAsImage("Window.SupportBy")
```
Или, например, в JasperReports среди поддерживаемых штрих-кодов нет QR-кода, а в NORD POS интегрирована библиотека [ZXing](https://github.com/zxing/zxing), с помощью неё можно сгенерировать QR-кода для отчёта например с ссылкой на сайт.
```
com.nordpos.device.util.BarcodeImage.getQRCode("http://nordpos.mobi")
```
**Поле QR-кода ссылки на сайт**
```
com.nordpos.device.util.BarcodeImage.getQRCode("http://nordpos.mobi")
```
#### Настраиваем доступ
Теперь остался последний шаг, это открыть доступ к отчёту из NORD POS. С начала добавим кнопку нашего отчёт в интерфейс приложения. Открываем в **Настройки -> Ресурсы**, находим BeanShell-скрипт **Menu.Root** и добавляем в раздел **MenuSalesManagement** панель отчёта.
```
submenu.addPanel("/com/openbravo/images/appointment.png", "Menu.ProductList", "/io/example/reports/productsext.bsh");
```
Второй шаг, это разрешить в профиле для группы пользователей доступ к отчёту. Переходим **Настройки -> Профили**, выбираем роль из списка и добавляем в XML-документ разрешение доступа к нашему отчёту.
```
```
Всё, перезагружаем NORD POS, открываем панель отчёта и формируем его. На этом задача по созданию отчёта для NORD POS успешно завершена.
Кроме создания отчётов с помощью средств JasperReports в NORD POS можно формировать этикетки, заполнять таблицы, строить графики и диаграммы, но о заложенных для этого основах я постарался рассказать читателям Хабра в этой статье. А в дальнейшем, если это будет интересно, то я хочу продолжить рассказ о других возможностях NORD POS, которые появились благодаря использованию сторонних библиотек. Но прежде хотел бы сделать небольшой опрос среди тех читателей, кто обе части дочитал до конца. | https://habr.com/ru/post/248587/ | null | ru | null |
# Kali Linux получил графический интерфейс для подсистемы Windows для Linux (WSL2). Инструкция по установке
Команда разработчиков Kali Linux [представила](https://www.kali.org/docs/wsl/win-kex/) графический интерфейс для подсистемы Windows для Linux (WSL). Решение называется Win-Kex (Windows + Kali Desktop EXperience). Теперь можно запускать популярный дистрибутив для пентеста на ПК с Windows 10 в WSL2 с GUI.
Специалисты портала Bleeping Computer проверили, что это действительно работает. Они [опубликовали](https://www.bleepingcomputer.com/news/security/kali-linux-gets-a-gui-desktop-in-windows-subsystem-for-linux/) свою инструкцию по установке и запуску Kali Linux с графическим интерфейсом для подсистемы Windows для Linux (WSL2).
Установка Kali Linux с GUI возможна только на ПК с ОС Windows 10 версии 2004.
На подготовительном этапе необходимо в ОС активировать подсистему Windows для Linux.
Открыть PowerShell (сейчас и далее под администратором) и запустить:
```
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
```
Перезагрузить ПК.
Открыть PowerShell и запустить:
```
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
```
```
dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
```
Перезагрузить ПК.
Далее необходимо [скачать](https://docs.microsoft.com/ru-ru/windows/wsl/wsl2-kernel) и установить WSL2.
Потом нужно открыть PowerShell и запустить:
```
wsl --set-default-version 2
```
Далее нужно [установить](https://www.microsoft.com/en-us/p/kali-linux/9pkr34tncv07?activetab=pivot:overviewtab) Kali Linux из магазина Microsoft Store.
Чтобы поменять тип установки kali-linux с WSL1 на WSL2 нужно в PowerShell запустить:
```
wsl --set-version kali-linux 2
```
Далее нужно выполнить установку и запустить Kali Linux.
Потом нужно установить пакет Win-KeX.
```
sudo apt update && sudo apt install kali-win-kex
```
или
```
sudo apt update
sudo apt dist-upgrade
sudo apt install -y kali-win-kex
```
Можно также установить расширенную сборку Kali Linux.
```
sudo apt install kali-linux-large
```
После окончание установки GUI для Kali Linux запускается командой «kex».
Видеоинструкция по установке Kali Linux на ПК с Windows 10 в WSL2 с GUI за 5 минут. | https://habr.com/ru/post/515726/ | null | ru | null |
# Правдоподобная реконструкция Инстаграм-подобных фильтров
Существует куча софта, который позволяет пользователям применять различные цветовые фильтры к своим фотография. Пионером в этом деле был Инстаграм и иногда хочется сделать в своем приложении уже знакомые пользователям фильтры. И я хочу представить набор утилит, который позволит в полу-автоматическом режиме очень точно воспроизводить цветовые фильтры из других приложений в своём приложении.
#### <https://github.com/homm/color-filters-reconstruction>
Людям нравятся фильтры из Инстаграма. Они пытаются [воспроизвести](https://github.com/girliemac/Filterous) их [снова](https://github.com/girliemac/filterous-2) и [снова](https://github.com/acoomans/instagram-filters). И [снова](https://github.com/lukexyz/CV-Instagram-Filters) и [снова](https://www.practicepython.org/blog/2016/12/20/instagram-filters-python.html). И [снова](https://code.tutsplus.com/tutorials/create-instagram-filters-with-php--net-24504) и [снова](https://picturepan2.github.io/instagram.css/). Проблема с этими попытками в том, что люди пытаются вручную подобрать цветовую коррекцию, которая будет хоть как-то похожа на то, что делают оригинальные фильтры. Для меня же было намного более интересно попробовать воспроизвести фильтры основываясь на более надежных методах и математике. И похоже, что это единственная попытка действительно точного воссоздания цветовых фильтров.
Для примера, одно из следующих изображений было получено с применением фильтра `Clarendon` на [оригинальном изображении](https://habrastorage.org/webt/4d/if/um/4difumo3r3kn4pfa4l36gwtbvoo.jpeg) в самом Инстаграме, а другое с помощью наложения восстановленного фильтра. Попробуйте угадать, какое восстановлено.
[](https://habrastorage.org/webt/q6/oh/-v/q6oh-vtrwr146qwprnotjim-bfe.jpeg) [](https://habrastorage.org/webt/nm/6h/qk/nm6hqk2rt8ieqjadzpgen7vuagk.jpeg)
Для сравнения, это результат применения того же фильтра из коммерческого набора «Инстаграм-подобных фильтров», который вы без труда сможете нагуглить:
[](https://habrastorage.org/webt/zp/49/q6/zp49q6abhzy2sff0ae9ze8j3ic0.jpeg)
Данный фильтр с натяжкой можно назвать похожим на оригинальный.
Как это работает
----------------
Метод основан на [трехмерных цветовых таблицах поиска](https://en.wikipedia.org/wiki/3D_lookup_table) (3D color LUT) и их двумерном представлении — [изображениях Халда](http://www.quelsolaar.com/technology/clut.html). Основная идея очень простая — образец изображения Халда с равномерным распределением цвета обрабатывается с помощью исходного фильтра, цветовые трансформации которого требуется воспроизвести. Обработанное таким образом изображение Халда может быть использовано для очень точной аппроксимации цветовых трансформаций исходного фильтра.
Полученное изображение Халда может быть использовано в целом ряде программ и библиотек, таких как GraphicsMagick или Photoshop. Также его можно использовать в приложениях для macOS и iOS с помощью библиотеки [CocoaLUT](http://cocoadocs.org/docsets/CocoaLUT/0.2.31/). Кроме того, изображение Халда может быть конвертировано в формат 3D LUT куба, который очень распространен в приложениях для обработки видео. И небольшой спойлер: поддержка 3D color LUT появится в следующей версии [Pillow 5.2](https://pillow.readthedocs.io/) для Питона.
Ограничения
-----------
Этот метод может захватывать только однородные преобразования цвета. Любые царапины, градиенты, виньетирование и прочие текстуры, накладываемые поверх изображения, не попадут в реконструкцию и даже будут мешать правильной реконструкции. Также реконструкция получается не очень правдоподобной, если исходный фильтр действует по-разному в разных областях изображения.
Тем не менее, на мой взгляд, этот метод максимально правдоподобно восстанавливает 32 из 40 инстаграмовских фильтров (если не считать виньетирование, наложить которое не представляет труда уже после обработки) и с переменным успехом позволяет добиться чего-то похожего для оставшихся восьми.
Требования
----------
Для генерации и конвертирования изображений Халда вам понадобится интерпретатор Питона с pip.
```
$ git clone https://github.com/homm/color-filters-reconstruction.git
$ cd color-filters-reconstruction
$ pip install -r requirements.txt
```
После получения изображений Халда, вам уже не понадобится никакой софт из этого репозитория. Зато понадобится какая-либо библиотека, которая умеет их применять. Это может быть GraphicsMagick, которая имеет биндинги для большинства популярных языков, включая Python, Ruby, PHP, JavaScript™, а также интерфейс командной строки.
Руководство
-----------
1. Для начала вам потребуется создать единичное изображение. Просто выполните:
```
$ ./bin/generate.py
```
Вы увидите файл с названием `hald.5.png`. Число в имени файла — это квадратный корень из размера таблицы поиска. То есть 5 означает, что файл содержит таблицу размером `25×25×25` элементов.
[](https://habrastorage.org/webt/gx/p6/lu/gxp6luqbrkdecqzntso2s0afdxo.png)
Этот файл немного отличается от привычного представления изображений Халда. В нем таблица реплицирована 4 раза и добавлены отступы. Кроме того, каждая ячейка таблицы занимает не один пиксель, а квадрат 8×8 пикселей. Всё это сделано, чтобы противостоять различным искажениям, как самого исходного фильтра, так и сжатия JPEG.
2. Обработайте единичное изображение с помощью исходного фильтра. Если речь об Инстаграме, то единичное изображение нужно загрузить в мобильное устройство и опубликовать с наложением интересующего фильтра. После этого в фотопотоке появится обработанное единичное изображение. Его и нужно забрать с устройства обратно.
[](https://habrastorage.org/webt/31/9h/c3/319hc39yr2u-r5dnyfteb4ahw3u.jpeg)
Важно, чтобы разрешение полученного изображения с фильтром было точно таким же, как у исходного единичного изображения.
3. Сконвертируйте изображение с фильтром в настоящее изображение Халда:
```
$ ./bin/convert.py raw/1.Clarendon.jpg halds/
```
Здесь `halds/` — директория, куда попадёт полученный фильтр.
[](https://habrastorage.org/webt/lg/4d/dx/lg4ddxgiwwr5zxpngzqntfjx32g.png)
4. Вы великолепны! Полученный фильтр сразу же можно применять к любым другим изображениям.
```
$ gm convert sample.jpg -hald-clut halds/1.Clarendon.png out.jpeg
```
[](https://habrastorage.org/webt/tv/xf/be/tvxfbedk9j7sz_lluh8cyg4ddzo.jpeg) [](https://habrastorage.org/webt/qk/5q/0j/qk5q0jpzdzvvgebgz-gry9antno.jpeg)
Дополнительные советы
---------------------
Хотя настройки по умолчанию в большинстве случаев позволяют получить высококачественные фильтры Халда, бывают ситуации, когда этого недостаточно.
Некоторые нежелательные эффекты могу появляться, если исходный фильтр имеет сильные искажения на локальном уровне или заметные градиенты в центре изображения. Самый заметный неприятный эффект — одноцветные полоски. Вот, например, оригинальное изображение и изображение, полученное после обработки восстановленным фильтром `Hudson`, в котором наиболее заметны эти проблемы:
```
# Создать изображение Халда из обработанной Инстаграмом картинки
$ ./bin/convert.py raw/15.Hudson.jpg halds/
# Применить изображение Халда к другому изображению
$ gm convert girl.jpg -hald-clut halds/15.Hudson.png girl.15.jpg
```
[](https://habrastorage.org/webt/ly/oh/oi/lyohoia4msqmaupk1zmi5vrnnis.jpeg) [](https://habrastorage.org/webt/--/l1/oi/--l1oi_ntnq9tt9ebkxg_zcm05m.jpeg)
На обработанном изображении объекты выглядят плоскими и пастеризованными: лицо, волосы, стулья на заднем плане. Хотя пастеризация и является довольно распространенным эффектом в обработке изображений, она не была частью исходного фильтра `Hudson`.
Если вы внимательнее посмотрите на [единичное изображение с примененным фильтром Hudson](https://github.com/homm/color-filters-reconstruction/blob/master/raw/15.Hudson.jpg), вы заметите, что оно довольно шумное. И это является источником проблемы.
[](https://github.com/homm/color-filters-reconstruction/blob/master/raw/15.Hudson.jpg)
К счастью, можно попросить утилиту `convert.py` применить трехмерное Гауссово размытие к таблице поиска во время конвертации, что уменьшит шум. Для этого нужно поставить пакет [SciPy](https://www.scipy.org/) (входит в поставку macOS по умолчанию).
```
# Следующую строку нужно выполнить только один раз
$ pip install scipy
$ ./bin/convert.py raw/15.Hudson.jpg halds/ --smooth 1.5
$ gm convert girl.jpg -hald-clut halds/15.Hudson.png girl.15.fixed.jpg
```
[](https://habrastorage.org/webt/--/l1/oi/--l1oi_ntnq9tt9ebkxg_zcm05m.jpeg) [](https://habrastorage.org/webt/4j/tb/v3/4jtbv38zqgmdm9qxptsprocn7sk.jpeg)
Как видите, все неприятные эффекты ушли. Вы можете найти другие опции у `convert.py`, выполнив `./bin/convert.py --help`.
Удачи с обратной инженерией! | https://habr.com/ru/post/354934/ | null | ru | null |
# Настройка программы Asymptote
Из всех хабов этот показался мне наиболее подходящей для этой темы. Итак.
Скопировано [с моего блога](https://matematikaandinformatika.blogspot.com/) в целях создания еще одного русскоязычного источника информации по данной теме.
Я опишу этот процесс для [Asymptote](https://ru.wikipedia.org/wiki/Asymptote) 2.35. Итак, вот я скачал эту программу, установил. Если мы хотим использовать эту программу в полном объеме, то следующий шаг для этого — соединение ее с  (я делаю описание для используемой мной реализации 'a — MiKTeX2.9, предполагая, что эта программа установлена и настроена должным образом: к ней подключен репозиторий, выбрана установка пакетов на лету, и т. д.). Я предполагаю, что в процессе установки Asymptote и MiKTeX папки, в которых предлагалось установщиками этих программ создавать файлы этих программ, не изменялись пользователем. Тогда открываем папку `C:\Program Files\Asymptote`, в ней находятся файлы *asycolors.sty* и *asymptote.sty*. Открываем папку `C:\Program Files\MiKTeX 2.9\tex\latex`, создаем в ней папки *asycolors* и *asymptote* и копируем в эти папки одноименные файлы sty, названные выше. Не забываем пройти **Пуск>MiKTeX2.9>Maintenance (Admin)>Settings (Admin)** и там последовательно нажать *Refresh FNDB*, *Update Formats*, *Ok*. Все, Asymptote знает, где находится *TeX*. Сделаю маленькое отступление от перечисления нужных сторонних компонентов для Asymptote. Я в TeXworks чисто на интуиции создал такой инструмент верстки *Asymptote*:
И теперь я могу открывать файлы .asy в TeXworks'е и обрабатывать эти файлы моим инструментом. Все получающиеся при этом файлы, в том числе и конечные .pdf с создаваемыми изображениями, анимацией, файлы .mpg (см. ниже) образуются в одной папке с обрабатываемом файлом .asy, независимо от наличия/отсутствия в этом файле кодов анимированной графики.
Отмечу, что в окне, приведенном на фото, имеющем заголовок «Настройки TeXworks» в разделе «Пути к ТеХ и сопотствующим программам», путь к папке программы Asymptote не был добавлен ни мной вручную, ни системой автоматически в процессе использования созданного мной инструмента Asymptote. При открытии же файлов .asy в проводнике:
эти файлы, как и следует ожидать по заголовку окна командной строки, в котором выводится инфа о ходе начатой обработки, образуются в папке `C:\Windows\System32`, тоже независимо от присутствия/отсутствия в этом файле анимации. Далее, нужна программа [ghostscript](https://www.ghostscript.com/). Эта программа нужна для нормального построения графики даже из файлов .asy, в которых нет анимации. Про анимацию я вообще молчу. Я с Asymptote 2.35 использую ghostscript версии 9.23. Что касается версии самой Asymptote, так я, было, разогнался и установил версию 2.45. И что? При тестировании кодов из папки примеров Asymptote, даже не содержащих анимацию (файлы с анимацией я тогда просто не умел превращать в .pdf) я не смог получить .pdf из бо́льшего числа файлов .asy, чем при использовании версии 2.35, даже при установке более новой версии ghostscript. Повозился я, повозился, плюнул, поудалял все эти обновленные версии и сделал, как было. Так, потом нужно установить [imagemagick](https://imagemagick.org/script/download.php). Я дал ссылку не на домашнюю страницу проекта, а на страницу, с которой непосредственно нужно скачивать установочный файл. Вот тоже проблема была: долго не мог решить, какой файл нужно скачать для Винды7. И так, и так, и прочитать-то негде, что именно нужно установить для Asymptote. Потом наугад скачал *ImageMagick-7.0.8-42-Q16-x86-dll.exe*. Когда ее не было, обработка файлов .asy с анимацией, выходным форматом которых является .pdf, не вызывала вообще никаких ошибок. Отсутствие этой программы дало о себе знать при попытке получения анимированного файла .gif из файла wheel.asy следующей ошибкой в командной строке (для примера я взял обработку файла wheel.asy, описания ошибок при получении .gif из других файлов .asy выглядят также, различия только в, быть может, значениях недопустимого параметра):
Попытка же обработки этого файла в TeXworks упомянутым выше моим инструментом Asymptote давало такую ошибку:
Путем достаточно долгих поисков инфы в Инете, да и то только на англоязычных сайтах, форумах мне удалось узнать, что у меня на компе не хватает программы ImageMagick.
ВАЖНЫЙ МОМЕНТ: В PATH ПУТЬ К ЭТОЙ ПРОГРАММЕ ДОЛЖЕН СТОЯТЬ ПЕРЕД ПУТЕМ К ПАПКЕ SYSTEM32.
, потому что ImageMagick при обработке файлов .asy с анимацией использует утилиту convert.exe, а файл с точно таким же названием существует в папке system32 и когда system32 стоит в РАТН перед ImageMagick, система при вызове этого файла прогрой ImageMagick ищет файл convert.exe не в папке программы ImageMagick, а в папке system32 и успешно его находит, только вот применение этого файла для этих целей оканчивается не успехом, а ошибкой, описанной выше. Про эту проблему и сам John Bowman говорит [здесь](https://sourceforge.net/p/asymptote/discussion/409349/thread/11ef82fe/?limit=25#8e0b/70d1), во второй реплике 2016-05-12:
Я сделал этот снимок после перевода этой страницы на русиш в браузере Гугл. Я это нашел сейчас и ответ ниже собеседника подтверждает правильность моей догадки о том, как вплетать файл convert.exe из папки программы ImageMagick в работу Asymptote. Да, если бы не переводчик этого браузера, сомневаюсь я, что написал бы эту статью. Ежли мы хотим использовать ну, совсем на полную катушку, то нам нужно еще скачать [ffmpeg](https://ffmpeg.zeranoe.com/builds/). Отсутствие этой прогры дало о себе знать только при попытке обработки файла earthmoon.asy, из чего я делаю вывод, что эта програ нужна Asymptote только для обработки файлов .asy с анимацией, выходным форматом которых является .mpg. Так что, если вы не используете ее помимо Asymptote, то, скорее всего, ей вы будете пользоваться довольно редко. Но тем не менее расскажу, как и это делать, тем более, что при этом затрону момент, который нам понадобится в будущем. Итак, переходим по приведенной немного выше ссылке. Далее нажимаем на кнопки, обведенными оранжевыми прямоугольниками, на следующем фото:
Скачиваем этот архив, распаковываем его. Я, т. к. мне понадобилось добавить папку bin этой прогры в РАТН, чтобы не засорять его лишними буквами, распаковал его прямо на диск `С:\`. Если вы тоже так сделали, то добавляем в PATH строку *C:\ffmpeg-4.1.3-win32-shared\bin*. В отличии от программы ImageMagick, положение ffmpeg в РАТН относительно пути к папке system32 не имеет значения, также, как, между прочим, не имеет значения это положение и относительно пути к папке прогры ImageMagick. Я так понял, что, когда Asymptote включает в дело ffmpeg, начинает работу файл `...\ffmpeg-4.1.3-win32-shared\bin\ffmpeg.exe`. Файл же ffmpeg.exe имеется и в папке прогры ImageMagick, однако, при запросе у него, к примеру, версии, выдается ошибка, так что у меня сложилось впечатление, что этот файл в конкретно этой версии ImageMagick с дефектом и именно поэтому нам и понадобилось устанавливать еще и прогру ffmpeg: мы этим просто добавили на комп работоспособный файл ffmpeg.ехе, необходимый для получения формата .mpg, а если бы этот файл программы ImageMagick работал, программа ffmpeg была бы вообще не нужна. Впрочем, это мое личное мнение, которое я на данный момент не могу ничем подтвердить. Однако, наличие файла ffmpeg.exe в папке прогры ImageMagick поначалу вызывало проблему: с одной стороны, видимо, получение .mpg без ImageMagick вообще невозможно, потому что при исключении его из РАТН (но с наличием в РАТН ffmpeg) ничего не получалось. Значит, вначале в дело вступает эта программа. Ну, а коль она вступила в дело, она тянет и свой файл ffmpeg.exe (даже при положении в РАТН пути к ffmpeg.exe перед путем к ImageMagick), а он не работает. И поэтому ничего не получалось. И снова это всего лишь мое умозаключение. А выходом из этой проблемы оказалось простое удаление файла ffmpeg.exe из папки прогры ImageMagick.
Во время изучения технологии обработки файла earthmoon.asy из подпапки animations папки examples обозначилась следующая деталь. После установки прогры ffmpeg описанными выше действиями и добавления ее в РАТН, открытие этого файла для получения из него .mpg в проводнике (см. выше) получалось на раз, а обработка в TeXworks — ну ни в какую и все тут! И так, и так — никак! Оказалось, что дело в являющемся даже для англоязычного пользователя тайной файле *config.asy*. Что это такое? Это обыкновенный файл с расширением *.asy* и именем *config*. Создатели Asymptote предполагали, что если пользователь дойдет до такого уровня владения их прогрой, когда ему этот файл понадобится, то бо́льшая часть его потребностей удовлетворится при условии нахождения этого файла в одной и той же папке. Эта папка создается при установке программы Asymptote. Например, если пользователь установил эту программу, находясь в учетной записи ИВАН, то абсолютный путь к этой папке будет следующим: `C:\Users\ИВАН\.asy`. Это не является проблемой для англоязычных пользователей: все буквы в полном пути к этой папке содержат, скорее всего, только латинские буквы и програ Asymptote без труда отыскивает файл config.asy. Однако, если пользователь является русскоязычным, то, скорее всего, имя той учетки, под которой он пользуется компом, написано кириллическими буквами. И потому Asymptote не может найти эту папку, а, значит, не может найти и файл config.asy. Но опять-таки, это мое объяснение поведения Asymptote, а я не программист и даже не любитель программирования (хотя я не могу сказать, что программирование мне так уж и не нравится). Казалось бы, тупик. Но, к счастью, создатели Asymptote предусмотрели эту возможную проблему. Они сделали так, что эта програ перед тем, как искать файл config.asy а папке `C:\Users\...\.asy`, где вместо многоточия стоит имя пользователя, ищет его в папке с обрабатываемым файлом .asy. Итак, при обработке файла earthmoon.asy я стал создавать в одной папке с ним файл config.asy следующего содержания:
```
import settings;
convert ="C:\Program Files\ImageMagick-7.0.8-Q16\convert.exe";
```
и только после этого у меня все стало получаться. По правде говоря, я потом понял, что можно обходиться и без файла config.asy: если бы я в файл earthmoon.asy включил строки
```
settings.convert ="C:\Program Files\ImageMagick-7.0.8-Q16\convert.exe";
```
или вставил бы строки из приведенного мной файла config.asy непосредственно в файл earthmoon.asy и при этом в папке с этим файлом отсутствовал бы файл config.asy, то это бы ничего не изменило: при обработке такого файла earthmoon.asy точно так же получается работоспособный файл .mpg (отмечу, что присутствие файла config.asy в одной папке с файлом .asy, из которого собираются получить работоспособный файл .mpg или включение строк из файла config.asy в файл .asy, из которого собираются получить работоспособный файл .mpg, но тогда с необязательным присутствием файла config.asy в одной папке с файлом asy, из которого хотят получить работоспособный файл .mpg, является обязательным условием создания работоспособного файла .mpg). На каком-то этапе обработки в TeXworks файлов с выходным форматом .mpg в папке с этим файлом .asy наблюдается следующая форменное безобразие (когда я делал снимок, шла обработка файла earthmoon.asy, в котором я для ускорения процесса и для сокращения количества образующихся файлов установил в файле earthmoon.asy значение , равным 4):
Это свидетельствует о том, что Asymptote подключил к процессу ImageMagick и все идет как нужно. А когда работа Asymptote оканчивается, все файлы с этими ужасными именами исчезают и в папке остается только 3 файла — 2 файла, которые там были с самого начала: файл config.asy и файл .asy, из которого изготавливался файл .mpg и, собственно, сам файл .mpg. Отмечу, что, кроме переменной окружения convert есть и другие переменные окружения [gs, pdfviewer, texpath, dvips](https://sourceforge.net/p/asymptote/discussion/409349/thread/11ef82fe/?limit=25#8e0b/70d1) и, например, [python](https://sourceforge.net/p/asymptote/discussion/409349/thread/95364762/?limit=25#286d/d70c), значения которых можно указывать в конфигурационном файле config.asy и, по-видимому, это еще не все такие переменные (значения этих переменных являются путями, и только поэтому я их упоминаю вместе с упоминанием переменной convert).
Фух, вроде ничего не упустил. | https://habr.com/ru/post/466863/ | null | ru | null |
# Как просто наблюдать за состоянием сайта
Чтобы дистанционно следить за работоспособностью серверов, профессионалы используют специальные программные комплексы, вроде [Zabbix](https://www.zabbix.com/) или [Icinga](https://icinga.com/). Но, если вы начинающий владелец или администратор одного-двух веб-сайтов с небольшой нагрузкой, то нет нужды в больших системах мониторинга. Главный параметр — быстро ли сайт обслуживает пользователей. Поэтому следить за работой сайта можно с помощью простой программы, с любого компьютера, подключённого к интернету.
Давайте сейчас напишем такой скрипт — простейшего мониторинга доступности и скорости работы сайта. Эту программу можно запустить на домашнем компьютере, смартфоне и так далее. Программа имеет всего две функции:
* показывает на экране время, за которое ваш сайт выдаёт пользователям страницы,
* при медленных ответах сайта или ошибках программа записывает данные в файл («журнал», или лог-файл). Эти данные стоит время от времени проверять, чтобы исправлять проблемы, когда они только начинаются. Поэтому мы позаботимся о том, чтобы записывать эти логи в наглядной, удобной для быстрого просмотра форме.
Я буду описывать каждый шаг довольно подробно, чтобы даже новичок, лишь немного знакомый с написанием командных файлов (bat и cmd в системах DOS и Windows, sh в системах типа UNIX-а), разобрался без особых проблем и смог приспособить скрипт ко своим нуждам. **Но прошу не использовать этот скрипт бездумно, ибо при неверном применении он может не давать должных результатов и, вдобавок, сожрать много трафика**.
Опишу скрипт для операционной системы типа «Линукс» и его использование на домашнем компьютере. По тем же принципам, такое можно сделать и на других платформах. А тем, кто лишь присматривается к возможностям Линукса, может быть интересен ещё один пример, каким простым и мощным средством являются его скрипты.
### 1. Организация прежде всего
Заведём отдельную папку для этой программы и создадим в ней 3 файла. Например, у меня это папка /home/me/Progs/iNet/monitor (здесь me — имя моего пользователя, Progs/iNet — моя папка для программ, связанных с интернетом, и monitor — название этой программы, от слова мониторить, то есть, наблюдать. Поскольку я единственный пользователь этого компьютера, то держу такие файлы среди личных папок (/home), в отдельном разделе диска, что позволяет сохранять их при переустановке системы). В этой папке будут файлы:
* README.txt — здесь описание (на случай склероза): что за программа, справочная информация к ней и т.д.
* mon.sh — здесь будет программа, опрашивающая сайт.
* server.log — сюда она будет записывать показатели состояния сайта. В нашем случае это просто дата, время и длительность отклика сайта (плюс дополнительная информация, если на наш запрос сервер отвечает ошибкой).
(Для удобства правки и, если что, восстановления файлов, можно включить эту папку в систему контроля версий Git; здесь я не буду этого описывать).
### 2. Настойчиво и расслабленно
Файл mon.sh мы будем запускать с регулярным небольшим интервалом, например, 60 секунд. Я использовал для этого стандартное средство, предоставляемое операционной системой (точнее, средой рабочего стола).
Моя среда Рабочего стола — Xfce. Это один из самых популярных вариантов для Линукса. Xfce нравится мне тем, что позволяет практически полностью настраивать всё окружение — именно так, как тебе удобно. При этом Xfce несколько компактнее и быстрее двух других известных систем — Gnome и KDE. (Интересны и другие варианты — например, среда LXDE ещё быстрее и легче, чем Xfce, но пока не так богата по возможностям).
Нужное нам средство, в случае Xfce — это плагин для рабочей панели «Монитор общего назначения» (Generic Monitor). Обычно он уже установлен, но, если нет, Установщик легко найдёт его: «Genmon» (описание: [xfce4-genmon-plugin](https://goodies.xfce.org/projects/panel-plugins/xfce4-genmon-plugin)). Это плагин, который можно добавить на панель и задать ему в настройках: (1) выполняемую команду и (2) периодичность её выполнения в секундах. В моём случае, команда:
/home/me/Progs/iNet/monitor/mon.sh
(или, что то же самое, ~/Progs/iNet/monitor/mon.sh).
### 3. Когда программы ещё нет, ошибки уже есть
Если вы проделали сейчас все эти шаги — создали файлы и запустили плагин на панели — то видите там результат запуска нашей программы (сообщение об ошибке: файл mon.sh не является программой). Тогда, чтобы сделать файл исполняемым, зайдём в нашу папку и поставим ему разрешение на запуск — * или файловым менеджером: Свойства — Разрешения — Разрешить выполняться как программа (Properties — Permissions — Allow this file to run as a program);
* или командой с терминала: **chmod 755 mon.sh**
И в самом файле напишем такие первые строки:
```
#!/bin/bash
# Monitor server responses (run this every 60 seconds):
#
info=$(curl -I -o /dev/stdout -w '%{time_total}эяю' --url https://example.ru/ -m 9 -s)
errr=$(echo $?)
```
Вместо «example.ru» подставьте название вашего сайта, за состоянием которого вы будете наблюдать. И, если он работает по http, поставьте http вместо https. Строка #!/bin/bash означает, что это скрипт для запуска программой Баш ([bash](http://mywiki.wooledge.org/BashFAQ/) — наверное, самой распространённой для выполнения скриптов на Линуксе). Для работы посредством другого командного интерпретатора его указывают вместо Баша. Остальные строки с диезом в начале — комментарии. Первая собственно строка кода — **info=$()** и в этих скобках команда curl с параметрами. Такая конструкция — нечто=$(что-то) — означает «выполнить команду в скобках и присвоить результат переменной слева». В данном случае, я назвал переменную «info». Эта команда в скобках — curl (на жаргоне именуемая некоторыми «Курл») — посылает запрос в сети по заданному адресу и возвращает нам ответ сервера. (Мой знакомый сказал, объясняя: «Как журавлик курлыкает — и получает ответ от какого-то другого журавля в небе»). Рассмотрим параметры:
```
curl -I -o /dev/stdout -w '%{time_total}эяю' --url https://example.ru/ -m 9 -s
```
**-I** значит, что мы запрашиваем не всю страницу, а только её «заголовки HTTP». Нам не нужен каждый раз текст страницы целиком, чтобы убедиться в работоспособности сайта. Поскольку мы будем проверять сайт часто, важно сделать размер передаваемых данных как можно меньше. Это экономит и трафик, и электричество, и нагрузку на сервер — и на живую природу.
Кстати, обратите внимание, сколько у вас запасного трафика (не используется за месяц) на хостинге. Ниже увидите, какой объём данных передаётся и сможете посчитать, хватит ли вам запасов; если что, период проверки сайта можно увеличить до 5, 10, или даже 30-60 минут. Хотя в этом случае картина будет не такой полной — и мелкие перебои могут остаться незамеченными; но, в целом, при мониторинге сайта важнее обнаруживать длительные проблемы, чем однократные перебои. Также, какой трафик вы можете себе позволить на вызывающем компьютере? В моём случае — настольный ПК с безлимитным трафиком — это не так важно; но для мобильного устройства или тарифа с лимитами стоит посчитать и, возможно, увеличить интервалы проверки.
### 4. Шаг следует за шагом, кроме первого шага
Поехали дальше: **-o /dev/stdout** значит «ответ, полученный Курлом от сервера, направить в такой-то файл». И в данном случае это не файл на диске, а /dev/stdout — Стандартное устройство вывода. Обычно «Стандартное устройство вывода» — это наш экран, где мы можем видеть итоги работы программы. Но в скрипте мы часто направляем этот «стандартный вывод» на дальнейшую обработку (сейчас — сохраняем в переменную info). И дальше мы будем, чаще всего, либо направлять итоги команд в переменные, либо передавать их следующим командам по цепочке. Для создания цепочек из команд служит оператор pipe («Труба»), изображаемый как вертикальная черта ("|").
**-w '%{time\_total}эяю'**: здесь -w значит «сформатировать и выдать на стандартное устройство вывода такую-то дополнительную информацию». А конкретно, нас интересует time\_total — сколько всего времени заняла передача запрос-ответа между нами и сервером. Вы, наверное, знаете, что есть более простая команда, ping («Пинг»), чтобы быстро запросить сервер и получить от него ответ, «понг». Но Пинг только проверяет, что сервер хостинга жив, и сигнал туда-обратно идёт столько-то времени. Это показывает предельную скорость доступа, но ещё ничего не говорит нам о том, как быстро сайт выдаёт реальное содержимое. Пинг может работать быстро, и при этом сайт может тормозить или вообще не работать — из-за высокой нагрузки или каких-то внутренних проблем. Поэтому мы используем именно Курла и получаем действительное время выдачи сервером нашего содержимого.
(И по этому параметру можно судить, достаточно ли сервер производительно работает для ваших задач, удобно ли пользователям его типичное время отклика. Не возникает ли проблем — например, мои сайты на многих хостингах с течением времени замедлялись, и приходилось искать другой хостинг).
Вы заметили странные буквочки «эяю» после {time\_total}? Я добавил их как уникальную метку, которой наверняка не будет в отправленных нам с сервера заголовках (хотя делать предположения, что будет и чего не будет у пользователей ваших программ — дурной тон и дорога в бездну. Не делайте так!.. Или, когда делаете, пусть вам хотя бы будет стыдно). По этой метке (надеюсь) мы потом сможем легко вытащить нужный нам кусочек информации из целой кучи строк в переменной info. Итак, **curl -w '%{time\_total}эяю'** (при правильных остальных параметрах) выдаст нам что-то вроде:
0.215238эяю
Это количество секунд, которое заняло обращение к сайту, плюс наша метка. (Кроме этого параметра, в переменной info нас будет интересовать, главным образом, «Status code» — код состояния, или, по-простому, код ответа сервера. Обычно, когда сервер выдаёт запрошенный файл, код «200». Когда страница не найдена, это знаменитое 404. Когда на сервере ошибки, это, чаще всего, 500 с чем-то).
### 5. Творческий подход — отец самопроверки
Остальные параметры у нашего curl-а таковы:
```
--url https://example.ru/ -m 9 -s
```
что значит: запросить такой-то адрес; максимальное время ожидания ответа 9 секунд (можно ставить меньше, потому что редкий пользователь будет ждать ответа от сайта так долго, он быстрее сочтёт сайт не работающим). И "-s" означает silent, то есть, curl не будет сообщать нам лишних подробностей.
Кстати, на панели рабочего стола обычно места немного, поэтому для отладки скрипта лучше запускать его с терминала (в его папке, командой ./mon.sh). А у нашего плагина панели поставим пока большую паузу между запусками команды — скажем, 3600 секунд.
Для отладки мы можем запустить этот curl без обрамляющих скобочек и посмотреть, что он выдаст. (Из этого и рассчитать расход трафика). Мы увидим, в основном, набор заголовков HTTP, типа:
```
HTTP/1.1 302 Found
Server: QRATOR
Date: Sun, 11 Feb 2019 08:06:57 GMT
Content-Type: text/html; charset=UTF-8
Connection: keep-alive
Keep-Alive: timeout=15
X-Powered-By: PHP/7.2.14-1+ubuntu16.04.1+deb.sury.org+1
Location: https://habr.com/ru/
X-Frame-Options: SAMEORIGIN
X-Content-Type-Options: nosniff
Strict-Transport-Security: max-age=63072000; includeSubDomains; preload
X-Cache-Status: HIT
0.033113эяю
```
Первой строкой здесь мы видим «HTTP/1.1 302 Found» — что значит: используется протокол передачи данных «HTTP/1.1», код ответа сервера — «302 Found». При запросе другой страницы это может быть код «301 Moved Permanently» и т.п. В дальнейшем примере, нормальный ответ моего сервера — «HTTP/2 200». Если же ваш сервер в норме отвечает по-другому, подставьте этот его ответ вместо «HTTP/2 200» в этом скрипте.
Последней строкой, как мы видим, Курл выдаёт, за сколько секунд мы получили ответ сервера, с нашей приписанной меткой.
Интересно: мы можем так настроить сайт, чтобы он сообщал по этим нашим запросам (и только по ним!) дополнительную информацию о своём состоянии — например, в «самодельном» заголовке HTTP. Скажем, какова нагрузка на процессоры сайта, сколько у него свободной памяти и места на диске, быстро ли работает база данных. (Конечно, для этого сайт должен быть динамическим, то есть, запросы должны обрабатываться программой — на PHP, Node.JS или т.п. Ещё вариант — использовать на сервере специальные программное обеспечение). Но, возможно, эти подробности нам пока не очень нужны. Цель этого скрипта — просто регулярно следить за общей работоспособностью сайта. Во случае проблем — мы уже будем разбираться с диагностикой другими средствами. Поэтому сейчас мы пишем самый простой скрипт, который будет работать для любого сайта, даже статического, и без дополнительных настроек на сервере. В дальнейшем, при желании, можно будет расширить возможности скрипта; а пока сделаем основу.
Строка **errr=$(echo $?)** означает: записать в переменную errr результат команды «echo $?». Команда echo означает вывести некий текст на Стандартное устройство вывода (stdout), а символы "$?" — это текущий код ошибки (оставшийся от выполнения предыдущей команды). Так что, если наш curl вдруг не сможет достучаться до сервера, то выдаст ненулевой код ошибки, и мы узнаем об этом, проверив переменную errr.
### 6. Целесообразность
Здесь я хочу сделать небольшое отступление от технических материй, чтобы читать текст было интереснее. (Если не согласны, пропустите три абзаца). Скажу так, что всякая человеческая деятельность по-своему целесообразна. Даже когда человек намеренно бьётся лбом об стену (или об пол… об клавиатуру...), в этом есть своя целесообразность. Например, он даёт выход эмоциональной энергии — может, не «лучшим» способом, но уж как умеет. (Да и само понятие «лучший» бессмысленно с точки зрения *этого мгновения в этом месте* — потому что лучшее и худшее возможно лишь по сравнению с чем-то ещё).
Я сейчас пишу этот текст, вместо, казалось бы, более важных для меня дел — почему? Во-первых, чтобы подвести итоги, пересмотреть и внутренне разложить по полочкам то, чему за эти два дня научился в написании скриптов… Вынести из оперативной памяти и уложить на хранение. Во-вторых, я таким способом немножко отдыхаю… В-третьих, надеюсь, что это разжёванное объяснение пригодится кому-то ещё (и мне самому, возможно, когда-нибудь). Как, не важно, лучшая ли, но внятная напоминалка по теме скриптов и запросов на сервер.
Кто-то, может, поправит меня в чём-то, и итог станет ещё лучше. Кто-то получит кусочек полезной информации. Целесообразно ли это? Пожалуй… это то, что я могу сейчас сделать и делаю. Завтра, может быть, я просплюсь и проведу переоценку нынешних действий… но и эта переоценка даст что-то небесполезное для дальнейшей жизни.
Итак, по выполнении запроса, у нас два кусочка данных:
* основной блок информации от сервера (если, конечно, ответ сервера пришёл), мы записали его в переменную info;
* код ошибки команды curl (0, если без ошибок) — записан в переменную errr.
Именно потому, что понадобятся оба итога — и info, и код ошибки — я и записал их в переменные, а не сразу передал итоги Курла другим командам через Трубу. Но теперь в этом скрипте пора полазить и по трубам:
```
code=$(echo "$info" | grep HTTP | grep -v 'HTTP/2 200')
date=$(echo "$info" | grep -i 'date:')
dlay=$(echo "$info" | grep эяю | sed -e 's/эяю//')
```
В каждой из этих строк мы записываем очередную переменную — сохраняем итоги выполнения команд. И в каждом случае это не одна команда, а цепочка; первое звено везде одинаково: **echo "$info"** — выдаёт в поток Стандартного устройства вывода (stdout) тот самый блок информации, что мы сохранили, получив от curl-а. Дальше по трубе этот поток передаётся команде grep («Греп»). Греп выбирает изо всех строк только те, в которых находит соответствие шаблону. (Параметр -i означает «не учитывать регистр»). Как видите, в первом случае мы выбираем строку, содержащую «HTTP». Эта строка, вытащенная из кучи остальных, передаётся по трубе дальше, команде **grep -v 'HTTP/2 200'**. Здесь параметр **-v** — противоположность параметру **-e**, он отфильтровывает строки, где найден такой-то шаблон. Итого, в переменной code окажется строка с кодом ответа сервера (типа «HTTP/1.1 302 Found»), но только если это не 'HTTP/2 200'. Так я отфильтровываю строки, которые мой сайт посылает в нормальном случае, и сохраняю лишь «аномальные» ответы. (Если у вас нормальный ответ сервера иной, подставьте его туда).
Аналогично, в переменную date мы записываем строку, в которой сервер выдал его текущие дату и время. Это что-то вроде "**date: Sun, 11 Feb 2019 08:06:57 GMT**" (как правило, в часовом поясе GMT, он же UTC). Нам надо записывать дату (но лишь один раз в сутки!) в наш лог-файл («журнал состояния сервера») — server.log. А заодно выведем это время на экран. Можно было бы записать в лог дату-время и со своего компьютера, но для удобства возьмём эти, раз уж всё равно сервер их прислал.
Похоже и с нашей третьей переменной, dlay (от английского слова дилей — задержка). Выбираем по нашей нежной метке «эяю» строку, в которой сохранили длительность ожиданияния ответа от сервера. Удаляем эту метку, уже не нужную, с помощью команды [sed](https://www.gnu.org/software/sed/manual/sed.html) — и сохраняем результат.
Теперь, если мы для проверки напечатаем эти переменные — например, добавив в наш скрипт строки:
```
printf 'errr: %s\n' "$errr"
printf 'code: %s\n' "$code"
printf '%s\n' "$date"
printf 'dlay: %s\n' "$dlay"
```
должно получиться что-то вроде:
```
errr: 0
code:
date: Mon, 11 Feb 2019 12:46:18 GMT
dlay: 0.236549
```
Итого: код ошибки curl-а — ноль (значит, отработал нормально). Код состояния сервера — не записан (так как был нормальным). Дата и время. Длительность ответа. Осталось правильно вывести, что нужно, на экран и, если нужно, записать в файл.
Это самое интересное: что, при каких условиях и как записывать?
### 7. Хитрые выводы
Чтобы не утомлять вас больше подробностями, расскажу кратко (а [хороших справочников](https://devhints.io/bash) по всем этим командам в интернете достаточно). Кстати, краткость — одна из главных целей, которых мы будем добиваться при записи в этот лог. Тогда он будет и удобен для просмотра, и никогда не займёт много места на диске (в отличие от иных логов, что растут мегабайтами в день).
Первое: позаботимся о том, чтобы записывать дату в лог лишь по одному разу, а не в каждой строке. Для этого выделим из нашей переменной date по отдельности текущую дату (curr) и время (time):
```
curr=$(echo "$date" | sed -e 's/\(20[0-9][0-9]\).*$/\1/')
time=$(echo "$date" | sed -e 's/^.*\ \([0-9][0-9]:.*\)\ GMT\r$/\1/')
```
А также считаем из лог-файла строки с датами и возьмём последнюю дату (prev):
```
prev=$(cat /home/me/Progs/iNet/monitor/site.log | grep -e 'date:' | tail -1)
```
Если наша текущая дата (curr) не равна предыдущей (из файла, prev) — то наступил новый день (или, скажем, файл логов был пуст); тогда пишем новую дату в файл:
```
if [[ $curr != $prev ]]; then
printf '%s\n' "$curr" >>/home/me/Progs/iNet/monitor/site.log
printf '%s %s %s\n' "$time" "$dlay" "$code" >>/home/me/Progs/iNet/monitor/site.log
```
… и заодно записываем текущую информацию: время, задержка получения ответа с сайта, код ответа сайта (если не обычный):
```
printf '%s %s %s\n' "$time" "$dlay" "$code" >>/home/me/Progs/iNet/monitor/site.log
```
Это поможет ориентироваться: такой-то день начался с такой-то скорости работы сайта. В остальных случаях давайте не загромождать файл лишними записями. Безусловно, запишем, если получили необычный код состояния сервера:
```
elif [[ -n $code ]]; then
printf '%s %s %s\n' "$time" "$dlay" "$code" >>/home/me/Progs/iNet/monitor/site.log
```
А также пишем, если время ответа сервера больше обычного. У меня сайт отвечал обычно за 0.23-0.25 секунд, поэтому я фиксирую ответы, которые заняли дольше 0.3 секунд:
```
elif (( $(echo "$dlay > 0.3" | bc -l) )); then
printf '%s %s\n' "$time" "$dlay" >>/home/me/Progs/iNet/monitor/site.log
```
Наконец, раз в час я просто записываю время, полученное от сервера — как знак, что он жив, и заодно как своеобразную разметку файла:
```
else
echo "$time" | grep -e :00: | cat >>/home/me/Progs/iNet/monitor/site.log
fi
```
Получаем такое содержание файла, где разметка ежечасными записями помогает визуально, не вчитываясь, видеть, когда нагрузка выше или ниже (больше число записей в час):
```
19:42:28 0.461214
19:53:29 0.443956
20:00:29
20:09:30 2.156462
20:10:29 0.358294
20:45:29 0.313378
20:51:30 0.563886
20:54:30 0.307219
21:00:30 0.722343
21:01:30 0.310284
21:09:30 0.379662
21:10:31 1.305779
21:12:35 5.799455
21:23:31 1.054537
21:24:31 1.230391
21:40:31 0.461266
21:42:37 7.140093
22:00:31
22:12:37 5.724768
22:14:31 0.303500
22:42:37 5.735173
23:00:32
23:10:32 0.318207
date: Mon, 11 Feb 2019
00:00:34 0.235298
00:01:33 0.315093
01:00:34
01:37:41 5.741847
02:00:36
02:48:37 0.343234
02:56:37 0.647698
02:57:38 1.670538
02:58:39 2.327980
02:59:37 0.663547
03:00:37
03:40:38 0.331613
04:00:38
04:11:38 0.217022
04:50:39 0.313566
04:55:45 5.719911
05:00:39
```
И, наконец, выводим информацию на экран. А также, если curl сработал с ошибкой, выводим и записываем сообщение об этом (и заодно запускаем Пинг и логируем — проверить, жив ли сервер вообще):
```
printf '%s\n%s\n%s' "$time" "$dlay" "$code"
if (( $errr != 0 )); then
date >>/home/me/Progs/iNet/monitor/site.log
date
printf 'CURL Request failed. Error: %s\n' "$errr" >>/home/me/Progs/iNet/monitor/site.log
printf 'CURL Request failed. Error: %s\n' "$errr"
pung=$(ping -c 1 178.248.237.68)
printf 'Ping: %s\n----\n' "$pung" >>/home/me/Progs/iNet/monitor/site.log
printf 'Ping: %s\n' "$pung"
fi
```
Замените адрес IP во строке ping-а на реальный адрес IP вашего сайта.
### 8. Послесловие
Итог трудов:
Слева на панельке видно время в UTC и текущая отзывчивость сайта. Справа — лог: видно слёту, даже при беглом прокручивании, в какие часы нагрузка была больше или меньше. Можно заметить и аномально медленные ответы (пики; хотя пока непонятно, откуда они берутся).
Вот и всё. Скрипт получился простой, дубовый, и его можно совершенствовать: работать над оптимизацией, переносимостью, улучшением оповещений и отображений, с учётом прокси и кеша…
Но уже в этом виде программы она, наверное, может дать представление о состоянии вашего сайта. И пусть это будет сайт мудро целесообразный, полезный для людей и всех существ!
**Полный текст скрипта с комментариями. Не забудьте внести необходимые изменения!**
```
#!/bin/bash
# Monitor server responses (run this every 60 seconds):
info=$(curl -I -o /dev/stdout -w '%{time_total}эяю' --url https://example.ru/ -m 9 -s)
errr=$(echo $?)
# errr = CURL error code https://curl.haxx.se/libcurl/c/libcurl-errors.html
code=$(echo "$info" | grep HTTP | grep -v 'HTTP/2 200')
date=$(echo "$info" | grep -i 'date:')
dlay=$(echo "$info" | grep эяю | sed -e 's/эяю//')
# code = Response code = 200?
# => empty, otherwise response code string
#
# date = from HTTP Header of the server responded, like:
# Date: Sun, 10 Feb 2019 05:01:50 GMT
#
# dlay = Response delay ("time_total") from CURL, like:
# 0.25321
#printf 'errr: %s\n' "$errr"
#printf 'code: %s\n' "$code"
#printf '%s\n' "$date"
#printf 'dlay: %s\n' "$dlay"
curr=$(echo "$date" | sed -e 's/\(20[0-9][0-9]\).*$/\1/')
time=$(echo "$date" | sed -e 's/^.*\ \([0-9][0-9]:.*\)\ GMT\r$/\1/')
prev=$(cat /home/me/Progs/iNet/monitor/site.log | grep -e 'date:' | tail -1)
# = Previously logged date, like:
# date: Sun, 10 Feb 2019
# Day logged before vs day returned by the server; usually the same
if [[ $curr != $prev ]]; then
# Write date etc., at the beginning of every day:
printf '%s\n' "$curr" >>/home/me/Progs/iNet/monitor/site.log
printf '%s %s %s\n' "$time" "$dlay" "$code" >>/home/me/Progs/iNet/monitor/site.log
elif [[ -n $code ]]; then
# If the response had HTTP error code - log it:
printf '%s %s ? %s\n' "$time" "$dlay" "$code" >>/home/me/Progs/iNet/monitor/site.log
elif (( $(echo "$dlay > 0.3" | bc -l) )); then
# If the response delay was large - log it:
printf '%s %s %s\n' "$time" "$dlay" "$code" >>/home/me/Progs/iNet/monitor/site.log
else
# If it's the start of an hour - just log the time
echo "$time" | grep -e :00: | cat >>/home/me/Progs/iNet/monitor/site.log
fi
# To screen:
printf '%s\n%s\n%s' "$time" "$dlay" "$code"
# On CURL error:
if (( $errr != 0 )); then
date >>/home/me/Progs/iNet/monitor/site.log
date
printf 'CURL Request failed. Error: %s\n' "$errr" >>/home/me/Progs/iNet/monitor/site.log
printf 'CURL Request failed. Error: %s\n' "$errr"
pung=$(ping -c 1 178.248.237.68)
printf 'Ping: %s\n----\n' "$pung" >>/home/me/Progs/iNet/monitor/site.log
printf 'Ping: %s\n' "$pung"
fi
```
**PS. По итогам обсуждения** (на 12.02.2019):
Как я и надеялся, знатоки написали много интересных комментариев.
Обдумав, могу ответить на вопрос [rsashka](https://habr.com/en/users/rsashka/), в чём преимущество этого скрипта.
Другие средства, вроде [NetData](https://github.com/netdata/netdata) (спасибо [tchspprt](https://habr.com/en/users/tchspprt/) за наводку!), дают большой массив данных, которые не будут долго храниться. NetData хорошее средство, когда ты каждый день работаешь, обслуживаешь сайты профессионально. Хорошо подходит для диагностики текущих проблем.
А скрипт вроде моего — это чтобы присматривать вполглаза, занимаясь другими делами. Скрипт не требует особого изучения и настроек. Это неплохо для непрофессионалов. А его логи занимают так мало места, что их можно вообще не стирать. Они могут накапливаться годами, и лет через N+1 можно будет посмотреть: «Ого, в 2019 году у меня время отклика было в полтора раза ниже!..»
То есть, своя ниша у такого решения есть — в основном, для не занимающихся сисадминством постоянно. (Как говорит [tchspprt](https://habr.com/en/users/tchspprt/): «Примерно как соседского кота покормить на время отпуска»).
[andreymal](https://habr.com/en/users/andreymal/) посоветовал интересный способ учитывать и потом просматривать нагрузку сайта, без дополнительных средств, просто через логи доступа на сайте. И можно по ним строить красивые графики. Я, наверное, попробую этот вариант и выложу на [Гитхабе](https://github.com/chang-zhao), что получилось.
[unnforgiven](https://habr.com/en/users/unnforgiven/) посоветовал ещё интересное решение — наверное, несложное (prometheus, blackbox и alermanager установить через docker composer). На моём простом, дешёвом VPS не хватит для этого памяти; и Linux со старым ядром — Докер не запустится. Но за вариант спасибо!
Ещё совет [tchspprt](https://habr.com/en/users/tchspprt/): Graphite + Prometheus + Grafana. Или снабдить скрипт красивой графикой (gnuplot или rrdtool).
[Mcalexvrn](https://habr.com/en/users/mcalexvrn/) советует простое средство: [uptimerobot](http://uptimerobot.com/). Спасибо!
Благодарю всех за такой массив информации! Пусть это пригодится людям… | https://habr.com/ru/post/439894/ | null | ru | null |
# VPS как анонимный прокси и не только…
Сегодня каждый пользователь Интернет может приобрести VPS и использовать удаленный сервер, например, для размещения собственного сайта или организации DNS сервера. В данном посте я расскажу о нестандартном использовании VPS: о том как создать личный анонимный прокси сервер и обеспечить резервный доступ к уже существующим сервисам.
#### **Исходные данные:**
* VPS в Европе (ОС FreeBSD8.3) с белым ip (yyy.yyy.yyy.yyy)
* Интернет-шлюз в России (ОС FreeBSD8.1) с белым ip (xxx.xxx.xxx.xxx)
* Локальная сеть за шлюзом с серверами (HTTP-SERVER, HTTPS-SERVER, PROXY-SERVER)
#### **Доступ к Интернет ресурсу через анонимный прокси сервер**
Client ---> Интернет-шлюз (PF) --rdr--> Local Proxy Server (SQUID) --vpn--> VPS Proxy Server (SQUID) ---> Internet
##### *Файервол PF на Интернет-шлюзе*
Для анонимного доступа к определенным ресурсам сформируем специальную таблицу PF ip адресов:
```
table persist file "/etc/pf/iplists/anonymsites.txt"
```
В нашей схеме клиент использует прозрачный прокси, поэтому в PF необходимо создать редирект:
```
$ext_ip="xxx.xxx.xxx.xxx"
$int_if="внутренний интерфейс"
rdr on $int_if proto tcp from $clients to port 80 -> $ext\_ip port 3129
rdr on $int\_if proto tcp from $clients to port 443 -> $ext\_ip port 3129
```
Перенаправляем трафик, идущий от клиентов по портам 80, 443 на определенные ресурсы через локальный прокси сервер (порт 3129).
##### *Локальный прокси сервер SQUID*
В стандартную конфигурацию SQUID2.7, как прокси для локальной сети, необходимо внести следующие директивы:
```
http_port 3129
# анонимность в сети
header_access From deny all
header_access Server deny all
header_access User-Agent deny all
header_access WWW-Authenticate deny all
header_access Link deny all
header_access X-Forwarded-For deny all
header_access Via deny all
header_access Cache-Control deny all
forwarded_for off
# направим весь пришедший трафик на родительский прокси сервер на VPS через vpn-туннель
cache_peer 10.10.10.250 parent 3128 0 no-query no-digest
cache_peer_access 10.10.10.250 allow all
never_direct allow all
```
##### *Туннель на основе OpenVPN*
Создадим между Интернет-шлюзом и VPS vpn-туннель, установив openvpn сервер (10.10.10.1) на шлюзе, а клиент на VPS (10.10.10.250).
```
#Конфигурация OpenVPN сервера
mode server
tls-server
port 2080
proto udp
dev tun
ca /etc/openvpn/keys/ca.crt
cert /etc/openvpn/keys/server.crt
key /etc/openvpn/keys/server.key
dh /etc/openvpn/keys/dh1024.pem
tls-auth /etc/openvpn/keys/ta.key 0
topology subnet
ifconfig 10.10.10.1 255.255.255.0
keepalive 10 120
max-clients 10
comp-lzo
cipher DES-EDE3-CBC
user nobody
group nogroup
persist-key
persist-tun
verb 4
mute 20
client-to-client
client-config-dir /etc/openvpn/ccd
status /var/log/openvpn/openvpn-status.log
log-append /var/log/openvpn/openvpn.log
```
```
#Конфигурация OpenVPN клиента
client
dev tun
proto udp
remote xxx.xxx.xxx.xxx 2080
pull
topology subnet
user nobody
group nobody
persist-key
persist-tun
ca /usr/local/etc/openvpn/keys/ca.crt
cert /usr/local/etc/openvpn/keys/vps.crt
key /usr/local/etc/openvpn/keys/vps.key
tls-client
tls-auth /usr/local/etc/openvpn/keys/ta.key 1
cipher DES-EDE3-CBC
comp-lzo
verb 3
status /var/log/openvpn-status.log
log /var/log/openvpn.log
mute 20
```
##### *VPS прокси сервер SQUID*
Cтандартная конфигурация SQUID2.7 с анонимным доступом.
```
http_port 3128
#анонимность в сети
header_access From deny all
header_access Server deny all
header_access User-Agent deny all
header_access WWW-Authenticate deny all
header_access Link deny all
header_access X-Forwarded-For deny all
header_access Via deny all
header_access Cache-Control deny all
forwarded_for off
```
#### **Резервный доступ к серверам (HTTP, HTTPs) извне**
Internet ---> VPS (PF) --vpn+stunnel--> Интернет-шлюз (PF) ---> локальный сервер (HTTP, HTTPs)
##### *Файервол PF на VPS*
Добавим редирект в файервол PF на VPS:
```
$ext_if="внешний интерфейс"
rdr on $ext_if proto tcp from any to $ext_if port 80 -> 127.0.0.1 port 8180
rdr on $ext_if proto tcp from any to $ext_if port 443 -> 127.0.0.1 port 4443
```
Будем перенаправлять трафик, предназначенный для веб-сервера за Интернет-шлюзом, на адрес локальной петли порты 8180 и 4443, на котором работает Stunnel.
##### *Туннель Stunnel*
Возможно было, конечно, обойтись и без Stunnel, просто добавив статический маршрут и проброс портов на PF до локального сервера, но решил поэкспериментировать. В данном случае Stunnel необходим для проксирования внешнего трафика на локальный веб-сервер (192.168.XXX.YYY). Конфигурация Stunnel на VPS и Интернет-шлюзе:
```
#stunnel.conf на VPS
pid = /var/run/stunnel.pid
debug = 4
output = /var/log/stunnel.log
cert = /usr/local/etc/stunnel/stunnel.cert
key = /usr/local/etc/stunnel/stunnel.key
sslVersion = SSLv3
options = DONT_INSERT_EMPTY_FRAGMENTS
ciphers = AES256-SHA
socket = l:TCP_NODELAY=1
socket = r:TCP_NODELAY=1
compression = rle
[http]
client = yes
accept = 8180
connect = 10.10.10.1:8180
TIMEOUTclose = 0
[https]
client = yes
accept = 4443
connect = 10.10.10.1:4443
TIMEOUTclose = 0
```
```
#stunnel.conf на Интернет-шлюзе
pid = /var/run/stunnel.pid
debug = 4
output = /var/log/stunnel.log
cert = /usr/local/etc/stunnel/stunnel.cert
key = /usr/local/etc/stunnel/stunnel.key
sslVersion = SSLv3
options = DONT_INSERT_EMPTY_FRAGMENTS
ciphers = AES256-SHA
socket = l:TCP_NODELAY=1
socket = r:TCP_NODELAY=1
compression = rle
[http]
accept = 8180
connect = 192.168.XXX.YYY:80
TIMEOUTclose = 0
[https]
accept = 4443
connect = 192.168.XXX.YYY:443
TIMEOUTclose = 0
```
Так, можно обеспечить резервный доступ к сервису через дополнительный белый ip. Например, домену `example.com` в DNS можно сопоставить основной внешний ip, а субдомену `www.example.com` (часто алиас для основного) — ip удаленного VPS. | https://habr.com/ru/post/217629/ | null | ru | null |
# Обгоняем компилятор
На форумах и в других местах общения разработчиков сейчас часто повторяется, что приличный оптимизирующий компилятор всегда будет превосходить жалкие, почти человеческие потуги программы, написанной вручную на ассемблере. Есть редкие случаи, как, например, MPEG-декодеры, где хорошее использование инструкций SIMD может позволить ассемблированию полностью превзойти компилятор. Но обычно, и везде, мы слышим, что компилятор всегда работает лучше.
Причиной обычно указывают то, что у современного центрального процессора имеется столько конвейеров и конфликтов по управлению, с которыми приходится иметь дело, что простая программа ассемблера не сделает работу хорошо, обращаясь с ними.
Но так ли это? Давайте не будем просто воспринимать на веру слова некоторых парней в интернете, как библейское откровение, а проведём небольшой эксперимент и выясним.
Мы просто возьмём несложный кусок кода и рассмотрим его. Я не собираюсь выбрать пример, который может выиграть, в большой степени, от экзотических встроенных функций. Вместо этого я возьму старый стандартный quicksort.
Здесь показана простая быстрая сортировка в C++, которую мы протестируем:
```
struct Item { int key; int value; };
extern "C"
void sortRoutine(Item *items, int count)
{
if (count <= 1)
return; // already sorted if only zero/one element
// Pick the pivot.
Item pivot = items[count-1];
int low = 0;
for (int pos=0;pos
```
Ничего необычного. Это не самый лучший алгоритм сортировки в мире, а это — даже не самая лучшая реализация, но он простой и делает своё дело неплохо.
Теперь попробуем прямо выполнить простую реализацию такого подхода в ассемблере:
```
sortRoutine:
; rcx = items
; rdx = count
sub rdx, 1
jbe done
; Pick the pivot.
mov r8, [rcx+rdx*8] ; r8 = pivot data
xor r9, r9 ; r9 = low
xor r10, r10 ; r10 = pos
partition:
cmp [rcx+r10*8], r8d
jg noswap
; swap elements
mov rax, [rcx+r10*8]
mov r11, [rcx+r9*8]
mov [rcx+r9*8], rax
mov [rcx+r10*8], r11
inc r9
noswap:
inc r10
cmp r10, rdx
jb partition
; move pivot into place
mov rax, [rcx+r9*8]
mov [rcx+rdx*8], rax
mov [rcx+r9*8], r8
; recurse
sub rdx, r9
lea rax, [rcx+r9*8+8]
push rax
push rdx
mov rdx, r9
call sortRoutine
pop rdx
pop rcx
test rdx, rdx
jnz sortRoutine
done:
ret
```
Написать это оказалось довольно просто, в основном благодаря операторам гибкой адресации к памяти Intel. Что интересно — я не делал никакой реальной попытки обращать внимание на планирование, конвейеризацию и так далее. Я просто написал это как несложную программу на ассемблере.
Теперь давайте оценим затраченное время. Я написал простую тестовую программу, сортирующую массив из 1 000 000 позиций. Тест был выполнен 100 раз и было взято наилучшее значение для всего набора. Версия С++ была скомпилирована с использованием gcc 4.8.1, clang 3.8.0 и MSVC 2013.
Результаты
----------
```
sort_cpp_recurse_gcc.exe : 99 мс - наилучший результат для 100 прогонов
sort_cpp_recurse_clang.exe : 99 мс - наилучший результат для 100 прогонов
sort_cpp_recurse_ms.exe : 98 мс - наилучший результат для 100 прогонов
sort_asm_recurse.exe : 92 мс - наилучший результат для 100 прогонов
```
Ну, это интересно. Различные компиляторы дают, в основном, одинаковый результат с незначительным преимуществом у MSVC. **Но версия ассемблера работает явно быстрее** — почти на 7% в этом случае.
Дело в том, в C++ не всегда имеется хорошее представление базовой машины. Это нормально, когда речь идёт о переменных, но его представление стека очень ограничено. C++ считает, что мы можем использовать стек только для вызовов, тогда как в действительности — одна из вещей, которые мы можем делать, это использовать его в качестве стека данных.
Попробуем и посмотрим, что получится. Мы удалим рекурсивные обращения к sortRoutine и вместо этого будем извлекать наши диапазоны данных непосредственно из стека. Это позволяет нам работать в едином цикле без необходимости, фактически, обращаться к рекурсии. Часто такой подход может дать значительное преимущество, поскольку устраняет потери времени на каждом входе в функцию / выходе из неё.
Соответствующая программа имеется в архивном файле ниже.
```
sort_cpp_recurse_gcc.exe : 99 мс - наилучший результат для 100 прогонов
sort_cpp_recurse_clang.exe : 99 мс - наилучший результат для 100 прогонов
sort_cpp_recurse_ms.exe : 98 мс - наилучший результат для 100 прогонов
sort_asm_recurse.exe : 92 мс - наилучший результат для 100 прогонов
sort_cpp_iter_gcc.exe : 106 мс - наилучший результат для 100 прогонов
sort_cpp_iter_clang.exe : 97 мс - наилучший результат для 100 прогонов
sort_cpp_iter_ms.exe : 95 мс - наилучший результат для 100 прогонов
sort_asm_iter.exe : 92 мс - наилучший результат для 100 прогонов
```
Интересно. Версия ассемблера дала почти тот же результат. Я полагаю, это связано с тем, что, хотя итеративный подход устраняет потери на работу с функциями, но такие потери у нашей написанной вручную версии для x64 на самом деле невелики, поэтому выигрыша не наблюдается.
Но для версий C++ иная ситуация. Большинство продемонстрировало незначительное увеличение скорости, но gcc явно медленнее! Насколько я могу видеть из дизассемблирования, управление построено так, как будто оно пытается запутать само себя. Увеличенные маршруты управления и связанные с этим навороты привели к усложнённому «жонглированию».
Я скомпилировал эти тесты на x64, где соглашением по умолчанию о вызовах является fastcall. Полагаю, что если взамен скомпилировать решение для варианта на 32 бита, использующего соглашение на базе стека cdecl, то нерекурсивная версия дала бы сравнительно лучший результат. Я не пробовал — оставляю как упражнение для читателя.
Заключение
----------
Создаётся впечатление, что старая присказка «современные компиляторы всегда быстрее, чем написанная вами на ассемблере программа» совсем не обязательно является правильной.
Однако правильно то, что компилятор делает *достаточно хорошо* свою работу, а с кодом легче работать. Поэтому, хотя можно было бы выжать ещё немного скорости, но это вряд ли оправдано из-за появляющихся трудностей, связанных с техобслуживанием.
Версия ассемблера *была* всё же быстрее. Полагаю, что если в этом посте вы нашли для себя что-то полезное — так это то, что народ в интернете *иногда может говорить нечто, совсем не соответствующее действительности*.
**Материалы**
[sorttest.zip](http://www.codersnotes.com/notes/beating-the-compiler/sorttest.zip) — Все коды, использованные в данной статье. | https://habr.com/ru/post/317078/ | null | ru | null |
# Отслеживание заполнения форм с помощью Google Analytics
Эффективность работы коммерческого интернет-проекта зависит от количества заказов, регистраций, отзывов и других элементов обратной связи оставленных посетителями сайта через электронную форму.
Соответственно, форма — уязвимое место приема таких обращений, которое может сократить их число из-за своей неэффективности.
Для оценки эффективности можно использовать различные методы, но сейчас мы остановимся на оценке форм с помощью системы веб-аналитики Google Analytics.
Идея данного метода взята из статьи [«Use Virtual Page Views to See Which Steps Visitors Abandon From»](http://www.seomoz.org/blog/11-conversion-lessons-learned-2009).
В данной статье рассматривает ее применение на практике.
#### Отслеживание с помощью событий в Google Analytics
Сначала определим каким образом в Google Analytics будут поступать данные. Для этого будем использоваться метод отслеживания событий существующий в системе.
Все данные, получаемые с форм, будут поступать в Google Analytics с помощью метода [\_trackEvent()](http://code.google.com/intl/ru/apis/analytics/docs/tracking/eventTrackerGuide.html).
Спецификация данного метода такова:
**\_trackEvent(category, action, opt\_label, opt\_value)**
**category** (обязательно) — название для группы объектов, которые следует отслеживать
**action** (обязательно) — данное свойство определяет тип взаимодействия с сайтом (клик, скачивание, просмотр и т.д.)
**label** (необязательно) — дополнительные характеристики отслеживаемых событий (имя скачиваемого файла, название страницы на которой осуществилось событие и т.д.)
**value** (необязательно) — целое число, которое можно использовать для предоставления численных данных об отслеживаемых событиях
#### Установка кода на страницах сайта
Пока что мы определились каким образом данные будут передаваться системе Google Analytics.
Теперь рассмотрим откуда и как будут браться сами данные.
Для этого используем библиотеку [jQuery](http://jquery.com/).
Для передачи адреса страницы в систему веб-аналитики Google Analytics используется [jquery url parser](http://projects.allmarkedup.com/jquery_url_parser/index.php) и [:input Selector](http://api.jquery.com/input-selector/) библиотеки jQuery.
В итоге код обрабатывающий форму на странице будет выглядеть следующим образом:
````
$(document).ready(function() {
var currentPage = jQuery.url.attr("path");
$(':input').blur(function () {
if($(this).val().length > 0){
pageTracker.\_trackEvent("Form: " + currentPage, "input\_exit", $(this).attr('name'));
}
});
});
````
Значения событий (label) берутся из атрибута «name» полей формы.
В тег «head» прописываем строки подключения библиотеки:
#### Полученные данные в отчетах Google Analytics
Полученные результаты можно наблюдать в отчете «Отслеживание событий» системы Google Analytics.
Данный отчет располагается в разделе меню «Содержание»:
Перейдя в подраздел «Категории» перед нами откроется отчет содержащий список всех форм с указанием страниц, на которых они были размещены, и где были произведены действия. В данном отчете также отображается и количество событий для каждой формы.
Нажав на адрес формы можно ознакомится с отчетом, содержащим все события связанные с ней.
Ярлыки события — это те поля формы, в которых была зафиксирована активность посетителей сайта.
Оригинальная форма имеет следующий вид:
Какие выводы можно сделать из полученных данных:
* На основе полученных данных можно отследить какие поля формы пользователи заполняют чаще, а какие остаются незаполненными, что приводит к неотправке формы. Особенно такие данные будут полезны для форм с большим количеством полей, списков и других элементов.
* Cравнение количества активностей зафиксированных в форме с реально пришедшими запросами через эту форму. Если видим что пользователи что-то вводят, а информация не поступает нам, то возможно что-то не так с формой и стоит ее проверить — она не работает, или частые сбои при отправке данных, например. | https://habr.com/ru/post/100930/ | null | ru | null |
# PHP-Дайджест № 160 (1 – 15 июля 2019)
[](https://habr.com/ru/post/460022/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHP 7.4.0 alpha 3, ReactPHP 1.0 LTS, порция полезных инструментов, видеозаписи с конференций, подкасты и многое другое.
Приятного чтения!
### Новости и релизы
* [PHP 7.3.7](https://www.php.net/ChangeLog-7.php#7.3.7)
* [PHP 7.2.20](https://www.php.net/ChangeLog-7.php#7.2.20)
* [PHP 7.4.0 alpha 3](https://www.php.net/archive/2019.php#2019-07-11-1) — Последний альфа-релиз из [запланированных](https://wiki.php.net/todo/php74#timetable). Фиче-фриз должен быть 22 июля, поэтому текущий [список изменений](https://github.com/php/php-src/blob/php-7.4.0alpha3/UPGRADING) может дополниться только теми, по которым голосование стартовало не позже 8 июля. Итого сейчас на голосовании:
• [Deprecations for PHP 7.4](https://wiki.php.net/rfc/deprecations_php_7_4)
• [Escape PDO "?" parameter placeholder](https://wiki.php.net/rfc/pdo_escape_placeholders)
• [Deprecate curly brace syntax for accessing array elements and string offsets](https://wiki.php.net/rfc/deprecate_curly_braces_array_access)
• [Add str\_starts\_with(), str\_ends\_with() and related functions](https://wiki.php.net/rfc/add_str_begin_and_end_functions).
Также пара свежих изменений без отдельных RFC:
• `proc_open` будет принимать аргументы в виде массива, их не надо экранировать и при этом процесс запустится напрямую без промежуточного запуска shell:
```
proc_open(['php', '-r', 'echo "Hello World\n";'], $descriptors, $pipes);
```
• В PHP 7.4 будет бросаться notice при попытке неправильного использования скалярных типов как массивов. Раньше такие вызовы просто возвращали `null`:
```
$null = null;
var_dump($null[0]); // NULL
$int = 42;
var_dump($int['foo']); // NULL
var_dump(true[0] === false[0]); // true
```
### Инструменты
* [humbug/php-scoper](https://github.com/humbug/php-scoper) — Инструмент позволяет в один шаг добавить префикс ко всем неймспейсам в указанной папке. Может пригодиться, когда необходимо использовать несколько версий одного пакета, [пример использования для WordPress-плагинов](https://developer.yoast.com/safely-using-php-dependencies-in-the-wordpress-ecosystem/).
* [CaptainHookPhp/captainhook](https://github.com/CaptainHookPhp/captainhook) — Менеджер Git-хуков для PHP-проектов.
* [sebastianfeldmann/phpbu](https://github.com/sebastianfeldmann/phpbu) — Инструмент для создания резервных копий файлов и баз данных. Умеет шифровать бэкапы и отправлять в хранилища.
* [localheinz/http-method](https://github.com/localheinz/http-method) — Набор констант с названиями HTTP-методов.
* [spiral/roadrunner](https://github.com/spiral/roadrunner/) — Сервер приложений для PHP на Golang. Добавлена поддержка FastCGI, настройки CORS из коробки, встроенные метрики на Prometheus. Подробный обзор в [докладе от автора](https://www.youtube.com/watch?v=647CIr6ZkDA).
* [leocarmo/circuit-breaker-php](https://github.com/leocarmo/circuit-breaker-php) — Реализация паттерна [Circuit Breaker](https://martinfowler.com/bliki/CircuitBreaker.html) для PHP. Альтернатива: [ackintosh/ganesha](https://github.com/ackintosh/ganesha).
### Symfony
* [Symfony Local Web Server, 6 месяцев спустя](https://symfony.com/blog/symfony-local-web-server-6-months-later)
* [Неделя Symfony #654 (8-14 июля 2019)](https://symfony.com/blog/a-week-of-symfony-654-8-14-july-2019)
* [Переносим Symfony-приложение на Kubernetes](https://itnext.io/publishing-symfony-application-with-helm-ecb525b34289)
### Laravel
*  [10 полезных методов Коллекций Laravel](https://laravel.demiart.ru/10-helpful-methods-laravel-collections/)
* [Исследование TestCase в Laravel](https://timacdonald.me/the-case-laravel-testcase/) и ускорение загрузки на 50% во время тестов.
*  [Делаем Event Sourcing в Laravel с помощью EventSauce](https://astrocasts.com/live-sessions/projects/event-sourcing-with-laravel-and-eventsauce/session-1)
### Yii
* [Как реализовать «логин под другим юзером» для тестирования приложения](https://2amigos.us/blog/how-to-do-identity-impersonation-with-yii2)
* [Последние релизы Yii 2 и новости Yii 3](https://opencollective.com/yiisoft/updates/yii-2-0-22-extension-releases-and-yii-3-progress)
### Async PHP
* [ReactPHP 1.0 LTS](https://www.lueck.tv/2019/announcing-reactphp-lts) — 7 лет назад свет увидел первый релиз ReactPHP v0.1.0. А сейчас, команда проекта анонсировала версии 1.0 пакетов [reactphp/dns](https://github.com/reactphp/dns), [reactphp/cache](https://github.com/reactphp/cache) и мета-пакета [reactphp/react](https://github.com/reactphp/react). Таким образом, все основные пакеты теперь достигли стабильной версии. Релиз идёт с пометкой LTS и значит будет поддерживаться не менее двух лет.
*  Пишем RESTful API с помощью ReactPHP: [Добавляем роуты](https://www.youtube.com/watch?v=vUZ98oHwzco), [Рефакторим добавляя контроллеры](https://www.youtube.com/watch?v=xJbFS7NBF14), [Тестовые ендпоинты](https://www.youtube.com/watch?v=9LILEZqdtkA), [Добавляем обработку ошибок](https://www.youtube.com/watch?v=fl7gcLRhPTY)
* [Используем ReactPHP для запуска команд Drupal](https://glamanate.com/blog/using-reactphp-run-drupal-tasks)
* [swoft-cloud/swoft 2.0](https://github.com/swoft-cloud/swoft) — Фреймворк на базе Swoole для реализации микросервисов, вдохновлённый Spring Cloud из Java. Реализует PSR-7, PSR-14, PSR-15 и использует АОП. [Вводный пост](https://medium.com/@inhereat/php-coroutine-framework-swoft-2-0-d41825750d68) в поддержку.
### Security
* [nbs-system/snuffleupagus](https://github.com/nbs-system/snuffleupagus) — Расширение блокирует запуск потенциально небезопасного кода в рантайме. [Об использовании](https://dustri.org/b/snuffleupagus-versus-recent-high-profile-vulnerabilities.html) для предотвращения недавно опубликованных уязвимостей.
* [paragonie/argon2-refiner](https://github.com/paragonie/argon2-refiner) — Инструмент поможет подобрать [оптимальные параметры](https://wiki.php.net/rfc/argon2_password_hash#discussion_issues) для хеширования с помощью алгоритма Argon2id, [добавленного в PHP 7.3](https://wiki.php.net/rfc/argon2_password_hash_enhancements).
* [Используем нюансы парсера запросов в PHP](https://www.secjuice.com/abusing-php-query-string-parser-bypass-ids-ips-waf/) для обхода систем предотвращения/обнаружения вторжений в сеть.
* [Magento 2.3.1: Unauthenticated Stored XSS to RCE](https://blog.ripstech.com/2019/magento-rce-via-xss/) — Разбор [уязвимостей](http://www.opennet.ru/opennews/art.shtml?num=51027) в Magento (<2.3.1), которые позволяли неаутентифицированному пользователю захватить магазин и перенаправить платежи.
### Материалы для обучения
* [Предзагрузка в PHP 7.4](https://stitcher.io/blog/preloading-in-php-74)
* [Хорошие практики написания Dockerfile](https://blog.docker.com/2019/07/intro-guide-to-dockerfile-best-practices/)
* [Как правильно работать с Null значениями](https://afilina.com/null-hell)
* [Прекратите использовать DateTime](https://blog.nikolaposa.in.rs/2019/07/01/stop-using-datetime/)
*  [Микросервисы или монолит: ищем решение](https://habr.com/ru/post/459810/)
*  [Спецификации в PHP](https://habr.com/ru/post/455030/)
*  [Whitespace Обфускатор для PHP](https://habr.com/ru/post/458710/)
*  [composer vs npm: многомодульная разработка](https://habr.com/ru/post/458018/)
*  [Разработка под Docker. Локальное окружение. Часть 1](https://habr.com/ru/post/459972/)
### Аудио/Видео
*  [DevConf 2019, Москва](https://www.youtube.com/watch?v=ufLTLgM1jZs&list=PLuezgi8scAZi6SdRgQMYk1jmC0KMse6m2)
*  [PHPDay 2019, Verona](https://www.youtube.com/playlist?list=PLWK9j6ps_unnnmpaIjDuA_WVJIwWkj1Zv)
*  [PHP Town Hall Episode 67](https://www.youtube.com/watch?v=OFlqCv3V-40) — О Zend Framework 3 и Laminas c [Adam Culp](https://twitter.com/adamculp).
*  [That Podcast Episode 60](https://thatpodcast.io/episodes/episode-60-the-one-where-we-talk-twig-drupal-and-sculpin-with-oliver-davies) — O Twig, Drupal, и Sculpin с [Oliver Davies](https://twitter.com/opdavies).
*  [That Podcast Episode 61](https://thatpodcast.io/episodes/episode-61-the-one-where-we-discuss-symfony-s-http-client-with-nicolas-grekas) — О новом компоненте HTTP Client в Symfony с [Nicolas Grekas](https://twitter.com/nicolasgrekas). Николас [говорит](https://twitter.com/nicolasgrekas/status/1149718300408078342), что PSR-18 не совместим с HTTP/2, потому что стандарт синхронный по своей сути.
### Занимательное
* [Запускаем PHP в JavaScript](https://francisco.io/blog/running-php-in-javascript/) — Автор использует [glayzzle/php-parser](https://github.com/glayzzle/php-parser) и [kornelski/babel-preset-php](https://gitlab.com/kornelski/babel-preset-php). Из более интересных штук можно глянуть на [oraoto/pib](https://github.com/oraoto/pib) – PHP, транслированный в JS с помощью [Emscripten](https://github.com/emscripten-core/emscripten).
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
> Короткая аудиоверсия дайджеста в подкасте [Пятиминутка PHP №56](https://5minphp.ru/episode56/)
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 159](https://habr.com/ru/post/458292/) | https://habr.com/ru/post/460022/ | null | ru | null |
# Аутентификация пользователей на Arduino с RFID
[](https://habrahabr.ru/company/intersystems/blog/279893/)Введение
--------
В [предыдущей статье](https://habrahabr.ru/company/intersystems/blog/273749/) я только начинал работать с Arduino, в результате чего закономерно получилась метеостанция. В этой статье пойдём дальше — будем делать аутентификацию с помощью RFID карт и Arduino в приложении InterSystems Caché.
Передача аутентификации
-----------------------
В Caché есть механизм [делегирования аутентификации](http://docs.intersystems.com/cache20161/csp/docbook/DocBook.UI.Page.cls?KEY=GCAS_delegated) — передачи процесса аутентификации пользовательскому коду. Чтобы его включить, надо сделать следующее:
1. Написать код аутентификации пользователей в рутине ZAUTHENTICATE. У неё есть 4 точки входа: получения логина/пароля, их проверка и назначение прав, смена пароля, формирование токена. Подробнее об этом ниже.
2. Включить передачу аутентификации в Caché (SMP → System Administration → Security → System Security → Authentication/CSP Session Options, установите флаг Allow Delegated authentication и сохраните настройки).
3. Включить передачу аутентификации для требуемых сервисов (SMP → Menu → Manage Services → Сервис → Allowed Authentication Methods → выбрать Delegated → Save) и/или приложений (SMP → Menu → Manage Web Applications → Приложение → Allowed Authentication Methods → выбрать Delegated → Save).
Как это работает
----------------
Вот что происходит, когда пользователь аутентифицируется в сервисе или веб-приложении, для которого включена передача аутентификации:
1. Вызывается рутина ZAUTHENTICATE. Код этой рутины пишется пользователем и может быть любым Caché ObjectScript кодом, в том числе и [$ZF](http://docs.intersystems.com/cache20161/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fzf-1#RCOS_B78412) вызовы.
2. Следующий шаг зависит от того, был ли успешным вызов ZAUTHENTICATE:
* Если вызов ZAUTHENTICATE успешен и это первый раз, когда данный пользователь аутентифицируется с ZAUTHENTICATE, то для него создаётся запись пользователя типа “Delegated user”. Если ZAUTHENTICATE назначает пользователю права или другие свойства, они становятся соответствующими свойствами пользователя.
* Если вызов ZAUTHENTICATE успешен и это не первый раз, когда данный пользователь аутентифицируется с ZAUTHENTICATE, то его запись пользователя обновляется.
* Если вызов ZAUTHENTICATE не успешен, пользователю выдаётся ошибка доступа.
3. Если для инстанса и сервиса включена двухфакторная аутентификация, то производится поиск номера телефона пользователя и оператора. Если они заданы, происходит двухфакторная аутентификация, если нет — юзер не аутентифицируется.
4. Делегированный пользователь отображается в таблице пользователей.
Откуда пользователи?
--------------------
Есть два метода аутентификации в зависимости от того какие способы аутентификации включены для приложения/сервиса:
* Delegated — имя/пароль берутся из GetCredentials, проверяются средствами ZAUTHENTICATE (тип пользователя — делегированный).
* Delegated и Password — имя/пароль берутся из GetCredentials, проверяются стандартными механизмами Caché (тип пользователя — Caché).
Теперь перейдём к рассмотрению рутины ZAUTHENTICATE и её точек входа.
ZAUTHENTICATE
-------------
Эта основная рутина, содержащая 4 точки входа.
#### ▍GetCredentials
Эта точка входа вызывается в том случае, когда передача аутентификации включена для сервиса, и она вызывается вместо запроса логина/пароля у пользователя. Код этой рутины устанавливает логин и пароль (любым способом). Впоследствии (вне этой рутины) полученные логин и пароль аутентифицируются, будто пользователь их ввёл как обычно. Метод получения логина и пароля может быть любой — ввод с клавиатуры, API, считывание внешнего устройства — в этой статье будем использовать аутентификацию с помощью RFID карты.
Данная точка входа возвращает статус, и если это ошибка, то она будет записана в аудит, а попытка аутентификации будет отклонена. Исключение — ошибка $SYSTEM.Status.Error($$$GetCredentialsFailed), в таком случае пользователю предложат ввести логин/пароль стандартным методом Caché. Сигнатура следующая:
```
GetCredentials(ServiceName, Namespace, Username, Password, Credentials) Public { }
```
Где:
* ServiceName — название сервиса, через который идёт подключение
* Namespace — область, если указана при подключении
* Username — имя пользователя
* Password — пароль
* Credentials — в настоящее время не используется
Отмечу важную особенность этой точки входа. Если для сервиса/приложения включена и передача аутентификации и обычная аутентификация по паре логин/пароль (Password Authentication), то логин и пароль, полученные через GetCredentials, будут использованы для стандартной аутентификации по паролю.
#### ▍ZAUTHENTICATE
В случае если первоначальная аутентификация успешна, ZAUTHENTICATE устанавливает роли и другие свойства пользователя. В случае если это не первая аутентификация, свойства могут быть изменены. Для этого в коде рутины устанавливаются свойства массива Properties. Сигнатура:
```
ZAUTHENTICATE(ServiceName, Namespace, Username, Password, Credentials, Properties) Public { }
```
Массив Properties:
* Properties("Comment") — комментарий
* Properties("FullName") — имя и фамилия
* Properties("NameSpace") — стартовая область
* Properties("Roles") — список ролей через запятую
* Properties("Routine") — стартовая рутина
* Properties("Password") — пароль
* Properties("Username") — имя пользователя
* Properties("PhoneNumber") — телефонный номер пользователя
* Properties("PhoneProvider") — оператор телефона
* Properties("AutheEnabled") — включить стандартную двухфакторную аутентификацию (для этого надо установить значение, равное $$$AutheTwoFactorSMS)
#### ▍ChangePassword
Точка входа для смены пароля пользователя. Сигнатура следующая:
```
ChangePassword(Username, NewPassword, OldPassword, Status) Public { }
```
Где:
* NewPassword — новый пароль
* OldPassword — старый пароль
* Status — результат операции изменения пароля
#### ▍SendTwoFactorToken
Для использования в стандартной двухфакторной аутентификации. Определяет формат запроса и токена аутентификации. Сигнатура:
```
SendTwoFactorToken(Username, ServiceName,Namespace,Application,Credentials,SecurityToken,TwoFactorTimeout,UserPhoneNumber) Public { }
```
Где:
* Application — CSP приложение или рутина, к которой подключается пользователь
* SecurityToken — токен, который будет отправлен пользователю
* TwoFactorTimeout — время действия токена
* UserPhoneNumber — телефонный номер пользователя
Пример
------
Для начала покажу простейший пример для терминала Caché в Windows — сервиса %Service\_Console, который будет спрашивать логин и пароль у пользователя. Включим передачу аутентификации в системе для этого сервиса. После этого напишем рутину ZAUTHENTICATE (в области %SYS):
```
ZAUTHENTICATE(ServiceName, Namespace, Username, Password, Credentials, Properties) PUBLIC {
#Include %occErrors
#Include %occStatus
Quit $$$OK
}
GetCredentials(ServiceName, Namespace, Username, Password, Credentials) Public {
#Include %occErrors
#Include %occStatus
Do ##class(%Prompt).GetString("USER:",.Username)
Do ##class(%Prompt).GetString("PASS:",.Password)
Quit $$$OK
}
```
В терминале это будет выглядеть аналогично обычному логину.
```
>USER: _SYSTEM
>PASS: SYS
```
RFID
----
Перейдём к аутентификации на RFID. Идея состоит в следующем — из Caché сделаем возможность записывать в зашифрованном виде информацию на карточку, а при аутентификации будем её считывать, расшифровывать и возвращать на проверку.
Для начала соберём схему из Arduino Uno и модуля RFID-RC522:
Вот код на С, использующий библиотеку [MF522](https://github.com/miguelbalboa/rfid) (там же есть распиновка для других моделей Arduino). Он по COM порту принимает 2 команды:
* Get — по ней на com порт передаётся содержимое блоков RFID карты 2, 4, 5, 6
* Set@bloc2@bloc4@bloc5@bloc6 — по ней содержимое блоков 2, 4, 5, 6 на карте перезаписывается пришедшими данными
**Код на C**
```
#include //include the SPI bus library
#include //include the RFID reader library
#define SS\_PIN 10 //slave select pin
#define RST\_PIN 9 //reset pin
#define u1b 2 //Block on a card for user1 byte array
#define u2b 4 //Block on a card for user2 byte array
#define p1b 5 //Block on a card for pass1 byte array
#define p2b 6 //Block on a card for pass2 byte array
MFRC522 mfrc522(SS\_PIN, RST\_PIN); // instatiate a MFRC522 reader object.
MFRC522::MIFARE\_Key key; //create a MIFARE\_Key struct named 'key', which will hold the card information
byte readbackblock[18]; //This array is used for reading out a block. The MIFARE\_Read method requires a buffer that is at least 18
String inString = ""; // COM port incoming data buffer
void setup() {
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin(); // Init SPI bus
mfrc522.PCD\_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
// Serial.println("Scan a MIFARE Classic card");
// Prepare the security key for the read and write functions - all six key bytes are set to 0xFF at chip delivery from the factory
// Since the cards in the kit are new and the keys were never defined, they are 0xFF
// if we had a card that was programmed by someone else, we would need to know the key to be able to access it.
// This key would then need to be stored in 'key' instead.
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF; // keyByte is defined in the "MIFARE\_Key" 'struct' definition in the .h file of the library
}
}
void loop() {
// put your main code here, to run repeatedly:
// Receive data from com port
while (Serial.available() > 0) {
int inChar = Serial.read();
if (inChar != '\n') {
inString += (char)inChar;
} else {
// New line
while (!initCard()); // connect to an RFID card
String Action = inString.substring(0, 3);
if (Action == "Set") {
// Write login and pass into the card
setUserAndPassToCard(inString);
} else if (Action == "Get") {
// Read login and pass from the card
readUserAndPassToCom();
} else {
Serial.println(Action);
}
disconnectCard(); // disconnect RFID card
inString = "";
}
}
}
/// Read blocks with user/pass info and output the to COM port:
/// user1user2@pass1pass2
void readUserAndPassToCom()
{
readBlockToCom(u1b);
readBlockToCom(u2b);
Serial.write("@");
readBlockToCom(p1b);
readBlockToCom(p2b);
Serial.println("");
}
/// Set user/pass info into a card
/// Data: Set@user1@user2@pass1@pass2
/// Data sample: Set@1234567890123456@1234567890123456@1234567890123456@1234567890123456
void setUserAndPassToCard(String Data) {
// Serial.println(Data);
byte user1[16], user2[16], pass1[16], pass2[16];
String user1str = inString.substring(4, 20);
String user2str = inString.substring(21, 37);
String pass1str = inString.substring(38, 54);
String pass2str = inString.substring(55, 71);
stringToArray(user1str, user1, sizeof(user1));
stringToArray(user2str, user2, sizeof(user2));
stringToArray(pass1str, pass1, sizeof(pass1));
stringToArray(pass2str, pass2, sizeof(pass2));
writeBlock(u1b, user1); // u1b is the block number, user1 is the block content
writeBlock(u2b, user2);
writeBlock(p1b, pass1);
writeBlock(p2b, pass2);
Serial.println("Done");
}
void stringToArray(String str, byte array[], int arrlength)
{
for (int j = 0 ; j < arrlength ; j++)
{
array[j] = str.charAt(j);
}
}
bool initCard()
{
// Look for new cards (in case you wonder what PICC means: proximity integrated circuit card)
if ( ! mfrc522.PICC\_IsNewCardPresent()) {//if PICC\_IsNewCardPresent returns 1, a new card has been found and we continue
return false; //if it did not find a new card is returns a '0' and we return to the start of the loop
}
// Select one of the cards
if ( ! mfrc522.PICC\_ReadCardSerial()) {//if PICC\_ReadCardSerial returns 1, the "uid" struct (see MFRC522.h lines 238-45)) contains the ID of the read card.
return false; //if it returns a '0' something went wrong and we return to the start of the loop
}
return true;
}
void disconnectCard()
{
// Halt PICC
mfrc522.PICC\_HaltA();
// Stop encryption on PCD
mfrc522.PCD\_StopCrypto1();
}
void readBlockToCom(int number)
{
readBlock(number, readbackblock);//read the block back
for (int j = 0 ; j < 16 ; j++) //print the block contents
{
Serial.write (readbackblock[j]);//Serial.write() transmits the ASCII numbers as human readable characters to serial monitor
}
}
int writeBlock(int blockNumber, byte arrayAddress[])
{
// this makes sure that we only write into data blocks. Every 4th block is a trailer block for the access/security info.
int largestModulo4Number = blockNumber / 4 \* 4;
int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector
if (blockNumber > 2 && (blockNumber + 1) % 4 == 0) {
Serial.print(blockNumber); //block number is a trailer block (modulo 4); quit and send error code 2
Serial.println(" is a trailer block:");
return 2;
}
//Serial.print(blockNumber);
//Serial.println(" is a data block:");
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*authentication of the desired block for access\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
byte status = mfrc522.PCD\_Authenticate(MFRC522::PICC\_CMD\_MF\_AUTH\_KEY\_A, trailerBlock, &key, &(mfrc522.uid));
// byte PCD\_Authenticate(byte command, byte blockAddr, MIFARE\_Key \*key, Uid \*uid);
// this method is used to authenticate a certain block for writing or reading
// command: See enumerations above -> PICC\_CMD\_MF\_AUTH\_KEY\_A = 0x60 (=1100000),
// this command performs authentication with Key A
// blockAddr is the number of the block from 0 to 15.
// MIFARE\_Key \*key is a pointer to the MIFARE\_Key struct defined above, this struct needs to be defined for each block.
// New cards have all A/B= FF FF FF FF FF FF
// Uid \*uid is a pointer to the UID struct that contains the user ID of the card.
if (status != MFRC522::STATUS\_OK) {
Serial.print("PCD\_Authenticate() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 3;//return "3" as error message
}
// it appears the authentication needs to be made before every block read/write within a specific sector.
// If a different sector is being authenticated access to the previous one is lost.
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*writing the block\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
status = mfrc522.MIFARE\_Write(blockNumber, arrayAddress, 16);
//valueBlockA is the block number, MIFARE\_Write(block number (0-15), byte array containing 16 values, number of bytes in block (=16))
// status = mfrc522.MIFARE\_Write(9, value1Block, 16);
if (status != MFRC522::STATUS\_OK) {
Serial.print("MIFARE\_Write() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 4;//return "4" as error message
}
//Serial.println("block was written");
}
int readBlock(int blockNumber, byte arrayAddress[])
{
int largestModulo4Number = blockNumber / 4 \* 4;
int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*authentication of the desired block for access\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
byte status = mfrc522.PCD\_Authenticate(MFRC522::PICC\_CMD\_MF\_AUTH\_KEY\_A, trailerBlock, &key, &(mfrc522.uid));
// byte PCD\_Authenticate(byte command, byte blockAddr, MIFARE\_Key \*key, Uid \*uid);
// this method is used to authenticate a certain block for writing or reading
// command: See enumerations above -> PICC\_CMD\_MF\_AUTH\_KEY\_A = 0x60 (=1100000),
// this command performs authentication with Key A
// blockAddr is the number of the block from 0 to 15.
// MIFARE\_Key \*key is a pointer to the MIFARE\_Key struct defined above, this struct needs to be defined for each block.
// New cards have all A/B= FF FF FF FF FF FF
// Uid \*uid is a pointer to the UID struct that contains the user ID of the card.
if (status != MFRC522::STATUS\_OK) {
Serial.print("PCD\_Authenticate() failed (read): ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 3;//return "3" as error message
}
// it appears the authentication needs to be made before every block read/write within a specific sector.
// If a different sector is being authenticated access to the previous one is lost.
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*reading a block\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
byte buffersize = 18;//we need to define a variable with the read buffer size, since the MIFARE\_Read method below needs a pointer to the variable that contains the size...
status = mfrc522.MIFARE\_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE\_Read requires a pointer instead of just a number
if (status != MFRC522::STATUS\_OK) {
Serial.print("MIFARE\_read() failed: ");
Serial.println(mfrc522.GetStatusCodeName(status));
return 4;//return "4" as error message
}
}
```
Класс Arduino.Delegate, который имеет 2 точки входа:
* SetCredentials — принимает на вход логин и пароль, шифрует их AES шифрованием с помощью ключа хранящегося в системе и записывает на RFID карту.
* GetCredentials — получает шифротекст с карты и расшифровывает его, возвращая логин, пароль и статус операции.
**Arduino.Delegate**
```
/// Delegated Authentication with Arduino.
/// Installation steps:
/// 1. Connect arduino (and upload C code from Delegated.ino there)
/// 2. Make this class visible in %SYS namespace (import there or map pckage)
/// 3. Set SerialPort parameter to a correct value and recompile the class
/// 4. Run Do ##class(Arduino.Delegated).InitEncryption(Key, IV)
/// 5. Write encrypted user credentials to RFID card with SetCredentials
/// 6. Import ZAUTHENTICATE into %SYS
/// 7. Enable Delegated and password auth for relevant services and/or apps
Class Arduino.Delegated [ Abstract ]
{
Parameter SerialPort As %String = "com3";
/// Creates managed encryption key.
/// key - Input key material.
/// Key material 16, 24, or 32 characters long (on Unicode systems, with all character values < 256) is used directly.
/// Otherwise, Password-Based Key Derivation Function #2 (PBKDF2)
/// is used with HMAC-SHA-1,
/// no salt, and one iteration
/// to generate an AES key of the next larger valid size (up to 32 bytes).
/// (See RSA Laboratories Public-Key Cryptography Standards #5 for more information.)
///
/// IV - Initialization vector (optional).
/// If this argument is present it must be 16 characters long (on Unicode systems, with all character values < 256).
/// If this argument is omitted (or is an empty string), a null initialization vector is used.
///
/// Do ##class(Arduino.Delegated).Init("", "")
ClassMethod Init(Key As %String, IV As %String)
{
New $Namespace
Set $Namespace = "%SYS"
Set ^Arduino("Key")= Key
Set ^Arduino("IV")= IV
}
/// Send Arduino the command to set credentials on a card to Username/Password (encrypted)
/// Do ##class(Arduino.Delegated).SetCredentials("\_SYSTEM", "SYS")
ClassMethod SetCredentials(Username As %String(MAXLEN=15), Password As %String(MAXLEN=15)) As %Status
{
Set Status = $$$OK
Set CipherUsername = ..EncryptText(Username)
Set CipherPassword = ..EncryptText(Password)
Set User1 = $Extract(CipherUsername, 1, 16)
Set User2 = $Extract(CipherUsername, 17, 32)
Set User2 = ..AppendToString(User2, , 16)
Set Pass1 = $Extract(CipherPassword, 1, 16)
Set Pass2 = $Extract(CipherPassword, 17, 32)
Set Pass2 = ..AppendToString(Pass2, , 16)
Set CommandList = $ListBuild("Set", User1, User2, Pass1, Pass2)
Set Command = $ListToString(CommandList, "@")
Set Status = ..ExecuteCommand(.Command)
If (Status = "Done") {
Set Status = $$$OK
} Else {
Set Status = $$$ERROR($$$GeneralError, "SetCredentials failure, received: " _ Status)
}
Return Status
}
/// Connect to an Arduino device, receive credentials, decode them and set to Username/Password variables.
/// do ##class(Arduino.Delegated).GetCredentials(.Username, .Password)
ClassMethod GetCredentials(Output Username As %String, Output Password As %String) As %Status
{
Kill Username, Password
Set Username = ""
Set Password = ""
Set Status = $$$OK
Set Credentials = ..ExecuteCommand("Get")
If (($L(Credentials) =65) && ($L(Credentials,"@") = 2)) {
Set CipherUsername = $Piece(Credentials, "@", 1)
Set CipherPassword = $Piece(Credentials, "@", 2)
Set CipherUsername = $Extract(CipherUsername, 1, 24) // we need only first 24 characters
Set CipherPassword = $Extract(CipherPassword, 1, 24)
Set Username = ..DecryptText(CipherUsername)
Set Password = ..DecryptText(CipherPassword)
} Else {
Set Status = $$$ERROR($$$GeneralError, "GetCredentials failure, received: " _ Credentials)
}
Return Status
}
/// Send one line at a time, using common terminating characters (i.e., CR) and receive output
/// Possible comands:
/// **Get** - reads an RFID card and returns information in a format: user@pass
/// **Set@user1@user2@pass1@pass2** - sets information on a RFID card
/// in a format: user@pass (where user = user1@user2)
/// Returns output, produced by Arduino
/// w ##class(Arduino.Delegated).ExecuteCommand("Get")
ClassMethod ExecuteCommand(ByRef Command As %String, SerialPort = {..#SerialPort}) As %String
{
set x=""
try {
//Parameters used to open the serial device:
// portstate = " 0801n0" - by byte position:
// 1: space indicates "don't disconnect the port"
// 2: 0 indicates "don't use modem control"
// 3: 8 indicates 8 data bits
// 4: 0 indicates no parity
// 5: 1 indicates one stop bit
// 6: n indicates that flow control is disabled
// 7: 0 indicates disable DTR
// /BAUD=9600 determines the baud rate, of course.
open SerialPort:(:::" 0801n0":/BAUD=9600)
set old = $io //Keep track of the original device
use SerialPort
write $char(10)
hang 1
write Command _ $Char(10)
read x //Read until a termination character is reached
use old
close SerialPort
} catch ex {
close SerialPort
w $System.Status.GetErrorText(ex.AsStatus())
}
return x
}
/// Get key to encode/decode via EncryptText/DecryptText
ClassMethod GetKey() [ CodeMode = expression ]
{
$Get(^Arduino("Key"))
}
/// Get IV to encode/decode via EncryptText/DecryptText
ClassMethod GetIV() [ CodeMode = expression ]
{
$Get(^Arduino("IV"))
}
/// Encrypt PlainText with AESCBCEncrypt
/// Write ##class(Arduino.Delegated).EncryptText("string")
ClassMethod EncryptText(PlainText As %String) As %String
{
Set Text=$ZConvert(PlainText,"O","UTF8")
Set Text=$System.Encryption.AESCBCEncrypt(Text, ..GetKey(), ..GetIV())
Set Ciphertext=$System.Encryption.Base64Encode(Text)
Return Ciphertext
}
/// Decrypt PlainText with AESCBCEncrypt
/// Write ##class(Arduino.Delegated).DecryptText("sFgKzZVle187N4OqhhcXPw==")
ClassMethod DecryptText(CipherText As %String) As %String
{
Set Text=$System.Encryption.Base64Decode(CipherText)
Set Text=$System.Encryption.AESCBCDecrypt(Text, ..GetKey(), ..GetIV())
Set PlainText=$ZConvert(Text,"I","UTF8")
Return PlainText
}
/// Extends right side of a String by Character up to Length chars
/// Write ##class(Arduino.Delegated).AppendToString("")
ClassMethod AppendToString(String As %String, Character As %String(MAXLEN=1) = "_", Length As %Integer = {$Length(String)}) As %String
{
Set Difference = Length - $Length(String)
Return:Difference<=0 String
Set Tail = $Justify("", Difference)
Set Tail = $Translate(Tail, " ", Character)
Return String _ Tail
}
}
``` | https://habr.com/ru/post/279893/ | null | ru | null |
# Тетрис на микроконтроллере в Tera Term
В этом году компания Atmel анонсировала линейку «младших» кортексов М0+ семейства SAM D09, SAM D10, SAM D11. Эти не сильно «навороченные» контроллеры имеют низкую цену и небольшие корпуса. Причем в линейке присутствуют камни в легкопаяемых корпусах SOIC-14 и SOIC-20. Для ознакомления с возможностями контроллера доступны очень дешевые отладки из серии Xplained mini, которые совместимы с шилдами от Arduino. Эти особенности, возможно, вызовут интерес не только среди профессиональных разработчиков, но и у радиолюбителей.
Когда отладки попали к нам в руки, захотелось вместо «серьёзной» демонстрационной задачи в честь приближающегося Нового года сделать что-нибудь забавное и креативное. Мы поскребли по сусекам и нашли старенький проектик — тетрис на MEGA168 через терминалку и решили портировать его на новый камень и представить общественности. Практического смысла в этом никакого, что называется Just for fun. Кому интересны подробности, прошу под кат.
#### Кратко о новых микроконтроллерах
* [SAM D09](http://www.atmel.com/products/microcontrollers/arm/sam-d.aspx#samd09) — младший представитель семейства SAM D. Имеет 8К или 16К флеша и 4К SRAM. Варианты корпусов QFN-24 и SOIC-14. На борту DMA и Event system. 2 SERCOM — универсальных коммуникационных модулей, которые могут конфигурироваться как USART, SPI или I2C. 5-ти или 10-ти канальный 12-ти битный АЦП.
* [SAM D10](http://www.atmel.com/products/microcontrollers/arm/sam-d.aspx#samd10) — апгрейд D09 в части добавления дополнительных таймеров, аналогового компаратора, ЦАП и контроллера сенсорных кнопок, а так же дополнительного SERCOM для некоторых модификаций. Варианты корпусов QFN-24, SOIC-14, SOIC-20.
* [SAM D11](http://www.atmel.com/products/microcontrollers/arm/sam-d.aspx#samd11) — тот же D10, но с добавлением Full-Speed USB Device.
Внешний вид отладочной платы. Программатор на борту, подключение через разъем Micro USB.
#### Теперь про сам тетрис
Работа тетриса основана на нескольких базовых принципах:
* общение с терминалкой осуществляется по протоколу VT100,
* обновление картинки происходит по таймеру,
* любая фигура вписывается в квадрат определенных размеров (4 на 4 символа).
Тетрис использует три [команды](https://ttssh2.osdn.jp/manual/en/about/ctrlseq.html#CSI) из протокола [VT100](https://ru.wikipedia.org/wiki/VT100): очистка экрана, перемещение курсора в начало и сделать курсор невидимым.
Для работы по этому протоколу можно использовать терминалку Tera term, например.
Для управления используются 5 клавиш-букв клавиатуры:
* **n** – начать новую игру,
* **w** или **space** – повернуть фигуру,
* **s** – уронить фигуру,
* **d** – переместить вправо,
* **a** – переместить влево.
**В коде можно легко переназначить клавиши управления на другие**
```
switch (c)
{
case 'w':
case ' ':
//ROTATE
tetris_rotate();
break;
case 's':
//DOWN
tetris_gravity();
break;
case 'd':
//RIGHT
tetris_move_right();
break;
case 'a':
//LEFT
tetris_move_left();
break;
default: break;
}
if (c == 'n')
{
c=0;
//Seed random function so we do not get same start condition
//for each new game. In essence we will not start a new game
//exactly at the same time.
srand(tick);
//New Game
is_running = true;
terminal_cursor_off();
terminal_clear();
tetris_init();
tetris_new_block();
terminal_cursor_home();
tetris_print();
}
```
Скорость игры устанавливается таймером. Для более опытных игроков можно задать «тиканье» быстрее, тогда и фигуры будут падать быстрее.
Конечно же, подсчитываются очки: за каждую исчезнувшую строку добавляется 100 очков. За каждую следующую «исчезнувшую» одновременно с первой, добавляется в два раза больше очков, чем за предыдущую.
#### Портируем с mega на samd10
Из периферии контролера нам нужен SERCOM в режиме UART для непосредственной передачи фигурок и картинки, и таймер для отсчета времени обновления картинки.
Вместо милой сердцу любого программиста 8-битных контроллеров настройки UART битами в регистрах:
```
static void board_init(void)
{
/*Configure IO pins:
* - UART pins
* - SW pin
* - LED pin
*/
DDRD &= ~USART_RX_PIN_bm;
DDRD |= USART_TX_PIN_bm;
PORTD |= USART_TX_PIN_bm;
PORTB |= SW_PIN_bm;
DDRB &= ~SW_PIN_bm;
/*Disable all modules we will not use*/
PRR = (1 << PRTWI) | (1 << PRTIM2) | (1 << PRTIM0) | (1 << PRSPI) | (1 << PRADC);
}
```
конфигурируем sercom для работы в режиме uart, не забывая разрешить прерывания и callback по приему символа.
**Конфигурация Sercom в режиме uart**
```
static void configure_console(void)
{
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART_MODULE, &usart_conf);
}
enum status_code usart_enable_rx_interrupt( struct usart_module *const module, uint8_t *rx_data)
{
// Sanity check arguments
Assert(module);
Assert(rx_data);
// Issue internal asynchronous read
// Get a pointer to the hardware module instance
SercomUsart *const usart_hw = &(module->hw->USART);
module->rx_buffer_ptr = rx_data;
// Enable the RX Complete Interrupt
usart_hw->INTENSET.reg = SERCOM_USART_INTFLAG_RXC;
return STATUS_OK;
}
void configure_usart_callbacks(void)
{
usart_register_callback(&cdc_uart_module, USART_RX_callback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED);
}
```
В исходном коде для меги данные по uart принимались с помощью putc, для samd10 сделаем проще: пусть просто по прерыванию каждый полученный байт сваливается в определенную переменную. Это решение не претендует на правильность и безопасность, оно для простоты перехода и ускорения его.
Подробно про то, как победить порой слишком «умную» ASF для приема одного байта по прерываниям, мы писали в нашей [статье](http://we.easyelectronics.ru/cortex/nastroyka-uart-po-preryvaniyam-dlya-atmel-sam-d20-d21.html) на сайте we.easyelectronics.ru.
Перейдем к таймерам.
Код для меги:
```
void init_timer(void)
{
/*Start timer used to iterate game and seed random function*/
TIFR1 = 1 << OCF1A;
TIMSK1 = 1 << OCIE1A;
OCR1A = TIMER_TOP_VALUE;
TCCR1B = (1 << WGM12) | (1 << CS12) | (1 << CS10);
}
ISR(TIMER1_COMPA_vect, ISR_BLOCK)
{
++tick;
iterate_game = true;
}
```
И соответствующий код для samd10
```
/** Configures TC function with the driver.
*/
static void configure_tc(void)
{
struct tc_config config_tc;
tc_get_config_defaults(&config_tc);
config_tc.counter_size = TC_COUNTER_SIZE_16BIT;
config_tc.wave_generation = TC_WAVE_GENERATION_MATCH_FREQ;
config_tc.counter_16_bit.compare_capture_channel[0] = 2000;
config_tc.clock_prescaler=TC_CLOCK_PRESCALER_DIV1024;
tc_init(&tc_instance, CONF_TC_INSTANCE, &config_tc);
tc_enable(&tc_instance);
}
/** Registers TC callback function with the driver.
*/
static void configure_tc_callbacks(void)
{
tc_register_callback(&tc_instance, tc_callback_to_counter, TC_CALLBACK_CC_CHANNEL0);
tc_enable_callback(&tc_instance, TC_CALLBACK_CC_CHANNEL0);
}
static void tc_callback_to_counter( struct tc_module *const module_inst)
{
++tick;
iterate_game = true;
}
```
Вот и все. Весь остальной код для обработки движения фигур и всей остальной логики остается таким же.
Полностью проект для samd 10 лежит на [github](https://github.com/marus-ka/tetris_samd10).
**Настройки для Tera Term:**
Стоимость отладочной платы [ATSAMD10-XMINI](http://r-ng.ru/node/67) составляет 450 рублей. | https://habr.com/ru/post/275401/ | null | ru | null |
# Как звучит сердцебиение: перевод бумажной кардиограммы в WAV-формат
Многим неоднократно приходилось сталкиваться с обследованием сердца в медицинских учреждениях с помощью кардиографа. Данный аппарат измеряет биоэлектрическую активность сердца, регистрируя результат на бумажной ленте. Современные кардиографы записывают результат измерения не на бумагу, а в цифровую память. Однако в качестве конечного носителя записанной информации зачастую применятся бумажная лента. Визуально она представляет собой длинную миллиметровую бумагу небольшой ширины, которая скручена в рулон. На бумаге, помимо миллиметровой сетки, нарисован во всю длину некий график, который отражает закон изменения измеряемой величины во времени. Измеряемая величина, как я понимаю, это есть разность потенциалов между отведениями. Чаще всего на одной ленте представлено сразу несколько графиков, так как регистрируются разности потенциалов между множеством отведений. Однако, не вдаваясь в подробности медицины, в дальнейшем будем рассматривать один из первых основных графиков. Кроме графиков, на ленте имеется дополнительная текстовая информация: масштаб по горизонтали (мм/сек), по вертикали (мм/мВ), измеренная частота сердцебиения (уд/мин) и прочее.
Возникла идея преобразовать данный график в звуковой формат, воспроизвести результат и послушать, как это будет звучать.
По предварительному анализу можно сделать вывод, что частотный состав такой волны не очень насыщенный. Фактически это низкие частоты, включая инфразвук, который, как считается, не слышен. Однако можно будет увидеть, как диффузор НЧ динамика будет повторять колебания, похожие на «колебания» сердца. На самом же деле, ввиду наличия емкостных дифференцирующих цепей на пути распространения сигнала от звуковой карты ПК до НЧ усилителя, колебания динамической головки не будут в точности повторять колебания, представленные на кардиограмме. И это при условии, что нигде не установлены фильтры, срезающие сверхнизкие частоты. Кроме того, будут присутствовать нелинейные искажения, сопровождающиеся кратными гармониками верхних частот. Тем не менее, не принимая во внимание вышеизложенный анализ, поставим задачу так: преобразовать график на бумаге в формат WAV, чтобы при открытии этого файла в звуковом редакторе вид волны совпадал с бумажным вариантом и, кроме того, чтобы соответствовал временной масштаб.
Для начала надо прикинуть глубину квантования (разрешающая способность цифрового аудио по вертикали). Я рассматриваю один из стандартных: 8 или 16 бит. Второй вариант (16 бит) – это 65536 сэмплов по вертикали, что будет соответствовать 65536 пикселей картинки, которая представляет собой скан или фотографию кардиограммы. Это очень много, и смысла в этом нет. Если брать 8 бит – это 256 сэмплов, или 256 пикселей картинки. Вот это уже более подходящий вариант. При этом динамический диапазон аудио составит 6\*8=48 дБ. Я не знаю, какой динамический диапазон у кардиограммы, но думаю, что не больше. У самого аппарата он естественно больше, но погрешность неизбежна при выводе кардиограммы на бумагу, особенно если речь идёт о прямой прорисовке пером. Кстати, насчёт последнего. Я не буду брать во внимание старые образцы, которые нарисованы «радиальным» пером. Миллиметровая бумажная лента для таких кардиограмм специфическая: по вертикали вместо прямых линий нанесены дуги окружностей. Что касается масштаба по горизонтали – частота дискретизации – будет рассчитываться исходя из масштаба кардиограммы и размера изображения. От этого параметра будет зависеть скорость воспроизведения, и она должна соответствовать реальной «скорости кардиограммы».
Бумагу с кардиограммой следует отсканировать в ч/б виде с оттенками серого в достаточном разрешении. Затем нужно изменить размер изображения таким образом, чтобы требуемая кардиограмма вписывалась в полосу шириной 256 пикселей. Я нашёл в Интернете множество изображений с кардиограммами. В качестве примера рассмотрим два из них.
Первое изображение, можно сказать, уже почти подготовленное. Высота изображения – 431. Ширина – 1023. Волна по ширине полностью заполняет весь рисунок. А вот по высоте нужно оставить 256, обрезав изображение сверху и снизу так, чтобы волна располагалась приблизительно по центру.
На втором рисунке изображено сразу несколько кардиограмм. Возьмём самую первую. После обрезки получилась картинка размерами 508 на 61.
Не растягивая изображение по вертикали, сделаем картинку по высоте 256, заполнив созданную область белой пустотой. Волна также должна располагаться приблизительно по центру. Ширину 508 при вырезании я выбрал так, чтобы оставить как можно большее число целых миллиметровых клеток, которые также видны на изображении.
Оба изображения нужно преобразовать к такому виду, при котором будет виден только чёрный график на белом фоне и больше ничего. Это делается элементарно. Ввиду того, что график нарисован намного жирнее, чем миллиметровая сетка, в графическом редакторе с помощью регулировок «яркость, контрастность, насыщенность» можно добиться требуемого результата. Если не получается идеального преобразования, лишний оставшийся «мусор» над графиком необходимо стереть инструментом «ластик». Все изображения требуется сохранить в формат монохромного BMP. Таким образом, в картинке уже точно останутся только белые и чёрные цвета.
Прежде приступить к описанию алгоритма преобразования картинки в WAV, стоит оговорить некоторые нюансы, которые упростят программирование. Получившиеся картинки необходимо повернуть на 90 градусов против часовой стрелки (ширина и высота изображения при этом поменяются местами). Это нужно для того, чтобы сориентировать начало кардиограммы с началом BMP файла. Известно, что цветовые данные каждого пикселя BMP файла записываются в файл по порядку построчно, начиная с нижнего левого угла. Затем картинки необходимо открыть в редакторе «MS Paint» (у меня Windows XP) и выполнить сохранение в 8-битный BMP (256 цветов). Конечно же, произойдёт «переопределение информации», но зато при таком формате каждый пиксель изображения соответствует одному байту, что очень удобно при программировании. Байт «0» — пиксель чёрного цвета, а байт «255» — белого. В результате должно получиться примерно следующее (здесь две картинки соединены и уменьшены вдвое).
Что касается выходного формата – будем выводить не в стандартный WAV файл, а в файл RAW-данных (PCM). Это также упрощает программирование, ибо при выводе в WAV необходимо ещё позаботиться о 44-байтном заголовке. В распространённом звуковом редакторе «Adobe Audition 1.5» PCM файл открывается без проблем. Более того, можно даже выводить в текстовый файл десятичные числа PCM данных в столбик, предварительно сформировав специфический текстовый заголовок. Как ни странно, но такие файлы Adobe Audition также открывает.
Опишем алгоритм преобразования. А алгоритм очень простой: нужно проанализировать каждую строчку BMP файла снизу вверх. Анализ будет заключаться в подсчёте слева направо идущих подряд белых пикселей, пока не встретится чёрный. Полученные целочисленные неотрицательные значения нужно записать в выходной PCM файл в бинарном виде. Размер выходного файла будет в точности совпадать с высотой обрабатываемого изображения. Глубина квантования 8 бит PCM формата аудиоданных подразумевает кодировку сэмплов по такому же принципу. Значение «0» — максимальное отрицательное значения сэмпла аудио, значение «255» — максимальное положительное, а «128» — нулевое значение (посередине). К примеру, файл PCM аудио данных тишины будет содержать одинаковые байты значением «128». Стоит оговорить, что в строчке может встретиться несколько подряд идущих чёрных пикселей, в зависимости от толщины линии кардиограммы. Но описанный алгоритм «ловит» верхнюю огибающую, чего вполне будет достаточно. Тем более, острые пики кардиограммы, направленные вверх, лучше будут схватываться этим способом.
Теперь можно приступить к написанию текста программы. Программа, написанная на Си, весьма простая и в подробных комментариях не нуждается.
```
#include //Нужная библиотека, как обычно;
int main(){ //Типа начало программы;
FILE \*in,\*out; //Входной и выходной файлы;
unsigned long int h,i; //Высота изображения и итератор цикла;
unsigned char px,s; //Прочитанный пиксель и насчитанный сэмпл аудио;
in=fopen("1.bmp","rb"); //Открываем файл на чтение;
out=fopen("1.pcm","wb"); //Открываем файл на запись;
fseek(in,22,SEEK\_SET); //Позиционируемся в то место заголовка, где записана высота изображения
fread(&h,4,1,in); //Считываем высоту изображения (4 байта);
for(i=0;i
```
После выполнения программы над файлом «1.bmp» будет создан файл «1.pcm» в том же каталоге с программой. При попытке открытия файла в Adobe Audition должно всплыть следующее окно.
Необходимо выбрать «Моно», «8-бит», а частоту дискретизации в поле ввода напечатать исходя из расчёта: f=h/(s/v), где h – высота рисунка (оно же и число сэмплов в аудио), s – длинна кардиограммы в миллиметрах, v – масштаб кардиограммы в мм/сек. Последний параметр написан на кардиограмме. На первой кардиограмме ничего не написано, но масштаб, как правило, часто составляет 25 мм/сек. Расчёты частот дискретизации в Excel для наших примеров продемонстрированы на рисунке ниже.
Как сказано выше, вводим в соответствующее поле необходимые значения частот дискретизации для каждого из примеров. Можно вводить даже десятичные доли, всё равно потом произойдёт автоматическое округление до целого.
При нажатии «OK» соглашаемся с тем, что работаем с «Unsigned 8 bit» сэмплами (будет ещё одно окошко), после чего в основном поле звукового редактора развернётся вид волны нашего файла. Заметим, что данный вид будет представлен «вверх ногами», и для полного соответствия с бумажным вариантом следует выполнить инвертирование волны в соответствующем меню. В результате это будет выглядеть так.
Вторая кардиограмма выглядит «потише», так как она изначально была не очень большая по размеру.
К сожалению, не все звуковые карты позволяют воспроизводить аудио на произвольной частоте дискретизации, точнее, подавляющее большинство вовсе не умеет. Для того чтобы корректно воспроизвести файл, необходимо выполнить функцию «Конвертировать тип сэмпла». Будем преобразовывать к ближайшему стандартному значению 8000 Гц, заодно увеличим разрешающую способность по амплитуде до 16 бит. Последнее необходимо для точности на этапе интерполяции при апсэмплинге. Если оставить 8 бит, то оставшаяся область спектра будет заполнена шумом квантования. Кстати говоря, данную процедуру можно было выполнить программно на этапе преобразования BMP-PCM, даже с применением интерполяции. Но одна из целей являлась простота программного кода.
После операции апсэмплинга можно прослушивать и наслаждаться результатом. Можно сохранить результат в стандартный wav или mp3 файл. Звучит ровно так же, как я и предполагал изначально.
По [этой](https://cloud.mail.ru/public/FwSY/Tx3h2zdpi) ссылке можно скачать rar-архив, в котором содержатся два WAV-файла с результатом. | https://habr.com/ru/post/419527/ | null | ru | null |
# 10 противоестественных способов вычисления чисел Фибоначчи
Задача вычисления первых двух десятков чисел Фибоначчи давно потеряла практическую ценность для программистов и используется преимущественно для иллюстрации базовых принципов программирования — рекурсии и итерации. Я же использую ее для демонстрации нескольких языков программирования, в которых она приобретает необычный и местами даже нездоровый вид.
Итак, мой рейтинг десяти наиболее противоестественных способов вычисления чисел Фибоначчи из написанных мной за последние полгода в рамках проекта [Progopedia](http://progopedia.ru). Для уточнения задачи потребуем, чтобы выводом программы были первые 16 чисел в виде
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987,…
#### 10. [Sanscript](http://bit.ly/bgOuuy)
Визуальный язык программирования, в котором все элементы языка представлены в виде элементарных блоков, из которых составляется собственно «код», именуемый диаграммой потоков (flowgram). Место в рейтинге этот язык заслужил размером диаграмм (два, ну три десятка элементов — максимум, который можно использовать на одной диаграмме без скроллинга и окончательного запутывания в связях между блоками) и неудобством использования ключевых структур языка (каждый цикл или условный переход требует для своего описания одной или нескольких отдельных диаграмм, которые мгновенно загромождают логику программы многоуровневой вложенностью и передачей глобальных переменных в виде параметров цикла). Ну, и собственно визуальностью — программа не пишется, а рисуется, и клавиатура как таковая используется только для ввода значений констант и (опционально) переименования элементарных блоков и написания комментариев.
Главная диаграмма потоков
Тело цикла
#### 9. gnuplot
Особенность этого языка (до версии 4.4.0) — отсутствие циклов как таковых. Впрочем, это можно простить — все-таки gnuplot не язык общего назначения, а программа для построения графиков. А цикл можно сымитировать, создав отдельный интерпретируемый файл с телом цикла, который «читается» для начала цикла и «перечитывается» для каждой итерации.
Файл run.gp (главный)
`#!/usr/bin/env gnuplot
i = 1
a = 1
b = 1
res = ''
load "fibonacci.gp"
print res, '...'`
Файл fibonacci.gp (имитация цикла)
`res = res . a . ', '
c = a
a = b
b = b+c
i = i+1
if (i <= 16) reread`
#### 8. Haskell
Ленивые вычисления в комплекте с бесконечными списками — одна из самых известных фишек Haskell — позволяют определить (но не вычислить) числа Фибоначчи в одну строчку кода, остальной код запрашивает нужные числа и выводит их в нужном формате. А все-таки для программиста, получившего классическое воспитание в рамках процедурной парадигмы, этот способ далеко не очевиден и уж точно не естественен.
`module Main where
import Text.Printf
fibs :: [Int]
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
line n = printf "%d, " $ fibs !! n
main = do
sequence_ $ map line [1..16]
putStrLn "..."`
#### 7. SQL
Конечно, SQL сам по себе языком программирования не является, и в большинстве реализаций к нему прилагается процедурное расширение, с использованием которого поставленная задача решается вполне классическим образом. Интерес представляет решение без расширений, на «чистом» SQL. Впрочем, на «чистом» SQL решить не получится — по стандарту язык запросов не содержит ничего, что можно было бы использовать в качестве цикла. Решения получаются зависимыми от конкретной реализации и прилагающихся к ней плюшек.
#### 7.1. Oracle SQL (с версии 9i)
Во внутреннем запросе генерируются индексы чисел (с 1 до 16) при помощи псевдостолбца level и конструкции connect by. В следующем запросе вычисляются сами числа Фибоначчи по их индексам при помощи формулы Бине. Оставшиеся два запроса упорядочивают числа по их индексам и соединяют их в одну строку нужного формата.
````
SELECT REPLACE(MAX(SYS_CONNECT_BY_PATH(fib||', ', '/')),'/','')||'...'
FROM ( SELECT n, fib, ROW_NUMBER()
OVER (ORDER BY n) r
FROM (select n, round((power((1+sqrt(5))*0.5, n)
-power((1-sqrt(5))*0.5, n))/sqrt(5)) fib
from (select level n
from dual
connect by level <= 16) t1) t2
)
START WITH r=1
CONNECT BY PRIOR r = r-1;
````
#### 7.2. Oracle SQL (с версии 10g)
Удобный, но редко применяемый и поэтому малоизвестный оператор model позволяет реализовать цикл внутри SQL-запроса.
````
select max(s) || ', ...'
from
(select s
from dual
model
return all rows
dimension by ( 0 d )
measures ( cast(' ' as varchar2(200)) s, 0 f)
rules iterate (16)
( f[iteration_number] = decode(iteration_number,
0, 1, 1, 1, f[iteration_number-1] + f[iteration_number-2]),
s[iteration_number] = decode(iteration_number,
0, to_char(f[iteration_number]),
s[iteration_number-1] || ', ' || to_char(f[iteration_number]))
)
);
````
#### 7.3. MySQL
Возможность вычисления результатов запроса в цикле реализована более лаконично, чем в Oracle.
````
select concat(group_concat(f separator ', '), ', ...')
from (select @f := @i + @j as f, @i := @j, @j := @f
from information_schema.tables, (select @i := 1, @j := 0) sel1
limit 16) t
````
#### 7.4. Microsoft SQL Server (с версии 2005)
Еще одна достаточно лаконичная реализация циклов, на этот раз с помощью рекурсивного запроса.
````
with fibonacci(a, b) as
(
select 1, 1
union all
select b, a+b from fibonacci where b < 1000
)
SELECT cast(a as varchar)+', ' AS [text()]
FROM fibonacci
FOR XML PATH ('')
````
#### 6. [FP](http://progopedia.ru/language/fp/)
FP — прототип всех существующих языков программирования, использующих парадигму [программирование на уровне функций](http://progopedia.ru/paradigm/function-level/) (function-level, не путать с functional, то есть просто [функциональной](http://progopedia.ru/paradigm/functional/)). Изобретенный в 1977 году, он является скорее математической моделью, чем настоящим языком программирования: у него не было даже официального стандарта (кроме единственной статьи, в которой он описан), не говоря уже о реализации! Тем не менее, в наше время существуют интерпретаторы этого языка, обычно написанные в рамках студенческой работы. Одним из них является [Furry Paws](http://progopedia.ru/implementation/furry-paws/), и его уютное название совершенно не соответствует «комфортности» его использования.
Программирование на уровне функций предполагает построение программы из элементарных функций, комбинируемых при помощи функционалов (функциональных форм). Так, ~1 — элементарная функция, всегда возвращающая значение 1; id — функция, возвращающая переданное ей значение, [] — функциональная форма, объединяющая свои аргументы в последовательность и т.д.
`one = eq.[id, ~1]
dec = sub.[id, ~1]
seq = one -> [~1] ; cat.[seq.dec, [id]]
fibonacci = lt.[id, ~3] -> ~1 ; add.[fibonacci.sub.[id, ~1], fibonacci.sub.[id, ~2]]
main = show.(return @fibonacci.(seq.~16))`
#### 5. [J](http://www.jsoftware.com/)
Еще один язык, использующий «программирование на уровне функций», достойный преемник FP. Интересен тем, что практически любое выражение на нем можно записать несколькими способами, от почти традиционного до совершенно противоестественного (что и требовалось в данной статье). Так, например, вычисление чисел Фибоначчи при помощи формулы Бине можно записать вполне цивильно:
`load 'printf'
g =: 0.5 * (1 + 5 ^ 0.5)
fib =: (0.2 ^ 0.5) * (g &^ - (1-g) &^)
fstr=: '...' ,~ ,~^:4 '%d, '
fstr printf fib 1+i.16`
А можно заменить практически все математические операции на их эквиваленты, специфичные для J:
`load 'printf'
g =: -: >: %:5
fib =: (%:5) %~ g&^ - (1-g)&^
fstr =: '...' ,~ ,~^:4 '%d, '
fstr printf fib"0 >:i.16`
И едва ли кому-то будет очевидно, что %: — это извлечение квадратного корня, >: — инкремент, -: — деление на два, а %~ — деление, причем при записи делимое и делитель меняются местами.
Вычисление с использованием рекурсии:
`load 'printf'
fibr=: 1:`(-&2 + &fibr -&1) @.(2&<)"0
fstr=: '...' ,~ ,~^:4 '%d, '
fstr printf fibr 1+i.16`
#### 4. [Hanoi Love](http://progopedia.ru/language/hanoi-love/)
Малоизвестный эзотерический язык, интересный своим минимализмом и использованием стековой модели памяти. В отличие от следующего языка, основная сложность заключается не в выполнении арифметических действий, а в получении содержимого именно тех элементов стеков, которые нужны на каждом шаге. Вывод на печать, впрочем, так же неприятен, поэтому вычисляется и выводится только первая шестерка чисел.
`;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;.'...;;;;;;;;;;;;.'...,..''''''..`.'.
..;.'.,.'...:...,.'..;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
"'.,.'...,"'.'...,"''.,...'.,..'..,...'...;.'.,.,!...,,,...;;"'"'"'`
Описание языка и комментарии к приведенному коду можно найти на странице [Hanoi Love](http://progopedia.ru/language/hanoi-love/).
#### 3. [Brainfuck](http://progopedia.ru/language/brainfuck/)
Классика жанра эзотерического программирования — Brainfuck. Язык, в котором даже копирование или сложение не является элементарной операцией, вывод на печать
трехзначного числа достоин отдельной оды, а уж использование его для решения какой-то конкретной задачи — ну просто мечта мазохиста :-)
В авторском интерпретаторе (Muller's Brainfuck) содержимое ячеек памяти хранится в переменных типа byte, и числа Фибоначчи с 14-го по 16-ое вызвали бы переполнение памяти. Реализация длинной арифметики на Brainfuck — это уже не симптом, а практически диагноз, поэтому при написании решения предполагалось, что ячейка памяти может хранить числа до 1000 (во многих реализациях языка для хранения используются достаточно вместительные типы данных).
`++++++++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++++
++++++++>++++++++++++++++>>+<<[>>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>
+>>]<<<<<<]>[<+>-]>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-
]>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<[++++++++++
++++++++++++++++++++++++++++++++++++++.[-]]<<<+++++++++++++++++++++++
+++++++++++++++++++++++++.[-]<<<<<<<.>.>>[>>+<<-]>[>+<<+>-]>[<+>-]<<<
-]<<++...`
Описание языка и комментарии к приведенному коду можно найти на странице [Brainfuck](http://progopedia.ru/language/brainfuck/).
#### 2. [Brainloller](http://progopedia.ru/dialect/brainloller/)
Cамый простой из графических диалектов Brainfuck, придуманный Lode Vandevenne.
Программы читаются с картинок PNG, команды записываются пикселями разных цветов, и к имеющимся в Brainfuck восьми командам добавляются еще две — управление указателем на текущий пиксель. Ко всем прелестям Brainfuck добавляется еще полная нечитабельность «кода» и полная невозможность
«кодировать» без вспомогательных средств (например, конвертера программ и картинок).
Авторский интерпретатор языка канул в лету, поэтому для генерации «программы» пришлось писать свой. «Программа» приведена в десятикратном увеличении.
#### 1. [Unary](http://progopedia.ru/dialect/unary/)
Куда уж хуже? — подумает читатель, листая экран дрогнувшей рукой. Да, бывает еще хуже. В предыдущих языках программу можно было хотя бы объять взглядом, а это уже немало.
Встречайте победителя рейтинга — Unary. Диалект Brainfuck, придуманный тем же Lode Vandevenne (о, мсье знает толк в извращениях!), предполагает, что команды Brainfuck преобразуются в двоичные коды и конкатенируются в одно двоичное число, унарная запись которого и является программой на Unary. Программа генерации чисел Фибоначчи представляет собой строку из
167967665105731198557055496639385943332278803897935697536099438828197
665241403160165880863622431582784595268769268183940269756210147305655
704025762911607244068691728105306566342622386432823429136972542304655
647901781271798433263001837026612851345264031562174039657802748245705
398528237993320520942720239597540583536934220029626573406470088757427
393143000966310611249037587993216365993804186165097620168960460854977
571944373603975793034586829061577464233522714007498991416860375267535
193648636795096472789203729505034887001634966681420589637468649908257
407260923590831776308356684326657774592110098643361324426156431864437
942781495979555960608253552679248495326880775320385281559763269974848
026839024530519989287202261977272377723622502479809174132505837648641
033569945906182518892142219706483917757108086522763280388915772444727
238483811923456440363260610571471034139736312976255142288379411989404
9017738035 (то есть примерно 1.68\*10^906) нулей.
Я уверена, что перечисленные здесь языки — далеко не самое страшное, с чем может столкнуться программист (во всяком случае, не все из них :-) ), но я не волшебник, я только учусь. | https://habr.com/ru/post/94421/ | null | ru | null |
# Хаос-инжиниринг, часть 3: Методы и инструменты
> Мы становимся тем, что мы лицезреем. Сначала мы формируем инструменты, потом инструменты формируют нас.
>
>
>
> —Маршал Маклюэн
*Хотелось бы искренне поблагодарить и выразить признательность моему хорошему другу [Рикардо Суэйрасу](https://medium.com/@094459) за его обзор, вклад и за то, что не давал мне бросить эту статью недописанной. Рикардо, ты просто легенда!*
Важно помнить, что хаос-инжиниринг — это не когда выпускаешь на свободу мартышек и без разбору вводишь отказы. Хаос-инжиниринг — это четко определенная, [формализованная методика](https://en.wikipedia.org/wiki/Scientific_method) экспериментирования.
> "Хаос-инжиниринг включает тщательное наблюдение, суровый скептицизм по отношению к объекту наблюдения, поскольку когнитивные предположения искажают интерпретации результатов. Эта методика подразумевает формулировку гипотез через индукцию, основанную на подобных наблюдениях; экспериментальное и основанное на измерениях тестирование выводов, сделанных из подобных гипотез; корректировку или отказ от гипотез, основанных на результатах экспериментов"
>
>
>
> —Wikipedia
Хаос-инжиниринг начинается с понимания стабильного состояния системы, с которой вы имеете дело, последующую формулировку гипотезы и, наконец, эксперимент, который подтверждает ее, помогая увеличить запас прочности системы.
*Фазы хаос-инжиниринга*
В [первой части серии статей](https://medium.com/@adhorn/chaos-engineering-ab0cc9fbd12a) я представил хаос-инжиниринг и обсудил каждый шаг описанной выше методики.
Во [второй части](https://medium.com/@adhorn/chaos-engineering-part-2-b9c78a9f3dde) — разобрал сферы, в которые надо инвестировать, когда проектируете эксперименты по хаос-инжинирингу, и как выбирать верные гипотезы.
В этой, третьей части я сосредоточусь на самом эксперименте и представлю подборку инструментов и методов, которые покрывают широкий спектр введения отказов.
Список — не исчерпывающий, но для начала, и чтобы дать пищу для размышлений, его должно хватить.
Введение отказа — что это и для чего нужно?
-------------------------------------------
Введение отказа служит для проверки, соответствует ли ответ системы спецификациям при нормальных условиях нагрузки. Впервые эту технику применили, когда [внедряли отказы на уровне "железа"](https://ieeexplore.ieee.org/document/780999/) — на уровне контактов, путем изменения электрических сигналов на устройствах.
В программировании введение отказов помогает улучшить устойчивость системы ПО и позволяет исправлять недостатки в устойчивости к потенциальным отказам в системе. Это называется устранением отказов. Также он помогает оценить ущерб от отказа — т.е. радиус поражения, — еще до того, как отказ случится в производственной среде. Это называется прогнозированием неисправностей.
Введение отказов имеет несколько ключевых преимуществ, помогая:
* понимать и практиковать ответы на случайности и инциденты.
* понимать эффекты реальных отказов.
* понимать эффективность и ограничения механизмов отказоустойчивости.
* устранять ошибки проектирования и обнаруживать единые точки отказа.
* понимать и улучшать наблюдаемость системы.
* понимать радиус поражения отказов и сужать его.
* понимать распространение ошибки между компонентами системы.
### Категории введения отказов
Существует 5 категорий введения отказа: на уровне (1) ресурса; (2) сети и зависимостей; (3) приложения, процесса и сервиса; (4) инфраструктуры; и (5) человеческом уровне\*\*.
Далее я рассмотрю каждую из категорий и приведу пример введения отказов для каждой из них. Еще я рассмотрю пример введения отказов и инструментов оркестрации типа "все в одном".
> \*\*Важно! В этом посте я не затрагиваю введение отказов на человеческом уровне, но рассмотрю его в следующем.
1 — Введение отказа на уровне ресурса, aka нехватка ресурсов.
-------------------------------------------------------------
Да, облачные технологии приучили нас к тому, что ресурсы практически неограничены, но спешу разочаровать вас: они все же не бесконечны. Экземпляр, контейнер, функция и проч. — вне зависимости от абстракции, ресурсы в конце концов заканчиваются. Выход за грани допустимого, максимальное исчерпание ресурсов называется истощением.
Нехватка ресурсов имитирует атаку типа ["отказ в обслуживании"](https://en.wikipedia.org/wiki/Denial-of-service_attack), только не обычную, чтобы внедриться в намеченный сервер. Это введение отказов, возможно распространено, потому, наверное, что в применении не сложно.
### Истощая ресурсы ЦПУ, памяти и ввода/вывода
Один из моих любимых инструментов — [stress-ng,](https://www.mankier.com/1/stress-ng) переписка оригинального [инструмента нагрузочного тестирования, за авторством Амоса Уотерленда](https://directory.fsf.org/wiki/Stress).
Со stress-ng можно вводить отказы, нагружая различные физические подсистемы компьютера, так же как и управляя интерфейсами ядра системы, используя стресс-тесты. Доступны следующие стресс-тесты: ЦПУ, кэш ЦПУ, устройство, ввод/вывод, прерывание, файловая система, память, сеть, ОС, конвейер, планировщик и ВМ. [Man-страницы](https://www.mankier.com/1/stress-ng) включают полное описание всех доступных стресс-тестов, а таких всего 220!
Ниже — несколько практических примеров, как использовать stress-ng:
Нагрузка на ЦПУ `matrixprod` дает нужный микс операций с памятью, кэшем и плавающей запятой. Это, пожалуй. лучший способ хорошенько разогреть ЦПУ.
```
❯ stress-ng —-cpu 0 --cpu-method matrixprod -t 60s
```
Нагрузка `iomix-bytes` пишет N-байты для каждого процесса-обработчика `iomix`; по умолчанию задан 1 Гб, и он идеален для выполнения стресс-теста вводы/вывода. В этом примере я задам 80% свободного места файловой системы.
```
❯ stress-ng --iomix 1 --iomix-bytes 80% -t 60s
```
`vm-bytes` отлично подходит для стресс-тестов памяти. В этом примере stress-ng запускает 9 стресс-тестов виртуальной памяти, которые в час совокупно потребляют 90% доступной памяти. Т.о., каждый тресс-тест потребляет 10% доступной памяти.
```
❯ stress-ng --vm 9 --vm-bytes 90% -t 60s
```
### Нехватка дискового пространства на жестких дисках
`dd` — это утилита командной строки, собранная для того, что конвертировать и копировать файлы. Однако `dd` умеет читать и/или писать из файлов особых устройств типа `/dev/zero` и `/dev/random` для таких задач, как резервное копирование загрузочного сектора жесткого диска и получение фиксированного объема случайных данных. Т.о., ее можно использовать для введения отказов на сервере и имитации переполнения диска. У вас файлы журнала переполняли сервер и роняли приложение? Так вот, `dd` поможет — и сделает больно!
**Используйте `dd` очень осторожно. Введете не ту команду — и данные на харде сотрутся, уничтожатся или перепишутся!**
```
❯ dd if=/dev/urandom of=/burn bs=1M count=65536 iflag=fullblock &
```
### Подтормаживание API приложений
Производительность, устойчивость и масштабируемость API имеют большое значение. API вообще жизненно необходимы для сборки приложений и роста бизнеса.
Нагрузочное тестирование — отличный способ проверить приложение, прежде чем оно попадет в производственную среду. Также это классный метод стрессовой нагрузки, поскольку зачастую вскрывает исключения и ограничения, которые при иных обстоятельствах остались бы невидимы до встречи с реальным трафиком.
[`wrk`](https://github.com/wg/wrk) — это инструмент для сбора контрольных показателей HTTP, создающий значительную нагрузку на системы. Особенно люблю влупить проверки доступности API, особенно если речь идет о [проверке работоспособности](https://medium.com/@adhorn/patterns-for-resilient-architecture-part-3-16e8601c488e), потому что они вскрывают много чего относительно проектировочных решений на уровне кода разработчика: как настроен кэш? как реализовано ограничение скорости? отдает ли система приоритет проверкам работоспособности относительно балансировщиков нагрузки?
Вот с чего можно начать:
```
❯ wrk -t12 -c400 -d20s http://127.0.0.1/api/health
```
Эта команда запускает 12 потоков и держит открытыми 400 соединений по HTTP в течение 20 секунд.
2 — Введение отказов на уровне сети и зависимостей
--------------------------------------------------
Книга [Питера Дойча](http://wiki.c2.com/?PeterDeutsch) "8 заблуждений распределенных вычислений" ([The Eight Fallacies of Distributed Computing](http://eightfallaciesofdistributedcomputing/)) — это свод предположений, которые разработчики допускают, проектируя распределенные системы. А потом прилетает ответочка в виде недоступности, и приходится все переделывать. Эти ошибочные предположения звучат так:
* Сеть надежна.
* Задержка равна 0.
* Пропускная способность бесконечна.
* Сеть безопасна.
* Топология не меняется.
* Администратор всего один.
* Стоимость передачи 0.
* Сеть однородна.
Этот список — хорошая отправная точка для выбора введения отказов, если проверяете, выдержит ли ваша распределенная система отказ сети.
Введение задержки, потери и обрыва сети
### Введение задержки, потери или обрыва сети
`tc` ([контроль трафика](http://tldp.org/HOWTO/Traffic-Control-HOWTO/intro.html)) — инструмент командной строки Linux, используемый для конфигурации пакетного планировщика ядра Linux. Он определяет, как пакеты выстраиваются в очередь на передачу и принятие в сетевом интерфейсе. Операции включают постановку в очередь, определение политики, классификацию, планировку, формирование и потери.
`tc` можно использовать для имитации задержки и потери пакета для приложений UDP или TCP или ограничения использования ширины полосы определенного сервиса — чтобы имитировать условия интернет-трафика.
**— введение задержки в 100 мс**
```
#Start
❯ tc qdisc add dev etho root netem delay 100ms
#Stop
❯ tc qdisc del dev etho root netem delay 100ms
```
**— введение задержки в 100 мс с дельтой в 50 мс**
```
#Start
❯ tc qdisc add dev eth0 root netem delay 100ms 50ms
#Stop
❯ tc qdisc del dev eth0 root netem delay 100ms 50ms
```
**— повреждение 5% сетевых пакетов**
```
#Start
❯ tc qdisc add dev eth0 root netem corrupt 5%
#Stop
❯ tc qdisc del dev eth0 root netem corrupt 5%
```
**— потеря 7% пакетов с 25-процентной корреляцией**
```
#Start
❯ tc qdisc add dev eth0 root netem loss 7% 25%
#Stop
❯ tc qdisc del dev eth0 root netem loss 7% 25%
```
> **Важно!** 7% достаточно, чтобы не упало приложение TCP.
### Играя с "/etc/hosts" — статической таблицей поиска для имен узлов
`/etc/hosts` — простой текстовый файл, который связывает IP-адреса с именами узлов, по строчке на адрес. Каждому узлу требуется одна строка, содержащая следующую информацию:
```
IP_address canonical_hostname [aliases...]
```
Файл hosts — одна из нескольких систем, которые обращаются к сетевым узлам в компьютерной сети и переводят понятные людям имена узлов в IP-адреса. И да, вы угадали: благодаря ему удобно обманывать компьютеры. Вот несколько примеров:
**— Заблокировать доступ к API DynamoDB для инстанса ЕС2**
```
#Start
# make copy of /etc/hosts to /etc/host.back
❯ cp /etc/hosts /etc/hosts.back
❯ echo "127.0.0.1 dynamodb.us-east-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.us-east-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.us-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.us-west-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.eu-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.eu-north-1.amazonaws.com" >> /etc/hosts
#Stop
# copy back the old version /etc/hosts
❯ cp /etc/hosts.back /etc/hosts
```
**— Заблокировать доступ к API EC2 из инстанса ЕС2**
```
#Start
# make copy of /etc/hosts to /etc/host.back
❯ cp /etc/hosts /etc/hosts.back
❯ echo "127.0.0.1 ec2.us-east-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.us-east-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.us-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.us-west-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.eu-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.eu-north-1.amazonaws.com" >> /etc/hosts
#Stop
# copy back the old version /etc/hosts
❯ cp /etc/hosts.back /etc/hosts
```
Смотрите вживую: сначала API ЕС2 доступен и `ec2 describe-instances` успешно возвращается.
Как только я добавил `127.0.01 ec2.eu-west-1.amazonaws.com` к `/etc/hosts`, и вызов API ЕС2 падает.
Разумеется, это работает для всех API AWS.
Рассказал бы я вам анекдот про DNS...
-------------------------------------
### … но, боюсь, до вас дойдет только на вторые сутки. В смысле, через 24 часа.
21 октября 2016 года из-за [DDoS атаки Dyn](https://en.wikipedia.org/wiki/2016_Dyn_cyberattack) приличное число платформ и сервисов в Европе и Северной Америке оказались недоступными. Согласно [докладу ThousandEyes о производительности DNS по всему миру за 2018 год](https://www.thousandeyes.com/resources/2018-global-dns-performance-benchmark-report), 60% предприятий и SaaS-провайдеров все еще полагаются на единичный источник DNS-провайдера и, т.о., становятся уязвимыми перед сбоями DNS. А поскольку без DNS интернета не будет, здорово будет симулировать отказ DNS, чтобы оценить вашу устойчивость к ближайшему отказу DNS.
**Blackholing** — это метод, при помощи которого традиционно снижают ущерб [DDoS атаки](https://en.wikipedia.org/wiki/Denial-of-service_attack). Плохой сетевой трафик направляется в "черную дыру" и сбрасывается в void. Версия `/dev/null` для работы в сети :-) Можно использовать его для имитации потери сетевого трафика или протокола, того же [DNS](https://en.wikipedia.org/wiki/Domain_Name_System), скажем.
Для этой задачи нужен инструмент [`iptables`](https://linux.die.net/man/8/iptables), который используется для настройки, поддержания и проверки IP-пакета в ядре Linux.
Чтобы прогнать DNS-трафик через blackhole, попробуйте вот что:
```
#Start
❯ iptables -A INPUT -p tcp -m tcp --dport 53 -j DROP
❯ iptables -A INPUT -p udp -m udp --dport 53 -j DROP
#Stop
❯ iptables -D INPUT -p tcp -m tcp --dport 53 -j DROP
❯ iptables -D INPUT -p udp -m udp --dport 53 -j DROP
```
### Введение отказов с использованием Toxiproxy.
Есть у инструментов Linux вроде `tc` и `iptables` одна — но не единственная — серьезная проблема. Они требуют разрешение root для исполнения, а это создает проблемы для некоторых организаций и сред. Прошу любить и жаловать — **Toxiproxy**!
[Toxiproxy](https://github.com/shopify/toxiproxy) — это ТСР-прокси с открытым исходным кодом, разработанный [командой инженеров Shopify](https://engineering.shopify.com/). Он помогает имитировать хаотичные сетевые и системные условия или реальные системы. Поместите его между различными компонентами архитектуры, как показано ниже.
Он создан специально для тестирования, CI и сред разработки, и вносит предопределенную или случайную путаницу, которая управляется через настройки. Toxiproxy использует [**toxics**](https://github.com/shopify/toxiproxy#toxics) для манипуляции связями между клиентом и кодом разработчика, и его можно конфигурировать через [API HTTP](https://github.com/shopify/toxiproxy#http-api). А еще к нему в комплекте идет достаточное для начала работы количество toxics.
Нижеприведенный пример показывает, как Toxiproxy работает с клиентским кодом toxics, вводя задержку в 1000 мс в связь между моим клиентом Redis, redis-cli и самим Redis.
Toxiproxy успешно используется Shopify во всех производственных средах и средах разработки с октября 2014 года. Больше информации — у них [в блоге](https://shopifyengineering.myshopify.com/blogs/engineering/building-and-testing-resilient-ruby-on-rails-applications).
3 — Введение отказов на уровне приложения, процесса и сервиса
-------------------------------------------------------------
ПО падает. Это факт. И как вы поступаете? Следует ли логиниться через SSH на сервере и перезапускать давший сбой процесс? Системы контроля за процессом обеспечивают функции контроля состояния или изменения состояния типа start, stop, restart. Системы контроля обычно применяются для того, чтобы обеспечить стабильный контроль процесса. [`systemd`](https://en.wikipedia.org/wiki/Systemd) — как раз такой инструмент, обеспечивающий базовые кирпичики управления процессом для Linux. [`Supervisord`](http://supervisord.org/introduction.html#overview) предлагает контроль нескольких процессов на операционных системах типа UNIX.
Когда разворачиваете приложение, следует использовать эти инструменты. Это, безусловно, хорошая практика — тестировать ущерб от убийства критически важных процессов. Убедитесь, что вам приходят оповещения и что процесс перезапускается автоматически.
**— убить процессы Java**
```
❯ pkill -KILL -f java
#Alternative
❯ pkill -f 'java -jar'
```
**— убить процессы Python**
```
❯ pkill -KILL -f python
```
Конечно же, можно использовать команду `pkill`, чтобы убить довольно много других процессов, запущенных в системе.
Введение отказов базы данных
----------------------------
Если есть извещения об отказе, которые не любят получать операторы, то это те, которые относятся к отказам базы данных. Данные — на вес золота, и потому всякий раз, как падает БД, растет риск потерять данные клиента.
*Будет просто легкое обслуживание. И-и-и-и… все упало*
Порой способность восстановить данные и как можно быстрее привести БД в рабочее состояние решает будущее компании. К несчастью, также не всегда легко подготовиться к различным режимам отказа БД — и многие из них всплывут только в производственной среде.
Однако если вы используете [Amazon Aurora](https://aws.amazon.com/rds/aurora/), можно проверить устойчивость к отказам кластера БД Amazon Aurora, используя [запросы введения отказа](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Managing.FaultInjectionQueries.html).
### Введение отказа Amazon Aurora
Запросы на введение отказа выпускаются как команды SQL к инстансу Amazon Aurora и позволяют планировать имитацию одного из следующих событий:
* Отказ пишущего ли читающего инстанса БД.
* Отказ Aurora Replica.
* Отказ диска.
* Перегрузка диска.
Посылая запрос на введение отказа, надо также указать количество времени, в течение которого будет имитироваться событие отказа.
**— вызвать отказ инстанса Amazon Aurora:**
```
ALTER SYSTEM CRASH [ INSTANCE | DISPATCHER | NODE ];
```
**— имитировать отказ Aurora Replica:**
```
ALTER SYSTEM SIMULATE percentage PERCENT READ REPLICA FAILURE
[ TO ALL | TO "replica name" ]
FOR INTERVAL quantity { YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND };
```
**— имитировать отказ диска для кластера БД Aurora:**
```
ALTER SYSTEM SIMULATE percentage PERCENT DISK FAILURE
[ IN DISK index | NODE index ]
FOR INTERVAL quantity { YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND };
```
**— имитировать отказ диска для кластера БД Aurora:**
```
ALTER SYSTEM SIMULATE percentage PERCENT DISK CONGESTION
BETWEEN minimum AND maximum MILLISECONDS
[ IN DISK index | NODE index ]
FOR INTERVAL quantity { YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND };
```
Отказы в мире бессерверных приложений
-------------------------------------
Введение отказа может стать настоящим вызовом, если вы используете бессерверные компоненты, поскольку бессерверно управляемые сервисы типа AWS Lambda нативно не поддерживают введение отказов.
### Введение отказов в функции Lambda
Чтобы разобраться в этой проблеме, я написал [небольшую библиотеку python](https://github.com/adhorn/aws-lambda-chaos-injection) и [прослойку lambda](https://github.com/adhorn/aws-lambda-layer-chaos-injection) — для введения отказов в [AWS Lambda](https://aws.amazon.com/lambda/). В настоящий момент и то, и то поддерживает задержку, ошибки, исключения и введение кода ошибки НТТР. Введение отказа достигается путем настройки [AWS SSM Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) следующим образом:
```
{
"isEnabled": true,
"delay": 400,
"error_code": 404,
"exception_msg": "I really failed seriously",
"rate": 1
}
```
Можно добавить декоратор python в функцию handler, чтобы ввести отказ.
**— сгенерировать исключение:**
```
@inject_exception
def handler_with_exception(event, context):
return {
'statusCode': 200,
'body': 'Hello from Lambda!'
}
>>> handler_with_exception('foo', 'bar')
Injecting exception_type with message I really failed seriously a rate of 1
corrupting now
Traceback (most recent call last):
File "", line 1, in
File "/.../chaos\_lambda.py", line 316, in wrapper
raise \_exception\_type(\_exception\_msg)
Exception: I really failed seriously
```
**— ввести код ошибки "неверный НТТР":**
```
@inject_statuscode
def handler_with_statuscode(event, context):
return {
'statusCode': 200,
'body': 'Hello from Lambda!'
}
>>> handler_with_statuscode('foo', 'bar')
Injecting Error 404 at a rate of 1
corrupting now
{'statusCode': 404, 'body': 'Hello from Lambda!'}
```
**— ввести задержку:**
```
@inject_delay
def handler_with_delay(event, context):
return {
'statusCode': 200,
'body': 'Hello from Lambda!'
}
>>> handler_with_delay('foo', 'bar')
Injecting 400 of delay with a rate of 1
Added 402.20ms to handler_with_delay
{'statusCode': 200, 'body': 'Hello from Lambda!'}
```
Жмакните [здесь](https://github.com/adhorn/aws-lambda-chaos-injection), чтобы узнать больше об этой библиотеке питон.
### Введение отказа в исполнение Lambda через ограничение параллелизма
Lambda по умолчанию использует в целях безопасности регулировку параллельных исполнений всех функций в определеннном регионе, на аккаунт. Параллельные исполнения относятся к нескольким исполнениям кода функции, происходящих в любой отдельно взятый момент времени. Они используются для масштабирования вызов функции к входящему запросу. Но оно может служить и для обратной цели: остановки исполнения Lambda.
```
❯ aws lambda put-function-concurrency --function-name --reserved-concurrent-executions 0
```
Эта команда снизит параллелизм до нуля, провоцируя отказы запросов с ошибкой типа "торможение" — код неисправности `429`.
### Thundra — трассировка бессерверных передач
[**Thundra**](https://www.thundra.io/) — это инструмент наблюдения за бессерверными приложениями, имеющий встроенную способность вводить отказы в бессерверные приложения. Он делает [обработчики-обертки](https://docs.thundra.io/docs/python-span-listeners) для введения отказов типа «отсутствие обработчика ошибок» — для операций с DynamoDB, "отсутствие нейтрализации ошибок" — для источника данных, или "отсутствие тайм-аута в исходящих НТТР-запросах". Я сам его не пробовал, но в этом [посте](https://blog.thundra.io/chaos-test-your-lambda-functions-with-thundra) за авторством [Янь Чуи](https://twitter.com/theburningmonk) и в этом [великолепном видео](https://www.youtube.com/watch?v=TpoN1wm2bok) [Марши Вильяльба](https://twitter.com/mavi888uy) процесс неплохо описывается. Выглядит многообещающе.
И в заключении раздела о бессерверных приложениях скажу, что о трудностях хаос-инжиниринга применительно к бессерверным приложениям у Янь Чуи есть [отличная статья](https://hackernoon.com/how-can-we-apply-the-principles-of-chaos-engineering-to-aws-lambda-80f87e3237e2). Всем рекомендую к прочтению.
4 — Введение отказов на уровне инфраструктуры
---------------------------------------------
С введения отказов на уровне инфраструктуры все и началось — как для [Amazon, так и для Netflix.](https://medium.com/@adhorn/chaos-engineering-ab0cc9fbd12a) Введение отказов на уровне инфраструктуры — от отключения целого дата-центра до остановки инстансов в случайном порядке — осуществить, наверное, проще всего.
И, естественно, первым на ум приходит пример с "[обезьяной хаоса](https://github.com/Netflix/chaosmonkey)".
### Остановка инстансов EC2, выбранных случайно в некоторой зоне доступности.
В пору становления Netflix хотел ввести жесткие архитектурные правила. Он развернул свою "обезьяну хаоса" как одно из первых приложений на AWS, чтобы установить автомасштабируемые stateless-микросервисы — в том смысле, что любой инстанс можно уничтожить или заменить автоматически, не вызывая потерь состояния совсем. "Обезьяна хаоса" позаботилась, чтобы никто это правило не нарушил.
Следующий сценарий — аналогичный "обезьяне хаоса" — это остановка любого инстанса в случайном порядке, в конкретной зоне доступности в пределах одного региона.
```
❯ stop_random_instance(az="eu-west-1a", tag_name="chaos", tag_value="chaos-ready", region="eu-west-1")
```
```
import boto3
import random
REGION = 'eu-west-1'
def stop_random_instance(az, tag_name, tag_value, region=REGION):
'''
>>> stop_random_instance(az="eu-west-1a", tag_name='chaos', tag_value="chaos-ready", region='eu-west-1')
['i-0ddce3c81bc836560']
'''
ec2 = boto3.client("ec2", region_name=region)
paginator = ec2.get_paginator('describe_instances')
pages = paginator.paginate(
Filters=[
{
"Name": "availability-zone",
"Values": [
az
]
},
{
"Name": "tag:" + tag_name,
"Values": [
tag_value
]
}
]
)
instance_list = []
for page in pages:
for reservation in page['Reservations']:
for instance in reservation['Instances']:
instance_list.append(instance['InstanceId'])
print("Going to stop any of these instances", instance_list)
selected_instance = random.choice(instance_list)
print("Randomly selected", selected_instance)
response = ec2.stop_instances(InstanceIds=[selected_instance])
return response
```
Заметили фильтры `tag_name` и `tag_value`? Такие вот мелочи предотвратят отказ не тех инстансов. #lessonlearned
*И да… перезапустишь базу данных — молодец [упс, не тот инстанс]*
5 — Введение отказов и инструменты оркестрации типа "все в одном"
-----------------------------------------------------------------
Вполне вероятно, что вы потерялись в таком множестве инструментов. К счастью, есть парочка введений отказа и инструментов оркестрации, которые включают в себя большую их часть и ими легко пользоваться.
### Chaos Toolkit
Один из моих любимых инструментов — [Chaos Toolkit](https://github.com/chaostoolkit), платформа с открытым исходным кодом для хаос-инжиниринга, которую коммерчески поддерживает замечательная команда [ChaosIQ](https://chaosiq.io/). Вот лишь некоторые из них: [Расс Майлз](https://twitter.com/russmiles), [Силвейн Хеллегуарх](https://twitter.com/lawouach) и [Марк Паррьен](https://twitter.com/mperrien).
Chaos Toolkit определяет декларативный и расширяемый API для удобного проведения эксперимента по хаос-инжинирингу. Он включает драйверы для AWS, Google Cloud Engine, Microsoft Azure, Cloud Foundry, Humino, Prometheus и Gremlin.
Расширения — это набор проверок и действий, используемых для экспериментов так: останавливаем случайно выбранный инстанс в конкретной зоне доступности, если `tag-key` содержит значение `chaos-ready`.
```
{
"version": "1.0.0",
"title": "What is the impact of randomly terminating an instance in an AZ",
"description": "terminating EC2 instance at random should not impact my app from running",
"tags": ["ec2"],
"configuration": {
"aws_region": "eu-west-1"
},
"steady-state-hypothesis": {
"title": "more than 0 instance in region",
"probes": [
{
"provider": {
"module": "chaosaws.ec2.probes",
"type": "python",
"func": "count_instances",
"arguments": {
"filters": [
{
"Name": "availability-zone",
"Values": ["eu-west-1c"]
}
]
}
},
"type": "probe",
"name": "count-instances",
"tolerance": [0, 1]
}
]
},
"method": [
{
"type": "action",
"name": "stop-random-instance",
"provider": {
"type": "python",
"module": "chaosaws.ec2.actions",
"func": "stop_instance",
"arguments": {
"az": "eu-west-1c"
},
"filters": [
{
"Name": "tag-key",
"Values": ["chaos-ready"]
}
]
},
"pauses": {
"after": 60
}
}
],
"rollbacks": [
{
"type": "action",
"name": "start-all-instances",
"provider": {
"type": "python",
"module": "chaosaws.ec2.actions",
"func": "start_instances",
"arguments": {
"az": "eu-west-1c"
},
"filters": [
{
"Name": "tag-key",
"Values": ["chaos-ready"]
}
]
}
}
]
}
```
Провести вышеупомянутый эксперимент просто:
```
❯ chaos run experiment_aws_random_instance.json
```
Сила Chaos Toolkit в том, что, во-первых, он с открытым исходным кодом и его можно подстроить под ваши нужды. Во-вторых, он прекрасно вписывается в конвейер CI/CD и поддерживает непрерывный хаос-тестинг.
Минус Chaos Toolkit в том, что на его освоение требуется время. Более того, в нем нет готовых экспериментов, так что придется писать их самому. Впрочем, я знаком с командой в ChaosIQ, которая работает не покладая рук, разбираясь с этой задачей.
### Gremlin
Еще один мой любимчик — Gremlin. Вмещает в себя исчерпывающий набор режимов введения отказов в несложном инструменте с интуитивным пользовательским интерфейсом. Такая себе "Хаос-как-услуга".
Gremlin поддерживает введение отказов на уровне [ресурса, сети и запросов](https://www.gremlin.com/docs/infrastructure-layer/attacks/#state-gremlins), позволяя быстро экспериментировать со всей системой, в т.ч. с "железом", различными облачными провайдерами, контейнеризированными средами, включая Kubernetes, приложениями и — в некоторой степени — бессерверными приложениями.
Плюс бонус — ребята из [Gremlin](https://twitter.com/GremlinInc) большие молодцы, пишут отличный контент для [блога](https://www.gremlin.com/blog/) и всегда готовы помочь! Вот некоторые из них: [Мэтью](https://twitter.com/callmeforni), [Колтон](https://twitter.com/KoltonAndrus), [Тэмми](https://twitter.com/tammybutow), [Рич](https://twitter.com/richburroughs), [Ана](https://twitter.com/Ana_M_Medina) и [HML](https://twitter.com/HoReaL).
В использовании Gremlin проще некуда:
Сперва войдите в приложение Gremlin и выберите "Create Attack".
Назначьте цель — инстанс.
Выберите тип отказа, который хотите ввести, и да начнется хаос!
Должен признать, что Gremlin всегда мне нравился: с ним эксперименты по хаос-инжинирингу интуитивно просты.
Минус в [ценовой политике](https://www.gremlin.com/pricing/) — требуется лицензия для работы, что может не подойти для начинающих пользователей или разовых работ. Однако недавно добавили его бесплатную версию. Более того, Gremlin-клиент и daemon нужно устанавливать в инстансы, которые надо атаковать, а это не всем по душе.
### Run Command от AWS System Manager
Приложение [Run command для работы с EC2](https://aws.amazon.com/blogs/aws/new-ec2-run-command-remote-instance-management-at-scale/), представленное в 2015 году, сделано для простого и безопасного администрирования инстансов. Сегодня оно позволяет удаленно и безопасно управлять конфигурацией ваших инстансов — не только ЕС2, но и конфигурированные в вашей [гибридной среде](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-managedinstances.html). Это включает локальные серверы и виртуальные машины, и даже ВМ в других облачных средах, используемых с Systems Manager.
Run Command позволяет автоматизировать задачи DevOps или выполнять ad-hoc обновления конфигурации, вне зависимости от размера вашего парка.
В то время, как Run Command по большей части используется для задач типа установки и первоначального развертывания приложений, получения журналов или подключения инстансов к домену Windows, он также хорошо подходит для проведения хаос-экспериментов.
У меня есть статья на тему [введения хаоса с использованием AWS System Manager](https://medium.com/@adhorn/injecting-chaos-to-amazon-ec2-using-amazon-system-manager-ca95ee7878f5) и множества [готовых введений отказов](https://github.com/adhorn/chaos-ssm-documents) с открытым исходным кодом. Попробуйте — прикольно!
Закругляемся!
-------------
Прежде чем завершить эту статью, я бы хотел подчеркнуть несколько ключевых моментов относительно введения отказов.
1 — Хаос-инжиниринг — это не про то, чтобы взять и сломать что-нибудь в производственной среде. Это путешествие. В нем вы учитесь на экспериментах в контролируемой среде — да и любой другой, — будь то локальная среда разработчика, бета, стейджинг или производственная среда. Путешествие можно начинать, где бы вы ни находились! Лучше меня скажет [Ольга Холл](https://twitter.com/ovhall):
> "Примите Хаос сейчас. Возьмите его с собой в путь".
>
> —Ольга Холл, старший менеджер в резилиенс-инжиниринг Amazon Prime Video
2 — Прежде чем вводить отказ, помните, что принципиально важно наладить программу мониторинга и оповещений. Без них вы просто не поймете ущерба ваших экспериментов по хаосу или сумеете оценить радиус поражения, а ведь это критично для нормальных практик хаос-инжиниринга.
3 — Некоторые из введений отказа могут причинить реальный ущерб, поэтому будьте аккуратнее и начинайте с тестовых инстансов, чтобы не пострадали клиенты.
4 — И, наконец, тесты, тесты и еще раз тесты. Помните, что хаос-инжиниринг — это про уверенность в вашем приложении и инструментах, которые должны выдерживать неблагоприятные условия.
Ну вот и все, спасибо, народ, что дочитали до конца. Надеюсь, вам понравилась третья часть. Прошу, не стесняйтесь давать обратную связь, делиться мнениями и хлопать в ладоши :-)
— Эдриан | https://habr.com/ru/post/480802/ | null | ru | null |
# Не используйте Java7 ни для чего
Java 7 вышла не так давно, но за 5 дней до её релиза было обнаружено несколько ужасных ошибок в горячей оптимизации циклов, которая включена по умолчанию и приводит Java Virtual Machine к краху (в лучшем случае).
Эти ошибки ([1],[2],[3]) заметили пользователи и разработчики Apache Lucene/Solr ([4],[5]). Их обещали устранить в Java 7 Update 2 ([6]).
**Замечание**: эти ошибки также могут проявляться в Java 6, если включён один из флагов оптимизации: `-XX:+OptimizeStringConcat` или `-XX:+AggressiveOpts` у JVM.
Итог: [не используйте Java 7](http://www.lucidimagination.com/search/document/1a0d3986e48a9348/warning_index_corruption_and_crashes_in_apache_lucene_core_apache_solr_with_java_7) ни для чего, за исключением тех случаев, когда ваша программа не содержит циклов.
* [1] <http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7070134>
* [2] <http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7044738>
* [3] <http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7068051>
* [4] <https://issues.apache.org/jira/browse/LUCENE-3335>
* [5] <https://issues.apache.org/jira/browse/LUCENE-3346>
* [6] <http://s.apache.org/StQ>
**Upd** thx: [OLS](https://habrahabr.ru/users/ols/), [WebSpider](https://habrahabr.ru/users/webspider/). | https://habr.com/ru/post/125362/ | null | ru | null |
# Подробный мануал «Как создать инфо-тип PA в SAP HR» или «Как приручить SAP?» (часть 1)
SAP – довольно распространенная система на крупных предприятиях не только запада, но и стран постсоветского пространства. Существует много сплетен и обсуждений, как позитивных, так и негативных по поводу SAP. И негативные отзывы связаны в основном, не столько со сложностью системы, сколько с интуитивно не понятным интерфейсом и отсутствием доступной литературы (книг, инструкций) на понятном русском языке.
Этой статьей я хочу дать начало доступным инструкциям по некоторым аспектам SAP, с которыми часто возникают проблемы у начинающих SAP’ёров. Данная статья будет посвящена созданию инфо-типов администрирования персонала (PA) для модуля SAP HR. Если данная инструкция Вам понравится и будет полезна, дорогой читатель, то, надеюсь, она будет не последней.
Скоро будет год, как я работаю на должности внутреннего консультанта SAP на проекте по внедрению модуля SAP HR очень крупного предприятия в Украине. SAP изучал с нуля: «гугл», скачанные курсы и советы внешних консультантов. Поэтому в данной статье я попытаюсь пошагово и доступно показать, как создавать инфо-типы PA для таких же новичков, каким и я был год назад (хоть и сейчас тоже далеко не «гуру»).
1. Для начала запускаем транзакцию **PM01** – создаем инфо-тип. Пользовательские инфо-типы требуется создавать на 9-ку (предварительно советую проверить свободный номер для инфо-типа). Также в блоке *«Подобъекты»* радио-кнопка должна стоять на *«Структура PS»*. Далее нажимаем кнопку *«Сгенерировать объекты»*.
Система предлагает нам создать структуру для нашего инфо-типа. Соглашаемся.
2. Создаем нашу структуру. Стандартные поля (напр. *BEGDA, PERNR*) создавать не нужно, они автоматически привяжутся к инфо-типу. По рекомендации SAP поля нужно называть на ZZ\*. Также определяем типы данных для наших полей согласно типов существующих полей в системе (напр. *PLANS*, который автоматом поставит тип данных NUMC и длиной в 8 символов), либо сами выбираем тип данных (напр. *CHAR*), нажав на кнопку *«Тип компонента»*, задаем ему длину и даем краткое описание нашему полю.
Ещё один полезный совет. Если для какого-либо поля требуется средство поиска (как например стандартное средство поиска для выбора даты, при нажатии на пиктограмму, появляющуюся справа от поля), переходим на вкладку *«Справка/проверка знач. ввода»*, где нажимаем на *«ключик»* и кнопку *«Средство поиска»*. В 90% случаев требуемые средства поиска есть в стандарте, как например, поиск шт. должности по орг. структуре, как показано на скриншоте.
Активируем нашу структуру. При возникновении окошка показанного ниже не пугаемся, а нажимаем «Нет».
3. После этого нажимаем *«Назад»*. Соглашаемся на несколько сообщений, после чего система предлагает заполнить табличку **(T582A)**, где хранятся характеристики нашего инфо-типа. Нам нужно создать запись для своего инфо-типа, для этого советую скопировать уже существующий.
Сохраняем. Если нам потребуется изменить эти данные, то заходим в транзакцию **SM30**, где вызываем ракурс ведения **V\_T582A**.
4. Наш инфо-тип создан. Его можно уже создать для человека в **PA30**, и использовать по назначению, если Ваш инфо-тип простой, и не требует никаких «подтягиваний» значений, операций после внесения данных и т.д.
На этом все инструкции обычно заканчиваются, и оказывается, что у нас инфо-тип не очень и простой, и что делать далее не понятно. Так, что я продолжу углубляться в данную тему.
В транзакции PM01, в блоке подобъекты есть ещё несколько строк, которые нам понадобятся:
а) Пул модулей (*MPXXXX0*, где *ХХХХ* – наш инфо-тип), где уже сгенерированы include-программы:
— \*10 – Глобальные данные;
— \*20 – PBO-логика;
— \*30 – PAI-логика;
— \*40 – подпрограммы,
где «\*» — *«MPXXXX»*.
Нам, в основном, потребуется PBO-логика *(Process Before Output)* и PAI *(Process After Input)*. В PBO описываем все, что происходит с момента запуска ИТ до вывода его на экран (например мы подтянем действующую шт. должность человека, по которому создаем ИТ в поле *zzold\_pos*). В PAI описываем все то, что будет происходить после нажатия «Enter», когда мы уже ввели информацию (напр., если нам надо посчитать, сколько осталось времени до даты *zznew\_date* c текущей).
б) Экран. Нам, для нашего инфо-типа, потребуется экран *2000* – это экран для ввода и просмотра, тот что появляется в транзакции PA30. *3000* – для вывода записей ИТ списком (в **PA30** пиктограмма в виде «горки с солнышком». *4000* и *5000* – для быстрого и пакетного ввода ИТ. Здесь мы затронем только *2000* экран, т.к. для быстрого и пакетного ввода потребуется отдельная инструкция, и наверно в несколько раз больше этой.
5. Для начала зайдем в *2000* экран, там выбираем радио-кнопкой *«Редактор форматов»*. В нём мы сможем «рисовать» экран нашего ИТ. У нас уже созданы все поля из созданной нами структуры. Рисуем, наводим красоту.
При выборе поля открывается ещё одно окошко, с параметрами поля. Тут есть несколько нюансов. Во-первых, заполняем атрибуты. Здесь можно настроить обязательно ли это поле для заполнения, или отметить, что это поле только для вывода, либо же сделать текст выделенным (рисует его синим). Во-вторых, первое поле напротив надписи «Группы» должно быть обязательно заполнено. Значение *«006»*, говорит о том, что данное поле видимо всегда. «Погуглив» можно найти, какие требуется вносить значения в эти 4 поля, например, для отображения поля только после нажатия на Enter. Это очень важный момент, для созданных уже полей там будет *«006»,* но если вы создадите новое поле, и не заполните группу, то не увидите новое поле на экране, и с этим можно долго мучаться.
Следующим шагом будет выбор радио-кнопкой строки «Логика выполнения», где мы для нашего экрана пропишем логику выполнения.
В открывшемся окне все уже сгенерировано, а нам остается только прописывать дополнительную логику. Тут тоже есть Process Before Output и Process After Input. В модуле *PXXXX*, где *ХХХХ* – наш инфо-тип, мы можем писать все, что позволяет нам ABAP. Ниже пример кода в этом модуле, где мы при создании инфо-типа по человеку подтягиваем его штатку, и из **1000 ИТ** по штатной должности подтягиваем описывающий текст.
```
TABLES: PA0001, HRP1000.
DATA: FLAG(1).
IF FLAG IS INITIAL.
FLAG = '1'.
SELECT SINGLE * FROM PA0001 WHERE PERNR eq P9508-PERNR
AND BEGDA le P9508-BEGDA
AND ENDDA ge P9508-BEGDA.
MOVE PA0001-PLANS TO P9508-ZZOLD_POS.
SELECT SINGLE * FROM HRP1000 WHERE OBJID eq PA0001-PLANS
AND OTYPE eq 'S '
AND BEGDA le P9508-BEGDA
AND ENDDA ge P9508-BEGDA.
MOVE HRP1000-STEXT TO P9508-ZZOLD_POS_TEXT.
ENDIF.
```
Кроме того, в PAI тоже можно создать свой модуль, в котором можно описать логику, после того, как мы заполнили данные и нажали *Enter.*
```
IF P9508-ZZOLD_POS NE PA0001-PLANS.
SELECT SINGLE * FROM HRP1000 WHERE OBJID EQ P9508-ZZOLD_POS
AND OTYPE EQ 'S '
AND BEGDA LE P9508-BEGDA
AND ENDDA GE P9508-BEGDA.
MOVE HRP1000-STEXT TO P9508-ZZOLD_POS_TEXT.
ENDIF.
CLEAR HRP1000.
SELECT SINGLE * FROM HRP1000 WHERE OBJID EQ P9508-ZZNEW_POS
AND OTYPE EQ 'S '
AND BEGDA LE P9508-BEGDA
AND ENDDA GE P9508-BEGDA.
MOVE HRP1000-STEXT TO P9508-ZZNEW_POS_TEXT.
```
Здесь мы смотрим, не изменили ли мы штатную должность, и читаем из **1000 ИТ** описывающий текст по новой штатной должности.
Ниже скриншот, как выглядит созданный инфо-тип.
Всё, на этом создание нашего инфо-типа окончено. Старался объяснить всё как можно доступней для начинающих. Я надеюсь, что моя статья Вам пригодится. Если будут вопросы, то пишите, всегда буду рад помочь. | https://habr.com/ru/post/167935/ | null | ru | null |
# Туториал по AsyncDisplayKit 2.0 (Texture): Начало работы
«Искусство – это все, что вы можете сделать хорошо. Все, что вы можете сделать качественно» (Robert M. Pirsig).
> *От переводчика*:
>
> С появлением autoLayout создавать интерфейс iOS-приложения стало намного проще и быстрее. Вам больше не нужно думать о подгонке размеров под определенные устройства, autoLayout сделает это за вас. Вычисление происходит на основе констрейнтов относительно ближайших элементов. Чем больше таких зависимостей, тем дольше будет строиться autoLayout, и это основная проблема всех приложений с сложным интерфейсом.
>
> Использование AsyncDisplayKit позволит вам на порядок уменьшить объем работ, выполняемых в основном потоке, и реализовать сложные интерфейсы с минимальным количеством кода. Ребята из Raywenderlich сделали подробный и наглядный туториал по работе с ним. Надеюсь, что перевод статьи поможет вам ещё быстрее освоить этот фреймворк.
>
>
>
>
AsyncDisplayKit – это UI фреймворк, который был разработан и применен Facebook в приложении Paper. Он помог команде разработчиков Paper найти ответ на один из ключевых вопросов: как сохранить основной поток приложения максимально свободным.
Сейчас многие приложения основываются на пользовательском интерфейсе, который в значительной степени зависит от непрерывных движений и анимации на основе физики. По крайней мере, ваш UI, наверняка, базируется на каком-то из видов Scroll View.
Такие типы пользовательских интерфейсов полностью зависят от основного потока и чрезвычайно чувствительны к его тормозам. Нагруженный основной поток означает отброшенные фреймы и неприятный пользовательский опыт.
Основные факторы работы потока включают:
* **Measurement and Layout**: такие события, как вызов метода **heightForRowAtIndexPath:** или **sizeThatFits** класса **UILabel**, а также экспоненциальная стоимость расчета констрейнтов.
* **Image Decoding**: использование **UIImage** в режиме просмотра изображения означает, что данные изображения сначала должны быть декодированы.
* **Drawing**: сложный текст, а также отрисовка градиентов и теней вручную.
* **Object Life Cycle**: создание, управление и уничтожение системных объектов (т. е. cоздание **UIView**).
При правильном использовании AsyncDisplayKit позволяет выполнять все измерения, компоновку и рендеринг асинхронно по умолчанию. Без дополнительной оптимизации приложение может примерно на порядок уменьшить объем работ, выполняемых в основном потоке.
Кроме этих преимуществ в производительности, современный AsyncDisplayKit предлагает впечатляющий набор удобств для разработчиков, позволяющий реализовывать сложные интерфейсы с минимальным количеством кода.
В этом туториале AsyncDisplayKit 2.0, состоящем из двух частей, вы узнаете всё необходимое для создания полезного и динамического приложения с использованием ASDK.
> **Внимание**: ASDK несовместим ни с [Interface Builder](http://www.youtube.com/watch?v=RY_X7l1g79Q&feature=youtu.be&t=29m37s), ни с AutoLayout, поэтому вы не будете использовать их. Хотя ASDK полностью поддерживает Swift (в отличие от ComponentKit), многие его пользователи все еще пишут на Objective-C. На момент создания этого туториала большинство из топ-100 бесплатных приложений вообще не содержало кода на Swift (хотя 6 использовали ASDK). Поэтому статья сосредоточена на Objective-C. Но есть и Swift версия образца проекта на случай, если вы ненавидите [скобки](https://ru.wikipedia.org/wiki/Скобки).
Начнем
------
Для начала [загрузите стартовый проект](https://koenig-media.raywenderlich.com/uploads/2016/12/AsyncDisplayKit-Starter-4.zip).
Проект использует [CocoaPods](https://cocoapods.org/), чтобы подключить AsyncDisplayKit. Итак, в обычном стиле CocoaPods, зайдите и откройте **RainforestStarter.xcworkspace**, но НЕ **RainforestStarter.xcodeproj**.
> **Примечание**: Для работы с этим туториалом требуется соединение с интернетом.
Скомпилируйте и запустите приложение, состоящее из одной **UITableView**, содержащей список животных. Если вы посмотрите на код в **AnimalTableController**, то увидите, что это обычный класс **UITableViewController**, который вы, наверное, видели много раз.
> **Примечание**: Убедитесь, что код запущен на реальном девайсе, а не на симуляторе.
Проскрольте таблицу и обратите внимание на количество фреймов, которые были пропущены. Не нужно запускать инструменты, чтобы увидеть, что это приложение нуждается в улучшении производительности.
Вы можете исправить это, используя AsyncDisplayKit.
Представляем ASDisplayNode
--------------------------
**ASDisplayNode** – базовый класс ASDK и, по сути, просто объект «view» в паттерне MVC, аналогично **UIView** или **CALayer**. Лучший способ представить ASDisplayNode – подумать об отношении между **UIViews** и **CALayers**, с которыми вы уже должны быть знакомы.
Помните, что на экране в iOS-приложении всё представлено через объект **CALayer**. **UIViews** создают и владеют поддержкой **CALayer**, к которому они добавляют сенсорную обработку и другие функции. Сам класс **UIView** не является *подклассом* **CALayer**. Вместо этого он оборачивает объект слоя, расширяя его функциональность.
В случае **ASDisplayNode** эта абстракция расширяется: вы можете думать о них как об обертывании представления так же, как представление заворачивает слой.
Что узлы приносят в таблицу кроме обычного представления, так это то, что они могут быть созданы и сконфигурированы в фоновых очередях и одновременно представлены по умолчанию.
К счастью, API для работы с узлами должен быть невероятно знакомым любому, кто использовал **UIViews** или **CALayers**. Все свойства view, которые вы обычно используете, доступны в эквивалентном классе узла. Вы можете получить даже доступ к самой вью или лееру, так же, как к **.layer** класса **UIView**.
Контейнеры узла
---------------
Хотя сами по себе узлы обеспечивают возможность значительного повышения производительности, настоящая магия происходит, когда они используются совместно с одним из четырех контейнерных классов.
К этим классам относятся:
* **ASViewController**: подкласс **UIViewController**, который позволяет предоставить узел, которым вы хотите управлять.
* **ASCollectionNode и ASTableNode**: эквиваленты узла **UICollectionView** и **UITableView**, подкласс которых поддерживается под капотом.
* **ASPagerNode**: подкласс **ASCollectionNode**, который обеспечивает высокую производительность чтения по сравнению с **UIPageViewController** из фреймворка **UIKit**.
Если честно, настоящая магия исходит от **ASRangeController**, который использует каждый из этих классов, чтобы повлиять на поведение содержащихся узлов. А пока просто доверьтесь мне и запомните это на будущее.
Преобразование TableView
------------------------
Первое, что вы должны сделать – это преобразовать текущее представление таблицы в узел таблицы. Это довольно просто.
### Замена tableView на tableNode
Сначала перейдите к AnimalTableController.m. Добавьте следующую строку ниже других import в этом классе:
```
#import
```
Так вы импортируете ASDK, чтобы использовать фреймворк.
Затем перейдите и замените объявление свойства **tableView**:
```
@property (strong, nonatomic) UITableView *tableView;
```
на **tableNode**:
```
@property (strong, nonatomic) ASTableNode *tableNode;
```
Это приведет к тому, что большинство кода в этом классе сломается, но не паникуйте!
Серьезно, не переживайте. Эти ошибки и предупреждения будут служить вашим ориентиром при преобразовании того, что сейчас есть, в то, что вы хотите.
Ошибки в **-viewDidLoad**, конечно, связаны с тем, что **tableView** больше не существует. Я не собираюсь заставлять вас просматривать весь проект и изменять все экземпляры **tableView** на **tableNode** (найти и заменить не так уж и сложно, поэтому не бойтесь), но если вы это сделали, то увидите, что:
1. Вы должны присвоить **ASTableNode** свойству.
2. У узла таблицы нет метода с именем **-registerClass:forCellReuseIdentifier:**.
3. Вы не можете добавлять узел как subview.
На этом этапе вы должны просто заменить **-viewDidLoad** на следующее:
```
- (void)viewDidLoad {
[super viewDidLoad];
[self.view addSubnode:self.tableNode];
[self applyStyle];
}
```
Интересно, что вы вызываете **-addSubnode:** для **UIView**. Этот метод был добавлен ко всем **UIViews** через категорию и в точности эквивалентен:
```
[self.view addSubview:self.tableNode.view];
```
Затем исправьте **-viewWillLayoutSubviews**, замените реализацию этого метода на следующую:
```
- (void)viewWillLayoutSubviews {
[super viewWillLayoutSubviews];
self.tableNode.frame = self.view.bounds;
}
```
Все это заменяет **self.tableView** на **self.tableNode** для установки фрейма таблицы.
Затем найдите метод **-applyStyle** и замените реализацию следующим:
```
- (void)applyStyle {
self.view.backgroundColor = [UIColor blackColor];
self.tableNode.view.separatorStyle = UITableViewCellSeparatorStyleNone;
}
```
Строка, которая задает **separatorStyle** для таблицы – единственная измененная строка. Обратите внимание, как осуществляется доступ к свойству представления табличного узла, чтобы установить **separatorStyle** для таблицы. **ASTableNode** не раскрывает все свойства **UITableView**, поэтому вам нужно получить доступ к экземпляру **UITableView** базового узла таблицы, чтобы изменить определенные свойства **UITableView**.
Затем добавьте следующую строку в самом начале **-initWithAnimals**:
```
_tableNode = [[ASTableNode alloc] initWithStyle:UITableViewStylePlain];
```
И добавьте этот код в конец, перед оператором return инициализатора:
```
[self wireDelegation];
```
Так вы инициализируете **AnimalTableController** с узлом таблицы и вызовете **-wireDelegation** для подключения делегатов узла таблицы.
### Настройка источника данных и делегата табличного узла
Как и **UITableView**, **ASTableNode** использует источник данных и делегат для получения информации о себе. Протоколы **ASTableDataSource** таблицы Table и **ASTableDelegate** очень похожи на **UITableViewDataSource** и **UITableViewDelegate**. Фактически, они определяют некоторые из тех же самых методов, таких как **-tableNode: numberOfRowsInSection:**. Два набора протоколов не соответствуют друг другу полностью, потому что **ASTableNode** ведет себя немного иначе, чем **UITableView**.
Найдите **-wireDelegation** и замените **tableView** на **tableNode** в реализации:
```
- (void)wireDelegation {
self.tableNode.dataSource = self;
self.tableNode.delegate = self;
}
```
Теперь вы получите warning, что **AnimalTableController** на самом деле не соответствует правильному протоколу. Сейчас **AnimalTableController** соответствует **UITableViewDataSource** и **UITableViewDelegate**. В следующих разделах вы будете принимать и реализовывать каждый из этих протоколов, чтобы узел таблицы мог функционировать.
### Соответствие ASTableDataSource
В верхней части **AnimalTableController.m** найдите следующее объявление интерфейса категории **DataSource**:
```
@interface AnimalTableController (DataSource)
@end
```
И замените **UITableViewDataSource** на **ASTableDataSource**:
```
@interface AnimalTableController (DataSource)
@end
```
Теперь, когда объявление **AnimalTableController** соответствует **ASTableDataSource**, пришло время сделать это.
Перейдите в нижнюю часть **AnimalTableController.m** и найдите реализацию категории **DataSource**.
Сначала измените **UITableViewDataSource** метод **-tableView: numberOfRowsInSection:** на метод протокола **ASTableDataSource**, заменив его следующим.
```
- (NSInteger)tableNode:(ASTableNode *)tableNode numberOfRowsInSection:(NSInteger)section {
return self.animals.count;
}
```
Далее **ASTableNodes** ожидает, что его ячейки будут возвращены по-другому, нежели ячейки **UITableView**. Чтобы приспособиться к новой парадигме, замените **-tableView: cellForRowAtIndexPath:** на следующий метод:
```
//1
- (ASCellNodeBlock)tableNode:(ASTableView *)tableView nodeBlockForRowAtIndexPath:(NSIndexPath *)indexPath {
//2
RainforestCardInfo *animal = self.animals[indexPath.row];
//3
return ^{
//4
CardNode *cardNode = [[CardNode alloc] initWithAnimal:animal];
//Вы добавите здесь что-нибудь потом…
return cardNode;
};
}
```
Рассмотрим этот раздел:
1. **ASCellNode** является ASDK эквивалентом **UITableViewCell** или **UICollectionViewCell**. Важно отметить, что этот метод возвращает **ASCellNodeBlock**. Это связано с тем, что **ASTableNode** поддерживает все свои ячейки внутри и предоставляет блок для каждого index path, он может одновременно инициализировать все свои ячейки, когда будет готов.
2. Первое, что вы делаете – берете ссылку на модель данных, необходимую для заполнения этой ячейки. Это очень важная закономерность. Вы захватываете данные, а затем получаете их в следующем блоке. **IndexPath** не должен использоваться внутри блока, если данные изменяются до того, как блок был вызван.
3. Затем вы возвращаете блок, возвращаемым значением которого должен быть **ASCellNode**.
4. Не нужно беспокоиться о переиспользовании ячейки, расслабьтесь и инициализируйте её обычным способом. Заметьте, что теперь вы возвращаете **CardNode** вместо **CardCell**.
Это подводит меня к важному моменту. Как вы, возможно, уже заметили, при использовании ASDK нет переиспользования ячеек. Об этом уже дважды говорилось, но просто имейте это ввиду. Не бойтесь перейти в начало класса и удалить.
```
static NSString *kCellReuseIdentifier = @«CellReuseIdentifier»;
```
Вам больше это не нужно. Только подумайте. Вам никогда не придется волноваться о **-prepareForReuse** снова …
### Соответствие ASTableDelegate
Перейдите в начало **AnimalTableController.m** и найдите следующее объявление интерфейса категории **Делегата**:
```
interface AnimalTableController (Delegate)@end
```
и замените **UITableViewDelegate** на **ASTableDelegate**:
```
interface AnimalTableController (Delegate)@end
```
Теперь, когда **AnimalTableController** принимает **ASTableDelegate**, пора перейти к реализации. Переместитесь к нижней части **AnimalTableController.m** и найдите реализацию этой категории **Делегата**.
Уверены, вы знаете, что с **UITableView** вам нужно обеспечить реализацию **-tableView:heightForRowAtIndexPath:**. Это происходит из-за того, что с **UIKit**, высота каждой ячейки вычисляется и возвращается делегатом таблицы.
**ASTableDelegate** не нуждается в **-tableView:heightForRowAtIndexPath:**. В ASDK все **ASCellNodes** ответственны за определение их собственного размера. Вместо того, чтобы обеспечивать статическую высоту, вы можете дополнительно определить минимальный и максимальный размер для своих ячеек. В данном случае нужно, чтобы каждая ячейка была как минимум так же высока, как 2/3 экрана.
Сейчас просто замените **-tableView:heightForRowAtIndexPath:** на:
```
- (ASSizeRange)tableView:(ASTableView *)tableNode
constrainedSizeForRowAtIndexPath:(NSIndexPath *)indexPath {
CGFloat width = [UIScreen mainScreen].bounds.size.width;
CGSize min = CGSizeMake(width, ([UIScreen mainScreen].bounds.size.height/3) * 2);
CGSize max = CGSizeMake(width, INFINITY);
return ASSizeRangeMake(min, max);
}
```
Скомпилируйте и запустите проект, чтобы увидеть, что получилось.
У нас получилась плавная таблица! Как только вы сделали это, подготовьтесь сделать еще лучше.
Бесконечный скролл с пакетной выборкой
--------------------------------------
В большинстве приложений сервер имеет больше возможных данных, чем количество ячеек, которые вы хотели бы показать в таблице. Это означает, что в каждом приложении, над которым вы работаете, будет установлен механизм для загрузки следующего пакета данных от сервера, потому что пользователь приближается к концу текущего набора данных.
Много раз это обрабатывалось вручную, запоминая смещение контента в делегате scrollView в методе **-scrollViewDidScroll:**. С ASDK есть более декларативный способ сделать это. Вы можете сказать заранее, сколько страниц нужно для загрузки новых данных.
Сперва раскомментируйте вспомогательные методы, которые были включены. Перейдите в конец **AnimalTableController.m** и раскомментируйте эти два метода в категории **Helpers**. Вы можете считать **-retrieveNextPageWithCompletion:** сетевым вызовом, в то время как **-insertNewRowsInTableNode** – стандартный метод для добавления новых элементов в таблицу.
Затем добавьте следующую строку к **-viewDidLoad:**.
```
self.tableNode.view.leadingScreensForBatching = 1.0; // overriding default of 2.0
```
Установка **leadingScreensForBatching** в 1.0 означает, что вы хотите, чтобы новые пакеты были загружены каждый раз, когда пользователь прокрутил к точке, где до конца таблицы остался лишь 1 элемент.
Теперь добавьте следующий метод к реализации категории **Делегата**:
```
- (BOOL)shouldBatchFetchForTableNode:(ASTableNode *)tableNode {
return YES;
}
```
Этот метод нужен для того, чтобы сказать таблице, должна ли она продолжить выполнять запросы для загрузки новых пакетов. Если вы знаете, что загружать больше нечего – верните **NO**.
Если вы действительно хотите, чтобы эта таблица скроллилась бесконечно, просто верните **YES**, чтобы гарантировать, что всегда будут запрашиваться новые пакеты.
Затем также добавьте:
```
- (void)tableNode:(ASTableNode *)tableNode willBeginBatchFetchWithContext:(ASBatchContext *)context {
//1
[self retrieveNextPageWithCompletion:^(NSArray *animals) {
//2
[self insertNewRowsInTableNode:animals];
//3
[context completeBatchFetching:YES];
}];
}
```
Этот метод вызовется, когда пользователь приблизится к концу таблицы, и таблица получит **YES** от **-shouldBatchFetchForTableNode:**.
Давайте рассмотрим этот раздел:
1. Во-первых, вы должны выполнить запрос, чтобы показать следующий пакет животных. Обычно это массив объектов, возвращаемых API.
2. После завершения обновите таблицу с недавно загруженными данными.
3. Наконец, удостоверьтесь, что вызвали **-completeBatchFetching:** с **YES**. Запросы на получение новых данных не будут выполнены, пока предыдущий не был завершен.
Скомпилируйте, запустите и начните скролить. Не останавливайтесь, пока вы не увидите другую птицу. Они бесконечны.
Умный preloading
----------------
Вы когда-нибудь пробовали загружать контент заранее в приложении с помощью scrollView или PageViewController? Возможно, вы работали над полноэкранной фото галереей и захотели, чтобы следующие несколько изображений были загружены и ожидали, а пользователи редко видели placeholder.
Когда вы работаете над такой системой, как эта, начинаете осознавать, что есть много вещей, о — которых стоит подумать.
* Сколько памяти вы занимаете?
* Как много информации нужно загружать заранее?
* Когда вы решаете вывести ответ пользователям?
И задача становится намного сложнее, когда у вас контент разного размера. У вас есть PageViewController с CollectionView внутри каждого контроллера? Теперь вы должны подумать о том, как динамично загружать контент в обоих направлениях … И настроить отображение для каждого устройства, которое поддерживаете.
В каждом из контейнерных классов есть понятие состояния интерфейса для каждого из узлов. В любой момент времени узел может быть в любой комбинации:
* **Preload Range:** Обычно дальний диапазон от видимого. Когда контент для каждого подузла в ячейке, такого как ASNetworkImageNode, должен быть загружен из внешнего источника; из API или локального кэша, например. Это контрастирует с пакетной выборкой, которая должна использоваться для выборки объектов моделей, представляющих сами ячейки.
* **Display Range:** Здесь происходят отрисовка текста и декодирование изображения.
* **Visible Range:** В этом диапазоне узел на экране занимает по крайней мере один пиксель.
Эти диапазоны также работают с метрикой «screenfuls» и могут быть легко настроены с помощью свойства **ASRangeTuningParameters**.
Например, вы используете **ASNetworkImageNode** для отображения изображения на каждой странице галереи. Каждый узел запрашивает данные из сети, когда входит в диапазон предварительной загрузки, и декодирует изображение, которое было извлечено, когда оно входит в диапазон отображения.
На самом деле, вы не должны постоянно думать об этих диапазонах, если не хотите. Встроенные компоненты, такие как **ASNetworkImageNode** и **ASTextNode**, в полной мере используют их. Это означает, что вы увидите преимущества по умолчанию.
> **Примечание**: Одна вещь, которая может быть не очевидной, состоит в том, что эти диапазоны не складывают. Вместо этого они накладываются и сходятся на видимом диапазоне. Если вы установите дисплей и выберете оба диапазона на один экран, они проявятся в одно и то же время. Эти данные обычно нужны для отображение на экране, поэтому обычно диапазон упреждающей выборки должен быть немного больше, чтобы узлы были готовы запустить процесс дисплея, когда они доберутся до этого диапазона.
>
> В целом, ведущая сторона диапазона больше, чем конечная. Когда пользователь изменяет направление скролла, размеры диапазонов тоже меняются, чтобы подготовиться к контенту, к которому двигается пользователь.
Интерфейс узла в состоянии обратного вызова
-------------------------------------------
Возможно, вам интересно, как эти диапазоны правильно работают? Хорошо, что спросили.
У каждого узла в системе есть **interfaceState** свойство, которое является типом «битового поля» (NS\_OPTION) **ASInterfaceState**. Поскольку **ASCellNode** перемещается через представление прокрутки, которым управляет **ASRangeController**, каждый подузел обновляет **interfaceState** свойство. Это значит, что даже самые глубокие узлы в дереве могут реагировать на изменения **interfaceState**.
К счастью, редко приходится возиться с битами **interfaceState** узла напрямую. Чаще всего вы просто хотите отреагировать на переход узла в определенное состояние или выход из него. Вот тут-то и появляются обратные вызовы состояния интерфейса.
### Наименование узлов
Чтобы увидеть, как узел переходит из одного состояния в другое, полезно дать ему имя. Таким образом, вы сможете наблюдать, как каждый узел загружает свои данные, отображает их содержимое, появляется на экране, а затем делает всё это наоборот, когда исчезает.
Вернитесь к **-tableNode:nodeBlockForRowAtIndexPath:** и найдите комментарий, в котором говорится:
```
//Вы добавите здесь что-нибудь потом…
```
Ниже добавьте следующую строку, чтобы дать каждой ячейке **debugName**.
```
cardNode.debugName = [NSString stringWithFormat:@«cell %zd», indexPath.row];
```
Теперь вы сможете отслеживать перемещение ячеек через диапазоны.
### Наблюдение за ячейками
Перейдите в **CardNode\_InterfaceCallbacks.m**. Здесь вы найдете шесть методов, которые сможете использовать для отслеживания прогресса узла через различные диапазоны. Раскомментируйте их, а затем скомпилируйте и запустите. Удостоверьтесь, что ваша консоль в Xcode видна, и затем медленно прокручивайте. Смотрите, как различные ячейки реагируют на свои изменяющиеся состояния.
> **Примечание**: В большинстве случаев единственным способом изменения ASInterfaceState, который вам нужен, является метод **-didEnterVisibleState** или **-didExitVisibleState**.
>
> Основная реализация скрыта от вас. Чтобы проверить, что вы можете сделать, интегрировав состояния Preload и Display, посмотрите на код в **ASNetworkImageNode**. Все узлы сетевых изображения будут автоматически извлекать и декодировать свое содержимое, а также освобождать память, без необходимости двигать пальцем.
(Интеллектуальный Preloading)2
------------------------------
В версии 2.0 была введена концепция интеллектуальной предварительной загрузки контента по нескольким направлениям. Скажем, у вас есть вертикально прокручиваемое представление таблицы, и в какой-то момент на экране появляется ячейка, содержащая горизонтальный вид коллекции.
Хотя эта коллекция сейчас технически находится в видимой области, вам не хотелось бы загружать всю коллекцию заранее. Вместо этого оба вида прокрутки имеют свой собственный **ASRangeController** с отдельными настраиваемыми параметрами настройки диапазона.
### Ввод второй размерности
Теперь, когда вы завершили **AnimalTableController**, вы можете использовать его как страницу в **ASPagerNode**.
Контроллер представления, который вы будете использовать для размещения этого пейджера, уже находится в проекте, поэтому первое, что вам нужно сделать, это перейти в **AppDelegate.m**.
Найдите **-installRootViewController** и замените:
```
AnimalTableController *vc = [[AnimalTableController alloc]
initWithAnimals:[RainforestCardInfo allAnimals]];
```
на:
```
AnimalPagerController *vc = [[AnimalPagerController alloc] init];
```
Затем перейдите в **AnimalPagerController.m** и добавьте следующие строки в инициализатор, прямо перед оператором return. Все, что вам нужно сделать, это создать новый пейджер и установить его **dataSource** в качестве этого контроллера представления.
```
_pagerNode = [[ASPagerNode alloc] init];
_pagerNode.dataSource = self;
```
Узел пейджера фактически является подклассом **ASCollectionNode**, предварительно сконфигурированным для использования таким же образом, как и **UIPageViewController**. Хорошо, что думать об API на самом деле немного проще, чем о **UIPageViewController**.
Следующее, что вам нужно сделать, это реализовать методы источника данных пейджера. Перейдите к реализации категории **ASPagerDataSource** в конец этого файла.
Сначала скажите пейджеру, что число его страниц равно количеству массивов животных, в данном случае, три, заменив существующий **-numberOfPagesInPagerNode:**.
```
- (NSInteger)numberOfPagesInPagerNode:(ASPagerNode *)pagerNode {
return self.animals.count;
}
```
Затем вам нужно реализовать **-pagerNode:nodeAtIndex:** аналогично методу источника данных узла, который вы ранее реализовали для **ASTableNode**.
```
- (ASCellNode *)pagerNode:(ASPagerNode *)pagerNode nodeAtIndex:(NSInteger)index {
//1
CGSize pagerNodeSize = pagerNode.bounds.size;
NSArray *animals = self.animals[index];
//2
ASCellNode *node = [[ASCellNode alloc] initWithViewControllerBlock:^{
return [[AnimalTableController alloc] initWithAnimals:animals];
} didLoadBlock:nil];
return node;
}
```
Давайте рассмотрим этот раздел:
1. Несмотря на то, что эта версия не является блочной, хорошей практикой является сначала захватить вашу модель данных.
2. На этот раз вы используете мощный инициализатор **-initWithViewControllerBlock:**. Все, что вам нужно – это вернуть блок, возвращающий контроллер узла таблицы, который вы исправили ранее, и управляемое представление будет автоматически использоваться в качестве представления для каждой страницы.
После добавления этого метода, у вас будет полностью функционирующий пейджер, ячейки которого будут сгенерированы из созданного ранее **tableNodeController**. Это полностью поставляется с двухмерной предварительной загрузкой, основанной на вертикальной и горизонтальной прокрутке, выполняемой пользователем!
Куда идти дальше?
-----------------
Полную версию проекта для этого туториала по AsyncDisplayKit 2.0 можно скачать [здесь](https://koenig-media.raywenderlich.com/uploads/2016/12/AsyncDisplayKit-Finished-4.zip). У нас также есть [вариант](https://koenig-media.raywenderlich.com/uploads/2016/12/RainForestSwift-1.zip) на Swift.
Скоро будет готов перевод 2 части этого проекта. Она позволит узнать о новой, мощной системе компоновки, представленной в AsyncDisplayKit 2.0.
Можете провести небольшое исследование, прежде чем двигаться дальше: откройте домашнюю страницу [AsyncDisplayKit](http://texturegroup.org) и прочитайте часть документации. У Скотта Гудсона (Scott Goodson, оригинального автора AsyncDisplayKit) также есть несколько лекций, которые могут вас заинтересовать, самые [новые](https://www.youtube.com/watch?v=0bOdPUvSzG0) из которых дают хороший обзор нескольких больших проблем с изображениями, которые фреймворк пытается решить.
Возможно, вам будет интересно [Building Paper](https://www.youtube.com/watch?v=OiY1cheLpmI). Хотя в то время все это не было open sourse, и многое изменилось, довольно интересно посмотреть, с чего все это начиналось.
Наконец, сообщество AsyncDisplayKit приветствует вновь прибывших. Есть общедоступный [канал в Slack](http://texturegroup.org/slack.html), в который любой может вступить и задать вопросы.
Надеемся, вам понравился этот туториал, сообщите, есть ли у какие-либо вопросы или комментарии, присоединившись к обсуждению на форуме.
**От переводчика:**
В апреле разработчики переименовали фреймворк. Теперь он называется Texture. Подробнее можно прочитать [тут](https://medium.com/@Pinterest_Engineering/introducing-texture-a-new-home-for-asyncdisplaykit-e7c003308f50).
P.S. Отдельное спасибо [BeataSunshine](https://habrahabr.ru/users/beatasunshine/) и [evgen](https://habrahabr.ru/users/evgen/) за помощь в переводе статьи. | https://habr.com/ru/post/329002/ | null | ru | null |
# IpHoster.ru? НЕТ
*Админы делятся на тех, кто не делает бекапы и на тех, кто уже делает*
Привет, читатель! Скажи, было ли у тебя такое, чтобы по какой-то глупой причине ты не успел заплатить за хостинг и просрочил оплату на два дня? Думаю, у всякого такое бывало. Наверное, вам хостер вынес предупреждение или, даже, заблокировал сайт? Да, неприятно, но не смертельно (если, конечно, у вас не сверхпосещаемый портал). Вот и у меня такое случилось — впервые за год использования выделенного сервера я задержал оплату на два дня. Но сотрудники бравого хостинга решили, что простой блокировки — недостаточно. **iphoster.ru** решили наказать меня максимально, по всем пунктам, как только могли.
История
-------
Хостинг был заказан 17 декабря 2009 года для стартапа, который плавно и неспеша готовился к запуску. Мы хотели, чтобы идея созрела, потому год или два на запуск — это не страшно. Всё это время мы его готовили прям на нашем личном сервере.
Машинка не самая мощная, но хватало с головой:
Процессор: Pentium 4
Оперативная память: 512 Mб
Диск: 60 Гб
IP адреса: 5
OS: Debian 5
Цена в 40уе в месяц была несравнима с удобством сообственного хостинга и увереностью в сообственных данных.
На сервере кроме нашего будущего стартапа хостилось несколько моих проектов:
Фреймворк libcanvas (http://libcanvas.com) и [консольный форум](http://habrahabr.ru/blogs/i_am_advertising/67301/) (http://freecr.ru). Так же, я «дал убежище» некоторым своим товарищам для их проектов, например [nerman](https://habr.com/users/nerman/)
Кроме того, я использовал его для работы, а также для многих мелких статей и скриптов.
Также, там располагались системы контроля версий моих проектов.
Я бы не сказал, что хостинг был очень надёжным. Иногда бывало по несколько часов не было связи с ним. Один раз даже произошёл интересный случай, из-за которого мой сервер не работал 25-26 ноября 2010 года.
Ближе к обеду 25-ого числа мне приходит смс о том, что сервер не работает. Но я — в другом городе, приезжаю к вечеру и начинаю разбираться. Потом пишу в поддержку. Хотя этот случай имеет только косвенное отношение к результату, но обратите внимание, как лояльно я отношусь к их проблемам и как акцентирую на важности данных.
> `[Shock
>
>
>
> Ребята, привет! Сервер \"173.212.242.162\".
>
>
>
> Сначала - вырубился apache. При попытке перезапустить выдало сообщение:
>
> shock:/# /etc/init.d/apache2 restart
>
> Restarting web server: apache2(5)Input/output error: apache2: could not open error log file /var/log/apache2/error.log.
>
> Unable to open logs
>
> failed!
>
>
>
> Потом заметилась такая фигня:
>
>
>
> shock:/# ls -l /var/log
>
> ls: cannot access /var/log/dmesg.1.gz: Input/output error
>
> ls: cannot access /var/log/auth.log.3.gz: Input/output error
>
> ls: cannot access /var/log/syslog: Input/output error
>
> ls: cannot access /var/log/dmesg.3.gz: Input/output error
>
> ls: cannot access /var/log/vsftpd.log: Input/output error
>
>
>
> На Лоре пишут, что это проблема с жёстким диском и необходимо срочно переезжать на другой диск, пока можно восстановить данные
>
>
>
> В итоге сделал shock:/# reboot
>
> Уже 15 минут сервер на стартует, пинги не доходят.
>
>
>
>
>
> Support (Александр М.)
>
>
>
> Здравствуйте Павел,
>
> Попробуйте отправить запрос на ребут из биллинг-панели. Сотрудники ДЦ перезагрузят сервер.
>
> С уважением, Специалист службы технической поддержки компании IPhoster
>
>
>
> Shock
>
> у меня есть подозрение, что не поднимается сеть из-за того, что не может писать в логи. то есть ребут сам по себе не поможет... но щас отправлю
>
>
>
>
>
> Support (Александр М.)
>
> Дело в том, что в ДЦ burst произошла авария, и сейчас сотрудники ДЦ делают все возможное для скорейшего устранения проблемы. Скорее всего, проблема на Вашем сервере связана с этим, и нужно дождаться, пока все сервера переведут в штатный режим работы.
>
>
>
> Shock
>
> Ясно. **Самое главное - данные уцелеют**? Можно подробнее про аварию почитать?
>
> ps. Хороший новый дизайн, но очень тяжело отправить сообщение в файрфоксе - нету кнопки отправления: habreffect.ru/files/c48/83ca4f6c6/form.png](http://habreffect.ru/files/c48/83ca4f6c6/form.png)
>
>
>
>
>
> Support (Александр М.)
>
> Приветствую Павел,
>
> Да, с данными ничего произойти не должно. Вот информация от ДЦ:
>
>
>
>
> > There was a large explosion up the street from the Scranton PA data center.
> >
> > Following that, there was issue with one of our generator systems.
> >
> > We are working on the issue and should be resolved as quickly as possible.
> >
> > No ETA/details on explosion yet, but power is out in a multi-block radius.
> >
> > I would expect us to be running on generator power most of the day during repair from the power company.
> >
> >
> >
> > We have currently returned power to the data center and called in extra staff to physically go through any servers that remain offline.
>
>
>
>
>
> Shock
>
> Спасибо) Удивляет только, почему сначала были проблемы с фс, а только потом вырубило сервак. Ну да ладно, наладится - увидим. Спасибо! Приятной ночи!
>
>
>
>
>
> Support (Александр М.)
>
> Доброй ночи Павел,
>
> Спасибо за понимание. Если нужна будет наша помощь - обращайтесь.
>
>
>
> Shock
>
> Ребята, сервер поднялся. фигня с Input/output error продолжается.
>
>
>
>
>
> Support (Александр Х.)
>
> Уважаемый Павел,
>
> Исправил.
>
>
>
> Shock
>
> спасибо, а что было то?)
>
>
>
> Shock
>
> ПС:
>
>
>
> shock:/# dd\_rescue /dev/hda7 /dev/null
>
> dd\_rescue: (warning): /dev/null (32768.0k): Invalid argument! 31744.0k
>
> dd\_rescue: (warning): /dev/null (65536.0k): Invalid argument! 64512.0k
>
> dd\_rescue: (warning): /dev/null (98304.0k): Invalid argument! 97280.0k
>
> dd\_rescue: (warning): /dev/null (131072.0k): Invalid argument! 130048.0k
>
> dd\_rescue: (warning): /dev/null (163840.0k): Invalid argument! 162816.0k
>
> dd\_rescue: (warning): /dev/null (196608.0k): Invalid argument! 195584.0k
>
> ....
>
>
>
> винт умер?
>
>
>
>
>
> Support (Александр Х.)
>
> Здравствуйте Павел,
>
> да нет. сейчас вроде проблем нету.
>
>
>
> Shock:
>
> Только-что запустил:
>
> shock:/# dd\_rescue /dev/hda7 /dev/null
>
> dd\_rescue: (warning): /dev/null (32768.0k): Invalid argument! 31744.0k
>
> dd\_rescue: (warning): /dev/null (65536.0k): Invalid argument! 64512.0k
>
> dd\_rescue: (warning): /dev/null (98304.0k): Invalid argument! 97280.0k
>
> ...
>
>
>
> dd\_rescue: (warning): /dev/null (2260992.0k): Invalid argument! 2259968.0k
>
> dd\_rescue: (warning): /dev/null (2293760.0k): Invalid argument! 2292736.0k
>
> dd\_rescue: (warning): /dev/null (2326528.0k): Invalid argument! 2325504.0k
>
> dd\_rescue: (warning): /dev/null (2359296.0k): Invalid argument! 2358272.0k
>
>
>
> dd\_rescue: (info): ipos: 2427200.0k, opos: 2427200.0k, xferd: 2427200.0k
>
> errs: 160, errxfer: 80.0k, succxfer: 2427200.0k,
>
> +curr.rate: 40085kB/s, avg.rate: 36254kB/s, avg.load: 2.3%
>
>
>
> и еще несколько раз выскакивает сообщение \"Bad block: 4456471\" (где-то так), но скопировать не успеваю
>
> Вот скрин: [habreffect.ru/files/e1f/f30ad6918/bad-block.png](http://habreffect.ru/files/e1f/f30ad6918/bad-block.png)
>
>
>
> Спасибо, что подняли, **щас сервер доступен - это на самом деле очень важно.**
>
> Но боюсь, что эта фигня может стать причиной проблем в будущем(
>
> В т.ч. потери информации. Лучше застраховаться.
>
>
>
> Кстати, **бекапы у вас делаются на случай**, например, проблем с железом?
>
>
>
>
>
> Support (Александр Х.)
>
> Уважаемый Павел,
>
>
>
> Проверил, проблема действительно имеет место.
>
> shock:~# lsof | grep var
>
> acpid 1852 root 4u unix 0xde18c900 5033 /var/run/acpid.socket
>
> dbus-daem 1862 messagebus 3u unix 0xde18c100 5053 /var/run/dbus/system_bus_socket
>
> dbus-daem 1862 messagebus 8u unix 0xde0e3480 5090 /var/run/dbus/system_bus_socket
>
> avahi-dae 1874 avahi 11u unix 0xde0e3080 5087 /var/run/avahi-daemon/socket
>
> cron 2054 root cwd DIR 3,7 4096 1011843 /var/spool/cron
>
> cron 2054 root 3u REG 3,7 5 408022 /var/run/crond.pid
>
> shock:~# /etc/init.d/cron stop
>
> Stopping periodic command scheduler: crond.
>
> shock:~# lsof | grep var
>
> acpid 1852 root 4u unix 0xde18c900 5033 /var/run/acpid.socket
>
> dbus-daem 1862 messagebus 3u unix 0xde18c100 5053 /var/run/dbus/system_bus_socket
>
> dbus-daem 1862 messagebus 8u unix 0xde0e3480 5090 /var/run/dbus/system_bus_socket
>
> avahi-dae 1874 avahi 11u unix 0xde0e3080 5087 /var/run/avahi-daemon/socket
>
> shock:~# kill -9 1874
>
> shock:~# kill -9 1862
>
> shock:~# kill -9 1852
>
> shock:~# umount /var
>
> shock:~# badblocks -v /dev/hda7
>
> Checking blocks 0 to 9791585
>
> Checking for bad blocks (read-only test): 2228224 done, 11:17 elapsed
>
> 2228236 done, 11:21 elapsed
>
> 2228237 done, 11:24 elapsed
>
> 2228238 done, 11:25 elapsed
>
> 2228239 done, 11:26 elapsed
>
> done
>
> Pass completed, 5 bad blocks found.
>
>
>
> Я отправил запрос в ДЦ. После получения от них ответа Вы будите уведомлены.
>
>
>
> 2010-11-29 23:23:04
>
> Тикет закрыт автоматически в связи с окончанием срока жизни.`
Больше писем я от них никуда не получал, но через пару дней проблема спустя несколько часов неработоспособности сервера пропала. Фиг с ним.
Естественно, двое суток простоя по вине хостера **были оплачены из моего кармана** (я уж молчу про моральный ущерб), но я человек не конфликтный, потому решил пропустить это. Мои нервы и нервы сотрудников хостинга дороже каких-то небольших денег.
К сути
------
17-ого числа я должен был снова платить, но в силу задержки банковского счёта не успел снять деньги. Стабильная работа сервера в данный момент была не так критична, я учел, что он может быть отключён за неуплату и осознавал, что необходимо заплатить как можно скорее. В ночь с 18-ого на 19-ое я наконец-то положил деньги на счёт WebMoney, проверил, что сайты [libcanvas.com](http://libcanvas.com) и [freecr.ru](http://freecr.ru) до сих пор доступны, сервер работает я перечислил им оплату, которая была принята и спокойно лёг спать. К вечеру 19-ого числа сервер уже не работал.
> `**2011-01-20 10:02:28**
>
> Shock
>
> Ребят, что там с сервером? Пинги не идут, на запросы не отвечает. Продолжается уже половину суток. Несколько часов назад отправлял запрос на перезагрузку, но не помогло.
>
>
>
> Support (Александр Х.)
>
> Уважаемый Павел,
>
> Отправил запрос в ДЦ. После получения от них ответа Вы будете уведомлены.
>
>
>
> Support (Александр Х.)
>
> Доброе утро Павел,
>
> Ваш сервер был отменен за не уплату 18 января.
>
>
>
> Shock
>
> Оплата была произведена, когда сервер ещё работал. Сейчас указывает, что осталось 26 дней:
>
> 
>
>
>
> Денис З. (Администратор):
>
> **без разницы, если сервер не работает значить его уже разобрали на запчасти, а винчестер отформатировали. Желаете, чтобы был сделан повторно заказ?**
>
>
>
> Shock
>
> Ребята, вы шутите? Я задержался на один день, а вы убили все данные, которые там были?
>
> Я с вас просто в диком шоке, если это так. И нету возможности всё вернуть, как было?
>
>
>
> Есть бекапы?
>
>
>
> Денис З. (Администратор):
>
> задержка была на 2 дня, так как задержка оплата вообще не возможна. Я уточню по данным.
>
>
>
> Shock
>
> Жду`
Как вам нравится такое отношение? Удалить все данные из-за задержки в два дня. Я вчера [задавал вопрос в q&a](http://habrahabr.ru/qa/4047/) и из шестнадцати человек ни один не сказал, что это было бы нормальное поведение для хостера.
Они не то, что не дали мне немного времени для экстренной ситуации (мало ли что случилось?), они не позвонили, не написали емейл лично, даже не сохранили данные — самый ценный ресурс сейчас, а для них это стоило бы всего 10-20 центов в день. Неужели эти копейки стоят того, чтобы так по-хамски относится к клиентам? А ведь фактический ущерб был нанесен на тысячи долларов!
А деньги, которые я заплатил за январь-февраль месяць — лежат на счету и до сих пор тикают, хотя услуга не представляется. Я еще не поднимал этот вопрос, но у меня почему-то не возникает сомнений, что с деньгами будет как всегда, но не это самое важное.
Вывод
-----
Хостер решил, что правильное наказание за два дня просрочки — взять деньги за следующий месяц, после чего удалить все данные с моего сервера, разобрать компьютер и даже не узнать у клиента причины такой ситуации. А вдруг это был всего-лишь сбой в ихнем програмном обеспечении?
Если, не дай Бог, у вас есть у них сайты или выделенные сервера — знайте, за малейшее недовольство данные будут нещадно стёрты без возможности восстановления даже без предварительного обсуждения! Бегите от них! **iphoster.ru** — это всё то плохое, что может быть у хостинга. | https://habr.com/ru/post/112249/ | null | ru | null |
# FreePBX и CallBack: видеть номера звонящих
Доброго дня!
Это очень маленькая заметка, но и вопрос прост. Прост, да не так прост, простите за X.
Во FreePBX есть отличный модуль **Callback**. Система сбрасывает звонок и перезванивает, соединяя с указанным номером. Но при этом теряется CallerID, и в софтофонах высвечивается замечательный «Unknown».
Сейчас я расскажу, как это пофиксить из вебморды за минуту.
Нам понадобится модуль **Set Caller ID**. Установите его, если он отсутствует.
Цепочка выглядит так:
Inbound Routes -> Callback. Звонок поступает на созданный callback, происходит terminate call, и каллбэк перезванивает клиенту.
Далее:
Callback Destination -> Set Caller ID -> Наше назначение. То есть в Destination нашего Callback`а мы указываем не конечную точку, куда принять звонок, а элемент модуля Set Caller ID, в котором уже стоит наше назначение. Модуль как бы становится прослойкой между Callback и назначением.
Ну и теперь самое главное: настройки полей модуля Set Caller ID:
`Caller id name: CALLBACK ${CUT(CUT(CHANNEL,@,1),/,2)}
Caller id num: ${CUT(CUT(CHANNEL,@,1),/,2)}`
Итог: нормальное отображение номера звонящего в CDR и софтофонах.
Удачи! | https://habr.com/ru/post/301756/ | null | ru | null |
# Программируем императивно в Хаскеле, используя линзы
Хаскель получает много нелестных отзывов, потому что в нём нет встроенного инструментария для работы с изменениями и состояниями. Поэтому, если мы хотим испечь полный состояний яблочный пирог, нам необходимо для начала создать целую вселенную операторов для работы с состояниями. Однако за это уже заплачено с лихвой и это уже пройденный этап, и сейчас программисты на Хаскеле наслаждаются более элегантным, лаконичным и мощным императивным кодом, чем даже то, что вы можете найти в само-описывающих императивных языках. Впрочем, вы и сами сможете в этом убедится.
#### Линзы
Ваш билет к элегантному коду — это библиотека линз (`lens`).
Вы определяете ваши данные как обычно, только добавляете к началу имён ваших полей знак подчёркивания. Например, мы можем определить игру(Game) как:
```
data Game = Game
{ _score :: Int
, _units :: [Unit]
, _boss :: Unit
} deriving (Show)
```
полную существ(Unit):
```
data Unit = Unit
{ _health :: Int
, _position :: Point
} deriving (Show)
```
чьи местоположения определяются через точки (Point):
```
data Point = Point
{ _x :: Double
, _y :: Double
} deriving (Show)
```
Мы добавляем к полям знак подчёркивания, потому что мы не будем их использовать напрямую. Вместо этого, мы будем их использовать для того, чтобы построить линзы, с которыми значительно приятнее работать.
Мы можем построить линзы двумя путями. Первый вариант — вручную создать линзы используя удобную функцию `lens` из `Control.Lens`. Например, мы можем определить линзу `score` для поля `_score` следующим образом:
```
import Control.Lens
score :: Lens' Game Int
score = lens _score (\game v -> game { _score = v })
```
Тип `Lens` как карта для навигации по сложным типам данных. Мы используем линзу `score` для того, что бы от типа `Game` прийти к `_score`.
Тип отражает, откуда мы должны начать и чем закончить: `Lens' Game Int` означает, что мы должны начать с `Game` и закончить `Int` (для поля `_score` в нашем случае). Аналогично, наши другие линзы ясно отражают начальные и конечные точки их типов:
```
units :: Lens' Game [Unit]
units = lens _units (\game v -> game { _units = v })
boss :: Lens' Game Unit
boss = lens _boss (\game v -> game { _boss = v })
health :: Lens' Unit Int
health = lens _health (\unit v -> unit { _health = v })
position :: Lens' Unit Point
position = lens _position (\unit v -> unit { _position = v })
x :: Lens' Point Double
x = lens _x (\point v -> point { _x = v })
y :: Lens' Point Double
y = lens _y (\point v -> point { _y = v })
```
Однако, зачастую мы ленивы и не хотим писать рутинный код, В этом случае можно выбрать другой путь, используя шаблонный Хаскель (`Template Haskell`) чтобы он создал линзы за нас:
```
{-# LANGUAGE TemplateHaskell #-}
import Control.Lens
data Game = Game
{ _score :: Int
, _units :: [Unit]
, _boss :: Unit
} deriving (Show)
data Unit = Unit
{ _health :: Int
, _position :: Point
} deriving (Show)
data Point = Point
{ _x :: Double
, _y :: Double
} deriving (Show)
makeLenses ''Game
makeLenses ''Unit
makeLenses ''Point
```
Только помните, шаблонный Хасель трубует, что бы декларация `makeLenses` шла после декларации типов данных.
##### Начальное состояние
Следующее, что нам надо сделать, это инициализировать начальное состояние игры.
**initialState :: Game**
```
initialState :: Game
initialState = Game
{ _score = 0
, _units =
[ Unit
{ _health = 10
, _position = Point { _x = 3.5, _y = 7.0 }
}
, Unit
{ _health = 15
, _position = Point { _x = 1.0, _y = 1.0 }
}
, Unit
{ _health = 8
, _position = Point { _x = 0.0, _y = 2.1 }
}
]
, _boss = Unit
{ _health = 100
, _position = Point { _x = 0.0, _y = 0.0 }
}
}
```
Мы создали трёх героев, которые будут сражаться против босса подземелья. Да начнётся битва!
##### Первые шаги
Теперь мы можем использовать наши линзы! Давайте создадим функцию, чтобы наши воины нападали на босса.
```
import Control.Monad.Trans.Class
import Control.Monad.Trans.State
strike :: StateT Game IO ()
strike = do
lift $ putStrLn "*shink*"
boss.health -= 10
```
Функция нападение(`strike`) печатает нам похожий звук в консоле, далее уменьшает здоровье боса 10 единиц здоровья.
Тип функции нападения показывает нам, что мы оперируем с `StateT Game IO` монадой. Вы можете думать, что это такой встроенный язык, где мы создаём слой чистых состояний игры (то есть `StateT Game`) поверх побочных эффектов (то есть `IO`) так, что мы можем одновременно и изменять состояния, и печатать наши милейшие эффекты от битвы на консоль. Всё, что нужно сейчас помнить, это то, что если мы хотим использовать побочные эффекты нам нужно использовать функцию `lift`.
Давайте попробуем использовать нашу функцию в интерпретаторе (`ghci`). Для этого нам понадобится начальное состояние:
**execStateT strike initialState**
```
>>> execStateT strike initialState
*shink*
Game {_score = 0, _units = [Unit {_health = 10, _position = Poin
t {_x = 3.5, _y = 7.0}},Unit {_health = 15, _position = Point {_
x = 1.0, _y = 1.0}},Unit {_health = 8, _position = Point {_x = 0
.0, _y = 2.1}}], _boss = Unit {_health = 90, _position = Point {
_x = 0.0, _y = 0.0}}}
```
Функция `execStateT` берёт наш код с состояниями и наше начальное состояние, запускает его, и производит новое состояние. Интерпретатор автоматически выводит нам на экран, и мы сразу можем анализировать результат. На выходе получилась каша, однако, если натренировать свой глаз, вы сможете увидеть, что у босса сейчас только 90 единиц здоровья.
Мы сможем увидеть это более легко, если мы сначала создадим новую переменную для полученного состояния
```
>>> newState <- execStateT strike initialState
*shink*
```
а потом извлечём из него необходимую информацию:
```
>>> newState^.boss.health
90
```
#### Композиция
Следующий код очень сильно напоминает императивный и объекто-ориентированный код:
```
boss.health -= 10
```
Что тут происходит?? Хаскель определённо **не** мульти-парадигменный язык, но мы имеем то, что появляется в мульти-парадигменном коде.
Невероятно, но ничто в этом коде не является фишкой встроенной в язык!
* `boss` и `health` — всего лишь линзы, которые мы определили выше
* `(-=)` — инфиксная функция
* `(.)` — функциональная композиция из хаскельного `Prelude`!
Подождите, `(.)` — это функциональная композиция?! Действительно?!
Вот где происходит вся магия линз. Линзы — это самые обычные функции, и весь наш «мульти-парадигменный» код на самом деле является ничем иным, как смесью функций!
Фактически, тип `Lens' a b` представляет собой синоним типа функций высшего порядка:
```
type Lens' a b =
forall f . (Functor f) => (b -> f b) -> (a -> f a)
```
Вам нет необходимости всё понимать сейчас. Просто помните, что `Lens' a b` — функция высшего порядка, которая берёт тип `(b -> f b)` в качестве входного аргумента, и возвращает новую функцию типа `(a -> f a)`. `Functor` — часть теории, которую сейчас можно рассматривать как «магию».
**Убедимся, что boss . health :: Lens' Game Int**Вооружённые этим знанием, давайте посмотрим, как можно разложить типы функций `boss` и `health`:
```
boss :: Lens' Game Unit
-- раскрывается в :
boss :: (Functor f) => (Unit -> f Unit) -> (Game -> f Game)
health :: Lens' Unit Int
-- раскрывается в :
health :: (Functor f) => (Int -> f Int) -> (Unit -> f Unit)
```
Теперь посмотрим определение функциональной композиции:
```
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(f . g) x = f (g x)
```
Заметьте, если мы заменим наши переменные типов на:
```
a ~ (Int -> f Int)
b ~ (Unit -> f Unit)
c ~ (Game -> f Game)
```
тогда мы получим совершенно однозначное соответствие для композиции двух линз:
```
(.) :: ((Unit -> f Unit) -> (Game -> f Game))
-> ((Int -> f Int ) -> (Unit -> f Unit))
-> ((Int -> f Int ) -> (Game -> f Game))
```
Если мы проведём обратную замену синонима на `Lens'`, мы получим:
```
(.) :: Lens' Game Unit -> Lens' Unit Int -> Lens' Game Int
boss . health :: Lens' Game Int
```
Отсюда следует, что композиция линз — тоже линза! Фактически, линзы формируют категорию, где `(.)` — категориальный оператор композиции, а функция идентичности `id` — тоже линза:
```
(.) :: Lens' x y -> Lens' y z -> Lens' x z
id :: Lens' x x
```
В итоге, используя то, что можно убрать пробелы возле оператора, мы получаем код, который выглядит так, как и нотация объектно-ориентированного кода!
Категории дают невероятно легко соединять и группировать компоненты на лету. Например, если мы ожидаем часто изменять здоровье босса, мы можем определить композицию линз:
```
bossHP :: Lens' Game Int
bossHP = boss.health
```
и теперь можем использовать это везде, где ранее было необходимо использовать `boss.health`.
```
strike :: StateT Game IO ()
strike = do
lift $ putStrLn "*shink*"
bossHP -= 10
```
и так же находить новое значение здоровья:
```
>>> newState^.bossHP
90
```
##### Перечеслимые
Линзы основываются на одной действительно очень элегантной теории, и в результате мы получаем то, что в большинстве императивных языков нельзя сделать просто!
Например, давайте скажем, что наш босс — это дракон который дышит огнём, повреждающим героев. Используя линзы, можем добиться этого эффекта одной строчкой:
```
fireBreath :: StateT Game IO ()
fireBreath = do
lift $ putStrLn "*rawr*"
units.traversed.health -= 3
```
Это создаёт возможность работать с линзами по новому!
```
traversed :: Traversal' [a] a
```
`traversed` помогает нам «докопаться» до значений в списке так, что мы можем работать с ним как с единым целым, вместо того, чтобы вручную обходить весь список. Однако, в этот раз мы используем тип `Traversal'` вместо `Lens'`.
`Traversal'` — это та же самый `Lens'`, только слабее:
```
type Traversal' a b =
forall f . (Applicative f) => (b -> f b) -> (a -> f a)
```
Если мы создаём композицию `Traversal'` и `Lens'`, мы получаем более слабый тип, а именно `Traversal'`. Это работает вне зависимости от того, в каком порядке мы объединяем:
```
(.) :: Lens' a b -> Traversal' b c -> Traversal' a c
(.) :: Traversal' a b -> Lens' b c -> Traversal' a c
units :: Lens' Game [Unit]
units.traversed :: Traversal' Game Unit
units.traversed.health :: Traversal' Game Int
```
Фактически, нам даже не надо это знать. Компилятор правильно сам найдёт тип:
```
>>> :t units.traversed.health
units.traversed.health
:: Applicative f =>
(Int -> f Int) -> Game -> f Game
```
Это в точности совпадает с определением `Traversal' Game Int`!
Собственно, почему бы нам не объединить эти две линзы в одну?
```
partyHP :: Traversal' Game Int
partyHP = units.traversed.health
fireBreath :: StateT Game IO ()
fireBreath = do
lift $ putStrLn "*rawr*"
partyHP -= 3
```
Давайте так же используем функцию `partyHP`, чтобы узнать новое значение здоровья:
```
>>> newState <- execStateT fireBreath initialState
*rawr*
>>> newState^.partyHP
:3:11:
No instance for (Data.Monoid.Monoid Int)
arising from a use of `partyHP'
.........
```
Упс! Это ошибка типа, потому что мы не можем получить единственное значение здоровья! Именно поэтому `Traversal'` слабее, чем `Lens'`: обходиимые могут указывать на множество значений, поэтому они не поддерживают хорошо определённый путь показать единственное значение. Система помогла нам избавиться от возможного бага.
Вместо этого, мы должны определить, что мы хотим получить список с помощью функции `toListOf`:
```
toListOf :: Traversal' a b -> a -> [b]
```
Это даёт нам удовлетворительный результат:
```
>>> toListOf partyHP newState
[7,12,5]
```
или инфиксный эквивалент функции `toListOf`: `(^..)`:
```
>>> initialState^..partyHP
[10,15,8]
>>> newState^..partyHP
[7,12,5]
```
Это даёт нам ясный вид того, что получили мы то, что и хотели при помощи `fireBreath`.
А давайте получим что-то на самом деле причудливое. Мы можем определить перечисление по географической области. Мы сможем это сделать?
```
around :: Point -> Double -> Traversal' Unit Unit
around center radius = filtered (\unit ->
(unit^.position.x - center^.x)^2
+ (unit^.position.y - center^.y)^2
< radius^2 )
```
Конечно, мы можем! Мы смогли ограничить огненное дыхание окружностью!
*`filtered` на самом деле не является теоретически перечислимым, поскольку он не сохраняет количество элементов*
```
fireBreath :: Point -> StateT Game IO ()
fireBreath target = do
lift $ putStrLn "*rawr*"
units.traversed.(around target 1.0).health -= 3
```
Заметьте, насколько выразительный код — мы уменьшаем здоровье у всех, кто вокруг цели. Этот код сообщает нам значительно больше, нежели его эквивалент в лидирующих императивных языках. И полученный код оставляет значительно меньше пространства для ошибок.
В любом случае, давайте вернёмся к огнедыщащему. Для начала посмотрим, кто рядом с ним:
```
> initialState^..units.traversed.position
[Point {_x = 3.5, _y = 7.0},Point {_x = 1.0, _y = 1.0},Point {_x
= 0.0, _y = 2.1}]
```
Хм, два воина находятся близко друг другу. Давайте-ка я метну туда файербол.
```
>>> newState <- execStateT (fireBreath (Point 0.5 1.5)) initialState
*rawr*
>>> (initialState^..partyHP, newState^..partyHP)
([10,15,8],[10,12,5])
```
Попал!
#### Масштабирование
Мы можем делать более уникальные вещи с линзами. Например, масштабировать подмножество нашего глобального состояния.
```
retreat :: StateT Game IO ()
retreat = do
lift $ putStrLn "Retreat!"
zoom (units.traversed.position) $ do
x += 10
y += 10
```
Как и ранее, мы можем объединить две линзы в одну, если мы собираемся ещё использовать их:
```
partyLoc :: Traversal' Game Point
partyLoc = units.traversed.position
retreat :: StateT Game IO ()
retreat = do
lift $ putStrLn "Retreat!"
zoom partyLoc $ do
x += 10
y += 10
```
Что ж, давайте попробуем!
```
>>> initialState^..partyLoc
[Point {_x = 3.5, _y = 7.0},Point {_x = 1.0, _y = 1.0},Point {_x
= 0.0, _y = 2.1}]
>>> newState <- execStateT retreat initialState
Retreat!
>>> newState^..partyLoc
[Point {_x = 13.5, _y = 17.0},Point {_x = 11.0, _y = 11.0},Point
{_x = 10.0, _y = 12.1}]
```
Давайте посмотрим внимательно на тип масштабирования в нашем контексте:
```
zoom :: Traversal a b -> StateT b IO r -> StateT a IO r
```
Функция `zoom` имеет несколько теоретических замечательных возможностей. Например, мы ожидаем, что композиция масштабированых 2х линз должно давать тот же результат, что и масштабирование их композиций.
```
zoom lens1 . zoom lens2 = zoom (lens1 . lens2)
```
и что масштабирование пустой линзы даст себя саму:
```
zoom id = id
```
Другими словами, функция `zoom` — это функтор, а значит он подчиняется законам функтора!
##### Объединяем команды
До этого мы рассматривали одну команду за раз, но сейчас давайте объединим концепции и императивно зададим битву между действующими лицами:
```
battle :: StateT Game IO ()
battle = do
-- Зарядить!
forM_ ["Take that!", "and that!", "and that!"] $ \taunt -> do
lift $ putStrLn taunt
strike
-- Дракон просыпается!
fireBreath (Point 0.5 1.5)
replicateM_ 3 $ do
-- настоящее мужество!
retreat
-- Дракон преследует их
zoom (boss.position) $ do
x += 10
y += 10
```
Что же, поехали!
```
>>> execStateT battle initialState
Take that!
*shink*
and that!
*shink*
and that!
*shink*
*rawr*
Retreat!
Retreat!
Retreat!
Game {_score = 0, _units = [Unit {_health = 10, _position = Poin
t {_x = 33.5, _y = 37.0}},Unit {_health = 12, _position = Point
{_x = 31.0, _y = 31.0}},Unit {_health = 5, _position = Point {_x
= 30.0, _y = 32.1}}], _boss = Unit {_health = 70, _position = P
oint {_x = 30.0, _y = 30.0}}}
```
Я думаю, что люди действительно не шутят, когда говорят, что Хаскель — лучший императивный язык!
#### Заключение
Мы всего лишь приоткрыли завесу возможностей библиотеки `lens`, которая по праву считается одной из королевских драгоценностей экосистемы Хаскеля. Вы можете также использовать линзы для чистого программирования, для того, чтобы мощные и сложные конструкции сжать в очень читаемый и элегантный код. Впрочем, можно ещё много писать про эту замечательную библиотеку. | https://habr.com/ru/post/190442/ | null | ru | null |
# Berkeley Unified Parallel C (UPC). Установка в среде Windows и Linux
 Unified Parallel C (UPC) — это расширение языка C, разработанное для высокопроизводительных вычислений на крупномасштабных параллельных машинах. Язык представляет единую программную модель для систем с общей и разделенной памятью. Количество параллелизма фиксируется на старте программы, обычно с одним потоком на ядро процессора.
» [Официальный сайт UPC](http://upc.gwu.edu)
» [Официальный сайт Berkeley UPC](http://upc.lbl.gov)
В своё время возникли определенные трудности с разворачиванием UPC и отсутствием каких-либо подсказок по первым шагам ни в русскоязычном, ни в англоязычном сегменте интернета, кроме официальной инструкции [INSTALL.TXT](http://upc.lbl.gov/download/dist/INSTALL.TXT), которую пришлось переваривать.
Чтобы сей опыт не пропал даром, я решил написать статью по установке UPC в различных средах.
В случае возникновения трудностей или вопросов можно обратиться к создателям за [технической поддержкой](http://upc.lbl.gov/docs/user/contact.shtml). Отвечают довольно быстро (с учетом того, что находятся на другой стороне планеты). Большая благодарность Paul Hargrove и Dan Bonachea за то, что помогли во всём этом разобраться.
### Установка Berkeley UPC в Windows
**Подготовка среды**
В основном UPC заточен под Linux, поэтому первое, что придется сделать, это установить линуксоподобную консоль и необходимые пакеты:
**1.** Установить Cygwin (лучше в папку с названием без пробелов, например, C:\Programs\Cygwin64)
→ [www.cygwin.com/setup-x86.exe](http://www.cygwin.com/setup-x86.exe)
→ [www.cygwin.com/setup-x86\_64.exe](http://www.cygwin.com/setup-x86_64.exe)
Помимо установки по умолчанию потребуется добавить пакеты gcc (gcc-core, gcc-g++). Проверить установку можно командой:
```
cygcheck -s
```
**2.** Установить [Perl](https://www.perl.org/get.html) либо скачать его среди пакетов Cygwin
**Установка Berkeley UPC**
**1.** Скачать [Berkeley UPC](http://upc.lbl.gov/download/) (C:\Programs\berkeley\_upc-2.22.3\setup)
**2.** Создать подкаталог build (C:\Programs\berkeley\_upc-2.22.3\setup\build)
**3.** Запустить Cygwin
**4.** Запустить скрипт configure. Для указания каталога установки необходимо использовать опцию `--prefix=dir`, для указания сети по умолчанию `--with-default-network=smp` (Symmetric Multiprocessing, локальная многоядерная машина):
```
cd /cygdrive/c/Programs/berkeley_upc-2.22.3/setup/build
../configure --prefix=/cygdrive/c/Programs/berkeley_upc-2.22.3 --with-default-network=smp
```
> SUCCESS! The configure step is now complete. You should now proceed with:
>
> gmake; gmake install
**5.** Скомпилировать UPC:
```
make
```
**6.** Установить UPC:
```
make install
```
Папки opt, dbg содержат различные построения runtime библиотек, используемых кодом UPC. Папка opt содержит оптимизации и используется по умолчанию. Папка dbg используется для отладки при использовании параметра –g в upcc. Не следует использовать напрямую содержимое этих папок. Необходимо пользоваться утилитами upcc и upcrun в папке build или подпапке bin в папке инсталляции.
Чтобы не указывать каждый раз путь до утилит, можно добавить путь bin в переменную среды PATH (Свойства компьютера -> Дополнительные параметры системы -> Параметры среды).
**Тесты конфигурации UPC (по желанию)**
**0.** Каждая подпапка build содержит конфигурационный файл upcc.conf. При необходимости проверить его и отредактировать.
**1.** Минимальный тест конфигурации (из папки build):
```
env UPCC_FLAGS= ./upcc --norc --version
```
> This is upcc (the Berkeley Unified Parallel C compiler), v. 2.22.3
>
> (getting remote translator settings...)
>
> ----------------------+---------------------------------------------------------
>
> UPC Runtime | v. 2.22.3, built on Oct 26 2016 at 10:22:58
>
> ----------------------+---------------------------------------------------------
>
> UPC-to-C translator | v. 2.22.2, built on May 12 2016 at 15:50:34
>
> | host aphid linux-x86\_64/64
>
> | gcc v4.2.4 (Ubuntu 4.2.4-1ubuntu4)
>
> ----------------------+---------------------------------------------------------
>
> Translator location | [upc-translator.lbl.gov/upcc-2.22.2.cgi](http://upc-translator.lbl.gov/upcc-2.22.2.cgi)
>
> ----------------------+---------------------------------------------------------
>
> networks supported | udp smp
>
> ----------------------+---------------------------------------------------------
>
> default network | smp
>
> ----------------------+---------------------------------------------------------
>
> pthreads support | available (if used, default is 2 pthreads per process)
>
> ----------------------+---------------------------------------------------------
**2.** Скомпилировать тесты:
```
make tests-hello
```
> ==== UPC «HELLO WORLD» TESTS SUCCESSFULLY COMPILED ====
>
> Your UPC compilation setup appears to be working for all detected networks: udp smp
>
> You should now test UPC runtime operation for each network of interest.
>
> Start by testing the single-node smp/pthreaded network, with a command like:
>
> ./upcrun -n 2 libupcr-smp-par-test
**3.** Проверить результаты для каждого типа сети:
```
./upcrun -n 2 ./opt/libupcr-smp-par-test
```
> UPCR: UPC threads 0..1 of 2 on SERAVKIN-PC (process 0 of 1, pid=17100)
>
> Welcome to Berkeley UPC!!!
>
> — Hello from thread 0
>
> — Hello from thread 1
```
./upcrun -n 2 ./opt/libupcr-udp-par-test
```
> upcrun: nodes not specified! See RUNNING UDP-BASED UPC JOBS in 'man upcrun'
**Пример**
```
cd /cygdrive/c/Programs/berkeley_upc-2.22.3/bin
./upcc /cygdrive/c/Programs/berkeley_upc-2.22.3/upc-examples/hello.upc -o hello -pthreads
./upcrun -n 4 hello
```
> UPCR: UPC threads 0..3 of 4 on SERAVKIN-PC (process 0 of 1, pid=32016)
>
> Welcome to Berkeley UPC!!!
>
> — Hello from thread 2!!!
>
> — Hello from thread 1!!!
>
> — Hello from thread 3!!!
>
> — Hello from thread 0!!!
**Неприятные ограничения**
В среде Windows возможно использование только онлайн транслятора UPC-to-C (используется по умолчанию). Следовательно, нужно быть онлайн, работает медленнее. Но самое напряжное, что потенциально у Беркли есть возможность перехватывать все программы. Если задачки учебные, то как бы ладно, а если что-то серьезное, то уже как-то неуютно. Плюс, есть опасения, что отладка работает только в Linux. Чтобы всё это дело завелось на Windows можно установить виртуальную машину
### Виртуальная ROSA Fresh
**1.** Сначала нужно установить виртуальный менеджер, например, [Oracle VM VirtualBox](https://www.virtualbox.org/).
**2.** Скачать образ Linux. Выбор пал на [ROSA Fresh KDE](https://www.rosalinux.ru/rosa-fresh/), т.к. это отечественная разработка.
**3.** Добавить новую машину Other Linux, выделить оперативную память сколько не жалко.
**4.** Настроить:
> Система – Процессор: процессоры – все ядра, ограничение 90% (иначе основная система перестанет реагировать при интенсивной нагрузке).
>
> Дисплей – Экран: видеопамять 96 Мб
>
> Носители — добавить образ с линукс
>
> Сеть – сетевой мост.
**5.** Запустить виртуальную машину. Выбрать пункт Install ROSA Desktop, следовать подсказкам системы. Первые впечатления положительные.
### Установка в среде Linux
**Подготовка среды**
**Rosa**
**1.** Установить g++, запустив в терминале команду:
```
urpmi gcc-c++
```
**Alt Linux**
**1.** Установить g++ (через репозитарий или найти последнюю версию):
```
apt-cache search gcc-c++
apt-get install gcc5-c++
```
**2.** Установить perl-Term-ReadLine-Gnu
```
apt-get install perl-Term-ReadLine-Gnu
```
**Установка Berkeley UPC-to-C translator**
**1.** Cкачать [Berkeley UPC-to-C translator](http://upc.lbl.gov/download/source.shtml) и открыть терминал в папке (через контекстное меню).
**2.** Запустить команду make:
```
make
```
> — \*\*\* Build complete! \*\*\*
>
> You may now install the compiler with:
>
> make install PREFIX=/prefix/to/use
**3.** Запусть install с повышенными привилегиями:
```
sudo make install
```
> — \*\*\* Installation complete! \*\*\*
>
> To use this translator LOCALLY, insert the following pathname:
>
> /usr/local/bupc\_translator/targ
>
> in the 'translator' setting of upcc.conf or ~/.upccrc,
>
> or pass it to upcc -translator=path
**Сборка Berkeley UPC**
**1.** Скачать [Berkeley UPC](http://upc.lbl.gov/download/)
**2.** Создать подпапку build, открыть терминал в папке (через контекстное меню)
**3.** Запустить конфигурационный файл с указанием локального транслятора и сети по умолчанию smp (Symmetric Multiprocessing, локальная многоядерная машина):
```
../configure BUPC_TRANS=/usr/local/bupc_translator/targ --with-default-network=smp
```
> SUCCESS! The configure step is now complete. You should now proceed with:
>
> gmake; gmake install
**4.** Скомпилировать UPC:
```
make
```
**Тесты конфигурации UPC (по желанию)**
**0.** Каждая подпапка build содержит конфигурационный файл upcc.conf. При необходимости проверить его и отредактировать
**1.** Запустить тест конфигурации из папки build:
```
env UPCC_FLAGS= ./upcc --norc --version
```
> This is upcc (the Berkeley Unified Parallel C compiler), v. 2.22.3
>
> ----------------------+---------------------------------------------------------
>
> UPC Runtime | v. 2.22.3, built on Oct 26 2016 at 14:01:01
>
> ----------------------+---------------------------------------------------------
>
> UPC-to-C translator | v. 2.22.2, built on Oct 25 2016 at 16:22:01
>
> | host Rosa-VB linux-x86\_64/64
>
> | gcc v4.9.2 20140811 (ROSA)
>
> ----------------------+---------------------------------------------------------
>
> Translator location | /usr/local/bupc\_translator/targ
>
> ----------------------+---------------------------------------------------------
>
> networks supported | udp smp
>
> ----------------------+---------------------------------------------------------
>
> default network | smp
>
> ----------------------+---------------------------------------------------------
>
> pthreads support | available (if used, default is 2 pthreads per process)
>
> ----------------------+---------------------------------------------------------
**2.** Запустить компиляцию теста:
```
make tests-hello
```
> ==== UPC «HELLO WORLD» TESTS SUCCESSFULLY COMPILED ====
>
> Your UPC compilation setup appears to be working for all detected networks: udp smp
>
> You should now test UPC runtime operation for each network of interest.
>
> Start by testing the single-node smp/pthreaded network, with a command like:
>
> ./upcrun -n 2 libupcr-smp-par-test
**3.** Проверить результаты для каждого типа сети:
```
./upcrun -n 2 ./opt/libupcr-smp-par-test
```
> UPCR: UPC threads 0..1 of 2 on Rosa-VB (pshm node 0 of 1, process 0 of 1, pid=12494)
>
> Welcome to Berkeley UPC!!!
>
> — Hello from thread 1
>
> — Hello from thread 0
```
./upcrun -n 2 ./opt/libupcr-udp-par-test
```
> upcrun: nodes not specified! See RUNNING UDP-BASED UPC JOBS in 'man upcrun'
**Установка Berkeley UPC**
**1.** Запустить команду make install из build с повышенными правами. По умолчанию установка производится в каталог /usr/local/berkeley\_upc. Чтобы изменить каталог можно использовать опцию `--prefix=dir`
```
sudo make install
```
**2.** Добавить путь в переменную окружения. Для этого добавить строчку в файл /home/user/.bashrc (автоматический запуск при открытии терминала), либо применить для текущей сессии:
```
export PATH=$PATH:/usr/local/berkeley_upc/bin
```
**3.** Проверить запуск:
```
upcc --version
```
> This is upcc (the Berkeley Unified Parallel C compiler), v. 2.22.3
**Пример**
**1.** Открыть терминал в папке upc-examples.
**2.** Выполнить команды:
```
upcc ./hello.upc -o hello -pthreads
upcrun -n 4 hello
```
> UPCR: UPC threads 0..1 of 4 on Rosa-VB (pshm node 0 of 1, process 0 of 2, pid=13295)
>
> UPCR: UPC threads 2..3 of 4 on Rosa-VB (pshm node 0 of 1, process 1 of 2, pid=13320)
>
> Welcome to Berkeley UPC!!!
>
> — Hello from thread 1
>
> — Hello from thread 3
>
> — Hello from thread 0
>
> — Hello from thread 2
### Среда разработки Eclipse
В среде разработке Eclipse имеется поддержка языка Berkeley UPC. Достаточно распаковать из архива [Eclipse for Parallel Application Developers](https://www.eclipse.org/downloads/packages/eclipse-parallel-application-developers/neonr). Подробнее о проекте Eclipse Parallel Tools Platform (PTP) можно [почитать тут](http://www.eclipse.org/ptp/).
После распаковки необходимо выполнить следующие настройки:
**0.** Установить [Java Runtime Environment](http://www.oracle.com/technetwork/java/javase/downloads/index.html)
**1.** Проверить обновления: Открыть меню Help → Check For Updates. Обновить C/C++ Berkeley UPC (Unified Parallel C) Toolchain Support
**2.** Создать новый проект «Hello World UPC Project», Toolchains: Linux Berkeley UPC (много полезных настроек по умолчанию)
**3.** Указать пути includes: открыть Properties проекта → C/C++ General → Path and Symbols. Для языка UPC добавить include пути:
Конфигурация Release:
```
/usr/local/berkeley_upc/opt/include/upcr_preinclude
/usr/include
```
Конфигурация Debug:
```
/usr/local/berkeley_upc/dbg/include/upcr_preinclude
/usr/include
```
**4.** Отключить проверку орфографии русских комментариев. Правой кнопкой мыши по комментарию, выбрать пункт Disable spell check.
**5.** Добавить быстрые кнопки на русской раскладке. Меню Window — Preferences — General — Editors — Keys. Скопировать пункты «Copy», «Cut», «Paste» и в поле Binding добавить свою комбинацию
### Примечания
**Использование**
Много встроенного мануала:
```
man upcc
man upcrun
```
**Отладка**
UPDATE: [Berkeley Unified Parallel C (UPC). Отладка с помощью GNU gdb C debbuger. Стек вызова](https://habrahabr.ru/post/317196/)
Благодарю за внимание! Надеюсь, кому-нибудь пригодится | https://habr.com/ru/post/315190/ | null | ru | null |
# Запускаем бесплатный мощный сервер Minecraft в облаке
Minecraft — это не просто игра. Его используют в школах для развития детей, для воссоздания архитектурных объектов, улучшения безопасности на реальных улицах. Сегодня Cloud4Y поделится интересным способом запуска бесплатного сервера Minecraft в облаке.
В этой статье я покажу, как настроить и запустить свой собственный частный выделенный сервер Minecraft в облаке. Я [уже писал об этом раньше](https://blogs.oracle.com/developers/how-to-setup-and-run-a-free-minecraft-server-in-the-cloud), но в прошлый раз сервер был всего с одним ядром процессора и 1 ГБ оперативной памяти. Теперь же мы будем создавать сервер с **4** ядрами ЦП и **24** ГБ ОЗУ! Этого более чем достаточно, чтобы 20 человек могли играть с отличной производительностью (при этом ещё остаются ресурсы на создание дополнительного сервера под другие нужды). И, самое главное, всё это удовольствие абсолютно бесплатно.
Почему это круто
----------------
В этом посте я покажу, как можно запустить новую виртуальную машину Oracle, которая использует новый чип на базе Arm. Эти виртуальные машины имеют почти линейное масштабирование рабочих нагрузок, а также лучшее соотношение цены и производительности по сравнению с процессорами на базе x86. Они подходят для широкого спектра рабочих нагрузок, включая веб-приложения, кодирование медиафайлов, инференс ИИ и многое другое. Здорово, что Oracle сотрудничает с разными поставщиками технологий, благодаря чему серверная разработка на Arm стала проще.
Шаг 1: регистрируем вечно бесплатный аккаунт
--------------------------------------------
Если у вас ещё нет учётной записи Oracle Cloud, вам необходимо создать аккаунт «всегда бесплатно». Перейдите на [cloud.oracle.com/free](http://cloud.oracle.com/free) и нажмите «Зарегистрироваться». Если у вас уже есть учётная запись, просто залогиньтесь.
Для регистрации вам нужно будет ввести ваше имя, фамилию и email. Вы получите письмо для подтверждения адреса электронной почты.
После подтверждения почты введите пароль (# 1) и подтвердите его (# 2). Затем выберите имя для своего облачного аккаунта (# 3). Вы наверняка захотите выбрать что-то уникальное и запоминающееся, потому что в дальнейшем будете использовать именно это имя учетной записи для входа в систему. Кроме того, нужно выбрать ближайший к вам домашний регион (# 4). Я живу в Джорджии в Соединенных Штатах, поэтому домашним регионом выбрал «Восточный Эшберн США».
Введите свой домашний адрес и нажмите «Продолжить».
Теперь вам нужно ввести и подтвердить номер мобильного телефона.
Получив проверочный код, введите его на странице регистрации.
Далее нужно ввести номер банковской карты. Это нужно для проверки пользователя. Номер карты будет храниться в Oracle для упрощения перехода на платную учётную запись, если вы в будущем решите это сделать. Не волнуйтесь, с вас 100% не будет взиматься никакая плата, пока вы не решите улучшить аккаунт до платного.
**Ещё раз!**С вас точно никогда не будет взиматься плата за «всегда бесплатную» учётную запись. Если вы хотите перейти на платную учётку, это нужно специально делать вручную!
После того, как вы прошли верификацию по платёжному средству, можно завершать процесс регистрации. Осталось только принять условия и нажать «Start my free trial» (Начать работу с бесплатной пробной версией).
**Потерпите!**Подготовка новой облачной учёной записи займёт всего несколько минут. Когда всё будет готово к работе, вы получите электронное письмо. После этого можно войти в систему и продолжить изучение данного руководства.
Шаг 2: создаём экземпляр виртуальной машины
-------------------------------------------
Первое, что нужно сделать, чтобы ваш сервер Minecraft заработал, – запустить новую «виртуальную машину» (ВМ) в Oracle Cloud. Делается это очень просто, нужно кликнуть «Create a VM instance» (Создать экземпляр виртуальной машины) прямо на главной странице консоли Oracle Cloud.
Дайте своему экземпляру ВМ имя (я назвал свой «minecraft-server») и выберите «compartment» (Отсек). Отсеки — это способ группировать разные вещи. Вы можете оставить отсек, который стоит по умолчанию («root»). Также укажите «домен доступности» — для наших целей подойдёт любой!
Теперь прокрутите вниз до раздела «Image and shape» (Образ и конфигурация). Убедитесь, что выбран «Oracle Linux 7.9», а затем нажмите «Change shape» (Изменить конфигурацию).
В диалоговом окне выберите тип экземпляра для виртуальной машины — «Ampere» (ARM), а в разделе «Shape series» выберите конфигурацию «VM.Standard.A1.Flex». Укажите количество ЦП и ОЗУ, которые хотите получить на своём сервере. Для «всегда бесплатных» серверов ARM можно выделять до 4 OCPU и 24 ГБ оперативной памяти. Это означает, что вы можете сделать одну виртуальную машину с 4 OCPU и 24 ГБ RAM или 4 ВМ с 1 OCPU и 6 ГБ RAM на каждой (либо любую другую комбинацию в указанных пределах). Выбор будет зависеть от того, что у вас будет располагаться на виртуальной машине.
**Совет:** вы можете [проверить требования к серверу для Minecraft,](https://minecraft.fandom.com/wiki/Server/Requirements/Dedicated) чтобы убедиться, что ваш сервер им соответствует.
В нашем случае я выделил 2 OCPU и 6 ГБ RAM. Этого должно быть достаточно для создания надежного сервера, где одновременно могут разместиться более 20 игроков. И у меня всё ещё остаются 2 OCPU и 18 ГБ оперативной памяти на «всегда бесплатном» аккаунте для запуска других виртуальных машин.
После того, как вы выбрали конфигурацию, убедитесь, что видите отметку «Всегда бесплатно».
Далее нужно выбрать виртуальную частную сеть (VCN). Если у вас уже есть существующий VCN с общедоступной подсетью, выберите его. Если нет, нажмите «Create new virtual cloud network» (Создать новую виртуальную частную сеть). Затем выберите «Create new public subnet» (Создать общедоступную подсеть) и оставьте имена по умолчанию. Наконец, убедитесь, что выбран параметр «Assign a public iPv4» (Назначить общедоступный IPv4-адрес). Это важно, так как в противном случае вы не сможете подключиться к этому серверу из интернета!
Теперь нам нужно привязать ключи SSH к этой виртуальной машине. Если вы знакомы с концепцией SSH-ключей и уже имеете открытый ключ, который хотите использовать, выберите «Upload public key files» (Загрузить файлы открытого ключа) и загрузите свой. Если для вас это незнакомая технология, считайте SSH-ключи уникальным набором идентификаторов, которые позволяют безопасно войти на ваш сервер. Нажмите «Generate SSH key pair» (Сгенерировать пару ключей SSH) и сохраните свои закрытый и открытый ключи на локальном компьютере. Мы будем использовать их чуть позже, чтобы войти на виртуальную машину.
Оставьте значения по умолчанию и нажмите «Создать».
Вы сразу же будете перенаправлены на страницу сведений о виртуальной машине. Ваш экземпляр ВМ будет в статусе `PROVISIONING` (предоставляется).
Примерно через 30-60 секунд состояние изменится на `RUNNING` (Запущен). Найдите свой IP-адрес и скопируйте его.
Шаг 3: подключаемся к работающей виртуальной машине в облаке
------------------------------------------------------------
Чтобы установить Minecraft на нашу виртуальную машину, необходимо к ней удаленно подключиться. Если вы не знакомы с технологией SSH, я рекомендую вам для начала разобраться с ней и узнать, как установить (или использовать уже установленный) клиент SSH на ваш компьютер. Процесс может несколько различаться для разных операционных систем. [Вот отличная статья с инструкциями под разные ОС](https://www.howtogeek.com/311287/how-to-connect-to-an-ssh-server-from-windows-macos-or-linux/).
Для подключения к своей виртуальной машине вы будете использовать имя пользователя opc (Oracle Public Cloud). На своём Mac я подключаюсь с помощью следующей команды (обратите внимание, я замазал IP-адрес своего сервера):
Шаг 4: устанавливаем Java
-------------------------
Поскольку сервер Minecraft работает на Java, сначала необходимо установить Java Development Kit (JDK) на виртуальную машину. Вы можете узнать, какая версия JDK доступна для установки, с помощью следующей команды:
```
$ yum list jdk*
```
Вы увидите что-то типа такого:
```
loaded plugins: langpacks, ulninfo
Available Packages
jdk-11.0.11.0.1.aarch64 2000:11.0.11.0.1-ga ol7_oci_included
```
Для установки стоит выбрать самую последнюю версию (версию с наибольшим номером). Скопируйте имя пакета и установите его с помощью:
```
$ sudo yum install jdk-11.0.11.0.1.aarch64
```
После завершения установки вы можете убедится в правильности версии с помощью команды:
```
$ java --version
```
В ответ вы получите что-то вроде:
```
java 11.0.11.0.1 2021-03-31 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.11.0.1+1-LTS-5)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.11.0.1+1-LTS-5, mixed mode)
```
Шаг 5: устанавливаем сервер Minecraft
-------------------------------------
И теперь мы переходим к самой увлекательной части: установке сервера Minecraft! Перейдите на [эту страницу](https://www.minecraft.net/en-us/download/server) (на своём локальном компьютере, а не на виртуальной машине) и скопируйте ссылку на последнюю версию файла .jar для загрузки сервера Minecraft.
```
$ wget https://launcher.mojang.com/v1/objects/1b557e7b033b583cd9f66746b7a9ab1ec1673ced/server.jar
```
А теперь попробуйте запустить сервер с помощью:
```
$ java -Xmx1024M -Xms1024M -jar server.jar nogui
```
О нет, не сработало! Скорее всего вы увидите нечто подобное:
```
[19:30:33] [main/ERROR]: Failed to load properties from file: server.properties
[19:30:33] [main/WARN]: Failed to load eula.txt
[19:30:33] [main/INFO]: You need to agree to the EULA in order to run the server. Go to eula.txt for more info.
```
Внутри каталога с файлом .JAR, появится новый файл. Откройте eula.txt с помощью Nano, чтобы отредактировать его:
```
$ nano eula.txt
```
В файле измените `false` на `true`.
Шаг 6: откроем порты брандмауэра, чтобы разрешить общий доступ
--------------------------------------------------------------
Прежде чем мы попытаемся запустить сервер снова, давайте скорректируем настройки сети, чтобы игроки могли получить доступ к этому серверу через брандмауэр Oracle Cloud. Вернувшись к информации о виртуальной машине, кликните ссылку для созданной (или выбранной вами) подсети.
Выберите Security List по умолчанию.
Нажмите «Добавить правила входа».
Добавьте 2 правила входа: одно для TCP и одно для UDP — каждое с «`Source CIDR`» `0.0.0.0/0` и диапазоном портов назначения `25565`, как показано ниже.
Вам также необходимо открыть эти порты в брандмауэре виртуальной машины, поэтому выполните следующие команды в терминале SSH:
```
sudo firewall-cmd --permanent --zone=public --add-port=25565/tcp
sudo firewall-cmd --permanent --zone=public --add-port=25565/udp
sudo firewall-cmd --reload
```
Шаг 7: запуск сервера
---------------------
```
$ java -Xmx1024M -Xms1024M -jar server.jar nogui
```
Выводы
------
Мы рассмотрели, как создать и запустить собственный бесплатный сервер Minecraft в Oracle Cloud. Но ведь есть масса других интересных проектов, которые вы можете реализовать с помощью своей «всегда бесплатной» учётной записи в облаке!
---
**Что ещё интересного есть в блоге**[**Cloud4Y**](https://www.cloud4y.ru/?utm_source=habr&utm_medium=referral&utm_campaign=article)
→ [Частые ошибки в настройках Nginx, из-за которых веб-сервер становится уязвимым](https://habr.com/ru/company/cloud4y/blog/547164/)
→ [Фишинг с поддельным приглашением на встречу](https://habr.com/ru/company/cloud4y/blog/562780/)
→ [Облачная кухня: готовим данные для мониторинга с помощью vCloud API и скороварки](https://habr.com/ru/company/cloud4y/blog/555722/)
→ [Подготовка шаблона vApp тестовой среды VMware vCenter + ESXi](https://habr.com/ru/company/cloud4y/blog/542000/)
→ [VMware предупредила о критических уязвимостях в удаленном исполнении кода в vCenter](https://habr.com/ru/company/cloud4y/news/t/559332/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу. | https://habr.com/ru/post/563440/ | null | ru | null |
# Библиотеки для декодирования видео. Сравнение на Python и Rust
Многие задаются вопросом — насколько медленный Python в операциях декодирования? Правда ли, что компилируемые языки дают прирост скорости во всем, чего касаются? Что быстрее: OpenCV или ничего? Ответы на эти и другие бесполезные вопросы под катом вы прочитать не сможете. Там обычное скучное исследование производительности в конкретной задаче.
Все заинтересовавшиеся, добро пожаловать!
Основная часть проекта, над которым я работаю, состоит в распознавании людей и их действий на видео в реальном времени. Изначально он был написан на Python+OpenCV. Разумеется, в какой-то момент внезапно потребовалось наращивать масштаб, повышать производительность и всячески оптимизировать. И первым делом я решил осмотреться среди библиотек для работы с видеопотоком. А заодно узнать как сильно язык влияет на производительность этой задачи.
Рассматривал самые популярные (на самом деле, выбор не особо велик):
1. [OpenCV](https://opencv.org/)
2. [FFmpeg](https://ffmpeg.org/)
3. [GStreamer](https://gstreamer.freedesktop.org/)
4. [VLC](https://www.videolan.org/vlc/index.ru.html)
5. [Valkka](https://valkka.readthedocs.io/en/latest/)
VLC и Valkka отпали практически сразу. Первый без вызова графического интерфейса так и не заработал. На второй крайне мало документации и еще меньше библиотек для других языков.
А вот о первых трех я расскажу поподробнее и сравню их производительность на Python.
### OpenCV
#### Плюсы
* Крайне простой интерфейс взаимодействия
* Наличие библиотеки для Python с кучей СV функций
* Отличная производительность
#### Минусы
* Отсутствие возможности нормально управлять процессом получения и декодирования кадров с rtsp-потока. И если для FFmpeg через переменную окружения еще можно задать несколько параметров, то для GStreamer вообще нельзя. Хотя и этот малый набор не спасает никак
* Использование FFmpeg в качестве бэкенда по-умолчанию (подробности в разделе про FFmpeg)
* Из-за упрощённого интерфейса нет возможности получить кадр на промежуточном этапе
После запроса кадра мы сразу получаем готовый numpy.ndarray, да еще и в BGR (к слову операция преобразования в RGB достаточно быстрая). И если для простой программы проблем нет, то для более сложной, когда производительности одного ядра не хватает, начинаются проблемы. А любая попытка распараллелить обработку с помощью библиотеки мультипроцессинга начинает забирать дополнительные ресурсы, так как при передаче между процессами объекты в python должны быть pickable.
Это означает, что библиотека, например, при добавлении в Queue, для передаваемых объектов автоматически выполняет pickle.dumps() и pickle.loads() (к слову в версии Python 3.8 пообещали эту проблему исправить через shared memory). Это довольно накладно для FullHD кадров. В качестве ndarray кадр занимает ~6мб оперативной памяти.
То же происходит и при попытке передать эти данные по сети. Полученный numpy.ndarray нужно преобразовать в bytes перед отправкой, на что тратится довольно значительное количество процессорного времени.
### FFmpeg
#### Плюсы
* Самое быстрое декодирование из тройки
* Возможность управлять процессом получения и декодирования
* Большое количество документации
#### Минусы
* Проблема упомянутая в разделе OpenCV — отвратительное качество работы с нестабильным rtsp-потоком: большое количество битых кадров при перегрузке как источника, так и получателя. Для нейросетей это критично, потому что понять, что кадр битый не так-то просто, а обученная нейросеть в этом шуме может увидеть что-нибудь с вероятностью сильно отличной от нуля
* Еще один немаловажный фактор — отсутствие нативной библиотеки для работы с Python. На выбор всего два варианта: либо получать байты через linux pipe, либо писать их в zram хранилище и читать. В общем, оба варианта так себе
### GStreamer
#### Плюсы
* Хорошие библиотеки для [Python](https://gitlab.freedesktop.org/gstreamer/gst-python) и [Rust](https://gitlab.freedesktop.org/gstreamer/gstreamer-rs)
* Богатый набор элементов для построения конвейера декодирования. Можно декодированный кадр разветвлять на несколько конвейеров и обрабатывать по-разному
* Отлично работает с rtsp, умеет изменять входную задержку (что очень важно для систем реагирования в реальном времени), сбрасывать битые кадры
#### Минусы
* Плохое качество документации
* По разным бенчмаркам медленнее, чем FFmpeg примерно на 5-10%
Примеры кода и производительность
---------------------------------
Вначале разберем примеры реализации для каждого варианта. Из-за особенностей обработки, описанных выше, тестирование буду проводить в нескольких вариантах:
1. Просто получение кадра
2. Получение кадра с конвертацией в RGB и GRAY8 (в некоторых задачах для ML достаточно и серого кадра, а данных в нем в 3 раза меньше)
3. Получение кадра, конвертация и сериализация/десериализация через pickle
Для OpenCV объяснения вряд ли требуются. Статей о начале работы с этой библиотекой — полный хабр.
```
import pickle
import cv2
source = 'Tractor_500kbps_x264.mp4'
cap = cv2.VideoCapture(source)
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
pickle.loads(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).dumps())
cap.release()
```
Для FFmpeg есть несколько библиотек для Python ([ffmpeg-python](https://github.com/kkroening/ffmpeg-python), [scikit-video](http://www.scikit-video.org/stable/), [ffmpy](https://ffmpy.readthedocs.io/en/latest/), [ffmpeg](https://github.com/jiashaokun/ffmpeg)). Лучшая, на мой взгляд, [ffmpeg-python](https://github.com/kkroening/ffmpeg-python): хорошая документация, удобный синтаксис запросов. Но все эти библиотеки — только обертка поверх консольного вызова через subprocess.Popen и последующей передачей данных через linux pipe в stdout, а код на Python уже слушает stdout и превращает данные в numpy ndarray.
Выглядит это примерно следующим образом:
```
from subprocess import Popen, PIPE, DEVNULL
import numpy as np
import cv2
source = 'Tractor_500kbps_x264.mp4'
width, height = (1920, 1080)
stream_url = f'ffmpeg -vcodec h264 -i {source} -f rawvideo -pix_fmt yuv420p pipe:'.split(' ')
with Popen(stream_url, stdout=PIPE, stderr=DEVNULL) as p:
while p.stdout.readable():
yuv_height = int(height+height//2)
raw_frame = p.stdout.read(yuv_height * width)
if len(raw_frame) == yuv_height * width:
frame = np.frombuffer(raw_frame, np.uint8).reshape((yuv_height, width))
cv2.cvtColor(frame, cv2.COLOR_YUV2RGB_I420)
else:
break
p.stdout.flush()
```
В приведенном выше коде есть несколько интересных моментов. Например, чтобы прочитать bytearray нужно знать разрешение кадра. Можно, конечно, воспользоваться ffprobe и так же, запустив его в отдельном субпроцессе, получить эти данные перед началом обработки. Но это крайне неудобно, и время запуска удваивается, т. к. ffprobe должен подключиться к rtsp-потоку и взять один кадр.
Второй момент — это цветовое пространство. По умолчанию все видео файлы и видеопотоки используют подмножество YUV, чаще это [I420](https://fourcc.org/pixel-format/yuv-i420/) (YUV420p), кадр которого состоит из полного кадра яркости и двух цветоразностных полукадров. А модели свёрточных нейросетей чаще всего обучены на RGB.
Кстати, декодирование кадра на GPU (например на [NVDEC](https://developer.nvidia.com/nvidia-video-codec-sdk)) преобразует кадр в цветовое пространство NV12 которое тоже является подмножеством YUV. В случае с ffmpeg мы можем задать преобразование через него или использовать функции OpenCV. Разницу будет видно в тестах производительности.
C GStreamer все несколько больше кода, но, в целом, не сложнее.
**Большой кусок кода для GStreamer**
```
import numpy as np
import cv2
import gi
gi.require_version('Gst', '1.0')
gi.require_version('GLib', '2.0')
gi.require_version('GObject', '2.0')
from gi.repository import GLib, Gst
def bus_call(bus, message, loop, pipe):
t = message.type
if t == Gst.MessageType.EOS:
pipe.set_state(Gst.State.NULL)
loop.quit()
elif t == Gst.MessageType.ERROR:
err, debug = message.parse_error()
print(f'{err}: {debug}')
pipe.set_state(Gst.State.NULL)
loop.quit()
return Gst.FlowReturn.OK
def yuv_rgb(appsink):
sample = appsink.emit("pull-sample")
buf = sample.get_buffer()
caps = sample.get_caps()
height = caps.get_structure(0).get_value('height')
width = caps.get_structure(0).get_value('width')
stream_format = caps.get_structure(0).get_value('format')
data = buf.extract_dup(0, buf.get_size())
if data:
frame = np.frombuffer(data, np.uint8).reshape((height+height//2, width))
cv2.cvtColor(frame, cv2.COLOR_YUV2RGB_I420)
return Gst.FlowReturn.OK
def pipe_init(source, on_new_sample, pix_format):
Gst.init(None)
pipe = Gst.Pipeline.new('dynamic')
src = Gst.ElementFactory.make('filesrc')
demux = Gst.ElementFactory.make('qtdemux')
parse = Gst.ElementFactory.make('h264parse')
decode = Gst.ElementFactory.make('avdec_h264')
convert = Gst.ElementFactory.make('videoconvert')
sink = Gst.ElementFactory.make('appsink')
for item in (src, demux, parse, decode, convert, sink):
pipe.add(item)
src.link(demux)
demux.connect('pad-added', lambda element, pad: element.link(parse))
parse.link(decode)
decode.link(convert)
convert.link(sink)
src.set_property('location', source)
sink.set_property("emit-signals", True)
sink.set_property("max-buffers", 1)
caps = Gst.caps_from_string(f"video/x-raw, format=(string){pix_format}")
sink.set_property("caps", caps)
sink.set_property("drop", True)
sink.set_property("wait-on-eos", True)
sink.set_property('sync', False)
sink.connect("new-sample", on_new_sample)
return pipe
def run(source, sink_callback, pix_format):
loop = GLib.MainLoop()
pipe = pipe_init(source, sink_callback, pix_format)
bus = pipe.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect('message', bus_call, loop, pipe)
pipe.set_state(Gst.State.PLAYING)
loop.run()
run('Tractor_500kbps_x264.mp4', yuv_rgb, 'I420')
```
У GStreamer отличие в специальном элементе appsink, который вызывает callback-функцию и передает в нее полученный кадр.
### Что же с производительностью?
Все варианты тестирования производились на Intel Core i5-6600K, по 10 итераций. Для Python использовалась библиотека timeit. В качестве тестового видео взял стандартное [Tractor\_500kbps\_x264.mp4](https://s3.amazonaws.com/x265.org/video/Tractor_500kbps_x264.mp4).
Параметры сравнения:
* pure — это кадр без конвертации
* gray8 — конвертация из BGR в GRAY8 средствами OpenCV
* rgb — конвертация из BGR в RGB средствами OpenCV
* yuv\_gray — яркостная часть кадра от I420
* yuv\_gray8 — конвертация из YUV420p в GRAY8 средствами OpenCV
* yuv\_rgb — конвертация из YUV420p в RGB средствами OpenCV
* native\_gray — конвертация из YUV420p в GRAY8 средствами библиотеки
* native\_rgb — конвертация из YUV420p в RGB средствами библиотеки
#### Native
У FFmpeg и GStreamer есть возможность проверить производительность обработки, сбрасывая кадры в /dev/null. Эти цифры мы будем считать за базовые.
```
ffmpeg -vcodec h264 -i Tractor_500kbps_x264.mp4 -f null /dev/null
frame= 252 fps=0.0 q=-0.0 Lsize=N/A time=00:00:10.28 bitrate=N/A speed=24.6x
gst-launch-1.0 filesrc location="Tractor_500kbps_x264.mp4" ! qtdemux ! h264parse ! avdec_h264 ! videoconvert ! fakesink
Execution ended after 0:00:00.551382068
```
#### OpenCV
Здесь опций мало. Мы можем замерить только получение кадра и конвертацию в два цветовых пространства с эмуляцией через pickle передачи по сети или в соседний процесс. Как видно, на больших объемах данных pickle полностью убивает производительность.
| Формат | Всего времени | Времени на итерацию | Кадров в секунду |
| --- | --- | --- | --- |
| pure | 8.7099с | 0.8710с | 289.3268 fps |
| gray8 | 20.3162с | 2.0316с | 124.0389 fps |
| rgb | 74.3420с | 7.4342с | 33.8974 fps |
#### FFmpeg
Здесь опций уже больше. Потому что появляется возможность использовать встроенный преобразователь цветового пространства или использовать встроенный в OpenCV. Также отпадает необходимость сериализовывать кадр через pickle при отправке по сети или в соседний процесс.
| Формат | Всего времени | Времени на итерацию | Кадров в секунду |
| --- | --- | --- | --- |
| pure | 8.3283с | 0.8328с | 302.5810 fps |
| yuv\_gray | 7.3772с | 0.7377с | 341.5925 fps |
| yuv\_gray8 | 8.2721с | 0.8272с | 304.6402 fps |
| yuv\_rgb | 9.3969с | 0.9397с | 268.1733 fps |
| native\_gray | 10.7005с | 1.0700с | 235.5041 fps |
| native\_rgb | 13.7820с | 1.3782с | 182.8466 fps |
Как видно, собственная функция преобразования цветового пространства работает помедленнее, чем в OpenCV. yuv\_gray — это яркостная составляющая I420 кадра, а цветоразностную схему просто выбрасываем.
#### GStreamer
Те же самые возможности, что и FFmpeg, только с возможностью большего контроля над процессом.
| Формат | Всего времени | Времени на итерацию | Кадров в секунду |
| --- | --- | --- | --- |
| pure | 7.1359с | 0.7136с | 353.1457 fps |
| yuv\_gray | 6.8841с | 0.6884с | 366.0609 fps |
| yuv\_gray8 | 7.3328с | 0.7333с | 343.6599 fps |
| yuv\_rgb | 8.9191с | 0.8919с | 282.5403 fps |
| native\_gray | 20.2932с | 2.3832с | 105.7409 fps |
| native\_rgb | 23.8318с | 2.0293с | 124.1793 fps |
Преобразование цветового пространства еще медленнее, чем в FFmpeg. Остальные форматы чуть быстрее из-за нормального способа передачи кадра.
При обработке через Python теряется примерно 30% производительности относительно тестового случая. Однако, как видно будет дальше, GStreamer, на самом деле, сильно оптимизирует вывод, чем выигрывает больше скорости, и реальная цифра находится в пределах от 10% до 20%. Также в начале мне показалось странным, что преобразование в RGB быстрее, чем в GRAY8. Но это подтверждается тестированием без python:
```
gst-launch-1.0 filesrc location="Tractor_500kbps_x264.mp4" ! qtdemux ! h264parse ! avdec_h264 ! videoconvert ! "video/x-raw, format=(string)GRAY8" ! fakesink
Execution ended after 0:00:02.229323128
gst-launch-1.0 filesrc location="Tractor_500kbps_x264.mp4" ! qtdemux ! h264parse ! avdec_h264 ! videoconvert ! "video/x-raw, format=(string)RGB" ! fakesink
Execution ended after 0:00:01.150704119
```
Казалось бы, возможно, это Python слишком медленный, и можно использовать какой-нибудь компилируемый язык, чтобы выжать еще немножко скорости. В качестве нового модного и молодежного языка будет Rust.
#### OpenCV
```
extern crate opencv;
use opencv::{core, videoio, imgproc};
fn main() -> opencv::Result<()> {
let filename = "Tractor_500kbps_x264.mp4";
let mut cam = videoio::VideoCapture::new_from_file_with_backend(filename, videoio::CAP_ANY)?;
let opened = videoio::VideoCapture::is_opened(&cam)?;
if !opened { panic!("Unable to open default camera!") };
let mut frame = core::Mat::default()?;
let mut gray = core::Mat::default()?;
loop {
cam.read(&mut frame)?;
if frame.size()?.width > 0 {
imgproc::cvt_color(&frame, &mut gray, imgproc::COLOR_BGR2RGB, 0)?;
}
else {
break
}
}
}
```
#### GStreamer
**Большой кусок кода для GStreamer на Rust**
```
extern crate opencv;
use crate::opencv::prelude::Vector;
use std::time::SystemTime;
use opencv::{core, videoio, imgproc};
use opencv::types::{VectorOfint};
extern crate gstreamer as gst;
extern crate gstreamer_app as gst_app;
extern crate failure;
extern crate glib;
use failure::Error;
use gst::prelude::*;
#[macro_use]
extern crate failure_derive;
#[derive(Debug, Fail)]
#[fail(display = "Missing element {}", _0)]
struct MissingElement(&'static str);
struct Camera {
pipe: gst::Pipeline,
main_loop: glib::MainLoop,
}
impl Camera {
fn new(location: &str) -> Camera {
Camera {
pipe: Camera::create_pipeline(location).unwrap(),
main_loop: glib::MainLoop::new(None, false),
}
}
fn run(&self) -> Result<(), Error> {
self.create_bus()?;
self.pipe.set_state(gst::State::Playing)?;
self.main_loop.run();
Ok(())
}
fn create_bus(&self) -> Result<(), Error>{
let bus = self.pipe.get_bus().expect("Pipeline without bus. Shouldn't happen!");
let ml = self.main_loop.clone();
let pipe = self.pipe.clone();
bus.add_watch(move |_: &gst::Bus, msg: &gst::Message| {
use gst::MessageView;
match msg.view() {
MessageView::Eos(..) => {
pipe.set_state(gst::State::Null).unwrap();
ml.quit();
},
MessageView::Error(err) => {
println!(
"Error from {:?}: {} ({:?})",
err.get_src().map(|s| s.get_path_string()),
err.get_error(),
err.get_debug()
);
pipe.set_state(gst::State::Null).unwrap();
ml.quit();
}
_ => (),
};
glib::Continue(true)
});
Ok(())
}
fn create_pipeline(location: &str) -> Result {
gst::init()?;
let src = gst::ElementFactory::make("filesrc", Some("src"))
.ok\_or(MissingElement("cant create filesource"))?;
let demux = gst::ElementFactory::make("qtdemux", Some("demux"))
.ok\_or(MissingElement("cant create demux"))?;
let parse = gst::ElementFactory::make("h264parse", Some("parse"))
.ok\_or(MissingElement("cant create parse"))?;
let decode = gst::ElementFactory::make("avdec\_h264", Some("decode"))
.ok\_or(MissingElement("cant create decodebin"))?;
let convert = gst::ElementFactory::make("videoconvert", Some("convert"))
.ok\_or(MissingElement("cant create convert"))?;
let sink = gst::ElementFactory::make("appsink", Some("appsink"))
.ok\_or(MissingElement("cant create appsink"))?;
src.set\_property("location", &location)?;
let pipeline = gst::Pipeline::new(None);
pipeline.add\_many(&[&src, &demux, &parse, &decode, &convert, &sink])?;
src.link(&demux)?;
parse.link(&decode)?;
decode.link(&convert)?;
convert.link(&sink)?;
let sink\_pad = parse.get\_static\_pad("sink").unwrap();
demux.connect\_pad\_added(move |\_dbin, src\_pad| {
src\_pad.link(&sink\_pad).expect("Not linked");
});
let appsink = sink.dynamic\_cast::()
.expect("Sink element is expected to be an appsink!");
appsink.set\_emit\_signals(true);
appsink.set\_max\_buffers(1);
appsink.set\_drop(true);
appsink.set\_wait\_on\_eos(false);
appsink.set\_property("sync", &false)?;
appsink.set\_callbacks(
gst\_app::AppSinkCallbacks::new()
.new\_sample(move |appsink: &gst\_app::AppSink| {
let sample = appsink.pull\_sample().ok\_or(gst::FlowError::Eos)?;
let buffer = sample.get\_buffer().ok\_or\_else(||gst::FlowError::Error)?;
let map = buffer.map\_readable().ok\_or\_else(||gst::FlowError::Error)?;
let samples = map.as\_slice();
let dims = VectorOfint::from\_iter(vec![1080+1080/2, 1920]);
let frame = core::Mat::from\_slice(samples).unwrap().reshape\_nd(1, &dims).unwrap();
let mut rgb = core::Mat::default().unwrap();
imgproc::cvt\_color(&frame, &mut rgb, imgproc::COLOR\_YUV2RGB\_I420, 3).unwrap();
Ok(gst::FlowSuccess::Ok)
})
.build()
);
Ok(pipeline)
}
}
fn main() {
let filename = "Tractor\_500kbps\_x264.mp4";
let camera = Camera::new(filename);
camera.run().expect("Loop stopped");
}
```
| Библиотека | Результат | Всего времени | Времени на итерацию | Кадров в секунду |
| --- | --- | --- | --- | --- |
| OpenCV | pure | 8.733с | 0.8733с | 288.5606 fps |
| OpenCV | rgb | 10.5890с | 1.0589с | 237.9828 fps |
| GStreamer | pure | 5.487с | 0.5487с | 459.2673 fps |
| GStreamer | yuv\_rgb | 7.8290с | 0.7829с | 321.8802 fps |
В случае с OpenCV прироста вообще не получилось. А вот GStreamer дает ~15% прироста производительности. Причем основная производительность опять же теряется на конвертации цветового пространства через OpenCV. Основное предположение, что в случае с Python используется библиотека opencv-python из pypi, в составе которой поставляется OpenCV, собранный с оптимизациями. Здесь же используется системный, из репозиториев Arch Linux.
В итоге получается, что комбинация декодирования через GStreamer и конвертации цветого пространства через OpenCV позволяет добиться хорошей производительности и гибкости при написании параллельного или распределённого по сети кода.
Код всех тестов можно посмотреть [здесь](https://gitlab.com/menstenebris/video_pipeline). | https://habr.com/ru/post/467537/ | null | ru | null |
# Туннели I2P: Чесночное шифрование и однонаправленная передача информации
Анонимность участников сети I2P достигается путем использования туннелей. Важная особенность I2P заключается в том, что длину туннеля, его начало и конец знает только тот, кто его создал.
Каждый узел сети имеет свои входящие и исходящие туннели, при этом по умолчанию он также выступает в роли транзитного узла в цепочках других участников. Туннели I2P являются однонаправленными - по каждому туннелю трафик идет только в одну сторону. В анонимной сети пользователь не имеет прямого доступа к абоненту на другой стороне, в распоряжении лишь информация о начальном узле в его *входящем* туннеле. Обращение к входящему туннелю другого участника сети происходит через анонимизирующую цепочку со своей стороны - через *исходящий* туннель. После установления контакта, адресату сообщается для ответа информация о входящем туннеле обратившегося к нему участника сети. О том, как узлы находят входящие туннели друг друга для первого обращения, читайте в [статье про флудфилы](https://habr.com/ru/post/563958/).
Цепочки из нескольких узлов - это, если не самая основная, то одна из важнейших логических частей I2P. В рамках данной статьи растолкуем принцип их построения и умозрительно докажем, что уровню анонимности в I2P можно доверять.
Транспорты
----------
Ходовые низкоуровневые сетевые протоколы на сегодняшний день это TCP и UDP. Они обеспечивают логику доставки информации между абонентами, но абсолютно никак не отвечают за приватность этой информации - ее может перехватить по пути следования любой желающий. Ввиду этого для более высокоуровневых протоколов прикладных программ возникает необходимость в шифровании информации.
В работе I2P используются транспортные протоколы [NTCP2](https://geti2p.net/spec/ntcp2) - аналог TCP, и [SSU](https://geti2p.net/spec/ssu) - аналог UDP. По сути дела, эти протоколы являются криптографическими обертками своих старших братьев. Информация в рамках "невидимого интернета" передается по этим протоколам, что позволяет скрыть всю передаваемую информацию от домашнего провайдера.
NTCP2 и SSU не просто шифруют информацию, но еще и примешивают случайное количество лишних байт. "Мусор" не оставляет шанса системам анализа трафика, так как размер пакетов является случайным и фактически ни о чем не говорит. После расшифровки пакета в пункте назначения холостые байты просто откидываются.
NTCP2 и SSU являются инструментами для безопасного соединения peer-to-peer - прямой связи с другими роутерами сети. В начале этого материала сказано, что анонимность внутри I2P достигается за счет туннелей, состоящих из нескольких промежуточных узлов. Ввиду этого не будем останавливаться на том, как узлы общаются между собой напрямую, а пойдем ближе к теме анонимизирующих туннелей. Подробно о транспортном протоколе NTCP2 на русском языке читайте [тут](https://habr.com/ru/post/416785/).
Что есть туннель
----------------
I2P-роутеры, то есть все узлы сети, общаются между собой по протоколу I2NP. Фактический перечень типов сообщений I2NP можно увидеть в [исходном коде](https://github.com/PurpleI2P/i2pd/blob/openssl/libi2pd/I2NPProtocol.h#L123-L140), либо обратиться к [официальной документации](https://geti2p.net/spec/i2np) за детальным объяснением.
По сути дела, I2NP содержит исчерпывающий набор типов возможных сообщений, необходимых для общения I2P-роутеров между собой. Обратите внимание на типы, имена которых содержат слово `Tunnel`. Именно они интересны нам в рамках этой статьи. Вся пользовательская информация передается внутри туннелей в виде зашифрованных блоков от роутера к роутеру, благодаря чему изначальный источник информации теряется, а ее настоящий получатель остается неизвестным, так как неизвестно на каком из транзитных роутеров туннель прерывается.
К логике туннелей предъявляется два основных требования: анонимность создателя туннеля перед его участниками, а также совместимость транзитных узлов цепочки по транспортам. Кратко про построение туннелей сказано в большой [статье](https://habr.com/ru/post/552072/#tunnels) про I2P, однако сейчас мы углубимся в недра этого сложного механизма и еще раз убедимся в том, что уровень анонимности в I2P является беспрецедентным в своем роде.
Аналогия архитектуры I2P с обычной сетью
----------------------------------------
Чтобы дальнейший рассказ не казался сухой спецификацией, которую невозможно понять даже после двух прочтений, немного упростим изначальное понимание сетевой архитектуры I2P, сравнив ее с привычной сетью.
На иллюстрации принципиально схожие уровни обычной сети TCP/IP и сети I2P находятся напротив друг друга - на одной строкеВаше устройство подключается к интернету через маршрутизатор (роутер). Это может быть домашний роутер с подключением через провод или Wi-Fi, либо роутер сотового оператора с подключением через сети 3G/4G/5G. Суть от этого не меняется. Перед тем, как установить логическое IP-соединение с роутером, устройство обменивается служебной информацией на низком уровне - на иллюстрации он обозначен, как "Ethernet-фреймы" (упрощенно). После установки логической связи по протоколу IP с роутером, вы можете обращаться через него к компьютерам по всему миру. Когда вы открываете сайт, сервер которого находится в соседнем городе, ваш трафик проходит через множество транзитных узлов интернет-провайдеров, при этом у вас остается прямое сообщение только с изначальным маршрутизатором. Все промежуточные узлы работают с вами на уровне IP-соединений - передают некие пакеты информации из точки А в точку Б. Каждый логический агрегат по пути следования вашего трафика строит IP-соединение со своими соседями также на более низком уровне, как вы и ваш домашний роутер. Получается, что множество компьютеров и роутеров по всему миру устанавливают низкоуровневую связь со своими физическими соседями через провода (или другие среды передачи информации) и, основываясь на этой связи, объединяются в IP-сети, где царствует привычная глазу маршрутизация с IPv4 или IPv6 адресами. Самый высокий уровень связи TCP/IP обозначен на иллюстрации, как "прикладной". Это вершина пирамиды - пользовательский трафик, например, запрос браузера на сайт по протоколу HTTPS. Более низкие уровни ничего не знают про ваш сайт и браузер, они просто работают на то, чтобы передать некую бинарную информацию в пункт назначения, где она будет прочитана в изначальном виде и обработана.
I2P работает поверх TCP/IP, но имеет свою дополнительную структуру, которая отчасти повторяет обычную сеть, но с сильным уклоном в приватность и анонимность. I2P-роутер - программный клиент на вашем устройстве, который обеспечивает всю внутреннюю логику сети. Сообщения I2NP являются базовым инструментом общения I2P-роутеров между собой. Туннели являются аналогом IP-соединений, которые обеспечивают прямое взаимодействие с другими роутерами и через них взаимодействие с узлами, прямой контакт с которыми отсутствует. Высший уровень на иллюстрации - "чесночное сообщение" - это пользовательская информация, доставляемая по туннелям, но имеющая смысл только для конечного получателя, который может ее расшифровать.
Сообщения скрытой сети проходят через обычный интернет, но их содержимое может быть осмыслено только на уровне выше, для выхода на который нужен I2P-роутер. Это свойство называется оверлейностью. Если вдаваться в формализм, термин "глубинный интернет" в отношении I2P и других скрытых сетей должен звучать противоположно, например, "интернет высокого уровня".
Чесночное сообщение, образующее туннель
---------------------------------------
Каждый I2P-роутер публикует информацию о себе на флудфилах - справочных узлах сети. Полный адрес роутера называется "Router Info", или просто "RI". Помимо информации о непосредственной доступности (IP-адресы и адреса [интродьюсеров](https://habr.com/ru/post/564772/)), а также некоторой служебной информации, RI содержит публичный ключ шифрования роутера.
Локальная база сети I2P-роутера полностью состоит из файлов RI других участников сети. Когда роутеру необходимо обзавестись туннелем, первым делом выбираются его будущие участники. Поиск кандидатов происходит в локальной базе сети (netDb). Учитываются заявленная пропускная способность роутера, транспортная совместимость с соседями, а также данные из профиля, если он имеется. Под профилированием подразумевается локальная хроника роутера о взаимодействии с конкретным участником сети и оценка его стабильности - нестабильный роутер не будет использован при построении туннеля.
Когда кандидаты выбраны, создается чесночное сообщение. Если строится туннель не длиннее четырех хопов (прыжков), чеснок всегда содержит четыре зубчика, то есть четыре сообщения. В противном случае чеснок состоит из восьми сообщений (по количеству максимально возможной длины туннеля). По умолчанию туннели имеют длину в три транзитных узла.
Принцип чесночного сообщения заключается в том, что каждый участник туннеля получает полный набор сообщений (чеснок), но может прочитать только один зубчик, предназначенный ему. Затем чесночное сообщение целиком передается дальше согласно полученных в зубчике инструкций. Зубчики опознаются получателями по первым 16 байтам, которые являются началом хеша от их ключа шифрования. После прочтения чесночного сообщения, участник заменяет содержимое зубчика на свой ответ. Чтобы информация осталась в тайне, она шифруется симметричным ключом.
Занимательнейший нюанс заключается в том, что конкретный узел может увидеть лишь свой зубчик в чесноке. Это не позволяет строить догадки о других участниках туннеля по хешам их ключей. Прием обеспечивается дополнительным симметричным шифрованием всего чеснока. Возможно, когда-нибудь об этом будет отдельная заметка, но вот исходный код для самых смелых:
libi2pd/Tunnel.cpp
```
hop = m_Config->GetLastHop ()->prev;
while (hop)
{
// decrypt records after current hop
TunnelHopConfig * hop1 = hop->next;
while (hop1)
{
hop->DecryptRecord (records, hop1->recordIndex);
hop1 = hop1->next;
}
hop = hop->prev;
}
```
```
while (hop)
{
// decrypt current hop
if (hop->recordIndex >= 0 && hop->recordIndex < msg[0])
{
if (!hop->DecryptBuildResponseRecord (msg + 1))
return false;
}
else
{
LogPrint (eLogWarning, "Tunnel: hop index ", hop->recordIndex, " is out of range");
return false;
}
// decrypt records before current hop
TunnelHopConfig * hop1 = hop->prev;
while (hop1)
{
auto idx = hop1->recordIndex;
if (idx >= 0 && idx < msg[0])
hop->DecryptRecord (msg + 1, idx);
else
LogPrint (eLogWarning, "Tunnel: hop index ", idx, " is out of range");
hop1 = hop1->prev;
}
hop = hop->prev;
}
```
На сегодняшний день чесночные сообщения бывают трех типов и имеют соответствующие отличия:
* Старый. Используется, когда все транзитные роутеры в туннеле используют шифрование El Gamal. Каждое сообщение составляет 528 байт и содержит ключи AES: одноразовый - для шифрования ответа, вектор инициализации (IV), ключ шифрования IV и основной ключ, используемый в течение жизни туннеля для луковичного (многослойного симметричного) шифрования.
* Переходный. Используется, когда среди транзитных роутеров есть узлы как со старым шифрованием El Gamal, так и новые с [ECIES](https://habr.com/ru/post/504610/). Каждое сообщение составляет 528 байт, но для ECIES-узлов используется другое шифрование для ответа: ключ симметричного шифрования в непосредственном виде не передается, а вычисляется по протоколу [Noise](http://noiseprotocol.org/) (Noise\_N).
* Новый - "чеснок с короткими сообщениями". Используется, когда все транзитные роутеры используют шифрование ECIES и имеют версию не ниже 2.39.0, если речь про i2pd, или 1.5.0 для Java-роутера. Каждое сообщение составляет 218 байт. Зубчики не содержат вышеупомянутые ключи, потому что в данном случае все они являются вычисляемыми. AES используется только в качестве основного ключа шифрования для туннеля, в остальном используются алгоритмы AEAD/Chaha20/Poly1305 и ChaCha20. Подробнее о коротких чесночных сообщениях читайте в [спецификации](https://geti2p.net/spec/proposals/157-new-tbm).
Уникальность нового типа чесночных сообщений заключается в его размере - стандартный чеснок из четырех зубчиков умещается в один килобайт. На момент публикации статьи все туннельные сообщения сети I2P разделяются на фрагменты по одному килобайту. Это стандартный размер, который является элементом борьбы с анализом трафика.
Чеснок минимального размера с зубчиками по 528 байт требует отправки трех туннельных сообщений. Несмотря на обфускацию трафика, гипотетически можно выявить закономерность: три килобайтовых сообщения - это стандартный чеснок. Если видим характерное движение трафика, значит, наблюдаемый пользователь строит туннель, либо является транзитным звеном в туннеле другого пользователя. На практике эта угроза из разряда фантастики, потому что туннели живут всего по десять минут, а активные узлы постоянно участвую более, чем в двух тысячах транзитных туннелей. Можно представить сколько чесноков на подобном роутере пролетает лишь в течение минуты...
При использовании коротких сообщений, весь чеснок умещается в одно туннельное сообщение, поэтому новый чеснок абсолютно сливается с остальным потоком информации. Теряется последняя надежда шпиона на анализ трафика на предмет трех килобайтовых сообщений подряд. Но не всё о паранойе, дамы и господа! Одно туннельное сообщение вместо трех - это фактор увеличения скорости построения туннеля: меньше пакетов идет - меньше вероятность того, что какой-то из них может потеряться, да и передается меньший объем информации быстрее.
Исходящие и входящие туннели строятся схожим образом:
* При построении *входящего* туннеля, чтобы остаться инкогнито, роутер-создатель передает чеснок первому участнику через свой исходящий туннель. Затем чеснок передается от узла к узлу и приходит обратно к создателю туннеля. Для последнего участника цепочки создатель не отличается от очередного транзитного узла.
* При построении *исходящего* туннеля картина обратная: роутер-создатель передает чеснок напрямую ближайшему по цепочке роутеру, который не может знать является ли роутер, передавший чеснок, хозяином чеснока, или таким же транзитным узлом. Зубчик последнего транзитного узла содержит информацию для отправки чеснока обратно создателю. Пройдя всю цепочку, чеснок возвращается создателю через один из входящих туннелей.
При старте I2P-роутер не имеет настоящих туннелей, только два туннеля нулевой длины. При создании первых полноценных туннелей необходимые обращения происходят не через анонимизирующие цепочки узлов, а напрямую - через туннель нулевой длины. В силу того, что это редкое событие и обращение через туннель нулевой длины неотличим от нормального, эта особенность не считается слабым местом архитектуры I2P.
Туннели в практическом контексте сети
-------------------------------------
Зубчики чеснока помимо ключей шифрования содержат информацию о номерах туннелей (каждый - 4 байта). Один номер - это номер туннеля, на который роутер будет принимать сообщения, а второй номер - это номер туннеля на следующем транзитном узле, адрес которого прилагается, куда текущий транзитный роутер будет передавать поступающую информацию.
Чесночные сообщения содержат лишь краткие адреса роутеров, которым нужно дальше по цепочке передать чеснок. Адрес роутера является хешем SHA256 от его полного Router Info. Если нужного роутера нет в локальной базе, транзитному узлу необходимо обратиться к флудфилу, чтобы получить его полный адрес (RI). При составлении чеснока, создателем туннеля учитывается транспортная совместимость соседей между собой, что снижает вероятность неудачной попытки построения туннеля. Например, глупо просить роутер без IPv6-адреса связаться с участником сети, у которого есть только IPv6.
Туннель считается неудавшимся, если ответ долго не приходит, либо чеснок вернулся, но кто-то из опрошенных роутеров в свой ответ заложил отказ от участия (это может быть связано с лимитом на количество транзитных туннелей и прочим).
Когда туннель создан, его жизненный цикл ограничивается десятью минутами. После этого времени все транзитные узлы перестают принимать пакеты в рамках старого туннеля, а его создателю к этому времени необходимо иметь уже новый туннель - он создается незадолго до "протухания" старого. После обновления входящих туннелей, если речь идет о серверной конечной точке, которая ждет обращения от других участников сети, также обновляется ее лизсет - контактная информация на флудфилах, которая включает в себя сведения о входящих туннелях.
Как таковое чесночное шифрование используется в I2P только при создании туннелей. В рабочем режиме в туннеле используется только луковичное шифрование (плюс сквозное шифрование от пользователя до пользователя).
Луковичное шифрование - это термин, означающий многослойное шифрование симметричным ключом. Если кто-то забыл или не знает: при симметричном шифровании шифрование и расшифровка осуществляются одним ключом, в отличие от асимметричных алгоритмов, где шифрование происходит публичным ключом, а расшифровка - приватным. Асимметричное шифрование применяется при сквозном шифровании.
Все туннели являются однонаправленными, при этом транзитные узлы не знают ничего: является ли туннель входящим или исходящим, сколько в нем участников и так далее. Их задача заключается в шифровании проходящей информации полученным (или выведенным математически) симметричным ключом и передача получившегося пакета следующему узлу.
Особые роли принимают лишь конечные узлы в туннелях: для *исходящего* туннеля последний узел является Endpoint, а первый узел во *входящем* туннеле - Gateway. В отличие от обычных "серединных" узлов, эти двое знают о своем месте в цепочке благодаря специальным флагам, которые они получают в чесноке. Задача Endpoint заключается в сборе килобайтных туннельных сообщений в более весомый пакет (до 64 килобайт) и его передача дальше согласно инструкций (во входящий туннель, напрямую другому роутеру, либо локальная обработка информации). Задача Gateway обратная: разбивать полученные сообщения на стандартные фрагменты по одному килобайту и отправлять эти фрагменты дальше по *входящему* туннелю.
**При отправке** пакета, роутер поочередно **расшифровывает** его всеми ключами транзитных узлов. Это делается, чтобы после того, как каждый транзитный узел зашифрует информацию, она оказалась в исходном виде. Это особенность симметричных алгоритмов шифрования AES и ChaCha20. Звучит немного сложно, но суть в том, что шифрование и расшифровка - это зеркальные операции и при расшифровке исходной информации она шифруется, но чтобы ее потом расшифровать нужно провести операцию в обратном направлении, то есть зашифровать.
На последнем роутере исходящего туннеля - Endpoint - снимается последний слой луковичного шифрования и информация передается во входящий туннель другой стороны. Несмотря на то, что в этом месте всё луковичное шифрование снято, пользовательская информация не подвержена угрозе, так как к ней в первую очередь применяется сквозное шифрование.
Во входящем туннеле всё более просто для ума непосвященного человека: каждый транзитный узел добавляет шифрование своим ключом (и это действительно просто новый слой шифрования), затем передает получившийся пакет следующему узлу. Конечный получатель, сняв все луковичное шифрование, подвергает информацию расшифровке своим асимметричным ключом и проводит проверку подписи, после чего расшифрованная информация поднимается на уровень выше и отдается внешнему (прикладному) приложению в исходном виде.
В общих чертах завершенная схема передачи пользовательских данных выглядит, как показано на иллюстрации.
При исходящем туннеле:
* I2P-роутер принимает информацию от внешнего локального приложения, упаковывает ее в `I2NP Data` (gzip + служебные заголовки);
* Осуществляется сквозное шифрование ключом получателя (ключ из лизсета), получается `I2NP Garlic`;
* Информация подготавливается для отправки по конкретному туннелю, образуется сообщение `I2NP Tunnel`;
* Трафик оборачивается в криптографию транспортного протокола;
* Информация уходит по физической сети первому (ближайшему) узлу исходящего туннеля.
При входящем туннеле:
* По сети приходят пакеты, предназначенные I2P-роутеру;
* Происходит обработка транспортных протоколов, расшифровка I2NP-сообщений;
* Сообщение является `I2NP Tunnel` - туннельным сообщением;
* По идентификатору туннеля роутер понимает, что данное сообщение пришло из его туннеля. Снимается луковичное шифрование;
* Имеющееся сообщение типа `I2NP Garlic` - это исходное сообщение отправителя, зашифрованное асимметричным ключом получателя. Роутер, являясь держателем адреса, который является получателем данного сообщения, расшифровывает его приватным ключом адреса (на самом деле используются одноразовые ключи и прочее, но пощадите нашу с вами психику!);
* На выходе получается `I2NP Data` - пользовательская информация (gzip + служебные заголовки), которая распаковывается и отдается внешнему приложению.
В описании к иллюстрации сделан акцент на пользовательской информации, получаемой из туннеля, потому что существует еще много служебных сообщений и там дела обстоят иначе.
Необходимо отметить, что `I2NP Garlic` - это тип, который всего лишь обозначает сообщение с однослойным сквозным шифрованием, а не чесночное сообщение, которое используется при построении туннеля. Возможно, когда-то здесь планировалось использование именно чесночного шифрования, но судьба практической реализации распорядилась иначе.
---
Это упрощенное объяснение работы туннелей I2P, но вопреки всем усилиям по упрощению материал оказался весьма сложным для восприятия. Как бы то ни было, самое главное, я считаю, это наличие хотя бы какого-то понимания технологии, на которую вы решитесь положиться в решении важных задач. | https://habr.com/ru/post/576094/ | null | ru | null |
# Jinja2 в мире C++, часть вторая. Рендеринг
 Это вторая часть истории о портировании шаблонного движка Jinja2 на C++. Первую можно почитать здесь: [Шаблоны третьего порядка, или как я портировал Jinja2 на C++](https://habr.com/post/416581/). В ней речь пойдёт о процессе рендеринга шаблонов. Или, иначе говоря, о написании "с нуля" интерпретатора питоноподобного языка.
Рендеринг как таковой
---------------------
После парсинга шаблон превращается в дерево, содержащее узлы трёх типов: **простой текст**, **вычисляемые выражения** и **управляющие конструкции**. Соответственно, в процессе рендеринга простой текст должен без каких-либо изменений помещаться в выходной поток, выражения — вычисляться, преобразовываться в текст, который и будет помещён в поток, а управляющие конструкции — исполняться. С первого взгляда ничего сложного в том, чтобы реализовать процесс рендернга, не было: надо просто обойти все узлы дерева, всё вычислить, всё исполнить и сгенерировать текст. Всё просто. Ровно до тех пор, пока соблюдаются два условия: а) вся работа ведётся со строками только одного типа (string или wstring); б) используются только очень простые выражения и базовые. Собственно, именно с такими ограничениями и реализованы inja и Jinja2CppLight. В случае же моей [Jinja2Cpp](https://github.com/flexferrum/Jinja2Cpp) оба условия не срабатывают. Во-первых, мною изначально закладывалась прозрачная поддержка обоих типов строк. Во-вторых, вся разработка затевалась как раз ради поддержки спецификации Jinja2 почти в полном объёме, а это, в сущности, полноценный скриптовый язык. Поэтому с рендерингом пришлось поковыряться больше, чем с парсингом.
### Вычисление выражений
 Шаблон не был бы шаблоном, если бы его нельзя было параметризовать. В принципе, Jinja2 допускает вариант шаблонов "в себе" — все нужные переменные можно задать внутри самого шаблона, а потом его отрендерить. Но работа в шаблоне с параметрами, полученными "снаружи", остаётся основным кейсом. Таким образом, результат вычисления выражения зависит от того, какие переменные (параметры) с каким значениями видны в точки вычисления. И загвоздка в том, что в Jinja2 есть не просто области видимости (которые могут быть вложенными), но ещё и с непростыми правилами "прозрачности". Например, вот есть шаблон:
```
{% set param1=10 %}
{{ param1 }}
```
В результате его рендеринга будет получен текст `10`
Вариант чуть сложнее:
```
{% set param1=10 %}
{{ param1 }}
{% for param1 in range(10) %}-{{ param1 }}-{% endfor %}
{{ param1 }}
```
Отрендерится уже в `10-0--1--2--3--4--5--6--7--8--9-10`
Цикл порождает новый скоуп, в котором можно определить свои параметры-переменные, и эти параметры не будут видны за пределами скоупа, как и не будут перетирать значения одноименных параметров во внешнем. Ещё хитрее с конструкциями extends/block, но об этом уже лучше почитать в документации на Jinja2.
Таким образом, появляется контекст вычислений. А точнее, рендеринга вообще:
```
class RenderContext
{
public:
RenderContext(const InternalValueMap& extValues, IRendererCallback* rendererCallback);
InternalValueMap& EnterScope();
void ExitScope();
auto FindValue(const std::string& val, bool& found) const
{
for (auto p = m_scopes.rbegin(); p != m_scopes.rend(); ++ p)
{
auto valP = p->find(val);
if (valP != p->end())
{
found = true;
return valP;
}
}
auto valP = m_externalScope->find(val);
if (valP != m_externalScope->end())
{
found = true;
return valP;
}
found = false;
return m_externalScope->end();
}
auto& GetCurrentScope() const;
auto& GetCurrentScope();
auto& GetGlobalScope();
auto GetRendererCallback();
RenderContext Clone(bool includeCurrentContext) const;
private:
InternalValueMap* m_currentScope;
const InternalValueMap* m_externalScope;
std::list m\_scopes;
IRendererCallback\* m\_rendererCallback;
};
```
[Отсюда](https://github.com/flexferrum/Jinja2Cpp/blob/63e67774dd3fad846e50101451a92c50ce1b8441/src/render_context.h#L19).
Контекст содержит в себе указатель на коллекцию значений, полученных при вызове функции рендеринга, список (стек) скоупов, текущий активный скоуп и указатель на callback-интерфейс, с различными полезными для рендеринга функциями. Но о нём чуть позже. Функция поиска параметра последовательно поднимается по списку контекстов вплоть до внешнего, пока не найдёт нужный параметр.
Теперь немного о самих параметрах. С точки зрения внешнего интерфейса (и его пользователей) Jinja2 поддерживает следующий список допустимых типов:
* Числа (int, double)
* Строки (narrow, wide)
* bool
* Массивы (больше похожие на безразмеиные кортежи)
* Словари
* Отрефлексированные C++-структуры
Всё это описывается специальным типом данных, созданным на базе boost::variant:
```
using ValueData = boost::variant, boost::recursive\_wrapper, GenericList, GenericMap>;
class Value {
public:
Value() = default;
template
Value(T&& val, typename std::enable\_if, Value>::value>::type\* = nullptr)
: m\_data(std::forward(val))
{
}
Value(const char\* val)
: m\_data(std::string(val))
{
}
template
Value(char (&val)[N])
: m\_data(std::string(val))
{
}
Value(int val)
: m\_data(static\_cast(val))
{
}
const ValueData& data() const {return m\_data;}
ValueData& data() {return m\_data;}
private:
ValueData m\_data;
};
```
[Отсюда](https://github.com/flexferrum/Jinja2Cpp/blob/63e67774dd3fad846e50101451a92c50ce1b8441/include/jinja2cpp/value.h#L92).
Разумеется, элементы массивов и словарей могут быть любых из перечисленных типов. Но проблема в том, что для внутреннего использования этот набор типов слишком узкий. Для упрощения реализации нужна была поддержка следующих дополнительных типов:
* Строка в целевом формате. Может быть narrow или wide в зависимости от того, какой тип шаблона рендерится.
* callable-тип
* Узел AST-дерева
* Пара "ключ-значение"
Путем такого расширения появилась возможность передавать через контекст рендеринга служебные данные, которые иначе бы пришлось "светить" в публичных заголовках, а также более удачно обощать некоторые алгоритмы, работающие с массивами и словарями.
Boost::variant был выбран не случайно. Его богатые возможности используются для работы с параметрами конкретных типов. В Jinja2CppLight для этих же целей используются полиморфные классы, а в inja — система типов библиотеки nlohmann json. Обе эти альтернативы, увы, мне не подошли. Причина: возможность n-арной диспетчеризации для boost::variant (а теперь — и std::variant). Для вариантного типа можно сделать статический визитор, который принимает два конкретных хранимых типа, и натравить его на пару значений. И все сработает как надо! В случае же с полиморфными классами или простыми union'ами такого удобства не выйдет:
```
struct StringJoiner : BaseVisitor<>
{
using BaseVisitor::operator ();
InternalValue operator() (EmptyValue, const std::string& str) const
{
return str;
}
InternalValue operator() (const std::string& left, const std::string& right) const
{
return left + right;
}
};
```
[Отсюда](https://github.com/flexferrum/Jinja2Cpp/blob/63e67774dd3fad846e50101451a92c50ce1b8441/src/value_visitors.h#L733).
Вызывается такой визитор предельно просто:
```
InternalValue delimiter = m_args["d"]->Evaluate(context);
for (const InternalValue& val : values)
{
if (isFirst)
isFirst = false;
else
result = Apply2(result, delimiter);
result = Apply2(result, val);
}
```
`Apply2` здесь — это обёртка над `boost::apply_visitor`, которая применяет визитор заданного шаблонном параметром типа к паре вариантных значений, делая предварительно некоторые преобразования, если это нужно. Если конструктору визитора требуются параметры — они передаются после объектов, к которым применяется визитор:
```
comparator = [](const KeyValuePair& left, const KeyValuePair& right)
{
return ConvertToBool(Apply2(left.value, right.value, BinaryExpression::LogicalLt, BinaryExpression::CaseSensitive));
};
```
 Таким образом, логика выполнения операций с параметрами выходит следующей: variant(ы) -> распаковка с помощью visitor'а -> выполнение нужного действия над конкретными значениями конкретных типов — > упаковка результата обратно в variant. И минимум подковерной магии. Можно было бы реализовать всё как в js: выполнять операции (например, сложения) в любом случае, выбрав некую систему преобразований строк в числа, чисел в строки, строки в списки и т. п. И получать при этом странные и неожиданные результаты. Я выбрал более простой и предсказуемый путь: если операция над значением (или парой значений) невозможна или алогична, то возвращается пустой результат. Поэтому при сложении числа со строкой можно в результате получить строку только в том случае, если используется операция конкатенации ('~'). В противном случае результатом будет пустое значение. Приоритет операций определяется грамматикой, поэтому никаких дополнительных проверок при обработке AST делать уже не нужно.
### Фильтры и тесты
 То, что в других языках называется "стандартной библиотекой" в Jinja2 называется "фильтрами". В сущности, фильтр — это некая сложная операция над значением, стоящим слева от знака '|', результатом работы которой будет новое значение. Фильтры можно выстраивать в цепочку, организуя пайплайн:
`{{ menuItems | selectattr('visible') | map(attribute='title') | map('upper') | join(' -> ') }}`
Здесь из массива menuItems будут выбраны только те элементы, у которых атрибут visible выставлен в true, потом у этих элементов будет взят атрибут title, преобразован в верхний регистр, и получившийся список строк будет склеен с разделителем ' -> ' в одну строку. Или, скажем, во пример "из жизни":
```
{% macro MethodsDecl(class, access) %}
{% for method in class.methods | rejectattr('isImplicit') | selectattr('accessType', 'in', access) %}
{{ method.fullPrototype }};
{% endfor %}
{% endmacro %}
```
[Отсюда](https://github.com/flexferrum/autoprogrammer/blob/ace6511e81731d96c89ffd144764ca626075b8e6/src/generators/metaclasses/metaclasses_generator.cpp#L30).
**Альтернативный вариант**
```
{% macro MethodsDecl(class, access) %}
{{ for method in class.methods | rejectattr('isImplicit') | selectattr('accessType', 'in', access) | map(attribute='fullPrototype') | join(';\n') }};
{% endmacro %}
```
Этот макрос перебирает все методы заданного класса, отбрасывает те, у которых атрибут isImplicit выставлен в true, из оставшихся выбирает те, у которых значение атрибута accessType совпадает с одним из заданных, и выводит их прототипы. Относительно наглядно. И уж всяко проще, чем трехэтажные циклы и if'ы городить. К слову, что-то похожее в C++ можно делать в рамках спецификации [range v.3](https://ericniebler.github.io/std/wg21/D4128.html).
Собственно, основной промах по времени был связан с реализацией около сорока фильтров, которые я включил в базовый набор. С чего-то я взял, что справлюсь с этим за неделю-другую. Это было слишком оптимистично. И хотя типовая реализация фильтра довольно проста: взять значение и применить к нему некоторый функтор, их оказалось слишком много, и пришлось повозиться.
Отдельной интересной задачкой в процессе реализации стала логика обработки аргументов. В Jinja2, как и в питоне, передаваемые в вызов аргументы могут быть как именованные, так и позиционные. А параметры в объявлении фильтра могут быть как обязательные, так и опциональные (со значениями по-умолчанию). Причём, в отличие от C++, опциональные параметры могут находиться в любом месте объявления. Надо было придумать алгоритм совмещения этих двух списков с учётом разных кейсов. Вот, скажем, есть функция range: `range([start, ]stop[, step])`. Она может быть вызвана следующими способами:
```
range(10) // -> range(start = 0, stop = 10, step = 1)
range(1, 10) // -> range(start = 1, stop = 10, step = 1)
range(1, 10, 3) // -> range(start = 1, stop = 10, step = 3)
range(step=2, 10) // -> range(start = 0, stop = 10, step = 2)
range(2, step=2, 10) // -> range(start = 2, stop = 10, step = 2)
```
И так далее. И очень бы хотелось, чтобы в коде реализации функции фильтра не нужно было все эти кейсы учитывать. В итоге остановился на том, что в коде фильтра, тестера или функции параметры получаются строго по имени. И отдельная функция сопоставляет фактический список аргументов с ожидаемым списком параметров попутно проверяя, что все обязательные параметры тем или иным образом заданы:
**Большой кусок кода**
```
ParsedArguments ParseCallParams(const std::initializer_list& args, const CallParams& params, bool& isSucceeded)
{
struct ArgInfo
{
ArgState state = NotFound;
int prevNotFound = -1;
int nextNotFound = -1;
const ArgumentInfo\* info = nullptr;
};
boost::container::small\_vector argsInfo(args.size());
boost::container::small\_vector posParamsInfo(params.posParams.size());
isSucceeded = true;
ParsedArguments result;
int argIdx = 0;
int firstMandatoryIdx = -1;
int prevNotFound = -1;
int foundKwArgs = 0;
// Find all provided keyword args
for (auto& argInfo : args)
{
argsInfo[argIdx].info = &argInfo
auto p = params.kwParams.find(argInfo.name);
if (p != params.kwParams.end())
{
result.args[argInfo.name] = p->second;
argsInfo[argIdx].state = Keyword;
++ foundKwArgs;
}
else
{
if (argInfo.mandatory)
{
argsInfo[argIdx].state = NotFoundMandatory;
if (firstMandatoryIdx == -1)
firstMandatoryIdx = argIdx;
}
else
{
argsInfo[argIdx].state = NotFound;
}
if (prevNotFound != -1)
argsInfo[prevNotFound].nextNotFound = argIdx;
argsInfo[argIdx].prevNotFound = prevNotFound;
prevNotFound = argIdx;
}
++ argIdx;
}
int startPosArg = firstMandatoryIdx == -1 ? 0 : firstMandatoryIdx;
int curPosArg = startPosArg;
int eatenPosArgs = 0;
// Determine the range for positional arguments scanning
bool isFirstTime = true;
for (; eatenPosArgs < posParamsInfo.size(); ++ eatenPosArgs)
{
if (isFirstTime)
{
for (; startPosArg < args.size() && (argsInfo[startPosArg].state == Keyword || argsInfo[startPosArg].state == Positional); ++ startPosArg)
;
isFirstTime = false;
continue;
}
int prevNotFound = argsInfo[startPosArg].prevNotFound;
if (prevNotFound != -1)
{
startPosArg = prevNotFound;
}
else if (curPosArg == args.size())
{
break;
}
else
{
int nextPosArg = argsInfo[curPosArg].nextNotFound;
if (nextPosArg == -1)
break;
curPosArg = nextPosArg;
}
}
// Map positional params to the desired arguments
int curArg = startPosArg;
for (int idx = 0; idx < eatenPosArgs && curArg != -1; ++ idx, curArg = argsInfo[curArg].nextNotFound)
{
result.args[argsInfo[curArg].info->name] = params.posParams[idx];
argsInfo[curArg].state = Positional;
}
// Fill default arguments (if missing) and check for mandatory
for (int idx = 0; idx < argsInfo.size(); ++ idx)
{
auto& argInfo = argsInfo[idx];
switch (argInfo.state)
{
case Positional:
case Keyword:
continue;
case NotFound:
{
if (!IsEmpty(argInfo.info->defaultVal))
result.args[argInfo.info->name] = std::make\_shared(argInfo.info->defaultVal);
break;
}
case NotFoundMandatory:
isSucceeded = false;
break;
}
}
// Fill the extra positional and kw-args
for (auto& kw : params.kwParams)
{
if (result.args.find(kw.first) != result.args.end())
continue;
result.extraKwArgs[kw.first] = kw.second;
}
for (auto idx = eatenPosArgs; idx < params.posParams.size(); ++ idx)
result.extraPosArgs.push\_back(params.posParams[idx]);
return result;
}
```
[Отсюда](https://github.com/flexferrum/Jinja2Cpp/blob/6331e7bdf31c229589452b1cbfc68f262029dae5/src/expression_evaluator.cpp#L369).
Вызывается он таким вот образом (для, скажем, `range`):
```
bool isArgsParsed = true;
auto args = helpers::ParseCallParams({{"start"}, {"stop", true}, {"step"}}, m_params, isArgsParsed);
if (!isArgsParsed)
return InternalValue();
```
и возвращает следующую структуру:
```
struct ParsedArguments
{
std::unordered_map> args;
std::unordered\_map> extraKwArgs;
std::vector> extraPosArgs;
ExpressionEvaluatorPtr<> operator[](std::string name) const
{
auto p = args.find(name);
if (p == args.end())
return ExpressionEvaluatorPtr<>();
return p->second;
}
};
```
нужный аргумент из которой забирается просто по своему имени:
```
auto startExpr = args["start"];
auto stopExpr = args["stop"];
auto stepExpr = args["step"];
InternalValue startVal = startExpr ? startExpr->Evaluate(values) : InternalValue();
InternalValue stopVal = stopExpr ? stopExpr->Evaluate(values) : InternalValue();
InternalValue stepVal = stepExpr ? stepExpr->Evaluate(values) : InternalValue();
```
Аналогичный механизм применяется при работе с макросами и тестерами. И хотя, вроде бы, ничего сложного в том, чтобы описать аргументы каждого фильтра и теста, нет (как и реализовать его), но даже "базовый" набор, в который вошло примерно пятьдесят тех и других, оказался достаточно объёмным для реализации. И это при том условии, что в него не вошли всякие хитрые штуки, как форматирование строк под HTML (или C++), вывод значений в форматах типа xml или json, и тому подобные вещи.
В следующей части речь пойдёт о реализации работы с несколькими шаблонами (export, include, макросы), а также про увлекательные приключения с реализацией обработки ошибок и работе со строками разной ширины.
Традиционно, ссылки:
[Спецификация Jinja2](http://jinja.pocoo.org/docs/2.10/templates/)
[Реализация Jinja2Cpp](https://github.com/flexferrum/Jinja2Cpp) | https://habr.com/ru/post/419011/ | null | ru | null |
# 3 способа задать разметку для различных устройств в C#/XAML приложениях Windows UWP
[](http://habrahabr.ru/post/268695/)
Для начала, хотелось бы напомнить, каким образом можно было создавать универсальные приложения в Windows 8.1. Создавалось решение с тремя проектами: для телефона, для Windows 8.1 и проект с общим кодом. А как теперь в Windows 10? Сейчас расскажу.
Вот так выглядело универсальное приложение в Windows 8.1
Но потом появилась Windows 10 и сразу возник резонный вопрос:
Это что ж теперь учить все заново?
Отчасти небольшие изменения действительно есть. Но если у вас было хорошее понимание универсальных проектов Windows 8.1, то для вас все будет привычно. Более того добавилась определенная гибкость.
Давайте сначала рассмотрим какие устройства на платформе Windows UWP существуют на данный момент (в продаже, в планах или в прототипе):
Устройства объединены в отдельные семейства:
На диаграмме стоит многоточие, так как платформа растет и видов устройств может стать больше со временем.
Теперь вместо того, чтобы получить решение с несколькими проектами под каждое семейство устройств достаточно создать папку, указав в ее названии имя семейства. Например, так:
В данном случае, если приложение будет запущено на мобильном устройстве, то будет отображена страница MainPage из папки DeviceFamily-Mobile.
Причем, заметьте, если вы создадите страницу внутри папки с названием MainPage, то она будет создана без файла кода MainPage.xaml.cs
Это был первый способ.
Второй способ аналогичен первому, но вместо создания папки к имени файла добавляется .DeviceFamily-Type
Третий способ – из codebehind.
Если скомпилировать проект и рассмотреть файл MainPage.g.i.cs то можно найти перегрузку метода InitializeComponent, которая принимает в качестве параметра System.Uri resourceLocator
```
public void InitializeComponent(global::System.Uri resourceLocator)
{
if (_contentLoaded)
return;
_contentLoaded = true;
if (resourceLocator == null)
{
resourceLocator = new global::System.Uri("ms-appx:///MainPage.xaml");
}
global::Windows.UI.Xaml.Application.LoadComponent(this, resourceLocator, global::Windows.UI.Xaml.Controls.Primitives.ComponentResourceLocation.Application);
}
```
А значит для того чтобы загрузить нужную страницу мы можем поступить так:
```
public MainPage()
{
if (Windows.System.Profile.AnalyticsInfo.VersionInfo.DeviceFamily=="Windows.Mobile")
{
InitializeComponent(new Uri("ms-appx:///MobileMainPage.xaml", UriKind.Absolute));
}
else
{
InitializeComponent();
}
}
```
В данном случае если приложение будет запущено на мобильном устройстве, то будет загружена страница MobileMainPage.xaml
Теперь немного о том как в коде C# определить какое семейство устройств используется на данный момент. Сделать это очень просто с помощью такого вот кода:
```
if (String.Equals(Windows.System.Profile.AnalyticsInfo.VersionInfo.DeviceFamily, "Windows.Desktop"))
{
// значит семейство Desktop и можно что-то нужное сделать
}
```
Если вы захотите использовать в своем приложении API определенного семейства устройств, то вы можете добавить ссылку на любое из расширений платформы UWP
Избитым примером использования API семейства устройств можно считать проверку на присутствие аппаратной кнопки «Назад» на телефоне (hardware Back button).
```
bool isHardwareButtonsAPIPresent =
Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons");
if (isHardwareButtonsAPIPresent)
{
Windows.Phone.UI.Input.HardwareButtons.CameraPressed += HardwareButtons_CameraPressed;
}
private void HardwareButtons_CameraPressed(object sender, Windows.Phone.UI.Input.CameraEventArgs e)
{
// здесь своя реализация события нажатия «Назад»
}
```
Для проверки используется метод isTypePresent который содержится в классе [Windows.Foundation.Metadata.ApiInformation](https://msdn.microsoft.com/en-us/library/windows/apps/windows.foundation.metadata.apiinformation). Этот класс обладает также и другими методами для проверки на наличие доступных возможностей API (событий, свойств…)
Или вот чуть менее избитый пример, который в случае наличия у устройства статусбара меняет его цвет на шоколадный:
```
if (Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar"))
{
var statusBar = Windows.UI.ViewManagement.StatusBar.GetForCurrentView();
statusBar.BackgroundColor = Windows.UI.Colors.Chocolate;
statusBar.BackgroundOpacity = 1;
}
```
Пример можно найти на [GitHub](https://github.com/programmersommer/Device_family_demo) | https://habr.com/ru/post/268695/ | null | ru | null |
# Раскрашиваем треугольник программным способом
Мне интересно воссоздавать работу GPU программно, поэтому я решил поделиться моим пониманием того, как можно выполнить раскраску треугольников методами простой линейной алгебры.
> Я напишу обобщённый 2D-массив элементов типа **uint32\_t** под названием **colorBuffer**, который может быть резервным хранилищем чего-то простого, например, выводимого в файл изображения, или буфером цвета окна SDL.
Задаём треугольник
------------------
Треугольник можно задать тремя точками, или **вершинами**. Каждая вершина имеет различные атрибуты; пока мы добавим каждой вершине только положение на экране.
То есть если бы мы захотели нарисовать треугольник с вершиной в нижнем левом углу, нижнем правом углу и вверху по центру, то мы бы могли задать его так:
```
struct Point
{
float x;
float y;
};
struct Vertex
{
Point position;
};
// Top middle
Vertex v0 = {WINDOW_WIDTH/2, 0.0f};
// Bottom right
Vertex v1 = {WINDOW_WIDTH, WINDOW_HEIGHT};
// Bottom left
Vertex v2 = {0.0f, WINDOW_HEIGHT};
```
> Нужно добавить, что вершины задаются в порядке **по часовой стрелке**. Сначала верхняя в центре, потом нижняя правая и нижняя левая. В дальнейшем это будет очень важно.
Каждая вершина имеет позицию, состоящую из двух значений с плавающей запятой. Их два, потому что при работе с экраном у нас есть всего два измерения: ширина (x) и высота (y).
Точкой начала координат экрана считается верхний левый угол: значения y становятся больше при смещении вниз, а значения x — при сдвиге вправо. Поэтому нижний правый угол треугольника имеет наибольшие значения.
Функция ребёр
-------------
Итак, каждая вершина треугольника имеет положение на экране, но нам нужно знать, какие из экранных пикселей находятся внутри этого треугольника, чтобы их можно было раскрасить соответствующим образом. Мы хотим, чтобы пиксели в треугольнике были не чёрными, а пиксели за пределами треугольника — чёрными. Этим займётся за нас линейная алгебра.
Сначала мы создадим вектор из каждой вершины до следующей соседней вершины, двигаясь **по часовой стрелке**, вычитанием позиции одной вершины из другой. Вспомним, что Точка A — Точка B создаёт вектор, указывающий из Точки B в Точку A.
Это красные векторы, названные **e10** (v1 — v0), **e21** (v2 — v1) и **e02** (v0 — v2).
Если мы хотим узнать, находится ли точка P внутри треугольника, то можно использовать свойство векторного произведения 2D-векторов. Для каждого ребра (e10, e21, e02) мы можем найти векторное произведение вектора этого ребра с вектором из начальной точки ребра к точке P.
Новый вектор является результатом вычитания p — v0, что создаёт вектор из v0 в p. Если мы возьмём двухмерное векторное произведение двух зелёных векторов (p-v0 и e10), то получим значение, являющееся отрицательным, положительным или нулевым.
* **Положительное**: точка P находится справа от e10 (внутри треугольника)
* **Отрицательное**: точка P находится слева от e10 (снаружи треугольника)
* **Нулевое**: точка P находится на e10 (ни внутри, ни снаружи)
То же самое мы делаем для двух других векторов рёбер.
Зелёный вектор является результатом вычитания p — v1, что создаёт вектор из v1 в p.
Зелёный вектор является результатом вычитания p — v2, что создаёт вектор из v2 в p.
Двухмерное векторное произведение получается довольно просто:
> A x B = A.x \* B.y — A.y \* B.x
```
Vector e10 = v1 - v0;
Vector e21 = v2 - v1;
Vector e02 = v0 - v2;
Vector p0 = p - v0;
Vector p1 = p - v1;
Vector p2 = p - v2;
```
Тогда если мы хотим протестировать точку P относительно e10:
```
float result = Edge(e10, p);
```
Всё это означает, что если мы хотим узнать, находится ли точка внутри треугольника, можно взять векторные произведения вектора каждой точки с вектором каждого ребра. Если *все* они больше нуля (или равны ему), то точка находится внутри треугольника и мы можем раскрасить этот пиксель.
Мы можем задать ещё одну структуру для представления Vector и перегрузить оператор вычитания, чтобы создавать Vector из вычитания двух точек. Структуры Point и Vector имеют одинаковое содержимое (два float), но благодаря их разделению код становится более понятным.
```
struct Vector
{
float x;
float y;
};
Vector operator-(Point lhs, Point rhs)
{
Vector result;
result.x = lhs.x - rhs.x;
result.y = lhs.y - rhs.y;
return result;
}
```
Затем мы создаём функцию, сообщающую нам по позициям двух векторов (точек рёбер) и тестируемой точки векторное произведение векторов из этих точек.
```
float Edge(Point v0, Point v1, Point p)
{
// Vector from edge origin to test point
Vector a = p - v0;
// Vector from edge origin to edge end
Vector b = v1 - v0;
// 2D cross product
// Zero: Point is on edge
// Positive: Point is right of edge
// Negative: Point is left of edge
return a.x * b.y - a.y * b.x;
}
```
Рисование треугольника
----------------------
Чтобы отрендерить треугольник, мы итеративно обходим все пиксели экрана и проверяем, содержится ли их позиция внутри треугольника. Если да, то раскрашиваем пиксель белым. Если нет, то ничего не делаем.
```
// Top middle
Vertex v0 = {WINDOW_WIDTH/2, 0.0f};
// Bottom right
Vertex v1 = {WINDOW_WIDTH, WINDOW_HEIGHT};
// Bottom left
Vertex v2 = {0.0f, WINDOW_HEIGHT};
for (unsigned int y = 0; y < WINDOW_HEIGHT; ++y)
{
for (unsigned int x = 0; x < WINDOW_WIDTH; ++x)
{
Point p = {(float)x, (float)y};
// Clockwise
float e10 = Edge(v1.position, v0.position, p);
float e21 = Edge(v2.position, v1.position, p);
float e02 = Edge(v0.position, v2.position, p);
// Point is inside triangle
if (e10 >= 0.0f && e21 >= 0.0f && e02 >= 0.0f)
{
colorBuffer[y][x] = 0xffffffff;
}
}
}
```
Так мы получаем следующее изображение:
Затенение треугольника
----------------------
Замечательно. Мы можем задавать треугольник тремя точками и заливать его сплошным цветом. Разумеется, наша конечная цель — не сплошной цвет. Было бы здорово, если бы могли связать с вершиной и другие атрибуты, кроме позиции, а затем интерполировать эти атрибуты для всего множества пикселей, составляющих треугольник.
Это можно реализовать при помощи **барицентрических координат**. Векторное произведение двух 2D-векторов на самом деле является площадью параллелограмма, образованного этими двумя векторами. Половина площади этого параллелограмма — это площадь меньшего треугольника, образованного двумя точками треугольника и проверяемой точкой.
Если соединить проверяемую точку с каждой вершиной, то можно визуализировать три меньших треугольника, образующих общий треугольник. Сумма площадей этих треугольников составляет площадь всего треугольника.
Каждая из этих раскрашенных площадей обозначает меньший треугольник.
Если указать на каждом меньшем треугольнике его площадь, то мы увидим нечто интересное.
* Когда точка P приближается к v0, площадь красного треугольника становится больше.
* Когда точка P приближается к v1, больше становится площадь зелёного треугольника.
* Когда точка P приближается к v2, больше становится площадь синего треугольника.
При перемещении точки P по треугольнику площади составляющих его треугольников изменяются в зависимости от близости точки к каждой из трёх вершин. Другими словами, если с каждой вершиной связаны какие-то атрибуты (например цвет), то можно использовать выведенное выше векторное произведение для получения значения, сообщающего, какая пропорция атрибута каждой из вершин должна вносить вклад в точку как целое.
Если мы разделим каждый из результатов, возвращённых из функции рёбер и разделим их на общую площадь основного треугольника, то получим нормализованное значение (от 0.0 до 1.0) для каждой вершины. Это значение является **весом** этой вершины в проверяемой точке. Можно умножить вес каждой вершины на атрибут вершины и сложить все три взвешенных значения, чтобы получить окончательное значение.
Это можно продемонстрировать, назначив каждой вершине цвет.
Мы создадим struct для задания цвета, которая будет всего лишь четырьмя float, и добавим переменную цвета в структуру Vertex.
```
struct Color
{
float r, g, b, a;
};
struct Vertex
{
Point position;
Color color;
};
```
Затем мы переопределим треугольник и назначим красный цвет вершине v0, зелёный — v1, а синий — v2.
```
// Top middle - red
Vertex v0 =
{
{WINDOW_WIDTH/2, 0.0f},
{1.0f, 0.0f, 0.0f, 1.0f}
};
// Bottom right - green
Vertex v1 =
{
{WINDOW_WIDTH, WINDOW_HEIGHT},
{0.0f, 1.0f, 0.0f, 1.0f}
};
// Bottom left - blue
Vertex v2 =
{
{0.0f, WINDOW_HEIGHT},
{0.0f, 0.0f, 1.0f, 1.0f}
};
```
Для нормализации весов нужно разделить каждую на общую площадь треугольника, которую можно найти, передав каждую из трёх вершин в функцию рёбер. После этого для нахождения цвета точки достаточно просуммировать все взвешенные цвета.
```
float area = Edge(v2.position, v1.position, v0.position);
for (unsigned int y = 0; y < WINDOW_HEIGHT; ++y)
{
for (unsigned int x = 0; x < WINDOW_WIDTH; ++x)
{
Point p = {(float)x, (float)y};
// Clockwise
float e0 = Edge(v2.position, v1.position, p);
float e1 = Edge(v0.position, v2.position, p);
float e2 = Edge(v1.position, v0.position, p);
// Point is inside triangle
if (e0 >= 0.0f && e1 >= 0.0f && e2 >= 0.0f)
{
// Barycentric weights
float w0 = e0 / area;
float w1 = e1 / area;
float w2 = e2 / area;
float r =
w0 * v0.color.r
+ w1 * v1.color.r
+ w2 * v2.color.r;
float g =
w0 * v0.color.g
+ w1 * v1.color.g
+ w2 * v2.color.g;
float b =
w0 * v0.color.b
+ w1 * v1.color.b
+ w2 * v2.color.b;
uint8_t red = r * 255;
uint8_t green = g * 255;
uint8_t blue = b * 255;
uint8_t alpha = 255;
colorBuffer[y][x] = (red << 24 | green << 16 | blue << 8 | alpha);
}
}
}
```
> Значение, возвращаемое функцией Edge, является площадью параллелограмма, образованного векторами, но нас интересует площадь треугольника, равная её половине. Однако, поскольку мы делим результаты функции Edge (e1, e2, e3) на ещё один результат функции Edge (площадь), то 1/2 сокращается, поэтому нам не нужно об этом заботиться.
> Когда треугольник меньше размера всего окна/изображения, то будет неэффективно обходить весь размер окна/изображения. Логичнее будет создать ограничивающий прямоугольник этого треугольника, вычислив его минимальные и максимальные значения X и Y, а затем обойдя только эту область.
Результаты
----------
После выполнения программы получается следующий затенённый треугольник:
Пиксели, более близкие к верхней вершине, становятся более красными, к правой вершине — более зелёными, к левой — более синими. Площади между ними являются сочетанием цветов.
Заключение
----------
Все, кто работал с графическими API наподобие OpenGL должны увидеть сходства между написанным мной и тем, как используется OpenGL.
В OpenGL мы передаём в GPU буфер данных вершин, содержащий атрибуты каждой вершины (например, позицию, цвет, нормаль), а он затем интерполирует эти атрибуты между пикселями (фрагментами), составляющими треугольник на экране.
В статье мы выполнили похожие действия. | https://habr.com/ru/post/526340/ | null | ru | null |
# Хирургическая операция по увеличению буфера последовательного порта у Arduino IDE
Я не большой фанат инфраструктуры Arduino. Да, сегодня у нас есть уже больше вариантов – к примеру, [pro IDE](https://hackaday.com/2019/10/21/the-arduino-ide-finally-grows-up/) и [Platform IO](https://hackaday.com/2017/04/07/platformio-and-visual-studio-take-over-the-world/). Однако от оригинальной IDE у меня всегда случается изжога. И всю её степень я оценил только накануне, когда захотел сделать нечто очень простое: увеличить принимающий буфер последовательного порта ATmega32. В итоге я пришёл к решению, которое может помочь вам и с другими проблемами – так что, даже если вам не нужна конкретно эта возможность, вам, возможно, будет полезно посмотреть, что именно я сделал.
Данный опыт оставил у меня двоякое впечатление. С одной стороны, я презираю этот невзрачный редактор за то, что он прячет от меня слишком много, и даёт очень мало полезных инструментов. С другой стороны, меня впечатлило то, насколько он гибкий, если докопаться до деталей его внутреннего устройства.
Во-первых, вы, наверное, спросите, зачем я использую IDE. Коротко говоря, я его не использую. Однако если вы делаете нечто, чем будут пользоваться другие, его практически невозможно игнорировать. Как бы вы ни настраивали собственную среду разработки, как только ваш код выходит в интернет, кто-нибудь попробует использовать его с IDE. Когда-то я писал о [компьютере на базе Z80 за $4](https://hackaday.com/2017/01/02/retrocomputing-for-4-with-a-z80/). У меня редко бывает время на сборку того, о чём я пишу, однако я очень хотел попробовать собрать этот маленький компьютер. Какое-то время всё лежало в полуразобранном состоянии, а потом мне прислали для него плату. Я её получил, и – как вы уже догадались – всё ещё немножечко полежало в полуразобранном состоянии. Но я, наконец, нашёл время закончить проект и загрузил CP/M.
Единственной проблемой проекта было отсутствие хороших вариантов передачи данных с него на ПК и обратно. Казалось, что лучше всего делать шестнадцатеричные файлы Intel и копировать/вставлять их через терминал. Мне хотелось чего-то получше, и в результате я угодил в кроличью нору субботнего утра. В итоге я придумал способ добавлять собственные пункты меню в Arduino IDE, чтобы править настройки компилятора в зависимости от железа, которое используется в проекте. Такому трюку стоит обучиться, поскольку он может пригодиться и за пределами этой конкретной задачи.
Проблема: ограничение размера буфера последовательного порта Arduino
--------------------------------------------------------------------
Не буду загружать вас деталями о том, как заставить плату работать, поскольку вам это будет интересно, только если она у вас есть. Все детали есть в [обсуждении на Hackaday.io](https://hackaday.io/project/19000-a-4-4ics-z80-homemade-computer-on-breadboard), если вам это реально нужно. В итоге получалось, что для передачи через XModem буфер последовательного порта Arduino был недостаточно большим для того, чтобы считаь его надёжным. Всё вроде бы работало и с буфером по умолчанию размером в 64 байта, однако XModem отправляет больше данных, и легко представить, как буфер переполняется.
Насколько сложным может быть обновление буфера? С какой-то стороны это тривиальная задача. С другой стороны – очень сложная, потому что ваши инструменты очень сильно пытаются вам помочь.
Набор инструментов
------------------
В проекте маленького компьютера используется реальный чип Z80 и ATMega32A почти для всех вспомогательных функций. Он даёт тактовую частоту, работает последовательным портом, накопителем, и т.д. Однако Arduino IDE не поддерживает напрямую ATMega32A, поэтому для этого придётся установить набор инструментов. Ситуация требовала [MightyCore](https://github.com/MCUdude/MightyCore), поэтому я её и использовал.
Библиотеки для последовательного порта настроены при помощи операторов #define, чтобы вы могли исправить размер буфера. По умолчанию, если ничего не настраивать, вы получите значения, основанные на количестве доступной RAM:
```
#if !defined(SERIAL_TX_BUFFER_SIZE)
#if ((RAMEND - RAMSTART) < 1023)
#define SERIAL_TX_BUFFER_SIZE 16
#else
#define SERIAL_TX_BUFFER_SIZE 64
#endif
#endif
#if !defined(SERIAL_RX_BUFFER_SIZE)
#if ((RAMEND - RAMSTART) < 1023)
#define SERIAL_RX_BUFFER_SIZE 16
#else
#define SERIAL_RX_BUFFER_SIZE 64
#endif
#endif
```
Вносим изменения
----------------
Всё просто, не так ли? Определяем символы перед загрузкой HardwareSerial.h. Опаньки – этот файл грузится в Arduino.h. ИП хочет добавить его к вашей программе и заставляет грузиться первым. Вроде бы некоторые версии IDE проверяли, не включили ли вы его уже, чтобы не включать его повторно, однако версия 1.8.5 этого не делает. Может, я могу передать какие-то настройки компилятору? Не-а. По крайней мере, не через IDE.
Попробовал я много всего. Хотелось, конечно, просто изменить основные библиотеки. Но это нехорошо. Позже вам могут потребоваться настройки по умолчанию. Если обновить набор инструментов, то все обновления потеряются. Мне хотелось избежать этого. Кто-то в интернете посоветовал сделать копию файлов платформы и изменять их. Не идеальное решение.
Проверяем предположения при помощи
----------------------------------
Мне было видно, что то, что я делал, не срабатывает, поскольку я временно вставлял операторы #if и #error в HardwareSerial.cpp. К примеру:
```
#if SERIAL_RX_BUFFER_SIZE==256
#error 256
#endif
```
Теперь, если при компиляции вылетит ошибка 256, я узнаю, что размер установлен. Если нет, тогда система сопротивляется моим изменениям.
Компромисс: добавление настроек в меню на уровне платы
------------------------------------------------------
Я очень хотел придумать способ изменить настройки только в конкретном проекте, и таким образом задать размер последовательного буфера. Мне это не удалось. Зато мне удалось изменить boards.txt от Mighty Core. Да, мне придётся следить за тем, чтобы обновления не затёрли мои правки, однако они простые, и если чего-то не хватает в файле, это будет очевидно.
Очевидно это будет потому, что я создал меню для IDE, которое появляется только при использовании ATMega32 для Mighty Core. В меню можно выбрать один из предустановленных размеров буфера.
Для достижения такого результата нужно сделать три шага:
1. Сказать IDE, что у вас есть новый пункт меню, и описать, как он выглядит.
2. Новый пункт должен менять настройки компилятора.
3. Поскольку существующая система тоже меняет настройки компилятора, нужно убедиться в том, что они не испортятся.
Первый шаг делается легко. Мой файл boards.txt лежал в ~/.arduino15/packages/MightyCore/hardware/avr/2.0.5/boards.txt. Почти в самом верху там есть список пунктов меню, и в конец я добавил свои:
```
# Menu options
menu.clock=Clock
menu.BOD=BOD
menu.LTO=Compiler LTO
menu.variant=Variant
menu.pinout=Pinout
menu.bootloader=Bootloader
menu.SerialBuf=Serial Port Buffers (RX/TX)
```
Затем я сдвинул строки вниз и добавил своё меню перед существующей настройкой LTO для ATMega32:
```
32.menu.SerialBuf.disabled=Default
32.menu.SerialBuf.disabled.compilerSB.c.extra_flags=
32.menu.SerialBuf.disabled.compilerSB.cpp.extra_flags=
32.menu.SerialBuf.SB64=64/64
32.menu.SerialBuf.SB64.compilerSB.c.extra_flags=-DSERIAL_RX_BUFFER_SIZE=64 -DSERIAL_TX_BUFFER_SIZE=64
32.menu.SerialBuf.SB64.compilerSB.cpp.extra_flags=-DSERIAL_RX_BUFFER_SIZE=64 -DSERIAL_TX_BUFFER_SIZE=64
32.menu.SerialBuf.SB128=128/128
32.menu.SerialBuf.SB128.compilerSB.c.extra_flags=-DSERIAL_RX_BUFFER_SIZE=128 -DSERIAL_TX_BUFFER_SIZE=128
32.menu.SerialBuf.SB128.compilerSB.cpp.extra_flags=-DSERIAL_RX_BUFFER_SIZE=128 -DSERIAL_TX_BUFFER_SIZE=128
32.menu.SerialBuf.SB12864=128/64
32.menu.SerialBuf.SB12864.compilerSB.c.extra_flags=-DSERIAL_RX_BUFFER_SIZE=128 -DSERIAL_TX_BUFFER_SIZE=64
32.menu.SerialBuf.SB12864.compilerSB.cpp.extra_flags=-DSERIAL_RX_BUFFER_SIZE=128 -DSERIAL_TX_BUFFER_SIZE=64
32.menu.SerialBuf.SB256=256/256
32.menu.SerialBuf.SB256.compilerSB.c.extra_flags=-DSERIAL_RX_BUFFER_SIZE=256 -DSERIAL_TX_BUFFER_SIZE=256
32.menu.SerialBuf.SB256.compilerSB.cpp.extra_flags=-DSERIAL_RX_BUFFER_SIZE=256 -DSERIAL_TX_BUFFER_SIZE=256
32.menu.SerialBuf.SB25664=256/64
32.menu.SerialBuf.SB25664.compilerSB.c.extra_flags=-DSERIAL_RX_BUFFER_SIZE=256 -DSERIAL_TX_BUFFER_SIZE=64
32.menu.SerialBuf.SB25664.compilerSB.cpp.extra_flags=-DSERIAL_RX_BUFFER_SIZE=256 -DSERIAL_TX_BUFFER_SIZE=64
32.menu.SerialBuf.SB25632=256/32
32.menu.SerialBuf.SB25632.compilerSB.c.extra_flags=-DSERIAL_RX_BUFFER_SIZE=256 -DSERIAL_TX_BUFFER_SIZE=32
32.menu.SerialBuf.SB25632.compilerSB.cpp.extra_flags=-DSERIAL_RX_BUFFER_SIZE=256 -DSERIAL_TX_BUFFER_SIZE=32
```
Структура меню
--------------
Видно, что объект 32.menu группирует все элементы вместе для данного процессора. Дальше идёт наш ключ меню (SerialBuf). После этого идут уникальные ключи для каждого пункта меню. Их важно не использовать повторно. Если, к примеру, у вас будет два ключа SB64, то работать будет только один из них.
Если к этому ключу приписать знак равно, можно назначить текст для данного пункта меню. К примеру, «Default» или «64/64». Также можно добавить к ключу свойство, и оно будет назначено, когда пункт активируют.
Если, допустим, выбрать 256/256, то компилятор выставляет свойство compilerSB.c.extra\_flags. Почему я придумал такое название свойства, вы поймёте чуть позже.
Мирное сосуществование
----------------------
Свойства compilerSB.c.extra\_flags нет. Правильно оно называется compiler.c.extra\_flags. Однако настройка Mighty Core LTO использует такой же ключ. Поэтому было важно, чтобы новое меню появлялось первым, а также устанавливало ненастоящее свойство. Потом требуется подправить код LTO:
```
# Compiler link time optimization
32.menu.LTO.Os=LTO disabled
32.menu.LTO.Os.compiler.c.extra_flags={compilerSB.c.extra_flags}
32.menu.LTO.Os.compiler.c.elf.extra_flags=
32.menu.LTO.Os.compiler.cpp.extra_flags={compilerSB.cpp.extra_flags}
32.menu.LTO.Os.ltoarcmd=avr-ar
32.menu.LTO.Os_flto=LTO enabled
32.menu.LTO.Os_flto.compiler.c.extra_flags={compilerSB.c.extra_flags} -Wextra -flto -g
32.menu.LTO.Os_flto.compiler.c.elf.extra_flags=-w -flto -g
32.menu.LTO.Os_flto.compiler.cpp.extra_flags={compilerSB.cpp.extra_flags} -Wextra -flto -g
32.menu.LTO.Os_flto.ltoarcmd=avr-gcc-ar
```
Основное изменение состоит в том, что каждый набор флагов добавляется в заданное в настройках меню. Таким образом все флаги добавляются в правильное свойство, compiler.c.extra\_flags.
Я настроил перехват ошибок для всех случаев, чтобы гарантировать, что всё назначится верно.
Настройка под себя
------------------
Вы, конечно же, можете изменить параметры, если вам нужно что-то другое. Также этот трюк можно использовать для задания других параметров до того, как управление получает файл Arduino.h. Есть [документация](https://arduino.github.io/arduino-cli/platform-specification/), описывающая то, как настраивать разные параметры платформы, включая и boards.txt.
Возможно, было бы лучше создать свой отдельный файл boards.txt с той же самой информацией, но тогда мне потребовалось бы брать с собой и остаток Mighty Core. Вместо этого я просто сохранил копию этого файла под именем boards.txt.custom, и если моё меню исчезнет, я просто сравню его содержимое с boards.txt, чтобы посмотреть, что там поменялось.
Естественно, если вам не нужно заниматься поддержкой людей, использующих IDE, то на это можно просто забить. Лучше использовать Pro IDE, даже несмотря на некоторые его недостатки. Ну и всегда можно обратиться к Platform.io.
> См. также:
>
>
>
> * «[Выпущена альфа-версия новой IDE для Arduino](https://habr.com/ru/news/t/472194/)»
> * «[ESP8266 прошивка, программирование в Arduino IDE](https://habr.com/ru/post/371853/)»
> * «[Arduino IDE: почему не компилируются скетчи (и как этого избежать)](https://habr.com/ru/post/392931/)»
> | https://habr.com/ru/post/512260/ | null | ru | null |
# Визуализация данных для киноманов: скрапим рекомендации фильмов и делаем интерактивный граф
Однажды я наткнулся на [интерактивную карту lastfm](http://sixdegrees.hu/last.fm/interactive_map.html) и решил обязательно сделать подобный проект для фильмов. Под катом история о том, как собрать данные, построить граф и создать своё интерактивное демо на примере данных с кинопоиска и imdb. Мы рассмотрим фреймворк для скрапинга Scrapy, пробежимся по методам визуализации больших графов и разберёмся с инструментами для интерактивного отображения больших графов в браузере.
1. Сбор данных: Scrapy
======================
В качестве источника данных я выбрал кинопоиск. Однако, потом оказалось, что этого очень мало и я соскрапил IMDb. Чтобы составить граф, для каждого фильма нужно знать список рекомендуемых фильмов. Если поискать, то можно найти достаточно парсеров кинопоиска и всевозможных неофициальных api, но нигде нет возможности достать рекомендации. IMDb открыто делится своим датасетом, но и там рекомендаций нет. Поэтому выбор остаётся только один: писать своего паука.
На хабре уже есть несколько статей о скрапинге, поэтому я пропущу обзор возможных подходов. В двух словах: если вы пишете на python и не хотите писать свой фреймворк, используйте [Scrapy](https://scrapy.org/). Практически всё, что вам может понадобиться, в нём уже предусмотрено.
Scrapy действительно очень мощный и в то же время очень простой инструмент. Порог входа довольно низкий, но в то же время Scrapy легко масштабируется на проекты любого объёма и сложности. В нём действительно собрано всё что нужно. От инструментов непосредственно парсинга и HTTP запросов, обработки и сохранения полученных элементов, до управления работой проекта, включая способы обхода блока, паузы и возобновления скрапинга и т. д.
Создание проекта начинается с команды `scrapy startproject mycoolproject`, после чего вы получаете готовую структуру с шаблонами необходимых элементов и файлы минимальной рабочей конфигурации. Чтобы сделать из этого рабочий проект достаточно описать способ парсинга страницы — то есть создать паука и положить его в папку `spiders` внутри проекта, и описать какую именно информацию вы хотите извлечь — то есть унаследовать свой класс от класса `scrapy.item` в скрипте `items.py`. Таким образом можно сделать полностью рабочий проект меньше чем за час. Для сохранения результатов есть встроенные средства: например запись в csv или json, но лучше всё-таки использовать внешнюю БД, если проект не на пять минут. Поведение связанное с обработкой результатов, включая сохранение задаётся в `pipelines.py`. Остаётся последний важный файл — `settings.py` назначение которого понятно из названия. Здесь можно задать конфигурацию проекта связанную например с использованием прокси, таймингом между запросами и многим другим.
И так, по шагам:
* Смотрим в статьях [раз](https://habrahabr.ru/post/308660/), [два](https://habrahabr.ru/post/115710/) и в [документации](https://docs.scrapy.org/en/latest/) как создавать проект для Scrapy. По аналогии создаём свой класс для items.
**items.py для кинопоиска**
```
import scrapy
class MovieItem(scrapy.Item):
'''Movie scraped info'''
movie_id = scrapy.Field()
name = scrapy.Field()
like = scrapy.Field()
genre = scrapy.Field()
date = scrapy.Field()
country = scrapy.Field()
director = scrapy.Field()
```
* Ищем нужные нам элементы на странице и достаём их xpath. Это можно сделать например через chrome: щёлкаем правой кнопкой мыши на элемент, выбираем inspect element, в коде снова щёлкаем правой кнопкой мыши, и ищем пункт copy -> xpath. Для отладки можно запустить scrapy-shell и передать в него url страницы: `scrapy-shell https://www.kinopoisk.ru/film/518214/`. У вас будет инстанциирован объект response, из которого можно будет получать нужные элементы.
**Вот так:**
```
$scrapy-shell https://www.kinopoisk.ru/film/sakhar-i-korica-1915-201125/
$response.xpath('//span[@itemprop="director"]/a/span/text()').extract_first()
'Эрнст Любич'
```
* Настраиваем обработку полученных объектов. Я выбрал для сохранения запись в базу sqlite, потому что это очень просто.
* Проверяем что всё работает, выставив при запуске параметр `CLOSESPIDER_PAGECOUNT=5`, чтобы ограничить число запросов.
* В бой! Создаём директорию для сохранения промежуточных результатов, например `crawls1`. Запускаем паука с параметром `scrapy crawl myspider -s JOBDIR=crawls1`: теперь, если что-то пойдёт не так, мы сможем перезапустить паука с того же места, где он закончил. Соответствующий раздел в [документации](https://doc.scrapy.org/en/latest/topics/jobs.html).
##### 1.1 Обход ограничения на число запросов.
Кинопоиск забанил меня ещё на этапе отладки паука, когда я отправлял раз в несколько минут пачку из 5-ти запросов с таймаутом в 1 секунду. Чтобы обойти ограничания существует множество опций. Для скрапи легко нагугливаются готовые примеры использования тора, случайного перебора прокси из списка, либо подключения к платным сервисам rotating proxy. Так как у нас ”проект выходного дня”, я выбрал rotating proxy — самый быстрый в реализации вариант, правда приходится подключаться к платному сервису. Как это работает: вы подключаетесь к конкретному ip:port вашего провайдера прокси, а на выходе получаете новый ip на каждый запрос. Со стороны scrapy вам нужно добавить одну строку в файле settings.py своего проекта и в каждом запросе передавать параметр для пары ip:port.
**В коде это выглядит так:**Ищем в settings.py соответствующий раздел и добавляем туда строчку:
```
DOWNLOADER_MIDDLEWARES = {
'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware':543
}
```
Затем в каждом запросе вашего паука:
```
scrapy.Request(url=url, callback=self.parse,
meta={'proxy':'http://YOU_RPROXY_IP:PORT'})
```
Автор вдохновившего меня проекта начал с Nightwish и дальше обходил рекомендации lastfm в ширину, как дерево — поэтому у него получился связный граф. Мой подход был похожим. С кинопоиска можно доставать фильмы по id, который судя по всему просто соответствует порядковому номеру фильма на сайте. Если просто брать все id подрят, то выйдет не очень хорошо, потому что большинство фильмов не имеют рекомендаций и будут одиночными точками, которые превратятся в шум на карте. ID свежих фильмов имеют порядок 500000 — это довольно много для наглядной отрисовки, поэтому начнём со списка топ 250 фильмов и будем итеративно обходить списки рекомендаций каждого фильма.
Я ожидал получить порядка 100 000 фильмов, но к после ночи скрапинга оказалось, что паук остановился на ~12600. Рекомендации в кинопоиске на этом кончаются. Как было упомянуто вначале, за новыми данными я полез на IMDb. Скрапинг IMDb оказался ещё проще. Пара часов на переписывание готового проекта и новый паук готов к старту. Через два-три дня кроулинга (8 запросов в секунду, чтобы не наглеть) паук остановился, собрав 173+ тысячи фильмов. Полный код пауков можно посмотреть на гитхабе: [кинопоиск](https://github.com/iggisv9t/kinoposik-spider) и [IMDb](https://github.com/iggisv9t/imdb-spider).
2. Визуализация
===============
С одной стороны, инструментов визуализации графов целый зоопарк. С другой стороны, когда у речь идёт об очень больших графах, этот зоопарк вдруг куда-то разбегается. Я выбрал для себя два инструмента на такие случаи: это sfdp из [graphviz](https://www.graphviz.org/) и [gephi](https://gephi.org/). SFDP — это CLI утилита с широким набором параметров, способен отрисовывать графы на миллион узлов, но в нашем случае — это не самый удобный инструмент, потому что нам нужно контролировать процесс укладки. Для случаев вроде нашего отлично подходит Gephi — это приложение с графическим интерфейсом и универсальным набором укладок, практически на любой вкус.
Экспорт данных для графа делаем простым скриптом на python. Я обычно использую формат dot, потому что он очень простой, что называется "human readable". Изначально формат предназначен для использования в graphviz, но сейчас поддерживается многими другими приложениями для работы с графами.
**Описание формата**
В начале мы пишем заголовок `digraph kinopoisk {\n` и не забываем в конце файла записать закрывающую скобку `}`. В каждой строке описываем рёбра графа `node1 -> node2;` и закрываем список. Описание формата здесь: [официальные доки](https://www.graphviz.org/doc/info/lang.html) и [простые примеры в википедии](https://en.wikipedia.org/wiki/DOT_(graph_description_language)).
**Пример файла с пояснением**
```
digraph sample {
1 -> 2;
1 -> 3;
5 -> 4 [weight="5"];
4 [shape="circle"];
}
```
`digraph` — значит, что мы объявляем направленный граф. Если нужен не направленный, то пишем просто `graph`. `sample` — это имя нашего графа (не обязательно). В каждой строке обявлены рёбра или вершины. Если рёбра не направленные, то вместо `->` пишем `--`. В квадратных скобках можно объявить параметры ребра или вершины. В этом примере мы задаём ребру между узлами 5 и 4 вес равный пяти, а вершине 4 форму круга. Имена вершин не обязательно обозначать числами, это могут быть и строки. Больше примеров и параметров смотрите в документации. В нашем случае вполне достаточно возможностей описанных выше.
#### 2.1 Сравнение укладок
Для больших графов в gephi есть две разумные опции: OpenOrd и ForceAtlas 2. OpenOrd — очень быстрый приближённый алгоритм, но имеет мало настраиваемых параметров. ForceAtlas похож на другие классические force-directed алгоритмы, даёт более точные результаты, очень гибкий в настройке, но за это приходится платить временем. Ниже примеры работы обоих алгоритмов на графе, представляющем собой сетку.
Модельный граф-сетка. Слева OpenOrd, справа ForceAtlas.
Можно подумать, что OpenOrd вообще не стоит использовать если есть время ждать более точный результат. На самом деле не редки случаи графов, когда ForceAtlas собирает все узлы в один плотный комок, а OpenOrd показывает хоть какую-нибудь структуру.
Для ускорения процесса я использовал OpenOrd в качестве начального приближения и затем "размазывал" граф с помощью ForceAtlas. Чтобы на изображении было хоть что-то понятно, нужно устранить наложение узлов друг на друга. Для этого удобно использовать укладку Yifan Hu — чтобы немного размазать кластера, и noverlap, чтобы совсем устранить наложение. На устранение наложения в графе кинопоиска ушла ночь, с imdb не удалось справиться и за целые выходные.
3. Экспорт результатов: Интерактивная карта
===========================================
Gephi умеет экспортировать картинки в svg, png и много других форматов. Но с большими данными приходят большие сложности. Одной только красивой картинки мало. Мы хотим видеть названия фильмов и как они связаны. Если рисовать метки узлов, то при таком их количестве мы получим совершенно нечитаемое облоко букв. Есть опции использовать SVG и масштабировать его пока не станет что-то видно, или рисовать только самые важные метки. Но есть вариант лучше, на котором я и решил сосредоточиться. Делаем интерактивную карту.
##### Обзор инструментов:
**sigma.js**
Первая опция, одна из самых простых и в то же время самая наглядная — это плагин для gephi с экспортом в [sigma.js](http://sigmajs.org/) шаблон. На гифке выше как раз оно. Устанавливаем плагин через меню gephi, после чего у нас появляется новый пункт меню экспорта во вкладке file. Заполняем форму, экспортируем и получаем готовую рабочую визуализацию. Просто и мощно. Результат можно посмотреть [здесь](https://iggisv9t.github.io/kinopoisk/index.html). Недостаток: на больших графах браузер едва справляется.
**gefx-js**
Следующая опция ещё проще предыдущей и в целом очень похожа. [gefx-js](https://github.com/raphv/gexf-js) — нужно просто экспортировать ваш проект из gephi в формат gexf и положить в папку с шаблоном. Готово. Недостаток точно такой же как в предудщем случае. Более того, если с помощью sigmajs я мог просмотривать граф imdb хотя бы локально, то с gefx-js он просто не загрузился.
**openseadragon**
Для случаев, когда нужно показать очень большую картинку есть [seadragon](https://openseadragon.github.io/). Принцип точно такой же как при рендеринге географических карт: при масштабировании подгружаются новые тайлы, соответствующие текущему увеличению и области просмотра. Именно так и сделал автор вдохновившего меня проекта. Недостаток один: интерактивности минимум. Невозможно выделить узлы, сложно увидеть куда идут рёбра. Невозможно "заглянуть за" перекрытия узлов и рёбер.
**shinglejs**
А что, если сделать что-то вроде смеси предыдущих вариантов, чтобы при масштабировании граф подгружался тайлами, но не картинками, а как в первом случае, с интерактивностью узлов и рёбер? Готовое решение нашлось буквально чудом, это [shinglejs](https://www.ayalpinkus.nl/shinglejs/).
Плюсы: можно рендерить очень (очень-очень) большие графы в браузере, сохраняя интерактивность.
Минусы: Не так красиво, как sigmajs, подготовка данных не тривиальна.
**Скрин графа в с shinglejs**
Не так красиво, зато очень шустро
Для визуализации графа imdb я выбрал последний вариант. Выбора в общем-то и не было. Результат можно посмотреть [здесь](https://iggisv9t.github.io/imdb/index.html), а дальше немного о том, как подготовить данные для такой визуализации.
**Экспорт данных в shinglejs:**
Как я уже сказал, экспорт данных в последнем случае не очень простой, поэтому я приведу пример, как выгрузить граф из gephi для shinglejs.
* Экспортируем граф из gephi в формате gdf — это наверное единственный простой способ получить коордианты узлов в виде таблицы. Структура файла такая: сначала идёт таблица с описанием узлов, затем таблица с описанием рёбер.
* Читаем файл и достаём из него описание вершин и рёбер. Я делал это с помощью pandas, затем рубил датафрейм на два: рёбра и узлы. О работе с [pandas](https://habrahabr.ru/company/ods/blog/322626/).
* Меняем названия колонок в соответствии с доками [shinglejs](https://www.ayalpinkus.nl/shinglejs/) и экспортируем в json. Shinglejs не поддерживает прямого экспорта цветов, зато для каждого узла можно указать "communities" и раскрасить уже их. Поэтому рейтинги фильмов выгружаем как метки сообществ.
* В исходниках главной страницы не забудьте указать список цветов для сообществ. Для окрашивания узла из списка цветов берётся элемент с номером который вычисляется так: `id сообщества % количество цветов`.
* Склеиваем файлы в один. Я делал это через bash: `cat start imdbnodes.json middle imdbedges.json end > imdbdata.json`, предварительно создав файлы `start, middle, stop` содержанием "`{"nodes":`", "`, "relations":`" и "`}`" соответственно.
* Далее по инструкции с [оф. сайта](https://www.ayalpinkus.nl/shinglejs/)
* Не забудьте создать bitmap и положить его в папку с данными графа, иначе на большом отдалении будет видно только несколько узлов или вообще ничего. Автор проекта, кажется, не указал эту деталь, но по умолчанию пример будет пытаться подгрузить файлы `image_2400.jpg` и `image_1200.jpg`, а не npm как может показаться после сборки дефолтного проекта.
4. Интересные наблюдения
========================
На графе lastfm есть явная кластеризация связанная со странами происхождения музыкальных коллективов, например японский поп и рок, греческий метал и т. д. В точности то же самое происходит с фильмами. Очень чётко отделяется корейское кино, турецкое, японское и бразильское. В imdb далеко от основной массы выделяется большой кластер мультфильмов. На обоих графах очень плотно собирается кластер фильмов о супергероях из комиксов. Вроде бы очевидно, но тем не менее неожиданно, что плохие фильмы собираются в одно большое облако. Есть отдельные кластера музыкальных клипов, детских youtube-блогов и фанатских фильмов по вселенной Гарри Поттера.
5. Что ещё можно делать с этими данными
=======================================
Я уверен, что читатели смогут придумать и сделать на полученных данных ещё много интересных проектов. Мне в голову сразу приходят такие идеи:
* Кластеризовать и составлять тематические подборки. У меня отлично отработал DBSCAN почти с первого захода. (Пример будет дальше)
* Делать собственные рекомендательные системы
* Собирать интересные статистики о фильмах в целом
* Конечно же, расширять свою фильмотеку.
### 5.1 DBSCAN
Для кластеризации графов есть много специальных методов, и все они достойны отдельных статей. Я в качестве эксперимента использовал метод для графов не предназначенный. Рассуждения были такими: раз визуально граф разложился на облака похожих фильмов, то области где фильмы особенно плотно сблизились можно найти с помощью [DBSCAN](https://en.wikipedia.org/wiki/DBSCAN). Давайте разберёмся, что этот метод делает, не вдаваясь в глубокие подробности. Название DBSCAN расшифровывается как density-based scan, то есть применяя этот метод, мы объединяем точки, которые расположены друг к другу достаточно плотно. Формализуется это через два основных гиперпараметра — это радиус, в котором мы ищем соседей для каждой точки и минимальное число соседей.
**1. Получаем координаты.**
Для этого экспортируем наш граф из gephi в формате gdf. Читаем файл как csv с помощью pandas:
```
data = pd.read_csv('./kinopoisk.gdf')
# gdf содержит как-бы два файла в одном
# сначала описание вершин, а потом описание рёбер
# pandas читает это как целый файл, а недостающие поля в конце
# заполняет как nan поэтому можно достать информацию о вершинах например вот так
data_nodes = data[data['y DOUBLE'].apply(lambda x: not np.isnan(x))]
```
Давайте теперь нарисуем и посмотрим, на что это похоже.
```
plt.figure(figsize=(7, 7))
plt.scatter(data['x DOUBLE'].values, data['y DOUBLE'].values, marker='.', alpha=0.3);
```
Отлично, DBSCAN с таким должен справиться.
**2. Кластеризуем.**
Подбираем параметры и смотрим на распределение размеров кластеров. Никакой серьёзной работы не планировалось, поэтому качество я оценивал "на глаз".
```
from sklearn.cluster import DBSCAN
coords = data_nodes[['x DOUBLE', 'y DOUBLE']].values
dbscan = DBSCAN(eps=70, min_samples=5, leaf_size=30, n_jobs=-1)
labels = dbscan.fit_predict(coords)
plt.hist(labels, bins=50);
```
Распределение по размерам кластеров
Давайте раскрасим наши точки в цвета кластеров и посмотрим насколько результат похож на правду.
```
plt.figure(figsize=(8, 8))
for l in set(labels):
coordsm = coords[labels == l]
plt.scatter(coordsm[:,0], coordsm[:,1], marker='.', alpha=0.3);
```
Выглядит как то, что мы и хотели получить.
Попробуем получить кластер какого-нибудь фильма в виде списка. Я не позаботился о том, чтобы сделать удобный способ получения списка, поэтому в этот раз без кода. Ниже список фильмов, который попали в один кластер с "реальными упырями". По-моему неплохо.
**Таблица с фильмами**
| movie\_id | name | date | genre | country | director |
| --- | --- | --- | --- | --- | --- |
| 271695 | Третья планета от Солнца | 1996-01-09 | фантастика | США | Терри Хьюз |
| 663135 | Соседи | 2012-09-26 | комедия | США | Крис Кох |
| 277375 | Инопланетяне | 1997-11-07 | мультфильм | Франция | Джим Гомез |
| 81845 | Суини Тодд, демон-парикмахер с Флит-стрит | 2007-12-03 | мюзикл | США | Тим Бёртон |
| 445196 | Руки-ноги за любовь | 2010-10-29 | триллер | Великобритания | Джон Лэндис |
| 271878 | Красный отель | 2007-12-05 | комедия | Франция | Жерар Кравчик |
| 3609 | Планкетт и Маклейн | 1999-01-22 | боевик | Великобритания | Джейк Скотт |
| 183497 | Бурк и Харе | 1972-02-03 | ужасы | Великобритания | Вернон Сьюэлл |
| 3482 | Доктор и дьяволы | 1985-10-04 | ужасы | Великобритания | Фредди Фрэнсис |
| 2528 | Ценности семейки Аддамс | 1993-11-19 | фэнтези | США | Барри Зонненфельд |
| 503578 | Колыбельная | 2010-02-12 | фэнтези | Польша | Юлиуш Махульский |
| 87404 | Красная харчевня | 1951-10-19 | комедия | Франция | Клод Отан-Лара |
| 5293 | Семейка Аддамс | 1991-11-22 | фэнтези | США | Барри Зонненфельд |
| 18089 | Похитители тел | 1945-02-16 | ужасы | США | Роберт Уайз |
| 271846 | Продавец мертвых | 2008-10-10 | ужасы | США | Гленн МакКвейд |
| 272111 | Свежезахороненные | 2007-09-09 | драма | Канада | Чаз Торн |
| 34186 | Эльвира: Повелительница тьмы | 1988-09-30 | комедия | США | Джеймс Синьорелли |
| 818981 | Реальные упыри | 2014-01-19 | комедия | Новая Зеландия | Джемейн Клемент |
| 8421 | Эдвард руки-ножницы | 1990-12-06 | фэнтези | США | Тим Бёртон |
| 5622 | Сонная Лощина | 1999-11-17 | ужасы | США | Тим Бёртон |
| 2389 | Битлджус | 1988-03-29 | фэнтези | США | Тим Бёртон |
Мне такой подход кажется интересным из-за того, что мы получаем список похожих фильмов, которые не обязательно связаны прямыми рекомендациями, и даже не обязательно достижимы за небольшое число шагов при обходе графа. То есть, так можно найти фильм, который попадётся если просто кликать похожие фильмы прямо на сайте.
P. S.
Спасибо всем друзьям, которые готовы были отвечать на мои вопросы, всем киноманам — новых открытий, а датасаентистам качественных данных! | https://habr.com/ru/post/348110/ | null | ru | null |
# Простой WebSocket-сервер на Node.JS
Сейчас мы с вами напишем простой WebSocket-сервер на node.js. При подключении к этому серверу в ответ придёт приветственное сообщение. А так же будет доступна к выполнению пара не сложных команд.
Для этого потребуется установить [Node.js](https://nodejs.org/en/download/) с менеджером пакетов npm, он идёт в комплекте
### Настройка проекта
В начале, нам потребуется создать директорию будущего проекта
```
mkdir websocket-server-node
```
Переходим в директорию
```
cd websocket-server-node
```
Далее нужно инициализировать новый проект через npm
```
npm init
```
Установщик потребует ответить на несколько вопросов, их можно пропустить
После инициализации проекта, необходимо добавить в проект библиотеку [WS](https://www.npmjs.com/packege/ws) и настройку для работы с текстом в UTF-8
```
npm install ws
```
```
npm install --save-optional utf-8-validate
```
### Код websocket-сервера
Теперь приступим к написанию кода. В директории проекта создадим новый файл **server.js**, откроем файл. Далее я последовательно опишу весь код, а вот [ссылка на полный код на GitHub](https://github.com/bkwebeagle/websocket-server-nodejs).
#### server.js:
В начале нужно подключить библиотеку для работы с websocket
```
const WebSocket = require('ws');
```
Далее, создадим константу, экземпляр класса WebSocket, с указанием порта на котором будет запущен WebSocket-сервер.
```
const wsServer = new WebSocket.Server({port: 9000});
```
В отличии от HTTP-сервера, WebSocket-сервер принимает подключение и удерживает его. HTTP-сервер принимает запросы напрямую, а WebSocket-сервер принимает запросы от подключения, такое соединение является полнодуплексное.
Напишем обработчик подключения, в качестве обработчика укажем функцию **onConnect**.
```
wsServer.on('connection', onConnect);
```
В момент подключения нового клиента в onConnection передаётся объекта ws-соединения, через него сервер будет общаться с каждым конкретным клиентом.
Функция onConnect принимает только один параметр, назовём его wsClient. В нашем конкретном примере мы подключим только два обработчика событий на объект wsClient: message и close.
**message** - обрабатывает событие входящего сообщения от клиента.
**close** - событие разрыва соединения с клиентом.
В самом начале функции onConnect, выведем в консоль сообщение что новый пользователь в сети. И отправим клиенту приветственное сообщение
Далее опишу заготовку для функции onConnect:
```
function onConnect(wsClient) {
console.log('Новый пользователь');
// отправка приветственного сообщения клиенту
wsClient.send('Привет');
wsClient.on('message', function(message) {
/* обработчик сообщений от клиента */
}
wsClient.on('close', function() {
// отправка уведомления в консоль
console.log('Пользователь отключился');
}
}
```
На событие **close** сервер выведет в консоль уведомление.
Теперь напишем обработчик сообщений со стороны клиента. Договоримся, что команды сервер будет принимать в JSON-формате. JSON позволит отдельно указывать команду и параметры, а ответ сервера будет возвращаться в текстовом формате.
Формат JSON команд от клиента:
```
{
action: 'ECHO' | 'PING',
data?: string // необязательный параметр
}
```
Как видно из формата, сервер будет принимать две команды:
* echo-запрос, в ответ на который сервер отправит содержимое data
* ping, в ответ сервер отправит pong
* если команда не известна, сервер выведет в консоль уведомление "Неизвестная команда"
**Содержимое обработчика сообщений от клиента:**
```
try {
// сообщение пришло текстом, нужно конвертировать в JSON-формат
const jsonMessage = JSON.parse(message);
switch (jsonMessage) {
case 'ECHO':
wsClient.send(jsonMessage.data);
break;
case: 'PING':
setTimeout(function() {
wsClient.send('PONG');
}, 2000);
break;
default:
console.log('Неизвестная команда');
break;
}
} catch (error) {
console.log('Ошибка', error);
}
```
Как вы уже видите, на команду PING сервер не сразу ответит, а подождёт 2 секунды.
Добавим в конце файла server.js строку, которая выведет в консоль информацию, на каком порту запущен сервер.
```
console.log('Сервер запущен на 9000 порту');
```
### Запуск сервера
Для запуска сервера необходимо перейти в консоль и ввести команду:
```
node server.js
```
Сервер доступен локально по адресу <ws://localhost:9000>. Остановить сервер можно сочетанием клавиш:
* Для Windows и Linux (Ctrl + C)
* Для MacOs (Cmd + C)
Если хотите проверить работу сервера с другого устройства в рамках локальной сети, то откройте ещё одно окно консоли и запустите команду
для Window:
```
ipconfig
```
для Linux и MacOS:
```
ifconfig
```
В моём случае локальный адрес **192.168.0.15**, значит из локальной сети сервер будет доступен по адресу **ws://192.168.0.15:9000**.
### Проверка работы сервера
Чтобы протестировать работу сервера, откроем любую страницу в браузере и нажмём клавишу F12. Откроется DevTools, перейдём в консоль браузера и скопируем следующий код:
```
const myWs = new WebSocket('ws://localhost:9000');
// обработчик проинформирует в консоль когда соединение установится
myWs.onopen = function () {
console.log('подключился');
};
// обработчик сообщений от сервера
myWs.onmessage = function (message) {
console.log('Message: %s', message.data);
};
// функция для отправки echo-сообщений на сервер
function wsSendEcho(value) {
myWs.send(JSON.stringify({action: 'ECHO', data: value.toString()}));
}
// функция для отправки команды ping на сервер
function wsSendPing() {
myWs.send(JSON.stringify({action: 'PING'}));
}
```
Запустите этот код. Далее в консоли браузера вызовите функцию wsSendPing:
```
wsSendPing()
```
Через 2 секунды сервер пришлёт ответ, и в консоли выведется:
**Message: PONG**
Вызовите функцию wsSendEcho, к примеру, с содержимым "Test!", и в консоли будет выведено:
**Message: Test!**
Вот и всё! Кому понравилось, ставьте Like, подписывайтесь. Всем Добра!
[Ссылка на полный код GitHub](https://github.com/bkwebeagle/websocket-server-nodejs) | https://habr.com/ru/post/546758/ | null | ru | null |
# Запуск предустановленной копии Windows в VirtualBox под Ubuntu
Озадачился вчера таким вопросом. Итак, в наличии:
— лаптоп с Pentium Dual-Core 1.86 GHz и 2GB памяти
— стоящие на одном винте Ubuntu 9.04 и Windows XP SP3. Винда побита на два раздела — системный и хранилище.
— желание запустить существующую винду из убунты
Зачем? Собственно, просто влом было ставить новую винду в виртуалбоксе при наличии уже стоящей с нужным набором софта.
Сразу скажу, работает медленно (как собственно и ожидалось), но для браузерных тестов и ещё мелочей каких должно хватить. И ещё **ВАЖНО** — при лицензионной винде она должна запросить реактивации изи-за существенной смены оборудования.
После некоторого гугления нашлась [вот эта статья](http://blarts.wordpress.com/2007/12/06/how-to-run-virtualbox-using-a-physical-partition-using-ubuntu-feisty-fawn/), по которой всё было и сделано.
Вкратце о шагах:
— добавить своего юзера в группу disk через `sudo vi /etc/group` или `sudo usermod -a -G disk`
— перегрузиться в винду. Именно перегрузиться — для того чтобы сработало добавление прав нужен релогин. Пробовал без перезагрузки зайти по ssh — не работало создание файла образа (см. ниже)
— в винде добавить новый профиль оборудования и перегрузиться обратно
— в убунте выполнить
`VBoxManage internalcommands createrawvmdk -filename /pat/to/file.wmdk -rawdisk /dev/sda -register`
Должно получиться что-то вроде следующего:
`VirtualBox Command Line Management Interface Version 2.1.4_OSE
(C) 2005-2009 Sun Microsystems, Inc.
All rights reserved.
RAW host disk access VMDK file /home/halien/build/Win/image_sda1.wmdk created successfully.`
здесь важно указать именно диск на котором стоит основной загрузчик, не раздел винды. То есть будет запускаться с загрузчика и выбора ОС.
— добавить в виртуалбоксе новую запись выбрав в качестве образа свежесозданный файл
— поставить не слишком мало памяти (я пробовал на ~800MB)
— запустить, не забывая выбрать ОС и профиль оборудования
— Важно **НЕ** ставить Guest Additions в предустановленную винду — иначе а) она перестанет загружатсья до их удаления и б) (не подтверждено, но больше вроде нечему) слетает кодировка в русских текстовых страницах при загрузке (выбор режима загрузки, профиля оборудования)
Вот, собственно, и всё. | https://habr.com/ru/post/68421/ | null | ru | null |
# Drag and Drop для вставки картинок
Не так давно был [анонсирован](http://habrahabr.ru/blogs/GMail/91131/) функционал прикладывания файлов к письму через Drag'n'drop. На днях команда GMail расширила эту функцию, добавив возможность прикладывать картинки прямо в тело письма перетаскиванием файлов.
Раньше тоже можно было добавлять картинки, включив в Labs соответствующую функцию. Однако опыт показывает, что многим удобнее перетаскивание.
Работает этот функционал, пока, только в браузере Google Chrome (впервые фича GMail работает только в Chrome. Правда может еще в Сафари? Я не проверял), но скорее всего в ближайшее время этот функционал добавят ещё и в Firefox. Чтобы добавлять картинки, письмо, конечно, должно быть формата Rich text.
Картинка загружается на сервер GMail как attachment. После добавления появляется плашка изменения размера, которая, в отличие о подобного функционала в blogger.com, реальный размер картинки не меняет, точнее не подставляет уменьшенную копию, а просто выставляет размеры тегу img. Это и плюс и минус одновременно. Конечно, хотелось бы чтобы GMail делал пиктограмку с увеличением до оригинала по клику, но это бы увеличило объем информации, который хранится на серверах GMail.
Ну и последняя ложка дёгтя: попытка перетащить несколько картинок сразу ни к чему не приведёт. В общем, команде GMail ещё есть над чем работать.
`xPost: Выдернув из Контекста` | https://habr.com/ru/post/93436/ | null | ru | null |
# Простейшая реализация HashMap на Go
Всем доброго времени суток. Для начинающего программиста (коим я и являюсь) реализация базовых структур данных, по типу бинарных деревьев и связных списков, довольно легка. Чего не скажешь о хэш картах. В этой статье мы и разберём пример её реализации.
Об устройстве хэш карты
-----------------------
В данном примере мы будем рассматривать хэш-карту на базе функции[**хеширования Пирсона**](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%9F%D0%B8%D1%80%D1%81%D0%BE%D0%BD%D0%B0). Данная функция имеет на выходе число типа`uint8`, как следствие мы можем использовать 256 ячеек памяти для хранения результата на базе ключа. Однако есть такой недостаток хэш-функций как коллизии. Тут в дело вступают связные списки. Условимся, что наша структура хэш-картыбудет иметь в себе массив длинною 256, а каждый из элементов будет являться связным списком.
Разберёмся на примере
---------------------
Начнём с хэш-функции.
Краткими словами эта функция получающая на вход любое количество байт и возвращающая при этом 1 байт. Её реализация базируется на наборе инструкций (в данном случае сдвиг элемента на номер символа в таблицы ASCII), а так же на 256-байтной таблицы поиска, содержащей перестановку значений от 0 до 255.
```
var table[256]int = func()[256]int {
var data [256]int
rand.Seed(time.Now().Unix())
for index, _ := range(data) { data[index] = index }
for index, _ := range(data) {
rv := rand.Intn(256)
data[index], data[rv] = data[rv], data[index]
}
return data
}()
```
В начале мы создаём массив из 256 элементов, каждый из которых имеет значение, равное своему индексу, а затем перемешиваем эти элементы в рандомном порядке.
```
func hash8(message string) int {
// using global table
var hash int = len(message)%256
for _, value := range(message) {
hash = table[(hash + int(value))%256]
}
return hash
}
```
А вот и реализация алгоритма :)
Рассмотрим её поподробнее. Получая на вход строку, мы декларируем переменную `hash`равную`(длина строки) mod 256`, она же и будет служить результатом хэш-функции. Далее итерируя по строке мы присваиваем `hash`значение равное значение элемента таблицы поиска по индексу `(hash + номер в ASCII) mod 256`.
Разобравшись с хэш-функцией рассмотрим реализацию самой хэш-карты.
```
type Node struct {
key string
value string
next *Node
}
type List struct {
head *Node
}
type Map struct {
map_list [256]*List
len int64
}
```
Как и писалось выше хэш-карта базируется на массиве длинною 256 элементов. Каждый элемент это начало/голова связного списка `List`, состоящего из узлов `Node`, которые в свою очередь имеют переменные ключ `key` и значение `value`. Помимо того `Map` имеет переменную `len`, которая нужна для подсчёта длины карты.
Теперь перейдём к методам. Для начала надо реализовать метода работы связного списка:
1. Вставка элемента
2. Удаление элемента
3. Вывод элементов (в частность ключей)
СпойлерНиже мы не будем детально рассматривать реализацию методов связного списка...
Об это как-нибудь будет пост.
```
func (l *List) add(key, val string, m *Map) {
new_data := &Node{value: val, key: key}
if l.head == nil {
l.head = new_data
m.len++
} else {
current := l.head
for current.next != nil {
if key == current.key {
current.value = val
return
}
current = current.next
}
if key == current.key {
current.value = val
return
}
current.next = new_data
m.len++
}
}
```
Для вставки элемента мы проходим по связному списку, при нахождении такого же ключа, как и входного, изменяем значение, в ином случае добавляем в конец новый элемент и увеличиваем счётчик длины на 1.
```
func (l *List) delete(key string, m *Map) {
current := l.head
if current.key == key {
l.head = l.head.next
m.len--
return
}
for current.next != nil {
if current.next.key == key {
current.next = current.next.next
m.len--
return
}
current = current.next
}
panic("Key is missing!!")
}
```
Для удаления элемента там необходимо пройтись по списку и найти нужный ключ и удалить этот элемент (заменив его на следующий), попутно уменьшив счётчик длины. В случае отсутствия ключа возвращаем ошибку.
```
func (l *List) print() []string {
var result []string
current := l.head
if current != nil {
result = append(result, current.key)
}
for current.next != nil {
result = append(result, current.next.key)
current = current.next
}
return result
}
```
Для получения ключей списка мы проходим по нему и собираем все ключи в массив `result`, а затем возвращаем его.
Следующим шагом необходимо реализовать методы самой структуры `Map`***:*** 1. Вставка
2. Удаление
3. Получение значения по ключу
4. Получение всех ключей
```
func (m *Map) insert(key, val string) {
if m.map_list[hash8(key)] == nil {
m.map_list[hash8(key)] = &List{}
}
m.map_list[hash8(key)].add(key, val, m)
}
```
Для вставки элемента мы проверяем наличие данных в массиве по индексу результата хэш-функции, в случае, если его нет создаём экземпляр структуры `List`. Иначе у нас возникает коллизия. Для этого обращаемся к элементу (который является экземпляром структуры `List`) и вызываем у него ранее описанный метод `add`.
```
func (m *Map) delete(key string) {
elem := m.map_list[hash8(key)]
if elem == nil { panic("Map is nil!!") }
if elem.head.key == key && elem.head.next == nil {
m.map_list[hash8(key)] = nil
m.len--
fmt.Println("+")
} else if elem.head.next != nil {
elem.delete(key, m)
} else {
panic("Key is missing!!")
}
}
```
Для реализации удаления элемента проверяем наличие элемента в массиве по индексу результата хэш-функции:
* Если элемент пустой, то возвращаем ошибку.
* Если есть элемент, но следующего за ним нет, то присваиваем элементу массива `nil`.
* Если есть элемент и последующий за ним, то вызываем метод `delete` у элемента массива (который имеет тип `*List)`.
* В ином случае возвращаем ошибку о том, что ключ отсутствует.
```
func (m *Map) get_value(key string) string {
if m.map_list[hash8(key)] == nil { panic("Map is nil!!") }
current := m.map_list[hash8(key)].head
if current != nil && current.key == key { return current.value }
for current.next != nil {
if current.next.key == key { return current.next.value }
current = current.next
}
panic("Key is missing!!")
}
```
Чтобы получить значение по ключу, необходимо получить связный список из массива на основе результата хэш-функции. Далее пройтись по связному списку, сравнивая входной и текущий ключ.
```
func (m *Map) keys() []string {
var answer [] string
for _, data := range(m.map_list) {
if data != nil { answer = append(answer, data.print()...)}
}
return answer
}
```
Для выгрузки всех ключей мы проходим по всему массиву. Если в элементе есть данные, то дополняем слайс `answer` результативным слайсом функции `print` у структуры `List`.
Итоги
-----
Мы разобрались, как реализовать простую хэш-карту на основе 8-битной [хэш-функции Пирсона](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%9F%D0%B8%D1%80%D1%81%D0%BE%D0%BD%D0%B0#:~:text=%D0%A5%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%20%D0%9F%D0%B8%D1%80%D1%81%D0%BE%D0%BD%D0%B0%20%E2%80%94%20%D1%85%D0%B5%D1%88%2D%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F%2C,%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D1%82%20%D0%BE%D1%82%20%D0%BA%D0%B0%D0%B6%D0%B4%D0%BE%D0%B3%D0%BE%20%D0%B1%D0%B0%D0%B9%D1%82%D0%B0%20%D0%B2%D0%B2%D0%BE%D0%B4%D0%B0.) с помощью языка Go. Рассмотрели краевые случаи всех описанных методов, а так же возникновение коллизии. Сложность данной структуры (как на чтение, так и на запись) я бы оценил в наилучшем случает, как O(1), в наихудшем же случае она доходит до O(n), при возникновении коллизии и формировании связного списка длинною > 1.
[Исходный код](https://github.com/BinaryBun/hash_map8bit) | https://habr.com/ru/post/688964/ | null | ru | null |
# Exceptional situations: part 1 of 4
[](https://github.com/sidristij/dotnetbook)
Introduction
------------
It’s time to talk about exceptions or, rather, exceptional situations. Before we start, let’s look at the definition. What is an exceptional situation?
This is a situation that makes the execution of current or subsequent code incorrect. I mean different from how it was designed or intended. Such a situation compromises the integrity of an application or its part, e.g. an object. It brings the application into an extraordinary or exceptional state.
But why do we need to define this terminology? Because it will keep us in some boundaries. If we don’t follow the terminology, we can get too far from a designed concept which may result in many ambiguous situations. Let’s see some practical examples:
```
struct Number
{
public static Number Parse(string source)
{
// ...
if(!parsed)
{
throw new ParsingException();
}
// ...
}
public static bool TryParse(string source, out Number result)
{
// ..
return parsed;
}
}
```
This example seems a little strange, and it is for a reason. I made this code slightly artificial to show the importance of problems appearing in it. First, let’s look at the `Parse` method. Why should it throw an exception?
* Because the parameter it accepts is a string, but its output is a number, which is a value type. This number can’t indicate validity of calculations: it just exists. In other words, the method has no means in its interface to communicate a potential problem.
* On the other hand, the method expects a correct string that contains some number and no redundant characters. If it doesn’t contain, there is a problem in prerequisites to the method: the code which calls our method has passed wrong data.
Thus, the situation when this method gets a string with incorrect data is exceptional because the method can return neither a correct value nor anything. Thus, the only way is to throw an exception.
The second variant of the method can signal some problems with input data: the return value here is `boolean` which indicates successful execution of the method. This method doesn’t need to use exceptions to signal any problems: they are all covered by the `false` return value.
Overview
--------
Exceptions handling might look as easy as ABC: we just need to place `try-catch` blocks and wait for corresponding events. However, this simplicity became possible due to the tremendous work of CLR and CoreCLR teams that unified all the errors that come from all directions and sources into the CLR. To understand what we are going to talk about next, let’s look at a diagram:
We can see that inside big .NET Framework there are two worlds: everything that belongs to CLR and everything that doesn’t, including all possible errors appearing in Windows and other parts of the unsafe world.
* Structured Exception Handling (SEH) is a standard way Windows handles exceptions. When `unsafe` methods are called and exceptions are thrown, there is the unsafe <-> CLR conversion of exceptions in both directions: from unsafe to CLR and backward. This is because CLR can call an unsafe method which can call a CLR method in turn.
* Vectored Exception Handling (VEH) is a root of SEH and allows you to put your handlers in places where exceptions might be thrown. In particular, it used for placing `FirstChanceException`.
* COM+ exceptions appear when the source of a problem is a COM component. In this case, a layer between COM and a .NET method must convert a COM error into a .NET exception.
* And, of course, wrappers for HRESULT. They are introduced to convert a WinAPI model (an error code is contained in a return value, while return values are obtained using method parameters) into a model of exceptions because it is an exception that is standard for .NET.
On the other hand, there are languages above CLI each of which more or less have functions for handling exceptions. For example, recently VB.NET or F# had a richer exception handling functionality expressed in a number of filters that didn’t exist in C#.
Return codes vs. exception
--------------------------
Separately, I should mention a model of handling application errors using return codes. The idea of simply returning an error is plain and clear. Moreover, if we treat exceptions as a `goto` operator, the use of return codes becomes more reasonable: in this case, the user of a method sees the possibility of errors and can understand which errors may occur. However, let’s not guess what is better and for what, but discuss the problem of choice using a well reasoned theory.
Let’s suppose that all methods have interfaces to deal with errors. Then all methods would look like:
```
public bool TryParseInteger(string source, out int result);
public DialogBoxResult OpenDialogBox(...);
public WebServiceResult IWebService.GetClientsList(...);
public class DialogBoxResult : ResultBase { ... }
public class WebServiceResult : ResultBase { ... }
```
And their use would look like:
```
public ShowClientsResult ShowClients(string group)
{
if(!TryParseInteger(group, out var clientsGroupId))
return new ShowClientsResult { Reason = ShowClientsResult.Reason.ParsingFailed };
var webResult = _service.GetClientsList(clientsGroupId);
if(!webResult.Successful)
{
return new ShowClientsResult { Reason = ShowClientsResult.Reason.ServiceFailed, WebServiceResult = webResult };
}
var dialogResult = _dialogsService.OpenDialogBox(webResult.Result);
if(!dialogResult.Successful)
{
return new ShowClientsResult { Reason = ShowClientsResult.Reason.DialogOpeningFailed, DialogServiceResult = dialogResult };
}
return ShowClientsResult.Success();
}
```
You may think this code is overloaded with error handling. However, I would like you to reconsider your position: everything here is an emulation of a mechanism that throws and handles exceptions.
How can a method report a problem? It can do it by using an interface for reporting errors. For example, in `TryParseInteger` method such interface is represented by a return value: if everything is OK, the method will return `true`. If it’s not OK, it will return `false`. However, there is a disadvantage here: the real value is returned via `out int result` parameter. The disadvantage is that on the one hand the return value is logically and by perception has more "return value” essence than that of `out` parameter. On the other hand, we don’t always care about errors. Indeed, if a string intended for parsing comes from a service that generated this string, we don’t need to check it for errors: the string will always be correct and good for parsing. However, suppose we take another implementation of the method:
```
public int ParseInt(string source);
```
Then, there is a question: if a string does have errors, what should the method do? Should it return zero? This won’t be correct: there is no zero in the string. In this case, we have a conflict of interests: the first variant has too much code, while the second variant has no means to report errors. However, it’s actually easy to decide when to use return codes and when to use exceptions.
> If getting an error is a norm, choose a return code. For example, it is normal when a text parsing algorithm encounters errors in a text, but if another algorithm that works with a parsed string gets an error from a parser, it can be critical or, in other words, exceptional.
Try-Catch-Finally in brief
--------------------------
A `try` block covers a section where a programmer expects to get a critical situation which is treated as a norm by external code. In other words, if some code considers its internal state inconsistent based on some rules and throws an exception, an external system, which has a broader view of the same situation, can catch this exception using a `catch` block and normalize the execution of application code. Thus, *you legalize exceptions in this section of code by catching them*. I think it is an important idea that justifies the ban on catching all `try-catch(Exception ex){ ...}` exceptions *just in case*.
It doesn’t mean that catching exceptions contradicts some ideology. I say that you should catch only the errors that you expect from a particular section of code. For example, you can’t expect all types of exceptions inherited from `ArgumentException` or you can’t get `NullReferenceException`, because often it means that a problem is rather in *your* code than in a called one. But it’s appropriate to expect that you won’t be able to open an intended file. Even if you 200% sure you will be able, don’t forget to check.
The `finally` block is also well known. It is suitable for all cases covered by `try-catch` blocks. Except for several rare *special* situations, this block will *always* work. Why was such a guarantee of performance introduced? To clean up those resources and groups of objects which were allocated or captured in `try` block and which this block has responsibility for.
This block is often used without `catch` block when we don’t care which error broke an algorithm, but we need to clean up all resources allocated for this algorithm. Let’s look at a simple example: a file copying algorithm needs two open files and a memory range for a cash buffer. Imagine that we allocated memory and opened one file, but couldn’t open another one. To wrap everything in one "transaction” atomically we put all three operations in a single `try` block (as a variant of implementation) with resources cleaned in `finally`. It may seem like a simplified example but the most important is to show the essence.
What C# actually lacks is a `fault` block which is activated whenever an error occurs. It’s like `finally` on steroids. If we had this, we could, for example, create a single entry point to log exceptional situations:
```
try {
//...
} fault exception
{
_logger.Warn(exception);
}
```
Another thing I should touch in this introduction is exception filters. It is not a new feature on the .NET platform but C# developers may be new to it: exception filtering appeared only in v. 6.0. Filters should normalize a situation when there is a single type of exception that combines several types of errors. It should help us when we want to deal with a particular scenario but have to catch the whole group of errors first and filter them later. Of course, I mean the code of the following type:
```
try {
//...
}
catch (ParserException exception)
{
switch(exception.ErrorCode)
{
case ErrorCode.MissingModifier:
// ...
break;
case ErrorCode.MissingBracket:
// ...
break;
default:
throw;
}
}
```
Well, we can now rewrite this code properly:
```
try {
//...
}
catch (ParserException exception) when (exception.ErrorCode == ErrorCode.MissingModifier)
{
// ...
}
catch (ParserException exception) when (exception.ErrorCode == ErrorCode.MissingBracket)
{
// ...
}
```
The improvement here is not in the lack of `switch` construct. I believe this new construct is better in several things:
* using `when` for filtering we catch exactly what we want and it’s right in terms of ideology;
* the code becomes more readable in this new form. Looking through code our brain can identify blocks for handling errors more easily as it initially searches for `catch` and not `switch-case`;
* the last but not least: a preliminary comparison is BEFORE entering the catch block. It means that if we make wrong guesses about potential situations, this construct will work faster than `switch` in the case of throwing an exception again.
Many sources say that the peculiar feature of this code is that filtering happens *before* stack unrolling. You can see this in situations when there are no other calls except usual between the place where an exception is thrown and the place where filtering check occurs.
```
static void Main()
{
try
{
Foo();
}
catch (Exception ex) when (Check(ex))
{
;
}
}
static void Foo()
{
Boo();
}
static void Boo()
{
throw new Exception("1");
}
static bool Check(Exception ex)
{
return ex.Message == "1";
}
```
You can see from the image that the stack trace contains not only the first call of `Main` as the point to catch an exception, but the whole stack before the point of throwing an exception plus the second entering into `Main` via unmanaged code. We can suppose that this code is exactly the code for throwing exceptions that is in the stage of filtering and choosing a final handler. However, *not all calls can be handled without stack unrolling*. I believe that excessive uniformity of the platform generates too much confidence in it. For example, when one domain calls a method from another domain it is absolutely transparent in terms of code. However, the way methods calls work is an absolutely different story. We are going to talk about them in the next part.
### Serialization
Let’s start by looking at the results of running the following code (I added the transfer of a call across the boundary between two application domains).
```
class Program
{
static void Main()
{
try
{
ProxyRunner.Go();
}
catch (Exception ex) when (Check(ex))
{
;
}
}
static bool Check(Exception ex)
{
var domain = AppDomain.CurrentDomain.FriendlyName; // -> TestApp.exe
return ex.Message == "1";
}
public class ProxyRunner : MarshalByRefObject
{
private void MethodInsideAppDomain()
{
throw new Exception("1");
}
public static void Go()
{
var dom = AppDomain.CreateDomain("PseudoIsolated", null, new AppDomainSetup
{
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
});
var proxy = (ProxyRunner) dom.CreateInstanceAndUnwrap(typeof(ProxyRunner).Assembly.FullName, typeof(ProxyRunner).FullName);
proxy.MethodInsideAppDomain();
}
}
}
```
We can see that stack unrolling happens before we get to filtering. Let’s look at screenshots. The first is taken before the generation of an exception:
The second one is after it:
Let’s study call tracing before and after exceptions are filtered. What happens here? We can see that platform developers made something that at first glance looks like the protection of a subdomain. The tracing is cut after the last method in the call chain and then there is the transfer to another domain. But I think this looks strange. To understand why this happens let’s remember the main rule for types that organize the interaction between domains. These types should inherit `MarshalByRefObject` and be serializable. However, despite the strictness of C# exception types can be of any nature. What does it mean? This means that situations may occur when an exception inside a subdomain can be caught in a parent domain. Also, if a data object that can get into an exceptional situation has some methods that are dangerous in terms of security they can be called in a parent domain. To avoid this, the exception is first serialized and then it crosses the boundary between application domains and appears again with a new stack. Let’s check this theory:
```
[StructLayout(LayoutKind.Explicit)]
class Cast
{
[FieldOffset(0)]
public Exception Exception;
[FieldOffset(0)]
public object obj;
}
static void Main()
{
try
{
ProxyRunner.Go();
Console.ReadKey();
}
catch (RuntimeWrappedException ex) when (ex.WrappedException is Program)
{
;
}
}
static bool Check(Exception ex)
{
var domain = AppDomain.CurrentDomain.FriendlyName; // -> TestApp.exe
return ex.Message == "1";
}
public class ProxyRunner : MarshalByRefObject
{
private void MethodInsideAppDomain()
{
var x = new Cast {obj = new Program()};
throw x.Exception;
}
public static void Go()
{
var dom = AppDomain.CreateDomain("PseudoIsolated", null, new AppDomainSetup
{
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
});
var proxy = (ProxyRunner)dom.CreateInstanceAndUnwrap(typeof(ProxyRunner).Assembly.FullName, typeof(ProxyRunner).FullName);
proxy.MethodInsideAppDomain();
}
}
```
For C# code could throw an exception of any type (I don’t want to torture you with MSIL) I performed a trick in this example casting a type to a noncomparable one, so we could throw an exception of any type, but the translator would think that we use `Exception` type. We create an instance of the `Program` type, which is not serializable for sure, and throw an exception using this type as workload. The good news is that you get a wrapper for non-Exception exceptions of `RuntimeWrappedException` which will store an instance of our `Program` type object inside and we will be able to catch this exception. However, there is bad news that supports our idea: calling `proxy.MethodInsideAppDomain();` will generate `SerializationException`:
Thus, you can’t transfer such an exception between domains as it is not possible to serialize it. This, in turn, means that using exception filters for wrapping methods calls in other domains will anyway lead to stack unrolling despite that the serialization seems to be unnecessary with `FullTrust` settings of a subdomain.
> We should pay additional attention to the reason why serialization between domains is so necessary. In our artificial example, we create a subdomain which doesn’t have any settings. It means it works in FullTrust way. CLR fully trusts its content and doesn’t run any additional checks. However, when you insert at least one security setting, the full trust will disappear and CLR will start controlling everything that happens inside a subdomain. So, when you have a fully trusted domain you don’t need a serialization. Admit, we don’t need to protect ourselves. But serialization exists not only for protection. Each domain loads all necessary assemblies a second time and creates their copies. Thus, it creates copies of all types and all VMTs. Of course, when passing an object from domain to domain you will get the same object. But its VMTs won’t be its own and this object can’t be cast to another type. In other words, if we create an instance of a `Boo` type and get it in another domain the casting of `(Boo)boo` won’t work. In this case, serialization and deserialization will solve the problem as the object will exist in two domains simultaneously. It will exist with all its data where it was created and it will exist in the domain of usage as a proxy object, ensuring that methods of an original object are called.
By transferring a serialized object between domains you get a full copy of the object from one domain in another one while keeping some delimitation in memory. However, this delimitation is fictional. It is used only for those types that are not in `Shared AppDomain`. Thus, if you throw something non-serializable as an exception, but from `Shared AppDomain`, you won’t get an error of serialization (we can try throwing `Action` instead of `Program`). However, stack unrolling will anyway occur in this case: as both variants should work in a standard way. So that nobody will be confused.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
> | https://habr.com/ru/post/454630/ | null | en | null |
# Подборка @pythonetc, июль 2018
Это вторая подборка советов про Python и программирование из моего авторского канала [@pythonetc](http://t.me/pythonetc). Предыдущие подборки:
* [Июнь 2018](https://habr.com/company/mailru/blog/416605/)
Регулярные языки
----------------
Регулярный язык (regular language) — это формальный язык, который можно представить в виде [конечного автомата](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82). Иными словами, для посимвольной обработки текста вам достаточно лишь помнить текущее состояние, причем количество таких состояний конечно.
Прекрасный пример: машина, которая проверяет, являются ли входные данные простым числом вроде –3, 2.2 или 001. В начале статьи показана схема конечного автомата. Двойные окружности обозначают конечные состояния, в них машина может остановиться.
Машина начинает работать с позиции ①. Возможно, находит минус, затем цифру, а затем на позиции ③ обрабатывает необходимое количество цифр. После этого может проверяться наличие десятичного разделителя (③ → ④), после которого идет одна цифра (④ → ⑤) или больше (⑤ → ⑤).
Классический пример нерегулярного языка — семейство строковых выражений вида:
`a-b
aaa-bbb
aaaaa-bbbbb`
Формально, нам нужна строка, содержащая N экземпляров `a`, затем `–`, потом — N экземпляров `b`, где N — целое число больше 0. Вы не сможете это реализовать с помощью конечного автомата, поскольку придется запоминать количество символов, которые вы посчитали, что можно сделать, только используя бесконечное количество состояний.
Регулярные выражения могут задавать только регулярные языки. Прежде чем воспользоваться ими, убедитесь, что вашу строку вообще можно обработать с помощью конечного автомата. К примеру, они не годятся для обработки JSON, XML или даже арифметических выражений с вложенными скобками.
Забавно, что многие современные движки регулярных выражений не являются регулярными. Например, модуль regex для Python поддерживает рекурсию (которая [поможет](https://regex101.com/r/JzH9vZ/1) в решении задачи с `aaa-bbb`).
Динамическая диспетчеризация
----------------------------
Когда Python исполняет вызов метода, допустим, `a.f(b, c, d)`, он сначала должен выбрать правильную функцию `f`. В силу полиморфизма `a` определяет, что будет в итоге выбрано. Процесс выбора метода обычно называют динамической диспетчеризацией (dynamic dispatch).
Python поддерживает только полиморфизм с единичной диспетчеризацией (single-dispatch polymorphism). Это означает, что на выбор объекта влияет лишь сам объект (в нашем примере — `a`). В других языка могут учитываться типы `b`, `c` и `d` — такой механизм называется множественной диспетчеризацией (multiple dispatch). Ярким примером является язык C#.
Однако множественную диспетчеризацию можно эмулировать с помощью единичной. Именно для этого был создан шаблон проектирования «visitor»: в нем дважды используется единичная диспетчеризация для имитации двойной.
Помните, что перегрузка (overload) методов (как в Java и С++) — не аналог множественной диспетчеризации. Динамическая диспетчеризация работает в рантайме, а перегрузка выполняется только в ходе компиляции.
Эти примеры помогут вам лучше разобраться в теме:
* [Шаблон «посетитель» на Python](https://repl.it/@VadimPushtaev/visitor)
* [Переопределение в Java работает не так, как множественная диспетчеризация](https://repl.it/@VadimPushtaev/singledispatch)
* [Множественная диспетчеризация в C#](https://repl.it/@VadimPushtaev/multipledispatch)
Встроенные имена
----------------
В Python легко можно модифицировать все стандартные переменные, которые доступны в глобальной области видимости:
```
>>> print = 42
>>> print(42)
Traceback (most recent call last):
File "", line 1, in
TypeError: 'int' object is not callable
```
Это полезно, если ваш модуль определяет функции, чьи имена совпадают с именами встроенных функций. Такое случается и в ситуациях, когда вы практикуетесь в метапрограммировании и принимаете в качестве идентификатора произвольное строковое значение.
Но даже если вы продублируете имена каких-то встроенных функций, вам может понадобиться доступ к тому, на что они изначально ссылались. Именно для этого существует модуль builtins:
```
>>> import builtins
>>> print = 42
>>> builtins.print(1)
1
```
Также в большинстве модулей доступна переменная `__builtins__`. Но тут есть одна уловка. Во-первых, это особенность реализации cpython, и обычно её вообще не следует использовать. Во-вторых, `__builtins__` может ссылаться как на `builtins`, так и на `builtins.__dict__`, в зависимости от того, как именно был загружен текущий модуль.
strace
------
Иногда приложение начинает странно вести себя в бою. Вместо того, чтобы перезапускать его, возможно, вам захочется понять причину проблем, пока это возможно.
Очевидное решение — проанализировать действия программы и попытаться понять, какая часть кода исполняется. Правильное логирование облегчает эту задачу, но ваши логи могут оказаться недостаточно подробными по причине архитектуры или выбранного в настройках уровня логирования.
В подобных случаях может быть полезен strace. Это Unix-утилита, отслеживающая системные вызовы. Можете запустить ее предварительно — `strace python script.py` — но обычно удобнее подключаться к уже работающему приложению: `strace -p PID`.
```
$ cat test.py
with open('/tmp/test', 'w') as f:
f.write('test')
$ strace python test.py 2>&1 | grep open | tail -n 1
open("/tmp/test", O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0666) = 3
```
Каждая строка трейса содержит имя системного вызова, аргументы в скобках и возвращаемое значение. Поскольку некоторые аргументы используются для возвращения результата системного вызова, а не для передачи ему данных, вывод строки может быть приостановлен до завершения системного вызова.
В этом примере вывод остановлен, пока не завершится запись в STDIN:
```
$ strace python -c 'input()'
read(0,
```
Литералы кортежей
-----------------
Одной из наиболее несогласованных частей синтаксиса Python являются литералы кортежей.
Для создания кортежа достаточно перечислить значения через запятую: `1, 2, 3`. А что насчет кортежа, состоящего из одного элемента? Просто добавляем висячую запятую: `1,`. Это выглядит некрасиво и нередко приводит к ошибкам, но вполне логично.
Как насчет пустого кортежа? Это одна запятая — `,`? Нет, это `()`. А что, скобки создают кортеж, как и запятые? Нет, `(4)` — не кортеж, это просто `4`.
```
In : a = [
...: (1, 2, 3),
...: (1, 2),
...: (1),
...: (),
...: ]
In : [type(x) for x in a]
Out: [tuple, tuple, int, tuple]
```
Чтобы запутать всё еще сильнее, для литералов кортежей часто требуются дополнительные скобки. Если вам нужно, чтобы кортеж был единственным аргументом функции, то очевидно, что `f(1, 2, 3)` работать не будет — придется написать `f((1, 2, 3))`. | https://habr.com/ru/post/419025/ | null | ru | null |
# Как обойти капчу: нейросеть на Tensorflow,Keras,python v числовая зашумленная капча
Тема капч не нова, в том числе для Хабра. Тем не менее, алгоритмы капч меняются, как и алгоритмы их решения. Поэтому, предлагается помянуть старое и прооперировать следующий вариант капчи:
попутно понять работу простой нейросети на практике, а также улучшить ее результаты.
Сразу оговоримся, что не будем погружаться в размышления о том, как работает нейрон и что с этим всем делать, статья не претендует на научность, а только предоставляет небольшой туториал.
### Плясать от печки. Вместо вступления
Возможно повторятся чьи-то слова, но большинство книг по Deep Learning действительно начинаются с того, что читателю предлагаются заранее заготовленные данные, с которыми он начинает работать. Как-то MNIST — 60 000 рукописных цифр, CIFAR-10 и т.п. После прочтения человек выходит подготовленным… к этим наборам данных. Совершенно не ясно, как использовать свои данные и главное, как что-то улучшить при построении своей собственной нейросети.
Поэтому очень кстати вышла статья на [pyimagesearch.com](https://www.pyimagesearch.com/2018/09/10/keras-tutorial-how-to-get-started-with-keras-deep-learning-and-python/) о том как работать со своими собственными данными, а также ее [перевод](https://www.reg.ru/blog/keras/).
Но, как говорится, хрен редьки не слаще: даже с переводом разжеваной статьи по keras осталось много слепых мест. Опять же предлагается заранее подготовленный датасет, только уже с котами, собаками и пандами. Придется заполнить пустоты самостоятельно.
Однако за базу будет взята эта статья и код.
### Собираем данные по капчам
Здесь нет ничего нового. Нам нужны капчи-образцы, т.к. сеть будет учиться по ним под нашим руководством. Можете намайнить капч самостоятельно, а можете взять немного здесь - [29 000 капч](https://yadi.sk/d/Ubw1EKCkzLSN2g). Теперь необходимо нарезать цифр из каждой капчи. Необязательно резать все 29 000 капч, тем более, что 1 капча дает 5 цифр. 500 капч будет более чем достаточно.
Как резать? Можно в photoshopе, но лучше иметь нож получше.
Поэтому вот код ножа на python — [скачать](https://yadi.sk/d/PhOTxdZABnH0QQ). (для Windows. Предварительно создать папки C:\1\test и C:\1\test-out).
На выходе получится свалка из цифр от 1 до 9 (нулей в капче нет).
Далее надо разобрать этот завал из цифр по папкам от 1 до 9 и разложить в каждую папку по соответствующей цифре. Так себе занятие. Но за день можно разобрать до 1000 цифр.
Если при выборе цифры возникает сомнение какая из цифр, лучше удалить этот образец. И ничего страшного если цифры будут зашумлены или неполностью входить в «кадр»:
Набрать в каждую папку надо штук по 200 образцов каждой цифры. Можно эту работу поручить сторонним сервисам, но лучше сделать все самим, чтобы потом не искать неправильно соотнесенные цифры.
### Нейросеть. Тестовая
*Тятя, тятя, наши сети притащили мертвеца*
Перед тем как начать работать с собственными данными лучше пройтись по вышеуказанной статье и запустить код, чтобы понять, что все компоненты (keras, tensorflow и т.п.) установлены и работают корректно.
Будем использовать простую сеть, синтаксис запуска которой из командной (!) строки:
```
python train_simple_nn.py --dataset animals --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png
```
\*Tensorflow может писать при работе об ошибках в собственных файлах и устаревших методах, можно это исправить руками, а можно просто игнорировать.
Главное, чтобы на выходе после отработки программы в папке проекта output появились два файла: simple\_nn\_lb.pickle и simple\_nn.model, а на экран будет выведено изображение животного с надписью и процентом распознавания, например:
### Нейросеть — собственные данные
Теперь, когда тест работоспособности сети проверен, можно подключить собственные данные и начать обучать сеть.
Поместим в папку dat папки с цифрами, содержащими отобранные образцы по каждой цифре.
Папку dat для удобства разместим в папке с проектом (например рядом c папкой animals).
Теперь синтаксис запуска обучения сети будет таким:
```
python train_simple_nn.py --dataset dat --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png
```
Однако пока рано запускать обучение.
Необходимо поправить файл train\_simple\_nn.py.
1. В самый конец файла:
```
#model.summary()
score = model.evaluate(testX, testY, verbose=1)
print("\nTest score:", score[0])
print('Test accuracy:', score[1])
```
Это добавит информативности.
2.
```
image = cv2.resize(image, (32, 32)).flatten()
```
поменять на
```
image = cv2.resize(image, (16, 37)).flatten()
```
Здесь мы изменяем размер входной картинки. Почему именно такой размер? Потому как большинство из нарезанных цифр имеют такой размер либо приводятся к нему. Если масштабировать до 32x32 пикселя, картинка будет искажена. Да и зачем это делать?
Кроме того, загоняем это изменение в try:
```
try:
image = cv2.resize(image, (16, 37)).flatten()
except:
continue
```
Т.к. некоторые картинки программа не может переварить и выдает None, поэтому они пропускаются.
3.Теперь самое важное. Там где комментарий в коде
> определим архитектуру 3072-1024-512-3 с помощью Keras
Архитектура сети в статье определена как 3072-1024-512-3. Это означает, что сеть получает на вход 3072 (32 пикселя \* 32 пикселя \* 3), далее слой 1024, слой 512 и на выходе 3 варианта — кот, собака или панда.
В нашем случае вход 1776 (16 пикселей\*37 пикселей\*3), далее слой 1024, слой 512, на выходе 9 вариантов цифр.
Поэтому наш код:
```
model.add(Dense(1024, input_shape=(1776,), activation="sigmoid"))model.add(Dense(512, activation="sigmoid"))
```
\*9 выходов дополнительно указывать не нужно, т.к. программа сама определяет количество выходов по количеству папок в датасете.
### Запускаем
```
python train_simple_nn.py --dataset dat --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png
```
Так как картинки с цифрами маленькие, сеть обучается очень быстро (5-10 мин) даже на слабом железе, используя только CPU.
После прогона программы в командой строке посмотрим результаты:
Это означает, что на обучающем наборе достигнута верность — 82,19%, на контрольном — 75,6 % и на тестовом — 75,59 %.
Нам надо ориентироваться на последний показатель большей частью. Почему остальные также важны будет пояснено далее.
Посмотрим также графическую часть работы нейросети. Она в папке output проекта simple\_nn\_plot.png:
### Быстрее, выше, сильнее. Улучшаем результаты
Совсем коротко о настройке нейросети можно посмотреть [здесь](https://pikabu.ru/story/komandnaya_rabota_6877065).
Вариант подлиннее следующий.
Добавим эпох.
В коде меняем
```
EPOCHS = 75
```
на
```
EPOCHS = 200
```
Увеличим «количество раз», которое сеть пройдет обучение.
Результат:
Таким образом, 93,5%, 92,6%, 92,6%.
В картинках:
Здесь заметно, что синяя и красные линии после 130 эпохи начинают разъезжаться друг от друга и это говорит, что дальнейшее увеличение числа эпох ничего не даст. Проверим это.
В коде меняем
```
EPOCHS = 200
```
на
```
EPOCHS = 500
```
и снова прогоняем.
Результат:
Итак, имеем:
99%,95,5%,95,5%.
И на графике:
Что ж, увеличение числа эпох, явно пошло сети на пользу. Однако этот результат обманчив.
Проверим работу сети на реальном примере.
Для этих целей в папке проекта есть скрипт predict.py. Перед запуском подготовимся.
В папку images проекта положим файлы с изображениями цифр с капчи, ранее не попадавшиеся сети в процессе обучения. Т.е. надо взять цифры не из набора датасета dat.
В самом файле поправим две строки для размера изображений по умолчанию:
```
ap.add_argument("-w", "--width", type=int, default=16, help="target spatial dimension width")
ap.add_argument("-e", "--height", type=int, default=37, help="target spatial dimension height")
```
Запускаем из коммандной строки:
```
python predict.py --image images/1.jpg --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --flatten 1
```
И видим результат:
Другая картинка:
Однако не со всеми зашумленными цифрами работает:
Что здесь можно сделать?
1. Увеличить количество экземпляров цифр в папках для обучения.
2. Попробовать другие методы.
### Попробуем другие методы
Как видно из последнего графика, синяя и красная линии расходятся примерно на 130 эпохе. Это означает, что, обучение после 130 эпохи неэффективно. Зафиксируем результат на 130 эпохе: 89,3%,88%,88% и посмотрим, работают ли другие методы улучшения работы сети.
**Снизим скорость обучения.**
```
INIT_LR = 0.01
```
на
```
INIT_LR = 0.001
```
Результат:
41%,39%,39%
Что ж, мимо.
**Дабавим дополнительный скрытый слой.**
```
model.add(Dense(512, activation="sigmoid"))
```
на
```
model.add(Dense(512, activation="sigmoid"))
model.add(Dense(258, activation="sigmoid"))
```
Результат:
56%,62%,62%
Получше, но нет.
Однако, если увеличить количество эпох до 250:
84%,83%,83%
При этом красная и синяя линия не отрываются друг от друга после 130 эпохи:
**Сохраним 250 эпох и применим прореживание**:
```
from keras.layers.core import Dropout
```
Между слоями вставим прореживание:
```
model.add(Dense(1024, input_shape=(1776,), activation="sigmoid"))
model.add(Dropout(0.3))
model.add(Dense(512, activation="sigmoid"))
model.add(Dropout(0.3))
model.add(Dense(258, activation="sigmoid"))
model.add(Dropout(0.3))
```
Результат:
53%,65%,65%
Первое значение ниже остальных, это говорит о том, что сеть не обучается. Для этого рекомендуют увеличить количество эпох.
```
model.add(Dense(1024, input_shape=(1776,), activation="sigmoid"))
model.add(Dropout(0.3))
model.add(Dense(512, activation="sigmoid"))
model.add(Dropout(0.3))
```
Результат:
88%,92%,92%
С 1 дополнительным слоем, прореживанием и 500 эпохами:
```
model.add(Dense(1024, input_shape=(1776,), activation="sigmoid"))
model.add(Dropout(0.3))
model.add(Dense(512, activation="sigmoid"))
model.add(Dropout(0.3))
model.add(Dense(258, activation="sigmoid"))
```
Результат:
92,4%,92,6%,92,58%
Несмотря на более низкий процент по сравнению с простым увеличением эпох до 500, график выглядит более ровным:
И сеть обрабатывает изображения, которые ранее выпадали:
Соберем теперь все в один файл, который нарежет изображение с капчей на входе на 5 цифр, прогонит каждую цифру через нейросеть и выдаст результат в интерпретатор python.
Здесь попроще. В файл, который нарезал нам цифры из капчи добавим файл, который занимается предсказаниями.
Теперь программа не только нарежет капчу на 5 частей, но и выведет все распознанные цифры в интерпретатор:
Опять же надо иметь в виду, что программа не дает 100% результата и зачастую одна из 5 цифр неверна. Но и это неплохой результат, если учесть, что в обучающем наборе всего по 170-200 экземпляров для каждого числа.
Распознавание капчи длится 3-5 сек на компьютере средней мощности.
Как еще можно попытаться улучшить работу сети можно почитать в книге «Библиотека Keras — инструмент глубокого обучения» А. Джулли, С.Пала.
Итоговый скрипт, который режет капчу и распознает — [здесь](https://yadi.sk/d/Fg3qB9f_fAL2Eg).
Запускается без параметров.
Переработанные скрипты для [тренировки](https://yadi.sk/d/CC5To6wSU5hWRw) и [теста](https://yadi.sk/d/L4AKO_k9yuhOrA) сети.
Капчи для теста, в том числе с ложным срабатыванием — [здесь](https://yadi.sk/d/lDxVGYxqSZpX7w).
Модель для работы — [здесь](https://yadi.sk/d/jCRZA9TJy1wrLQ).
Цифры, разложенные по папкам — [здесь](https://yadi.sk/d/jQF3Xh59imVvEw). | https://habr.com/ru/post/464337/ | null | ru | null |
# Деплой Rails-приложения с помощью Docker
#### Введение
Эта запись о том, как я деплоил Ruby On Rails-приложение на сервер DigitalOcean, чтобы оно работало в отдельном Docker-контейнере. Для простоты, я собираюсь очень подробно объяснить процесс развертки Rails-приложения внутри Docker-контейнера
В этом посте:
* Как я установил Docker на сервере
* Dockerfile для моего Rails-приложения
* Сборка с гемами из Gemfile
* Сборка со скомпилированными ассетами
* Запуск приложения в Docker
* Переменные окружения Docker для database.yml
Давайте начнем с установки на сервере.
#### Установка Docker на сервере
Первым делом я загрузил новый Ubuntu 14.04 на DigitalOcean и установил Docker:
```
workstation $ ssh root@178.62.232.206
server $ apt-get install docker.io
server $ docker -v
Docker version 1.0.1, build 990021a
```
#### Dockerfile и nginx.conf
Теперь нам нужно собрать Docker-образ из Rails-приложения. Так получилось, что Jeroen (Jeroen van Baarsen, прим. перев.) написал об этом на прошлой неделе: [Как я собрал Docker-образ для Rails-приложения](https://intercityup.com/blog/how-i-build-a-docker-image-for-my-rails-app/). Я буду использовать его пост в качестве основы для дальнейших шагов.
Я буду собирать образ на том же сервере, на котором хочу впоследствии хостить само приложение. Я решил сделать так, потому что хочу, чтобы приложение не было в публичном доступе, поэтому публичный Docker-репозитарий — плохой вариант для этого. Я бы мог настроить для себя приватный репозитарий, но тогда я должен был бы поддерживать его, чего я не хочу делать в данный момент. В этом посте, я рассматриваю самый простой способ использования Docker для хостинга приложения.
В свой проект intercity-website я добавил следующие конфигурационные файлы Dockerfile и nginx.conf:
##### Dockerfile
```
FROM phusion/passenger-ruby21
MAINTAINER Firmhouse "hello@firmhouse.com"
ENV HOME /root
ENV RAILS_ENV production
CMD ["/sbin/my_init"]
RUN rm -f /etc/service/nginx/down
RUN rm /etc/nginx/sites-enabled/default
ADD nginx.conf /etc/nginx/sites-enabled/intercity_website.conf
ADD . /home/app/intercity_website
WORKDIR /home/app/intercity_website
RUN chown -R app:app /home/app/intercity_website
RUN sudo -u app bundle install --deployment
RUN sudo -u app RAILS_ENV=production rake assets:precompile
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
```
Как можно заметить, Dockerfile использует базовый образ phusion/passenger-ruby21. Он добавляет конфиг Nginx, код приложения, запускает bundler для установки gem'ов а также прекомпилирует ассеты.
##### nginx.conf
```
# This is the server block that serves our application.
server {
server_name intercityup.com;
root /home/app/intercity_website/public;
passenger_enabled on;
passenger_user app;
passenger_ruby /usr/bin/ruby2.1;
}
# This is the server block that redirects www to non-www.
server {
server_name www.intercityup.com;
return 301 $scheme://intercityup.com$request_uri;
}
```
#### Сборка образа для контейнера приложения
Я добавил эти файлы в мой репозитарий. Теперь я собираюсь загрузить его на сервер и собрать контейнер:
```
my_workstation $ git archive -o app.tar.gz --prefix=app/ master
my_workstation $ scp app.tar.gz root@178.62.232.206:
my_workstation $ ssh root@ 178.62.232.206
server $ tar zxvf app.tar.gz
server $ docker build --tag="intercity-website" app/
```
Эта команда выводит много результатов и делает много всего. Когда я в первый раз я запустил docker build, это заняло несколько минут. Это потому, что Docker должен скачать базовый образ phusion/passenger-ruby21. Это делается только один раз. После загрузки базового образа процесс продолжится в соответствии с моим Dockerfile.
Теперь команда docker images показывает мой образ:
```
server $ docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
intercity-website latest 629f05f42915 3 minutes ago 1.011 GB
```
#### Запуск контейнера в первый раз
Настало время запустить приложение.
```
server $ docker run --rm -p 80:80 intercity-website
```
Эта команда запускает контейнер, выводит некоторые данные, и, наконец, выводит следующую строку:
```
[ 2014-09-23 11:23:11.9005 113/7fb22942b780 agents/Watchdog/Main.cpp:728 ]: All Phusion Passenger agents started!
```
Теперь давайте посмотрим, корректно ли работает приложение. Выполним запрос с помощью curl:
```
server $ curl -H "Host: intercityup.com" http://localhost/
We`re sorry, but something went wrong (500)
...
```
Упс, что-то пошло не так. Судя по логу, находящийся внутри контейнера, (для доступа в который я использовал docker-bash от Phusion), я забыл создать базу данных. Так что теперь я собираюсь установить на сервере MySQL.
#### Установка базы данных
Я буду использовать стандартный сервер MySQL, доступный в Ubuntu 14.04:
```
server $ apt-get install mysql-server
```
После установки, и задания пароля администратора, я могу создать базу данных для приложения:
```
server $ mysql -u root -p
mysql> create database intercity_website_production;
Query OK, 1 row affected (0.00 sec)
mysql> grant all on intercity_website_production.* to 'intercity' identified by 'rwztBtRW6cFx9C';
Query OK, 0 rows affected (0.00 sec)
```
После этого я изменил /etc/mysql/my.cnf а также bind-address с 127.0.0.1 на мой внешний IP адрес, 178.62.232.206. Таким образом, Rails в моем контейнере теперь может использовать MySQL. В /etc/mysql/my.cnf я заменил строку с bind-address на следующую:
```
bind-address = 178.62.232.206
```
И перезапустил MySQL:
```
server $ /etc/init.d/mysql restart
```
#### Использование переменных окружения для настройки базы данных
Я собираюсь использовать переменные окружения, чтобы мой контейнер мог использовать их для авторизации в MySQL. Чтобы сделать это, мне нужно сделать две вещи: 1) Подготовить database.yml файл в репозитории к использованию переменных окружения. и 2) настроить Nginx для передачи этих переменных в процесс passenger'a.
Вот мой новый database.yml, подготовленный для переменных окружения:
```
production:
adapter: mysql2
host: <%= ENV['APP_DB_HOST'] %>
port: <%= ENV['APP_DB_PORT'] || "3306" %>
database: <%= ENV['APP_DB_DATABASE'] %>
username: <%= ENV['APP_DB_USERNAME'] %>
password: <%= ENV['APP_DB_PASSWORD'] %>
```
Чтобы эти переменные окружения работали для моего Rails-приложения, мне нужно настроить Nginx. Это обусловлено тем, что Nginx сбрасывает все переменные окружения, за исключением тех, которые вы определяете.
Я добавил в Rails-приложение файл rails-env.conf:
```
env APP_DB_HOST;
env APP_DB_PORT;
env APP_DB_DATABASE;
env APP_DB_USERNAME;
env APP_DB_PASSWORD;
```
А также поправил Dockerfile, чтобы он добавлял файл rails\_env при сборке контейнера:
```
FROM phusion/passenger-ruby21
MAINTAINER Firmhouse "hello@firmhouse.com"
ENV HOME /root
ENV RAILS_ENV production
CMD ["/sbin/my_init"]
RUN rm -f /etc/service/nginx/down
RUN rm /etc/nginx/sites-enabled/default
ADD nginx.conf /etc/nginx/sites-enabled/intercity_website.conf
# Add the rails-env configuration file
ADD rails-env.conf /etc/nginx/main.d/rails-env.conf
ADD . /home/app/intercity_website
WORKDIR /home/app/intercity_website
RUN chown -R app:app /home/app/intercity_website
RUN sudo -u app bundle install --deployment
RUN sudo -u app RAILS_ENV=production rake assets:precompile
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
EXPOSE 80
```
#### Построение образа с поддержкой переменных окружения
Я добавил в репозитарий новый конфиг Nginx. Теперь я намерен пересобрать новую версию контейнера:
```
workstation $ git archive -o app.tar.gz --prefix=app/ master
workstation $ scp app.tar.gz root@178.62.232.206:
workstation $ ssh root@178.62.232.206
server $ tar zxvf app.tar.gz
server $ docker build --tag="intercity-website" app/
```
#### Запуск rake с переменными окружения
После сборки контейнера я могу настроить базу данных. В следующей команде я использую переменные окружения для передачи информации о подключении к базе данных для запуска rake db:setup. Обратите внимание, что я добавил к команде аргумент -u app. Этот аргумент нужен, чтобы удостовериться, что rake db:setup запускается от имени пользователя app внутри контейнера.
```
server $ docker run --rm -e "RAILS_ENV=production" -e "APP_DB_HOST=178.62.232.206" -e "APP_DB_DATABASE=intercity_website_production" -e "APP_DB_USERNAME=intercity" -e "APP_DB_PASSWORD=rwztBtRW6cFx9C" -e "APP_DB_PORT=3306" -u app intercity-website rake db:setup
intercity_website_production already exists
-- create_table("invite_requests", {:force=>true})
-> 0.0438s
-- initialize_schema_migrations_table()
-> 0.1085s
```
##### Ух-ты! Сработало!
#### Запуск приложения с переменными окружения
Теперь я могу запустить контейнер с теми же переменными окружения и попытаться получить доступ к нему из браузера, чтобы проверить, работает ли он:
```
server $ docker run --rm -p 80:80 -e "RAILS_ENV=production" -e "APP_DB_HOST=178.62.232.206" -e "APP_DB_DATABASE=intercity_website_production" -e "APP_DB_USERNAME=intercity" -e "APP_DB_PASSWORD=rwztBtRW6cFx9C" -e "APP_DB_PORT=3306" intercity-website
```
Когда я открываю [178.62.232.206](http://178.62.232.206), я вижу Rails-приложение, которое подключается к базе данных, и также вижу, ассеты был скомпилированы и все работает. Победа!
#### Заключение
На этом мы завершаем пост, где мы:
1. Установили Docker на сервере
2. Настроили Dockerfile и построили образ контейнера
3. Настроили базу данных с помощью переменных окружения
#### Что дальше?
У меня до сих пор есть вопросы, требующие ответа. Я и другие разработчики в Intercity ещё будем писать о них. Вот некоторые из вопросов, которые нужно решить:
* Как автоматизировать развертывание? Может быть использовать что-то вроде Capistrano?
* Что мне нужно, чтобы получить нулевое время простоя? Когда я сперва остановлю, а потом запущу контейнер, для запуска новой версии приложения, подключения будут сброшены.
* Где хранить переменные окружения для каждого из приложений, которые я собираюсь развернуть на сервере?
* Как мне ускорить построение контейнера? Нужно ли мне запускать каждый раз bundler и rake assets:precompile для каждого деплоя?
Я надеюсь, что вам понравился этот пост. Буду рад советам и вопросам!
Большое спасибо за внимание. | https://habr.com/ru/post/238069/ | null | ru | null |
# Тематическое моделирование средствами BigARTM
### Введение
Обратил внимание на перевод публикации под названием «Тематическое моделирование репозиториев на GitHub» [1]. В публикации много теоретических данных и очень хорошо описаны темы, понятия, использование естественных языков и многие другие приложения модели BigARTM.
Однако, обычному пользователю без знаний в области тематического моделирования для практического использования достаточно знаний интерфейса и чёткой последовательности действий при подготовке текстовых исходных данных.Разработке прогамного обеспечения для подготовки текстовых данных и выбору среды разработки и посвящена данная публикация.
### Установка BigARTM в Windows и подготовка исходных данных
Установка BigARTM хорошо изложена в видео презентации [2], поэтому я на ней останавливаться не буду, отмечу только что приведенные в документации программы рассчитаны на определённую версию и на скаченной версии могут не работать. В статье используется версия\_v 0.8.1.
Программа BigARTM работает только на Python 2.7. Поэтому для создания единого программного комплекса все вспомогательные программы и примеры написаны на Python 2.7, что привело к некоторому усложнению кода.
Текстовые данные для тематического моделирования должны пройти обработку в соответствии со следующими этапами [4].
1. Лемматизация или стемминг;
2. Удаление стоп-слов и слишком редких слов;
3. Выделение терминов и словосочетаний.
Рассмотрим как можно реализовать на Python указанные требования.
### Что лучше применять: лемматизацию или стемминг?
Ответ на этот вопрос мы получим из следующего листинга, в котором в качестве примера использован первый абзац текста из статьи [5]. Здесь и дальше части листинга и результат их работы буду представлять как они выводятся в формате среды jupyter notebook.
**Листинг лемматизации с lemmatize**
```
# In[1]:
#!/usr/bin/env python
# coding: utf-8
# In[2]:
text=u' На практике очень часто возникают задачи для решения\
которых используются методы оптимизации в обычной жизни при \
множественном выборе например подарков к новому году мы интуитивно \
решаем задачу минимальных затрат при заданном качестве покупок '
# In[3]:
import time
start = time.time()
import pymystem3
mystem = pymystem3 . Mystem ( )
z=text.split()
lem=""
for i in range(0,len(z)):
lem =lem + " "+ mystem. lemmatize (z[i])[0]
stop = time.time()
print u"Время, затраченное lemmatize- %f на обработку %i слов "%(stop - start,len(z))
```
Результат роботы листинга по лемматизации.
> *на практика очень часто возникать задача для решение который использоваться метод оптимизация в обычный жизнь при множественный выбор например подарок к новый год мы интуитивно решать задача минимальный затрата при задавать качество покупка*
Время, затраченное lemmatize — 56.763000 на обработку 33 слов
**Листинг стемминга с stemmer NLTK**
```
#In [4]:
start = time.time()
import nltk
from nltk.stem import SnowballStemmer
stemmer = SnowballStemmer('russian')
stem=[stemmer.stem(w) for w in text.split()]
stem= ' '.join(stem)
stop = time.time()
print u"Время, затраченное stemmer NLTK- %f на обработку %i слов "%(stop - start,len(z))
```
Результат роботы листинга:
> *на практик очен част возника задачи, для решен котор использ метод оптимизац в обычн жизн при множествен выборе, например, подарк к нов год мы интуитивн реша задач минимальн затрат при зада качеств покупок*
Время, затраченное stemmer NLTK- 0.627000 на обработку 33 слов
**Листинг стемминга с модулем Stemmer**
```
#In [5]:
start = time.time()
from Stemmer import Stemmer
stemmer = Stemmer('russian')
text = ' '.join( stemmer.stemWords( text.split() ) )
stop = time.time()
print u"Время, затраченное Stemmer- %f на обработку %i слов"%(stop - start,len(z))
```
Результат роботы листинга:
> *на практик очен част возника задачи, для решен котор использ метод оптимизац в обычн жизн при множествен выборе, например, подарк к нов год мы интуитивн реша задач минимальн затрат при зада качеств покупок*
Время, затраченное Stemmer- 0.093000 на обработку 33 слов
**Вывод**
Когда время на подготовку данных для тематического моделирования не критично, следует применять лемматизацию при помощи модулей pymystem3 и mystem, в противном случаи следует применить стемминг при помощи модуля Stemmer.
### Где взять список стоп-слов для их последующего удаления?
Стоп-слова по определению слова не несущих смысловой нагрузки. Список таких слов нужно составлять с учётом специфики текста, однако должна быть основа. Основу можно получить при помощи корпуса brown.
**Листинг получения stop-words**
```
#In [6]:
import nltk
from nltk.corpus import brown
stop_words= nltk.corpus.stopwords.words('russian')
stop_word=" "
for i in stop_words:
stop_word= stop_word+" "+i
print stop_word
```
Результат роботы листинга:
> *и в во не что он на я с со как а то все она так его но да ты к у же вы за бы по только ее мне было вот от меня еще нет о из ему теперь когда даже ну вдруг ли если уже или ни быть был него до вас нибудь опять уж вам ведь там потом себя ничего ей может они тут где есть надо ней для мы тебя их чем была сам чтоб без будто чего раз тоже себе под будет ж тогда кто этот того потому этого какой совсем ним здесь этом один почти мой тем чтобы нее сейчас были куда зачем всех никогда можно при наконец два об другой хоть после над больше тот через эти нас про всего них какая много разве три эту моя впрочем хорошо свою этой перед иногда лучше чуть том нельзя такой им более всегда конечно всю между*
Получить список стоп-слов можно и в сетевом сервисе [6] по заданному тексту.
**Вывод**
Рационально сначала использовать основу стоп-слов, например, из корпуса brown и уже после анализа результатов обработки изменять или дополнять список стоп-слов.
### Как выделить из текста термины и ngram?
В публикации [7] для тематического моделирования с применением программы BigARTM рекомендуют «После лемматизации по коллекции можно собирать n-граммы. Биграммы можно добавлять в основной словарь, разделив слова специальным символом, отсутствующим в Ваших данных:
* русский\_общение;
* украинский\_родной;
* засылать\_казачок;
* русский\_больница.
Приводим листинг для выделения из текста bigrams, trigrams, fourgrams, fivegrams.
Листинг адаптирован под Python 2.7.10 и настроен на выделение bigrams, trigrams,fourgrams ,fivegrams из текста.В качестве специального символа использован — "\_".
**Листинг получения bigrams,trigrams, fourgrams , fivegrams**
```
#In [6]:
#!/usr/bin/env python
# -*- coding: utf-8 -*
from __future__ import unicode_literals
import nltk
from nltk import word_tokenize
from nltk.util import ngrams
from collections import Counter
text = "На практике очень часто возникают задачи для решения которых используются методы\ оптимизации в обычной жизни при множественном выборе например подарков к новому\
году мы интуитивно решаем задачу минимальных затрат при заданном качестве покупок"
#In [7]:
token = nltk.word_tokenize(text)
bigrams = ngrams(token,2)
trigrams = ngrams(token,3)
fourgrams = ngrams(token,4)
fivegrams = ngrams(token,5)
#In [8]:
for k1, k2 in Counter(bigrams):
print (k1+"_"+k2)
#In [9]:
for k1, k2,k3 in Counter(trigrams):
print (k1+"_"+k2+"_"+k3)
#In [10]:
for k1, k2,k3,k4 in Counter(fourgrams):
print (k1+"_"+k2+"_"+k3+"_"+k4)
#In [11]:
for k1, k2,k3,k4,k5 in Counter(fivegrams):
print (k1+"_"+k2+"_"+k3+"_"+k4+"_"+k5)
```
Результат роботы листинга. Для сокращения привожу только по одному значению из каждой ngram.
bigrams — новому\_году
trigrams — заданном\_качестве\_покупок
fourgrams — которых\_используются\_методы\_оптимизации
fivegrams- затрат\_при\_заданном\_качестве\_покупок
**Вывод**
Приведенную программу можно использовать для выделения устойчиво повторяющихся в тексте NGram учитывая каждую как одно слово.
### Что должна содержать программа для подготовки текстовых данных к тематическому моделированию ?
Чаще копии документов располагают по одному в отдельном текстовом файле. При этом исходными данными для тематического моделирования является так называемый «мешок слов», в котором слова, относящиеся к определённому документу, начинаются с новой строки после тега -|text.
Следует отметить, что даже при полном выполнении приведенных выше требований высока вероятность того, что наиболее часто употребляемые слова не отражают содержание документа.
Такие слова могут быть удалены из копии исходного документа. При этом необходимо контролировать распределение слов по документам.
Для ускорения моделирования, после каждого слова через двоеточие указывается частота его употребления в данном документе.
Исходными данными для тестирования программы были 10 статей из Википедии. Названия статей следующие.
1. География
2. Математика
3. Биология
4. Астрономия
5. Физика
6. Химия
7. Ботаника
8. История
9. Физиология
10. Информатика
**Листинг получения готового для моделирования текста**
```
#In [12]:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import codecs
import os
import nltk
import numpy as np
from nltk.corpus import brown
stop_words= nltk.corpus.stopwords.words('russian')
import pymystem3
mystem = pymystem3.Mystem()
path='Texts_habrahabr'
f=open('habrahabr.txt','a')
x=[];y=[]; s=[]
for i in range(1,len(os.listdir(path))+1): #перебор файлов с документами по номерам i
filename=path+'/'+str(i)+".txt"
text=" "
with codecs.open(filename, encoding = 'UTF-8') as file_object:# сбор текста из файла i-го документа
for line in file_object:
if len(line)!=0:
text=text+" "+line
word=nltk.word_tokenize(text)# токинезация текста i-го документа
word_ws=[w.lower() for w in word if w.isalpha() ]#исключение слов и символов
word_w=[w for w in word_ws if w not in stop_words ]#нижний регистр
lem = mystem . lemmatize ((" ").join(word_w))# лемматизация i -го документа
lema=[w for w in lem if w.isalpha() and len(w)>1]
freq=nltk.FreqDist(lema)# распределение слов в i -м документе по частоте
z=[]# обновление списка для нового документа
z=[(key+":"+str(val)) for key,val in freq.items() if val>1] # частота упоминания через : от слова
f.write("|text" +" "+(" ").join(z).encode('utf-8')+'\n')# запись в мешок слов с меткой |text
c=[];d=[]
for key,val in freq.items():#подготовка к сортировке слов по убыванию частоты в i -м документе
if val>1:
c.append(val); d.append(key)
a=[];b=[]
for k in np.arange(0,len(c),1):#сортировка слов по убыванию частоты в i -м документе
ind=c.index(max(c)); a.append(c[ind])
b.append(d[ind]); del c[ind]; del d[ind]
x.append(i)#список номеров документов
y.append(len(a))#список количества слов в документах
a=a[0:10];b=b[0:10]# TOP-10 для частот a и слов b в i -м документе
y_pos = np.arange(1,len(a)+1,1)#построение TOP-10 диаграмм
performance =a
plt.barh(y_pos, a)
plt.yticks(y_pos, b)
plt.xlabel(u'Количество слов')
plt.title(u'Частоты слов в документе № %i'%i, size=12)
plt.grid(True)
plt.show()
plt.title(u'Количество слов в документах', size=12)
plt.xlabel(u'Номера документов', size=12)
plt.ylabel(u'Количество слов', size=12)
plt.bar(x,y, 1)
plt.grid(True)
plt.show()
f.close()
```
Результат роботы листинга по генерации вспомогательных диаграмм.Для сокращения привожу только одну диаграмму для TOP-10 слов из одного документа и одну диаграмму распределение слов по документам.
В результате работы программы мы получили десять диаграмм на которых отобраны по частоте употребления 10 слов.Кроме этого программа строит диаграмму распределения количества слов по документам. Это удобно для предварительного анализа исходных данных.При большом количестве документов частотные диаграммы можно сохранять в отдельной папке.
Результат роботы листинга по генерации «мешка слов».Для сокращения привожу данные из созданного текстового файла habrahabr.txt только по первому документу.
> |text земной:3 кругом:2 страна:4 перекипелый: 2 человек:2 традиция:2 строение:2 появление:2 некоторый:2 имя:2 первый:4 создавать:2 находить:2 греческий:3 иметь:4 форма:2 ii:2 обитаемый:4 содержать:3 река:4 восточный:2 море:6 место:2 эратосфен:3 сведение:2 вид:3 геродот:3 смысл:4 картография:2 известный:2 весь:2 воображать:2 немало:2 наука:4 современный:2 достижение:2 период:2 шар:3 определение:2 предположение:2 закладывать:2 представление:7 составлять:3 изображать:2 страбометр:3 термин:2 круглый:7 употребляться:2 берег:2 южный:2 координата:2 земля:16 посвящать:2 доходить:2 карта:7 дисциплина:2 меридиан:2 диск:2 аристотель:4 должный:2 описание:6 отдельный:2 географический:12 оно:2 окружать:3 анаксимандра:2 название:8 тот:2 автор:2 сочинение:3 древний:8 поздний:4 опыт:2 птолемей:2 география:10 время:3 труд:2 также:6 объезд:3 свой:2 подходить:2 круг:2 омывать:3 средиземное:2 греков:2 китай:2 век:6 ее:2 океан:3 северный:2 сторона:2 эпоха:3 внутренний:2 плоский:2 красный:2 аррианин:2 который:8 другой:2 пользоваться:3 этот:5 основа:3 жить:2
Была использована одна текстовая модальность обозначенная в начале каждого документа как |text. После каждого слова через двоеточие введено число его употребления в тексте. Последнее ускоряет как процесс создания batch так и заполнение словаря.
### Как можно упростить работу с BigARTM для создания и анализа topic ?
Для этого нужно во первых готовить текстовые документы и проводить их анализ с использованием предложных программных решений, а во вторых использовать среду разработки jupyter notebook.
В директории notebooks размещаются все необходимые для работы программы папки и файлы.
Части программного кода отлаживаются в отдельных файлах и после отладки собираются в общий файл.
Предложенная подготовка текстовых документов позволяет провести тематическое моделирование на упрощённом варианте BigARTM без регуляризаторов и фильтров.
**Листинг для создания batch**
```
#In [1]:
#!/usr/bin/env python
# -*- coding: utf-8 -*
import artm
# создание частотной матрицы из batch
batch_vectorizer = artm.BatchVectorizer(data_path='habrahabr.txt',# путь к "мешку слов"
data_format='vowpal_wabbit',# формат данных
target_folder='habrahabr', #папка с частотной матрицей из batch
batch_size=10)# количество документов в одном batch
```
Из файла habrahabr.txt программа в папке habrahab создаёт один batch из десяти документов, количество которых приведено в переменной batch\_size=10. Если данные не изменяются и частотная матрица уже создана, то указанную выше часть программы можно пропустить.
**Листинг для заполнения словаря и создания модели**
```
#In [2]:
batch_vectorizer = artm.BatchVectorizer(data_path='habrahabr',data_format='batches')
dictionary = artm.Dictionary(data_path='habrahabr')# загрузка данных в словарь
model = artm.ARTM(num_topics=10,
num_document_passes=10,#10 проходов по документу
dictionary=dictionary,
scores=[artm.TopTokensScore(name='top_tokens_score')])
model.fit_offline(batch_vectorizer=batch_vectorizer, num_collection_passes=10)#10 проходов по коллекции
top_tokens = model.score_tracker['top_tokens_score']
```
Программа BigARTM после загрузки данных в словарь dictionary генерирует 10 тем (по числу документов), количество которых приведено в переменной num\_topics=10.Количество проходов по документу и по коллекции указаны в переменных num\_document\_passes=10, num\_collection\_passes=10.
**Листинг для создания и анализа topics**
```
#In [3]:
for topic_name in model.topic_names:
print (topic_name)
for (token, weight) in zip(top_tokens.last_tokens[topic_name],
top_tokens.last_weights[topic_name]):
print token, '-', round(weight,3)
```
Результат роботы программы BigARTM:
> topic\_0
>
> растение — 0.088
>
> ботаника — 0.032
>
> век — 0.022
>
> мир — 0.022
>
> линней — 0.022
>
> год — 0.019
>
> который — 0.019
>
> развитие — 0.019
>
> аристотель — 0.019
>
> природа — 0.019
>
> topic\_1
>
> астрономия — 0.064
>
> небесный — 0.051
>
> тело — 0.046
>
> задача — 0.022
>
> движение — 0.018
>
> изучать — 0.016
>
> метод — 0.015
>
> звезда — 0.015
>
> система — 0.015
>
> который — 0.014
>
> topic\_2
>
> земля — 0.049
>
> географический — 0.037
>
> география — 0.031
>
> древний — 0.025
>
> который — 0.025
>
> название — 0.025
>
> представление — 0.022
>
> круглый — 0.022
>
> карта — 0.022
>
> также — 0.019
>
> topic\_3
>
> физика — 0.037
>
> физический — 0.036
>
> явление — 0.027
>
> теория — 0.022
>
> который — 0.022
>
> закон — 0.022
>
> общий — 0.019
>
> новый — 0.017
>
> основа — 0.017
>
> наука — 0.017
>
> topic\_4
>
> изучать — 0.071
>
> общий — 0.068
>
> раздел — 0.065
>
> теоретический — 0.062
>
> вещество — 0.047
>
> видимый — 0.047
>
> физический — 0.044
>
> движение — 0.035
>
> гипотеза — 0.034
>
> закономерность — 0.031
>
> topic\_5
>
> физиология — 0.069
>
> щитовидный — 0.037
>
> человек — 0.034
>
> организм — 0.032
>
> латы — 0.03
>
> артерия — 0.025
>
> железа — 0.023
>
> клетка — 0.021
>
> изучать — 0.021
>
> жизнедеятельность — 0.018
>
> topic\_6
>
> математика — 0.038
>
> клетка — 0.022
>
> наука — 0.021
>
> организм — 0.02
>
> общий — 0.02
>
> который — 0.018
>
> математический — 0.017
>
> живой — 0.017
>
> объект — 0.016
>
> ген — 0.015
>
> topic\_7
>
> история — 0.079
>
> исторический — 0.041
>
> слово — 0.033
>
> событие — 0.03
>
> наука — 0.023
>
> который — 0.023
>
> источник — 0.018
>
> историография — 0.018
>
> исследование — 0.015
>
> философия — 0.015
>
> topic\_8
>
> термин — 0.055
>
> информатика — 0.05
>
> научный — 0.031
>
> язык — 0.029
>
> год — 0.029
>
> наука — 0.024
>
> информация — 0.022
>
> вычислительный — 0.017
>
> название — 0.017
>
> science — 0.014
>
> topic\_9
>
> век — 0.022
>
> который — 0.022
>
> наука — 0.019
>
> химический — 0.019
>
> вещество — 0.019
>
> химия — 0.019
>
> также — 0.017
>
> развитие — 0.017
>
> время — 0.017
>
> элемент — 0.017
Полученные результаты в целом отвечают темам и результат моделирования можно считать удовлетворительным. При необходимости в программу можно добавить регуляризаторы и фильтры.
### Выводы по результатам работы
Мы рассмотрели все этапы подготовки текстовых документов к тематическому моделированию. На конкретных примерах провели простой сравнительный анализ модулей для лемматизации и стемминга. Рассмотрели возможность использования NLTK для получения списка стоп-слов и поиска словосочетаний для русского языка. Рассмотрены листинги, написанные на Python 2.7.10 и адаптированные для русского языка, что позволяет их интегрировать в единый прогамный комплекс. Разобран пример тематического моделирования в среде jupyter-notebook, которая предоставляет дополнительные возможности для работы с BigARTM.
**Используемые ссылки**1. [Тематическое моделирование репозиториев на GitHub](https://habrahabr.ru/post/312596).
2. [Lecture 49 — Установка BigARTM в Windows](https://www.coursera.org/learn/unsupervised-%20learning/lecture/qmsFm/ustanovka-bigartm-v-windows)
3. [bigartm/bigartm](https://github.com/bigartm/bigartm/releases)
4. [Основы обработки текстов.](http://docplayer.ru/40376022-Osnovy-obrabotki-tekstov.html)
5. [Решение задач линейного программирования с использованием Python.](https://habrahabr.ru/post/330648/)
6. [Испытываем новый алгоритм проверки. Вопросы и предложения.](https://glvrd.ru/)
7. [Использование библиотеки для тематического моделирования BigARTM.](http://www.machinelearning.ru/wiki/images/f/f5/MelLain_Python_API_slides.pdf) | https://habr.com/ru/post/334668/ | null | ru | null |
# Салат «Руководство Microsoft под SymbolTable с нежным привкусом Antlr4»
Всегда ли нужно использовать то, что предлагают?
Разобравшись с посетителем и слушателем, пришло время попробовать «Велосипед». Изучая способы построения внешних DSL я столкнулся с проблемой получения практики. Не буду далеко ходить книга Фаулера про то, как построить язык мечты «DSL», к сожалению, оказалась совсем не обезболивающим, а скорее на оборот тропой в кустах крапивы.
Глава 12 Symbol Table
> Место для хранения во время синтаксического анализа всех
>
> идентифицируемых объектов для разрешения ссылок.
Понятно? Конечно понятно, к описанию претензий нет.
> Многим языкам приходится ссылаться на объекты во многих точках кода. Если есть
>
> язык, который определяет конфигурацию задач и их зависимости, значит, нужен способ,
>
> которым одна задача могла бы сослаться на зависимые задачи в своем определении.
В книге представлена задача по сбору на работу
```
go_to_work -> drink_coffee dress
drink_coffee -> make_coffee wash
dress -> wash
```
И вот магия DSL, то для чего он создается, а именно код не нужно комментировать, достаточно просто прочитать, что бы определить зависимости между задачами.
Но я кофе не пью, и подвернулась книга «руководство microsoft по проектированию архитектуры приложений». Отличная задача – Разработать приложение под винду, чем сейчас и займемся.
И так MS уверяет
Данное руководство поможет:
• Понять базовые принципы и шаблоны построения архитектуры и дизайна для разработки успешных решений на платформе Microsoft.
• Правильно выбрать стратегии и шаблоны проектирования, которые помогут при проектировании слоев, компонентов и сервисов решения.
• Определить и реализовать ключевые технические решения.
• Определить и реализовать основные показатели качества и сквозные функции для решения.
• Правильно выбрать технологии для реализации решения.
• Создать возможный вариант базовой архитектуры решения.
• Правильно выбрать предлагаемые группой patterns & practices решения и руководства, которые помогут в реализации решения.
Отлично. У нас есть бесплатный список задач, который после реорганизации имеет вид
1. Понять\_базовые\_принципы
2. Выбрать\_стратегии\_и\_шаблоны
3. Реализовать\_ключевые\_технические\_решения
4. Реализовать\_основные\_показатели\_качества
5. Выбрать\_технологии
6. Создать\_возможный\_вариант\_базовой\_архитектуры
7. Выбрать\_предлагаемые\_решения\_и\_руководства
Ну и зависимости между ними
6 -> 3 4 5
2 -> 1 7
5 -> 7
7 -> 1
3 -> 2 5
4 -> 3
Пока все идет хорошо.
> Грамматика этого DSL исключительно проста.
>
>
> ```
> grammar file...
> network : SEP? dependency (SEP dependency)* SEP?;
> dependency
> : lhs=ID '->' rhs+=ID+
> {helper.recognizedDependency($lhs, $rhs);}
> ;
>
> ```
>
И это все? Что такое SEP, что такое ID? Не ну действительно я только недавно начал разбираться с грамматикой, да вообще с внешним DSL отличным от простого XML. За этим и пришел сюда – яма. Через 60 страниц листания, я узрел
```
SEP : ('-' | ' ' );
```
Через еще 50
```
fragment LETTER : ('a'..'z' | 'A'..'Z' | '_');
fragment DIGIT : ('0'..'9');
ID : LETTER (LETTER | DIGIT)* ;
```
Задачи описаны на русском, эх а пусть и DSL будет на нем же!
Собрав все вместе и изрядно поплясав вокруг кодировки для поддержки кириллицы
```
grammar WorkGrammar;
network : SEP? dependency (SEP dependency)* SEP?;
dependency
: lhs=ID '->' rhs+=ID+;
ID : LETTER (LETTER | DIGIT)* ;
fragment LETTER : ( 'а'..'я' | 'А'..'Я' | '_' );
fragment DIGIT : ('0'..'9');
SEP : ('-' | ' ' );
WS : [\t\r]+->skip;
```
Я конечно не писатель (не разработчик), а читатель (пользователь), и мне как пользователю это доставило не самые приятные проблемы (и в тех поддержку не позвонишь, в запросах к Google раздавались гудки, ни кто не брал).
С грамматикой видимо все! F5 породил Lexer и Parser!
Task что то называть класс ну очень не очень, поэтому просто Work
```
class Work
{
List \_dep;
public Work( string name )
{
Name = name;
\_dep = new List();
}
public string Name { get; private set; }
public IEnumerable Dependencies { get { return \_dep; } }
public bool Completed { get; set; }
public void AddDependency( Work dep )
{
\_dep.Add( dep );
}
}
```
Как выяснилось в [Битва «Слушатель vs Посетитель» на стадионе antlr4](http://habrahabr.ru/post/259691/) посетитель и слушатель довольно не малы и тяжеловесны (хотя можно и их использовать), а так же в целях самообразования, пробуем обойти дерево на «Велосипеде».
```
class WorksLoader
{
public Dictionary Load( WorkGrammarParser.NetworkContext context )
{
Dictionary result = new Dictionary();
foreach ( var dep in context.dependency() )
{
var work = GetWork( dep.lhs.Text, result );
foreach ( var right in dep.\_rhs )
{
var depWork = GetWork( right.Text, result );
work.AddDependency( depWork );
}
}
return result;
}
Work GetWork( string name, Dictionary works )
{
if ( !works.ContainsKey( name ) )
works[name] = new Work( name );
return works[name];
}
}
```
Возможности Antlr4 по генерации контекстов радуют, сильно упрощает обход.
Класс с методом Load возвращающий таблицу символов (словарь работ) с уже определенными зависимостями.
Пришло время самому интересному, исходнику
```
Создать_возможный_вариант_базовой_архитектуры -> Реализовать_ключевые_технические_решения Реализовать_основные_показатели_качества Выбрать_технологии
Выбрать_стратегии_и_шаблоны -> Понять_базовые_принципы Выбрать_предлагаемые_решения_и_руководства
Выбрать_технологии -> Выбрать_предлагаемые_решения_и_руководства
Выбрать_предлагаемые_решения_и_руководства -> Понять_базовые_принципы
Реализовать_ключевые_технические_решения -> Выбрать_стратегии_и_шаблоны Выбрать_технологии
Реализовать_основные_показатели_качества -> Реализовать_ключевые_технические_решения
```
Не очень читаемые разделители (если укоротить названия работ, то вполне) ну да ладно, это во много раз лучше A -> B C
Определив текст нашего языка в ресурсы, можно получить список работ
```
class Program
{
static void Main( string[] args )
{
AntlrInputStream input = new AntlrInputStream(Resource.Input);
WorkGrammarLexer lexer = new WorkGrammarLexer( input );
CommonTokenStream tokens = new CommonTokenStream( lexer );
WorkGrammarParser parser = new WorkGrammarParser( tokens );
var works = new WorksLoader().Load( parser.network());
var ready = GetReadyWorks(works);
}
static Dictionary GetReadyWorks( Dictionary works )
{
Dictionary ready = new Dictionary();
foreach ( var currentWork in works.Select(e=>e.Value) )
{
if ( currentWork.Dependencies.Count() == 0 || currentWork.Dependencies.All( e => e.Completed ) )
ready[currentWork.Name] = currentWork;
}
return ready;
}
}
```
F5! Работает! Если бы… Результат выдается не тот который ожидался. Потратив изрядное время на выявление проблемы -> засада расположилась там где ее ни кто не ожидал -> грамматика. Вообще не реально, мало того что она дается не полная и нет ни каких исходных материалов, так она еще и с ошибками. Возмутительно!
Рабочая грамматика
```
grammar WorkGrammar;
network : SEP? dependency ('\n' dependency)*;
dependency
: lhs=ID '->' rhs+=ID+;
ID : LETTER (LETTER | DIGIT)* ;
fragment LETTER : ( 'а'..'я' | 'А'..'Я' | '_' );
fragment DIGIT : ('0'..'9');
SEP : ('-' | ' ' );
WS : [\t\r]+->skip;
```
При разработке DSL на Antlr4 по книге Фаулера чувства двухбокие, вкус с горчинкой, с одного бока описание, текст на высоте, с другого же по мимо того что примеров на C# не найти, так еще изучение затрудняется проблемами поиска частей описания по сем разделам, и багами которые разработчик заботливо раскидал то тут то там.
#### P.S
Всегда ли нужно использовать то, что предлагают?
Мое мнение, что если позволяет время, то лучше написать свои классы по обходу деревьев! Хотя многое зависит от самой задачи. | https://habr.com/ru/post/260271/ | null | ru | null |
# TileTool — модуль для обучения детей основам разработки игр
Последнее время из каждого чайника напористо лезет реклама обучения языку Python. И это не удивительно, поскольку Python уверенно занял лидирующее положение в качестве первого языка для изучения программирования. А его простота, обилие вспомогательных модулей и скорость написания кода сделали его лидером для обучения детей программированию, полностью вытеснив, популярные лет 20 назад QBasic и Pascal.
> *Обучаем играючи...*
>
>
Последние тренды в обучении детей сводятся к игровым механикам. Чтобы заинтересовать ребенка программированием - преврати обучение в игру или предложи научиться игры создавать. Из-за этой логики одним из самых популярных модулей для Python, используемых в обучении стал Pygame, позволяющий создавать простые и не очень игры, без глубокого погружения в тонкости реализации, что очень удобно для детей в процессе начального освоения программирования.
### О чем статья?
В этой статье я хотел бы поделиться с хабравцеми и маленькими хабрятами одним очень удобным дополнением для Pygame, найденным на просторах интернета буквально пару дней назад, но покорившем мое сердце. А все от того, что модуль, о котором пойдет речь, упрощает процесс создания 2D игрушек, делая его простым, наглядным, быстрым и увлекательным.
### Маленький ликбез о плиточных играх
Огромное количество плоских 2D игрушек относятся к так называемым "плиточным" играм, в которых основой построения игрового мира служат минимальные элементы - плитки, чаще всего квадратные с нанесенной на них текстурой.
К плиточным играм относятся и Сапёр и легендарный Марио и практически все стратегии на развитие территорий и пошаговые стратегии.
В основе построения мира лежит поле, составленное из отдельных квадратиков, каждый из которых может быть закрашен своим цветом или заполнен какой то текстурой.
Задача программиста нарисовать этот квадратный мир с помощью кода и научить персонажа в этом мире жить. Именно за простое создание игрового мира и отвечает модуль под названием TileTool.
### TileTool - может всё или почти всё?
Устанавливаем модуль в командной строке
> **pip install tiletool**
>
>
И через минуту мы готовы приступать.
У модуля на данный момент имеется три режима работы, то есть три варианта сборки мира.
1. Генератор прямоугольников
2. Создание мира из \*.txt или \*.csv файлов
3. Создание мира из файлов \*.tmx, созданных в визуальном редакторе плиточных уровней Tiled (<https://www.mapeditor.org/> - сайт редактора)
Для начала необходимо создать минимальный каркас проекта на Pygame, выглядит он так:
```
import pygame #Импортируем модуль Pygame
pygame.init() #Инициализируем инструментарий Pygame
window=pygame.display.set_mode((700, 640)) #Создаем окно шириной 700 и высотой 640
while True: #Бесконечный цикл, в котором будет "жить" игра
for i in pygame.event.get(): #Перебираем все события, происходящие в окне
if i.type == pygame.QUIT: #Если событие совпадаем с "закрытием окна", то есть нажатием на креcтикстик
pygame.quit() #Выходим из Pygame
pygame.display.update() #Обновляем экран
```
Данный код создает игровое окно и запускает цикл в котором будут происходить все события игры, а также делает возможным закрытие окна.
Теперь перейдем к созданию мира и сделаем это тремя разными способами.
**Способ №1. Генератор.**
TileTool позволяет создать прямоугольную область в виде контура или с заполнением клетками. Для этого до бесконечного цикла создаем объект на базе класса TileTool.
```
#Импортируем модуль TileTool
import tiletool
#Cоздаем первый объект TileTool с шириной в 7 и высотой 5 тайлов
#в координатах x=120 и y=120 с включенной заливкой
#Необязательный параметр fill принимая значение 1, заполняет весь создаваемый прямоугольник плитками,мии
#значение fill=0, оставляет внутреннее пространство пустым
Box=tiletool.TileTool((7,5),120,120,fill=1)
#К созданному объекту Box применяем метод fill_dict, связывая таким образом
#элементы созданной матрицы с графическими файлами тайлов
Box.fill_dict((1,0),('platform2.png','Empty'))
```
Тут требуется некоторое пояснение. В результате создания объекта, формируется двумерная матрица или таблица, такого вида:
в ней "1" стоят там, где позднее будут подставлены плитки, а "0" там, где останется пустое пространство.
Метод fill\_dict собственно и нужен для того, чтобы соединить графические файлы с матрицей, заменив единички на файл с картинкой, а вместо нуликов оставить пустое пространство.
```
Box.fill_dict((1,0),('platform2.png','Empty'))
# (1, 0) - кортеж с возможными значениями матрицы
# ('platform2.png','Empty') - соответствующий кортеж замен
# цифра 1 из первого котрежа заменится на изображение из файла platform2.png,
# цифра 0 заменится на "пустоту"
```
Всё, прямоугольник создан и заполнен тайлами. Осталось его отобразить в нашем окне.
```
while True:
#Внутри бесконечного цикла к объекту Box применяем метод blit_tiles, в который передаем имя нашего окна
Box.blit_tiles(window)
```
Одна из приятных фишек модуля заключается в том, что созданный прямоугольник, или, как многие уже догадались платформу, можно заставить двигаться буквально одной командой.
```
#Добавим в бесконечный цикл строчку:
Box.moving_tile((300,300),1,500,'HORIZONTAL',window)
#(300, 300) - левая или верхняя граница при движении платформы
#1 - скорость движения
#500 - значение правой или нижней границы движения платформы
#'HORIZONTAL' или 'VERTICAL' - направление движения горизонтально или вертикально
#window - имя окна
#И наша платформа будет двигаться горизонтально от точки (300,300) до (500,300) с минимальной скоростью 1.
#Если это слишком быстро, можно настроить частоту кадров с помощью метода tick модуля Pygame
#А чтобы движущийся объект не оставлял за собой след,
#над строкой с движением добавим заливку окна черным цветом
window.fill((0,0,0))
```
В результате полный код примера с генератором платформ будет выглядеть так:
```
import pygame
import tiletool
pygame.init()
window=pygame.display.set_mode((700, 640)) #creating the window(создаем окно)
Box=tiletool.TileTool((7,5),120,120,fill=0) #Создаем платформу
Box.fill_dict((1,0),('platform.png','Empty')) #Связываем графические файл и платформой. Файл platform.png должен содержать изображения тайла и лежать в папке с проектом
while True:
window.fill((0,0,0)) #Заливаем окно черным для очистки следа от движущегося объекта
Box.blit_tiles(window) #Отображаем платформу на экране
Box.moving_tile((300,300),1,500,'HORIZONTAL',window) #Заставляем платформу двигаться
for i in pygame.event.get():
if i.type == pygame.QUIT:
pygame.quit()
pygame.display.update()
```
Всего четыре строчки кода, а у нас уже есть движущаяся платформа, которая ко всему прочему, является наследницей класса pygame.sprite.Sprite, что позволяет добавлять ее в группы и проверять коллизии.
**Способ 2. Создание мира из \*.txt или \*.csv файлов**
Многие визуальные редакторы миров умеют экспортировать созданные слои, карты в формат csv или txt. Некоторые разработчики пользуются Excel'ем для рисования уровней. О вкусах не спорят. Тем не менее, TileTool прекрасно работает с подобными форматами. Внешне нарисованный в txt мир выглядит как то так:
По сути своей это такая же матрица, что создавалась Генератором в первом примере. Отличие лишь в том, что задача модуля не создать, а прочитать готовую матрицу из файла и связать ее с текстурами тайлов.
```
#Импортируем модули
import pygame
import tiletool
pygame.init() #Инициализируем инструментарий Pygame
window=pygame.display.set_mode((800, 800)) #Создаем игровое окно
#Cоздаем объект на основе csv-файла(файла с разделителем) в координатах(100,100)
Box1=tiletool.TileTool('test.csv',100,100)
#Связываем ключи из файла с картинками, для 0 передаем "empty"
Box1.fill_dict((42,21,0),('platform.png','platform2.png','empty'))
#Cоздаем объект на основе txt-файла с разделителем в координатах(0,0)
Box2=tiletool.TileTool('temp.txt',0,0)
#Cвязываем ключи из файла с картинками, для -1 передаем "empty"
Box2.fill_dict((10,-1),('platform.png','empty'))
while True:
window.fill((0,0,0))
#Размещаем оба объекта в окне
Box1.blit_tiles(window)
Box2.blit_tiles(window)
#Первый объект заставляем циклично двигаться
Box1.moving_tile((300,500),1,500,'VERTICAL',window)
for i in pygame.event.get():
if i.type == pygame.QUIT:
pygame.quit()
pygame.display.update()
```
Небольшое замечание по строчке
> Box1.fill\_dict((42,21,0),('platform.png','platform2.png','empty'))
>
>
В файлах txt и csv в открытом виде видны значения, используемые в построении миров. В методе fill\_dict в первом кортеже необходимо перечислить все значения используемые в файлах, а во втором кортеже сопоставить значениям имена графических файлов, а чтобы оставить "пустоту", достаточно передать 'empty'.
Как и в первом примере - всего пара строк и из текстовых файлов получаются готовые платформы.
**Способ 3. Создание мира из файлов \*.tmx (редактор миров Tiled)**
Не скрою, это мой любимый способ, поскольку визуальный редактор уровней Tiled в разы упрощает и ускоряет процесс создания больших и сложных уровней для двумерных игрушек. Умеет работать как с плоскими картами, так и с изометрией, что дает возможности создавать псевдо 3D игры.
Редактор "плиточных" уровней TiledПроект Tiled содержит в себе файлы \*.tsx, \*.tmx, графические файлы тайлов.
Одно из основных преимуществ редактора заключается в возможности создания многослойных уровней, что позволяет разделить фоновое изображение, передний, средний планы, добиваясь эффекта параллакса в движении, а кроме того, в одном файле нарисовать и статические элементы и на отдельных слоях платформы, которым уже в дальнейшем с помощью TileTool можно задать режимы движения.
И так, к практике:
```
import tiletool
import pygame
window=pygame.display.set_mode((800, 800))
#Создаем два объекта из одного файла desert1.tmx,
#отличаться объекты будут номером слоя, за который будут отвечать.
#Так, Box1 становится хозяином слоя №1 и мы может независимо управлять этим слоем
#Box2 становится владельцем слоя №2, который мы позднее заставим двигаться.
Box1=tiletool.TileTool('desert1.tmx',0,0,layer=1)
Box2=tiletool.TileTool('desert1.tmx',0,0,layer=2)
#Нам не нужно вызывать метод fill_dict, так как вся информация о изображениях,
#привязанных к ключам, указана в .tsx файле, относящемуся к данному .tmx файлу
while True:
window.fill((0,0,0))
Box1.blit_tiles(window)
Box2.blit_tiles(window)
Box2.moving_tile((0,0),1,200,'HoriZONTAL',window)
for i in pygame.event.get():
if i.type == pygame.QUIT:
pygame.quit()
pygame.display.update() #Oбновляем экран
```
И снова, всего три строчки и полчаса сэкономленного времени, которые можно потратить не на отрисовку игрового мира, а на работу с коллизиями и игровой механикой.
**Способ 4 (бонусный):**
У модуля TileTool есть еще один приятный метод, позволяющий в пару строк создавать персонажа и нацеливать на него виртуальную камеру, которая будет следить за ним, создавая иллюзию движения. Выглядит это так:
А реализуется примерно так:
```
import tiletool
import pygame
window=pygame.display.set_mode((700, 640))
#Cоздаем объект класса TileTool на основе первого слоя .tmx файла.
b1=tiletool.TileTool('desert.tmx',0,0,layer=1)
#Загружаем изображение и конвертируем его в подходящий формат, теперь в переменной filename находится файла с изображением нашего героя.
filename=pygame.image.load('platform.png').convert_alpha()
#Cоздаем объект класса platforms_objects в координатах x=100,y=200,
#за ним будет следовать камера. Также передаем в метод изображение героя.
f1=tiletool.platforms_objects(100,20,filename)
#Cледующие 2 строчки ограничивают частоту кадров в секунду
clock = pygame.time.Clock()
fps = 300
#Kамера будет следить за объектом f1 в координатах (0-1000) по x и (0-1000) по y.
#При выходе из этих координат объект выйдет за пределы экрана.
camera_obj=tiletool.camera(1000,1000,f1)
while True:
window.fill((0,0,0)) #Заливаем окно черным для очистки следа от движущегося объекта.
clock.tick(fps) #Настраиваем скорость обновления экрана.
#Oтображаем объект в окне. Необходимо передать объект класса camera во все вызовы blit_tiles.
b1.blit_tiles(window,camera_obj)
#Oтображаем объект platforms_objects в окне.
#Следует передать вызов метода drawCam,
#как в примере вместо свойства rect объекта,
#чтобы объект мог отображаться в координатах, нужных камере.
window.blit(f1.image,camera_obj.drawCam(f1))
for i in pygame.event.get():
if i.type == pygame.QUIT:
pygame.quit()
# Эти сторочки отвечают за движение объекта, используйте стрелки для движения.
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
f1.rect.x-=1
elif keys[pygame.K_RIGHT]:
f1.rect.x+=1
elif keys[pygame.K_DOWN]:
f1.rect.y+=1
elif keys[pygame.K_UP]:
f1.rect.y-=1
pygame.display.update() # Oбновляем экран.
```
Сравнительно недавно я в учебных целях реализовывал один уровень игры Марио, на что у меня ушло около 6 часов чистого времени. Познакомившись с модулем TileTool я решил переписать свой проект с использованием предоставившихся возможностей. Времени ушло 2.5 часа, а код сократился практически вдвое!
Автор модуля заявляет, что в следующих версиях появится поддержка изометрии, что даст возможность упрощать работу над псевдо 3D играми, что было бы очень кстати.
А в качестве заключения, хочу лишний раз подчеркнуть, что наличие огромного числа модулей для Python'a позволяет в разы сократить время прототипирования и разработки практически любых программ. И что тоже немаловажно, дает возможность не углубляться в изучение всего подряд, позволяя сосредоточится на одном узком направлении. На примере TileTool, я не хочу заморачиваться с "рисованием миров" и тратить на это свое время, мне интереснее физика движения, игровая механика, реалистичные коллизии, и на отработке этих элементов я хотел бы сосредоточиться. Те же, кому наоборот интереснее генерировать миры, могут сосредоточиться на изучении этой темы, а для физики движения использовать сторонние модули. Как говорится о вкусах не спорят!
Благодарю за терпение в данном лонгриде. Обзор получился довольно общим, и позволяет в общих чертах познакомиться с модулем, упрощающем жизнь создателей плиточных игрушек. Если стиль изложения и данный модуль вам понравились, с радостью поделюсь со всеми парой подробных и пошаговых статей-мануалов, написанных лично, о том как я с помощью модуля TileTool реализовал игры Марио и Сапёр. А также, если интересно, могу выложить мануал по редактору Tiled. | https://habr.com/ru/post/665042/ | null | ru | null |
# Использование МатАнализа в компьютерных играх (часть 3)
***Ключевые слова:*** *DPS (DamagePerSecond); Wolfram Mathematica; дискретность и непрерывность; матанализ; заработок игровой валюты в компьютерных играх; паки ArcheAge.*
Введение
--------
Всем знакомы однотипные вопросы в школьных задачах по математике про мотоциклиста выехавшего из пункта А в пункт Б, которые вызывают скуку, отвращение, или просто безразличие. Вопросы, которые вызывают, все что угодно кроме интереса к изучению математики. Очевидно что, гораздо больший интерес и больше эмоций вызывают вопросы типа:
**1)** *«как он смог меня одолеть в игре, если у моего персонажа и здоровья больше и DPS (Damage Per Second) выше?!»*
**2)** *«как быстрее всего заработать голду (игровую валюту), чтобы сделать своего персонажа сильнее?!»*
На самом деле эти игровые вопросы очень похожи на классические школьные задачи. Разница лишь в том, что есть заинтересованность в получении ответа на игровые вопросы, есть цель, ради которой хочется решить эти задачи. К сожалению, очень многие преподаватели в школах и вузах совершенно не умеют заинтересовать обучаемых в получении конкретной информации, новом методе решений математических задач, доведении их до ответа. Но раз уж игры вызывают этот самый интерес, то грех не воспользоваться заинтересованностью в игре, для пробуждения интереса к математическому анализу.
Вот две задачи, которые являются лишь переформулированными вышеупомянутыми вопросами.
**1)** *Петя и Коля решили помочь дедушке наполнить две одинаковые пустые бочки водой из колодца. Петя таскал воду в 5-и литровом ведре и на один заход к колодцу и обратно к бочке тратил 3 минуты, а Коля в 8-и литровом и на один заход тратил 5 минут. Каждый заполнял свою бочку. Кто из мальчиков быстрее заполнит свою бочку, если а) объём бочки 60 литров? б) если объем бочки 56 литров? (начали мальчики одновременно)*
**2)** *Два купца Семён и Добрыня покупают у крестьян по 10 пудов мёда за 5 золотых и везут его на продажу в соседние города. Добрыня везёт в ближайший город и продаёт там за 8 золотых, весь путь до города и обратно у него занимает 2 дня. Семён же, желающий продавать своё мёд как можно дороже, не ленится и везёт его ещё дальше, тратя на весь путь 3 дня, и продавая мёд в другом городе за 10 золотых. Кто же из купцов заработает больше за 360 дней непрерывной работы? Как изменится ситуация, если оба купца вынудят крестьян снизить цену на мёд до 3 золотых?*
Разбор этих задач, описанный ниже, поможет ответить на животрепещущие вопросы игры ArcheAge (и других) про «паки» и DPS. А также позволит задуматься над такими понятиями как «дискретность» и «непрерывность», а так же над таким, казалось бы, очевидным вопросом как «прибыль».
Парадокс ДПС
------------
Для того чтобы было легче разобраться с задачей про бочку, очень удобно нарисовать всё что происходит на графике. Красным цветом обозначим Петю, а зелёным Колю. Получим две лесенки. Бочка Коли и бочка Пети заполняются дискретно, длина ступенек равна времени похода до колодца и обратно к бочке, а высота равна количеству принесенной воды в литрах. На большей части полученного графика красная лесенка выше зелёной, но вот на некоторых участках выше зелёная.
Чтобы наполнить бочку объёмом 60 литров, используя 5 литровое ведро, нужно 12 раз сбегать с этим ведром до колодца. В итоге Петя потратит 3минуты\*12раз=36минут. Коле же, с его 8 литровым ведром, нужно 60/8=7.5раз. Получаем нецелое число. За 7 походов Коля принесёт только 7\*8=56 литров, что меньше чем нужно. А если ещё раз Коля пойдет за водой, то принесет уже 64 литра, что даже больше чем надо. В итоге Коле потребуется 8раз\*5минут=40минут, то есть Петя раньше наполнит свою бочку.
Ситуация меняется если надо было принести 56 литров. Для этого Коле нужно сбегать 56/8=7 раз, и займёт это 35 минут. Пете же потребуется 56/5=11.2раза, но так как важно именно целое число, то на самом деле Пете потребуется сходить 12 раз и займёт это 12\*3=36минут. В данном случае Петя наполнит свою бочку позже Коли.
Получается вот такая странная ситуация, что ответ на вопрос кто же быстрее заполнит бочку, зависит не только от мальчиков, но и от размеров бочки. Причём если посмотреть на график, то мест где графики пересекаются довольно много. Более того, можно даже сделать бочку Пети 55.9 литра, то есть меньше чем у Коли, а он всё равно заполнит её позже. Ещё удивительнее этот факт становится, если рассчитать среднюю скорость заполнения бочки Петей и Колей. У Пети средняя скорость равна 5/3=1.666 литра/минуту, а у Коли 8/5=1.600 литра/минуту. Коля может даже начать позже на полминуты, и всё равно Петя будет вторым.
То есть у Пети и скорость заполнения больше, и бочка меньше, и начал он раньше, а он всё равно заполнит свою бочку позже, чем Коля заполнит свою.
Вот такой парадоксальный результат получается именно из-за того, что процесс заполнения бочки носит дискретный характер.
Если же рассматривать случай когда два противника в игре наносят друг другу удары с разной силой и разной скоростью, то эта ситуация будет аналогична бочкам и ведрам, которую мы уже рассмотрели. И как было показано выше, не всегда стоит полагаться в оценке силы вас и вашего противника на так называемую DPS, то есть на среднюю скорость нанесения повреждений.
Совсем ли DPS неприменима? Не совсем. В некоторых случаях она вполне адекватно описывает ситуацию.
Для каждой лесенки, можно построить две параллельные прямые, которые будут проходить через верхние угловые точки и через нижние.
Та лестница, у которой DPS выше, после какого-то момента всегда будет выше второй. А этот момент можно найти как пересечение нижней прямой лестницы большего DPS, с верхней прямой лестницы меньшего DPS. Вот формулы для этих двух прямых.
**fDPSL1(t)=(DPH1/Period1)\*(t-Period1);
fDPSH2(t)=(DPH2/Period2)\*t;**
DPH1 и DPH2 это сила удара (объём ведра) за период Period1 и Period2 соответственно. DPH1/Period1=DPS1. А пересечение этих прямых происходит в момент
**T = Period1/(1-DPS2/DPS1)**
Из этой формулы видно, что влияние дискретности ситуации, и возможность возникновения связанных с дискретностью парадоксов, зависит от двух факторов. Первый фактор, это примерное равенство DPS обоих противников. В таком случае, знаменатель обращается в нуль, и время прекращения влияния дискретности ситуации стремится к бесконечности. Второй фактор, это период ударов того, у кого DPS выше. Чем выше частота ударов, тем меньше период, а значит и время прекращения влияния дискретности будет меньше.
Ещё из формулы для верхней прямой
**fDPSH2(t)=(DPH2/Period2)\*t**
видно, что это просто формула графика урона от времени при фиксированном DPS.
**fDPSH2(t)=DPS2\*t**
Если у противников DPS одинаков, то в лучшем положении окажется тот, у кого МЕНЬШЕ и сила и период ударов. В предельном случае, если период ударов стремится к нулю, то лесенка превратится в «непрерывную» прямую вида fDPSH(t)=DPS\*t. И данная прямая является наиболее выгодным вариантом при фиксированной PDS.
Таким образом, если есть выбор увеличить на N% силу удара или увеличить на те же N% частоту удара, то выгоднее увеличивать частоту, хотя в обоих этих случаях DPS увеличится одинаково. Однако, как показывает практика, многие в силу каких-то интуитивных заблуждений предпочитают увеличивать силу удара.
Ловушка жадности
----------------
Задача про купцов решается аналогичным образом. Семён за одну поездку тратит 5 золотых, получает 10, итого прибыль 5 золотых за 3 дня. Добрыня за 2 дня получает 3 золотых. За 360 дней Семён сделает 120 поездок и заработает 600золотых. Добрыня же заработает 360/2\*3=540 золотых. В итоге Семён правильно делает, что возит дальше, он заработает больше Добрыни. Если же Семён и Добрыня договорятся, и найдут способ заставить крестьян продавать им мёд по 3 золотых. То тогда Семён за одну поездку получит уже 7 золотых, а Добрыня 5. За 360 дней Семён получит 360/3\*7=840, а Добрыня 360/2\*5=900. То есть Добрыня за 360 дней заработает больше Семёна, несмотря на то, что продавать будет свой товар дешевле.
В экономике есть такое понятие как рентабельность — отношение прибыли от реализации к себестоимости реализованной продукции.
Так вот, если рассматривать отношение прибыли к затратам, то у Семёна рентабельность может показаться выше. За одну поездку потратив 5 золотых, он получает 5золотых прибыли. Добрыня же за 5 золотых получает лишь 3 золотых прибыли. Но с таким подходом, как можно заметить, совершенно не учитывается время, а его по хорошему нужно вставлять в себестоимость как зарплату Семену и Добрыни за перевозку. То есть помимо тех денег, что они вкладывают, нужно учитывать и то время, что они тратят. И когда идёт речь о получении прибыли, о способе заработка, то нужно обязательно принимать во внимание не только саму прибыль, полученную в результате каких-то действий, но и затраченное на них время.
Что бы стало яснее, как же так получается, что продавать по более низкой цене бывает выгодно, снова нарисуем график. На графике показана зависимость получаемой прибыли в единицу времени от себестоимости товара для 3 разных случаев. В каждом из случаев товар и его себестоимость будут считаться одинаковыми, а вот цена продажи и время на перевозку будут различны. Графики строятся по простой формуле
**F[Себестоимость]=(ЦенаПродажи — Себестоимость)/Время перевозки**
Примеры времени и цен продажи взяты из игры ArcheAge. Время измеряется в минутах, а цены в «голде».
В первом случае ЦенаПродажи =8г, Время =6минут, во втором ЦенаПродажи =11г, Время = 10минут, и в третьем случае ЦенаПродажи =13г, Время =16минут
В сети можно найти таблицу цен продажи всех возможных грузов в игре ArcheAge, например [тут](http://iddqd-guild.ru/?app=forums&module=forums&controller=topic&id=6837)
Но, тем не менее, в этих таблицах не указаны расстояния до мест продажи, что конечно является большим недостатком.
Реальные же затраты на сырье, которое необходимо для изготовления товаров, в игре достаточно сильно варьируются, в силу колебаний игрового рынка. Цены, вообще говоря, выставляются игроками, в том числе и так называемые «очки работы», которые необходимы для производства товара, и которые тоже можно покупать на «рынке». Себестоимость в данном примере приблизительно 7г, но может быть и значительно дороже.
Пониманию некоторой задачи, процесса, очень часто помогает рассмотрение крайних случаев. Если себестоимость товара равно нулю, то вся прибыль на единицу времени определяется временем, которое будет затрачено на перевозку. В общем случае все 3 прямые могут и не пересекаться, но в данном конкретном случае, при низкой себестоимости выгоднее возить в ближайшее место продажи. Если же себестоимость высокая, то она может быть выше чем цена продажи в ближайших точках, а это значит, что вы будете работать с отрицательной рентабельностью, то есть тратить больше, чем получаете. И тогда единственной возможностью заработать хоть сколько-то будет продажа в самом удалённом месте, где цена продажи выше себестоимости. Но при слишком высокой себестоимости, даже там продавать становится не выгодно. Так же существует и промежуточный вариант, когда выгоднее всего возить на среднее расстояние.
Стоит отметить, что эффекты, связанные с «дискретностью» получения прибыли, тут тоже естественно присутствуют. Принцип разбора этих эффектов, аналогичен тому, что был рассмотрен выше.
Когда такое пытаешься рассказать игрокам, очень часто получаешь в ответ «Лол?! Я знаю, что нужно делать! Чё ты меня учишь?!». Люди упорно стремятся продать свой товар как можно дороже, и совершенно не обращают внимания на то, сколько времени они на это тратят. Время же можно выражать в валюте и использовать уже эту «цену времени» в себестоимости, и тогда всё становится гораздо понятнее. Но очень часто встречаются те, кто ради 1 голды готовы везти ещё дальше, тратя время с гораздо меньшей эффективностью. В итоге пожадничав, они больше теряют.
И что самое интересное, даже те, кто знают об этих тонкостях, очень часто поддаются внутреннему сиюминутному соблазну, слепой ошибочной интуиции, и коварному и опасному чувству алчности, и всё равно прут туда, где объективно не выгодно продавать, но зато где они увидят, что цена продажи их товара выше. Психофизиология — против неё даже матан порой не работает. Зато эту особенности человеческого восприятия любят использовать в своих целях все кому не лень, паразитируя на жадинах.
Wolfram Mathematica
-------------------
[Wolfram Mathematica](http://www.wolfram.com/mathematica/) это черезвычайно мощный инструмент для решения разнообразных задач любой сложности. Однако не стоит думать, что раз Mathematica столько всего может, то она чрезвычайно сложна в использовании. На самом деле, я её очень часто использую просто как очень удобный, но и очень продвинутый калькулятор. При этом нет необходимости писать код алгоритмов. Чтобы нарисовать графики, или быстро сделать интерактивное окно, с полями ввода, ползунками и рисовалкой функций в реальном времени, то хватит несколько простых команд, которые очень подробно, на куче примерах описаны во встроенном хелпе.
Вот пример кода для отрисовки графиков прибыль/себестоимость.
**Код в Mathematica**
```
a = {{6, 8}, {10, 11}, {16, 13}};
f[i_, x_] := (a[[i]][[2]] - x)/a[[i]][[1]];
Plot[{f[1, x], f[2, x], f[3, x]}, {x, 0, 13},
PlotStyle -> {Red, Orange, Green}, PlotRange -> All]
```
И пример кода для вот такого удобного окошка для отрисовки дискретных процессов. Можно менять параметры и сразу сравнивать полученные результаты на графике.
**Код в Mathematica**
```
TotalD[DPH_, CD_, tDelay_, tDuration_] :=
Table[{n, DPH*(Quotient[n - tDelay, CD])}, {n, 0, tDuration,
tDuration/1000}];
(*Дискретный график наносимых повереждений участником боя через \
единицу времени*)(*Quotient даёт нам целое число количества ударов \
нанесеннного за некратное перезарядке время*)
DiffD[DPH1_, CD1_, tDelay1_, DPH2_, CD2_, tDelay2_, tDuration_] :=
Table[{n,
DPH2*(Quotient[n - tDelay2, CD2]) -
DPH1*(Quotient[n - tDelay1, CD1])}, {n, 0, tDuration,
tDuration/
1000}];(*Разница количества повреждений нанесенных двумя \
участинками*)
fDPSH[t_, DPH_, CD_,
tDelay_] := (DPH/CD)*(t -
tDelay);(*fDPSH и fDPSH это прямые которые "ограничевают" граффик \
наносимых повреждений. Можно сказать что это оценки сверху и снизу*)
fDPSL[t_, DPH_, CD_, tDelay_] := (DPH/CD)*(t - CD - tDelay);
Manipulate[
Column[{
Row[{
Row[{"DPS1=", Dynamic[N[DPH1/CD1]]}, Frame -> True,
FrameStyle -> {Red, Red}],
Row[{Dynamic[
If[DPH1/CD1 == DPH2/CD2, " EQUAL ",
If[DPH1/CD1 > DPH2/CD2, " MORE THAN ", "LESS THAN "]]]}],
Row[{"DPS2=", Dynamic[N[DPH2/CD2]]}, Frame -> True,
FrameStyle -> {Green, Green}]
}],
Show[{
Plot[
{fDPSL[t, DPH1, CD1, Delay1],
fDPSH[t, DPH1, CD1, Delay1],
fDPSL[t, DPH2, CD2, Delay2],
fDPSH[t, DPH2, CD2, Delay2]},
{t, 0, Duration},
PlotStyle -> {Darker[Orange], Darker[Orange], Darker[Blue],
Darker[Blue], PlotRange -> All}
],
ListLinePlot[
{TotalD[DPH1, CD1, Delay1, Duration],
TotalD[DPH2, CD2, Delay2, Duration],
DiffD[DPH1, CD1, Delay1, DPH2, CD2, Delay2, Duration]},
PlotStyle -> {Red, Green, Gray}, PlotRange -> All]
}, PlotRange -> All]
}],
{{DPH1, 10, "Value1"}, 0, 100, Appearance -> "Open"},
{{CD1, 0.8, "Period1"}, 0, 20, Appearance -> "Open"},
{{Delay1, 0}, -2, 2, Appearance -> "Open"},
{{DPH2, 8, "Value2"}, 0, 100, Appearance -> "Open"},
{{CD2, 0.7, "Period1"}, 0, 20, Appearance -> "Open"},
{{Delay2, 0}, -2, 2, Appearance -> "Open"},
{{Duration, 10}, 2, 1000, Appearance -> "Open"},
ControlPlacement -> {Right, Right, Right, Right, Right, Right, Right,
Right}
]
```
Нужно просто скопировать код в пустое окно Wolfram Mathematica и нажать Shift+Enter. Результат вы получите в том же окне.
Выводы
------
Интернет не всезнающ. Гайды, рецепты, методички на все случаи жизни в нём не найти. В каждом конкретном случае всё равно доработка, модернизация общеизвестных методов позволит достичь лучших результатов. Но для этого требуются анализировать ситуацию, и на основе известных данных синтезировать новые методы. Но такие навыки сами собой не возникнут, им нужно обучаться, тренировать. А это порой бывает делать скучно и лениво. Выхода два: либо пытаться процесс обучения в школе или в вузе, который зачастую кажется бессмысленным и скучным, делать осознанным, осмысленным и интересным, либо, занимаясь чем-то интересным и увлекательным, находить в этом интересные моменты, анализировать их и пытаться решить поставленные в игре задачи, как полноценные задачи по математике.
Если препод вам попался скучный и безынициативный, то это не повод не заниматься МатАнализом. В конце концов, оправдываясь плохим преподом, вы свою жизнь интереснее, а себя успешнее не сделаете. | https://habr.com/ru/post/283208/ | null | ru | null |
# Flutter.dev: Continuous delivery с Flutter
***Перевод статьи подготовлен в преддверии старта курса [«Flutter Mobile Developer»](https://otus.pw/WKU2/).***
---
*Следуйте лучшим практикам непрерывного развертывания (continuous delivery — CD) вместе с Flutter, чтобы ваше приложение было непременно доставлено вашим бета-тестерам и проверялось на регулярной основе без необходимости прибегать к ручным манипуляциям.*
### fastlane
В этом руководстве показано, как интегрировать [fastlane](https://docs.fastlane.tools/) (набор инструментов с открытым исходным кодом) в существующие рабочие процессы тестирования и непрерывной интеграции (continuous integration — CI), например, Travis или Cirrus.
**Local setup**
Перед переходом в облачную систему настоятельно рекомендуется протестировать процесс сборки и развертывания локально. Вы также можете реализовать непрерывное развертывание с локального компьютера.
1. Установите fastlane: `gem install fastlane` или `brew install fastlane`. Для получения более развернутой информации посетите [документацию Fastlane](https://docs.fastlane.tools/).
2. Создайте проект Flutter и, когда он будет готов, убедитесь, что ваш проект собирается посредством
* `flutter build appbundle`; и
* `flutter build ios --release --no-codesign`.
3. Инициализируйте проекты Fastlane для каждой платформы.
* Запустите `fastlane init` в каталоге `[project]/android`.
* Запустите `fastlane init` в каталоге `[project]/ios`.
4. Убедитесь, что `Appfile`ы содержат адекватные метаданные для вашего приложения.
* Убедитесь, что `package_name` в `[project]/android/fastlane/Appfile` совпадает с именем вашего пакета в `AndroidManifest.xml`.
* Убедитесь, что `[project]/ios/fastlane/Appfile` также соответствует идентификатору пакета `Info.plist`. Внесите в `apple_id`, `itc_team_id`, `team_id` данные вашей учетной записи.
5. Настройте локальные учетные данные для входа в сторы.
* Следуйте [настройке Supply](https://docs.fastlane.tools/getting-started/android/setup/#setting-up-supply) и убедитесь, что `fastlane supply init` успешно синхронизирует данные с вашей Play Store консоли. О*тноситесь к .json файлу как к своему паролю и не храните его в каких-либо общедоступных репозиториях систем контроля версий*.
* Ваш юзернейм ITunes Connect уже находится в ваших `Appfile`ах в поле `apple_id`. Запишите в переменную среды `FASTLANE_PASSWORD` ваш пароль iTunes Connect. В противном случае он будет запрашиваться при загрузке в iTunes/TestFlight.
6. Настройте цифровую подпись кода.
* В Android есть два ключа для подписи: ключ развертывания и ключ загрузки. Конечные пользователи загружают .apk, подписанный «ключом развертывания». «Ключ загрузки» используется для аутентификации .aab/.apk, загружаемого разработчиками в Play Store, и переподписывается ключом развертывания по завершению загрузки в Play Store.
+ Для ключа развертывания настоятельно рекомендуется использовать автоматическую подпись, которая управляется облаком. Для получения дополнительной информации [см. официальную документацию Play Store](https://support.google.com/googleplay/android-developer/answer/7384423?hl=en).
+ Чтобы создать ключ загрузки следуйте [инструкции по генерации ключа](https://developer.android.com/studio/publish/app-signing#sign-apk).
+ Настройте gradle на использование ключа загрузки во время создания билда приложения в режиме release, отредактировав `android.buildTypes.release` в `[project]/android/app/build.gradle`.
* В iOS, когда вы будете готовы к тестированию и развертыванию с помощью TestFlight или App Store, создайте и подпишите приложение, используя сертификат распространения вместо сертификата разработки.
+ Создайте и загрузите сертификат распространения в [консоли Apple Developer Account](https://developer.apple.com/account/ios/certificate/).
+ откройте `[project]/ios/Runner.xcworkspace/` и выберите сертификат распространения на панели настроек вашей цели.
7. Создайте скрипт `Fastfile` для каждой платформы.
* Для Android следуйте [руководству по развертыванию бета-версии Fastlane Android](https://docs.fastlane.tools/getting-started/android/beta-deployment/). Все редактирование может заключаться всего лишь в добавлении `lane`, которая вызывает `upload_to_play_store`. Установите значение аргумента `aab` в `../build/app/outputs/bundle/release/app-release.aab`, чтобы использовать пакет, который `flutter build` уже подготовил.
* Для iOS следуйте [руководству по развертыванию бета-версии Fastlane iOS](https://docs.fastlane.tools/getting-started/ios/beta-deployment/). Все редактирование может заключаться всего лишь в добавлении `lane`, которая вызывает `build_ios_app` с `export_method: 'app-store'` и `upload_to_testflight`. В iOS потребуется дополнительный билд, поскольку `flutter build` создает `.app`, а не архивирует `.ipas` для релиза.
Теперь вы готовы выполнять развертывание локально или переносить процесс развертывания в систему непрерывной интеграции (CI).
### Выполнение развертывания локально
1. Создайте приложение в режиме release.
* `flutter build appbundle`.
* `flutter build ios --release --no-codesign`. Сейчас не нужно подписывать, так как fastlane будет осуществлять подпись при архивировании.
2. Запустите скрипт Fastfile на каждой платформе.
* `cd android`, затем `fastlane [название созданной вами lane]`.
* `cd ios`, затем `fastlane [название созданной вами lane]`.
### Настройка сборки и развертывания в облаке
Сначала проследуйте инструкциям в разделе локальной настройки, описанном в разделе «Локальная настройка», чтобы убедиться, что процесс работает корректно, прежде чем переходить на облачную систему, такую как Travis.
Главное, на что следует обратить внимание — это то, что, поскольку облачные инстансы эфемерны и ненадежны, вы не должны оставлять свои учетные данные, такие как JSON учетной записи службы Play Store или сертификат распространения iTunes на сервере.
Системы непрерывной интеграции (CI), такие как [Cirrus](https://cirrus-ci.org/guide/writing-tasks/#encrypted-variables), обычно поддерживают зашифрованные переменные среды для хранения приватных данных.
Примите все меры предосторожности, чтобы не выводить значения этих переменных на консоль в ваших тестовых скриптах. Эти переменные также не должны быть доступны в пул-реквестах, пока они не будут смержены, чтобы злоумышленники не могли создать пул-реквест, который умыкнет эти секреты. Будьте осторожны при взаимодействии с этими секретами в пул-реквестах, которые вы принимаете и мержите.
1. Сделайте учетные данные эфемерными.
* В Android:
+ Удалите поле `json_key_file` из `Appfile` и сохраните содержимое JSON строки в зашифрованном переменной вашей CI системы. Используйте аргумент `json_key_data` в `upload_to_play_store`, чтобы прочитать переменную среды непосредственно в вашем `Fastfile`.
+ Сериализуйте свой ключ загрузки (например, используя base64) и сохраните его как зашифрованную переменную среды. Вы можете десериализовать его в своей системе CI на этапе установки с помощью
+ ```
echo "$PLAY_STORE_UPLOAD_KEY" | base64 --decode > /home/cirrus/[directory # и имя файла, указанное в вашем gradle].keystore
```
* В iOS:
+ Переместите локальную переменную среды `FASTLANE_PASSWORD` для использования зашифрованных переменных сред в системе CI.
+ Системе CI требуется доступ к вашему сертификату распространения. Рекомендуется использовать систему Fastlane [Match](https://docs.fastlane.tools/actions/match/) для синхронизации ваших сертификатов на разных машинах.
2. Рекомендуется использовать Gemfile вместо использования индетерминированного `gem install fastlane` в системе CI, чтобы гарантировать стабильность и воспроизводимость зависимостей fastlane между локальными и облачными машинами каждый раз. Однако этот шаг не является обязательным.
* В обоих `[project]/android` и `[project]/ios` папках создайте Gemfile, содержащий следующее содержимое:
* ```
source "https://rubygems.org"
gem "fastlane"
```
* В обоих каталогах запустите `bundle update` и внесите `Gemfile.` и `Gemfile.lock` в систему контроля версий.
* При локальном запуске используйте `bundle exec fastlane` вместо `fastlane`.
3. Создайте тестовый скрипт CI, например `.travis.yml` или `.cirrus.yml`, в корне репозитория.
* Сегментируйте свой скрипт для работы на платформах Linux и macOS.
* Не забудьте указать зависимость от Xcode для macOS (например, o`sx_image: xcode9.2`).
* См. [документацию Fastlane по CI](https://docs.fastlane.tools/best-practices/continuous-integration) для настройки конкретной CI.
* На этапе установки, в зависимости от платформы, убедитесь, что:
+ Bundler доступен с помощью `gem install bundler`.
+ Для Android убедитесь, что Android SDK доступен и указан путь `ANDROID_SDK_ROOT`.
+ Запустите `bundle install` в `[project]/android` или `[project]/ios`.
+ Убедитесь, что Flutter SDK доступен и установлен в `PATH`.
* На скриптовом этапе задачи CI:
+ Запустите приложение `flutter build appbundle` или `flutter build ios --release --no-codesign`, в зависимости от платформы.
+ `cd android` или `cd ios`
+ `bundle exec fastlane [имя lane]`
**Ссылки**
См. [скрипт Cirrus](https://github.com/flutter/flutter/blob/master/.cirrus.yml) для репозитория фреймворка Flutter.
### Другие службы
Ниже приведены некоторые другие варианты, которые помогут автоматизировать развертывание вашего приложения.
+ [Codemagic CI/CD для Flutter](https://blog.codemagic.io/getting-started-with-codemagic/)
+ [Flutter CI/CD с Bitrise](https://devcenter.bitrise.io/getting-started/getting-started-with-flutter-apps/)
+ [Appcircle CI/CD для Flutter](https://appcircle.io/blog/guide-to-automated-mobile-ci-cd-for-flutter-projects-with-appcircle/)
+ [GitHub Actions- CI/CD от GitHub](https://github.com/features/actions)
А здесь [пример проекта](https://github.com/nabilnalakath/flutter-githubaction) | https://habr.com/ru/post/520230/ | null | ru | null |
# Proof Of Concept на Python или как портировать С/С++
Язык программирования Python существует уже 31 год. Это полностью объектно-ориентированный язык. За все время существования на нем стало возможно применять разные парадигмы. Сейчас этот язык может поддерживать:
* объектно ориентированную парадигму
* структурное программрование
* обобщенное программирование
* функциональное программирование
* метапрограммирование
* контрактное и логическое программирование
Список уже достаточно внушителен, но язык можно продолжать развивать за счет дополнительных плагинов и библиотек.
Помимо всех этих возможностей из-за простого синтаксиса язык стал самым распространенным для прототипирования различных функций больших и маленьких проектов. Некоторые области Computer Science вообще изначально используют этот язык, потому что он максимально прост и не обязательно долго листать документацию, чтобы понять, как создать простейшее приложение. На Python написано большое количество библиотек, которые могут решать различные задачи: от 3D моделирования до сетевого взаимодействия. Причем использовать язык можно не только на уровне абстракций, которые применяют языки высокого уровня, но также можно выполнять и более низкоуровневые задачи.
Статья будет содержать 3 части, в ходе которых мы будем иссследовать возможность портирования C/C++ кода для различных ОС. В этой статье посмотрим, насколько эффективно можно реализовать возможность работы с оперативной памятью и получением данных от системы.
### Библиотека ctypes
Python не был бы так популярен, если бы на его запуск и написание алгоритма тратилось столько времени, сколько требуют языки программирования C/C++. Такое сравнение мы используем не случайно, ведь именно C и C++ являются языками, на которых написан софт со сложной структурой в несколько миллионов строк. К таким гигантам можно отнести в том числе и операционные системы: в них любая библиотека, интерфейс, протокол с большой долей вероятности создавались с использованием C/C++.
Так почему же python можно легко использовать для портирования того или иного кода, написанного на другом популярном языке программирования? Ответ прост: python содержит набор примитивов для работы с другими языками. Поэтому можно "подружить" библиотеку, которая написана на языке программирования C/C++ и др., с новой программой на Python.
В Python для этих целей используется библиотека Ctypes. На момент написания статьи она все еще входит в язык и даже заявлена для [beta версии](https://docs.python.org/3.10/library/ctypes.html). И все, что эта библиотека делает - предоставляет совместимые с C compatible типы данных, которые позволяют работать с библиотеками и другим расшариваемым кодом. Поэтому, если необходимо, можно написать обертку для Python над старой или новой библиотекой и потом просто вызывать функцию так, как будто Python всегда умел работать с ней.
На самом деле это очень крутая функция, так как для преобразования типов и структур данных можно потратить много времени. Познакомимся с библиотекой поближе.
### Ctypes: пример
Библиотека Ctypes позиционируется как механизм для работы в первую очередь с расшариваемым кодом. То есть стартовая часть работы библиотеки может включать функцию загрузки этого кода в память приложения. Для этого в каждой операционной системе есть свой объект. Например, если приложение разрабатывается под ОС Windows, то понадобятся следующие функции библиотеки Ctypes:
* cdll
* windll
* oledll
Выбор необходимой функции зависит от соглашения о вызовах (stdcall, cdecl, fastcall), которую будет использовать расшариваемый портируемый код. Разница в существующих соглашениях о вызовах состоит в последовательности передачи параметров для функций, работой с возвращаемыми значениями и сопутствующими работе функции структурами данных. Получается, чтобы работать с библиотекой Ctypes, придется сначала понять, как работает расшариваемый код и при помощи какого соглашения он создан.
Для отличия можно использовать следующий короткий свод правил:
* если в имени функции есть символ `_` и нет символа `@`, тогда это `__cdecl`
* если имя функции начинается с символа `_` и содержит знак `@` это `__stdcall`
* если имя функции содержит несколько символов `@` это `__fastcall`.
Кстати, для операционной системы Windows еще проще можно определять тип fascall соглашения: Windows библиотеки и исполняемые файлы для x64 архитектуры могут использовать только fastcall.
Все типы данных в ctypes начинаются с префикса `с_`. Полный список их можно найти [здесь](https://docs.python.org/3.10/library/ctypes.html).
Попробуем выполнить простую операцию - открыть диалоговое окно в ОС Windows через ctypes. Использовать будем Windows 10, Python 3.9. Исходник:
```
import ctypes
MB_OK = 1
_user32 = ctypes.WinDLL('user32', use_last_error=True)
_MessageBoxW = _user32.MessageBoxW
_MessageBoxW.restype = ctypes.c_int
def MessageBoxW(hwnd, text, caption, utype):
result = _MessageBoxW(hwnd, text, caption, utype)
if not result:
raise ctypes.WinError(ctypes.get_last_error())
return result
def main():
result = MessageBoxW(None, "Message", "Title", MB_OK)
return result
if __name__ == "__main__":
main()
```
Результат выглядит примерно так:
Просто, хотя и много доподнительных определений. Попробуем переключиться на портирование чего-то специфичного.
### Работа с памятью
Работа с этим ресурсом является чуть ли не основной фишкой, которую используют языки программирования типа С/С++. И дело тут в том, что они умеют работать с памятью без ограничений, причем за большей частью операций с памятью программист должен следить самостоятельно. Чтение памяти может быть полезно для изучения структуры объектов, с которыми работает приложение или операционная система.
Иногда приложению требуется изменить ту или иную часть оперативной памяти другого приложения или самого себя во время работы. Для проведения всех операций используется метод сканирования памяти на нахождение данных по заданным характеристикам. Поэтому остро стоит вопрос о возможности работать с указателями. Попробуем реализовать этот функционал.
Прямое обращение к указателям и проведение арифметических операций, к сожалению, не доступно. Но есть пара вариантов, как это можно реализовать. Не очень изящно, но зато эффективно. Варианты могут быть такими:
* создание объекта, который будет по размеру соответствовать размеру сканируемого объема памяти
* использование указателя для сканирования, но при этом нужно найти способ модифицировать его адрес
* использовать функции WinApi
3-й вариант как раз наш способ. Попробуем его реализовать. Для работы с WinApi придется использовать [документацию](https://docs.microsoft.com/en-us/windows/win32/api/).
И так как это работа через WinApi, то для выполнения чтения нужно провести несколько операций:
1. Получить хэндлер процесса
2. Запросить доступ к нужному адресу
3. Считать данные
Если переводить на функции, которые необходимы для чтения оперативной памяти, то нужно разобрать документацию по следующим функциям:
* [GetCurrentProcessId](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getcurrentprocessid)
* [OpenProcess](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-openprocess)
* [ReadProcessMemory](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-readprocessmemory)
Для всех функций желательно так же определить константы, которыми они пользуются, поэтому будем их задавать в начале скрипта. В итоге у нас получится вот такой код:
```
from ctypes import *
from ctypes.wintypes import *
import binascii
# Определим какие функции нам необходимы для работы
_kernel32 = WinDLL('kernel32.dll')
OpenProcess = _kernel32.OpenProcess
OpenProcess.argtypes = DWORD,BOOL,DWORD
OpenProcess.restype = HANDLE
ReadProcessMemory = _kernel32.ReadProcessMemory
ReadProcessMemory.argtypes = HANDLE,LPVOID,LPVOID,c_size_t,POINTER(c_size_t)
ReadProcessMemory.restype = BOOL
GetProcessId = _kernel32.GetCurrentProcessId
GetProcessId.restype = c_int
_user32 = WinDLL('user32.dll')
IsMenu = _user32.IsMenu
# Раздел констант, чтобы не искать по документации
STANDARD_RIGHTS_REQUIRED = 0x000F0000
SYNCHRONIZE = 0x00100000
PROCESS_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF)
#Функция для показа содержимого памяти в удобном формате
def hexdump(p):
output = []
l = len(p)
i = 0
while i < l:
output.append('{:04d} '.format(i))
for j in range(16):
if (i + j) < l:
byte = p[i + j]
output.append('{:02X} '.format(byte))
else:
output.append(' ')
if (j % 16) == 7:
output.append(' ')
output.append(' ')
output.append('\n')
i += 16
return ''.join(output)
def main:
# найдем PID
procId = GetProcessId()
if get_last_error() != 0:
print("Cannot get Process ID")
return -1
# для работы с процессом нужно получить хэндл
process_handle = OpenProcess(PROCESS_ALL_ACCESS, False, procId)
if get_last_error() != 0:
print("Cannot get Process Handle")
return -1
#Начинаем читать
pIsMenu = ctypes.cast(IsMenu, POINTER(c_byte))
STRLEN = 255
buf = create_string_buffer(STRLEN)
bytesReaded = c_size_t()
if not ReadProcessMemory(process_handle, pIsMenu, buf, STRLEN, byref(s)):
print("Cannot read memory!")
return -1
rawBytes = ""
for i in buf:
rawBytes+=i.hex()
rawBytes = binascii.unhexlify(rawBytes)
hexdump(rawBytes)
if __name__ == "__main__":
main()
```
При работе с WinAPI лучше всего проверять результат, мало ли, что вернула функция. Поэтому, чтобы не было неожиданных ситуаций, нужно описать, какие параметры использует функция и какие данные должна вернуть. А чтобы было удобнее смотреть содержимое оперативной памяти, добавили функцию для красивого отображения.
В следующей статье попробуем поработать с механизмами добавления кода в уже работающий процесс и помониторим его активность. А сейчас хочу пригласить всех желающих на бесплатный демоурок в рамках которого обсудим различные виды типизации, заглянем в теорию типов, рассмотрим примеры и best practice по аннотированию в Python, а также поговорим про существующие type checker'ы. [Регистрация уже доступна по ссылке](https://otus.pw/Gdfk/).
Курс Python, обучение Python course онлайн, курсы Python, программист Python — курсы | OTUS[otus.ru](https://otus.ru/lessons/python-professional/) | https://habr.com/ru/post/649087/ | null | ru | null |
# Обзор новых возможностей в NDepend 6
Что такое NDepend уже было [рассказано](http://habrahabr.ru/post/70387/) на хабре — это статический анализатор кода на .NET'е. Недавно вышла новая — 6-я версия этой замечательной утилиты, о новых возможностях которой рассказывается ниже. Это перевод, оригинальная статья [здесь](http://blog.ndepend.com/ndepend-version-6-insights/).
#### Правильный выбор новых возможностей
Недавно [вышел NDepend 6](http://www.ndepend.com/ndepend-v6). До сих пор выход главных релизов назначался на время после выхода Visual Studio, и сейчас Visual Studio 2015 в предрелизном состоянии. NDepend 6 это результат напряжённых работ в течении 18 месяцев. После [11 лет разработки](http://www.ndepend.com/release-notes) NDepend достиг определённого уровня зрелости, но всё ещё остаётся много возможностей и улучшений, которые возможно сделать. И для версии 6 самым деликатным вопросом оказался выбор новых возможностей и улучшений для пользователей. С тех пор как в 2013 году была выпущена версия 5, были получены идеи с [Visual Studio User Voices](https://visualstudio.uservoice.com/forums/121579-visual-studio/filters/top) и [NDepend User Voices](http://ndepend.uservoice.com/forums/226344-ndepend-user-voice/filters/top). Собственно говоря, [новые возможности 6-й версии](http://www.ndepend.com/ndepend-v6) хорошо отражают [наиболее востребованные возможности](http://ndepend.uservoice.com/forums/226344-ndepend-user-voice/status/1106390), которые были завершены.
#### Интеграция в процесс сборки
Пользователи просили о большей интеграции NDepend в процесс автоматической сборки. Они запускали [NDepend.Console.exe](http://www.ndepend.com/docs/ndepend-console) для сбора информации и [отчёта](http://www.ndepend.com/sample-reports/) о том, не нарушаются ли [важные правила](http://www.ndepend.com/docs/critical-cqlinq-rule), по которым процесс сборки считается неудачным (эту информацию можно получить по коду возврата от NDepend.Console.exe). Пользователи просили показать больше информации непосредственно в инструментах сборки. Существует много технологий сборки, самые запрашиваемые из которых это [TFS](http://www.ndepend.com/docs/tfs-integration-ndepend), [TeamCity](http://www.ndepend.com/docs/teamcity-integration-ndepend) и [SonarQube](http://www.ndepend.com/docs/sonarqube-integration-ndepend). В результате разработчики сотрудничали с высококлассными экспертами этих технологий, чтобы сделать встроенную интеграцию, которая, предположительно, включает большинство сценариев использования, и которая будет поддерживаться для будущих версий и получать новые возможности.
#### Улучшенная интеграция с Visual Studio
Т.к. пользователи хотели большей интеграции с процессом сборки, то в течении последнего года усилия в основном были посвящены инструментам для Visual Studio. NDepend был интегрирован в Visual Studio с помощью технологии VS Addin — это решение было принято командой разработки в 2009 году. В то время VSIX (другой стопоб разработки расширений для студии) был сырой, а также надо было поддерживать VS2008 и VS2005, поэтому VS Addin был правильным выбором. Со времененем VS Addin становился всё менее актуальным, не получал улучшений от Microsoft, и приводил к сбоям, но самое главное — не было возможности запомнить расположение окон NDepend во время выполнения. Это доставляло пользователям большие неудобства и заканчивалось просьбами на [User Voice запомнить расположение окон](https://ndepend.uservoice.com/forums/226344-ndepend-user-voice/suggestions/5564192-remember-window-layouts).
Начиная с версии 6 NDepend основывается на технологии VSIX для интеграции в VS 2015, 2013, 2012 и 2010. Кроме того, Microsoft запретил использовать VS Addin в 2015 студии. В любом случае, благодаря VSIX стало возможным сделать более гладкую и надёжную интеграцию с Visual Studio, с запоминанием окон, новыми возможностями (например, прикрепление проекта NDepend к .suo (а не только к .sln), и полную поддержку горячих клавиш).
Также, были три возможности, представленные бесплатными расширениями для студии, которые были включены в NDepend, чтобы они всегда были под рукой.
#### Улучшения правил
Правила для кода на .NET'е — основная возможность NDepend'а. Пользователи оставили много отзывов о способах как улучшить существующие правила, в основном уменьшить ложные срабатывания. Поэтому было переделано около трети правил по умолчанию в соответствии с их рекомендациями.
Это здорово, что правила для кода — изменяемые [LINQ-запросы на C#](http://www.ndepend.com/features/cqlinq#CQL), которые содержат немного комментариев. Но для многих пользователей они были недостаточно информативны о том, почему правило создаёт предупреждение, почему соблюдение конкретного правила улучшит код, и как исправить нарушение правила. Поэтому была добавлена возможность добавлять 2 форматированных текста в исходный код правила NDepend через теги и . Это хорошая возможность описать каждое правило по умолчанию и более подробно объяснить его пользователю. И в интерфейсе и в отчёте пользователь может выбрать что смотреть — Description/HowToFix или исходный код правила на C# LINQ.
Другая потребность пользователей была, чтобы делать доступными правила между несколькими проектами NDepend. Обычно у компании есть несколько проектов, анализируемых с помощью NDepend, и пользователи хотят управлять ими всеми сразу. И беря во внимание, что на NDepend писать свои правила для кода на .NET проще чем где либо ещё, пользователи хотели возможность использовать один профиль для разных проектов. Поэтому в NDepend 6 есть возможность определить список правил, которые можно использовать совместно в проектах NDepend.
#### Визуализация метрик кода
В NDepend уже была визуализация метрик кода с помощью [treemap](https://en.wikipedia.org/wiki/Treemapping), и было решено добавить раскраску. Идея в том, что можно показать две метрики кода. Одна представлена прямоугольной областью, а другая цветом прямоугольника. Например, на следующей картинке показано покрытие кода NDepend 6 тестами специфичным, но удобным и точным способом.
* Прямоугольники — методы,
* Прямоугольные области пропорциональны количеству строк кода,
* Цвет прямоугольника — процент покрытия кода тестами.
Взглянув, сразу понятно что цветной treemap может помочь понять информацию, которую было бы сложно понять другим способом. Несмотря на то, что код NDepend покрыт тестами на 82%, можно увидеть скопления красных прямоугольников которые показывают код, недостаточно покрытый тестами. Вероятно, больше нет инструмента, который может показать это с такой точностью.
Разработчики NDepend стараются делать возможности продукта связными. Поэтому можно визуализировать не только любые две из многих [метрик NDepend'а](http://www.ndepend.com/docs/code-metrics), а и свои метрики кода, [описанные через LINQ-запросы на C#](http://www.ndepend.com/docs/treemap-visualization-of-code-metrics#Custom), а также можно подсветить конечный код правила или запроса. В результате если запросить сложные методы, то их можно отобразить на цветном treemap:
Стоит отметить, что т.к. покрытие кода тестами это один из самых важных показателей качества, то также был добавлен отдельный интерфейс для этого в результатах кода запроса:
#### Что ещё должно было быть сделано
Продукт находится в постоянно меняющейся среде. Это значит, некоторые возможности, хорошо работающие раньше, должны быть пересмотрены. Некоторые из этих нужных улучшений были сделаны в NDepend 6-й версии.
**Вспомогательный код, сгенерированный компилятором C# и VB.NET:** От версии к версии в C# и VB.NET появлялось всё больше сахара. Это началось с анонимных методов и итераторов в C# 2.0. Затем появились лямбды и анонимные типы в C# 3.0, а затем async/await в C# 5.0. Эти конструкции заставляют компилятор генерировать дополнительные методы и типы. И т.к. эти конструкции довольно часто используются, эти сгенерированные элементы накапливаются в коде IL. А [NDepend в основном полагается на IL код для получения информации о коде](http://www.ndepend.com/docs/ndepend-analysis-inputs-explanation). Поэтому модель кода NDepend включает все сгенерированные методы и типы и это раздражает пользователя, которому в основном интересен только его код. Теперь NDepend исправляет это. Просто избавиться от всех этих сгенерированных элементов не выход, т.к. они, на самом деле, содержат некоторый пользовательский код. Поэтому были разработаны некоторые эвристики, чтобы объединить эти сгенерированные элементы с пользовательскими классами и методами, которые содержат код, из-за которого это генерируется компилятором. Таким образом не пришлось идти на компромисс — все данные модели кода сохранены, включая метрики кода (количество строк, процент покрытия, цикломатическая сложность, ...), зависимости и различия.
**Улучшенная поддержка async:** Асинхронные конструкции имеют специфичность, что вызвало некоторые затруднения у NDepend. Пользовательский код, на самом деле, встраивается компилятором в сгенерированный метод, который переопределяет виртуальный метод [IAsyncStateMachine.MoveNext()](https://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.iasyncstatemachine.movenext(v=vs.110).aspx). Поэтому IL код, вызывающий этот сгенерированный метод MoveNext() связан с абстрактным методом интерфейса, а не с реализацией. Вызовы асинхронного метода теряются в IL коде… и, следовательно, в модели кода NDepend. Благодаря эвристикам, написанным для предыдущего пункта, NDepend теперь способен анализировать и выявлять правильных вызывающих асинхронных методов.
**Поддержка высокого разрешения:** Сейчас мониторы с высоким разрешением (такие как 4K) становятся доступными и, как следствие, всё больше разработчиков работают с соответствующими настройками Windows. Это значит, что плотность пикселей выше и, следовательно, для отображения графического элемента (текст, картинка) используется больше пикселей. Интерфейс NDepend'а в основном основан на Windows Form и GDI+, и эти технологии по умолчанию не очень хорошо масштабируются когда Windows настроена на высокое разрешение. Когда пользователи начали сообщать об этой проблеме, то было решено переделать весь интерфейс NDepend'а, чтобы он мог работать с настройками разрешения от 100% до 250%. Это была возможность улучшить некоторые графические элементы и научиться некоторым способам работы с Windows Form и GDI+ при высоком разрешении. Результаты этого будут описаны в будущей статье в блоге NDepend, т.к. в интернете видно, что это является проблемой для многих разработчиков.
**Темы в Visual Studio:** Из статистики видно, что большинство пользователей используют NDepend из Visual Studio. Поэтому темы интерфейса NDepend не очень хорошо сочетаются со стандартными темами Visual Studio, такими как Светлая (Light), Тёмная (Dark), Синяя (Blue) и стандартной темой VS2010. К счастью в NDepend элементы меню, панели, привязки… основаны на библиотеке [DevExpress WinForm](https://www.devexpress.com/Products/NET/Controls/WinForms/) и их последняя версия включает эти темы (и не только). Поэтому помогло простое обновление до последней версии.
**Улучшение анализа:** Некоторые улучшения должны были быть сделаны в отношении анализа. Проект NDepend'а ссылается на некоторые каталоги и имена сборок (без расширения файла). Во время анализа расположение сборок для анализа находилось следующими двумя способами. Если найдено много копий сборки, то если они все одинаковые, то NDepend брал одну из них, а если они различались, то NDepend сообщал об ошибке, т.к. эта ситуация считается серьёзной проблемой разворачивания решения. Но со временем появлялись новые технологии, такие как Windows Phone или Portable Class Libraries, и они приводили к такой ситуации во время исправной работы. Поэтому при обнаружении такой ситуации теперь NDepend 6 использует эвристический анализ для нахождения правильной сборки, основываясь на её версии, зависимостях и размере файла. | https://habr.com/ru/post/261265/ | null | ru | null |
# Пулинг объектов в Unity 2021+
Разрабатывая игры, вы могли заметить, что создание порядка 100 экземпляров пуль в секунд.
* **A**: **уменьшить** количество пуль до 20
* **B**: **реализовать** свою собственную пулинговую систему
* **C**: **заплатить** 50 долларов за пулинговую систему в Asset Store
* **D**: **использовать** новый Pooling API Unity, представленный в 2021 году
*(СМОТРИТЕ ВИДЕО В ОРИГИНАЛЕ СТАТЬИ)*
В этой статье мы рассмотрим последний вариант.
Сегодня вы узнаете, как использовать новый Pooling API, представленный в 2021 году.
Начиная с Unity 2021, у вас есть доступ к широкому набору фич для работы с пулами, которые помогут вам разрабатывать высокопроизводительные проекты на Unity.
Готовы узнать о них побольше?
### Когда вам нужен пул?
Начнем с самого главного вопроса: когда вам нужен пул?
Я задаю его, потому что пулы не должны быть вашим дежурным решением.
Пул объектов в Unity определенно имеет некоторые важные недостатки, которые приносят больше вреда, чем пользы, поэтому использовать его нужно с умом.
Но мы рассмотрим это позже.
Если вкратце, то вам стоит рассматривать возможность использования пулов, когда:
* Вы **создаете и уничтожаете игровые объекты очень быстро**, например пули оружия.
* Вы **часто аллоцируете и высвобождаете объекты, хранящиеся в куче** (вместо их повторного использования). Это относится и к коллекциям C#.
Эти операции вызывают много аллокаций, следовательно вы сталкиваетесь с:
* Избыточным расходом тактов процессора на операций создания и уничтожения (или new/dispose).
* Преждевременной сборкой мусора, вызывающей фризы, которые ваши игроки не оценят.
* Фрагментацией памяти, которая затрудняет поиск свободных смежных областей памяти.
Не кажется ли вам, что эти проблемы могут представлять для вас угрозу?
(Если сейчас - нет, то они могут позже)
Но давайте продолжим.
### Итак, что же такое это (объектный) пулинг в Unity в конце-то концов?
Теперь, когда вы понимаете, попали ли вы в беду (или все еще в безопасности), позвольте мне быстро объяснить, что такое пулинг.
Пулинг - это метод оптимизации производительности, который заключается в повторном использовании сущностей C# вместо того, чтобы создавать и уничтожать их каждый раз, когда они вам нужны.
Сущность может быть чем угодно: игровым объектом, инстансом префаба, словарем C# и т. д.
Позвольте мне продемонстрировать концепцию пулинга в контекст реального примера.
Допустим, вам нужно завтра утром пойти за продуктами.
Что вы обычно берете с собой, кроме кошелька и ключей?
Ну, можно взять **многоразовые сумки**. В конце концов, вам нужны какие-то контейнеры, чтобы донести продукты домой.
Итак, вы берете пустые многоразовые сумки, наполняете их продуктами и возвращаетесь домой.
Вернувшись домой, вы опустошаете свои сумки и кладете их обратно в ящик.
Это и есть пул.
Многоразовые сумки — лучшая альтернатива, чем покупка (аллокация) пластиковых пакетов и их выбрасывание (высвобождение) каждый раз, когда вы идете за покупками.
Вам нужна сумка?
Хорошо, вы идете к своему пулу сумок (например, ящик на кухне), **берете** несколько, используете их, **вытаскиваете** все из них и, наконец, **возвращаете** их обратно в пул.
Поняли в чем соль?
Вот основные детали юзкейса пулинга:
* **Элементы**, для которых вы хотите задействовать пул, например, многоразовые сумки, инстанцированная пуля и т.д. ...
* **Глобальная цель** для всех этих элементов, например, перенос продуктов, стрельба пулями и т.д. ...
* **Функции**, которые вы выполняете над пулом и его элементами: **Take** (взять), **Return** (вернуть), **Reset** (сбросить).
В случае с шутером вы можете создавать и уничтожать пули каждый раз при выстреле… или вы можете заранее создать определенное количество, а затем повторно использовать их следующим образом:
* Вы создаете тысячу пуль и помещаете их в пул.
* Каждый раз, когда вы стреляете из своего оружия, вы берете пулю из этого пула.
* Когда пуля попадает во что-то и исчезает, вы возвращает ее обратно в пул.
Таким образом вы экономите такты процессора, необходимые для создания и уничтожения этих префабов. Кроме того, вы уменьшаете нагрузку на сборщик мусора.
Теперь, прежде чем сразу нырнуть в пулинг, обратите внимание на несколько моментов...
### Когда следует отказаться от использования пула?
У техники пулинга есть несколько (потенциальных) проблем:
1. **Ваши элементы могут загрязняться**. Поскольку они уже использовались в прошлом, вы могли оставить их в непригодном состоянии, например, пули с небольшими остатками красной краски на них. Это означает, что вам нужно потратить несколько тактов процессора, чтобы очистить свои элементы перед их использованием: операция **reset**.
2. **Вы резервируете память, которая может вам так и не понадобиться**. Если вы создаете пул с тысячами пуль, но все, что ваш игрок хотел сделать, это полюбоваться видами, то вы зря потратили память.
3. **Это усложняет вашу кодовую базу**. Вам необходимо управлять жизненным циклом своих пулов. Это не только увеличивает количество тактов процессора, но и увеличивает количество **мозговых тактов** из-за обработки большей кодовой базы.
Все, что вам нужно сделать, — это избегать пулов в тех случаях, когда вы не получите от них никакой выгоды.
Скажем, нет никакой необходимости пулить финального босса. В конце концов, он существует в единственном экземпляре.
Помните: самое главное — это частота ваших операций создания и уничтожения.
Если вы делаете их часто, рассматривайте возможность использования пулов. В противном случае даже не думайте об этом.
Позже мы рассмотрим больше проблем с пулами.
Теперь давайте посмотрим на наши доступные варианты для реализации пулов.
### Пулы объектов в Unity 2021: ваши варианты
Если вы хотите добавить пул объектов в свой проект Unity, у вас есть три варианта:
* Создать свою собственную систему
* Купить стороннюю систему пулинга
* Импортировать `UnityEngine.Pool`
Давайте рассмотрим их.
#### A) Создаем свою собственную систему пулинга
Один из вариантов — применить на практике свое мастерство.
Внедрение вашей собственной системы пулинга не выглядит слишком сложным, поскольку вам нужно всего лишь реализовать несколько операций:
* Создать и удалить пул (Create & dispose)
* Взять из пула (Take)
* Вернуться в пул (Return)
* Операции сброса (Reset)
Но это часто становится гораздо сложнее, когда вы начинаете думать о:
* Типобезопасности
* Управление памятью и структурах данных
* Пользовательской аллокации/высвобождении объектов
* Потокобезопасности
Это уже больше похоже на головную боль? Чувствую, ваше лицо побледнело...
Предлагаю не изобретать велосипед (если только это не учебное упражнение).
Поскольку это уже решенная проблема, используйте что-то, что работает, чтобы вы могли сосредоточиться на своем проекте.
Сосредоточьтесь на том, чтобы доставить удовольствие своим игрокам. В любом случае они вам за это заплатят. Проверим второй вариант.
#### B) Сторонние системы пулинга объектов
Здесь вам всего лишь нужно выбирать одного из таких поставщиков, как:
* The Unity Asset Store
* Github
* Друг или член семьи
Давайте рассмотрим несколько примеров:
### Pooling Toolkit
### 13Pixels Pooling
### Pure Pool
### Pro Pooling
* [RecyclerKit](https://github.com/prime31/RecyclerKit)
* [Unity Object Pool](https://github.com/thefuntastic/unity-object-pool)
Но прежде чем вы нажмете кнопку покупки… прочитайте немного дальше.
Сторонние инструменты могут творить чудеса и обладают множеством фич.
Но у них есть недостатки:
* Вы полагаетесь на их поддержку в исправлении проблем и обновлении пакетов для более новых версий редактора.
* Если у вас нет исходного кода, вы не сможете исправить проблемы самостоятельно.
* Больше фич = сложнее код. Вам потребуется время, чтобы понять и поддерживать их систему.
* Они могут быть достаточно дорогими (и по деньгам и по времени).
Вы, наверное, все это и так уже знали, но об этом всегда стоит упомянуть.
И в настоящее время осталось еще меньше причин для использования сторонних решений, поскольку Unity втихаря зарелизила новый API для пулинга в Unity 2021.
И это основная тема этой статьи.
#### C) Новый Pooling API от Unity
Начиная с версии 2021 года, Unity зарелизила несколько механизмов пулинга C#, которые помогут вам во множестве юзкейсов.
Эти новые пулы объектов напрямую интегрированы в движок Unity. Не требуется никаких дополнительных загрузок, и они поддерживается в актуальном состоянии при каждом обновлении Unity.
Огромный плюс — у вас есть доступ к их исходному коду.
И я должен отметить, что их реализации довольно просты. Это приятное вечернее чтиво.
Давайте посмотрим, как вы можете начать использовать Unity Pooling API прямо сегодня, чтобы снизить затраты на операции, о которых и вы, и я прекрасно знаем.
### Как использовать новый Object Pooling API в Unity 2021
Первый шаг — убедиться, что вы используете Unity 2021+.
(Я имею в виду, вы можете просто скопировать и вставить код в любой из ваших старых проектов... но эй, я этого не говорил, если что)
После этого, это просто вопрос знания Unity Pooling API:
* Операции пулинга
* Различные контейнеры пулов
Я уже рассказывал вам несколько спойлеров о пулах. Но теперь давайте углубимся в них.
(СМОТРИТЕ ВИДЕО В ОРИГИНАЛЕ СТАТЬИ)
#### 1. Построение вашего пула
Первая операция, которую вам нужно сделать, — это построить контейнер для пула по вашему выбору. Обычно это делается в одну строчку кода, так что здесь не беспокойтесь.
Параметры конструктора зависят от конкретного контейнера, который вы хотите использовать, но они очень похожи. Вот обычные параметры конструктора пула Unity:
| | |
| --- | --- |
| | |
| `createFunc` | Вызывается для создания нового экземпляра вашего объекта, например `() => new GameObject(“Bullet”) or () => new Vector3(0,0,0)` |
| `actionOnGet` | Вызывается, когда вы берете экземпляр из пула, например, для активации игрового объекта. |
| `actionOnRelease` | Вызывается, когда вы возвращаете экземпляр в пул, например, чтобы очистить и деактивировать экземпляр. |
| `actionOnDestroy` | Вызывается, когда пул уничтожает этот элемент, то есть когда он не помещается (превышает максимальный размер) или пул уничтожается. |
| `collectionCheck` | True, если вы хотите, чтобы Unity проверяла, что этот элемент еще не был в пуле, когда вы пытаетесь его вернуть (только в редакторе). |
| `defaultCapacity` | Размер пула по умолчанию: начальный размер стека/списка, который будет содержать ваши элементы. |
| `maxSize` | Размер пула: максимальное количество свободных элементов, которые находятся в пуле в любой момент времени. Если вы вернете предмет в заполненный пул, он будет уничтожен. |
Вот как вы можете создать пул `GameObjects`:
```
_pool = new ObjectPool(createFunc: () => new GameObject("PooledObject"), actionOnGet: (obj) => obj.SetActive(true), actionOnRelease: (obj) => obj.SetActive(false), actionOnDestroy: (obj) => Destroy(obj), collectionChecks: false, defaultCapacity: 10, maxPoolSize: 10);
```
Я оставил названия параметров для наглядности; не стесняйтесь пропускать их в вашем коде.
И, конечно же, это всего лишь пример с `GameObject`. Вы можете использовать его с любым типом, с которым захотите.
Хорошо, теперь у вас есть пул \_GameObject\_’ов.
Как нам им пользоваться?
#### 2. Создание элементов пула
Первое, что Unity нужно знать, — это как создавать больше ваших \_GameObject\_’ов, когда вы запрашиваете больше, чем доступно.
Мы уже указали это в конструкторе, поскольку передали функцию `createFunc` в качестве первого параметра конструктору пула.
Каждый раз, когда вы захотите взять `GameObject` из пустого пула, Unity создаст его для вас и отдаст вам.
И для его создания он будет использовать переданнуювами функцию`createFunc`.
А как нам взять `GameObject` из пула?
#### 3. Извлечение элемента из пула
Теперь, когда ссылка на пул хранится в `_pool`, вы можете вызвать его функцию `Get`:
```
GameObject myGameObject = _pool.Get();
```
Вот и все.
Теперь вы можете использовать объект по своему усмотрению (в определенных рамках).
Когда вы закончите с ним, вам нужно вернуть его обратно в свой пул, чтобы вы могли использовать его позже.
#### 4. Возврат элемента в пул
Итак, вы использовали свой элемент несколько минут, и теперь он вам больше не нужен. Что дальше?
Вот чего вы сейчас не делаете: вы не уничтожаете (destroy/dispose) его сами. Вместо этого вы возвращаете его в пул, чтобы пул мог правильно управлять своим жизненным циклом в соответствии с предоставленными вами функциями.
Как это сделать? Легко:
```
_pool.Return(myObject);
```
Тогда пул:
1. Вызовет функцию `actionOnRelease`, которую вы предоставили с этим элементом качестве аргумента, чтобы деактивировать его, остановить систему частиц и т.д. ...
2. Проверит, есть ли достаточно места в своем внутреннем списке/стеке на основе MaxSize
3. Если есть достаточно свободного пространство в контейнере, он поместит туда объект.
4. Если свободного места нет, то он уничтожит объект, вызвав `actionOnDestroy`.
Вот и все.
А теперь об уничтожении элементов.
#### 5. Уничтожение элемента из вашего пула
Всякий раз, когда вы утилизируете (dispose) свой пул, или в нем нет внутреннего пространства для хранения возвращаемых вами элементов, пул уничтожает эти элементы.
И делает это он, вызывая функцию `actionOnDestroy`, которую вы передали в его конструкторе.
Эта функция может быть совершенно пустой или вызывать `Destroy(myObject)`*,* если мы говорим об объектах, управляемых Unity.
И, наконец, когда вы закончите работу с пулом, вы должны его утилизировать.
#### 6. Очистка и утилизация вашего пула
Утилизация вашего пула — это высвобождение ресурсов, принадлежащих пулу. Часто внутри вашего пула есть стек или список, содержащий элементы, которые можно свободно из него брать. Что ж, вы избавляетесь от своего пула, вызывая:
```
_pool.Dispose();
```
Вот это собственно и есть вся функциональность пула. Но нам все еще не хватает одного важного момента.
**Не все пулы созданы для одних и тех же юзкейсов**
Давайте посмотрим, какие типы пулов предлагает Unity, чтобы удовлетворить ваши потребности.
Типы пулов в Unity 2021+
------------------------
#### LinkedPool и ObjectPool
Первая группа пулов — это те, которые охватывают обычные объекты C# (95%+ элементов, которые вы, возможно, захотите поместить в пул).
Типичным вариантом использования пулов этого типа являются игровые объекты — независимо от того, созданы они из префабов или нет.
Разница между `LinkedPool` и `ObjectPool` заключается во **внутренней структуре данных**, которую Unity использует для хранения элементов, которые вы хотите поместить в пул.
`ObjectPool` просто использует Stack C#, который использует массив C# под капотом:
```
private T[] _array;
```
Будучи стеком, он содержит большой кусок непрерывной памяти.
Наихудший случай — наличие 0 элементов (длина = 0) в большом пуле (емкость = 100000). Там у вас будет большой кусок зарезервированной памяти, который вы не используете.
Изменение размера стека происходит, когда вы превышаете его емкость. И это дорого, так как вам нужно выделить больший кусок и скопировать элементы.
> Подсказка: вы можете избежать изменения размера стека, играя с параметром конструктора `maxCapacity`.
>
>
`LinkedPool` использует связанный список, который может улучшить управление памятью в зависимости от вашего юзкейса. Вот как выглядит эта структура данных:
```
internal class LinkedPoolItem { internal LinkedPool.LinkedPoolItem poolNext; internal T value; }
```
Используя `LinkedPool`, вы используете память только для элементов, которые фактически хранятся в пуле.
Но это требует дополнительных затрат: вы тратите больше памяти на элемент и больше тактов процессора для управления этой структурой данных. В любом случае вы, вероятно, знаете разницу между массивами и связанными списками.
Итак, давайте поговорим о следующей категории классов пулов в Unity.
#### ListPool, DictionaryPool, HashSetPool, CollectionPool
Теперь мы поговорим о пулах коллекций C# в Unity.
Видите ли, при разработке игр вам, скорее всего, придется использовать списки, словари, хеш-множества и коллекции.
И достаточно часто вам нужно часто создавать/уничтожать эти коллекции.
Мы часто делаем это в структурах ИИ при выполнении определенных одноразовых действий или алгоритмов. Там нам часто требуются вспомогательные структуры данных для выполнения поиска, оценки и скоринга.
Вот в чем собственно дело.
Каждый раз, когда вы создаете и уничтожаете коллекции, вы оказываете давление на систему управления памятью. Это потому, что вы:
* Аллоцируете и высвобождаете коллекцию плюс ее внутренние структуры данных.
* Вы можете динамически изменять размер своих коллекций.
Таким образом, решение, которое помогает с некоторыми из этих рантайм аллокаций в Unity, - это пулинг коллекций.
Когда вам понадобится список, вы можете просто взять его из пула, использовать и вернуть, когда закончите.
Вот пример:
```
var manuallyReleasedPooledList = ListPool.Get();
manuallyReleasedPooledList.Add(Random.insideUnitCircle);
// Use your pool
// ...
ListPool.Release(manuallyReleasedPooledList);
```
А вот другая конструкция, которая освобождает для вас пул коллекций:
```
using (var pooledObject = ListPool.Get(out List automaticallyReleasedPooledList))
{
automaticallyReleasedPooledList.Add(Random.insideUnitCircle);
// Use your pool
// ...
}
```
Каждый раз, когда вы выходите за пределы этого `using` блока, Unity будет возвращать список в пул за вас.
`CollectionPool` - это базовый класс для этих конкретных коллекций; поэтому, если вы создаете свои собственные коллекции, вы можете создать для них пул, унаследовав от него.
`ListPool`, `DictionaryPool` и `HashSetPool` - это особые пулы для соответствующих типов коллекций.
Но вы должны быть осторожны с этими пулами для коллекций. Я говорю это, потому что внутри все эти пулы коллекций в Unity работают на основе статической переменной пула. Это означает вот что.
Использование этих пулов коллекций нарушит функцию, которая сокращает время итерации в редакторе: **отключение перезагрузки домена**. Если вы необдуманно используете такие статические пулы, объединенные элементы будут сохраняться на протяжении выполнений в редакторе. И это не очень весело.
Наконец, давайте посмотрим на других плохишей: `GenericPool` и его близнеца `UnsafeGenericPool`.
Они, как и описывают их названия, являются пулами общих объектов. Но в них есть кое-что особенное.
#### GenericPool и UnsafeGenericPool
Итак, что такого особенного с этими пулами объектов?
Опять же, `GenericPool` и `UnsafeGenericPool` являются пулами статических объектов. Таким образом, их использование не позволит вам отключить перезагрузку домена, чтобы сократить время итерации редактора.
С другой стороны, вам не нужно беспокоиться о создании их для любого из ваших юзкейсов.
Вы просто используете их, когда и где бы (и кем бы) вы ни находились.
```
var pooledGameObject = GenericPool.Get(); pooledGameObject.transform.position = Vector3.one; GenericPool.Release(pooledGameObject);
```
Вот так просто.
Вариант `UnsafeGenericPool` работает лучше за счет пропуска важной проверки: проверки **уже возвращенного** **объекта**. Видите ли, когда вы возвращаете объект в пул, возможно, вы уже возвращали его в прошлом (и не вынимали его из пула). Это может быть проще, чем вы думаете, особенно если вы используете статические пулы и одни и те же объекты используются в нескольких местах.
В этом случае элемент может дважды появиться во внутренней структуре данных пула. И угадайте, что происходит, когда вы берете два элемента?
БАБАХ!
Вы будете использовать один и тот же объект в двух разных местах, и естественно будете перезаписывать изменения в нем. Представьте, что вы использовали один и тот же игровой объект для двух разных игроков.
Подводя итоги различий:
> `GenericPool` использует статический `ObjectPool` с `collectionCheck = true`
>
> `UnsafeGenericPool` использует статический `ObjectPool` с `collectionCheck = false`
>
>
Хорошо, как вы видели, не все в пулах красиво и аккуратно. Но вотрем еще немного соли в рану.
### Проблемы с пулами (почему вы не должны ими злоупотреблять)
Я мог бы написать как минимум 3 статьи, подробно описывающих неприятные проблемы, которые могут возникнуть с пулами.
Но вместо того, чтобы делать это, я просто обозначу их здесь, основываясь на отличном посте [Джексона Данстана](https://www.jacksondunstan.com/articles/3829).
Вот некоторые из проблем, с которыми вы можете столкнуться при использовании пулов:
1. **Вашим объектам требуется явный возврат**. Если вы забудете вернуть объект пула, сборщик мусора должен будет выполнить ту работу, которой вы хотели избежать в первую очередь (в лучшем случае).
2. **Вы должны сбросить состояние ваших объектов**. Если вы не сбросите состояние своих объектов, старые данные будут попадать в экземпляры, которые вы получаете из пула. Объект больше не будет «свежим». Ваши пули могут содержать следы крови.
3. Если вы используете один и тот же объект из пула в разных местах, вы должны **вернуть объект только тогда, когда все его пользователи закончат с ним**. Вы не хотите возвращать объект несколько раз, так как это гарантированно вызовет у вас головную боль. Таким образом, вам потребуется какой-то ручной подсчет ссылок, дорогостоящие для процессора проверки или стратегия, чтобы убедиться, что есть только один владелец.
4. **Управление памятью коллекций трудно**. Вы можете пулить списки, хэш-множества, словари и тому подобное. Но делать предположения об их размерах сложно. Когда вы получаете список из пула, он может иметь размер 4, в то время как вам действительно нужен список размером 1000+. Вы бы принудительно изменили размер. Бывает и наоборот. Короче говоря, вы можете в конечном итоге потратить много памяти на поддержание жизни огромных коллекций, когда вам нужно всего несколько предметов для них.
5. **По умолчанию пулы не являются потокобезопасными**. А если вы добавите механизмы для поддержки потоковой безопасности, тогда вы добавите накладные расходы на процессор, которые могут больше не окупаться.
Хорошая пища для размышлений.
#### Так, что еще?
Пулы — отличные инструменты для снижения:
* затрат производительности, связанных с распределением ресурсов в игровом процессе;
* давления, которое вы оказываете на бедный сборщик мусора;
А с Unity 2021+ теперь стало проще, чем когда-либо, принять пул как образ жизни разработчика, поскольку теперь у нас есть встроенное pooling API.
Однако я объяснил темную сторону пулов. Сторона, которая может доставить вам массу боли во время разработки вашего проекта.
Пул — это еще один инструмент повышения производительности, который вы должны знать. И чем больше инструментов вы знаете, тем лучше.
---
> Перевод материала подготовлен в рамках курса [**"Unity Game Developer. Professional"**](https://otus.pw/rOdC/)**.** Если вам интересно узнать о курсе подробнее, приглашаем на [день открытых дверей](https://otus.pw/Yi6O/): на нем преподаватель расскажет о формате и особенностях обучения, о программе и выпускном проекте.
>
> | https://habr.com/ru/post/560880/ | null | ru | null |
# Functools – сила функций высшего порядка в Python
В стандартной библиотеке Python есть множество замечательных модулей, которые помогают делать ваш код чище и проще, и `functools` определенно является одним из них. В этом модуле есть множество полезных функций высшего порядка, которые можно использовать для кэширования, перегрузки, создания декораторов и в целом для того, чтобы делать код более функциональным, поэтому давайте отправимся на экскурсию по этому модулю и посмотрим, что он может нам предложить.
### Кэширование
Давайте начнем с самых простых, но довольно мощных функций модуля `functools`. Начнем с функций кэширования (а также декораторов) - `lru_cache`*,* `cache` и `cached_property`. Первая из них - `lru_cache`предоставляет кэш последних результатов выполнения функций, или другими словами, запоминает результат их работы:
```
from functools import lru_cache
import requests
@lru_cache(maxsize=32)
def get_with_cache(url):
try:
r = requests.get(url)
return r.text
except:
return "Not Found"
for url in ["https://google.com/",
"https://martinheinz.dev/",
"https://reddit.com/",
"https://google.com/",
"https://dev.to/martinheinz",
"https://google.com/"]:
get_with_cache(url)
print(get_with_cache.cache_info())
# CacheInfo(hits=2, misses=4, maxsize=32, currsize=4)
print(get_with_cache.cache_parameters())
# {'maxsize': 32, 'typed': False}
```
В этом примере мы делаем GET-запросы и кэшируем их результаты (до 32 результатов) с помощью декоратора `@lru_cache`. Чтобы увидеть, действительно ли кэширование работает, можно проверить информацию о кэше функции, с помощью метода `cache_info`, который показывает количество удачных и неудачных обращений в кэш. Декоратор также предоставляет методы `clear_cache` и `cache_parameters` для аннулирования кэшированных результатов и проверки параметров, соответственно.
Если вам нужно более детализированное кэширование, можете включить необязательный аргумент `typed=true`, что позволяет кэшировать аргументы разных типов по отдельности.
Еще один декоратор для кэширования в `functools` – это функция, которая называется просто `cache`. Она является простой оберткой `lru_cache`, которая опускает аргумент `max_size`, уменьшая его, и не удаляет старые значения.
Еще один декоратор, который вы можете использовать для кэширования – это `cached_property`. Как можно догадаться из названия, он используется для кэширования результатов атрибутов класса. Механика очень полезная, если у вас есть свойство, которое дорого вычислять, но оно при этом остается неизменным.
```
from functools import cached_property
class Page:
@cached_property
def render(self, value):
# Do something with supplied value...
# Long computation that renders HTML page...
return html
```
Этот простой пример показывает. Как можно использовать `cached_property`, например, для кэширования отрисованной HTML - страницы, которая должна снова и снова показываться пользователю. То же самое можно сделать для определенных запросов к базе данных или долгих математических вычислений.
Еще одна прелесть `cached_property` в том, что он запускается только при поиске, поэтому позволяет нам менять значение атрибута. После изменения атрибута закэшированное ранее значение меняться не будет, вместо этого будет вычислено и закэшировано новое значение. А еще кэш можно очистить, и все, что нужно для этого сделать – это удалить атрибут.
Я хочу закончить этот раздел предостережением относительно всех вышеперечисленных декораторов – не используйте их, если у вашей функции есть какие-то побочные эффекты или если она при каждом вызове создает изменяемые объекты, поскольку это явно не те функции, которые вы захотите кэшировать.
### Сравнение и упорядочивание
Вероятно, вы уже знаете, что в Python можно реализовать операторы сравнения, такие как `<`, `>=` или `==`, с помощью `lt`, `gt` или `eq`. Однако, может быть довольно неприятно реализовывать каждый из `eq`, `lt`, `le`, `gt` или `ge`. К счастью, в `functools` есть декоратор `@total_ordering`, который может помочь нам в этом, ведь все, что нам нужно реализовать – это `eq` и один из оставшихся методов, а остальные декоратор сгенерирует автоматически.
```
from functools import total_ordering
@total_ordering
class Number:
def __init__(self, value):
self.value = value
def __lt__(self, other):
return self.value < other.value
def __eq__(self, other):
return self.value == other.value
print(Number(20) > Number(3))
# True
print(Number(1) < Number(5))
# True
print(Number(15) >= Number(15))
# True
print(Number(10) <= Number(2))
# False
```
Так мы можем реализовать все расширенные операции сравнения несмотря на то, что руками написали только `eq` и `lt`. Наиболее очевидным преимуществом является удобство, которое заключается в том, что не нужно писать все эти дополнительные волшебные метода, но, вероятно, важнее здесь уменьшение количества кода и его лучшая читаемость.
### Перегрузка
Вероятно, всех нас учили, что перегрузки в Python нет, но на самом деле есть простой способ реализовать ее с помощью двух функций из `functools`, а именно `singledispatch` и/или `singledispatchmethod`. Эти функции помогают нам реализовать то, что мы бы назвали алгоритмом множественной диспетчеризации, который позволяет динамически типизированным языкам программирования, таким как Python, различать типы во время выполнения.
Учитывая, что перегрузка функций сама по себе является довольно обширной темой, я посвятил отдельную статью `singledispatch` и `singledispatchmethod`. Если вы хотите узнать о теме побольше, вы можете прочитать о ней [здесь](https://martinheinz.dev/blog/50).
### Partial
Мы все работаем с различными внешними библиотеками или фреймворками, многие из которых предоставляют функции и интерфейсы, требующие от нас передачи коллбэков, например, для асинхронных операций или прослушивания событий. В этом нет ничего нового, но что, если нам нужно еще и передать некоторые аргументы вместе с коллбэком. Именно здесь и пригодится `functools.partial`*.* Можно использовать `partial` для замораживания некоторых (или всех) аргументов функции, создавая новый объект с упрощенной сигнатурой функции. Запутались? Давайте рассмотрим несколько примеров из практики:
```
def output_result(result, log=None):
if log is not None:
log.debug(f"Result is: {result}")
def concat(a, b):
return a + b
import logging
from multiprocessing import Pool
from functools import partial
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("default")
p = Pool()
p.apply_async(concat, ("Hello ", "World"), callback=partial(output_result, log=logger))
p.close()
p.join()
```
Код выше показывает, как можно использовать `partial` для передачи функции (`output_result`) вместе с аргументом (`log=logger`) в качестве коллбэка. В этом случае мы воспользуемся `multiprocessing.apply_async`, которая асинхронно вычисляет результат функции (`concat`) и возвращает результат коллбэка. Однако `apply_async` всегда будет передавать результат в качестве первого аргумента, и, если мы хотим включить какие-то дополнительные аргументы, как в случае с `log=logger`, нужно использовать `partial`.
Мы рассмотрели достаточно продвинутый вариант использования, а более простым примером может быть обычное создание функции, которая пишет в `stderr` вместо `stdout`:
```
import sys
from functools import partial
print_stderr = partial(print, file=sys.stderr)
print_stderr("This goes to standard error output")
```
С помощью этого простого трюка мы создали новую callable-функцию, которая всегда будет передавать `file=sys.stderr` в качестве именованного аргумента для вывода, что позволяет нам упростить код и не указывать значение именованного аргумента каждый раз.
И последний хороший пример. Мы можем использовать `partial` в связке с малоизвестной функцией `iter`, чтобы создать итератор, передав вызываемый объект и `sentinel` в `iter`, что можно применить следующим образом:
```
from functools import partial
RECORD_SIZE = 64
# Read binary file...
with open("file.data", "rb") as file:
records = iter(partial(file.read, RECORD_SIZE), b'')
for r in records:
# Do something with the record...
```
Обычно при чтении файла мы хотим итерироваться по строкам, но в случае бинарных данных нам может понадобиться итерироваться по записям фиксированного размера. Сделать это можно, создав вызываемый объект с помощью `partial`, который считывает указанный чанк данных и передает их в `iter` для создания итератора. Затем этот итератор вызывает функцию чтения до тех пор, пока не дойдет до конца файла, всегда беря только указанный объем чанка (`RECORD_SIZE`). Наконец, по достижении конца файла возвращается значение `sentinel` *(b'')* и итерация прекращается.
### Декораторы
Мы уже говорили о кое-каких декораторах в прошлых разделах, но не о декораторах для создания еще большего количества декораторов. Одним из таких декораторов является `functools.wraps`. Чтобы понять зачем он нужен, давайте просто посмотрим на пример:
```
def decorator(func):
def actual_func(*args, **kwargs):
"""Inner function within decorator, which does the actual work"""
print(f"Before Calling {func.__name__}")
func(*args, **kwargs)
print(f"After Calling {func.__name__}")
return actual_func
@decorator
def greet(name):
"""Says hello to somebody"""
print(f"Hello, {name}!")
greet("Martin")
# Before Calling greet
# Hello, Martin!
# After Calling greet
```
Этот пример показывает, как можно реализовать простой декоратор. Мы оборачиваем функцию, выполняющую определенную задачу (`actual_func`), внешним декоратором, и она сама становится декоратором, который затем можно применить к другим функциям, например, как в случае с `greet`. При вызове функции `greet`вы увидите, что она выводит сообщения как от `actual_func`, так и свои собственные. Вроде выглядит нормально, не так ли? Но что будет, если мы сделаем так:
```
print(greet.__name__)
# actual_func
print(greet.__doc__)
# Inner function within decorator, which does the actual work
```
Когда мы вызываем имя и документацию декорированной функции, мы понимаем, что они были заменены значениями из функции декоратора. Это плохо, поскольку мы не можем перезаписывать все наши имена функций и документацию каждый раз при использовании какого-либо декоратора. Как же решить эту проблему? Конечно же, с помощью `functools.wraps`:
```
from functools import wraps
def decorator(func):
@wraps(func)
def actual_func(*args, **kwargs):
"""Inner function within decorator, which does the actual work"""
print(f"Before Calling {func.__name__}")
func(*args, **kwargs)
print(f"After Calling {func.__name__}")
return actual_func
@decorator
def greet(name):
"""Says hello to somebody"""
print(f"Hello, {name}!")
print(greet.__name__)
# greet
print(greet.__doc__)
# Says hello to somebody
```
Единственная задача функции `wraps` – это копирование имени, документации, списка аргументов и т.д., для предотвращения перезаписи. Если учесть, что `wraps` – это тоже декоратор, можно просто добавить его в нашу `actual_func`, и проблема решена!
### Reduce
Последнее, но не менее важное в модуле `functools` – это `reduce`. Возможно, из других языков, вы можете знать ее как `fold` (Haskell). Эта функция берет итерируемый объект и сворачивает (складывает) все его значения в одно. Применений этому множество, например:
```
from functools import reduce
import operator
def product(iterable):
return reduce(operator.mul, iterable, 1)
def factorial(n):
return reduce(operator.mul, range(1, n))
def sum(numbers): # Use `sum` function from standard library instead
return reduce(operator.add, numbers, 1)
def reverse(iterable):
return reduce(lambda x, y: y+x, iterable)
print(product([1, 2, 3]))
# 6
print(factorial(5))
# 24
print(sum([2, 6, 8, 3]))
# 20
print(reverse("hello"))
# olleh
```
Как видно из кода, `reduce`может упростить или сжать код в одну строку, которая в противном случае была бы намного длиннее. С учетом сказанного злоупотреблять этой функцией только ради сокращения кода, делать ее «умнее» - обычно плохая идея, поскольку она быстро становится страшной и нечитаемой. По этой причине, на мой взгляд, пользоваться ей стоит экономно.
А если помнить, что `reduce`частенько сокращает все до одной строки, ее отлично можно скомбинировать с `partial`:
```
product = partial(reduce, operator.mul)
print(product([1, 2, 3]))
# 6
```
И, наконец, если вам нужен не только итоговый «свернутый» результат, то вы можете использовать `accumulate` – из другого замечательного модуля `itertools`. Для вычисления максимума ее можно использовать следующим образом:
```
from itertools import accumulate
data = [3, 4, 1, 3, 5, 6, 9, 0, 1]
print(list(accumulate(data, max)))
# [3, 4, 4, 4, 5, 6, 9, 9, 9]
```
### Заключение
Как видите, в `functools` есть множество полезных функций и декораторов, которые могут облегчить вам жизнь, но это лишь верхушка айсберга. Как я говорил вначале, в стандартной библиотеке Python есть множество функций, которые помогают писать код лучше, поэтому, помимо функций, которые мы здесь рассмотрели, вы можете обратить внимание на другие модули, такие как `operator` или `itertools` (мою статью об этом модуле вы можете прочитать [здесь](https://martinheinz.dev/blog/16)) или просто отправляйтесь в [Python Module Index](https://docs.python.org/3/py-modindex.html) и изучите все, на что обратите внимание, и я просто уверен, что вы найдете там что-то полезное.
---
> Материал подготовлен в рамках курса [«Python Developer. Professional»](https://otus.pw/UBM8/).
>
> Всех желающих приглашаем на онлайн-интенсив «Быстрая разработка JSON API приложений на Flask». На этом уроке мы:
> — Познакомимся со спецификацией JSON API;
> — Узнаем, что такое сериализация/десериализация данных;
> — Узнаем, что такое marshmallow и marshmallow-jsonapi;
> — Познакомимся со Swagger;
> — Посмотрим на обработку и выдачу связей.
>
> [**→ РЕГИСТРАЦИЯ**](https://otus.pw/6sqk/)
>
> | https://habr.com/ru/post/573164/ | null | ru | null |
# Интеграция PostgreSQL с MS SQL Server для тех, кто желает побыстрее и поглубже
Недавно на хабре уже было опубликовано [описание интеграции](https://habrahabr.ru/company/postgrespro/blog/309490/) PostgreSQL и MSSQL. Но, деталей там категорически не хватало. Посему, цели сей публикации следующие:
* расширить и углубить общедоступную информацию о FDW для MSSQL называемом [tds\_fdw](https://github.com/tds-fdw/tds_fdw): рассказать о разнице в мажорных версиях и описать базовые проблемы совместимости;
* рассказать о возможностях оптимизации запросов, использующих внешние таблицы;
* затронуть тему кэширования внешних данных в материализованных представлениях;
* сказать пару слов об экзотических подходах к интеграции PostgreSQL и MSSQL.
### Установка и настройка TDS FDW
Ребята из PostgresPro уже достаточно [сказали](https://habrahabr.ru/company/postgrespro/blog/309490/) об этом процессе, повторяться не буду. Оставлю лишь несколько ссылок на официальную документацию PostgreSQL и на примеры из tds\_fdw:
* создание расширения (extension) в PG: [офф.документация](https://www.postgresql.org/docs/current/static/sql-createextension.html);
* создание сервера: [офф.документация](https://www.postgresql.org/docs/9.5/static/sql-createserver.html), [пример из tds\_fdw](https://github.com/tds-fdw/tds_fdw/blob/master/ForeignServerCreation.md);
* создание отображения пользователей (user mapping): [офф.документация](https://www.postgresql.org/docs/9.5/static/sql-createusermapping.html), [пример из tds\_fdw](https://github.com/tds-fdw/tds_fdw/blob/master/UserMappingCreation.md);
* создание внешней таблицы (foreign table): [офф.документация](https://www.postgresql.org/docs/9.5/static/sql-createforeigntable.html), [пример из tds\_fdw](https://github.com/tds-fdw/tds_fdw/blob/master/ForeignTableCreation.md).
И ещё один момент: пожалуйста, не делайте как указано в [инструкции по установке tds\_fdw](https://github.com/tds-fdw/tds_fdw/blob/master/InstallUbuntu.md)
```
sudo make USE_PGXS=1 install
```
[Спасите котиков](https://habrahabr.ru/post/130868/), соберите deb-пакет и радуйтесь жизни:
```
sudo USE_PGXS=1 checkinstall
```
### Различия между мажорными версиями TDS FDW
На текущий момент существует две актуальные версии FDW'шки: стабильная 1.0.7 и 2.0.0-alpha, которая, по сути, является master-веткой и в которой происходит всё самое интересное. Вот небольшой список их различий:
* в 2.0.0 наконец-то появилась поддержка pushdown для условий в блоке WHERE, относящихся непосредственно к внешней таблице; однако он пока плохо работает при использовании опции *query* внутри объявления foreign\_table;
* появилась поддержка версии tds 7.4 (ниже опишу почему это нужно и важно);
* есть некоторые проблемы с работой DISTINCT по внешней таблице ([вот issue на GitHub'е](https://github.com/tds-fdw/tds_fdw/issues/99)), хотя доподлинно не известно: у меня ли руки не оттуда растут или баг довольно хитрый и проявляется только при определённом стечении обстоятельств.
### Подводные камни совместимости
До недавнего времени, tds\_fdw не работал с версией tds выше 7.3. Но в ходе написания сей статьи поддержку версии 7.4 пришлось [изыскать](https://github.com/tds-fdw/tds_fdw/issues/100). Поэтому теперь, начиная с коммита [3a803c](https://github.com/tds-fdw/tds_fdw/commit/3a803c5840b8cf69e1a725fb4377d0f95a53a4e9), tds\_fdw поддерживает все актуальные версии tds.
Почему же поддержка этой версии так важна? Лично для меня это важно из-за необходимости работать с MSSQL 2012. Если коротко: в Ruby on Rails для подключения к MSSQL используется библиотека [activerecord-sqlserver-adapter](http://activerecord-sqlserver-adapter), которая, в свою очередь, использует [tiny\_tds](https://github.com/rails-sqlserver/tiny_tds), который использует [FreeTDS](http://www.freetds.org/), который умеет общаться с MSSQL. Вся беда в том, что для RoR 3 и соответствующих мажорных версий библиотек, использование версии tds 7.1 прибито гвоздями и изменять её через конфиг можно только в 4+ версии. При этом версия 7.1 замечательно работает с MSSQL 2008, но при общении с MSSQL 2012 появляются следующие ошибки:
```
DB-Library error: DB #: 20017, DB Msg: Unexpected EOF from the server
```
```
ActiveRecord::LostConnection: TinyTds::Error: closed connection: ...
```
```
TinyTds::Error: Adaptive Server connection failed
```
И им подобные.
Их хотелось избежать перейдя на использование FDW, так как обновить RoR — это категорически дольше и дороже. Но tds\_fdw не поддерживал нужной версии и пришлось с этим что-то делать.
Что же касается ошибок, то все они появляются рандомно и произрастают из-за одного и того же места; вносят некоторое «разнообразие» в приложение, заставляя его отваливаться в случайных местах в случайное время. Лечится же всё это безобразие только использованием правильной версии tds. Для MSSQL 2012 это tds 7.4.
Здесь же первая засада: поддержка версии tds 7.4 реализована во FreeTDS начиная с версии 0.95. Но из коробки в Ubuntu 14.04 и 16.04 идут версии [0.91-5](http://packages.ubuntu.com/trusty/freetds-common) и [0.91-6.1build1](http://packages.ubuntu.com/xenial/freetds-common) соответственно. И получить более новую версию FreeTDS можно двумя способами:
1. собрать FreeTDS [из исходников](https://github.com/FreeTDS/freetds);
2. воспользоваться [альтернативным PPA](https://launchpad.net/~jamiewillis/+archive/ubuntu/freetds) с версией FreeTDS 1.00.
Во втором случае есть один нюанс: в указанном репозитории есть пакет только для Ubuntu 14.04 (которая trusty). Для 16.04 (которая xenial), там ничего нет. Но, в целом, ничего фатального и если в 16.04 поправить **/etc/apt/sources.list.d/jamiewillis-freetds-trusty.list** на что-нибудь вот такое:
```
deb http://ppa.launchpad.net/jamiewillis/freetds/ubuntu trusty main
```
То можно будет ставить пакет и в последней Ubuntu (и таки да, он работает без проблем).
Если же у вас CentOS, то под неё можно [легко найти](https://rpmfind.net/linux/rpm2html/search.php?query=freetds) FreeTDS до версии 0.95 включительно. Всё что старше придётся собирать из исходников.
#### Временное решение проблемы совместимости
Если ошибка под номером 20017 и её производные очень сильно докучают, а возможности заиспользовать необходимую версию tds нет, то можно обработать исключение, выбрасываемое PostgreSQL и перезапустить блок/метод/etc, обращающийся к MSSQL через FDW. В моём случае для RoR приложения это выглядело так:
```
def retry_mssql_operation(tries = 5)
begin
yield
rescue ActiveRecord::StatementInvalid => e
if e.message =~ /^PG::FdwUnableToCreateExecution/ && tries > 0
tries -= 1
retry
else
raise
end
end
end
```
На первое время спасает, но для долговременного решения категорически не подходит.
### Немного о pushdown и о том, как работает FDW «на пальцах»
Прежде чем перейти к вопросам оптимизации запросов к внешней БД хотелось бы сказать несколько слов о pushdown. Почему-то описание сего механизма не востребовано в русскоязычных ресурсах (либо я не знаком с его правильным переводом, а [трицепсовый жим вниз на блоке](http://www.multitran.ru/c/m.exe?l1=1&l2=2&s=pushdown) это явно не из той оперы). Поэтому хочется коротко рассказать о нём.
В простейшем случае, когда мы в PG выполняем запрос вида:
```
SELECT column_name FROM foreign_table WHERE column_id = 42;
```
Фактически в БД происходин следующее:
1. из ассоциированой с foreign\_table таблицы (или не таблицы), находящейся на стороннем сервере, извлекается всё содержимое в postgres;
2. затем, полученные данные фильтруются на основании условий из WHERE.
Не шибко эффективная схема, особенно если из таблицы с несколькими миллионами строк хочется получить всего лишь одну. И вот здесь появляется pushdown. Сей механизм позволяет уменьшить количество строк, которые мы получаем от удалённого сервера. Делается это посредством конструирования запроса к внешней БД с учётом того, что мы хотим на стороне PG, то есть с учётом того что указано в WHERE, JOIN, ORDER и др. Иначе говоря, FDW разбирает исходный запрос в PotsgreSQL, выбрать из него то, что может понять удалённое хранилище данных и собрать новый запрос, сообразно этим условиям. Отсюда вытекает очевидное следствие: pushdown применим не для всех FDW (например, для [file\_fdw](https://www.postgresql.org/docs/9.5/static/file-fdw.html) pushdown почти бесполезен, а вот для [postgres\_fdw](https://www.postgresql.org/docs/9.5/static/postgres-fdw.html) или *tds\_fdw* — совсем наоборот).
Итого: pushdown — это круто, он позволяет использовать механизмы внешнего хранилища данных, уменьшает объём данных, циркулирующих между PG и внешним хранилищем, тем самым ускоряя выполнение запросов, но, при этом, он является отдельным механизмом, поэтому его нужно реализовывать, поддерживать и это довольно нетривиальная задача.
### Ускорение запросов
С установкой, настройкой и матчастью разобрались. Теперь приступим к описанию того, как можно побыстрее извлечь данные из MSSQL.
#### Pushdown
Пригодится такой подход в случае простых запросов, не обременённых различными JOIN и прочими SQL-ухищрениями. В последней версии tds\_fdw (на текущий момент это 2.0.0-alpha) появилась поддержка простейшего pushdown для WHERE.
Для примера рассмотрим таблицу *simple\_table* из БД MSSQL. В этой таблице есть два поля: id и data. Определение внешней таблицы для неё будет следующим:
```
CREATE FOREIGN TABLE mssql_table (
id integer,
custom_data varchar OPTIONS (column_name 'data'))
SERVER mssql_svr
OPTIONS (schema_name 'dbo',
table_name 'simple_table',
row_estimate_method 'showplan_all',
match_column_names '1');
```
В данном случае, первый столбец имеет одинаковое название в PostgreSQL и в MSSQL: id. У второго столбца различные имена в PG и в MSSQL, поэтому здесь нужна опция *column\_name*. Сей параметр явно задаёт отображение столбцов из PostgreSQL на столбцы в MSSQL. Так же, в конце указан параметр *match\_column\_name*, который отвечает за неявный мапинг названий колонок по именам, то есть, благодаря ему, мапается столбец id.
Всё, теперь если выполнить запрос:
```
SELECT custom_data FROM mssql_table WHERE id = 42;
```
FDW должен обработать условие, указанное в WHERE и собрать правильный запрос в MSSQL. Например такой:
```
SELECT data FROM simple_table WHERE id = 42;
```
В случае tds\_fdw версии 1.0.7 и ниже запрос в MSSQL будет другим:
```
SELECT id, data FROM simple_table;
```
Ещё раз повторюсь: pushdown, на текущий момент, работает только для WHERE; для JOIN, ORDER и прочих функций типа MAX, LOWER и др. он не взлетит.
И ещё одно: как же узнать, какой фактически запрос выполнился на стороне MSSQL? При использовании FDW для, например, MySQL, в explain появляется вот такая строка:
```
Remote query: SELECT `id`, `customer_id`, `order_date` FROM `data`.`orders`
```
И это удобно. В tds\_fdw такого пока нет и нужно идти более длинным путём через логи FreeTDS. По умолчанию, во FreeTDS логи отключены, но это легко исправить покопавшись в **/etc/freetds/freetds.conf**. Там можно найти вот такие строки:
```
; dump file = /tmp/freetds.log
; debug flags = 0xffff
```
У которых нужно убрать точку с запятой в начале.
Теперь для любого запроса в MSSQL из PG, FreeTDS будет логировать всё что сможет. Это замедлит выполнение все внешних запросов и может наплодить кучу логов (в моём случае обычный SELECT сделал лог в ~300Мб, а JOIN еле ужодился в ~1.5Гб). Но зато в логих будет видно что фактически выполнилось в MSSQL. К тому же, объём логов можно уменьшить, поигравшись с `debug flags`. Подробнее о логировании во FreeTDS написать [здесь](http://www.freetds.org/userguide/logging.htm), а детали о `debug flags` лежат [вот тут](http://www.freetds.org/userguide/freetdsconf.htm#TAB.FREETDS.CONF.DEBUGFLAGS).
#### Materialized view
[Материализованное представление](https://www.postgresql.org/docs/current/static/sql-creatematerializedview.html) (далее MV) — это обычное представление + таблица с данными. Сей подход поможет в случае сложных запросов с джойнами внешних и внутренних таблиц, с функциями, преферансом и куртизанками.
Профит от MV следующий: оно являются «родным» объектом для PG, то есть MV замечательно взаимодействует с остальными частями PostgreSQL и оно может быть проиндексировано и проанализировано независимо от источника данных, который его наполнил. Минусы тоже есть: MV нужно обновлять. Обновлять можно по внутренним триггерам, по внешним событиям, можно полностью пересоздавать и тд. Но, в любом случае, MV порождает отставание PG от первоисточника данных.
Для вышеописанной внешней таблицы MV можно создать следующим образом:
```
CREATE MATERIALIZED VIEW materialized_mssql_table AS
SELECT id, custom_data
FROM mssql_table;
```
Теперь все данные из MSSQL есть в PostgreSQL, а значит их можно индексировать как вздумается ([B-tree](https://ru.wikipedia.org/wiki/B-%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE), [GIN и GiST](https://www.postgresql.org/docs/current/static/textsearch-indexes.html) и др.), для них становится доступна [статистика](https://www.postgresql.org/docs/current/static/monitoring-stats.html), можно увидеть детали о плане выполнения запроса и ещё много чего приятного из PG.
Обновить MV можно через стандартные INCERT/UPDATE/DELETE команды, либо просто пересоздать всё содержимое при помощи
```
REFRESH MATERIALIZED VIEW CONCURRENTLY materialized_mssql_table;
```
Опция CONCURRENTLY позволяет обновить MV не блокируя конкурирующие запросы на чтение, но требует больше времени и ресурсов. Так же, для возможности использования CONCURRENTLY целевое MV должно удовлетворять некоторым требованиям. Их можно найти на [соответствующей странице документации](https://www.postgresql.org/docs/9.5/static/sql-refreshmaterializedview.html).
#### Экзотический подход
Честно говоря, чёрт знает, может ли взлететь этот подход, быть может уважаемая публика расскажет что-нибудь интересное на этот счёт. В любом случае, считаю что нужно о нём сказать, так как на профильных ресурсах на большинство вопросов по интеграции двух БД отвечают «используйте FDW» и никакого разнообразия не предвидится, даже если вы желаете странного.
Итак, когда это может понадобиться: в случае, если все вышеописанные варианты не помогли в силу различных ограничений. Например:
* неприлично большой объём внешней БД и невозможность её клонирования в PG;
* строгие требования к быстродействию и наличие оптимального запроса во внешнюю БД;
* желание выполнять параметризованный запрос, то есть аналог опции query для FDW, только с динамическим параметром, например хочется использовать полнотекстовый поиск на стороне MSSQL через функцию [CONTAINS](https://msdn.microsoft.com/ru-ru/library/ms187787.aspx);
* ещё что-нибудь необычное.
Чем пользоваться: [dbi-link](http://pgfoundry.org/projects/dbi-link/) или [dblink-tds](http://dblink-tds.projects.pgfoundry.org/). Сие есть аналоги [dblink'а](https://www.postgresql.org/docs/9.5/static/dblink.html) но с поддержкой нескольких СУБД: PostgreSQL, MySQL, MSSQL Server и Oracle в случае dbi-link и просто TDS'а в случае dblink-tds.
Как видится механика работы: как некий узкоспециализированный аналог FDW в виде функции PG, которая собирает внутри себя нужный запрос исходя из переданных аргументов, выполняет его во внешней БД через вышеуказанные инструменты, получает данные, обрабатывает их и возвращает их в PG как [pipeline-функция](http://manojadinesh.blogspot.ru/2011/11/pipelined-in-oracle-as-well-in.html). То есть, гипотетически, можно выполнить именно тот запрос, который хочется и представить его результат в виде, удобоваримом для последующей обработки в PG.
Всё вышесказанное является чистыми теоретическими соображениями. Если у вас есть реальный опыт использования этих или подобных инструментов, пожалуйста, поделитесь своими знаниями с миром.
### Заключение
На текущий момент есть единственное простое и рабочее решение для стыковки PostgreSQL и MSSQL. Это [tds\_fdw](https://github.com/tds-fdw/tds_fdw). У него есть много недоработок, но проект развивается, баги чинятся, фичи выкатываются и это здорово. Поэтому tds\_fdw может решить бо́льшую часть проблем, связанных с извлечением данных из MSSQL через PG. Тем же, кто хочется побыстрее, пооптимальнее и с куртизанками поможет PostgreSQL и его богатый арсенал инструментов по оптимизации. А те, кто желает очень странного и хочет делать всё внутри БД с минимумом внешних сервисов придётся туго. Инструментарий древний, документации нет, поддержки нет, ~~населена роботами~~ и кроме чтения исходников ничего не поможет. | https://habr.com/ru/post/312090/ | null | ru | null |
# Мой MikroTik – моя цифровая крепость (часть 2)
[](https://habr.com/ru/company/ruvds/blog/575966/)
Статья является продолжением [первой части](https://habr.com/ru/company/ruvds/blog/575808/), посвящённой организации практической безопасности сетей, построенных на оборудовании MikroTik. До этого уже даны общие рекомендации по настройке оборудования, а также подробно рассмотрены вопросы безопасности L1 и L2 уровней. В текущей части поговорим о настройке протокола **Dot1X** и работе **Firewall**. Лирическое отступление представлено в первой части статьи, поэтому не будем терять время и сразу приступим к техническому описанию. Продолжим говорить про организацию безопасности L2 и рассмотрим безопасность L3.
6. Защита L2 (продолжение)
--------------------------
Dot1X отличный протокол, который должен быть обязательно внедрён в корпоративной сети. Если он работает, то нелегитимное устройство при наличии фактического проводного подключения не получит доступ, пока не будет авторизовано в системе. Здесь в бой вступает открытое программное обеспечение [**Freeradius**](https://freeradius.org/), позволяющее организовать полноценный [RADIUS](https://ru.wikipedia.org/wiki/RADIUS) сервер. Поднимем его на устройстве, находящемся внутри периметра, канал связи лучше использовать шифрованный, повторим один из постулатов первой части статьи. Особых требований к ресурсам сервера не предъявляются, поэтому для тестов можно использовать самый [простой **VPS**](https://ruvds.com):
```
apt install freeradius freeradius-mysql freeradius-utils
systemctl start freeradius
```
Проверяем, что все запустилось:
```
systemctl status freeradius
netstat -aun
udp 0 0 0.0.0.0:1812 0.0.0.0:*
udp 0 0 0.0.0.0:1813 0.0.0.0:*
```
Настраиваем параметры RADIUS клиента, которым будет являться наше устройство MikroTik (соединение, разумеется, пускаем по шифрованному VPN туннелю, так как протокол RADIUS работает без шифрования):
```
vi /etc/freeradius/3.0/clients.conf
client MIKROTIK {
ipaddr = 192.168.1.1
secret = testtest
}
vi /etc/freeradius/3.0/dictionary
$INCLUDE /usr/share/freeradius/dictionary.mikrotik
Добавляем пользователей:
vi /etc/freeradius/3.0/users
sun Cleartext-Password := "test2"
Mikrotik-Group = "full"
```
Проверяем корректность работы RADIUS службы (в файле конфигурации */etc/freeradius/3.0/clients.conf* указан пароль по умолчанию для клиента «*testing123*», при подключении по localhost):
```
systemctl restart freeradius
radtest sun test2 localhost 0 testing123
radtest sun test2 192.168.1.9 0 testtest
radtest -t mschap test test localhost 0 testing123
```
Теперь настроим Dot1X клиент на оборудовании MikroTik:
```
/radius add address=192.168.1.9 secret=testtest service=wireless,dot1x timeout=1s
/interface dot1x server add comment=Test_Dot1X interface=LAN interim-update=30s
```
Настройки все прозрачны, поэтому на них не останавливаемся. Если всё сделано верно, то траблшутинг не понадобится. Просмотрим лог на наличие ошибок:
```
tail /var/log/freeradius/radius.log -F
```
Теперь рассмотрим настройку клиентской части на базе операционной системы Windows. Первым делом запустим необходимую службу Dot3svc:
Далее требуется настроить соответствующий сетевой интерфейс на работу с протоколом Dot1X, как показано на скрине:
Если всё сделано верно, то обмен пакетами начнётся только после того, как устройство пройдёт необходимую процедуру:
Просмотрим пакеты, передающиеся службой RADIUS:
```
tcpdump -i wlan1 'port 1812 or 1813'
IP 192.168.1.1.44019 >192.168.1.9.radius: RADIUS, Access-Request (1), id: 0xef length: 138
IP 192.168.1.9.radius > 192.168.1.1.44019: RADIUS, Access-Challenge (11), id: 0xef length: 80
IP 192.168.1.1.43602 > 192.168.1.9.radius: RADIUS, Access-Request (1), id: 0xf0 length: 153
IP 192.168.1.9.radius > 192.168.1.1.43602: RADIUS, Access-Challenge (11), id: 0xf0 length: 64
IP 192.168.1.1.54100 > 192.168.1.9.radius: RADIUS, Access-Request (1), id: 0xf1 length: 227
IP 192.168.1.1.54100 > 192.168.1.9.radius: RADIUS, Access-Request (1), id: 0xf1 length: 227
```
Если прошло корректно, то ваше устройство получит L2 доступ в локальную сеть:
Со стороны MikroTik это выглядит так:
Если нет, то будет примерно такая картина:
Кроме этого, как было сказано в первой части статьи, RADIUS сервер можно использовать для работы беспроводной сети по протоколу **WPA2-Enterprise**. В таком случае, при успешном подключении пользователей в логах можно увидеть сообщения:
Для удобного администрирования осталось обзавестись удобным интерфейсом. Для этого существует проект [**Daloradius**](http://daloradius.com), который представляет из себя красивое и удобное web приложение, позволяющее отслеживать работу Freeradius сервера и управлять его пользователями:
Для его установки выполним следующие действия:
```
apt install mariadb-server mariadb-client
mysql_secure_installation
```
Настроим базу данных:
```
mysql -u root -p
CREATE DATABASE radius;
GRANT ALL ON radius.* TO radius@localhost IDENTIFIED BY "verySTRONGpassword!!";
FLUSH PRIVILEGES;
```
Установим необходимые компоненты для работы web приложения и выполним необходимые настройки:
```
apt install apache2 php libapache2-mod-php wget unzip php-{gd,common,mail,mail-mime,mysql,pear,mbstring,xml,curl}
pear install DB
mysql -u root -p radius
```
После этого показанная красивая web морда будет доступна по адресу *IP\_your\_server/daloradius*, логин и пароль соответственно administrator и radius. Для безопасности нужно обязательно настроить HTTPS для вашего веб сервера. Ну вот и все, что касается безопасности L2, настало время переходить на новый уровень. Поехали…
7. Защита L3
------------
Первое, про что поговорим, это про **IP spoofing**. Если злоумышленник самостоятельно сконфигурирует IP адрес своего сетевого интерфейса, то, во-первых, может получить L3 доступ в сеть, во-вторых, вмешаться в её нормальное функционирование.
На рисунке приведено, как это выглядит, в том числе глазами MikroTik, когда DHCP сервер ему выдал адрес 192.168.1.2, а в ручном режиме был задан 192.168.1.55:
Для борьбы с этим необходимо выполнить настройки, знакомые из [первой части статьи](https://habr.com/ru/company/ruvds/blog/575808/):
```
/ip dhcp-server set dhcp_home add-arp=yes
/interface bridge set bridge arp=reply-only
```
Настало время перейти к [**firewall filter**](https://wiki.mikrotik.com/wiki/Manual:IP/Firewall/Filter). Покажем базовую настройку, на которую можно смело опираться в своих конфигурациях. Для разгрузки центрального процессора маршрутизатора первым делом добавляем правила:
```
/ip firewall filter
add action=accept chain=input comment="Accept established,related" connection-state=established,related
add action=drop chain=input comment="Drop invalid" connection-state=invalid
add action=accept chain=forward comment="Accept established,related" connection-state=established,related
add action=drop chain=forward comment="Drop invalid" connection-state=invalid
```
Таким образом, связанные и уже установленные соединения будут пролетать мимо firewall. Не валидные соединения отправляем в drop. Далее, как и в комментариях пользователя, упомянутого в первой части статьи, закрываем доступ из внешней сети к роутеру и LAN:
```
add action=drop chain=input comment="Drop all input from !bridge" in-interface=!bridge
add action=drop chain=forward comment="Drop all from WAN to !DSTNAT" connection-nat-state=!dstnat connection-state=new in-interface=WAN
```
Это база. Остальные правила можно прикручивать под себя. Так, например, можно заблокировать попытки [DOS](https://ru.wikipedia.org/wiki/DoS-%D0%B0%D1%82%D0%B0%D0%BA%D0%B0) маршрутизатора:
```
add action=add-src-to-address-list address-list=DDOS address-list-timeout=1h chain=input comment="List DDOS" connection-limit=100,32 connection-state=new in-interface=WAN
add action=drop chain=input comment="Drop DDOS list" src-address-list=DDOS
```
Существуют сервисы, которые ведут списки IP адресов, замеченных в различных незаконных действиях, такие как, [**spamhaus.org**](https://www.spamhaus.org/drop/drop.txt). Можно подгружать их в роутер и затем блокировать, но нам такой подход не очень нравится:
```
/system script add name="Spamhaus " source={
/tool fetch url="http://joshaven.com/spamhaus.rsc" mode=http;
:delay 30;
/ip firewall address-list remove [find where comment="SpamHaus"];
/import file-name=spamhaus.rsc;
}
```
Списки большие и могут здорово загрузить маршрутизатор, при этом в своей большей массе угрозу вашему конкретному устройству представлять не будут. Кроме этого, они содержат белые IP адреса, а ведь атака может разворачиваться из-под [NAT](https://ru.wikipedia.org/wiki/NAT) или даже внутренней сети. Поэтому не рекомендуем это в качестве эффективного способа защиты.
Поговорим теперь, каким способом можно силами firewall блокировать проходящий трафик по ключевым словам. Современный интернет работает по протоколу TLS, а значит это поле [TLS SNI hostname](https://ru.wikipedia.org/wiki/Server_Name_Indication), однако современные тенденции таковы, что в условиях международной борьбы за приватность частной жизни, этот способ будет становиться всё менее эффективным:
```
/ip firewall filter add action=drop chain=forward comment=TEST out-interface=WAN protocol=tcp tls-host=habr.com
```
Для тех сайтов, которые до сих пор работают по HTTP можно в прямом смысле анализировать проходящий трафик на содержание, ну так себе способ:
```
/ip firewall filter add action=drop chain=forward comment=TEST content=habr disabled=yes out-interface=WAN protocol=tcp
```
В RouterOS ещё есть такая специфичная штука, как [layer7-protocol](https://wiki.mikrotik.com/wiki/Manual:IP/Firewall/L7), которая позволяет искать в первых 10 пакетах ICMP, TCP или UDP соединения (или 2 Кбайт) (потока) нешифрованного трафика совпадения с регулярными выражениями:
```
/ip firewall filter add action=drop chain=forward comment=TEST disabled=yes layer7-protocol=habr out-interface=WAN protocol=tcp
/ip firewall layer7-protocol add name=habr regexp="*habr"
```
Ну очень специфическая штука, сильно грузит центральный процессор, но, говорят, может детектировать даже некоторые допотопные малвари: [Code Red](https://ru.wikipedia.org/wiki/Code_Red) и [Nimda](https://ru.wikipedia.org/wiki/Nimda) (атаки на Microsoft IIS веб-сервер). В идеале можно с помощью указанных настроек вычленять зловредный трафик и дропать его. Метод не очень, все [C2](https://encyclopedia.kaspersky.ru/glossary/command-and-control-server-c-c/#:~:text=C%26C%2D%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%20%E2%80%94%20%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%2C%20%D1%81,%D0%BE%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D1%8F%D1%82%D1%8C%20%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D1%83%D1%8E%20%D0%BD%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BA%D1%83%20%D0%B8%20%D1%82) сервера так не победить.
8. Заключение
-------------
На этом рассмотрение безопасности L2 и L3 закончим. Непосредственно возможности RouterOS подходят к концу, поэтому в третьей части статьи поговорим об интеграции с различными opensource решениями и покажем реализацию централизованного логирования.
P/S
[Часть 1. Настройка оборудования и вопросы безопасности L1 и L2 уровней](https://habr.com/ru/company/ruvds/blog/575808/)
[Часть 2. Настройка протокола Dot1X и работа Firewall](https://habr.com/ru/company/ruvds/blog/575966/)
[Часть 3. Варианты реализации централизованного логирования](https://habr.com/ru/company/ruvds/blog/576284/)
[Часть 4. Развертывание IDS и ее интеграция в инфраструктуру RouterOS](https://habr.com/ru/company/ruvds/blog/576352/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=olegtsss&utm_content=moj_mikrotik_%E2%80%93_moya_cifrovaya_krepost_(chast_2)) | https://habr.com/ru/post/575966/ | null | ru | null |
# Заголовок Last-Modified, Symfony и ускорение поисковой индексации
Многие разработчики при создании сайтов забывают про очень полезный заголовок Last-Modified, благодаря которому можно оптимизировать загрузку web-страниц и облегчить работу поисковым роботам. Далее я постараюсь восполнить этот досадный пробел.
#### Для чего нужен заголовок Last-Modified?
Функцией заголовка как можно догадаться из названия служит информирование клиента о дате последней модификации web-документа. Исходя из спецификации rfc 2616, клиент может «спросить» у веб сервера не изменилась ли страница с определенного числа, послав серверу заголовок «If-Modified-Since». Если страница не изменилась сервер возвращает только заголовок «304 Not Modified», в противном случае – сервер возвращает заголовок «200 OK» и тело страницы. Как видно, выгода на лицо как для сервера, так и для клиента: браузер не будет грузить страницу снова и снова, а веб сервер будет отдавать меньше данных.
#### Какие сайты индексируются лучше? Динамические или статичные?
Пару лет назад среди SEO-шников водились споры по поводу того, какие сайты индексируются лучше? Динамические, написанные например на php, или статичные, без использования языков программирования. Зная о заголовке Last-Modified, можно ответить на этот вопрос. Все дело в том, что веб сервер сам обрабатывает заголовок «If-Modified-Since» если файл статичный. В случае динамической генерации страницы вся ответственность за ответ ложится на язык программирования и разработчика. А так как разработчик за частую не интересуется этим вопросом, то заголовки не отдаются вовсе.
#### Как заголовок Last-Modified ускоряет поисковую индексацию?
Все просто, как написано [в помощи Яндекса](http://help.yandex.ru/webmaster/?id=995332), «робот не сможет получить информацию о том, обновилась ли страница сайта с момента последнего индексирования. А так как число страниц, получаемых роботом с сайта за один заход, ограничено, изменившиеся страницы будут переиндексироваться реже».
Представьте. Есть сайт с 10 тысячами страниц. Сайт написан на php. Не отдается корректно заголок Last-Modified. Поисковой робот не может получить информацию о том, обновилась ли страница сайта с момента последнего индексирования. Что он делает? Индексирует все страницы!!! А не только те, которые изменились.
Конечно! На многих сайтах используют [Sitemap](http://help.yandex.ru/webmaster/?id=1007070). Но Sitemap это рекомендация, помощь поисковому оптимизатору. Заменой заголовка Last-Modified он быть не может!
#### Настройка и обработка заголовока Last-Modified в php
Для того чтобы веб-сервер передавал php-backend'у заголовок If-Modified-Since необходимо ему от этом сообщить!
**Для связки nginx + php так,**
> `location ~ \.php$
>
> {
>
> …
>
> if\_modified\_since off;
>
>
>
> fastcgi\_pass fcgi;
>
> fastcgi\_index index.php;
>
> fastcgi\_param SCRIPT\_FILENAME /<путь > /web$fastcgi\_script\_name;
>
> …
>
> fastcgi\_pass\_header Last-Modified;
>
> include fastcgi\_params;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**Для связки apache + php, так**
> `# If-Modified-Since (if php is not installed as cgi then comment lines below)
>
> RewriteRule .\* - [E=HTTP\_IF\_MODIFIED\_SINCE:%{HTTP:If-Modified-Since}]
>
> RewriteRule .\* - [E=HTTP\_IF\_NONE\_MATCH:%{HTTP:If-None-Match}]
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если php работает как модуль, то ничего настраивать не надо!
**Простой php-код обработки запроса If-Modified-Since,**
> `$qtime = isset($\_SERVER['HTTP\_IF\_MODIFIED\_SINCE'])? $\_SERVER['HTTP\_IF\_MODIFIED\_SINCE']:'' ;
>
>
>
> $modified = substr(gmdate('r', $timestamp), 0, -5).'GMT';
>
>
>
> if ($hdr == $modified)
>
> {
>
> header ("HTTP/1.1 304 Not Modified ");
>
> header ("Last-Modified: $modified");
>
> exit();
>
> }
>
> header ("Last-Modified: $modified");
>
> //render
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Как обрабатывать запрос If-Modified-Since в symfony?
В symfony уже предусмотрен механизм обработки заголовка. Все что нужно разработчику, так это передать в объект sfWebResponse заголовок. В случае его указания фрейморк все сделает сам.
> `$datestamp = time();
>
> $response->setHttpHeader('Last-Modified', $response->getDate($datestamp));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так как на странице как правило располагается разный контент, то я написал метод, который выставляет самый поздний из переданных заголовков!
> `static public function setLastModified($datestamp)
>
> {
>
> $response = sfContext::getInstance()->getResponse();
>
> $request = sfContext::getInstance()->getRequest();
>
>
>
> if(is\_array($datestamp))
>
> {
>
> rsort($datestamp, SORT\_NUMERIC);
>
> $datestamp = $datestamp[0];
>
> }
>
>
>
> if(!$response->hasHttpHeader('Last-Modified'))
>
> {
>
> $response->setHttpHeader('Last-Modified', $response->getDate($datestamp));
>
> }
>
> else
>
> {
>
> $origLastModified = strtotime($response->getHttpHeader('Last-Modified'));
>
> if($origLastModified < $datestamp)
>
> $response->setHttpHeader('Last-Modified', $response->getDate($datestamp));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Его очень удобно использовать в случае, если на странице, например, располагается 3 последних видеролика, 3 последних статьи и там еще что-нибудь. Загружая каждую модель из базы данных, мы можем вызывать метод, и в итоге в ответе получив самую позднюю дату модификации.
Для интересующихся код обработки заголовка находится в классе sfCacheFilter.class.php.
В заключение хочу сказать, что использование заголовка Last-Modified не всегда оправдано. Например, если на сайте 5 тысяч страниц и на каждой находится один и тот же блок с часто меняющимся контентом, использовать заголовок будет бесполезно! В этом случае можно разве что отдавать разные заголовки для клиентов и поисковых роботов. Но как по мне обман роботов ни к чему хорошему не приводит. Ну или убрать этот блок ;).
Еще,
Проверить сайт на корректную обработку заголовка можно [тут](http://www.feedthebot.com/tools/if-modified/) или так,
> `php<br/
> $ch = curl\_init();
>
>
>
> $url = 'http://site.ru/1.php ';
>
>
>
> curl\_setopt($ch, CURLOPT\_URL, $url);
>
> curl\_setopt($ch, CURLOPT\_HEADER, true);
>
> curl\_setopt($ch, CURLOPT\_NOBODY, true);
>
> curl\_setopt($ch, CURLOPT\_HTTPHEADER, array(
>
> 'If-Modified-Since: Sun, 28 Nov 2010 15:45:53 GMT'
>
> ));
>
>
>
> ob\_start();
>
> curl\_exec ($ch);
>
> curl\_close ($ch);
>
> $data = ob\_get\_contents();
>
> ob\_end\_clean();
>
>
>
>
>
> echo nl2br($data);
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/109043/ | null | ru | null |
# ObjectScript API, интеграция с C++. Часть 2: выполнение скрипта на OS из C++
ObjectScript — новый объектно-ориентированный язык программирования с открытым исходным кодом. ObjectScript расширяет возможности таких языков, как JavaScript, Lua и PHP.
Часть 2: выполнение скрипта на OS из C++
----------------------------------------
Возьмем пример кода на OS из [Части 1: работа со стеком, вызов функций OS из C++](http://habrahabr.ru/post/152797/). Сделаем файл **main.os** со следующим содержимым:
```
print("10 * (3+2) = ", 10 * (3+2))
bar = {firsname="James", lastname="Bond"}
bar.profession = "actor"
print bar
print(concat(5, " big differences"))
```
Программа на C++, запускающая скрипт, будет выглядеть так:
```
#include "objectscript.h"
using namespace ObjectScript;
int main()
{
OS * os = OS::create();
os->require("main.os");
os->release();
return 0;
}
```
при выполнении программы в консоль выведется следующее:
```
10 * (3+2) = 50
{"firsname":"James","lastname":"Bond","profession":"actor"}
5 big differences
```
Вы можете скачать исходники ObjectScript и пример из данной статьи по [этой ссылке](https://github.com/unitpoint/objectscript/zipball/master), открыть **proj.win32\examples.sln**, проект **run\_os\_prog**.
Другие релевантные статьи об ObjectScript:
* [ObjectScript API, интеграция с C++. Часть 1: работа со стеком, вызов функций OS из C++](http://habrahabr.ru/post/152797/)
* [ObjectScript — новый язык программирования](http://habrahabr.ru/post/152289/) | https://habr.com/ru/post/152813/ | null | ru | null |
# Принципы SOLID в действии: от Slack до Twilio
Похоже, что в наши дни [RESTful API](https://www.twilio.com/docs/api/rest) существует абсолютно для всего. От платежей до бронирования столиков, от простых уведомлений до развёртывания виртуальных машин — почти всё доступно через простое HTTP-взаимодействие.
Если вы разрабатываете собственный сервис, то часто хотите обеспечить его работу одновременно на нескольких платформах. Проверенные временем принципы ООД (объектно-ориентированного дизайна) сделают ваш код более отказоустойчивым и упростят расширяемость.
В этой статье мы изучим один конкретный подход к проектированию, который называется SOLID (это акроним). Используем его на практике в написании сервиса с интеграцией [Slack](https://api.slack.com/), а затем расширим для использования с [Twilio](https://www.twilio.com/docs/api/rest).
Этот сервис высылает вам случайную карту Magic the Gathering. Если хотите проверить его в действии прямо сейчас, то отправьте слово *magic* на номер 1-929-236-9306 (только США и Канада — вы получите изображение по MMS, так что могут примениться тарифы вашего оператора). Также можете присоединиться к моей организации Slack, нажав [здесь](https://urldefense.proofpoint.com/v2/url?u=https-3A__join.slack.com_t_random-2Dmagic-2Dcard_shared-5Finvite_enQtMjY4NjE4NDE5MDQ1LTg1MGU5YjhmYTM3MzcyMWFiMGRiZGU2YTAzNGE0ODg4MWJjNjZkYjIwNzM4MmNmN2I5NTE5ODUyZWJmNmYzMTM&d=DwMFaQ&c=x_Y1Lz9GyeGp2OvBCa_eow&r=-dXmeaeOne04Df2gPNIXv20X463I7_WEN16Q2GO_4oE&m=5Dev1dCKYRUNbr2oyFzyBYgWCGCFV0MQzG_XHz8HnI0&s=psUebhSG0U_tAC88QJ3kPSaAr60Ot_5vFpgDDaKvW50&e=). После входа наберите: */magic*.
SOLID для «Магии»
=================
Если вы ещё не знакомы с [SOLID](https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)), это набор принципов объектно-ориентированного дизайна (ООД), которые популяризовал [дядя Боб Мартин](http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod). SOLID — это акроним для:
* S – SRP – Принцип единственной ответственности (Single Responsibility Principle)
* O – OCP – Принцип открытости/закрытости (Open Closed Principle)
* L – LSP – Принцип подстановки Барбары Лисков (Liskov Substitution Principle)
* I – ISP – Принцип разделения интерфейса (Interface Segregation Principle)
* D – DIP – Принцип инверсии зависимостей (Dependency Inversion Principle)
Если следовать этому набору принципов, вы сделаете код более отказоустойчивым и упростите расширяемость. Далее в статье мы подробнее поговорим о каждом из этих принципов.
Существует много хороших примеров SOLID на разнообразных языках. Вместо повторения известного примера `Shape`, `Circle`, `Rectangle`, `Area` я хотел бы показать преимущества SOLID в полнофункциональном приложении из реального мира.
Недавно я игрался со [Slack API](https://api.slack.com/). Там действительно очень просто создавать свои команды со слэшем. Также я большой фанат [Magic the Gathering](https://magic.wizards.com/en), так что мне пришла идея сделать слэш-команду Slack, которая выдаёт изображение случайной карты Magic the Gathering.
Я быстро осуществил задуманное с помощью [Spring Boot](https://projects.spring.io/spring-boot/). Как вы убедитесь далее, Spring Boot соблюдает пару принципов SOLID прямо из коробки.
У Twilio великолепный API для голосовых и текстовых сообщений. Я подумал, будет интересно посмотреть, насколько легко взять мой пример Slack и интегрировать его с Twilio. Идея в том, что вы отправляете текстовое сообщение с командой на известный телефонный номер — и получаете случайное изображение Magic the Gathering.
Далее следует разбор принципов SOLID (не по порядку) в действии в процессе этого упражнения по программированию.
Весь код можно найти [здесь](https://github.com/dogeared/magic-with-slack-and-twilio). Позже мы ещё посмотрим, как применить этот код на вашем собственном аккаунте Slack и/или Twilio, если хотите.
Первый проход: «Магия» со Slack
===============================
Просто сам факт использования Spring Boot для создания приложения Magic сразу обеспечивает два из пяти принципов SOLID без специальных усилий с вашей стороны. Однако вы по-прежнему отвечаете за правильную архитектуру приложения.
Поскольку в процессе написания кода мы будем изучать разные принципы, вы можете посмотреть пример кода в любой момент, проверив соответствующие теги в проекте GitHub (вы найдёте их в разделе “Releases”). Полный код этой главы выводится по тегу `[slack-first-pass](https://github.com/dogeared/magic-with-slack-and-twilio/tree/slack-first-pass)`.
Посмотрим на код `SlackController` (все исходники Java здесь: magic-app/src/main/java/com/afitnerd/magic), который представляет пример принципов `D` и `I` в SOLID:
```
@RestController
@RequestMapping("/api/v1")
public class SlackController {
@Autowired
MagicCardService magicCardService;
@Autowired
SlackResponseService slackResponseService;
@RequestMapping(
value = "/slack", method = RequestMethod.POST,
consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE, produces = MediaType.APPLICATION_JSON_VALUE
)
public @ResponseBody
Map slack(@RequestBody SlackSlashCommand slackSlashCommand) throws IOException {
return slackResponseService.getInChannelResponseWithImage(magicCardService.getRandomMagicCardImage());
}
}
```
### DIP: принцип инверсии зависимостей
Принцип [DIP](https://en.wikipedia.org/wiki/Dependency_inversion_principle) гласит:
> A. Модули верхних уровней не должны зависеть от модулей нижних уровней. Оба типа модулей должны зависеть от абстракций.
>
>
>
> Б. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.
Java и Spring Boot предельно упрощают реализацию этого принципа. В `SlackController` \*внедрён\* сервис `MagicCardService`. Это \*абстракция\*, поскольку является интерфейсом Java. И поскольку это интерфейс, здесь нет деталей.
Реализация `MagicCardService` не зависит конкретно от `SlackController`. Позже мы увидим, как обеспечить такое разделение между интерфейсом и его реализацией, разбив приложение на модули. Дополнительно рассмотрим другие современные способы, как внедрять зависимости в Spring Boot.
### ISP: принцип разделения интерфейса
Принцип [ISP](https://en.wikipedia.org/wiki/Interface_segregation_principle) гласит:
> Много отдельных клиентских интерфейсов лучше, чем один универсальный интерфейс.
В `SlackController` мы внедрили два отдельных интерфейса: `MagicCardService` и `SlackResponseService`. Один из них взаимодействует с сайтом Magic the Gathering. Другой взаимодействует со Slack. Создание единого интерфейса для выполнения этих двух отдельных функций нарушило бы принцип ISP.
Далее: «Магия» с Twilio
=======================
Для отслеживания кода из этой главы см. тег `[twilio-breaks-srp](https://github.com/dogeared/magic-with-slack-and-twilio/tree/twilio-breaks-srp)`.
Посмотрим на код TwilioController:
```
@RestController
@RequestMapping("/api/v1")
public class TwilioController {
private MagicCardService magicCardService;
static final String MAGIC_COMMAND = "magic";
static final String MAGIC_PROXY_PATH = "/magic_proxy";
ObjectMapper mapper = new ObjectMapper();
private static final Logger log = LoggerFactory.getLogger(TwilioController.class);
public TwilioController(MagicCardService magicCardService) {
this.magicCardService = magicCardService;
}
@RequestMapping(value = "/twilio", method = RequestMethod.POST, headers = "Accept=application/xml", produces=MediaType.APPLICATION_XML_VALUE)
public TwilioResponse twilio(@ModelAttribute TwilioRequest command, HttpServletRequest req) throws IOException {
log.debug(mapper.writeValueAsString(command));
TwilioResponse response = new TwilioResponse();
String body = (command.getBody() != null) ? command.getBody().trim().toLowerCase() : "";
if (!MAGIC_COMMAND.equals(body)) {
response
.getMessage()
.setBody("Send\n\n" + MAGIC_COMMAND + "\n\nto get a random Magic the Gathering card sent to you.");
return response;
}
StringBuffer requestUrl = req.getRequestURL();
String imageProxyUrl =
requestUrl.substring(0, requestUrl.lastIndexOf("/")) +
MAGIC_PROXY_PATH + "/" +
magicCardService.getRandomMagicCardImageId();
response.getMessage().setMedia(imageProxyUrl);
return response;
}
@RequestMapping(value = MAGIC_PROXY_PATH + "/{card_id}", produces = MediaType.IMAGE_JPEG_VALUE)
public byte[] magicProxy(@PathVariable("card_id") String cardId) throws IOException {
return magicCardService.getRandomMagicCardBytes(cardId);
}
}
```
Как упоминалось ранее, применим более современный подход к внедрению зависимости (лучшие практики). Как видите, мы сделали это с помощью Spring Boot Constructor Injection. Это просто красивый способ сказать, что в последней версии Spring Boot внедрение зависимости осуществляется следующим образом:
1. Установить одно или несколько скрытых полей в вашем классе, например:
```
private MagicCardService magicCardService;
```
2. Определить конструктор для установленных скрытых полей:
```
public TwilioController(MagicCardService magicCardService) {
this.magicCardService = magicCardService;
}
```
Spring Boot автоматически обработает внедрение объекта во время выполнения. Преимущество в том, что здесь есть возможность запускать проверку ошибок и валидацию на внедрённом объекте внутри конструктора.
Контроллер содержит две части: `/twilio` и `/magic_proxy/{card_id}`. Путь magic\_proxy требует небольшого пояснения, так что сначала разберём её, прежде чем говорить о нарушении принципа SRP.
### Забавы с TwiML
[TwiML](https://www.twilio.com/docs/api/twiml) — язык разметки Twilio Markup Language. Это основа всех ответов от Twilio, потому что TwiML представляет собой инструкции для Twilio. Одновременно это XML. Обычно такое не представляет проблемы. Однако URL'ы, которые возвращает сайт Magic the Gathering, представляет проблему для включения в документы TwiML.
URL, по которому извлекается картинка карты Magic the Gathering, выглядит примерно так:
```
http://gatherer.wizards.com/Handlers/Image.ashx?multiverseid=144276&type=card
```
Обратите внимание на амперсанд (&) в URL. Есть только два валидных способа внедрить амперсанд в документы XML:
1. Escape-символы
```
http://gatherer.wizards.com/Handlers/Image.ashx?multiverseid=144276&type=card
```
Здесь вместо амперсанда указан элемент `&`.
2. Фрагмент CDATA (символьные данные)
```
http://gatherer.wizards.com/Handlers/Image.ashx?multiverseid=144276&type=card
```
Любой из этих вариантов легко реализовать на Java с расширением [Jackson Dataformat XML](https://github.com/FasterXML/jackson-dataformat-xml) в процессоре Jackson JSON, встроенном в Spring Boot.
Проблема в том, что первый вариант приводит к ошибке при получении изображения с сайта Wizards of the Coast (мейнтейнеры игры Magic the Gathering), а второй вариант не поддерживается в Twilio (эй Twilio: может быть, реализовать поддержку CDATA в TwiML?)
Я обошёл это ограничение с помощью прокси для запросов. В данном случае генерируется такой код TwiML:
```
http:///api/v1/magic\_proxy/144276
```
При получении такого кода Twilio обращается к конечной точке `/magic_proxy`, а уже за сценой прокси получает картинку с сайта Magic the Gathering и выдаёт её.
Теперь продолжим изучение принципов SOLID.
### SRP: принцип единственной ответственности
Принцип SRP гласит:
> У класса должна быть только одна функция.
Вышеописанный контроллер работает как есть, но нарушает SRP, потому что отвечает и за возвращение ответа TwiML, и за прокси для картинок.
В данном примере это не слишком большая проблема, но несложно представить, как ситуация быстро выходит из-под контроля.
Если пройдёте по тегу `[twilio-fixes-srp](https://github.com/dogeared/magic-with-slack-and-twilio/tree/twilio-fixes-srp)`, то увидите новый контроллер под названием `MagicCardProxyController`:
```
@RestController
@RequestMapping("/api/v1")
public class MagicCardProxyController {
private MagicCardService magicCardService;
public MagicCardProxyController(MagicCardService magicCardService) {
this.magicCardService = magicCardService;
}
@RequestMapping(value = MAGIC_PROXY_PATH + "/{card_id}", produces = MediaType.IMAGE_JPEG_VALUE)
public byte[] magicProxy(@PathVariable("card_id") String cardId) throws IOException {
return magicCardService.getRandomMagicCardBytes(cardId);
}
}
```
Его единственная задача — возвращать байты изображения, полученного на прокси с сайта Magic the Gathering.
Теперь единственная функция `TwilioController` — выдавать код TwiML.
### Модули для реализации DIP
[Maven](https://maven.apache.org/) позволяет легко разбить проект на модули. У них могут быть разные области (scopes), но есть одинаковые: компиляция (по умолчанию), выполнение и тест.
Области берут на себя управление, когда модули задействуются в данной области. Область `runtime` проверяет, что классы конкретного модуля \*не\* доступны во время компиляции. Они доступны только во время выполнения. Это помогает реализовать принцип DIP.
Проще показать на примере. Посмотрите код по тегу `[modules-ftw](https://github.com/dogeared/magic-with-slack-and-twilio/tree/modules-ftw)`. Можно увидеть, что организация проекта радикально изменилась (как видно в IntelliJ):
Теперь здесь четыре модуля. Если посмотреть на модуль `magic-app`, то из `pom.xml` видно, как он полагается на другие модули:
```
...
com.afitnerd
magic-config
com.afitnerd
magic-api
compile
com.afitnerd
magic-impl
runtime
```
Заметьте, что `magic-impl` находится в области `runtime`, а `magic-api` — в области `compile`.
В `TwilioController` мы автоматически привязываемся к TwilioResponseService:
```
@RestController
@RequestMapping(API_PATH)
public class TwilioController {
private TwilioResponseService twilioResponseService;
…
}
```
А теперь посмотрите, что происходит, если попытаемся автоматически привязать реализованный класс таким образом:
```
@RestController
@RequestMapping(API_PATH)
public class TwilioController {
private TwilioResponseServiceImpl twilioResponseService;
…
}
```
IntelliJ не может найти класс TwilioResponseServiceImpl, потому что его \*нет\* в области `compile`.
По приколу можете попробовать удалить строку `runtime` из `pom.xml` — и увидите, что тогда IntelliJ радостно найдёт класс `TwilioResponseServiceImpl`.
Как мы убедились, модули maven в сочетании с областями (scopes) помогает реализовать принцип DIP.
Финишная прямая: рефакторинг Slack
==================================
Когда я написал это приложение в первый раз, то не думал о SOLID. Я просто хотел хакнуть приложение Slack, чтобы поиграться с функциональностью слэш-команд.
В первой версии все связанные со Slack сервисы и контроллеры просто выдавали `Map`. Это хороший трюк для приложений Spring Boot — выдавать любой ответ JSON, не беспокоясь о формальных моделях Java, представляющих структуру ответа.
По мере развития приложения возникло желание создать более формальные модели для читаемого и надёжного кода.
См. исходный код по тегу `[slack-violates-lsp](https://github.com/dogeared/magic-with-slack-and-twilio/tree/slack-violates-lsp)`.
Посмотрим на класс `SlackResponse` в модуле `magic-api`:
```
public abstract class SlackResponse {
private List attachments = new ArrayList<>();
@JsonInclude(JsonInclude.Include.NON\_EMPTY)
public List getAttachments() {
return attachments;
}
@JsonInclude(JsonInclude.Include.NON\_NULL)
public abstract String getText();
@JsonProperty("response\_type")
public abstract String getResponseType();
...
}
```
Здесь мы видим, что в классе `SlackResponse` есть массив `Attachments`, текстовая строка и строка `response_type`.
`SlackResponse` объявил тип `abstract`, а функции реализации методов `getText` и `getResponseType` ложатся на дочерние классы.
Теперь взглянем на один из дочерних классов `SlackInChannelImageResponse`:
```
public class SlackInChannelImageResponse extends SlackResponse {
public SlackInChannelImageResponse(String imageUrl) {
getAttachments().add(new Attachment(imageUrl));
}
@Override
public String getText() {
return null;
}
@Override
public String getResponseType() {
return "in_channel";
}
}
```
Метод `getText()` возвращает `null`. С таким ответом ответ будет содержать \*только\* изображение. Текст возвращается только в случае сообщения об ошибке. Тут \*явно\* пахнет LSP.
### LSP: принцип подстановки Барбары Лисков
Принцип LSP гласит:
> Объекты в программе должны иметь возможность замены на свои подтипы без изменения точности программы.
Когда вы имеете дело с иерархией наследования и дочерний класс \*всегда\* возвращает null, это явный признак нарушения принципа LSP. Потому что дочернему классу не нужен этот метод, но ему приходится реализовать его из-за интерфейса, описанного в родительском классе.
Посмотрите ветку `[master](https://github.com/dogeared/magic-with-slack-and-twilio/tree/master)` в проекте на GitHub. Там произведён рефакторинг иерархии `SlackResponse` для соответствия LSP.
```
public abstract class SlackResponse {
@JsonProperty("response_type")
public abstract String getResponseType();
}
```
Теперь единственное общее у всех дочерних классов, что они должны реализовать — это метод `getResponseType()`.
В классе `SlackInChannelImageResponse` есть всё необходимое для правильного ответа с картинкой:
```
public class SlackInChannelImageResponse extends SlackResponse {
private List attachments = new ArrayList<>();
public SlackInChannelImageResponse(String imageUrl) {
attachments.add(new Attachment(imageUrl));
}
public List getAttachments() {
return attachments;
}
@Override
public String getResponseType() {
return "in\_channel";
}
…
}
```
Больше не требуется никогда возвращать `null`.
Есть и другое небольшое улучшение: раньше у нас были некоторые аннотации JSON в классе `SlackResponse`: `@JsonInclude(JsonInclude.Include.NON_EMPTY)` и `@JsonInclude(JsonInclude.Include.NON_NULL)`.
Они были нужны для гарантии, что в JSON не попадёт пустой массив аттачментов или текстовое поле с нулевым значением. Хотя это мощные аннотации, из-за них объекты нашей модели становятся хрупкими, а другим разработчикам может быть не ясно, что происходит.
### OCP: принцип открытости/закрытости
Последний принцип, который мы рассмотрим в нашем путешествии по SOLID, это OCP.
Принцип OCP гласит:
> Программные сущности … должны быть открыты для расширения, но закрыты для модификации.
Идея в том, что при изменении техзадания ваш код более эффективно справится с любыми новыми требованиями, если вы расширяете классы, а не добавляете код в существующие классы. Это помогает сдержать «расползание кода».
В вышеприведённом примере нет дополнительной причины изменять класс `SlackResponse`. Если мы хотим добавить в приложение поддержку других типов ответов Slack, то легко опишем эту специфику в подклассах.
Здесь опять проявляет себя сила Spring Boot. Взгляните на класс `SlackResponseServiceImpl` в модуле `magic-impl`.
```
@Service
public class SlackResponseServiceImpl implements SlackResponseService {
MagicCardService magicCardService;
public SlackResponseServiceImpl(MagicCardService magicCardService) {
this.magicCardService = magicCardService;
}
@Override
public SlackResponse getInChannelResponseWithImage() throws IOException {
return new SlackInChannelImageResponse(magicCardService.getRandomMagicCardImageUrl());
}
@Override
public SlackResponse getErrorResponse() {
return new SlackErrorResponse();
}
}
```
Согласно условиям интерфейса, методы `getInChannelResponseWithImage` и `getErrorResponse` возвращают объект `SlackResponse`.
Внутри этих методов создаются различные дочерние объекты `SlackResponse`. Spring Boot и его встроенный jackson-маппер для JSON достаточно умны, чтобы выдать правильный JSON для конкретного объекта, который характеризуется внутри.
Если хотите обеспечить интеграцию для своей собственной организации в Slack или реализовать поддержку для аккаунта Twilio (или и то, и другое), то читайте дальше! В противном случае можно перейти к резюме в конце статьи.
Развёртывание приложения
========================
Если хотите на полную катушку использовать это приложение, то нужно правильно настроить Slack и Twilio после развёртывания приложения на Heroku.
Как вариант, можно установить или Slack, или Twilio. В любом случае, первым делом нужно развернуть приложение на Heroku. К счастью, это просто.
### Развёртывание на Heroku
Проще всего развернуть приложение на Heroku — нажать дружелюбную фиолетовую кнопку в [разделе README проекта GitHub](https://github.com/dogeared/magic-with-slack-and-twilio). Вам понадобится указать две детали: `BASE_URL` и `SLACK_TOKENS`.
`BASE_URL` — это полный путь и название вашего приложения Heroku. Например, у меня приложение установлено здесь: <https://random-magic-card.herokuapp.com>. Придерживайтесь такого же формата при выборе названия приложения: `https://.herokuapp.com`.
Здесь есть своеобразная проблемка курицы и яйца, потому что приложению Heroku нужна некоторая информация из Slack, а для интеграции Slack нужна некоторая информация о приложении Heroku. Поначалу можно оставить значение по умолчанию в поле `SLACK_TOKENS` — позже мы вернёмся и обновим это значение настоящим токеном Slack API.
Можете проверить правильность установки, перейдя по адресу `https://.herokuapp.com`. Вы должны увидеть в браузере случайную карту Magic the Gathering. Если появляется ошибка, посмотрите журнал ошибок в веб-интерфейсе приложения Heroku. Вот [пример веб-интерфейса в действии](https://random-magic-card.herokuapp.com).
### Настройка Slack
Перейдите по адресу <https://api.slack.com/apps> и нажмите кнопку `Create New App` для начала:
Введите название `App Name` и выберите рабочую среду `Workspace`, куда вы добавите приложение:
Далее нажмите на ссылку со слэш-командами `Slash Commands` слева, а там кнопку создания новой команды `Create New Command`:
Заполните значения для команды (например: `/magic`), `Request URL` (например: `https://.herokuapp.com/api/v1/slack`) и короткого описания. Затем нажмите `Save`.
Теперь ваша слэш-команда Slack полностью настроена:
Перейдите в раздел `Basic Information` в левой панели и разверните на экране раздел `Install app to your workspace section`. Нажмите кнопку `Install app to Workspace`.
Затем кнопку для авторизации:
Прокрутите экран `Basic Information`, куда вы вернулись, и сделайте запись о токене верификации.
Если вы установили Heroku CLI, то корректно установить свойство `SLACK_TOKENS` можно такой командой:
```
heroku config:set \
SLACK_TOKENS= \
--app
```
Как вариант, зайдите в [панель мониторинга Heroku](https://dashboard.heroku.com/), перейдите к своему приложению и измените значение `SLACK_TOKENS` в настройках.
Теперь слэш-команда должна сработать на канале Slack вашей организации, и в ответ вы получите карту Magic the Gathering:
### Настройка Twilio
Для настройки интеграции Twilio перейдите в [панель мониторинга Twilio в консоли](https://www.twilio.com/console).
Нажмите на троеточие и выберите `Programmable SMS`:
Выберите `Messaging Services`:
Создайте новый сервис обмена сообщениями, нажав на кнопку с красным плюсом (или нажмите “Create new Messaging Service” если ещё никаких сервисов нет):
Введите `Friendly Name`, выберите `Notifications, 2-Way` в графе `Use Case` и нажмите кнопку `Create`:
Проверьте наличие галочки в `Process Inbound Messages` и введите `Request URL` для своего приложения Heroku (например, `https://.herokuapp.com/api/v1/twilio`):
Нажмите кнопку `Save` для сохранения изменений.
Перейдите в раздел `Numbers` в левом меню и убедитесь, что для сервиса обмена сообщениями добавлен ваш номер Twilio:
Теперь вы можете протестировать службу Twilio, отправив на свой номер слово `magic` в виде текстового сообщения:
\*\*Примечание:\*\* Если отправить что-нибудь кроме слова `magic` (независимо от регистра), то выскочит сообщение об ошибке, показанное выше.
Резюме по SOLID
===============
Ещё раз публикуем таблицу SOLID, на этот раз с тегами проекта Github, которые соответствуют каждому принципу:
* S – SRP – Принцип единственной ответственности. Тег: `twilio-fixes-srp`. Разделяет контроллер `TwilioController` на две части, где у каждого контроллера только одна функция.
* O – OCP – Принцип открытости/закрытости. Тег: `master`. Класс `SlackResponse` цельный и не подлежит изменению. Его можно расширить без изменения кода существующего сервиса.
* L – LSP – Принцип подстановки Барбары Лисков. Тег: `master`. Никакой из дочерних классов `SlackResponse` не возвращает `null`, не содержит ненужных классов или аннотаций.
* I – ISP – Принцип разделения интерфейса. Тег: `slack-first-pass` посредством `master`. Службы `MagicCardService` и `SlackResponseService` выполняют разные функции и поэтому отделены друг от друга.
* D – DIP – Принцип инверсии зависимостей. Тег: `slack-first-pass` посредством `master`. Зависимые службы автоматически привязаны к контроллерам. Внедрение контроллера — это «лучшие практики» внедрения зависимости.
В разработке этого приложения есть некоторые сложности. Я уже говорил выше о проблеме с TwiML. Но со Slack возникают особые проблемы, которые я изложил в [этой](https://afitnerd.com/2017/05/24/what-if-spring-boot-handled-forms-like-json/) статье. TL;DR: Slack воспринимает для слэш-команд \*только\* POST-запросы `application/x-www-form-urlencoded`, а не более современные `application/json`. Из-за этого возникают сложности с обработкой входящих данных JSON со Spring Boot.
Основная идея в том, что принципы SOLID сделали код намного проще для работы и дальнейшего расширения.
На этом завершается наш обзор принципам SOLID. Надеюсь, он был полезнее, чем обычные простенькие примеры Java. | https://habr.com/ru/post/343966/ | null | ru | null |
# Установка дополнительных версий PHP в VestaCP с помощью Docker
Наверное, многие сталкивались с ситуацией, когда среди проектов, работающих на современном ПО, остается пара полузабытых, а держать отдельную машину под них не хочется. Вариантов решения — масса, но в службе поддержки хостинг-компании данная проблема не теряет своей актуальности. Мои коллеги разработали скрипт, помогающий добавить нужную версию PHP в VestaCP буквально за пару минут. Данный метод уже зарекомендовал себя с хорошей стороны, и он продолжает радовать сотрудников поддержки. Самое время его опубликовать и помочь всем, кто столкнулся с подобной проблемой.
Для того чтобы воспользоваться решением, достаточно скопировать одну строчку в терминал, но мы рассмотрим чуть подробнее, как всё это работает.
Установка
---------
Выполняется командой:
> git clone <https://github.com/kotpoliglot/vestaphpinstaller.git> && cd vestaphpinstaller && chmod +x dockerize.sh && bash dockerize.sh -s --5.6
>
>
Будет установлен (если не был установлен ранее) docker через [унифицированный инсталлятор](https://get.docker.com/) (проверялся на CentOS7 и Ubuntu).
Последний аргумент в команде — желаемая версия PHP. В настоящий момент доступны версии PHP: 5.2, 5.3, 5.4, 5.5, 5.6, 7.0, 7.1, 7.2 и 7.3. Скрипт создаст шаблон для Vesta и два сервисных файла: docker.httpd и docker.php.56.
Все сервисы выполняют установку/обновление образов, в связи с чем первый запуск (например, подключение шаблона в “Весте”) либо перезапуск при наличии обновлений может занять некоторое время.
PHP запускается от имени www-data. На хосте будет создан (если еще нет) соответствующий пользователь. Владелец директории сайта будет изменен на www-data, группа останется прежняя. Также будет создана директория /opt/docker/ для хранения конфигурационных файлов.
В итоге мы потратим ~700 Мб на установку самого докера и около ~300Мб на образы, но получим прирост производительности. Результаты измерения производительности средствами Bitrix в 1.5-2 раза выше для связки VestaCP + Docker, чем при использовании аналогичной версии PHP в качестве модуля Apache.
Установка на одноядерный процессор
----------------------------------
При установке докер-контейнера на сервер с одноядерным процессором (cpu=1) не будет автоматически запускаться контейнер PHP.
В таких случаях необходимо отредактировать файл /etc/systemd/system/docker.php.56.service (где 5.6 - установленная версия PHP):
`--cpus=2` изменить на `--cpus=1`
Далее перезапустить докер:
> systemctl stop docker
> systemctl start docker
>
>
После чего переключить на нужную версию PHP в панели VestaCP. В случае если нужная версия уже выбрана, то необходимо переключить на дефолтную, сохранить и снова переключить на нужную версию PHP.
Схема работы
------------
Схема работы выглядит следующим образом:
Nginx -> apache в контейнере -> php-fpm в контейнере.
Apache потребовалось запаковать в контейнер (~80mb) из-за различий версий между CentOS и Apache. Версия в Centos не позволяет корректно проксировать запросы на fpm.
Apache запускается на порту 9080, поэтому скрипт редактирует конфигурацию nginx. Переключение на стандартный шаблон Vesta (default) вернет прежний порт (8080).
PHP запускается на 9000+version, то есть 9056, 9070, 9072 и т.д.
HTTPD
-----
httpd запускается следующим образом:
> docker run --rm --network host
> -v /home:/home
> -v /var/log/httpd/domains:/var/log/apache2/domains
> -v /opt/docker/conf/web:/usr/local/apache2/conf/vhosts
> --name docker-httpd kotpoliglot/php:httpd
>
>
В /opt/docker/conf/web лежат хосты, httpd в контейнере с минимальным набором модулей из-за экономии ресурсов, хосты для контейнеров хранятся в /opt/docker/conf/web, в директории Vesta (/home/admin/conf/web/) создается пустой файл.
PHP
---
PHP запускается следующим образом:
> docker run --rm --network host --cpus=2
> -v /etc/passwd:/etc/passwd
> -v /etc/group:/etc/group
> -v /etc/hosts:/etc/hosts
> -v /var/lib/mysql/mysql.sock:/var/run/mysqld/mysqld.sock
> -v /opt/docker/conf/php/56/php.ini:/usr/local/etc/php/conf.d/docker.ini
> -v /home:/home --name php-56 kotpoliglot/php:56
>
>
passwd и group передаются в контейнер из-за различных требований к uname и uid в CentOS и Ubuntu.
/etc/hosts — внешние адреса доменов Vesta, они нужны в контейнере для корректной работы сокетов в Bitrix, например. Файл обновляется при каждом переключении шаблонов в Vesta.
/opt/docker/conf/php/56/php.ini — файл, с помощью которого можно повлиять на параметры PHP в контейнере.
Добавление модулей и пакетов
----------------------------
При необходимости можно добавить тот или иной модуль или пакет в контейнер. Образы собраны на основе [alpine](https://alpinelinux.org/) для экономии ресурсов. Пакеты ставятся через apk, например, создаем Dockerfile cо следующим содержимым:
> FROM kotpoliglot/php:56
> RUN apk add --no-cache libpng-dev
>
>
Затем сохраняем файл и выполняем:
> docker build -t kotpoliglot/php:56 .
>
>
### PHP
В случае, если требуется модуль для PHP, в контейнерах есть набор скриптов docker-php-ext-configure, docker-php-ext-install и docker-php-ext-enable ([описание](https://hub.docker.com/_/php/)).
Установка будет выглядеть следующим образом: создаем Dockerfile в произвольной директории со следующим содержимым:
> FROM kotpoliglot/php:56
> RUN docker-php-ext-install zip
>
>
Затем пересоздаем образ:
> docker build -t kotpoliglot/php:56 .
>
>
Будет создан новый образ с прежним именем и установленным модулем.
сервисном файле стоит удалить ExecStartPre=/usr/bin/docker pull kotpoliglot/php:56, чтобы запускался локальный образ, а не заново скачанный с DockerHub.
Сервисные файлы доступны по пути /etc/systemd/system/.
Если инструмент показался вам полезным — дайте знать, мы подготовим подобное решение, например, для панели ISPConfig. | https://habr.com/ru/post/569338/ | null | ru | null |
# Как с помощью трансферного обучения обнаружить вулканы на Гавайях
### Геопространственная сегментация изображений с использованием топографических данных и трансферного обучения
Data Science — это не только данные о клиентах. К старту нашего [флагманского курса](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_280122&utm_term=lead) рассмотрим пример геопространственной семантической сегментации, где с помощью данных цифровой модели рельефа отобразим шлаковые конусы на Гавайях.
---
Есть самые разные примеры семантической сегментации изображений с попиксельной идентификацией объектов — от [беспилотных авто](https://smartlabai.medium.com/deep-learning-based-semantic-segmentation-in-simulation-and-real-world-for-autonomous-vehicles-e7fe25cef816) до [обнаружения](https://towardsdatascience.com/deep-learning-for-ship-detection-and-segmentation-71d223aca649) судов на спутниковых изображениях. Но как насчёт примеров практического применения, в которых не используются эти наборы данных обычных изображений?
Разберёмся сначала, что такое «шлаковые конусы», и как с помощью [QGIS](https://qgis.org/en/site/index.html) быстро создать набор данных с размеченными данными. Затем проведём обработку данных и отбор/обучение модели, а после протестируем обученную модель на новых данных.
Что такое «шлаковые конусы»?
----------------------------
«Шлаковые конусы — это простейший тип вулкана. Они формируются частицами и сгустками застывшей лавы, выброшенными из одного жерла. <…> Большинство шлаковых конусов венчает чашеобразный *кра́тер*». [Геологическая служба США](https://pubs.usgs.gov/gip/volc/types.html).
Вместо тысячи слов:
Итак, нам нужны конусообразные объекты с крутыми склонами и круглым кратером посредине. Посмотрим, как они выглядят в наборе данных.
Загрузка и разметка данных
--------------------------
Для набора данных используем предоставленные USGS¹ данные ЦМР — топографические данные с крупнейшего Гавайского острова, где видна морфология шлаковых конусов. Нанесём на карту шлаковые конусы спящего вулкана [Мауна-Кеа](https://www.google.ru/maps/place/Mauna+Kea+Ice+Age+Natural+Area+Reserve/@19.8235951,-155.5825901,11.18z/data=!4m13!1m7!3m6!1s0x7bffdb064f79e005:0x4b7782d274cc8628!2sHawaii,+USA!3b1!8m2!3d19.8967662!4d-155.5827818!3m4!1s0x7953bdf95561b15d:0x582987cd20952faf!8m2!3d19.7915039!4d-155.4748835!5m1!1e4), чтобы построить модель отображения конусов соседнего вулкана [Хуалалаи](https://www.google.ru/maps/place/Hual%C4%81lai/@19.6811034,-155.9165149,12.38z/data=!4m13!1m7!3m6!1s0x7bffdb064f79e005:0x4b7782d274cc8628!2sHawaii,+USA!3b1!8m2!3d19.8967662!4d-155.5827818!3m4!1s0x79540a70234d7c0f:0xdf4d56417549044!8m2!3d19.6890817!4d-155.8646894!5m1!1e4).
Для разметки шлаковых конусов используем QGIS — отличное приложение для работы с геопространственными данными. Визуализируем шлаковые конусы, загружая данные в формате .geotiff и получая на выходе контурные горизонтали с интервалами 10 метров (подсказка: ищите небольшие плотно расположенные концентрические окружности):
Карта с горизонталями (интервал — 10 метров) шлаковых конусов на южном склоне Мауна-КеаЭто шлаковые конусы на основе уже определённых пространственных критериев. Нанесём их на карту, чтобы создать размеченные маски. Для простоты будем считать шлаковые конусы круглыми. Это значит, что метками будут круговые многоугольники. Создадим шейп-файл этих фигур и начнём загружать его метки и данные ЦМР geotiff:
```
#Loading a geotiff shapefile
def readimage():
print("reading image…")
with rasterio.open(path_image, "r") as ds:
arr = ds.read()
arr = np.transpose(arr, (1, 2, 0))
#Clip negative values to 0
arr = arr.clip(0)
print(arr.shape)
return arr
#Loading the shapefile mask
def readmask(link):
print("reading mask…")
geo = gpd.read_file(link)
with rasterio.open(path_image) as src:
raster = src.read()
geo = geo.to_crs(src.crs)
out_image, out_transform = rasterio.mask.mask(src, geo.geometry, filled=True)
masks = out_image[0,:,:]
#Set the mask labels to 1 and the rest to 0
masks[np.where(masks<=0)] = 0
masks[np.where(masks>0)] = 1
masks = masks.astype(np.int8)
masks = np.expand_dims(masks, axis=2)
return masks
```
Предварительная обработка данных
--------------------------------
В массиве ЦМР у нас весь остров. Уберём всё вокруг размеченной маски Мауна-Кеа, а этот массив из 2D переделаем в 3D с тремя каналами. Зачем? Для совместимости с моделью сегментации, которая использует предварительно обученный энкодер. Этому энкодеру обычно требуется трёхканальное входное изображение, например, цветное:
```
#Crop both the image and masks to the same Mauna Kea area
image = image[ymin:ymax, xmin:xmax,:]
masks = masks[ymin:ymax, xmin:xmax,:]
#Stack the image array and normalise
image = np.dstack((image, image, image))
image = (image — image.min())/(image.max() — image.min())
original_size = image.shape
```
Получится форма (4000, 6500, 3). Визуализируем изображение и маску:
Отображение высотных отметок (слева) и размеченных масок шлакового конуса (справа)Дублировав одно и то же изображение трижды, применим фильтры. Чтобы шлаковые конусы выделялись на фоне окружения, увеличим контраст. И добавим фильтр Собеля, чтобы чётче обозначались их круговые формы:
```
#Contrast enhancing
image_eq = exposure.equalize_adapthist(image, clip_limit=0.05)
#Sobel filter and normalising
image_sobel = filters.sobel(np.squeeze(image))
image_sobel = (image_sobel — image_sobel.min())/(image_sobel.max() — image_sobel.min())
#concatenate standard image, equalised and sobel together
images = np.dstack((image[:,:,0], image_sobel[:,:,0], image_sobel[:,:,0]))
```
Из этого большого массива мы использовали три канала. Разделим массив на мелкие массивы, которые отправим в модель. Вот результат разделения:
> Количество образцов, высота, ширина, количество каналов:
>
>
```
#Making image tiles
size = 224
step = int(size/2)
patch_arr = skimage.util.view_as_windows(image, (size, size, layer.shape[2]), step = step)
output = patch_arr.reshape((-1,) + (size, size, layer.shape[2]))
```
Процесс повторяется для входного изображения и масок, чтобы они дополняли друг друга. Итог — такие входные данные:
Тайлы изображений и маски из данных ЦМР по Мауна-КеаКакие интересные изображения! Итоговая форма массива будет такой: (1938, 224, 224, 3). Примеров для создания модели не так много, ещё и поэтому нужна предварительно обученная модель. Последний этап — разделение данных на обучающую и контрольную выборки:
```
x_train, x_val, y_train, y_val = train_test_split(images, masks, test_size=0.2, shuffle=True, random_state=123)
print(x_train.shape)
print(x_val.shape)
print(y_train.shape)
print(y_val.shape)
y_train = tf.cast(y_train, tf.float32)
y_val = tf.cast(y_val, tf.float32)
```
Построение и обучение модели
----------------------------
Воспользуемся, по-видимому, лучшим вариантом архитектуры сегментации — моделью UNET — с предварительно обученным энкодером из [Keras](https://keras.io/api/applications/). Наш энкодер — InceptionResNetV2, на наборе данных imagenet у него хорошая производительность, хотя подойдёт любая предварительно обученная модель:
```
input_shape = (size, size, 3)
inception = InceptionResNetV2(include_top = False, weights = "imagenet", input_tensor = input_shape)
inception.summary()
layer_names = [layer.name for layer in model.layers]
```
Нужно добавить соединения быстрого доступа между энкодером и декодером. Но сначала создадим декодер UNET, загрузив предварительно обученный энкодер с входными размерами и получив список имён слоёв для него.
Подходящий декодер будет создан после установки include\_top в False. С помощью декодера выходные данные энкодера возвращаются к исходным размерам входного изображения, а мы получаем соответствующую маску сегментации:
```
x = Conv2DTranspose(num_filters, (2,2), strides=2, padding="same")(inputs)
x = Conv2D(size, 2, padding="same", dilation_rate = 1, kernel_initializer = "he_normal")(x)
x = BatchNormalization()(x)
x = Dropout(0.2)(x)
x = Activation("LeakyReLU")(x)
```
Складывая эти блоки один на другой от большего к меньшему фильтру, получим декодер. Соединения быстрого доступа добавляются к слоям активации, где размер входного слоя — 224, 112, 56 и 28. В зависимости от используемой модели размер слоя может отличаться. Тогда потребуется заполнение:
```
skip_connection_2 = inception.get_layer(index = 3).output
skip_connection_2 = ZeroPadding2D(( (1, 0), (1, 0))
(skip_connection_2)
```
Посмотрите: четвёртый слой (индекс 3) надо заполнить до нужной формы. Благодаря соединениям быстрого доступа энкодер и декодер связываются конкатенацией выходных данных указанных уровней активации и транспонированных блоков декодера:
```
x = Concatenate()([x, skip_connection_2])
```
Создав декодер, завершаем модель конечным выходным слоем, используя сигмоидную функцию активации, ведь наша задача — бинарная сегментация, то есть определение, со шлаковым конусом мы имеем дело или нет:
```
outputs = Conv2D(1, (1,1), padding="same", activation="sigmoid")(last_layer)
```
При компиляции модели в функции потерь должна учитываться несбалансированность классов. Количество шлаковых конусов относительно фоновой области небольшое, поэтому воспользуемся Tversky Loss.
Есть много [разных](https://www.kaggle.com/bigironsphere/loss-function-library-keras-pytorch) функций потерь. Чтобы измерить процент перекрывающихся пикселей между входной маской и маской сегментации, возьмём коэффициент сходства Жаккара:
```
model.compile(tf.keras.optimizers.Adam(5e-5),
loss= tversky_loss, metrics=[jaccard_coefficient],)
reduce_lr = ReduceLROnPlateau(monitor="loss", factor=0.2, patience=15, verbose=1, mode="max", min_lr=1e-6)
early = tf.keras.callbacks.EarlyStopping(monitor="val_loss", patience=10)
history = model.fit(x_train, y_train, epochs=100, batch_size = 32, validation_data = (x_val,y_val), callbacks = [reduce_lr, early])
```
При низкой скорости обучения 1e-5 и ReduceLROnPlateau в течение 100 эпох моделью достигнуто чуть более 80% IoU валидации (пересечения по объединению). Не так уж плохо.
Улучшить показатель способна более совершенная стратегия разметки, без упрощений в виде круговых фигур в качестве меток, или другая модель энкодера. Можно поэкспериментировать и с замораживанием разных слоёв энкодера.
Тестирование модели на другом вулкане
-------------------------------------
Посмотрим, как хорошо модель сегментации распознаёт шлаковые конусы вулкана Хуалалаи:
Нормализованная ЦМР вулкана ХуалалаиПроходим те же этапы предварительной обработки входных данных, чтобы сделать их совместимыми с моделью. Снова убираем всё лишнее, применяем фильтры, разделяем массив на тайлы и получаем форму (420, 224, 224, 3).
Увеличивать размер образцов здесь не нужно, поэтому обойдёмся без получения плиток изображений. Вот какие здесь входные тайлы:
Тайлы изображений и маски из данных ЦМР по ХуалалаиПосле использования модели для формирования прогнозов:
```
y_pred = model.predict(tiled_Hualalai_image)
```
Посмотрите на сегментированные тайлы, прежде чем снова объединять тайлы изображений, чтобы сделать маску сегментации с размерами исходного изображения:
Прогнозируемая маска сегментации с входными тайлами изображенийПрогнозы в норме, но у модели проблемы с сегментированием небольших шлаковых конусов. Они могут быть связаны с размером шлаковых конусов в обучающей выборке Мауна-Кеа, которые обычно больше.
Посмотрим на изображение сегментации, наложенное на исходное входное изображение. Чтобы обнаружить шлаковые конусы было легче, наложим спрогнозированные маски сегментации на изображение с фильтром Собеля.
Шлаковые конусы изображены как маленькие точки или кольца:
Данные ЦМР с фильтром Собеля (слева) вместе с наложенными масками сегментации (справа)Изображение выглядит намного лучше:
* Расположение масок и шлаковых конусов вдоль вулкана в целом совпадает (северо-запад и юго-восток).
* Сегментированы шлаковые конусы различных размеров, а не только большие.
* Все шлаковые конусы по форме в целом соответствуют маскам сегментации.
Заключение
----------
Мы разобрали пример использования сегментации изображений с геопространственными наборами данных для идентификации шлаковых конусов на Гавайях. Преобразуя маски сегментации из входных данных ЦМР обратно в исходные координаты, можно сделать из них наборы данных для дальнейшего анализа (например, анализа распределения размеров шлаковых конусов или изменения их плотности). Спасибо за внимание!
Сноски*[1] Геологическая служба США, 2013, USGS 13 угловая секунда с20з156 1 x 1 градус: Геологическая служба США. Данные получены от Геологической службы США и из Национальной геопространственной программы. Данные Национальной карты бесплатны и взяты из открытых источников.*
Продолжить изучение Data Science или Python вы сможете на наших курсах:
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_280122&utm_term=conc)
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_280122&utm_term=conc)
Узнайте подробности [здесь](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_280122&utm_term=conc).
Другие профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_280122&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_280122&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_280122&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_280122&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_280122&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_280122&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_280122&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_280122&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_280122&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_280122&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_280122&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_280122&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_280122&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_280122&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_280122&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_280122&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_280122&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_280122&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_280122&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_280122&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_280122&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_280122&utm_term=cat) | https://habr.com/ru/post/648417/ | null | ru | null |
# Дональд Кнут — автор «Искусства программирования» и великий мастер ордена программистов Земли
Фото для коллажа взято с сайта The New York TimesУже совсем скоро – 10 января гранд-мастеру программирования исполнится 84 года, а он считает, что для окончания основного труда его жизни "Искусства программирования" ему необходимо еще 25 лет. Дай бог ему здоровья, сил и ясный ум, а со всем остальным он точно справится сам. Кстати, рост у него не как у мастера Йоды – 190 см, вот здесь хорошо видно по плечам, хотя он, конечно, сильно сутулится.
 https://www.fi.muni.cz/events/2019-10-09-donald-knuth-question-answer-session-boundless-interests-brno.html.enНа Хабре писали про Кнута предостаточно, потому ограничусь здесь моими любимыми цитатами и одной замечательной историей из его жизни, про которую здесь почему-то еще не упоминали.
Именно ее я поведал своим ученикам на самых первых уроках программирования лет 20 назад *(да, был такой период, когда я преподавал в техническом лицее в маленьком провинциальном городке у полярного круга).* Зачем же я ее рассказал? Чтобы объяснить, какие именно качества необходимы будущему программисту, хотя в нашей истории нет ни единого слова ни о программировании, ни о компьютерах.
"Дональд Кнут был младше вас, сидящих здесь в классе, ему едва ли исполнилось 14 лет, когда он услышал, как по ТВ объявили о конкурсе местной кондитерской компании: предлагалось из букв использованных в названии нового шоколадного батончика "Гигантские батончики Циглера" ("Ziegler's Giant Bar") составить наибольшее количество слов. Приз для победителя держали в тайне, но как обещали, он точно должен быть весьма ценным. Игры в слова, настолки типа скрэббла, до сих популярны в США и являются традиционным семейным досугом. Потому многие любители настольных игр, конечно же, тут же подписались на участие в конкурсе.
Поразмыслив Дональд тоже решил принять участие. Что он мог противопоставить компании (семье) из 5-6 друзей заядлых игроков- "монстров скрэббла", которые за считанные минуты могли составить десятки слов, а за один только вечер уж точно не менее нескольких сотен слов в сумме?
Если на короткой дистанции в 2-3 дня у него точно нет ни единого шанса, то на длинной – в две недели он вполне может победить, просто потому что примерно знал, как именно его соперники будут действовать. Каждый из игроков станет составлять список слов самостоятельно в течение определенного времени, затем они соберутся в одной большой комнате и начнут по очереди их зачитывать, при этом каждый игрок будет вычеркивать у себя уже прозвучавшие слова. В конце все полученные незачеркнутые слова будут занесены (переписаны) в основной список. На второй и третий день количество таких слов уменьшится в разы. При этом все больше времени станет уходить на сверку новых слов с предыдущим списком. Очевидно, что скорость роста основного списка будет неуклонно и быстро падать с каждым днем.
Так каким же образом Дональд мог обогнать целую команду таких игроков?
Только если выберет иной путь к достижению цели. И он делает это: зачем составлять слова из данного набора букв, когда можно проверять готовый список слов на наличие в нем этих самых букв?!
Если взять достаточно полный словарь английского языка, то база для поиска слов будет просто огромной, а, следовательно, итоговый результат должен быть заметно лучше чем у "монстров скрэббла". Тем более, что такой словарь у Дональда, а точнее у его отца – владельца типографии, был: *New Standard Unabridged Dictionary of the English Language*, *Funk & Wagnalls.* Замечательный двухтомник — всего навсего на две тысячи страниц.
Что же такое словарь? Это, по сути, список всех слов в алфавитном порядке. Значит, отпадает одна из главных проблем – проверка найденных слов на уникальность, поскольку в словаре изначально нет повторов. Скорость поиска слов таким методом хоть изначально не слишком высока, но будет практически постоянной все две недели, не снижаясь к концу срока.
 Идея использовать словарь, конечно же, замечательная, но как ее осуществить? Каким образом перебрать более 50 тысяч слов на наличие в них определенного набора букв за столь короткий срок? Кнут в воспоминаниях не описывает своего алгоритма, но, уверен, мы сами сможем восстановить его, используя его упоминания про закладки и карточки.
Для начала Дональд аккуратно выписывает буквы из фразы "Ziegler's Giant Bar", удаляя повторы и размещая их в алфавитном порядке (11 букв). На втором листе он выписывает все буквы **невходящие** в эту фразу так же в алфавитном порядке (15 букв). Затем вносит закладки в словарь по начальным буквам, которых нет в ключевой фразе. На этом этапе таким образом он исключает для будущего анализа, не менее 30 тысяч слов. Потом приступает к делу, составляя карточки с сочетаниями первых и вторых букв, пропуская ровно так же слова, у которых вторые буквы не входят в ключевую фразу. Уже на этом этапе у него остается всего около 10 тысяч слов. Поскольку словарь, напоминаю, упорядочен по алфавиту, натыкаясь, например, на третью букву невходящую в список, он листает словарь, пока эта или предыдущие по порядку буквы в словах не сменятся.
Тем не менее, такой кропотливый труд требует много времени, и с началом второй недели до окончания конкурса, понимая, что он катастрофически не успевает закончить перебор всех слов, Дональд отпрашивается с уроков на неделю, сославшись на сильные боли в животе, и запирается дома в подвале на восемь часов в день и больше, анализируя и выписывая полученные слова.
Итог его работы за две недели – четыре с половиной тысячи слов!
Ни один из других участников не составил более двух тысяч слов, у самих судей на руках изначально – список всего из двух с половиной тысяч. Такого результата от долговязого 13-летнего школьника не ожидал никто. Его пригласили на телепередачу, где торжественно вручили главный приз – телевизор и большую коробку шоколадных батончиков. Телевизор достался школе, а батончики он раздал своим одноклассникам".
Так какие же качества будущего программиста продемонстрировал Дональд Кнут в данной истории?
Первое: умение выполнить постановку задачи. То, чему в школе, да зачастую и в университетах не учат в принципе. Вспомните формулировки задач в учебниках: вот вам необходимые и достаточные данные для решения, а теперь решайте задачу и получите ответ. В жизни так не бывает. Ты получаешь задание, а вот постановку задачи ты должен сделать сам, как, впрочем, определить и найти нужные данные для ее решения. В нашем случае задание: "Составить как можно больше слов из данного набора букв", он свел к очень конкретно поставленной задаче: "Найти все слова в словаре *Funk&Wagnalls*, полностью состоящих из данного набора букв".
Второе: вместо того, чтобы действовать и сразу же приступить к поиску этих слов в словаре, он сначала разработал алгоритм отсеивания слов, неподходящих к требованиям задачи. К сожалению, у многих программистов умение остановиться и подумать, прежде чем начать стучать по клавиатуре, напрочь отстутствует, они предпочитают, как я это называю, "думать руками" – кодят сразу: "Хрен ли здесь думать – прыгать надо!" И это, уж извините, очень плохо.
Третье: хотя постановка задачи и разработка алгоритма решения задачи весьма интересны и очень важны, но занимают они в самом лучшем случае лишь 5% от затраченного времени и сил в процессе решения той или иной задачи. Остальное – рутина: реализация алгоритма с учетом особенностей языка программирования, доводка программы до рабочего состояния, затем тестирование, бесконечное вылавливание блох (исправление багов) в программе. Без огромного упорства и концентрации на предмете в программировании абсолютно точно нечего делать. Именно эти свойства и продемонстрировал нам тринадцатилетней подросток, работая без выходных две недели в подвале своего дома, просто потому что решил довести дело, за которое взялся, до конца. Увы, если у вас "шило в заднице" — программирование не для вас, каким бы острым и быстрым умом вы не обладаете.
После знакомства с основными понятиями и операторами языка программирования, давал ученикам эту задачу, как одну из начальных после освоения азов, причем исходный словарь они должны были найти сами. При желании можете раскрыть спойлер и посмотреть.
Ziegler's Giant Bar20 лет назад я использовал Турбо-Паскаль для обучения программированию, но здесь приведу образцы программ на Python. В файле-словаре Wordbook.txt все слова записаны в одну колонку без пробелов в начале и в конце слов.
```
with open("c:\wordbook.txt", "r") as file1:
mn_zgbar=set("zieglersgiantbar")
i=0
# итерация по строкам словаря
for line in file1:
if line[len(line)-1]=='\n':
line=line[:len(line)-1]
#line = line.replace('\n','')
mn_line=set(line)
if mn_zgbar >= mn_line: # проверка вхождения букв слова в ключевую фразу
i+=1
print(i,' ', line)
```
Но использовать операции с множествами, конечно же, нечестно, ведь программа должна быть написана учениками, еще не знакомыми с ними.
Вот вам такой вариант:
```
with open("c:\wordbook.txt", "r") as file1:
zgbar="abegilnrstz"
i=0
# итерация по строкам словаря
for line in file1:
if line[len(line)-1]=='\n':
line=line[:len(line)-1]
k=0
flag=False
while k
```
Ну и на закуску мои любимые цитаты Дональда Кнута. Добавляйте в комментариях свои!
> *Остерегайтесь ошибок в приведенном выше коде; я только доказал его правильность, но не проверял его.*
>
> *Случайные числа не должны генерироваться случайным образом выбранным методом.*
>
> *Наука - это знание, которое мы так хорошо понимаем, что можем обучить ему компьютер; а если мы не понимаем до конца, как с этим справляться - это искусство.*
>
> *В этом смысле мы должны постоянно стремиться превратить каждое искусство в науку: в процессе этого мы продвигаем дальше искусство.*
>
> *Давайте изменим наше традиционное отношение к построению программ: вместо того, чтобы воображать, что наша основная задача - указывать компьютеру, что ему делать, давайте сосредоточимся на объяснении людям того, что мы хотим, чтобы компьютер делал.*
>
> *Я предполагаю, что Бог существует, и рад, что это невозможно доказать. [Потому что] я бы проверил доказательство один раз, а потом тут же его забыл бы, ведь иначе я никогда не смог бы рассуждать о духовных вещах и тайнах. И, думаю, моя жизнь была бы очень неполной.*
>
>
@LKamrad
---
Дата-центр ITSOFT — размещение и аренда серверов и стоек в двух дата-центрах в Москве. За последние годы UPTIME 100%. Размещение GPU-ферм и ASIC-майнеров, аренда GPU-серверов, лицензии связи, SSL-сертификаты, администрирование серверов и поддержка сайтов. | https://habr.com/ru/post/599261/ | null | ru | null |
# Как использовать прогрессивное улучшение для вёрстки писем
[](http://habrahabr.ru/company/pechkin/blog/257915/)
При верстке [email-рассылок](https://pechkin-mail.ru/?utm_source=habr&utm_medium=referral&utm_campaign=progressive) важно сделать разметку пригодной для парсинга и добиться того, чтобы «рюшечки» не мешали чтению контента. А главным контентом в письме почти всегда является текст.
Сегодня мы поговорим о том, как использовать технику прогрессивного улучшения при разработке HTML-шаблонов писем.
#### Поговорим о тексте
Вряд ли можно найти среду более подходящую для прогрессивного улучшения, чем email. То, как письма парсятся и отображаются (а тут ничего в ближайшие годы не изменится), прямо диктует необходимость сначала думать о контенте, не стремясь всеми силами сделать сам шаблон визуально очень красивым.
Обычно дизайнеры и верстальщики, занимающиеся подготовкой писем, из кожи вон лезут, чтобы сделать текст «примерно одинаково выглядящим» в разных почтовых клиентах. Пользователь, открывший письмо в Gmail, должен видеть то же, что и человек, пользующийся на работе Outlook.
Тот самый «примерно одинаковый» внешний вид — важнейшая вещь, но для тех сред, которые поддерживают визуальные «красивости», можно создать более интересно оформленные шаблоны.
#### Вёрстка со стилем
Принимая во внимание важность того, как выглядит текст, можно вспомнить множество оформительских приемов, которые позволяют привлечь внимание к конкретным участкам этого текста — например, цитаты.
Хорошо выглядит выделение текста горизонтальными линиями подчеркивания, и если их не вытягивать на всю длину текста цитаты, то он выглядит еще лучше:
Чтобы заверстать это без добавления лишних тегов `---`, можно использовать несколько интересных техник, редко применяемых в почтовых рассылках.
##### TL;DR — это иллюзия
Шаблон письма должен быть максимально простым, поэтому добавлять лишний HTML-код не нужно. Первоначально код текста с цитатой выглядел так:
```
>
> Hey Bonita, nice to meet ya
>
>
>
```
Если поэкспериментировать с отступами для цитаты (``), то вскоре выяснится, что некоторые почтовые клиенты отрицательные отступы для внутренних элементов просто игнорируют — в итоге ширина текста выравнивается по границам шаблона.
Далее можно использовать псевдоэлементы ::before и ::after — их применяют в CSS для того, чтобы вставить на страницу стилизованные элементы, не являющиеся HTML-кодом (подробнее эта техника описана в руководстве Smashing Magazine).
Для создания искусственной границы в верхней части цитаты далее был использован элемент ::before`, а для аналогичного оформления его нижней части — элемент `::after`. Для того, чтобы добиться правильного расположения и размера, был создан следующий CSS:
```
blockquote {
position: relative;
}
blockquote:before,
blockquote:after {
content: '';
display: block;
height: 2px;
left: 0;
position: absolute;
right: 0;
}
blockquote:before {
top: -2px;
}
blockquote:after {
bottom: -2px;
}
```
Теперь псевдоэлементы находятся в тексте, но проблема в том, что они до сих пор прозрачны. Нужно каким-то образом добиться того, чтобы ровно половина каждой из двух линий посередине была серой, а оставшаяся часть сохранила белый фоновый цвет.
Этого удалось добиться, сделав фоном каждого псевдоэлемента,CSS3-градиент. Но куда лучше выглядит не плавное перетекание цвета градиента, а четкая граница между белым и серым цветом.
Чтобы получить нужный результат, часть градиента была закрашена белым цветом — начало на 25% от всей линии псевдоэлемента и затем в конце начиная с 75% длины линии. В итоге получился жесткий переход от белого к серому цвету.
```
blockquote:before,
blockquote:after {
background: linear-gradient(to right, #ffffff 25%, #e9e9e9 25%, #e9e9e9 75%, #ffffff 75%);
}
```
Поскольку разные браузеры и почтовые клиенты поддерживают различный синтаксис градиентов, то были использованы различные формулировки.
Все продвигается просто отлично, но есть одна небольшая проблема — использованный ранее код будет работать в очень ограниченном количестве почтовых программ.
#### Обеспечение отказоустойчивости\*
*\* На Хабре было несколько хороших [статей](http://habrahabr.ru/post/157115/) по progressive enhancement и graceful degradation и второе понятие там переводилось, как \_отказоустойчивость\_ — будем придерживаться принятой терминологии.*
Хорошая новость заключается в том, что некоторые популярные почтовые клиенты вроде Apple Mail, iPhone Mail и «дефолтного» клиента Android. Несмотря на это, об использовании псевдоэлементов можно забыть в Gmail или Outlook.
И здесь на сцену выходит техника progressive degradation (или отказоустойчивость). Для всех менее оснащенных технически почтовых клиентов нужно добавить пару простых границ на CSS:
```
blockquote {
border-top: 2px solid #d9d9d9;
border-bottom: 2px solid #d9d9d9;
}
```
Эти границы покажут вообще практически все почтовые программы, а если успешно «отрендерятся» элементы `::before` и `::after`, то они закроют собой серые линии новыми бело-серыми полосами.
Вот как выглядят оба варианта отображения в динамике:
Так стоит ли писать дополнительный CSS-код, только чтобы добавить несколько «рюшечек», которые еще не факт, что увидят все получатели письма? Каждый случай, каждая рассылка уникальны, и нет однозначного ответа — для того, чтобы принять такое решение, как минимум, нужно ознакомиться со статистикой использования почтовых клиентов участниками (ранее мы публиковали подробный материал по статистике для создания успешной рассылки).
Вполне оправдан подход, при котором создаются шаблоны писем, которые выглядят максимально хорошо в каждой среде использования, а не просто идентично во всех возможных почтовых клиентах.` | https://habr.com/ru/post/257915/ | null | ru | null |
# Простенький таймер на Javascript
Привет всем рылся у себя в архиве полугодовалой давности и обнаружил один интересный скриптик который должен был выполнять функцию таймера обратного отсчета времени в маленькой системе тестирования, прошу покритиковать, но не сильно :) вот собственно код, надеюсь кому-нибудь будет полезен
````
// конструктор принимает 4 параметра
// 1 - количество секунд
// 2 - id элемента в котором будет отображаться обратьный отсчет
// 3 - функция которая будет вызвана по истечении времени
// 4 - функция которая предназначена для того чтобы
// отслеживать прогресс и в случае необнодимости
// контролировать поведение таймера
function Timer(seconds, element, callback, stopcallback) {
this.total = parseInt(seconds) || 3600;
if (typeof callback != 'function')
throw new Error('Third argument was expecting function callback');
this.callback = callback;
// в качестве параметра element нужно передать id элемента
this.element = document.getElementById(element) || null;
this.stopcallback = stopcallback;
}
Timer.prototype = {
hours : 0,
minutes : 0,
seconds : 0,
// эта переменная будет
// хранить наш таймер
t : null,
init : function () {
this.tick();
},
tick : function () {
self = this;
// запускаем таймер
this.t = setTimeout(self.tick(), 1000);
// преобразовываем секунды в формат ЧЧ/ММ/СС
this.convert();
this.total -= 1;
},
convert : function () {
this.hours = parseInt(this.total / 3600);
this.minutes = parseInt((this.total % 3600) / 60);
this.seconds = parseInt((this.total % 3600) % 60);
if (this.hours < 10)
this.hours = '0' + this.hours;
if (this.minutes < 10)
this.minutes = '0' + this.minutes;
if (this.seconds < 0)
this.seconds = 0;
if (this.seconds < 10)
this.seconds = '0' + this.seconds;
this.stopcallback.apply(this);
// отображаем наше время
if (this.element) {
this.element.innerHTML = '';
this.element.innerHTML = this.hours + ':' + this.minutes + ':' + this.seconds;
}
// если время истекло вызываем функцию обратного вызова
// которая будет выполнять нечто что вам надо
if (this.total <= 0 || this.total < 0) {
this.total = 0;
this.callback.call();
clearTimeout(this.t);
return;
}
},
stop : function() {
clearTimeout(this.t);
}
}
// пример
var countDown = new Timer(130, 'someElement', doSomeActions, stopTimer);
countDown.init();
````
With best,
sultan | https://habr.com/ru/post/72460/ | null | ru | null |
# CSS: о выводе коротких и длинных текстов
Когда, пользуясь возможностями CSS, создают макет страницы, важно учитывать то, что в различных элементах этой страницы могут выводиться короткие и длинные текстовые материалы. Страницы, кроме того, нужно тестировать на предмет того, как они отображают тексты разной длины. Если разработчик чётко понимает то, как обрабатывать различные тексты, выводимые на странице, если он соответствующим образом спроектировал макет, это способно избавить его от множества неприятных неожиданностей.
[](https://habr.com/ru/company/ruvds/blog/535016/)
Есть много ситуаций, в которых изменение некоего текстового фрагмента путём добавления или удаления всего одного слова способно заметно изменить внешний вид страницы, или, что ещё хуже «поломать» макет и сделать невозможной нормальной работу с сайтом. Когда я только начинал изучать CSS, я недооценивал последствия, к которым может привести добавление единственного слова в некий элемент или удаление из него всего одного слова. Здесь я хочу поделиться различными способами обработки текстов разной длины средствами CSS.
Обзор проблем
-------------
Прежде чем я расскажу о том, как работать с текстами средствами CSS, мне хотелось бы остановиться на проблемах, связанных с выводом текстов. Предположим, у нас есть вертикальное меню.
*Вертикальное меню при переносе имени пользователя на вторую строку выглядит необычно*
В начале меню выводится имя пользователя. Длина имени может варьироваться. Особенно — если речь идёт о мультиязычных сайтах. В правой части вышеприведённого примера видно, что имя пользователя, при достижении им определённой длины, занимает две строки. По этому поводу можно задаться несколькими вопросами:
* Нужно ли в такой ситуации обрезать текст?
* Нужно ли размещать текст в нескольких строках? Если да — то каково максимальное количество таких строк?
Это — пример того, что происходит, если в некоем элементе выводится такое количество слов, которое превышает количество, на которое рассчитывал разработчик. А что если некое слово просто оказывается очень длинным? Если используются настройки, применяемые по умолчанию, то такое слово просто выйдет за пределы своего контейнера.
*Слово вышло за пределы контейнера*
Фронтенд-разработчик должен быть готов к такому, заранее приняв решение о том, как страница должна вести себя в подобных ситуациях. К счастью, существуют CSS-свойства, созданные специально для того чтобы решать подобные проблемы.
Кроме того, проблемы на страницах могут вызывать не только слишком длинные, но и слишком короткие тексты. Вывод короткого текста в элементе, не рассчитанном на такой текст, может либо «сломать» интерфейс, либо, как минимум, сделать так, что этот элемент будет странно выглядеть. Вот пример.
*Кнопка, в которой выводится слишком короткий текст, выглядит необычно*
Проблема тут в том, что кнопка, в которой выводится текст `Ok`, оказывается очень короткой. Я не говорю о том, что это — страшная проблема, но выглядит подобная кнопка не очень хорошо. Её, к тому же, в определённых ситуациях, может быть сложно найти на странице.
Что делать? Возможно, стоит настроить свойство кнопки `min-width`. Благодаря этому она сможет нормально выводить подписи разной длины.
Как видите, проблемы могут возникать как при выводе длинных, так и при выводе коротких текстов. Но, прибегнув к некоторым возможностям CSS, мы можем, по меньшей мере, ослабить влияние этих проблем на внешний вид и работоспособность страниц.
Длинные тексты
--------------
Теперь, когда мы обсудили проблемы, поговорим о возможностях CSS, которые позволяют наладить нормальную работу с длинными текстами.
### ▍Свойство overflow-wrap
Свойство `overflow-wrap` позволяет сообщить браузеру о том, что он должен разорвать слово, перенеся его на новую строку, в том случае, если слово не помещается в контейнер.
```
.card {
overflow-wrap: break-word;
}
```
*Без использования свойства overflow-wrap слово выходит за пределы контейнера*
### ▍Свойство hyphens
Значение `auto` CSS-свойства `hyphens` позволяет сообщить браузеру о том, что он должен самостоятельно принять решение о разделении длинных слов с использованием дефиса и о переносе их на новые строки. Это свойство может принимать и значение `manual`, что позволяет, используя особые символы, предусмотреть возможность и порядок переноса слова на новую строку в том случае, если в этом возникнет необходимость.
```
.element {
hyphens: auto;
}
```
*Без использования свойства hyphens браузер не переносит слово на новую строку*
Применяя значение `auto` свойства `hyphens` важно помнить о том, что браузер будет переносить любое слово, которое не помещается в строку. Что это значит? Взгляните на следующий рисунок.
*Браузер может использовать знак переноса в любом слове*
Обратите внимание на то, что браузер использовал знак переноса в слове, которое вполне может быть целиком перенесено на новую строку. При использовании свойства `hyphens: auto` браузер способен разрывать даже такие слова, которые не выходят за пределы контейнеров.
### ▍Обрезка однострочного текста
При обрезке текста, для вывода которого предусмотрено поле, вмещающее лишь одну строку, предложение укорачивается, а в его конец добавляется многоточие, указывающее на то, что текст, на самом деле, длиннее того фрагмента, который выведен на экране.
*Слева — однострочный текст, при выводе которого обрезка не используется. Справа — текст, при выводе которого используется обрезка*
В CSS нет свойства, которое могло бы называться «text-truncation», применимого для настройки автоматической обрезки текстов. Тут нам понадобится комбинация из нескольких свойств:
```
.element {
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
```
### ▍Обрезка многострочного текста
Если нужно обрезать текст, для вывода которого предусмотрено поле, вмещающее несколько строк, нужно прибегнуть к CSS-свойству `line-clamp`:
```
.element {
display: -webkit-box;
-webkit-line-clamp: 3;
-webkit-box-orient: vertical;
overflow: hidden;
}
```
Для того чтобы это сработало, необходимо использовать и свойство `display: -webkit-box`. Свойство `-webkit-line-clamp` позволяет указать максимальное количество строк, по достижении которого текст надо обрезать.
*Сравнение обрезки однострочного и многострочного текста*
Минус этого подхода заключается в том, что, если у элемента будет настроено свойство `padding`, нормальный вывод текста может быть легко нарушен. Настройка этого свойства приведёт к тому, что часть текста, которая, как ожидается, должна быть скрыта, окажется выведенной после обрезанного текста.
*Настройка свойства padding приводит к нарушению вывода текста*
### ▍Вывод длинных текстов в полях, поддерживающих горизонтальную прокрутку
В некоторых ситуациях непрактично организовывать разрыв слов или их перенос на новые строки с использованием дефиса. Например, если имеется поле, в котором должен выводиться фрагмент JavaScript-кода, такой код будет тяжело читать в том случае, если слова будут выводиться с переносом на новые строки. В подобном случае облегчить работу с текстом можно, предусмотрев возможность горизонтальной прокрутки содержимого поля.
```
.code {
overflow-x: auto;
}
```
*Поле, в котором осуществляется перенос слов на новые строки, и поле, в котором применяется горизонтальная прокрутка*
### ▍Свойство padding
В некоторых случаях, когда у элемента не настроено свойство `padding`, вспоминают об этом лишь встречаясь с проблемами, появляющимися при выводе данных на страницах. Взгляните на следующий пример.
*Проблема при выводе подписи к флажку*
Тут имеется набор флажков. Подпись одного из них выводится слишком близко к другому. Причина этого заключается в том, что при проектировании макета, используемого для вывода флажков, не настроены промежутки между ячейками сетки, в которых размещены данные. Этот пример, кстати, взят с реального сайта (Techcrunch).
Короткие тексты
---------------
Я знаю о том, что проблемы, связанные с короткими текстами распространены не так сильно, как проблемы, связанные с длинными текстами. Но возможность их возникновения, всё равно, очень важно учитывать при проектировании пользовательских интерфейсов.
### ▍Установка минимальной ширины элемента
Вернёмся к примеру, который я приводил в начале статьи.
*Кнопка, в которой выводится слишком короткий текст*
Как справиться с проблемой, возникающей при выводе на кнопке очень короткой надписи? Решить эту проблему можно, воспользовавшись свойством `min-width`. При таком подходе ширина кнопки, даже при выводе в ней короткой надписи, не будет меньше заданного значения.
*Результаты настройки минимальной ширины кнопки*
Теперь, когда мы поговорили о проблемах вывода длинных и коротких текстов и о решениях этих проблем, давайте разберём несколько практических примеров.
Практические примеры
--------------------
### ▍Карточка профиля пользователя
Карточки профиля пользователя часто содержат достаточно длинные тексты. В частности, проектируя подобную карточку, разработчику почти невозможно заранее узнать о том, насколько длинным будет имя пользователя. Как же быть?
*Имя пользователя обычной длины, помещающееся на карточке целиком. Обрезанное длинное имя, выводимое в одной строке. Обрезанное длинное имя, выводимое в нескольких строках*
Проектируя подобную карточку можно подготовиться к выводу в ней длинного имени пользователя, применив один из следующих двух приёмов:
```
/* Решение 1 */
.card__title {
text-overflow: ellipsis;
white-space: nowrap;
overflow: hidden;
}
/* Решение 2 */
.card__title {
display: -webkit-box;
-webkit-line-clamp: 2;
-webkit-box-orient: vertical;
overflow: hidden;
}
```
Как видите, длинный текст можно обрезать, выведя его либо в одной строке, либо — в нескольких строках.
### ▍Навигационные элементы
При работе над макетами мультиязычных сайтов нужно учитывать тот факт, что тексты, имеющие один и тот же смысл, но написанные на разных языках, могут иметь различную длину.
*Названия навигационных элементов, выведенные на разных языках*
Длина слова `About` из LTR-языка больше, чем длина аналогичного по смыслу слова из RTL-языка. При выводе на таком языке соответствующий пункт навигационного меню выглядит слишком коротким. Известно, что если в дизайне страниц используются маленькие [области](https://ishadeed.com/article/clickable-area/), с которыми нужно взаимодействовать пользователям, это плохо сказывается на UX. Как исправить проблему? В данном случае можно просто настроить минимальную ширину навигационного элемента:
```
.nav__item {
min-width: 50px;
}
```
*Решение проблемы короткого текста*
Если вас интересуют вопросы вывода данных на разных языках — взгляните на [этот](https://rtlstyling.com/posts/rtl-styling#3.-differences-in-word-sizes-between-languages) мой материал.
### ▍Поле для вывода содержимого статей
В полях для вывода объёмных текстов вполне могут попадаться очень длинные слова, не помещающиеся в контейнеры. Особенно часто с этим можно столкнуться при работе с сайтами на мобильных устройствах.
*Длинное слово выходит за пределы контейнера*
Здесь имеется длинное слово, которое выходит за пределы контейнера и является причиной появления горизонтальной полосы прокрутки. Выше мы уже говорили о решениях подобных проблем, которые заключаются в использовании CSS-свойств `overflow-wrap` или `hyphens`.
Например, эту проблему можно решить так:
```
.article-content p {
overflow-wrap: break-word;
}
```
### ▍Оформление виртуальной корзины для покупок
Названия товаров, которые покупатели интернет-магазинов «кладут» в корзины, могут быть очень разными. Это может быть и одно слово, и несколько строк. В следующем примере длина названия товара такова, что текст перекрывается кнопкой для удаления товара из корзины. Причина этого в том, что при проектировании макета корзины не было уделено достаточного внимания настройке расстояния между элементами.
*Вывод коротких и длинных названий в макете, который настроен неправильно*
Решить эту проблему можно, настроив внутренние или внешние отступы элементов. Конкретные действия зависят от ситуации. Здесь я приведу простой пример, предусматривающий использование свойства `margin-right` при настройке элемента, выводящего название товара.
```
.product__name {
margin-right: 1rem;
}
```
### ▍Flexbox-макеты и вывод длинных текстов
При выводе длинных текстов во Flexbox-макетах возможна ситуация, когда такие тексты переполняют родительские элементы. Взгляните на следующий пример.
*Элементы выглядят нормально*
Вот разметка к этому примеру:
```
### Ahmad Shadeed
Follow
```
Вот стили:
```
.user {
display: flex;
align-items: flex-start;
}
.user__name {
text-overflow: ellipsis;
white-space: nowrap;
overflow: hidden;
}
```
Если имя пользователя не слишком длинно — всё выглядит нормально. Но что случится в том случае, если имя окажется достаточно длинным? В такой ситуации текст переполнит родительский элемент, а это «поломает» макет.
*Длинное имя пользователя портит внешний вид страницы*
Причина возникновения этой проблемы заключается в том, что размеры Flex-элементов не сокращаются до величин, которые меньше минимального размера их содержимого. Решить эту проблему можно, установив в значение `0` свойство `min-width` элемента `.user__meta`:
```
.user__meta {
/* другие стили */
min-width: 0;
}
```
После этого даже вывод в элементе длинного имени пользователя не испортит макет. Некоторые подробности об использовании свойства `min-width` при разработке Flexbox-макетов вы можете найти в [этом](https://ishadeed.com/article/min-max-css/#setting-min-width-to-zero-with-flexbox) материале.
Итоги
-----
Надеюсь, теперь вы сможете справиться с проектированием элементов, поддерживающих аккуратный вывод длинных и коротких текстов. Я с большим удовольствием писал эту статью. Я, благодаря этому, вспомнил некоторые тонкости работы с разными текстами. А статья будет служить мне хорошим напоминанием о том, как важно обращать внимание на подготовку элементов страниц к выводу текстов разной длины.
Сталкивались ли вы с проблемами, связанными с выводом текстов разной длины на веб-страницах?
[](https://ruvds.com/ru-rub/news/read/126?utm_source=habr&utm_medium=article&utm_campaign=vconst&utm_content=%20Visual_Studio_Code)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=vconst&utm_content=Visual_Studio_Code#order) | https://habr.com/ru/post/535016/ | null | ru | null |
# Заменяем стандартный элемент input file
Недавно, занимаясь кастомизацией (да простят меня руссоведы) я бы даже назвал это веб-моддингом (ещё раз извините, уважаемые руссоведы) стандартных элементов формы, а в частности элемента file, я наткнулся на большую неприятность: он оказался не профпригоден для настройки. Суть вот в чём: от элемента file нам особенно нужно его диалоговое окно "Upload files", добыть который программными средствами в браузерах Mozilla и Opera невозможно, т.е. команда document.getElementById('SaveForm').click(); ничего не вернёт. Разработчики уверяют что это небезопасно, что спорно. А вот IE меня порадовал, он беспрепятственно отправляет нажатие мыши в элемент file, скорее всего по недосмотру разработчиков, оставивших «опаснейшую дыру» в Вашей безопасности.
Как я только не изворачивался ничего не получалось. Прогуглив три часа, наткнулся на первое свиду идеальное [решение](http://www.quirksmode.org/dom/inputfile.html): поместить file в div, сделать div прозрачным (opacity: 0%), обращаю ваше внимание именно на то что сделать его нужно прозрачным, но не невидимым (visibility: hidden), условно говоря opacity: 0% прячет элемент от глаз, а visibility:hidden ещё и от мыши. Но если поиграть с размерами шрифтов, метод начинает терять свою привлекательность, появляется возможность промахнуться мимо невидимой кнопки.
Спустя час, я наткнулся на ещё один пример [yamzbrowser](http://sourceforge.net/projects/yamzbrowser/) (позволяет осуществлять загрузку файлов на сервер из swf-объекта вставленного в html-страницу). Он повторяет первый метод, но! с одной лишь разницей: он подставляет div под курсор мыши при перемещении. Кстати, обнаружить это мне удалось именно благодаря Опере (обычно я пользуюсь Лисой, и это большая случайность что я открыл пример именно Оперой), так как автор забыл установить прозрачность ещё и для неё.
Изучив оба метода, я соединил их в одно и разработал решение для более широкого применения в Сети. И так, присаживайтесь поудобнее мы начинаем.
### Допущения
1. Размер элемента подменяющего file могут значительно отличаться от размеров самого file'а
2. Элемент file явлеятся частью формы
3. Только параноик отключает JavaScript в браузере
4. Посетитель относится к тем скромным 99% пользователей использующих Firefox, Opera или IE
5. Решение должно работать по одинаковому алгоритму во всех браузерах, т.е. вариант использования разных средств для IE — document.getElementById('SaveForm').click();, а для FF и Opera — подстановка, неприемлем
6. Решение может дублироваться на странице
### Алгоритм
При наведении мыши на подменяющую кнопку слой с элементом подставляется под курсор, так что бы курсор был в середине слоя, т.о. мы будем точно знать что пользователь не промахнётся мимо кнопки и visibility меняется на visible: слой с элементом остаётся невидимым, но доступным для мыши. При перемещении курсора двигаем слой в пределах подменяющей кнопки, по достижению края кнопки visibility получает значение hidden.
### Рецепт
#### HTML
#### CSS
`div.file{
position: absolute;
top: -1000px;
left: -1000px;
-moz-opacity: 0;
filter: alpha(opacity=0);
opacity: 0%;
visibility: hidden;
}`
div.file — используется именно класс .file а не id, ввиду допущения номер 6.
top, left: -1000px — прячет слой до того как до него доберётся javascript, так на всякий случай.
-moz-opacity, filter: alpha, opacity — задаёт прозрачность для FF, IE и Opera соответственно.
visibility: hidden — скрывает от мыши.
#### JavaScript
Функция divFileShow(divId,e), где divId — id слоя с элементом file, e — event. Функции mouseX и mouseY высчитывают положение мыши относительно левого верхнего угла для всех браузеров. Делает слой видимым для мыши и подставляет под курсор таким образом чтобы курсор оказался посередине слоя, так мы точно не промахнёмся.
`**function** divFileShow**(**divId,e**){**
**var** div = document.getElementById**(**divId**)**;
div.style.left = **(**mouseX**(**e**)** - Math.round**(**div.offsetWidth/2**))** + "px"**;**
div.style.top = **(**mouseY**(**e**)** - Math.round**(**div.offsetHeight/2**))** + "px";
div.style.visibility = "visible";
**}**`
Функция divFileMove(divId, butId, e), где divId — id слоя, butId — id подменяющей кнопки (необходим для получения габаритов кнопки), e — event. Она заставляет слой двигаться за мышью, при досижении границы объекта butId.
`**function** divFileMove**(**divId, butId, e**){**
**var** div = document.getElementById**(**divId**)**;
**var** button = document.getElementById**(**butId**)**;
**var** move = **true**;
**var** divX = parseInt**(**div.style.left**)** + Math.round**(**div.offsetWidth/2**)**;
**var** divY = parseInt**(**div.style.top**)** + Math.round**(**div.offsetHeight/2**)**;
**if (**divX < button.offsetLeft || divX > **(**button.offsetLeft + button.offsetWidth**)) {**
move = **false**;
**}**
**if (**divY < button.offsetTop || divY > **(**button.offsetTop + button.offsetHeight**)){**
move = **false**;
}
**if (**move**){**
div.style.left = **(**mouseX**(**e**)** - div.offsetWidth/2**)** + "px";
div.style.top = **(**mouseY**(**e**)** - div.offsetHeight/2**)** + "px";
**} else {**
div.style.visibility = "hidden";
**}
}**`
Функция result(fileId, divResultId), где fileId — id элемента файл, divResultId — id слоя куда будет выведено имя выбранного файла. Функция передаёт в innerHTML слоя только имя файла(например, «all my passwords.txt»), а в атрибут title помещает полный путь, по-моему, это удобнее.
`**function** result**(**fileId, divResultId**){**
**var** divResult = document.getElementById**(**divResultId**)**;
**var** formFile = document.getElementById**(**fileId**)**;
divResult.innerHTML = formFile.value.replace**(**/^([^\\\/]\*(\\|\/))\*/,""**)**;
divResult.setAttribute**(**"title",formFile.value**)**;
**}**`
И на последок две функции (mouseX(e), mouseY(e), где е — event) определяющие местоположение курсора на странице для IE и остальных браузеров, они отличаются только двумя буквами поэтому приведу одну из них.
`**function** mouseX **(**e**){**
**if (**e.pageX**)** **return** e.pageX;
**if (**e.clientX**)** **return** e.clientX + document.body.scrollLeft;
**}**`
### Примечание
Так как слой с элементом file перекрывает кнопку, ей не передаётся событие :hover, поэтому если вам необходимо сымитировать наведение мыши Вам придётся добавить соответствующй функционал самостоятельно либо путём изменения класса кнопки, либо изменения изображения.
[Рабочий пример](http://www.box.net/shared/15yynriuum), если кто-то хочет посодействовать правому делу разместите пример у себя для онлайн презентации, ссылку и благодарности в эту статью гарантирую.
Тестировалось в браузерах Firefox 2, Opera 9, IE 6.
Спасибо за внимание.
**P.S.** О багах сообщайте заранее не отходя от кассы ;) | https://habr.com/ru/post/13704/ | null | ru | null |
# Гетерогенный поиск в ассоциативных контейнерах на C++
Ассоциативные контейнеры в C++ работают с конкретным типом ключа. Для поиска в них по ключу подобного типа (*std::string*, *std::string\_view*, *const char\**) мы можем нести существенные потери в производительности. В этой статье я расскажу как этого избежать с помощью относительно недавно добавленной возможности гетерогенного поиска.
Имея контейнер *std::map с* мы должны быть проинформированны о возможной высокой цене при поиске (и некоторых других операциях с ключом в виде параметра) по нему в стиле *c.find("hello world")*. Дело в том, что по умолчанию все эти операции требуют ключ требуемого типа, в нашем случае это *std::string*. В результате чего при вызове *find* нам нужно неявно сконструировать ключ типа *std::string* из *const char\**, что будет стоить нам в лучшем случае одного лишнего *memcpy* (если в нашей реализации стандартной библиотеки есть "small string optimization" и ключ короткий), а также лишнего *strlen* (если компилятор не догадается или не будет иметь возможности вычислить длину строки во время компиляции). В худшем же случае придётся заплатить по полной: выделением и освобождением памяти из кучи для временного ключа на ровном, казалось бы, месте, а это уже может быть сопоставимо с самим временем поиска.
Мы можем избежать ненужной работы с помощью гетерогенного поиска. Функции для его корректной работы добавлены в упорядоченные контейнеры (*set*, *multiset*, *map*, *multimap*) во всех подобных местах с С++14 стандарта и в неупорядоченные (*unordered\_set*, *unordered\_multiset*, *unordered\_map*, *unordered\_multimap*) с C++20.
```
// до C++14 мы имели только такие функции поиска
iterator find(const Key& key);
const_iterator find(const Key& key) const;
// начиная с C++14 мы имеем ещё и вот такие
template < class K > iterator find(const K& x);
template < class K > const_iterator find(const K& x) const;
```
Но, как и всегда, в C++ в этом месте есть подвох, имя ему дефолтный компаратор. Компаратор по умолчанию для нашего *std::map* это *std::less* функция сравнения которого объявлена как:
```
// где T это тип нашего ключа, т.е. std::string
bool operator()(const T& lhs, const T& rhs) const;
```
Он не может быть использован для нашего гетерогенного сравнения, так как имеет всё такие же проблемы (нужно конструировать конкретный тип ключа). На помощь приходит специализация *std::less* которая лишена этих проблем.
```
template <>
struct less {
using is\_transparent = void;
template < class T, class U >
bool operator()(T&& t, U&& u) const {
return std::forward(t) < std::forward(u);
}
};
```
> Примерно так выглядит эта специализация, я упустил моменты с `constexpr` и `noexcept` для простоты описания.
Пометка *is\_transparent* говорит контейнерам, что этот компаратор умеет гетерогенное сравнение и по ней же становятся доступны новые функции гетерогенного поиска.
Теперь можно объявить контейнер, который будет использовать всё это добро и ключи будут сравниваться напрямую используя *operator<(const std::string&, const char\*)* без неявных преобразований к одному типу:
```
std::map> c;
c.find("hello world");
```
Естественно, можно написать и свой компаратор для своих типов, например, когда отсутствует глобальный *operator<* для них. Иногда мы просто не можем создать такой временный ключ прозрачно и гетерогенный поиск единственная возможность искать что-то в контейнерах по ключу, например, при хранении *std::thread* в *std::set* и поиску по *std::thread::id*.
```
struct thread_compare {
using is_transparent = void;
bool operator()(const std::thread& a, const std::thread& b) const {
return a.get_id() < b.get_id();
}
bool operator()(const std::thread& a, std::thread::id b) const {
return a.get_id() < b;
}
bool operator()(std::thread::id a, const std::thread& b) const {
return a < b.get_id();
}
};
// объявляем контейнер с нашим гетерогенным компаратором
std::set threads;
// имеем возможность искать по id
threads.find(std::this\_thread::get\_id());
```
Ну и не стоит забывать, что это всё касается не только функции `find`. Так же это касается функций: `count`, `equal_range`, `lower_bound`, `upper_bound` и `contains`.
Счастливого гетерогенного поиска, уважаемый хаброчитатель! | https://habr.com/ru/post/523668/ | null | ru | null |
# Вышел GitLab 10.7: Web IDE в открытом доступе и отчеты SAST для Go и C/C++
Добавление новой функциональности, ревью изменений и развертывание кода — все это стандартные рабочие процессы, с которыми ежедневно сталкиваются разработчики. С выходом данного релиза мы упрощаем их выполнение с помощью нашего Web IDE, более гибких конвейеров, дополнительного тестирования безопасности и многого другого.
Web IDE теперь в общем доступе и с открытым исходным кодом
----------------------------------------------------------
Мы в GitLab хотим, чтобы каждый участник мог вносить свой вклад в рабочий процесс независимо от того, является ли он начинающим пользователем, который только знакомится с git и работает над своим первым коммитом, или опытным разработчиком, проводящим ревью целого набора изменений. Локальное выполнение таких задач, как настройка среды разработки или переключение между ветками, может усложнить процесс разработки. При помощи нашего Web IDE вы можете вносить изменения в файлы, делать коммиты, проводить ревью изменений и предпросмотр Markdown напрямую из браузера. Вы даже можете открыть дифф мерж-реквеста с наглядным отображением изменений side by side. Web IDE выходит в общий доступ с версии 10.7, также мы [открываем доступ к ее исходному коду](#otkryt-ishodnyy-kod-web-ide-core-starter-premium-ultimate-free-bronze-silver-gold).
### Токены развертывания
Для любой организации, работающей с [контейнерами](https://www.docker.com/what-container), их регистр является ключевым компонентом инфраструктуры: это версионный репозиторий, который предоставляет легкий и безопасный доступ к образам контейнеров. Обычное применение регистра — предоставлять образы (images) оркестровщику, например Kubernetes(<https://kubernetes.io/>). Важно, чтобы у этой системы всегда был доступ к регистру, поскольку тот же Kubernetes пуллит образы контейнеров при первичном развертывании, при каждом перезапуске пода и при добавлении дополнительных подов в процессе масштабирования.
Ранее существовало только два способа получения доступа к регистру и репозиторию. Одним из них является [токен работы CI](https://docs.gitlab.com/ee/user/project/new_ci_build_permissions_model.html#job-token), который предоставляет временный доступ на время выполнения работы, а другим — [токен личного доступа](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html), который предоставляет конкретному пользователю доступ на неограниченное время. При использовании токена работы CI Kubernetes теряет доступ по завершению работы, так что такой вариант не подходит для повторяющихся событий, таких как перезапуски подов и масштабирование. У использования токенов личного доступа тоже есть минусы: либо доступ должен быть привязан к конкретному пользователю, либо требуется создание дополнительного аккаунта, на что требуется лицензия.
Для решения этой проблемы мы создали [токены развертывания](#tokeny-razvertyvaniya-core-starter-premium-ultimate-free-bronze-silver-gold), предоставляющие продолжительное разрешение на чтение. При помощи токена развертывания Kubernetes может получать все необходимые образы по мере необходимости, без привязки к конкретному пользователю и без получения ненужных прав доступа.
### Управление потоком выполнения CI/CD на основе переменных
Сервис CI/CD является одним из основных движущих элементов процесса разработки ПО. Он выполняет множество задач: от базовых, вроде сборки, тестирования и развертывания, до более творческих. Учитывая диапазон выполняемых задач, пользователям важно иметь возможность запуска определенных работ только по определенному требованию. GitLab CI/CD уже предоставляет большой набор настроек для [управления потоком выполнения](https://docs.gitlab.com/ee/ci/yaml/#only-and-except-complex), однако существовали некоторые сценарии, такие как ночные сборки, настроить которые было не так просто.
В GitLab 10.7 мы добавили возможность запускать работы на основе [значений определенных переменных](#podderzhka-peremennyh-dlya-klyuchevyh-slov-only-i-except-core-starter-premium-ultimate-free-bronze-silver-gold). Это позволит выполнять новые сценарии, такие как запуск работ, [относящихся к определенному расписанию](https://docs.gitlab.com/ee/user/project/pipelines/schedules.html) или [триггеру API](https://docs.gitlab.com/ee/ci/triggers/#making-use-of-trigger-variables).
SAST для языков Go и C/C++
--------------------------
Частью проекта [Complete DevOps](https://about.gitlab.com/2017/10/09/gitlab-raises-20-million-to-complete-devops/) является предоставление первоклассных инструментов безопасности. Система [статического тестирования безопасности приложений (SAST)](https://docs.gitlab.com/ee/user/project/merge_requests/sast.html) проводит анализ вашего исходного кода на наличие уязвимостей и выводит результат напрямую в окно мерж-реквеста. Однако для того, чтобы провести этот анализ, SAST требуется поддержка языка программирования, на котором вы пишете. По этой причине мы [добавляем поддержку Go и C/C++](#sast-dlya-go-i-cc-ultimate-gold) для SAST.
[Приглашаем на наши встречи!](https://about.gitlab.com/events/)
([MVP](https://about.gitlab.com/mvp/)) этого месяца — [Rob Watson](https://gitlab.com/rfwatson)
-----------------------------------------------------------------------------------------------
Rob добавил чекбокс, позволяющий [перенаправлять соединения HTTP на HTTPS для GitLab Pages](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/16273), что повышает безопасность контента.
Спасибо, Rob! В знак благодарности мы отправили ему фирменные кофту, носки и тануки ручной работы с символикой GitLab.
Открыт исходный код Web IDE (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
------------------------------------------------------------------------------------------
Новый Web IDE упрощает и ускоряет добавление небольших фиксов и работу с фидбэком по мерж-реквестам, поскольку убирает необходимость локального хранения изменений и переключения веток.
При помощи Web IDE вы можете вносить изменения в файлы, проводить предпросмотр Markdown, делать ревью изменений и проводить коммиты напрямую из браузера. Web IDE доступен в окнах просмотра репозиториев и отдельных файлов, а также в окне мерж-реквеста — все это позволяет быстро реагировать на фидбэк или вносить небольшие изменения прямо в процессе ревью кода. При открытии мерж-реквеста в Web IDE вы также можете просмотреть его дифф перед коммитом, что позволяет увидеть общую картину изменений мерж-реквеста прямо в IDE.
Изначально Web IDE был [добавлен в GitLab Ultimate 10.4](https://about.gitlab.com/2018/01/22/gitlab-10-4-released/#web-ide-editor-beta), а с данного релиза он выходит в общий доступ. Мы приняли решение сделать его исходный код открытым, поскольку мы верим в то, что только совместная работа позволяет создавать такую сложную и субъективную функциональность, как IDE. К тому же, это позволит большему количеству пользователей участвовать в работе над своими любимыми проектами.
[Документация по Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/)
Токены развертывания (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
-----------------------------------------------------------------------------------
Бывают ситуации, в которых необходимо на продолжительное время предоставить доступ на чтение к репозиториям или образам Docker, загруженным в регистр контейнеров GitLab. Ранее для этого нужно было использовать токены личного доступа (Personal Access Tokens — PAT), однако такие токены привязаны к конкретному пользователю и его правам доступа.
Токены развертывания, добавленные в GitLab 10.7, решают эту проблему путем предоставления постоянного токена, привязанного к конкретному проекту. Пользователи могут включать доступ к репозиторию или регистру контейнеров, отбирать этот токен и устанавливать для него срок истечения.
[Документация по токенам развертывания](https://docs.gitlab.com/ee/user/project/deploy_tokens/)
Поддержка переменных для ключевых слов ‘only’ и ‘except’ (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
-----------------------------------------------------------------------------------------------------------------------
GitLab CI/CD позволяет устанавливать условия для запуска определенной работы при помощи ключевых слов ‘only’ и ‘except’. Например, вы можете разрешить запуск работы развертывания только в ветке ‘master’.
В GitLab 10.7 мы расширили синтаксические возможности таких условий, что позволяет использовать выражения с переменными, в которых выполнение работы зависит от наличия определенной переменной окружения или ее значения. Например, вы можете указывать, какие работы должны запускаться, при помощи изменения значений переменных проекта. Или же вы можете ограничить запуск определенной работы только теми случаями, когда значение переменной `GITLAB_USER_NAME` совпадает с именем определенного пользователя.
[Документация по поддержке переменных](https://docs.gitlab.com/ee/ci/variables/#variables-expressions)
SAST для Go и C/C++ (ULTIMATE, GOLD)
------------------------------------
Система статического тестирования безопасности приложений (SAST) работает только в том случае, когда в проекте используется язык программирования, поддерживаемый одним из инструментов GitLab. Поэтому в каждом релизе мы добавляем поддержку новых языков.
В GitLab 10.7 мы добавили поддержку Go и C/C++, так что теперь вы можете использовать автоматическую проверку уязвимостей для проектов, написанных на этих языках. Для подключения этой функциональности не требуется никаких дополнительных действий — язык определяется в рантайме автоматически.
[Документация по SAST](https://docs.gitlab.com/ee/user/project/merge_requests/sast.html#supported-languages-and-frameworks)
Другие улучшения GitLab 10.7
----------------------------
### Комментарии в эпиках (ULTIMATE, GOLD)
В данном релизе мы продолжаем работу по внедрению в эпики функциональности [управления портфолио](https://about.gitlab.com/direction/#portfolio-management-and-issue-management). Теперь вы можете добавлять комментарии к эпикам и даже создавать отдельные треды обсуждений эпиков, такие же, как для задач и мерж-реквестов. Благодаря этому стало возможным проводить обсуждения в самом эпике, на более высоком уровне абстракции, а не использовать для этого существующие задачи или, что еще хуже, создавать новые.
Эта функциональность также поддерживается [API](https://docs.gitlab.com/ee/api/discussions.html).
Эпики пока что не поддерживают todo и оповещения по почте, но мы [работаем над этим](https://gitlab.com/groups/gitlab-org/-/epics/148).
[Документация по эпикам](https://docs.gitlab.com/ee/user/group/epics/#comment-or-start-a-discussion)
### Массовое добавление текста во все почтовые сообщения (PREMIUM, ULTIMATE, SILVER, GOLD)
Нередки случаи, когда организациям по различным причинам (от юридических до технических) требуется добавить дисклеймер или какой-либо другой текст во все их почтовые коммуникации.
В данном релизе мы добавили такую возможность: теперь администраторы GitLab могут ввести произвольный текст в настройках почты. Этот текст будет добавлен в конец всех писем, отправленных GitLab.
[Документация по добавлению текста в почтовые сообщения](https://docs.gitlab.com/ee/user/admin_area/settings/email.html)
### Задачи подгрупп в групповых досках задач (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Групповые доски задач предоставляют единый интерфейс управления задачами сразу нескольких проектов одной группы. Такой подход полезен для команд, в которых работа происходит в различных репозиториях (а значит и в различных проектах GitLab).
В предыдущих версиях GitLab, на групповую доску добавлялись задачи только непосредственно дочерних проектов этой группы (только один уровень). Начиная с данного релиза, на групповую доску добавляются задачи всех проектов всех подгрупп этой группы. Так что если вы используете сложную многоуровневую иерархию подгрупп, эта иерархия будет поддерживаться и групповыми досками задач.
[Документация по доскам задач](https://docs.gitlab.com/ee/user/project/issue_board.html)
### Фильтрация и добавление меток для подгрупп (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Работа с подгруппами является важной фичей GitLab, и мы хотим применить похожий подход к использованию меток. Начиная с данного релиза мы расширили возможности добавления меток к задачам и мерж-реквестам на различных уровнях подгрупп.
В частности, стало возможным добавление групповых меток определенной группы любым ее дочерним задачам и мерж-реквестам. Это значит, метка, созданная на определенном уровне групп, будет доступна для всех подгрупп уровнем ниже.
Поскольку объекты, принадлежащие к подгруппам, отображаются в списках задач и мерж-реквестов, мы добавили фильтрацию этих списков по групповым меткам, принадлежащим как к дочерним, так и материнским группам (потому что все они теперь могут обладать такими метками). Другими словами, у вас есть возможность фильтрации по всем возможным меткам объекта, независимо от его расположения в иерархии.
Такой подход к фильтрации также доступен в групповых досках задач, как в окне фильтра, так и в настройках доски.
[Документация по меткам](https://docs.gitlab.com/ee/user/project/labels.html)
### Значки проектов (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Многие проекты, например, [GitLab CI/CD](https://docs.gitlab.com/ee/user/project/pipelines/settings.html#pipeline-badges) и [shields.io](https://shields.io) используют значки (badges) для отображения статуса сборки и качества кода. Как правило, значки добавляются в README проекта.
Теперь можно подключить отображение значков под описанием проекта, а также их отображение для всех проектов группы.
[Документация по значкам проектов](https://docs.gitlab.com/ee/user/project/badges.html)
### Разрешения на снятие защиты с веток (PREMIUM, ULTIMATE, SILVER, GOLD)
Функциональность защищенных (protected) веток ограничивает разрешения на пуш и мерж в определенные ветки, например, можно запретить пуш напрямую в `master`. Однако, пользователи с уровнем доступа Master могут снимать защиту с веток, что позволяет им обходить такие запреты. Новые ограничения на снятие защиты позволяют указывать, каким именно пользователям и группам можно снимать защиту с определенной ветки.
На данный момент такие ограничения можно устанавливать только через API; мы [добавим поддержку интерфейса в следующем релизе](https://gitlab.com/gitlab-org/gitlab-ee/issues/5496). Также есть вероятность, что в последующих версиях мы уберем уровень доступа Admin (`60`) и добавим ограничения для уровня Owner в качестве альтернативы.
[Документация о защищенных ветках](https://docs.gitlab.com/ee/api/protected_branches.html#protect-repository-branches)
### Вес задач на карточках досок задач (STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
Ранее, при работе с доской задач, для просмотра веса определенной задачи нужно было нажать на ее карточку — ее вес отображался в боковом окне. Теперь он отображается на самой карточке. Благодаря этому нововведению, вы можете одним взглядом оценить вес всех задач на доске и количество работы, необходимой для их выполнения. Это особенно полезно для методологий вроде [Agile](https://about.gitlab.com/2018/03/05/gitlab-for-agile-software-development/).
[Документация по доскам задач](https://docs.gitlab.com/ee/user/project/issue_board.html)
### Плагины GitLab (CORE, STARTER, PREMIUM, ULTIMATE)
Поскольку GitLab — проект с открытым исходным кодом, его может дополнять каждый. Но не все пользователи хотят сразу выносить свои изменения в общий доступ, они могут хотеть сначала лично попробовать, что получилось. До сих пор это можно было делать только за счет запуска отдельного форка GitLab, который довольно тяжело поддерживать в актуальном состоянии.
Плагины позволяют вам отвечать на [системные хуки GitLab](https://docs.gitlab.com/ee/system_hooks/system_hooks.html) с помощью скрипта, который хранится на сервере GitLab — вы сможете легко расширять GitLab под ваши нужды. Например, автоматически настраивать собственные правила защищенной ветки, когда создаете новый проект.
[Документация о плагинах](https://docs.gitlab.com/ee/administration/plugins.html)
### Протокол Git HTTP(s) всегда доступен для работ CI/CD (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
В GitLab для доступа к репозиториям вы можете использовать или SSH, или HTTP(s). Иногда администраторы GitLab предпочитают блокировать доступ по HTTP(s) из соображений безопасности. К примеру, блокировка HTTP(s) не позволит пользователям раскрыть их данные входа при работе через небезопасные настройки клиента. Однако, блокировка HTTP(s) также мешает GitLab Runner клонировать репозиторий, из-за чего CI/CD работает не так, как ожидается.
Начиная с GitLab 10.7 у clone/fetch реквестов от GitLab Runner будет доступ к протоколу HTTP(s), даже если такой доступ запрещен пользователям. С точки зрения безопасности это не одно и то же, поскольку GitLab Runner всегда использует токены OTP, которые не могут быть использованы для выполнения атак.
[Документация по видимости и контролю доступа](https://docs.gitlab.com/ee/user/admin_area/settings/visibility_and_access_controls.html)
### Поддержка JSON Web Token OmniAuth (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
GitLab использует OmniAuth для того, чтобы пользователи могли войти в GitLab с помощью популярных сервисов, например, Twitter или Google, а также с помощью стандартных средств идентификации типа OAuth2. В Gitlab 10.7 в OmniAuth добавлена поддержка JSON Web Token (JWT).
JSON Web Token — это компактный автономный способ защищенной передачи информации, часто использующийся для идентификации между разными сервисами.
[Документация по предоставлению JWT OmniAuth](https://docs.gitlab.com/ee/administration/auth/jwt.html)
### Автоматическая фоновая проверка копий Geo (PREMIUM, ULTIMATE)
Автоматическая фоновая проверка копий теперь происходит во время работы Geo, чтобы удостовериться, что копия консистентна с исходником. Это важно при использовании Geo для аварийного восстановления: теперь при сбоях вы можете уверенно переходить на резервную копию — она такая же, как и основной инстанс GitLab.
С помощью `heads` и `tags` GitLab вычисляет контрольную сумму для каждого репозитория Git и проверяет, что контрольная сумма исходного инстанса совпадает с аналогичной для резервной копии. Проверка будет расширена в следующих релизах и будет также включать [загрузки](https://gitlab.com/gitlab-org/gitlab-ee/issues/5591) и [`keep-around` ссылки](https://gitlab.com/gitlab-org/gitlab-ee/issues/5196).
[Документация о фоновой проверке Geo](https://docs.gitlab.com/ee/administration/geo/disaster_recovery/background_verification.html)
### Создание проектов в группах для Starter (STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
Наша модель прав доступа стала более гибкой: теперь администратор может включить в настройках опцию, которая позволит пользователям с уровнем доступа Developer создавать проекты.
Раньше эта функциональность была доступна только пользователям плана GitLab Premium.
[Документация о группах](https://docs.gitlab.com/ee/user/group/index.html#default-project-creation-level)
### Экспорт проектов включает объекты LFS (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Экспорт проектов позволяет вам с удобством перемещать проекты (вместе с задачами, мерж-реквестами, метками, вики-страницами и загрузками) между инстансами GitLab. Теперь в экспорт проектов входят и объекты LFS: вы сможете перемещать репозитории с LFS объектами с помощью обычного экспорта проектов.
[Документация об импорте и экспорте проектов](https://docs.gitlab.com/ee/user/project/settings/import_export.html)
### Сканирование зависимостей стало независимой функциональностью (ULTIMATE, GOLD)
До этого релиза проверки безопасности внешних зависимостей и библиотек, используемых вашим приложением, происходили вместе с SAST. Даже с учетом того, что это тесно связанные друг с другом вещи, мы решили, что их нужно разделить на две независимых функциональности.
GitLab 10.7 представляет сканирование зависимостей в качестве отдельной выделенной части в отчетах безопасности, которая предоставляет информацию об уязвимых библиотеках, которые стоит обновить. Результаты будут доступны как в мерж-реквестах, так и в обзоре конвейера.
[Документация о сканировании зависимостей](https://docs.gitlab.com/ee/user/project/merge_requests/#dependency-scanning)
### Специальные таймауты работ для runner (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
В данный момент GitLab определяет сроки выполнения работ CI/CD на уровне проекта. Если работа выполняется дольше, она автоматически остановится с отчетом об ошибке.
В GitLab 10.7 появилась новая настройка таймаута на runner, применяющаяся ко всем работам, которые он запускает. Это особенно полезно для общих runner в целях предотвращения потенциальных злоупотреблений, когда проект устанавливает длинные таймауты.
[Документация по специальным таймаутам работ для runner](https://docs.gitlab.com/ee/ci/runners/#setting-maximum-job-timeout-for-a-runner)
### Легче узнать причину падения работы CI/CD (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Когда работа CI/CD падает, пользователи обычно хотят узнать, что случилось и сделать коммит исправления, после которого работа выполнится так, как ожидалось. До этого релиза для этого нужно было идти в детали работы и смотреть логи.
Чтобы сделать отладку проще и быстрее, GitLab 10.7 представляет новую возможность: причина падения указывается как часть статуса, который можно посмотреть целиком по наведению курсора.
[Документация по причинам падения работ CI/CD](https://docs.gitlab.com/ee/ci/pipelines.html#seeing-the-failure-reason-for-jobs)
### Поддержка Ubuntu 18.04 Bionic (CORE, STARTER, PREMIUM, ULTIMATE)
26 апреля вышла новая версия Ubuntu — [Ubuntu 18.04 Bionic](https://wiki.ubuntu.com/BionicBeaver/ReleaseNotes). GitLab теперь доступен и для нее.
[Установка GitLab на Ubuntu 18.04 Bionic](https://about.gitlab.com/installation/#ubuntu)
### Улучшения восстановления бэкапов GitLab (CORE, STARTER, PREMIUM, ULTIMATE)
GitLab 10.7 поддерживает восстановление вложенных директорий пользователя. Например, если ваш регистр находился по адресу `/var/mypath/gitlab/registry`, восстановление сработает. Раньше процесс пытался переименовать существующую директорию в `.`, на что не было разрешения. Теперь он будет создавать временную папку `tmp` в восстанавливаемой директории и перемещать все существующие файлы туда до восстановления резервной копии.
[Документация о бэкапах и восстановлении](https://docs.gitlab.com/ee/raketasks/backup_restore.html#restore-for-omnibus-installations)
### Автоматический редирект на HTTPS в GitLab Pages (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
GitLab Pages может предоставлять статические вебсайты через протоколы HTTP или HTTPS. HTTPS обычно предпочтительнее, так как шифрует весь трафик, защищая содержимое, пока оно передается по сети.
В случае, когда доступны оба варианта, в GitLab 10.7 пользователи могут настроить проекты так, чтобы HTTP запросы автоматически перенаправлялись на соответствующие URL с протоколом HTTPS. Это повысит безопасность и гарантирует, что данные не будут передаваться простым текстом.
[Документация по автоматическому перенаправлению на HTTPS в GitLab Pages](https://gitlab.com/gitlab-org/gitlab-pages/#https-only-domains)
### Автоматическое обновление сертификата GitLab Let's Encrypt (CORE, STARTER, PREMIUM, ULTIMATE)
В GitLab 10.5 мы упростили подключение HTTPS для инстансов GitLab с помощью [интеграции с Let’s Encrypt](https://about.gitlab.com/2018/02/22/gitlab-10-5-released/#instant-ssl-with-lets-encrypt-for-gitlab).
С GitLab 10.7 мы делаем этот процесс *еще проще*. Мы автоматизировали процесс обновления и убрали необходимость держать Let's Encrypt постоянно включенным. Все, что вам нужно сделать, чтобы подключить HTTPS — начать ваш `external_url` с `https://` — и всё!
[Документация по автоматическому обновлению Let's Encrypt](https://docs.gitlab.com/omnibus/settings/ssl.html#automatic-renewal)
### Облачный чарт GitLab доступен для Core (альфа) (CORE, STARTER, PREMIUM, ULTIMATE)
С введением [поддержки хранилища объектов в плане Core](https://gitlab.com/gitlab-org/gitlab-ce/issues/40781), альфа-версия [облачного нативного чарта GitLab](https://gitlab.com/charts/gitlab) теперь доступна без лицензии. Этот чарт представляет более облачную собственную архитектуру с контейнером для каждого компонента GitLab и не требует общего хранилища. Эти изменения повлияют на повышение гибкости, масштабируемости и производительности GitLab на Kubernetes.
[Документация о бэкапе и восстановлении](https://docs.gitlab.com/ee/raketasks/backup_restore.html#restore-for-omnibus-installations)
### Улучшения в доске метрик окружения (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
На доске метрик окружения появилась сводная статистика. Она отображает средние и максимальные значения каждой серии за определенный промежуток времени. Например, теперь можно быстро узнать среднее время ответа за последние 8 часов, чтобы понять, с чем обычно сталкиваются пользователи.
Также теперь отображается общее потребление процессора и памяти пода, что обеспечивает понимание того, как используются ресурсы конкретного окружения в кластере.
[Документация об отслеживании метрик в окружении](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#monitoring-ci-cd-environments)
### GitLab Runner 10.7 (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
С этим релизом также вышла новая версия GitLab Runner — 10.7. GitLab Runner — это проект с открытым исходным кодом, который используется для запуска и отсылки результатов ваших работ CI/CD обратно в GitLab.
##### Самые важные изменения:
* [Добавлена возможность определять память в контейнерах Docker](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/847)
* [Улучшена проверка здоровья сервисов](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/867)
* [Вернули Go к версии 1.8.7](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/869)
* [Добавили в регистрацию поддержку параметра max\_job\_timeout](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/846)
Полный список изменений вы найдете в [CHANGELOG GitLab Runner](https://gitlab.com/gitlab-org/gitlab-runner/blob/v10.7.0/CHANGELOG.md).
[Документация по GitLab Runner](https://docs.gitlab.com/runner)
### Улучшения Omnibus (CORE, STARTER, PREMIUM, ULTIMATE)
* Версия GitLab [Mattermost 4.8.1](https://about.mattermost.com/releases/mattermost-4-8/) включает несколько улучшений платформы. В том числе эндпоинты iOS, которые позволяют пользователям загружать файлы больше 20 Мб, — и многое другое.
* Обновлен дефолтный список `ssl_ciphers` для NGINX, за исключением `ECDHE-RSA-DES-CBC3-SHA` и `DES-CBC3-SHA` для предотвращения [Sweet32](https://nvd.nist.gov/vuln/detail/CVE-2016-2183).
* redis\_exporter обновлен 0.17.1.
[Документация по Omnibus GitLab](https://docs.gitlab.com/omnibus/README.html)
### Улучшения производительности (CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Среди всех улучшений производительности GitLab 10.7 отдельно хотим отметить:
* [Мерж-реквесты теперь загружаются быстрее и с меньшей нагрузкой](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/18383)
* [Раздел изменений мерж-реквестов теперь частично использует Vue для упрощения интерфейса и повышения производительности](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&milestone_title=10.7&search=MR+Diffs+Refactor+Part)
* [Уменьшено использование Redis в диффах мерж-реквестов](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/17746)
* [Количество личных проектов пользователя теперь кэшируется](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/18197)
* [API больше не выполняет запрос, если проект недействителен](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/18322)
* [При просмотре Atom-фида групп создается меньше запросов](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/18157)
* [Идентификаторы, создаваемые для задач, мерж-реквестов, майлстоунов и эпиков, теперь атомарны](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/18402)
[Полный список изменений производительности в GitLab 10.7](https://gitlab.com/groups/gitlab-org/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&label_name%5B%5D=performance&milestone_title=10.7)
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 10.7 released with open source Web IDE and SAST for Go and C/C++](https://about.gitlab.com/2018/04/22/gitlab-10-7-released/).
Над переводом с английского работали [rishavant](https://habr.com/users/rishavant/) и [sgnl\_05](https://habr.com/users/sgnl_05/). | https://habr.com/ru/post/354998/ | null | ru | null |
# Собираем свою библиотеку для SSR на React. Роутинг
Привет! Меня зовут Сергей, я занимаюсь фронтендом в [KTS](https://kts.studio/).
В [прошлой статье](https://habr.com/ru/company/kts/blog/566176/) мы создали библиотеку, которая позволяет запускать сервер для рендеринга React-приложения, работает в dev-режиме, а конфиги инкапсулированы внутри самой библиотеки, что делает ее простой в использовании.
Следующим шагом нужно доработать самое важное и интересное — механизм роутинга и получения данных на сервере и прокидывания их на фронт. Как и в первой части, будем ориентироваться на практики, применяемые в популярных фреймворках, но с некоторыми изменениями.
Принципы, которых будем придерживаться при разработке:
1. Удобное использование библиотеки
2. Максимальная приближенность используемых инструментов к привычным, используемым в стандартных React-приложениях с рендерингом на клиенте
3. Минимальное количество «контрактов» в коде. Наша задача — сделать так, чтобы пользователи библиотеки могли с ходу понимать, что и как происходит, а не часами изучать документацию и требуемую архитектуру приложения
План статьи:
* [Контекст приложения](#1)
* [Вспомогательная библиотека](#2)
* [Роутинг](#3)
* [Роутинг и данные](#4)
* [Навигация между страницами](#5)
* [Заключение](#6)
Поехали!
Контекст приложения
-------------------
Пожалуй, первое, что нам понадобится – сделать контекст для всего приложения. Практически в любом приложении есть какие-то глобальные нужные для работы сторы. В NextJS есть [возможность переопределить App](https://nextjs.org/docs/advanced-features/custom-app) – точку входа в приложение. Там вы можете сделать какие-то инициализации, сохранять и подмешивать данные в роуты при переходах. Хочется сделать нечто подобное.
В любом приложении на React всегда есть главный корневой компонент, который рендерит все приложение. Обычно он лежит в файле App и содержит провайдеры сторов, роутер и разные другие обертки, нужные в приложении. Чтобы не добавлять лишние сущности, можно переиспользовать такой файл, просто добавив нужный функционал и немного изменив интерфейс этого компонента.
Нам всего лишь нужно добавить некоторый глобальный контекст к компоненту App. Для этого, по аналогии с NextJS, добавим статический метод создания контекста к компоненту. Наш контекст должен быть сериализуемым, чтобы мы могли создать его на сервере, сериализовать, прокинуть на клиент и восстановить уже на клиенте. Выглядеть это будет так:
```
App.createContext = async (initialData) => {
return someContext;
};
```
someContext – это объект, который должно быть можно сериализовать. Как правило, [в такой глобальный контекст мы прокидываем стор](https://redux.js.org/usage/server-rendering), например, Redux. Обычно на своих проектах мы используем MobX в качестве стейт-менеджера, поэтому в своем тестовом проекте я также буду ориентироваться именно на него. Впрочем, это никак не влияет на функционал самой библиотеки – важно, что из функции createContext нужно вернуть некоторый сериализуемый объект.
Мой пример будет выглядеть так:
```
App.createContext = async (initialData) => {
if (typeof window === "undefined") {
enableStaticRendering(true); // На сервере для MobX нужно вызвать эту функцию
}
return new Store(initialData as StoreData);
};
```
В данном случае Store — это MobX-модель, которая должна уметь сериализовываться в JSON. Для этого можно добавить интерфейс
```
export interface AppContextType {
serialize(): Record;
}
```
и реализовать его в модели.
Отлично! Теперь остается только создать контекст на сервере и прокинуть на клиент.
Мы уже [экспортировали App для нашего сервера](https://habr.com/ru/company/kts/blog/566176/#2) (иначе как бы мы его отрендерили). Поэтому остается только вызвать App.createContext на сервере:
```
const { default: App } = serverExtractor.requireEntrypoint() as any;
const appUserContext = await App.createContext(); // Создаем контекст
const context = {
appContextSerialized: appUserContext.serialize(), // Сериализуем его
};
const renderedHtml = ejs.render(templateHtml, {
app: appString,
scripts,
styles,
context: serializeJavascript(context), // Добавляем в рендер шаблона
});
```
В сам шаблон index.html.ejs добавим поле для рендера контекста:
```
<% if (typeof(context) !== 'undefined') { %>
window.SERVER\_CONTEXT = <%- context %>;
window.INITIAL\_LOAD = true;
<% } %>
```
Отлично! Теперь достаем контекст на клиенте перед тем, как вызвать hydrate.
```
const store = await App.createContext(
(window as any).SERVER_CONTEXT.appContextSerialized
);
```
В функции createContext можно использовать initialData, которую мы получили с сервера.
Остается передать созданный стор в App и использовать его по своему усмотрению. Например, положить в контекст-провайдер:
```
// index
hydrate(
,
root
);
// App
export type SSRAppRoot = React.ComponentType & {
createContext: (
initialData?: Record
) => Promise | AppContextType;
};
const App: SSRAppRoot = ({ appContext }: Props) => {
return (
// тут наше приложение
);
};
```
И, конечно, не забываем то же самое сделать при серверном рендеринге App:
```
const view = ;
```
В качестве примера привожу код для глобального стора:
```
export class Store implements AppContextType {
test = 1;
constructor(initialData?: StoreData) {
makeObservable(this, {
test: observable,
inc: action.bound,
});
if (initialData) {
this.test = initialData.test;
}
}
inc() {
this.test += 1;
}
serialize() {
return {
test: this.test,
};
}
}
```
В итоге в ответе сервера видим нужные данные:
Целиком схему можно представить так:
Вспомогательная библиотека
--------------------------
Можно все оставить так. Но в будущем мы будем добавлять новые возможности в App, поэтому логично все вспомогательные утилиты сразу вынести в отдельную библиотеку.
Для этого создадим еще один пакет ssr-utils и настроим сборку. Эти пункты я опущу, они довольно стандартны. Весь код доступен на [github](https://github.com/ktsstudio/ssr-lib).
В ssr-utils вынесем типы и функцию для базового рендера приложения, а также компонент-обертку с контекстом:
```
// Обертка с контекстом
const SSRAppWrapper: React.FC = ({ appContext, children }: Props) => {
return (
{children}
);
};
// функция для рендера
export const renderApp = (App: SSRAppRoot, prepare?: () => void) => {
loadableReady(async () => {
const root = document.getElementById('app');
const store = await App.createContext(
(window as any).SERVER\_CONTEXT.appContextSerialized
);
prepare?.(); // на всякий случай, чтобы можно было сделать дополнительную логику перед hydrate
hydrate(
,
root
);
});
};
```
Используем эту библиотеку в тестовом приложении:
```
// index
import { renderApp } from "@kts/ssr-utils";
import App from "./App";
renderApp(App);
// App
const App: SSRAppRoot = ({ appContext }: Props) => {
return (
// Наше приложение
);
};
```
Роутинг
-------
Переходим к самому интересному. Кроме глобального контекста нам важно подгружать данные для определенной страницы и прокидывать их на клиент по аналогии с глобальным контекстом. Обычно для этого мы матчим на сервере запрашиваемый URL с заранее заданным конфигом роутов приложения, затем подгружаем данные и прокидываем их на страницу, и уже на самой странице на клиенте забираем их.
В версиях react-router со 2-й по 5-ю существует библиотека [react-router-config](https://www.npmjs.com/package/react-router-config), которая используется как раз для схемы с серверным рендерингом [в документации react-router](https://v5.reactrouter.com/web/guides/server-rendering). Обратите внимание, что в недавно вышедшей новой версии роутера необходимость в этой библиотеке отпадает. Но я буду рассматривать 5-ую версию: во-первых, она все еще актуальна для большинства проектов, а во-вторых, принципы, описанные далее, не зависят от версии пакета.
На правах рекламы скажу, что вместе с 6-ой версией react-router его создатели заопенсорсили SSR-фреймворк [Remix](https://remix.run/), про который мы сделали [перевод небольшого туториала](https://habr.com/ru/company/kts/blog/598071/) в нашем блоге.
Суть: мы задаем конфиг роутов, описанных объектами, в которых перечисляем путь, компонент для рендера и вложенные роуты в таком же формате. По такому конфигу мы сможем матчить запрошенный пользователем URL и рендерить нужный компонент.
Для примера я буду использовать такую структуру страничек:
* Main — главная
* About — страница «о проекте»
* About/id — страница с параметром
Пример конфига роутов:
```
export const routes: RouteConfig[] = [
{
path: "/about",
component: AboutPage as any,
routes: [
{
path: "/about/:id",
component: AboutIdPage as any,
},
],
},
{
path: "/",
exact: true,
component: MainPage,
},
];
```
Теперь на сервере остается матчить URL из запроса с этим конфигом и понимать, на какую страницу перешел пользователь. Для рендера нужной страницы мы просто используем [StaticRouter](https://v5.reactrouter.com/web/api/StaticRouter). Он будет отрисовывать нужную страницу один раз с предположением, что URL не может меняться. На то он и называется Static:
```
// Генерация view для рендера на сервере
const view = (
);
```
В сам App нужно добавить отрисовку роутов, как в обычном приложении. Это удовлетворяет нашему принципу «максимальной приближенности используемых инструментов» из начала статьи.
```
const App: SSRAppRoot = ({ appContext }: Props) => {
return (
{routes.map((route, i) => (
))}
);
};
```
Роутинг и данные
----------------
Теперь надо подгрузить нужные для каждого роута данные, отрендерить страницы вместе с ними и прокинуть их на фронт.
В NextJS этого можно достичь с помощью методов [getInitialProps](https://nextjs.org/docs/api-reference/data-fetching/getInitialProps) и [getServerSideProps](https://nextjs.org/docs/basic-features/data-fetching#getserversideprops-server-side-rendering), которые должны вернуть объект, который затем будет прокинут в качестве пропсов в компонент страницы. Довольно удобный и понятный механизм, попробуем его реализовать. В NextJS есть много оптимизаций и методов под разные кейсы, например, для пререндера. Нам достаточно будет одного метода loadData. В нем будем получать сам объект матча роута, чтобы фетчить нужные данные (например, по id), глобальный контекст AppContext (вдруг нам нужно что-то из глобального стора?), ну и предыдущую версию данных этой страницы (если мы ее уже загружали, может мы захотим просто отдавать закешированные данные).
Ниже сигнатура метода loadData для компонента AboutPage:
```
AboutPage.loadData = async (match, ctx, pageData) => {
// в match - данные роутера
// ctx - глобальный контекст
// pageData - данные страницы
if (pageData["/about"]) {
return pageData["/about"];
}
return { about: "data from loadData" };
};
```
Обращу внимание, что при использовании NextJS у меня часто возникала проблема именно с получением глобального контекста. Существуют случаи, когда он нужен, но Next прокидывает в вышеупомянутые функции свой контекст, который содержит в основном данные роутера: URL и т.д. В моем опыте добавление своих данных в этот контекст доставляло много хлопот.
Вернемся к нашему методу. Нам нужно вызвать его на сервере только в случае, если URL запроса совпадает с URL компонента AboutPage из нашего конфига. Значит, алгоритм будет такой: пробегаем по конфигу, ищем объект роута с совпадающим URL, берем у него компонент и вызываем метод loadData, если он есть.
На практике наша ssr-lib ничего не знает о файлах внутри проекта, где она используется. Поэтому мы используем «контракт в коде» и экспортируем конфиг роутов, чтобы забрать его на сервере — например из компонента App:
```
const { default: App, routes } = serverExtractor.requireEntrypoint() as any;
```
А функцию поиска нужного роута и загрузки данных можно вынести во вспомогательную библиотеку, она еще понадобится нам на клиенте:
```
export const loadRoutesData = async (
routes: RouteConfig[],
path: string,
appContext: AppContextType,
pageData: PageDataType = {}
) => {
// matchRoutes предоставляет библиотека react-router-config
const promises: any[] = matchRoutes(routes, path).map(({ route, match }) => ({
path: route.path,
url: match.url,
promise: (route?.component as any)
?.load() // загружаем компонент, у нас LazyLoad
.then(({ default: { type, loadData } }: any) => {
const load = loadData || type?.loadData;
return load ? load(match, appContext, pageData) : Promise.resolve(null); // Если есть loadData, вызываем.
}),
}));
const data = await Promise.all(promises.map((p) => p.promise));
return promises.reduce(
(acc, next, i) => ({
...acc,
[next.path]: data[i],
}),
{}
); // Возвращаем карту путь -> данные
};
```
Использовать функцию на сервере совсем просто:
```
const appUserContext = await App.createContext();
const pageData = await loadRoutesData(routes, req.path, appUserContext);
```
А полученные данные pageData с картой “путь” → данные будем передавать в контекст по аналогии с тем, как мы делали с глобальным контекстом:
```
const context = {
pageData,
appContextSerialized: appUserContext.serialize(),
};
const view = (
);
```
Обратите внимание, что данные мы передали в новый пропс у App — serverContext.
Для получения серверного контекста можно добавить функцию, которая будет возвращать пустой объект pageData, если контекст не передан:
```
export const getServerContext = (
serverContext?: ServerContextType
): ServerContextType =>
typeof window === 'undefined'
? serverContext || {
pageData: {},
}
: window.SERVER_CONTEXT;
```
После загрузки данных мы можем переложить их в state, чтобы потом использовать в компонентах и изменять при переходах между страницами. Для этого отлично подойдет наш SSRAppWrapper. Добавим хранение данных страниц в него:
```
const loadedContext = getServerContext(serverContext);
const [data, setData] = useState(loadedContext.pageData);
```
Обратите внимание, что в pageData хранятся данные всех роутов, сматченных в процессе парсинга URL. Например, для /about/123 будет сохранены данные страниц /about и /about/123 в объекте pageData с соответствующими ключами. Поэтому pageData мы будем хранить на самом верхнем уровне в обертке SSRAppWrapper.
Для использования данных страниц по аналогии с глобальным контекстом создадим контекст с pageData:
```
export type PageDataContextType = {
pageData: PageDataType;
setPageData: (d: Record) => void;
};
export const [
PageDataContext,
usePageDataContext,
] = createContext();
```
И используем этот контекст в SSRAppWrapper.
В NextJS мы могли бы получить данные в пропсах в нужном компоненте-странице. Чтобы добиться такого поведения, мы можем сделать обертку над компонентами страниц. Она будет подтягивать нужные данные из контекста и передавать в пропсы. Или можно ее не использовать и напрямую брать данные из контекста в нужных компонентах.
Такую обертку можно использовать вместо компонента Route из react-router. Сделаем свой SSRRoute:
```
type Props = { route: RouteConfig; path: string };
const SSRRoute: React.FC = ({ route, path }: Props) => {
// Забираем данные из контекста
const pageData = usePageDataContext().pageData[route.path as string];
const Component = route.component as any;
return (
}
/>
);
};
```
Аналогичную логику можно было сделать и в HOC’е и в хуке, не принципиально.
Теперь наш App будет выглядеть так:
```
const App: SSRAppRoot = ({ serverContext, appContext }: Props) => {
return (
{routes.map((route, i) => (
))}
);
};
```
На этом этапе мы уже можем протестировать приложение. В компонент AboutId, который отвечает за роут /about/:id, добавим функцию, которая будет фетчить данные, например из гитхаба:
```
type Props = { pageData: any };
const About: SSRPage = (props: Props) => {
const { id } = useParams<{ id: string }>();
return (
About with param {id} {props.pageData.login}
About
);
};
About.loadData = async () => {
const { data } = await axios.get("https://api.github.com/users/NapalmDeath");
// мб какие-то манипуляции с данными
return data;
};
```
При серверном рендеринге данные успешно рендерятся на странице:
Схема этого этапа:
Навигация между страницами
--------------------------
Теперь, когда при первом рендеринге страницы мы видим данные, полученные на сервере, нужно добавить ту же загрузку при переходе между страницами уже на клиенте.
Принцип довольно прост и описан в том же [react-router-config](https://github.com/remix-run/react-router/tree/v5.3.0/packages/react-router-config#matchroutesroutes-pathname). Мы будем отлавливать изменения состояния роутера и загружать данные. А пока они загружаются, показывать предыдущую страницу, то есть насильно устанавливать прошлое значение роутера. Как только данные загрузятся, можно «разблокировать» роутер и установить новую страницу.
Для этого можно написать хук, который мы будем использовать в SSRAppWrapper:
```
export const usePageLoader = (
routes: RouteConfig[],
appContext: AppContextType,
serverContext?: ServerContextType
): [RouteComponentProps, PageDataContextType, boolean] => {
const location = useLocation(); // Получаем текущий location
const context = useContext(__RouterContext); // получаем контекст роутера
const loadedContext = getServerContext(serverContext);
const [data, setData] = useState(loadedContext.pageData); // данные страницы
// Текущий и прошлый location будем хранить в стейте
const [currentLocation, setCurrentLocation] = useState(
location
);
const [prevLocation, setPrevLocation] = useState(location);
const [isLoading, setIsLoading] = useState(false); // идет ли загрузка данных
useEffect(() => {
// Если локейшн поменялся
if (window.INITIAL\_LOAD) {
// Если это первая загрузка (мы возвращаем INITIAL\_LOAD = true прямо с сервера в html), то ничего не делать, данные уже есть.
window.INITIAL\_LOAD = false;
return;
}
// Сохраняем прошлый локейшн, устанавливаем текущий и флаг загрузки
setPrevLocation(currentLocation);
setCurrentLocation(location);
setIsLoading(true);
// Загрузка данных из ssr-utils. Ее мы уже использовали на сервере
loadRoutesData(routes, location.pathname, appContext, data).then(
(loadedData) => {
// Обновляем данные страниц
setData((s) => ({
...s,
...loadedData,
}));
// Сбрасываем прошлый локейшн
setIsLoading(false);
setPrevLocation(null);
}
);
}, [location]);
// Реальный локейшн будем брать из предыдущего либо текущего. Когда данные грузятся – будет взять prevLocation, затем, когда загрузятся – current. Смотри код выше
const routeLocation = prevLocation || currentLocation;
const routerValue = useMemo(
() => ({
...context,
location: routeLocation || context.location,
}),
[routeLocation]
);
const pageDataValue = useMemo(
() => ({
pageData: data,
setPageData: setData,
}),
[routeLocation]
);
// Возвращаем значения для роутера и данных
return [routerValue, pageDataValue, isLoading];
};
```
Использовать такой хук будем в SSRAppWrapper:
```
const SSRAppWrapper: React.FC = ({
routes,
serverContext,
appContext,
children,
}: Props) => {
const [routerValue, pageDataValue, isLoading] = usePageLoader(
routes,
appContext,
serverContext
);
return (
<\_\_RouterContext.Provider value={routerValue}>
{isLoading && }
{children}
);
};
```
Обратите внимание на \_\_RouterContext. Это нужно, чтобы переопределить локейшн для всего роутера. На самом деле переопределить локейшн можно у компонентов Switch, но react-router позволяет рендерить роуты на любом уровне вложенности, и «добраться» до них из нашей библиотеки будет сложно: ведь мы ничего не знаем о пользовательском коде, который использует библиотеку. Максимум, что мы можем — добавлять контракты и интерфейсы взаимодействия. Поэтому очень удобным способом в данном случае будет глобальное переопределение значения в контексте роутера, которое, в свою очередь, будут использовать все Switch/Route и другие компоненты роутера на любом уровне вложенности в пользовательском коде.
TopBarProgress — это компонент, который будет подсвечивать загрузку страницы.
Отлично, теперь при смене страницы мы будем дожидаться загрузки данных и только потом рендерить новую страницу:
Схема:
Заключение
----------
В этой статье мы добавили функционал роутинга и загрузки данных для библиотеки серверного рендеринга на React, которую писали в [прошлой статье](https://habr.com/ru/company/kts/blog/566176/).
В процессе разработки мы постарались использовать только привычные инструменты, чтобы минимизировать число контрактов в коде и специфики «фреймворка». Конечно, этот пример не production-ready. На нем мы рассмотрели принципы серверного рендеринга, роутинга на сервере и клиенте, и загрузки данных, а также попробовали завернуть все это во «фреймворк» так, чтобы разработчики могли запускать сервер одной командой.
Надеюсь, было интересно и полезно. Весь код доступен на [github](https://github.com/ktsstudio/ssr-lib). | https://habr.com/ru/post/598571/ | null | ru | null |
# Обзор GraphQL-фреймворков на Java
В [предыдущей статье](https://habr.com/ru/company/hh/blog/677972/) мы поговорили о том, что такое graphQL, почему решили на него переходить, какие у него есть достоинства и недостатки. Но что делать дальше, если вы всё-таки решились внедрить graphQL в java-проект? Какие на данный момент есть фреймворки, чем они отличаются и какой вообще выбрать? Именно с этими проблемами мы и столкнулись почти год назад и не нашли адекватного ответа в одном источнике. Собрав по крупицам инфу из разных ресурсов (статьи, документации, доклады) и потыкав палочкой несколько фреймворков, мы сформировали общую базу знаний о них, которой и захотелось поделиться.
Если вам интересно, какие есть современные graphQL-фреймворки на java, как выбрать подходящий и посмотреть, как он может выглядеть в продакшне — эта статья для вас.
Всем привет! Меня зовут Артем, я бэкенд-разработчик в [hh.ru](http://hh.ru). Сегодня мы поговорим о современных решениях в GraphQL-мире на Java.
Статья также доступна в [видеоформате](https://www.youtube.com/watch?v=zMIjoMOl3F8).
### Тишина в библиотеке!
Сегодня почти на всех популярных языках программирования есть хотя бы одно GraphQL-решение. Конечно, больше всего эта тема развита в JS-мире. Java скорее на “догоняющей” позиции, но это не значит, что там всё сыро и грустно. Эти решения вполне production-ready, большинство из них проверены временем, и ими спокойно можно пользоваться.
### GraphQL-java
Первое, на что стоит обратить внимание — библиотека [Graphql-java](https://github.com/graphql-java/graphql-java). Это настоящий движок GraphQL, и более того – он единственный. А значит, какими бы фреймворками вы ни пользовались, в итоге в кишочках всё равно будет использована именно эта либа. Реализация data fetching, работа с контекстом, обработка ошибок, мониторинг, ограничение запроса, видимость полей и даже [dataloader](https://github.com/graphql/dataloader) — всё это уже реализовано в движке. Соответственно, можно его использовать напрямую или менять фреймворки довольно смело, чтобы определиться, какой подходит вам больше всего. Graphql-java — opensource, она разрабатывается простыми смертными ребятами, а последний коммит был буквально на днях. В общем, этот движок активно развивается.
Впрочем, несмотря на все плюсы вам следует хорошенько подумать, стоит ли использовать её в прямом виде. Мы вот не используем. Эта библиотека низкоуровневая, гибкая, а значит вербозная. Фреймворки в том числе помогают справиться с этим. Разумеется, движок вполне можно использовать напрямую, но это будет менее удобно.
Кроме этой библиотеки я выделил три фреймворка, заслуживающих внимания. Всё остальное — это, в основном, довольно мелкие библиотеки.
ИтогоGraphql-java:
| | |
| --- | --- |
| **Достоинства** | **Недостатки** |
| Движок graphql | Вербозная |
| Нет аналогов | |
| Низкоуровневая | |
| Гибкая | |
### Schema-first vs Code-first
Но для начала давайте рассмотрим два ключевых подхода к проектированию graphql-API на бекенде. Есть два противоборствующих лагеря — schema-first и code-first решения.
При классическом schema-first подходе мы сначала описываем graphql-схему и потом на её основе в коде реализуем модели и data fetchers. Плюсы такого подхода в том, что проектированием и разработкой схемы могут заниматься разные люди и даже департаменты — например, аналитики проектируют схему, а разработчики её имплементируют. Также может быть удобно написать схему и сразу отдать её клиентам, а самим параллельно разрабатывать бекенд. Минусом же можно отметить необходимость в реализации как схемы, так и кода — это может занимать чуть больше времени при разработке API + теперь появляется 2 источника, которые обязаны не конфликтовать друг с другом и быть полностью синхронизированы - лишнее звено, которое может поломаться.
При code-first подходе мы пишем только код и на основе аннотаций фреймворк сам генерирует схему. Здесь у нас только 1 источник правды, но и graphql-схему без кода не построишь.
Итоговое сравнение
| | |
| --- | --- |
| **Code-first** | **Schema-first** |
| 1 источник правды - код | Описываем и схему, и код |
| Нет кода - нет схемы | Сначала разрабатываем схему, на основе неё пишем код |
### Domain Graph Service
И первый фреймворк, на который мы обратим внимание — это [DGS](https://netflix.github.io/dgs/) (Domain Graph Service). Если вы были на докладе Пола Беккера на JPoint 2021 — вы уже знаете, о чём я. Остальным рекомендую ознакомиться, доклад очень классный.
Изначально был придуман Netflix в 2019 году, а уже в 2020 его выложили в opensource. И это полноценный фреймворк — он помогает работать с обслуживающим GraphQL-кодом, писать юнит-тесты, предоставляет свой error handling, code-gen для генерации data fetchers на основе схемы, ну и так далее. Это schema-first решение. И всё это production-ready, Netflix на полную его используют.
И всё-таки мы выбрали другое решение.
Во-первых, DGS — schema-first, а нам бы хотелось заиспользовать code-first подход - легче поднять, чуть быстрее разрабатывать, нет необходимости в разработке схемы без кода.
Во-вторых, DGS использует spring boot. И это прекрасно! Но мы внутри компании его не используем - у нас свой фреймворк, который использует чистый spring-core. Конечно, это не значит, что его не получится поднять — у нас получилось завести, предварительно пообщавшись с Полом на тему норм ли вообще поднимать без бута или авторы так не рекомендуют (норм). Но для этого нужно было разобраться в самом коде фреймворка, найти и объявить вручную с десяток незадокументированных и не всегда понятных бинов, которые в новых версиях DGS могут поломаться. В общем, не бесплатно в обслуживании.
Ну и в-третьих, даже несмотря на то, что это — полноценный фреймворк, вам всё равно придётся дописывать его для работы с юнит-тестами, error handling, мониторингом etc. Просто потому что ваш проект растёт и вам не будет хватать существующих решений.
Тем не менее, он очень крутой. Поэтому мы пометили его для себя “звездочкой” — решили, что в случае чего вернемся к нему.
ИтогоDGS:
* schema-first
* opensource от Netflix
* На Spring-boot
* Полноценный фреймворк
### Java SPQR
Следующая либа, которую мы разберём — это [Java SPQR](https://github.com/leangen/graphql-spqr).
Проверенная годами opensource-библиотека. Кроме того, это ещё и единственное code-first решение, к тому же не полноценный фреймворк, что довольно круто. Всё, что делает эта либа — реализует code-first подход и немножко помогает работать с обслуживающим GraphQL-кодом. Нас это абсолютно устраивало, на ней мы и остановились.
Но не смотря на наш выбор, сложно советовать её использовать на данный момент, ибо она забросилась. Последний коммит был больше года назад, ответов на issues не было, поддержки тоже нет.
Почему это может быть важно - как пример, graphql поддерживает наследование, и в 2020 году graphql-спека, а потом уже graphql-java, подхватила возможность работы с множественным наследованием интерфейсов. И вот уже 2022 год, но в SPQR нельзя воспользоваться этой новой фичей.
Однако, совсем недавно ментейнер [ответил](https://github.com/leangen/graphql-spqr/issues/417#issuecomment-1173841514) о планах возобновить работу над проектом, что не может не радовать.
Итого* Единственное code-first решение
* Минималистичен, не фреймворк
* Заброшен, но есть планы по возобновлению проекта
### Spring GraphQL
Последний фреймворк, о котором хочется поговорить — это [Spring GraphQL](https://github.com/spring-projects/spring-graphql).
Совсем свежачок, вышел в июле 2021. Джош Лонг о нём рассказывал на осеннем Joker 2021. Тоже schema-first подход, интеграция со спрингом (спасибо кэп), немного повторяет DGS — также есть свои обработчики ошибок, поддержка написания юнит-тестов, более удобная работа с data fetchers.
Стоит присмотреться, но аккуратно — фреймворк вышел недавно.
ИтогоSpring GraphQL:
* Schema-first
* Интеграция со спрингом
* Полноценный фреймворк
* Вышел совсем недавно
### Ну и как это выглядит?
Теперь давайте создадим простой graphql-сервер. В качестве стандартного стека будем использовать Java и Spring, а в качестве GraphQL — SPQR, в которой используется движок Graphql-java. Го в код!
Полный прототип можно скачать [здесь](https://github.com/hhru/hh-histories-graphql-demo/).
#### GraphQL bean
Для начала создадим главный GraphQL бин, который будет выполнять все запросы.
```
@Configuration
public class GraphQLConfig {
private final CandidateResolver candidateResolver;
private final ResumeResolver resumeResolver;
public GraphQLConfig(CandidateResolver candidateResolver,
ResumeResolver resumeResolver) {
this.candidateResolver = candidateResolver;
this.resumeResolver = resumeResolver;
}
@Bean
public GraphQLSchema getGraphQLSchema() {
return new GraphQLSchemaGenerator()
.withBasePackages("com.example.graphql.demo.models")
.withOperationsFromSingletons(candidateResolver, resumeResolver)
.generate();
}
@Bean
public GraphQL getGraphQL(GraphQLSchema graphQLSchema) {
return GraphQL.newGraphQL(graphQLSchema)
.queryExecutionStrategy(new AsyncExecutionStrategy())
.instrumentation(new CustomTracingInstrumentation())
.build();
}
}
```
Для выполнения ему нужно знать схему - `GraphQLSchema` - но так как SPQR про code-first подход, то мы заиспользуем генератор схемы, который по полям моделей из корневого package сам её построит.
После этого мы определим `ExecutionStrategy` — стратегия выполнения graphql-запроса. По дефолту каждая нода в графе выполняется асинхронно и за это как раз отвечает `AsyncExecutionStrategy`, который в случае чего можно поменять.
После этого переопределим инструментейшены (о них поговорим отдельно) и запустим бин.
#### Endpoint
Нам нужно откуда-то получить запрос, поэтому создадим обычный POST-метод, принимающий query. Он будет един для всех graphql-запросов, в отличие от REST, где на каждый запрос мы делали отдельный метод.
И после этого передадим запрос на выполнение graphql-бину.
```
@RestController
public class DemoController {
private final GraphQL graphQL;
@Autowired
DemoController(GraphQL graphQL) {
this.graphQL = graphQL;
}
@PostMapping(path = "graphql",
consumes = MediaType.APPLICATION_JSON_VALUE,
produces = MediaType.APPLICATION_JSON_VALUE)
public ExecutionResult graphql(@RequestBody EntryPoint entryPoint) {
ExecutionInput executionInput = ExecutionInput.newExecutionInput()
.query(entryPoint.query)
.build();
return graphQL.execute(executionInput);
}
public static class EntryPoint {
public String query;
}
}
```
#### Входные точки
Мы описали схему, мы умеем принимать запросы — но где описать входные точки в этот граф? За это в graphql отвечают Data Fetchers (или по-другому Resolvers) — бин, в котором мы опишем ноды графа.
```
@GraphQLQuery(name = "candidates")
public CompletableFuture> getCandidates() {
return CompletableFuture.supplyAsync(candidateService::getCandidates);
}
```
В данном случае мы создали входную точку `candidates`, которая возвращает некую модель `Candidate`.
```
public class Candidate {
private Integer id;
private String firstName;
private String lastName;
private String email;
private String phone;
// getters and setters are omitted
}
```
Более того, как раз по моделям в резолверах SPQR и построит схему.
Конечно, можно и нужно, чтобы таких нод было как можно больше, чтобы они переплетались между собой, создавая граф. Поэтому создадим ещё одну ноду `resumes` и свяжем её с кандидатами с помощью `@GraphQLContext`.
```
@GraphQLQuery(name = "resumes")
public CompletableFuture> getResumes(@GraphQLContext Candidate candidate) {
return CompletableFuture.supplyAsync(() -> resumeService.getResumes(candidate));
}
public class Resume {
private Integer id;
private String lastExperience;
private Salary salary;
// getters and setters are omitted
}
public class Salary {
private String currency;
private Integer amount;
// getters and setters are omitted
}
```
Работает это так - если в самом `candidates` запросить что-то из `resumes`, только тогда отработает этот резолвер.
#### Instrumentation
Помимо всего прочего, мы наверняка захотим мониторить состояние выполнения запроса: сколько времени выполняется каждый резолвер, сколько выполняется полный запрос, какие ошибки мы можем словить. Для этого при регистрации graphql-бина можно прописать Instrumentations — как дефолтные, так и кастомные.
Технически это класс, имплементящий `interface Instrumentation` (в нашем случае отнаследовались от `class SimpleInstrumentation`, обычной заглушки, чтобы не реализовывать все методы).
В нём прописаны методы, вызывающиеся при определённом состоянии запроса: когда запрос только начался выполняться, когда вызвался резолвер, когда он закончился выполняться etc.
CustomTracingInstrumentation
```
public class CustomTracingInstrumentation extends SimpleInstrumentation {
Logger logger = LoggerFactory.getLogger(CustomTracingInstrumentation.class);
static class TracingState implements InstrumentationState {
long startTime;
}
// Cоздаём контекст трэйсинга для конкретного запроса
@Override
public InstrumentationState createState() {
return new TracingState();
}
// Выполняется перед каждым запросом. Инициализируем контекст трейсинга для замеров времени выполнения
@Override
public InstrumentationContext beginExecution(InstrumentationExecutionParameters parameters) {
TracingState tracingState = parameters.getInstrumentationState();
tracingState.startTime = System.currentTimeMillis();
return super.beginExecution(parameters);
}
// Выполняется при завершении запроса. С помощью totalTime мерим время выполнения всего запроса
@Override
public CompletableFuture instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters) {
TracingState tracingState = parameters.getInstrumentationState();
long totalTime = System.currentTimeMillis() - tracingState.startTime;
logger.info("Total execution time: {} ms", totalTime);
return super.instrumentExecutionResult(executionResult, parameters);
}
// Выполняется при каждом вызове DataFetcher/Resolver. С помощью него будем мерить время выполнения каждого резолвера
@Override
public DataFetcher instrumentDataFetcher(DataFetcher dataFetcher, InstrumentationFieldFetchParameters parameters) {
// Так как любое поле в графе потенциально может быть резолвером, оставим только те, которые хотя бы что-то делают
if (parameters.isTrivialDataFetcher()) {
return dataFetcher;
}
return environment {
long startTime = System.currentTimeMillis();
Object result = dataFetcher.get(environment);
// Так как все ноды в нашем случае выполняются асинхронно, замерим время только для них
if(result instanceof CompletableFuture) {
((CompletableFuture) result).whenComplete((r, ex); {
long totalTime = System.currentTimeMillis() - startTime;
logger.info("Resolver {} took {} ms", findResolverTag(parameters), totalTime);
});
}
return result;
};
}
// Ветьеватая логика получения имени резолвера и его родителя (для лучшего понимания откуда вызывалась нода)
private String findResolverTag(InstrumentationFieldFetchParameters parameters) {
GraphQLOutputType type = parameters.getExecutionStepInfo().getParent().getType();
GraphQLObjectType parent;
if (type instanceof GraphQLNonNull) {
parent = (GraphQLObjectType) ((GraphQLNonNull) type).getWrappedType();
} else {
parent = (GraphQLObjectType) type;
}
return parent.getName() + "." + parameters.getExecutionStepInfo().getPath().getSegmentName();
}
}
```
На самом деле, Instrumentation довольно мощный функционал, который можно использовать не только для мониторинга. Например, уже реализованный `MaxQueryDepthInstrumentation`из graphql-java мерит максимальную глубину запроса и при превышении отменяет запрос, a с помощью `MaxQueryComplexityInstrumentation` можно поставить веса конкретным нодам и управлять сложностью запроса (но с ним есть нюансы, о них ещё поговорим в отдельной статье).
Этого достаточно, чтобы запустить наш сервис.
#### Сам запрос
```
{
candidates {
id,
firstName,
lastName,
phone,
email,
resumes {
id,
lastExperience,
salary {
currency,
amount
}
}
}
}
```
Ответ будет в стандартном для сервиса json-формате
```
{
"errors": [],
"data": {
"candidates": [
{
"id": 1,
"firstName": "Леонид",
"lastName": "Якубович",
"phone": "88005553535",
"email": "leonid@yakubovich.ru",
"resumes": [
{
"id": 501,
"lastExperience": "Ведущий шоу Поле чудес",
"salary": {
"currency": "RUB",
"amount": 40000
}
}
]
},
{
"id": 2,
"firstName": "Леонид",
"lastName": "Агутин",
"phone": "88005553030",
"email": "hophey@lalaley.com",
"resumes": [
{
"id": 502,
"lastExperience": "Ведущий шоу Голос",
"salary": {
"currency": "RUB",
"amount": 50000
}
}
]
}
]
},
"extensions": null,
"dataPresent": true
}
```
### Заключение
Вот как обстоят graphql-дела в java-мире. Мы рассмотрели разные фреймворки, оценили их достоинства и недостатки, а потом реализовали простенький graphql сервис на java. Надеюсь, вам было полезно.
Конечно, развивая эту технологию, вы наверняка столкнетесь со множеством других кейсов. Их мы обязательно разберём в следующих статьях. Но по крайней мере, сейчас нам удалось создать работающий прототип, и это было относительно легко. | https://habr.com/ru/post/681910/ | null | ru | null |
# Cloudflare PHP API Binding
***Перевод статьи подготовлен в преддверии старта курса [«Backend-разработчик на PHP»](https://otus.pw/QCBO/).***
---
Для тех разработчиков, которые используют PHP 7.0 или выше, Cloudflare предоставляет PHP API биндинг. Он поддерживает последнюю четвертую версию API Cloudflare. Вы можете использовать этот SDK для ряда целей, включая такие как:
* Управление и автоматизация изменений в своих DNS-записях в Cloudflare.
* Программное добавление зон в свою учетную запись.
* Версионирование и управление изменениями в Page Rules
* Автоматическая блокировка IP-адресов и User Agent-ов с использованием Zone Lockdown и UserAgent Rules.
* Получение IP-диапазонов Cloudflare для автоматизации вайтлистинга файрволом
### Поддерживаемые функции
В этой статье приводятся несколько распространенных примеров использования PHP API биндинга Cloudflare; в настоящее время мы поддерживаем следующие эндпоинты и методы аутентификации:
V4 Эндпоинты
* DNS
* IPs
* Page Rules
* User Agent Rules
* User Management (частичное)
* Zone Lockdown
* Zones
Аутентификации
* User Service Keys
* API Keys
### Установка
[Cloudflare PHP API биндинг](https://packagist.org/packages/cloudflare/sdk) доступен на Packagist в [cloudflare/sdk](https://packagist.org/packages/cloudflare/sdk), который может быть установлен с использованием Composer с помощью вызова *composer require cloudflare/sdk*:
Также если вы хотите ознакомиться непосредственно с исходным кодом или внести свой вклад в проект, вы можете найти исходный код на GitHub в репозитории [cloudflare/cloudflare-php](https://github.com/cloudflare/cloudflare-php).
### Начало работы
Вот небольшой пример работы с API
```
php
require_once('vendor/autoload.php');
$key = new \Cloudflare\API\Auth\APIKey('mjsa@junade.com', 'API KEY GOES HERE');
$adapter = new Cloudflare\API\Adapter\Guzzle($key);
$user = new \Cloudflare\API\Endpoints\User($adapter);
echo 'Your user ID is: ' . $user-getUserID() . PHP_EOL;
```
Запустив этот простой скрипт в командной строке, мы получим следующий вывод:
### Листинг зон
Вот как можно перечислить все зоны в учетной записи с помощью следующего кода:
```
php
require_once('vendor/autoload.php');
$key = new \Cloudflare\API\Auth\APIKey('mjsa@junade.com', 'API KEY GOES HERE');
$adapter = new Cloudflare\API\Adapter\Guzzle($key);
$zones = new \Cloudflare\API\Endpoints\Zones($adapter);
foreach ($zones-listZones()->result as $zone) {
echo $zone->name.' ('.$zone->plan->name.')'.PHP_EOL;
}
```
Запуск этого скрипта через командную строку даст следующий вывод:
### Очистка кэша на всех веб-сайтах
Вот еще один пример, который использует эндпоинт Purge Cache для полной очистки кэша на каждом веб-сайте нашей учетной записи (обратите внимание, что вы можете очистить отдельные файлы, использующие кэш, задействовав метод cachePurge вместо cachePurgeEverything):
```
php
require_once('vendor/autoload.php');
$key = new \Cloudflare\API\Auth\APIKey('mjsa@junade.com', 'API KEY GOES HERE');
$adapter = new Cloudflare\API\Adapter\Guzzle($key);
$zones = new \Cloudflare\API\Endpoints\Zones($adapter);
foreach ($zones-listZones()->result as $zone) {
echo "Cache purge for " . $zone->name . ": ";
echo $zones->cachePurgeEverything($zone->id) == true ? "successful" : "failed";
echo PHP_EOL;
}
```
Вы увидите следующий вывод в результате запуска этого скрипта в командной строке:
### Создание Page Rules
SDK также можно использовать для программного добавления Page Rules в Cloudflare Zone. Вот простой пример добавления правила Cache Bypass:
```
php
require_once('vendor/autoload.php');
$key = new \Cloudflare\API\Auth\APIKey('mjsa@junade.com', 'API KEY GOES HERE');
$adapter = new Cloudflare\API\Adapter\Guzzle($key);
$zones = new \Cloudflare\API\Endpoints\Zones($adapter);
$zoneID = $zones-getZoneID("junade.com");
$pageRulesTarget = new \Cloudflare\API\Configurations\PageRulesTargets('https://junade.com/noCache/*');
$pageRulesConfig = new \Cloudflare\API\Configurations\PageRulesActions();
$pageRulesConfig->setCacheLevel('bypass');
$pageRules = new \Cloudflare\API\Endpoints\PageRules($adapter);
$pageRules->createPageRule($zoneID, $pageRulesTarget, $pageRulesConfig, true, 6);
```
Мы можем легко получить ID нужной зоны, используя метод getZoneID класса эндпоинта Zones — этот вспомогательный метод возвращает ID по имени зоны.
Обратите внимание, что SDK использует внедрение зависимостей для указания цели и конфигурации правил страницы. Вот почему нам нужно передать экземпляры классов PageRulesTargets и PageRuleActions в метод createPageRule.
### DNS
SDK также можно использовать для программного добавления записей. Вот пример добавления DNS-записи:
```
php
require_once('vendor/autoload.php');
$key = new \Cloudflare\API\Auth\APIKey('mjsa@junade.com', 'API KEY GOES HERE');
$adapter = new Cloudflare\API\Adapter\Guzzle($key);
$zones = new \Cloudflare\API\Endpoints\Zones($adapter);
$zoneID = $zones-getZoneID("junade.com");
$dns = new \Cloudflare\API\Endpoints\DNS($adapter);
if ($dns->addRecord($zoneID, "A", 'example', '8.8.8.8', 0, true) === true) {
echo "DNS record created.". PHP_EOL;
}
```
Кроме того, мы также можем удалять, перечислять и просматривать детали DNS-записей с помощью этого SDK. Например, давайте создадим простой скрипт для перечисления типа и имени каждой DNS-записи в нашей зоне:
```
php
require_once('vendor/autoload.php');
$key = new \Cloudflare\API\Auth\APIKey('mjsa@junade.com', 'API KEY GOES HERE');
$adapter = new Cloudflare\API\Adapter\Guzzle($key);
$zones = new \Cloudflare\API\Endpoints\Zones($adapter);
$zoneID = $zones-getZoneID("icyapril.com");
$dns = new \Cloudflare\API\Endpoints\DNS($adapter);
foreach ($dns->listRecords($zoneID)->result as $record) {
echo $record->type." ".$record->name.PHP_EOL;
}
```
Таким будет вывод, когда я запущу этот скрипт для одной из моих зон:
---
[Узнать подробнее о курсе](https://otus.pw/QCBO/)
--- | https://habr.com/ru/post/498936/ | null | ru | null |
# live: новый способ задать обработчик события
[Как известно](http://habrahabr.ru/blogs/jquery/47548/), недавно вышла бета версия jQuery 1.3. Пока она сырая, тестируется, и в ней еще есть неприятные баги. Но знакомится с нововведениями стоит и я хотел бы кратко рассказать об одном из них.
Функция «live» представляет собой аналог функции bind, по синтаксису и сути они идентичны, но между ними есть одно огромное различие, которое лучше всего демонcтрирует следующий пример.
[Попробовать демо](http://habradigest.ru/garbage/jq/). Пояснения под катом.
В примере два набора кнопок, нажатие первых обрабатывается функцией назначенной через bind, вторых — через live.
При динамическом добавлении кнопок мы можем наблюдать основное отличие: в первом наборе новые кнопки не получают обработчика, во втором обработчик автоматически добавляется для каждой новой кнопки.
И хотя отличия в коде невелики:
> `$("input.test").bind("click", function() {
>
> alert("hello base input!");
>
> });
>
> $('input.lcmd').live("click", function() {
>
> alert("hello live input!");
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
по факту мы имеем огромную разницу.
PS: ранее подобный функционал можно было получить через [этот плагин](http://brandonaaron.net/docs/livequery/).
PPS: во время тестирования столкнулся с багом, который показывает насколько 1.3 еще сыра:
если указать сложный селектор $('#lblock input.lcmd').live(..., то обработчик не навесится вообще, причем, при замене на bind все работает прекрасно. Ждем исправлений в следующих версиях.
PPPS: а вот $('input.lcmd', $('#lblock')).live(… работает, что, в общем, не удивительно | https://habr.com/ru/post/47822/ | null | ru | null |
# Docker 1.9 + Weave 1.2.1 bridge mode
Сегодня, после обновления на Docker 1.9 у меня вполне ожидаемо сломался ранее прекрасной работающий [Weave](http://weave.works).
Описание возникших проблем и их решение под катом.
**Проблема №1**.
Проявляется в Ubuntu 14.04.
При попытке выполнить weave launch происходит следующее:
```
root@sahara:~/weave# /usr/local/bin/weave launch --no-dns --init-peer-count 8 --ipalloc-range 10.128.0.0/10 10.43.68.61 10.43.68.62 10.43.68.63 10.43.68.64 10.43.68.65 10.43.68.69 10.43.68.70
Error deleting container: Error response from daemon: Unable to remove filesystem for 4f15a00bcf3b7d6df83ed8467cad98177df331d2deed580c4547effc2db13a02: remove /var/lib/docker/containers/4f15a00bcf3b7d6df83ed8467cad98177df331d2deed580c4547effc2db13a02/shm: device or resource busy
```
Как выяснилось, это уже известная проблема:
[github.com/weaveworks/weave/issues/1647](https://github.com/weaveworks/weave/issues/1647)
[github.com/weaveworks/weave/issues/1652](https://github.com/weaveworks/weave/issues/1652)
Там пишут, что, возможно, поможет переход на использование overlayfs вместо aufs, но мне помогла установка ядра 3.19 (пакет linux-image-extra-virtual-lts-vivid)
Спасибо за помощь ребятам из Weave, сидящим на канале #weavenetwork в IRC
**Проблема №2**
Вторая проблема связана с тем, что я использую Weave для связи контейнеров в кластере Mesos + Kubernetes, и мне совсем не нужны болтающиеся неиспользуемые eth0 в контейнерах. Тем более, что я это настраивал еще во время Weave 1.0, когда еще не были придуманы методы адекватной связки Mesos и Weave.
Поэтому я использовал не рекомендуемый официально метод привязки weave к контейнерам заменой моста docker0 на weave.
Это работало вплоть до Docker 1.8 + Weave 1.1.1
Сегодня же все сломалось:
```
root@sahara:~/weave# /usr/local/bin/weave launch-router --no-dns --init-peer-count 8 --ipalloc-range 10.128.0.0/10 10.43.68.61 10.43.68.62 10.43.68.63 10.43.68.64 10.43.68.65 10.43.68.69 10.43.68.70
Error response from daemon: Cannot start container b5c0d3e7b69a0101586d1ffe79862f292ed72b72d3f6bf5e21debf086b81db67: [8] System error: failed to set gateway while updating gateway: network is unreachable
root@sahara:~/weave#
```
Тут уже помощь клуба из IRC не помогла, пришлось выплывать самому.
Путем долгих проб и ошибок выяснилось, что корень зла крылся в присвоении статического IP адресв мосту weave при начальной конфигурации.
А именно. Ранее я поднимал мост такой записью в `/etc/network/interfaces.d/weave`:
```
auto weave
iface weave inet manual
pre-up /usr/local/bin/weave --local create-bridge
post-up ip addr add dev weave 10.4.7.1/16
pre-down ifconfig weave down
post-down brctl delbr weave
```
Как выяснилось, если убрать `ip add...`, то docker --bridge weave запускается и нормально работает.
Так же, для запуска weave в таком режиме требуется выключать FASTDP:
`export WEAVE_NO_FASTDP=1`
В итоге, релевантные части фалов настройки:
/etc/network/interfaces.d/weave:
```
auto weave
iface weave inet manual
pre-up WEAVE_NO_FASTDP=1 /usr/local/bin/weave --local create-bridge
pre-down ifconfig weave down
post-down brctl delbr weave
```
/etc/init/weave.conf:
```
start on filesystem and started docker
respawn
script
export DOCKER_BRIDGE=weave
export WEAVE_NO_FASTDP=1
/usr/local/bin/weave launch-router --no-dns --init-peer-count 8 --ipalloc-range 10.128.0.0/10 10.43.68.61 10.43.68.62 10.43.68.63 10.43.68.64 10.43.68.65 10.43.68.69 10.43.68.70
/usr/local/bin/weave expose 10.4.7.1/16
/usr/bin/docker attach weave
end script
```
/etc/default/docker:
```
DOCKER_NETWORK_OPTS="--bridge weave --fixed-cidr=10.4.7.0/24"
```
Теперь все работает как и раньше.
Возможно, этот опыт сэкономит кому-нибудь время и нервы. | https://habr.com/ru/post/270521/ | null | ru | null |
# Метод погруженной границы для чайников
> Отношение между «чистыми» и «прикладными математиками» основаны на доверии и понимании. «Чистые математики» не доверяют «прикладным математикам», а «прикладные математики» не понимают чистых математиков.
>
>
Некоторое время назад я столкнулся с тем, что не смог найти доступных материалов, в которых на великом и могучем описывался бы метод погруженной границы. Если в кратце, то это метод вычислительной гидродинамики, который позволяет расчитывать обтекание достаточно сложных по форме и динамике объектов. Так вот русскоязычных публикаций на эту тему было крайне недостаточно. «Не беда, будем читать работы зарубежных коллег» — подумалось мне. Но и тут ждал небольшой подвох — все имеющиеся материалы и публикации по этому методу были очень теоретичны, а мне (не уверен, возможно это не только моя особенность) обычно сложно сделать переход от теоретических выкладок к более-менее рабочему воплощению в коде. Поэтому для таких же несчастных, что и я (и с некоторой долей надежды на советы от умудренных опытом личностей) я решил сделать краткое описание этого метода и предложить самый простой способ его реализации.
Я буду рассматривать только оригинальный метод Пескина, т.к. на мой взгляд он проще, чем метод фиктивных ячеек (ghost-cells), метод усеченных ячеек (cut-cells) и все прочие их модификации.
Итак, википедия говорит нам, что «метод погруженной границы» (immersed boundary method) — это подход к моделированию взаимодействия между жидкостью и обтекаемым объектом (т.к. часто применяется для моделирования тонких волокон в биологических системах, то иногда используют термин «fiber»). И это чертовски верно =)
Основная особенность данного подхода заключается в том, что вводятся две раздельные сетки для расчета течения жидкости (в эйлеровых координатах) и для расчета параметров погруженной границы (тех самых волокон-фибр в лагранжевых координатах). Это позволяет использовать для расчета жидкости простые сетки и быстрые вычислительные методы, перенося всю сложность моделирования на этап взаимодействия с погруженной границей.
С чисто теоретической точки зрения, такой фокус проделывается с помощью добавления в уравнение Навье-Стокса силы воздействия погруженной границы на жидкость (точнее, плотности силы):
Эта сила некоторым некоторым образом вычисляется на основе расположения расчетных точек погруженной границы, и изменяет течение. Полная система уравнений выглядит так:
с краевыми условиями на погруженной границе, например, такого вида (условие прилипания aka «no-slip condition»):
В этой системе уравнений  — есть переменные, которые описывают течение жидкости в области  с координатами , а  — переменные, которые описывают состояние погруженной границы в области  с координатами .
Собственно, взаимодействие жидкости и границы скрыто в последних двух уравнениях.
Если рассматривать все это безобразие с точки зрения реализации, то алгоритм для каждого шага по времени будет примерно следующим:
* В каждой точке погруженной границы вычисляем силу напряжения, исходя из ее текущего состояния
* Распределяем по некоторому алгоритму полученную силу на точки жидкости
* Вычисляем параметры течения жидкости с учетом полученной силы
* Интеполируем скорость из точек жидкости на узлы погруженной границы (из-за граничных условий скорость движения границы должна совпадать со скоростью жидкости)
* Изменяем положение узлов границы в соответствии со скоростью
Как можно заметить, в алгоритме есть два неопределенных момента — ничего не говориться о том, как именно определять силу напряжения, а также как вычислять параметры течения жидкости. В этом кроется серьезный плюс данного подхода — эти методы могут быть практически любыми =) Но чтобы быть более близким к реализации, мне придется как минимум рассказать о том, как же вычислять напряжение на границе (второй метод и правда можно выбрать произвольно, лишь бы он был достаточно точен).
На самом деле, крутые парни находят силу, которая образуется на границе, с помощью функционала энергии и учитывают силу растяжения и силу изгиба. Но к моему сожалению, я сам еще совершенно не разобрался с этим моментом. Поэтому можно схитрить и использовать менее точный, но достаточный для расчета метод штрафов (penalty method). Его суть проста — чем дальше граница отклонилась от своего первоначального положения, тем больше возникающая сила. В итоге необходимо только посчитать отклонение и умножить его на некоторый коэффициент жесткости, с которым можно поэксмериментировать.
Вторым тонким моментом в алгоритме является дельта-функция, которая фигурировала в системе уравнений. Нам необходимо иметь ее численный вариант и, по-хорошему, это целая песня, т.к. вариантов ее дискретизации огромная туча. Но в данном случае можно положиться на опыт коллег, которые советуют использовать такую (для трехмерного случая аналогично):
Теперь вместо тысячи слов можно описать получившийся алгоритм в виде кода.
Расчет напряжения на узлах может выглядеть примерно так:
```
for(int n = 0; n < boundary->nodes_count; ++n) {
Node *node = &boundary->nodes[n];
// get_area возвращает площадь поверхности, которая относится к данной точке
node->x_force = -boundary->stiffness * (node->x - node->x_ref) * boundary->get_area();
node->y_force = -boundary->stiffness * (node->y - node->y_ref) * boundary->get_area();
node->z_force = -boundary->stiffness * (node->z - node->z_ref) * boundary->get_area();
}
```
Распределение силы на точки жидкости:
```
for(int n = 0; n < boundary->nodes_count; ++n) {
// для узла границы находим ближайшую расчетную точку жидкости
int x_int = index(boundary->nodes[n].x, COORD_X);
int y_int = index(boundary->nodes[n].y, COORD_Y);
int z_int = index(boundary->nodes[n].z, COORD_Z);
// т.к. в дискретном варианте дельта-функции ненулевыми являются те узлы,
// которые находятся в двух шагах по сетке, то необходимо распределить силу
// на несколько (по две в каждую сторону) точек жидкости
for(int i = x_int-1; i <= x_int + 2; ++i) {
for(int j = y_int-1; j <= y_int + 2; ++j) {
for(int k = z_int-1; k <= z_int + 2; ++k) {
// находим расстояние от узла границы до текущей точки жидкости
long double dist_x = fabs(boundary->nodes[n].x - coord(i, COORD_X));
long double dist_y = fabs(boundary->nodes[n].y - coord(j, COORD_Y));
long double dist_z = fabs(boundary->nodes[n].z - coord(k, COORD_Z));
long double weight_x = delta(dist_x, COORD_X);
long double weight_y = delta(dist_y, COORD_Y);
long double weight_z = delta(dist_z, COORD_Z);
// прибавляем полученную силу к данной точке жидкости
force_X[i][j][k] += (boundary->nodes[n].x_force * weight_x * weight_y * weight_z) * boundary->get_area();
force_Y[i][j][k] += (boundary->nodes[n].y_force * weight_x * weight_y * weight_z) * boundary->get_area();
force_Z[i][j][k] += (boundary->nodes[n].z_force * weight_x * weight_y * weight_z) * boundary->get_area();
}
}
}
```
Любым угодным методом производим расчет течения. Затем интерполируем скорость на узлы жидкости:
```
for(int n = 0; n < boundary->nodes_count; ++n)
{
// по аналогии с силой, находим ближайщую точку
int x_int = index(boundary->nodes[n].x, COORD_X);
int y_int = index(boundary->nodes[n].y, COORD_Y);
int z_int = index(boundary->nodes[n].z, COORD_Z);
// и собираем скорость с ближайших точек
for(int i = x_int-1; i <= x_int + 2; ++i)
{
for(int j = y_int-1; j <= y_int + 2; ++j)
{
for(int k = z_int-1; k <= z_int + 2; ++k)
{
long double dist_x = fabs(boundary->nodes[n].x - coord(i, COORD_X));
long double dist_y = fabs(boundary->nodes[n].y - coord(j, COORD_Y));
long double dist_z = fabs(boundary->nodes[n].z - coord(k, COORD_Z));
long double weight_x = delta(dist_x, COORD_X);
long double weight_y = delta(dist_y, COORD_Y);
long double weight_z = delta(dist_z, COORD_Z);
boundary->nodes[n].x_vel += (velocity_U[i][j][k] * weight_x * weight_y * weight_z) * CB(Hx[i]);
boundary->nodes[n].y_vel += (velocity_V[i][j][k] * weight_x * weight_y * weight_z) * CB(Hy[j]);
boundary->nodes[n].z_vel += (velocity_W[i][j][k] * weight_x * weight_y * weight_z) * CB(Hz[k]);
}
}
}
}
```
Обновляем координаты узлов погруженной границы:
```
for(int n = 0; n < boundary->nodes_count; ++n)
{
boundary->nodes[n].x += boundary->nodes[n].x_vel;
boundary->nodes[n].y += boundary->nodes[n].y_vel;
boundary->nodes[n].z += boundary->nodes[n].z_vel;
}
```
Собственно, все. В данном подходе предполагается, что граница является гибкой, однако при достаточно высокой жесткости (она и правда должна быть огромной, учтите в экспериментах) можно симулировать поведение твердой границы.
Отмечу, что на данный момент для расчета течения жидкости я использую метод неполной аппроксимации минимальных невязок, а также приближаю исходную нестационарную проблему серией стационарных расчетов. Это, конечно, не самый лучший вариант, и делать так не стоит — но тем не менее он работает.
Все, отдаю этот текст на растерзание. Принимаются все рационализаторские замечания и предложения, т.к. работа еще очень далека от идеала.
На закуску, несколько картинок с обтеканием сферы при достаточно высокой вязкости (и на достаточно грубой сетке).
 | https://habr.com/ru/post/210276/ | null | ru | null |
# Новое в Symfony 2.4: компонент ExpressionLanguage
В Symfony 2.4 появится новый компонент — **ExpressionLanguage**. Компонент является движком для компиляции и исполнения «выражений».
Этот язык является урезанной версией твига. Выражения укладываются в одну строку и обычно возвращают булево значения, но не ограничиваются этим.
В отличии от твига, ExpressionLanguage работает в двух режимах:
* Компиляция: выражение компилируется в PHP код для последующего исполнения (код не зависит от среды выполнения)
* Исполнение: выражение исполняется без предварительной компиляции
Чтобы было возможно компилировать выражения в PHP код, не нуждающийся в модификации во время выполнения, оператор `.` должен быть явным и означать лишь одно возможное поведение: `foo.bar` — для свойств объекта, `foo['bar']` для доступа к массиву, `foo.getBar()` для вызова методов.
Использование компонента просто на сколько это возможно:
```
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
$language = new ExpressionLanguage();
echo $language->evaluate('1 + 1');
// echo 2
echo $language->compile('1 + 2');
// echo "(1 + 2)"
```
Язык выражений поддерживает все то же что и твиг: математические операторы, строки, числа, массивы, хеши, булевы переменные… Выражения могут рассматриваться как очень ограниченная PHP-песочница, в которой невозможны внешние воздействия, все переменные должны быть объявлены заранее до компиляции или исполнения выражения.
```
$language->evaluate('a.b', array('a' => new stdClass()));
$language->compile('a.b', array('a'));
```
Последнее, но не по значению — вы можете легко расширить язык с помощью функций. Они работают точно также как их аналоги в твиге (для подробного ознакомления посмотрите метод `register()`)
Как на счет примеров использования? Мы встроили компонент во множество других компонентов, используемых в Symfony.
#### Контейнер сервисов (Service Container)
Вы можете использовать выражения в любом месте, где можно передать аргумент в контейнер:
```
$c->register('foo', 'Foo')->addArgument(new Expression('bar.getvalue()'));
```
В контейнере выражения дополняются двумя функциями: `service()`, чтобы получить сервис, и `parameter`, чтобы получить значение параметра:
```
service("bar").getValue(parameter("value"))
```
В XML:
```
service('bar').getvalue(parameter('value'))
```
Здесь нет никакого оверхеда во время исполнения, так как PHP-дампер компилирует выражения. Предыдущий пример скомпилируется в следующий PHP код:
```
$this->get("bar")->getvalue($this->getParameter("value"))
```
#### Правила доступа (Access Control Rules)
Настройка правил доступа может ввести в заблуждения, что может привести к [незащищенным приложения](http://symfony.com/blog/security-access-control-documentation-issue)
Новая директива `allow_if` упрощает настройку правил доступа в вашем приложении:
```
access_control:
- { path: ^/_internal/secure, allow_if: "'127.0.0.1' == request.getClientIp() or has_role('ROLE_ADMIN')" }
```
Это правило ограничивает пути, начинающиеся с `/_internal/secure` для пользователей зашедших не с `localhost` или не имеющих права администратора.
`request`, `token` и `user` — переменные, к которым у вас есть доступ, `is_anonymous()`, `is_authenticated()`, `is_fully_authenticated()`, `is_rememberme()`, `and has_role()` — функции доступные в выражениях при настройке правил доступа.
#### Twig
Вы также можете использовать выражения в ваших шаблонах, с помощью функции `expression`
```
{% if is_granted(expression('has_role("FOO")')) %}
...
{% endif %}
```
Если вы используете **SensioFrameworkExtraBundle**, у вас также есть возможность обезопасить контроллеры, с аннотацией `@ Security`
```
/**
* @Route("/post/{id}")
* @Security("has_role('ROLE_ADMIN')")
*/
public function showAction(Post $post)
{
}
```
***Примечание**: Аннотация `@ Security` будет частью 3 версии бандла, который выйдет перед Symfony 2.4*
#### Кеширование
В третьей версии **SensioFrameworkExtraBundle** также будет доступна аннотация `@Cache`, которая дает доступ к HTTP кешированию. Вместо написания шаблонного кода снова и снова в простых ситуациях:
```
/**
* @Route("/post/{id}")
* @Cache(smaxage="15")
*/
public function showAction(Request $request, Post $post)
{
$response = new Response();
$response->setLastModified($post->getUpdated());
if ($response->isNotModified($request)) {
return $response;
}
// ...
}
```
Вы можете настроить все в аннотации (это также работает для ETag):
```
/**
* @Route("/post/{id}")
* @Cache(smaxage="15", lastModified="post.getUpdatedAt()")
*/
public function showAction(Post $post)
{
// ...
}
```
#### Маршрутизация (Routing)
Из коробки Symfony может выбрать роут по предопределенным переменным (таким как `info`, `method`, `sheme`), но некоторым нужна более сложная логика, базирующаяся на информации из запроса (объект `Request`)
Чтобы покрыть эти специальные случаи, вы можете использовать дериктиву `condition`, которая позволяет добавить любое выражение использующее переменные `request` и routing `context`:
```
hello:
path: /hello/{name}
condition: "context.getMethod() in ['GET', 'HEAD'] and request.headers.get('User-Agent') =~ '/firefox/i'"
```
И опять таки, используя PHP дампер правил маршрутизации (URL matcher), нет никакого оверхеда, так как все выражения компилируются в PHP код:
```
// hello
if (0 === strpos($pathinfo, '/hello') && preg_match('#^/hello/(?P[^/]++)$#s', $pathinfo, $matches)
&& (in\_array($context->getMethod(), array(0 => "GET", 1 => "HEAD"))
&& preg\_match("/firefox/i", $request->headers->get("User-Agent")))
) {
return $this->mergeDefaults(array\_replace($matches, array('\_route' => 'hello')), array ());
}
```
**Имейте ввиду, что эти условия не будут никак использоваться при генерации URL**
#### Validation
Новое условие `Expression` позволяет использовать выражения для валидации:
```
use Symfony\Component\Validator\Constraints as Assert;
/**
* @Assert\Expression("this.getFoo() == 'fo'", message="Not good!")
*/
class Obj
{
public function getFoo()
{
return 'foo';
}
}
```
В выражениях валидатора `this` ссылается на текущий объект валидации.
#### Движок бизнес-правил (Business Rule Engine)
Кроме того используя компонент в самом фреймворке язык выражений отличный кандидат для создания движка бизнесс-правил. Идея в том, что вебмастер (администратор) сайта может гибко настроить сайт, без использования PHP и без посвещения себя в проблемы безопасности:
```
# Get the special price if
user.getGroup() in ['good_customers', 'collaborator']
# Promote article to the homepage when
article.commentCount > 100 and article.category not in ["misc"]
# Send an alert when
product.stock < 15
```
Вот и последний пост, в котором я рассматриваю новые возможности Symfony 2.4. В течении нескольких дней будет доступна первая пред-релизная версия (release candidate).
*Чувствую что не всем приглянется подобное использование PHP, но прошу учесть что я переводчик, статьи, а не создатель этого компонента и пока сам не разобрался нравится он мне или нет (особенно поразило зачем выражения встроили в твиг).
Все замечания и пожелания пожалуйста в личку* | https://habr.com/ru/post/202058/ | null | ru | null |
# Редактор Urho3D (часть 2)
[Продолжаем](http://habrahabr.ru/post/265749/) постигать редактор Urho3D. В этом уроке мы научимся работать с физикой, познакомимся с префабами, освоим редактор частиц и заставим нашу пушку стрелять. А также, в качестве бонуса, научимся упаковывать ресурсы игры.
**Более актуальная версия этой и других статей находится на ГитХабе: [github.com/urho3d-learn/editor](https://github.com/urho3d-learn/editor)**
Физика
------
Urho3D поддерживает две физические библиотеки: Box2D и Bullet. Принципы работы с ними очень похожи, однако первая реализует перемещение нод только в плоскости XY, а вторая в трёхмерном пространстве. Компоненты Box2D находятся в меню Create->Component->Urho2D, а Bullet — в меню Create->Component->Physics.
Итак, загрузите сцену GameData\Scenes\Level01.xml из [прошлого](http://habrahabr.ru/post/265749/) урока (File->Open recent scene или File->Open scene...). У нас есть пол и пушка. Давайте добавим в сцену пушечное ядро. В браузере ресурсов (Resource Browser) откройте папку Models и перетащите Cannonball.mdl в окно Hierarchy на корневую ноду Scene. Чтобы пушка и пол не мешали работе, в окне Hierarchy щелкните по их нодам правой кнопкой мыши и выберите Enable/disable. При этом они исчезнут со сцены, а ноды будут окрашены в красный цвет. Теперь дважды щелкните по ноде с ядром и оно (ядро) окажется в центре экрана.
Теперь в браузере ресурсов откройте папку Materials и перетащите материал на компонент StaticModel в окне Hierarchy или в графу Material окна Attribute inspector. Задайте ноде имя и включите опцию Cast Shadows.
Добавьте к пушечному ядру компоненты RigidBody и CollisionShape (Create->Component->Physics). При этом к сцене будет автоматически добавлен компонент PhysicsWorld, который необходим для работы физики.
RigidBody определяет физические свойства объекта. Тела бывают статические и динамические. Статические тела неподвижны и являются лишь препятствиями, а динамические подвержены воздействию внешних сил (гравитации в том числе). Если у тела есть масса — оно динамическое, если масса равна нулю, то тело статическое.
Задайте для RigidBody массу, трение скольжения и трение качения как на скриншоте ниже. Хочу обратить ваше внимание на параметры CCD Radius и CCD Motion Threshold. Если небольшие объекты на большой скорости проскакивают сквозь преграды, то настройка этих параметров вам поможет.
CollisionShape определяет форму объекта, которая используется при расчете столкновений. Почему не использовать саму 3D-модель? В целях оптимизации. Например, чтобы определить пересечение со сферой, достаточно сравнить расстояние до центра сферы и радиус этой сферы. Это гораздо быстрее, чем вычислять пересечения множества треугольников. Объект может содержать несколько шейпов для более точного описания формы.
Выберите для компонента CollisionShape тип Sphere и установите радиус близким к радиусу пушечного ядра, как на скриншоте выше.
Убедитесь, что переключатель RevertOnPause активирован и нажмите кнопку RunUpdatePlay. Пушечное ядро под действием гравитации начнет падать вниз. Нажмите паузу и ядро вернется на место.
Префабы
-------
Тем, кто работал с Unity, будет знакомо это понятие. Префаб — это шаблон объекта, который можно многократно вставлять в сцену. Создайте папку Objects в каталоге GameData. Выделите ноду Cannonball, выберите пункт меню File->Save node as… и сохраните в файл GameData/Objects/Cannonball.xml. Теперь пушечное ядро можно удалить со сцены. Для добавления префабов в сцену используйте пункт меню File->Load node.
Пушка, стреляй!
---------------
Включите ноды пушки и пола, чтобы их было видно. Создайте для них компоненты RigidBody и CollisionShape. Для пола выберите тип шейпа StaticPlane (бесконечная плоскость) и задайте ему (полу) трение скольжения и трение качения равными единице (иначе тела по нему будут двигаться бесконечно, так как при контакте объектов их коэффициенты трения перемножаются). Для пушки выберите тип шейпа Capsule и задайте шейпу (не ноде) размер Size = (2, 4.3, 1) и смещение Offset Position = (0, 1.12, 0). Для пушки также добавьте компонент AnimationController (Create->Component->Logic), который позволит нам проигрывать созданную в 3D-редакторе анимацию выстрела.
**Теперь модифицируем скрипт пушки GameData\Scripts\Cannon.as (нажмите, чтобы раскрыть).**
```
class Cannon : ScriptObject
{
// Положительное или отрицательное направление вращения пушки.
int direction = 1;
// Задержка до следующего выстрела.
float shootDelay = 0.0f;
// Функция вызывается каждый кадр.
void Update(float timeStep)
{
// Угол поворота вокруг оси x (node указывает на ноду, к которой прикреплен скрипт).
float pitch = node.rotation.pitch;
// Меняем направление вращения, если значение угла выходит за заданные пределы.
if (pitch >= 70.0f)
direction = -1;
else if (pitch <= -10.0f)
direction = 1;
pitch += 30.0f * direction * timeStep;
node.rotation = Quaternion(pitch, 0.0f, 0.0f);
if (shootDelay > 0.0f)
shootDelay -= timeStep;
// Если нажат пробел и прошло достаточно времени с предыдущего выстрела,
if (input.keyDown[KEY_SPACE] && shootDelay <= 0.0f)
{
Shoot(); // то стреляем
shootDelay = 1.0f; // и вновь устанавливаем задержку в одну секунду.
AnimationController@ animCtrl = node.GetComponent("AnimationController");
animCtrl.SetTime("Models/Shoot.ani", 0.0f); // Перематываем анимацию в начало.
animCtrl.PlayExclusive("Models/Shoot.ani", 0, false, 0.0f); // Запускаем анимацию пушки.
SoundSource3D@ source = node.CreateComponent("SoundSource3D"); // Создаем источник звука.
Sound@ sound = cache.GetResource("Sound", "Sounds/Shoot.wav");
source.autoRemove = true; // Источник звука будет автоматически уничтожен после проигрывания.
source.Play(sound);
}
}
void Shoot()
{
// Определяем позицию кости CannonballPlace у пушки.
Vector3 position = node.GetChild("CannonballPlace", true).worldPosition;
// Добавляем в сцену префаб.
XMLFile@ xml = cache.GetResource("XMLFile", "Objects/Cannonball.xml");
Node@ newNode = scene.InstantiateXML(xml, position, Quaternion());
// Находим компонент RigidBody.
RigidBody@ body = newNode.GetComponent("RigidBody");
// Изначально у пушечного ядра уже будет импульс, так как ядро частично пересекается с пушкой
// и стремится оттолкнуться от него. Но нам нужен импульс побольше.
body.ApplyImpulse(node.rotation * Vector3(0.0f, 1.0f, 0.0f) * 15.0f);
}
}
```
Запускаем и наслаждаемся тем, как при нажатии пробела пушка надувается и изрыгает ядра.
Давайте сделаем так, чтобы ядра после десяти секунд своего существования самоуничтожались. Создайте в папке GameData\Scripts файл CannonBall.as с текстом:
```
class Dying : ScriptObject
{
float time = 0.0f;
void Update(float timeStep)
{
time += timeStep;
if (time > 10.0f)
node.Remove();
}
}
```
Затем загрузите префаб GameData/Objects/Cannonball.xml в сцену (File->Load node->As replicated/local...), добавьте к нему компонент ScriptInstance, укажите новосозданный файл и введите имя класса Dying (не забудьте нажать Enter). Теперь префаб можно сохранить и удалить со сцены. Запустите и посмотрите, как ядра исчезают.
Заячий городок
--------------
Добавим в сцену постройку из кубов, которую мы будем обстреливать из пушки. Как обычно, перетащите модель GameData/Models/Cube.mdl на корневую ноду Scene и задайте ей материал GameData/Materials/Cube.xml. Также включите опцию Cast Shadows. Добавьте компонент RigidBody (Mass = 1, Friction = 1, Rolling Friction = 0.2) и компонент CollisionShape (Shape Type = Box, Size = (2, 2, 2)). Разместите куб немного над землей (если вы его погрузите в землю, он будет выпрыгивать при запуске). Нажмите Ctrl+D для дублирования куба и сдвиньте копию вбок. Создайте еще одну копию.
Кстати, вы обратили внимание, что в окне Attribute inspector все значения, которые отличаются от дефолтных, помечены золотистым цветом?
Теперь выделите весь ряд кубов с зажатой кнопкой Ctrl и продублируйте его целиком. Поднимите копию над первым рядом (не забывайте про зазоры). Затем создайте еще один ряд.
Запустите. У нас возникла такая проблема, что после запуска кубы немного опускаются вниз, но вручную с большой точностью водрузить их друг на друга сложно. И тут нам на помощь придет переключатель RevertOnPause. Выключите его, а также отключите компонент ScriptInstance у пушки (так же, как мы ранее выключали ноды целиком, только теперь щёлкайте правой кнопкой мыши не по ноде, а по компоненту; другой способ для этого — нажать крестик в окне Attribute inspector).
Теперь запустите проигрывание, а когда кубы упадут — остановите. Сцена осталась в новом состоянии. Не забудьте снова включить RevertOnPause и ScriptInstance.
Частицы
-------
Создадим для пушечных ядер шлейф из частиц. Откройте редактор частиц через пункт меню View->Particle editor. Задайте следующие параметры:
* Direction (min) = (-0.1, -0.1, -0.1)
* Direction (max) = (0.1, 0.1, 0.1) — эти два значения определяют скорость разлета частиц в разных направлениях (для каждой частицы выбирается случайное значение в заданном диапазоне)
* Particle Size (min) = Particle Size (max) = (0.3, 0.3) — стартовый размер частиц у всех одинаковый
* Size Add = -0.8 — со временем размер частиц уменьшается
* Number of Particles = 1000 — максимальное число одновременно существующих частиц
* Emission Rate (min) = Emission Rate (max) = 80 — частота испускания частиц
* Relative Transform = Выкл. — чтобы частицы перемещались в мировых координатах, независимо от родительской ноды
Теперь добавим для частиц изменение цвета со временем. Нажмите два раза на кнопку New под блоком Color Frames, чтобы создать две новые строки и заполните поля как на скриншоте снизу. Первое значение — время, а дальше цвет в формате RGBA.
Нажмите на кнопку Save As, сохраните эффект в файл GameData\Particle\Sparks.xml и закройте окно редактора частиц. Загрузите префаб с пушечным ядром в сцену, добавьте к нему компонент ParticleEmitter (Create->Component->Geometry), укажите новосозданный эффект, сохраните префаб в файл и удалите пушечное ядро со сцены. Игра готова.
Что дальше?
-----------
Мы рассмотрели не все возможности редактора. Например, не было сказано ни слова про создание интерфейса или про редактор материалов. Однако, понимая общие принципы, разобраться с ними не составит никакого труда.
Теперь нужно оформить игру в виде отдельной программы. План очень простой: создаем минимальный скрипт, который загружает и запускает сцену. Но в сцене не хватает камеры, а используется внутренняя камера редактора, которая будет недоступна вне его. Как обычно, создайте новую ноду и добавьте к ней компонент Camera (Create->Component->Scene). Обязательно задайте ноде имя Camera, чтобы мы могли к ней обратиться в нашем скрипте. Расположите и поверните камеру как вам больше нравится (в этом вам поможет вид из камеры, который появляется в правом нижнем углу). Также к ноде с камерой прикрепите компонент SoundListener (Create->Component->Audio), без которого вы не услышите позиционируемых в пространстве звуков. Сохраните сцену и создайте файл GameData\Scripts\Main.as со следующим содержимым:
```
Scene@ scene_;
void Start()
{
scene_ = Scene();
// Загружаем сцену из файла.
scene_.LoadXML(cache.GetFile("Scenes/Level01.xml"));
// Находим в сцене ноду с камерой.
Node@ cameraNode = scene_.GetChild("Camera");
// Указываем движку, что мы хотим смотреть через эту камеру.
Viewport@ viewport = Viewport(scene_, cameraNode.GetComponent("Camera"));
renderer.viewports[0] = viewport;
// Задаем большой размер теневых карт, чтобы они были более четкие.
renderer.shadowMapSize = 2048;
// Указываем движку приемник звука, через который мы хотим слушать.
audio.listener = cameraNode.GetComponent("SoundListener");
}
```
Скопируйте папку CoreData и лаунчер Urho3DPlayer.exe в папку с игрой. А пакетный файл для запуска Start.bat у нас уже есть (из архива Urho3DHabrahabr02Start.zip). Он указывает лаунчеру папки, в которых содержатся ресурсы игры, размеры окна и стартовый скрипт.
```
start "" Urho3DPlayer.exe Scripts/Main.as -p "GameData;CoreData" -w -x 800 -y 600
```
Итоговый результат можно скачать [тут](https://github.com/1vanK/Urho3DHabrahabr02).
Обещанный бонус
---------------
Для начала скомпилируем все скрипты командой «ScriptCompiler.exe GameData/Scripts/\*.as». В результате получаем файлы с расширениями .asc. Недавно был добавлен [патч](https://github.com/urho3d/Urho3D/issues/864/), благодаря которому при отсутствии запрашиваемого .as файла загружается .asc файл, а значит теперь не нужно заниматься переименованиями. Просто переместите исходные .as файлы из папки GameData\Scripts в другое место, оставив только .asc файлы.
Для упаковки нам понадобится утилита Build\bin\tool\PackageTool.exe. Выполните команды:
```
PackageTool.exe CoreData CoreData.pak -c
PackageTool.exe GameData GameData.pak -c
```
Параметр "-c" активирует сжатие файлов (используется скоростной алгоритм [LZ4](https://en.wikipedia.org/wiki/LZ4_%28compression_algorithm%29)).
Теперь папки CoreData и GameData можно убрать. В результате имеем:
Ну и чтобы было совсем красиво, можно избавиться от пакетного файла Start.bat. Но для этого нужно модифицировать исходный код лаунчера (он в папке Urho3D\Source\Tools\Urho3DPlayer). Не стоит пугаться заранее — исходник лаунчера очень маленький, ведь он занимается только тем, что передает параметры запуска в движок. Вот эти параметры вам и нужно указать. Заодно можно и свой значок для приложения сделать.
Вместо заключения
-----------------
Пользуясь случаем, приглашаю желающих присоединиться к наполнению [русскоязычной Wiki](http://ru.urho3d.wikia.com). Спасибо за внимание! | https://habr.com/ru/post/265837/ | null | ru | null |
# Как мы суслика яблоками кормили или эффективный backend на Go для iOS
Как и обещал, рассказываю о том, как мы мигрировали свой бэкенд на Go и смогли уменьшить объем бизнес логики на клиенте более, чем на треть.
**Для кого**: небольшим компаниям, Go и мобильным разработчикам, а также всем, кто в тренде или просто интересуется данной тематикой.
**О чем**: причины перехода на Go, с какими сложностями столкнулись, а также инструкции и советы по улучшению архитектуры мобильного приложения и его бэкенда.
**Уровень**: junior и middle.
Долгое время наша команда мобильной аутсорс разработки работала над сторонними проектами, у которых были свои бэкенд разработчики, а мы выступали в роли подрядчика для конкретного продукта. Несмотря на то, что в договоренностях всегда было четко оговорено, что именно мы, как мобильные девелоперы, диктуем музыку и API, далеко не всегда это помогало.
Настолько не всегда, что недавно я сделал небольшой сборник травмирующих душу ситуаций, который выложил в одной из своих прошлых статей.
Так получилось, что у нас тогда в команде был довольно сильный Java(Spring) разработчик, и мы решили каждому новому заказчику твердо объявлять: мы сами пишем бэкенд, либо ищите кого-нибудь другого. Поначалу боялись, что такая принципиальная позиция будет отпугивать, а мы в итоге останемся голыми на хлебе и воде. Но как оказалось, что если мы уже понравились кому-то на этапе переговоров и с нами хотят работать, то практически обо всем можно договориться. Даже когда у клиента в команде уже есть свои люди, которых он изначально планировал задействовать. Тогда-то мы узнали такое умное слово как микросервисы, и что можно делать отдельный сервак с бизнес логикой, выполняющий задачи строго для мобильного приложения. Не буду спорить, что такой подход не везде уместен, но речь дальше пойдет не об этом.
Причины перехода на Go
----------------------
После нескольких успешных проектов Java оказалась слишком тяжелой для нас. Много времени уходило на рутину, чтобы сделать все максимально удобно для приложения.
Не хочу сказать ничего плохого о Spring и Java в целом, это удивительный инструмент под серьезные задачи, как огромный толстопузый испанский галеон. А мы искали что-то больше похожее на легковесный пиратский клипер.
Нам надо было быстро внедрять фичи, легко их менять и не греть голову в поисках самого оптимального решения в каждой ситуации. Знаете, как это бывает, когда долго гуглишь на предмет типового решения твоей задачи, чтобы оно было наиболее подходящим, потом оказывается, что из 10 из них 5 уже устарели. А потом еще тратишь полчаса на выбор названия для переменной.
У Go такой проблемы нет. От слова совсем. Иногда даже через слишком: сидишь, ищешь идеальное решение, а StackOverflow тебе на это отвечает: 'Ну да, просто циклом for, а ты чего ждал?'
Со временем к этому привыкаешь и перестаешь гуглить всякие мелочи по пустякам, а начинаешь включать голову и просто писать код.
Какие возникли сложности
------------------------
Начнем с того, что там нет наследования. Поначалу это просто выносило мозг. Приходится ломать все свое представление об ООП и привыкать к [утиной типизации](https://ru.wikipedia.org/wiki/%D0%A3%D1%82%D0%B8%D0%BD%D0%B0%D1%8F_%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F). Формулируя простыми словами: если это выглядит как утка, плавает как утка и крякает как утка, то это, возможно, и есть утка.
По сути, есть только интерфейсное наследование.
А во-вторых, из существенных минусов, — малое количество готовых инструментов, но зато много багов. Многие вещи нельзя сделать привычным способом, а кое-что вообще отсутствует как класс. Например, нет нормального фреймворка для IoC ([инверсия зависимостей](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B8_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B5%D0%B9)). Опытные гоферы скажут, что есть либа от Facebook. Но может я просто не умею ее готовить, либо все-таки ее удобство на самом деле оставляет желать лучшего. Оно просто не может сравниться со Spring и потому приходится много работать руками.
Еще из небольших ограничений Go в целом, например, нельзя сделать API вида:
```
/cards/:id
/cards/something
```
Так как для существующего http роутера — это взаимоисключающие запросы. Он путается между wildcard переменной и конкретным адресом something. Глупое ограничение, но приходится с этим жить. Если же кто-то знает решение, то буду рад услышать.
Также отсутствует hibernate или более менее адекватные аналоги. Да, есть множество ORM, но все они пока довольно слабые. Лучшее, что я встретил за время разработки на Go — это [gorm](http://jinzhu.me/gorm/). Ее главное преимущество — это удобнейший маппинг ответа от базы в структуру. А запросы придется писать на голом sql, если не хотите провести долгие часы за отладкой сомнительного поведения.
**P.S**. Хочу отдельно поделиться workaround-ом, который возник в процессе работы с этой либой. Если вам нужно записать id после insert в какую-то переменную с помощью gorm, а не в структуру как обычно, то поможет следующий костыль. На уровне запроса переименовываем результат returning на любой другой, отличный от id:
```
... returning id as value
```
С последующим сканом в переменную:
```
... Row().Scan(&variable)
```
Оказывается, дело в том, что поле 'id' воспринимается gorm-ом как конкретное поле объекта. И чтобы развязаться, нужно на уровне запроса ее переименовать во что-нибудь другое.
Плюсы или почему мы все-таки пишем на Go
----------------------------------------
Хочется начать с порога вхождения: он минимален. Вспоминая какой скрежет вызывал в освоении тот же Spring, то Go, по сравнению с ним, можно преподавать в младших классах, настолько он прост.
И эта простота заключается не только в языке, но и в окружении, которое он за собой несет. Вам не нужно читать долгие маны по gradle и maven, не потребуется писать длиннющие конфиги, чтобы все хотя бы просто один раз запустилось. Здесь все обходится парой команд, а достойный сборщик и профилировщик уже является частью языка и не требует глубокого исследования для старта.
Как говорится: easy to learn, hard to master. Это то, чего мне всегда лично не хватало в современных технологиях: их как будто делают не для людей.
Из этого же следует скорость разработки. Язык был сделан для одной цели:
По сути, это backend язык для бизнеса. Он быстр, он прост и позволяет решать сложные задачи понятными способами. Насчет сложных задач и понятности — это отдельная тема для разговора, потому что в Go есть такая классная вещь как горутинки и каналы. Это удобнейшая многопоточность с минимальной возможностью для выстрела себе в ногу.
Архитектура
===========
Web
---
В качестве web framework остановили свой выбор на [Gin](https://github.com/gin-gonic/gin). Есть еще [Revel](https://revel.github.io/), но нам он показался слишком узким и непоколебимо диктующим свою парадигму. Мы же предпочитаем чуть больше развязанные руки, чтобы можно было быть гибкими.
Gin соблазнил удобным API и отсутствием лишних сложностей. Порог вхождения у него просто приторно низкий. Настолько, что стажеры разбирались в нем буквально за день. Там просто негде запутаться. Весь нужный функционал как на ладони.
Конечно, и он не без проблем. Некоторые решения, например, кэш, сделаны третьей стороной. И происходит конфликт импортов, если вы у себя привыкли использовать import через github, а у них сделано через gopkg и наоборот. В итоге два плагина могут быть просто взаимоисключающими.
Если кто-то знает решение этой проблемы, то напишите, пожалуйста, в комментариях.
Менеджер зависимостей
---------------------
Долго писать не буду, а сразу скажу, что это без сомнений [Glide](https://github.com/Masterminds/glide). Если вы работали с gradle или maven, то вам наверняка знакома парадигма объявлений зависимостей в неком файле с последующим их задействованием по необходимости. Так вот Glide — это хомячий Gradle, с решением конфликтов и прочими плюшками.
Кстати, если у вас возникнут проблемы при тестировании, когда go test лезет в папку vendor, жадно тестируя каждую либу, то проблема решается элементарно:
```
go test $(glide novendor)
```
Этот параметр исключает папку vendor из тестирования. В сам репозиторий достаточно положить glide.yaml и glide.lock файлы.
Мобильной разработке это все никак не поможет, но просто, чтобы вы знали)
ORM и Realm
-----------
Это будет объемный раздел о передаче и хранении данных с бэкенда на клиент. Начнем с Go, плавно переходя на мобильную платформу.
**А что такое Realm и чем он лучше CoreData/Массивов/SQLite?**Если вы никогда не сталкивались с Realm и не понимаете о чем речь, то правильно раскрыли спойлер.
Realm — это мобильная база, которая облегчает работу с синхронизацией данных на протяжении всего приложения. В ней нет таких проблем как в CoreData, где постоянно приходится работать в контекстах, даже когда объект еще никуда не сохранен. Легче соблюдать консистентность.
Достаточно просто создать сущность и работать с ней как с обычным объектом, передавая между потоками и жонглируя ею как душе угодно.
Множество операций она делает за вас, но, конечно, и у нее есть косяки: отсутствует не привязанный к регистру поиск, в целом поиск не доделан нормально, потребляет памяти как не в себя (особенно на android), отсутствует группировка как в FRC, и так далее.
Мы посчитали, что стоит мириться с этими проблемами и оно того стоит.
Чтобы не повторяться, коротко скажу, что мы в качестве orm используем [Gorm](http://jinzhu.me/gorm/) и дам пару рекомендаций:
* Пишите SQL запросы руками, не ленитесь. Заодно выучите SQL, если еще этого не сделали.
* Старайтесь делать запросы в рамках одной транзакции, по возможности.
* Выбирайте из базы минимум необходимых вам полей.
* Обязательно маппите все в структуры. Чем меньше промежуточных переменных, тем лучше.
Наверное, это все применимо к любой технологии, тут я немного скапитанил, но все же. Лишний раз напомнить не повредит, это важно.
Теперь, что касается мобильного приложения. Ваша основная задача — сделать так, чтобы поля, возвращаемые в запросах, имели одинаковые названия с соответствующими им на клиенте. Этого можно легко добиться с помощью так называемых тегов:
Убедитесь, что тег json имеет правильное название. И желательно, чтобы у него был установлен флаг omitempty, как в примере. Это позволяет избежать захламления ответа пустующими полями.
**Почему Go?**У вас может справедливо возникнуть вопрос: при чем тут вообще Go, если одинаковые названия можно сделать в любом языке? И будете правы, но одним из преимуществ Go является легчайшее форматирование чего угодно через рефлексию и структуры. Пусть рефлексия есть во многих языках, но в Go с ней работать проще всего.
Кстати, если вам нужно спрятать из ответа пустую структуру, то наилучший способ — это перегрузить метод MarshalJSON у структуры:
```
// Допустим, надо скрыть пустое поле Pharmacy у объекта Object
func (r Object) MarshalJSON() ([]byte, error) {
type Alias Object
var pharmacy *Pharmacy = nil
// Если id != 0, то используем значение. Если нет - ставим nil
if r.Pharmacy.ID != 0 {
pharmacy = &r.Pharmacy
}
return json.Marshal(&struct {
Pharmacy *Pharmacy `json:"pharmacy,omitempty"`
Alias
}{
Pharmacy: pharmacy,
Alias: (Alias)(r),
})
}
```
Многие не заморачиваются и сразу пишут в структурах указатель вместо значения, но это не Go way. Go вообще не любит указатели там, где они не нужны. Это лишает его возможности оптимизировать ваш код и использовать весь свой потенциал.
Кроме названий полей еще обратите внимание на их типы. Числа должны быть числами, а строки строками (спасибо, кэп). В том, что касается дат, то удобнее всего использовать RFC3339. На сервере дату можно отформатировать также через перегрузку:
```
func (c *Comment) MarshalJSON() ([]byte, error) {
type Alias Comment
return json.Marshal(&struct {
CreatedAt string `json:"createdAt"`
*Alias
}{
CreatedAt: c.CreatedAt.Format(time.RFC3339),
Alias: (*Alias)(c),
})
}
```
А на клиенте это делается через форматирование даты по следующему шаблону:
```
"yyyy-MM-dd'T'HH:mm:ssZ"
```
Еще одним преимуществом RFC3339 является то, что он выступает форматом даты по умолчанию для Swagger. И сама по себе отформатированная таким образом дата, довольно читаема для человека, особенно по сравнению с posix time.
На клиенте же (пример для iOS, но на Android аналогично), при идеальном совпадении названий всех полей и отношений класса, сохранение можно сделать одним генерик методом:
```
func save(dictionary: [String : AnyObject]) -> Promise{
return Promise {fulfill, reject in
let realm = Realm.instance
// Если у вас есть дата в словаре, то здесь надо ее отформатировать перед записью.
// Так как реалм не умеет сохранять дату в виде строго.
try! realm.write {
realm.create(T.self, value: dictionary, update: true)
}
fulfill()
}
}
```
Для массивов ситуация аналогичная, но сохранение придется гонять уже в цикле. Часто неопытные разработчики допускают ошибку и заворачивают в цикл целиком блок записи:
```
array.forEach { object in
try! realm.write {
realm.create(T.self, value: object, update: true)
}
}
```
Что просто в корне неверно, потому что так вы открываете новую транзакцию на каждый объект, вместо того, чтобы сохранить все скопом. А если у вас подключены еще уведомления для обновлений, то все становится еще 'веселее'. Правильнее сделать следующим образом, вынося транзакцию на уровень выше:
```
try! realm.write {
array.forEach { object in
realm.create(T.self, value: object, update: true)
}
}
```
Как вы могли заметить, у нас полностью отвалился промежуточный слой, отвечающий за маппинг. Когда данные достаточно подготовлены, их можно сразу лупить в базу без дополнительной обработки. И чем лучше у вас бэкенд, тем меньше этой дополнительной обработки потребуется. В идеале только дату сконвертировать в объект. Все остальное должно быть сделано заранее.
Кстати, немного отходя от темы. Если вам не нужно иметь персистентную базу данных на клиенте, то это не повод отказываться от Realm. Он позволяет работать с собой строго в оперативной памяти, сбрасывая свое наполнение по первому требованию.
→ Ссылки для [iOS](https://realm.io/docs/swift/latest/#in-memory-realms) и [Android](https://realm.io/docs/java/latest/#in-memory-realm).
Такой подход позволяет использовать все преимущества реактивной базы данных и вышеописанный маппинг.
Еще хочу добавить для особо внимательных к мелочам: здесь нет утверждения, что Go — это единственно верное решение и панацея для мобильной разработки. Каждый может решать эту задачу по-своему. Мы выбрали этот путь.
Структура Go проекта
--------------------
Сейчас пойдет много кода для Go разработчиков. Если вы мобильный девелопер, то можете свободно пролистать к следующему разделу.
Теперь мы подошли к самому интересному, если вы Go разработчик. Допустим, вы пишите бэкенд для некоего типового приложения: у вас есть слой с REST API, некая бизнес логика, модель, логика работы с базой данных, утилиты, скрипты миграции и конфиг с ресурсами. Вам как-то все это надо увязать у себя в проекте по классам и папочкам, соблюсти принципы **SOLID** и, желательно, не сойти с ума при этом.
Пока накидаем абстрактно, не погружаясь слишком глубоко, но так, чтобы была понятна общая структура. Если будет интересно, то посвящу этому полноценный отдельный материал. Все-таки сейчас речь идет о мобильном приложении в связке с Go.
Сразу оговорюсь, что не претендую на догматичность своих высказываний, каждый волен работать в своем проекте как считает нужным.
Начнем со скриншота нашей структуры:
(До чего милые в Intellij Idea хомячки, не правда ли? Каждый раз умиляюсь)
В неразвернутых директориях содержатся сразу Go файлы, либо файлы ресурсов. Проще говоря, все раскрыто так, чтобы видеть максимальное погружение.
В этой статьей расскажу только о том, что отвечает за бизнес логику: api, сервисы, работа с базой и как все это зависит друг от друга. Если вы, уважаемая публика, проявите интерес к этой теме, то потом распишу и остальное, потому как информации там слишком много для одной статьи.
Итак, по порядку:
**Web**
В вебе хранится все, что отвечает за обработку запросов: байндеры, фильтры и контроллеры — а вся их спайка происходит в *api.go*. Пример такого склеивания:
```
regions := r.Group("/regions")
regions.GET("/list", Cache.Gin, rc.List)
regions.GET("/list/active", Cache.Gin, regionController.ListActive)
regions.GET("", binders.Coordinates, regionController.RegionByCoord)
```
Там же происходит инициализация контроллеров и инъекция зависимостей. По сути весь *api.go* файл состоит из метода Run, где формируется и стартуется роутер, и кучи вспомогательных методов по созданию контроллеров со всеми зависимостями и их групп.
**Web.Binders**
В папке *binders* располагаются биндеры, которые парсят параметры из запросов, конвертируют в удобный формат и закидывают в контекст для дальнейшей работы.
Пример метода из этого пакета. Он берет параметр из query, конвертирует в bool и кладет в контекст:
```
func OpenNow(c *gin.Context) {
openNow, _ := strconv.ParseBool(c.Query(BindingOpenNow))
c.Set(BindingOpenNow, openNow)
}
```
Самый простой вариант без обработки ошибок. Просто для наглядности.
**Web.Controllers**
Обычно на уровне контроллеров делают больше всего ошибок: напихают лишней логики, забудут про интерфейсы и изоляцию, а потом вообще скатятся к функциональному программированию. Вообще в Go контроллеры страдают от той же болезни, что и в iOS: их постоянно перенагружают. Поэтому сразу определим, какие задачи они должны выполнять:
* получать параметры запроса;
* вызывать соответствующий метод сервиса;
* отправлять ответ об успехе или ошибке с изменением форматирования по необходимости.
Необходимость — это, например, когда сервис логично возвращает числом id некоего объекта, нет ничего криминального в том, что контроллер обернет его в map перед отправкой:
```
c.IndentedJSON(http.StatusCreated, gin.H { "identifier": m.ID })
```
Возьмем какой-нибудь пример типового контроллера.
Класс, если опускать импорты, начинается с интерфейса контроллера. Да-да, соблюдаем букву 'D' в слове SOLID, даже если у вас всегда будет только одна реализация. Это значительно облегчает тестирование, давая возможность подменять сам контроллер на его mock:
```
type Order interface {
PlaceOrder(c *gin.Context)
AroundWithPrices(c *gin.Context)
}
```
Далее у нас идет сама структура контроллера и его конструктор, принимающий в себя зависимости, который мы будем вызывать при создании контроллера в *api.go*:
```
// С маленькой буквы, чтобы наружу ничего не вываливалось
type order struct {
service services.Order
}
func NewOrder(service services.Order) Order {
return ℴ {
service: service,
}
}
```
И, наконец, метод, обрабатывающий запрос. Так как мы успешно прошли слой с биндингом, то можем быть уверены, что все параметры у нас гарантировано есть и мы можем получить их с помощью MustGet, не боясь панических атак:
```
func (o order)PlaceOrder(c *gin.Context) {
m := c.MustGet(BindingOrder).(*model.Order)
o.service.PlaceOrder(m)
c.IndentedJSON(http.StatusCreated, gin.H {
"identifier": m.ID,
})
}
```
С опциональными параметрами та же история, но только на уровне биндера стоит заложить некое нулевое значение, которое вы будете проверять в контроллере, подставляя в него дефолтное при отсутствии, или просто игнорируя.
**Services**
Ситуация с сервисами во многом идентична, они так же начинаются с интерфейса, структуры и конструктора с последующим набором методов. Акцент хочется сделать на одной детали — это принцип работы с базой.
Конструктор сервиса должен принимать в себя набор репозиториев, с которыми он будет работать, и фабрику транзакций:
```
func NewOrder(repo repositories.Order, txFactory TransactionFactory) Order {
return ℴ { repo: repo, txFactory: txFactory }
}
```
Фабрика транзакций — это просто класс, генерирующий транзакции, здесь ничего сложного:
```
type TransactionFactory interface {
BeginNewTransaction() Transaction
}
```
**Полный код фабрики для gorm**
```
type TransactionFactory interface {
BeginNewTransaction() Transaction
}
type transactionFactory struct {
db *gorm.DB
}
func NewTransactionFactory(db *gorm.DB) TransactionFactory {
return &transactionFactory{db: db}
}
func (t transactionFactory)BeginNewTransaction() Transaction {
tx := new(transaction)
tx.db = t.db
tx.Begin()
return tx
}
```
А вот на самих транзакциях остановиться стоит. Начнем с того, что это вообще такое. Транзакция представляет из себя тот же интерфейс с реализацией, который содержит методы для старта транзакции, завершения, отката и доступа к реализации движка уровнем ниже:
```
type Transaction interface {
Begin()
Commit()
Rollback()
DataSource() interface{}
}
```
**Полный код транзакции для gorm**
```
type Transaction interface {
Begin()
Commit()
Rollback()
DataSource() interface{}
}
type transaction struct {
Transaction
db *gorm.DB
tx *gorm.DB
}
func (t *transaction)Begin() {
t.tx = t.db.Begin()
}
func (t *transaction)Commit() {
t.tx.Commit()
}
func (t *transaction)Rollback() {
t.tx.Rollback()
}
func (t *transaction)DataSource() interface{} {
return t.tx
}
```
Если с [begin](https://postgrespro.ru/docs/postgresql/9.6/sql-begin.html), [commit](https://postgrespro.ru/docs/postgresql/9.6/sql-commit.html), [rollback](https://postgrespro.ru/docs/postgresql/9.6/sql-rollback.html) все должно быть понятно, то Datasource — это просто костыль для доступа к низкоуровневой реализации, потому что работа с любой БД в Go устроена так, что транзакция является просто копией акссессора к базе со своими измененными настройками. Он нам понадобится позже при работе в репозиториях.
Собственно, вот и пример работы с транзакциями в методе сервиса:
```
func (o order)PlaceOrder(m *model.Order) {
tx := o.txFactory.BeginNewTransaction()
defer tx.Commit()
o.repo.Insert(tx, m)
}
```
Начали транзакцию, выполнили доступ к базе, закоммитили или откатили, как больше нравится.
Конечно, все преимущество транзакций особенно раскрывается при нескольких операциях, но и даже если у вас всего одна, как в примере, хуже от этого не будет.
**Экспертам**Знаю, что нет управления уровнями изоляции.
Если нашли еще какие косяки — пишите в комментах.
В качестве дополнительного совета юниорам, хочу сказать, что транзакция должна быть открыта минимально возможное время. Постарайтесь подготовить все данные так, чтобы на период между begin и commit приходилось минимальное количество логики и вычислений.
Бывает, что транзакцию открывают и идут курить, отправляя, например запрос в гугл. А потом удивляются, почему это с дедлоком зафакапилось все.
> *Интересный факт*
>
> Во многих современных базах данных, [deadlock](https://ru.wikipedia.org/wiki/%D0%92%D0%B7%D0%B0%D0%B8%D0%BC%D0%BD%D0%B0%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0) определяется максимально просто: по таймауту. При большой нагрузке сканировать ресурсы на предмет определения блокировки — дорого. Поэтому часто вместо этого используется обычный таймаут. Например, в [mysql](https://dev.mysql.com/doc/refman/5.7/en/innodb-parameters.html#sysvar_innodb_lock_wait_timeout). Если не знать эту особенность, то можно подарить себе чудеснейшие часы веселой отладки.
**Repositories**
Тоже самое: интерфейс, структура, конструктор, который, как правило, уже без параметров.
Просто приведу пример операции Insert, которую мы вызывали в коде сервиса:
```
func (order)Insert(tx Transaction, m *model.Order) {
db := tx.DataSource().(*gorm.DB)
query := "insert into orders (shop_id) values (?) returning id"
db.Raw(query, m.Shop.ID).Scan(m)
}
```
Получили из транзакции низкоуровневый модификатор доступа, составили запрос, выполнили его. Готово.
Всего этого вполне должно хватить, чтобы не угробить архитектуру. По крайней мере слишком быстро. Если возникли вопросы или возражения, то пишите в комментариях, буду рад обсудить.
Приложение
----------
Ладно, суслики это мило, но как теперь с этим работать на клиенте?
Начнем, как и в случае с Go, с нашего стека. Вообще, мы активно используем реактив практически везде, но сейчас расскажу про более щадящий вариант архитектуры, чтобы так сразу не травмировать ничью психику.
### Стек
**Сетевой слой**:
[Alamofire](https://github.com/Alamofire/Alamofire) для Swift проектов и [AFNetworking](https://github.com/AFNetworking/AFNetworking) для Objective-C.
Кстати, а вы знали, что Alamofire — это и есть AFNetworking? Префикс *AF* значит Alamofire, в чем можно убедиться, заглянув в лицензию AFNetworking:
**Замыкания**:
Многие в качестве callback-ов для бизнес логики передают в параметры запросов блоки для успеха/провала или лепят один на все. В итоге в параметрах каждого метода бизнес логики висит толстенное замыкание или даже не одно, что не сказывается положительно на читаемости проекта. Иногда блок отдают в качестве возвращаемого значения, что тоже неудобно.
Есть такая замечательная вещь как промисы. Реализация iOS: [PromiseKit](https://github.com/mxcl/PromiseKit). Простыми словами — вместо кучи блоков, передаваемых в метод, вы возвращаете объект, который потом можно развернуть не только в success/failure замыкания, но еще и некий always, вызывающийся всегда, независимо от успеха/провала метода. Их также можно чередовать, объединять и делать множество приятных вещей.
Как по мне, так ключевое преимущество — это именно последовательное применение. Можно разделить flow бизнес логики на маленькие операции, вызываемые друг за другом. В итоге, например, метод получения детализации для некого товара, будет выглядеть так:
```
func details(id: Int) -> Promise {
return getDetails(id)
.then(execute: parse)
.then(execute: save)
}
```
А так внутренний метод getDetails, просто делающий запрос на конкретный адрес:
```
func getDetails(id: Int) -> Promise> {
return Promise { fulfill, reject in
Alamofire.request(NetworkRouter.drugDetails(id: id)).responseJSON { fulfill($0) }
}
}
```
**Парсинг и сохранение**Не самый чистый код, но для копипасты подойдет. Прячу под кат, потому что код реально трэш. Постараюсь обновить, когда руки дойдут. Уже даже стыдно за легаси, кочующий из проекта в проект.
```
func parseAsDictionary(response: DataResponse) -> Promise<[String:AnyObject]> {
return Promise {fulfill, reject in
switch response.result {
case .success(let value):
let json = value as! [String : AnyObject]
guard response.response!.statusCode < 400 else {
let error = Error(dictionary: json)
reject(error)
return
}
fulfill(json)
break
case .failure(let nserror):
let error = Error(error: nserror as NSError)
reject(error)
break
}
}
}
// Выше этот метод уже был, но продублриюу
func save(items: [[String : AnyObject]]) -> Promise {
return Promise {fulfill, reject in
let realm = Realm.instance
try! realm.write {
items.forEach { item in
// Замените на свой класс или сделайте generic
realm.create(Item.self, value: item, update: true)
}
}
fulfill(items.count)
}
}
```
А в самом контроллере, если вы используете MVC, все максимально просто:
```
_ = service.details().then {[weak self] array -> Void in
// Success. Do w/e you like.
}
```
**База данных**
Вопрос про хранение данных описывал выше, когда говорил про работу с ORM на Go-side, поэтому повторяться не буду, только добавлю [ссылку](https://realm.io/docs/swift/latest/#notifications) на то как получать уведомления об обновлениях базы в том же контроллере. По сути если в БД что-то добавилось, то контроллер асинхронно об этом узнает. Это гораздо удобнее, чем каждый раз мучиться с подсчетом datasource при каждом малейшем движении. А если еще и эти изменения могут произойти не только из одного места, то вообще швах.
Сюда перетаскивать кусок кода из [гайда](https://realm.io/docs/swift/latest/#notifications) по fine-grained notifications не буду, дабы не плодить копипасту.
**Для extra-ленивых**
```
class ViewController: UITableViewController {
var notificationToken: NotificationToken? = nil
override func viewDidLoad() {
super.viewDidLoad()
let realm = try! Realm()
let results = realm.objects(Person.self).filter("age > 5")
// Observe Results Notifications
notificationToken = results.addNotificationBlock { [weak self] (changes: RealmCollectionChange) in
guard let tableView = self?.tableView else { return }
switch changes {
case .initial:
// Results are now populated and can be accessed without blocking the UI
tableView.reloadData()
break
case .update(_, let deletions, let insertions, let modifications):
// Query results have changed, so apply them to the UITableView
tableView.beginUpdates()
tableView.insertRows(at: insertions.map({ IndexPath(row: $0, section: 0) }),
with: .automatic)
tableView.deleteRows(at: deletions.map({ IndexPath(row: $0, section: 0)}),
with: .automatic)
tableView.reloadRows(at: modifications.map({ IndexPath(row: $0, section: 0) }),
with: .automatic)
tableView.endUpdates()
break
case .error(let error):
// An error occurred while opening the Realm file on the background worker thread
fatalError("\(error)")
break
}
}
}
deinit {
notificationToken?.stop()
}
}
```
### Взаимодействие внутри проекта
Многие разработчики болеют гигантоманией, которая вызывает у них желание запихнуть всю бизнес логику в один файл с названием *ApiManager.swift*. Или есть более латентные формы, когда этот файл делят на много других, где каждый — это extension от ApiManager, что на самом деле совсем не лучше.
Получается перегруженный божественный класс и к тому же singleton, отвечающий просто за все. Я сам раньше так работал, когда занимался мелкими приложениями, но на крупном проекте это здорово аукнулось.
Лечится это с помощью SOA (service oriented architecture). Есть отличное [видео от Rambler](https://www.youtube.com/watch?v=Eman1j06YsU), где подробнейшим образом разбирается, что это такое и с чем его едят, но я постараюсь на пальцах дать инструкцию по внедрению в проект.
Вместо одного менеджера делаем несколько сервисов. Каждый сервис — это отдельный класс без состояния с набором методов по вышеописанному принципу. Сервисы также могут вызывать друг друга, это нормально. А чтобы использовать сервис в контроллере, то просто передаете ему нужный объект в конструкторе или создаете во viewDidLoad. Конечно, второй вариант хуже, но для начала сойдет. Иногда бывает, что прямо здесь и сейчас надо срочно подключить еще один сервис в контроллер, а разгребать всю эту цепочку зависимостей, проверять каждое место, где контроллер используется, нет никакого желания.
Пример таких сервисов в одном из проектов:
Где в каждом сервисе находится ограниченный набор методов, за которые он отвечает и с которыми работает. Желательно, чтобы сервис не превышал 200-300 строк. Если он перевалил за этот объем, то значит бедняга выполняет совсем не одну задачу, которая ему предназначена.
В итоге, вся ваша логика на клиенте сводится к следующему: запрос на сервер, парсинг в контейнер и сохранение в базу. Все, никаких промежуточных действий.
Заключение
----------
Подытожу. Хорошо подготовленные данные на бэкенде в связке с Realm-ом на mobile-side дают возможность практически целиком отказаться от дополнительной бизнес логики на клиенте, сводя все к работе с интерфейсом. Можно не согласиться, но по-моему, так и должно быть. Ведь любой клиент, пусть даже и такой классный как iOS или Android, — это в первую очередь вью вашего продукта!
А перед тем как закончить, хотелось бы поделиться наболевшим. Многие в комментариях к моим статьям выказывают недовольство, что я рассказываю очевидные вещи и вообще капитаню, а кое-кто даже не стесняется минус в карму зарядить за это.
Но вот что я хочу сказать. Своей работой я стараюсь подтянуть общий уровень разработчиков в сообществе.
Вы можете сказать, что это чересчур смело. Но знаете, как становится грустно, когда на собеседование приходит человек, считающий себя классным специалистом или, по крайней мере, сильным мидлом, но при этом даже не знающий простейших вещей? Который путается между MVP и MVVM и похоже, что вообще разрабатывает интуитивно.
Из серии, когда заглядываешь человеку в код, видишь там несуразную лютую жесть и спрашиваешь его: “Вася, почему ты так сделал?” А он отвечает: “Хз, иначе не работало.”
Про архитектуру даже не заикаюсь.
Что ж, надеюсь, было полезно. И как всегда, буду рад услышать любые вопросы, критику и предложения.
**P.S.** Прикладываю опрос. Стоит ли делать в будущих статьях титульную информацию с кратким сюжетом и целевой аудиторией? Нигде такого не видел, но мне кажется, могло бы быть полезно. Да, есть тэги, но они, на мой взгляд, недостаточно заметны и не раскрывают сути. | https://habr.com/ru/post/331456/ | null | ru | null |
# Прокачиваем навыки отладки JavaScript с помощью консольных трюков
Перед вами перевод статьи из блога Better Programming на сайте Medium.com. Автор, [Indrek Lasn](https://twitter.com/lasnindrek), рассказывает об инструментах для отладки кода, которые предоставляет JavaScript.
Обычная отладка JavaScript-кода заключается в выводе результатов с помощью метода `console.log`. Однако, хоть этот способ и работает, его трудно назвать оптимальным. Почему бы тогда не сделать отладку более удобной?
Объект `console` обеспечивает доступ к консоли отладки браузера. Его можно использовать только в том случае, если JavaScript-код запускается в браузере (т. е. это код клиентской части, а не серверной). Реализация `console` может отличаться от браузера к браузеру, но, как правило, какой-то базовый функционал есть всегда. Лучшее в отладочных операторах — их способность работать со всеми библиотеками и фреймворками (за счет того, что они вшиты в ядро языка).
Самый простой пример использования `console.log` — вывод кода. Для примера возьмем следующий код:
```
function sayHello(name) {
console.log(name)
}
sayHello('Indrek')
```
Он выводит имя, которое передается в функцию `sayHello`.
*Вывод имени, переданного в функцию*
А если нам хочется узнать, сколько раз была вызвана функция `sayHello`? Ничего сложного. Используем для этого `console.count()`.
### console.count
Функция `count()` выводит количество вызовов с заданным параметром `label`. Если `label` не указан, то отображается количество вызовов с параметром по умолчанию.
```
function sayHello(name) {
console.count()
console.log(name)
}
sayHello("Indrek")
sayHello("William")
sayHello("Kelly")
```
Код выше выводит следующее:
*Подсчет количества вызовов функции sayHello*
Таким образом мы можем узнать общее количество вызовов функции. А если нужно узнать количество вызовов функции с одним и тем же именем? Это просто — достаточно передать аргумент `name` в метод `count`.
```
function sayHello(name) {
console.count(name)
}
sayHello("Indrek")
sayHello("William")
sayHello("Kelly")
sayHello("Indrek")
```
Вуаля! Данная функция отслеживает, сколько раз мы вызвали функцию с тем или иным именем.
*Подсчет количества упоминаний каждого имени*
### console.warn
Этот метод выводит в консоли предупреждение — полезно, когда используешь API или инструменты разработки. `console.warn` всегда может показать, что что-то идет не так: пропущен аргумент, устарела версия API и пр.
```
function sayHello(name) {
if(!name) {
console.warn("No name given")
}
}
sayHello()
```
Данный код проверяет, был ли передан функции аргумент `name`. Если этого не произошло, в консоли выводится предупреждение.
*Предупреждение о том, что имя не передано*
### console.table
При работе с массивами и объектами, когда дело доходит до отображения данных, весьма полезным оказывается метод `console.table`. Благодаря ему для каждого элемента в таблице отводится отдельная строка.
Давайте рассмотрим работу этого метода на примере с массивом фруктов. Если мы передадим массив в `console.table`, то увидим следующее:
```
const fruits = ["kiwi", "banana", "strawberry"]
console.table(fruits)
```
А если взглянем на консоль, то увидим таблицу, описывающую наш массив.
*Массив, представленный в виде таблицы*
Вообразите, насколько это полезно, если работать приходится с массивами из сотен, а то и тысяч значений. Давайте рассмотрим другой пример — теперь в нашем массиве будет заключено уже больше значений.
```
const fruits = [
"Apple",
"Watermelon",
"Orange",
"Pear",
"Cherry",
"Strawberry",
"Nectarine",
"Grape",
"Mango",
"Blueberry",
"Pomegranate",
"Carambola",
"Plum",
"Banana",
"Raspberry",
"Mandarin",
"Jackfruit",
"Papaya",
"Kiwi",
"Pineapple",
"Lime",
"Lemon",
"Apricot",
"Grapefruit",
"Melon",
"Coconut",
"Avocado",
"Peach"
];
console.table(fruits);
```
Вызвав `console.table`, мы увидим следующую таблицу:
*Все фрукты отображаются в виде таблицы*
Работать с массивами просто. Но что делать, если вместо массивов — объекты?
```
const pets = {
name: "Simon",
type: "cat"
};
console.table(pets);
```
Итак, вместо массива у нас теперь объект, который содержит два ключа: `name` (имя) и `type` (тип) питомца.
Прежде таблица выводила только значения, но теперь в ней представлены значения и ключи. А если взять еще один объект и попытаться внести его в таблицу?
```
const pets = {
name: "Simon",
type: "cat"
};
const person = {
firstName: "Indrek",
lastName: "Lasn"
}
console.table(pets, person);
```
Как и ожидалось, два отдельных объекта отображаются в двух разных таблицах.
*Два объекта*
Поскольку нам нужно объединить их в одной таблице, поместим оба объекта в массив.
```
const pets = {
name: "Simon",
type: "cat"
};
const person = {
firstName: "Indrek",
lastName: "Lasn"
}
console.table([pets, person]);
```
Теперь группируем объекты внутри таблицы.
*Группируем объекты, поместив их в массив*
### console.group
При работе с сетами или связанными данными можно использовать вложенные группы. Это удобно, поскольку позволяет выводить в консоль визуально связанные сообщения. Для создания новой вложенной группы нужно вызвать `console.group()`.
```
console.log("This is the first level");
console.group();
console.log("Level 2");
console.group();
console.log("Level 3");
console.warn("More of level 3");
console.groupEnd();
console.log("Back to level 2");
console.groupEnd();
console.log("Back to the first level");
```
Данный код выводит в консоль вложенные блоки с информацией. Это может быть полезно при работе с данными, представленными в табличном виде.
Метод `console.groupCollapsed()` работает похожим образом, однако новый блок по умолчанию свернут. Чтобы прочесть его, нужно нажать на кнопку развертывания.
### Заключение
Используйте все инструменты, которые предоставляет тот или иной язык программирования. Если в этом есть смысл — просто пробуйте! И небольшое примечание: я посвятил внутреннему отладчику JavaScript отдельную статью, которую можно прочитать [тут](https://medium.com/better-programming/how-to-find-bugs-in-your-code-with-the-debugger-a7f739ea98).
Если вы новичок в JavaScript и хотите изучать этот язык, рекомендую начать с чтения книг и параллельного написания небольших программ. Очень полезен будет учебник [«A Smarter Way to Learn JavaScript»](https://www.amazon.com/Smarter-Way-Learn-JavaScript-technology-ebook/dp/B00H1W9I6C/ref=as_li_ss_tl?keywords=javascript&qid=1564573678&s=gateway&sr=8-2&linkCode=sl1&tag=thegeniusde07-20&linkId=5acbe5c31239ae23b8119d9247c6c5ad&language=en_US), а вот [тут](https://medium.com/better-programming/the-secret-to-being-a-top-developer-is-building-things-heres-a-list-of-fun-apps-to-build-aac61ac0736c) есть список идей для написания забавных приложений.
Спасибо, что прочитали! | https://habr.com/ru/post/468189/ | null | ru | null |
# Начало работы с OpenCV и его применение в C#
Хочу немного рассказать про технологию OpenCV и её применение на языке программирования C#.
OpenCV (англ. Open Source Computer Vision Library, библиотека компьютерного зрения с открытым исходным кодом) — библиотека алгоритмов компьютерного зрения, обработки изображений и численных алгоритмов общего назначения с открытым кодом. Реализована на C/C++, также разрабатывается для Python, Java, Ruby, Matlab, Lua и других языков. Может свободно использоваться в академических и коммерческих целях — распространяется в условиях лицензии BSD.
На эту библиотеку я натолкнулся буквально недавно. На сайте [toster.ru](https://toster.ru/) я задал вопрос про необычные темы для дипломных работ и в одном из ответов получил ссылки на результат работы с этой библиотекой. Вот некоторые из них:
[www.youtube.com/watch?v=h9kPI7\_vhAU](https://www.youtube.com/watch?v=h9kPI7_vhAU)
[www.youtube.com/watch?v=256bg5\_vNvg](https://www.youtube.com/watch?v=256bg5_vNvg)
[www.youtube.com/watch?v=PUhwGTSNGhI](https://www.youtube.com/watch?v=PUhwGTSNGhI)
Для начала работы надо будет скачать нужные нам файлы с сайта [www.emgu.com/wiki/index.php/Main\_Page](http://www.emgu.com/wiki/index.php/Main_Page).
Emgu CV является кросс-платформенным .Net дополнением для библиотеки OpenCV для обработки изображений. Разработано для работы с .NET совместимыми языками, такими как C #, VB, VC ++, IronPython и т.д., может быть использовано в Visual Studio, Xamarin, работает с Windows, Linux, Mac OS X, IOS, Android и Windows Phone.
После того, как мы скачали и установили актуальную версию, можно приступать к работе. В данном примере мы будем находить и распознавать лицо и глаза человека.
Для этого нам понадобятся уже готовые xml-файлы, в которых содержится вся необходимая нам информация. Как было сказано, OpenCV является Open Source проектом, так что при желании можно найти множество уже готовых решений.
Для работы подключим соответствующие библиотеки:
```
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using Emgu.CV.Cvb;
```
Для начала нам потребуется создать экземпляр класса Capture:
```
Capture capture = new Capture();
```
Этот объект будет отвечать за перехват видео потока.
Для создания объекта, который распознает наше лицо или глаза, мы будем использовать замечательный класс HaarCascade. Классификатор (а именно каскад форсированных классификаторов, работающих с Хаара-подобными функциями) обучается с несколькими сотнями образцов видов конкретного объекта (например, лицо или автомобиль), называет положительные примеры, которые масштабируются в тот же размер (скажем, 20х20), и отрицательные примеры — произвольные изображения одного и того же размера.
То есть при создании экземпляра класса HaarCascade в его конструкторе мы указываем ссылку на xml файл, который содержит нужные нам данные.
```
//for face
HaarCascade faceCascade = new HaarCascade("haarcascade_frontalface_alt.xml");
//for eye
HaarCascade eyeCascade = new HaarCascade("haarcascade_eye.xml");
```
Для того, что бы работать дальше с перехваченным кадром, надо использовать метод QueryFrame().
```
Image image = capture.QueryFrame();
```
Мы получаем наш кадр, которые нам передает наше устройство (веб-камера). Далее найденное нами изображение переводим в серый цвет.
```
Image grayImage = image.Convert();
```
Теперь надо найти атрибуты, которые принадлежат нашему лицу и глазам.
```
var Face = grayImage.DetectHaarCascade(faceCascade)[0];
foreach (var face in Face)
{
//Если таковы найдены, то рисуем вокруг них круг, с заданным цветом и толщиной линии.
image.Draw(face.rect, new Bgr(255, 255, 255), 10);
}
//Аналогично и для глаз
var Eye = grayImage.DetectHaarCascade(eyeCascade)[0];
foreach (var eye in Eye)
{
image.Draw(eye.rect, new Bgr(0, 0, 255), 3);
}
```
Ну вот почти и все, остается только куда-то вывести полученное нами изображение. Для этого будем использовать элемент управления imageBox (его надо добавить в ручную).
```
imageBoxEyeAndFaceDetector.Image = image;
```
Теперь мы можем задать работу нашего когда в нужном нам месте, например, при нажатии кнопки.
```
Application.Idle += Method;
```
Ссылка для скачивания xml файлов: [ifolder.com.ua/z3fihkcet19n.html](http://ifolder.com.ua/z3fihkcet19n.html)
Так же советую просмотреть это видео для общего понимания работы машинного зрения [www.youtube.com/watch?v=TyEfJyJA7gQ](https://www.youtube.com/watch?v=TyEfJyJA7gQ).
Удачи вам в вашей работе.
#### Ссылки
[www.emgu.com/wiki/index.php/Main\_Page](http://www.emgu.com/wiki/index.php/Main_Page)
[ru.wikipedia.org/wiki/OpenCV](https://ru.wikipedia.org/wiki/OpenCV)
[devnuances.com](http://devnuances.com/) | https://habr.com/ru/post/260741/ | null | ru | null |
# Git for Windows: работа с параметром core.autocrlf
Я работаю в операционной системе «Windows 10». У меня на компьютере [установлена](https://ilyachalov.livejournal.com/237666.html) программа «Git for Windows» версии 2.35.1. В принципе, «Git for Windows» — это та же знаменитая программа (набор программ) «Git» (система управления версиями), только скомпилированная из исходного кода в исполняемый файл, который может запускаться в операционных системах «Windows» (изначально исходный код «Git» был написан для компиляции в исполняемый файл, запускаемый в операционной системе «Linux»).
Дистрибутив «Git for Windows» кроме программы «Git» содержит разные полезные для работы с «Git» программы, вроде программы-оболочки «Git Bash» с интерфейсом командной строки и программы «Git GUI» с графическим оконным интерфейсом. В [документации сказано](https://github.com/git-for-windows/git/wiki/Technical-overview), что «Git for Windows» является подмножеством платформы (набора инструментов и библиотек) «[MSYS2](https://en.wikipedia.org/wiki/Mingw-w64#MSYS2)». Как я понимаю, для компиляции используется компилятор из набора инструментов «[MinGW-w64](https://en.wikipedia.org/wiki/Mingw-w64)».
Окончания строк в разных операционных системах
----------------------------------------------
Как известно (возможно, не всем), в операционных системах «Windows» окончание строки обычно представляется двумя символами, в таблице Юникода они обозначены кодами U+000D (возврат каретки, по-английски «Carriage Return», сокращенно «CR») и U+000A (подача бумаги на следующую строку, по-английски «Line Feed», сокращенно «LF»). В мир компьютеров эти управляющие коды пришли из мира печатных (пишущих) машинок.
В Unix-подобных операционных системах окончание строки обычно представляется одним символом «LF». (Говорят, в операционных системах от компании «Apple» до появления операционной системы «Mac OS X», которая вышла в 2001 году, окончание строки представлялось одним символом «CR». Сейчас в операционных системах «macOS» окончание строки представляется одним символом «LF», как и в других Unix-подобных операционных системах.)
Из-за того, что большинство текстовых редакторов (даже заточенных под написание текстов программ) плохо умеет работать с окончаниями строк разного вида, вышеописанная разница приносит проблемы, если над одним и тем же проектом работают программисты из разных операционных систем.
Я подготовил для экспериментов текстовый файл, содержащий несколько строк с окончаниями разного вида. Для работы с кодом я обычно использую программы «VS Code» и «Notepad++». Обе эти программы могут правильно отображать строки с окончаниями разного вида. Однако, программа «VS Code» не отображает отдельные символы, входящие в окончания строк, поэтому в ней [не получается понять](https://ilyachalov.livejournal.com/258806.html), где и какое окончание строки использовано. Для просмотра и определения видов окончаний строк я обычно использую программу «Notepad++», она умеет отображать отдельные символы, входящие в окончания строк. Вот как у меня на компьютере выглядит в программе «Notepad++» тестовый файл «myfile.txt» (включено отображение всех символов, то есть и тех, которые обычно не отображаются в текстовых редакторах):
На иллюстрации выше видно, что две строки имеют окончания в виде пары символов CR и LF (эту пару символов часто обозначают как «CRLF»), а другие две строки — в виде LF. В программе «Notepad++» у меня не получилось создать разные виды окончаний строк в одном и том же файле (хотя можно скопировать и вставить существующие с помощью инструмента специальной вставки), поэтому я сначала ввел текст файла в программе «Notepad++» с одинаковыми окончаниями строк, а потом подправил два из этих окончаний строк в шестнадцатеричном (двоичном) редакторе. Кодировка файла «myfile.txt» — UTF-8 (как видно на иллюстрации, размер файла — 222 байта, русские буквы занимают по два байта).
Также на иллюстрации выше видно, что в строке состояния программы «Notepad++» режим работы с окончаниями строк показан как «Windows (CR LF)». Этот режим не влияет на отображение символов только что открытого файла. Он лишь говорит о том, что при вставке нового окончания строки (нажатием клавиши «Enter») будет вставлено окончание строки вида CRLF. Этот режим можно переключить на «Unix (LF)» или на «Macintosh (CR)», после чего можно будет клавишей «Enter» вставлять окончания строк вида LF или CR. Однако, переключение этого режима не дает возможности работать в одном файле одновременно с несколькими видами окончаний строк, так как при переключении этого режима меняются *сразу все* окончания строк в файле на выбранный в режиме вид окончаний строк.
Тестовый файл «myfile.txt» я разместил в папке `C:\Users\Илья\source\repos\test\`. Пока он в этой папке один. Будем считать эту папку папкой нашего проекта.
Создание Git-репозитория и параметр «core.autocrlf»
---------------------------------------------------
С программой «Git» можно работать множеством способов, но я предпочитаю самый универсальный — из командной строки. Для этого я обычно использую программу-оболочку «PowerShell» версии 7, а запускаю ее в программе-«эмуляторе терминала» «Windows Terminal». Итак, проверим, что программа «Git» установлена на компьютере и доступна в папке нашего проекта:
```
PS C:\Users\Илья\source\repos\test> git --version
git version 2.35.1.windows.2
```
Создадим Git-репозиторий для нашего проекта:
```
PS C:\Users\Илья\source\repos\test> git init
Initialized empty Git repository in C:/Users/Илья/source/repos/test/.git/
```
«Репозиторием» обычно называют папку (хранилище, базу данных), в которой хранится исходный код программы (папку проекта). А «Git-репозиторием» называют базу данных, в которой хранятся разные версии файлов нашего проекта, информация о них и об изменениях, вносимых в эти файлы. Сама программа (система программ) «Git» у меня установлена в папке `C:\Program Files\Git\`. Чтобы обеспечить управление версиями файлов нашего проекта, в папке нашего проекта с помощью вышеприведенной команды была создана скрытая папка «.git» (у меня в программе «Проводник Windows» включено отображение скрытых папок, поэтому ее там видно), в которой хранятся база данных с версиями файлов нашего проекта и разные служебные файлы.
Сразу после создания папки «.git» в ней уже есть файлы базы данных и разные служебные файлы. Но пока что эта база данных пуста (пока еще не содержит версий файлов нашего проекта). Чтобы файлы нашего проекта попали под отслеживание в них изменений от программы «Git», они должны быть добавлены в базу данных в папке «.git» посредством коммитов («коммит» — это операция регистрации изменений в файлах проекта).
Настройка работы программы «Git» [может быть произведена](https://ilyachalov.livejournal.com/238338.html) на трех разных уровнях: на уровне операционной системы (для всех ее пользователей), на уровне отдельного пользователя (global) и на уровне проекта (local). При установке программы «Git» программа-установщик обычно задает умолчательные настройки на уровне текущего пользователя операционной системы. В рамках данного поста мы затронем только настройки на уровне текущего проекта, они хранятся в файле `\.git\config` (этот файл не имеет расширения) текущего проекта. Этот файл был создан в результате вышеприведенной команды «git init», он — текстовый, но нет нужды редактировать его вручную, для этого есть отдельная команда «git config».
Если какой-либо параметр не определен в вышеупомянутом файле настроек текущего проекта, то значение этого параметра будет автоматически взято из файла настроек текущего пользователя операционной системы. Для чистоты эксперимента мы будем прямо прописывать нужное значение нужного параметра в файле настроек текущего проекта с помощью следующей команды:
```
PS C:\Users\Илья\source\repos\test> git config --local core.autocrlf true
```
Как работает параметр «core.autocrlf» мы проверим экспериментально, после чего станет понятно, для чего этот параметр можно использовать.
### 1. Параметр «core.autocrlf», значение «true»
Итак, с помощью команды, приведенной выше, мы установили для параметра «core.autocrlf» значение «true». Совершим первый коммит, в который включим текущую версию нашего тестового файла «myfile.txt»:
```
PS C:\Users\Илья\source\repos\test> git add "myfile.txt"
warning: LF will be replaced by CRLF in myfile.txt.
The file will have its original line endings in your working directory
PS C:\Users\Илья\source\repos\test> git commit -m "Первый коммит"
[master (root-commit) 4d71045] Первый коммит
1 file changed, 4 insertions(+)
create mode 100644 myfile.txt
```
В блоке кода выше приведены сразу две команды подряд. Команда «git add» формирует список содержимого будущего коммита. Когда содержимое коммита сформировано, делаем сам коммит (регистрацию изменений в коде программы в базе данных в папке «.git» нашего проекта) с помощью команды «git commit».
Два сообщения, выданные после первой команды в блоке кода выше, могут запутать неопытного пользователя. Первое сообщает о том, что окончания строк вида LF будут заменены окончаниями строк вида CRLF в нашем тестовом файле «myfile.txt». Второе сообщает, что версия файла «myfile.txt», находящаяся в папке проекта, сохранит окончания строк в оригинальном виде. На первый взгляд, эти сообщения противоречат друг другу. Путаница возникает из-за того, что в обоих сообщениях употреблено будущее время, но не уточняется, что события, о которых идет речь, хоть и произойдут в будущем, но произойдут НЕ одновременно.
На самом деле, во втором сообщении имеется в виду, что оригинальные окончания строк в файле «myfile.txt» останутся нетронутыми работой запущенной команды «git add». А первое сообщение предупреждает о том, что в будущем, после извлечения версии файла «myfile.txt» из базы данных в папку проекта, окончания строк вида LF будут затерты окончаниями строк CRLF из-за текущего значения настройки «core.autocrlf».
Проверим это на практике. После окончания работы двух команд, показанных в блоке кода выше, я заглянул в файл «myfile.txt», находящийся в папке проекта (в терминах программы «Git» ее называют «рабочей папкой» [working directory], так как именно тут мы работаем с файлами проекта, вносим в них изменения), и убедился, что окончания строк в нем остались без изменений (две строки с окончаниями вида CRLF, две строки с окончаниями вида LF). То есть обещание «The file will have its original line endings in your working directory» сбылось.
После этого я удалил файл «myfile.txt» из папки проекта в корзину операционной системы. Представим, что я потерял рабочие файлы своего проекта. Восстановим их (конкретно в нашем проекте один файл, но в общем случае их может быть много) в папку проекта из базы данных, созданной ранее средствами программы «Git» для нашего проекта:
```
PS C:\Users\Илья\source\repos\test> git checkout -f master
Already on 'master'
```
В результате этой команды в папке проекта снова появился файл «myfile.txt». Однако, все четыре окончания строк в этом файле теперь стали одного вида: CRLF. Сбылось обещание из предупреждения «warning: LF will be replaced by CRLF in myfile.txt.».
**Как работает настройка «core.autocrlf» со значением «true»?** Если при такой настройке мы помещаем версию измененного файла в базу данных «Git» данного проекта, то все найденные в этом файле окончания строк вида CRLF конвертируются в окончания строк вида LF. Если при такой настройке мы извлекаем версию файла, хранящуюся в базе данных «Git» данного проекта, то все найденные в этой версии файла окончания строк вида LF конвертируются в окончания строк вида CRLF. Вот как это можно показать схематично:
```
add, commit База checkout
--------------> данных Git -------------->
(CRLF -> LF) (LF) (LF -> CRLF)
```
Подчеркну, что на этой схеме внесение в базу данных (коммит) и извлечение из нее (checkout) разнесены во времени. Если внесение в базу данных произошло при настройке «core.autocrlf» со значением «true», а извлечение из базы данных произошло при настройке «core.autocrlf» со значением «false», то конвертация при извлечении не произойдет и все четыре окончания строк в извлеченном файле окажутся вида LF (в том виде, в котором этот файл был помещен в базу данных и хранится там). Это замечание может быть сходным образом применено и к другим значениям настройки «core.autocrlf».
### 2. Параметр «core.autocrlf», значение «false»
Схема работы при такой настройке:
```
add, commit База checkout
-------------------> данных Git ------------------->
(без конвертации) (CRLF и/или LF) (без конвертации)
```
При такой настройке в базе данных «Git» будет храниться именно то, что мы туда положили. И будет извлечено именно то, что хранится в базе данных, без изменений.
### 3. Параметр «core.autocrlf», значение «input»
Схема работы при такой настройке:
```
add, commit База checkout
--------------> данных Git ------------------->
(CRLF -> LF) (LF) (без конвертации)
```
### Зачем нужны эти три настройки
Параметр «core.autocrlf» со значением «false» — это естественный режим работы программы «Git», который использовался бы, если б не было разницы в представлении окончаний строк в разных операционных системах.
Собственно, параметр «core.autocrlf» придумали для обеспечения работы над одним проектом программистов из разных операционных систем. Предполагается, что программист в операционной системе «Windows» будет работать с файлами, в которых окончания строк только вида CRLF. При этом предполагается, что он включит для проекта настройку «core.autocrlf» со значением «true». Тогда он будет работать в своей папке проекта с файлами, в которых окончания строк будут вида CRLF, при этом в базе данных «Git» эти же файлы будут сохранены с окончаниями вида LF. Программист в операционной системе «Windows» этого даже не заметит, ведь конвертация происходит автоматически, как было показано выше в пункте 1.
В тот же момент программист в Unix-подобной операционной системе будет работать с той же базой данных «Git», но у него для проекта будет включена настройка «core.autocrlf» со значением «input» (или со значением «false»). Он будет получать из базы данных файлы с окончаниями строк вида LF, как и принято в Unix-подобных операционных системах.
В принципе, программист в операционной системе «Windows» тоже может использовать параметр «core.autocrlf» со значением «false» в случае, если он работает со своей базой данных «Git» один и пишет код только для операционных систем Windows. Либо он работает вместе с другими программистами, но все участники проекта работают в операционных системах «Windows» и проект предназначен только для операционных систем «Windows». Либо, еще один вариант, в коде есть файлы с окончаниями строк разного вида (CRLF и/или LF) и программист хочет сам отслеживать виды окончаний строк в своих файлах, без вмешательства программ, без автоматической конвертации.
### Полезные ссылки
1. В книге «Pro Git» (вторая редакция, вышла в 2014 году), авторы: Scott Chacon (Скотт Чакон) и Ben Straub (Бен Страуб), в главе 8 «Настройка Git», в подглаве 8.1 «[Конфигурация Git](https://git-scm.com/book/ru/v2/%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-Git-%D0%9A%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D1%8F-Git)» (статья большая, ищите в ее последней трети раздел «Форматирование и пробелы»).
2. Хороший, [развернутый ответ](https://stackoverflow.com/a/20653073/16458042) на вопрос «Git replacing LF with CRLF» на известном сайте «Stack Overflow». | https://habr.com/ru/post/703072/ | null | ru | null |
# Flightradar24 — как это работает? Часть 2, ADS-B протокол
Привет Хабр. Наверное каждый, кто хоть раз встречал или провожал родственников или друзей на самолет, пользовался бесплатным сервисом Flightradar24. Это весьма удобный способ отслеживания положения самолета в реальном времени.
В [первой части](https://habr.com/ru/post/408003/) был описан принцип работы такого онлайн-сервиса. Сейчас мы пойдем дальше, и выясним, какие данные передаются и принимаются от воздушного судна к приемной станции, и декодируем их самостоятельно с помощью Python.
История
-------
Очевидно, что данные о самолетах передаются не для того, чтобы пользователи видели их на своих смартфонах. Система называется ADS–B (Automatic dependent surveillance—broadcast), и служит для автоматической передачи информации о воздушном судне в диспетчерский центр — передаются его идентификатор, координаты, направление, скорость, высота и прочие данные. Ранее, до появления таких систем, диспетчер мог видеть лишь точку на радаре. Этого стало недостаточно, когда самолетов стало слишком много.
Технически, ADS-B состоит из передатчика на воздушном судне, который периодически посылает пакеты с информацией на достаточно высокой частоте 1090 МГц (есть и другие режимы, но нам они не так интересены, т.к. координаты передаются только здесь). Разумеется, кроме передатчика, есть и приемник где-то в аэропорту, но для нас, как для пользователей, интересен приемник наш собственный.
Кстати, для сравнения, первая такая система, Airnav Radarbox, расчитанная на обычных пользователей, появилась в 2007 году, и стоила около 900$, еще около 250$ в год стоила подписка на сетевые сервисы.
Отзывы тех первых российских владельцев можно почитать на форуме [radioscanner](http://www.radioscanner.ru/forum/topic30532.html). Сейчас, когда массово стали доступны RTL-SDR приемники, аналогичный девайс можно собрать за 30$, подробнее об этом было в [первой части](https://habr.com/ru/post/408003/). Мы же перейдем собственно, к протоколу — посмотрим как это работает.
Прием сигналов
--------------
Для начала, сигнал нужно записать. Весь сигнал имеет длительность всего лишь 120 микросекунд, поэтому чтобы комфортно разобрать его компоненты, желателен SDR-приемник с частотой дискретизации не менее 5МГц.
После записи мы получаем WAV-файл с частотой дискретизации 5000000 семплов/сек, 30 секунд такой записи «весят» около 500Мб. Слушать её медиаплеером разумеется, бесполезно — файл содержит не звук, а непосредственно оцифрованный радиосигнал — именно так работает Software Defined Radio.
Открывать и обрабатывать файл мы будем с помощью Python. Желающие поэкспериментировать самостоятельно, могут скачать пример записи [по ссылке](https://cloud.mail.ru/public/XP1c/oKDYrpdsw).
Загрузим файл, и посмотрим что внутри.
```
from scipy.io import wavfile
import matplotlib.pyplot as plt
import numpy as np
fs, data = wavfile.read("adsb_20190311_191728Z_1090000kHz_RF.wav")
data = data.astype(float)
I, Q = data[:, 0], data[:, 1]
A = np.sqrt(I*I + Q*Q)
plt.plot(A)
plt.show()
```
Результат: мы видим явные «импульсы» на фоне шума.
Каждый «импульс» — это и есть сигнал, структуру которого хорошо видно, если увеличить разрешение на графике.
Как можно видеть, картинка вполне соответствует тому, что приведено в описании выше. Можно приступать к обработке данных.
Декодирование
-------------
Для начала, нужно получить битовый поток. Сам сигнал закодирован с помощью manchester encoding:
Из разницы уровней в полубайтах легко получить реальные «0» и «1».
```
bits_str = ""
for p in range(8):
pos = start_data + bit_len*p
p1, p2 = A[pos: pos + bit_len/2], A[pos + bit_len/2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
elif avg1 > avg2:
bits_str += "1"
```
Структура самого сигнала имеет следующий вид:
Рассмотрим поля более подробно.
**DF** (Downlink Format, 5 бит) — определяет тип сообщения. Их несколько типов:
([источник таблицы](http://bibliotheek.knmi.nl/knmipubTR/TR336.pdf))
Нас интересует только тип DF17, т.к. именно он содержит координаты воздушного судна.
**ICAO** (24 бита) — международный уникальный код воздушного судна. Проверить самолет по его коду можно [на сайте](https://junzis.com/adb/) (к сожалению, автор перестал обновлять базу, но она еще актуальна). К примеру, для кода 3c5ee2 имеем следующую информацию:
Правка: в [комментарии к статье](https://habr.com/ru/post/443498/#comment_19889906) описание кода ICAO приведено более подробно, интересующимся рекомендую ознакомиться.
**DATA** (56 или 112 бит) — собственно данные, которые мы и будем декодировать. Первые 5 бит данных — поле **Type Code**, содержащее подтип хранящихся данных (не путать с DF). Таких типов довольно много:
([источник таблицы](https://mode-s.org/decode/adsb/introduction.html))
Разберем несколько примеров пакетов.
**Aircraft identification**
Пример в бинарном виде:
00100 011 000101 010111 000111 110111 110001 111000
Поля данных:
```
+------+------+------+------+------+------+------+------+------+------+
| TC,5 | EC,3 | C1,6 | C2,6 | C3,6 | C4,6 | C5,6 | C6,6 | C7,6 | C8,6 |
+------+------+------+------+------+------+------+------+------+------+
```
TC = 00100b = 4, каждый символ C1-C8 содержит коды, соответствующие индексам в строке:
#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####\_###############0123456789######
Раскодировав строку, несложно получить код самолета: EWG7184
```
symbols = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####_###############0123456789######"
code_str = ""
for p in range(8):
c = int(bits_str[8 + 6*p:8 + 6*(p + 1)], 2)
code_str += symbols[c]
print("Aircraft Identification:", code_str.replace('#', ''))
```
**Airborne position**
Если с названием все просто, то с координатами посложнее. Они передаются в виде 2х, четных и нечетных фреймов. Код поля TC = 01011b = 11.
Пример четного и нечетного пакетов:
```
01011 000 000101110110 00 10111000111001000 10000110101111001
01011 000 000110010000 01 10010011110000110 10000011110001000
```
Само вычисление координат происходит по достаточно хитрой формуле:
([источник](https://mode-s.org/decode/adsb/airborne-position.html))
Я не специалист по ГИС, так что откуда оно выводится, не знаю. Кто в курсе, напишите в комментариях.
Высота считается проще — в зависимости от определенного бита, она может представляться либо кратной 25, либо 100 футам.
**Airborne Velocity**
Пакет с TC=19. Интересно тут то, что скорость может быть как точная, относительно земли (Ground Speed), так и воздушная, измеряемая датчиком самолета (Airspeed). Еще передается множество разных полей:
([источник](https://mode-s.org/decode/adsb/airborne-velocity.html))
Заключение
----------
Как можно видеть, технология ADS-B стала интересным симбиозом, когда какой-либо стандарт пригождается не только профессионалам, но и обычным пользователям. Но разумеется, ключевую роль в этом сыграло удешевление технологии цифровых SDR-приемников, позволяющим на девайсе буквально «за копейки» принимать сигналы с частотой выше гигагерца.
В самом стандарте разумеется, гораздо больше всего. Желающие могут посмотреть PDF на странице [ICAO](https://www.icao.int/SAM/Documents/2017-ADSB/08%20FAA%20Briefing%20ADS_B%20Rules%20and%20Airspace%20(2).pdf) или посетить уже упомянутый выше [сайт](https://mode-s.org/decode/).
Вряд ли многим пригодится все вышенаписанное, но по крайней мере общая идея того, как это работает, надеюсь, осталась.
Кстати, готовый декодер на Python уже существует, его можно изучить [здесь](https://github.com/junzis/pyModeS). А владельцы SDR-приемников могут собрать и запустить готовый ADS-B декодер [со страницы](https://github.com/antirez/dump1090.git), подробнее об этом рассказывалось в [первой части](https://habr.com/ru/post/408003/).
Исходный код парсера, описанный в статье, приведен под катом. Это тестовый пример, не претендующий на production, но кое-что в нем работает, и парсить записанный выше файл, им можно.
**Исходный код (Python)**
```
from __future__ import print_function
from scipy.io import wavfile
from scipy import signal
import matplotlib.pyplot as plt
import numpy as np
import math
import sys
def parse_message(data, start, bit_len):
max_len = bit_len*128
A = data[start:start + max_len]
A = signal.resample(A, 10*max_len)
bits = np.zeros(10*max_len)
bit_len *= 10
start_data = bit_len*8
# Parse first 8 bits
bits_str = ""
for p in range(8):
pos = start_data + bit_len*p
p1, p2 = A[pos: pos + bit_len/2], A[pos + bit_len/2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
elif avg1 > avg2:
bits_str += "1"
df = int(bits_str[0:5], 2)
# Aircraft address (db - https://junzis.com/adb/?q=3b1c5c )
bits_str = ""
for p in range(8, 32):
pos = start_data + bit_len * p
p1, p2 = A[pos: pos + bit_len / 2], A[pos + bit_len / 2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
elif avg1 > avg2:
bits_str += "1"
# print "Aircraft address:", bits_str, hex(int(bits_str, 2))
address = hex(int(bits_str, 2))
# Filter specific aircraft (optional)
# if address != "0x3c5ee2":
# return
if df == 16 or df == 17 or df == 18 or df == 19 or df == 20 or df == 21:
# print "Pos:", start, "DF:", msg_type
# Data (56bit)
bits_str = ""
for p in range(32, 88):
pos = start_data + bit_len*p
p1, p2 = A[pos: pos + bit_len/2], A[pos + bit_len/2: pos + bit_len]
avg1, avg2 = np.average(p1), np.average(p2)
if avg1 < avg2:
bits_str += "0"
# bits[pos + bit_len / 2] = 50
elif avg1 > avg2:
bits_str += "1"
# http://www.lll.lu/~edward/edward/adsb/DecodingADSBposition.html
# print "Data:"
# print bits_str[:8], bits_str[8:20], bits_str[20:22], bits_str[22:22+17], bits_str[39:39+17]
# Type Code:
tc, ec = int(bits_str[:5], 2), int(bits_str[5:8], 2)
# print("DF:", df, "TC:", tc)
# 1 - 4 Aircraft identification
# 5 - 8 Surface position
# 9 - 18 Airborne position (w/ Baro Altitude)
# 19 Airborne velocities
if tc >= 1 and tc <= 4: # and (df == 17 or df == 18):
print("Aircraft address:", address)
print("Data:")
print(bits_str[:8], bits_str[8:14], bits_str[14:20], bits_str[20:26], bits_str[26:32], bits_str[32:38], bits_str[38:44])
symbols = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ#####_###############0123456789######"
code_str = ""
for p in range(8):
c = int(bits_str[8 + 6*p:8 + 6*(p + 1)], 2)
code_str += symbols[c]
print("Aircraft Identification:", code_str.replace('#', ''))
print()
if tc == 11:
print("Aircraft address:", address)
print("Data: (11)")
print(bits_str[:8], bits_str[8:20], bits_str[20:22], bits_str[22:22+17], bits_str[39:39+17])
# Bit 22 contains the F flag which indicates which CPR format is used (odd or even)
# First frame has F flag = 0 so is even and the second frame has F flag = 1 so odd
# f = bits_str[21:22]
# print("F:", int(f, 2))
# Altitude
alt1b = bits_str[8:20]
if alt1b[-5] == '1':
bits = alt1b[:-5] + alt1b[-4:]
n = int(bits, 2)
alt_ft = n*25 - 1000
print("Alt (ft)", alt_ft)
# lat_dec = int(bits_str[22:22+17], 2)
# lon_dec = int(bits_str[39:39+17], 2)
# print("Lat/Lon:", lat_dec, lon_dec)
# http://airmetar.main.jp/radio/ADS-B%20Decoding%20Guide.pdf
print()
if tc == 19:
print("Aircraft address:", address)
print("Data:")
# print(bits_str)
print(bits_str[:5], bits_str[5:8], bits_str[8:10], bits_str[10:13], bits_str[13] ,bits_str[14:24], bits_str[24], bits_str[25:35], bits_str[35:36], bits_str[36:65])
subtype = int(bits_str[5:8], 2)
# https://mode-s.org/decode/adsb/airborne-velocity.html
spd, hdg, rocd = -1, -1, -1
if subtype == 1 or subtype == 2:
print("Velocity Subtype 1: Ground speed")
v_ew_sign = int(bits_str[13], 2)
v_ew = int(bits_str[14:24], 2) - 1 # east-west velocity
v_ns_sign = int(bits_str[24], 2)
v_ns = int(bits_str[25:35], 2) - 1 # north-south velocity
v_we = -1*v_ew if v_ew_sign else v_ew
v_sn = -1*v_ns if v_ns_sign else v_ns
spd = math.sqrt(v_sn*v_sn + v_we*v_we) # unit in kts
hdg = math.atan2(v_we, v_sn)
hdg = math.degrees(hdg) # convert to degrees
hdg = hdg if hdg >= 0 else hdg + 360 # no negative val
if subtype == 3:
print("Subtype Subtype 3: Airspeed")
hdg = int(bits_str[14:24], 2)/1024.0*360.0
spd = int(bits_str[25:35], 2)
vr_sign = int(bits_str[36], 2)
vr = int(bits_str[36:45], 2)
rocd = -1*vr if vr_sign else vr # rate of climb/descend
print("Speed (kts):", spd, "Rate:", rocd, "Heading:", hdg)
print()
# print()
def calc_coordinates():
def _cprN(lat, is_odd):
nl = _cprNL(lat) - is_odd
return nl if nl > 1 else 1
def _cprNL(lat):
try:
nz = 15
a = 1 - math.cos(math.pi / (2 * nz))
b = math.cos(math.pi / 180.0 * abs(lat)) ** 2
nl = 2 * math.pi / (math.acos(1 - a/b))
return int(math.floor(nl))
except:
# happens when latitude is +/-90 degree
return 1
def floor_(x):
return int(math.floor(x))
lat1b, lon1b, alt1b = "10111000111010011", "10000110111111000", "000101111001"
lat2b, lon2b, alt2b = "10010011101011100", "10000011000011011", "000101110111"
lat1, lon1, alt1 = int(lat1b, 2), int(lon1b, 2), int(alt1b, 2)
lat2, lon2, alt2 = int(lat2b, 2), int(lon2b, 2), int(alt2b, 2)
# 131072 is 2^17, since CPR lat and lon are 17 bits each
cprlat_even, cprlon_even = lat1/131072.0, lon1/131072.0
cprlat_odd, cprlon_odd = lat2/131072.0, lon2/131072.0
print(cprlat_even, cprlon_even)
j = floor_(59*cprlat_even - 60*cprlat_odd)
print(j)
air_d_lat_even = 360.0 / 60
air_d_lat_odd = 360.0 / 59
# Lat
lat_even = float(air_d_lat_even * (j % 60 + cprlat_even))
lat_odd = float(air_d_lat_odd * (j % 59 + cprlat_odd))
if lat_even >= 270:
lat_even = lat_even - 360
if lat_odd >= 270:
lat_odd = lat_odd - 360
# Lon
ni = _cprN(lat_even, 0)
m = floor_(cprlon_even * (_cprNL(lat_even)-1) - cprlon_odd * _cprNL(lat_even) + 0.5)
lon = (360.0 / ni) * (m % ni + cprlon_even)
print("Lat", lat_even, "Lon", lon)
# Altitude
# Q-bit (bit 48) indicates whether the altitude is encoded in multiples of 25 or 100 ft (0: 100 ft, 1: 25 ft)
# The value can represent altitudes from -1000 to +50175 ft.
if alt1b[-5] == '1':
bits = alt1b[:-5] + alt1b[-4:]
n = int(bits, 2)
alt_ft = n*25 - 1000
print("Alt (ft)", alt_ft)
fs, data = wavfile.read("adsb_20190311_191728Z_1090000kHz_RF.wav")
T = 1/fs
print("Sample rate %f MS/s" % (fs / 1e6))
print("Cnt samples %d" % len(data))
print("Duration: %f s" % (T * len(data)))
data = data.astype(float)
cnt = data.shape[0]
# Processing only part on file (faster):
# cnt = 10000000
# data = data[:cnt]
print("Processing I/Q...")
I, Q = data[:, 0], data[:, 1]
A = np.sqrt(I*I + Q*Q)
bits = np.zeros(cnt)
# To see scope without any processing, uncomment
# plt.plot(A)
# plt.show()
# sys.exit(0)
print("Extracting signals...")
pos = 0
avg = 200
msg_start = 0
# Find beginning of each signal
while pos < cnt - 16*1024:
# P1 - message start
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg and pos - msg_start > 1000:
msg_start = pos
bits[pos] = 100
pos += 4
break
pos += 1
start1, start2, start3, start4 = msg_start, 0, 0, 0
# P2
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg:
start2 = pos
bits[pos] = 90
pos += 1
break
pos += 1
# P3
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg:
start3 = pos
bits[pos] = 80
pos += 1
break
pos += 1
# P4
while pos < cnt - 16*1024:
if A[pos] < avg and A[pos+1] > avg:
start4 = pos
bits[pos] = 70
pos += 1
break
pos += 1
sig_diff = start4 - start1
if 20 < sig_diff < 25:
bits[msg_start] = 500
bit_len = int((start4 - start1) / 4.5)
# print(pos, start1, start4, ' - ', bit_len)
# start = start1 + 8*bit_len
parse_message(A, msg_start, bit_len)
pos += 450
# For debugging: check signal start
# plt.plot(A)
# plt.plot(bits)
# plt.show()
```
Надеюсь, кому-то было интересно, спасибо за внимание. | https://habr.com/ru/post/443498/ | null | ru | null |
# Добавляем темную тему в iOS
Всем привет!
Меня зовут Андрей, я из команды «Мой Брокер». Я рассĸажу Вам ĸаĸ добавлял поддержĸу темной темы в iOS.
Apple в iOS 13 добавила темную тему для всей системы, пользователи могут выбрать светлое или темное оформление на настройках iOS. В темном режиме система использует более темную цветовую палитру для всех экранов, видов, меню и элементов управления.
Кому интересно — заходите под кат.
Поддержка темного оформления
----------------------------
Приложение созданное в Xcode 11 по-умолчанию поддерживает темное оформление в iOS 13. Но для полноценной реализации темного режима, необходимо внести дополнительные правки:
* Цвета должны поддерживать светлое и темное оформление
* Изображения должны поддерживать светлое и темное оформление
**Apple добавила несколько системных цветов, которые поддерживают светлое и темное оформление.**
В iOS 13 был представлен новый инициализатор **UIColor**:
```
init (dynamicProvider: @escaping (UITraitCollection) -> UIColor)
```
Добавим статическую функцию для создания цвета с поддержкой переключения между светлым и темным оформлением:
```
extension UIColor {
static func color(light: UIColor, dark: UIColor) -> UIColor {
if #available(iOS 13, *) {
return UIColor.init { traitCollection in
return traitCollection.userInterfaceStyle == .dark ? dark : light
}
} else {
return light
}
}
}
```
**CGColor** не поддерживает автоматическое переключение между светлым и темным оформлением.
Необходимо вручную менять **CGColor** после изменения оформления.
```
override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
super.traitCollectionDidChange(previousTraitCollection)
layer.borderColor = UIColor.Pallete.black.cgColor
}
```
Так же есть возможность добавить цвет для темного оформления в ресурсах.
Но я предпочитаю добавлять цвета в коде.
**UIColor.Pallete**
```
extension UIColor {
struct Pallete {
static let white = UIColor.color(light: .white, dark: .black)
static let black = UIColor.color(light: .black, dark: .white)
static let background = UIColor.color(light: .white, dark: .hex("1b1b1d"))
static let secondaryBackground = UIColor(named: "secondaryBackground") ?? .black
static let gray = UIColor.color(light: .lightGray, dark: .hex("8e8e92"))
}
}
```
Для изображений достаточно добавить вариант изображения для темного оформления прям в ресурсах.
#### Сделаем небольшое приложение для примера.
Приложение будет содержать два окна и три экрана.
Первое окно: экран авторизации.
Второе окно: экран ленты и экран профиля пользователя.
**Скриншоты в светлом и темном оформлении**  
  
Переключение светлой и темной темы
----------------------------------
Создаем enum для темы:
```
enum Theme: Int, CaseIterable {
case light = 0
case dark
}
```
Добавляем возможность хранения текущей темы, чтобы восстановить её после перезапуска приложения.
```
extension Theme {
// Обертка для UserDefaults
@Persist(key: "app_theme", defaultValue: Theme.light.rawValue)
private static var appTheme: Int
// Сохранение темы в UserDefaults
func save() {
Theme.appTheme = self.rawValue
}
// Текущая тема приложения
static var current: Theme {
Theme(rawValue: appTheme) ?? .light
}
}
```
**Persist**
```
@propertyWrapper
struct Persist {
let key: String
let defaultValue: T
var wrappedValue: T {
get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue }
set { UserDefaults.standard.set(newValue, forKey: key) }
}
init(key: String, defaultValue: T) {
self.key = key
self.defaultValue = defaultValue
}
}
```
Чтобы принудительно установить оформление нужно изменить стиль всех окон приложения.
Реализуем переключение темы в приложении.
```
extension Theme {
@available(iOS 13.0, *)
var userInterfaceStyle: UIUserInterfaceStyle {
switch self {
case .light: return .light
case .dark: return .dark
}
}
func setActive() {
// Сохраняем активную тему
save()
guard #available(iOS 13.0, *) else { return }
// Устанавливаем активную тему для всех окон приложения
UIApplication.shared.windows
.forEach { $0.overrideUserInterfaceStyle = userInterfaceStyle }
}
}
```
Так же необходимо менять стиль окна на текущую тему перед показом окна.
```
extension UIWindow {
// Устанавливаем текущую тему для окна
// Необходимо вызывать перед показом окна
func initTheme() {
guard #available(iOS 13.0, *) else { return }
overrideUserInterfaceStyle = Theme.current.userInterfaceStyle
}
}
```
**Скриншоты выбора светлой или темной темы** 
Добавляем переключение на системной тему
----------------------------------------
Добавляем системную тему в enum темы.
```
enum Theme: Int, CaseIterable {
case system = 0
case light
case dark
}
```
После принудительной установки светлой или темной темы, нельзя определить какое оформление включено в системе. Чтобы узнавать системное оформление добавляем окно в приложение, у которого не будем принудительно менять оформление. Так же необходимо реализовать изменение оформления, когда в приложении установлена системная тема и пользователь меняет оформление в iOS.
```
final class ThemeWindow: UIWindow {
override public func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
// Если текущая тема системная и поменяли оформление в iOS, опять меняем тему на системную.
// Например: Пользователь поменял светлое оформление на темное.
if Theme.current == .system {
Theme.system.setActive()
}
}
}
let themeWindow = ThemeWindow()
class AppDelegate: UIResponder, UIApplicationDelegate {
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
...
// Добавляем окно к приложению, но не показываем его
// Необходимо вызывать до установки главного окна приложения
themeWindow.makeKey()
...
return true
}
}
extension Theme {
@available(iOS 13.0, *)
var userInterfaceStyle: UIUserInterfaceStyle {
switch self {
case .light: return .light
case .dark: return .dark
case .system: return themeWindow.traitCollection.userInterfaceStyle
}
}
func setActive() {
// Сохраняем активную тему
save()
guard #available(iOS 13.0, *) else { return }
// Устанавливаем активную тему для всех окон приложения
// Не красим это окно чтобы узнавать системную тему
UIApplication.shared.windows
.filter { $0 != themeWindow }
.forEach { $0.overrideUserInterfaceStyle = userInterfaceStyle }
}
}
```
**Скриншоты выбора системной, светлой или темной темы** 
Результат
---------
Поддержка темного оформления и переключение между системной, светлой и темной темой.
**Скринвидео**
[Ссылка на весь проект](https://github.com/venvear/ThemeSwitcher) | https://habr.com/ru/post/493096/ | null | ru | null |
# Tarantool Kubernetes Operator
Kubernetes становится де-факто стандартом для запуска stateless-приложений. В основном потому, что позволяет значительно сократить time-to-market для доставки новых фич. Запуск stateful-приложений — баз данных, stateful-микросервисов — все еще представляет собой сложную задачу, но необходимость выдерживать конкуренцию и поддерживать высокий темп доставки подталкивает компании к экспериментам в этой области и создает спрос на подобные решения.
Представляем вам наше решение для запуска stateful-кластеров [Tarantool Cartridge](https://www.tarantool.io/ru/cartridge/): [Tarantool Kubernetes Operator](https://www.tarantool.io/ru/kubernetes/), за подробностями прошу под кат.
Оглавление:
1. [Вместо тысячи слов](#1)
2. [Чем вообще занимается оператор](#2)
3. [Немного про нюансы](#3)
4. [Как оператор работает](#4)
5. [Что оператор разворачивает](#5)
6. [Итог](#6)
Tarantool — это opensource база данных и сервер приложений в одном флаконе. Как база данных он обладает рядом уникальных характеристик: высокая эффективность утилизации железа, гибкая схема данных, поддержка как in-memory, так и дискового хранилища, возможность расширения за счет использования языка Lua. Как сервер приложений он позволяет переместить код приложения максимально близко к данным, достигая при этом минимального времени отклика и максимальной пропускной способности. Помимо этого Tarantool обладает [обширной экосистемой](https://www.tarantool.io/en/download/rocks), предоставляя готовые модули для решения прикладных задач: [шардинг](https://github.com/tarantool/vshard), [очередь](https://github.com/tarantool/queue), модули для облегчения разработки ([cartridge](https://github.com/tarantool/cartridge), [luatest](https://github.com/tarantool/luatest)), решения для эксплуатации ([metrics](https://github.com/tarantool/metrics), [ansible](https://github.com/tarantool/ansible-cartridge)) — и это только несколько примеров.
При всех своих достоинствах, возможности одного инстанса Tarantool не безграничны: для хранения терабайтов данных и обработки миллионов запросов необходимо поднимать десятки и сотни инстансов, а это уже распределенная система, со всеми присущими ей проблемами. Для их решения у нас есть [Tarantool Cartridge](https://github.com/tarantool/cartridge) — фрэймворк, основная задача которого — скрыть всевозможные сложности написания распределенных приложений и дать возможность разработчикам сфокусироваться на бизнес-ценности приложения. Cartridge предоставляет мощный набор компонентов для автоматической оркестрации кластера, автоматического распределения данных, webui для эксплуатации и инструменты разработчика.
Tarantool — это не только технологии, но еще и команда инженеров, которая занимается разработкой enterprise-систем “под ключ”, коробочных решений и поддержкой opensource-компонентов.
Глобально наши задачи можно поделить на два направления: разработка новых систем и аугментация уже существующих решений. Например, есть большая база от известного вендора. Чтобы отмасштабировать ее на чтение, за ней ставят eventually consistent кэш на Tarantool. Или наоборот: чтобы отмасштабировать запись, ставят Tarantool в конфигурации горячий/холодный, где по мере “остывания” данные скидываются на холодное хранилище и параллельно в очередь для аналитики. Или чтобы подпереть уже существующую систему, пишется облегченная версия этой системы (функциональный резерв), которая резервирует основную “по-горячему” с репликацией данных из основной системы. Подробнее можно узнать из [докладов с T+ 2019](https://www.youtube.com/channel/UCc2_EprBYT7O6iPIdwkjL_w).
У всех этих систем есть одна общая черта: их довольно сложно эксплуатировать. Быстро раскатать кластер на 100+ инстансов с резервированием в 3 ЦОДа, обновить приложение, которое хранит данные без простоев и просадок в обслуживании, сделать бэкап рестор на случай катастрофы или рукотворных ошибок, обеспечить незаметную отработку отказов компонентов, организовать управление конфигурацией… В общем, масса интересного.
А было бы здорово, если бы все это еще и эксплуатировалось так же просто, как разрабатывается. Kubernetes дает возможность достичь нужного результата, но использование специализированного оператора делает жизнь еще проще.
Вместо тысячи слов
------------------
Мы подготовили небольшой пример на основе Tarantool Cartridge, с ним и будем работать. Простенькое приложение типа «распределенное key value хранилище с HTTP интерфейсом». После запуска получим вот такую картину:
Где:
* Routers — часть кластера, которая отвечает за принятие и обработку входящих HTTP-запросов;
* Storages — часть кластера, отвечающая за хранение и обработку данных, из коробки поднимается 3 шарда, в каждом мастер и реплика.
Для балансировки входящего HTTP-трафика по роутерам используется кубернетовский Ingress. Данные распределяются в хранилище на уровне самого Tarantool с помощью [компонента vshard](https://github.com/tarantool/vshard).
Нам понадобится kubernetes 1.14+, сойдет и [minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/). Также не помешает наличие [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/). Для запуска оператора потребуется создать для него ServiceAccount, Role и RoleBinding:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/service_account.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/role.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/role_binding.yaml
```
Tarantool Operator расширяет Kubernetes API своими определениями ресурсов, создадим и их:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/crds/tarantool_v1alpha1_cluster_crd.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/crds/tarantool_v1alpha1_role_crd.yaml
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/crds/tarantool_v1alpha1_replicasettemplate_crd.yaml
```
К запуску оператора все готово, поехали:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/deploy/operator.yaml
```
Ждем, когда оператор запустится, и можем переходить к запуску приложения:
```
$ kubectl create -f https://raw.githubusercontent.com/tarantool/tarantool-operator/0.0.1/examples/kv/deployment.yaml
```
В yaml-файле с примером объявлен Ingress на web UI; он доступен на `cluster_ip/admin/cluster`. Когда хотя бы один Pod из Ingress’а поднимется, можно будет зайти туда и понаблюдать за тем, как в кластер добавляются новые инстансы и как меняется его топология.
Дожидаемся, когда кластер можно использовать:
```
$ kubectl describe clusters.tarantool.io examples-kv-cluster
```
Ожидаем, что в Status’е кластера будет следующее:
```
…
Status:
State: Ready
…
```
Все, приложение готово к использованию!
Нужно больше места в хранилище? Добавим шардов:
```
$ kubectl scale roles.tarantool.io storage --replicas=3
```
Шарды не справляются с нагрузкой? Увеличим количество инстансов в шарде, отредактировав шаблон replicaset’а:
```
$ kubectl edit replicasettemplates.tarantool.io storage-template
```
Установим `.spec.replicas`, равное например 2, чтобы увеличить количество инстансов в каждом репликасете до двух.
Кластер больше не нужен? Удаляем его вместе со всеми ресурсами:
```
$ kubectl delete clusters.tarantool.io examples-kv-cluster
```
Что-то пошло не так? [Забивайте тикет](https://github.com/tarantool/tarantool-operator/issues), будем оперативно разбирать. :)
Чем вообще занимается оператор
------------------------------
Запуск и эксплуатация кластера Tarantool Cartridge — это история о выполнении определенных действий, в определенном порядке, в определенный момент.
Сам по себе кластер управляется в первую очередь через админское API: GraphQL поверх HTTP. Можно, конечно, пойти уровнем ниже и вбивать команды прямо в консоль, но такое случается редко. Например, вот так выглядит запуск кластера:
1. Поднимаем нужное количество инстансов Tarantool, например под systemd.
2. Объединяем инстансы в membership:
```
mutation {
probe_instance: probe_server(uri: "storage:3301")
}
```
3. Присваиваем инстансам роли, прописываем идентификаторы инстанса и репликасета. Для этого также используется GraphQL API:
```
mutation {
join_server(
uri:"storage:3301",
instance_uuid: "cccccccc-cccc-4000-b000-000000000001",
replicaset_uuid: "cccccccc-0000-4000-b000-000000000000",
roles: ["storage"],
timeout: 5
)
}
```
4. Выполняем bootstrap компонента, отвечающего за шардинг. Также через API:
```
mutation {
bootstrap_vshard
cluster {
failover(enabled:true)
}
}
```
Несложно, правда?
Все становится интереснее, когда речь заходит о расширении кластера. Роль Routers из примера масштабируется просто: поднимаем больше инстансов, подцепляем их к существующему кластеру — готово! Роль Storages несколько хитрее. Хранилище шардированное, поэтому при добавлении/удалении инстансов необходимо выполнить перебалансировку, чтобы данные переехали на новые инстансы/переехали с удаляемых инстансов. Если этого не сделать, то в одном случае получим недогруженные инстансы, во втором — потеряем данные. А если в эксплуатации не один, а десяток вот таких кластеров с разными топологиями?
В общем, этим всем и занят Tarantool Operator. Пользователь описывает желаемое состояние кластера Tarantool Cartridge, а оператор транслирует это в набор действий над ресурсами k8s и в определенные вызовы к админскому API кластера Tarantool’ов — в определенном порядке, в определенный момент, и вообще всячески старается скрыть от пользователя все нюансы.
Немного про нюансы
------------------
В работе с админским API кластера Tarantool Cartridge важны как порядок вызовов, так и куда они приходят. Почему так?
Tarantool Cartridge несет на борту свое хранилище топологии, свой компонент service discovery и свой компонент работы с конфигурацией. Каждый инстанс кластера хранит копию топологии и конфигурации в yaml-файле.
```
servers:
d8a9ce19-a880-5757-9ae0-6a0959525842:
uri: storage-2-0.examples-kv-cluster:3301
replicaset_uuid: 8cf044f2-cae0-519b-8d08-00a2f1173fcb
497762e2-02a1-583e-8f51-5610375ebae9:
uri: storage-0-0.examples-kv-cluster:3301
replicaset_uuid: 05e42b64-fa81-59e6-beb2-95d84c22a435
…
vshard:
bucket_count: 30000
...
```
Обновление происходит согласованно с использованием механизма [двухфазного коммита](https://en.wikipedia.org/wiki/Two-phase_commit_protocol). Для успешного обновления необходим 100 % кворум: каждый инстанс должен ответить, иначе откат. Что это означает с точки зрения эксплуатации? Все запросы к админскому API, модифицирующие состояние кластера, надежнее всего отправлять на один инстанс, на лидера, иначе мы рискуем получить разные конфиги на разных инстансах. Tarantool Cartridge не умеет делать leader election (пока что не умеет), а Tarantool Operator умеет — и вам об этом можно знать только как о занимательном факте, потому что оператор всё разрулит.
Также каждый инстанс должен обладать фиксированным identity, то есть набором `instance_uuid` и `replicaset_uuid`, а также `advertise_uri`. Если вдруг случится перезапуск storage и изменится один из этих параметров, то вы рискуете развалить кворум — этим тоже занимается оператор.
Как оператор работает
---------------------
Задача оператора — приводить систему в заданное пользователем состояние и поддерживать систему в этом состоянии до поступления новых указаний. Для того чтобы оператор мог выполнять свою работу, ему нужны:
1. Описание состояния системы.
2. Код, который приводит систему в это состояние.
3. Механизм интеграции этого кода в k8s (например, чтобы получать уведомления об изменениях в состоянии).
Кластер Tarantool Cartridge описывается в терминах k8s через [Custom Resource Definition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/); оператору нужно 3 таких кастомных ресурса, объединенных под группой tarantool.io/v1alpha:
* Cluster — ресурс верхнего уровня, соответствует одному кластеру Tarantool Cartridge.
* Role — в терминах Tarantool Cartridge это [пользовательская роль](https://www.tarantool.io/en/enterprise_doc/1.10/dev/#defining-custom-cluster-roles).
* ReplicasetTemplate — шаблон, по которому будут создаваться StatefulSet’ы (почему stateful — расскажу чуть позже; не путать с k8s ReplicaSet).
Все эти ресурсы напрямую отражают модель описания кластера Tarantool Cartridge. Имея общий словарь, эксплуатации проще общаться с разработчиками и понимать, что те хотят увидеть в проде.
Код, приводящий систему в заданное состояние — в терминах k8s это Controller. В случае с Tarantool Operator контроллеров несколько:
* ClusterController — отвечает за взаимодействие с кластером Tarantool Cartridge, подключает инстансы к кластеру, отключает инстансы от кластера.
* RoleController — контроллер пользовательской роли, отвечает за развертывание StatefulSet’ов из шаблона и поддержание их числа в заданном количестве.
Что из себя представляет контроллер? Набор кода, поэтапно приводящего мир вокруг себя в порядок. ClusterController схематически можно изобразить вот так:
Точка входа — это проверка, существует ли ресурс Cluster’a, относительно которого произошло событие. Не существует? Выходим. Существует? Переходим к следующему блоку: захватываем Ownership над пользовательскими ролями. Захватили одну — вышли, на втором круге захватываем вторую. И так далее, пока не захватим все. Все роли захвачены? Значит переходим к следующему блоку операций. И так, пока не дойдем до последнего; вот тогда можно считать, что контролируемая система в заданном состоянии.
В целом все просто. Важно определить критерии успешности прохождения каждого этапа. Например, успешной мы считаем операцию присоединения к кластеру не тогда, когда она вернула условный success=true, а когда она вернула ошибку типа «already joined».
И последняя часть этого механизма — интеграция контроллера с k8s. С высоты птичьего полета, весь k8s состоит из набора контроллеров, порождающих события и реагирующих на них. События ходят через очереди, на которые мы можем подписываться. Схематически это можно изобразить вот так:
Пользователь вызывает `kubectl create -f tarantool_cluster.yaml`, создается соответствующий ресурс Cluster. ClusterController получает уведомление о создании ресурса Cluster. И первое, что он пытается сделать — найти все ресурсы Role, которые должны входить в этот кластер. Если находит, то назначает Cluster как Owner для Role и обновляет ресурс Role. RoleController получает уведомление об обновлении Role, видит, что у ресурса появился Owner, и начинает создавать StatefulSet’ы. И так далее по кругу: первый стриггерил второго, второй стриггерил третьего — и так, пока кто-нибудь не остановится. А еще можно триггериться по времени, например раз в 5 секунд, что иногда бывает полезно.
Вот и весь оператор: создаем кастомный ресурс и пишем код, который реагирует на события над ресурсами.
Что оператор разворачивает
--------------------------
Действия оператора в итоге приводят к тому, что k8s создает Pod’ы и контейнеры. В кластере Tarantool Cartridge, развернутом на k8s, все Pod’ы объединены в StatefulSet’ы.
Почему именно StatefulSet? Как я писал ранее, каждый инстанс Tarantool Cluster хранит у себя копию топологии и конфигурации кластера, а еще частенько на app server’ах нет-нет, да и используют какой-нибудь спейс, например под очереди или справочные данные, а это уже полноценное состояние. А еще StatefulSet дает гарантию сохранения identity Pod’ов, что важно при объединении инстансов в кластер: identity инстансов должен быть фиксированным, в противном случае мы рискуем потерять кворум при перезапуске.
Когда все ресурсы кластера созданы и приведены в нужное состояние, они формируют следующую иерархию:
Стрелками обозначено отношение Owner-Dependant между ресурсами. Оно нужно, чтобы [Garbage Collector](https://kubernetes.io/docs/concepts/workloads/controllers/garbage-collection/) прибирал за нами в случае, например, удаления Cluster.
В дополнение к StatefulSet’ам Tarantool Operator создает Headless Service, который нужен для leader election, и через него инстансы общаются между собой.
Под капотом Tarantool Operator лежит [Operator Framework](https://github.com/operator-framework/operator-sdk), сам код оператора — на golang, здесь ничего экстраординарного.
Итог
----
Вот, в общем-то, и все! Ждем от вас фидбэка и тикетов — куда ж без них, альфа-версия все-таки. Что дальше? А дальше предстоит масса работы по доведению этого всего до ума:
* Unit, E2E-тестирование;
* тестирование Chaos Monkey;
* нагрузочное тестирование;
* backup/restore;
* внешний topology provider.
Каждая из этих тем обширна сама по себе и заслуживает отдельного материала, ждите апдейтов! | https://habr.com/ru/post/465823/ | null | ru | null |
# Сетки из треугольников в играх
Поговорим о сетках треугольников. Сетки квадратов используются практически повсюду, от пикселей изображения до расположения домов в квартале. Сетки шестиугольников представлены тоже довольно широко, особенно в настольных играх. Однако сетки треугольников (равномерное заполнение 2D-плоскости равносторонними треугольниками) почему-то не очень популярны. Я встречал заявления, что они бесполезны, или что у них сложная математика. Но этой статьёй я докажу, что оба заявления ошибочны: вычисления на самом деле **проще**, чем при работе с шестиугольниками, к тому же треугольники обладают множеством преимуществ.
Все вычисления я выполнил в своём [коде на github](https://github.com/BorisTheBrave/grids/blob/main/src/updown_tri.py), однако стоит объяснить, как и зачем нужно использовать такие сетки.
Что такое «сетка треугольников»
-------------------------------
Когда я говорю о сетке треугольников, то подразумеваю тайловую карту, в которой все тайлы являются одинаковыми равносторонними треугольниками, выстроенными в переменные строки (или столбцы).
Важно здесь то, что каждая ячейка имеет ровно трёх соседей. Иногда встречаются игры, где отрисована сетка треугольников, но на самом деле фигуры расположены в *углах*. Каждый угол соединяется с шестью другими, то есть на самом деле это сетка не треугольников, а шестиугольников.
*В китайские шашки (Халма) играют на **сетке шестиугольников**, стилизованной на фотографии под сетку треугольников.*
И наоборот: если в игру играют на углах сетки шестиугольников, то на самом деле это сетка треугольников. Из-за этого свойства равномерные сетки шестиугольников и треугольников называют [**двойными**](https://mathworld.wolfram.com/DualTessellation.html).
Зачем использовать сетки треугольников
--------------------------------------
Треугольники обладают тремя потрясающими свойствами:
1. Они всегда планарны
2. Они просты
3. Их геометрия более удобна
### Планарность
Если выбрать любые три точки в трёхмерном пространстве, то через них всегда можно прочертить плоскость. То есть имея эти три точки, всегда можно нарисовать треугольник на поверхности этой плоскости. Для многоугольников с большим количеством вершин это не всегда верно. Если взять четыре 3D-вершины, то соединить их в многоугольник с четырьмя вершинами однозначным образом становится сложно. Страдающие подобной проблемой многоугольники называются **непланарными**, и в компьютерной графике они могут становиться серьёзной помехой, поэтому почти вся графика реального времени преобразует все объекты в треугольники.
Даже несмотря на то, что мы будем говорить о заполнении 2D-пространства, это свойство всё равно для нас полезно на случай, если мы захотим добавить карту высот. В сетке треугольников каждая вершина может располагаться на своей высоте, но в сетке не будет возникать проблем. Если проделать подобное с сеткой квадратов, то мы сразу же столкнёмся с появлением непланарных вершин.
*В Sim City 2000 использовались сетки квадратов и карты высот. Обратите внимание, что многие наклонные тайлы разделены на пары треугольников, потому что тайл непланарен.*
*Карта высот сетки треугольников. Никаких проблем с наклонами.*
### Простота
Математически понятно, что 3 меньше, чем 4 или 6. Это наименьшее количество вершин, которое может иметь многоугольник, поэтому треугольники — самая лучшая фигура для любого алгоритма, масштабирующегося в зависимости от количества точек или рёбер.
Например, в своём туториале по [Marching Cubes](https://www.boristhebrave.com/2018/04/15/marching-cubes-tutorial/) я говорил, что для учёта всех случаев в 2D требуется создать  различных тайлов. Так получается потому, что у каждого из четырёх углов есть два варианта. Треугольники имеют два варианта: смотрящий вверх и вниз, то есть для двух вариантов требуется по  разных тайлов. То есть в обоих случаях получаем 16 тайлов.
*Обратите внимание, что для треугольников нет «противоречивых» случаев.*
Но это самый простой случай. Если мы допускаем возможность поворота тайлов, то вариантов у треугольников становится меньше (4 против 6). А если нам нужно [больше чем два возможных значения](http://www.cr31.co.uk/stagecast/wang/3corn.html) в каждом из углов (54 против 81 или 10 против 21 с поворотами/отражениями).
*Поворачиваемые тайлы, необходимые для marching cubes*
Кроме того, треугольники хороши для линейных интерполяций. Три значения по треугольнику можно легко интерполировать при помощи [барицентрических координат](https://observablehq.com/@jobleonard/linear-interpolation-along-a-triangle-with-barycentric-co), в то время как квадратам требуется [билинейная интерполяция](https://en.wikipedia.org/wiki/Bilinear_interpolation), которая более сложна. Именно из-за этой разницы был изобретён [симплекс-шум](https://en.wikipedia.org/wiki/Simplex_noise) в качестве замены шуму Перлина — они работают одинаково, однако в симплекс-шуме используется сетка треугольников (в случае 2D).
### Геометрия лучше, чем у шестиугольников
При работе с шестиугольниками быстро понимаешь, что кучу неудобств доставляют их **рёбра**. Они не выстраиваются в прямую линию! Из-за этого невозможно разделить сетку линей. Невозможно собрать большой шестиугольник из множества маленьких.
В следующем разделе мы активно будем использовать прямые линии рёбер для понимания того, как работают сетки треугольников.
Хотя нужно признать, что у сеток треугольников есть собственные геометрические неудобства, в основном связанные с тем, как нужно обрабатывать треугольники, смотрящие в разных направлениях.
Как использовать сетки треугольников
------------------------------------
**Примечание:** в данном туториале в основном рассматриваются концепции и идеи, а не методы и код. Если вам интереснее реализация, то изучите написанную мной [справочную реализацию](https://github.com/BorisTheBrave/grids/blob/main/src/updown_tri.py).
Для начала нужно сказать, что существует множество способов работы с сетками треугольников. В этом разделе я опишу тот, который считаю лучшим — его легко понять и он имеет простые выражения практически для всех действий, которые вам понадобятся для работы с треугольниками. Я буду описывать треугольники, выстроенные в строки (треугольники «смотрящие» вверх и вниз), но для сеток, повёрнутых на 90 градусов, всё будет устроено так же.
Хитрость заключается в том, чтобы воспринимать сетку треугольников как задаваемую тремя множествами равномерно расположенных параллельных линий, наложенных друг на друга:
Пространство между каждой из этих параллельных линий называется **полосами**. Мы обозначим три направления полос как a, b и c, а сами полосы пронумеруем по порядку.
Тогда координатой треугольника будут три целых числа a, b, c, определяющие, в каких полосах находится треугольник. Всё очень просто!
Вероятно, вы зададитесь вопросом, почему мы используем три числа для описания ячейки в 2d-сетке. Просто так нам будет удобнее работать. Если попробовать использовать систему координат из двух чисел, то в конечном итоге придётся добавлять больше исключений для чётных и нечётных координат, или других аспектов. Похожий трюк используется и при работе с сетками шестиугольников, см. [эту статью о «кубических» координатах сеток шестиугольников](https://www.redblobgames.com/grids/hexagons/#coordinates-cube). Впрочем, третья координата практически избыточна — в этой системе сумма a + b + c всегда равна или 1, или 2. Поэтому можно просто хранить a, b и c в дополнительной булевой переменной.
Стоит заметить, что в такой системе нет треугольника с координатами (0, 0, 0). Я пронумеровал полосы таким образом, что точкой начала координат является вершина, окружённая шестью треугольниками в полосах 0 и 1. При другой нумерации полос система работает так же.
### Соседи
Когда мы переходим с одного треугольника на другой, то пересекаем одну из линий, разделяющих полосы. Я создал такую систему, что при перемещении из треугольника, указывающего вершиной вниз, мы прибавляем к координате единицу. А при выходе из треугольника вершиной вверх — вычитаем единицу.
```
def tri_neighbours(a, b, c):
"""Returns the tris that share an edge with the given tri"""
points_up = a + b + c == 2
if points_up:
return [
(a - 1, b , c ),
(a , b - 1, c ),
(a , b , c - 1),
]
else:
return [
(a + 1, b , c ),
(a , b + 1, c ),
(a , b , c + 1),
]
```
### Центр треугольника
Так как перемещение в соседний треугольник всегда является шагом заданного размера по одной из трёх полос, заданный треугольник можно найти, просто просуммировав все шаги, сделанные в трёх направлениях.
```
def tri_center(a, b, c):
"""Returns the center of a given triangle in cartesian co-ordinates"""
return (( 0.5 * a + -0.5 * c) * edge_length,
(-sqrt3 / 6 * a + sqrt3 / 3 * b - sqrt3 / 6 * c) * edge_length)
```
### Расстояние между треугольниками
Так как каждый шаг меняет координату на единицу, формула расстояния представляет собой всего лишь разность в каждой из координат.
```
def tri_dist(a1, b1, c1, a2, b2, c2):
"""Returns how many steps one tri is from another"""
return abs(a1 - a2) + abs(b1 - b2) + abs(c1 - c2)
```
В [следующей статье](https://www.boristhebrave.com/2021/05/27/some-triangle-grid-extensions/) я рассмотрю альтернативную функцию расстояния.
### В каком треугольнике находится точка
Чтобы найти треугольник, содержащий заданную точку, нужно просто определить, в каких трёх полосах находится треугольник. Это можно сделать, измерив расстояние, перпендикулярное к полосе из точки начала координат, что легко выполняется при помощи [скалярного произведения](https://en.wikipedia.org/wiki/Dot_product) с последующим усечением значения до целого числа.
```
def pick_tri(x, y):
"""Returns the triangle that contains a given cartesian co-ordinate point"""
return (
ceil(( 1 * x - sqrt3 / 3 * y) / edge_length),
floor(( sqrt3 * 2 / 3 * y) / edge_length) + 1,
ceil((-1 * x - sqrt3 / 3 * y) / edge_length),
)
```
`ceil` округляет число *вверх* до ближайшего целого, а `floor` округляет *вниз*. Нельзя просто округлить все три полосы в одном направлении, иначе возникнут сложности, например, с точкой с координатой (0, 0), которая находится в углу шести разных треугольников.
### Другие операции
С сеткой можно проделать множество других операций, например, измерять расстояния, рисовать линии и выполнять повороты. Всё это подробно описано в [моей справочной реализации](https://github.com/BorisTheBrave/grids/blob/main/src/updown_tri.py) на github.
Можете сравнить её с [реализацией сетки шестиугольников](https://github.com/BorisTheBrave/grids/blob/main/src/flat_topped_hex.py). С треугольниками работать намного проще, чем с шестиугольниками, поэтому я реализовал многие операции с шестиугольниками, сначала выполняя эквивалентную операцию с треугольниками, а затем преобразуя их в шестиугольники.
Надеюсь, я убедил вас, что сетки треугольников — недооценённый инструмент.
*Процедурная генерация сетки треугольников, выполненная [Tessera](https://assetstore.unity.com/packages/tools/level-design/tessera-procedural-tile-based-generator-155425)*
Дополнительные материалы
------------------------
[В моей следующей статье рассказывается о расширенных возможностях сеток треугольников](https://www.boristhebrave.com/2021/05/27/some-triangle-grid-extensions/).
Статья RedBlobGaming о [сетках](http://www-cs-students.stanford.edu/~amitp/game-programming/grids/) по-прежнему остаётся лучшим ресурсом для изучения сеток. Я слышал, что он работает над обновлённой версией.
Также могу порекомендовать вам [статью Джастина Помбрио о преобразовании из пикселей в шестиугольники](https://justinpombrio.net/programming/2020/04/28/pixel-to-hex.html), из которой я узнал, как удобно работает система треугольников и как она связана с сетками шестиугольников. | https://habr.com/ru/post/560586/ | null | ru | null |
# Распознавание речи во FreePBX с помощью Яндекс Speechkit
Привет, хабр!
Решил поделиться опытом интеграции Asterisk и сервиса Яндекса по распознаванию речи.
Загорелось моему заказчику внедрить в свою АТС фичу Voice2Text.
В качестве АТС использовался FreePBX.
Сразу в голову пришло использование сервисов распознавания речи от Google, но после нескольких часов безуспешных попыток добиться нужного результата решил попробовоть аналогичный сервис Яндекса.
Подробности под катом.
Исходные данные:
FreePBX Distro 12 Stable-6.12.65, CentOS 6.5, Asterisk 11 + неимоверное желание реализовать фичу Voice2Text :)
По умолчанию FreePBX пишет все записи в .wav, нам же нужно передать файлы на распознавание в .mp3. Для это воспользуемся sendmailmp3.
Работу sendmailmp3 можно разбить на некоторые этапы:
* «поймать» поток
* проанализировать содержание электронной почты
* разделить сообщение на части
* извлечь аудиофайл
* конвертировать wav в mp3
* восстановить содержимое почты
* Передать сообщение команде sendmail
Воспользуемся скриптом, который установит sendmailmp3 и все необходимые для работы пакеты.
Переходим в /tmp:
```
cd /tmp
```
Cкачиваем скрипт, который установит sendmailmp3:
```
wget http://pbxinaflash.com/installmp3stt.sh
```
Делаем файл исполняемым:
```
chmod +x installmp3stt.sh
```
И запускаем скрипт:
```
./installmp3stt.sh
```
Далее идем в веб-интерфейс FreePBX, Вкладка Settings, Voicemail Admin, Settings:
И там в поле mailcmd пишем /usr/sbin/sendmailmp3
А в поле format: wav
Теперь наши сообщения будут пересылаться на почту в формате mp3, добавим фичу Voice2Text.
Выбор сервисов Яндекса обусловлен тем, что можно отсылать файл прямо в mp3, а не перекодировать во flac или speex (по крайней мере другой информации о поддерживаемых форматах я не нашел), а также тем, что максимальная длина сообщения значительно больше нежели у гугла.
Прежде чем наш скрипт начнет полноценно работать, необходимо пройти по [ссылке](https://tech.yandex.ru/speechkit/cloud/doc/dg/concepts/About-docpage/), далее зайти в кабинет разработчика, авторизироваться в нем с помощью почтового ящика яндекса и запросить API-ключ. После этого вам придет письмо на указанную почту с дальнейшими инструкциями:
После того, как ваш ключ активирован, необходимо сформировать curl-запрос, который будет отсылать наш файлик на распознавание. Вид должен быть следующий:
[asr.yandex.net/asr\_xml](https://asr.yandex.net/asr_xml)?
uuid=<уникальный идентификатор пользователя>
& key=
& topic=<тема голосового запроса>
& [lang=<язык запроса>]
Поддерживаются следующие форматы:
* audio/x-speex 1
* audio/x-pcm;bit=16;rate=8000
* audio/x-pcm;bit=16;rate=16000 2
* audio/x-alaw;bit=13;rate=8000
* audio/x-wav
* audio/x-mpeg-3 3
Ответ возвращается в виде XML, содержащего n-best список гипотез распознавания (до 5 значений) с указанием степени достоверности для каждой гипотезы.
Пример удачного распознавания:
xml version=«1.0» encoding=«utf-8»?
улица басманная
Пример неудачного распознавания:
xml version=«1.0» encoding=«utf-8»?
/>
В результате чего на указанный вами почтовый ящик падает сообщение с вариантами распознавания и аттачем с mp3-файлом подобное этому:
Получившийся в результате скрипт имеет следующий вид:
**sendmailmp3**
```
#! /bin/sh
# Asterisk voicemail attachment conversion script, including voice recognition using Google API
#
# Revision history :
# 22/11/2010 - V1.0 - Creation by N. Bernaerts
# 07/02/2012 - V1.1 - Add handling of mails without attachment (thanks to Paul Thompson)
# 01/05/2012 - V1.2 - Use mktemp, pushd & popd
# 08/05/2012 - V1.3 - Change mp3 compression to CBR to solve some smartphone compatibility (thanks to Luca Mancino)
# 01/08/2012 - V1.4 - Add PATH definition to avoid any problem (thanks to Christopher Wolff)
# 31/01/2013 - V2.0 - Add Google Voice Recognition feature (thanks to Daniel Dainty idea and sponsoring :-)
# 04/02/2013 - V2.1 - Handle error in case of voicemail too long to be converted
# set language for voice recognition (en-US, en-GB, fr-FR, ...)
LANGUAGE="ru_RU"
# set PATH
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
# save the current directory
pushd .
# create a temporary directory and cd to it
TMPDIR=$(mktemp -d)
cd $TMPDIR
# dump the stream to a temporary file
cat >> stream.org
# get the boundary
BOUNDARY=`grep "boundary=" stream.org | cut -d'"' -f 2`
# cut the file into parts
# stream.part - header before the boundary
# stream.part1 - header after the bounday
# stream.part2 - body of the message
# stream.part3 - attachment in base64 (WAV file)
# stream.part4 - footer of the message
awk '/'$BOUNDARY'/{i++}{print > "stream.part"i}' stream.org
# if mail is having no audio attachment (plain text)
PLAINTEXT=`cat stream.part1 | grep 'plain'`
if [ "$PLAINTEXT" != "" ]
then
# prepare to send the original stream
cat stream.org > stream.new
# else, if mail is having audio attachment
else
# cut the attachment into parts
# stream.part3.head - header of attachment
# stream.part3.wav.base64 - wav file of attachment (encoded base64)
sed '7,$d' stream.part3 > stream.part3.wav.head
sed '1,6d' stream.part3 > stream.part3.wav.base64
# convert the base64 file to a wav file
dos2unix -o stream.part3.wav.base64
base64 -di stream.part3.wav.base64 > stream.part3.wav
# convert wav file to mp3 file
# -b 24 is using CBR, giving better compatibility on smartphones (you can use -b 32 to increase quality)
# -V 2 is using VBR, a good compromise between quality and size for voice audio files
lame -m m -b 24 stream.part3.wav stream.part3.mp3
# convert back mp3 to base64 file
base64 stream.part3.mp3 > stream.part3.mp3.base64
# generate the new mp3 attachment header
# change Type: audio/x-wav to Type: audio/mpeg
# change name="msg----.wav" to name="msg----.mp3"
sed 's/x-wav/mpeg/g' stream.part3.wav.head | sed 's/.wav/.mp3/g' > stream.part3.mp3.head
# convert wav file to flac compatible for Google speech recognition
# sox stream.part3.wav -r 16000 -b 16 -c 1 audio.flac vad reverse vad reverse lowpass -2 2500
# call Google Voice Recognition sending flac file as POST
curl -v -4 "asr.yandex.net/asr_xml?key=23988820-8719-4a2e-82ba-9ddd5a9bfe67&uuid=12345678123456781234567812345678&topic=queries⟨=ru-RU" -H "Content-Type: audio/x-mpeg-3" --data-binary "@stream.part3.mp3" 1>audio.txt
# curl --data-binary @audio.flac --header 'Content-type: audio/x-flac; rate=16000' 'https://www.google.com/speech-api/v2/recognize?key=AIzaSyB5lwncPRYpNrHXtN-Sy-LNDMLLU5vM1n8&xjerr=1&client=chromium&pfilter=0⟨='ru_RU'&maxresults=1' 1>audio.txt
# extract the transcript and confidence results
FILETOOBIG=`cat audio.txt | grep ""`
TRANSCRIPT=`cat audio.txt | cut -d"," -f3 | sed 's/^.\*utterance\":\"\(.\*\)\"$/\1/g'`
CONFIDENCE=`cat audio.txt | cut -d"," -f4 | sed 's/^.\*confidence\":0.\([0-9][0-9]\).\*$/\1/g'`
# generate first part of mail body, converting it to LF only
mv stream.part stream.new
cat stream.part1 >> stream.new
sed '$d' < stream.part2 >> stream.new
# beginning of transcription section
echo "---" >> stream.new
# if audio attachment is too big
if [ "$FILETOOBIG" != "" ]
then
# error message
echo "Voice message is too long to be transcripted." >> stream.new
else
# append result of transcription
echo "Message seems to be ( $CONFIDENCE% confidence ) :" >> stream.new
echo "$TRANSCRIPT" >> stream.new
fi
# end of message body
tail -1 stream.part2 >> stream.new
# append mp3 header
cat stream.part3.mp3.head >> stream.new
dos2unix -o stream.new
# append base64 mp3 to mail body, keeping CRLF
unix2dos -o stream.part3.mp3.base64
cat stream.part3.mp3.base64 >> stream.new
# append end of mail body, converting it to LF only
echo "" >> stream.tmp
echo "" >> stream.tmp
cat stream.part4 >> stream.tmp
dos2unix -o stream.tmp
cat stream.tmp >> stream.new
fi
# send the mail thru sendmail
cat stream.new | sendmail -t
# go back to original directory
popd
# remove all temporary files and temporary directory
sleep 50
rm -Rf $TMPDIR
```
На мой взгляд этот вариант несколько проще, нежели было описано [тут](http://habrahabr.ru/post/225179/), т.к. все сводится к запуску и изменению одного скрипта и пары кликов в веб-интерфейсе, а также присылает записи в mp3, а не в .wav. Безусловно, кто-то скажет, что это не unix-way:), но может кому-то будет полезно, хотя бы в целях ознакомления. | https://habr.com/ru/post/242109/ | null | ru | null |
# Windows service. Поиск системных ошибок и отображение их в WinForm C#
В этой статье мы разберем как с нуля создать приложение, которое будет работать со службами windows и отображать системные ошибки в WinForm (C#).
План этой статьи:
* Создание службы
* Event Viewer
* Код службы
* Проверка работы службы(Запуск службы вручную)
* Отображение WinForm
#### Создание службы
Открываем Visual Studio. Дальше File → New → Project → (Windows Desktop) → Windows Service (.Net Framework) → Ok.
Дальше нужно создать установщик. В открывшемся окне щелкаем ПКМ и выбираем «Add Installer». У вас создастся «ProjectInstaller.cs[Design]» после чего нужно будет перейти к коду «F7» или ПКМ «View Code». Нужно найти строку «InitializeComponent();», поставить на нее курсор и нажать «F12», дальше нужно добавить следующие строки:
```
this.serviceProcessInstaller1.Account = System.ServiceProcess.ServiceAccount.LocalSystem; //Чтоб не запрашивало имя пользователя и пароль
this.serviceInstaller1.Description = "Show me system error."; //Описание которое будет видно в списке служб
this.serviceInstaller1.DisplayName = "GetSystemError"; //Название службы которое будет видно в списке служб
```
Но добавлять эти строки нужно только в следующей последовательности и месте. Иначе будет ошибка при установке сервиса.
#### Event Viewer
Это нужно для проверки правильной работы нашей программы.
Event Viewer — программа для просмотра журнала событий которая есть на каждом компьютере с windows. Каждая программа, которая запускается на компьютере, публикует уведомление в журнале событий до того, как останавливается. Любой доступ к системе, изменение безопасности, подстройка операционной системы, аппаратный сбой и сбой драйвера — все это попадает в журнал событий. Event Viewer сканирует файлы текстового журнала, объединяет их и помещает в интерфейс.
Как его открыть? — Пуск → Event Viewer(в поиске) → «Просмотр журналов событий».
Дальше «Настраиваемые представления (Custom Views)» → «События управления (Administrative Events)». Тут мы можем увидеть все ошибки, предупреждения и информацию о них.
Есть 3 типа журнала: приложение(Application), системные(System) и безопасность(Security). Нам нужен только системный(System).
#### Код службы
Находим файл .cs с названием службы, у меня это «Service1.cs», открываем. В файле должно быть заготовлено 2 переопределенных метода:
* OnStart(string[] args) — выполняется при запуске службы,
* OnStop() — выполняется при остановке службы.
Есть так же еще несколько методов но они нам сейчас не потребуются. Найти их можно самостоятельно.
Данные которые мы получаем будем хранить в обновляемом текстовом файле, поэтому добавляем
```
using System.IO;
```
Добавляем код в метод OnStart(string[] args):
```
EventLog myLog; //Можно читать и записывать элементы журнала событий
string filepath = AppDomain.CurrentDomain.BaseDirectory + @"\ServiceLog.txt";; //Хранится путь к файлу
List list; //Список всех найденных ошибок
protected override void OnStart(string[] args)
{
myLog = new EventLog();
myLog.Log = "System"; //По умолчанию выставлен тип ошибок - приложение(Application), а нам нужны системные(System).
myLog.Source = "System Error";
for (int index = myLog.Entries.Count - 1; index > 0; index--) //Перебираем все системные ошибки от новых к более старым
{
var errEntry = myLog.Entries[index]; \\Чтение записи из журнала событий
if (errEntry.EntryType == EventLogEntryType.Error) \\Проверка ошибка ли это
{
//Получаем нужные данные из записи
var appName = errEntry.Source;
list = new List();
list.Add("Entry Type: " + Convert.ToString(errEntry.EntryType));
list.Add("Event log: " + (string)myLog.Log);
list.Add("Machine Name: " + (string)errEntry.MachineName);
list.Add("App Name: " + (string)errEntry.Source);
list.Add("Message: " + (string)errEntry.Message);
list.Add("Time Written: " + errEntry.TimeWritten.ToString());
list.Add("-\*-");
WriteToFile(list); //Записываем данные в файл
}
}
}
public void WriteToFile(List list) //Запись в файл
{
using (StreamWriter sw = File.AppendText(filepath))
{
for (int i = 0; i < list.Count; i++)
sw.WriteLine(list[i]);
}
}
```
Дальше нужно собрать решение «Solution» -> «Rebuild Solution». После успешной сборки можно проверять работу.
#### Проверка работы службы(Запуск службы вручную)
Службу windows нельзя запускать как обычное приложение. Можно запустить только через командную строку от имени администратора.
Запускаем командную строку от имени администратора. Ввести следующие команды:
```
cd C:\Windows\Microsoft.NET\Framework\v4.0.30319
InstallUtil.exe Путь\Имя вашей службы.exe
(InstallUtil.exe C:\Users\Анжелика\source\repos\WindowsService1\WindowsService1 \bin\Debug\WindowsService1.exe)
Команда для удаления сервиса: InstallUtil.exe -u Путь\Имя вашей службы.exe
```
Дальше нажимаем клавишу Win+R. Вводим «Services.msc». Находим в списке свой сервис, нажимаем на него, и нажимаем «Запустить(Start)». После успешного запуска сформируется файл по указанному в коде пути в котором будет находиться список системных ошибок.
Не забываем удалить службу после проверки.
#### Отображение WinForm
Для отображения в консоли если постараться то можно найти статьи, но для отображения в WinForm я так и не нашла, так что вот. По умолчанию проект службы создается типа «Application». Для отображения через консоль этот параметр в настройках нужно поменять, для WinForm оставить как есть. Дальше нужно добавить форму в проект. «WindowsService1» → ПКМ → Add → Windows Form → Add. И делаем примерно следующий дизайн. Дальше меняем файл «Program.cs».
Добавляем using:
```
using System.Windows.Forms;
using System.Security.Principal;
using System.ComponentModel;
using System.Diagnostics;
```
И меняем метод Main:
```
static void Main(string[] args)
{
WindowsPrincipal windowsPricipal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
bool hasAdministrativeRight = windowsPricipal.IsInRole(WindowsBuiltInRole.Administrator);
if (hasAdministrativeRight == false) //проверка на права администратора
{
ProcessStartInfo processInfo = new ProcessStartInfo(); //создаем новый процесс
processInfo.Verb = "runas"; //процесс должен быть запущен с правами администратора
processInfo.FileName = Application.ExecutablePath;
try
{
Process.Start(processInfo); //пытаемся запустить процесс
}
catch (Win32Exception){}
Application.Exit();
}
else
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(args)); //Запускаем форму
}
}
```
Добавляем новый класс «SystemError». («WindowsService1» -> ПКМ -> Add -> Class -> Add). Тут мы будем хранить данные об ошибках. Меняем его:
```
public string EntryType{ get; set; }
public string EventLog{ get; set; }
public string MachineName { get; set; }
public string AppName { get; set; }
public string Message { get; set; }
public string TimeWritten { get; set; }
```
Дальше в «Service1.cs» добавляем метод «RunFromForm(string[] args)» который запускает службу.
```
public void RunFromForm(string[] args)
{
OnStart(args);
OnStop();
}
```
Добавляем новый класс «GetListErrors». («WindowsService1» -> ПКМ -> Add -> Class -> Add). Тут мы будем доставать данные из файла. Добавляем using:
```
using System.IO;
```
Меняем его:
```
string filepath = AppDomain.CurrentDomain.BaseDirectory + @"\ServiceLog.txt";
SystemError systemError;
public List listSysErrs;
public void ReadFile() //Метод чтения из файла и запись в список системных ошибок
{
systemError = new SystemError();
listSysErrs = new List();
using (StreamReader sr = new StreamReader(filepath))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.Contains("-\*-"))
{
listSysErrs.Add(systemError);
systemError = new SystemError(); //Создается новый элемент системной ошибки в списке
}
if (line.Contains("Entry Type"))
{
systemError.EntryType = line.Substring(12);
}
else if (line.Contains("Event log"))
{
systemError.EventLog = line.Substring(11);
}
else if (line.Contains("Machine Name"))
{
systemError.MachineName = line.Substring(14);
}
else if (line.Contains("App Name"))
{
systemError.AppName = line.Substring(10);
}
else if (line.Contains("Message"))
{
systemError.Message = line.Substring(9);
}
else if (line.Contains("Time Written"))
{
systemError.TimeWritten = line.Substring(14);
}
}
}
}
```
Дальше меняем код формы «Form1.cs». Добавляем using:
```
using System.ServiceProcess;
using System.Diagnostics;
```
Меняем его:
```
Service1 service = new Service1();
List listSysErrs;
string[] args;
public Form1(string[] args)
{
InitializeComponent();
this.args = args;
if (Environment.UserInteractive)//Проверяет выполняется ли текущий процесс в режиме взаимодействия с пользователем
{
service.RunFromForm(args); //Запускаем службу
GetListErrors getListErrors = new GetListErrors();
getListErrors.ReadFile(); //получаем данные из файла результата службы
listSysErrs = getListErrors.listSysErrs;
FillDataGridView(); //Отображаем список в таблице
}
else
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { service };
ServiceBase.Run(ServicesToRun);
}
}
public void FillDataGridView() //Заполняет таблицу данными из списка
{
foreach (SystemError item in listSysErrs)
{
dataGridView1.Rows.Add(item.AppName, item.Message);
}
}
private void dataGridView1\_CellClick(object sender, DataGridViewCellEventArgs e) //При нажатии на любую ячейку на панели будут отображаться больше данных именно по ошибке которую нажали
{
SystemError sys = listSysErrs[dataGridView1.CurrentRow.Index];
label1.Text = "Entry Type: " + sys.EntryType +
"\nEvent log: " + sys.EventLog +
"\nMachine Name: " + sys.MachineName +
"\nApp Name: " + sys.AppName +
"\n\nMessage: " + FormatMessage(sys.Message) +
"\n\nTime Written: " + sys.TimeWritten;
}
private string FormatMessage(string msg) //Так как весь текст не помещается на панель, то нужно подкорректировать строку так чтоб она была видна полностью а не уходила бы в закат
{
string retMsg = "";
int count = 75;
if (msg.Length > count - 9)
{
retMsg += msg.Substring(0, count - 9) + "\n";
msg = msg.Substring(count - 9);
}
while (msg.Length > count)
{
retMsg += msg.Substring(0, count) + "\n";
msg = msg.Substring(count);
}
retMsg += msg + "\n";
return retMsg;
}
private void button1\_Click(object sender, EventArgs e) //По нажатию на кнопку мы перезапускаем службу как и ранее
{
if (Environment.UserInteractive)
{
while (dataGridView1.Rows.Count != 0)
{
dataGridView1.Rows.Remove(dataGridView1.Rows[dataGridView1.Rows.Count - 1]);
}
service.RunFromForm(args);
GetListErrors getListErrors = new GetListErrors();
getListErrors.ReedFile();
listSysErrs = getListErrors.listSysErrs;
FillDataGridView();
}
else
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { service };
ServiceBase.Run(ServicesToRun);
}
}
private void button2\_Click(object sender, EventArgs e)
{
Process.Start(AppDomain.CurrentDomain.BaseDirectory); //Выбираем файл
}
```
Теперь можно запускать службу как обычное приложение. Выглядит результат следующим образом:
 | https://habr.com/ru/post/452688/ | null | ru | null |
# Как убивать зомби эффективнее с ZeroTier
[](https://habr.com/ru/company/ruvds/blog/500760/)
У вас есть сервер под кроватью, умный дом на даче, а еще IP-камера в гараже. Как их всех объединить в одну сеть чтобы иметь доступ ко всем устройствам? В таких ситуациях принято использовать VPN, но есть решение эффективнее — ZeroTier. Он создает одноранговую (P2P) сеть между устройствами при этом настраивается сильно проще, чем VPN.
У нас уже выходил [цикл статей](https://habr.com/ru/company/ruvds/blog/485914/) про организацию P2P сети для удаленной поддержки пользователей. В ней мы рассматривали вариант построение децентрализированной виртуальной сети при помощи ZeroTier. В отличии от традиционных решений VPN в ZeroTier отсутствует центральный управляющий сервер и соединение устанавливается напрямую между устройствами.
Я часто использую ZeroTier для двух кейсов: подключаться к устройствам клиентов, чтобы оказать поддержку и убивать зомби в шутерах. Мне стало интересно сравнить альтернативные способы подключения по локальной сети.
Если вы хотите разобраться в принципе работы ZeroTier, про это мы выпускали подробную [статью с разбором](https://habr.com/ru/company/ruvds/blog/484178/).
Подключение по RDP для удаленной поддержки
------------------------------------------
Почти каждый день мне приходится подключаться к клиенту ~~для подавления восстания машин~~, чтобы помочь что-то решить. В условиях пандемии это коллеги, работающие из дома.
Для работы с внутренними сервисами компании требуется аутентификация из корпоративной сети и на офисном роутере давно поднят VPN на случай необходимости удаленно что-то где-то сделать.
Для меня подключиться к нему и прописать пару маршрутов в системе не составляет труда, но рядовому пользователю это оказалось трудоемким. Так когда-то сформировалась потребность в простом решении, которое позволит пострадавшему пользователю легко дать доступ к своему компьютеру.
Я даже не рассматривал тогда Teamviewer или Radmin из-за ограничений и стоимости. К тому же я сторонник православного RDP, а не сторонних утилит. Хотелось, чтобы решение было максимально простым в реализации и человеку потребовались минимум действий со своей стороны. А так как я переживаю не только за сотрудников родной, любимой компании и иногда помогают и сторонним персонажам, использовать корпоративный VPN-сервер было бы неправильным.
Что я сравнивал с ZeroTier
--------------------------
В сети можно найти несколько простых решений для реализации виртуальной сети:
* Tunngle, который уже не работает;
* Evolve, который слился с Player.me;
* Hamachi;
* Radmin VPN;
* И ZeroTier, который есть у нас прямо в [маркетплейсе](https://ruvds.com/ru-rub/marketplace).
Я планировал просить клиента установить одно из вышеперечисленных ПО, скачать и выполнить следующий скрипт, для включения RDP:
`# Execute with Administrator rights
$path = $MyInvocation.MyCommand.Path
if ($args[0] -ne $null) {
$path = $args[0]
}
$path = Split-Path -Path $path
$windowsID = [System.Security.Principal.WindowsIdentity]::GetCurrent()
$windowsPrincipal = New-Object System.Security.Principal.WindowsPrincipal($windowsID)
$adminRole=[System.Security.Principal.WindowsBuiltInRole]::Administrator
if ($windowsPrincipal.IsInRole($adminRole)) {
$Host.UI.RawUI.WindowTitle = $myInvocation.MyCommand.Definition + "(Elevated)"
$Host.UI.RawUI.BackgroundColor = "DarkBlue"
clear-host
}
else {
$newProcess = New-Object System.Diagnostics.ProcessStartInfo "PowerShell";
$newProcess.WorkingDirectory = $path;
$newProcess.Arguments = $myInvocation.MyCommand.Definition;
$newProcess.Verb = "runas";
[System.Diagnostics.Process]::Start($newProcess);
exit
}
# Set RDP enabled
Set-ItemProperty -Path "HKLM:\System\CurrentControlSet\Control\Terminal Server" -Name "fDenyTSConnections" –Value 0
# Create firewall rule
New-NetFirewallRule -DisplayName "Remote Desktop Allow TCP" -Program "%SystemRoot%\system32\svchost.exe" -Action Allow -Protocol TCP -LocalPort 3389 -Direction Inbound -Enabled True
New-NetFirewallRule -DisplayName "Remote Desktop Allow UDP" -Program "%SystemRoot%\system32\svchost.exe" -Action Allow -Protocol UDP -LocalPort 3389 -Direction Inbound -Enabled True
# Add user to RDU group
$User = $env:USERNAME
Add-LocalGroupMember -SID "S-1-5-32-555" -Member $User`
Параметры оценки каждой программы
---------------------------------
Все решения я оценивал по параметрам:
* Скорость передачи файлов по локальной сети;
* Простота установки, настройки и использования;
* Стоимость и ограничения;
* Функционал;
* Game (об этом в конце).
Моя оценка по каждому параметру субъективна и достойна критики. Поэтому я сконцентрировался на параметрах, которые можно измерить через тесты.
Hamachi
-------
На момент написания статьи, последняя версия программы «LogMeIn Hamachi for Windows 2.2.0.633» и вышла она в марте 2019-го. В бесплатной версии есть ограничение в 5 одновременных подключений к одной сети. Стоимость полной версии начинается с 49$ в год.
Чтобы начать работу, нужно:
* Зарегистрироваться в сервисе;
* Установить ПО;
* Создать или подключиться к готовой сети через графическое приложение.
Для оценки скорости передачи файлов я использовал CrystalDiskMark, выполняя тестирования чтения/записи в предварительно расшаренной для локальной сети папки и простое копирование большого файла.
При учете, что все тесты выполняются на двух пк с неизменной конфигурацией (в каждом тесте один и тот же диск, одни и те же настройки системы и прочее) результаты CrystalDiskMark должны давать представление о скорости передачи данных.
Ремарка: уже после написания статьи я засомневался, что выбрал лучшее решение для тестирования. Думаю в комментариях будет предложен лучший подход.
Результат по времени: копирование 9 Gb файла заняло ровно 21 минуту.
Результаты CrystalDiskMark.
Пинг между ПК не превышал 10ms.
Radmin VPN
----------
Последняя версия «Radmin VPN 1.1.3969.3» вышла в декабре 2019-го. Это полностью бесплатное приложение, с минималистичным дизайном и не требует даже регистрации.
Все что нужно, это:
* Скачать;
* Установить;
* Подключиться к сети;
* Скушать пончик.
Скорость передачи файлов значительно ниже, чем у Hamachi. 9Gb передавались добрых 43 минуты.
Результаты CrystalDiskMark также ниже чем у Hamachi.
Пинг: 10-11ms.
Возможно, если бы не съеденный пончик, то результаты были бы другими. При подключении по RDP никаких особых проблем не было.
ZeroTier
--------
Это уникальный в своем роде open source проект:
* Он доступен в виде публичного облачного решения;
* Предоставляется по модели SaaS;
* У него четыре плана подписки.
Дальше я буду рассматривать именно open source решение от стороннего разработчика: [ZeroTier network controller user interface](https://github.com/key-networks/ztncui).
Мы уже подробно рассматривали принцип его работы в [этой статье](https://habr.com/ru/company/ruvds/blog/484178/). Я перечислю лишь главные особенности, которые делают его таким интересным:
1. Так как мы говорим о P2P сети, трафик идет не через поднятый нами узел, а напрямую от устройства к устройству. Узел нужен исключительно для первоначальной установки соединения. Далее, он не участвует в работе. Узел можно и вовсе выключить, связь не будет разорвана. Он потребуется только в случае повторного подключения.
2. Узел нетребователен к ресурсам. Он спокойно работает на нашем [самом дешевом VPS](https://ruvds.com/vps_start/) за 130 р. в месяц (или 30 рублей, если успели отхватить тот самый тариф).
3. Нет ограничения на количество пользователей и сетей: можно подключать весь свой универский поток и устроить встречу одногруппников в Контрстрайк.
Чтобы создать узел, нам потребуется поднять VPS с серверной частью приложения. Процесс также был описан [ранее](https://habr.com/ru/company/ruvds/blog/485914/).
Клиентская часть ZeroTier One обладает минималистичным дизайном и очень скромным набором параметров. Нам потребуется отправить пользователю только ID нашего узла и авторизовать его.
9Gb летело 20 минут. Чуть быстрее чем Hamachi.
CrystalDiskMark также показал чуть более высокие значения.
Ping как и везде прыгал около 10ms.
Кейс второй: как ~~позадротить~~ культурно отдохнуть за офисным слабеньким ПК
-----------------------------------------------------------------------------
ZeroTier дает еще одну возможность — популярный сейчас способ стриминга игры на другое устройство (а-ля GeForce Now). Для этого есть сразу три альтернативы ZeroTier: RDP, Parsec и Moonlighrt. Давайте протестируем их.
### ▍ RDP
К сожалению, не приспособлен для такого. Большинство опробованных мною игр просто отказывались нормально работать. Либо крашились из-за несовместимости видеодрайвера, либо просто не реагировали на управление.
### ▍ Parsec
Это специализированный бесплатный софт, созданный для проброса видеоряда между ПК с акцентом на сверх низкую задержку. В отличии от Teamviewer или Radmin, Parsec способен в относительном комфорте передавать стабильные 60 FPS при FullHD изображении (чтобы не получать дрейкфейс снова и снова).
Для комфортного использования рекомендуется, чтобы у хоста было кабельное подключение со скоростью не ниже 30 Мбит/с.
В абсолютное большинство игр, можно комфортно играть, не испытывая высокий input lag, но, к сожалению, при этом страдает качество картинки. Из-за методов сжатия, на контрастных элементах изображение разбивается на пиксели и это сильно режет глаза. В FPS-зависимые игры, например шутеры, не удастся поиграть с должным уровнем комфорта. Input lag хоть и низкий, но время от времени заметны некоторые подергивания изображения, что хоть и не мешает меткой стрельбе, но раздражает.
В чем Parsec точно превосходит другие решения, так это в локальный ко-оп. Ввиду того что Parsec просто позволяет делиться изображением монитора, в любую локал ко-оп игру возможно поиграть без проблем. Причем расстояние между вами не играет роли. Я с удовольствием играл в Cuphead с другом из Новосибирска и не испытал каких-либо проблем с реакцией на происходящие.
Parsec также неплох и в повседневном рабочем использовании. Он шустрее, передает более качественное изображение по сравнению с Teamviewer и в нем отсутствуют какие-либо лимиты на количество удаленных рабочих столов. Однако для таких целей всегда я использую RDP, банально за встроенность в ОС и возможность проброса локальных накопителей.
### ▍ Moonlight
Это Open source, полностью бесплатное решение для игр на удаленке.
Процитирую их сайт:
> Moonlight (ранее Limelight) — это реализация протокола NVIDIA GameStream с открытым исходным кодом. Мы реализовали протокол, используемый NVIDIA Shield, и написали набор сторонних клиентов.
Самое очевидное и главное достижение Moonlight это возможность транслировать 4K видеоряд **при 120 и больше FPS** с полным отсутствием каких-либо задержек.
Moonlight работает только при условии, что на хостовой машине установлена карта Nvidia. Связанно это с тем, что проект эмулирует NVIDIA Shield и напрямую работает с драйвером. Именно это и позволяет транслировать 4K 120FPS без задержек в условиях локальной сети.
Помимо этого, второй недостаток Moonlight это отсутствие возможности играть по сети интернет без дополнительных танцев с бубном.
### ▍ Moonlight + Hamachi
К сожалению, у меня отсутствует карта захвата, а снимать монитор на телефон я просто не могу… Поэтому вам придется либо поверить моим словам либо самостоятельно протестировать каждое решение. Пропускной способности Hamachi хватает для комфортной игры в 2K 60-120FPS. При увеличении разрешения микрофризы становятся ощутимо сильнее.
Играть в FPS-зависимые игры возможно, но то тут, то там игра может зависнуть на четверть секунды. Parsec все же лучше себя показывает, с точки зрения минимизации задержек. Однако проигрывает по качеству изображения. Тут уже решать вам, что важнее: минимальный input lag и артефакты изображения или идеальная картинка, но микро-фризы?
### ▍ Moonlight + Radmin VPN
Radmin VPN повел себя так же, как и в синтетике. Относительно комфортно поиграть вышло только в FullHD и 60FPS. Разрешение чуть выше приводило к невыносимому слайдшоу. А время от времени картинка и вовсе замирала секунды на 2. К сожалению, эта связка показала себя хуже всего.
### ▍ Moonlight + ZeroTier
А вот теперь мы подобрались к вкусной парочке. Что и говорить, но официальный репозиторий Moonlight, советует именно ZeroTier для построения P2P соединения. Мне буквально не удалось отличить геймплей запущенной удаленно игры от запуска на локальном ПК. Все заявленные Moonlight фичи работают. Жаль, что у моего друга из Новосибирска карта от AMD и тестировать пришлось в рамках одного города, призвав брата (это север и юг Москвы).
Изображение плавное разрешение вплоть до 4K и идет без каких-либо тормозов. Отклик на нажатия мгновенный, в шутеры так играть можно. Пожалуй, эта связка лучший вариант для cloud гейминга.
Выводы
------
**ZeroTier** — пожалуй, лучшее доступное решение для быстрого построения peer-to-peer сетей. Да, его функционал не позволит строить сложные сети и не даст доступ ко всему многообразию настроек классического L2TP/IPsec. Но это далеко не всегда нужно для простых задач.
**Parsec** — наверное, единственный вариант для удаленной игры в проекты, поддерживающие локальный кооператив или раздельный экран (мне сразу вспомнился Lovers in a Dangerous Spacetime). Он не привязан к конкретной технологии физического оборудования и не требует дополнительной настройки сети. Однако, он может сильно пережимать качество изображения. В отсутствии возможности подключиться к удаленному пк штатными способами, подходит для быстрой компьютерной помощи.
**Moonlight** — Если на вашем игровом ПК установлена карта Nvidia то Moonlight + ZeroTier идеальная пара для удаленного гейминга. Проблему с настройкой виртуальной сети ZeroTier решает просто и элегантно. Moonlight, благодаря эмуляции Nvidia Shield, позволяет передавать потрясающую картинку без задержек. Он не дает возможности удаленной настройки ПК, но выше я описал другие решения.
[](http://ruvds.com/ru-rub/?utm_source=habr&utm_medium=article&utm_campaign=zaika&utm_content=usingzerotier#order) | https://habr.com/ru/post/500760/ | null | ru | null |
# Анализ шифровальщика Wana Decrypt0r 2.0
Анализ шифровальщика Wana Decrypt0r 2.0 для выявления функционала, анализа поведения и способов распространения вредоноса.
Wanna Decrypt0r, распространяемый через SMB — это вторая версия Wanna Cry, который распространялся более классическими способами (фишинг), поэтому он имеет индекс 2.0. В данный момент существуют минимум три ветки шифровальщика: фишинговая (первая), киллсвитч (первая волна), без киллсвитчера (выпущенная буквально несколько часов назад). По состоянию 22:00 14.05.2017 [обнаружены](https://geektimes.ru/post/289153/) второй и третий варианты вредоноса, в том числе без киллсвитчера.
Статистика
----------
### Заражения:
В настоящий момент (19:00 GMT+3) заражено 236,648 машин (вероятнее всего завтра эта цифра значительно увеличится). Хотя управляющий (вернее, отвечающий за распространение) домен удалось засинкхолить, судить о количестве заражений по "отстуку" на этот домен — неверно. Часть зараженных машин может находиться за NAT или отключена от глобальной сети.
### Выплаты:
Выкуп за расшифровку перечисляются на три биткоин кошелька:
* 115p7UMMngoj1pMvkpHijcRdfJNXj6LrLn: 4.33279223 BTC — $7799
* 13AM4VW2dhxYgXeQepoHkHSQuy6NgaEb94: 6.00472753 BTC — $10808
* 12t9YDPgwueZ9NyMgw519p7AA8isjr6SMw: 8.78127705 BTC — $15806
### Командные центры:
* gx7ekbenv2riucmf.onion
* 57g7spgrzlojinas.onion
* xxlvbrloxvriy2c5.onion
* 76jdd2ir2embyv47.onion
* cwwnhwhlz52maqm7.onion
### Поддерживаемые языки:
```
m_bulgarian, m_chinese (simplified), m_chinese (traditional), m_croatian, m_czech, m_danish, m_dutch, m_english, m_filipino, m_finnish, m_french, m_german, m_greek, m_indonesian, m_italian, m_japanese, m_korean, m_latvian, m_norwegian, m_polish, m_portuguese, m_romanian, m_russian, m_slovak, m_spanish, m_swedish, m_turkish, m_vietnamese
```
### Атрибуция:
Создать вредонос мог кто угодно, явных признаков, способных выявить авторов, пока не обнаружено, за исключением [следующей информации](https://pastebin.com/0LrH05y2):
```
00:34 < nulldot> 0x1000ef48, 24, BAYEGANSRV\administrator
00:34 < nulldot> 0x1000ef7a, 13, Smile465666SA
00:34 < nulldot> 0x1000efc0, 19, wanna18@hotmail.com
00:34 < nulldot> 0x1000eff2, 34, 1QAc9S5EmycqjzzWDc1yiWzr9jJLC8sLiY
00:34 < nulldot> 0x1000f024, 22, sqjolphimrr7jqw6.onion
00:34 < nulldot> 0x1000f088, 52, https://www.dropbox.com/s/deh8s52zazlyy94/t.zip?dl=1
00:34 < nulldot> 0x1000f0ec, 67, https://dist.torproject.org/torbrowser/6.5.1/tor-win32-0.2.9.10.zip
00:34 < nulldot> 0x1000f150, 52, https://www.dropbox.com/s/c1gn29iy8erh1ks/m.rar?dl=1
00:34 < nulldot> 0x1000f1b4, 12, 00000000.eky
00:34 < nulldot> 0x1000f270, 12, 00000000.pky
00:34 < nulldot> 0x1000f2a4, 12, 00000000.res
```
### Killswitch домен:
iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com. Уже существуют версии шифровальщика без этой функции.
### Шифрует файлы следующих расширений:
```
.doc, .docx, .xls, .xlsx, .ppt, .pptx, .pst, .ost, .msg, .eml, .vsd, .vsdx, .txt, .csv, .rtf, .123, .wks, .wk1, .pdf, .dwg, .onetoc2, .snt, .jpeg, .jpg, .docb, .docm, .dot, .dotm, .dotx, .xlsm, .xlsb, .xlw, .xlt, .xlm, .xlc, .xltx, .xltm, .pptm, .pot, .pps, .ppsm, .ppsx, .ppam, .potx, .potm, .edb, .hwp, .602, .sxi, .sti, .sldx, .sldm, .sldm, .vdi, .vmdk, .vmx, .gpg, .aes, .ARC, .PAQ, .bz2, .tbk, .bak, .tar, .tgz, .gz, .7z, .rar, .zip, .backup, .iso, .vcd, .bmp, .png, .gif, .raw, .cgm, .tif, .tiff, .nef, .psd, .ai, .svg, .djvu, .m4u, .m3u, .mid, .wma, .flv, .3g2, .mkv, .3gp, .mp4, .mov, .avi, .asf, .mpeg, .vob, .mpg, .wmv, .fla, .swf, .wav, .mp3, .sh, .class, .jar, .java, .rb, .asp, .php, .jsp, .brd, .sch, .dch, .dip, .pl, .vb, .vbs, .ps1, .bat, .cmd, .js, .asm, .h, .pas, .cpp, .c, .cs, .suo, .sln, .ldf, .mdf, .ibd, .myi, .myd, .frm, .odb, .dbf, .db, .mdb, .accdb, .sql, .sqlitedb, .sqlite3, .asc, .lay6, .lay, .mml, .sxm, .otg, .odg, .uop, .std, .sxd, .otp, .odp, .wb2, .slk, .dif, .stc, .sxc, .ots, .ods, .3dm, .max, .3ds, .uot, .stw, .sxw, .ott, .odt, .pem, .p12, .csr, .crt, .key, .pfx, .der
```
### Шифрование:
Для шифрования используется 2048-битный ключ RSA. На данный момент утилиты расшифровки не существует.
### Распространение:
Для распространения шифровальщика злоумышленниками используется критическая уязвимость MS17-010 в протоколе SMBv1. Хотя, согласно официальному бюллетеню безопасности, данной уязвимости подвержены версии Windows, начиная с Vista, последствия атаки оказались настолько серьезными, что компания Microsoft пошла на беспрецедентный шаг — был выпущен патч даже на снятую с поддержки Windows XP.
Злоумышленники использовали эксплоит ETERNALBLUE из архива АНБ, "слитого" группировкой ShadowBrokers. Сам комплекс представляет собой автоматизированную систему: сканер [DoublePulsar](https://github.com/countercept/doublepulsar-detection-script/blob/master/detect_doublepulsar_smb.py) для организации доступа и установки шифровальщика на уже забэкдоренные машины, либо эксплоит ETERNALBLUE.
После заражения системы шифровальщик сканирует локальную сеть для поиска других уязвимых хостов, а также сканирует случайные диапазоны сети Интернет.
Минимальное время заражения системы после выставления в интернет 445 портом — 3 минуты:
Анализ
------
Автоматизированный анализ вредоносного кода производился в специализированной системе tLab, которая представляет собой профессиональный инструмент для удаленного и безопасного анализа подозрительных объектов. Система позволяет автоматизировать процедуру анализа поведения исполняемых объектов и выявлять в них признаки вредоносных функций, далее система автоматически выдает полный интерактивный отчет. При этом используется уникальная технология глубокого анализа функциональности программ, основанная на полиморфных иерархических сетях Петри. Эта система — авторская разработка, реализованная в Казахстане компанией [T&T Security](http://tntsecure.kz/).
Компания T&T Security была основана в 2013 году в Казахстане, Астана. Основатель компании в течение последних 10 лет проводил исследования в области кибербезопасности в США. Целью создания компании является борьба с кибер-угрозами нового поколения.
В 2017 году T&T Security выпустила свой первый инновационный продукт систему [tLab](http://tntsecure.kz/tlab.html/) , которая представляет собой профессиональную поведенческую песочницу основанной на уникальной патентованной технологии обнаружения вредоносной активности. tLab может использоваться в качестве как профессионального инструмента для оперативного и глубокого анализа вредоносных объектов при SOC-центре, так и эффективной серверной песочницы для обнаружения и блокирования вредоносных объектов на периметре организации.
Анализ проводился над двумя объектами:
Объект №1
SHA256: 24d004a104d4d54034dbcffc2a4b19a11f39008a575aa614ea04703480b1022c
и
Объект №2
SHA256: ed01ebfbc9eb5bbea545af4d01bf5f1071661840480439c6e5babe8e080e41aa
tLab представляет уровень угрозы в мета-процентах (может быть более 100%), если выше предела опасности (85% по умолчанию) — считается вредоносным (выделяется красным). Предел опасности выставляется администратором tLab. Уровень угрозы вычисляется для отдельных индикаторов вредоносного/подозрительного поведения таких как шпионская активность, закрепление в ОС, эксплоит, прокси-активность и т.д. Для каждого индикатора уровень угрозы рассчитывается на основе определенных действий и комбинации действий в контексте цепочки активности.
В результате были обнаружены несколько индикаторов потенциальных угроз (функциональностей), таких как закрепление в ОС, нетипичная сетевая активность, модификация ОС и данных пользователя и прокси-активность. При этом первый объект продемонстрировал в полтора раза больший уровень угрозы. Это связано с тем, что данный объект имеет дополнительные функциональности, в том числе механизм само-распространения в виде сетевого червя.
Почти все индикаторы динамического анализа имеют угрозу, начиная от 100 мета-процентов. Особенно выделяется индикатор массовой активности, указывающие на огромное число повторяющихся системных событий, что является аномальным для легитимных приложений. В данном случае происходит перебор тысяч IP-адресов из возможного диапазона. Закрепление в ОС набрал уровень 90 благодаря установке сервиса и автозапуска извлеченных объектов. Прокси-активность обуславливается попыткой вредоносного объекта достижения системных действий через чужие легитимные средства (чужими руками), например с целью обхода детекта. В данном случае вредонос устанавливает на автозапуск свой извлеченной компонент через системную утилиту.
На основе обнаруженных индикаторов система автоматически выставила экспертный вердикт — Опасно.
### Полезная нагрузка
На поведенческом уровне оба объекта схожи и шифруют файлы пользователя. Первый объект имеет функции сетевого червя и пытается распространяться в сети через уязвимость в SMBv1, для чего он перебирает множество IP-адресов случайным образом и пытается соединиться на порт 445 (SMB). За 20 минут динамического анализа в песочнице вирус успел перебрать более 60 000 IP-адресов из различных диапазонов. Таким образом, вирус обладает способностью к самораспространению не только по локальной сети, но и возможность атаковать другие компьютеры в мировом масштабе.
Командные сервера вымогателя находятся в сети Tor. Во время работы вируса происходит соединение на порты 443, 9101, 9102 на ряд IP-адресов, являющихся входными нодами сети Tor. Во время очередного динамического анализа были зафиксированы попытки соединения на следующие адреса:
* 85.248.227.164:9002
* 194.109.206.212:443
* 217.79.190.25:9090
* 204.11.50.131:9001
* 95.183.48.12:443
* 171.25.193.9:80
* 195.154.164.243:443
* 131.188.40.189:443
* 5.9.159.14:9001
* 199.254.238.52:443
* 178.16.208.57:443
* 128.31.0.39:9101
* 154.35.175.225:443
* 163.172.35.247:443
При каждом новом динамическом анализе данный набор адресов меняется, но всегда является входной нодой Tor. Скорее всего, образец случайным образом выбирает "адрес: порт" из заранее заложенного в него списка адресов. На момент написания статьи количество входных нод в сеть Tor составляло [более 7 000](https://www.dan.me.uk/tornodes).
### Инсталляция и закрепление в ОС
Динамический анализ показал, что объекты закрепляются в ОС либо напрямую, либо через извлеченный исполняемый файл “tasksche.exe”, который является инсталлятором группы компонентов шифровальщика. Как видно из снимков экрана, вредоносы используют легитимную системную утилиту (“reg.exe”) для добавления своего объекта в автозапуск, используя следующую командную строку:
```
cmd.exe /c reg add hklm\software\microsoft\windows\currentversion\run /v "abzyckxcqecwnu394" /t reg_sz /d "\"c:\intel\abzyckxcqecwnu394\tasksche.exe\""
```
Такой подход классифицирован как прокси-активность, которая обычно используется для обхода обнаружения со стороны антивируса.
Объект №1 дополнительно устанавливает сервисы для обеспечения "выживаемости" его следующих компонентов:
```
c:\documents and settings\48=8ab@0b@\desktop\mapkep.bin
c:\intel\abzyckxcqecwnu394\tasksche.exe
```
Особенностью вредоноса является установка своего извлеченного объекта как сервис, который и порождает всю последующую активность.
В процессе инсталляции процесс “tasksche.exe” или сам вирус извлекает из себя и запускает файл “@wanadecryptor@.exe” множество раз в различные пользовательские папки и другие директории, содержащие файлы для зашифровывания, видимо для того, чтобы избежать единой точки отказа или обнаружения. Для извлечения используется пароль WNcry@2ol7.
Извлечение @wanadecryptor@.exe
```
c:\intel\abzyckxcqecwnu394\@wanadecryptor@.exe
c:\@wanadecryptor@.exe
c:\docs\@wanadecryptor@.exe
c:\docs\docs\@wanadecryptor@.exe
c:\documents and settings\default user\(01;=k\@wanadecryptor@.exe
c:\documents and settings\48=8ab@0b@\cookies\@wanadecryptor@.exe
c:\documents and settings\48=8ab@0b@\(01;=k\@wanadecryptor@.exe
c:\documents and settings\;l720b5;l\(01;=k\@wanadecryptor@.exe
c:\programms\@wanadecryptor@.exe
c:\programms\totalcmd\@wanadecryptor@.exe
c:\system volume information\_restore{1a1e1895-7822-43e9-a55a-8d2dc8b2dc2d}\@wanadecryptor@.exe
c:\system volume information\_restore{1a1e1895-7822-43e9-a55a-8d2dc8b2dc2d}\rp1\@wanadecryptor@.exe
c:\system volume information\_restore{1a1e1895-7822-43e9-a55a-8d2dc8b2dc2d}\rp2\@wanadecryptor@.exe
c:\system volume information\_restore{1a1e1895-7822-43e9-a55a-8d2dc8b2dc2d}\rp3\@wanadecryptor@.exe
c:\system volume information\_restore{1a1e1895-7822-43e9-a55a-8d2dc8b2dc2d}\rp4\@wanadecryptor@.exe
c:\temp\screener\@wanadecryptor@.exe
c:\documents and settings\all users\ 01g89 ab;\@wanadecryptor@.exe
c:\documents and settings\48=8ab@0b@\ 01g89 ab;\@wanadecryptor@.exe
c:\documents and settings\;l720b5;l\ 01g89 ab;\@wanadecryptor@.exe
```
Далее происходит запуск большинства извлеченных компонентов.
Процесс “@wanadecryptor@.exe” в свою очередь извлекает компоненты Tor-клиента и запускает его приложение “c:\intel\abzyckxcqecwnu394\taskdata\tor\taskhsvc.exe”.
```
c:\intel\abzyckxcqecwnu394\taskdata\tor\libeay32.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\libevent-2-0-5.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\libevent_core-2-0-5.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\libevent_extra-2-0-5.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\libgcc_s_sjlj-1.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\libssp-0.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\ssleay32.dll
c:\intel\abzyckxcqecwnu394\taskdata\tor\tor.exe
c:\intel\abzyckxcqecwnu394\taskdata\tor\zlib1.dll
c:\intel\abzyckxcqecwnu394\\taskdata\tor\taskhsvc.exe
c:\temp\screener\newwindows\@wanadecryptor@.exe
```
Кроме того, данный процесс производит ряд системных действий с использованием следующих команд Windows:
```
cmd.exe /c vssadmin delete shadows /all /quiet & wmic shadowcopy delete & bcdedit /set {default} bootstatuspolicy ignoreallfailures & bcdedit /set {default} recoveryenabled no & wbadmin delete catalog -quiet
```
Данные команды отключают сервис теневого копирования, удаляют существующие копии и отключают запуск по умолчанию средств восстановления при загрузке ОС.
### Особенности работы вредоноса
По результатам анализа, данный вредонос имеет сложную структуру активности, которая выражается в использовании множества независимых компонентов, резервировании объектов и методов прокси-деятельности. Как видно из цепочки активности, вирус-родитель извлекает ряд объектов и через них закрепляется в системе (автозапуск), перебирает входные узлы TOR сети, модифицирует настройку ОС и запускает компоненты шифрования пользовательских файлов. Более полная цепочка активности демонстрирует факт многократного запуска извлеченных компонентов шифровальщика, что, в свою, очередь было зафиксировано как аномальная массовая активность с высоким уровнем угрозы.
При всем объеме заложенной функциональности данный вредонос не обладает приемами сокрытия своего присутствия. Попытка скрыть свое присутствие или идентифицировать среду исполнения сегодня классифицируется как критичный IOC (index of compromise, индикатор компрометации).
Соответственно, мы наблюдаем тренд, когда вредоносные программы стараются не выделяться из общего потока легитимной активности таких программ, как инсталляторы, архиваторы, менеджеры файлов.
Итог
----
Вредоносный комплекс представляет из себя совокупность общедоступных компонентов и не требует высокой квалификации злоумышленников. Есть очень большая вероятность, что эти системы могли быть захвачены злоумышленниками ранее, шифровальщик лишь вскрыл проблему. Характер заражения, скорость и затронутые системы показывают, что на сегодняшний день многие системы не могут и не готовы противостоять современным кибергурозам. | https://habr.com/ru/post/328606/ | null | ru | null |
# Защита от XSS в Rails 3
Скорее всего вы уже знаете о том, что в Rails 3 по умолчанию добавлена защита от XSS атак. Это значит, что отныне вам никогда не придется вручную фильтровать ввод пользователя используя хелпер `h`, потому что рельсы всегда будут делать это за вас.
Тем не менее, всё не так просто, как кажется на первый взгяд. Рассмотрим следующий код:
> `Привет **друзья**!
>
>
>
> <%= tag(:p, some_text) %>
>
> <%= some_text %>`
>
>
В примере выше мы имеем несколько различных случаев, подразумевающих использование HTML тегов. В первом случае Rails не должен фильтровать тег , окружающий слово `друзья`, т.к. результатом будет явно не то, что вводил пользователь. Во втором случае Rails должен отфильтровать `some_text` внутри тега (но не весь тег ). Наконец, в третьем случае, `some_text` в некотором родительском теге должен быть отфильтрован.
В случае, если `some_text` выглядит как результатом будет:
> `Привет **друзья**!
>
>
>
> <script>evil\_js</script>
>
>
>
> <script>evil_js</script>`
Для того, чтобы это работало повсеместно в приложениях Rails, мы в внедрили новый подход под названием **`html_safe`**. Так, если строка являеться `html_safe` (что определяется посредством вызова метода `html_safe?` на строке), ERB оставляет её нетронутой. Если же строка не является `html_safe`, ERB, прежде чем вставить её на страницу, произведет фильтрацию.
> `def tag(name, options = nil, open = false, escape = true)
>
> "<#{name}#{tag_options(options, escape) if options}#{open ? ">" : " />"}".html_safe
>
> end`
Здесь Rails создает тег, указывая `teg_options` отфильтровать содержимое, после чего помечает все тело тега как безопасное. В результате и останутся не нетронутыми, в то время как вставленный пользователем контент будет подвержен фильтрации.
В первой реализации, в [плагине](http://github.com/nzkoz/rails_xss "rails-xss") [Koz’а](http://www.koziarski.com/ "Michael Koziarski") rails-xss, указанные условия выполнялись путём добавления специального флага ко всем строкам. Приложение Rails помечало нужные строки как безопасные, в то время как сам Rails переопределял методы `+` и `<<`, чтобы, в случае изменения строки, соответственно помечать результирующую.
Тем не менее, в ходе моего последнего тестирования производительности рельсов, я заметил, что переопределение каждой конкатенации строк выливается в довольно сильное падение производительности. Мало того, это падение линейно зависело от количества вставок `<%= %>` в шаблоне, т.е. большие шаблоны не поглощали стоимость (как если бы это был один вызов `<%= %>` на шаблон), а лишь увеличивали её.
Поразмыслив над проблемой больше, стало ясно (что позже подтвердили Koz, Jeremy и Evan Phoenix из Rubunius’а), что мы могли бы реализовать в точности такие же возможности более производительным путём, при этом даже с меньшим влиянием на Ruby API. Так как проблема сама по себе достаточно сложна, я не буду вдаваться в детали, описывая старую реализацию, а объясню как нужно использовать новую XSS защиту. Если вам довелось раньше использовать плагин Koz’а или вы уже работаете с предварительным релизами Rails, то заметите, что сегоднешний коммит изменяет не многое.
#### Safe Buffer
В Rails 3, буфер ERB является экземпляром `ActiveSupport::SafeBuffer`. SafeBuffer наследуется от `String`’а, переопределяя `+`, `concat` и `<<` таким образом, что:
* если другая строка безопасна (т.е. является SafeBuffer’ом), буфер просто выполняет конкатенацию
* если другая строка небезопасна (т.е. является простым String’ом), буфер выполняет фильтрацию, а затем конкатенацию
Вызов `html_safe` на простой строке возвращает `SafeBuffer`-обертку. Так как `SafeBuffer` наследуется от сроки, Ruby создает обертку чрезвычайно эффективно (лишь делая общим внутреннее хранилище `char*`).
В результате такой реализации, я начинал видеть вот такой способ записи:
> `buffer << other_string.html_safe`
Здесь Rails создает новый `SafeBuffer` для `other_string`, затем передает его в метод `<<` исходного `SafeBuffer`’а, который (метод) проверяет, является ли новый `SafeBuffer` безопасным. Для таких случаев был написан `safe_concat` — новый метод для буфера, который использует оригинальный метод concat, исключая необходимость создавать новый `SafeBuffer` и проверять его на безопасность.
Подобным образом, concat и `safe_concat` в `ActionView` являются прокси-методами для concat и `safe_buffer` над буфером, поэтому можно использовать safe\_concat в хелпере, если у вас есть HTML текст, который необходимо объединить с буфером без проверок и фильтрации.
ERB внутренне использует `safe_concat` везде на шаблоне вне тегов `<% %>`. Это значит, что, в моем сегодняшнем коммите, код XSS защиты никак не влияет на производительность в таких случаях (т.е. сканируя, по сути, весь ваш plain text).
Наконец, ERB теперь знает о хелпере `raw`, поэтому если вы напишете что-то вроде `<%= raw some_stuff %>`, ERB незаметно использует `safe_concat`, пропустив создание `SafeBuffer`’a и проверок `html_safety`.
#### Выводы
Вкратце, «XSS защита» означает следующее:
* если в `<%= %>` подается обычная строка, Rails всегда её отфильтрует
* если в `<%= %>` подается `SafeBuffer`, Rails её не фильтрует. Чтобы получить `SafeBuffer` из строки, необходимо вызвать на ней метод `html_safe`. Система XSS защиты несет крайне малое влияние на быстродействие, ограничивающееся лишь вызовом методом `html_safe?`
* если в `<%= %>` передать хелпер `raw`, то Rails обнаружит это на этапе компиляции шаблона, никак не воздействуя на производительность (т.е. в этом случае не происходят никакие проверки на `html_safe`)
* во *время выполнения* Rails не фильтрует никакие части шаблона вне `<% %>`, так-как справляется с этим в момент компиляции, результируя, опять-же, в отсутствии воздействия на производительность
Для сравнения, в исходной реализации XSS влиял на каждую конкатенацию или `+` для строк; влиял даже если приложение использовало хелпер `raw`, или на любую другую конкатенацию вне `<% %>` внутри шаблона.
Тем не менее, я хотел бы выразить личную благодарность Майклу Козиарски, предоставившему черновую реализацию своей идеи. Она работала, продемонстрировала концепцию, и сообщество вдоволь её оттестировало. В конце концов, она дала хорошее начало. | https://habr.com/ru/post/82726/ | null | ru | null |
# А вы когда-нибудь причиняли себе физическую боль собственным кодом?
Приходилось ли вам когда-нибудь ненароком причинить себе или другим физический вред из-за ошибок в коде? Мне – да.
Примерно год назад я работал со сгенерированными файлами в формате WAV, их было несколько тысяч. Я пытался снабдить их метками, рассортировать по папкам, создавал метаданные. В процессе я прослушал несколько штук, и, к моей досаде, оказалось, что все они начинаются с довольно продолжительной тишины. Это сильно раздражало, особенно когда прослушиваешь серию файлов подряд и постоянно спотыкаешься о паузы перед воспроизведением каждого следующего. Прекрасно, значит, еще и с этим придется что-то делать.
Я уже потратил сколько-то времени на поиск решений для удаления тишины из файлов, когда меня вдруг осенило: это ведь WAV! Данные в файлах формата WAV обычно представляют собой PCM-аудио, то есть каждое значение в файле задает амплитуду звука в некоторый момент времени. Соответственно, если у нас там действительно полная тишина, а не белый шум, то в файле этой тишине должны соответствовать сплошные нули, так ведь?
```
$ xxd testfile1.wav | head -n 100
00000000: 5249 4646 64b9 0e00 5741 5645 666d 7420 RIFFd...WAVEfmt
00000010: 1000 0000 0100 0200 44ac 0000 10b1 0200 ........D.......
00000020: 0400 1000 6461 7461 40b9 0e00 0000 0000 ....data@.......
00000030: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000040: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000050: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000060: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000070: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000080: 0000 0000 0000 0000 0000 0000 0000 0000 ................
# ... and a lot more zeros below
```
Так и есть. Ну что ж, значит, дело проще, чем казалось. Достаточно просто прочитать файлы, найти место, где заканчиваются эти нули, и убрать соответствующий фрагмент.
#### Как читаются файлы WAV
Сначала мне нужно было поближе познакомиться с форматом WAV, чтобы понять, как работать с такими файлами и управлять данными внутри них. Я подобрал несколько источников; одним из самых полезных оказалась [старая страница](https://web.archive.org/web/20141213140451im_/https://ccrma.stanford.edu/courses/422/projects/WaveFormat/) со stanford.edu (сайт сейчас уже недоступен, но, к счастью, сохранился на Wayback Machine). Там была очень доходчивая диаграмма:
Итак, структура файла WAV представляется довольно простой: сначала заголовок объемом в 44 байта, а дальше уже собственно данные. С этой информацией уже можно было приступать к коду. Требовалось только пропустить первые 44 байта, убрать последовательность из нулей в начале секции с данными, а всё остальное отправить на воспроизведение в исходном виде. Хотя не могу не добавить, что [в другом источнике](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html) мне попались такие сведения:
> *«Некоторые программы предполагают (и это очень наивно с их стороны), что вводная часть в заголовке всегда занимает ровно 44 байта (как говорится в таблице выше) и что всё остальное содержимое файла составляют только и исключительно аудиоданные. Делать подобные предположения небезопасно».*
Ну, я решил, что ничего страшного: программу я писал на C, так что за безопасность можно было особенно не переживать.
#### Код
Код был несложным, уложился меньше чем в сотню строк. По сути, он перебирал весь файл по байту, за исключением первых сорока четырех, и считал идущие подряд нули. Как только попадалось что-нибудь, что нулём не являлось, программа останавливалась, сохраняла соответствующий индекс, и начинала читать файл сначала. На этот раз она пропускала всё, что предшествует индексу (не считая заголовка), и выводила все остальные байты по стандартной схеме.
Целиком код приводить незачем, но вот та часть, которая будет нас интересовать:
```
// index was calculated above to be the index of
// the last consecutive zero byte
FILE *f = fopen(argv[1], "rb");
int ind = 0;
int current_byte;
while ((current_byte = fgetc(f)) != EOF) {
if (ind < 44 || ind >= index) {
fputc(current_byte, stdout);
}
ind += 1;
}
fclose(f);
```
Всё круто, всё просто. Пора тестировать. Я запустил программу на одном из файлов с особенно продолжительной паузой.
```
./strip_audio testfile1.wav > testfile1.nosilence.wav
```
Проверил, что выдаёт xxd для testfile1.nosilence.wav. Отлично, никаких нулей в начале. Значит, сработало. Чтобы окончательно убедиться, открою-ка я по-быстрому файл в аудиопроигрывателе.
[*Источник*](https://clips.twitch.tv/DignifiedAffluentDogNerfBlueBlaster-atCgFB3-aeQj9VbA)
В ту же секунду мне по ушам ударил самый мощный статический шум, который я в жизни слышал. Чуть не вывалившись из кресла, я отчаянно пытался стащить с себя наушники. Помню, дело было посреди ночи, и собака прибежала проверить, что там со мной.
#### Где я ошибся?
В ушах всё еще звенело, а я сидел и пытался осмыслить свои опрометчивые решения.
* Ошибка №1: надо было убавить звук.
* Ошибка №2: не надо было сидеть в наушниках.
* Ошибка №3: неучтённая единица.
А вы заметили третью ошибку в коде, который я приводил выше? Подсказка: смотрите на комментарий. Я рассчитал переменную index как индекс последнего байта, представляющего собой нули. А значит, за вычетом 44 байтов заголовка, теперь мы воспроизводим только то, что следует за индексом или накладывается на него. index у нас стоит на последнем нуле в серии, то есть мы включаем один лишний нулевой байт в секцию с данными.
Это можно исправить следующим образом:
```
// replaced >= with just >
if (ind < 44 || ind > index) {
fputc(current_byte, stdout);
}
```
Теперь в выдаче нет лишних нулей, и если воспроизвести файл, ничего страшного не случится. Я всё починил… Но стоп.
В файлах WAV у нас PCM-аудио, а нули в аудиоданных такого рода соответствуют полной тишине. Так разве этот лишний байт не должен быть совершенно бесшумным? Почему он оказался таким громким и таким статическим?
Для начала давайте сравним нормальный аудиофайл с монстром, которого я создал, при помощи Audacity:
Угадали, где монстр? Да, это тот самый, у которого амплитуда стабильно вывернута чуть ли не максимум. Почему так?
#### Как читаются аудиосэмплы
Я вернулся к источникам, которые отобрал, и попытался разобраться, как ошибка на единицу могла привести к подобному взрыву амплитуды. Я знал, что в моих файлах сэмпл содержит 16 бит, а канала два (стерео), поэтому стал искать соответствующую информацию. [Вот что говорилось](http://www.tactilemedia.com/info/MCI_Control_Info.html) в разделе про 16-битное стерео PCM-аудио:
> *«Каждый сэмпл содержится в целом числе i, которое представляет минимально достаточное количество байтов для хранения заданного размера сэмпла. Наименее значимый из байтов располагается в хранилище первым».*
«Минимально достаточное количество байтов для хранения заданного размера» — формулировка здесь излишне запутанная. i соответствует числу битов, которые содержатся в сэмпле. В нашем случае их шестнадцать. Соответственно, если у нас есть некое значение длиной в 16 битов, само собой, храниться оно будет в двух байтах. А дальше важный момент: наименее значимый из байтов располагается в хранилище первым. Вот оно.
Взгляните на график, который я сделал, чтобы показать, что привело к возникновению такого сильного сигнала:
В верхней части показан мой файл-монстр, в котором я случайно оставил лишний байт с нулями. В каждом из трёх сэмплов — s1, s2 и s3 – по два байта, причем второй более значимый. Следовательно, при переводе этих пар байтов в десятичную форму мы получаем очень высокую амплитуду.
В то же время, в нижней части видно, что, если убрать нулевой байт, сэмплы читаются так, как и должны, и значения в аудиофайле укладываются в рамки разумного.
Выходит, если бы у меня было 8-битное аудио, тогда пропущенный лишний байт не вызвал бы никаких проблем. Но оно было 16-битным, и в итоге, я сдвинул всю последовательность в сэмплах, так что наименее значимый байт стал читаться как наиболее значимый.
#### Выводы
* Проверяйте звуковую волну аудиофайла, прежде чем врубать его на максимальной громкости
* Читайте (и принимайте к сведенью) спецификации
* Учитывайте, как код может повлиять на вас и других людей | https://habr.com/ru/post/560960/ | null | ru | null |
# ASP.NET Core: Создание справочных страниц веб-API ASP.NET с помощью Swagger
При создании высоконагруженных приложений бывает сложно разобраться в различных API. Сформировать качественную документацию и справочные страницы в рамках веб-API посредством Swagger с интеграцией Swashbuckle .NET Core так же просто, как добавить пару пакетов NuGet и изменить Startup.cs.
Второй цикл статей по ASP.NET Core
----------------------------------
1. [Создание серверных служб для мобильных приложений](https://habrahabr.ru/company/microsoft/blog/319482/).
2. [Разработка приложений ASP.NET Core с помощью dotnet watch](https://habrahabr.ru/company/microsoft/blog/324312/).
3. [Создание справочных страниц веб-API ASP.NET с помощью Swagger](https://habrahabr.ru/company/microsoft/blog/325872/).
4. Открытый веб-интерфейс для .NET (OWIN).
5. Выбор правильной среды разработки .NET на сервере.
Введение
--------
Для начала поговорим о терминологии:
* [Swashbuckle](https://github.com/domaindrivendev/Ahoy) — это проект с открытым исходным кодом для создания документов Swagger для веб-API, построенных с помощью ASP.NET Core MVC.
* [Swagger](http://swagger.io/) — это машиночитаемое представление RESTful API, которое обеспечивает поддержку интерактивной документации, создание клиентских пакетов SDK и возможности обнаружения.
Данный учебный материал написан по примеру туториала [«Создание первого веб-API с помощью ASP.NET Core MVC и Visual Studio»](https://docs.microsoft.com/en-us/aspnet/core/tutorials/first-web-api). Если вам интересно, его можно скачать с [GitHub](https://github.com/aspnet/Docs/tree/master/aspnetcore/tutorials/first-web-api/sample).
Начало работы
-------------
Swashbuckle состоит из двух компонентов:
* *Swashbuckle.SwaggerGen*: содержит функции для создания документов JSON Swagger, которые описывают объекты, методы, типы возвращаемых значений и так далее.
* *Swashbuckle.SwaggerUI*: встроенная версия пользовательского интерфейса Swagger, который с помощью указанных выше документов создает индивидуально настраиваемый инструмент для описания функций веб-API и содержит функции тестирования для общедоступных методов.
Пакеты NuGet
------------
Чтобы добавить Swashbuckle, можно воспользоваться одним из способов:
* С помощью консоли диспетчера пакетов:
```
Install-Package Swashbuckle -Pre
```
* В Visual Studio:
o Правой кнопкой мыши щелкните проект в Обозревателе решений > Управление пакетами NuGet.
o Введите в поле поиска текст Swashbuckle.
o Поставьте флажок Include prerelease (Включить предварительный выпуск).
o В качестве источника пакетов укажите nuget.org.
o Коснитесь Swashbuckle package (пакет Swashbuckle), а затем — Install (Установить).
Добавьте Swagger и настройте его в связующее ПО
-----------------------------------------------
Добавьте SwaggerGen в набор сервисов в методах Configure и ConfigureServices, активируйте связующее ПО для обработки созданного документа JSON и пользовательского интерфейса Swagger.
```
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
services.AddLogging();
// Add our repository type
services.AddSingleton();
// Inject an implementation of ISwaggerProvider with defaulted settings applied
services.AddSwaggerGen();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
app.UseMvcWithDefaultRoute();
// Enable middleware to serve generated Swagger as a JSON endpoint
app.UseSwagger();
// Enable middleware to serve swagger-ui assets (HTML, JS, CSS etc.)
app.UseSwaggerUi();
}
```
В Visual Studio нажмите F5 для запуска приложения и перейдите к `http://localhost:/swagger/v1/swagger.json`. Здесь вы увидите созданный документ, описывающий конечные точки.
**Примечание:** браузеры Microsoft Edge, Google Chrome и Firefox отображают документы JSON без дополнительных настроек. Для Chrome созданы расширения, позволяющие форматировать документ для удобства чтения. Ниже приведен сокращенный пример на JavaScript.
```
{
"swagger": "2.0",
"info": {
"version": "v1",
"title": "API V1"
},
"basePath": "/",
"paths": {
"/api/Todo": {
"get": {
"tags": [
"Todo"
],
"operationId": "ApiTodoGet",
"consumes": [],
"produces": [
"text/plain",
"application/json",
"text/json"
],
"responses": {
"200": {
"description": "OK",
"schema": {
"type": "array",
"items": {
"$ref": "#/definitions/TodoItem"
}
}
}
},
"deprecated": false
},
"post": {
...
}
},
"/api/Todo/{id}": {
"get": {
...
},
"put": {
...
},
"delete": {
...
},
"definitions": {
"TodoItem": {
"type": "object",
"properties": {
"key": {
"type": "string"
},
"name": {
"type": "string"
},
"isComplete": {
"type": "boolean"
}
}
}
},
"securityDefinitions": {}
}
```
Этот документ используется для работы пользовательского интерфейса Swagger, доступного по адресу: `http://localhost:/swagger/ui`.
Каждый метод в контроллере ToDo можно протестировать из пользовательского интерфейса. Коснитесь метода, чтобы развернуть раздел, добавьте необходимые параметры и нажмите «Try it out!» (Попробовать).
Настройка и расширяемость
-------------------------
Swagger не только позволяет без труда представить API, но и содержит функции для документирования модели объекта и настройки внешнего вида и языка интерактивного пользовательского интерфейса.
#### Информация и описание API
Метод `ConfigureSwaggerGen` предназначен для добавления сведений об авторе и лицензии, а также описания.
```
services.ConfigureSwaggerGen(options =>
{
options.SingleApiVersion(new Info
{
Version = "v1",
Title = "ToDo API",
Description = "A simple example ASP.NET Core Web API",
TermsOfService = "None",
Contact = new Contact { Name = "Shayne Boyer", Email = "", Url = "http://twitter.com/spboyer"},
License = new License { Name = "Use under LICX", Url = "http://url.com" }
});
});
```
На следующем рисунке показан пользовательский интерфейс Swagger с информацией о версии.
#### Комментарии XML
Чтобы включить комментарии XML, правой кнопкой мыши щелкните проект в Visual Studio и выберите **Properties** (Свойства). Затем поставьте флажок **XML Documentation file** (Файл документации XML) под разделом **Output Settings** (Настройки выхода).
Сконфигурируйте Swagger для использования созданного файла XML.
**Примечание:** для Linux и операционных систем, не принадлежащих к семейству Windows, имена файлов и каталогов чувствительны к регистру. Например, поиск файла с именем `ToDoApi.XML` возможен в Windows, но невозможен в CentOS.
```
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
services.AddLogging();
// Add our repository type.
services.AddSingleton();
// Inject an implementation of ISwaggerProvider with defaulted settings applied.
services.AddSwaggerGen();
// Add the detail information for the API.
services.ConfigureSwaggerGen(options =>
{
options.SingleApiVersion(new Info
{
Version = "v1",
Title = "ToDo API",
Description = "A simple example ASP.NET Core Web API",
TermsOfService = "None",
Contact = new Contact { Name = "Shayne Boyer", Email = "", Url = "http://twitter.com/spboyer"},
License = new License { Name = "Use under LICX", Url = "http://url.com" }
});
//Determine base path for the application.
var basePath = PlatformServices.Default.Application.ApplicationBasePath;
//Set the comments path for the swagger json and ui.
var xmlPath = Path.Combine(basePath, "TodoApi.xml");
options.IncludeXmlComments(xmlPath);
});
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
app.UseStaticFiles();
app.UseMvcWithDefaultRoute();
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();
// Enable middleware to serve swagger-ui assets (HTML, JS, CSS etc.)
app.UseSwaggerUi();
}
```
В коде выше ApplicationBasePath получает путь к базовому каталогу приложения, что позволяет настроить полный путь к комментариям XML. `TodoApi.xml` работает только в этом примере, имя созданного файла XML с комментариями назначается на основе имени приложения.
Если использовать в методе комментарии с тремя косыми чертами, то можно улучшить пользовательский интерфейс Swagger: к заголовку раздела будет добавлено описание.
```
///
/// Deletes a specific TodoItem.
///
///
[HttpDelete("{id}")]
public void Delete(string id)
{
TodoItems.Remove(id);
}
```
Помните, что пользовательский интерфейс использует созданный файл JSON, и в нем также содержатся эти комментарии.
```
"delete": {
"tags": [
"Todo"
],
"summary": "Deletes a specific TodoItem",
"operationId": "ApiTodoByIdDelete",
"consumes": [],
"produces": [],
"parameters": [
{
"name": "id",
"in": "path",
"description": "",
"required": true,
"type": "string"
}
],
"responses": {
"204": {
"description": "No Content"
}
},
"deprecated": false
}
```
Для большей наглядности добавим , содержимое которого может представлять собой текст, объект JSON или XML для дальнейшего документирования метода.
```
///
/// Creates a TodoItem.
///
///
/// Note that the key is a GUID and not an integer.
///
/// POST /Todo
/// {
/// "key": "0e7ad584-7788-4ab1-95a6-ca0a5b444cbb",
/// "name": "Item1",
/// "isComplete": true
/// }
///
///
///
/// New Created Todo Item
/// Returns the newly created item
/// If the item is null
[HttpPost]
[ProducesResponseType(typeof(TodoItem), 201)]
[ProducesResponseType(typeof(TodoItem), 400)]
public IActionResult Create([FromBody, Required] TodoItem item)
{
if (item == null)
{
return BadRequest();
}
TodoItems.Add(item);
return CreatedAtRoute("GetTodo", new { id = item.Key }, item);
}
```
Обратите внимание, как благодаря дополнительным комментариям улучшился пользовательский интерфейс.
#### DataAnnotations
В API можно добавить контроллер `System.ComponentModel.DataAnnotations`, чтобы улучшить элементы пользовательского интерфейса Swagger.
Добавление аннотации `[Required]` к свойству `Name` класса `TodoItem` меняет информацию ModelSchema в пользовательском интерфейсе. Агенты проверки `[Produces("application/json")]`, `RegularExpression` и другие функции служат для уточнения информации, отображаемой на создаваемой странице. Чем больше метаданных используется в коде, тем более информативной становится справочная страница пользовательского интерфейса или API.
```
using System;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
namespace TodoApi.Models
{
public class TodoItem
{
public string Key { get; set; }
[Required]
public string Name { get; set; }
[DefaultValue(false)]
public bool IsComplete { get; set; }
}
}
```
#### Описание типов ответов
Разработчики, создающие высоконагруженные приложения, уделяют особое внимание выдаваемым результатам, особенно типам ответов, кодам ошибок (если они не стандартные). Для этого используются комментарии XML и DataAnnotations.
Для примера возьмем метод `Create()`. По умолчанию он выдает ответ «201 Created» (если элемент действительно создан) или «204 No Content» (если в тело POST не переданы данные). Однако не существует документации, которая подскажет, каким будет тот или иной ответ. Чтобы исправить ситуацию, добавим следующий фрагмент кода.
```
///
/// Creates a TodoItem.
///
///
/// Note that the key is a GUID and not an integer.
///
/// POST /Todo
/// {
/// "key": "0e7ad584-7788-4ab1-95a6-ca0a5b444cbb",
/// "name": "Item1",
/// "isComplete": true
/// }
///
///
///
/// New Created Todo Item
/// Returns the newly created item
/// If the item is null
[HttpPost]
[ProducesResponseType(typeof(TodoItem), 201)]
[ProducesResponseType(typeof(TodoItem), 400)]
public IActionResult Create([FromBody, Required] TodoItem item)
{
if (item == null)
{
return BadRequest();
}
TodoItems.Add(item);
return CreatedAtRoute("GetTodo", new { id = item.Key }, item);
}
```
#### Настройка пользовательского интерфейса
Готовый пользовательский интерфейс — функциональный и удобный, но при создании страниц документации для API вы наверняка захотите использовать свой бренд или фирменный стиль.
Это можно сделать с помощью компонентов Swashbuckle. Вам нужно будет добавить ресурсы для обслуживания статических файлов, которые обычно не включаются в проект веб-API, а затем создать структуру папок для их размещения.
Добавьте к проекту пакет NuGet `«Microsoft.AspNetCore.StaticFiles»: «1.0.0-*»`.
Включите связующее ПО для статических файлов.
```
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
// Enable static files middleware.
app.UseStaticFiles();
app.UseMvcWithDefaultRoute();
// Enable middleware to serve generated Swagger as a JSON endpoint
app.UseSwagger();
// Enable middleware to serve swagger-ui assets (HTML, JS, CSS etc.)
app.UseSwaggerUi();
}
```
Возьмите файл *index.html*, который используется на странице пользовательского интерфейса Swagger, из репозитория Github \_ и переместите его в папку `wwwroot/swagger/ui`, после чего создайте новый файл `custom.css` в той же папке.
Сделайте ссылку на *custom.css* в файле *index.html*.
В следующем CSS представлен образец индивидуально настроенного заголовка страницы.
*Файл custom.css*
```
.swagger-section #header
{
border-bottom: 1px solid #000000;
font-style: normal;
font-weight: 400;
font-family: "Segoe UI Light","Segoe WP Light","Segoe UI","Segoe WP",Tahoma,Arial,sans-serif;
background-color: black;
}
.swagger-section #header h1
{
text-align: center;
font-size: 20px;
color: white;
}
*Тело index.html*
ToDo API Documentation
======================
```
Но это далеко не всё, что можно сделать со страницей. Весь перечень возможностей для пользовательского интерфейса смотрите на [GitHub в репозитории Swagger UI](https://github.com/swagger-api/swagger-ui). | https://habr.com/ru/post/325872/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.