text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Практическое использование multiple bounds generic в Java
Не сильно ошибусь, если предположу, что мало кто активно использует эту возможность языка. Для тех кто не помнит, что это такое можно почитать [здесь](https://docs.oracle.com/javase/tutorial/java/generics/bounded.html). Я же переду к практике.
Наткнулся на проблему: надо послать уже существующее событие (GWT) по нажатию кнопки, но перед посылкой поставить атрибут (Command). Казалась бы, при чём здесь шаблоны…
А вот при чём:
Сам метод для создания кнопки тривиален, command это поле класса:
```
Component createEventLink(String link, final Event event) {
TextButton button = new TextButton(link, new SelectHandler() {
@Override
public void onSelect(SelectEvent e) {
//event.setCommand(command);
bus.fire(event);
}
});
return new WidgetComponent(button);
}
```
Проблема в строчке:
```
//event.setCommand(command);
```
Такого метода у объекта Event нет. Решение, вроде, очевидное: унаследовать наше события от промежуточного класса CommandEvent, у которого будет этот метод и который унаследован от Event. Наш метод выглядит теперь так:
```
Component createEventLink(String link, final CommandEvent event) {
TextButton button = new TextButton(link, new SelectHandler() {
@Override
public void onSelect(SelectEvent e) {
event.setCommand(command);
bus.fire(event);
}
});
return new WidgetComponent(button);
}
```
Эврика? Ха! Тут мы обнаруживаем, что одно из наших событий уже унаследовано от другого дочернего класса (e.g. GwtEvent) и никак не может наследовать наш класс CommandEvent.
Следующий шаг — создаём интерфейс ICommandEvent c методом setCommand() и каждое наше событие реализует его. Наш метод выглядит теперь так:
```
Component createEventLink(String link, final Event event) {
TextButton button = new TextButton(link, new SelectHandler() {
@Override
public void onSelect(SelectEvent e) {
if (event instanceof ICommandEvent) {
((ICommandEvent) event).setCommand(command);
} else {
throw new IllegalStateException("Only ICommandEvent allowed");
}
bus.fire(event);
}
});
return new WidgetComponent(button);
}
```
Ну некрасиво! К тому же в него можно передать любое событие, а обнаружится это только при запуске, что нехорошо.
И тут пора вспомнить о теме этой заметки — multiple bounds generic в Java. С ними наш метод выглядит так:
```
& ICommandEvent> Component createEventLink(String link, final E event) {
TextButton button = new TextButton(link, new SelectHandler() {
@Override
public void onSelect(SelectEvent e) {
event.setCommand(command);
bus.fire(event);
}
});
return new WidgetComponent(button);
}
```
Ровно то, что и требовалось. | https://habr.com/ru/post/344054/ | null | ru | null |
# Полноценный lazyload на node.js
С выходом Node.js 6.0 мы из коробки получили готовый набор компонентов для организации честного ленивого загрузчика. В данном случае я имею в виду lazyload, который пытается найти и загрузить нужный модуль только в момент запроса его по имени и находится в глобальной области видимости для текущего модуля, при этом не вмешиваясь в работу сторонних модулей. Написано по мотивам статей [Node.JS Избавься от require() навсегда](https://habrahabr.ru/post/273405/) и [Загрузчик модулей для node js с поддержкой локальных модулей и загрузки модулей по требованию](https://habrahabr.ru/post/275011/).
Данная статья носит больше исследовательский характер, а ее целью является показать особенности работы Node.js, показать реальную пользу от нововведений ES 2015 и по новому взглянуть на уже имеющиеся возможности JS. Замечу, что этот подход опробован в продакшене, но все же имеет несколько ловушек и требует вдумчивого применения, в конце статьи я опишу это подробнее. Данный DI может легко использоваться в прикладных программах.
Сразу приведу ссылку на [репозиторий](https://github.com/rumkin/node-di) с рабочим кодом.
И так, давайте опишем основные требования к нашей системе:
* Загрузчик не должен исследовать файловую систему перед началом работы.
* Загрузчик не должен подключаться вручную в каждом файле.
* Загрузчик не должен вмешиваться в работу сторонних модулей из директории node\_modules.
Работать это будет приблизительно так:
```
// script.js
speachModule.sayHello();
```
```
// deps/speach-module.js
exports.sayHello = function() {
console.log('Hello');
};
```
Псевдо-глобальная область видимости
-----------------------------------
Что такое псевдо-глобальная область видимости? Это область видимости переменных доступных из любого файла, но только внутри текущего модуля. Т.е. она не доступна модулям из node\_modules, или лежащим выше корня модуля. Но как этого добиться? Для этого нам понадобится изучить систему загрузки модулей Node.js.
Создайте файл exception.js:
```
throw 'test error';
```
А затем исполните его:
```
node exception.js
```
Посмотрите на метку позиции ошибки в трейсе, там явно не то что вы ожидали увидеть.
Дело в том, что система загрузки модулей самого Node.js при подключении модуля его содержимое [оборачивается в функцию](https://github.com/nodejs/node/blob/master/lib/internal/bootstrap_node.js#L422):
```
NativeModule.wrap = function(script) {
return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
};
NativeModule.wrapper = [
'(function (exports, require, module, __filename, __dirname) { ',
'\n});'
];
```
Как видите exports, require, **dirname,** filename не являются магическими переменными, как в других средах. А код модуля просто-напросто оборачивается в функцию, которая потом выполняется с нужными аргументами.
Мы можем сделать собственный загрузчик действующий по тому же принципу, подменить им дефолтный и затем управлять переменными модуля и добавлять свои при необходимости. Отлично, но нам нужно перехватывать обращение к несуществующим переменным. Для этого мы будем использовать `with`, который будет выступать посредником между глобальной и текущей областями видимости, а чтобы каждый модуль получил правильный scope, мы будем использовать метод scopeLookup, который будет искать файл `scope.js` в корне модуля и возвращать его для всех файлов внутри проекта, а для остальных передавать `global`.
> Довольно часто with критикуют за неочевидность и трудноуловимость ошибок, связанных с подменой переменных. Но при надлежащем использовании with ведет себя более чем предсказуемо.
Вот так может выглядеть обертка теперь:
```
var wrapper = [
'(function (exports, require, module, __filename, __dirname, scopeLookup) { with (scopeLookup(__dirname)) {',
'\n}});'
];
```
Полный код загрузчика в репозитории с примером.
Как я уже писал выше, сам scope хранится в файле `scope.js`. Это нужно для того, чтобы сделать более очевидным процесс внесения и отслеживания изменений в нашей области видимости.
Подгрузка модулей по требованию
-------------------------------
Хорошо. Теперь у нас есть файл scope.js, в котором объект export содержит значения псевдо-глобальной области видимости. Дело за малым: заменим объект exports на экземпляр Proxy, который мы обучим загружать нужные модули на лету:
```
const fs = require('fs');
const path = require('path');
const decamelize = require('decamelize');
// Собственно сам scope
const scope = {};
module.exports = new Proxy(scope, {
has(target, prop) {
if (prop in target) {
return true;
}
if (typeof prop !== 'string') {
return;
}
var filename = decamelize(prop, '-') + '.js';
var filepath = path.resolve(__dirname, 'deps', filepath);
return fs.existsSync(filepath);
},
get(target, prop) {
if (prop in target) {
return target[prop];
}
if (typeof prop !== 'string') {
return;
}
var filename = decamelize(prop, '-') + '.js';
var filepath = path.resolve(__dirname, 'deps', filename);
if (fs.existsSync(filepath)) {
return scope[prop] = require(filepath);
}
return null;
}
});
```
Вот, собственно и все. В итоге мы получили самый настоящий lazyload на Node.js, который незаметен для других модулей, позволяет избежать огромных require-блоков в заголовке файла, ну и, конечно, позволяет ускорить инициализацию системы.
Неочевидные трудности:
1. Данный подход требует написания собственного способа генерации кода для расчета покрытия тестами.
2. Требуется наличие отдельной точки входа, которая подключает загрузчик.
Уже сейчас использовать такой загрузчик можно в коде тестов, gulp/grunt файлов и т.п. | https://habr.com/ru/post/283086/ | null | ru | null |
# Кунг-фу стиля Linux: организация работы программ после выхода из системы
Если вы пользуетесь Linux с ранних дней появления этой ОС (или если, вроде меня, начинали с Unix), то вам не надо очень быстро и в больших количествах изучать то новое, что появляется в системе по мере её развития и усложнения. Вы можете разбираться с новым постепенно, в режиме обычной работы. Но если вы только начинаете знакомство с Linux, то вам будет непросто сразу в ней разобраться, сразу понять её особенности. Среди тех, кому приходится изучать Linux с нуля, те, кто пользуется Raspberry Pi, те, кого расстроило то, что Microsoft забросила Windows XP, те, кто развернул облачную среду для своего IoT-проекта, похожего на Skynet.
Недавно сын спросил меня о том, как сделать так, чтобы что-то работало бы на Linux-компьютере даже тогда, когда осуществлён выход из системы. Я подумал, что это — хороший вопрос, и что на него, в зависимости от того, о чём именно идёт речь, может и не быть простого ответа.
[](https://habr.com/ru/company/ruvds/blog/533336/)
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/567158/)
Есть четыре ситуации, которые можно рассмотреть, отвечая на этот вопрос:
1. Нужно запустить некую программу, выполнение которой, как заранее известно, займёт много времени.
2. Была запущена некая программа, а потом стало понятно, что её выполнение займёт много времени. После этого решено было выйти из системы, не прерывая работу этой программы.
3. Нужно написать скрипт или другую программу, которая может отключиться от терминала и работать сама по себе (такие программы называют демонами).
4. Нужно, чтобы некая программа работала бы всё время, даже сразу после перезагрузки системы, когда в неё ещё не входили.
Одна из особенностей Linux-подобных систем, усложняющих работу с ними, заключается в том, что они дают пользователю множество возможностей. В результате то, что работает в одной системе, в другой может и не работать. Если же говорить об одном и том же дистрибутиве, то тут шанс нахождения более или менее универсальных методик работы повышается. Я, чтобы не отвлекаться, собираюсь тут рассказать, в основном, о первых двух пунктах вышеприведённого списка. Я, кроме того, исхожу из предположения о том, что мы говорим о программах, работающих в режиме командной строки. Если вам нужно, чтобы после выхода из системы работали бы программы с графическим интерфейсом, то по этому поводу у меня возникает много вопросов. Это, определённо, возможно, но это странное желание, так как графическое окружение пользователя исчезнет после выхода из системы (правда, для создания постоянных рабочих столов можно воспользоваться [VNC](https://en.wikipedia.org/wiki/Virtual_Network_Computing) или [Nx](https://www.nomachine.com/)).
Я сосредоточусь на первых двух пунктах списка, но дам некоторые подсказки касательно двух других вариантов. Итак, программа, которая сама отключается от терминала, это — [демон](http://www.netzmafia.de/skripten/unix/linux-daemon-howto.html). Этот механизм можно создать самостоятельно, а можно и у кого-нибудь [позаимствовать](http://libslack.org/daemon/). Сделать так, чтобы программа выполнялась бы всё время, может быть сложно, а может быть и не очень сложно. В большинстве Linux-дистрибутивов есть файл `/etc/rc.local`, который запускается с root-правами при запуске системы (как минимум — при нормальном запуске). Сюда можно добавлять команды для автозапуска каких-нибудь программ. Если же требуется, например, создавать собственные сервисы, то тут нужно учитывать особенности системы, знать о том, что именно в ней используется — SystemV, Upstart, OpenRC или Systemd. Возможно, придётся столкнуться и с чем-то другим. Но это — отдельная большая тема.
Обеспечение работы программ после выхода из системы
---------------------------------------------------
Вернёмся к первым двум пунктам нашего списка. Представьте, что вам надо запустить программу `remote_backup`, и вы знаете о том, что вы её запустите (возможно, войдя в систему по ssh), а потом отключитесь, но при этом она должна продолжать работать. Или вы, возможно, хотите обезопасить себя и сделать так, чтобы она продолжала бы работать даже в том случае, если вы случайно выйдете из системы. В любом случае, при обычном запуске программы из командной строки выход из системы означает остановку программы. Или не означает?
Для этого нужно просто запустить программу так, чтобы она не зависела бы от текущей сессии пользователя. Если вы используете bash и всё у вас настроено правильно, то сделать это можно очень просто. Если для запуска программы в фоновом режиме используется `&`, то работать она будет и после выхода из системы. То же самое касается и приостановки работающей программы (`CTRL + Z`) с последующим переводом её в фоновый режим с помощью команды `bg`. Тут мы видим очередной пример гибкости Linux, возможности решить одну и ту же задачу множеством способов.
Если вы работаете с bash, это значит, что вы можете настраивать оболочку, в том числе — параметр `huponexit`. Попробуйте выполнить следующую команду:
```
shopt | grep huponexit
```
Если окажется, что опция `huponexit` выключена, это значит, что обычный перевод программы в фоновый режим позволит ей пережить завершение вашей сессии. Конечно, если то же самое попробовать в какой-нибудь другой системе, это может не сработать и вам придётся выяснять причины такого поведения системы.
Если вам известно о том, что вы пользуетесь bash с выключенной опцией `huponexit`, это значит, что запустить программу в фоне вы можете, просто добавив после команды запуска знак `&`:
```
remote_backup &
```
Но надёжнее будет явным образом выразить намерение, касающееся работы программы после выхода из системы. Сделать так может понадобиться хотя бы из-за того, что при использовании только что описанного метода после выхода из системы нельзя будет видеть никаких выходных данных программы. Если же вы достаточно предусмотрительны, то программу вы можете запустить с использованием `nohup`:
```
nohup remote_backup
```
Если вы хотите передать `nohup` ещё и какие-то аргументы — перечислите их в конце команды, как это обычно делается при работе с другими программами. `Nohup` решает следующие задачи:
1. Перенаправляет `stderr` в `stdout`.
2. Перенаправляет `stdout` в `nohup.out` (местоположение этого файла в разных версиях `nohup` может различаться, в частности, он может находиться по адресу `~/nohup.out`).
3. Перенаправляет `stdin` в нечитаемый файл.
4. Запускает программу и возвращает управление командной оболочке.
В итоге программа будет работать, но не сможет принимать никаких входных данных и при этом то, что она выводит, будет попадать в `nohup.out`. Если в `nohup.out` уже что-то есть, новые данные будут добавлены в конец файла.
Причина, по которой выполняются все эти перенаправления, заключается в том, что `nohup` обнаруживает то, что каждый из потоков подключён к терминалу. Если что-то уже перенаправлено в файл, `nohup` не будет это менять. То есть, например, можно поступить так:
```
nohup remote_backup >/tmp/backupstatus.log &
```
Или так:
```
nohup bash -c 'echo y | remote_backup >tmp/backupstatus.log' &
```
В последнем случае входные данные будут поступать из конвейера, поэтому `nohup` это менять не будет. А весь вывод программы (`stdout` и `stderr`) попадёт в `/tmp/backupstatus.log`.
Исследование nohup
------------------
Если вы хотите своими глазами увидеть то, как `nohup` воздействует на программы, войдите на Linux-сервер по ssh и выполните следующие команды:
```
echo '#!/bin/bash' >~/huptest
echo sleep 60 >>~/huptest
echo 'date >/tmp/test.txt' >>~/huptest
chmod +x ~/huptest
~/huptest
```
До тех пор, пока не истекут 60 секунд, нажмите клавишу клавиатуры, вводящую символ «тильда» (`~`). Затем нажмите клавишу, вводящую точку. В SSH тильда — это экранирующий символ (если он находится в начале строки). Воспользуйтесь командой `~?` если хотите узнать подробности об этом. Теперь сделайте небольшой перерыв, выпейте чего-нибудь, и вернитесь к компьютеру через несколько минут. Войдите в систему. Файла `/tmp/test.txt` вы не найдёте (если только он уже не был создан, но и в таком случае его содержимое позволит сделать правильные выводы). Это говорит нам о том, что завершение сессии остановило программу, ожидающую истечения 60 секунд для продолжения работы.
А теперь попробуйте такую конструкцию:
```
~/huptest &
```
Она сообщит оболочке о том, что ей не надо ждать завершения программы. Если вы пользуетесь bash, то это будет работать в том случае, если опция `huponexit` выключена. Вы можете поэкспериментировать, включая (`shopt -s huponexit`) и выключая (`shopt -u huponexit`) эту опцию.
И, наконец, можно выполнить ту же команду с использованием `nohup`:
```
nohup ~/huptest &
```
Но даже команда `nohup` не идеальна. Если программа, которую мы выполняем, сама перехватывает флаг `nohup`, то команда `nohup` нам не поможет. Правда, большинство программ не перехватывают этот флаг и `nohup` будет работать независимо от используемой оболочки и от её настроек.
Есть множество других способов достижения того же результата. Например, можете исследовать возможности команды `at`, которая запускает другие программы в заданное время (скажем — через секунду после текущего момента). При запуске программ будет использоваться sh, а не bash (без выполнения некоторых действий), но они будут работать в автономном режиме.
Отсутствие планирования
-----------------------
Правда, существует пара ситуаций, в которых `nohup` нам не поможет. Первая — это когда не планировалось запускать программу в фоновом режиме. Как быть, если что-то было запущено, а потом стало ясно, что операция будет выполняться достаточно долго? Что делать, если понадобилось срочно куда-то отойти? Может случиться и так, что нужно запустить программу, вручную ввести в неё какие-то данные, а потом перевести в фоновый режим.
Возможно, вы знаете о том, что работающую программу можно приостановить, воспользовавшись комбинацией клавиш `CTRL + Z`. Bash сообщит, что создано задание, и даст его номер. Потом, используя команду `bg`, можно перевести это задание в фоновый режим. Если, например, заданию присвоен номер `3`, то соответствующая команда будет выглядеть так:
```
bg %3
```
Если опция `huponexit` выключена, то больше ничего делать не надо. Но в общем случае нужно сообщить оболочке о том, что надо либо не отправлять заданию команды `HUP`, либо убрать его из таблицы заданий. Для решения обеих этих задач можно воспользоваться командой `disown`, встроенной в bash.
При использовании `disown` без опций будет осуществлено удаление именованного задания из таблицы заданий. Если вы не хотите заходить так далеко, воспользуйтесь опцией `-h` для того чтобы оболочка не передавала бы конкретному заданию сигнал `HUP`. Можно ещё воспользоваться опцией `-a`, позволяющей воздействовать на все задания, или опцией `-r`, которая позволяет обращаться ко всем работающим заданиям. Это — стандартная возможность bash (то есть — справку по ней можно найти в справке по bash), поэтому работать она будет не во всех командных оболочках. После того, как вы обработали фоновую задачу с помощью `disown`, вы можете спокойно выходить из системы.
Постоянные сессии
-----------------
Как это обычно бывает в Linux, существует несколько способов решения одной и той же задачи. Для работы с сессиями можно воспользоваться screen или tmux. Работа с этими утилитами похожа на работу с VNC, когда можно выйти из системы, а потом, войдя в неё, обнаружить, что всё, с чем до этого работали, никуда не делось. Если вы решаете множество задач с использованием командной строки, то можете попробовать byobu (это даст вам приятный интерфейс для screen) или tmux.
*Использование tmux*
Если вы хотите это испытать — войдите в систему как обычно и запустите screen, tmux или byobu. Снова запустите тестовый скрипт (с `&` в конце команды или без использования этого символа). Потом воспользуйтесь вышеописанным фокусом `~.` для «убийства» сессии. Далее, снова войдите в систему и перезапустите ту же программу (то есть — screen, tmux или byobu). Перед вами окажется экран, выглядящий таким же, каким он был в тот момент, когда вы вышли из системы. Это, в целом, довольно полезная возможность. Кроме того, она позволяет организовать работу с несколькими окнами, но в нашем случае это значения не имеет.
Проблема богатства возможностей
-------------------------------
Мощь Linux отчасти основана на том, что у пользователей этой ОС есть множество способов решения одной и той же задачи. В этом же кроются и проблемы Linux. Причём, эти проблемы возникают не, например, тогда, когда нужно настроить миниатюрный компьютер Raspberry Pi, находящийся под полным контролем одного человека. Настоящие сложности появляются в ситуациях, когда нужно развернуть что-то на множестве компьютеров, за которыми работают разные пользователи, и на которых, возможно, даже установлены разные дистрибутивы.
Конечно, если стремиться к разработке универсальных решений, это — далеко не единственная проблема. Если нужно писать скрипты, которые смогут успешно работать в самых разных Posix-системах, можно почитать [документацию GNU](https://www.gnu.org/savannah-checkouts/gnu/autoconf/manual/autoconf-2.69/html_node/Portable-Shell.html#Portable-Shell) по autoconf. Там можно найти много полезного.
Как вы запускаете Linux-программы, которые должны работать после выхода из системы?
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/567158/)
[](https://ruvds.com/ru-rub/news/read/126?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=linux-fu-x-command)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=ilinux-fu-x-command#order) | https://habr.com/ru/post/533336/ | null | ru | null |
# Блиц-проверка алгоритмов машинного обучения: скорми свой набор данных библиотеке scikit-learn
Глобальная паутина изо дня в день пополняется статьями о популярных, наиболее употребляемых алгоритмах машинного обучения для решения различных задач. Причём основа этих статей, немного изменённая по форме в том или ином месте, кочует от одного исследователя данных к другому. При этом все эти работы объединяет один общепринятый, непреложный постулат: применение того или иного алгоритма машинного обучения зависит от размера и природы имеющихся в распоряжении данных и поставленной задачи.
Вдобавок к этому особо настоявшиеся исследователи данных, делясь своим опытом, подчёркивают: *«Выбор метода оценки должен частично зависеть от ваших данных и от того, в чём, по вашему мнению, модель должна быть хороша» («Data Science: инсайдерская информация для новичков. Включая язык R», авторы Кэти О’Нил, Рэйчел Шатт)*.
Другими словами, за плечами статистика/исследователя данных должен быть не только опыт в предметной области, но и широкий багаж разношёрстных знаний: *«Исследователь данных – тот, кто обладает познаниями в следующих сферах: математика, статистика, вычислительная техника, машинное обучение, визуализация, средства обмена данными…»* (из той же книги). Только основательно загрузив в голову познания из вышеупомянутых областей можно подступать к машинному обучению и находить решения обозначенных проблем.
Как по мне, подобное начало вполне годится для какой-нибудь очередной полуторакилограммовой книги по Data Science, либо научной статьи-страшилки с последующими «ниочёмными» двухэтажными формулами, символами и закорючками, оказывающими гнетущее, тягчайшее воздействие на новичков в области машинного обучения и просто случайно заинтересовавшихся данным направлением неискушённых читателей, не обременённых «необходимыми знаниями». К тому же круглое число 10 из тех же статей про 10 наиболее популярных алгоритмов машинного обучения ([к примеру](https://www.dataquest.io/blog/top-10-machine-learning-algorithms-for-beginners/)) только усиливают накладываемый эффект.
[На habr’е также отличились](https://habr.com/ru/company/microsoft/blog/317512/): *«Ответ на вопрос: “Какой алгоритм машинного обучения использовать?”- всегда звучит так: “Смотря по обстоятельствам”. Выбор алгоритма зависит от объёма, качества и природы данных. Он зависит от того, как вы распорядитесь результатом. Он зависит от того, как из алгоритма были созданы инструкции для реализующего его компьютера, а ещё от того, сколько у вас времени. Даже самые опытные специалисты по анализу данных не скажут вам, какой алгоритм лучше, пока сами не попробуют».*
Бесспорно, все эти знания, а также упорство и интерес необходимы и пригодятся в достижении хороших результатов не только на пути постижения машинного обучения, но и во многих других направлениях. К тому же они облегчат понимание того, что алгоритмов машинного обучения (далее – алгоритмов) далеко не один десяток; но это уже потом, при самостоятельном изучении.
Моя цель – познакомить читателя с наиболее используемыми алгоритмами с практической и доступной точки зрения. (Подстелить интерес в повествовании должен тот факт, что я отнюдь не программист и – уж тем более – не математик (свят-свят-свят!). Инженерное образование плюс опыт в «предметной отрасти» размером 10 лет (прямо какое-то магическое число) – вот, как говорится, и все мои вещи, весь мой багаж, с которым я пошёл в лоб на машинное обучение. Благодаря накопившемуся опыту в «нефтянке», идеи применения искусственных нейронных сетей и алгоритмов машинного обучения нашлись сразу (читай – имелись необходимые наборы данных). Оставалось лишь разобраться с малым – научиться крутить-вертеть данными, чтобы корректно подать их на вход «программы» и какой, собственно, алгоритм выбрать. И далее по замкнутому кругу. Отмечу, что путь мой был тернистым и весёлым — «пули свистели над головой» (из м/ф «Приключения Фунтика»), — но всё же мне удавалось делать заметки, и если обозначится интерес, то в будущем опубликую и другие сообщения.)
Итак, предлагаю подступиться к «машинлёрнингу» с другой стороны: почему бы не скормить имеющийся у вас набор данных (в примерах будут подгружены наборы данных, хорошо поддающийся обучению) множеству алгоритмов сразу, а по результатам решить, каким из них уделить более пристальное внимание с последующим тщательным изучением и подбором оптимальных параметров, усиливающих результат. Более того, главная ценность метода, о котором речь впереди, в том, что его результаты позволят ответить на вопрос, чего стоит ваш набор данных: *«начинайте с решения задачи и убедитесь в том, что вам есть что оптимизировать»* (тоже от какого-то настоявшегося статистика пошло, «респект» ему, совет дельный!).
How it is made?
Известно, что основная масса задач, решаемых при помощи алгоритмов, относится к проблемам классификации (classification) и регрессионного анализа (predictive analysis). Под *классификацией* понимается устойчивое разграничение единиц наблюдения (экземпляров) набора данных к определённой категории (классу) по результатам обучения. *Регрессионный анализ* представляет собой набор статистических методов и процессов для оценки взаимосвязи между переменными [*Статистика: Учеб.пособие/Под ред. проф. М.Р. Ефимовой. – М.: ИНФРА-М, 2002*]. Цель регрессионного анализа состоит в том, чтобы оценить значение непрерывной выходной переменной по значениям входных переменных [[ссылка](https://neerc.ifmo.ru/wiki/index.php?title=%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D1%86%D0%B8%D0%B8_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D0%B8)].
Оставим за скобками тот факт, что регрессионный анализ имеет в своём распоряжении два разных метода – predictive modeling и forecasting. Отметим только, что если имеется временной ряд (time-series data), то с помощью регрессионной модели на основе явного тренда при соблюдении стационарности (постоянства) можно выполнить прогнозирование (forecasting). Если условия формирования уровней временного ряда изменяются, то есть стационарности (non-stationary process) не наблюдается, то дело за predictive modeling. Особо нацеленным на полное овладение ML предлагаю прочесть вот эту статью на английском языке: [ссылка](https://www.onemodel.co/blog/ai-academy-forecasting-vs-predictive-modeling). Если по этому поводу возникнет дискуссия, то с удовольствием приму в ней участие.
Поскольку в примерах данной статьи временные ряды использоваться не будут, то под термином *прогнозирование* понимается *predictive analysis*.
Для решения проблем классификации и прогнозирования подходит целый диапазон алгоритмов, часть из которых мы рассмотрим далее. Для удобства последующий текст будет разделён на две части: в первой рассмотрим наиболее распространённые алгоритмы классификации, вторую посвятим алгоритмам регрессионного анализа. Для каждой части будет представлен «игрушечный» набор данных, подгруженный из [библиотеки scikit-learn](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.datasets) (v0.21.3): *digits dataset (classification)* и *boston house-price dataset (regression)*, а также приведены ссылки на каждый рассматриваемый алгоритм библиотеки scikit-learn для самостоятельного ознакомления и, возможно, изучения.
Все примеры кода выполнены в консоли [IDE Spyder](http://wiki-org.ru/wiki/Spyder_(IDE)) 3.3.3 на Python 3.7.3.
### Проблема классификации
Сначала импортируем необходимые модули и функции, которые мы будем использовать для решения проблемы классификации данных:
```
# Импортирование необходимых модулей и атрибутов
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import LinearSVC
from sklearn.svm import SVC
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import Normalizer
from matplotlib import pyplot
```
Загружаем набор данных ‘digits’ напрямую из [модуля ‘sklearn.datasets’](https://scikit-learn.org/stable/datasets/index.html) :
```
# Загрузка набора данных
dataset = load_digits()
```
IDE Spyder предоставляет удобный инструмент «Менеджер переменных», который пригодится на всех порах изучения машинного обучения (во всяком случае, для меня), как и [другие «фишки»](http://obscurityway.blogspot.com/2011/03/spyder.html):
Запускаем код. В консоли «менеджер переменных» кликаем на переменную *dataset*. Выводится следующий словарь:
Описание набора данных следующее:
В данном примере ключ ‘images’ нам не понадобится, поэтому переменной *Х* присваиваем ‘data’, представляющий собой многомерный массив NumPy с набором признаков, размерностью 1797 строк на 64 столбца, а переменной *Y* – ‘target’, многомерный массив NumPy с маркером на каждую строку.
```
# Загрузка набора данных
# dataset = load_digits()
X = dataset.data
Y = dataset.target
```
Далее разделяем набор данных на тренировочную и тестовую части, настраиваем параметры оценивания алгоритмов (используется кросс-валидация[[один](http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D1%80%D0%BE%D1%81%D1%81-%D0%B2%D0%B0%D0%BB%D0%B8%D0%B4%D0%B0%D1%86%D0%B8%D1%8F), [два](https://scikit-learn.org/stable/modules/cross_validation.html)]), определяя метрику ‘accuracy’ в параметре ‘scoring’ [[ссылка](https://scikit-learn.org/stable/modules/model_evaluation.html)]. Accuracy – это доля верно классифицированных объектов относительно общего количества объектов. Чем ближе результат к 1, тем лучше [[ссылка](https://docs.microsoft.com/ru-ru/dotnet/machine-learning/resources/metrics)]. При этом в одной из книг встречалось, что отличными считаются результаты от 0.95 (или 95%) и выше.
```
# Разделение набора данных на тренировочные и тестовые части
test_size = 0.2
seed = 7
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
# Настройка параметров оценивания алгоритма
num_folds = 10
n_estimators = 100
scoring = 'accuracy'
```
Переменные *X\_train* и *Y\_train* пустим на тренировочные нужды, *X\_test* и *Y\_test* – на выработку прогнозных значений. При этом переменная *Y\_test* не участвует в расчёте прогноза: с помощью метода ‘score’, одинакового для каждого из представленных далее алгоритмов, мы подсчитаем правильные ответы с помощью метрики ‘accuracy’. Это позволит нам судить о том, как справляется алгоритм с поставленной задачей. Не спорю, с нашей стороны это так по-человечески подло не подсказывать машине правильные ответы, но как иначе проверить её performance?
Ниже представлен список алгоритмов, которым-то мы и скормим набор данных. По результатам выполнения расчётов будем делать вывод, какой алгоритм (какие из алгоритмов) показывает наибольшую эффективность. Данный метод вполне может носить название **«блиц-проверка алгоритмов машинного обучения»** (далее – блиц-проверка).
Для удобства вывода информации рядом с каждым алгоритмом будет проставлена аббревиатура. Необходимо отметить, что настройки каждого алгоритма принимаются по умолчанию (default), за исключением некоторых моментов, дабы предоставить равные условия.
#### Линейные алгоритмы:
— Логистическая регрессия\* / [Logistic Regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression) (‘LR’)
*\* Слово «регрессия» может сбить с толку. Но не забываем, что «Логистическая регрессия» — это алгоритм классификации*
— Линейный дискриминантный анализ / [Linear Discriminant Analysis](https://scikit-learn.org/stable/modules/generated/sklearn.discriminant_analysis.LinearDiscriminantAnalysis.html) (‘LDA’)
#### Нелинейные алгоритмы:
— Метод k-ближайших соседей (классификация) / [K-Neighbors Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html) (‘KNN’)
— Деревья принятия решений / [Decision Tree Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html) (‘CART’)
— Наивный классификатор Байеса / [Naive Bayes Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html) (‘NB’)
— Линейный метод опорных векторов (классификация) / [Linear Support Vector Classification](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) (‘LSVC’)
— Метод опорных векторов (классификация) / [C-Support Vector Classification](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html) (‘SVC’)
#### Алгоритм искусственной нейронной сети:
— Многослойный персептрон / [Multilayer Perceptrons](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html) (‘MLP’)
#### Ансамблевые алгоритмы:
— Bagging (классификация) / [Bagging Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingClassifier.html) (‘BG’) (Bagging = Bootstrap aggregating)
— Случайный лес (классификация) / [Random Forest Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html) (‘RF’)
— Экстра-деревья (классификация) / [Extra Trees Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html) (‘ET’)
— AdaBoost (классификация) / [AdaBoost Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) (‘AB’) (AdaBoost = Adaptive Boosting)
— Градиентный boosting (классификация) / [Gradient Boosting Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html) (‘GB’)
Таким образом, список ‘models’ содержит следующие модели:
```
models = []
models.append(('LR', LogisticRegression()))
models.append(('LDA', LinearDiscriminantAnalysis()))
models.append(('KNN', KNeighborsClassifier()))
models.append(('CART', DecisionTreeClassifier()))
models.append(('NB', GaussianNB()))
models.append(('LSVC', LinearSVC()))
models.append(('SVC', SVC()))
models.append(('MLP', MLPClassifier()))
models.append(('BG', BaggingClassifier(n_estimators=n_estimators)))
models.append(('RF', RandomForestClassifier(n_estimators=n_estimators)))
models.append(('ET', ExtraTreesClassifier(n_estimators=n_estimators)))
models.append(('AB', AdaBoostClassifier(n_estimators=n_estimators, algorithm='SAMME')))
models.append(('GB', GradientBoostingClassifier(n_estimators=n_estimators)))
```
Как уже было сказано, оценивание эффективности каждого алгоритма выполняется с помощью кросс-валидации. В итоге выводится сообщение (msg – сокр. от message), содержащее следующие сведения: имя модели в виде аббревиатуры, средняя оценка 10-кратной перекрёстной проверки на тренировочных данных (метрика ‘accuracy’), в скобках представлено среднее квадратичное отклонение (standard deviation), а также значение метрики ‘accuracy’ на тестовых данных.
```
# Оценивание эффективности выполнения каждого алгоритма
scores = []
names = []
results = []
predictions = []
msg_row = []
for name, model in models:
kfold = KFold(n_splits=num_folds, random_state=seed)
cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
names.append(name)
results.append(cv_results)
m_fit = model.fit(X_train, Y_train)
m_predict = model.predict(X_test)
predictions.append(m_predict)
m_score = model.score(X_test, Y_test)
scores.append(m_score)
msg = "%s: train = %.3f (%.3f) / test = %.3f" % (name, cv_results.mean(), cv_results.std(), m_score)
msg_row.append(msg)
print(msg)
```
После запуска кода получаем следующие результаты:
```
LR: train = 0.957 (0.014) / test = 0.948
LDA: train = 0.951 (0.014) / test = 0.946
KNN: train = 0.985 (0.013) / test = 0.981
CART: train = 0.843 (0.033) / test = 0.830
NB: train = 0.819 (0.048) / test = 0.806
LSVC: train = 0.942 (0.017) / test = 0.928
SVC: train = 0.343 (0.079) / test = 0.342
MLP: train = 0.972 (0.012) / test = 0.961
BG: train = 0.952 (0.021) / test = 0.941
RF: train = 0.968 (0.017) / test = 0.965
ET: train = 0.980 (0.010) / test = 0.975
AB: train = 0.827 (0.049) / test = 0.823
GB: train = 0.964 (0.013) / test = 0.968
```
[Диаграмма размаха](http://statistica.ru/glossary/general/diagramma-razmakha/) ([«ящик с усами»](https://ru.wikipedia.org/wiki/%D0%AF%D1%89%D0%B8%D0%BA_%D1%81_%D1%83%D1%81%D0%B0%D0%BC%D0%B8)) (box-and-whiskers diagram or plot, box plot):
В результате выполнения блиц-проверки на «сырых» данных видно, что наибольшую эффективность на тестовых данных показали алгоритмы ‘KNN’ (k-ближайшие соседи), ‘ET’ (экстра-деревья), ‘GB’ (градиентный «бустинг»), ‘RF’ (случайный лес) и ‘MLP’ (многослойный персептрон):
```
KNN: train = 0.985 (0.013) / test = 0.981
ET: train = 0.980 (0.010) / test = 0.975
GB: train = 0.964 (0.013) / test = 0.968
RF: train = 0.968 (0.017) / test = 0.965
MLP: train = 0.972 (0.012) / test = 0.961
LR: train = 0.957 (0.014) / test = 0.948
LDA: train = 0.951 (0.014) / test = 0.946
BG: train = 0.952 (0.021) / test = 0.941
LSVC: train = 0.942 (0.017) / test = 0.928
CART: train = 0.843 (0.033) / test = 0.830
AB: train = 0.827 (0.049) / test = 0.823
NB: train = 0.819 (0.048) / test = 0.806
SVC: train = 0.343 (0.079) / test = 0.342
```
При этом многие алгоритмы очень привередливы к тем данным, которые им подают. Поэтому одним из обязательных шагов является так называемая предварительная подготовка данных (data pre-processing [[ссылка](https://scikit-learn.org/stable/modules/preprocessing.html)])
Однако бывает, что алгоритм показывает лучшие результаты без предварительной обработки. Отсюда следующая рекомендация: включить в блиц-проверку несколько преобразований исходного набора данных и по выполнении расчётов сравнить результаты, чтобы выловить суть проблемы в целом.
Наиболее часто используемыми методами предварительной подготовки данных являются:
– [стандартизация;](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html)
– [масштабирование](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html) (по умолчанию диапазон [0, 1]);
– [нормализация](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Normalizer.html)
Данные операции с последующей оценкой можно автоматизировать и поставить на конвейер с помощью инструмента [Pipeline](https://scikit-learn.org/stable/modules/compose.html#pipeline).
Фрагмент кода со стандартизацией исходных данных имеет следующий вид:
```
# Блиц-проверка алгоритмов на стандартизованных исходных данных
# Стандартизация исходных данных (функция StandardScaler)
pipelines = []
pipelines.append(('SS_LR', Pipeline([('Scaler', StandardScaler()), ('LR', LogisticRegression())])))
pipelines.append(('SS_LDA', Pipeline([('Scaler', StandardScaler()), ('LDA', LinearDiscriminantAnalysis())])))
pipelines.append(('SS_KNN', Pipeline([('Scaler', StandardScaler()), ('KNN', KNeighborsClassifier())])))
pipelines.append(('SS_CART', Pipeline([('Scaler', StandardScaler()), ('CART', DecisionTreeClassifier())])))
pipelines.append(('SS_NB', Pipeline([('Scaler', StandardScaler()), ('NB', GaussianNB())])))
pipelines.append(('SS_LSVC', Pipeline([('Scaler', StandardScaler()), ('LSVC', LinearSVC())])))
pipelines.append(('SS_SVC', Pipeline([('Scaler', StandardScaler()), ('SVC', SVC())])))
pipelines.append(('SS_MLP', Pipeline([('Scaler', StandardScaler()), ('MLP', MLPClassifier())])))
pipelines.append(('SS_BG', Pipeline([('Scaler', StandardScaler()), ('BG', BaggingClassifier(n_estimators=n_estimators))])))
pipelines.append(('SS_RF', Pipeline([('Scaler', StandardScaler()), ('RF', RandomForestClassifier(n_estimators=n_estimators))])))
pipelines.append(('SS_ET', Pipeline([('Scaler', StandardScaler()), ('ET', ExtraTreesClassifier(n_estimators=n_estimators))])))
pipelines.append(('SS_AB', Pipeline([('Scaler', StandardScaler()), ('AB', AdaBoostClassifier(n_estimators=n_estimators, algorithm='SAMME'))])))
pipelines.append(('SS_GB', Pipeline([('Scaler', StandardScaler()), ('GB', GradientBoostingClassifier(n_estimators=n_estimators))])))
# Оценивание эффективности выполнения каждого алгоритма
scores_SS = []
names_SS = []
results_SS = []
predictions_SS = []
msg_SS = []
for name, model in pipelines:
kfold = KFold(n_splits=num_folds, random_state=seed)
cv_results = cross_val_score(model, X_train, Y_train, cv=kfold)
names_SS.append(name)
results_SS.append(cv_results)
m_fit = model.fit(X_train, Y_train)
m_predict = model.predict(X_test)
predictions_SS.append(m_predict)
m_score = model.score(X_test, Y_test)
scores_SS.append(m_score)
msg = "%s: train = %.3f (%.3f) / test = %.3f" % (name, cv_results.mean(), cv_results.std(), m_score)
msg_SS.append(msg)
print(msg)
# ящик с усами (StandardScaler)
fig = pyplot.figure()
fig.suptitle('Сравнение результатов выполнения алгоритмов на стандарт. данных')
ax = fig.add_subplot(111)
red_square = dict(markerfacecolor='r', marker='s')
pyplot.boxplot(results_SS, flierprops=red_square)
ax.set_xticklabels(names_SS, rotation=45)
pyplot.show()
```
Обратите внимание на добавку ‘\_SS’ (сокращение от StandardScaler) к именам списков. Это сделано для того, чтобы не сваливать в кучу результаты, а также для их удобного просмотра с помощью «менеджера переменных» после выполненных преобразований.
Запуск фрагмента кода выдаёт следующие результаты:
```
SS_LR: train = 0.958 (0.015) / test = 0.949
SS_LDA: train = 0.951 (0.014) / test = 0.946
SS_KNN: train = 0.968 (0.023) / test = 0.970
SS_CART: train = 0.853 (0.036) / test = 0.835
SS_NB: train = 0.756 (0.046) / test = 0.751
SS_LSVC: train = 0.945 (0.018) / test = 0.941
SS_SVC: train = 0.976 (0.015) / test = 0.990
SS_MLP: train = 0.976 (0.012) / test = 0.973
SS_BG: train = 0.947 (0.018) / test = 0.948
SS_RF: train = 0.973 (0.016) / test = 0.970
SS_ET: train = 0.980 (0.012) / test = 0.975
SS_AB: train = 0.827 (0.049) / test = 0.823
SS_GB: train = 0.964 (0.013) / test = 0.968
```
Ящик с усами (StandardScaler):
По итогам расчёта на стандартизованных данных в лидеры выбились следующие алгоритмы:
```
SS_SVC: train = 0.976 (0.015) / test = 0.990
SS_ET: train = 0.980 (0.012) / test = 0.975
SS_MLP: train = 0.976 (0.012) / test = 0.973
SS_KNN: train = 0.968 (0.023) / test = 0.970
SS_RF: train = 0.973 (0.016) / test = 0.970
SS_GB: train = 0.964 (0.013) / test = 0.968
SS_LR: train = 0.958 (0.015) / test = 0.949
SS_BG: train = 0.947 (0.018) / test = 0.948
SS_LDA: train = 0.951 (0.014) / test = 0.946
SS_LSVC: train = 0.945 (0.018) / test = 0.941
SS_CART: train = 0.853 (0.036) / test = 0.835
SS_AB: train = 0.827 (0.049) / test = 0.823
SS_NB: train = 0.756 (0.046) / test = 0.751
```
Как говорится, из грязи в князи: метод опорных векторов (‘SVC’), накормленный стандартизованными данными, уделал остальные, показав отличный результат. При «ручной» проверке, сравнивая значения переменных *Y\_test* и *predictions\_SS[6]*, алгоритм не пережевал только несколько значений.
Далее выполняется аналогичный код для функций MinMaxScaler (масштабирование) и Normalizer (нормализация). Приводить полностью код в статье не стану. Вы можете скачать его из моего репозитория на GitHub’е: [ссылка](https://github.com/ZakharovOleg?tab=repositories).
Только не забудьте ненадолго зависнуть и посмеяться про себя над ‘for educational purpose only’! :)
В итоге, после прохода по всему коду, получаем следующие результаты:
```
LR: train = 0.957 (0.014) / test = 0.948
LDA: train = 0.951 (0.014) / test = 0.946
KNN: train = 0.985 (0.013) / test = 0.981
CART: train = 0.843 (0.033) / test = 0.830
NB: train = 0.819 (0.048) / test = 0.806
LSVC: train = 0.942 (0.017) / test = 0.928
SVC: train = 0.343 (0.079) / test = 0.342
MLP: train = 0.972 (0.012) / test = 0.961
BG: train = 0.952 (0.021) / test = 0.941
RF: train = 0.968 (0.017) / test = 0.965
ET: train = 0.980 (0.010) / test = 0.975
AB: train = 0.827 (0.049) / test = 0.823
GB: train = 0.964 (0.013) / test = 0.968
SS_LR: train = 0.958 (0.015) / test = 0.949
SS_LDA: train = 0.951 (0.014) / test = 0.946
SS_KNN: train = 0.968 (0.023) / test = 0.970
SS_CART: train = 0.853 (0.036) / test = 0.835
SS_NB: train = 0.756 (0.046) / test = 0.751
SS_LSVC: train = 0.945 (0.018) / test = 0.941
SS_SVC: train = 0.976 (0.015) / test = 0.990
SS_MLP: train = 0.976 (0.012) / test = 0.973
SS_BG: train = 0.947 (0.018) / test = 0.948
SS_RF: train = 0.973 (0.016) / test = 0.970
SS_ET: train = 0.980 (0.012) / test = 0.975
SS_AB: train = 0.827 (0.049) / test = 0.823
SS_GB: train = 0.964 (0.013) / test = 0.968
MMS_LR: train = 0.961 (0.013) / test = 0.953
MMS_LDA: train = 0.951 (0.014) / test = 0.946
MMS_KNN: train = 0.985 (0.013) / test = 0.981
MMS_CART: train = 0.850 (0.027) / test = 0.840
MMS_NB: train = 0.796 (0.045) / test = 0.786
MMS_LSVC: train = 0.964 (0.012) / test = 0.958
MMS_SVC: train = 0.963 (0.016) / test = 0.956
MMS_MLP: train = 0.972 (0.011) / test = 0.963
MMS_BG: train = 0.948 (0.024) / test = 0.946
MMS_RF: train = 0.973 (0.014) / test = 0.968
MMS_ET: train = 0.983 (0.010) / test = 0.981
MMS_AB: train = 0.827 (0.049) / test = 0.823
MMS_GB: train = 0.963 (0.013) / test = 0.968
N_LR: train = 0.938 (0.020) / test = 0.919
N_LDA: train = 0.952 (0.013) / test = 0.949
N_KNN: train = 0.981 (0.012) / test = 0.985
N_CART: train = 0.834 (0.028) / test = 0.825
N_NB: train = 0.825 (0.043) / test = 0.805
N_LSVC: train = 0.960 (0.014) / test = 0.953
N_SVC: train = 0.551 (0.053) / test = 0.586
N_MLP: train = 0.963 (0.018) / test = 0.946
N_BG: train = 0.949 (0.016) / test = 0.938
N_RF: train = 0.973 (0.015) / test = 0.970
N_ET: train = 0.982 (0.012) / test = 0.980
N_AB: train = 0.825 (0.040) / test = 0.820
N_GB: train = 0.953 (0.022) / test = 0.956
```
‘Top 5’ результатов:
```
SS_SVC: train = 0.976 (0.015) / test = 0.990
N_KNN: train = 0.981 (0.012) / test = 0.985
KNN: train = 0.985 (0.013) / test = 0.981
MMS_KNN: train = 0.985 (0.013) / test = 0.981
MMS_ET: train = 0.983 (0.010) / test = 0.981
```
Таким образом, по результатам блиц-проверки алгоритмов машинного обучения для решения проблемы классификации набора данных ‘digits’ наиболее подходящими алгоритмами машинного обучения являются: метод k-ближайших соседей (‘KNN’), метод опорных векторов (‘SVC’) и экстра-деревья (‘ET’). Данным алгоритмам стоит уделить более пристальное внимание для дальнейшего развития результатов, направленных на увеличение эффективности расчётов. Всё, как говорится, решаемо.
И на этой приподнятой ноте гладко переходим ко 2-й части.
### Проблема прогнозирования
Двигаемся по накатанной:
```
# Импортирование необходимых модулей и атрибутов
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso
from sklearn.linear_model import ElasticNet
from sklearn.linear_model import LarsCV
from sklearn.linear_model import BayesianRidge
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.svm import LinearSVR
from sklearn.svm import SVR
from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import BaggingRegressor
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import Normalizer
from matplotlib import pyplot
# Загрузка набора данных
dataset = load_boston()
```
Запускаем код и разбираемся со словарём. Описание и ключи следующие:
Переменной *Х* присваиваем ключ ‘data’, представляющий собой многомерный массив NumPy с набором признаков, размерностью 506 строк на 13 столбцов, а переменной *Y* – ‘target’, многомерный массив NumPy с маркером на каждую строку.
```
# Загрузка набора данных
#dataset = load_boston()
X = dataset.data
Y = dataset.target
```
Разделяем набор данных на тренировочную и тестовую части, настраиваем параметры оценивания алгоритмов. В параметре ‘scoring’ устанавливаем одну из традиционных для регрессионного анализа [метрику ‘r2’](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html):
```
# Загрузка набора данных
dataset = load_boston()
X = dataset.data
Y = dataset.target
# Разделение набора данных на тренировочные и тестовые части
test_size = 0.2
seed = 7
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
# Настройка параметров оценивания алгоритма
num_folds = 10
n_iter = 1000
n_estimators = 100
scoring = 'r2'
```
R2 – коэффициент детерминации – это доля дисперсии зависимой переменной, объясняемая рассматриваемой моделью ([ссылка](http://www.machinelearning.ru/wiki/index.php?title=%D0%9A%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82_%D0%B4%D0%B5%D1%82%D0%B5%D1%80%D0%BC%D0%B8%D0%BD%D0%B0%D1%86%D0%B8%D0%B8)).
*«Коэффициент детерминации для модели с константой принимает значения от 0 до 1. Чем ближе значение коэффициента к 1, тем сильнее зависимость. При оценке регрессионных моделей это интерпретируется как соответствие модели данным. Для приемлемых моделей предполагается, что коэффициент детерминации должен быть хотя бы не меньше 50% (в этом случае коэффициент множественной корреляции превышает по модулю 70%). Модели с коэффициентом детерминации выше 80% можно признать достаточно хорошими (коэффициент корреляции превышает 90%). Равенство коэффициента детерминации единице означает, что объясняемая переменная в точности описывается рассматриваемой моделью»* (там же).
Для решения проблемы прогнозирования задействуем следующие алгоритмы:
#### Линейные алгоритмы:
— Линейная регрессия / [Linear Regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html#sklearn.linear_model.LinearRegression) (‘LR’)
— Гребневая регрессия (ридж-регрессия) / [Ridge Regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html) (‘R’)
— Лассо-регрессия (от англ. LASSO — Least Absolute Shrinkage and Selection Operator) / [Lasso Regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html#sklearn.linear_model.Lasso) (‘L’)
— Метод регрессии «Эластичная сеть» / [Elastic Net Regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html#sklearn.linear_model.ElasticNet) (‘ELN’)
— Метод наименьших углов / [Least Angle Regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lars.html#sklearn.linear_model.Lars) (LARS) (‘LARS’)
— Байесовская гребневая регрессия / [Bayesian ridge regression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.BayesianRidge.html#sklearn.linear_model.BayesianRidge) (‘BR’)
#### Нелинейные алгоритмы:
— Метод k-ближайших соседей (регрессия) / [k-nearest neighbors regressor](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsRegressor.html) (‘KNR’)
— Деревья регрессии / [Decision Tree Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html) (‘DTR’)
— Линейный метод опорных векторов (регрессия) / [Linear Support Vector Machine – Regression](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVR.html) / (‘LSVR’)
— Метод опорных векторов (регрессия) / [Epsilon-Support Vector Regression](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html#sklearn.svm.SVR) (‘SVR’)
#### Ансамблевые алгоритмы:
— AdaBoost (регрессия) / [AdaBoost Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostRegressor.html#sklearn.ensemble.AdaBoostRegressor) (‘ABR’) (AdaBoost = Adaptive Boosting)
— Bagging (регрессия) / [Bagging Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingRegressor.html#sklearn.ensemble.BaggingRegressor) (‘BR’) (Bagging = Bootstrap aggregating)
— Экстра-деревья (регрессия) / [Extra Trees Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesRegressor.html#sklearn.ensemble.ExtraTreesRegressor) (‘ETR’)
— Градиентный boosting (регрессия) / [Gradient Boosting Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html#sklearn.ensemble.GradientBoostingRegressor) (‘GBR’)
— Случайный лес (регрессия) / [Random Forest Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html#sklearn.ensemble.RandomForestRegressor) (‘RFR’)
Таким образом, список ‘models’ содержит следующие модели:
```
models = []
models.append(('LR', LinearRegression()))
models.append(('R', Ridge()))
models.append(('L', Lasso()))
models.append(('ELN', ElasticNet()))
models.append(('LARS', Lars()))
models.append(('BR', BayesianRidge(n_iter=n_iter)))
models.append(('KNR', KNeighborsRegressor()))
models.append(('DTR', DecisionTreeRegressor()))
models.append(('LSVR', LinearSVR()))
models.append(('SVR', SVR()))
models.append(('ABR', AdaBoostRegressor(n_estimators=n_estimators)))
models.append(('BR', BaggingRegressor(n_estimators=n_estimators)))
models.append(('ETR', ExtraTreesRegressor(n_estimators=n_estimators)))
models.append(('GBR', GradientBoostingRegressor(n_estimators=n_estimators)))
models.append(('RFR', RandomForestRegressor(n_estimators=n_estimators)))
```
Как и в случае с классификацией, оценивание эффективности каждого алгоритма выполняется с помощью кросс-валидации. Выводимое сообщение содержит следующие сведения: имя модели в виде аббревиатуры, средняя оценка 10-кратной перекрёстной проверки на тренировочных данных (метрика ‘r2’), в скобках представлено среднее квадратичное отклонение (standard deviation), а также коэффициент детерминации r2 на тестовых данных.
```
# Оценивание эффективности выполнения каждого алгоритма
scores = []
names = []
results = []
predictions = []
msg_row = []
for name, model in models:
kfold = KFold(n_splits=num_folds, random_state=seed)
cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
names.append(name)
results.append(cv_results)
m_fit = model.fit(X_train, Y_train)
m_predict = model.predict(X_test)
predictions.append(m_predict)
m_score = model.score(X_test, Y_test)
scores.append(m_score)
msg = "%s: train = %.3f (%.3f) / test = %.3f" % (name, cv_results.mean(), cv_results.std(), m_score)
msg_row.append(msg)
print(msg)
# Диаграмма размаха («ящик с усами»)
fig = pyplot.figure()
fig.suptitle('Сравнение результатов выполнения алгоритмов')
ax = fig.add_subplot(111)
red_square = dict(markerfacecolor='r', marker='s')
pyplot.boxplot(results, flierprops=red_square)
ax.set_xticklabels(names, rotation=45)
pyplot.show()
```
После запуска кода получаем следующие результаты:
```
LR: train = 0.746 (0.068) / test = 0.579
R: train = 0.744 (0.067) / test = 0.570
L: train = 0.689 (0.070) / test = 0.641
ELN: train = 0.677 (0.074) / test = 0.662
LARS: train = 0.744 (0.069) / test = 0.579
BR: train = 0.739 (0.069) / test = 0.571
KNR: train = 0.434 (0.288) / test = 0.538
DTR: train = 0.671 (0.145) / test = 0.637
LSVR: train = 0.550 (0.144) / test = 0.459
SVR: train = -0.012 (0.048) / test = -0.003
ABR: train = 0.810 (0.078) / test = 0.763
BR: train = 0.854 (0.064) / test = 0.805
ETR: train = 0.889 (0.047) / test = 0.836
GBR: train = 0.878 (0.042) / test = 0.863
RFR: train = 0.852 (0.068) / test = 0.819
```
Диаграмма размаха:
Явные лидеры – ансамблевые методы ‘GBR’ (градиентный «бустинг»), ‘ETR’ (экстра-деревья), ‘RFR’ (случайный лес) и ‘BR’ («бэггинг»):
```
GBR: train = 0.878 (0.042) / test = 0.863
ETR: train = 0.889 (0.047) / test = 0.836
RFR: train = 0.852 (0.068) / test = 0.819
BR: train = 0.854 (0.064) / test = 0.805
ABR: train = 0.810 (0.078) / test = 0.763
ELN: train = 0.677 (0.074) / test = 0.662
L: train = 0.689 (0.070) / test = 0.641
DTR: train = 0.671 (0.145) / test = 0.637
LR: train = 0.746 (0.068) / test = 0.579
LARS: train = 0.744 (0.069) / test = 0.579
BR: train = 0.739 (0.069) / test = 0.571
R: train = 0.744 (0.067) / test = 0.570
KNR: train = 0.434 (0.288) / test = 0.538
LSVR: train = 0.550 (0.144) / test = 0.459
SVR: train = -0.012 (0.048) / test = -0.003
```
Один «адабуст», «лошара» эдакая, отстаёт.
Возможно, тройку лидеров причешут стандартизация и нормализация. Давайте выясним, выполнив оставшуюся часть кода.
Результаты следующие:
```
SS_LR: train = 0.746 (0.068) / test = 0.579
SS_R: train = 0.746 (0.068) / test = 0.578
SS_L: train = 0.678 (0.054) / test = 0.510
SS_ELN: train = 0.665 (0.060) / test = 0.513
SS_LARS: train = 0.744 (0.069) / test = 0.579
SS_BR: train = 0.746 (0.066) / test = 0.576
SS_KNR: train = 0.763 (0.098) / test = 0.739
SS_DTR: train = 0.610 (0.242) / test = 0.629
SS_LSVR: train = 0.727 (0.091) / test = 0.482
SS_SVR: train = 0.653 (0.126) / test = 0.610
SS_ABR: train = 0.811 (0.076) / test = 0.819
SS_BR: train = 0.853 (0.074) / test = 0.813
SS_ETR: train = 0.887 (0.048) / test = 0.846
SS_GBR: train = 0.878 (0.038) / test = 0.860
SS_RFR: train = 0.851 (0.071) / test = 0.818
N_LR: train = 0.751 (0.099) / test = 0.576
N_R: train = 0.287 (0.126) / test = 0.271
N_L: train = -0.030 (0.032) / test = -0.000
N_ELN: train = -0.007 (0.030) / test = 0.023
N_LARS: train = 0.751 (0.099) / test = 0.576
N_BR: train = 0.744 (0.100) / test = 0.589
N_KNR: train = 0.485 (0.192) / test = 0.504
N_DTR: train = 0.729 (0.080) / test = 0.765
N_LSVR: train = 0.182 (0.108) / test = 0.136
N_SVR: train = 0.086 (0.076) / test = 0.084
N_ABR: train = 0.795 (0.053) / test = 0.752
N_BR: train = 0.854 (0.054) / test = 0.827
N_ETR: train = 0.877 (0.048) / test = 0.850
N_GBR: train = 0.852 (0.063) / test = 0.872
N_RFR: train = 0.852 (0.051) / test = 0.801
```
Как видно, ансамблевые методы по-прежнему впереди всех.
‘Top 5’ вмещает следующие результаты:
```
N_GBR: train = 0.852 (0.063) / test = 0.872
GBR: train = 0.878 (0.042) / test = 0.863
SS_GBR: train = 0.878 (0.038) / test = 0.860
N_ETR: train = 0.877 (0.048) / test = 0.850
SS_ETR: train = 0.887 (0.048) / test = 0.846
```
Выведем диаграмму сравнения результатов:
*Y-test* – это эталон. Пять отборных результатов, представленные на диаграмме, выделены пунктирной линией (dashed). Видно, что все пики были воспроизведены либо с точным повторением, либо в той или иной степени.
Небольшая выдержка ручного сравнения эталонных значений и прогнозных значений алгоритма, входящего в Top 5:
Таким образом, по результатам блиц-проверки алгоритмов машинного обучения для решения проблемы прогнозирования набора данных ‘boston house-price’ наиболее подходящими алгоритмами являются градиентный «бустинг» (‘GBR’) и экстра-деревья (‘ETR’). Данным алгоритмам стоит уделить более пристальное внимание для дальнейшего развития результатов и усиления эффективности прогнозов.
### Послесловие
Блиц-проверка алгоритмов машинного обучения позволяет в первом приближении выявить наиболее эффективные алгоритмы для решения проблем классификации и регрессионного анализа (прогнозирования). Мы убедились в этом, обработав набор данных ‘digits’, блестяще рассортировав экземпляры на 10 классов, а также набор данных ‘boston house-price’, «изюмительно» разобравшись с нахождением зависимостей и выполнив «колеблющийся» прогноз зависимой переменной.
Вам же предлагается опробовать этот метод на ваших собственных наборах данных либо на тех, которые вы можете нарыть на различных репозиториях, включая GitHub. К примеру: [ссылка](http://archive.ics.uci.edu/ml/index.php).
Раздобудьте подходящий по цели набор данных — и натравите на него стайку алгоритмов в упряжке блиц-проверки. А там и выяснится, чья возьмёт: один в поле не воин. :)
И в заключение. Я буду благодарен за ваши комментарии, вопросы и пожелания, так как основу этой статьи составляет информация, которой я делюсь с новыми коллегами по каждому новому проекту в области машинного обучения. У каждого из них своя специализация, про машинное обучение и искусственные нейронные сети многие из них только «где-то слышали», поэтому для меня важно рассказать о сложном, многогранном и, наконец, неподступном (это я про ИНС и машинное обучение в целом):), простым и понятным языком; показать, что не боги горшки обжигают; и что если есть интерес, то можно не один десяток алгоритмов «запрячь». :)
P.S. К концу статьи уже сам стал предсказывать, поэтому на подступающие вопросы о том, где я взял схему-шпаргалку на первом рисунке выдаю: всё на том же сайте scikit-learn.org (*'Choosing the right estimator'*): [ссылка](https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html). А олицетворение искусственного интеллекта в виде зарумянившегося Самоделкина – так это по волнам памяти моего счастливого детства. | https://habr.com/ru/post/475552/ | null | ru | null |
# Баг движка Google Chrome с падением от 16 символов уже используют для создания игр
[](https://habrastorage.org/files/12b/987/6f9/12b9876f988e412584b12762df26eae8.png)19 сентября [получила](http://habrahabr.ru/post/267229/) огласку информация о баге Chrome. Браузер аварийно завершается, если в адресную строку ввести последовательность из 16 символов. В Google уже знают о баге, хотя обнаруживший не получил денежное вознаграждение — это не уязвимость безопасности. Природа ошибки связана с некорректной обработкой нулевого байта. Атаку можно сравнить с [похожим случаем](http://habrahabr.ru/post/259393/), когда Skype после вставки 8 символов ломался полностью: клиент завершался и больше не запускался. Chrome понадобилось 16, ровно в два раза больше.
Баг работает не только в самом браузере Chrome, но и в программах, использующих его движок — это как другие браузеры и сборки Chromium, так и Steam, клиенты мессенджера Slack и так далее. Для падения браузера нужно вставить ссылку в адресную строку, но также сработает наведение указателя мыши на гиперссылку с проблемным кодом. Последний факт уже используют для создания игр, которые наказывают падением браузера.
Комбинация из 16 символов — это `a/%%30%30`. При её вставке в адресную строку или при наведении указателя мыши на гиперссылку, ведущую на неё, [происходит](http://www.theregister.co.uk/2015/09/20/chrome_url_crash/) следующее:
* Последовательность в конце ссылки преобразуется в `%00`, а `0x30` — это ASCII-код для 0. На конце УРЛ появляется нулевой байт.
* УРЛ передаётся в [GURLToDatabaseURL](https://github.com/adobe/chromium/blob/master/chrome/browser/history/url_database.cc#L62)(), которая вызывает [ReplaceComponents](https://chromium.googlesource.com/chromium/src/+/32352ad08ee673a4d43e8593ce988b224f6482d3/url/gurl.cc#254)().
* УРЛ снова обрабатывается, обнаруживается нулевой байт. Его там быть не должно, поэтому УРЛ помечается как недействительная.
* Ссылка возвращается GURLToDatabaseURL(), со стороны которой ожидается валидность УРЛ. Происходит вызов [spec](https://github.com/scheib/chromium/blob/master/url/gurl.cc#L174)().
* УРЛ невалидна. Вызов [DCHECK](https://www.chromium.org/developers/coding-style#TOC-CHECK-DCHECK-and-NOTREACHED-)() приводит к падению.
При наведении курсора мыши над проблемной гиперссылкой происходит примерно то же самое, хотя в этом случае УРЛ обрабатывается в другой части браузера. Но и здесь ожидается только корректный адрес.
Вероятно, этот баг скоро исправят, но некоторые пытаются привлечь к нему внимание с помощью небольших игр-демонстраций. Пощекотать себе нервы могут пользователи следующих веб-обозревателей: **Google Chrome**, **Opera**, **«Яндекс.Браузера»** и других хромоподобных браузеров на движке Blink. В Microsoft Edge, Internet Explorer и Mozilla Firefox игры не работают. Перед открытием одной из двух следующих страниц рекомендуется сохранить работу и убедиться в том, что не будут потеряны важные данные.
Первая игра носит название [%%30%30](https://github.com/szhu/3030/tree/master). Это лабиринт, созданный обычным HTML-кодом. Он выглядит как веб-страница с кликабельными картинками, по которым нужно провести указатель мыши. Нужно располагать курсор строго над эмодзи с мишками, не натыкаясь на деревья, иначе браузер упадёт. Для пользователей браузеров с иммунитетом: процесс выглядит [следующим образом](https://habrastorage.org/files/dd3/72c/b9d/dd372cb9d2624b4a9eafe8ac2cc89434.gif) (2,26 МиБ).
**<https://github.com/szhu/3030/tree/master>**
Первый пример простой, но скучный. [Второй](http://linkofdeath.com/) куда более интерактивен и жесток. Это веб-сайт, на котором кликабельная точка гоняется за курсором мыши. Если она его настигнет, то попадёт в фокус, и браузер упадёт. Достижения в игре регистрирует счётчик очков. К недостаткам игры можно отнести низкую скорость движения и предсказуемость поведения «хищника».
**[http://linkofdeath.com](http://linkofdeath.com/)**
[](https://habrastorage.org/files/2d9/845/c9f/2d9845c9fbb34e6895268e10492f6d41.png)
[Описание ошибки на баг-трекере Chromium](https://code.google.com/p/chromium/issues/detail?id=533361) | https://habr.com/ru/post/384459/ | null | ru | null |
# Как добавить поиск на свой Hugo сайт
Hugo - **статический** генератор сайтов, но что же делать если хочется добавить интерактивный элемент? Система поиска - важная, а зачастую и необходимая функция на сайте, но написать её используя только Hugo попросту не получиться, исходя из природы инструмента. Потому придётся примкнуть к тёмной стороне и вспомнить JS...
Идея
----
Система поиска будет использовать JSON файл как *поисковый индекс,* где будет храниться информация о страницах (regular page, ака single). Чтобы самостоятельно не вбивать информацию о каждой новой странице, файл должен сам генерировать нужную нам структуру.
Страница с форматом JSON
------------------------
Для начала нужно объявить в конфиге (config.toml) страницу, которая будет иметь формат JSON. Самый лёгкий вариант - главная. Кстати говоря, это не уничтожит вашу home page, т.е. она будет также отображаться следуя вашему index.html.
**config.toml**
```
[outputs]
home = ["HTML", "JSON"]
```
Поисковый индекс
----------------
Теперь создадим самогенерирующийся JSON файл, где будет храниться нужная нам информация по каждой странице. Создадим файл index.json (в той же директории, где находится index.html, в моём случае - layouts).
**index.json**
```
{{ $number := 0 -}}
{{ $pages := len .Site.RegularPages }}
[
{{- range.Site.RegularPages -}}
{{- $number = add $number 1 -}}
{
"title": "{{ .Title }}",
"url": "{{ .RelPermalink }}",
"plain": "{{ .PlainWords }}",
"parent": "{{ .Parent.Title }}"
}
{{- if and (ge $number 1) (lt $number $pages) }},{{ end -}}
{{- end }}
]
```
Раскроем что творит это детище. Мы проходим по всем обычным страницам сайта (regular page, ака single) со строчки 4, и выдёргивает нужные нам параметры (title - название, url - ссылка, plain - содержание страницы, parent - директория в которой находится страница). $number и $pages вместе с if and - нужны, чтобы расставить запятые между элементами JSON, не более.
Оформляем search bar
--------------------
Создадим контейнер для поля поиска и результатов поиска.
**index.html**
```
Ищешь что-то?
=============
```
Для примера прилагаю также свой CSS файл. Не жалко.
**style.css**
```
.search-wrapper {
text-align: center ;
padding: 15px;
}
.input {
border: 1px solid #373b42;
border-radius: 5px;
height: 25px;
width: 30%;
font-size: 14px;
padding: 2px 23px 2px 30px;
background-color: #21262d;
color: #ffffff;
font-family: JetBrains Mono, regular;
}
.input:hover, .input:focus {
border: 1px solid #58a6ff;
}
.searchResults {
position: absolute;
left: 46%;
width: 23%;
top: 25%;
background-color: #0d1117;
border: 1px solid #373b42;
}
.search-result-item {
padding: 20px;
}
.search-result-item a {
text-decoration: none;
color: #58a6ff;
}
```
Теперь пришло время обратиться к нашему лучшему другу - JS. Нам надо, чтобы при каком-либо действии запускалась генерация JSON файла (aka нашего поискового индекса). Легче всего это сделать при фокусировке пользователя на поле ввода запроса на поиск.
Напишем функцию "запуска" JSON.
```
const GetPostsJSON = async () =>
{
let response = await fetch('/index.json')
let data = await response.json()
return data
}
```
А также функцию фильтрации результатов на основе запроса. Эта же функция будет "добавлять" HTML кода для отображения результатов в нашем контейнере.
```
const filterPostsJSON = (query, element) =>
{
let result, itemsWithElement;
query = new RegExp(query, 'ig')
result = dataJSON.filter(item => query.test(item.title) | query.test(item.plain))
itemsWithElement = result.map(item => (
`
[${item.parent} / ${item.title}](${item.url})
`
))
element.style.display = 'block';
element.innerHTML = itemsWithElement.join('');
}
```
В данном случае я проверяю на совпадение в имени странице (*item.title*) и содержании страницы (*item.plain*).
Далее остаётся только добавить обработку events.
```
const searchInputAction = (event, callback) =>
{
searchInput.addEventListener(event, callback)
}
// - При фокусировании на поиске вызывать getPostsd
searchInputAction('focus', () => getPostsJSON().then(data => dataJSON = data))
// - Фильтровать результаты по запросу
searchInputAction('keyup', (event) => filterPostsJSON(event.target.value, searchResult))
```
Дело в шляпе
------------
Вот так, с помощью щепотки JS можно добавить простую систему поиска на Hugo сайт. Оно вам не эластик сёрч, но для небольших решений подходит отлично.
Если тебе интересно узнать про системы посложнее, рекомендую обратиться к [данному проекту](https://www.npmjs.com/package/hugo-elasticsearch). | https://habr.com/ru/post/678506/ | null | ru | null |
# Бэкап Linux и восстановление его на другом железе
Я работаю в организации с маленьким штатом, деятельность тесно связана с IT и у нас возникают задачи по системному администрированию. Мне это интересно и частенько я беру на себя решение некоторых.
На прошлой неделе мы настраивали FreePBX под debian 7.8, нанимали фрилансера. В процессе настройки оказалось, что сервер (да, я так называю обычный PC) не хочет грузится с HDD при подключенных USB 3G модемах, которые мы используем для звонков на мобильные, колупание BIOSа не помогло. Непорядок. Решил, что нужно перенести его на другую железяку. Так появилось сразу две связанные задачи:
* сделать бэкап сервера;
* восстановить бэкап на другом железе.
Гугление не дало внятных ответов, как это сделать, пришлось собирать информацию кусками и пробовать. Всякие acronis’ы отбросил сразу, ибо не интересно.
Опыт общения с linux-системами у меня небольшой: настройка VPN сервера на open-vpn, ftp-сервера и еще пара мелочей. Сам себя я характеризую как человека умеющего читать маны и править конфиги :)
Ниже я описываю свой частный случай и почему я поступил именно так. Надеюсь, новичкам будет полезно, а бородатые админы улыбнутся вспомнив молодость.
##### Начинаем копать теорию:
По созданию бэкапов уйма статей, я для себя отметил два способа: [tar](http://www.opennet.ru/man.shtml?topic=tar&category=1) — упаковывает и сжимает все файлы, при этом не сохраняется MBR, мой бэкап будет весить около 1.5 Gb; [dd](http://www.opennet.ru/man.shtml?topic=dd&category=1) — делает полную копию раздела, включая MBR и всю область, где нет файлов, архив будет равен размеру раздела, в моем случае ~490 Gb.
Второй способ требует наличия внешнего жесткого диска объемом не меньше раздела, который архивируем. Да и что с ним потом делать, непонятно, хранить на полочке? Остановился на tar, чуть сложнее в реализации, нужно будет создать MBR, но время создания/восстановления архива существенно меньше, хранить бэкап проще, полтора гига можно закинуть в облако и скачать, когда будет нужно. Записывать его можно на ту же live-флэшку, с которой буду грузиться.
###### Итак, план действия:
1. создание бэкапа;
2. форматирование, разметка диска, создание файловой системы;
3. восстановление бэкапа;
4. создание MBR;
5. тестирование и устранение неполадок.
#### 1. Создание бэкапа
Грузимся с live-флэшки, у меня это debian-live-7.8.0-amd64-standard.
Переключаемся на root:
```
sudo su
```
Монтируем раздел, который будем архивировать, у меня это sda1, чтобы случайно не наломать дров, монтируем только для чтения. Посмотреть все свои разделы можно при помощи команд *ls /dev | grep sd* или *df -l*
```
mount -o ro /dev/sda1 /mnt
```
Наша флэшка уже примонтирована, но в режиме только чтения, нужно перемонтировать для чтения-записи, чтобы писать туда бэкап.
```
mount -o remount,rw /dev/sdb1 /lib/live/mount/medium
```
Все готово для создания архива
```
tar -cvzpf /lib/live/mount/medium/backupYYYYMMDD.tgz --exclude=/mnt/var/spool/asterisk/monitor --exclude=/mnt/var/spool/asterisk/backup /mnt/
```
Здесь у нас параметры: c — создать архив, v — выводить информацию о процессе, z — использовать сжатие gzip, p — сохраняем данные о владельцах и правах доступа, f — пишем архив в файл, путь к файлу, --exclude — исключаем из архива каталог (я исключил каталоги с записями разговоров и каталог с бэкапами FreePBX), /mnt/ — каталог, который архивируем.
Ждем… у меня вся подготовка и создание архива заняли 10 минут. Будь флэшка быстрее, уложился бы в 7-8 минут.
Отмонтируем диск:
```
umount /mnt
```
… и перезагружаемся.
```
reboot
```
Складываем архив в надежное место за пределами офиса.
Восстановление бэкапа на другом железе
--------------------------------------
##### 2. Размечаем диск, создаем файловую систему
Грузимся с live-флэшки, у меня все та же debian-live-7.8.0.
Переключаемся на root:
```
sudo su
```
Размечаем диск. Мне понравилась утилита с псевдографическим интерфейсом cfdisk. Там все просто и понятно.
```
cfdisk
```
Удаляем все имеющиеся разделы. Я создал два новых раздела, один на 490 Gb под / (sda1) и 10 Gb под swap (sda2) в конце диска, т.к. он практически не будет задействован. Проверим типы разделов. Который под систему должен иметь тип 83 Linux, второй — 82 Linux swap / Solaris. Помечаем системный раздел загрузочным (bootable), сохраняем изменения и выходим.
Cоздаем файловую систему на первом разделе.
```
mkfs.ext4 /dev/sda1
```
##### 3. Распаковываем архив.
Монтируем отформатированный раздел
```
mount /dev/sda1 /mnt
```
Распаковываем архив прямо с флэшки
```
tar --same-owner -xvpf /lib/live/mount/medium/backupYYYYMMDD.tgz -C /mnt/
```
Параметр --same-owner — сохраняет владельцев у распаковываемых файлов, x — извлекаем из архива, v — выводить информацию о процессе, p — сохраняем права доступа, f — указываем файл, который распаковываем, C — распаковываем в категорию.
##### 4. Создаем MBR на новом диске.
Чтобы корректно создать загрузочную запись, монтируем рабочие каталоги к нашему будущему root-каталогу, у меня это /mnt. Каталоги /dev и /proc сейчас используются live-системой, используем параметр bind, чтобы они были доступны сразу в двух местах:
```
mount --bind /dev /mnt/dev
mount --bind /proc /mnt/proc
```
Переключаемся на новую систему используя chroot:
```
chroot /mnt
```
Делаем swap-раздел для новой системы:
```
mkswap /dev/sda2
```
Подключаем его же:
```
swapon /dev/sda2
```
Чтобы grub работал, нужно указать ему правильные UUID разделов в fstab, сейчас там прописаны разделы предыдущей системы:
```
nano /etc/fstab
```
Открываем второй терминал (Alt+F2) под root:
```
sudo su
```
Вызываем:
```
blkid
```
И видим текущие UUID разделов.
Вручную переписываем их в fstab переключаясь между Alt+F1 и Alt+F2. Да, муторно, но попытки копировать занимали у меня больше времени, чем переписывание. Сохраняем fstab.
Устанавливаем grub2. У меня один физический диск, поэтому ставим его на sda:
```
grub-install /dev/sda
```
На чистый диск должно встать без ошибок. Обновляем информацию из fstab:
```
update-grub
```
Возвращаемся в Live-систему:
```
exit
```
Размонтируем все каталоги:
```
umount /mnt/dev
umount /mnt/proc
umount /mnt
```
Если вылазят процессы, которые используют эти каталоги, убиваем их используя fuser.
Все, поехали. Грузимся с жесткого диска:
```
reboot
```
Здесь статья должна была закончиться, но у меня возникли проблемы с подключением к интернету. Сервер видит сеть, видит компьютеры в ней, но в интернет не ходит… а это как бы важно для телефонии.
##### 5. Тестирование и устранение неполадок.
```
ifconfig -a
```
Показывет интерфейсы eth1 и lo, гугление сказало, что gateway можно прописать только подключению eth0, остальные рассчитаны только на работу внутри сети.
Похоже, отсутствие eth0 вызвано способом переноса системы. Находим файл, который отвечает за нумерацию интерфейсов, смотрим туда:
```
nano /etc/udev/rules.d/70-persistent-net.rules
```
Действительно, там два активных интерфейса, определенных MAC’ами. Комментируем первый, второму прописываем eth0.
Перезапуск /etс/init.d/networking не помог, поэтому перезагружаемся:
```
reboot
```
Подключаем донглы, проверяем, все работает.
Спасибо за внимание. | https://habr.com/ru/post/251659/ | null | ru | null |
# Deep dive into PostgreSQL internal statistics. Алексей Лесовский
Расшифровка доклада 2015 года Алексея Лесовского "Deep dive into PostgreSQL internal statistics"
**Disclaimer от автора доклада:** *Замечу что доклад этот датирован ноябрем 2015 года — прошло больше 4 лет и прошло много времени. Рассматриваемая в докладе версия 9.4 уже не поддерживается. За прошедшие 4 года вышло 5 новых релизов в которых появилась масса новшеств, улучшений и изменений относительно статистики и часть материала устарела и не актуальна. По мере ревью я постарался отметить эти места чтобы не вводить тебя читатель в заблуждения. Переписывать же эти места я не стал, их очень много и получится в итоге совсем другой доклад.*
СУБД PostgreSQL — это огромный механизм, при этом состоит этот механизм из множества подсистем, от слаженной работы которых напрямую зависит производительность СУБД. В процессе эксплуатации обеспечивается сбор статистики и информации о работе компонентов, что позволяет оценить эффективность PostgreSQL и принять меры для повышения производительности. Однако, этой информации очень много и представлена она в достаточно упрощенном виде. Обработка этой информации и ее интерпретация порой совсем нетривиальная задача, а "зоопарк" инструментов и утилит запросто поставит в тупик даже продвинутого DBA.
Добрый день! Меня зовут Алексей. Как Илья сказал, я буду рассказывать про статистику PostgreSQL.
Статистика активности PostgreSQL. У PostgreSQL есть две статистики. Статистика активности, про которую будет речь. И статистика планировщика о распределении данных. Я буду рассказывать именно о статистике активности PostgreSQL, которая позволяет нам судить о производительности и как-то ее улучшать.
Расскажу, как эффективно использовать статистику для решения самых разных проблем, которые у вас возникают или могут возникнуть.
Чего не будет в докладе? В докладе я не буду касаться статистики планировщика, т.к. это отдельная тема на отдельный доклад о том, как данные хранятся в базе и о том как планировщик запросов получает представление о качественных и количественных характериситках этих данных.
И не будет обзоров инструментов, я не буду сравнивать один продукт с другим. Никакой рекламы не будет. Отбросим это.
Я хочу вам показать, что использовать статистику – это полезно. Это нужно. Использовать ее нестрашно. Нам понадобится всего лишь обычный SQL и базовые знания о SQL.
И поговорим, какую статистику выбирать для решения проблем.
Если мы посмотрим на PostgreSQL и в операционной системе запустим команду для просмотра процессов, то увидим "черный ящик". Мы увидим какие-то процессы, которые что-то делают, и мы по названию можем примерно представить, что они там делают, чем занимаются. Но, по сути, это черный ящик, вовнутрь мы заглянуть не можем.
Мы можем посмотреть нагрузку на процессор в `top`, можем посмотреть утилизацию памяти какими-то системными утилитами, но заглянуть вовнутрь PostgreSQL мы не сможем. Для этого нам нужны другие инструменты.
И продолжая дальше я расскажу, куда тратится время. Если мы представим PostgreSQL в виде такой схемы, то можно будет ответить, куда тратится время. Это две вещи: это обработка клиентских запросов от приложений и фоновые задачи, которые выполняет PostgreSQL для поддержания своей работоспособности.
Если мы начнем рассматривать с левого верхнего угла, то мы можем проследить, как обрабатывается клиентские запросы. Запрос приходит от приложения и для дальнейшей работы открывается клиентская сессия. Запрос передается в планировщик. Планировщик строит план запроса. Отправляет его дальше на выполнение. Происходит какой-то блочный ввод-вывод данных связанный с таблицами и индексами. Необходимые данные читаются с дисков в память в специальную область "shared buffers". Результаты запроса, если это updates, deletes, фиксируются в журнале транзакций в WAL. Некоторая статистическая информация попадает в лог или в коллектор статистики. И результат запроса отдается уже клиенту обратно. После чего клиент может повторить все заного с новым запросом.
Что у нас с фоновыми задачами и с фоновыми процессами? У нас есть несколько процессов, которые обеспечивают работоспособность и поддерживают базу данных в нормальном рабочем режиме. Эти процессы также будут затрагиваться в докладе: это autovacuum, checkpointer, процессы, связанные с репликацией, background writer. Каждого из них я буду затрагивать по мере доклада.
Какие проблемы есть со статистикой?
* Информации много. PostgreSQL 9.4 предоставляет 109 метрик для просмотра данных статистики. Однако, если в базе данных хранятся много таблиц, схем, баз, то все эти метрики придется умножить на соответствующее количество таблиц, баз. Т. е. информации становится еще больше. И утонуть в ней очень легко.
* Следующая проблема – это то, что статистика представлена счетчиками. Если мы посмотрим эту статистику, то мы увидим постоянно увеличивающиеся счетчики. И если с момента сброса статистики прошло очень много времени, мы увидим миллиардные значения. И они нам ничего не говорят.
* Нет истории. Если у вас произошел какой-то сбой, что-то упало 15-30 минут назад, не получится воспользоваться статистикой и посмотреть, что происходило 15-30 минут назад. Это проблема.
* Отсутствие встроенного в PostgreSQL инструмента – это проблема. Разработчики ядра не предоставляют никакой утилиты. У них нет ничего такого. Они просто дают статистику в базе. Пользуйтесь, делайте к ней запрос, что хотите, то и делайте.
* Так как встроенного в PostgreSQL инструмента нет, то это является причиной другой проблемы. Множество сторонних инструментов. Каждая компания, у которой есть более-менее прямые руки, пытается написать свою программу. И в итоге в community очень много инструментов, которыми можно пользоваться для работы со статистикой. И в одних инструментах есть одни возможности, в других инструментах нет других возможностей, либо есть какие-то новые возможности. И возникает ситуация, что нужно использовать два-три-четыре инструмента, которые друг друга перекрывают и обладают разными функциями. Это очень неприятно.
Что из этого следует? Важно уметь брать статистику напрямую, чтобы не зависеть от программ, либо как-то самому улучшить эти программы: добавить какие-то функции, чтобы получить свою выгоду.
И нужны базовые знания SQL. Чтобы получить какие-то данные из статистики, нужно составить запросы SQL, т. е. вам нужно знать, как составляются select, join.
Статистика предлагает нам несколько вещей. Их можно разделить на категории.
* Первая категория – это события, происходящие в базе. Это когда в базе происходит какое-то событие: запрос, обращение к таблице, автовакуум, коммиты, то это все события. Соответствующие этим события счетчики инкрементируются. И мы можем отследить эти события.
* Вторая категория – это свойства объектов такие, как таблицы, базы. У них есть свойства. Это размер таблиц. Мы можем отследить рост таблиц, рост индексов. Можем посмотреть изменения в динамике.
* И третья категория – это время, затраченное на событие. Запрос – это событие. У него есть своя конкретная мера длительности. Здесь запустился, тут закончился. Мы можем это отследить. Либо время чтения блока с диска или записи. Такие вещи тоже отслеживаются.
Источники статистики представлены следующим образом:
* В разделяемой памяти (shared buffers) есть сегмент для размещения там статичтических данных, там есть и те самые счетчики, которые постоянно инкрементируются, когда происходит те или иные события, либо возникают какие-то моменты в работе базы.
* Все эти счетчики не доступны пользователю и даже не доступны администратору. Это низкоуровневые вещи. Чтобы к ним обратиться PostgreSQL предоставляет интерфейс в виде SQL функций. Мы можем сделать select выброки с помощью этих функций и получить какую-то метрику (или набор метрик).
* Однако использовать эти функции не всегда удобно, поэтому функции являются базой для представлений (VIEWs). Это виртуальные таблицы, которые предоставляют статистику по какой-то конкретной подсистеме, либо по какому-то набору событий в базе данных.
* Эти встроенные представления (VIEWs) являются основным интерфейсом пользователя для работы со статистикой. Они доступны по-умолчанию без какой-либо дополнительной настройки, можете сразу ими пользоваться, смотреть, брать оттуда информацию. А еще есть contrib'ы. Contrib'ы есть официальные. Вы можете установить пакет postgresql-contrib (например, postgresql94-contrib), подгрузили необходимый модуль в конфигурации, указать для него параметры, перезапустить PostgreSQL и можно пользоваться. (Примечание. *В зависимости от дистрибутива, в последних версиях contrib пакет является частью основного пакета*).
* И есть неофициальные contrib. Они не поставляются в стандартной поставке PostgreSQL. Их нужно либо скомпилировать, либо установить как библиотеку. Варианты могут быть самые разные, в зависимости от того, что придумал разработчик этого неофициального contrib’а.
На этом слайде представлены все те представления (VIEWs) и часть тех функций, которые доступны в PostgreSQL 9.4. Как мы видим, их очень много. И довольно легко запутаться, если вы столкнулись с этим в первый раз.
Однако, если мы возьмем предыдущую картинку `Как тратится время на PostgreSQL` и совместим с этим списком, то получим вот такую картинку. Каждое представление (VIEWs), либо каждую функцию мы можем использовать в тех или иных целях для получения соответствующей статистики, когда у нас работает PostgreSQL. И можем получить уже какую-то информацию о работе подсистемы.
Первое, что мы рассмотрим, это `pg_stat_database`. Как мы видим, это представление. В ней очень много информации. Самая разнообразная информация. И она дает очень полезное знание, что у нас происходит в базе данных.
Что мы можем полезное оттуда взять? Начнем c самых простых вещей.
```
select
sum(blks_hit)*100/sum(blks_hit+blks_read) as hit_ratio
from pg_stat_database;
```
Первое, что мы можем посмотреть – это процент попадания в кэш. Процент попадания в кэш – это полезная метрика. Она позволяет оценить, какой объем данных берется из кэша shared buffers, а какой объем читается с диска.
Понятное дело, что **чем большее у нас попадание в кэш, то тем лучше**. Мы оцениваем эту метрику как процент. И, например, если у нас процентное отношение этих попаданий в кэш больше 90 %, то это хорошо. **Если оно опускается ниже 90 %, значит, у нас памяти недостаточно для удержания горячей "головы" данных в памяти. И чтобы эти данные использовать, PostgreSQL вынужден обращаться к диску и это медленнее чем если бы данные читались из памяти. И нужно уже думать над увеличением памяти: либо shared buffers увеличивать, либо наращивать железную память (RAM).**
```
select
datname,
(xact_commit*100)/(xact_commit+xact_rollback) as c_ratio,
deadlocks, conflicts,
temp_file, pg_size_pretty(temp_bytes) as temp_size
from pg_stat_database;
```
Что можно еще взять из этого представления? Можно посмотреть аномалии происходящие в базе. Что здесь показано? Здесь есть commits, rollbacks, создание временных файлов, их объем, deadlocks и конфликты.
Мы можем воспользоваться этим запросом. Этот SQL довольно простой. И можем посмотреть вот эти данные у себя.
И здесь сразу пороговые значения. Мы смотрим соотношение commits и rollbacks. Commits – это успешное подтверждение транзакции. Rollbacks – это откат, т. е. транзакция делала какую-то работу, напрягала базу, что-то считала, а потом произошел сбой, и результаты транзакции отбрасываются. Т. е. **количество rollbacks, постоянно увеличивающихся, это плохо. И следует как-то избегать их, и править код, чтобы такого не происходило.**
**Конфликты (conflicts) связаны с репликацией. И их тоже следует избегать.** Если у вас какие-то запросы, которые выполняются на реплике и возникают конфликты, то нужно эти конфликты разбирать, смотреть, что происходит. Детали можно найти в логах. И устранять конфликтные ситуации, чтобы запросы приложения работали без ошибок.
**Deadlocks – это тоже плохая ситуация. Когда запросы борются за ресурсы, один запрос обратился к одному ресурсу и взял блокировку, второй запрос обратился ко второму ресурсу и также взял блокировку, а потом оба запроса обратились к ресурсам друг друга и заблокировались в ожидании когда сосед отпустит блокировку. Это тоже проблемная ситуация. Их нужно решать на уровне переписывания приложений и сериализации доступа к ресурсам.** И если вы видите, что у вас deadlocks увеличиваются постоянно, нужно смотреть детали в логах, разбирать возникашие ситуации и смотреть в чем проблема.
**Временные файлы (temp\_files) – это тоже плохо. Когда пользовательскому запросу не хватает памяти для размещения оперативных, временных данных, он создает на диске файл. И все операции которые бы он мог выполнить во временном буфере в памяти, начинает выполнять уже на диске. Это медленно.** Это увеличивает время выполнения запроса. И клиент, отправивший запрос к PostgreSQL получит ответ чуть позже. Если эти все операции будут выполняться в памяти, Postgres ответит гораздо быстрее и клиент будет меньше ждать.
Pg\_stat\_bgwriter – это представление описывает работу двух фоновых подсистем PostgreSQL: это `checkpointer` и `background writer`.
Для начала разберем контрольные точки, т.н. `checkpoints`. Что такое контрольные точки? Контрольная точка это позиция в журнале транзакций сообщающая что все изменения данных зафиксированные в журнала успешно синхронизированны с данными на диске. Процесс в зависимости от рабочей нагрузки и настроек может быть длительными и по большей части заключается в синхронизации грязных страниц в shared buffers с датфайлами на диске. Для чего это нужно? Если бы PostgreSQL все время обращался к диску и брал оттуда данные, и записывал данные при каждом обращении, это было бы медленно. Поэтому у PostgreSQL есть сегмент памяти, размер которого зависит от параметров в конфигурации. Postgres размещает в этой памяти оперативные данные для последующей обработки или выдачи по запросам. В случае запросов на изменение данных происходит их изменение. И мы получаем две версии данных. Одна у нас в памяти, другая на диске. И периодически нужно эти данные синхронизировать. Нам нужно то, что изменено в памяти, синхронизировать на диск. Для этого нужны checkpoint.
Checkpoint проходит по shared buffers, помечает грязные страницы, что они нужны для checkpoint. Потом запускает второй проход по shared buffers. И страницы, которые помечены для checkpoint, он их уже синхронизирует. Таким образом выполняется синхронизация данных уже с диском.
Есть два типа контрольных точек. Один checkpoint выполняется по тайм-ауту. Это checkpoint полезный и хороший – `checkpoint_timed`. И есть checkpoints по требованию – `checkpoint required`. Такая контрольная точка происходит когда у нас идет очень большая запись данных. Мы записали очень много журналов транзакций. И PostgreSQL считает, что ему нужно все это как можно быстрее синхронизировать, сделать контрольную точку и жить дальше.
И если вы посмотрели статистику `pg_stat_bgwriter` и увидели, что у вас **checkpoint\_req гораздо больше, чем checkpoint\_timed, то это плохо. Почему плохо? Это значит, что PostgreSQL находится в постоянной стрессовой ситуации, когда ему нужно записывать данные на диск.** Checkpoint по таймауту менее стрессовый и выполняется согласно внутреннему расписанию и как бы растянут по времени. У PostgreSQL есть возможность сделать паузы в работе и не напрягать дисковую подсистему. Это для PostgreSQL полезно. И запросы, которые выполняются во время checkpoint не будут испытывать стрессы от того, что дисковая подсистема занята.
И для регулировки checkpoint есть три параметра:
* `сheckpoint_segments`.
* `сheckpoint_timeout`.
* `сheckpoint_competion_target`.
Они позволяют регулировать работу контрольных точек. Но не буду на них задерживаться. Их влияние – это уже отдельная тема.
**Внимание:** Рассматриваемая в докладе версия 9.4 уже неактуальна. В современных версиях PostgreSQL параметр `checkpoint_segments` заменен параметрами `min_wal_size` и `max_wal_size`.
Следующая подсистема это фоновый писатель — `background writer`. Что он делает? Он работает постоянно в бесконечном цикле. Сканирует страницы в shared buffers и странички грязные, которые он нашел, сбрасывает на диск. Таким образом он помогает checkpointer'у делать меньше работы в процессе выполнения контрольных точек.
Для чего он еще нужен? Он обеспечивает потребность в чистых страницах в shared buffers если они вдруг потребуются (в большом количестве и сразу) для размещения данных. Предположим возникла ситуация когда для выполнения запроса потребовались чистые страницы и они уже есть в shared buffers. Постгресовый `backend` просто берет их и использует, ему не надо самому ничего чистить. Но если вдруг таких страниц нет, бэкенд приостанавливает работу и начинает поиск страниц чтобы сбросить их на диск и взять для своих нужд — что негативно сказывается на времени выполняющегося в данный момент запроса. **Если вы видите, что у вас параметр `maxwritten_clean` большой, это значит, что background writer не справляется со своей работой и нужно увеличивать параметры `bgwriter_lru_maxpages`**, чтобы он смог за один цикл сделать больше работы, больше очистить страничек.
**И другой очень полезный показатель – это `buffers_backend_fsync`.** Бэкенды не делают fsync, потому что это медленно. Они передают fsync выше по IO stack checkpointer’у. У checkpointer есть своя очередь, он периодически fsync обрабатывает и страницы в памяти синхронизирует с файлами на диске. **Если очередь большая у checkpointer и заполнена, то бэкенд вынужден сам делать fsync и это замедляет работу бэкенда**, т. е. клиент получит ответ позже, чем мог бы. Если вы видите, что у вас это значение больше нуля, то это уже проблема и **нужно обратить внимание на настройки background writer'а и также оценить производительность дисковой подсистемы.**
**Внимание:** \_Следующий текст описывает статистические представления связанные с репликацией. Большая часть имен представлений и функций была переименована в Postgres 10. Суть переименований сводилась к замене `xlog` на `wal` и `location` на `lsn` в именах функций/представлений и т.п. Частный пример, функция `pg_xlog_location_diff()` была переименована в `pg_wal_lsn_diff()`.\_
Тут тоже у нас много всего. Но понадобятся нам всего лишь пункты, связанные с location.
**Если мы видим, что все значения равны, то это идеальный вариант и реплика не отстает от мастера.**
Вот эта шестнадцатеричная позиция – это позиция в журнале транзакций. Она постоянно увеличивается, если в базе есть какая-то активность: inserts, deletes и т. д.
```
сколько записано xlog в байтах
$ select
pg_xlog_location_diff(pg_current_xlog_location(),'0/00000000');
лаг репликации в байтах
$ select
client_addr,
pg_xlog_location_diff(pg_current_xlog_location(), replay_location)
from pg_stat_replication;
лаг репликации в секундах
$ select
extract(epoch from now() - pg_last_xact_replay_timestamp());
```
Если эти вещи отличаются, значит есть какой-то лаг. Лаг – это отставание реплики от мастера, т. е. данные отличаются между серверами.
Есть три причины отставания:
* Это дисковая подсистема не справляется с записью синхронизации файлов.
* Это возможные ошибки сети, либо перегрузка сети, когда данные не успевают доезжать до реплики и он не может их воспроизвести.
* И процессор. Процессор – это очень редкий случай. И я видел такое два или три раза, но такое тоже может быть.
И вот три запроса, которые нам позволяют использовать статистику. Мы можем оценить, сколько записано у нас в журнале транзакции. Есть такая функция `pg_xlog_location_diff` и можем оценить лаг репликации в байтах и секундах. Мы тоже для этого используем значение из этого представления (VIEWs).
**Примечание:** \_Вместо pg\_xlog\_location*diff() функции можно использовать оператор вычитания и вычитать один location из другого. Удобно.*
С лагом, который в секундах, есть один момент. Если на мастере не происходит никакой активности, транзакция там была где-то 15 минут назад и активности никакой нет, и если мы на реплике посмотрим этот лаг, то мы увидим лаг в 15 минут. Об этом стоит помнить. И это может вводить в ступор, когда вы посмотрели этот лаг.
Pg\_stat\_all\_tables – еще одно полезное представление. Оно показывает статистику по таблицам. Когда у нас в базе есть таблицы, с ним есть какая-то активность, какие-то действия, мы можем эту информацию получить из этого представления.
```
select
relname,
pg_size_pretty(pg_relation_size(relname::regclass)) as size,
seq_scan, seq_tup_read,
seq_scan / seq_tup_read as seq_tup_avg
from pg_stat_user_tables
where seq_tup_read > 0 order by 3,4 desc limit 5;
```
Первое, что мы можем посмотреть, это последовательные сканирования по таблице. Само число после этих проходов еще не обязательно плохо и не показатель того, что нам нужно уже что-то предпринимать.
**Однако есть вторая метрика – seq\_tup\_read. Это количество строк, возвращенных в результате последовательного сканирования. Если усредненное число превышает 1 000, 10 000, 50 000, 100 000, то это уже показатель, что возможно вам нужно где-то построить индекс, чтобы обращения были по индексу, либо возможно оптимизировать запросы которые использую такие последовательные сканирования, чтобы такого не было.**
Простой пример – допустим, запрос с большим OFFSET и LIMIT стоит. К примеру сканируется 100 000 строк в таблице и после этого берется 50 000 нужных строк, а предыдщие отсканированные строки отбрасываются. Это тоже плохой кейс. И такие запросы нужно оптимизировать. И здесь вот такой простой SQL-запрос, на котором можно это посмотреть и оценить полученные цифры.
```
select
relname,
pg_size_pretty(pg_total_relation_size(relname::regclass)) as
full_size,
pg_size_pretty(pg_relation_size(relname::regclass)) as
table_size,
pg_size_pretty(pg_total_relation_size(relname::regclass) -
pg_relation_size(relname::regclass)) as index_size
from pg_stat_user_tables
order by pg_total_relation_size(relname::regclass) desc limit 10;
```
Размеры таблиц также можно получить с помощью этой таблицы и с помощью дополнительных функций `pg_total_relation_size()`, `pg_relation_size()`.
Вообще, есть метакоманды `\dt` и `\di`, которые можно использовать в PSQL и также посмотреть размеры таблиц и индексов.
Однако использование функций помогает нам посмотреть размеры таблиц еще с учетом индексов, либо без учетов индексов и уже делать какие-то оценки на основе роста базы данных, т. е. как она у нас растет, с какой интенсивностью и делать уже какие-то выводы об оптимизации размеров.
Активность на запись. Что такое запись? Давайте рассмотрим операцию `UPDATE` – операцию обновления строк в таблице. По сути, update – это две операции (а то и ещё больше). Это вставка новой версии строки и пометка старой версии строки как устаревшей. В последствии придет автовакуум и вот эти устаревшие версии строк вычистит, пометит это место как доступное для повторного использования.
Кроме того, update – это не только обновление таблицы. Это еще обновление индексов. Если у вас на таблице много индексов, то при update все индексы, в которых участвуют поля, обновляемые в запросе, нужно будет также обновить. В этих индексах также будут устаревшие версии строк, которые нужно будет почистить.
```
select
s.relname,
pg_size_pretty(pg_relation_size(relid)),
coalesce(n_tup_ins,0) + 2 * coalesce(n_tup_upd,0) -
coalesce(n_tup_hot_upd,0) + coalesce(n_tup_del,0) AS total_writes,
(coalesce(n_tup_hot_upd,0)::float * 100 / (case when n_tup_upd > 0
then n_tup_upd else 1 end)::float)::numeric(10,2) AS hot_rate,
(select v[1] FROM regexp_matches(reloptions::text,E'fillfactor=(\\d+)') as
r(v) limit 1) AS fillfactor
from pg_stat_all_tables s
join pg_class c ON c.oid=relid
order by total_writes desc limit 50;
```
И за счет свего дизайна, UPDATE – это тяжеловесные операции. Но их можно облегчить. Есть `hot updates`. Они появились в PostgreSQL версии 8.3. И что это такое? Это легковесный update, который не вызывает перестроение индексов. Т. е. мы обновили запись, но при этом обновилась только запись в страничке (которая принадлежит таблице), а индексы по-прежнему указывают на ту же самую запись в странице. Там немного такая интересная логика работы, когда приходит вакуум, то он эти цепочки `hot` перестраивает и все продолжает работать без обновления индексов, и происходит все с меньшей тратой ресурсов.
**И когда у вас `n_tup_hot_upd` большое, то это очень хорошо. Это значит, что легковесные updates преобладают и это по ресурсам выходит нам дешевле и все прекрасно.**
```
ALTER TABLE table_name SET (fillfactor = 70);
```
Как увеличить объем `hot update`ов? Мы можем использовать `fillfactor`. Он определяет размер резервируемого свободного месте при заполнении страницы в таблице с помощью INSERT'ов. Когда в таблицу идут inserts, то они полностью заполняют страничку, не оставляют в ней пустого места. Потом выделяется новая страничка. Снова данные заполняются. И это поведение по умолчанию, fillfactor = 100 %.
**Мы можем сделать fillfactor в 70 %. Т. е. при inserts выделилась новая страничка, но заполнилось всего лишь 70 % странички. И 30 % у нас осталось на резерв. Когда нужно будет сделать update, то он с высокой долей вероятности произойдет в той же самой страничке, и новая версия строки поместится в ту же страничку. И будет сделан hot\_update. Таким образом облегчается запись на таблицах.**
```
select c.relname,
current_setting('autovacuum_vacuum_threshold') as av_base_thresh,
current_setting('autovacuum_vacuum_scale_factor') as av_scale_factor,
(current_setting('autovacuum_vacuum_threshold')::int +
(current_setting('autovacuum_vacuum_scale_factor')::float * c.reltuples))
as av_thresh,
s.n_dead_tup
from pg_stat_user_tables s join pg_class c ON s.relname = c.relname
where s.n_dead_tup > (current_setting('autovacuum_vacuum_threshold')::int
+ (current_setting('autovacuum_vacuum_scale_factor')::float * c.reltuples));
```
Очередь автовакуума. Автовакуум – это такая подсистема, по которой статистике в PostgreSQL очень мало. Мы можем в таблицах только в pg\_stat\_activity увидеть, сколько у нас вакуумов длятся в данный момент. Однако понять, сколько таблиц в очереди у него с ходу очень сложно.
**Примечание:** \_Начиная с версии Postgres 10 ситуация с отслеживанием ватовакуума сильно улучшилась — появилось представление pg\_stat\_progress*vacuum, которое существенно упрощает вопрос мониторинга автовакуума.*
Мы можем использовать вот такой упрощенный запрос. И можем посмотреть, когда должен будет сделан вакуум. Но, как и когда должен запуститься вакуум? Вот эти устаревшие версии строк, о которых я говорил раньше. Update произошел, новая версия строки вставилась. Появилась устаревшая версия строки. В таблице `pg_stat_user_tables` есть такой параметр `n_dead_tup`. Он показывает количество "мертвых" строк. И как только количество мертвых строк стало больше, чем определенный порог, к таблице придет автовакуум.
И как рассчитывается этот порог? Это вполне конкретное процентное отношение от общего числа строк в таблице. Есть параметр `autovacuum_vacuum_scale_factor`. Он и определяет процентное отношение. Допустим, 10 % + там дополнительный базовый порог в 50 строк. И что получается? Когда у нас мертвых строк стало больше чем "10 % + 50" от всех строк в таблице, то мы ставим таблицу на автовауум.
```
select c.relname,
current_setting('autovacuum_vacuum_threshold') as av_base_thresh,
current_setting('autovacuum_vacuum_scale_factor') as av_scale_factor,
(current_setting('autovacuum_vacuum_threshold')::int +
(current_setting('autovacuum_vacuum_scale_factor')::float * c.reltuples))
as av_thresh,
s.n_dead_tup
from pg_stat_user_tables s join pg_class c ON s.relname = c.relname
where s.n_dead_tup > (current_setting('autovacuum_vacuum_threshold')::int
+ (current_setting('autovacuum_vacuum_scale_factor')::float * c.reltuples));
```
Однако тут есть один момент. Базовые пороги у параметров `av_base_thresh` и `av_scale_factor` могут назначаться индивидуально. И, соответственно, порог будет не глобальный, а индивидуальный для таблицы. Поэтому чтобы рассчитать, там нужно использовать ухищрения и уловки. И если вам интересно, то вы можете посмотреть на опыт наших коллег из Avito (ссылка на слайде недействительно и обновлена в тексте).
Они написали для [munin plugin](https://github.com/avito-tech/dba-utils/blob/master/munin/vacuum_queue), которые учитывает эти вещи. Там портянка на два листа. Но считает он корректно и довольно эффективно позволяет оценить, где у нас вакуума много требуется для таблиц, где мало.
Что мы можем с этим сделать? **Если у нас очередь большая и автовакуум не справляется, то мы можем поднять количество воркеров вакуума, либо просто сделать вакуум агрессивнее**, чтобы он триггерился раньше, обрабатывал таблицу маленькими кусочками. **И тем самым очередь будет уменьшаться.** — Главное здесь следить за нагрузкой на диски, т.к. вакуум штука небесплатная, хотя с появлением SSD/NVMe устройств проблема стала менее заметной.
Pg\_stat\_all\_indexes – это статистика по индексам. Она небольшая. И мы можем по ней получить информацию по использованию индексов. И например можем определить какие индексы у нас лишние.
Как я уже говорил, **update – это не только обновление таблиц, это еще и обновление индексов.** Соответственно, если у нас на таблице много индексов то при обновлении строк в таблице, индексы проиндексированных полей также нужно обновить, и **если у нас есть неиспользуемые индексы, по которым нет индексовых сканирований, то они у нас висят балластом. И от них нужно избавляться.** Для этого нам нужно поле `idx_scan`. Мы просто смотрим количество индексных сканирований. Если у индексов ноль сканирований за относительно длинный период хранения статистики (не менее чем 2-3 недели), то вероятней всего это плохие индексы, нам нужно от них избавиться.
**Примечание:** *При поиске неиспользуемых индексов в случае кластеров потоковой репликации нужно проверять все узлы кластера, т.к. статистика не глобальная, и если индекс неиспользуется на мастере, то он может использоваться на репликах (если там есть нагрузка).*
Две ссылки:
<https://github.com/dataegret/pg-utils/blob/master/sql/low_used_indexes.sql>
<http://www.databasesoup.com/2014/05/new-finding-unused-indexes-query.html>
Это более продвинутые примеры запросов для того, как искать неиспользуемые индексы.
Вторая ссылка – это довольно интересный запрос. Там очень нетривиальная логика заложена. Рекомендую его для ознакомления.
Что еще стоит подытожить по индексам?
* Неиспользуемые индексы – это плохо.
* Занимают место.
* Замедляют операции обновления.
* Лишняя работа для вакуума.
**Если мы удалим неиспользуемые индексы, то мы сделаем базе только лучше.**
Следующее представление – это `pg_stat_activity`. Это аналог утилиты `ps`, только в PostgreSQL. Если `ps`'ом вы смотрите процессы в операционной системе, то `pg_stat_activity` вам покажет активность внутри PostgreSQL.
Что мы можем оттуда полезного взять?
```
select
count(*)*100/(select current_setting('max_connections')::int)
from pg_stat_activity;
```
Мы можем посмотреть общую активность, что происходит в базе. Можем сделать новый деплой. У нас там все взорвалось, коннекты новые не принимаются, ошибки сыплются в приложении.
```
select
client_addr, usename, datname, count(*)
from pg_stat_activity group by 1,2,3 order by 4 desc;
```
Мы можем выполнить вот такой запрос и посмотреть общий процент подключений относительно максимального лимита подключений и посмотреть, кто у нас занимает больше всего коннектов. И в данном приведенном случае мы видим, что user `cron_role` открыл 508 коннектов. И что-то с ним там произошло. Нужно с ним разбираться и смотреть. И вполне возможно, что это какое-то аномальное число подключений.
Если у нас нагрузка OLTP, запросы должны выполняться быстро, очень быстро и не должно быть долгих запросов. Однако, если возникают долгие запросы, то в краткосрочной перспективе ничего страшного нет, но **в долгосрочной перспективе долгие запросы вредят базе, они увеличивают bloat эффект таблиц, когда происходит фрагментация таблиц. И от bloat, и от долгих запросов нужно избавляться.**
```
select
client_addr, usename, datname,
clock_timestamp() - xact_start as xact_age,
clock_timestamp() - query_start as query_age,
query
from pg_stat_activity order by xact_start, query_start;
```
Обратите внимание: вот таким запросом мы можем определять долгие запросы и транзакции. Мы используем функцию `clock_timestamp()` для определения времени работы. **Долгие запросы, которые мы нашли, мы можем их запомнить, выполнить `explain`, посмотреть планы и как-то оптимизировать.** Текущие долгие запросы мы отстреливаем и дальше живем.
```
select * from pg_stat_activity where state in
('idle in transaction', 'idle in transaction (aborted)';
```
**Плохие транзакции – это транзакции в состоянии idle in transaction и idle in transaction (aborted).**
Что это значит? Транзакции имеют несколько состояний. И одно из этих состояний могут принимать в любой момент времени. Для определения состояний есть поле `state` в этом представлении. И мы используем его для определения состояния.
```
select * from pg_stat_activity where state in
('idle in transaction', 'idle in transaction (aborted)';
```
И, как я уже сказал выше, эти два состояния **idle in transaction и idle in transaction (aborted) – это плохо. Что это такое? Это когда приложение открыло транзакцию, сделало какие-то действия и ушло по своим делам. Транзакция осталась открытая. Она висит, в ней ничего не происходит, она занимает коннект, блокировки на измененные строки и потенциально еще увеличивает bloat других таблиц, из-за архитектуры транзакционного движка Postrges'а. И такие транзакции тоже следует отстреливать, потому что они вредные вообще, при любом раскладе.**
Если вы видите, что их у вас в базе больше 5-10-20, то нужно уже обеспокоиться и начинать с ними что-то делать.
Здесь мы также для времени вычисления используем `clock_timestamp()`. Транзакции отстреливаем, приложение оптимизируем.
Как я уже говорил выше, блокировки – это когда две и больше транзакций борются за один или группу ресурсов. Для этого у нас есть поле `waiting` с булевым значением `true` или `false`.
**True – это значит, что процесс находится в ожидании, нужно что-то делать. Когда процесс находится в ожидании, значит, клиент, который инициировал этот процесс тоже ждет. Клиент в браузере сидит и тоже ждет.**
**Внимание:** \_Начиная с версии Postgres 9.6 поле `waiting` удалено и вместо него добавлены два более информативных поля `wait_event_type` и `wait_event`.\_
Что делать? **Если вы видите true, в течение долго времени то значит, от таких запросов надо избавляться. Мы просто такие транзакции отстреливаем. Разработчикам пишем, что нужно как-то оптимизировать, чтобы не было гонки за ресурсами. И дальше разработчики оптимизируют приложение, чтобы такого не возникало.**
И крайний, но при этом потенциально не фатальный случай – это **возникновение deadlocks. Две транзакции обновили два ресурса, потом обращаются к ним снова, уже к противоположным ресурсам. PostgreSQL в этом случае берет и сам отстреливает транзакцию, чтобы другая могла продолжить работу. Это тупиковая ситуация и она сама не разбирается. Поэтому PostgreSQL вынужден принимать крайние меры.**
<https://github.com/lesovsky/uber-scripts/blob/master/postgresql/sql/c4_06_show_locked_queries.sql>
<https://github.com/lesovsky/uber-scripts/blob/master/postgresql/sql/show_locked_queries_95.sql>
<https://github.com/lesovsky/uber-scripts/blob/master/postgresql/sql/show_locked_queries_96.sql>
<http://big-elephants.com/2013-09/exploring-query-locks-in-postgres/>
И вот два запроса, которые позволяют отслеживать блокировки. Мы используем представление `pg_locks`, которая позволяет отслеживать тяжеловесные блокировки.
И первая ссылка – это сам текст запроса. Он довольно-таки длинный.
И вторая ссылка – это статья по locks. Ее полезно почитать, она очень интересная.
Итак, что мы видим? Мы видим два запроса. Транзакция с `ALTER TABLE` – это блокирующая транзакция. Она запустилась, но не завершилась и приложение запстившее эту транзакцию где-то занимается другими делами. И второй запрос – update. Он ждет, когда закончится alter table, чтобы продолжить свою работу.
Вот так мы можем выяснять, кто кого залочил, держит и можем разбираться с этим дальше.
Следующий модуль – это `pg_stat_statements`. Как я уже сказал, это модуль. Чтобы им воспользоваться нужно подгрузить его библиотеку в конфигурации, перезапустить PostgreSQL, установить модуль (одной командой) и дальше у нас появится новое представление.
```
Cреднее время запроса в милисекундах
$ select (sum(total_time) / sum(calls))::numeric(6,3)
from pg_stat_statements;
Самые активно пишущие (в shared_buffers) запросы
$ select query, shared_blks_dirtied
from pg_stat_statements
where shared_blks_dirtied > 0 order by 2 desc;
```
Что мы можем оттуда взять? Если говорить о простых вещах, мы можем взять среднее время выполнения запроса. Время растет, значит, у нас PostgreSQL отвечает медленно и нужно что-то предпринимать.
Можем посмотреть самые активные пишущие транзакции в базе данных, которые меняют данные в shared buffers. Посмотреть, кто у нас там обновляет или удаляет данные.
И можем просто посмотреть разную статистику по этим запросам.
<https://github.com/dataegret/pg-utils/blob/master/sql/global_reports/query_stat_total.sql>
Мы `pg_stat_statements` используем для построения отчетов. Раз в сутки сбрасываем статистику. Накапливаем ее. Перед сбросом статистики в следующий раз, строим отчет. Вот ссылка на отчет. Вы можете его посмотреть.
Что мы делаем? Мы подсчитываем общую статистику по всем запросам. Затем для каждого запроса мы считаем его индивидуальный вклад в эту общую статистику.
И что мы можем посмотреть? Мы можем посмотреть суммарное время выполнения всех запросов конкретного типа на фоне всех остальных запросов. Можем посмотреть использование ресурсов процессора и ввода-вывода относительно общей картины. И уже оптимизировать эти запросы. Мы строим топ запросов по этому отчету и уже получаем пищу для размышления, что оптимизировать.
Что у нас осталось за кадром? Осталось еще несколько представлений, которые я не стал рассматривать, потому что время ограничено.
Есть `pgstattuple` – это тоже дополнительный модуль из стандартного пакета contribs. Он позволяет оценить `bloat` таблицы, т.н. фрагментацию таблицы. И если фрагментация большая, нужно ее убирать, использовать разные инструменты. И функция `pgstattuple` работает долго. И чем больше таблиц, тем дольше она будет работать.
Следующий contrib – это `pg_buffercache`. Он позволяет проводить инспекцию shared buffers: насколько интенсивно и под какие таблицы утилизируются страницы буфера. И просто позволяет заглянуть в shared buffers и оценить происходящее там.
Следующий модуль – это `pgfincore`. Он позволяет проводить низкоуровневые операции с таблицами через системный вызов `mincore()`, т. е. он позволяет загрузить таблицу в шаредные буфера, либо ее выгрузить. И позволяет помимо прочего проводить инспекцию страничного кэша операционной системы, т. е. в каком объеме у нас таблица занимаем в page cache, в shared buffers и просто позволяет оценить загруженность таблицы.
Следующий модуль – `pg_stat_kcache`. Он также использует системный вызов `getrusage()`. И выполняет его перед и после выполнения запроса. И в полученной статистике позволяет оценить, сколько у нас запрос затратил на выполнение дискового ввода-вывода, т. е. операции с файловой системой и смотрит использование процессора. Однако модуль молодой (кхе-кхе) и для своей работы он требует PostgreSQL 9.4 и pg\_stat\_statements, о котором я говорил ранее.
* Умение пользоваться статистикой – полезно. Вам не нужны сторонние программы. Вы можете сами заглянуть, посмотреть, что-то сделать, выполнить.
* Пользоваться статистикой несложно, это обычный SQL. Вы собрали запрос, составили, отправили, посмотрели.
* Статистика помогает ответить на вопросы. Если у вас возникают вопросы, вы обращаетесь к статистике – смотрите, делаете выводы, анализируете результаты.
* И экспериментируйте. Запросов много, данных много. Всегда можно оптимизировать какой-то уже существующий запрос. Можно сделать свою версию запроса, которая подходит вам больше, чем оригинал и использовать его.
**Ссылки**
Годные ссылки, которые встречались в статье, по материалам которой, были в докладе.
Автор пиши ещё
<https://dataegret.com/news-blog> (eng)
The Statistics Collector
<https://www.postgresql.org/docs/current/monitoring-stats.html>
System Administration Functions
<https://www.postgresql.org/docs/current/functions-admin.html>
Contrib modules
<https://www.postgresql.org/docs/current/pgstatstatements.html>
<https://www.postgresql.org/docs/current/pgstattuple.html>
<https://www.postgresql.org/docs/current/pgbuffercache.html>
<https://github.com/klando/pgfincore>
<https://github.com/dalibo/pg_stat_kcache>
SQL utils and sql code examples
<https://github.com/dataegret/pg-utils>
Всем спасибо за внимание! | https://habr.com/ru/post/505440/ | null | ru | null |
# Ежедневная архивация веб-проектов
Вот такую вещь я сделал сегодня. А перед этим — ещё год назад, работая в веб-студии.
Предлагается вашему вниманию bat-скрипт для ежедневной архивации home-директории вашего сайта и базы данных (MySQL).
*Требования:* **Windows** (у меня на работе — 2000), команда **mysqldump** доступная сразу из командной строки, **WinRAR** или любой другой архиватор, работающий из командной строки.
`@echo off
set DATE = `date \T`
@md "%DATE%"
cd "%DATE%"
mysqldump drupal -u root > "drupal-%DATE%.sql"
"C:\Program Files\WinRAR\rar.exe" a -inul "htdocs-%DATE%.rar" c:\apache\htdocs
cd "../"`
Скрипт может запускаться вручную или планировщиком по расписанию (достаточно стандартного системного планировщика). Линуксоиды могут легко переписать этот скрипт для своей системы.
При выполнении в среде Windows 2000 генерируется директория типа "**Пн 17.12.2007**", а в ней два файла — "**drupal-Пн 17.12.2007.sql**" и "**htdocs-Пн 17.12.2007.rar**". Новый день — новая директория. Преимущество отдельной директории в том, что у вас может создаваться несколько бэкапов разных сайтов.
И напоследок — если кто-то знает, как изменить формат даты на 2007-12-12 — напишите пожалуйста. | https://habr.com/ru/post/17633/ | null | ru | null |
# Играючи BASH'им дальше
Первая статья [И. BASH'им в начало](https://habrahabr.ru/post/335960)
Вдохновившись отзывами на первую статью я продолжил разработку piu-piu. В игре появилось интро\меню, реализовано посимвольное появление объектов, изменилось цветовое решение. Палитра теперь определяется по времени года, правда, из-за недостатка цветов пришлось ограничиться 3-мя вариантами: зима — начало весны, весна — лето и осень. Изменения можно оценить, скачав игру [тут](https://github.com/vaniacer/piu-piu-SH). Далее немного букв как это все получилось.
**Гифка с новым геймплеем**
Я начал с реализации посимвольного вывода объектов. Что может быть проще? Просто сделай срез элемента спрайта, но…
Управляющие коды (цвет) срежутся, и вместо цветного символа получится каша. Необходимо пересобрать элемент спрайта посимвольно, вставляя нужные управляющие коды перед каждым символом. Поприсядав изрядное количество времени со срезами я, наконец, разработал похожий алгоритм. Тестовый сценарий:
```
#!/bin/bash
# подключаю свою табличку с красками
. ~/SCR/color
# тестовый спрайт
sprite=(
'/¯¯¯¯¯\'
'| 0 |'
'\_____/'
)
# расцветка тестового спрайта
sprite_color=(
"$RED"
"$GRN"
"$BLU"
)
# уже знакомые функции выхода и определения размеров
function bye () {
stty echo
printf "${CON}${DEF}"
clear
ls --color=auto
exit
}
function get_dimensions {
size=($(stty size))
endx=${size[1]}
endy=${size[0]}
}
# инициализация
get_dimensions
X=$endx
Y=$[$endy/2]
sn=${#sprite[@]} # количество элементов спрайта
sl=${#sprite[0]} # ширина спрайта, считаетсяя по наибольшему элементу
trap bye INT; stty -echo; printf "${COF}"; clear
# цикл
while true; do sleep 0.1; get_dimensions
for (( p=0; p<${sn}; p++ )); do # цикл по элементам спрайта
end=$[1-(${X}-${endx})]
if [ $X -gt 0 ]; then
bgn=0
XY ${X} $(($Y + $p)) \
# цвет | срез спрайта
"${sprite_color[$p]}${sprite[$p]:${bgn}:${end}} ${DEF}"
else
bgn=$[1-$X]
XY 1 $(($Y + $p)) \
"${sprite_color[$p]}${sprite[$p]:${bgn}:${end}} ${DEF}"
fi
done
((X--)); [ $X -lt -${sl} ] && X=$endx
done
```
Получилось так:
Но этот алгоритм позволяет «красить» только строки целиком, это не было пределом мечтаний и не соответствовало существующей раскраске спрайтов. Пришлось поприседать еще. Таблица цветов расширилась, для каждого символа определен свой цвет. Каждый элемент массива цветов преобразуется в отдельный массив, индексы которого совпадают с индексами элемента спрайта. Затем элемент цвета и элемент спрайта рисуются в нужном месте и в нужное время.
```
#!/bin/bash
. ~/SCR/color
# новый тестовый спрайт
sprite=(
' /¯¯¯¯¯\ '
'-----|12345|-------- '
' --|12345|--- '
' ----|12345|---- '
' \_____/ '
)
# расцветка тестового спрайта, свой цвет для каждого символа
C01=$UND$BLU; C02=$UND$BLD$BLU C03=$DEF$MGN
sprite_color=(
"$DEF $DEF $DEF $DEF $DEF $DEF $DEF"
"$DEF $RED $GRN $C01 $C03 $YLW $DEF $RED $DEF $DEF $DEF $BLU $DEF"
"$DEF $RED $GRN $C02 $C03 $YLW $DEF $DEF $GRN $DEF $DEF $DEF $DEF"
"$DEF $RED $GRN $C01 $C03 $YLW $DEF $DEF $DEF $BLU $DEF $DEF $DEF"
"$DEF $DEF $DEF $DEF $DEF $DEF $DEF"
)
function bye () {
stty echo
printf "${CON}${DEF}"
clear
ls --color=auto
exit
}
function get_dimensions {
size=($(stty size))
endx=${size[1]}
endy=${size[0]}
}
get_dimensions
X=$endx
Y=$[$endy/2]
L=1
sn=${#sprite[@]}
sl=${#sprite[1]}
trap bye INT; stty -echo; printf "${COF}"; clear
while true; do sleep 0.1; get_dimensions
((L++)); ((X--)); [ $X -lt -${sl} ] && { X=$endx; L=1; }
for (( p=0; p<${sn}; p++ )); do
color=(${sprite_color[p]}); YY=$[$Y+${p}]
# вложенные циклы по символам элементов спрайта
if [ $X -gt 1 ]; then
for (( k=0; k<${L}; k++ )); do
XY $[${k}+${X}] ${YY} \
"${color[$k]}${sprite[$p]:$k:1}"
done
else
for (( k=1; k<${sl}; k++ )); do
XY ${k} ${YY} \
"${color[$[$k-$X]]}${sprite[$p]:$[$k-$X]}"
done
fi
done
done
```
Теперь все символы могут быть разноцветными:
Отлично! Я решил проверить как это будет рисоваться поверх другого спрайта. Добавил статический спрайт в основной цикл:
```
for (( p=0; p<${sn}; p++ )); do
XY 3 $[${endy}/2+${p}] "${sprite[$p]}"
done
```
И проверил:
Нормально, но если сзади «маска» получается сама собой, то передняя часть рисуется квадратом, затирая все, опять присядания.
```
#!/bin/bash
. ~/SCR/color
# у спрайта появились индексы смещения
sprite=(
5' /¯¯¯¯¯\ '
0' -----|12345|-------- '
3' --|12345|--- '
1' ----|12345|---- '
5' \_____/ '
)
# немного изменил таблицу расцветки
sprite_color=(
"$DEF"
"$DEF $DEF $DEF $DEF $DEF $DEF $DEF $MGN $YLW $grn $RED $MGN $DEF"
"$DEF $DEF $DEF $DEF $DEF $DEF $DEF $BLU $GRN $cyn $ylw $blu $DEF"
"$DEF $DEF $DEF $DEF $DEF $DEF $DEF $YLW $RED $BLU $grn $YLW $DEF"
"$DEF"
)
function bye {
stty echo
printf "${CON}${DEF}"
clear
ls --color=auto
exit
}
function get_dimensions {
size=($(stty size))
endx=${size[1]}
endy=${size[0]}
}
get_dimensions
X=$endx
Y=$[$endy/2]
L=1
sn=${#sprite[@]}
sl=${#sprite[1]}
trap bye INT; stty -echo; printf "${COF}"; clear
while true; do sleep 0.1; get_dimensions
# фоновый спрайт
for (( p=0; p<${sn}; p++ )); do
XY 3 $[${endy}/2+${p}] "${sprite[$p]}"
done
# увеличиваю циферки
((L++)); ((X--))
[ $X -lt -${sl} ] && { X=$endx; L=1; }
for (( p=0; p<${sn}; p++ )); do
# определяю цвет
color=(${sprite_color[p]})
# координату Y
YY=$[$Y+${p}]
# смещение начала
stp=${sprite[$p]:0:1}
# срез спрайта
spr=${sprite[$p]:1}
if [ $X -gt 1 ]; then
for (( k=0; k<${L}; k++ )); do
if [ $k -ge $stp ]; then
XY $[${k}+${X}] ${YY} \
"${DEF}${color[$k]}${spr:$k:1}"
fi
done
else
for (( k=1; k<${sl}; k++ )); do
XY ${k} ${YY} \
"${color[$[$k-$X]]}${spr:$[$k-$X]}"
done
fi
done
done
```
Красота!
**Небольшое лирическое отступление**Механика посимвольного вывода построена на срезах. Срезы вообще очень удобны. Их можно использовать для всяких прикольных штук при работе с текстом.
Баш позволяет делать срезы как переменных, так и массивов. Пример, срез переменной:
```
a=1234567890
# отрезали 3 символа вначале
echo ${a:3}
4567890
# вырезали 3 символа из тела
echo ${a:3:3}
456
# можно указывать отрицательное значение второго элемента среза, это подрежет конец
echo ${a:(-4)}
123456
echo ${a:(-5):(-2)}
678
```
А теперь срез массива:
```
a=( 1 2 3 4 5 6 7 8 9 0 )
# отрезали 3 элемента вначале
echo ${a[*]:3}
4 5 6 7 8 9 0
# вырезали 3 символа из тела
echo ${a[*]:3:3}
# срез с конца
echo ${a[@]:(-5)}
6 7 8 9 0
# а так почему-то нельзя
echo ${a[@]:(-5):(-1)}
bash: (-1): выражение подстроки < 0
```
Помню, во времена Спектрума ты не мог называться крутым кодером, если не сделал крутой скроллер. И все крутые парни делали их(мы тоже). Во всех демках были скроллеры с бесконечными гритингсами, матами, шутками-прибаутками. Хорошее было время. Попробуем запилить скроллер на BASH'е, используя срезы конечно:
```
#!/bin/bash
# подключаю палитру и функцию рисования XY
. ~/SCR/color
# текст, можно задать параметром
text=${1:-'Hello Wo00000o0000000o000orld! '}; N=${#text}
# опять эти функции
function bye {
stty echo
printf "${CON}${DEF}"
clear
ls --color=auto
exit
}
function get_dimensions {
size=($(stty size))
endx=${size[1]}
endy=${size[0]}
}
# инициализация
get_dimensions
trap bye INT
stty -echo
printf "${COF}"
X=$[$endx+1]
Y=$[$endy/2]
L=0; clear
# цикл
while true; do sleep 0.05; get_dimensions
[ $X -gt 1 ] \
&& XY $X $Y "${text:0:$L}" \
|| XY 1 $Y "${text:$[1-$X]:$L}"
[ $X -lt -$N ] && { X=$endx; L=0; } || ((X--))
[ $L -lt $endx ] && ((L++))
done
```
Привет мир!
А если прикрутить сюда *figlet*, получится вообще хорошо:
```
#!/bin/bash
. ~/SCR/color
text=${1:-'Hello Wo00000o0000000o000orld! '}; N=${#text}
function bye {
stty echo
printf "${CON}${DEF}"
clear
ls --color=auto
exit
}
function get_dimensions {
size=($(stty size))
endx=${size[1]}
endy=${size[0]}
}
get_dimensions
trap bye INT
stty -echo
printf "${COF}"
IFSOLD=$IFS
IFS=$'\n'
# добавился фиглет
figlet_text=( $(figlet -w$[$N*10] "${text}") )
IFS=$IFSOLD
NF=${#figlet_text[1]}
NFL=${#figlet_text[*]}
X=$[$endx+1]
Y=$[$endy/2-$NFL/2]
L=0; clear
while true; do sleep 0.05; get_dimensions
if [ $X -gt 1 ]; then
# цикл по элементам фиглетового текста
for ((i=0; i<$NFL; i++)); do
XY $X $[$Y+$i] "${figlet_text[$i]:0:$L}"
done
else
for ((i=0; i<$NFL; i++)); do
XY 1 $[$Y+$i] "${figlet_text[$i]:$[1-$X]:$L}"
done
fi
[ $X -lt -$NF ] && { X=$endx; L=0; } || ((X--))
[ $L -lt $endx ] && ((L++))
done
```
Тут есть одна тонкость. Я переопределяю символ «разделитель». По умолчанию разделителями являются: пробел, таб, переход строки. Все это хранится в системной переменной *IFS*. Я запоминаю старое значение:
```
IFSOLD=$IFS
```
Затем устанавливю разделителем только переход строки *\n*:
```
IFS=$'\n'
```
Офиглеваю текст в массив *figlet\_text* командой:
```
figlet_text=( $(figlet -w$[$N*10] "${text}") )
```
Ключ -w задает фиглету ширину строки, т.к. по умолчанию он вписывает текст в экран. А это добавляет ненужные переходы строки, и чуда не происходит. Ну и возвращаю старое значение разделителя:
```
IFS=$IFSOLD
```
Фиглетовый скроллер!
Итак, спрайты режутся, скорей впихивай этот алгоритм в игру! Я попробовал и о… очень сильно расстроился. Скорость, мягко говоря, оставляла желать лучшего:
Множественные вложенные циклы отрицательно сказываются на быстродействии (внезапно). А ведь я пробовал без деревьев, облаков и прочей мишуры, мда.
Но после такого количества присяданий не хотелось выбрасывать идею на помойку. Моск начал работать. Решение было найдено. Использовать оба метода! Юху! Появление\исчезновение посимвольно а полет по экрану «быстрым» методом. Цикл объектов теперь выглядит так:
```
NO=${#OBJ[@]}
for (( i=0; i<$NO; i++ )); do
OI=(${OBJ[$i]})
OX=${OI[0]}
OY=${OI[1]}
cuter=${OI[2]}
type=${OI[3]}
case $type in
# объекты с меняющимися спрайтами(быстрый\медленный)
# дерево 1 медленный спрайт
"tree1" ) sprite=("${tree1[@]}")
# палитра медленного спрайта
sprite_color=("${tree1_color[@]}")
# быстрый спрайт
sprite_fast=("${tree12[@]}")
# функция - двигатель
# +---------+------+------+------+
# | функция |таймер|высота|ширина|
# +---------+------+------+------+
mover $Q 4 4;;
# дерево 2
"tree2" ) sprite=("${tree2[@]}")
sprite_color=("${tree2_color[@]}")
sprite_fast=("${tree22[@]}")
mover $W 6 6;;
# дерево 3
"tree3" ) sprite=("${tree3[@]}")
sprite_color=("${tree3_color[@]}")
sprite_fast=("${tree32[@]}")
mover $E 9 10;;
# облако 1
"cloud1") sprite=("${cloud1[@]}")
sprite_color=("${cloud1_color[@]}")
sprite_fast=("${cloud12[@]}")
mover $Q 3 7;;
# облако 2
"cloud2") sprite=("${cloud2[@]}")
sprite_color=("${cloud2_color[@]}")
sprite_fast=("${cloud22[@]}")
mover $W 3 9;;
# облако 3
"cloud3") sprite=("${cloud3[@]}")
sprite_color=("${cloud3_color[@]}")
sprite_fast=("${cloud32[@]}")
mover $E 3 12;;
# враги
"alien" ) sprite=("${alien[@]}")
sprite_color=("${alien_color[@]}")
sprite_fast=("${alien2[@]}")
mover 0 3 5;;
# объекты с только быстрыми спрайтами
# выстрел босса
# быстрый спрайт
"bfire" ) sprite=("${bfire[@]}")
# функция - двигатель
# +---------+------+------+------+
# | функция |таймер|высота|ширина|
# +---------+------+------+------+
mover 0 6 4;;
# бонус - патроны
"ammo" ) sprite=("${ammob[@]}")
mover 0 3 4;;
# бонус - жизнь
"life" ) sprite=("${lifep[@]}")
mover 0 3 4;;
# бонус - усилитель ствола
"gunup" ) sprite=("${gunup[@]}")
mover 0 3 4;;
# взрывы, не латают, рисуем 1 раз
"boom" ) er=${boomC}
for part in "${boom[@]:$B:$boomC}"; do
stp=${part:0:1}
spr=${part:1}
XY $[${OX} + $stp] ${OY} "${spr}"; ((OY++))
done
[ ${E} = 0 ] && { ((B+=${boomC}))
[ $B -gt ${boomN} ] && { B=0; erase_obj ${i}; }; };;
esac; done
```
А вот функция *mover*:
```
function mover () {
er=$2 # кол-во линий спрайта
width=$3 # ширина спрайта
# плюсуем циферки
[ ${1} = 0 ] && {
((OX--))
((cuter++))
OBJ[$i]="$OX $OY $cuter $type"
}
# не улетел ли объект
case ${type} in
'alien'|'tree'[1-3]|'cloud'[1-3])
[ $OX -lt -$width ] && {
remove_obj ${i}
case ${type} in
"alien") ((enumber--));;
esac; return
};;
*)
[ $OX -lt 1 ] && {
erase_obj ${i}
case ${type} in
"alien") ((enumber--));;
esac; return; };;
esac
# рисовалка
for (( p=0; p<${er}; p++ )); do
case ${type} in
# быстрые\медленные спрайты
'alien'|'tree'[1-3]|'cloud'[1-3])
color=(${sprite_color[$p]})
YY=$[$OY+${p}]
stp=${sprite[$p]:0:1}
spr=${sprite[$p]:1}
# прилетает\летит
if [ $OX -gt 1 ]; then
if [ $cuter -lt $width ]; then
# прилетает, посимвольный вывод
for (( k=0; k<${cuter}; k++ )); do
if [ $k -ge $stp ]; then
XY $[$k+$OX] $YY \
"${color[$k]}${spr:$k:1}"
fi
done
else
# летит, переключение на быстрый спрайт
stp=${sprite_fast[$p]:0:1}
spr=${sprite_fast[$p]:1}
XY $[${OX} + $stp] $[$OY + $p] "${spr}"
fi
# улетает
else
# опять посимвольно
for (( k=1; k<${width}; k++ )); do
x=$[$k-$OX]
XY $k $YY "${color[$x]}${spr:$x}"
done
fi;;
# только быстрые спрайты
*) XY ${OX} $[$OY + $p] "${sprite[$p]}";;
esac
# проверка коллизий
case ${type} in
"gunup" )
case "$[$OY + $p] $OX" in
"$HY $HX")
[ ${G} -lt 4 ] && ((G++))
erase_obj ${i}
break;;
esac;;
"life" )
case "$[$OY + $p] $OX" in
"$HY $HX")
((life++))
erase_obj ${i}
break;;
esac;;
"ammo" )
case "$[$OY + $p] $OX" in
"$HY $HX")
((ammo+=100))
erase_obj ${i}
break;;
esac;;
"bfire" )
case "$OY $OX" in
"$HY $HX")
((life--))
erase_obj ${i}
break;;
esac;;
"alien" )
# столкновение с пулей
for (( t=0; t<${NP}; t++ )); do
case "$[$OY + 1] $[$OX + $p]" in
"${PIU[$t]}") # есть бонус?
if [ $[RANDOM % $rnd] -eq 0 ]; then
OBJ+=("$OX $OY 0 ${bonuses[$[RANDOM % \
${#bonuses[@]}]]}")
((frags++))
((enumber--))
remove_obj ${i}
remove_piu ${t}
OBJ+=("${OX} ${OY} 0 boom")
break
fi;;
esac
done
# столкновение с героем
case "$[$OY + 1] $[$OX + $p]" in
"$HY $HX")
((life--))
((frags++))
((enumber--))
remove_obj ${i}
OBJ+=("${OX} ${OY} 0 boom")
break;;
esac;;
esac
done
}
```
Пришлось нарисовать по 2 комплекта спрайтов для обоих методов вывода. И ограничить количество одновременно вылетающих объектов. Для чужих я добавил в условие появления тайминг. А деревьям\облакам уменьшил вероятность появления. Вот какие спрайты получились, на примере дерева:
```
# "медленный" спрайт
tree3=(
3' _._ '
2' / \ '
1' _\ | / '
0'/ \║/__ '
0'\_\/║/ \ '
3' \║|/_/ '
4' ║/ '
4' ║ '
4' ║ ')
# основной цвет меняется в зависимости от времени года
case $month in
0[1-4]|12) CLR=${cyn} ;; # зима
0[5-8] ) CLR=${BLD}${GRN};; # лето
09|1[0-1]) CLR=${DIM}${red};; # осень
esac
CM1=${SKY}${BLK}
tree3_color=(
"${SKY} ${SKY} ${SKY} ${CLR} ${CLR} ${CLR} ${SKY}"
"${SKY} ${SKY} ${CLR} ${SKY} ${SKY} ${SKY} ${CLR} ${SKY}"
"${SKY} ${CLR} ${CLR} ${SKY} ${CM1} ${SKY} ${CLR} ${SKY}"
"${CLR} ${SKY} ${SKY} ${CLR} ${CM1} ${CLR} ${CLR} ${CLR} ${SKY}"
"${CLR} ${CLR} ${CM1} ${CLR} ${CM1} ${CLR} ${SKY} ${SKY} ${CLR} ${SKY}"
"${SKY} ${SKY} ${SKY} ${CM1} ${CM1} ${CLR} ${CM1} ${CLR} ${CLR} ${SKY}"
"${SKY} ${SKY} ${SKY} ${SKY} ${CM1} ${CM1} ${SKY}"
"${SKY} ${SKY} ${SKY} ${SKY} ${CM1} ${SKY}"
"${SKY} ${SKY} ${SKY} ${SKY} ${CM1} ${SKY}")
# "быстрый" спрайт
tree32=(
3${CLR}'_._ '${SKY}
2${CLR}'/ \ '${SKY}
1${CLR}'_\ '${CM1}'|'${CLR}' / '${SKY}
0${CLR}'/ \\'${CM1}'║'${CLR}'/__ '${SKY}
0${CLR}'\_'${CM1}'\\'${CLR}'/'${CM1}'║'${CLR}'/ \ '${SKY}
3${BLK}'\║'${CLR}'|'${CM1}'/'${CLR}'_/ '${SKY}
4${BLK}'║/ '${SKY}
4${BLK}'║ '${SKY}
4${BLK}'║ '${SKY})
```
И тут мы плавно переходим к следующей фиче. Основной цвет деревьев, облаков и фона меняется в зависимости от времени года. Время года определяется по месяцу. Месяц определяется *date'ом*:
```
month=$(date +'%m')
```
В разное время года игра будет выглядеть по разному. Сейчас так, осень:
А скоро будет так, зима — начало весны:
А так будет совсем не скоро. Весна — лето:
Но читеры могут сделать так:
```
month=07
```
Да, пулялка может увеличиваться до х5, и босс немного подрос.
А вот такое интро\меню появилось в игре:
Но тут тоже не все было гладко в плане быстродействия. Большие спрайты даже поодиночке жутко тормозили в посимвольном режиме вывода. Пришлось делать присядания опять, да.
Я решил нарезать спрайты на куски по 3 символа и выводить их «быстрым» методом:
```
D=$DEF; C1=$BLU; C2=$RED; C3=$YLW; C4=$red
C5=$BLD$YLW; C6=$BLD$GRN; C7=$blu; C8=$BLD$RED
# ░ ░░░ ░░ ░ ░░ ░░ ░░ ░
# ░ ░ ▒██████ ░▒██████ ▒██░ ▒██
# ░ ░░▒▓██ ▒▓██ ▓▓▓██▓ ▒▓██ ░▒▓██░░ ░
#░ ░ ░░▒▓██ ▒▓██ ▒▒▒▓██ ░▒▓██░ ▒▓██░
# ▒▓██████░ ░▒▓██ ░▒▓██ ░▒▓██░░ ░ ░
# ░ ▒▓██▓▓▓▓ ░ ▒▓██░ ▒▓██░░▒▓██ ░
# ▒▓████▒▒▒░ ░ ▓██████ ▒▓██████░░ ░
#░ ░▒▓▓▓▓ ░ ░░▒▓▓▓▓▓▓ ░ ▒▓▓▓▓▓░
# ░ ▒▒ ░ ░ ░ ░▒▒▒▒▒▒ ░ ░░▒▒▒▒░ ░
piu=(
"$C1 " "░ " " ░░" "░ ░" "░ " " " "░ " "░░ " " " " ░" "░ " "░░ " "░$D " " "
"$C1 ░ " " ░" " $C2▒" "$C3███" "███" " $C1░$C2▒" "$C3███" "███" " $C2▒$C3█" "█$C1░ " " $C2▒$C3█" "█$D " " " " "
"$C1 " "░ ░" "░$C2▒$C4▓" "$C3██ " "$C2▒$C4▓$C3█" "█ $C4▓" "▓▓$C3█" "█$C4▓ " "$C1▒$C4▓$C3█" "█ $C1░" "$C2▒$C4▓$C3█" "█$C1░░" " ░$D " " "
"$C1░ ░" " ░░" "$C2▒$C4▓$C3█" "█ $C2▒" "$C4▓$C3██" " $C2▒▒" "▒$C4▓$C3█" "█ $C2░" "▒$C4▓$C3█" "█$C1░ " "$C2▒$C4▓$C3█" "█$C1░$D " " " " "
"$C1 " " " "$C2▒$C4▓$C5█" "███" "██$C1░" " ░$C2▒" "$C4▓$C3██" " $C1░$C2▒" "$C4▓$C3██" " $C1░$C2▒" "$C4▓$C3██" "$C1░░ " "░ ░$D" " "
"$C1 ░" " $C2▒" "$C4▓$C3██" "$C4▓▓▓" "▓ " "$C1░ $C2▒" "$C4▓$C3██" "$C1░ $C2▒" "$C4▓$C3██" "$C1░░$C2▒" "$C4▓$C3██" " $C1░$D " " " " "
"$C2 " "▒$C4▓$C3█" "███" "$C2▒▒▒" "$C1░ ░" " $C4▓$C3█" "███" "██ " "$C1▒$C4▓$C3█" "███" "██$C1░" "░ ░$D" " " " "
"$C1░ ░" "$C2▒$C4▓▓" "▓▓ " "$C1░ ░" "░$C2▒$C4▓" "▓▓▓" "▓▓ " "$C1░ $C2▒" "$C4▓▓▓" "▓▓$C1░$D" " " " " " " " "
"$C1 ░ " "▒▒ " "░ ░" " ░ " "░▒▒" "▒▒▒" "▒ ░" " ░░" "▒▒▒" "▒░ " " ░ " " " " " "$D ")
piuN=${#piu[*]}; piuC=14
# ░░ ▒▒███░
# ░░░ ▒████ ▒▓███░
# ░ ▒████▒▓▓▓▓ ░░▒▓▓███ ░░ ░
#░ ▒▓▓▓▓ ▒████░▒▓███░░
# ▒ ▒▒ ▒▓▓▓▓▒▓███░
# ░░░ ▒▒▒ ░░▒▒░
arr=(
" " " " " " " " " $C7░░" " $C3▒▒" "$C6███" "$C7░$D " "" ""
" " " " " $C7░" "░░ " "$C2▒$C8██" "██ " "$C7▒$C3▓$C6█" "██$C7░$D" "" ""
" " " $C7░ " "▒$C8██" "██$D$C2▒" "$C3▓▓▓" "▓ $C7░" "░$C7▒$C3▓" "▓$C6██" "█ $C7░" "░ ░$D"
" " "$C7░ $C2▒" "$C3▓▓▓" "▓ $C2▒" "$C8███" "█$D$C7░$C3▒" "$C3▓$C6██" "█$C7░░$D" " " ""
" " " $C7▒ " "▒▒ " " $C2▒$C3▓" "▓▓▓" "$C7▒$C3▓$C6█" "██$C7░$D" " " "" ""
" " " " " $C7░░" "░ ▒" "▒▒ " "░░▒" "▒░$D " " " "" "")
arrN=${#arr[*]}; arrC=10
```
Рисуется вся эта красота своими функциями *left*, *right* и *intro*:
```
function left () { N=$1; C=$2
# move
[ $OX -ge $end ] && {
((OX-=3)); [ $cuter -ne $C ] && ((cuter++))
for ((j=0; j<$N; j+=$C)); do
line=("${sprite[@]:$j:$cuter}")
YY=$[$OY+$j/$C]; spr=
for part in "${line[@]}"; dospr+="${part}"; done
XY $OX $YY "${spr}"
done; OBJ[$i]="$OX $OY $cuter $end $type $pause"
} || { remove_obj $i; ((Q++)); OBJ+=("${scenario[$Q]}"); }
}
function right () { N=$1; C=$2
# move
[ $OX -le $end ] && {
[ $cuter -ne $C ] && ((cuter++)) || ((OX+=3))
for ((j=0; j<$N; j+=$C)); do
line=("${sprite[@]:$j:$C}")
YY=$[$OY+$j/$C]; spr=
for ((k=$[$C-$cuter]; k<$C; k++)); do spr+="${line[k]}"; done
XY $OX $YY "${spr}"
done; OBJ[$i]="$OX $OY $cuter $end $type $pause"
} || { remove_obj $i; ((Q++)); OBJ+=("${scenario[$Q]}"); }
}
function intro { get_dimensions; Q=0
scenario=(
# сценарий появления объектов
#----------+-------+-----+------------+----+
# старт X |старт Y|резак| конец X |тип |
#----------+-------+-----+------------+----+
"$[$endx+1] 3 0 $[endx/2-34] piu"
"$[$endx+1] 3 0 $[endx/2+2] piu"
"-2 12 0 $[endx/2-16] arr"
"0 0 0 0 end")
OBJ=("${scenario[$Q]}")
while true; do sleep 0.005; NO=${#OBJ[@]}
for (( i=0; i<$NO; i++ )); do
OI=(${OBJ[$i]}); OX=${OI[0]}; OY=${OI[1]}
cuter=${OI[2]}; end=${OI[3]}; type=${OI[4]}
case $type in
#-----+-------------------+------+------+------+
#тип | спрайт |функц.|высота|ширина|
#-----+-------------------+------+------+------+
"arr") sprite=("${arr[@]}"); right $arrN $arrC;;
"piu") sprite=("${piu[@]}"); left $piuN $piuC;;
"end") return ;;
esac
done
done
}
```
Последовательность появления объектов задается в массиве *scenario*. Пункт меню *conf* дает возможность кастомизации (небольшой) самолетика. Можно изменить цвет самолетика и символ на хвосте (и его цвет).
И еще кучка мелких доработок\исправлений по ходу написания двух статей (к слову о пользе статей). Дальше хочется поработать над оптимизацией, приподнять фпс и попробовать реализовать кооператив по сети, продолжение следует. На этом пока все (где-то я это слышал).
Продолжение [И. BASH'им вместе](https://habrahabr.ru/post/339268)
Пиу, пиу, пиу! :) | https://habr.com/ru/post/337896/ | null | ru | null |
# Как Clojure помогает ускорить написание Selenium-тестов
 Привет, читатель! Если доводилось писать Selenuim-тесты чуть сложнее чем на пару полей ввода и одну кнопку, то эта статья может пригодиться.
Наверняка знакомо чувство неправильности происходящего, когда внезапно отказывался работать тест-кейс длиной в пару минут, вынуждая тыкаться вслепую, чтобы найти поломавшийся css- или xpath-селектор в сложном Single Page Application, раз за разом запуская этот медленный сценарий, только чтобы дождаться вывода лога в консоль. Оказывается, можно писать Selenium-тесты с комфортом!
**О чём статья - другими словами для нубов**Про Selenium. Когда-то это был просто плагин для FireFox. Нажимаешь кнопочку "запись", и начинаешь дергать интерфейсы тестируемого сайта (формочки, ссылки). Практически без знания программирования, полученный сценарий можно править, подставляя нужные значения проверок. Всё — тест готов! Запускай каждый раз после деплоя, и проверяй, чего сдвинул локтем. Потом в Selenium добавили API для разных языков. В частности есть и для JAVA. Через API можно делать тоже самое: запускать браузер с требуемым сайтом, проверять переданные значения в формах, ходить по ссылкам и т.д. Беда в том, что скрипт выполняется медленно. Чтобы тестировать тесты, надо перезапускать сценарий, а это форменная пытка. Clojure (поверх JAVA) позволяет выполнять куски кода в работающей программе посредством [REPL](https://ru.wikipedia.org/wiki/REPL) прямо в редакторе!
#### Разбор проекта с Selenium-тестами
[Проект доступен на GitHub](https://github.com/seryh/example-selenium-project), особенности:
* Кроссплатформенность — писать тесты можно под ОС Windows, с профайлом +windows, затем собирать jar файл под \*nix, и выкладывать на сервер.
* Работа сразу с двумя web drivers: selenium и phantom, это удобно когда нужно визуально отладить тест в Selenium, скомпилировать jar, который работает с Phantom и залить его на Linux-сервер где его будет дергать какой-нибудь CI-скрипт.
[В зависимостях проекта](https://github.com/seryh/example-selenium-project/blob/master/project.clj#L7-L16) можно увидеть библиотеку — clj-webdriver, это основной инструмент для работы с веб-драйвером, [документация к нему](https://github.com/semperos/clj-webdriver/wiki/Taxi-API-Documentation#exists).
Разберем простой тест [example-selenium-project.tests.gosuslugi-main](https://github.com/seryh/example-selenium-project/blob/master/src/example_selenium_project/tests/gosuslugi_main.clj):
```
(deftest gosuslugi-main-search-form
(profile/open-browser "https://www.gosuslugi.ru/")
(try
(->> ($ ".index-slider-search input")
(type-text "загранпаспорт")
(->>keys Keys/ARROW_DOWN)
(->>keys Keys/ARROW_DOWN)
(->>keys Keys/ENTER))
(when-not ($ ".title_search")
(throw (Exception. "redirect to search result, error")))
(swap! profile/tests-success inc)
(is true)
(log/info "gosuslugi-main-search-form -> ok")
(catch Exception e
(log/info "gosuslugi-main-search-form -> fail" (.getMessage e))
(swap! profile/tests-fail inc)
(is false))))
```
```
(deftest gosuslugi-main-search-form ...)
```
`deftest` — макрос, импортируется из библиотеки `clojure.test`. Это встроенная в Clojure библиотека для написания тестов. Имеет стандартный для тестов функционал. Макрос `deftest` просто создает функцию.
Сам тест обернут в `(try ... catch)` для удобства, чтобы прерывать выполнение формы вызовом `Exception`, или же в любых нестандартных случаях (например, если не найден элемент), и выполнять форму в `catch`, обрабатывающую провал теста.
```
(->> ($ ".index-slider-search input") ...)
```
`->>` — стандартный Clojure-макрос для написания более читабельного кода "шиворот навыворот". Без него сценарий выглядел бы так:
```
(->>keys Keys/ENTER
(->>keys Keys/ARROW_DOWN
(->>keys Keys/ARROW_DOWN
(type-text "загранпаспорт" ($ ".index-slider-search input")))))
```
Макрос `->>` принимает список форм и раскрывает их, передавая последовательно результат выполнения, как последний аргумент, следующей форме. Чтобы использовать макрос `->>`, я сделал [несколько функций-обёрток](https://github.com/seryh/example-selenium-project/blob/master/src/utils/webdriver.clj), которые следуют простому соглашению — принимают последним аргументом объект element, и возвращают его же.
`(swap! profile/tests-success inc)` и `(swap! profile/tests-fail inc)` — простые счетчики успешных и проваленных тестов.
#### Почему Clojure?
Простой ответ — уровень абстракции над сложностью. Должно быть ты уже [сходил в Википедию](https://ru.wikipedia.org/wiki/Clojure), посмотрел на синтаксис этого Lisp-диалекта, и проходишь первую стадию принятия неизбежного. Пройдёшь её или нет — дело твоё, могу только дать несколько советов, основанных на опыте.
* Clojure — легкий в изучении язык, более высокий порог входа связан с его отличием от императивного подхода, который нам вбивают в голову со школы. Переборов закостенелость сознания, мы увидим что Clojure превращается в удобный инструмент, позволяющий упростить разработку приложения.
* Как же не запутаться в таком обилии скобок? Особых проблем со скобками нет, к ним привыкаешь за день, когда понимаешь их назначение. Так же в редакторах появился ряд хороших инструментов, которые облегчают инкубационный период Clojure-разработчика. Во-первых, прекрасный [Parinfer](https://shaunlebron.github.io/parinfer/), доступен для большинства редакторов. А во-вторых, банальное включение в настройках редактора радужных скобок.
* Для написания тестов не понадобится доскональное знание Clojure. [Трансдьюсеры, редьюсеры и прочая муть](https://habrahabr.ru/post/247889/) — изучение этого можно отложить на потом. Для старта достаточно [освоить базу](https://learnxinyminutes.com/docs/ru-ru/clojure-ru/) за пару-тройку вечеров.
**Как Parinfer помогает закрывать скобки в зависимости от отступов**
#### Быстрый старт по инструментам разработки
> Если бы ты провел молодость будучи хиппи в Америке 60-х годов, то мог вкусить дух свободны, демократии ~~и лёгких наркотиков~~; если не довелось, ничего страшного — этот дух ты можешь ощутить используя в работе REPL Clojure.
**REPL Clojure** — выводит написание Selenium-тестов на совершенно иной уровень! Ключевая особенность этого [REPL](https://ru.wikipedia.org/wiki/REPL) от любых других в том, что можно писать код в уже работающем приложении, не теряя его состояний. Этот инструмент позволяет не просто составлять рабочие css- или xpath-селекторы, но и проводить тесты в каком угодно порядке, и проверять работоспособность любого из узлов большого тест-кейса не теряя состояния сложного Single Page Application.
**Демонстрация возможностей REPL в редакторе Atom**
Выполнение кода нашего проекта построчно посредством REPL в редакторе LightTable
**Редактор кода для Clojure** — почти под все популярные редакторы и IDE существуют плагины для поддержки Clojure, я остановился на [IntelliJ IDEA + Cursive](https://cursive-ide.com), как имеющий наименее низкий порог входа. Небольшая [инструкция](https://cursive-ide.com/userguide/repl.html) по настройке и использованию REPL в Cursive.
Также популярны:
* Emacs + [Cider](https://github.com/clojure-emacs/cider) ([Spacemacs](http://spacemacs.org/))
* [Atom](https://atom.io/) + [Proto REPL](https://atom.io/packages/proto-repl)
* [LightTable](http://lighttable.com)
**Leiningen** — менеджер зависимостей, как npm из мира Node.js. С тем отличием, что, как зависимость, Leiningen преподносит ещё и сам интерпретатор Clojure. Поэтому нам достаточно будет [установить Leiningen](http://leiningen.org), Clojure он скачает сам.
**Про библиотеки**Основной [репозиторий Clojure](https://clojars.org), так же можно использовать библиотеки из maven-репозитория (несметные богатства Java-сообщества). [Подборка полезных библиотек](http://www.clojure-toolbox.com).
После этого можно создать новый Clojure-проект, набрав в консоли:
```
lein new app example-selenium-project
```
Leiningen создаст нам всё дерево проекта и конфигурационный файл — project.clj, (в npm его аналог — package.json).
Таже в Leiningen очень хорошо реализована работа с профайлами, определив ряд своих профайлов в разделе `:profiles` файла [project.clj](https://github.com/seryh/example-selenium-project/blob/master/project.clj), можно очень гибко разделять работу программы в окружениях develop или production, и не только.
Можно запускать приложение с любым количеством профайлов, например:
```
lein with-profile +windows,+selenium run
```
Или скомпилировать jar с нужными профайлами:
```
lein with-profile +windows,+phantom uberjar
```
#### Заключение
Рискну предположить что Clojure является на сегодня наиболее удобным инструментом для написания Selenium-тестов. Благодаря двум факторам: интерактивному REPL и макросам, которые позволяют создать свой собственный лаконичный [DSL](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BC%D0%B5%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA)-подпроект. Как показывает практика, можно не знать сам язык Clojure и успешно работать с DSL на фасаде. Это открывает неплохие возможности к быстрому подключению новых специалистов к написанию и поддержке тестов.
#### Полезные ссылки
* [Видео-курсы по Clojure](http://clojurecourse.by/).
* [Slack-чатик](https://clojurians.slack.com/) — инвайт можно получить [тут](https://clojurians.typeform.com/to/b4I3Nv), подключайтесь к #clojure-russia каналу!
* [WebMeetups > clojure-russia](http://webmeetups.net/mgroups/25) — видео-записи тусовок.
**Критика статьи в Slack-чатике #clojure-russia****yashaka**
у меня есть подозрения что за трай кетч в тест логике могут не слабо накинуться… любые сложные конструкции типа ифов, циклов, трай кетчов — считаются плохим тоном в написании тестов
в нашем примере — это ведь функционал логирования по сути, и такие вещи обычно выносят в какие то абстракции…
может если есть желание показать удобство, то стоит показать как вынести такой код логирования в какую то — то ли функцию толи макрос дополнительный вокруг deftest
**seryh**
ну юнит тесты и селениум тесты, разные вещи. на практике try в селениуме очень удобен. так как почти все отваливания тестов происходят из за устаревших селекторов (edited) или еще какой внезапной фигни которую сложно предсказать
**yashaka**
логика “не использовать сложные конструкции” растет от того факта что тестов много, они могут менятся, и их пишет большое количество людей — поэтому нет времени сильно вдумываться в флоу — тесты должны быть буквально очевидными
по крайней мене насколько я это себе понимаю:)
в селениум тестах — это еще более важно, так как тесты сложнее сами по себе…
**seryh**
да простор для улучшения большой ) руки пока не дошли
**yashaka**
> или еще какой внезапной фигни которую сложно предсказать
внезапная фигня — это в любом случае эксепшен
и полетевший эксепшен — это уже упавший тест с репортом
просто встроенные в селениум эксепшены — мало информативны
поэтому люди и пишут свои врапперы вокруг селениума
как бы потому — что бы тест логика оставалась простой и очевидной…
**seryh**
я там в статье отметил в заключении что можно dsl написать простой
а в примере, так наколенная поделка
**yashaka**
я сам автоматизатор, а не разработчик, и вишу тут в чатах на эту тему,
и там как только какой то новичок показывает тест с ифами и трай кетчами — сразу льются горы нравоучений…
здесь суть не в том что хорошо а что плохо…
а в том что и так у нас посыл громкий как для неформального языка, и народ начнет лить критику :)
и получается мы им с нашими “наколенными подделками” только еще больше повода даем
У меня сейчас завал, поэтому к сожалению нет времени на то что бы помочь… Но если мы не спешим, то где то через недельку-вторую, я смог бы поконтрибьютить в эту статью…
**motor4ik**
а кейс самый главный не рассмотрен в статье? что упал тест и как его реплом починить?
я так понимаю это была киллерфича статьи нет?
**seryh**
публикация на понедельник запланирована. вообще если взлетит то можно и вторую статью запилить
и свой dsl для тестирования запилить =Р
а так, небольшой примерчик сейчас, вполне понятный новичку
P.S. Я выступаю лишь в роли вдохновителя и редактора, автор статьи — [seryh](https://habrahabr.ru/users/seryh/). | https://habr.com/ru/post/308228/ | null | ru | null |
# Пишем свой плагин для XBMC. Пока без блекджека и всех остальных
Всем привет. Речь в топике пойдёт о создании плагина (программного дополнения, аддона) к замечательной программе [XBMC](http://xbmc.org/). Уровень сложности: для начинающих. Понадобятся знания HTML и общее представление о работе сайтов; не помешает знать как выглядит [Python](http://ru.wikipedia.org/wiki/Python). Не ждите под катом уникальных алгоритмов и магического кода, это скорее отправная точка и общее объяснение механики работы плагинов. Код будет, надеюсь, наглядным.
Некоторые из вас могут спросить: «Ведь есть [репозиторий seppius](http://code.google.com/p/seppius-xbmc-repo/), который решает почти все проблемы с воспроизведением онлайн-контента в рунете (в контексте XBMC). Зачем велосипеды?». Я приведу свои доводы в небольшом предисловии.
#### Предисловие
Я занялся разработкой плагинов XBMC, когда у меня появился лишний ноутбук. Было принято решение, чтобы мёртвым грузом не валялся, сделать мультимедиа приставку для телевизора (TV был лишён связи с Всемирной паутиной). XBMC был шикарным решением проблемы, но вот незадача: живу-то я в Кыргызстане. Весь трафик с IP-адресов не относящихся к нашей стране очень дорог («внешка», не знаю есть ли у вас подобное? Лишь пару месяцев назад стали появляться доступные безлимитные тарифы). А вот внутренний трафик практически бесплатен (многие популярные сайты с медиа-контентом вообще не тарифицируются у многих провайдеров). Придумано, сделано. К моменту написания статьи мной охвачены все нужные ресурсы. Теперь занимаюсь разработкой [PVR](http://wiki.xbmc.org/index.php?title=PVR) плагина.
Я уже не пишу на Python код такой, какой будет приведён в статье. Но это было моей отправной точкой и пониманием механизмов работы дополнений.
#### Подготовка
Нам понадобятся:
* [Python 2.x](http://www.python.org/download/) не перепутайте с 3.x ([здесь](http://wiki.xbmc.org/index.php?title=Python_development) сказано что в XBMC используется версия 2.4, но мне кажется что информация устарела);
* [XBMC 11 Eden](http://xbmc.org/download/) или [XBMC 12 Frodo](http://xbmc.org/download/) (сейчас для нас разницы нет, но лучше использовать последнюю версию, хоть она и RC)
* Ваш любимый текстовый редактор
Устанавливаем вышеуказанные. Путь у Вас может отличаться – в скобках я указал свой: Python (C:\Python\, далее **PathPython**)
Не будет лишнем знать где лежит лог-файл XBMC:
**Windows**: %APPDATA%\XBMC\xbmc.log
**Linux**: $HOME/.xbmc/temp/xbmc.log
**Mac OS X**: /Users//Library/Logs/xbmc.log
#### Часть первая. Тренировка
Отмечу, что мои знания Python'а были практически нулевые. Поэтому, если и Вы с ним никогда не сталкивались, то пугаться не стóит. В изучении той области функционала, которая нам нужна, он очень прост. Ну, по крайней мере, мне так показалось.
В качестве подопытного кролика был выбран сайт [LineCinema](http://www.linecinema.org/). Почему? Потому что ~~[гладиолус](http://lurkmore.to/%D0%9F%D0%BE%D1%82%D0%BE%D0%BC%D1%83_%D1%87%D1%82%D0%BE_%D0%B3%D0%BB%D0%B0%D0%B4%D0%B8%D0%BE%D0%BB%D1%83%D1%81)~~ я зашёл в тему [Запросы на создание плагинов](http://xbmc.ru/forum/showthread.php?t=428) (XBMC Russia) и на одной из последних страниц (если хотите точности, то на 87-ой) увидел запрос для этого сайта. Далее просто Сайт.
Итак, создаём в текстовом редакторе новый файл и пишем следующий код:
```
# -*- coding: utf-8 -*-
# Импортируем нужные нам библиотеки
import urllib, urllib2, re, sys, os
# Функция для получения исходного кода web-страниц
def GetHTML(url):
headers = {'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3', 'Content-Type':'application/x-www-form-urlencoded'}
conn = urllib2.urlopen(urllib2.Request(url, urlencode({}), headers))
html = conn.read()
conn.close()
return html
# Тест на работоспособность
html = GetHTML('http://www.linecinema.org/')
print html
```
Сохраняем **PathPython/test.py**
Открываем Командную строку и переходим в папку PathPython. Выполняем:
`python test.py`
Результатом её выполнения должен быть исходный код страницы Сайта.
**Визуально**
Теперь, в браузере открываем Сайт и лезем в исходный код (различные веб-инспекторы и firebug нам не помогут). Здесь надо обратить внимание на строчку
```
```
и не забыть, что кодировка страницы windows-1251.
Ищем ссылки раздела «Фильмы По Жанрам» и узнаём, что они имеют вид:
```
[Драма](/newsz/drama-online/)
```
Переключаемся (или открываем, если успели закрыть) на **test.py**. Удаляем строку
```
print html
```
И на её место пишем
```
genre_links = re.compile('<(.+?)>
').findall(html.decode('windows-1251'))
# Сопоставляем результаты первого и второго (.+?) с переменными url и title (будут присвоены в порядке указания)
for url, title in genre_links:
print title + ' [' + url + ']'
```
Где (.+?) регулярное выражение, пропускающее все символы (про регулярные выражения Python можно почитать на [хабре](http://habrahabr.ru/post/115825/)).
Сохраняем файл и повторяем в Командной строке
`python test.py`
На этот раз результатом будут названия жанров и ссылка.
**Визуально**
Но есть лишние ссылки, которые в XBMC будут бесполезны: «Главная», «Заказать фильм», «Тех. Поддержка». Что с ними делать? Мы их исключим. Для начала грубо, хотя можно было бы использовать [BeautifulSoup](http://habrahabr.ru/post/114503/).
Напишем функцию `isLinkUseful()`, специально для Сайта, т. к. «лишние» ссылки будут объявлены внутри:
```
def isLinkUseful(needle):
haystack = ['/index.php', '/newsz/Televydenye/100432-2008-3-11-432.html', '/newsz/500183-tex-podderzhka.html'] # список “лишних” ссылок
return needle not in haystack
```
и изменим последние строчки:
```
for url, title in genre_links:
if isLinkUseful(url):
print title + ' [' + url + ']'
```
Проверяем. Всё как надо:
**Визуально**
Ещё немного тренировки. Теперь проверим один из разделов. Я взял «Документальный» (/newsz/dokumentalnyij-online/). Изменим код:
```
#url = 'http://www.linecinema.org/'
#html = GetHTML(url)
#genre_links = re.compile('<(.+?)>').findall(html.decode('windows-1251'))
#for url, title in genre_links:
#if isLinkUseful(url):
#print title + ' [' + url + ']'
url = 'http://www.linecinema.org/newsz/dokumentalnyij-online/'
html = GetHTML(url)
genre_links = re.compile(' <(.+?)>
========
').findall(html.decode('windows-1251'))
for url, title in genre_links:
print title
```
Проверяем и видим, что здесь исключать ничего не надо:
**Визуально**
Тут мы использовали `(.+?)
======` (да-да, с пробелами), т. к. в исходном коде тоже с пробелами и если бы мы использовали просто `(.+?)`, то получили бы все ссылки со страницы. А оно нам надо?
#### Часть вторая. Адаптируемся к XBMC
Для начала было бы неплохо создать папку (где Вам больше всего нравится). И название можно было бы оставить «Новая папка (∞)», но не в этот раз. Прочитав [Рекомендации к разработке дополнений](http://wiki.xbmc.org/index.php?title=Add-on_development) можно узнать, что название папки составляется по следующему шаблону:
``[.].
Следуя этому шаблону (я надеюсь, Вы всё-таки прочтёте рекомендации) название будет следующим:
**plugin.video.linecinema**
Зайдем внутрь папки и заполним пустоту. [Официальные требования](http://wiki.xbmc.org/index.php?title=Add-on_development) к видео/аудио/некоторым другим add-on’ам (если Вы до сих пор не в курсе, мы делаем именно видео-плагин) гласят, что структура должна быть следующей:
addon.py
addon.xml
changelog.txt
fanart.jpg
icon.png
LICENSE.txt
/resources
settings.xml
/language/
/lib/
/media/
* **addon.py** – здесь будет находится основной код плагина. В принципе, название не имеет значения (так как мы сами укажем его в файле addon.xml). В большинстве плагинов он назван default.py
* **addon.xml** – сообщает XBMC: тип плагина (видео, аудио, изображения, скрипт и [так далее](http://wiki.xbmc.org/index.php?title=Addon.xml#The_.3Cextension.3E_elements)); какой файл надо выполнить при обращении (тот самый \*.py); платформу и зависимости; версию, автора и описание плагина. О форматировании можно почитать [здесь](http://wiki.xbmc.org/index.php?title=Addon.xml).
* **changelog.txt**, **LICENSE.txt** – надеюсь, понятно из названия.
* **fanart.jpg** – фоновое изображение плагина. [Ссылка на рекомендации](http://wiki.xbmc.org/index.php?title=Add-on_development#fanart.jpg).
* **icon.png** – "лицо" нашего плагина. [Рекомендации](http://wiki.xbmc.org/index.php?title=Add-on_development#icon.png).
* **/resources/settings.xml** – хранит в себе настройки плагина (ну, к примеру, логин/пароль для авторизации на сайтах), т.е. то, что мы хотим использовать в addon.py. Хранит не сами значения конечно же, а разметку формы, куда мы будем эти значения вписывать. [Описание и формат](http://wiki.xbmc.org/index.php?title=Addon_Settings).
* **/resources/language/** - языковые файлы. Если хотите, чтобы Ваш плагин попал в официальный репозиторий, то абсолютно всё [надо переводить](http://wiki.xbmc.org/index.php?title=Language_support).
* **/resources/lib/** - лучшее место для хранения дополнительных библиотек Python.
* **/resources/media/** - сюда прятать изображения, звуки, видео и т. п.
Из всего вышеперечисленного мы задействуем: addon.py, addon.xml и… всё. Но в конце статьи можно найти архив, в котором сохранена вся структура.
Код файла addon.xml:
```
xml version="1.0" encoding="utf-8" standalone="yes"?
video
LineCinema.org
Привет, Хабрахабр.
Это тестовый плагин для сайта LineCinema.org
all
```
Остановимся подробнее. Из строки ``XBMC узнает, что директория с плагином называется "plugin.video.linecinema", отображаемое название "LineCinema", версия 0.0.1, имя автора "noname".
Из строки />`, что для работы просто необходима библиотека [xbmc.python](http://mirrors.xbmc.org/docs/python-docs/) версии 1.0.
Далее `video` точка входа – файл "addon.py". А сам плагин надо разместить во вкладке "Видео дополнения".
Если остались непонятные места, то попробуйте перечитать [формат файла addon.xml](http://wiki.xbmc.org/index.php?title=Addon.xml).
Перейдём к файлу addon.py:
```
# -*- coding: utf-8 -*-
import urllib, urllib2, re, sys
import xbmcplugin, xbmcgui
def get_params():
param=[]
paramstring=sys.argv[2]
if len(paramstring)>=2:
params=sys.argv[2]
cleanedparams=params.replace('?','')
if (params[len(params)-1]=='/'):
params=params[0:len(params)-2]
pairsofparams=cleanedparams.split('&')
param={}
for i in range(len(pairsofparams)):
splitparams={}
splitparams=pairsofparams[i].split('=')
if (len(splitparams))==2:
param[splitparams[0]]=splitparams[1]
return param
```
xbmcplugin и xbmcgui – модули из библиотеки xbmc.python.
Функция `get_params()` – честно говоря, даже не пытался разобраться в том, что она делает. Шестым чувством догадываюсь, что разбивает строку обращения плагина на параметры, позволяющее сохранять переменные при переходе по директориям плагина. Если непонятно, то не кидайте тухлое яйцо в меня. Это функция, которая очень часто встречается в плагинах, взята из одного из них.
Пишем дальше:
```
def addLink(title, url):
item = xbmcgui.ListItem(title, iconImage='DefaultVideo.png', thumbnailImage='')
item.setInfo( type='Video', infoLabels={'Title': title} )
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=item)
def addDir(title, url, mode):
sys_url = sys.argv[0] + '?title=' + urllib.quote_plus(title) + '&url=' + urllib.quote_plus(url) + '&mode=' + urllib.quote_plus(str(mode))
item = xbmcgui.ListItem(title, iconImage='DefaultFolder.png', thumbnailImage='')
item.setInfo( type='Video', infoLabels={'Title': title} )
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sys_url, listitem=item, isFolder=True)
```
`addDir(title, url, mode)` – будет создавать пункт для перехода по ссылке и отображения новых пунктов. `Mode` – переменная, хранящая номер функции для обработки ссылки (ниже будет понятно что к чему).
`addLink(title, url)` – будет создавать пункт, при переходе на который начнётся воспроизведение `url`. В `url` должна храниться прямая ссылка на видео/аудио/изображение и т.п.
Добавляем ниже:
```
params = get_params()
url = None
title = None
mode = None
try: title = urllib.unquote_plus(params['title'])
except: pass
try: url = urllib.unquote_plus(params['url'])
except: pass
try: mode = int(params['mode'])
except: pass
xbmcplugin.endOfDirectory(int(sys.argv[1]))
```
Это будут наши "глобальные переменные". А `xbmcplugin.endOfDirectory(int(sys.argv[1]))` сообщит XBMC, что это конец "директории" и больше пунктов не будет.
Осталось совсем немного. Добавляем наши функции `getHTML(url)` и `isLinkUseful(needle)` из первой части и теперь *addon.py* должен выглядеть следующим образом:
**addon.py**
```
# -*- coding: utf-8 -*-
import urllib, urllib2, re, sys
import xbmcplugin, xbmcgui
def getHTML(url):
headers = {'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3', 'Content-Type':'application/x-www-form-urlencoded'}
conn = urllib2.urlopen(urllib2.Request(url, urllib.urlencode({}), headers))
html = conn.read()
conn.close()
return html
def isLinkUseful(needle):
haystack = ['/index.php', '/newsz/Televydenye/100432-2008-3-11-432.html', '/newsz/500183-tex-podderzhka.html']
return needle not in haystack
def get_params():
param=[]
paramstring=sys.argv[2]
if len(paramstring)>=2:
params=sys.argv[2]
cleanedparams=params.replace('?','')
if (params[len(params)-1]=='/'):
params=params[0:len(params)-2]
pairsofparams=cleanedparams.split('&')
param={}
for i in range(len(pairsofparams)):
splitparams={}
splitparams=pairsofparams[i].split('=')
if (len(splitparams))==2:
param[splitparams[0]]=splitparams[1]
return param
def addLink(title, url):
item = xbmcgui.ListItem(title, iconImage='DefaultVideo.png', thumbnailImage='')
item.setInfo( type='Video', infoLabels={'Title': title} )
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=item)
def addDir(title, url, mode):
sys_url = sys.argv[0] + '?title=' + urllib.quote_plus(title) + '&url=' + urllib.quote_plus(url) + '&mode=' + urllib.quote_plus(str(mode))
item = xbmcgui.ListItem(title, iconImage='DefaultFolder.png', thumbnailImage='')
item.setInfo( type='Video', infoLabels={'Title': title} )
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sys_url, listitem=item, isFolder=True)
params = get_params()
url = None
title = None
mode = None
try: title = urllib.unquote_plus(params['title'])
except: pass
try: url = urllib.unquote_plus(params['url'])
except: pass
try: mode = int(params['mode'])
except: pass
xbmcplugin.endOfDirectory(int(sys.argv[1]))
```
У Вас так же? Если да, то отлично.
Теперь опять вспомним первую часть и проанализируем Сайт: у нас будет список жанров; было бы неплохо найти и показать какие фильмы есть в каждой из категорий; отобразить ссылку на просмотр фильма. Получается нам нужны три функции. Назовём их так: **Categories()** – список жанров, **Movies()** – список доступных фильмов, **Videos()** – ссылки на видео. Приступим:
```
def Categories():
url = 'http://www.linecinema.org'
html = getHTML(url)
genre_links = re.compile('<(.+?)>
').findall(html.decode('windows-1251').encode('utf-8'))
for link, title in genre_links:
if isLinkUseful(link):
addDir(title, url + link, 20)
```
`addDir(title, url + link, 20)` заменил нам `print title + ' [' + url + ']'`. `Categories()` не будет иметь входных параметров - `url` нам надо объявить самим. Обратите внимание, что последний слеш убран – он будет компенсирован переменной `link`.
Цифра `20` – сообщит, что следующая функция будет `Movies(url)`. Но ведь магии не бывает и нам надо написать для этого в конец файла, перед `xbmcplugin.endOfDirectory(int(sys.argv[1]))`, проверку:
```
if mode == None:
Categories()
elif mode == 20:
Movies(url)
elif mode == 30:
Videos(url, title)
```
Чем это попахивает тут? Не говнокодом ли? Ну точно, им самым. Но такая модель помогла мне разобраться что к чему, сейчас я её, конечно же, не использую. А вот мой первый плагин был точно таким же.
Не отвлекаемся и парсим список фильмов:
```
def Movies(url):
html = getHTML(url)
movie_links = re.compile(' <(.+?)>
========
').findall(html.decode('windows-1251').encode('utf-8'))
for link, title in movie_links:
addDir(title[:-12], link, 30)
```
Опять код из первой части. `title[:-12]` что это за страшный смайлик? Если убрать [:-12], то вы увидите, что название будет иметь вид "Умопомрачительный фильмец / Magnificent movie (2013) HDRip онлайн". И зачем нам "онлайн"? Убрать его!
Теперь надо выдернуть прямую ссылку на видео. Открываем любую ссылку фильма с Сайта и смотрим его исходный код. Ого, да тут нас ждали! Видим вот такой блок:
```
flashvars = {
uid: "player\_uppod",
bufferproc2 :1,
bufferproc\_reloadsec :10,
st: "/templates/linecinema-dle90/swf/video30-365.txt",
file: "http://st7.linecinema.org/s/820e31e7cbe3e8c362785b733db56c57/film10/Druzea.navek.DVDRip.flv"
};
params = {bgcolor:"#ffffff", allowFullScreen:"true", allowScriptAccess:"always",wmode:"opaque"};
attributes = {
id: "player\_uppod",
name: "player\_uppod"
};
swfobject.embedSWF("/templates/linecinema-dle90/swf/uppod.swf", "player\_uppod", "570", "440", "10.0.0",false,flashvars,params,attributes);
```
А вот и ссылка: `st7.linecinema.org/s/820e31e7cbe3e8c362785b733db56c57/film10/Druzea.navek.DVDRip.flv` (у Вас может отличаться). Исходя из этого делаем функцию:
```
def Videos(url, title):
html = getHTML(url)
link = re.compile('file: "(.+?)"').findall(html.decode('windows-1251').encode('utf-8'))[0]
addLink(title, link)
```
С кодом закончили. Сравните свой результат с моим:
**Файл addon.py**
```
# -*- coding: utf-8 -*-
import urllib, urllib2, re, sys
import xbmcplugin, xbmcgui
def getHTML(url):
headers = {'User-Agent':'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3', 'Content-Type':'application/x-www-form-urlencoded'}
conn = urllib2.urlopen(urllib2.Request(url, urllib.urlencode({}), headers))
html = conn.read()
conn.close()
return html
def isLinkUseful(needle):
haystack = ['/index.php', '/newsz/Televydenye/100432-2008-3-11-432.html', '/newsz/500183-tex-podderzhka.html']
return needle not in haystack
def Categories():
url = 'http://www.linecinema.org'
html = getHTML(url)
genre_links = re.compile('<(.+?)>
').findall(html.decode('windows-1251').encode('utf-8'))
for link, title in genre_links:
if isLinkUseful(link):
addDir(title, url + link, 20)
def Movies(url):
html = getHTML(url)
movie_links = re.compile(' <(.+?)>
========
').findall(html.decode('windows-1251').encode('utf-8'))
for link, title in movie_links:
addDir(title[:-12], link, 30)
def Videos(url, title):
html = getHTML(url)
link = re.compile('file: "(.+?)"').findall(html.decode('windows-1251').encode('utf-8'))[0]
addLink(title, link)
def get_params():
param=[]
paramstring=sys.argv[2]
if len(paramstring)>=2:
params=sys.argv[2]
cleanedparams=params.replace('?','')
if (params[len(params)-1]=='/'):
params=params[0:len(params)-2]
pairsofparams=cleanedparams.split('&')
param={}
for i in range(len(pairsofparams)):
splitparams={}
splitparams=pairsofparams[i].split('=')
if (len(splitparams))==2:
param[splitparams[0]]=splitparams[1]
return param
def addLink(title, url):
item = xbmcgui.ListItem(title, iconImage='DefaultVideo.png', thumbnailImage='')
item.setInfo( type='Video', infoLabels={'Title': title} )
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=url, listitem=item)
def addDir(title, url, mode):
sys_url = sys.argv[0] + '?title=' + urllib.quote_plus(title) + '&url=' + urllib.quote_plus(url) + '&mode=' + urllib.quote_plus(str(mode))
item = xbmcgui.ListItem(title, iconImage='DefaultFolder.png', thumbnailImage='')
item.setInfo( type='Video', infoLabels={'Title': title} )
xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]), url=sys_url, listitem=item, isFolder=True)
params = get_params()
url = None
title = None
mode = None
try: title = urllib.unquote_plus(params['title'])
except: pass
try: url = urllib.unquote_plus(params['url'])
except: pass
try: mode = int(params['mode'])
except: pass
if mode == None:
Categories()
elif mode == 20:
Movies(url)
elif mode == 30:
Videos(url, title)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
```
Наконец-то, перейдём к установке плагина. Существует два простых способа: установка из репозитория и установка из файла ZIP. Нам подходит второй. Запаковываем в ZIP нашу папку (папку!) любым архиватором. Затем запускаем XBMC, переходим **Система (Настройки)** > **Дополнения** > **Установить из файла ZIP** и указываем путь до нашего архива. После сообщения о том, что "Дополнение успешно включено", идём в главное меню **Видео** > **Дополнения** > **LineCinema**.
**Скриншоты**
#### Полезные ссылки
* [ZIP с исходниками](http://code.google.com/p/xbmc-kg-ontv/downloads/detail?name=plugin.video.linecinema.zip)
* Официальные руководства: [HOW-TO:Write plugins for XBMC](http://wiki.xbmc.org/index.php?title=HOW-TO:Write_plugins_for_XBMC) (wiki) и [XBMC Addon Developers Guide](https://www.google.kg/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&ved=0CC0QFjAA&url=http%3A%2F%2Fxbmc-gpodder-integration.googlecode.com%2Ffiles%2FXBMC%2520Addon%2520Developers%2520Guide%2520-R7.pdf&ei=_Uf2UJ7TKPHU4QS84YDICQ&usg=AFQjCNGqm1zWNmZPk7KLDJKOPW0gCwsevQ&bvm=bv.41018144,d.bGE) (pdf)
* Неофициальные репозитории аддонов: [3rd party add-on repositories](http://wiki.xbmc.org/index.php?title=3rd_party_add-on_repositories)
* [Форум XBMC Russia](http://xbmc.ru)
* [XBMC Community Forum](http://forum.xbmc.org/)
**Спасибо за внимание. Надеюсь было интересно… или полезно.** Не исключаю, что у меня ужасная манера изложения, но это первый опыт в написании статей.
**P.S.** Пожалуйста, не кидайте в меня тухлые помидоры.``` | https://habr.com/ru/post/166097/ | null | ru | null |
# Кроссбаузерный скроллинг
На сегодняшний день эффекты при скроллинге набрали достаточно большую популярность (так называемый [параллакс](http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%BB%D0%BB%D0%B0%D0%BA%D1%81)). Но, к сожалению, эти эффекты нейтивно не поддерживаются мобильными устройствами. Не так давно Mark Dalgleish предложил свой вариант решения этой проблемы:
##### Библиотеки
Выбираем одну из тач-библиотек:
[iScroll by Matteo Spinelli](//cubiq.org/iscroll-4)
[Scrollability by Joe Hewitt](//joehewitt.github.com/scrollability/)
[Zynga Scroller by Zynga](//zynga.github.com/scroller)
И подключаем [Modernizr](//modernizr.com/)
##### Обертка
Если ваш выбор пал на iScroll, вам следует поместить контент внутри блоков #wrapper и #scroller
```
* ...
```
##### Определяем тач-устройство с помощью Modernizr и создаем для него новый экземпляр iScroll
```
var myScroller = Modernizr.touch ? new iScroll('scroller') : null;
```
##### Добавляем стили
```
#wrapper {
overflow: auto;
}
/* Переопределяем #wrapper для тач-устройств */
/* Класс head.touch создается Modernizer'ом в случаи если ваш браузер поддерживает тач-ивенты */
.touch #wrapper {
overflow: hidden;
}
```
##### Функция для нормализации позиции скрола
```
function getScroll(elem, iscroll) {
var x, y;
if (Modernizr.touch && iscroll) {
x = iscroll.x * -1;
y = iscroll.y * -1;
} else {
x = elem.scrollLeft;
y = elem.scrollTop;
}
return {x: x, y: y};
}
```
##### Финальный штрих
```
var myScroller = Modernizr.touch ? new iScroll('scroller') : null;
(function animationLoop(){
window.requestAnimationFrame(animationLoop);
var scroll = getScroll(window, myScroller);
// Теперь мы можем использовать кроссплатформенные координаты
scroll.x;
scroll.y;
})();
```
> [Почему для анимации следует использовать requestAnimationFrame](http://habrahabr.ru/post/114358/) | https://habr.com/ru/post/147351/ | null | ru | null |
# Слияние Rails и Merb: Год спустя (часть 1 из 6)
*Шесть последовательных статей о слиянии Rails и Merb были опубликованы на [www.engineyard.com](http://www.engineyard.com) с декабря 2009 до апреля 2010 года. Это первая из них.*
Сегодня ровно год с того дня, как мы объявили о слиянии Rails и Merb. Тогда было много скептических отзывов относительно успешности этого предприятия. Самой распространенной ассоциацией у тех, кто слышал о наших планах, был единорог. На RailsConf в прошлом году, и DHH (Девид Хайнемайер Ханссон, автор Rails. — *прим. перев.*), и я упоминали единорога в своих докладах, вызывая смех относительно поставленных нами огромных ожиданий и явной невозможности выполнить их для версии 3.0.
Прошел год, настало время отразить то, как хорошо мы потрудились для достижения поставленных целей. На протяжении следующих нескольких дней я детально опишу прогресс, совершенный в сторону каждого из пунктов моего оригинального поста (<http://www.engineyard.com/blog/2008/rails-and-merb-merge/>).
Я уже сделал несколько докладов на эти темы, так что кто-то из вас уже мог видеть отдельные вещи, но я хотел также записать это для тех, кто еще не успел. Я также добавил информацию, опущенную раньше из-за ее сложности для устного доклада, и слишком новую, чтобы быть где-то рассказанной.
#### Модульность
*Rails станет более модульным, начиная с реализации самого ядра, включая возможность включать или выключать отдельные компоненты по желанию. Мы сфокусируемся на уменьшении повторений кода внутри Rails, чтобы сделать возможной замену частей Rails без вмешательства в остальные части. Это то, чем является хваленая «модульность» Merb.*
Мы потратили большое количество времени на этом этапе, принесшем нам действительно много плодов. Я приведу несколько характерных примеров.
##### ActiveSupport
Во-первых, мы прошлись по ActiveSupport, сделав его приспособленным к выбору нужных элементов. Это значит, что использование inflector (перевод слов из единственного числа во множественное и наоборот), time extensions, class extensions, и всего остального теперь возможно без самостоятельного изучения графа зависимостей. Вот что я имею ввиду (на примере метода `to_sentence` в ActiveSupport из Rails 2.3):
> `Copy Source | Copy HTML
> module ActiveSupport
> module CoreExtensions
> module Array
> module Conversions
> def to\_sentence(options = {})
> ...
> options.assert\_valid\_keys :words\_connector, :two\_words\_connector, :last\_word\_connector, :locale
> ...
> end
> ...
> end
> end
> end`
Как видите, в `to_sentence` присутствует вызов `assert_valid_keys`, который находится в другом модуле, что означает, что чтобы подключить только `active_support/core_ext/array/conversions`, вам нужно было бы пройтись по файлу, найти все неявные зависимости, и подключить соответствующие модули отдельно. И конечно, структура этих зависимостей могла бы легко измениться в будущей версии Rails, поэтому надеяться на то, что найдется в результате, было бы небезопасно. В Rails 3 тот же файл начинается с:
> `Copy Source | Copy HTML
> require 'active\_support/core\_ext/hash/keys'
> require 'active\_support/core\_ext/hash/reverse\_merge'
> require 'active\_support/inflector'`
Это потому, что мы сами прошлись по всей библиотеке ActiveSupport, нашли неявные зависимости и сделали их явными. Как результат, вы можете вытащить нужные вам специфические библиотеки для маленького проекта, а не весь ActiveSupport.
Лучше того, теперь отдельные части Rails явно декларируют **свои** зависимости на ActiveSupport. Так, например, код, добавляющий запись в лог для ActionController получил такие строки в начале:
> `Copy Source | Copy HTML
> require 'active\_support/core\_ext/logger'
> require 'active\_support/benchmarkable'`
Это означает, что все части Rails теперь знают, какие именно части ActiveSupport им нужны. Для простоты сделано так, что Rails 3 поставляется с полным набором модулей ActiveSupport, так что вы сможете использовать вещи типа `3.days` или `3.kilobytes` без проблем. В то же время, если вы хотите большего контроля над тем, какие именно модули подключаются в приложение, это возможно. Вы можете объявить `config.active_support.bare = true` в конфигурации, и включатся только те части ActiveSupport, которые явно указаны в файлах проекта. Вам все равно придется инклудить разные побрякушки, если хотите их использовать – `3.days` не будет работать прямо из коробки с включенным флагом `bare`.
##### ActionController
Еще одна область нуждавшаяся в переработке — это ActionController. Раньше ActionController содержал множество в корне отличных элементов внутри себя. При ближайшем рассмотрении мы обнаружили, что на самом деле это были три различных компонента.
Во-первых, функциональность диспетчера. Она включала в себя сам диспетчер, маршрутизацию, мидлваре и расширения rack. Во-вторых, в нем было большое количество кода контроллера, предназначенного для использования еще где-нибудь, и на самом деле использованного повторно в ActionMailer. Наконец, был код, выполнявший функцию посредника между этими двумя, управлявший запросами и ответами сквозь всю архитектуру контроллера.
В Rails 3 каждый из этих компонент отделен от другого. Функциональность диспетчера была вынесена в ActionDispatch, ее код ужат и действительно превращен в концептуальный компонент. Части ActionController, предназначенные для использования не-HTTP контроллерами, были перемещены в новый компонент под названием AbstractController, от которого наследуются и ActionController, и ActionMailer.
Наконец, сам ActionController подвергся тщательной реконструкции. По сути, мы изолировали каждый отдельный компонент и сделали возможным начать с минимума и дополнить его компонентами на ваш выбор. Наш старый друг `ActionController::Base` просто начинает оттуда же и добавляет **все** нужное. Например, посмотрите на начало новой версии этого класса:
> `Copy Source | Copy HTML
> module ActionController
> class Base < Metal
> abstract!
> include AbstractController::Callbacks
> include AbstractController::Logger
> include ActionController::Helpers
> include ActionController::HideActions
> include ActionController::UrlFor
> include ActionController::Redirecting
> include ActionController::Rendering
> include ActionController::Renderers::All
> include ActionController::Layouts
> include ActionController::ConditionalGet
> include ActionController::RackDelegation
> include ActionController::Logger
> include ActionController::Benchmarking
> include ActionController::Configuration`
Все, что мы тут делаем — добавляем все доступные модули, так что начальный путь использования Rails такой же как и раньше. По-настоящему сильная сторона того, что мы тут сделали, та же, что и в ActiveSupport: каждый модуль объявляет свои зависимости от других модулей, так что вы можете включить, например, `Rendering` без необходимости выяснять, какие еще модули должны быть подключены и в каком порядке.
Вот полностью рабочий контроллер Rails 3:
> `Copy Source | Copy HTML
> class FasterController < ActionController::Metal
> abstract!
> # Rendering будет включен лейаутами, но я включу
> # его тут для понятности
> include ActionController::Rendering
> include ActionController::Layouts
> append\_view\_path Rails.root.join("app/views")
> end
>
> class AwesomeController < FasterController
> def index
> render "очень\_быстро"
> end
> end`
И дальше в файле маршрутизации с полным успехом можно сделать:
> `Copy Source | Copy HTML
> MyApp.routes.draw do
> match "/must\_be\_fast", :to => "awesome#index"
> end`
В сущности, `ActionController::Base` стал всего лишь одним из способов создания контроллеров. Это то же, что классический Rails, но с возможностью сделать свое, если оригинал не по вкусу. Действительно легко привести в соответствие вашим требованиям: если вы хотите добавить функциональность `before_filter` в `FasterController`, можно просто добавить `AbstractController::Callbacks`.
Заметьте, что добавление этих модулей автоматически добавило `AbstractController::Rendering` (функциональность рендеринга общая с ActionMailer), `AbstractController::Layouts` и `ActiveSupport::Callbacks`.
Это делает возможным элементарно добавить только нужную вам функциональность в чувствительных для производительности местах без необходимости использования полностью другого API. Если требуется дополнительная функциональность, вы легко можете добавить дополнительные модули или в конце-концов использовать полный `ActionController::Base` без необходимости отказываться от чего-то по пути.
Это, фактически, идея ядра Rails 3: нет монолитных компонент, только модули без сложных взаимосвязей, работающие по умолчанию в больших пакетах. Это позволяет людям продолжать использовать Rails так же, как в предыдущих версиях, но подкрепляет код возможностями альтернативных вариантов. Больше нет функциональности, заключенной в недоступных формах.
Непосредственная выгода из всего этого — что ActionMailer намеренно получает всю функциональность ActionController простым путем. Все, начиная с лейаутов и хелперов до фильров использует идентичный код, используемый в ActionController, так что ActionMailer никогда не сможет соскользнуть с функциональности ActionController (в процессе того, как будет развиваться сам ActionController).
Мидлваре также получает руку помощи. `ActionController::Middleware`, мидлваре со всеми преимуществами ActionController, позволяет вам добавлять любые возможности ActionController по вашему усмотрению (как Rendering, ConditionalGet, Request и Response объекты, и т.д.). Вот пример:
> `Copy Source | Copy HTML
> # Длинный способ
> class AddMyName < ActionController::Middleware
> def call(env)
> status, headers, body = @app.call(env)
> headers["X-Author"] = "Yehuda Katz"
> headers["Content-Type"] = "application/xml"
>
> etag = env["If-None-Match"]
> key = ActiveSupport::Cache.expand\_cache\_key(body + "Yehuda Katz")
> headers["ETag"] = %["#{Digest::MD5.hexdigest(key)}"]
> if headers["ETag"] == etag
> headers["Cache-Control" = "public"]
> return [304, headers, [" "]]
> end
>
> return status, headers, body
> end
> end`
> `Copy Source | Copy HTML
> # Использование дополнительных Rack хелперов
> class AddMyName < ActionController::Middleware
> include ActionController::RackDelegation
>
> def call(env)
> self.status, self.headers, self.response\_body = @app.call(env)
>
> headers["X-Author"] = "Yehuda Katz"
>
> # вы можете делать теперь больше хороших вещей
> self.content\_type = Mime::XML # delegates to the response
> response.etag = "#{response.body}Yehuda Katz"
> response.cache\_control[:public] = true
>
> self.status, self.response\_body = 304, nil if request.fresh?(response)
>
> response.to\_a
> end
> end`
> `Copy Source | Copy HTML
> # Использование хелперов ConditionalGet
> class AddMyName < ActionController::Middleware
> # подключение RackDelegation
> include ActionController::ConditionalGet
>
> def call(env)
> self.status, self.headers, self.response\_body = @app.call(env)
>
> headers["X-Author"] = "Yehuda Katz"
>
> self.content\_type = Mime::XML
> fresh\_when :etag => "#{response.body}Yehuda Katz", :public => true
>
> response.to\_a
> end
> end`
Я думаю, мы действительно выполнили обещание внести модульность в Rails. Я думаю, что уровень того, что получилось в новой версии, превышает уровень ожиданий многих год назад, и это точно территория золотого единорога. Наслаждайтесь!
В следующий раз я расскажу о улучшении производительности в Rails 3. Надеюсь, это будет не слишком быстро. :) | https://habr.com/ru/post/87907/ | null | ru | null |
# Как написать UI-тесты с использованием Instagram-аккаунтов и не получить блок
Привет, Хабр. Довольно часто при покрытии различных сервисов автотестами (selenium или appium) нам приходится использовать аккаунты других социальных сетей. Это может понадобиться, например, если мы тестируем регистрацию на нашем сервисе через эту социальную сеть, или авторизацию, шаринг, лайки и так далее.
И, конечно, довольно часто социальные сети банят наших тестовых пользователей, потому что считают их вовсе не тестовыми, а «подозрительными». В данной статье я расскажу, как бороться с банами Instagram и почему *приходится* это делать.
Суть проблемы
-------------
Итак, давайте разбираться по порядку. Начнем с того, что у нас есть сервис, который нам надо покрыть UI-тестами. И на нем есть некий функционал, который зависит от каких-либо социальных сетей. Например, у нас есть возможность авторизоваться на сайте через Instagram. Как покрыть такой функционал тестами?
На первый взгляд все просто. Мы создаем юзера на Instagram и прописываем его email и пароль в тесте (в специально созданном для этого месте):
```
class InstagramUsers:
EMAIL = "some_email@example.com"
PASS = "secret"
```
Далее пишем тест, который находит необходимую иконку и кликает на нее.
Запуская тест в браузере, само собой, мы запускаем «чистую» сессию. Это значит, что никакой авторизации ни на одном из сайтов у нас нет (нет соответствующих кук). То же самое касается нативного приложения: поднимая эмулятор или запуская приложение «честно», мы не должны быть авторизованы ни на одном сервисе.
Тест делает следующее. Он открывает нужный экран, находит иконку социальной сети и кликает на нее. Начинается процесс авторизации на Instagram. В нужном окошке мы вводим email и пароль нашего аккаунта (пример для web):
Соответственно, тест авторизуется и далее идет проверка взаимодействия нашего сервиса с Instagram. Мы видим желаемый статус теста «success» и радуемся — все в порядке.
После этого мы добавляем тест в CI и начинаем его запускать по расписанию. И через несколько дней или даже часов тест начинает падать. Открываем скриншот с ошибкой и видим следующее:
Instagram забанил нашего пользователя и тест перестал работать… На первый взгляд единственное, что можно с этим сделать — создать новый аккаунт в Instagram. Но тогда теряется суть автоматизации тестирования. :)
Для данной проблемы есть два решения.
Первое решение
--------------
Мы можем сохранять куки, полученные от Instagram, между запусками тестов. И авторизовываться только в необходимом случае. Правда тут я вижу несколько проблем.
Во-первых, если у нас много тестов, нам рано или поздно захочется их распараллелить, чтобы процесс тестирования проходил быстрее. В данном случае придется решать проблему параллельного доступа к данным. Когда [expire date](https://en.wikipedia.org/wiki/HTTP_cookie#Expires_and_Max-Age) у авторизационной куки закончится, нам надо как-то гарантировать, что два или более тестов не попробуют авторизоваться в Instagram одновременно из параллельных потоков.
Во-вторых, при подходе с «предустановленной» авторизацией мы не проверим полный процесс взаимодействия с соцсетью от авторизации там до, например, авторизации на нашем сервисе. Как мы можем гарантировать, что сервис работает, если наши автотесты проверяют только половину кейзов?
Второе решение
--------------
Собственно, ради чего я сел писать статью… Мы можем авторизовываться на Instagram через Facebook. Странно звучит, верно? Сейчас я расскажу подробнее.
По какой-то причине Instagram не банит аккаунты, которые то и дело авторизовываются через Facebook вместо формы авторизации. Честно, я не знаю почему так происходит, я наткнулся на эту особенность от безысходности, пытаясь решить вопрос с баном аккаунтов. И решил поделиться с вами.
Итак, последовательность действий следующая. Мы создаем пользователя на Facebook. Далее мы создаем пользователя Instagram, сразу привязанного к пользователю Facebook. В тестах прописываем только доступы к пользователю Facebook.
Сам тест надо научить логиниться в Instagram через Facebook. Тут сложностей возникнуть не должно.
Итог
----
Я не люблю [воркэраунды](https://en.wikipedia.org/wiki/Workaround). Чем проще подход, который мы применяем в тестировании, тем он честнее. Соответственно, тем спокойнее можно спать по ночам. Но, к сожалению, иногда приходится «выкручиваться».
В отличие от Instagram, у Facebook есть возможность честно создавать тестовых пользователей, которых не банят, когда их используешь в автотестах. Про это подробно рассказано в этой [статье](https://habrahabr.ru/company/badoo/blog/305736/).
Я очень надеюсь, что однажды все крупные сервисы будут иметь подобный API. Еще больше я надеюсь, что если ребята из Instagram увидят этот материал, они не просто исправят эту особенность, а сделают адекватный способ получения тестовых аккаунтов для автоматизированного тестирования.
У меня все, спасибо за внимание. | https://habr.com/ru/post/344408/ | null | ru | null |
# WAI-ARIA: стандарт доступности активных интернет-приложений
WAI-ARIA (Web Accessibility Initiative — Accessible Rich Internet Applications) — стандарт доступности активных Интернет-приложений, определяет подходы к тому, чтобы сделать содержимое сайтов и интернет-приложения более доступными для людей с ограниченными возможностями. Настоящая статья описывает проблемы, решению которых посвящен стандарт WAI-ARIA, а также знакомит с пакетом технических документов WAI-ARIA. Используемая терминология описана в ранее опубликованной на хабре статье [«Стандарт доступности содержимого WAI-WCAG 1.0».](http://habrahabr.ru/blogs/webstandards/28157/)
Применение стандарта особенно эффективно для сайтов с динамическим содержимым и развитыми элементами управления пользовательским интерфейсом, разработанными с использованием Ajax, HTML, JavaScript, и связанных с ними технологий. В настоящее время, некоторые функциональные возможности веб-сайтов недоступны для части пользователей с ограниченными физическими возможностями, особенно для людей, полагающихся на программы, читающие с экрана и для тех людей, которые не могут использовать мышь. WAI-ARIA задает новые пути предоставления функциональных возможностей программами-помощниками. С помощью WAI-ARIA разработчики могут создавать прогрессивные веб-приложения, доступные и удобные для всех пользователей.
#### Как сделать Ajax и связанные с ним технологии доступными?
Все больше сайтов в Интернете используют для управления страницей сложные и продвинутые системы, такие как, древовидные меню на Javascript. Чтобы обеспечить доступ людям с физическими нарушениями, специальным браузерам и технологиям-помощникам необходимо взаимодействовать с этими системами управления, однако информация, которая для этого требуется, оказывается недоступной на большинстве существующих сегодня сайтов.
Другим примером барьера на пути к нормальному использованию возможностей сайта может служить техника перетаскивания объектов (drag & drop), недоступная пользователям, не способным управлять мышью, имеющим в распоряжении только клавиатуру. Даже относительно простые сайты могут оказаться сложными в использовании, если они требуют огромного количества нажатий клавиш при управлении с помощью только одной клавиатуры.
Многие Интернет-приложения, разработанные с применением Ajax (известным так же как AJAX), DHTML и других технологий создают дополнительные проблемы доступа к информации. Например, если содержимое страницы изменяется в ответ на действия пользователя, по истечении определенного времени или в связи с внезапными обновлениями, то это новое содержимое может оказаться недоступным для людей, использующих программы чтения с экрана – слепых или людей с когнитивными расстройствами.
Стандарт WAI-ARIA позволяет решить эти проблемы доступа, устанавливая способы сделать всю необходимую информацию о работе сайта доступной программам-помощникам. С помощью стандарта даже сложные интернет-приложения можно сделать доступными и удобными для людей с ограниченными возможностями.
#### Технические решения
Рассмотрим принцип работы стандарта WAI-ARIA более конкретно. Стандарт WAI‑ARIA задает набор атрибутов HTML, позволяющих идентифицировать взаимодействующие с пользователем функции, установить их взаимосвязь и текущее расположение. Стандарт описывает новые техники навигации для выделения областей и основных элементов структуры сайта, таких как меню, основное содержимое, второстепенное содержимое, информация о баннерах. Например, с использованием WAI-ARIA разработчики могут обозначить области на страницах, позволяя пользователям легко перемещаться между областями с помощью клавиатуры без необходимости многокоратно нажимать клавишу Tab.
WAI-ARIA включает в себя технологии для обозначения элементов управления, активных областей AJAX, событий и самодельных элементов управления. Техники WAI-ARIA применимы к кнопкам, выпадающим спискам, календарям, древовидным элементам, и др.
Стандарт WAI-ARIA предоставляет авторам сайтов:* Роли для описания типа активного элемента, например: «menu,» «treeitem,» «slider,» и «progressmeter». Например
* Роли для описания структуры страниц, например: заголовки, области и таблицы.
* Атрибуты для описания состояния, в котором находится элемент управления, например «checked» для чекбокса и «haspopup» для меню.
* Атрибуты для задания активных областей страницы, допускающих обновления (например, биржевые котировки), а также способа появления данных обновлений. Например, важные обновления могут представляться в диалоговом окне, а второстепенные — появляться прямо на странице.
* Атрибуты для перетаскивания объектов, описывающие переносимые ресурсы и целевые положения в документе. Возможность управления с клавиатуры объектами и событиями.
Пример использования атрибутов:
`onkeydown="return checkBoxEvent(event);"
onclick="return checkBoxEvent(event);" >
A checkbox label`
#### Документы стандарта WAI-ARIA
Технические документы стандарта WAI-ARIA разработаны рабочей группой [PFWG (Protocols and Formats Working Group)](http://www.w3.org/WAI/PF/), которая является частью W3C-WAI (World Wide Web Consortium Web Accessibility Initiative).
Пакет документов стандарта WAI-ARIA, находящийся сегодня в виде черновика, содержит следующие документы (на английском языке):* [Техническое описание стандарта WAI-ARIA 1.0.](http://www.w3.org/TR/wai-aria/)
* [Учебник WAI-ARIA для начинающих.](http://www.w3.org/TR/wai-aria-primer/)
* [Практические рекомендации по применению WAI-ARIA](http://www.w3.org/TR/wai-aria-practices/)
* [План развития WAI-ARIA](http://www.w3.org/TR/wai-aria-roadmap/)
Кросспост: [Введение в WAI-ARIA: стандарт доступности активных интернет-приложений](http://webew.ru/articles/1290.webew)
[Оригинал на английском языке](http://www.w3.org/WAI/intro/aria) | https://habr.com/ru/post/40730/ | null | ru | null |
# Автоматический контроль времени жизни общих C++-QML объектов
Речь пойдет об объектах, используемых в C++ и QML одновременно, верхушкой иерархии наследования которых является QObject. Насколько мне известно, реализации механизма автоматического контроля времени жизни таких объектов на уровне библиотеки не существует. Подобный механизм избавил бы от сложностей, возникающих при ручном контроле времени жизни объектов, а так же от потенциальных багов, утечек памяти и крешей приложения. В этой статье я опишу этапы реализации данного механизма, а так же проблемы, рассмотренные в процессе исследования данной проблемы.
Для C++ объектов в отдельности используются интеллектуальные указатели. Однако, в таком случае обращение к данным объектам из QML будет некорректным, т.к. после разрушения их интеллектуальными указателями, объекты станут невалидными. В QML время жизни объектов контролирует garbage collector, но при условии, что [ownership](http://doc.qt.io/qt-5/qtqml-cppintegration-data.html#data-ownership)-у объекта выставлена опция QQmlEngine::JavaScriptOwnership, объект, не имеющий на себя ссылок в коде, разрушится при первом срабатывании сборщика мусора и дальнейшее обращение к нему со стороны C++ приведет к неблагоприятным последствиям.
Проблема заключается в том, что каждая из сторон не берет на себя владение объектом в момент, когда другая сторона собирается удалить объект, т.к. первая не получает уведомление об этом.
Эта проблема может быть решена с помощью класса, который отдавал бы владение той стороне, в которой планируется использовать объект в дальнейшем. Идея в том, что данный класс дорабатывает стандартный интеллектуальный указатель, а для универсальности его использования наш класс будет расширять тот smart pointer, который мы ему укажем шаблонным параметром. Начальный скелет класса выглядит так:
```
template class Container = std::shared\_ptr>
class QmlCppSmartPtr : public Container {
};
```
Переключение владения должно быть непосредственно перед попыткой удаления объекта стороной, на которой он не будет использоваться в дальнейшем. Для этого соответствующая сторона должна вызвать некий коллбэк, внутри которого, собственно, и будет происходить переключение владения.
Вызванный на стороне С++ коллбэк реализовать весьма просто, например, им может быть кастомный Deleter, переданный параметром в конструктор базового класса. Для вызова коллбэка со стороны QML нам понадобился бы сигнал о том, что QML собирается разрушить объект, однако подобный сигнал на данный момент в Qt не реализован. Единственный сигнал, который на первый взгляд заслуживает внимания — сигнал destroyed класса QObject, однако он нам не подходит, т.к. этот сигнал вызывается уже в процессе удаления объекта и в этот момент переключение владения может привести к неопределенному поведению приложения.
После некоторого раздумья и пары экспериментов оказалось, что сигнал, уведомляющий о том, что сборщик мусора собирается разрушить объект, нам не нужен.
Согласно документации управлять владением можно так же с помощью указания parent объекту (parent ownership semantics).
```
template class Container = std::shared\_ptr>
class QmlCppSmartPtr : public Container {
public:
explicit QmlCppSmartPtr(Object\* object)
: Container(object, std::bind(&QmlCppSmartPtr::deleteObject,
this,
std::placeholders::\_1)) {
object->setParent(new QObject());
QQmlEngine::setObjectOwnership(object, QQmlEngine::JavaScriptOwnership);
}
private:
void deleteObject(Object\* object) {
object->parent()->deleteLater();
object->setParent(nullptr);
}
};
```
Выставляя объекту опцию QQmlEngine::JavaScriptOwnership, мы обязуем сборщик мусора следить за объектом, но при этом не удалять его, пока у него есть parent. После того, когда объект стал “сиротой”, garbage collector продолжает за ним следить, к тому же с этих пор появилась возможность и удалить его. Это он и сделает при первом же срабатывании, **даже если на объект не осталось ссылок в QML/JS коде**. Последнее утверждение является логичным, потому что меняя опцию на QQmlEngine::JavaScriptOwnership, пользователь фреймверка не должен и не может знать, используется ли до сих пор этот объект на Qml стороне. QQmlEngine обязан обрабатывать запросы изменения ownership, пока объект висит в памяти. Видимо, разработчики Qt позаботились об этом.
Учитывая утверждение о том, что сборщик мусора берет на себя обязанность контролировать объект на протяжении его времени жизни, независимо от того, обнулился ли счетчик ссылок на этот объект, возникло предположение, что переключение владения можно реализовать и без помощи parent ownership semantics:
```
template class Container = std::shared\_ptr>
class QmlCppSmartPtr : public Container {
public:
explicit QmlCppSmartPtr(Object\* object)
: Container(object, std::bind(&QmlCppSmartPtr::deleteObject,
this,
std::placeholders::\_1)) {
QQmlEngine::setObjectOwnership(object, QQmlEngine::CppOwnership);
}
private:
void deleteObject(Object\* object) {
QQmlEngine::setObjectOwnership(object, QQmlEngine::JavaScriptOwnership);
}
};
```
После некоторых доработок механизма получилась реализация вида:
```
template
struct SimpleOwnershipPolicy {
static void init(Object\* object) {
QQmlEngine::setObjectOwnership(object, QQmlEngine::CppOwnership);
}
static void destroy(Object\* object) {
QQmlEngine::setObjectOwnership(object, QQmlEngine::JavaScriptOwnership);
}
};
template
struct ParentOwnershipPolicy {
void init(Object\* object) {
object->setParent(new QObject());
QQmlEngine::setObjectOwnership(object, QQmlEngine::JavaScriptOwnership);
}
void destroy(Object\* object) {
object->parent()->deleteLater();
object->setParent(nullptr);
}
};
template class Container>
struct SmartPointer {
using type = Container;
};
template
struct SmartPointer {
using type = std::unique\_ptr>;
};
template class Container = std::unique\_ptr,
template class OwnershipPolicy = SimpleOwnershipPolicy>
class QmlCppSmartPtr : public SmartPointer::type {
public:
explicit QmlCppSmartPtr(Object\* object,
OwnershipPolicy && ownershipPolicy = OwnershipPolicy())
: SmartPointer::type(object,
std::bind(&QmlCppSmartPtr::deleteObject,
this,
std::placeholders::\_1))
, m\_ownershipPolicy(std::move(ownershipPolicy)) {
m\_ownershipPolicy.init(object);
}
private:
void deleteObject(Object\* object) {
m\_ownershipPolicy.destroy(object);
}
OwnershipPolicy m\_ownershipPolicy;
};
```
Способы управления владением я вынес в стратегии для полноты выбора, оставив во внимании оба подхода. Код стратегии SimpleOwnershipPolicy более производителен, но ParentOwnershipPolicy, на мой взгляд, менее подвержена возможным изменениям внутри самого Qt, а так же документация дает больше гарантий корректной работы этого метода.
**Пример использования данного класса:**
```
class SomeObject : public QObject // общий C++-QML объект
{
Q_OBJECT
public:
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged)
SomeObject(QString const& name, int val);
virtual ~SomeObject() override;
explicit SomeObject(QObject *parent = 0);
QString name() const;
void setName(QString const& name);
int value() const;
void setValue(int val);
signals:
void valueChanged();
void nameChanged();
private:
QString m_name;
int m_val;
};
class QmlObjectProvider : public QObject
{
Q_OBJECT
public:
Q_INVOKABLE SomeObject* createObject(QString const& name, int value) {
m_cppObjects.emplace_back(new SomeObject(name, value));
return m_cppObjects.back().data();
}
Q_INVOKABLE void removeObjectsFromCppSide() {
m_cppObjects.clear();
}
private:
std::vector> m\_cppObjects;
};
...
// передача объектов в QML
qmlRegisterType("com.provider", 1, 0, "QmlObjectProvider");
qmlRegisterType("com.provider", 1, 0, "SomeObject");
engine.rootContext()->setContextProperty("qmlObjectProvider", &qmlObjectProvider);
```
QML code:
```
...
import com.provider 1.0
Button {
onClicked: {
var obj = qmlObjectProvider.createObject("SomeObjectName", 42);
qmlObjectProvider.removeObjectsFromCppSide(); // удаляем объекты на C++ стороне
text = obj.name; // объект в QML еще живой и умрет, после выхода из области видимости и срабатывания gc
}
}
```
Инстанциировать класс и экспортировать объект класса в QML можно так же следующим образом:
```
QmlCppSmartPtr object; // используются unique\_ptr и SimpleOwnershipPolicy как параметры по умолчанию.
...
QmlCppSmartPtr object; // использование shared\_ptr
...
return object.get();
```
P.S.: Код протестирован с помощью Qt 5.5, gcc 4.9.1 | https://habr.com/ru/post/274915/ | null | ru | null |
# Представляем Kubernetes CCM (Cloud Controller Manager) для Яндекс.Облака
В продолжение к недавнему [релизу CSI-драйвера](https://habr.com/ru/company/flant/blog/486190/) для Яндекс.Облака мы публикуем ещё один Open Source-проект для этого облака — [Cloud Controller Manager](https://github.com/flant/yandex-cloud-controller-manager). CCM необходим не только для кластера в целом, но и собственно CSI-драйвера. Подробности о его предназначении и некоторые особенности реализации — под катом.
Введение
--------
### Зачем это?
Мотивы, побудившие нас к разработке CCM для Яндекс.Облака, полностью совпадают с уже описанными в [анонсе](https://habr.com/ru/company/flant/blog/486190/) CSI-драйвера. Мы обслуживаем множество Kubernetes-кластеров у разных облачных провайдеров, для чего используем единый инструмент. Он реализует многочисленные удобства «в обход» managed-решений этих провайдеров. Да, у нас довольно специфичный случай и потребности, однако созданные из-за них наработки могут пригодиться и другим пользователям.
### Что вообще такое CCM?
Как правило, мы подготавливаем окружающую нас среду для кластера *извне* — например, с помощью Terraform. Но иногда есть необходимость управлять окружающей нас облачной средой *из кластера*. Такая возможность предусмотрена, и именно её реализует [CCM](https://kubernetes.io/docs/concepts/architecture/cloud-controller/).
В частности, Cloud Controller Manager обеспечивает пять основных типов взаимодействия:
1. **Instances** – реализует связь 1:1 между объектом узла в Kubernetes (`Node`) и виртуальной машиной в облачном провайдере. Для этого мы:
* заполняем поле `spec.providerID` в объекте `Node`. К примеру, для OpenStack CCM это поле имеет следующий формат: `openstack:///d58a78bf-21b0-4682-9dc6-2132406d2bb0`. Можно видеть имя облачного провайдера и уникальный UUID server’а (виртуальная машина в OpenStack) объекта;
* дополняем `nodeInfo` в объекте `Node` информацией о виртуальной машине. Например, указываем instance type в AWS;
* проверяем наличие виртуальной машины в облаке. К примеру, если объект `Node` перешёл в состояние `NotReady`, можно проверить, существует ли вообще виртуальная машина в облачном провайдере по `providerID`. Если её нет — удаляем объект `Node`, который в противном случае остался бы в кластере навечно;
2. **Zones** – задаёт failure domain для объекта `Node`, чтобы планировщик мог выбрать узел для Pod’а согласно регионам и зонам в облачном провайдере;
3. **LoadBalancer** – при создании объекта `Service` с типом `LoadBalancer` создаёт некий балансировщик, который направит трафик извне к узлам кластера. Например, в Yandex.Cloud можно использовать `NetworkLoadBalancer` и `TargetGroup` для этих целей;
4. **Route** – строит сеть между узлами, т.к. по требованиям Kubernetes каждый pod должен иметь свой IP-адрес и иметь возможность достучаться до любого другого pod’а. Для этих целей можно использовать оверлейную сеть (VXLAN, GENEVE) или задать таблицу маршрутизации прямо в виртуальной сети облачного провайдера:
5. **Volume** – позволяет динамически заказывать PV, используя PVC и SC. Изначально этот функционал являлся частью CCM, но ввиду большой сложности был вынесен в отдельный проект Container Storage Interface (CSI). Про CSI мы не раз [писали](https://habr.com/ru/company/flant/blog/465417/) и, как уже говорилось, даже [выпустили](https://habr.com/ru/company/flant/blog/486190/) CSI-драйвер.
Ранее весь код, взаимодействующий с облаком, лежал в основном Git-репозитории проекта Kubernetes по адресу `k8s.io/kubernetes/pkg/cloudprovider/providers`, но от этого решили отказаться из-за неудобства работы с большой кодовой базой. Все старые реализации были вынесены в [отдельный репозиторий](https://github.com/kubernetes/legacy-cloud-providers). Для удобства дальнейшей поддержки и разработки все общие компоненты тоже были вынесены в [отдельный репозиторий](https://github.com/kubernetes/cloud-provider).
Как и в случае с CSI, многие крупные поставщики облачных услуг уже разработали свои CCM для использования облаков в Kubernetes. Если же CCM у поставщика нет, но все необходимые функции доступны через API, то можно реализовать CCM самостоятельно.
Чтобы написать свою реализацию CCM, достаточно реализовать [нужные Go-интерфейсы](https://github.com/kubernetes/cloud-provider/blob/release-1.17/cloud.go#L43).
И [вот что у нас получилось](https://github.com/flant/yandex-cloud-controller-manager).
Реализация
----------
### Как пришли к этому
Разработку (а точнее — даже использование) мы начали с [готового(!) CCM](https://github.com/dlisin/yandex-cloud-controller-manager) для Yandex.Cloud годовой давности.
Однако в этой реализации нам не хватало:
* аутентификации через JWT IAM-токен;
* поддержки Service controller’а.
По согласованию с автором *(dlisin)* в Telegram, мы форкнули yandex-cloud-controller-manager и дописали недостающие функции.
### Основные возможности
На текущий момент CCM поддерживает следующие интерфейсы:
* *Instances*;
* *Zones*;
* *LoadBalancer*.
В будущем, когда Yandex.Cloud начнёт работать с продвинутыми возможностями VPC, мы добавим и интерфейс *Routes*.
### LoadBalanacer как главный вызов
Изначально мы пробовали, как у других реализаций CCM, создавать пару из `LoadBalancer` и `TargetGroup` для каждого `Service` с типом `LoadBalancer`. Однако у Yandex.Cloud обнаружилось одно интересное ограничение: нельзя использовать `TargetGroups` с пересекающимися `Targets` (пара `SubnetID` — `IpAddress`).
Поэтому внутри созданного CCM запускается контроллер, который при изменении объектов `Node` собирает информацию обо всех интерфейсах на каждой виртуальной машине, группирует их по принадлежности к определённым `NetworkID`, создаёт по `TargetGroup` на `NetworkID`, а также следит за актуальностью. Впоследствии, при создании объекта `Service` с типом `LoadBalanacer` мы просто прикрепляем заранее созданную `TargetGroup` к новым `NetworkLoadBalanacer`'ам.
Как начать пользоваться?
------------------------
CCM поддерживает Kubernetes версии 1.15 и выше. В кластере для его работы требуется, чтобы флаг `--cloud-provider=external` был установлен в значение `true` для kube-apiserver, kube-controller-manager, kube-scheduler и всех kubelet’ов.
Все необходимые шаги по самой установке описаны в [README](https://github.com/flant/yandex-cloud-controller-manager/blob/master/README.md). Инсталляция сводится к созданию объектов в Kubernetes из манифестов.
Для использования CCM также понадобится:
* [указать](https://cloud.yandex.ru/docs/resource-manager/operations/folder/get-id) в манифесте идентификатор каталога (`folder-id`) Яндекс.Облака;
* сервисный аккаунт для взаимодействия с API Яндекс.Облака. В манифесте `Secret` необходимо [передать авторизованные ключи](https://cloud.yandex.com/docs/iam/concepts/authorization/key) от сервисного аккаунта. В документации [описано](https://cloud.yandex.ru/docs/iam/quickstart-sa), как создать сервисный аккаунт и получить ключи.
Будем рады обратной связи и [новым issues](https://github.com/flant/yandex-cloud-controller-manager/issues), если столкнетесь с какими-то проблемами!
Итоги
-----
Реализованный CCM мы используем в пяти Kubernetes-кластерах на протяжении двух последних недель и планируем расширить их число до 20 в ближайший месяц. Использовать CCM для больших и критических инсталляций K8s в настоящий момент не рекомендуем.
Как и в случае с CSI, будем рады, если разработчики Яндекса возьмут на себя развитие и поддержку этого проекта — мы готовы передать репозиторий по их просьбе, чтобы заниматься более профильными для нас задачами.
P.S.
----
Читайте также в нашем блоге:
* «[Наш опыт разработки CSI-драйвера в Kubernetes для Яндекс.Облака](https://habr.com/ru/company/flant/blog/486190/)»;
* «[Готовить Kubernetes-кластер просто и удобно? Анонсируем addon-operator](https://habr.com/ru/company/flant/blog/455543/)»;
* «[Расширяем и дополняем Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/455543/)». | https://habr.com/ru/post/490356/ | null | ru | null |
# Руководство разработчика Prism — часть 4, разработка модульных приложений
> **Оглавление**
>
> 1. [Введение](http://habrahabr.ru/post/176851/)
> 2. [Инициализация приложений Prism](http://habrahabr.ru/post/176853/)
> 3. [Управление зависимостями между компонентами](http://habrahabr.ru/post/176861/)
> 4. [Разработка модульных приложений](http://habrahabr.ru/post/176863/)
> 5. [Реализация паттерна MVVM](http://habrahabr.ru/post/176867/)
> 6. [Продвинутые сценарии MVVM](http://habrahabr.ru/post/176869/)
> 7. [Создание пользовательского интерфейса](http://habrahabr.ru/post/176895/)
>
> 1. [Рекомендации по разработке пользовательского интерфейса](http://habrahabr.ru/post/177925/)
> 8. [Навигация](http://habrahabr.ru/post/178009/)
> 1. [Навигация на основе представлений (View-Based Navigation)](http://habrahabr.ru/post/182052/)
> 9. [Взаимодействие между слабо связанными компонентами](http://habrahabr.ru/post/182580/)
>
Модульное приложение является таким приложением, которое можно разделить на ряд функциональных блоков (модули), которые могут быть интегрированы в одно целое. Клиентский модуль инкапсулирует часть общей функциональности приложения и обычно представляет собой набор взаимосвязанных функциональных частей. Он может включать набор связанных компонент, таких как функции приложения, включая пользовательский интерфейс и бизнес-логику, или части инфраструктуры приложения, такие как службы уровня приложения для журналирования, или аутентификации и авторизации пользователей. Модули независимы друг от друга, но могут взаимодействовать друг с другом слабо связанным способом. Модульные приложения могут облегчить разработку, тестирование, развертывание, и расширение вашего приложения.
Например, рассмотрим персональное банковское приложение. Пользователь может получить доступ к множеству функций, таких как передача денег между учетными записями, оплата счетов, и обновление персональных данных, используя единственный пользовательский интерфейс (UI). Однако, каждая из этих функций инкапсулируется в пределах дискретного модуля. Эти модули связываются друг с другом и с системами бэкэнда, такими как серверы баз данных и веб-сервисы. Прикладные службы интегрируют различные компоненты в пределах каждого из различных модулей и обрабатывают взаимодействие с пользователем. Пользователь видит интегрированное представление, которое похоже на единственное цельное приложение.
Следующая иллюстрация показывает проект модульного приложения.
### Преимущества, получаемые от создания модульных приложений
Вы, вероятно, уже создаете хорошо спроектированное приложение, используя сборки, интерфейсы, классы и хорошие объектно-ориентированные принципы разработки. В этом случае, если не принять серьёзные меры, то дизайн ваших приложения останется «монолитным» (где вся функциональность реализуется сильно связанным способом в пределах приложения), это может привести к тому, что приложение будет трудно разработать, тестировать, расширять, и поддерживать.
Модульный подход к построению приложения, с другой стороны, может помочь выделить крупномасштабные функциональные области и разрабатывать, или тестировать их независимо. Это может сделать разработку и тестирование легче, а ваше приложение более гибким и легко расширяемым в будущем. Преимущество модульного подхода в том, что он может сделать архитектуру приложения более гибкой и удобной для сопровождения, путём разделения приложения на части, которыми легко управлять. Каждая часть инкапсулирует определенную функциональность, и интегрируется через четкие, но слабо связанные каналы.
#### Поддержка Prism разработки модульных приложений
Prism помогает разрабатывать модульные приложения и управлять модулями во время выполнения. Используя функциональность Prism, вы можете сэкономить время, так как вам не нужно реализовывать и тестировать свою собственную платформу для построения модульных приложений. Prism поддерживает следующие функции для разработки модульных приложений:
* Каталог модулей для регистрации именованных модулей, или определения их расположения; можно создать каталог модулей следующими способами:
+ Определяя модули в коде, или в XAML.
+ Для WPF: обнаруживая модули в каталоге, таким образом, можно загрузить все модули, не определяя их явно в централизованном каталоге.
> **Заметка.**
>
> При использовании этого подхода, сборки с модулями могут не компилироваться автоматически, при сборке проекта, и не копироваться в выходную директорию, так как на них отсутствуют ссылки из проекта исполняемого файла.
>
>
+ Для WPF: определяя модули в конфигурационном файле.
* Декларативно задавать атрибуты для модулей, служащие для определения режима инициализации и внедрения зависимостей.
* Интеграция с контейнерами внедрения зависимостей, для поддержания слабой связанности между модулями.
* Для загрузки модулей:
+ Управление зависимостями, включая дублирование и обнаружение циклов, для гарантирования того, что модули загрузятся в правильном порядке и что они загрузятся и инициализируются лишь один раз.
+ Фоновая загрузка модулей и загрузка по требованию, чтобы минимизировать время запуска приложения; оставшаяся часть модулей может быть загружена и инициализирована в фоновом режиме или по необходимости.
### Базовые понятия
Этот раздел предоставляет базовые понятия, связанные с модульным принципом в Prism, включая интерфейс `IModule`, процесс загрузки модулей, каталог модулей, поддержание связи между модулями, а также контейнеры внедрения зависимостей.
#### *IModule*: строительный блок модульных приложений
Модуль является логическим набором функциональных компонент и ресурсов, собранных в одном месте. Модули могут быть разработаны, протестированы, развернуты, и интегрированы в приложение по отдельности. Пакет может включать одну или более сборок, которые могут располагаться по отдельности, или собираться в едином XAP файле. У каждого модуля имеется центральный класс, который ответственен за инициализацию и интеграцию функциональности модуля в приложение. Этот класс реализует интерфейс `IModule`. Присутствия класса, реализующего интерфейс `IModule`, достаточно, чтобы идентифицировать пакет как модуль. У интерфейса `IModule` есть единственный метод `Initialize`, в пределах которого можно реализовать любую логику, необходимую для инициализации и интеграции функциональности модуля в приложение. В зависимости от цели модуля, он может регистрировать представления в регионах пользовательского интерфейса, делать доступными для приложения дополнительные службы, или расширять его функциональность. Следующий код показывает минимальную реализацию модуля.
```
public class MyModule : IModule {
public void Initialize() {
// Код инициализации расположен здесь.
}
}
```
> **Заметка**
>
> Вместо использования механизма инициализации, предоставляемого интерфейсом `IModule`, *Stock Trader RI* использует декларативный, основанный на атрибутах подход для того, чтобы зарегистрировать представления, службы, и типы.
#### Время жизни модуля
Процесс загрузки модуля в Prism включает следующее:
1. **Регистрация/обнаружение модулей.** Модули, которые будут загружены во время выполнения для определенного приложения, определяются в каталоге модулей. Каталог содержит информацию о загружаемых модулях, их расположение, и порядок, в котором они должны быть загружены.
2. **Загрузка модулей.** Сборки, которые содержат модули, загружаются в память. Эта фаза может потребовать загрузки модуля из сети или из другого удаленного расположения, или локального каталога.
3. **Инициализация модулей.** Создание класса модуля и вызов метода `Initialize` через интерфейс `IModule`.
Следующая иллюстрация показывает процесс загрузки модуля.
#### Каталог модулей
`ModuleCatalog` содержит информацию о модулях, которые могут использоваться приложением. Каталог является, по существу, набором классов `ModuleInfo`. Каждый модуль описывается классом `ModuleInfo`, который хранит имя, тип и расположение модуля. Есть несколько типичных подходов к заполнению `ModuleCatalog` экземплярами `ModuleInfo`:
* Регистрация модулей в коде.
* Регистрация модулей в XAML.
* Регистрация модулей в конфигурационном файле (только в WPF).
* Обнаружение модулей в локальном каталоге на диске (только в WPF).
Выбор механизма регистрации и обнаружения, который следует использовать, зависит от того, что необходимо приложению. Использование конфигурационного файла или файла XAML позволяет приложению не хранить ссылки на модули. Использование локального каталога может позволить приложению обнаруживать модули без необходимости определять их в каком-либо файле.
#### Управление моментом загрузки модуля
Приложения Prism могут инициализировать модули при первой возможности, что известно как «when available», или когда приложение нуждается в них, что известно как «on-demand». Для приложений Silverlight, модули могут быть загружены вместе с приложением, или в фоновом режиме после того, как приложение запустится. Рассмотрите следующие инструкции по загрузке модулей:
* Модули, требуемые для работы приложения, должны быть загружены вместе с приложением и инициализированы при старте.
* Модули, содержащие функции, которые почти всегда используются при обычном использовании приложения, могут быть загружены в фоновом режиме и инициализированы, когда они становятся доступными.
* Модули, содержащие те функции, которые редко используются (или модули поддержки, от которых другие модули могут зависеть), могут быть загружены в фоновом режиме и инициализированы по требованию.
Рассмотрите способ разделения приложения, сценарии общего использования, скорость запуска приложения, а также число и размер загрузок, чтобы определить то, как необходимо сконфигурировать загрузку и инициализацию модулей.
#### Интеграция модулей с приложением
Prism предоставляет следующие классы, необходимые для загрузки вашего приложения: `UnityBootstrapper` и `MefBootstrapper`. Эти классы могут использоваться для создания и конфигурирования менеджера модулей, который необходим для обнаружения и загрузки модулей. Можно переопределить метод конфигурации каталога модулей, чтобы зарегистрировать модули, определенные в файле XAML, конфигурационном файле, или указать расположение каталога.
Используйте метод `Initialize` модуля, чтобы интегрировать модуль с остальной частью приложения. Способ, которым вы это сделаете, будет зависеть от структуры приложения и содержимого модуля. Ниже показаны общие шаги, которые необходимо совершить для интеграции модуля в ваше приложение:
* Добавьте представления, содержащиеся в модуле, к структуре навигации приложения. Это общий шаг при создании UI составного приложения, используя обнаружение, или инжекцию представлений.
* Подпишитесь на события уровня приложения или службы.
* Зарегистрируйте совместно используемые службы в контейнере внедрения зависимостей приложения.
#### Поддержка связи между модулями
Даже учитывая, что модули должны быть слабо связаны, им свойственно обмениваться друг с другом данными и сообщениями. Есть несколько коммуникационных паттернов для слабо связанных систем, каждый со своими преимуществами и недостатками. Как правило, в конечном счёте, используются комбинации этих паттернов. Далее представлены некоторые из этих паттернов:
* **Слабо связанные события.** Модуль может широковещательно передать, что имело место определённое событие. Другие модули могут подписаться на получение таких событий. Таким образом, они будут уведомлены, когда это событие произойдёт. Слабо связанные события являются довольно лёгким способом установления связи между модулями. В связи с этим, это легко реализуется. Однако, проект, который слишком полагается на события, может стать трудным для поддержки, особенно если событий много, или они должны быть организованы вместе для выполнения единственной задачи. В этом случае, использование общей службы может быть более рациональным.
* **Совместно используемые службы.** Совместно используемая служба является классом, к которому можно получить доступ через общий интерфейс, обычно разрешаемый через контейнер. Как правило, совместно используемые службы находятся в совместно используемой сборке и предоставляют услуги в масштабе всей системы, такие как аутентификация, журналирование, или конфигурация. Такие службы часто являются синглтонами.
* **Совместно используемые ресурсы.** Если вы не хотите, чтобы модули непосредственно связывались друг с другом, вы можете сделать так, чтобы они связались косвенно через совместно используемый ресурс, такой как база данных или ряд веб-сервисов.
#### Внедрение зависимостей и модульные приложения
Контейнеры, такие как Unity Application Block (Unity) и Managed Extensibility Framework (MEF), позволяют вам легко использовать инверсию управления (IoC) и внедрение зависимостей, которые являются мощными шаблонами разработки, помогающими соединять компоненты слабо связанным способом. Это позволяет компонентам получать ссылки на другие компоненты, от которых они зависят, без необходимости жёстко кодировать эти ссылки, получая, таким образом, повторное использование кода и повышенную гибкость. Внедрение зависимости очень полезно при создании слабо связанного модульного приложения. Prism разрабатывалась так, чтобы быть независимым от DI контейнера, используемого для композиции компонентов приложения. Выбор контейнера – ваше дело, и оно будет в значительной степени зависеть от основных эксплуатационных характеристик и предпочтений. Существуют две основные платформы внедрения зависимости для рассмотрения от Microsoft – Unity и MEF.
Patterns&practices Unity Application Block представляет полнофункциональный контейнер внедрения зависимостей. Он поддерживает инжекцию, основанную на свойствах, инжекцию, основанную на конструкторах и инжекцию политик, которая позволяет прозрачно вводить поведения и политики между компонентами. Он также поддерживает множество других функций, типичных для контейнеров внедрения зависимостей.
MEF (который теперь является частью .NET Framework 4 и Silverlight 4) позволяет создавать расширяемые приложения, поддерживая основанную на внедрении зависимостей композицию, а также предоставляет другие функции, которые поддерживают модульную разработку приложений. Это позволяет приложению обнаруживать компоненты во время выполнения и затем интегрировать их в приложение. MEF предоставляет прекрасные возможности для расширения и композиции. Они включают обнаружение сборок и типов, разрешение зависимостей, внедрение зависимостей, и некоторые возможности по загрузке сборок и XAP файлов. Prism поддерживает использование таких функций MEF, как:
* Ассоциация типов модуля с расположением их XAP файлов.
* Регистрация модулей через XAML и в коде для WPF и Silverlight.
* Регистрация модулей через конфигурационные файлы и сканируемые каталоги для WPF.
* Отслеживание состояния загрузки модулей.
* Пользовательские декларативные метаданные для модулей.
### Ключевые решения
Первое решение, которое вы должны принять, состоит в том, хотите ли вы разработать модульное приложение. Есть многочисленные преимущества создания модульных приложений, как было обсуждено в предыдущем разделе, но также существует дополнительное время и усилия, которое вы должны приложить, чтобы получить эти преимущества. Если вы всё же решите разрабатывать модульное приложение, то есть ещё несколько вещей для рассмотрения:
* **Определите платформу, которую вы будете использовать.** Можно создать свою собственную модульную платформу, использовать Prism, MEF, или другую платформу.
* **Определите, как организовать ваше приложение.** Приблизьтесь к модульной архитектуре, определив границы каждого модуля, включая то, какие сборки являются частью каждого модуля. Можно решить использовать модульный принцип, чтобы облегчить разработку, для управления тем, как приложение будет развёрнуто, или для поддержки сменной или расширяемой архитектуры.
* **Определите, как разделить ваши модули.** Модули могут быть разделены, основываясь на требованиях, например, по функциональным областям, предоставленным модулям, группам разработчиков и требованиям развёртывания.
* **Определите базовые службы, которые приложение предоставит всем модулям.** К примеру, это может быть служба сообщения об ошибках, или служба аутентификации и авторизации.
* **Если вы используете Prism, определяете, как вы будете регистрировать модули в каталоге модулей.** Для WPF можно зарегистрировать модули в коде, в XAML, в конфигурационном файле, или настроить обнаружение модулей в локальном каталоге на диске. Для Silverlight можно зарегистрировать модули в коде или в XAML.
* **Определите свою стратегию передачи данных и зависимостей между модулями.** Модули должны будут связываться друг с другом, и вы должны будете иметь дело с зависимостями между модулями.
* **Определите контейнер внедрения зависимостей.** Как правило, модульные системы требуют внедрения зависимостей, инверсии управления, или локатора служб для обеспечения слабой связанности, динамической загрузки, и создания модулей. Prism позволяет сделать выбор между Unity, MEF, или другим контейнером и предоставляет библиотеки для приложений на основе Unity или MEF.
* **Минимизируйте время запуска приложения.** Подумайте о загрузке модулей по требованию и фоновой загрузке, чтобы минимизировать время запуска приложения.
* **Определите требования развёртывания.** Вы должны будете подумать о том, как вы намереваетесь развёртывать своё приложение. Это может влиять на число сборок собираемых в XAP файлы. Вы могли бы также разделить совместно использованные библиотеки, такие как Prism, чтобы использовать сборки, кэширующиеся в Silverlight.
Следующие разделы детально рассматривают эти решения.
#### Разделение приложения на модули
Когда вы разрабатываете своё приложение модульным способом, вы структурируете его на отдельные клиентские модули, которые могут быть индивидуально разработаны, протестированы, и развёрнуты. Каждый модуль будет инкапсулировать часть полной функциональности вашего приложения. Одно из первых проектных решений, которые необходимо сделать, состоит в решении того, как разделить функциональность вашего приложения по дискретным модулям.
Модуль должен инкапсулировать ряд связанной функциональности и иметь набор различных обязанностей. Модуль может представить вертикальный разрез приложения или горизонтального слой служб. У больших приложений, вероятно, будут оба типа модулей.
Большое приложение может иметь модули, организованные как по вертикальным срезам, так и по горизонтальным слоям. Например, модули могут включать следующее:
* Модуль, который содержит определённую функцию приложения, такую как модуль новостей в *Stock Trader Reference Implementation (Stock Trader RI)*.
* Модуль, который содержит определённую подсистему или функциональность для ряда связанных разделов использования, таких как покупка, выставление счёта, или главная бухгалтерская книга.
* Модуль, который содержит службы инфраструктуры, такие как журналирование, кэширование, и службы авторизации, или веб-сервисы.
* Модуль, который содержит службы, вызывающие line-of-business (LOB) системы, такие как Siebel CRM и SAP, в дополнение к другим внутренним системам.
У модуля должен быть минимальный набор зависимостей от других модулей. Когда у модуля есть зависимость от другого модуля, он должен быть слабо связан с ним через интерфейсы, определённые в совместно используемой библиотеке, а не через конкретные типы, или, используя `EventAggregator`, чтобы связаться с другими модулями через события.
Цель модульного принципа состоит в том, чтобы разделить приложение таким способом, что оно станет гибким, удобным в сопровождении, и устойчивым, даже тогда, когда функции и технологии добавляются и удаляются. Лучший способ достичь этого состоит в том, чтобы разработать ваше приложение так, чтобы модули были настолько независимы, насколько возможно, имели чётко определённые интерфейсы, и были максимально изолированы.
##### Определение соотношения проектов и модулей
Есть несколько способов создания и упаковки модули. Рекомендуемый и наиболее распространённый способ заключается в создании единственной сборки на модуль. Это помогает разделить модули логически и способствует надлежащей инкапсуляции. Это также позволяет говорить о сборке как о модуле и наоборот. Однако ничто не препятствует тому, чтобы единственная сборка содержала несколько модулей, в некоторых случаях это может быть предпочтительным для минимизации числа проектов в вашем решении. Большое приложение вполне может иметь 10-50 модулей. Перенос каждого модуля в свой собственный проект добавляет сложности к решению и может замедлить производительность Visual Studio. Иногда имеет смысл разделить модуль или набор модулей на собственные решения, если вы хотите придерживаться одного модуля на проект или сборку.
##### XAP и факторинг модуля
Для приложений Silverlight модули обычно упаковываются в отдельных файлах XAP, хотя в некоторых случаях, у вас может быть больше чем один модуль на XAP. Следует рассмотреть, в каком количестве файлов XAP вы нуждаетесь, чтобы минимизировать число и размер запросов загрузки, требуемых для запуска приложения и активации новой опции. Если вы хотите разделять каждый модуль на его собственный проект/сборку, вы должны решить, вставить ли каждую сборку его собственный XAP для развёртывания или включать несколько сборок в единственный XAP.
Некоторые факторы, влияющие на ваш выбор того, включать ли несколько модулей в единственный файл XAP или разделить их:
* **Размер загрузки и совместно использованные зависимости.** У каждого файла XAP есть небольшое количество дополнительных издержек размера в его декларации и .zip упаковке. Кроме того, если будут общие зависимости между модулями, и они не относятся к зависимому модулю или кэшируемой библиотеке, то каждый XAP будет включать эти зависимые библиотеки, которые могут значительно увеличить размер загрузки.
* **Синхронизация того, когда несколько модулей необходимы приложению.** Если загружаются и используются одновременно несколько модулей, такие как предоставление представлений при запуске приложения, упаковка их в единственном файле XAP может сделать загрузку немного быстрее и позволит гарантировать, что оба модуля станут физически доступными клиенту одновременно. Функция модульного принципа Prism гарантирует, что модули, которые указывают на зависимости, загрузятся в правильном порядке. Но есть небольшое количество издержек производительности, включенных в создание двух загрузок вместо одной, даже если суммарный размер загрузки одинаков.
* **Управление версиями модулей.** Если различные модули будут разработаны на независимых временных шкалах и потенциально развернуты отдельно, вы можете захотеть поместить их в отдельные XAP, чтобы они могли быть отмечены различными версиями более чисто и обновлены независимо.
Чтобы избежать загружать одной и те же сборки несколько раз в каждом XAP, есть два подхода, которые могут использоваться:
* Разложить совместно использованные зависимости в отдельный модуль инфраструктуры, и иметь потребляемые модули, берущие зависимости от этого совместно используемого модуля.
* Пользуйтесь *Assembly Library Caching* в Silverlight, чтобы поместить совместно используемые типы в совместно используемую библиотеку, которая загружается один раз и кэшируется Silverlight, а не загрузчиком модулей Prism.
#### Используйте внедрение зависимостей для достижения слабой связанности
Модуль может зависеть от компонентов и услуг, предоставленных хост-приложением или другими модулями. Prism поддерживает возможность регистрации зависимости между модулями так, чтобы они были загружены и инициализированы в правильном порядке. Prism также поддерживает инициализацию модулей, после их загрузки. Во время инициализации, модуль может получить ссылки на дополнительные компоненты и службы, которых ему требуются, и/или зарегистрировать любые компоненты и службы, которые он содержит, чтобы сделать их доступными для других модулей.
Модуль должен использовать независимый механизм для получения экземпляров внешних интерфейсов вместо того, чтобы непосредственно создавать конкретные типы. Он может сделать это через контейнер внедрения зависимостей или фабричные службы. Контейнеры внедрения зависимости, такие как Unity или MEF, позволяют типу автоматически получать экземпляры интерфейсов посредством внедрения зависимостей. Prism интегрируется и с Unity, и с MEF, чтобы позволить модулям легко использовать механизм внедрения зависимостей.
Следующая схема показывает типичную последовательность операций при загрузке модулей, которые требуются для получения или регистрации ссылок на компоненты и службы.
В этом примере сборка `OrdersModule` определяет класс `OrdersRepository` (наряду с другими представлениями и классами, которые реализуют функциональность заказа). Сборка `CustomerModule` определяет класс `CustomersViewModel`, который зависит от класса `OrdersRepository`, основанного на интерфейсе, предоставленном службой. Запуск приложения и процесс загрузки содержит следующие шаги:
1. Bootstrapper запускает процесс инициализации модуля, и загрузчик модуля загружает и инициализирует `OrdersModule`.
2. В этапе инициализации `OrdersModule`, он регистрирует `OrdersRepository` в контейнере.
3. Загрузчик модуля загружает `CustomersModule`. Порядок загрузки модулей может быть определён на основе их метаданных.
4. `CustomersModule` создаёт экземпляр `CustomerViewModel`, разрешая его через контейнер. `CustomerViewModel` имеет зависимость от `OrdersRepository` (основанную на его интерфейсе) и указывает на это через инжекцию свойства или конструктора. Контейнер вводит эту зависимость при создании модели представления, основанной на типе, зарегистрированном `OrdersModule`. Конечным результатом является интерфейсная ссылка из `CustomerViewModel` на `OrderRepository` без жёсткой связи между этими классами.
> **Заметка**
>
> Интерфейс, используемый, чтобы представить `OrderRespository` (`IOrderRepository`), мог находиться в отдельной сборке совместно используемых служб, или в сборке служб заказов, которая содержит только интерфейсы служб и типы, необходимые для их публикации. Таким образом, нет никакой жёсткой зависимости между `CustomersModule` и `OrdersModule`.
Заметьте, что у обоих модулей есть неявная зависимость от контейнера внедрения зависимости. Эта зависимость вводится во время создания модуля в загрузчике.
### Базовые сценарии
Этот раздел описывает общие сценарии, с которыми вы столкнётесь, работая с модулями в вашем приложении. Эти сценарии включают определение модуля, регистрацию и обнаружение модулей, загрузку модулей, инициализацию модулей, определение зависимостей модуля, загрузку модулей по требованию, загрузку удалённых модулей в фоновом режиме, и определение состояния процесса загрузки. Можно зарегистрировать и модули в коде, в XAML, в конфигурационном файле приложения, или сканируя локальный каталог.
#### Определение модуля
Модуль является логическим набором функциональности и ресурсов, который может быть отдельно разработан, протестирован, развернут, и интегрирован в приложение. У каждого модуля есть центральный класс, который ответственен за инициализацию модуля и интеграции его функциональности в приложение. Этот класс реализует интерфейс `IModule`, как показано ниже.
```
public class MyModule : IModule {
public void Initialize() {
// Инициализация модуля.
}
}
```
> **Заметка**
>
> Имена модулей должны быть уникальными в пределах всего приложения.
Тот путь, которым вы реализуете метод `Initialize`, будет зависеть от требований вашего приложения. Тип класса модуля, режим инициализации, и любые зависимости модуля задаются в каталоге модулей. Для каждого модуля в каталоге загрузчик создаёт экземпляр класса модуля и затем вызывает метод `Initialize`. Модули обрабатываются в порядке, определённом в каталоге модулей. Порядок инициализации во время выполнения зависит от того, когда модули загрузятся, станут доступны, и их зависимости удовлетворятся.
В зависимости от типа каталога модулей, который использует ваше приложение, зависимости модуля, могут быть установлены или декларативными атрибутами непосредственно в классе модуля, или в пределах файла каталога модулей. Следующие разделы предоставят более детальную информацию.
#### Регистрация и обнаружений модулей
Модули, которые может загрузить приложение, определяются в каталоге модулей. Загрузчик модулей Prism использует каталог модулей, чтобы определить, какие модули доступны для загрузки, когда их загрузить, и в каком порядке они должны быть загружены.
Каталог модулей представляет собой класс, реализующий интерфейс `IModuleCatalog`. Класс каталога модулей создаётся классом загрузчика во время инициализации приложения. Prism предоставляет различные реализации каталога модулей, из которых вы можете выбрать необходимый. Можно также заполнить каталог модулей из другого источника данных, вызывая метод `AddModule` или наследуя класс от `ModuleCatalog`, чтобы создать каталог модулей со специализированным поведением.
> **Заметка**
>
> Как правило, модули в Prism используют контейнер внедрения зависимости и Common Service Locator, чтобы получить экземпляры типов, которые требуются для инициализации модуля. Хотя полный процесс регистрации, обнаружения, загрузки, и инициализации модулей является одним и тем же, детали могут измениться в зависимости от того, какой контейнер используется. Контейнерно-специфичные различия между подходами рассматриваются всюду в этой теме.
##### Регистрация модулей в коде
Самый базовый каталог модулей предоставляется классом `ModuleCatalog`. Можно использовать этот каталог, чтобы зарегистрировать модули в коде, задавая тип класса модуля. Можно также задать режим инициализации и имя модуля. Чтобы зарегистрировать модуль непосредственно в классе `ModuleCatalog`, вызовите метод `AddModule` в классе `Bootstrapper` своего приложения.
```
protected override void ConfigureModuleCatalog() {
Type moduleCType = typeof(ModuleC);
ModuleCatalog.AddModule(
new ModuleInfo() {
ModuleName = moduleCType.Name,
ModuleType = moduleCType.AssemblyQualifiedName,
});
}
```
В предыдущем примере, на модули непосредственно ссылается оболочка, таким образом, определяются типы классов модулей, которые могут использоваться в вызове метода `AddModule`. Именно поэтому этот пример использует `typeof(Module)`, чтобы добавить модули к каталогу.
> **Заметка**
>
> Если у приложения есть прямая ссылка на тип модуля, можно добавить этот тип, как показано выше. Иначе вы должны предоставить полностью определённое имя типа и расположение сборки.
Чтобы увидеть другой пример определения каталога модулей в коде, смотрите `StockTraderRIBootstrapper.cs` в *Stock Trader RI*.
> **Заметка**
>
> Базовый класс `Bootstrapper` предоставляет метод `CreateModuleCatalog`, чтобы помочь в создании `ModuleCatalog`. По умолчанию, этот метод создаёт экземпляр `ModuleCatalog`, но этот метод может быть переопределён в производном классе для создания других типов каталога модулей.
##### Регистрация модулей с помощью XAML файла
Можно определить каталог модулей декларативно в файле XAML. Файл XAML определяет, какой нужно создать класс каталога модулей и какие модули к нему добавить. Обычно `.xaml` файл добавляется как ресурс к вашему проекту оболочки. Каталог модулей создаётся в загрузчике вызовом метода `CreateFromXaml`. С технической точки зрения, этот подход подобен определению `ModuleCatalog` в коде, потому что файл XAML просто определяет иерархию объектов, которые будут инстанцироваться.
Следующий пример кода показывает файл XAML, задающий каталог модулей.
```
ModuleE
```
> **Заметка**
>
> `ModuleInfoGroups` обеспечивают удобный способ сгруппировать модули, которые находятся в одном и том же .xap файле или сборке, инициализируются одинаковым образом, или имеют зависимости только от модулей в той же самой группе. Зависимости между модулями могут быть определены в пределах модулей, в `ModuleInfoGroup`, однако, невозможно задать зависимости между модулями в различных `ModuleInfoGroups`. Помещение модулей в группы модулей является не обязательным. Свойства, которые устанавливаются для группы, будут применены ко всем модулям в ней. Отметьте, что модули также могут быть зарегистрированы, не будучи в группе.
>
>
В классе `Bootstrapper` вы должны указать, что файл XAML является источником для `ModuleCatalog`, как показано ниже.
```
protected override IModuleCatalog CreateModuleCatalog() {
return ModuleCatalog.CreateFromXaml(
new Uri("/MyProject.Silverlight;component/ModulesCatalog.xaml", UriKind.Relative));
}
```
##### Регистрация модулей, используя конфигурационный файл
В WPF возможно задать информацию о модуле в файле `App.config`. Преимущество этого подхода состоит в том, что этот файл не компилируется в приложение. Это облегчает добавление или удаление модулей во время выполнения, без перекомпиляции приложения.
Следующий код показывает конфигурационный файл, задающий каталог модулей. Если вы хотите, чтобы модуль автоматически загрузился, установите `startupLoaded="true"`.
```
```
> **Заметка**
>
> Даже если ваши сборки находятся в глобальном кэше сборок или в той же самой папке, где и приложение, требуется атрибут `assemblyFile`. Атрибут используется, чтобы отобразить `moduleType` на корректный `IModuleTypeLoader`, который будет использоваться.
В классе `Bootstrapper` приложения, вы должны задать, что конфигурационный файл является источником для `ModuleCatalog`. Чтобы сделать это, используйте класс `ConfigurationModuleCatalog`, как показано в следующем коде.
```
protected override IModuleCatalog CreateModuleCatalog() {
return new ConfigurationModuleCatalog();
}
```
> **Заметка**
>
> Можно все ещё добавить модули к `ConfigurationModuleCatalog` в коде. Можно использовать это, например для того, чтобы удостовериться в том, что модули абсолютно необходимые для функционирования вашего приложения, добавляются в каталог модулей.
> **Заметка**
>
> Silverlight не поддерживает конфигурационные файлы. Если вы хотите использовать такой подход для конфигурации в Silverlight, рекомендуется создать ваш собственный `ModuleCatalog`, который читает конфигурацию модулей из веб-сервиса на сервере.
##### Обнаружение модулей в локальном каталоге
Класс `DirectoryModuleCatalog` позволяет вам задавать локальный каталог как каталог модулей в WPF. Этот каталог модулей будет сканировать указанную папку, и искать сборки, которые предоставляют модули для вашего приложения. Чтобы использовать этот подход, вы должны будете использовать декларативные атрибуты на своих классах модулей, чтобы определить имена модулей и любые зависимости, которые они имеют. Следующий пример кода показывает каталог модулей, который заполняется, обнаруживая сборки в локальном каталоге.
```
protected override IModuleCatalog CreateModuleCatalog() {
return new DirectoryModuleCatalog() {ModulePath = @".\Modules"};
}
```
> **Заметка**
>
> Эта функциональность не поддерживается в Silverlight, потому что модель безопасности Silverlight не позволяет вам загружать сборки из файловой системы.
#### Загрузка модулей
После того, как `ModuleCatalog` заполнится, модули готовы для загрузки и инициализации. Загрузка модуля означает, что сборка модуля загружается с диска в память. Если сборка отсутствует на диске, то её, возможно, придётся сначала получить из другого источника. Примером этого является загрузка сборки из интернета, используя Silverlight `.xap` файлы. `ModuleManager` ответственен за координирование процесса инициализации и загрузки.
#### Инициализация модулей
После загрузки модулей, они инициализируются. Это означает, что создаётся экземпляр класса модуля и вызывается его метод `Initialize`. Инициализация является тем местом, где происходит интеграция модуля в приложение. Рассмотрим следующие возможности при инициализации модуля:
* **Регистрация представления их модуля в приложении.** Если ваш модуль будет участвовать в композиции пользовательского интерфейса, используя обнаружение или внедрение представлений, то ваш модуль должен будет связать свои представления или модели представления с соответствующими регионами.
* **Подпишитесь на события или службы уровня приложения.** Часто приложения предоставляют специализированные службы и/или события, которыми интересуется ваш модуль. Используйте метод `Initialize`, чтобы добавить функциональность модуля к событиям и службам уровня приложения. Например, приложение может генерировать событие, когда оно завершает работу, и ваш модуль хочет реагировать на это событие. Также возможно, что ваш модуль должен будет предоставлять некоторые данные для службы уровня приложения. Например, если вы создали службу `MenuService` (ответственную за добавление и удаление пунктов меню), метод `Initialize` модуля – то место, где можно добавлять корректные пункты меню.
> **Заметка**
>
> Время жизни экземпляра модуля по умолчанию является недолгим. После того, как вызывают метод `Initialize` во время процесса загрузки, ссылка на экземпляр модуля удаляется. Если вы не создадите цепочку ссылок на экземпляр модуля, то он будет собран сборщиком мусора. Такое поведение может быть нежелательным при отладке, если вы подписываетесь на события, которые содержат слабую ссылку на ваш модуль, потому что ваш модуль «исчезает» при запуске сборщика мусора.
* **Регистрация типов в контейнере внедрения зависимостей.** Если вы используете контейнер внедрения зависимостей, такой как Unity или MEF, модуль может зарегистрировать типы для использования их в приложении или в других модулях. Также можно использовать контейнер для разрешения экземпляров типов, в которых нуждается модуль.
#### Определение зависимостей модуля
Модули могут зависеть от других модулей. Если *Module A* зависит от *Module B*, то *Module B* должен быть инициализирован перед *Module A*. `ModuleManager` отслеживает эти зависимости и инициализирует модули в правильном порядке. В зависимости от того, как вы определили свой каталог модулей, можно определить свои зависимости модуля в коде, конфигурации, или XAML.
##### Определение зависимостей в коде
Для приложений WPF, которые регистрируют модули в коде или обнаруживают их в папке, Prism предоставляет декларативные атрибуты для класса модуля, как показано в следующем примере.
```
[Module(ModuleName = "ModuleA")]
[ModuleDependency("ModuleD")]
public class ModuleA: IModule {
...
}
```
##### Определение зависимостей в XAML
Следующий XAML показывает, что *Module F* зависит от *Module E*.
```
ModuleE
```
##### Определение зависимостей в файле конфигурации
Следующий пример файла App.config показывает, что *Module D* зависит от *Module B*.
```
```
#### Загрузка модулей по требованию
Для загрузки модулей по требованию, вы должны указать, что они должны быть загружены в каталог модулей с установленным параметром `InitializationMode` в `OnDemand`. После этого, вы должны добавить код в своё приложении, запрашивающий загрузку модуля.
##### Задание загрузки по требованию в коде
Определение, того что модуль должен загружаться по требованию через атрибуты, показано в следующем примере.
```
protected override void ConfigureModuleCatalog() {
Type moduleCType = typeof(ModuleC);
this.ModuleCatalog.AddModule(new ModuleInfo() {
ModuleName = moduleCType.Name,
ModuleType = moduleCType.AssemblyQualifiedName,
InitializationMode = InitializationMode.OnDemand
});
}
```
##### Задание загрузки по требованию в XAML
Можно определить `InitializationMode.OnDemand`, когда вы задаёте каталог модулей в XAML, как показано в следующем примере кода.
```
...
...
```
##### Задание загрузки по требованию в файле конфигурации
Вы можете определить `InitializationMode.OnDemand` при задании каталога модулей в файле `App.config`, как показано в следующем примере кода.
```
...
....
```
##### Запрос на загрузку модуля
После того, как модуль определяется как загружаемый по требованию, приложение может запросить его загрузку. Коду, который хочет инициировать загрузку, требуется получить ссылку на службу `IModuleManager`, зарегистрированную в контейнере загрузчиком.
```
private void OnLoadModuleCClick(object sender, RoutedEventArgs e) {
moduleManager.LoadModule("ModuleC");
}
```
#### Удалённая загрузка модулей в фоновом режиме
Загрузка модулей в фоновом режиме после того, как приложение запускается, или только когда пользователь в них нуждается, может уменьшить время запуска приложения.
##### Подготовка модуля для удалённой загрузки
В приложениях Silverlight модули упаковываются в `.xap` файлы. Чтобы загрузить модуль отдельно от приложения, создайте отдельный `.xap` файл. Можно захотеть поместить несколько модулей в единственный `.xap` файл, чтобы оптимизировать число запросов загрузки в замен размера каждого .xap файла.
> **Заметка**
>
> Для каждого .xap файла, вы должны будете создать новый проект приложения Silverlight. В Visual Studio 2008 и 2010, только проекты приложения производят отдельные `.xap` файлы. Вы не будете нуждаться в `App.xaml` или файлах `MainPage.xaml` в этих проектах.
##### Отслеживание процесса загрузки
Класс `ModuleManager` предоставляет событие для отслеживания продвижения загрузки модулей. Он предоставляет загруженные байты против полного размера загрузки для получения процента продвижения. Можно использовать его, чтобы вывести на экран визуальные индикаторы хода загрузки.
```
this.moduleManager.ModuleDownloadProgressChanged += this.ModuleManager_ModuleDownloadProgressChanged;
```
```
void ModuleManager_ModuleDownloadProgressChanged(object sender,
ModuleDownloadProgressChangedEventArgs e) { ... }
```
#### Определение того, что модуль был загружен
Служба `ModuleManager` предоставляет событие, чтобы отследить, когда модуль загружен или не в состоянии загрузиться.
```
this.moduleManager.LoadModuleCompleted += this.ModuleManager_LoadModuleCompleted;
```
```
void ModuleManager_LoadModuleCompleted(object sender, LoadModuleCompletedEventArgs e) { ... }
```
Чтобы сохранить приложение и модули слабо связанным, вы должны избегать использования этого события для интеграции модуля с приложением. Используйте вместо этого метод модуля `Initialize`.
`LoadModuleCompletedEventArgs` содержит свойство `IsErrorHandled`. Если модуль не в состоянии загрузиться, и приложение хочет препятствовать тому, чтобы `ModuleManager` регистрировал ошибку и выдал исключение, нужно установить это свойство в `true`.
> **Заметка**
>
> После того, как модуль загружается и инициализируется, сборка модуля не может быть выгружена. Ссылка экземпляра модуля не будет сохранена библиотеками Prism, таким образом, экземпляр класса модуля сможет быть собран «мусор» после того, как инициализация выполнена.
#### Модули в MEF
Этот раздел только выделяет различия при использовании MEF в качестве контейнера внедрения зависимостей.
> **Заметка**
>
> При использовании MEF, `MefBootstrapper` использует `MefModuleManager`. Он расширяет `ModuleManager` и реализует интерфейс `IPartImportsSatisfiedNotification`, чтобы гарантировать, что `ModuleCatalog` обновляется, когда новые типы импортируются MEF.
##### Регистрация модулей в коде, используя MEF
При использовании MEF можно применять атрибут `ModuleExport` к классам модуля, чтобы MEF мог их автоматически обнаружить.
```
[ModuleExport(typeof(ModuleB))]
public class ModuleB : IModule {
...
}
```
Можно также использовать MEF, чтобы обнаружить и загрузить модули, используя класс `AssemblyCatalog`, который может использоваться для обнаружения всех экспортируемых классов модуля в сборке, и класс `AggregateCatalog`, который позволяет нескольким каталогам быть объединёнными в один логический каталог. По умолчанию, класс `MefBootstrapper` создает экземпляр `AggregateCatalog`. Можно переопределить метод `ConfigureAggregateCatalog`, чтобы зарегистрировать сборки.
```
protected override void ConfigureAggregateCatalog() {
base.ConfigureAggregateCatalog();
//На Module A определены ссылки в проекте и непосредственно в коде.
this.AggregateCatalog.Catalogs.Add(
new AssemblyCatalog(typeof(ModuleA).Assembly));
this.AggregateCatalog.Catalogs.Add(
new AssemblyCatalog(typeof(ModuleC).Assembly));
}
```
Prism реализация `MefModuleManager` синхронизирует `AggregateCatalog` MEF и Prism `ModuleCatalog`, таким образом позволяя Prism обнаружить модули, добавленные через `ModuleCatalog` или `AggregateCatalog`.
> **Заметка**
>
> MEF широко использует ``Lazy, чтобы предотвратить инстанцирование экспортируемых и импортированных типов до использования свойства Value`.`
>
> ##### Обнаружение модулей в локальном каталоге, используя MEF
>
>
>
> MEF предоставляет класс `DirectoryCatalog`, который может использоваться, чтобы просмотреть папку для сборок, содержащих модули (и другие экспортируемые MEF типы). В этом случае, вы переопределяете метод `ConfigureAggregateCatalog`, чтобы зарегистрировать каталог. Этот подход доступен только в WPF.
>
>
>
> Чтобы использовать этот подход, вы сначала должны задать имена модулей и их зависимости, используя атрибут `ModuleExport`, как показано в следующем примере.
>
>
>
>
> ```
> protected override void ConfigureAggregateCatalog() {
> base.ConfigureAggregateCatalog();
>
> DirectoryCatalog catalog = new DirectoryCatalog("DirectoryModules");
> this.AggregateCatalog.Catalogs.Add(catalog);
> }
> ```
>
>
> ##### Задание зависимостей в коде, используя MEF
>
>
>
> Для приложений WPF, используйте атрибут `ModuleExport`, как показано ниже.
>
>
>
>
> ```
> [ModuleExport(typeof(ModuleA), DependsOnModuleNames = new string[] { "ModuleD" })]
> public class ModuleA : IModule {
> ...
> }
> ```
>
>
> Поскольку MEF позволяет вам обнаруживать модули во время выполнения, можно также во время выполнения обнаружить новые зависимости между модулями. Хотя можно использовать MEF вместе с `ModuleCatalog`, важно помнить, что `ModuleCatalog` проверяет цепочки зависимости, при загрузке из XAML или конфигурации (прежде чем какие-либо модули будут загружены). Если модуль будет перечислен в `ModuleCatalog` и затем будет загружен с использованием MEF, то будут использоваться зависимости `ModuleCatalog`, и атрибут `DependsOnModuleNames` будет проигнорирован. Использование MEF с `ModuleCatalog` наиболее распространено в приложениях Silverlight, у которых есть модули в отдельных файлах XAP.
>
>
>
> ##### Задание загрузки по требованию в MEF
>
>
>
> Если вы используете MEF и атрибут `ModuleExport` для того, чтобы определить модули и зависимости от модуля, можно использовать свойство `InitializationMode`, чтобы определить, что модуль должен быть загружен по требованию, как показано ниже.
>
>
>
>
> ```
> [ModuleExport(typeof(ModuleC), InitializationMode = InitializationMode.OnDemand)]
> public class ModuleC : IModule { ... }
> ```
>
>
> ##### Подготовка модуля к удалённой загрузке в MEF
>
>
>
> Под капотом, приложение Prism, использующее MEF, используют класс MEF `DeploymentCatalog`, чтобы загрузить `.xap` файлы и обнаружить сборки и типы в пределах этих .xap файлов. `MefXapModuleTypeLoader` добавляет каждый `DeploymentCatalog` к `AggregateCatalog`.
>
>
>
> Если два различных `.xap` файла добавляются и содержат одну и ту же совместно используемую сборку, то эти типы импортируются снова. Это может вызвать ошибки рекомпозиции, когда тип назначен быть синглтоном и находится в сборке, совместно используемой модулями. `Microsoft.Practices.Prism.MefExtensions.dll` пример такой сборки.
>
>
>
> Чтобы избежать двойного импорта, откройте каждый проект модуля и отметьте те совместно используемые DLL как `'Copy Local'=false`. Это помешает сборке быть упакованной в .xap файле модуля и быть импортированной снова. Это также уменьшает полный размер каждого .xap файла. Вы должны гарантировать, что или приложение ссылается на совместно используемую сборку, или то, что будет загружен .xap файл, который содержит совместно используемые сборки прежде, чем .xap файлы модулей будет загружены.
>
>
>
> ### Дополнительная информация
>
>
>
> Для получения дополнительной информации о кэшировании сборок, смотрите «How to: Use Assembly Library Caching» на MSDN: <http://msdn.microsoft.com/en-us/library/dd833069(VS.95).aspx>
>
>
>
> Чтобы узнать больше о модульном принципе в Prism, смотрите Modularity with MEF for WPF QuickStart или Modularity with Unity for WPF QuickStart. Чтобы узнать больше о QuickStarts, смотрите [Modularity QuickStarts for WPF](http://msdn.microsoft.com/en-us/library/ff921068(v=PandP.40).aspx).
>
>
>
> Для получения информации о функциях библиотеки Prism, используемых при построении модульных приложений, смотрите "[Modules](http://msdn.microsoft.com/en-us/library/gg430866(v=PandP.40).aspx#Modules)" в "[Extending Prism](http://msdn.microsoft.com/en-us/library/gg430866(v=PandP.40).aspx)." | https://habr.com/ru/post/176863/ | null | ru | null |
# Преимущества Common Lisp
Лисп часто рекламируют как язык, имеющий преимущества перед остальными из-за того, что он обладает некоторыми уникальными, хорошо интегрированными и полезными фичами.
Далее следует попытка выделить набор особенностей стандартного Common Lisp, кратко и с примерами.
Эта статья, вероятно, будет больше всего полезна тем, кто имеет какой-то опыт в программировании, заинтересован лиспом и хочет лучше понять, что делает его таким привлекательным.
Текст по большому счёту основан на списке особенностей CL и обзоре CL Роберта Стренда (Robert Strandh).
#### Богатая и точная арифметика
Лисп предоставляет богатую иерархию числовых типов, которые хорошо интегрированы с остальными частями языка.
**Длинные числа** (bignums) создаются автоматически по мере надобности, что снижает риск переполнений и обеспечивает точность. Например, мы можем быстро вычислить значение 10↑↑4:
```
> (expt (expt (expt (expt 10 10) 10) 10) 10)
100000000000000000000000000000000000[...]
```
**Рациональные числа** представляются в виде дробей, так что никаких ошибок округления при их использовании не происходит. Точная рациональная арифметика интегрирована в язык:
```
> (+ 5/9 3/4)
47/36
```
**Комплексные числа** также являются встроенным типом данных в лиспе. Они могут быть представлены в виде краткого синтаксиса: #c(10 5) означает 10 + 5i. Арифметические операции также могут работать с комплексными значениями:
```
> (* 2 (+ #c(10 5) 4))
#C(28 10)
```
#### Обобщённые ссылки
*Формы* или *позиции* (places) могут использоваться так, как если бы они были отдельными изменяемыми переменными. При помощи SETF и других подобных конструкций можно изменять значения, которые концептуально связаны с заданной позицией.
Например, можно использовать SETF следующим образом:
```
> (defvar *colours* (list 'red 'green 'blue))
*COLOURS*
> (setf (first *colours*) 'yellow)
YELLOW
> *colours*
(YELLOW BLUE GREEN)
```
А PUSH — так:
```
> (push 'red (rest *colours*))
(RED BLUE GREEN)
> *colours*
(YELLOW RED BLUE GREEN)
```
Обобщённые ссылки работают не только в применении к спискам, но и ко многим другим видам структур и объектов. Например, в объектно-ориентированных программах один из способов изменить какое-то поле объекта — при помощи SETF.
#### Множественные значения
Значения могут быть объединены без явного создания структуры, такой как список. Например, (values 'foo 'bar) возвращает два значения — 'foo и 'bar. При помощи этого механизма функции могут возвращать сразу несколько значений, что может упростить программу.
Например, FLOOR — это стандартная функция, которая возвращает два значения:
```
> (floor pi)
3
0.14159265358979312d0
```
По соглашению функции, которые возвращают несколько значений, по умолчанию используются так, как будто бы возвращалось только одно значение — первое.
```
> (+ (floor pi) 2)
5
```
При этом вы можете явно получить и использовать остальные значения. В следующем примере мы разделяем целую и дробную части PI при округлении:
```
> (multiple-value-bind (integral fractional)
(floor pi)
(+ integral fractional))
3.141592653589793d0
```
#### Макросы
Макрос в лиспе — это своего рода функция, которая получает в качестве аргументов лисповские формы или объекты и, как правило, генерирует код, который затем будет скомпилирован и выполнен. Это происходит до выполнения программы, во время фазы, которая называется *развёрткой макросов* (macroexpansion). Макросы могут выполнять какие-то вычисления во время развёртки, используя полные возможности языка.
Одно из применений макросов — преобразовывать какой-либо исходный код в представление, корректное в терминах уже существующих определений. Другими словами, макросы позволяют добавлять новый синтаксис к языку (такой подход известен как *синтаксическая абстракция*).
Это позволяет с лёгкостью встраивать в лисп предметно-ориентированные языки (DSL), так как специальный синтаксис может быть добавлен в язык перед выполнением программы.
Основной выигрыш от использования макросов заключается в том, что они расширяют возможности языка, позволяя программисту выражать свои идеи проще и при помощи меньшего объёма кода. Можно добавить в язык новые средства так, как будто они являются встроенными. К тому же, если макросы использовать для предварительного вычисления данных или инициализации, они могут помочь в оптимизации производительности.
#### Макрос LOOP
Макрос LOOP — это мощное средство для представления циклов. На самом деле это целый небольшой встроенный язык для описания итерационных процессов. LOOP предоставляет все необходимые типы выражений для записи циклов, от простых повторений до итераторов и сложных конечных автоматов.
```
> (defvar *list*
(loop :for x := (random 1000)
:repeat 5
:collect x))
*LIST*
> *list*
(324 794 102 579 55)
```
```
> (loop :for elt :in *list*
:when (oddp elt)
:maximizing elt)
579
```
```
> (loop :for elt :in *list*
:collect (log elt) :into logs
:finally
(return
(loop :for l :in logs
:if (> l 5.0) :collect l :into ms
:else :collect l :into ns
:finally (return (values ms ns)))))
(5.7807436 6.6770835 6.3613024)
(4.624973 4.0073333)
```
#### Функция FORMAT
Функция FORMAT поддерживает встроенный язык для описания того, как данные должны быть отформатированы. Помимо простой текстовой подстановки, инструкции FORMAT-а могут в компактном виде выражать различные правила генерации текста, такие как условия, циклы и обработка граничных случаев.
Мы можем отформатировать список имён при помощи такой функции:
```
(defun format-names (list)
(format nil "~{~:(~a~)~#[.~; and ~:;, ~]~}" list))
```
```
> (format-names '(doc grumpy happy sleepy bashful
sneezy dopey))
"Doc, Grumpy, Happy, Sleepy, Bashful, Sneezy and Dopey."
> (format-names '(fry laurie))
"Fry and Laurie."
> (format-names '(bluebeard))
"Bluebeard."
```
FORMAT передаёт свой результат в указанный поток, будь то стандартный вывод на экран, строка или любой другой поток.
#### Функции высшего порядка
Функции в лиспе являются настоящими сущностными первого класса. Функциональные объекты могут динамически создаваться, передаваться в качестве параметров или возвращаться в качестве результата. Таким образом, поддерживаются функции **высшего порядка**, то есть такие, аргументы и возвращаемые значения которых сами могут быть функциями.
Здесь вы видите вызов функции SORT, аргументами которой являются список и ещё одна функция (в данном случае это #'<):
```
> (sort (list 4 2 3 1) #'<)
(1 2 3 4)
```
**Анонимные функции**, которые также называют лямбда-выражениями, могут использоваться вместо имени передаваемой функции. Они особенно полезны, когда вы хотите создать функцию для однократного использования, не засоряя программу лишним именем. В общем случае их можно использовать для создания лексических замыканий.
В данном примере мы создаём анонимную функцию, чтобы использовать её в качестве первого аргумента MAPCAR:
```
> (mapcar (lambda (x) (+ x 10))
'(1 2 3 4 5))
(11 12 13 14 15)
```
При создании функции захватывают контекст, что позволяет нам использовать полноценные лексические замыкания:
```
(let ((counter 10))
(defun add-counter (x)
(prog1
(+ counter x)
(incf counter))))
```
```
> (mapcar #'add-counter '(1 1 1 1))
(11 12 13 14)
> (add-counter 50)
64
```
#### Обработка списков
Поскольку списки являются фундаментальным встроенным типом данных в лиспе, есть обширный набор функций для манипуляции списками. Благодаря таким функциям и макросам, списки можно использовать для быстрого прототипирования других структур данных.
Например, мы можем вот так работать с обычным списком:
```
> (defvar *nums* (list 0 1 2 3 4 5 6 7 8 9 10 11 12))
*NUMS*
> (list (fourth *nums*) (nth 8 *nums*))
(3 8)
> (list (last *nums*) (butlast *nums*))
((12) (0 1 2 3 4 5 6 7 8 9 10 11))
> (remove-if-not #'evenp *nums*)
(0 2 4 6 8 10 12)
```
А так — с ассоциативным списком
```
> (defvar *capital-cities* '((NZ . Wellington)
(AU . Canberra)
(CA . Ottawa)))
*CAPITAL-CITIES*
> (cdr (assoc 'CA *capital-cities*))
OTTAWA
> (mapcar #'car *capital-cities*)
(NZ AU CA)
```
#### Лямбда-списки
Лямбда-список задаёт параметры функций, макросов, форм связывания и некоторых других конструкций. Лямбда-списки определяют обязательные, опциональные, именованные, хвостовые (rest) и дополнительные параметры, а также значения по умолчанию и тому подобное. Это позволяет определять очень гибкие и выразительные интерфейсы.
**Опциональные параметры** не требуют от вызывающего указывать какое-либо значение. Для них может быть определено значение по умолчанию, в противном случае вызываемый код может проверять, было ли предоставлено значение и действовать по ситуации.
Следующая функция принимает опциональный параметр delimiter, значением по умолчанию для которого является пробельный символ:
```
(defun explode (string &optional (delimiter #\Space))
(let ((pos (position delimiter string)))
(if (null pos)
(list string)
(cons (subseq string 0 pos)
(explode (subseq string (1+ pos))
delimiter)))))
```
При вызове функции EXPLODE мы можем либо предоставить опциональный параметр, либо опустить его.
```
> (explode "foo, bar, baz" #\,)
("foo " " bar " " baz")
```
```
> (explode "foo, bar, baz")
("foo," "bar," "baz")
```
**Именованные параметры** аналогичны опциональным параметрам, но их можно передавать в произвольном порядке, поскольку они определяются именами. Использование имён улучшает читаемость кода и служит своего рода документацией, когда вы делаете вызов с несколькими параметрами.
К примеру, сравните эти два вызова функций:
```
// In C:
xf86InitValuatorAxisStruct(device, 0, 0, -1, 1, 0, 1);
```
```
;; In Lisp:
(xf86-init-valuator-axis-struct :dev device :ax-num 0
:min-val 0 :max-val -1
:min-res 0 :max-res 1
:resolution 1)
```
#### Символы как сущности первого класса
Символы — это уникальные объекты, полностью определяемые своими именами. Скажем, 'foo — это символ, чьё имя «FOO». Символы могут использоваться в качестве идентификаторов или как некие абстрактные имена. Сравнение символов происходит за фиксированное время.
Символы, как и функции, являются сущностями первого класса. Их можно динамически создавать, квотировать (quote, unevaluate), хранить, передавать в качестве аргументов, сравнивать, преобразовывать в строки, экспортировать и импортировать, на них можно ссылаться.
Здесь '\*foo\* является идентификатором переменной:
```
> (defvar *foo* 5)
*FOO*
> (symbol-value '*foo*)
5
```
#### Пакеты как сущности первого класса
Пакеты, которые играют роль пространств имён (namespaces), также являются объектами первого класса. Поскольку их можно создавать, хранить, возвращать в качестве результата во время выполнения программы, возможно динамически переключать контекст или преобразовывать пространства имён динамически.
В следующем примере мы используем INTERN для того, чтобы включить символ в некоторый пакет:
```
> (intern "ARBITRARY"
(make-package :foo :use '(:cl)))
FOO::ARBITRARY
NIL
```
В лиспе есть специальная переменная \*package\*, которая указывает на текущий пакет. Скажем, если текущим пакетом является FOO, то можно выполнить:
```
> (in-package :foo)
#
> (package-name \*package\*)
"FOO"
```
#### Специальные переменные
Лисп поддерживает динамический контекст переменных в дополнение к лексическому контексту. Динамические переменные в некоторых случаях могут быть полезны, так что их поддержка позволяет добиться максимальной гибкости.
Например, мы можем перенаправить вывод какого-то кода в нестандартный поток, такой как файл, создав динамическую связь для специальной переменной \*standard-output\*:
```
(with-open-file (file-stream #p"somefile"
:direction :output)
(let ((*standard-output* file-stream))
(print "This prints to the file, not stdout."))
(print "And this prints to stdout, not the file."))
```
Помимо \*standard-output\*, лисп включает несколько специальных переменных, которые хранят состояние программы, включая ресурсы и параметры, такие как \*standard-input\*, \*package\*, \*readtable\*, \*print-readably\*, \*print-circle\* и т.д.
#### Передача управления
В лиспе есть два способа передачи управления в точку, находящуюся выше в иерархии вызовов. При этом может учитываться лексическая или динамическая область, для локальных и нелокальных переходов, соответственно.
**Именованные блоки** позволяют вложенной форме вернуть управление из любой именованой родительской формы при помощи BLOCK и RETURN-FROM.
К примеру, здесь вложенный цикл возвращает список из блока early в обход внешнего цикла:
```
> (block early
(loop :repeat 5 :do
(loop :for x :from 1 :to 10 :collect x :into xs
:finally (return-from early xs))))
(1 2 3 4 5 6 7 8 9 10)
```
**Catch/throw** — это что-то вроде нелокального goto. THROW производит переход к последнему встреченному CATCH и передаёт значение, которое было указано в качестве параметра.
В функции THROW-RANGE, основанной на предыдущем примере, мы можем применить THROW и CATCH, используя при этом динамическое состояние программы.
```
(defun throw-range (a b)
(loop :for x :from a :to b :collect x :into xs
:finally (throw :early xs)))
```
```
> (catch :early
(loop :repeat 5 :do
(throw-range 1 10)))
(1 2 3 4 5 6 7 8 9 10)
```
Когда достаточно использовать лексическую область видимости и catch/throw, когда необходимо учитывать динамическое состояние.
#### Условия, перезапуск
Система условий (conditions) в лиспе — это механизм для передачи сигналов между частями программы.
Одно из возможных применений — вызывать исключения и обрабатывать их, примерно так же, как это делается в Java или Python. Но, в отличие от других языков, во время передачи сигнала в лиспе стек *не разворачивается*, поэтому все данные сохраняются и обработчик сигнала может перезапустить программу начиная с любой точки в стеке.
Этот подход к обработке исключительных ситуаций позволяет улучшить разделение задач и добиться таким образом большей структурированности кода. Но такой механизм имеет более широкую область применения, как системы передачи произволных сообщений (а не только ошибок) между частями программы.
Пример использования системы условий можно увидеть в статье [Common Lisp: A Tutorial on Conditions and Restarts](http://web.archive.org/web/20110724195120/http://chaitanyagupta.com/lisp/restarts.html).
#### Обобщённые функции
Объектная ситема Common Lisp (Common Lisp Object System, CLOS) не привязывает методы к классам, а позволяет использовать обобщённые функции.
Обобщённые функции задают сигнатуры, которым могут удовлетворять несколько различных методов. При вызове выбирается метод, который лучше всего соответствует аргументам.
Здесь мы определяем обобщённую функцию, которая обрабатывает события от клавиатуры:
```
(defgeneric key-input (key-name))
```
Затем определяем несколько методов, которые удовлетворяют различным значениям KEY-NAME.
```
(defmethod key-input (key-name)
;; Default case
(format nil "No keybinding for ~a" key-name))
(defmethod key-input ((key-name (eql :escape)))
(format nil "Escape key pressed"))
(defmethod key-input ((key-name (eql :space)))
(format nil "Space key pressed"))
```
Посмотрим на вызов методов в действии:
```
> (key-input :space)
"Space key pressed"
> (key-input :return)
"No keybinding for RETURN"
> (defmethod key-input ((key-name (eql :return)))
(format nil "Return key pressed"))
> (key-input :return)
"Return key pressed"
```
Мы обошлись без конструкций а-ля switch и явной работы с таблицей методов. Таким образом, мы можем добавлять обработку новых частных случаев независимо, динамически, по мере надобности и вообще в любой точке программы. Это, в частности, обеспечивает развитие программ на лиспе «снизу-вверх».
Обобщённые функции определяют некоторые общие характеристики группы методов. Скажем, способы комбинации методов, опции специализации и другие свойства могут задаваться обобщённой функцией.
Лисп предоставляет многие полезные стандартные обобщённые функции; примером может служить PRINT-OBJECT, которая может быть специализирована для любого класса, чтобы задать его текстовое представление.
#### Комбинации методов
Комбинации методов позволяют при вызове какого-либо метода выполнить целую *цепочку* методов, либо в некотором порядке, либо так, чтобы одни функции обрабатывали результаты других.
Есть встроенные способы комбинации методов, которые выстраивают методы в заданном порядке. Методы, снабжённые ключевыми словами :before, :after или :around помещаются в соответствующее место в цепочке вызовов.
Например, в предыдущем примере каждый из методов KEY-INPUT повторяет вывод фразы «key pressed». Мы можем улучшить код при помощи комбинации типа :around
```
(defmethod key-input :around (key-name)
(format nil "~:(~a~) key pressed"
(call-next-method key-name)))
```
После этого мы заново определим методы KEY-INPUT, в каждом из них указав лишь одну строку:
```
(defmethod key-input ((key-name (eql :escape)))
"escape")
```
При вызове KEY-INPUT происходит следующее:
* вызывается метод с меткой :around
* он вызывает следующий метод, то есть одну из специализированных версий KEY-INPUT,
* которая возвращает строку, и эту строку форматирует метод с :around.
Надо заметить, что вариант по умолчанию можно обработать по-разному. Мы можем просто использовать пару THROW/CATCH (более продвинутая реализация могла бы использовать условия):
```
(defmethod key-input (key-name)
(throw :default
(format nil "No keybinding for ~a" key-name)))
(defmethod key-input :around (key-name)
(catch :default
(format nil "~:(~a~) key pressed"
(call-next-method key-name))))
```
В результате, встроенный способ комбинации методов позволяет нам обобщить обработку событий от клавиатуры в модульный, расширяемый, легко изменяемый механизм. Эта техника может быть дополнена при помощи определяемых пользователем способов комбинации; скажем, можно добавить способ комбинации, который будет выполнять суммирование или сортировку результатов методов.
#### Множественное наследование
Любой класс может иметь много предков, что позволяет создавать более богатые модели и достигать более эффективного повторного использования кода. Поведение дочерних классов определяется в соответствии с порядком следования, который строится по определениям классов-предков.
При помощи комбинаций методов, метаобъектного протокола и других особенностей CLOS можно обходить традиционные проблемы множественного наследования (такие как fork-join).
#### Метаобъектный протокол
Метаобъектный протокол (Meta-object protocol, MOP) — это программный интерфейс к CLOS, который сам реализован при помощи CLOS. MOP даёт программистам возможность исследовать, использовать и модифицировать внутреннее устройство CLOS через сам CLOS.
#### Классы как сущности первого класса
Сами классы также являются объектами. При помощи MOP можно изменять определение и поведение классов.
Пусть класс FOO является потомком класса BAR, тогда мы можем при помощи функции ENSURE-CLASS добавить, скажем, класс BAZ к списку предков FOO:
```
(defclass bar () ())
(defclass foo (bar) ())
(defclass baz () ())
```
```
> (class-direct-superclasses (find-class 'foo))
(#)
> (ensure-class 'foo :direct-superclasses '(bar baz))
#
> (class-direct-superclasses (find-class 'foo))
(# #)
```
Мы использовали функцию CLASS-DIRECT-SUPERCLASSES, чтобы получить информацию о предках класса; в данном случае она принимает в качестве аргумента класс в виде объекта, полученного от FIND-CLASS.
Приведённый пример иллюстрирует механизм, при помощи которого классы могут модифицироваться во время выполнения программы, что позволяет, кроме всего прочего, динамически добавлять в классы примеси (mixins).
#### Динамические переопределения
Лисп представляет собой очень интерактивную и динамическую среду. Функции, макросы, классы, пакеты, параметры и объекты могут быть переопределены практически в любое время, и при этом результат будет адекватен и предсказуем.
Так, если вы переопределили класс во время выполнения программы, изменения немедленно будут применены ко всем объектам и подклассам данного класса. Мы можем определить класс BALL со свойством radius и его подкласс TENNIS-BALL:
```
> (defclass ball ()
((%radius :initform 10 :accessor radius)))
#
> (defclass tennis-ball (ball) ())
#
```
Вот объект класса TENNIS-BALL, у него есть слот для свойства radius:
```
> (defvar *my-ball* (make-instance 'tennis-ball))
*MY-BALL*
> (radius *my-ball*)
10
```
А теперь мы можем переопределить класс BALL, добавив в него ещё один слот volume:
```
> (defclass ball ()
((%radius :initform 10 :accessor radius)
(%volume :initform (* 4/3 pi 1e3)
:accessor volume)))
#
```
И \*MY-BALL\* автоматически обновился, получив новый слот, который был определён в классе-предке.
```
> (volume *my-ball*)
4188.790204786391d0
```
#### Доступ к компилятору во время выполнения программы
Благодаря функциям COMPILE и COMPILE-FILE компилятор лиспа можно напрямую использовать из выполняемой программы. Таким образом, функции, которые создаются или изменяются во время работы программы, также могут скомпилированы.
Выходит, программы можно компилировать поэтапно, что делает разработку интерактивной, динамической и быстрой. Запускаемые программы могут изменяться, отлаживаться и расти постепенно.
#### Макросы компиляции
Макросы компиляции определяют альтернативные стратегии для компиляции функции или макроса. В отличие от обычных макросов, макрос компиляции не расширяет синтаксис языка и может быть применён только во время компиляции. Поэтому они в основном используются для того, чтобы определить способы оптимизации кода отдельно от самого кода.
#### Определения типов
Хотя лисп и является динамически типизированным языком — что довольно удобно при быстром прототипировании — программист может явно указать типы переменных. Это, а также другие директивы, позволяют компилятору оптимизировать код, как будто бы язык был статически типизированным.
Например, мы можем определить типы параметров в нашей функции EXPLODE, вот так:
```
(defun explode (string &optional (delimiter #\Space))
(declare (type character delimiter)
(type string string))
...)
```
#### Программируемый парсер
Парсер лиспа позволяет легко разбирать входные данные. Он получает текст из входного потока и создаёт лисповские объекты, которые обычно называют S-выражениями. Это очень сильно упрощает разбор входных данных.
Парсер можно использовать посредством нескольких функций, таких как READ, READ-CHAR, READ-LINE, READ-FROM-STRING и т.д. Входной поток может быть файлом, вводом с клавиатуры и так далее, но, кроме того, мы можем читать данные из строк или последовательностей символов при помощи соответствующих функций.
Вот простейший пример чтения при помощи READ-FROM-STRING, который создаёт объект (400 500 600), то есть список, из строки "(400 500 600)".
```
> (read-from-string "(400 500 600)")
(400 500 600)
13
> (type-of (read-from-string "t"))
BOOLEAN
```
**Макросы чтения** (reader macros) позволяют определить специальную семантику для заданного синтаксиса. Это возможно потому, что парсер лиспа является программируемым. Макросы чтения — это ещё один способ расширить синтаксис языка (они обычно используются, чтобы добавить синтаксический сахар).
Некоторые стандартные макросы чтения:
* #'foo — функции,
* #\\ — символы (characters),
* #c(4 3) — комплексные числа,
* #p"/path/" — пути к файлам.
Парсер может сгенерировать любой объект, для которого определены правила чтения; в частности, эти правила можно задать при помощи макросов чтения. На самом деле парсер, о котором идёт речь, используется и для интерактивных интерпретаторов (read-eval-print loop, REPL).
Вот так мы можем прочитать число в шестнадцатеричной записи при помощи стандартного макроса чтения:
```
> (read-from-string "#xBB")
187
```
#### Программируемая печать
Система текстового вывода в лиспе предоставляет возможности для печати структур, объектов или каких-либо ещё данных в разном виде.
PRINT-OBJECT — это встроенная обобщённая функция, которая принимает в качестве аргументов объект и поток, и соответствующий метод выводит в поток текстовое представление данного объекта. В любом случае, когда нужно текстовое представление объекта, используется эта функция, в том числе в FORMAT, PRINT и в REPL.
Рассмотрим класс JOURNEY:
```
(defclass journey ()
((%from :initarg :from :accessor from)
(%to :initarg :to :accessor to)
(%period :initarg :period :accessor period)
(%mode :initarg :mode :accessor mode)))
```
Если мы попытаемся распечатать объект класса JOURNEY, мы увидим нечто подобное:
```
> (defvar *journey*
(make-instance 'journey
:from "Christchurch" :to "Dunedin"
:period 20 :mode "bicycle"))
*JOURNEY*
> (format nil "~a" *journey*)
"#"
```
Можно определить метод PRINT-OBJECT для класса JOURNEY, и с его помощью задать какое-то текстовое представление объекта:
```
(defmethod print-object ((j journey) (s stream))
(format s "~A to ~A (~A hours) by ~A."
(from j) (to j) (period j) (mode j)))
```
Наш объект теперь будет использовать новое текстовое представление:
```
> (format nil "~a" *journey*)
"Christchurch to Dunedin (20 hours) by bicycle."
``` | https://habr.com/ru/post/143490/ | null | ru | null |
# Теоретические структуры данных и их применение в JavaScript. Ч1. Пары
> «Плохие программисты думают о коде. Хорошие программисты думают о структурах данных и их взаимосвязях», — Линус Торвальдс, создатель Linux.
Примем в качестве аксиомы, что очень часто решение любой задачи в программировании сводится к выбору правильной структуры данных. Данную аксиому можно доказать, но это долго и статья немного о другом. Сегодня мы поговорим об одной из самых простых теоретических структур, о паре.
Пара — это структура данных, которая хранит в себе два любых элемента данных, подразумевая, что мы хотим как-то логически объединить их в один. Она решает именно эту задачу, т.е. если некие элементы данных `а` и `b` нам нужно представить в виде `аb`, то мы можем реализовать эту конструкцию на паре.
Если вы думаете, что никогда не сталкивались или не столкнётесь с чем-то подобным, то это не так.
Вот самый простой пример вычисляемого свойства из документации VUE:
```
var vm = new Vue({
el: '#demo',
data: {
firstName: 'Foo',
lastName: 'Bar'
},
computed: {
fullName: function () {
return this.firstName + ' ' + this.lastName
}
}
})
```
С точки зрения теории `fullName` это пара. И таких примеров бесчисленное множество в технике и реальном мире, который мы зачастую моделируем программным кодом.
Вы можете справедливо заметить, что мы можем логически объединить любое количество элементов и будете правы. Это подводит нас к более сложной структурно концепции **составных данных**, одной из которых является **пара**. С составными данными разберёмся чуть позднее, сейчас сосредоточимся на паре.
Теория говорит нам, что пары обладают следующими свойствами:
* **имутабельность**, т.к. пара это не что-то существующее само по себе, а лишь объединённое представление двух других элементов данных, то менять её крайне нежелательно. Если есть необходимость поменять значение пары, то лучше создать новую(как в функциональном программировании в общем-то и положено. Тему имутабельности мы обсуждали в статье про основные идеи функционального программирования, когда говорили про [чистые функции](https://habr.com/ru/post/474702/))
* **пара должна предоставлять интерфейс для получения элементов из которых она состоит**. Этот пункт требует определённых пояснений. Мы создаём пару для логического объединения двух разных единиц данных. Геттеры нужны прежде всего для того, чтобы вызывающий код, который не знает изначальные данные, из которых была создана пара, но знает о паре, мог получить элементы составляющие пару.
Представим псевдокодом пару как объект:
```
pair = { a, b }
```
Если мы в вызывающем коде будем работать с парой напрямую в таком стиле: `pair.a`, то изменив реализацию пары будем вынуждены переписывать вызывающий код везде, где фигурирует обращение к паре. Это не здорово!
Пара это абстракция(пусть даже низкого уровня), поэтому неправильно было бы работать с её составляющими напрямую. Работая с составными частями любой абстракции, мы должны использовать интерфейс абстракции, иначе код превратится в хаос(сложнее станет его читать, проще допустить ошибку, но самое главное сложнее изменять, т.к. одно изменение придётся вносить в разных частях кода).
Пары можно реализовывать очень по разному. В любом языке программирования существует более чем одна возможность реализовать эту структуру данных.
Например, можно реализовать пару для произвольных типов данных:
```
//тут мы храним исходные значения в замыкании
//для нас не важен тип входных данных
const pair = (first, second) => (elementType) => {
switch(elementType) {
case 'first':
return first;
case 'second':
return second;
}
};
//у нас есть некий интерфейс, который позволяет нам работать с данными,
// из которых состоит пара
const getFirstElement = (pair) => (pair('first'));
const getSecondElement = (pair) => (pair('second'));
```
Такой способ работы называется отправкой сообщений. Как ни странно, но именно этот способ взаимодействия сущностей когда-то до С/С++ называли ООП.
Обязательно ли нам использовать конструкцию `switch` ? Разумеется, необязательно. Это детали технической реализации, а реализаций может быть великое множество!
Самое главное — сделать пару имутабельной!
Например, можно реализовать тот же самый функционал используя [Map](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Map)
```
//тут мы храним данные в мапе
//несмотря на это, тип исходных данных для нас не важен
const pair = (first, second) => (
new Map([
['first', first],
['second', second],
])
);
//и снова мы предоставляем интерфейс
const getFirst = (pair) => (pair.get('first'));
const getSecond = (pair) => (pair.get('second'));
```
Обратите внимание, что первую реализацию можно легко заменить на вторую. а вторую на первую! Вызывающий код не поменяется. Это и есть важное преимущество абстракций. Мы можем легко поменять реализацию абстракции в программе, но работающий с этой абстракцией код не узнает об этих изменениях. Нам не нужно будет править код, который работает с этими абстракциями, если мы захотим поменять реализацию самих абстракций. Это очень важно, т.к. экономит деньги заказчика и повышает премии разработчика.
Кстати, допустим, мы не знаем про существование Мапов в js, но умеем работать с объектами.
```
//снова для нас не важен тип исходных данных
//снова наша абстракция имутабельна
const pair = (first, second) => (
Object.freeze({
'first': first,
'second': second,
})
);
//снова у нас есть интерфейс, который позволяет работать с составляющими пару данными
const getFirst = (pair) => (pair.first);
const getSecond = (pair) => (pair.second);
```
Как легко догадаться обе предыдущие реализации также можно заменить на третью и от этого ничего не поменяется (*На самом деле, есть некоторое отличие. Мапы не выбрасывают исключения при попытке изменить свойства напрямую, а «замороженные объекты» бросают `TypeError: Cannot assign to read only property`. Однако, в контексте статьи это не важно.* ).
### Для чего знание теоретических структур данных может нам пригодится?
Если мы взглянем на работу программистом с «высоты птичьего полёта», то увидим, что по сути он занимается тем. что создаёт инструменты, которые манипулируют определёнными наборами данных. Следовательно, нам постоянно приходится подбирать для данных какую-то структуру хранения и придумывать способы работы с ними или придавать хаотичному набору данных определённую структуру. Понимание типовых структур данных позволяет нам владеть набором готовых решений для разных типовых задач и просто выбирать наиболее удобный в конкретной задаче способ.
Разберём пример:
«Реализуйте механизм работы с дробями. Дроби должны храниться в обыкновенном формате. т.е. в виде 1/2. Также необходимо реализовать базовые операции(сложение, вычитание, умножение, деление). Необходимо предусмотреть нормализацию.»
Давайте осмыслим условие задачи! Нам необходимо реализовать абстракцию для некоей математической сущности, поэтому разумно обратиться к [первоисточнику](https://ru.wikipedia.org/wiki/%D0%94%D1%80%D0%BE%D0%B1%D1%8C_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)). Конечно, если опытные программисты читают этот текст, то наверняка они сразу без прочтения статьи о дробях в математике представили себе решение в коде, но мы предположим. что мы слабо себе представляем, как работают дроби и проиллюстрируем весь ход рассуждений.
Материал из википедии говорит нам, что дроби бывают обыкновенные (1/4) и десятичные (0.1). Очевидно, что по условию задачи нам необходимо работать с дробями в обыкновенном формате представления.
Также мы видим, что обыкновенная дробь представляет собой **логическое объединение двух** чисел(числитель и знаменатель), это вернейший сигнал о необходимости использовать пару в качестве структуры данных для этой задачи.
В коде мы могли бы описать данную структуру так:
```
//в данном случае для нас важен тип передаваемых данных,
//но мы подразумеваем, что это всегда числа
//в любом случае проверку на тип разумно ставить в вызывающем коде,
// а не в самой абстракции
const makeRational = (num, denom) => (
new Map([
['num', num],
['denom', denom],
])
);
//как вы помните, нам необходимо реализовать гетеры
//для того чтобы код, который не знает о первоначальных данных, но знает о паре
//мог работать с её составляющими
const getNumer = (rat) => (rat.get('num'));
const getDenom = (rat) => (rat.get('denom'));
```
Далее нам следует разобрать ситуацию с дробями такого плана 8/4, 6/9. В условии задачи сказано о необходимости предусмотреть нормализацию. Нормализацией дроби называют вынесение из неё наибольшего общего делителя(НОД).
Реализуем функцию для поиска НОДдвух чисел:
```
//Gcd это абревиатура НОД на английском
const getGcd = (a, b) => ((a % b) ? getGcd(b, a % b) : Math.abs(b));
```
Если текст функции вам не понятен, то советую почитать про [рекурсию](https://habr.com/ru/post/480520/).
Чтобы нормализовать дробь нам необходимо разделить её числитель и знаменатель на НОД. Напишем функцию нормализации:
```
const normalize = (n1, n2) => {
const commonDivisor = getGcd(n1, n2);
return [n1 / commonDivisor, n2 / commonDivisor];
};
```
Логично было бы поместить нормализацию в конструктор makeRational, чтобы всегда нормализовать данные при создании дроби.
```
const makeRational = (num, denom) => {
const [normalizeNum, normalizeDenom] = normalize(num, denom);
return new Map([
['num', normalizeNum],
['denom', normalizeDenom],
]);
};
```
Далее поработаем над интерфейсом операций.
1) Сложение
Чтобы сложить две обыкновенные дроби, следует привести их к общему знаменателю. Затем сложить числители, а знаменатель оставить без изменений.
```
//т.к. нормализация у нас заложена в конструктор дроби,
//то первый пункт выполнится в момент конструирования результата,
//нам же остаётся передать в конструктор результат выполнения второго пункта
const add = (rat1, rat2) => (
makeRational(
getNumer(rat1) * getDenom(rat2) + getNumer(rat2) * getDenom(rat1),
getDenom(rat1) * getDenom(rat2),
));
```
2) Вычитание
Чтобы получить разность дробей, их также надо привести к общему знаменателю, а затем вычесть числители, знаменатель при этом оставить без изменений.
```
//тут ситуация идентичная со сложением
//первый шаг выполняется при конструировании результата
const sub = (rat1, rat2) => (
makeRational(
getNumer(rat1) * getDenom(rat2) - getNumer(rat2) * getDenom(rat1),
getDenom(rat1) * getDenom(rat2),
));
```
3) Умножение
Чтобы умножить две обыкновенные дроби, нужно перемножить их числители и знаменатели.
```
const multi = (rat1, rat2) => (
makeRational(
getNumer(rat1) * getNumer(rat2),
getDenom(rat1) * getDenom(rat2),
));
```
4) Деление
Чтобы поделить одну обыкновенную дробь на другую, нужно умножить первую дробь на дробь, обратную второй. Обратной называют дробь, у которой числитель равен знаменателю исходной, а знаменатель числителю исходной.
```
const div = (rat1, rat2) => (
makeRational(
getNumer(rat1) * getDenom(rat2),
getDenom(rat1) * getNumer(rat2),
));
```
Как видите, мы в каждой операции создаём новую сущность. Это следствие правила имутабельности. Замечу, что и в математике операции над числами не меняют исходное число, а создают новое: `1 + 2 = 3`.
Следует обратить внимание. что мы можем поменять реализацию `makeRational` на любую другую, но вызывающий код об этом не узнает и продолжит работать. Это следствие того, что мы правильно реализовали абстракцию и работаем с её составляющими через интерфейс, а не напрямую.
Также немаловажно, чтобы пользователь мог получить свои данные в привычном ему представлении, поэтому введём одну дополнительную функцию.
```
const ratToString = (rat) => `${getNumer(rat)}/${getDenom(rat)}`;
```
Приложу листинг тестов:
```
describe('normalize', () => {
test('should work', () => {
expect(normalize(21, 6)).toEqual([7, 2]);
expect(normalize(2, 3)).toEqual([2, 3]);
});
});
describe('rational', () => {
test('getters', () => {
const rat1 = makeRational(3, 9);
expect(getNumer(rat1)).toBe(1);
expect(getDenom(rat1)).toBe(3);
const rat3 = makeRational(-4, 16);
expect(getNumer(rat3)).toBe(-1);
expect(getDenom(rat3)).toBe(4);
});
test('add⊂', () => {
const rat1 = makeRational(3, 9);
const rat2 = makeRational(10, 3);
expect(add(rat1, rat2)).toEqual(makeRational(11, 3));
expect(sub(rat1, rat2)).toEqual(makeRational(-3, 1));
const rat4 = makeRational(12, 5);
const rat3 = makeRational(-4, 16);
expect(add(rat3, rat4)).toEqual(makeRational(43, 20));
expect(sub(rat3, rat4)).toEqual(makeRational(-53, 20));
const rat5 = makeRational(1, 15);
const rat6 = makeRational(4, 25);
expect(add(rat5, rat6)).toEqual(makeRational(17, 75));
expect(sub(rat5, rat6)).toEqual(makeRational(-7, 75));
});
test('multi÷', () => {
const rat1 = makeRational(1, 2);
const rat2 = makeRational(2, 3);
expect(multi(rat1, rat2)).toEqual(makeRational(2, 6));
const rat3 = makeRational(1, 3);
const rat4 = makeRational(1, 2);
expect(div(rat3, rat4)).toEqual(makeRational(2, 3));
});
test('ratToString', () => {
const rat1 = makeRational(3, 9);
const rat3 = makeRational(-4, 16);
expect(ratToString(rat1)).toBe('1/3');
expect(ratToString(rat3)).toBe('-1/4');
});
});
```
Заключение
----------
Текст получился довольно объёмным, но надеюсь, понятным. Подведём итоги:
1. Мы можем использовать структуру данных пара всегда, когда нам надо логически объединить два несвязанных между собой значения
2. Пара должна быть имутабельна
3. Пара должна предоставлять интерфейс для работы со своими составляющими
Заранее извиняюсь, если статья показалась кому-то перегруженной. Я в основном ориентируюсь на не очень опытных разработчиков, поэтому стараюсь писать так, чтобы логика моих рассуждений и выбор того или иного решения были предельно понятны.
Если статья окажется интересна сообществу. то направление **типовых структур данных** будет продолжено. Следующая тема — связанные списки. | https://habr.com/ru/post/493692/ | null | ru | null |
# DIY-метаданные: как мы собрали велосипед, который везет на себе технологические данные компании
Привет, Хабр! Меня зовут Ткачев Константин, и я работаю архитектором в Леруа Мерлен.
В этой статье я хочу рассказать, как мы смогли, используя только open-source, построить систему работы с метаданными, которая позволила:
* централизовать и унифицировать описания данных, используемых в компании;
* автоматизировать процессы загрузки данных в корпоративное хранилище — платформу данных;
* и сделать еще многое-многое другое…
А если добавить к этому, что мы сделали это быстро — и в итоге за пару месяцев получили работающую систему, то станет ясно, почему мы решили поделиться этим опытом с пользователями Хабра.
Что такое метаданные
--------------------
Если совсем коротко, то метаданные — это информация (данные) о другой информации. Метаданные могут описывать объекты базы данных, как, например, это выполняет [системный каталог PostgreSQL](https://www.postgresql.org/docs/current/catalogs.html), или процессы обработки данных ETL/ELT в виде направленного графа (DAG’а) [Airflow](https://airflow.apache.org/).
Важность метаданных в IT-системах чрезвычайно высока, поскольку без них поиск и использование нужной информации были бы весьма и весьма затруднительны.
Разработанная нами система управления метаданными оперирует, если так можно выразиться, технологическими метаданными, которые описывают:
* структуру источников центрального хранилища данных компании — платформу данных (платформа);
* различные STTM (Source To Target Mapping);
* настройки наших инструментов, например Airflow, который используется для загрузки данных в платформу (о работе нашего коммунального Airflow мы писали [тут](https://habr.com/ru/company/leroy_merlin/blog/580944/));
* права доступов к объектам платформы;
* описания DAG’ов Airflow, использующихся в одном из наших решений — [Marts Loader](https://habr.com/ru/company/leroy_merlin/blog/564276/);
* правила работы наших сервисов, например, условия партиционирования таблиц платформы данных для соответствующего сервиса.
Наши метаданные не только описывают данные, но и определяют потоки их обработки, а также настройки инструментов работы с данными в нашей компании.
С чего все началось
-------------------
В далеком 2019-м одним из направлений наших работ было построение платформы данных, к которой ваш покорный слуга имел самое непосредственное отношение. Мы определились с подходом и инструментарием, за исключением того, что у нас не была выбрана система управления метаданными и справочниками. В данной статье речь пойдет только о метаданных, так как о справочниках и всем, что с ними связано, напрашивается целый цикл статей)).
Поскольку нам необходимо было оперативно двигаться в отношении построения платформы и мы начинали интегрировать первые источники, отсутствие инструментария по работе с различными метаданными «несколько» сдерживало нас. Можно сказать, что, создавая платформу данных, мы не знали, что она будет в себе хранить и как в ней можно будет найти требуемую информацию. Необходимо было в краткие сроки найти подходящий инструмент. В число базовых требований были включены гибкость применения и расширение функциональных возможностей инструмента. Да, и мы, в рамках принятого подхода, рассматривали только open-source-инструменты.
Требования к системе управления метаданными
-------------------------------------------
Требования к системе управления метаданными включают:
* описание объектов и процессов информационных систем, причем не только платформы данных;
* описание различных настроек работы информационных систем;
* возможность предоставления метаданных через REST API;
* наличие инструмента по редактированию и просмотру метаданных с учетом прав доступа;
* возможность гибкой классификации и редактирования структуры метаданных;
* необходимость дополнительно обеспечить data lineage (забегая немного вперед, скажу, что мы это обеспечили хранением STTM, которые используются в наших процессах обработки данных);
* скорость разработки и применения инструмента управления метаданными;
* скорость освоения сотрудниками компании;
* простую интеграцию в CI/CD pipeline;
* обеспечение качества метаданных, на основе выработанных критериев;
* использование только собственных разработок или open-source-инструментов.
Рассматривали собственную разработку с хранением метаинформации в БД (планировали использовать PostgreSQL), но времени на разработку относительно гибкой структуры и пользовательского интерфейса не было, так как, повторю, начиналась интеграция источников.
Также мы рассмотрели применение следующих инструментов:
* [Hive metastore](https://hive.apache.org/)
* [Apache Atlas](https://atlas.apache.org/)
* [Amundsen](https://www.amundsen.io/)
**Hive** metastore заточен для описания таблиц в БД, включая наименования и типы столбцов, а также специфическую для HDFS информацию — партиции и бакеты. Мы же планировали не только описывать таблицы в БД, тем более что системный каталог платформы данных уже решал эту задачу.
**Atlas** предполагал слишком уж большой уровень абстракции, мы решили, что его применение, описание метаданных и поддержка будут сложны и нам, как внедренцам, и пользователям.
**Amundsen** неплох: имеет приятный интерфейс и развитые средства Data Discovery, использует Airflow для Data ingestion, [ElasticSearch](https://www.elastic.co/) для поиска данных и [Neo4J](https://neo4j.com/) или Atlas для хранения метаданных, API layer реализован с использованием [Flask](https://flask.palletsprojects.com/). В общем, он нам понравился, но все-таки его функционал ограничен (фактически ограничен предоставляемым UI) и он не отвечал многим из наших требований. Стоит отметить, что к исследованию Amundsen мы приступили, уже начав разработку собственного инструмента, и это окончательно повлияло на наше решение. Если перед вами стоит вопрос выбора инструмента управления метаданными, то можем порекомендовать обратить внимание на эту систему.
Жизнь не стоит на месте, появляются новые интересные инструменты для работы с метаданными. Мы пробуем использовать появившиеся возможности и сейчас мы тестируем такое средство как [Open Metadata](https://docs.open-metadata.org/). Пока у нас нет полного представления о всех его функциях, но вполне вероятно, что оно приживется в нашем стеке технологий))
DIY-путь
--------
Поскольку мы компания, работающая в сегменте DIY (Do It Yourself), то и на подходы в области IT-технологий философия компании влияет — разумеется, в хорошем смысле этого слова. Мы не сторонники изобретать велосипед, но у нас руки горят доработать этот самый велосипед, чтобы он максимально соответствовал целям, ради которых мы его используем. Ну и, конечно, добавить немного индивидуальности и привнести что-то свое и полезное — дополнительная мотивация для нас.
А если серьезно, то мы хотели в достаточно короткое время разработать систему, которая позволит удовлетворить наши потребности в области описания данных и, что немаловажно, их использования широкой аудиторией.
Так мы начали создавать свою систему по управлению метаданными, или **DIY-мету**.
Как все это работает (архитектура DIY-меты)
-------------------------------------------
Общая идея такова...
Метаданные мы решили хранить в виде файлов yaml. Почему? Этот формат читабелен и пользователям легко с ним работать.
Для хранения и изменения DIY-меты мы используем github. Пользователи выполняют изменения метаданных и формируют pull request (PR). Выбрав github, как систему хранения для DIY-меты, мы дополнительно получили ряд полезных и вкусных «плюшек»:
* использование в CI/CD pipeline (об этом подробнее позже);
* решение вопроса с авторизацией и аутентификацией, в том числе использование CODEOWNERS для ограничения изменений данных в GIT.
После изменений в виде PR стартует CI/CD pipeline, который выполняет тестирование, сборку и деплой контейнера Docker с сервисом метаданных на определенное окружение (в зависимости от того, в какую ветку был PR). В результате сборки контейнер содержит yaml-файлы с метаданным.
Доступ к DIY-мете для наших информационных систем и пользователей предоставляется посредством сервиса метаданных.
Структура хранения метаданных и соглашение по наименованию объектов
-------------------------------------------------------------------
Получилось, что в нашем случае метаданные — набор yaml-файлов и python-файлов, которые объединены в определенную структуру хранения.
Python-файлы содержат тесты пользователей, которые проверяются в рамках автотестов, о чем я расскажу ниже более подробно.
Однако простота и гибкость ведения DIY-меты могла обернуться полной неразберихой, поэтому мы задали определенные правила наименования, а также верхнеуровневую классификацию метаданных в виде структуры каталогов (папок). Таким образом, у нас появилось соглашение, которое определяет структуру хранения файлов и их наименования. При этом, поскольку мы храним DIY-мету как файлы в каталогах (как в файловой системе), мы сохраняем определенную гибкость по переопределению описания данных.
И еще, для некоторых типов файлов, структура которых должна быть четко определена, мы задали канонические схемы в виде json-схем. Эти схемы используются автотестами для проверки корректного описания данных. Например, такие схемы описывают таблицы, которые являются источниками для платформы данных, также схемы используются для задания мэппингов атрибутов объектов.
Ниже приведена структура метаданных, которую мы используем.
```
metadata(root)
|
├── metadata_repository_tests (for metadata tests: structure, naming, etc)
|
├── system_1 (e.g. dataplatform)
| |
| ├── processes
| | ├── base (base process)
| | | ├── ...
| | | └── data.yaml (types mapping, etc)
| | |
| | ├── technology process_1
| | | ├── ...
| | | └── data.yaml (types mapping, etc)
| | └── technology process_N
| | ├── ...
| | └── data.yaml (types mapping, etc)
| |
| ├── data (sources, destinations, etc)
| │ ├── data_name_1
| │ | ├── namespace_1 (!!!! If only necessary !!!)
| | | | ├── object_name_1
| │ | | | └── data.yaml
| │ | | ├── object_name_N
| │ | | | └── data.yaml
| | | | └── data.yaml
| | | └── data.yaml
| │ │
| │ ├── data_name_N
| │ | └── ...
| | |
| | └── data.yaml
| |
| ├── access
| │ ├── system_1(Greenplum)
| | | |
| │ | ├── data_name_1/namespace
| │ │ | └── data.yaml
| │ │ ├── ...
| | │ │
| | | └── data_name__N/namespace
| │ | └── data.yaml
| │ |
| │ ├── system_2 (NiFi)
| | ├── system_3 (S3)
| | └── system_N (Airflow)
| |
| ├── infrastructure
| | |
| | ├── airflow_<...>
| | └── ...
| |
| └── data.yaml (common information about system)
|
└── system_N
```
А ниже приведен пример шаблона описания таблицы базы данных, который является источником платформы данных. Для этого шаблона у нас определена каноническая схема в json.
```
object:
name:
key\_list:
-
-
confidentiality:
- confidential
- sensitive
attibutes:
- name:
type:
- name:
type:
...
```
CI/CD pipeline
--------------
Применить изменения и выкатить их на окружения нам помогает старина [Jenkins](https://www.jenkins.io/).
Понятно, что CI-часть у нас организована в github. При PR происходят достаточно стандартные действия: на Jenkins’е клонируется репозиторий с DIY-метой (в том числе с Jenkinsfile), а затем запускается процесс, определенный в Jenkinsfile, который тестирует изменения, собирает Docker-контейнер с DIY-метой и деплоит его на нужное окружение в зависимости от ветки GIT, в которую были внесены изменения.
Для старта CD pipleline в github настроены webhooks на наш сервер Jenkins, а он знает URL репозитория DIY-меты в github, по которому расположен в том числе Jenkinsfile, содержащий инструкции для исполнения. Базовый образ Docker’а, использующийся для создания контейнера, получаем из нашего [Artifactory](https://jfrog.com/), пароли получаем из [Vault](https://www.vaultproject.io/) и сохраняем их в переменных окружения.
В процесс деплоя мы внесли ограничения по изменению на ПРОД-окружении. Для изменений в **master**-ветке (и, соответственно, на ПРОД-окружении сервиса метаданных) пользователям нужен approve их PR от CODEOWNERS, для изменения в dev- или test-ветке (ДЕВ- или ТЕСТ-окружение сервиса) approve не нужен.
Сервис метаданных
-----------------
Итак, как я уже сказал выше, сервис метаданных — Docker-контейнер, который содержит сами метаданные и предоставляет API для доступа к DIY-мете. Доступ есть только на чтение. Сервис развернут на окружениях, которые соответствуют веткам в GIT: ДЕВ-окружение сервиса использует **dev**-ветку, ПРОД-окружение использует ветку **master**.
Первая версия сервиса была реализована на [Flask](https://flask.palletsprojects.com/), так как нам был нужен быстрый результат. Позднее, по мере развития работы сервиса, мы портировали его на Go, что повысило производительность и надежность, а также стабилизировали процесс деплоя сервиса.
Автотесты
---------
Поскольку метаданные — особо важные данные, то после их изменения мы выполняем проверки, связанные с содержанием изменений. Автотесты существенно упрощают code-review и экономят нам время, что позволяет сфокусироваться на новых DIY — инструментах и сервисах)))
Поскольку сама DIY-мета хранится в GIT’е, то проверке подвергаются только измененные/добавленные метаданные (***git diff*** нам в помощь). Проверок несколько, приведу основные:
* соответствие соглашению о наименовании файлов и папок DIY-меты;
* соответствие определенных файлов заранее заданной канонической схеме;
* yaml-линтер проверяет на соответствие формату;
* поскольку мы предоставили разработчикам возможность писать собственные тесты, которые запускаются при тестировании изменений, то дополнительно проверяем тесты разработчиков на наличие команд, которые могут потенциально удалить или изменить как метаданные, так и данные.
Надо сказать, автотесты можно использовать также и локально (на машинах разработчиков), и, что примечательно, автотесты работают на разных платформах (Windows, Linux).
Schema evolution
----------------
Дополнительно мы определили требования к процессу изменения структуры данных и конкретные инструкции, которым необходимо следовать при такого рода изменениях. В числе прочего коснулись, например, следующих вопросов:
* использование значений по умолчанию для атрибутов/полей объектов данных, что обеспечивает обратную совместимость;
* изменение существующих атрибутов/полей (наименование, тип); такие изменения выполняются путем добавления новых полей; поскольку в конечном итоге данные попадают в таблицы Платформы, такой подход позволяет сохранять историю;
* требования и рекомендации по использованию данных после изменения структуры.
Вместо заключения
-----------------
В настоящее время результаты наших усилий по созданию DIY-меты пользуются популярностью, что не может нас не радовать.
Так получилось, что все системы и сервисы, которые выполняют обработку данных в интересах платформы и автоматизируют процессы интеграции и предоставления доступа, пользуются DIY-метой: это и Airflow, и Marts Loader, и все процессинги обработки данных. Да, мы разрабатываем системы, которые позволяют автоматизировать процессы интеграции в платформу и ускорить их до нескольких дней, но это уже совсем другая история… | https://habr.com/ru/post/701448/ | null | ru | null |
# Dagaz: Подробности
***В «пи» цифр не пересчитать,
«е» — бесконечно столь же.
А если их с конца писать, какое будет больше?
Мартин Гарднер «Крестики-нолики»***
Для этой статьи, я хотел выбрать другой эпиграф, но счёл его излишне пафосным. Очередной [релиз](https://glukkazan.github.io/index.html) вновь затянулся. За это время, я успел сменить работу! Работа на новом месте отнимает уйму сил, но я продолжаю находить время для своего маленького увлечения. И надо сказать, то, с чем мне приходится сталкиваться в процессе, становится всё сложнее и сложнее. Я расскажу вам об этом. Я хотел начать с другого эпиграфа, но этот тоже неплох.
В этот раз, случились новые [манкалы](https://glukkazan.github.io/mancala/mancala.svg) и "[игры-переходы](https://skyruk.livejournal.com/tag/%D0%B8%D0%B3%D1%80%D1%8B-%D0%BF%D0%B5%D1%80%D0%B5%D1%85%D0%BE%D0%B4%D1%8B)" (это [Хальма](https://glukkazan.github.io/races/halma-10x10.htm) и её родственники). Своего рода гонки, в которых надо занять своими фигурами дом противника, раньше него. Фигуры (и свои и чужие) можно перепрыгивать (как в [шашках](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8)), но никаких взятий нет. Да что я вам объясняю? Наверняка, многие из вас в детстве играли в "[Уголки](https://glukkazan.github.io/races/halma-8x8.htm)".
[](https://glukkazan.github.io/races/halma-8x8.htm)
На первый взгляд, игра выглядит простой, но проблемы начались уже на уровне ядра. Помните, я [рассказывал](https://habr.com/post/335228/) о составных ходах? По многим причинам, их удобнее представлять именно составными — в виде единого целого, а не в виде последовательности частичных ходов. Это более удобно для AI, да и с точки зрения дизайна, существуют игры, описание которых в форме составных ходов выглядит гораздо естественнее. Но есть одна проблема.
В шашках, при выполнении составного хода, фигуры убираются с доски (возможно по завершении хода). В Уголках — можно прыгать через свои или противника фигуры до бесконечности. Буквально. И никакие расширения здесь не спасают, поскольку всё зацикливается не доходя до них, в ядре, ещё на этапе генерации списка ходов. Пришлось изменять эту логику, реализуя там опцию (**detect-loops**), о которой вполне стоило бы подумать заранее.
**С ботом всё тоже вышло непросто**Главная проблема, с этим семейством игр, заключается в том, что не так-то легко подобрать оценочную функцию, адекватно представляющую ситуацию на доске. Поскольку целью игры является достижение «дома» противника, можно оценивать суммарное расстояние от всех фигур до целевых полей ([манхэттенское](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D1%80%D0%BE%D0%B4%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D1%80%D1%82%D0%B0%D0%BB%D0%BE%D0%B2) или [евклидово](https://ru.wikipedia.org/wiki/%D0%95%D0%B2%D0%BA%D0%BB%D0%B8%D0%B4%D0%BE%D0%B2%D0%B0_%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D0%BA%D0%B0) — без разницы), но в Хальме, при удачном стечении обстоятельств, фигуры могут пропрыгать всю доску одним ходом, так что такая оценка мало что даёт.
С целевыми полями тоже не всё ясно. Нельзя направлять все фигуры на одно и то же поле. Первая фигура, которая до него доберётся тут же его и займёт. Идеально было бы определять оптимальные целевые поля для каждой из фигур и двигаться к ним, но это сложно, в вычислительном плане. Кроме того, ситуация на доске с каждым ходом меняется. В общем, я решил не заглядывать далеко вперёд и ограничиться чисто [эвристическим алгоритмом](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/heuristic-ai.js).
**С такой вот оценкой качества хода**
```
Dagaz.AI.heuristic = function(ai, design, board, move) {
var t = getTargets(design, board, board.player);
var m = getMove(move);
var r = 1;
if (m !== null) {
if (!design.inZone(0, board.player, m.start)) {
if (_.indexOf(t.first, m.end) >= 0) {
r = 1000 + getDistance(t.first, m.start) - getDistance(t.first, m.end);
}
if (_.indexOf(t.goal, m.end) >= 0) {
r = 700 + getDistance(t.first, m.start) - getDistance(t.first, m.end);
}
if ((r == 1) && (_.indexOf(t.second, m.end) >= 0)) {
r = 500 - getDistance(t.second, m.end);
}
}
if (r == 1) {
if (design.inZone(2, board.player, m.end) && !design.inZone(2, board.player, m.start)) {
r = 300;
}
}
if (bestFound(design, board, 300)) return -1;
if (r == 1) {
var goals = getGoals(design, board, board.player);
if (!_.isUndefined(goals[m.start])) {
var goal = goals[m.start];
if (m.next == goal.next) {
r = 100 + distance(goal.end, m.start) - distance(goal.end, m.end);
}
}
}
if (notBest(design, board, r)) return -1;
var b = board.apply(move);
if (isRestricted(design, b, board.player)) return -1;
}
return r;
}
```
Не идеальное решение, но для начала вполне рабочее. Если бот видит ход, которым можно «пропрыгать» в «дом» противника, он выбирает его. В противном случае — постепенно уменьшает расстояние до цели, стараясь избегать заторов. Самая печальная ситуация может случиться если один игрок (случайно или умышленно) оставит свою фигуру в «доме», а другой — «запрёт» её двойным рядом своих фигур.
**Конечно, вероятность такой ситуации довольно низка**Благодаря правилу, предложенному Сидни Сэксоном — изобретателем и коллекционером игр из Нью Йорка. Его предложение заключается в следующем: если фигура имеет возможность покинуть свой «дом», прыжком через фигуру противника или цепочкой прыжков, начинающейся с такого хода — она обязана это сделать. Я опробовал различные варианты правил, исключающих возможность запирания фигур в их собственном «доме» и нашёл правило Сидни Сэксона наиболее удачным. После выхода из своего «дома», фигура более не может в него возвращаться (хотя и имеет право проходить через него, в процессе выполнения хода).
На всякий случай, я запрещаю ходы «запирающие» противника (при отсутствии просмотра на много ходов вперёд, можно позволить себе довольно сложные эвристики), устанавливая им отрицательные оценки, но не менее опасна для бота и ситуация «запирания» пустых целевых полей (особенно это заметно в [классической Хальме](https://glukkazan.github.io/races/halma-10x10.htm), с её чисто ортогональными ходами). В общем, этому боту есть куда расти.
В играх, где фигуры разрешается брать, всё ещё более усложняется. И таких игр много! Пожалуй, наиболее известной из них является "[Камелот](https://glukkazan.github.io/checkers-like/camelot.htm)", придуманный Джорджем Паркером в 1930 году. Но лично мне куда больше нравится гораздо менее известная игра, построенная на основе той же механики.
[](https://glukkazan.github.io/checkers-like/suff.htm)
Эта [игра](https://glukkazan.github.io/checkers-like/suff.htm) — сама история! В далёком 1908 году, Суфражистки придумали её для продвижения своих политических взглядов. Здесь есть всё: Палата общин, [Альберт-холл](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D0%B1%D0%B5%D1%80%D1%82-%D1%85%D0%BE%D0%BB%D0%BB), городская тюрьма и больница. Женщины-[суфражистки](https://ru.wikipedia.org/wiki/%D0%A1%D1%83%D1%84%D1%80%D0%B0%D0%B6%D0%B8%D1%81%D1%82%D0%BA%D0%B8) сражаются с полисменами. Их цель — провести 6 своих человек в Палату общин. В свой штаб — Альберт-холл они заходить не могут. Перемещаются фигуры в любом направлении. Также допускаются прыжки через дружеские и вражеские фигуры.
Серия прыжков, при этом, может быть сколь угодно длинной. Если дело происходит на «арене», вражеские фигуры, при прыжке через них, срубаются и отправляются в тюрьму или больницу. Обычные фигуры рубят только по диагонали, крупные (констебли и лидеры суфражисток) — в любом направлении. Когда в тюрьме и больнице набирается по 6 фигур, их можно «обменять», снова введя в игру. Таким образом, фигуры, как в "[Сёги](https://glukkazan.github.io/shogi/shogi-board.htm)" или "[Столбовых шашках](https://glukkazan.github.io/checkers/column-checkers.htm)", никогда не покидают игру.
Вообще, весь этот релиз как раз на тему подобных опций. Например, я наконец-то осилил правильное превращение фигур в [Шахматах](https://glukkazan.github.io/checkmate/chess.htm) (до сих пор, все пешки превращались только в ферзей, что вообще говоря, неправильно). Я не стал сильно с этим заморачиваться и отрисовал диалог выбора прямо на канвасе. Получилось неплохо (ещё бы руки дошли сделать так, чтобы они мат от пата отличали, так было бы вообще замечательно).
[](https://glukkazan.github.io/checkmate/gardner-chess.htm)
Другая «ядерная» доработка была связана с улучшением пользовательского интерфейса и имеет свою предысторию. В проекте уже довольно давно существует [механизм](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/model/common-setup-v2.js), позволяющий кодировать текущую позицию, передавая её через URL. С учётом того, что описания всех состояний игры, в этом формате, записываются в лог, он неплохо помогает в отладке. Вот только пользователю, знать ничего не знающему про лог браузера, пользы от него мало.
**Нет-нет, это не вся польза!**Существует целый ряд игр, игровой процесс которых состоит из множества (возможно разнородных) этапов. В качестве примера, можно привести популярную игру 2008-го года — [Kamisado](https://glukkazan.github.io/breakthrough/kamisado.htm). Каждый этап этой игры (до прохождения одной из фигур на последнюю горизонталь) относительно короткий, но по его завершении, игра продолжается. Игроки, по оговоренным правилам, вновь расставляют свои фигуры на первой линии и снова пытаются достичь последней горизонтали раньше противника (фигура, принесшая победу в предыдущем этапе получает новые способности).
[](https://glukkazan.github.io/breakthrough/kamisado.htm)
Именно этот аспект игры автоматизирует опция "**progressive-levels**", выполняющая автоматический переход к следующему этапу игры, при победе одного из игроков. А поскольку начальная расстановка фигур от одного этапа к другому различается, она вычисляется модулем [common-setup](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/model/common-setup-v2.js) и передаётся в следующий этап игры через [URL](https://ru.wikipedia.org/wiki/URL).
[](https://glukkazan.github.io/custodian/reversi.htm)
Рука об руку с этой возможностью идёт другой способ, позволяющий разнообразить начальную расстановку фигур. Опция "**selector**" позволяет кодировать несколько начальных расстановок (и даже конфигураций доски), в рамках одного [JS-файла](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/other-games/reversi.js). Обновите начальную страницу [Reversi](https://glukkazan.github.io/custodian/reversi.htm) и вы поймёте, что я имею в виду.
Новый подключаемый [модуль](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/utils/session-manager.js) призван решить проблему. Конструктивно — это обычное дерево, в котором сохраняются все игровые состояния, фигурировавшие когда либо в игровой сессии (а поскольку это дерево, в перспективе, всю историю игры можно будет выгружать в [SGF](https://ru.wikipedia.org/wiki/Smart_Game_Format)-файл). Пользователь имеет возможность «листать» эти состояния, используя кнопки, появляющиеся вверху экрана.
[](https://glukkazan.github.io/checkers/russian-checkers.htm)
Это действительно удобно, но из двух стрелочек, занимающих место наверху, можно извлечь ещё больше пользы. Именно этим и занимается опция "**advisor-mode**". Если пользователь думает дольше заданного времени, бот, с которым он играет, рассчитывает ход за него и помещает новое игровое состояние в «session-manager». Предложенный ход можно принять, просто нажав кнопку «вперёд». А если ход не понравится, то его всегда можно откатить.
Много радости, в процессе разработки, принёс звук (казалось бы, чего уж проще). Первая [реализация](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/utils/sound-manager.js) оказалась слишком наивной. Не знаю с чем это связано, но где-то посредине игры, звук просто переставал проигрываться, без каких либо сообщений в логе. Это проявлялось во всех имеющихся у меня браузерах, пока я не стал кэшировать созданные объекты Sound в памяти. Но тут пришла другая беда.
Если звук проигрывался продолжительный, а бот соображал достаточно быстро (как в [манкалах](https://glukkazan.github.io/mancala/ohojichi-2x6.htm), например), то звук его хода просто «проглатывался», что выглядело крайне неприятно. Здесь шаманить пришлось долго и дело кончилось [костылями](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/utils/sound-manager-v2.js). При установленном флаге «clonable», я всё таки создаю несколько экземпляров Sound, по одному на каждого игрока (пусть и проигрывают они один и тот же звук). Конечно, это никак не помогло с IE, отказывавшимся (очевидно, по религиозным соображениям) иметь дело как с «wav», так и с «ogg» файлами. Этот браузер, у меня, работает бесшумно!
В остальном, релиз прошёл без приключений. Компанию "[Хальме](https://glukkazan.github.io/races/halma.htm)" и [манкалам](https://glukkazan.github.io/mancala/mancala.svg) составили пара [игр](https://glukkazan.github.io/checkmate/anti-king.htm) [шахматных](https://glukkazan.github.io/checkmate/neutral-king.htm), а [также](https://glukkazan.github.io/shogi/rocket-shogi.htm) [великое](https://glukkazan.github.io/shogi/leshogi.htm) [множество](https://glukkazan.github.io/shogi/ikusa-shogi.htm) [вариаций](https://glukkazan.github.io/shogi/treasure-shogi.htm) [Сёги](https://glukkazan.github.io/shogi/hex-kyoto-shogi.htm), вычитанных мной в очередном номере "[Il fogliaccio degli astratti](http://www.tavolando.net/FdA.html)" и ещё одна простенькая [игра](https://glukkazan.github.io/stalemate/rhombic-chess-variant.htm) от китайских товарищей. Ах да, вот ещё что:
[](https://glukkazan.github.io/elimination/find-pair.htm)
Просто небольшой тренажёр кратковременной памяти. Надо открывать одинаковые пары (дама с дамой, король с королём и т.п.) одинакового цвета. За это даются очки и на всё про всё 200 кликов. Поскольку к очкам начисляются бонусы (за чередование красной и чёрной масти, например), можно посоревноваться с друзьями на предмет того, у кого память лучше. Дерзайте!
***И всех с Наступающим Новым Годом!*** | https://habr.com/ru/post/429494/ | null | ru | null |
# Проектирование синхронных схем. Быстрый старт с Verilog HDL
 На просторах рунета можно найти достаточно много статей с введением в Verilog HDL. Все они описывают синтаксис и семантику языка, но, к сожалению, не раскрывают основных парадигм, используемых при проектировании цифровых схем. Представьте себе, что вам объясняют синтаксис языка Java, но не рассказывают ничего про объектно-ориентированное проектирование. Если вы знакомы с ООП, то такого введения будет достаточно, но если вы знаете только Си, то писать скорей всего будете “по-старому”, создавая огромные классы со сложными методами.
Примерно так происходит с программистами, изучающими цифровую схемотехнику и языки описания аппаратуры. Быстро разобравшись с несложным синтаксисом языка, они начинают описывать конструкции, безумные с точки зрения хардверного инженера. Среди моих студентов встречались люди, написавшие “сортировку пузырьком” за такт, сумасшедшие асинхронные схемы, которые работали по-разному при каждом запуске и разной погоде за окном, огромные комбинационные делители, уводившие place&route в глубокую многочасовую задумчивость.
Для тех, у которых нет времени прочитать учебник для начинающих, но есть желание или
необходимость спроектировать несколько простых схем я решил написать это небольшое введение об основной современной парадигме проектирования цифровых схем – синхронных схемах. И об одном из языков, используемых для их описания.
Статья рассчитана на новичков. Для понимания текста потребуется минимальный набор знаний – понимание работы синхронного D-триггера и вентилей.
#### Синхронные схемы
**Синхронные цифровые схемы** состоят из комбинационных вентилей(gates), цепей (nets) и триггеров (flip-flops). В синхронной схеме есть единственный сигнал синхронизации, который управляет всеми элементами памяти (триггерами).
Формально, синхронную схему можно определить следующим образом:
Синхронная схема — это цифровая схема **C** состоящая из вентилей, триггеров и цепей распространения сигналов, которая удовлетворяет следующим условиям:
* В схеме существует единственная цепь **clk**, по которой распространяется сигнал синхронизации (тактовый сигнал, clock signal)
* Сигнал **clk** управляется входным портом схемы.
* Множество портов, управляемых сигналом **clk**, эквивалентно множеству входов синхронизации триггеров
* Определим схему **C’** следующим образом: Схема **C’** получается из схемы **C** путем: (1) удаления цепи **clk**, (2) удаления входного порта, управляющего сигналом **clk**, (3) заменой всех триггеров на выходной порт (вместо входа D) и входной порт (вместо выхода Q). Полученная схема **C’** должна быть комбинационной
Пример синхронной схемы показан на рисунке:
А вот несколько примеров схем, не являющихся синхронными:
Практически все существующие цифровые схемы являются синхронными, либо состоят из нескольких синхронных схем, взаимодействующих через асинхронные каналы. Причина популярности синхронных схем — в простоте анализа времени распространения сигналов. Временной анализ (англ. Timing analysis) — тема для отдельной статьи, но кратко коснуться этого вопроса все-таки надо.
Рассмотрим следующую схему, реализующую функцию R = A+B+1:
Регистры A, B и R сохраняют значения на входах D по переднему фронту сигнала синхронизации (clk), т.е. в тот момент времени, когда значение clk изменяется из 0 в 1.
Сигналы распространяются через сумматоры (и другие комбинационные элементы) не мгновенно, а с задержкой, зависящей от длины самого большого пути из вентилей (критического пути), т.е. от сложности элемента. К примеру, критический путь в сумматоре будет проходить через сигналы переноса в старший разряд (представьте себе вычисление суммы “столбиком”).
Предположим, что сначала во всех регистрах был записан 0. А на входы in0, in1 сначала подаются значения 1 и 4, а потом 2 и 1. Тогда временная диаграмма для нашей схемы может выглядеть следующим образом:
По первому фронту clk значения 1 и 4 будут записаны в регистры A и B. После того как сигнал распространится через сумматоры, значение результата 1 + 4 + 1 = 6 появится на проводе t1. Затем, по второму фронту clk результат будет записан в регистр R, а новые входные значения в регистры A и B.
Теперь представим, что период сигнала clk уменьшился в два раза. Тогда второй фронт сигнала clk появится на регистре R до того, как на t1 появятся правильные данные. Т.е. схема будет работать неверно!
Отсюда следует основное правило корректности работы синхронной схемы:
**Задержка через критический путь в схеме должна быть меньше периода сигнала синхронизации.**
Под критическим путем понимается самый длинный путь в схеме, от выхода до входа регистра. Из этого правила выводится следствие, которое характеризует один из самых больших недостатков синхронных схем:
**Синхронная схема работает на частоте, определяемой критическим путем в схеме.**
Представьте, что в схеме тысячи комбинационных путей с задержкой в 1 наносекунду. И один путь с задержкой в 2 наносекунды. Из-за этого единственного пути схема должна тактироватся на частоте в 500 МГц, хотя могла бы работать на гигагерце. Поэтому, при проектировании синхронных схем длинные комбинационные цепочки разбивают регистрами на конвейерные стадии. К примеру, в процессоре AMD Bulldozer средняя длина комбинационного пути – 12-14 FO4 эквивалентных вентилей (задержка, эквивалентная инвертору единичного размера, нагруженному 4-мя инверторами).
Несмотря на этот недостаток, синхронные схемы стали очень популярны. Синхронные схемы без труда поддаются автоматическому временному анализу, т.е. частота, на которой схема может корректно работать, определяется программой (временным анализатором) автоматически. Когда разработчик может отстраниться от этих деталей, синхронную схему можно специфицировать набором пересылок между регистрами. Такой подход к описанию схем – Register Transfer Logic (RTL) стал мэйнстримом в описании логики работы цифровых схем. К примеру, схему из нашего примера можно описать следующими пересылками:
`A = in0
B = in1
R = A+B+1`
На каждом такте в регистр А записывается in0, в регистр B записывается in1, а в регистр R значение A + B + 1. Идея описывать схемы на RTL в виде текста лежит в основе языков описания аппаратуры: Verilog HLD и VHDL. Пришло время познакомиться с одним из них поближе.
#### Описание синхронных схем на Verilog HDL
##### Модули
Программа на Verilog, она же описание схемы, состоит из модулей (module), точнее из экземпляров модулей (module instances). Модуль можно представить как “черный ящик” с торчащими из него проводами — портами (ports). Порты бывают трех типов: входные (input), выходные (output) и двунаправленные (inout). В большинстве случаев используются первые два типа портов. Двунаправленные порты нужны для моделирования двунаправленных шин, на базе выходов с тремя состояниями и открытым стоком. Их мы рассматривать не будем.
Список портов описывается в заголовке модуля. К примеру, рассмотрим этот пустой модуль:
`**module** blackbox // module - ключевое слово, blackbox - имя модуля
(
**input** a, b, c // входные порты a,b,c
**input** [7:0] bus, // входной порт bus - 8-разрядная шина
**output** [7:0] bus_out // выходной порт bus_out, также 8-разрядный
);
// Здесь добавляется тело модуля
**endmodule** // endmodule - конец описания модуля, ключевое слово`
В теле модуля описывается его функциональность. Этот модуль пустой, его порты никуда не подключены. Перед тем как перейти к описанию функциональности модулей, познакомимся с основными типами данных в Verilog.
##### Типы данных
В Verilog существуют два класса типов: типы для моделирования аппаратуры и стандартные арифметические типы данных, скопированные из языка Си. Мы будем рассматривать только первый из классов, т.к. именно он используется для моделирования сигналов в схеме.
В Verilog сигнал может принимать 4 значения:
* 0 – логический ноль, или ложь
* 1 – логическая единица, или истина
* x – неопределенное значение. К примеру, значение регистра в начальный момент симуляции (до сброса или первой записи в регистр)
* z – состояние с высоким импедансом. Чаще всего сигнал принимает это значение, если он никуда не подключен – “обрыв провода”
В большинстве модулей на Verilog используются 2 основных типа данных – **wire** и **reg**. Из названия может показаться, что **wire** моделирует провод, а **reg** – регистр, но, как будет показано далее, это не совсем так. Наличие двух типов это скорее баг в дизайне языка, в SystemVerilog – современной версии Verilog, есть универсальный тип **logic**, который может использоваться во всех случаях.
Рассмотрим каждый из типов по отдельности.
**Wires**
Тип **wire** служит для моделирования сигналов, которые не могут “хранить” состояние. К примеру, значение на выходе комбинационной схемы полностью определяется значениями на входах. Если значения на входе меняются, меняется и значение на выходе, т.е. состояние не хранится. Тип **wire** используется вместе с операцией непрерывного присваивания — **assign**. При непрерывном присваивании, всякий раз когда меняется значение переменных в правой части присваивания, обновляется значение переменной в левой части. К примеру, простую комбинационную схему можно описать следующим образом:
`**module** comb
(
**input** wire [7:0] a,b,
**output** [7:0] res // тип wire устанавливается по-умолчанию, но можно написать output wire [7:0] res
);
**assign** res = a+b+1;
**endmodule**`
Сигналы можно объявлять и внутри тела модуля:
`**module** comb
(
**input** wire [7:0] a,b,
**output** [7:0] res
);
**wire** [3:0] x,y;
**assign** x = a[3:0] + b[3:0]; // складываются 4 младших разряда на шинах а и b
**assign** y = a[7:4] + b[7:4]; // складываются 4 старших разряда на шинах а и b
**assign** res = x+y;
**endmodule**`
**Regs**
Тип **reg** может хранить значение и используется в процедурных блоках. Процедурный блок в Verilog – процедура, срабатывающая по определенному событию. К примеру, этим событием может быть фронт тактового сигнала или начало симуляции. В процедурных блоках могут использоваться Си-подобные управляющие конструкции:
* if… else..
* for
* do… while..
* case (аналог switch)
Процедурные блоки могут моделировать как синхронные схемы (схемы с памятью), так и комбинационные схемы. К примеру, рассмотрим описание схемы двоичного счетчика:
`**module** counter
(
**input** clk, reset,
**output** [7:0] data
);
**reg** [7:0] counter;
**assign** data = counter;
**always** @(**posedge** clk) // процедурный блок срабатывает по положительному фронту clk
**begin**
**if** (reset)
counter = 0;
**else**
counter = counter + 1;
**end**
**endmodule**`
Строка **always** @(**posedge** clk) называется списком чувствительности. Она определяет события, по которым выполняется процедурный блок. Данный блок выполняется по каждому положительному фронту (positive edge) сигнала синхронизации. Таким образом, блок моделирует логику работы счетчика, сигнал counter будет просинтезирован как регистр.
Процедурные блоки могут моделировать и комбинационные схемы. К примеру, следующий код просинтезируется в комбинационный сумматор:
`**wire** [7:0] a,b;
**reg** [7:0] res;
**always** @*
**begin**
**res** = a+b;
**end**`
Здесь список чувствительности **always** @\* означает, что процедурный блок выполняется каждый раз, когда изменяются значения сигналов в правой части операций присваивания. В данном случае процедурный блок срабатывает каждый раз, когда изменяются сигналы a и b. Эквивалентном этой строчке, будет следующий список чувствительности:
`**always** @(a **or** b) // блок срабатывает каждый раз, когда меняется **a** или **b**`
При описании комбинационной схемы с помощью процедурного блока **always** необходимо помнить, что значения всех изменяемых в блоке сигналов, должны полностью определятся сигналами в списке чувствительности. В противном случае синтезатору придется вставить в схему элементы памяти — защелки (latches).
К примеру, рассмотрим следующий процедурный блок:
`**wire** a,b;
**reg** res;
**always** @*
**begin**
if(a & b) res = 1;
else if (!a & b) res = 0;
****end****`
В процедурном блоке не описано, что будет в случае если b = 0. Если b = 0 значение res не должно меняться, не зависимо от значения a. Поэтому будет просинтезирована следующая схема:
Как правило, появление защелок в схеме означает ошибку в коде.
**Неблокирующие присваивания**
Все присваивания, которые мы использовали в примерах с процедурными блоками, в Verilog называются «блокирующими» присваиваниями. Они работают привычным программисту образом.
Помимо блокирующих присваиваний, в Verilog есть еще один тип присваивания, используемый в процедурных блоках — неблокирующее присваивание, обозначаемое оператором "<=". Неблокирующее присваивание выполняется не сразу, в том месте где объявлено, а откладывается до выхода из процедурного блока. Рассмотрим пример:
`**reg** a,b;
**always** @(**posedge** clk)
**begin**
a <= b;
b <= a;
**end**`
В этом примере на каждом такте сигналы a и b будут обмениватся значениями. Синтезированная схема будет выглядеть следующим образом:
Неблокирующие присваивания обычно используют при описании логики работы регистров. Блокирующие присваивания чаще используются для описания комбинационных схем.
#### Заключение
На этом небольшое введение в Verilog заканчивается. Надеюсь, кому-то оно было полезно.
Тем кто хочет познакомиться с Verilog и проектированием цифровых схем немного глубже, могу порекомендовать эти две книжки для начинающих:
* [Pong P. Chu. FPGA Prototyping By Verilog Examples](http://www.amazon.com/FPGA-Prototyping-Verilog-Examples-ebook/dp/B005PS4YCC/ref=sr_1_4?ie=UTF8&qid=1328555703&sr=8-4)
* [S. Harris, D. Harris. Digital Design and Computer Architecture](http://www.amazon.com/Digital-Design-Computer-Architecture-ebook/dp/B0035YPIOQ/ref=sr_1_1?s=digital-text&ie=UTF8&qid=1328556084&sr=1-1) | https://habr.com/ru/post/137643/ | null | ru | null |
# 4 революционных возможности JavaScript из будущего
JavaScript, с момента выхода стандарта ECMAScript 6 (ES6), быстро и динамично развивается. Благодаря тому, что теперь новые версии стандарта [ECMA-262](https://tc39.es/ecma262/) выходят ежегодно, и благодаря титаническому труду всех производителей браузеров, JS стал одним из самых популярных языков программирования в мире.
Недавно я [писал](https://areknawo.com/ecmascript-2020-biggest-new-features/) о новых возможностях, которые появились в стандарте [ES2020](https://www.ecma-international.org/ecma-262/11.0/). Хотя некоторые из этих возможностей и весьма интересны, среди них нет таких, которые достойны называться «революционными». Это вполне можно понять, учитывая то, что в наши дни спецификация JS обновляется достаточно часто. Получается, что у тех, кто работает над стандартом, просто меньше возможностей для постоянного внедрения в язык чего-то особенного, вроде ES6-модулей или стрелочных функций.
[](https://habr.com/ru/company/ruvds/blog/510900/)
Но это не значит, что нечто исключительно новое в итоге в языке не появится. Собственно говоря, об этом я и хочу сегодня рассказать. Мне хотелось бы поговорить о 4 возможностях, которые, в перспективе, можно будет назвать революционными. Они находятся сейчас на разных стадиях [процесса](https://tc39.es/process-document/) согласования предложений. Это, с одной стороны, означает, что мы можем никогда их в JavaScript и не увидеть, а с другой стороны — наличие подобных предложений даёт нам надежду на то, что мы их, всё же, когда-нибудь встретим в языке.
Декораторы (decorators)
-----------------------
Начнём мы с возможности, которую, вероятно, чаще всего просят включить в язык, и вокруг которой поднято довольно много шума. Пару лет назад о ней писали буквально повсюду. Речь идёт о [декораторах](https://github.com/tc39/proposal-decorators).
Возможно, вы уже знакомы с декораторами. Особенно — если вы пишете на TypeScript. Это, в сущности, концепция метапрограммирования, нацеленная на то, чтобы дать разработчику возможность «внедрять» собственный функционал в классы, в их отдельные поля и методы, в итоге делая классы программируемыми.
Взгляните на следующий пример:
```
function sealed(constructor: Function) {
Object.seal(constructor);
Object.seal(constructor.prototype);
}
@sealed
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
greet() {
return "Hello, " + this.greeting;
}
}
```
Тут я решил действовать осторожно и привёл пример использования [TypeScript-декораторов](https://www.typescriptlang.org/docs/handbook/decorators.html). Сделал я это, преимущественно, для того, чтобы показать общую идею. В вышеприведённом фрагменте кода мы создали декоратор `sealed` и применили его к классу `Greeter`. Как несложно заметить, декоратор — это просто функция, у которой есть доступ к конструктору класса, к которому она применена (это — цель). Мы используем ссылку на конструктор, а так же — метод `Object.seal()` для того чтобы сделать класс нерасширяемым.
Для того чтобы применить декоратор к классу, мы записываем имя декоратора со значком `@` сразу перед объявлением класса. В результате получается, что перед объявлением класса появляется конструкция вида `@[name]`, что в нашем случае выглядит как `@sealed`.
Проверить работоспособность декоратора можно, скомпилировав этот TS-код с включённой опцией `experimentalDecorators` и попробовав изменить прототип класса:
```
Greeter.prototype.test = "test"; // ERROR
```
В результате, теперь у вас должно появиться общее понимание того, зачем вообще нужны декораторы. Но мне хотелось бы затронуть тут один непростой вопрос. Он касается того, в каком состоянии сейчас находится согласование предложения по декораторам.
Я решил использовать TypeScript для демонстрации декораторов не без причины. Дело в том, что предложение, касающееся внедрения декораторов в JavaScript, появилось уже несколько лет назад. И оно сейчас «всего лишь» на 2 стадии согласования из 4. И в синтаксис, и в возможности декораторов из этого предложения постоянно вносят изменения. Но это не останавливает JS-сообщество от использования данной концепции. Для того чтобы в этом убедиться, достаточно взглянуть на огромные опенсорсные проекты вроде TypeScript или Angular v2+.
Правда, всё это, с течением времени, и по мере того, как предложение развивается, ведёт к проблеме, связанной с несовместимостью спецификаций. А именно, спецификация декораторов сильно развилась с момента появления соответствующего предложения, но многие проекты всё ещё её не реализовали. Пример на TypeScript, показанный выше, это демонстрация реализации более старой версии предложения. То же самое можно сказать и об Angular, и даже о Babel (хотя, в случае с Babel, можно говорить о том, что сейчас [ведётся работа](https://github.com/babel/proposals/issues/11) над реализацией более новой версии этой спецификации). В целом же, более новая версия предложения, в которой используется ключевое слово `decorator` и синтаксис, пригодный для компоновки, пока ещё не нашла хоть какого-то заметного применения.
В итоге можно сказать, что у декораторов есть потенциальная возможность изменить то, как мы пишем код. И эти изменения уже показывают себя, даже учитывая то, что внедрение декораторов находится на ранней стадии. Правда, учитывая текущее положение дел, декораторы лишь фрагментируют сообщество, и я полагаю, что они пока ещё не готовы к по-настоящему серьёзному использованию. Я посоветовал бы тем, кому декораторы интересны, немного подождать перед их внедрением в продакшн. Моя рекомендация, правда, не относится к тем, кто использует фреймворки, в которых применяются декораторы (вроде Angular).
Области (realms)
----------------
Теперь давайте немного сбавим обороты и поговорим об одной возможности, не такой сложной, как декораторы. Речь идёт об [областях](https://github.com/tc39/proposal-realms).
Возможно, вы уже бывали в ситуациях, когда вам нужно запустить собственный код, или код стороннего разработчика, но при этом сделать это так, чтобы этот код не повлиял бы на глобальное окружение. Многие библиотеки, в особенности — браузерные, работают через глобальный объект `window`. В результате они могут друг другу мешать в том случае, если в проекте используется слишком много неконтролируемых разработчиком библиотек. Это может приводить к ошибкам.
Сейчас решение этой проблемы в браузере заключается в использовании элементов , а в некоторых особых случаях — в использовании веб-воркеров. В среде Node.js ту же проблему решают с помощью модуля `vm` или с помощью [дочерних процессов](https://nodejs.org/api/child_process.html). Для решения подобных проблем и предназначен API Realms.
Этот API направлен на то, чтобы позволить разработчикам создавать отдельные глобальные окружения, называемые областями. В каждой такой области имеются собственные глобальные сущности. Взгляните на следующий пример:
```
var x = 39;
const realm = new Realm();
realm.globalThis.x; // undefined
realm.globalThis.x = 42; // 42
realm.globalThis.x; // 42
x; // 39
```
Здесь мы создаём новый объект `Realm`, используя соответствующий конструктор. С этого момента у нас есть полный доступ к новой области и к её глобальным объектам через свойство `globalThis` (введённое в ES2020). Тут можно видеть, что переменные основного «инкубатора» отделены от переменных в области, которую мы создали.
В целом, API Realms планируется как очень простой механизм, но — механизм полезный. Этот API отличается весьма специфическим набором вариантов использования. Он не даёт нам более высокий уровень безопасности, или возможности по многопоточному выполнению кода. Но он отлично, не создавая при этом лишней нагрузки на систему, справляется со своей основной задачей, с обеспечением базовых возможностей по созданию изолированных окружений.
Предложение по API Realms сейчас находится на 2 стадии согласования. Когда оно, в итоге, попадёт в стандарт, можно будет ожидать того, что оно будет использоваться в «тяжёлых» библиотеках, зависящих от глобальной области видимости, в онлайн-редакторах кода, оформленных в виде «песочниц», в различных приложениях, ориентированных на тестирование.
Do-выражения (do expressions)
-----------------------------
Синтаксис JavaScript, как и синтаксис большинства языков программирования, включает в себя инструкции (statements) и выражения (expressions). Самая заметная разница между этими конструкциями заключается в том, что выражения могут быть использованы как значения (то есть — их можно назначать переменным, передавать функциям и так далее), в то время как инструкции в таком качестве использовать нельзя.
Из-за этого различия именно выражениям чаще всего отдают предпочтение, стремясь к написанию более чистого и компактного кода. В JavaScript это можно увидеть, если проанализировать популярность функциональных выражений (function expression), куда входят и стрелочные функции, в сравнении с объявлениями функций (function declaration, function statement). Та же ситуация видна, если сравнить методы для перебора массивов (вроде `forEach()`) с циклами. То же самое, в случае с более продвинутыми программистами, справедливо и при сравнении [тернарного оператора](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) и инструкции `if`.
Предложение по [do-выражениям](https://github.com/tc39/proposal-do-expressions), находящееся на 1 стадии согласования, нацелено на то, чтобы ещё сильнее расширить возможности JS-выражений. И, кстати, не надо путать понятие «do-выражение» с циклами `do…while`, так как это — совершенно разные вещи.
Вот пример:
```
let x = do {
if (foo()) {
f();
} else if (bar()) {
g();
} else {
h();
}
};
```
Здесь представлен синтаксис из предложения по do-выражениям. В целом, перед нами — фрагмент JS-кода, обёрнутый в конструкцию `do {}`. Последнее выражение в этой конструкции «возвращается» в качестве итогового значения всего do-выражения.
Похожий (но не идентичный) эффект достижим с использованием IIFE (Immediately Invoked Function Expression, немедленно вызываемое функциональное выражение). Но в случае с do-выражениями весьма привлекательным кажется их компактный синтаксис. Тут, при схожем функционале, не нужно ни `return`, ни каких-то некрасивых вспомогательных конструкций вроде `(() => {})()`. Именно поэтому я полагаю, что после того, как do-выражения попадут в стандарт, их воздействие на JavaScript будет сравнимо с воздействием на язык стрелочных функций. Удобство выражений и дружелюбный синтаксис, так сказать, в одной упаковке, выглядят весьма заманчиво.
Сопоставление с образцом (pattern matching)
-------------------------------------------
Эта возможность последняя в данном материале, но она далеко не последняя по значимости. Речь идёт о предложении, направленном на внедрении в язык механизма [сопоставления с образцом](https://github.com/tc39/proposal-pattern-matching).
Возможно, вы знакомы с JS-инструкцией `switch`. Она похожа на `if-else`, но её возможности немного сильнее ограничены, и она, безусловно, лучше подходит для организации выбора одной из множества альтернатив. Вот как она выглядит:
```
switch (value) {
case 1:
// ...
break;
case 2:
// ...
break;
case 3:
// ...
break;
default:
// ...
break;
}
```
Лично я считаю инструкцию `switch` слабее инструкции `if`, так как `switch` умеет сравнивать то, что ей передано, только с конкретными значениями. Данное ограничение можно [обойти](https://stackoverflow.com/questions/5464362/javascript-using-a-condition-in-switch-case), но я не могу придумать — зачем. Кроме того, инструкция `switch` перегружена вспомогательными элементами. В частности, речь идёт об инструкциях `break`.
Механизм сопоставления с образцом можно рассматривать как более функциональную, основанную на выражениях, и потенциально более универсальную версию инструкции `switch`. Вместо простого сравнения значений, механизм сопоставления с образцом позволяет разработчику сравнивать значения со специальными образцами (шаблонами), которые поддаются глубокой настройке. Вот фрагмент кода, демонстрирующий пример предложенного API:
```
const getLength = vector => case (vector) {
when { x, y, z } -> Math.hypot(x, y, z)
when { x, y } -> Math.hypot(x, y)
when [...etc] -> vector.length
}
getLength({x: 1, y: 2, z: 3})
```
Тут используется довольно-таки необычный для JavaScript синтаксис (хотя он основан на синтаксисе, встречающемся в таких языках, как [Rust](https://doc.rust-lang.org/book/ch18-00-patterns.html) или [Scala](https://docs.scala-lang.org/tour/pattern-matching.html#inner-main)), у которого есть некоторые общие черты с уже известной нам инструкцией `switch`. Здесь, вместо ключевого слова `switch`, используется слово `case`, которое отмечает начало блока, в котором выполняется проверка значения. Затем, внутри блока, используя ключевое слово `when`, мы описываем шаблоны, с помощью которых хотим проверять значения. Синтаксис шаблонов напоминает синтаксис уже имеющегося в языке механизма деструктурирования объектов. Сравнивать значения можно с объектами, содержащими выбранные свойства, их можно сравнивать со значениями свойств объектов и со многими другими сущностями. Для того чтобы узнать подробности о данном механизме — взгляните на [этот](https://github.com/tc39/proposal-pattern-matching/blob/latest/CORE.md) документ.
После описания шаблона идёт стрелка («flat arrow», `->`), указывающая на выражение (в перспективе — даже на другое значение), которое должно быть вычислено при нахождении совпадения с образцом.
Я полагаю, что наличие в JS подобных возможностей позволит нам писать, так сказать, код нового поколения. Однако предложенный сейчас синтаксис кажется мне несколько тяжеловесным, так как он вводит в язык много совершенно новых конструкций. И тот факт, что данное предложение всё ещё находится на 1 стадии согласования, заставляет меня думать о том, что ему ещё есть куда улучшаться. Эта возможность выглядит весьма многообещающе, но ей предстоит пройти ещё долгий путь прежде чем она попадёт в официальную спецификацию JS.
Итоги
-----
На этом я завершаю рассказ о революционных возможностях JavaScript, которые, возможно, мы увидим в языке в будущем. Есть и другие подобные возможности, например — предложения о [внешней стандартной библиотеке](https://github.com/tc39/proposal-built-in-modules) и о [конвейерном операторе](https://github.com/tc39/proposal-pipeline-operator). Но я выбрал для этого материала только то, что показалось мне самым интересным. Учитывайте, что эти возможности всё ещё находятся на стадии предложений. Со временем они могут измениться. А может случиться так, что в стандарт они так никогда и не попадут. Но если вы, в любом случае, хотите быть в числе тех, кто раньше других пользуется подобными возможностями, я советую вам присмотреться к таким проектам, как [Babel](https://babeljs.io/). Эти проекты дают путёвку в жизнь многим JS-предложениям (в особенности тем, которые связаны с синтаксисом). Это позволяет всем желающим экспериментировать с новейшими возможностями задолго до того, как они появятся в реализациях языка.
**Каких возможностей вам больше всего не хватает в JavaScript?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=4javascript) | https://habr.com/ru/post/510900/ | null | ru | null |
# svn tips
Сегодня занимался устройством проекта и возился с svn — решил поделиться некоторыми советами:
**Автоматическая заливка кода на сервер из репозитория после коммита**
**Версионирование файлов настроек (Settings.php/xml/yml)**
**Храниение жирных и малоизменчивых сторонних библиотек в репозитории с быстрым чекаутом проекта**
* **Автоматическая заливка кода на сервер из репозитория после коммита**
сайт на php и захотелось, чтоб после коммита в репозиторий код на демо-сервере автоматически обновлялся.
Cделать это можно с использованием svn-hooks: в корне каждого репозитория есть папочка hooks, в которую можно положить чтонить исполняемое (например shall-скрипт: full/path/to/svn update path/to/web/folder) и назвать определенным образом (например post-commit.sh или post-commit.bat) — и после каждого комита этот скрипт будет выполняться и обновлять код на демке (возможны проблемы с разрешениями на доступ к файлам — читайте ссылки).
При этом на демку будут выкладываться и служебные файлы svn. Эта проблема решается настройками apache:
`Order deny,allow
Deny from all
или использованием svn команды export (http://svnbook.red-bean.com/en/1.0/re10.html) вместо update (http://svnbook.red-bean.com/en/1.1/re28.html).
Тут перед вами встаёт тонкий выбор. Использовать export кажется проще. Однако при использовании update вы потом сможете залить быстрые фиксы сделанные прямо на сервере в svn репозиторий.
links:
arstechnica.com/articles/columns/linux/linux-20050406.ars
subversion.tigris.org/faq.html#website-auto-update
кстати с использованием svn-hooks можно делать очень много полезного: запускать тесты, оповещать кого-нибудь, автоматически собирать приложение и т.д.`
**Как версионировать настройки (Settings.php/xml/yml)**
итак у нас есть файл с настройками он будет правится под каждую машину на которую ваше приложение будет ставиться. Поэтому каждый групповой коммит с новой машины будет переписывать этот файл в репозитории и при обновлении рабочей версии на другой машине он тоже может неприятно переписать настройки на этой машине. Как быть нам подсказывает [subversion.tigris.org/faq.html#ignore-commit](http://subversion.tigris.org/faq.html#ignore-commit):
следует скопировать файл с начальными настройками например settings.php в settings.template.php и добавить settings.php в svn:ignore. И в результате при развертывании приложения надо произвести обратную операцию копирования settings.template.php в settings.php (settings.php отсутствует в репозитории) и потом подправить его под конкретную установку. Из-за svn:ignore файл settings.php коммитеться уже не будет
**Как хранить жирные сторонние библиотеки**
В моем случае это было dojo (прекрасный js toolkit), который намного больше самого проекта (и практически не будет меняться), а попытка залить его в репозиторий и получить обратно занимает неприятно много времени. Поэтому я немного модифицировал предыдущий прием для решения этой проблемы:
итак мы имеем глубокую папку dojo — добавляем ее в svn:ignore — и архивируем в extract\_to\_dojo.archiv — который и заливаем в репозиторий. При разворачивании на новом месте надо произвести обратную операцию.
В принципе для автоматизации развёртывания новой версии можно написать небольшой скриптик, который пройдёт по всем /extract\_to(.?)\.rar/ и разархивирует их в $1
Для тех кто вынужден работать на платформе Win полезная сборка svn + apache + gui — [www.visualsvn.com](http://www.visualsvn.com/) | https://habr.com/ru/post/26753/ | null | ru | null |
# Роспотребнадзор закупает SEO услуги на 280т.р и настаивает на использовании SEOPult
Сегодня нашли в нашей [системе поиска по госзаказам](http://tender-consalt.ru/tenders) такой [тендер](http://zakupki.gov.ru/Tender/ViewPurchase.aspx?PurchaseId=558668): на право заключения Государственного контракта на продвижение сайта института.
Как выяснилось заказчик уже определен госконтрактом и техзаданием…
Из технического задания:
`*Требуется провести оптимизационные работы для улучшения видимости сайта www.cmd-online.ru поисковыми системами Yandex, Rambler и Google по следующим поисковым запросам:
Дальше идет перечисление примерно 200 запросов.*`
Оценка результатов работ проводится по достаточно грамотной методике:
`*Результат выполнения работ
Срок проведения работ делится на три этапа по одному месяцу каждый. Результаты каждого этапа определяются следующим образом:
Первый этап – нахождение 20% ключевых слов, перечисленных в данном Техническом задании, на первых страницах выдачи поисковых систем не менее чем 21 (двадцать один) день в месяц.
Второй этап – нахождение 45% ключевых слов, перечисленных в данном Техническом задании, на первых страницах выдачи поисковых систем не менее чем 21 (двадцать один) день в месяц.
Третий этап – нахождение 75% ключевых слов, перечисленных в данном Техническом задании, на первых страницах выдачи поисковых систем не менее чем 21 (двадцать один) день в месяц.
Начиная с 4-го (четвертого) календарного месяца с момента начала продвижения нахождение 75% ключевых слов, перечисленных в данном Техническом задании, на первых страницах выдачи поисковых систем не менее чем 21 (двадцать один) день в месяц.
Приемка выполненных работ происходит 1 раз в месяц по итогам ежедневной проверки нахождения отобранных случайным образом 20 ключевых слов. Не менее указанного выше процента от 20 слов должны присутствовать на первых страницах выдачи поисковых систем Yandex, Rambler и Google.*`
Цены конечно несколько завышены на мой взгляд, но по-моему это первый известный случай когда государство закупает SEO услуги.
**upd.** заказчик в госконтракте настаивает на использовании системы SEOPULT ;)
*`3.1.4. Для простановки внешних ссылок использовать Premium-аккаунт, зарегистрированный в сервисе Seopult по соответствующему Государственный контракту.`*
еще один интересный пункт
*`Предоставление доступа к сервису NetPM по адресу www.netpm.ru для самостоятельной проверки текущих позиций.`*
**upd.** в коментах ссылка, как нашли подрядчика который участвовал в написании ТЗ и госконтракта. | https://habr.com/ru/post/73941/ | null | ru | null |
# Ещё один Telegram-бот для видеонаблюдения
В данной статье мы рассмотрим основные принципы работы telegram-бота для видеонаблюдения.
Прочитав [статью о созданном телеграм-боте из подручных материалов](https://habrahabr.ru/post/341678/), захотелось поделиться с общественностью своим решением для видеонаблюдения.
Железо
------
В отличие от подхода автора указанной статьи, я целенаправленно закупал необходимое оборудование для организации видеонаблюдения в квартире с целью дополнительной безопасности. Я купил IP-камеру которая умела следить за движением в кадре, складывать в папку на ftp и даже отправлять на email. Но всё это было, во-первых, неудобно, во-вторых, в прошивке была ошибка, что отправка на e-mail не работала должным образом, ну и, наконец, было много ложных срабатываний. Поэтому, решено было написать telegram-бота, как самый удобный способ для оповещения и управления наблюдением.
Итак, из железа у меня — камера фирмы IPEYE, которая умеет брать питания через сеть (POE), POЕ-инжектор, небольшой сервачок на Ubuntu Server, интернет с резервированием через USB-модем, ну и UPS для поддержки питания всей системы.
Определяем открытие двери
-------------------------
У меня всего одна камера, направленная на входную дверь. В идеале, мне хотелось, чтобы я получал изображение входящего в эту дверь человека. Сначала я пробовал настроить детекцию движения силами самой камеры:
[](https://habrastorage.org/webt/ws/gr/z-/wsgrz-40nukwzrnjipssvg2kv94.png)
Но к сожалению, как я ни крутил ползунки, камера в полумраке сходила с ума и начинала постоянно оповещать о движении в кадре при переходе из дневного в ночной режим и наоборот. Можно было, конечно, поднять `motion`, он следит за движением в кадре гораздо аккуратнее. Но мне не хотелось поднимать дополнительный сервис, поэтому я решил оставить стандартную возможность камеры складывать изображения на ftp, и проверять на ложность срабатывания уже своими силами.
Для этого я написал простенький демон на php, который следит за папкой на предмет появления новых изображений, открывает их и анализирует разницу в освещённости заранее выбранных областей, примерно так (области специально выбраны выше, чтобы человек случайно не закрывал области):
Если разница превышает экспериментально подобранный порог, значит дверь действительно открыта.
Настраиваем бота
----------------
Итак, наш демон определил, что движение в кадре есть и дверь открыта. Дальше надо отправить это изображение в чат telegram. Для этого нам надо зарегистрировать нового бота через BotFather и получить API-ключ. Для взаимодействия с API Telegram я использовал библиотеку [longman/telegram-bot](https://github.com/php-telegram-bot/core). Телеграм предоставляет два способа получения новых сообщений long-polling и веб-хук. Второй способ мне показался предпочтительнее, но для его работы потребуется статичный URL с SSL-сертификатом. Для этого используем letsencrypt или самоподписанный сертификат который надо отправить BotFather. Подробнее о регистрации ботов можно почитать в документации телеграма.
Анализ wi-fi клиентов
---------------------
Когда получаешь много сообщений, начинаешь их просто игнорировать, поэтому необходима была некая автоматизация, чтобы оповещения отправлялись только тогда, когда никого нет дома. Сделать это можно очень просто, достаточно просканировать сеть на наличие в ней определённых wi-fi клиентов. Для этого надо установить `arp-scan` (`sudo apt-get install arp-scan`), тогда определить что клиент с необходимым мак-адресом подключён можно так:
```
$output = exec("arp-scan -q --retry=1 --timeout=500 --numeric --destaddr={$mac} {$ip} | grep -oP --color=never \"{$mac}\"");
$result = $output === $mac;
```
Здесь я специально указываю конкретный ip-адрес, чтобы не сканировать всю сеть. Но для этого надо зафиксировать в DHCP ip-шник для этого MAC-адреса. Но, в принципе, указывать ip необязательно.
[](https://habrastorage.org/webt/fl/fi/qd/flfiqdngpyymoreq6jyw1kluaas.png)
Запись видео
------------
Фотографии это, конечно, хорошо. Но лучше всего покажет входящего человека — видео. Т. к. видео у нас никуда не пишется, "раздобыть" его можно только записав поток. К счаcтью, моя камера предоставляет несколько rtsp потоков закодированных в h264. Чтобы отправить видео, надо записать поток, и отправить его как файл. Для этого воспользуемся `avconv` (форк `ffmpeg` в Ubuntu):
```
$ffmpeg = "avconv -rtsp_transport tcp -i rtsp://user:password@192.168.1.10/1/h264major -t 10 -an -vcodec copy {$file}";
$mv = "mv {$file} {$out}";
passthru("nohup sh -c '{$ffmpeg} && {$mv}' > /dev/null 2>&1 &");
```
Здесь я пишу видео в фоне, после чего перемещаю его в папку для слежения. Демон подхватит новый файл и отправит его как видео. Т. к. звука в видео у меня нет, Telegram автоматически конвертирует его в gif на desktop-клиенте, что очень удобно.
Автоподнятие демона
-------------------
Демон написан на php, и хотя он может работать месяцами, от ошибок никто не застрахован. Поэтому, хорошо бы следить, что демон не завершил процесс. Можно, было бы, конечно, настроить `supervisor`, но я решил сделать просто автоподнятие по cron-у. Если процесс жив, демон повторно не запускается:
```
passthru("ps -p $pid > /dev/null", $result);
return !$result;
```
Заключение
----------
Благодаря всем проделанным действиям, бот оповещает меня о входящем человеке двумя фотографиями и пятисекундным видео. Как бонус, бот также может оповещать о времени ухода и прихода определённых wi-fi клиентов, и находятся ли они сейчас дома.
С результатом вы можете ознакомиться на [github](https://github.com/paulzi/ipcamera-telegram-bot). | https://habr.com/ru/post/343616/ | null | ru | null |
# Proxmox 4. День второй. Thin-LVM
Добрый день, друзья. После ранее опубликованной [статьи](https://habrahabr.ru/post/315086/) много воды утекло, было поднято несколько серверов, несколько уже на новой 5-ой версии. Были и кластеры и CEPH и даже репликация с двумя нодами (появилась функция в 5-ке). Для себя принял решение (как и советовали в прошлых комментариях), что проще и удобнее ставить debian, правильно размечать диски и поверх рабочего soft-raid поднимать proxmox.
О разметке, о VLM и о тонких дисках далее и пойдет речь.
На одном сервере столкнулся с очень большой и неприятной вещью. Сервер отдельный, на debian 8. При разметке, в которой отдельное большое место выделяется под thin-lvm диск для хранения дисков виртуальных машин, есть одна тонкость, которую я не учитывал ранее.
**Пример реальной конфигурации:** создан soft raid-10 из 4 дисков по 3 Тб.
Из общих 5,7 Тб выделен отдельный диск в 5,37 типа LVM-Thin для дисков виртуалок. Размещены виртуальные машины, общий выделенный объем дисков которых составил 4,03 ТБ. Машины работали себе и понемногу заполняли диски. Заполнение за полгода составило в среднем на 20-30% в каждой из виртуалок.
В очередной день (естественно понедельник, который совпал еще и с первым днем долгожданного отпуска) наш сервер zabbix начал лихорадочно отправлять через телеграмм уведомления от витруалок. Сначала про отказы отдельных сервисов типа http или ssh, а потом и вовсе про потерю пингов. Полез подключаться через ssh на почтовую виртуалку, тормозит, с первых пары секунд ничего не понятно, тут прилетают еще с десяток сообщений от zabbix о проблемах других виртуалок. Боковым взглядом понимаю, что плохо у всех виртуалок, кроме самого гиперзивора. Залезаю на него и открываю консоль первой же проблемной машины.
И вижу
**Заголовок спойлера**`device-mapper: message ioctl on failed: Operation not supported`
Первым, что подумал, рассыпался soft-raid. Но почему не было уведомления на эту тема от самого гипера – раз, почему гиппер работает внешне корректно – два.
Лезу на lvm –a И вижу общие данные по pve\data
Data% — 23,51%
Meta% — 99,95%
Шах и мат.
Проверяю остальные виртуалки – лежат с такими же ошибками записи, сервисы лихорадочно дергаются в конвульсиях. Пользователи – в истерике.
Из всех вменяемых статей в гугле на эту тему – везде пишут одно и тоже средство – расширить место с помощью добавления дополнительного физического жесткого диска.
Учитывая, что попасть в наш местный форд нокс, где находится этот сервер сложновато, теряем кучу времени, отправляем атишника с флешкой на 8Гб. Через 1,5 часа он на месте, вставляет флешку, я добавляю ее в группу lvm, расширяю meta диск еще на 3 Гб командой:
**Заголовок спойлера**`lvresize --poolmetadatasize +3G pve/data`
И получаю в итоге Meta% — 1,58%
Перезапускаю по очереди машины, проверяя их диски и исправляя проблемы руками, т.к. некоторые (например, почтовый сервер) не захотели без проблем и исправлений по sfck запускаться по-человечески. И наконец-то решаю проблему.
Что это было, Карл? — спрашиваю я себя.
Создавая раздел Thin-LVM и добавляя его в proxmox я и не думал, что надо вручную учитывать емкость метаданных, вычислять их на калькуляторе и задавать вручную при создании диска. Почему такие важные, критичные показатели никак не мониторятся к примеру через тот же GUI Proxmox?
Ребята, если не сложно, в комментариях, очень прошу высказаться по этому поводу, что сделано не так, почему очень мало написано про создание Thin и именно про meta данные. И какие есть варианты решения проблемы помимо моего. Далеко не всегда рядом может оказаться авторизованный человек с флешкой, которого пустили в ДЦ, дали доступ в стойку, а я, находясь в отпуске за 1 тыс км, сумел-таки простоем в 2 часа решить проблему.
P.S.: Ну и результат конечно же меня не устраивает. Флешка таки торчит в сервере. Добавлена в группу LVM и может сдохнуть в любой момент (с потерей метаданных в этом случае – а это хуже, чем, когда система их просто не может записать). При возвращении буду думать, как избавиться от флешки другими путями (менять и\или добавить диск в сервер уже нельзя). По этому поводу, товарищи, так же хотел бы услышать объективные комментарии. | https://habr.com/ru/post/339676/ | null | ru | null |
# Рецепты от CHEFa: автоматизированное развёртывание сред бизнес-приложений с использованием HPE OneView
Информационные технологии становятся неотъемлемой частью продуктов и услуг нового стиля IT, в котором бизнес ожидает получить запрошенные ресурсы под новые приложения почти мгновенно. IT ресурсы, в парадигме новых требований со стороны современных приложений, должны автоматически выделяться, использоваться, возвращаться и повторно использоваться из общего пула узлов вычислений, хранения, и сети.
[](http://habrahabr.ru/company/hpe/blog/273605/)
Такая инфраструктура может иметь различные типы аппаратных платформ, абстрагированные под единой системой управления. Этот подход называется «инфраструктура как код» (infrastructure-as-code). Видение компании Hewlett Packard Enterprise это движение к Composable (Составляемая) Инфраструктуре — гибкому пулу ресурсов, из которого, под управлением менеджера HPE OneView с помощью шаблонов и API, происходит развертывание, обслуживание и контроль приложений.
Чтобы реализовать концепцию Composable Инфраструктуры и автоматизировать развертывания сред для бизнес-приложений, HPE объединил свои наработки с известным разработчиком ПО для управления конфигурациями приложений CHEF Software.
CHEF (Шэф) — система управления конфигурациями, написанная на Ruby и Erlang, с использованием предметно-ориентированного языка для описания конфигураций. Используется для упрощения задач настройки и поддержки множества серверов и может интегрироваться в облачные платформы для автоматизации управления текущими и автоматизации процесса настройки новых серверов.
Пользователь CHEF создаёт определенные «рецепты» с описанием того, как управлять серверными приложениями (например, Apache, MySQL или Hadoop) и их настроек.
«Рецепт» — это описание состояния ресурсов системы, в котором она должна находиться в конкретный момент времени, включая установленные пакеты, запущенные службы, созданные файлы. CHEF проверяет, что каждый из ресурсов системы настроен правильно и пытается исправить состояние ресурса, если оно не соответствует ожидаемому.
**«Рецепты» используются как для управления Linux-узлами, так и Windows (в последних релизах)**
Драйвер развертывания CHEF для HPE OneView, позволяет IT администраторам использовать «рецепты» CHEF, чтобы автоматизировать процесс физического развертывания как физической среды, включая серверы, сетевые соединения, хранение, так и развертывание операционных систем и приложений. Такая интеграция увеличивает скорость отдачи для бизнеса и повышает надежность развертывания, благодаря автоматизации всех шагов.
*Рис.1 — Схема взаимодействия драйвера CHEF с HPE OneView*
Чтобы создать быструю и эффективную IT инфраструктуру организация должна трансформировать традиционные физические системы в гибкие пулы физических и виртуальных ресурсов.
По мере такой трансформации организация часто сталкивается со сложностями в автоматизации развертывания «bare metal» физического оборудования. Развертывание всегда сложный процесс. Он требует установки и подготовки аппаратного обеспечения, подключений, ОС и стека приложений на подходящем для этой задачи оборудовании. Эти процессы часто требуют ручного управления и мониторинга, что занимает много времени и может приводить к появлению ошибок.
Вот тут и появляется идея Composable инфраструктуры. В такой инфраструктуре есть гибкий пул вычислителей, хранения и сети, ресурсы в нем выделяются, увеличиваются, уменьшаются, повторно используются динамически, используя программно-определяемый подход. В портфеле решений Hewlett Packard Enterprise все продукты серверов, систем хранения и сетей передачи данных специально разрабатывались для встраивания в такую программно-определяемой инфраструктуру.
Например, каждый сервер оснащен чипом iLO, что позволяет без установки агентов в ОС собирать состояние всех аппаратных компонент и настроить взаимодействие с сервером. Системы хранения и сетевые устройства в портфеле решений Hewlett Packard Enterprise понимают открытый стандарт API RESTful. Оставалось создать продукт, который был бы способен объединить все наработки в аппаратной части портфеля и создать полноценный оркестратор, который сможет управлять всей инфраструктурой ЦОДа. Таким продуктов стал OneView, выпущенный в октябре 2013 года.
HPE OneView
-----------
*Рис.2 — Окружающая среда HPE OneView*
HPE OneView — программный продукт полного цикла управления современного ЦОД: использует коннекторы для управления сетью, серверами и системами хранения, построенных на продуктах Hewlett Packard Enterprise, Brocade, некоторыми коммутаторами Cisco, интегрируется во все известные гипервизоры и может обращаться к ним для развертывания виртуальных сред.
Поставляется в виде образа виртуальной машины Vmware или Hyper-v и может быть развернут на любом оборудовании с поддержкой этих гипервизоров. HPE OneView имеет понятный и простой в освоении интерфейс, который можно адаптировать под определенные группы администраторов, добавляя или убирая компоненты в графической консоли. Помимо этого, HPE OneView может интегрироваться с инфраструктурой ЦОДа — UPS, PDU (Schneider Electric, Eaton и др.), стойками, позволяя получить трехмерную картину того, что происходит в серверных залах и управлять перемещением приложений или виртуальных машин, основываясь на полученных данных.
*Рис.3 — Температурная карта ЦОД в OneView*
Администратор может построить карту взаимодействия устройств в интерфейсе OneView:
*Рис.4 — Связи элементов серверной архитектуры*
HPE OneView заменяет целиком 5 предшествующих продуктов управления серверной инфраструктурой: HP SIM, Insight Control, Onboard Administrator, VCM, HPSUM.
В версии 2.0 HPE OneView расширил свои возможности — появился функционал миграции профилей (настроек IP, WWN, MAC адресов и других параметров) сервера с одного блейд-отсека на другой, как между отсеками с одинаковыми блейд-серверами (те же типы процессоров, памяти, сетевых адаптеров), так и между отсеками с разными поколениями блейд-серверов с разными поколениями CPU, типом LAN и FC адаптеров. Причем, такая миграция возможна теперь не только в рамках одной блейд-корзины, но и между несколькими.
*Рис.5 — Новые возможности по миграции профилей в OneView 2.0*
HPE OneView позволяет администраторам использовать шаблоны и профили для реализации на своем предприятии идеи программно-определяемой архитектуры или инфраструктуры-как-код (infrastructure-as-code).
Шаблоны, поставляемые вместе с OneView, могут легко адаптированы и изменены под различные приложения и исходя из специфики оборудования в каждом конкретном случае.
Эти шаблоны рекомендуется использовать в подходе DevOps потому, что они уменьшают время развертывания инфраструктуры для разработчиков и устраняют рассогласованность между представителями департамента IT, позволяя за считанные минуты начать тестировать приложения.
Шаги развёртывания
------------------
Для того, чтобы показать возможность автоматизированного развертывания приложений «с нуля», используя возможности OneView и CHEF необходимо выполнить несколько шагов.
**Развёртывание физического сервера, используя HPE OneView**
Для этого заходим в консоль HPE OneView — Server Profiles — Create Profile. И получаем примерно такое окно:
*Рис.6 — Создание профиля в OneView*
В этом сценарии имя профиля задается «Web Server Template», заполняются параметры блейд-корзины, блейд-сервера, сетевых подключений, основываясь на конкретных моделях оборудования в вашем ЦОДе.
Нажимаем «Create» и сохраняем профиль. Далее нужно установить драйвер интеграции CHEF и OneView.
**Развертывание ОС, используя шаблон в OneView**
Загружаем скрипт «chef-settings-Linux®» с сайта [GitHub](https://github.com/HewlettPackard/chef-provisioning-oneview). Меняем в скрипте следующие значения:
>
> ```
> CHEF_PROXYSERVER: the proxy server address
> YUM_REPOSITORY_INFO: the yum repository information
> CHEF_CERT: the SSH certificate information to be copied into the authorization files
> LOGIN_DISABLED: should be set to YES/yes to disable user login and NO/no if LOGIN using username/password should not be disabled
> ```
>
Этот скрипт необходимо встроить в пакет развертывания ОС — OS Build Plan. Подробнее о создании OS Build Plan [тут](http://www8.hp.com/h20195/V2/getpdf.aspx/4AA4-8057ENW.pdf?ver=1.0) и [тут](http://h20564.www2.hpe.com/hpsc/doc/public/display?docId=c04618680).
**Конфигурация стека приложения, используя Cookbook (поваренная книга) CHEF**
Далее создаем поваренную книгу и рецепт в CHEF. Какой главный инструмент шеф-повара? Нож!
Первый файл рецепта будет иметь такое же название, находим его <https://github.com/HewlettPackard/chef-provisioning-oneview#prerequisites> и заполняем все параметры вашего окружения.
Следующим шагом мы создаем сам рецепт, заменяя параметры приведенного ниже кода на актуальные для вашего окружения:
>
> ```
> require 'chef/provisioning'
> with_driver 'oneview'
> with_chef_server "<https://my-chef.my-domain.com/organizations/my-org>",
> :client_name => Chef::Config[:node_name],
> :signing_key_filename => Chef::Config[:client_key]
> machine 'web01' do
> recipe 'my_server_cookbook::default'
> machine_options :driver_options => {
> :server_template => 'Web Server Template',
> :os_build => 'CHEF-RHEL-6.5-x64',
> :host_name => 'chef-web01',
> :ip_address => 'xx.xx.xx.xx',
> :domainType => 'workgroup',
> :domainName => 'sub.domain.com',
> :mask => '255.255.255.0',
> :dhcp => false,
> :gateway => 'xx.xx.xx.1',
> :dns => 'xx.xx.xx.xx,xx.xx.xx.xx,xx.xx.xx.xx',
> :connections => {
> #1 => { ... } (Reserved for PXE on our setup)
> 2 => {
> :ip4Address => 'xx.xx.xx.xx',
> :mask => '255.255.254.0', # Optional
> :dhcp => false
> :gateway => 'xx.xx.xx.1' # Optional
> :dns => 'xx.xx.xx.xx' # Optional
> }
> },
> :custom_attributes => {
> :chefCert => 'ssh-rsa AA...' # Optional
> }
> },
> :transport_options => {
> :user => 'root', # Optional. Defaults to 'root'
> :ssh_options => {
> :password => Chef::Config.knife[:node_root_password]
> }
> },
> :convergence_options => {
> :ssl_verify_mode => :verify_none, # Optional
> :bootstrap_proxy => '[http://proxy.domain.com:8080](http://proxy.domain.com:8080/)' # Optional
> }
> chef_environment '_default'
> converge true
> end
> ```
>
Развёртываем! Теперь, когда все готово, приступаем к финальной части. CHEF будет использовать созданный рецепт и совместно с драйвером OneView будет проведено полное развертывание web-сервера «с нуля».
В консоли CHEF нужно встать на директорию, содержащую рецепт и выполнить команду:
```
$ bundle exec chef-client -z путь_к_рецепту.rb
```
Заглянем в консоль OneView и посмотрим, как происходит развертывание нашего приложения:
*Рис.7 — Тихо, идет развертывание!*
Когда развертывание будет завершено — проверим, что все компоненты установлены и настроены правильно:
*Рис.8 — Проверяем параметры*
Теперь переключаемся в консоль CHEF и проверяем, что узел действительно создан с использованием рецепта CHEF:
*Рис.9 — CHEF тоже знает об этом узле*
Также проверяем, что серверу присвоен серийный номер, на нем сконфигурирован Apache и поднят Apache Webserver, сколько потребовалось времени и какие были сделаны шаги:
*Рис.10 — Большинство компонент проинициализированы за секунды!*
То, что этот сервер сейчас виден в консоли значит, что он правильно сконфигурирован и посылает информацию о себе. Пришло время убедиться, что приложение действительно работает, для этого обращаемся к Webserver в браузере:
*Рис.11 — Webserver жив и готов работать!*
Механика развёртывания в HPE OneView состоит из 5 шагов:
**1.** Мы выбираем совместимое серверное оборудование из пула доступных серверов, управляемых HPE OneView, используя поиск HPE OneView REST API.
**2.** Создаем новый шаблон профиля сервера, используя HPE OneView REST API и назначаем:
**A.** Версию прошивки, BIOS, конфигурацию локального хранилища: HPE OneView использует встроенный HP Intelligent Provisioning (IP), окружение Linux для PXE boot, которое уже встроено в iLO baseboard management card (BMC) процессор, SmartStart.
**B.** Сетевые подключения: HPE OneView использует сетевую платформу virtual connect для динамического представления сетевых подключений для серверов из пула сетевых подключений.
**C.** Сеть SAN: HPE OneView автоматизирует представление сети SAN для хранилища HPE 3PAR и для коммутаторов Fibre Channel, включая Brocade, Cisco и HPE Networking.
**3.** Развертывается выбранная ОС как только предоставление физических ресурсов окончено:
**A.** Серверный профиль сконфигурирован на загрузку установочного образа по сети.
**B.** Сервер включается и начинается загрузка PXE boot.
**C.** Драйвер OneView запускает установку ОС, используя HPE OneView REST API (Insight Control server provisioning).
**4.** Задаются параметры сети
**A.** IP адреса, подсети, имя хостов, и т.д. для различных сетевых адаптеров и виртуальных сетевых адаптеров, позволяя создавать сложные сетевые конфигурации.
**5.** CHEF разворачивает стек приложений поверх развернутой ОС
**A.** Загрузка клиента CHEF на сервер, после этого клиент CHEF регистрируется на сервере CHEF.
**B.** Запуск клиента CHEF на новом сервере, который подтягивает необходимую «поваренную книгу» с сервера CHEF и применяет рецепт для конфигурации Web сервера.
Видео процесса развертывания:
Как видим — используя рецепты CHEF, совместно с аппаратными и программными продуктами Hewlett Packard Enterprise, можно получить простую, открытую и полностью автоматизированную инфраструктуру-как-код для развертывания приложений. Не бойтесь экспериментировать, только так можно стать настоящим шефом IT кухни!
Для самостоятельного изучения: [Ван](http://www.hp.com/go/composablepartners) — [Ту](http://www8.hp.com/h20195/v2/GetPDF.aspx/4AA6-1024ENW.pdf) — [Фри](https://www.chef.io/blog/2015/09/18/bare-metal-provisioning-with-chef-and-hp-oneview/) — [Фо](https://github.com/HewlettPackard/chef-provisioning-oneview)
Спасибо за внимание! | https://habr.com/ru/post/273605/ | null | ru | null |
# ASP.NET MVC Урок 9. Configuration и загрузка файлов
**Цель урока.** Научиться использовать файл конфигурации Web.config. Application section, создание своих ConfigSection и IConfig. Научиться загружать файлы, использование file-uploader для загрузки файла, последующая обработка файла.
В этом уроке мы рассмотрим работу с конфигурационным файлом Web.config. Это xml-файл и в нем хранятся настройки программы.
Рассмотрим подробнее, из чего состоит этот файл:
* **configSection**. Это секция отвечает за то, какие классы будут обрабатывать далее объявленные секции. Состоит из атрибута name — это тег, далее объявленной секции, и type – к какому классу относится.
* **connectionStrings**. Это секция отвечает за работу с указанием строк инициализаций соединений с базами данных.
* **appSettings**. Секция параметров типа key/value.
* **system.web, system.webServer**. Секции параметров для работы веб-приложения.
* **runtime.** Секция по настройке в режиме выполнения. Определение зависимостей между dll.
* **Остальные секции.** Другие секции с параметрами, объявленными в configSection.
##### IConfig (и реализация).
Аналогично Repository, конфигуратор будем создавать как сервис. Создаем IConfig и Config-реализацию в папке Global (/Global/Config/IConfig.cs):
```
public interface IConfig
{
string Lang { get; }
}
```
И
```
public class Config : IConfig
{
public string Lang
{
get
{
return "ru";
}
}
}
```
Добавляем строку в RegisterServices (/App\_Start/NinjectWebCommon.cs):
```
kernel.Bind().To().InSingletonScope();
```
И выводим в BaseController:
```
[Inject]
public IConfig Config { get; set; }
```
Теперь сделаем в инициализации контроллера переопеределение CultureInfo в потоке (/Controllers/BaseController.cs):
```
protected override void Initialize(System.Web.Routing.RequestContext requestContext)
{
try
{
var cultureInfo = new CultureInfo(Config.Lang);
Thread.CurrentThread.CurrentCulture = cultureInfo;
Thread.CurrentThread.CurrentUICulture = cultureInfo;
}
catch (Exception ex)
{
logger.Error("Culture not found", ex);
}
base.Initialize(requestContext);
}
```
И добавим вывод даты в Index.cshtml (/Areas/Default/Views/Home/Index.cshtml):
```
@DateTime.Now.ToString("D")
```
Получаем вывод:
И по-настоящему свяжем это с Web.Config. Добавим в Web.config в appSettings строку:
```
```
В Config.cs (/Global/Config/Config.cs):
```
public string Lang
{
get
{
return ConfigurationManager.AppSettings["Culture"] as string;
}
}
```
Запускаем – результат тот же, теперь изменим значение в Web.config на fr:
```
```
Получаем дату:
```
mardi 5 mars 2013
```
Отлично! Можете попробовать еще с несколькими языками. Список сокращений находится тут <http://msdn.microsoft.com/en-us/goglobal/bb896001.aspx>
##### Создание своих типов ConfigSection
В этой части мы рассмотрим создание своих собственных ConfigSection. В этой главе мы реализуем загрузку файлов и создание превью. Нам понадобятся следующие данные: во-первых, зависимость mime-type от расширения, и иконка файлов (для скачивания, например):
* расширение
* mime-type
* большая иконка
* маленькая иконка
и во-вторых, данные для создания превью:
* наименование превью (например, UserAvatarSize)
* ширина
* высота
Оба типа делаются одинаково, так что я распишу только создание одного из них. Пусть это будет IconSize, для создания превью. Первое, что надо сделать — это создать класс, наследуемый ConfigurationElement (/Global/Config/IconSize.cs):
```
public class IconSize : ConfigurationElement
{
[ConfigurationProperty("name", IsRequired = true, IsKey = true)]
public string Name
{
get
{
return this["name"] as string;
}
}
[ConfigurationProperty("width", IsRequired = false, DefaultValue = "48")]
public int Width
{
get
{
return (int)this["width"];
}
}
[ConfigurationProperty("height", IsRequired = false, DefaultValue = "48")]
public int Height
{
get
{
return (int)this["height"];
}
}
}
```
Рассмотрим подробнее:
* **ConfigurationProperty** состоит из имени, это имя атрибута в строке
* **IsRequired** – обязательный этот параметр или нет
* **IsKey** – является ли ключом (как первичный ключ в БД)
* **DefaultValue** – значение по умолчанию
Следующий шаг – это создание класса коллекции (так как у нас будет множество элементов) и секции (/Global/Config/IconSize.cs):
```
public class IconSizesConfigSection : ConfigurationSection
{
[ConfigurationProperty("iconSizes")]
public IconSizesCollection IconSizes
{
get
{
return this["iconSizes"] as IconSizesCollection;
}
}
}
public class IconSizesCollection : ConfigurationElementCollection
{
protected override ConfigurationElement CreateNewElement()
{
return new IconSize();
}
protected override object GetElementKey(ConfigurationElement element)
{
return ((IconSize)element).Name;
}
}
```
В Web.config добавляем:
```
…
```
Теперь необходимо объявить класс разбора этой секции в configSection:
```
```
Обратите внимание, что в описание type необходимо указать имя dll (`LessonProject`), в которой он содержится. Это важно, но будет рассмотрено в unit-тестах.
##### MailSettings
Создадим одиночный конфиг для настроек по работе с smtp-почтой. Нам понадобятся:
* SmtpServer. Имя сервера.
* SmtpPort. Порт, обычно 25й.
* SmtpUserName. Логин.
* SmtpPassword. Пароль.
* SmtpReply. Обратный адрес в строке Reply-to.
* SmtpUser. Имя пользователя в строке From.
* EnableSsl. Да/нет, использовать ли работу по Ssl.
Файл (/Global/Config/MailSetting.cs):
```
public class MailSetting : ConfigurationSection
{
[ConfigurationProperty("SmtpServer", IsRequired = true)]
public string SmtpServer
{
get
{
return this["SmtpServer"] as string;
}
set
{
this["SmtpServer"] = value;
}
}
[ConfigurationProperty("SmtpPort", IsRequired = false, DefaultValue="25")]
public int SmtpPort
{
get
{
return (int)this["SmtpPort"];
}
set
{
this["SmtpPort"] = value;
}
}
[ConfigurationProperty("SmtpUserName", IsRequired = true)]
public string SmtpUserName
{
get
{
return this["SmtpUserName"] as string;
}
set
{
this["SmtpUserName"] = value;
}
}
[ConfigurationProperty("SmtpPassword", IsRequired = true)]
public string SmtpPassword
{
get
{
return this["SmtpPassword"] as string;
}
set
{
this["SmtpPassword"] = value;
}
}
[ConfigurationProperty("SmtpReply", IsRequired = true)]
public string SmtpReply
{
get
{
return this["SmtpReply"] as string;
}
set
{
this["SmtpReply"] = value;
}
}
[ConfigurationProperty("SmtpUser", IsRequired = true)]
public string SmtpUser
{
get
{
return this["SmtpUser"] as string;
}
set
{
this["SmtpUser"] = value;
}
}
[ConfigurationProperty("EnableSsl", IsRequired = false, DefaultValue="false")]
public bool EnableSsl
{
get
{
return (bool)this["EnableSsl"];
}
set
{
this["EnableSsl"] = value;
}
}
}
```
Добавим в Web.config:
```
```
И
```
```
Добавим все это теперь в IConfig.cs и Сonfig.cs (/Global/Config/IConfig.cs):
```
public interface IConfig
{
string Lang { get; }
IQueryable IconSizes { get; }
IQueryable MimeTypes { get; }
MailSetting MailSetting { get; }
}
```
И
```
public IQueryable IconSizes
{
get
{
IconSizesConfigSection configInfo = (IconSizesConfigSection)ConfigurationManager.GetSection("iconConfig");
return configInfo.IconSizes.OfType().AsQueryable();
}
}
public IQueryable MimeTypes
{
get
{
MimeTypesConfigSection configInfo = (MimeTypesConfigSection)ConfigurationManager.GetSection("mimeConfig");
return configInfo.MimeTypes.OfType().AsQueryable();
}
}
public MailSetting MailSetting
{
get
{
return (MailSetting)ConfigurationManager.GetSection("mailConfig");
}
}
```
Мы еще добавим MailTemplates — шаблоны которые нам понадобятся для рассылки email при регистрации, или при напоминании пароля.
##### Простая загрузка файлов
Сейчас рассмотрим стандартный пример загрузки файла на сервер, и больше никогда не будем пользоваться таким способом. Класс SimpleFileView для взаимодействия (/Models/Info/SimpleFileView.cs):
```
public class SimpleFileView
{
public HttpPostedFileBase UploadedFile { get; set; }
}
```
Обратите внимание на наименование класса для приема файлов. Итак, создадим контроллер SimpleFileController (/Areas/Default/Controllers/SimpleFileController.cs):
```
public class SimpleFileController : DefaultController
{
[HttpGet]
public ActionResult Index()
{
return View(new SimpleFileView());
}
[HttpPost]
public ActionResult Index(SimpleFileView simpleFileView)
{
return View(simpleFileView);
}
}
```
И добавим View:
```
@model LessonProject.Models.Info.SimpleFileView
@{
ViewBag.Title = "Index";
Layout = "~/Areas/Default/Views/Shared/_Layout.cshtml";
}
Index
-----
@using (Html.BeginForm("Index", "SimpleFile", FormMethod.Post, new {enctype = "multipart/form-data", @class = "form-horizontal" }))
{
Загрузите файл:
@Html.TextBox("UploadedFile", Model.UploadedFile, new { type = "file", @class = "input-xlarge" })
@Html.ValidationMessage("UploadedFile")
Upload
}
```
Обратите внимание, на enctype в атрибутах формы и на type в атрибутах TextBox (на самом деле тип еще бывает password, checkbox, radio, но для них есть соответствующие методы в @Html-классе). Enctype необходимо установить в “multipart/form-data”, чтоб была возможность загрузить большой объём информации.
Загружаем и проверяем. Наш файл благополучно загружен, только необходимо сохранить InputStream в некий файл. Но оставим пока так и рассмотрим недостатки.
Первый недостаток – это то, что во всех браузерах форма выбора файла выглядит по-разному:
Конечно, ведь дизайнер представляет себе, что загрузка файлов выполняется как в Safari, а заказчик проверяет в Chrome и IE, и начинает спрашивать у разработчиков: «Что за самодеятельность?»
Второй недостаток –если форма не прошла валидацию, то эти поля необходимо выбрать заново. Т.е. есть такая форма:
* Имя
* Фамилия
* Электронная почта
* Дата рождения
* Фотография
* Фотография первого разворота паспорта
* Фотография второго разворота паспорта
* Фотография паспорта с пропиской
* Пароль
* Пароль еще раз
* Капча
И вдруг вы набрали пароль неверно, или капчу не так ввели, или фотография второго разворота паспорта слишком большая, или вы забыли перегнать из raw-формата в jpeg.
В итоге фотографии, прописку и капчу надо вводить заново. Естественно, это совсем не user friendly, и раздражает заказчика (к тому же дизайнер нарисовал красиво, а выглядит убого).
##### Загрузка файла (ов) с помощью Ajax
Определим как должна вести себя загрузка файла:
* Пользователь кликает на «загрузить».
* Открывается форма выбора файла
* Пользователь выбирает файл
* Файл загружается, или выдается ошибка о том, что что-то не так
* Если даже форма и не проходит валидацию, то файл остается загруженным и его не нужно загружать заново.
Это называется ajax-загрузка и для нее используем fineuploader (<http://fineuploader.com/>). Библиотека платная, но мы скачаем и соберем исходники (у нас же есть bundle!). Скачиваем исходники по ссылке: <https://github.com/valums/file-uploader>. Перемещаем js-файлы в папку /Scripts/fine-uploader. Css-файлы перемещаем в /Content и изображения в /Content/images. Перепишем правильно url в fineuploader.css для изображений:
```
.qq-upload-spinner {
display: inline-block;
background: url("images/loading.gif");
width: 15px;
height: 15px;
vertical-align: text-bottom;
}
.qq-drop-processing {
display: none;
}
.qq-drop-processing-spinner {
display: inline-block;
background: url("images/processing.gif");
width: 24px;
height: 24px;
vertical-align: text-bottom;
}
```
Файлы инициализируем в BundleConfig.cs (/App\_Start/BundleConfig.cs):
```
bundles.Add(new ScriptBundle("~/bundles/fineuploader")
.Include("~/Scripts/fine-uploader/header.js")
.Include("~/Scripts/fine-uploader/util.js")
.Include("~/Scripts/fine-uploader/button.js")
.Include("~/Scripts/fine-uploader/ajax.requester.js")
.Include("~/Scripts/fine-uploader/deletefile.ajax.requester.js")
.Include("~/Scripts/fine-uploader/handler.base.js")
.Include("~/Scripts/fine-uploader/window.receive.message.js")
.Include("~/Scripts/fine-uploader/handler.form.js")
.Include("~/Scripts/fine-uploader/handler.xhr.js")
.Include("~/Scripts/fine-uploader/uploader.basic.js")
.Include("~/Scripts/fine-uploader/dnd.js")
.Include("~/Scripts/fine-uploader/uploader.js")
.Include("~/Scripts/fine-uploader/jquery-plugin.js")
);
bundles.Add(new StyleBundle("~/Content/css/fineuploader")
.Include("~/Content/fineuploader.css"));
```
Создаем контроллер FileController.cs (/Areas/Default/Controllers/FileController.cs):
```
public class FileController : DefaultController
{
[HttpGet]
public ActionResult Index()
{
return View();
}
public ActionResult Upload(HttpPostedFileWrapper qqfile)
{
return Json(new { result = "ok", success = true});
}
}
```
Метод-action Upload принимает строковое значение qqfile, я ниже рассмотрю, почему так. А сейчас создадим View для Index. Для этого:
* Создаем кнопку, при нажатии на которую мы загружаем файл.
* Файл загружается и создается превью
* Файл и превью сохраняются в файловую систему
* Метод возвращает ссылку, куда были загружены файл и превью, через Json-ответ
* Если файлы не удалось загрузить, то выдается соответствующая ошибка
* Обрабатываем json-результат и уведомляем, что файл и превью загружено
* Верификация формы и запись в БД не нужны.
View для Index:
```
@{
ViewBag.Title = "Index";
Layout = "~/Areas/Default/Views/Shared/_Layout.cshtml";
}
@section styles {
@Styles.Render("~/Content/css/fineuploader")
}
@section scripts {
@Scripts.Render("~/bundles/fineuploader")
@Scripts.Render("~/Scripts/default/file-index.js")
}
Index
-----
Image
Upload
![]()
```
Наша кнопка с id=UploadImage. Добавляем file-index.js файл для обработки (/Scripts/default/file-index.js):
```
function FileIndex() {
_this = this;
this.ajaxFileUpload = "/File/Upload";
this.init = function () {
$('#UploadImage').fineUploader({
request: {
endpoint: _this.ajaxFileUpload
},
}).on('error', function (event, id, name, reason) {
//do something
})
.on('complete', function (event, id, name, responseJSON) {
alert(responseJSON);
});
}
}
var fileIndex = null;
$().ready(function () {
fileIndex = new FileIndex();
fileIndex.init();
});
```
Теперь обработаем загрузку:
```
public ActionResult Upload(HttpPostedFileWrapper qqfile)
{
var extension = Path.GetExtension(qqfile.FileName);
if (!string.IsNullOrWhiteSpace(extension))
{
var mimeType = Config.MimeTypes.FirstOrDefault(p => string.Compare(p.Extension, extension, 0) == 0);
//если изображение
if (mimeType.Name.Contains("image"))
{
//тут сохраняем в файл
var filePath = Path.Combine("/Content/files", qqfile.FileName);
qqfile.SaveAs(Server.MapPath(filePath));
return Json(new
{
success = true,
result = "error",
data = new
{
filePath
}
});
}
}
return Json(new { error = "Нужно загрузить изображение", success = false });
}
```
В Content добавим папку files — это будет папка пользовательских данных. Разберем код:
* Получаем qqfile (тут ничего не поменять, это параметр обусловлен fineuploader).
* Из него получаем extension.
* По extension находим mimeType. Для .jpg, .gif, .png – мы получаем mime-type типа «image/…». Таким образом, мы проверяем, что этот файл можно загрузить.
* Далее, используя имя файла, составляем абсолютный путь к папке /Content/files (которую мы заранее создали) с помощью Server.MapPath.
* Далее сохраняем файл с помощью SaveAs.
* Возвращаем имя файл в json data.filePath.
Проверяем, всё ли загружается, и приступим к созданию превью.
##### Создание превью
Во-первых, мы немного схитрили с mime-type = «image\...», ведь к ним относится и bmp, и tiff файлы, которые не поддерживаются браузерами.
Так что создадим класс PreviewCreator в проекте LessonProject.Tools (PreviewCreator.cs):
```
public static class PreviewCreator
{
public static bool SupportMimeType(string mimeType)
{
switch (mimeType)
{
case "image/jpg":
case "image/jpeg":
case "image/png":
case "image/gif":
return true;
}
return false;
}
}
```
И заменим в FileController.cs (/Areas/Default/Controller/FileController.cs):
```
if (mimeType != null && PreviewCreator.SupportMimeType(mimeType.Name))
```
В PreviewCreator есть много функций для создания превью, так что я перечислю разные варианты создания изображения и подробно разберу один из них. Стоит учесть, что все превью создаются в формате jpeg. Итак, какие есть варианты:
* Цветной и чернобелый вариант. Контролируется параметром grayscale (по умолчанию = false)
* Превью. (`CreateAndSavePreview`) Если исходное изображение меньше, чем размеры превью, то изображение размещается посередине белого холста. Если по отношению к размерам исходный размер имеет вертикальную ориентированность (квадратик из портретного формата) – вырезаем верхнюю часть. Если же отношение горизонтально ориентированно относительно размера, то вырезаем середину.
* Аватар. (`CreateAndSaveAvatar`) Если исходное изображение меньше, чем размеры превью, то изображение просто сохраняется. Если по отношению к размерам исходный размер имеет вертикальную ориентированность (квадратик из портретного формата) – то уменьшаем, по высоте. Если же отношение горизонтально ориентированно относительно размера, то вырезаем середину.
* Изображение. (`CreateAndSaveImage`) Если изображение меньше, чем максимальные размеры, то сохраняем исходное. Если же изображение не вписывается в границы, то уменьшаем, чтобы оно не превышало максимальный размер, и сохраняем.
* По размеру. (`CreateAndSaveFitToSize`) Если изображение меньше, чем размеры, то оно будет растянуто до необходимых размеров. С потерей качества, конечно же.
* Обрезать. (`CropAndSaveImage`) Кроме стандартных параметров передаются координаты для обрезки изображения.
Cоздадим превью (`CreateAndSavePreview`), взяв из конфигурации размеры для создания превью AvatarSize (/Areas/Default/Controllers/FileController.cs):
```
var filePreviewPath = Path.Combine("/Content/files/previews", qqfile.FileName);
var previewIconSize = Config.IconSizes.FirstOrDefault(c => c.Name == "AvatarSize");
if (previewIconSize != null)
{
PreviewCreator.CreateAndSavePreview(qqfile.InputStream, new Size(previewIconSize.Width, previewIconSize.Height), Server.MapPath(filePreviewPath));
}
return Json(new
{
success = true,
result = "error",
data = new
{
filePath,
filePreviewPath
}
});
```
Запускаем. Загружаем. Файлы должны загрузиться, и создастся превью.
Теперь сделаем обработку в file-index.js (/Scripts/default/file-index.js):
```
$('#UploadImage').fineUploader({
request: {
endpoint: _this.ajaxFileUpload
},
})
.on('error', function (event, id, name, reason) {
//do something
})
.on('complete', function (event, id, name, responseJSON) {
$("#ImagePreview").attr("src", responseJSON.data.filePreviewPath);
});
```
теперь наш файл загружается вместе с превью. Путь большого файла также можно передавать отдельно, и записывать, например, в hidden поле и сохранять в дальнейшем в БД как строку.
Что плохого в такой конструкции, так это две следующие проблемы:
* файлы могут быть перезаписаны, но это решается тем, что можно брать только расширение, а имя файлу присваивать отдельно, или добавлять немного соли
* файлы могут быть загружены и не связаны с БД. Это можно решить тем, что для каждой таблице файлы записывать в отдельную папку, а потом делать поиск и удалять не записанные.
##### Получение файлов по ссылке
Есть еще один метод загрузки файла. Файл свободно болтается в интернете, а мы указываем путь к нему (например, при авторизации с facebook), а мы уже по ссылке сохраняем этот файл.
Это делается так:
```
var webClient = new WebClient();
var bytes = webClient.DownloadData(url);
var ms = new MemoryStream(bytes);
```
Где url – путь к файлу. Можно сложнее, с использованием HttpWebRequest:
```
public ActionResult Export(string uri)
{
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
webRequest.Method = "GET";
webRequest.KeepAlive = false;
webRequest.PreAuthenticate = false;
webRequest.Timeout = 1000;
var response = webRequest.GetResponse();
var stream = response.GetResponseStream();
var previewIconSize = Config.IconSizes.FirstOrDefault(c => c.Name == "AvatarSize");
var filePreviewPath = Path.Combine("/Content/files/previews", Guid.NewGuid().ToString("N") + ".jpg");
if (previewIconSize != null)
{
PreviewCreator.CreateAndSavePreview(stream, new Size(previewIconSize.Width, previewIconSize.Height), Server.MapPath(filePreviewPath));
}
return Content("OK");
}
```
Тут файл задается через генерацию Guid.NewGuid. Проверяем:
```
http://localhost/File/Export?uri=https://st.free-lance.ru/users/chernikov/upload/sm_f_81850beffd0d0c89.jpg
```
Файл загрузился и обработан. Всё супер!
Рекомендую пройтись дебаггером по работе PreviewCreator, чтобы понять, как там всё устроено.
Все исходники находятся по адресу <https://bitbucket.org/chernikov/lessons> | https://habr.com/ru/post/176069/ | null | ru | null |
# Экспорт ключа SignalCom в OpenSSL
*У вас стоит задача интегрироваться с удалённым сервисом, который работает по ГОСТу и "только через КРИПТО-КОМ", а вы хотите использовать OpenSSL с gost? На форуме "Сигнал-КОМ" вы видите кучи сообщений, что "ключи из формата КРИПТО-КОМ нельзя конвертировать в формат OpenSSL-гост-совместимых"? На самом деле конвертация возможна.*
**tl;dr:** <http://gostcrypto.com/demo-sc-keys.html>
Как сконвертировать уже имеющиеся ключи из проприетарного в ортодоксальный формат?
Я не параноик
-------------
Идёте на <http://gostcrypto.com/demo-sc-keys.html> и указав файлы контейнера типа "mk.db3", "masks.db3", "kek.opq", "rand.opq" и файл приватного ключа по типу "Keys\00000001.key", нажмите кнопку "Export PrivateKey".
В текущей версии gostcrypto.com ключ будет не совсем PEM-совместимым, т.к. используется длина более 64 символов:
```
-----BEGIN PRIVATE KEY-----
MEYCAQAwHQYGKoUDAgITMBMGByqFAwICIwEGCCqFAwcBAQICBCIEIG0GEmE3dhrHzm1KfFDpKBWEmMydwcmP0hNKvXXbEbLO
-----END PRIVATE KEY-----
```
Чтобы сделать его PEM-совместимым просто добавьте новую строку после 64 символа:
```
-----BEGIN PRIVATE KEY-----
MEYCAQAwHQYGKoUDAgITMBMGByqFAwICIwEGCCqFAwcBAQICBCIEIG0GEmE3dhrH
zm1KfFDpKBWEmMydwcmP0hNKvXXbEbLO
-----END PRIVATE KEY-----
```
Я параноик или хочу cli-версию
------------------------------
На момент публикации этой статьи gostcrypto не node-фицирована и есть попытка её node-фикации в пул-реквесте. Там же cli-утилита для экспорта в PEM-compatible формат.
Ставим её и пробуем экспортировать ключ:
```
sudo npm install -g https://github.com/garex/nodejs-gost-crypto/archive/nodefy.tar.gz
cd /tmp
wget https://www.contact-sys.com/files/redactor/files/TestContactKey.zip
unzip TestContactKey.zip -d TestContactKey
gost-export-signalcom-key --pse TestContactKey --key Keys/00000001.key
```
В результате мы получаем в STDOUT:
```
-----BEGIN PRIVATE KEY-----
MEYCAQAwHQYGKoUDAgITMBMGByqFAwICIwEGCCqFAwcBAQICBCIEIG0GEmE3dhrH
zm1KfFDpKBWEmMydwcmP0hNKvXXbEbLO
-----END PRIVATE KEY-----
```
И в STDERR:
```
OK: Private SignalCom key successfully exported in STDOUT in "PEM" format.
``` | https://habr.com/ru/post/317406/ | null | ru | null |
# Оver-provisioning ресурсов в кластерах на базе mesos
Разработчики Apache mesos [заявляют](http://mesos.apache.org/documentation/latest/oversubscription/), что mesos научился делать overprovisioning начиная с версии 0.23.0, вышедшей в сентябре прошлого года. Для этого ввели понятие отзываемых (revocable) ресурсов, и если приложение выполняется на отзываемых ресурсах — его всегда можно попросить освободить ресурсы частично (throttle) или полностью (kill). Определить, на каких ресурсах будет выполняться задача можно на этапе запуска, пометив некоторые (или все) запрошенные задачей ресурсы как `revocable`.
На практике, для использования этой фичи нужно:
* Заявить о поддержке REVOCABLE\_RESOURCES при регистрации framework в mesos
* Подключить к mesos slave модуль resource estimator, который бы оценивал количество отзываемых ресурсов (например измеряя разницу между потребленными и выделенными ресурсами) и предсказывал изменения в потреблении ресурсов (например на основе статистической модели)
* Подключить к mesos slave модуль QoS Controller, который бы убивал или ограничивал в ресурсах задачи, запущенные на отзываемых ресурсах.
Как видно из требований выше, для эффективного использования предложенной модели требуется некоторая поддержка со стороны выполняемых в mesos задач, как минимум в части управления потребляемыми ресурсами. Конечно, будет очень круто написать resource estimator привязанный к логике приложения, но даже предсказания на основе ежедневной статистики изменения нагрузки дадут неплохой эффект.
В комплекте с mesos сейчас поставляются пара resource estimator'ов:
* `noop` — заглушка, запрещающая oversubscription
* `fixed` — позволяющий объявить отзываемыми фиксированное количество ресурсов хоста.
и пара qos controller'ов:
* `noop` — отключит отзыв ресурсов на уровне хоста
* `load` — умеет убивать все задачи, выполняемые на отзываемых ресурсах, если load average на хосте превысит пороговые значения
К сожалению на этом хорошие новости пока заканчиваются, т.к. поддержка со стороны распространенных framework'ов практически отсутствует.
В **Marathon** например поддержка отзываемых ресурсов пока реализована крайне слабо:
* первый пункт требований [выполнен чисто формально](https://github.com/mesosphere/marathon/blob/releases/0.15/src/main/proto/mesos/mesos.proto#L262) в релизе 0.15.0
* есть [статья](https://mesosphere.com/blog/2015/08/26/turbocharging-your-mesos-cluster-with-oversubscription/) квартальной давности в корпоративном блоге.
* есть [opened issue](https://github.com/mesosphere/marathon/issues/2424) на поддержку revocable (resource) offers с крайне вялым обсуждением.
Кстати, в вышеупомянутой [статье](https://mesosphere.com/blog/2015/08/26/turbocharging-your-mesos-cluster-with-oversubscription/) есть утверждение которое полезно показать менеджменту, требующему оптимизировать использование ресурсов отталкиваясь от низкой утилизации cpu на хостах, например:
*While CPU and memory allocation is often close to or above 80% of those peak loads, the average usage is typically below 20%.*
В **kubernets**, и того меньше — удалось найти один [непопулярный issue](https://github.com/kubernetes/kubernetes/issues/19529) с упоминанием проблемы.
Таким образом, сейчас на базе стека mesos-marathon не получится использовать over-provisioned ресурсы, что явно сказывается на экономической эффективности решения. | https://habr.com/ru/post/276773/ | null | ru | null |
# Автоматизация создания объектов при помощи конвейера
Привет, Хабр!
Я не являюсь каким-то очень известным экспертом, однако мне очень интересен процесс обработки данных, а также написания кода для обработки этих самых данных. В процессе написания различных методов обработки этих самых данных у меня родилась идея частичной автоматизации, кхм, написания методов обработки.
Введение
--------
Предположим, у нас есть набор инструментов(сущностей) для обработки какого-то потока данных, или построения других комплексных сущностей, а также постоянно меняющиеся условия последовательности композиции этих сущностей для воспроизведения алгоритма обработки.
На примере транспортных средств
-------------------------------
Есть у нас набор атомарных компонентов:
```
class EngineA;
class EngineB;
class WingsA;
class WingsB;
class FrameA;
class FrameB;
class WheelsA;
class WheelsB;
```
и т.д.
Если нам нужна машина - мы просто объявляем **класс Car**, в котором есть нужный корпус, колеса, двигатель и т.д. Аналогично с какой-нибудь лодкой, мы бы объявили **класс Boat**, и быстренько набросали агрегацию нужных частей лодки.
Если же нам нужна и лодка, и машина, и даже самолет - мы можем воспользоваться паттерном фабрика, но что делать, если нам нужны машины, лодки, самолеты, и мы заранее не знаем сколько, когда, и в каком порядке.
Можно под каждую задачу писать отдельную агрегацию, предусмотрев классы Car, Boat, Plane с общим интерфейсом ITransport. Если нам нужно 2 машины, и 5 лодок - мы можем через цикл создать необходимое количество объектов. Однако, если нам важна последовательность, создавать подряд однотипные объекты через циклы уже не так просто. И чем больше параметров - тем больше времени нужно будет на написание того или иного кода для очередного шаблонного транспортного средства
**Попробуем сэкономить это время, поставив создание объектов на поток!**
Положим, у нас есть некий интерфейс ITransport
```
class ITransport
{
public:
virtual void move() = 0;
};
```
реализованный в таких классах как Car, Boat, Plane.
```
class Car final : public virtual ITransport
{
public:
Car() = default;
~Car() = default;
void move() override
{
std::cout << "Car is move" << std::endl;
// do something with parts
}
private:
std::unique_ptr < IFrame > _frame;
std::unique_ptr < IWheels > _wheels;
std::unique_ptr < IEngine > _engine;
};
class Boat final : public virtual ITransport
{
public:
Boat() = default;
~Boat() = default;
void move() override
{
std::cout << "Boat is move" << std::endl;
// do something with parts
}
private:
std::unique_ptr < IFrame > _frame;
std::unique_ptr < IEngine> _engine;
};
class Plane final : public virtual ITransport
{
public:
Plane() = default;
~Plane() = default;
void move() override
{
std::cout << "Plane is move" << std::endl;
// do something with parts
}
private:
std::unique_ptr < IFrame > _frame;
std::unique_ptr < IEngine> _engine;
std::unique_ptr < IWings > _wings;
};
```
И нам нужно сделать 2 машины, лодку, 3 самолета и еще одну лодку, и именно в такой последовательности.
Перед самим классом конвейера будет необходимо объявить словарь с видами транспорта, который наш конвейер должен уметь производить. Для универсальности будем все необходимые параметры хранить в виде строк.
```
enum class VehTypes
{
Car,
Boat,
Plane
};
static std::map < std::string, VehTypes > VehCast{
{"Car", VehTypes::Car},
{"Boat", VehTypes::Boat},
{"Plane", VehTypes::Plane}
};
```
**Теперь, сам класс конвейера.**
```
class Conveyor final
{
public:
using _TyParameters = std::map < std::string, std::string >;
using _TyStorage = std::vector < _TyParameters >;
Conveyor(const _TyStorage& blueprints)
: _blueprints(blueprints) { }
~Conveyor() = default;
std::vector < Vehicles::ITransport* > vehicles()
{
std::vector < Vehicles::ITransport* > result;
for (auto&& blueprint : _blueprints)
{
switch (VehCast[blueprint["type"]])
{
case VehTypes::Car: result.emplace_back(new Vehicles::Car());
break;
case VehTypes::Boat: result.emplace_back(new Vehicles::Boat());
break;
case VehTypes::Plane: result.emplace_back(new Vehicles::Plane());
break;
}
}
return result;
}
private:
_TyStorage _blueprints;
};
```
Исходя из нежелания сильно переусложнять пример я опущу код интерпретатора для построения объекта из текстовых данных, а также прочие однотипные моменты касательно создания объектов.
Для удобства понимания переопределяем два новых типа:
* Параметры - словарь с информацией о транспортном средстве
* Хранилище - массив с информацией об объектах, в нужной нам последовательности.
```
using _TyParameters = std::map < std::string, std::string >;
using _TyStorage = std::vector < _TyParameters >;
```
В конструктор мы лишь передаем информацию о том, какие транспортные средства нам нужны(их описание).
Дальше, единственное что нам нужно - пройтись циклом по данным описаниям, и на их основе заполнить наш массив транспортных средств сконструированными объектами конкретных видов.
**Проверяем**
Создаем необходимый список(над этим можно отдельно поработать) транспортных средств с их параметрами.
Создаем конвейерный класс и передаем ему этот список.
Получаем набор готовых объектов.
```
Conveyor::_TyStorage blueprints
{
{
{"type", "Car"}, {"engineType", "EngineA"}, {"wheelsType", "WheelsB"}, etc..
},
{
{"type", "Car"},
},
{
{"type", "Boat"},
},
{
{"type", "Plane"},
},
{
{"type", "Plane"},
},
{
{"type", "Plane"}
},
{
{"type", "Boat"}
},
};
Conveyor conveyor(blueprints);
for (auto&& transport : conveyor.vehicles())
{
transport->move();
}
```
**Результат**
В итоге
-------
И хотя мы тратим не сильно меньше времени на описание композиции атомарных объектов для каждой операции, суммарно, мы потратим на много меньше времени на процесс описания всего набора операций.
Данный способ не отличается идеальной производительностью, и по началу требует время на описание всех необходимых компонентов, однако в дальнейшем снижает суммарное время на описание новых последовательностей обработки данных/конструирования сущностей.
Из слабых мест данного подхода к конструированию объектов могу отметить необходимость каждый раз добавлять новые типы в словарь, а также постоянно дописывать интерпретатор новых текстовых параметров, если у вас постоянно добавляются новые атомарные компоненты. | https://habr.com/ru/post/539512/ | null | ru | null |
# Планировщик путешествий своими руками за пару часов
*Автор: Сергей Матвеенко*
Однажды ко мне пришел инвестор одного проекта и сказал: «Давай сделаем планировщик путешествий по картам Google!» Я согласился. Тогда инвестор стал рассказывать, как техдиректор представлял себе архитектуру этого планировщика: он говорил что-то про связь с сервером, про ключ API, про запросы в Google, про деньги за запросы, которых будет много и т. д. Все выглядело сложно и красиво. Однако затем мы стали внимательно читать документацию Google API и вдруг поняли, что на самом деле нам сервер не нужен. Вообще! Весь планировщик можно сделать на клиенте. А самое интересное — мы можем обойтись даже без API-ключа (при условии, что мы будем использовать JS API). В итоге я за два дня смог написать такой планировщик, с логикой на стороне клиента, на основе Google API, без использования сервера. Все оказалось очень просто.
Я расскажу, как можно сделать простейший планировщик такого рода буквально за пару часов. Конечно, за это время можно собрать только прототип, но главное — он будет работать! Его главной функцией будет прокладка оптимального маршрута между достопримечательностями в интересующем нас городе; может присутствовать разбивка плана поездки по дням. Все будет сделано на AngularJS с использованием Google Maps/Places API. Я расскажу об особенностях работы с этим API и о некоторых его возможностях, которые не указаны в документации. Также мы поговорим о выделении логики в клиентские приложения.
Итак, как именно будет выглядеть такой планировщик? Это будет просто строка поиска в браузере, в которую мы будем вводить название интересующего нас города или места. В ответ на такой поисковый запрос нам будет выдаваться это место на карте Google, список достопримечательностей в этом месте и ближайших окрестностях с описанием, фотографиями и отзывами. И, конечно, между достопримечательностями будет прокладываться оптимальный маршрут по картам Google c указанием примерного времени перемещения между ними. Также можно будет легко добавить возможность разбить план посещения достопримечательностей по дням.
Что нам понадобится?
--------------------
Во-первых, нам понадобится библиотека **Google** **Places**. Это самое главное, что обеспечит работу планировщика:
```
```
— это **Autocomplete**, очень полезный проект для AngularJS, который оборачивает библиотеку Google Places и работу с автозаполнением. Rawgit — обвязка вокруг GitHub, у которой тоже есть CDN.
```
```
— это собственно **AngularJS**.
```
```
— это **Bootstrap**.
```
```
— это **jQuery**, который нужен Bootstrap’у.
```
```
— это **таблицы стилей** от Autocomplete и Bootstrap.
Вот и все внешнее, что у нас есть. Все это загружено с CDN — сервер нам не нужен вообще!
Ищем место на карте
-------------------
Теперь попробуем сделать поиск интересующего нас города на карте. Вот как мы используем Autocomplete:
```
destinationData
```
{{destination|json}}
```
```
Как мы видим, тут у нас один input:
```
```
Таким образом, благодаря Angular-проекту Google Places Autocomplete мы получаем работающее автозаполнение. Это значит, что мы можем начать вводить название места в форму поиска (даже с ошибками), и нам в поиске будут предлагаться подходящие варианты:
В итоге у нас получился поиск места с отображением его местоположения на карте Google:
Что дальше?
Ищем ближайшие достопримечательности
------------------------------------
Раньше (до версии 3) поиск по местам в Google API осуществлялся одним методом — там было очень много параметров, и все было очень сложно. Теперь поиск поделен на три метода. В частности, появился выделенный radar search — поиск по ближайшим интересным местам. Раньше такие места приходилось дополнительно фильтровать, т. к. в результатах поиска попадались города и страны. А сейчас все просто.
### Как он работает?
Google обычно предлагает сразу показывать результаты поиска на карте. Но, на самом деле, нам это сейчас не нужно, ведь мы просто хотим получить список ближайших мест. Поэтому мы используем radar search (`service.radarSearch`) без карты в радиусе 50 км — это обычный радиус города и окрестностей. Мы ищем обычные туристические места вроде музеев, церквей, ночных клубов, зоопарков и т. д., которые мы перечисляем как типы Google (`types`).
```
$scope.destinationOptions = {
location : destination.geometry.location,
radius : 50000
};
$scope.popularPoints = [];
$scope.map = new google.maps.Map(document.getElementById('map'), {
center : $scope.destinationOptions.location,
zoom : 5
});
var service = new google.maps.places.PlacesService($scope.map);
var radarOptions = {
location : $scope.destinationOptions.location,
radius : $scope.destinationOptions.radius,
types : [ 'airport', 'amusement_park', 'aquarium', 'art_gallery', 'casino', 'church',
'city_hall', 'courthouse', 'hindu_temple', 'library', 'museum', 'night_club',
'park', 'stadium', 'synagogue', 'university', 'zoo' ]
};
service.radarSearch(radarOptions, function(points) {
points.slice(0, 8).forEach(function(point) {
service.getDetails({
placeId : point.place_id
}, function(details) {
$scope.popularPoints.push(details);
});
});
$scope.$digest();
});
```
Итак, мы получаем запрос к радар-поиску и вместо того, чтобы использовать рендерер и начать работать с картой, забираем все в Angular, и поиск выдает нам восемь первых мест (а возвращает он 200 результатов). Сразу же мы с помощью того же сервиса запрашиваем подробности о местах и добавляем к себе в ангуляровский scope: `$scope.popularPoints.push(details)`.
Так мы сделали поиск — когда находим место на карте, тут же отображается и список всех достопримечательностей в радиусе 50 км. Также, если это нужно, мы сможем раскрыть этот список и увидеть изображения этого места, а также разные подробности и комментарии пользователей с рейтингом.
Прокладываем маршрут
--------------------
Но если бы я просто показал самые лучшие достопримечательности в результатах поиска, инвестор был бы недоволен, ведь хочется еще спланировать наилучший маршрут по этим местам. Поэтому под результатами поиска у нас будет кнопка, которая сможет показать нам этот маршрут. Как она работает?
Оказывается, и тут тоже Google всё сделал за нас — он предоставляет полный интерфейс к механизмам Google Maps по планированию и прокладке маршрутов — вплоть до промежуточных точек. Но, как любят говорить некоторые мои знакомые, API тут сделан «чужими для хищников». Потому что, если у меня есть список точек, я просто хочу передать их вместе и сказать, что собираюсь по ним поездить. Но оказывается, что так не бывает, а бывает так, что мы начинаем только в каком-то одном месте и заканчиваем в каком-то другом конкретном месте, и внутри нужно выцепить slice’ом промежуточные точки.
```
$scope.tripCalc = function() {
var directionsService = new google.maps.DirectionsService();
directionsService.route({
origin : $scope.points[0].geometry.location,
destination : $scope.points[$scope.points.length - 1].geometry.location,
waypoints : $scope.points.slice(1, $scope.points.length - 1).map(function(point) {
return {
location : point.geometry.location
};
}),
travelMode: google.maps.TravelMode.DRIVING
}, function(result) {
$scope.route = result;
$scope.$digest();
});
}
```
Однако мы нашли выход — замыкали точки начала (`origin`) и конца (`destination`) маршрута на отель, в котором отдыхает человек. Также мы потом сделали и разбиение по дням — с учетом, что ночевать мы можем в разных отелях. Т. ч. можно сделать и так, например, что начальная точка — аэропорт, вторая — пункт аренды автомобилей, а конечная — отель первой ночи. Еще мы можем проложить маршрут так, чтобы искать в середине дня рестораны, чтобы пообедать. Все эти точки можно получить с помощью указания соответствующих типов в запросе к API Google Maps (параметр `types`). На самом деле, это простая задача программирования — выстроить массив объектов и отразить его в `waypoints`. Так мы получаем готовый маршрут.
Самое интересное и самое приятное — возможность показывать дистанцию и время, которое будет потрачено на то, чтобы переместиться между двумя точками маршрута. Это значит, что, если мы, например, едем между точками шесть часов — это подсказка, чтобы подыскать ресторан по пути, а если едем через ночь — значит, хорошо бы подсказать и отель. Все это делается на клиенте.
Нужен ли сервер?
----------------
И тут мы подходим к интересной дискуссии, которая возникла у нас, когда мы делали этот планировщик путешествий. А действительно ли мы хотим сохранять все это на сервере? Нужно ли нам знать, что искал пользователь?
На самом деле, нам интересно только одно: чтобы пользователь заказал у нас то, что мы хотим продать. Не буду говорить, что мы хотели продать пользователю, но, допустим, это могут быть комнаты в отелях, которые он выбрал в этом планировщике. По большому счету, этот планировщик — просто added value, добавленная стоимость, всего лишь удобный сервис на сайте, который продает комнаты в отелях. Т. ч. нам на сервере сохранять ничего не нужно — все можно делать на клиенте. Таким образом, мы можем просто прикрутить кнопки для бронирования номеров в отелях там, где эти отели отображаются при планировании маршрута.
Конечно, какая-то аналитика нам все же может понадобиться, но и тут мы можем обойтись без сервера, если используем Google Analytics. Так, например, если нам нужно знать, какие места больше всего искали пользователи, текст поиска может без проблем прыгать через HTML5 API в URL, и Google Analytics это подхватит.
Все остальное нас уже не очень волнует. Мы можем теперь рекламировать страницу, а Google пусть справляется с нагрузкой — при этом будет ограничено только количество запросов с одного IP, т. е. от пользователя. Мы можем выложить страницу на Amazon S3 и тогда сможем вообще не думать о нагрузке и о том, что наша рекламная кампания может положить наши серверы. Если же мы добавим еще отзывы от пользователей, пользователь начнет завязываться на какой-то интерактив на сайте, который, на самом деле, весь загружен снаружи.
Так что планировщик мы практически сделали — еще немного, и его можно продавать.
На самом деле, именно такие способы организации интерфейса эффективнее всего. Сейчас большие поставщики действительно сделали все, чтобы нам ни о чем не надо было беспокоиться. Например, последние два года, когда мои знакомые спрашивали, как им сделать сайт, я не мог ответить им ничего лучше, кроме как: «Идите на blogspot». Ведь там все есть! Так и Google Maps предоставляет все, что нужно. Но на каких условиях?
Условия использования GoogleMaps API
------------------------------------
Если бегло читать официальные инструкции к Google Maps API, может показаться, что все обязательно должно происходить где-то на картах Google — мы должны что-то нарисовать и ничего с этим не делать. Но, если читать внимательней, оказывается, что, по условиям Google, все, что мы обязаны делать — это, грубо говоря, нарисовать в нижнем углу логотип Google и ссылки на всякие условия использования. Получается, что Google дал нам все необходимые данные, и мы на их основе можем хоть собственную карту рисовать и вообще распихивать эти данные, как нам угодно, лишь бы не забыть написать, что данные получены от Google. Поэтому вы можете делать на сайте все, что угодно на JavaScript, и без всякого сервера.
Исходник проекта
----------------
[Gist](https://gist.github.com/lig/29e1494bc1a578b5898b9974a0e3726a#file-index-html) | https://habr.com/ru/post/301310/ | null | ru | null |
# Прореживание таймфреймов (криптовалюты, форекс, биржи)
Некоторое время назад передо мной была поставлена задача написать процедуру, которая выполняет прореживание котировок рынка Форекс (точнее, данных таймфреймов).
Формулировка задачи: данные поступают на вход с интервалом в 1 секунду в таком формате:
* Название инструмента (код пары USDEUR и пр.),
* Дата и время в формате unix time,
* Open value (цена первой сделки в интервале),
* High value (максимальная цена),
* Low value (минимальная цена),
* Close value (цена последней сделки),
* Volume (громкость, или объём сделки).
Необходимо обеспечить пересчёт и синхронизацию данных в таблицах: 5 сек, 15 сек, 1 мин, 5 мин, 15 мин, и т.д.
Описанный формат хранения данных имеет название OHLC, или OHLCV (Open, High, Low, Close, Volume). Он применяется часто, по нему сразу можно построить график «Японские свечи».
Под катом я описал все варианты, какие смог придумать, как можно прореживать (укрупнять) полученные данные, для анализа, например, зимнего скачка цены биткоина, а по полученным данным вы сразу построите график «Японские свечи» (в MS Excel такой график тоже есть). На картинке выше этот график построен для таймфрейма «1 месяц», для инструмента «bitstampUSD». Белое тело свечи означает рост цены в интервале, чёрное — снижение цены, верхний и нижние фитили означают максимальную и минимальную цены, которые достигались в интервале. Фон — объём сделок. Хорошо видно, что в декабре 2017 цена вплотную приблизилась к отметке 20К.
Решение будет приведено для двух движков БД, для Oracle и MS SQL, что, в некотором роде, даст возможность сравнить их на этой конкретной задаче (обобщать сравнение на другие задачи мы не будем).
Тогда я решил задачу тривиальным способом: расчёт верного прореживания во временную таблицу и синхронизация с целевой таблицей — удаление строк, которые существуют в целевой таблице, но не существуют во временной и добавление строк, которые существуют во временной таблице, но не существуют в целевой. На тот момент Заказчика решение удовлетворило, и задачу я закрыл.
Но сейчас я решил рассмотреть все варианты, потому что указанное выше решение содержит одну особенность — его трудно оптимизировать для двух случаев сразу:
* когда целевая таблица пуста и нужно добавить много данных,
* и когда целевая таблица большая, и необходимо добавлять данные маленькими порциями.
Это связано с тем, что в процедуре придётся соединять целевую таблицу и временную таблицу, а присоединять нужно к большей меньшую, а не наоборот. В указанных выше двух случаях большая/меньшая меняются местами. Оптимизатор будет принимать решение о порядке соединения на основании статистики, а статистика может быть устаревшая, и решение может быть принято неверное, что приведёт к значительной деградации производительности.
В этой статье я опишу методы разового прореживания, которое может пригодиться читателям для анализа, например, зимнего скачка цены биткоина.
Процедуры онлайн-прореживания можно будет скачать с github по ссылке внизу статьи.
К делу… Моя задача касалась прореживания с таймфрейма «1 сек» до следующих, но здесь я рассматриваю прореживания с уровня транзакций (в исходной таблице поля STOCK\_NAME, UT, ID, APRICE, AVOLUME). Потому что такие данные выдаёт сайт bitcoincharts.com.
Собственно, прореживание c уровня транзакций до уровня «1 сек» выполняется такой командой (оператор легко транслируется в прореживание с уровня «1 сек» до верхних уровней):
**На Oracle:**
```
select
1 as STRIPE_ID
, STOCK_NAME
, TRUNC_UT (UT, 1) as UT
, avg (APRICE) keep (dense_rank first order by UT, ID) as AOPEN
, max (APRICE) as AHIGH
, min (APRICE) as ALOW
, avg (APRICE) keep (dense_rank last order by UT, ID) as ACLOSE
, sum (AVOLUME) as AVOLUME
, sum (APRICE * AVOLUME) as AAMOUNT
, count (*) as ACOUNT
from TRANSACTIONS_RAW
group by STOCK_NAME, TRUNC_UT (UT, 1);
```
Функция *avg () keep (dense\_rank first order by UT, ID)* работает так: поскольку запрос с группировкой GROUP BY, то каждая группа рассчитывается независимо от других. В пределах каждой группы строки сортируются по UT и ID, нумеруются функцией *dense\_rank*. Поскольку далее идет функция first, то выбирается та строка, где *dense\_rank* вернула 1 (иными словами, выбирается минимальное) — выбирается первая транзакция внутри интервала. Для этого минимального UT, ID, если бы там было несколько строк, считалось бы среднее. Но в нашем случае там будет гарантированно одна строка (из-за уникальности ID), поэтому получившееся значение сразу возвращается как AOPEN. Несложно заметить, что функция *first* заменяет собой две агрегатные.
**На MS SQL**
Здесь нет функций *first/last* (есть *first\_value/last\_value*, но это не то). Поэтому придётся соединять таблицу саму с собой.
Запрос отдельно приводить не буду, но его можно посмотреть ниже в процедуре *dbo.THINNING\_HABR\_CALC*. Конечно, без *first/last* он не настолько изящен, но работать будет.
Как же эту задачу можно решить одним оператором? (Здесь, под термином «один оператор» подразумевается не то, что оператор будет один, а то, что не будет циклов, «дёргающих» данные по одной строчке.)
Я перечислю все известные мне варианты решения этой задачи:
1. SIMP (simple, простой, декартово произведение),
2. CALC (calculate, итерационное прореживание верхних уровней),
3. CHIN (china way, громоздкий запрос для всех уровней сразу),
4. UDAF (user-defined aggregate function),
5. PPTF (pipelined and parallel table function, процедурное решение, но всего с двумя курсорами, фактически, два оператора SQL),
6. MODE (model, фраза MODEL),
7. и IDEA (ideal, идеальное решение, которое не может работать сейчас).
Забегая вперёд скажу, что этот тот редкий случай, когда процедурное решение PPTF оказывается самым эффективным на Oracle.
Скачаем файлы транзакций с сайта <http://api.bitcoincharts.com/v1/csv>
Я рекомендую выбрать файлы kraken\*. Файлы localbtc\* сильно зашумлены — содержат отвлекающие строки с нереалистичными ценами. Все kraken\* содержат порядка 31M транзакций, я рекомендую исключить оттуда krakenEUR, тогда транзакций становится 11М. Это наиболее удобный объём для тестирования.
Выполним скрипт в Powershell для генерации управляющих файлов для SQLLDR для Oracle и для генерации запроса импорта для MSSQL.
```
# MODIFY PARAMETERS THERE
$OracleConnectString = "THINNING/aaa@P-ORA11/ORCL" # For Oracle
$PathToCSV = "Z:\10" # without trailing slash
$filenames = Get-ChildItem -name *.csv
Remove-Item *.ctl -ErrorAction SilentlyContinue
Remove-Item *.log -ErrorAction SilentlyContinue
Remove-Item *.bad -ErrorAction SilentlyContinue
Remove-Item *.dsc -ErrorAction SilentlyContinue
Remove-Item LoadData-Oracle.bat -ErrorAction SilentlyContinue
Remove-Item LoadData-MSSQL.sql -ErrorAction SilentlyContinue
ForEach ($FilenameExt in $Filenames)
{
Write-Host "Processing file: "$FilenameExt
$StockName = $FilenameExt.substring(1, $FilenameExt.Length-5)
$FilenameCtl = '.'+$Stockname+'.ctl'
Add-Content -Path $FilenameCtl -Value "OPTIONS (DIRECT=TRUE, PARALLEL=FALSE, ROWS=1000000, SKIP_INDEX_MAINTENANCE=Y)"
Add-Content -Path $FilenameCtl -Value "UNRECOVERABLE"
Add-Content -Path $FilenameCtl -Value "LOAD DATA"
Add-Content -Path $FilenameCtl -Value "INFILE '.$StockName.csv'"
Add-Content -Path $FilenameCtl -Value "BADFILE '.$StockName.bad'"
Add-Content -Path $FilenameCtl -Value "DISCARDFILE '.$StockName.dsc'"
Add-Content -Path $FilenameCtl -Value "INTO TABLE TRANSACTIONS_RAW"
Add-Content -Path $FilenameCtl -Value "APPEND"
Add-Content -Path $FilenameCtl -Value "FIELDS TERMINATED BY ','"
Add-Content -Path $FilenameCtl -Value "(ID SEQUENCE (0), STOCK_NAME constant '$StockName', UT, APRICE, AVOLUME)"
Add-Content -Path LoadData-Oracle.bat -Value "sqlldr $OracleConnectString control=$FilenameCtl"
Add-Content -Path LoadData-MSSQL.sql -Value "insert into TRANSACTIONS_RAW (STOCK_NAME, UT, APRICE, AVOLUME)"
Add-Content -Path LoadData-MSSQL.sql -Value "select '$StockName' as STOCK_NAME, UT, APRICE, AVOLUME"
Add-Content -Path LoadData-MSSQL.sql -Value "from openrowset (bulk '$PathToCSV\$FilenameExt', formatfile = '$PathToCSV\format_mssql.bcp') as T1;"
Add-Content -Path LoadData-MSSQL.sql -Value ""
}
```
Создадим таблицу транзакций на Oracle.
```
create table TRANSACTIONS_RAW (
ID number not null
, STOCK_NAME varchar2 (32)
, UT number not null
, APRICE number not null
, AVOLUME number not null)
pctfree 0 parallel 4 nologging;
```
На Oracle запустите файл *LoadData-Oracle.bat*, предварительно исправив параметры подключения в начале скрипта Powershell.
Я работаю на виртуальной машине. Загрузка всех файлов 11M транзакций в 8 файлах kraken\* (я пропустил файл EUR) заняла порядка 1 минуты.
И создадим функции, которые будут выполнять усечение дат до границ интервалов:
```
create or replace function TRUNC_UT (p_UT number, p_StripeTypeId number)
return number deterministic is
begin
return
case p_StripeTypeId
when 1 then trunc (p_UT / 1) * 1
when 2 then trunc (p_UT / 10) * 10
when 3 then trunc (p_UT / 60) * 60
when 4 then trunc (p_UT / 600) * 600
when 5 then trunc (p_UT / 3600) * 3600
when 6 then trunc (p_UT / ( 4 * 3600)) * ( 4 * 3600)
when 7 then trunc (p_UT / (24 * 3600)) * (24 * 3600)
when 8 then trunc ((trunc (date '1970-01-01' + p_UT / 86400, 'Month') - date '1970-01-01') * 86400)
when 9 then trunc ((trunc (date '1970-01-01' + p_UT / 86400, 'year') - date '1970-01-01') * 86400)
when 10 then 0
when 11 then 0
end;
end;
create or replace function UT2DATESTR (p_UT number) return varchar2 deterministic is
begin
return to_char (date '1970-01-01' + p_UT / 86400, 'YYYY.MM.DD HH24:MI:SS');
end;
```
Рассмотрим варианты. Сначала приведен код всех вариантов, далее скрипты для запуска и тестирования. Сначала задача описана для Oracle, далее — для MS SQL
#### Вариант 1 — SIMP (Тривиальный)
Весь набор транзакций умножается декартовым произведением на набор из 10 строк с числами от 1 до 10. Это нужно, чтобы из одной строки транзакции получить 10 строк с усечёнными до границ 10 интервалов датами.
После этого строки группируются по номеру интервала и усечённой дате и выполняется приведённый выше запрос.
Создадим VIEW:
```
create or replace view THINNING_HABR_SIMP_V as
select STRIPE_ID
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID) as UT
, avg (APRICE) keep (dense_rank first order by UT, ID) as AOPEN
, max (APRICE) as AHIGH
, min (APRICE) as ALOW
, avg (APRICE) keep (dense_rank last order by UT, ID) as ACLOSE
, sum (AVOLUME) as AVOLUME
, sum (APRICE * AVOLUME) as AAMOUNT
, count (*) as ACOUNT
from TRANSACTIONS_RAW
, (select rownum as STRIPE_ID from dual connect by level <= 10)
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID);
```
#### Вариант 2 — CALC (вычисляемый итерационно)
В этом варианте мы итерационно прореживаем с транзакций до уровня 1, с уровня 1 до уровня 2, и так далее
Создадим таблицу:
```
create table QUOTES_CALC (
STRIPE_ID number not null
, STOCK_NAME varchar2 (128) not null
, UT number not null
, AOPEN number not null
, AHIGH number not null
, ALOW number not null
, ACLOSE number not null
, AVOLUME number not null
, AAMOUNT number not null
, ACOUNT number not null
)
/*partition by list (STRIPE_ID) (
partition P01 values (1)
, partition P02 values (2)
, partition P03 values (3)
, partition P04 values (4)
, partition P05 values (5)
, partition P06 values (6)
, partition P07 values (7)
, partition P08 values (8)
, partition P09 values (9)
, partition P10 values (10)
)*/
parallel 4 pctfree 0 nologging;
```
Вы можете создать индекс по полю STRIPE\_ID, но экспериментальным путём установлено, что на объёме 11М транзакций без индекса получается выгоднее. При б**о**льших количествах ситуация может измениться. А можно партиционировать таблицу, раскомментирвав блок в запросе.
Создадим процедуру:
```
create or replace procedure THINNING_HABR_CALC_T is
begin
rollback;
execute immediate 'truncate table QUOTES_CALC';
insert --+ append
into QUOTES_CALC
select 1 as STRIPE_ID
, STOCK_NAME
, UT
, avg (APRICE) keep (dense_rank first order by ID)
, max (APRICE)
, min (APRICE)
, avg (APRICE) keep (dense_rank last order by ID)
, sum (AVOLUME)
, sum (APRICE * AVOLUME)
, count (*)
from TRANSACTIONS_RAW a
group by STOCK_NAME, UT;
commit;
for i in 1..9
loop
insert --+ append
into QUOTES_CALC
select --+ parallel(4)
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, i + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from QUOTES_CALC a
where STRIPE_ID = i
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, i + 1);
commit;
end loop;
end;
/
```
Для симметрии создадим простое VIEW:
```
create view THINNING_HABR_CALC_V as
select * from QUOTES_CALC;
```
#### Вариант 3 — CHIN (китайский код)
Метод отличается брутальной прямолинейностью подхода, и заключается в отказе от принципа «Не повторяй себя». В данном случае — отказ от циклов.
Вариант приводится здесь только для полноты картины.
Забегая вперёд скажу, что по производительности на данной конкретной задаче занимает второе место.
**Большой запрос**
```
create or replace view THINNING_HABR_CHIN_V as
with
T01 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select 1
, STOCK_NAME
, UT
, avg (APRICE) keep (dense_rank first order by ID)
, max (APRICE)
, min (APRICE)
, avg (APRICE) keep (dense_rank last order by ID)
, sum (AVOLUME)
, sum (APRICE * AVOLUME)
, count (*)
from TRANSACTIONS_RAW
group by STOCK_NAME, UT)
, T02 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T01
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T03 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T02
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T04 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T03
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T05 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T04
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T06 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T05
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T07 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T06
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T08 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T07
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T09 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T08
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
, T10 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select
STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T09
group by STRIPE_ID, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1))
select * from T01 union all
select * from T02 union all
select * from T03 union all
select * from T04 union all
select * from T05 union all
select * from T06 union all
select * from T07 union all
select * from T08 union all
select * from T09 union all
select * from T10;
```
#### Вариант 4 — UDAF
Вариант с User Defined Aggregated Function здесь приводить не буду, но его можно посмотреть на github.
#### Вариант 5 — PPTF (Pipelined and Parallel table function)
Создадим функцию (в пакете):
```
create or replace package THINNING_PPTF_P is
type TRANSACTION_RECORD_T is
record (STOCK_NAME varchar2(128), UT number, SEQ_NUM number, APRICE number, AVOLUME number);
type CUR_RECORD_T is ref cursor return TRANSACTION_RECORD_T;
type QUOTE_T
is record (STRIPE_ID number, STOCK_NAME varchar2(128), UT number
, AOPEN number, AHIGH number, ALOW number, ACLOSE number, AVOLUME number
, AAMOUNT number, ACOUNT number);
type QUOTE_LIST_T is table of QUOTE_T;
function F (p_cursor CUR_RECORD_T) return QUOTE_LIST_T
pipelined order p_cursor by (STOCK_NAME, UT, SEQ_NUM)
parallel_enable (partition p_cursor by hash (STOCK_NAME));
end;
/
create or replace package body THINNING_PPTF_P is
function F (p_cursor CUR_RECORD_T) return QUOTE_LIST_T
pipelined order p_cursor by (STOCK_NAME, UT, SEQ_NUM)
parallel_enable (partition p_cursor by hash (STOCK_NAME))
is
QuoteTail QUOTE_LIST_T := QUOTE_LIST_T() ;
rec TRANSACTION_RECORD_T;
rec_prev TRANSACTION_RECORD_T;
type ut_T is table of number index by pls_integer;
ut number;
begin
QuoteTail.extend(10);
loop
fetch p_cursor into rec;
exit when p_cursor%notfound;
if rec_prev.STOCK_NAME = rec.STOCK_NAME
then
if (rec.STOCK_NAME = rec_prev.STOCK_NAME and rec.UT < rec_prev.UT)
or (rec.STOCK_NAME = rec_prev.STOCK_NAME and rec.UT = rec_prev.UT and rec.SEQ_NUM < rec_prev.SEQ_NUM)
then raise_application_error (-20010, 'Rowset must be ordered, ('||rec_prev.STOCK_NAME||','||rec_prev.UT||','||rec_prev.SEQ_NUM||') > ('||rec.STOCK_NAME||','||rec.UT||','||rec.SEQ_NUM||')');
end if;
end if;
if rec.STOCK_NAME <> rec_prev.STOCK_NAME or rec_prev.STOCK_NAME is null
then
for j in 1 .. 10
loop
if QuoteTail(j).UT is not null
then
pipe row (QuoteTail(j));
QuoteTail(j) := null;
end if;
end loop;
end if;
for i in reverse 1..10
loop
ut := TRUNC_UT (rec.UT, i);
if QuoteTail(i).UT <> ut
then
for j in 1..i
loop
pipe row (QuoteTail(j));
QuoteTail(j) := null;
end loop;
end if;
if QuoteTail(i).UT is null
then
QuoteTail(i).STRIPE_ID := i;
QuoteTail(i).STOCK_NAME := rec.STOCK_NAME;
QuoteTail(i).UT := ut;
QuoteTail(i).AOPEN := rec.APRICE;
end if;
if rec.APRICE < QuoteTail(i).ALOW or QuoteTail(i).ALOW is null then QuoteTail(i).ALOW := rec.APRICE; end if;
if rec.APRICE > QuoteTail(i).AHIGH or QuoteTail(i).AHIGH is null then QuoteTail(i).AHIGH := rec.APRICE; end if;
QuoteTail(i).AVOLUME := nvl (QuoteTail(i).AVOLUME, 0) + rec.AVOLUME;
QuoteTail(i).AAMOUNT := nvl (QuoteTail(i).AAMOUNT, 0) + rec.AVOLUME * rec.APRICE;
QuoteTail(i).ACOUNT := nvl (QuoteTail(i).ACOUNT, 0) + 1;
QuoteTail(i).ACLOSE := rec.APRICE;
end loop;
rec_prev := rec;
end loop;
for j in 1 .. 10
loop
if QuoteTail(j).UT is not null
then
pipe row (QuoteTail(j));
end if;
end loop;
exception
when no_data_needed then null;
end;
end;
/
```
Создадим VIEW:
```
create or replace view THINNING_HABR_PPTF_V as
select * from table (THINNING_PPTF_P.F (cursor (select STOCK_NAME, UT, ID, APRICE, AVOLUME from TRANSACTIONS_RAW)));
```
#### Вариант 6 — MODE (model clause)
Вариант итерационно рассчитывает прореживание для всех 10 уровней можно с помощью фразы *MODEL* clause с фразой *ITERATE*.
Вариант тоже непрактичный, поскольку он оказывается медленным. На моём окружении 1000 транзакций по 8 инструментам рассчитываются за 1 минуту. Большая часть времени тратится на вычисление фразы *MODEL*.
Здесь я привожу этот вариант лишь для полноты картины и как подтверждение того факта, что на Oracle почти все сколь угодно сложные вычисления возможно выполнить одним запросом, без использования PL/SQL.
Одной из причин низкой производительности фразы *MODEL* в этом запросе является то, что поиск по критериям справа производится для *каждого* правила, которых у нас 6. Первые два правила вычисляются довольно быстро, потому что там прямая явная адресация, без джокеров. В остальных четырёх правилах есть слово *any* — там вычисления производятся медленнее.
Второе затруднение в том, что приходится рассчитывать референсную модель. Она нужна потому, что список dimension должен быть известен **до** вычисления фразы *MODEL*, мы не можем рассчитывать новые измерения внутри этой фразы. Возможно, это можно обойти с помощью двух фраз MODEL, но я не стал это делать из-за низкой производительности большого числа правил.
Добавлю, что можно было бы не рассчитывать *UT\_OPEN* и *UT\_CLOSE* в референсной модели, а использовать те же функции *avg () keep (dense\_rank first/last order by)* непосредственно во фразе *MODEL*. Но так получилось бы ещё медленнее.
Из-за ограничения производительности я не буду включать этот вариант в процедуру тестирования.
```
with
-- построение первого уровня прореживания из транзакций
SOURCETRANS (STRIPE_ID, STOCK_NAME, PARENT_UT, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select 1, STOCK_NAME, TRUNC_UT (UT, 2), UT
, avg (APRICE) keep (dense_rank first order by ID)
, max (APRICE)
, min (APRICE)
, avg (APRICE) keep (dense_rank last order by ID)
, sum (AVOLUME)
, sum (AVOLUME * APRICE)
, count (*)
from TRANSACTIONS_RAW
where ID <= 1000 -- увеличьте значение для каждого интсрумента здесь
group by STOCK_NAME, UT)
-- построение карты PARENT_UT, UT для 2...10 уровней и расчёт UT_OPEN, UT_CLOSE
-- используется декартово произведение
, REFMOD (STRIPE_ID, STOCK_NAME, PARENT_UT, UT, UT_OPEN, UT_CLOSE)
as (select b.STRIPE_ID
, a.STOCK_NAME
, TRUNC_UT (UT, b.STRIPE_ID + 1)
, TRUNC_UT (UT, b.STRIPE_ID)
, min (TRUNC_UT (UT, b.STRIPE_ID - 1))
, max (TRUNC_UT (UT, b.STRIPE_ID - 1))
from SOURCETRANS a
, (select rownum + 1 as STRIPE_ID from dual connect by level <= 9) b
group by b.STRIPE_ID
, a.STOCK_NAME
, TRUNC_UT (UT, b.STRIPE_ID + 1)
, TRUNC_UT (UT, b.STRIPE_ID))
-- конкатенация первого уровня и карты следующих уровней
, MAINTAB
as (
select STRIPE_ID, STOCK_NAME, PARENT_UT, UT, AOPEN
, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT, null, null from SOURCETRANS
union all
select STRIPE_ID, STOCK_NAME, PARENT_UT, UT, null
, null, null, null, null, null, null, UT_OPEN, UT_CLOSE from REFMOD)
select STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT
from MAINTAB
model
return all rows
-- референсная модель содержит карту уровней 2...10
reference RM on (select * from REFMOD) dimension by (STRIPE_ID, STOCK_NAME, UT) measures (UT_OPEN, UT_CLOSE)
main MM partition by (STOCK_NAME) dimension by (STRIPE_ID, PARENT_UT, UT) measures (AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
rules iterate (9) (
AOPEN [iteration_number + 2, any, any]
= AOPEN [cv (STRIPE_ID) - 1, cv (UT)
, rm.UT_OPEN [cv (STRIPE_ID), cv (STOCK_NAME), cv (UT)]]
, ACLOSE [iteration_number + 2, any, any]
= ACLOSE [cv (STRIPE_ID) - 1, cv (UT)
, rm.UT_CLOSE[cv (STRIPE_ID), cv (STOCK_NAME), cv (UT)]]
, AHIGH [iteration_number + 2, any, any]
= max (AHIGH)[cv (STRIPE_ID) - 1, cv (UT), any]
, ALOW [iteration_number + 2, any, any]
= min (ALOW)[cv (STRIPE_ID) - 1, cv (UT), any]
, AVOLUME [iteration_number + 2, any, any]
= sum (AVOLUME)[cv (STRIPE_ID) - 1, cv (UT), any]
, AAMOUNT [iteration_number + 2, any, any]
= sum (AAMOUNT)[cv (STRIPE_ID) - 1, cv (UT), any]
, ACOUNT [iteration_number + 2, any, any]
= sum (ACOUNT)[cv (STRIPE_ID) - 1, cv (UT), any]
)
order by 1, 2, 3, 4;
```
#### Вариант 6 — IDEA (ideal, идеальный, но неработоспособный)
Запрос, описанный ниже, потенциально был бы самым эффективным и потреблял бы количество ресурсов, равное теоретическому минимуму.
Но ни Oracle, ни MS SQL не позволяют записать запрос в такой форме. Полагаю, это продиктовано стандартом.
```
with
QUOTES_S1 as (select 1 as STRIPE_ID
, STOCK_NAME
, TRUNC_UT (UT, 1) as UT
, avg (APRICE) keep (dense_rank first order by ID) as AOPEN
, max (APRICE) as AHIGH
, min (APRICE) as ALOW
, avg (APRICE) keep (dense_rank last order by ID) as ACLOSE
, sum (AVOLUME) as AVOLUME
, sum (APRICE * AVOLUME) as AAMOUNT
, count (*) as ACOUNT
from TRANSACTIONS_RAW
-- where rownum <= 100
group by STOCK_NAME, TRUNC_UT (UT, 1))
, T1 (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
as (select 1, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT
from QUOTES_S1
union all
select STRIPE_ID + 1
, STOCK_NAME
, TRUNC_UT (UT, STRIPE_ID + 1)
, avg (AOPEN) keep (dense_rank first order by UT)
, max (AHIGH)
, min (ALOW)
, avg (ACLOSE) keep (dense_rank last order by UT)
, sum (AVOLUME)
, sum (AAMOUNT)
, sum (ACOUNT)
from T1
where STRIPE_ID < 10
group by STRIPE_ID + 1, STOCK_NAME, TRUNC_UT (UT, STRIPE_ID + 1)
)
select * from T1
```
Этот запрос соответствует следующей части документации Oracle:
*If a subquery\_factoring\_clause refers to its own query\_name in the subquery that defines it, then the subquery\_factoring\_clause is said to be recursive. A recursive subquery\_factoring\_clause must contain two query blocks: the first is the anchor member and the second is the recursive member. The anchor member must appear before the recursive member, and it cannot reference query\_name. The anchor member can be composed of one or more query blocks combined by the set operators: UNION ALL, UNION, INTERSECT or MINUS. The recursive member must follow the anchor member and must reference query\_name exactly once. You must combine the recursive member with the anchor member using the UNION ALL set operator.*
Но противоречит следующему абзацу документации:
*The recursive member cannot contain any of the following elements:
The DISTINCT keyword or a GROUP BY clause
An aggregate function. However, analytic functions are permitted in the select list.*
Таким образом, в recursive member агрегаты и группировка недопустимы.
### Тестирование
Проведём сначала для **Oracle**.
Выполним процедуру расчёта для метода CALC и запишем время её выполнения:
```
exec THINNING_HABR_CALC_T
```
Результаты расчёта по четырём методам находятся в четырёх view:
* THINNING\_HABR\_SIMP\_V (будет выполнять расчёт, вызывая сложный SELECT, поэтому будет выполняться долго),
* THINNING\_HABR\_CALC\_V (отобразит данные из таблицы QUOTES\_CALC, поэтому выполнится быстро),
* THINNING\_HABR\_CHIN\_V (тоже будет выполнять расчёт, вызывая сложный SELECT, поэтому будет выполняться долго),
* THINNING\_HABR\_PPTF\_V (будет выполнять функцию THINNING\_HABR\_PPTF).
Время выполнения по всем методам уже замерены мной и приведены в таблице в конце статьи.
Для остальных VIEW выполним запросы и запишем время выполнения:
```
select count (*) as CNT
, sum (STRIPE_ID) as S_STRIPE_ID, sum (UT) as S_UT
, sum (AOPEN) as S_AOPEN, sum (AHIGH) as S_AHIGH, sum (ALOW) as S_ALOW
, sum (ACLOSE) as S_ACLOSE, sum (AVOLUME) as S_AVOLUME
, sum (AAMOUNT) as S_AAMOUNT, sum (ACOUNT) as S_ACOUNT
from THINNING_HABR_XXXX_V
```
где XXXX — SIMP, CHIN, PPTF.
Эти VIEW рассчитывают дайджест набора. Для расчёта дайджеста нужно выполнить fetch всех строк, и с помощью дайджеста можно сравнить наборы между собой.
Также сравнить наборы можно с помощью пакета dbms\_sqlhash, но это намного медленнее, потому что требуется сортировка исходного набора, да и расчёт хэша выполняется небыстро.
Также в 12c есть пакет DBMS\_COMPARISON.
Можно одновременно проверить корректность всех алгоритмов. Посчитаем дайджесты таким запросом (при 11М записей на виртуальной машине это будет относительно долго, порядка 15 минут):
```
with
T1 as (select 'SIMP' as ALG_NAME, a.* from THINNING_HABR_SIMP_V a
union all
select 'CALC', a.* from THINNING_HABR_CALC_V a
union all
select 'CHIN', a.* from THINNING_HABR_CHIN_V a
union all
select 'PPTF', a.* from THINNING_HABR_PPTF_V a)
select ALG_NAME
, count (*) as CNT
, sum (STRIPE_ID) as S_STRIPE_ID, sum (UT) as S_UT
, sum (AOPEN) as S_AOPEN, sum (AHIGH) as S_AHIGH, sum (ALOW) as S_ALOW
, sum (ACLOSE) as S_ACLOSE, sum (AVOLUME) as S_AVOLUME
, sum (AAMOUNT) as S_AAMOUNT, sum (ACOUNT) as S_ACOUNT
from T1
group by ALG_NAME;
```
Мы видим, что дайджесты совпадают, значит все алгоритмы выдали одинаковые результаты.
Теперь воспроизведём всё то же самое на **MS SQL**. Я тестировал на версии 2016.
Предварительно создайте базу DBTEST, после этого в ней создайте таблицу транзакций:
```
use DBTEST
go
create table TRANSACTIONS_RAW
(
STOCK_NAME varchar (32) not null
, UT int not null
, APRICE numeric (22, 12) not null
, AVOLUME numeric (22, 12) not null
, ID bigint identity not null
);
```
Загрузим скачанные данные.
На MSSQL создайте файл format\_mssql.bcp:
```
12.0
3
1 SQLCHAR 0 0 "," 3 UT ""
2 SQLCHAR 0 0 "," 4 APRICE ""
3 SQLCHAR 0 0 "\n" 5 AVOLUME ""
```
И запустите скрипт LoadData-MSSQL.sql в SSMS (этот скрипт был сгенерирован единственным powershell скриптом, приведенным в разделе этой статьи для Oracle).
Создадим две функции:
```
use DBTEST
go
create or alter function TRUNC_UT (@p_UT bigint, @p_StripeTypeId int) returns bigint as
begin
return
case @p_StripeTypeId
when 1 then @p_UT
when 2 then @p_UT / 10 * 10
when 3 then @p_UT / 60 * 60
when 4 then @p_UT / 600 * 600
when 5 then @p_UT / 3600 * 3600
when 6 then @p_UT / 14400 * 14400
when 7 then @p_UT / 86400 * 86400
when 8 then datediff (second, cast ('1970-01-01 00:00:00' as datetime), dateadd(m, datediff (m, 0, dateadd (second, @p_UT, cast ('1970-01-01 00:00:00' as datetime))), 0))
when 9 then datediff (second, cast ('1970-01-01 00:00:00' as datetime), dateadd(yy, datediff (yy, 0, dateadd (second, @p_UT, cast ('1970-01-01 00:00:00' as datetime))), 0))
when 10 then 0
when 11 then 0
end;
end;
go
create or alter function UT2DATESTR (@p_UT bigint) returns datetime as
begin
return dateadd(s, @p_UT, cast ('1970-01-01 00:00:00' as datetime));
end;
go
```
Приступим к реализации вариантов:
#### Вариант 1 — SIMP
Выполните:
```
use DBTEST
go
create or alter view dbo.THINNING_HABR_SIMP_V as
with
T1 (STRIPE_ID)
as (select 1
union all
select STRIPE_ID + 1 from T1 where STRIPE_ID < 10)
, T2 as (select STRIPE_ID
, STOCK_NAME
, dbo.TRUNC_UT (UT, STRIPE_ID) as UT
, min (1000000 * cast (UT as bigint) + ID) as AOPEN_UT
, max (APRICE) as AHIGH
, min (APRICE) as ALOW
, max (1000000 * cast (UT as bigint) + ID) as ACLOSE_UT
, sum (AVOLUME) as AVOLUME
, sum (APRICE * AVOLUME) as AAMOUNT
, count (*) as ACOUNT
from TRANSACTIONS_RAW, T1
group by STRIPE_ID, STOCK_NAME, dbo.TRUNC_UT (UT, STRIPE_ID))
select t.STRIPE_ID, t.STOCK_NAME, t.UT, t_op.APRICE as AOPEN, t.AHIGH
, t.ALOW, t_cl.APRICE as ACLOSE, t.AVOLUME, t.AAMOUNT, t.ACOUNT
from T2 t
join TRANSACTIONS_RAW t_op on (t.STOCK_NAME = t_op.STOCK_NAME and t.AOPEN_UT / 1000000 = t_op.UT and t.AOPEN_UT % 1000000 = t_op.ID)
join TRANSACTIONS_RAW t_cl on (t.STOCK_NAME = t_cl.STOCK_NAME and t.ACLOSE_UT / 1000000 = t_cl.UT and t.ACLOSE_UT % 1000000 = t_cl.ID);
```
Отсутствующие функции *first/last* реализованы двойным самосоединением таблиц.
#### Вариант 2 — CALC
Создадим таблицу, процедуру и view:
```
use DBTEST
go
create table dbo.QUOTES_CALC
(
STRIPE_ID int not null
, STOCK_NAME varchar(32) not null
, UT bigint not null
, AOPEN numeric (22, 12) not null
, AHIGH numeric (22, 12) not null
, ALOW numeric (22, 12) not null
, ACLOSE numeric (22, 12) not null
, AVOLUME numeric (38, 12) not null
, AAMOUNT numeric (38, 12) not null
, ACOUNT int not null
);
go
create or alter procedure dbo.THINNING_HABR_CALC as
begin
set nocount on;
truncate table QUOTES_CALC;
declare @StripeId int;
with
T1 as (select STOCK_NAME
, UT
, min (ID) as AOPEN_ID
, max (APRICE) as AHIGH
, min (APRICE) as ALOW
, max (ID) as ACLOSE_ID
, sum (AVOLUME) as AVOLUME
, sum (APRICE * AVOLUME) as AAMOUNT
, count (*) as ACOUNT
from TRANSACTIONS_RAW
group by STOCK_NAME, UT)
insert into QUOTES_CALC (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
select 1, t.STOCK_NAME, t.UT, t_op.APRICE, t.AHIGH, t.ALOW, t_cl.APRICE, t.AVOLUME, t.AAMOUNT, t.ACOUNT
from T1 t
join TRANSACTIONS_RAW t_op on (t.STOCK_NAME = t_op.STOCK_NAME and t.UT = t_op.UT and t.AOPEN_ID = t_op.ID)
join TRANSACTIONS_RAW t_cl on (t.STOCK_NAME = t_cl.STOCK_NAME and t.UT = t_cl.UT and t.ACLOSE_ID = t_cl.ID);
set @StripeId = 1;
while (@StripeId <= 9)
begin
with
T1 as (select STOCK_NAME
, dbo.TRUNC_UT (UT, @StripeId + 1) as UT
, min (UT) as AOPEN_UT
, max (AHIGH) as AHIGH
, min (ALOW) as ALOW
, max (UT) as ACLOSE_UT
, sum (AVOLUME) as AVOLUME
, sum (AAMOUNT) as AAMOUNT
, sum (ACOUNT) as ACOUNT
from QUOTES_CALC
where STRIPE_ID = @StripeId
group by STOCK_NAME, dbo.TRUNC_UT (UT, @StripeId + 1))
insert into QUOTES_CALC (STRIPE_ID, STOCK_NAME, UT, AOPEN, AHIGH, ALOW, ACLOSE, AVOLUME, AAMOUNT, ACOUNT)
select @StripeId + 1, t.STOCK_NAME, t.UT, t_op.AOPEN, t.AHIGH, t.ALOW, t_cl.ACLOSE, t.AVOLUME, t.AAMOUNT, t.ACOUNT
from T1 t
join QUOTES_CALC t_op on (t.STOCK_NAME = t_op.STOCK_NAME and t.AOPEN_UT = t_op.UT)
join QUOTES_CALC t_cl on (t.STOCK_NAME = t_cl.STOCK_NAME and t.ACLOSE_UT = t_cl.UT)
where t_op.STRIPE_ID = @StripeId and t_cl.STRIPE_ID = @StripeId;
set @StripeId = @StripeId + 1;
end;
end;
go
create or alter view dbo.THINNING_HABR_CALC_V as
select *
from dbo.QUOTES_CALC;
go
```
Варианты 3 (CHIN) и 4 (UDAF) я не реализовывал на MS SQL.
#### Вариант 5 — PPTF
Создадим табличную функцию и view. Эта функция является просто табличной, а не parallel pipelined table function, просто вариант сохранил своё историческое название от Oracle:
```
use DBTEST
go
create or alter function dbo.THINNING_HABR_PPTF ()
returns @rettab table (
STRIPE_ID bigint not null
, STOCK_NAME varchar(32) not null
, UT bigint not null
, AOPEN numeric (22, 12) not null
, AHIGH numeric (22, 12) not null
, ALOW numeric (22, 12) not null
, ACLOSE numeric (22, 12) not null
, AVOLUME numeric (38, 12) not null
, AAMOUNT numeric (38, 12) not null
, ACOUNT bigint not null)
as
begin
declare @i tinyint;
declare @tut int;
declare @trans_STOCK_NAME varchar(32);
declare @trans_UT int;
declare @trans_ID int;
declare @trans_APRICE numeric (22,12);
declare @trans_AVOLUME numeric (22,12);
declare @trans_prev_STOCK_NAME varchar(32);
declare @trans_prev_UT int;
declare @trans_prev_ID int;
declare @trans_prev_APRICE numeric (22,12);
declare @trans_prev_AVOLUME numeric (22,12);
declare @QuoteTail table (
STRIPE_ID bigint not null primary key clustered
, STOCK_NAME varchar(32) not null
, UT bigint not null
, AOPEN numeric (22, 12) not null
, AHIGH numeric (22, 12)
, ALOW numeric (22, 12)
, ACLOSE numeric (22, 12)
, AVOLUME numeric (38, 12) not null
, AAMOUNT numeric (38, 12) not null
, ACOUNT bigint not null);
declare c cursor fast_forward for
select STOCK_NAME, UT, ID, APRICE, AVOLUME
from TRANSACTIONS_RAW
order by STOCK_NAME, UT, ID; -- THIS ORDERING (STOCK_NAME, UT, ID) IS MANDATORY
open c;
fetch next from c into @trans_STOCK_NAME, @trans_UT, @trans_ID, @trans_APRICE, @trans_AVOLUME;
while @@fetch_status = 0
begin
if @trans_STOCK_NAME <> @trans_prev_STOCK_NAME or @trans_prev_STOCK_NAME is null
begin
insert into @rettab select * from @QuoteTail;
delete @QuoteTail;
end;
set @i = 10;
while @i >= 1
begin
set @tut = dbo.TRUNC_UT (@trans_UT, @i);
if @tut <> (select UT from @QuoteTail where STRIPE_ID = @i)
begin
insert into @rettab select * from @QuoteTail where STRIPE_ID <= @i;
delete @QuoteTail where STRIPE_ID <= @i;
end;
if (select count (*) from @QuoteTail where STRIPE_ID = @i) = 0
begin
insert into @QuoteTail (STRIPE_ID, STOCK_NAME, UT, AOPEN, AVOLUME, AAMOUNT, ACOUNT)
values (@i, @trans_STOCK_NAME, @tut, @trans_APRICE, 0, 0, 0);
end;
update @QuoteTail
set AHIGH = case when AHIGH < @trans_APRICE or AHIGH is null then @trans_APRICE else AHIGH end
, ALOW = case when ALOW > @trans_APRICE or ALOW is null then @trans_APRICE else ALOW end
, ACLOSE = @trans_APRICE, AVOLUME = AVOLUME + @trans_AVOLUME
, AAMOUNT = AAMOUNT + @trans_APRICE * @trans_AVOLUME
, ACOUNT = ACOUNT + 1
where STRIPE_ID = @i;
set @i = @i - 1;
end;
set @trans_prev_STOCK_NAME = @trans_STOCK_NAME;
set @trans_prev_UT = @trans_UT;
set @trans_prev_ID = @trans_ID;
set @trans_prev_APRICE = @trans_APRICE;
set @trans_prev_AVOLUME = @trans_AVOLUME;
fetch next from c into @trans_STOCK_NAME, @trans_UT, @trans_ID, @trans_APRICE, @trans_AVOLUME;
end;
close c;
deallocate c;
insert into @rettab select * from @QuoteTail;
return;
end
go
create or alter view dbo.THINNING_HABR_PPTF_V as
select *
from dbo.THINNING_HABR_PPTF ();
```
Выполним расчёт таблицы QUOTES\_CALC для метода CALC и запишем время выполнения:
```
use DBTEST
go
exec dbo.THINNING_HABR_CALC
```
Результаты расчёта по трём методам находятся в трёх view:
* THINNING\_HABR\_SIMP\_V (будет выполнять расчёт, вызывая сложный SELECT, поэтому будет выполняться долго),
* THINNING\_HABR\_CALC\_V (отобразит данные из таблицы QUOTES\_CALC, поэтому выполнится быстро)
* THINNING\_HABR\_PPTF\_V (будет выполнять функцию THINNING\_HABR\_PPTF).
Для двух VIEW выполним запросы и запишем время выполнения:
```
select count (*) as CNT
, sum (STRIPE_ID) as S_STRIPE_ID, sum (UT) as S_UT
, sum (AOPEN) as S_AOPEN, sum (AHIGH) as S_AHIGH, sum (ALOW) as S_ALOW
, sum (ACLOSE) as S_ACLOSE, sum (AVOLUME) as S_AVOLUME
, sum (AAMOUNT) as S_AAMOUNT, sum (ACOUNT) as S_ACOUNT
from THINNING_HABR_XXXX_V
```
где XXXX — SIMP, PPTF.
Теперь можно сравнить результаты расчёта по трём методам для MS SQL. Это можно сделать одним запросом. Выполните:
```
use DBTEST
go
with
T1 as (select 'SIMP' as ALG_NAME, a.* from THINNING_HABR_SIMP_V a
union all
select 'CALC', a.* from THINNING_HABR_CALC_V a
union all
select 'PPTF', a.* from THINNING_HABR_PPTF_V a)
select ALG_NAME
, count (*) as CNT, sum (cast (STRIPE_ID as bigint)) as STRIPE_ID
, sum (cast (UT as bigint)) as UT, sum (AOPEN) as AOPEN
, sum (AHIGH) as AHIGH, sum (ALOW) as ALOW, sum (ACLOSE) as ACLOSE, sum (AVOLUME) as AVOLUME
, sum (AAMOUNT) as AAMOUNT, sum (cast (ACOUNT as bigint)) as ACOUNT
from T1
group by ALG_NAME;
```
Если три строки совпадают по всем полям — результат расчёта по трём методам идентичный.
Я настоятельно советую на этапе тестирования использовать маленькую выборку, потому, что производительность этой задачи на MS SQL невысокая.
Если вы располагаете только движком MS SQL, и хотите рассчитывать больший объём данных, то можно попробовать следующий метод оптимизации: можно создать индексы:
```
create unique clustered index TRANSACTIONS_RAW_I1 on TRANSACTIONS_RAW (STOCK_NAME, UT, ID);
create unique clustered index QUOTES_CALC_I1 on QUOTES_CALC (STRIPE_ID, STOCK_NAME, UT);
```
Результаты замера производительности на моей виртуальной машине, следующие:
Скрипты можно скачать с [github](https://github.com/yaroslavbat/thinning_habr): Oracle, схема THINNING — скрипты этой статьи, схема THINNING\_LIVE — *онлайн-скачивание* данных с сайта bitcoincharts.com и *онлайн-прореживание* (но этот сайт в онлайн-режиме отдаёт данные только за последние 5 дней), и скрипт для MS SQL тоже по этой статье.
**Вывод:**
Эта задача решается быстрее на Oracle, чем на MS SQL. С ростом количества транзакций разрыв становится всё более существенным.
На Oracle наиболее оптимальным оказался вариант PPTF. Здесь процедурный подход оказался выгоднее, такое случается нечасто. Остальные методы показали тоже приемлемый результат — я тестировал даже объём 367М транзакций на виртуальной машине (метод PPTF рассчитал прореживание за полтора часа).
На MS SQL наиболее производительным оказался метод итерационного расчёта (CALC).
Почему же метод PPTF на Oracle оказался лидером? Из-за параллельности выполнения и из-за архитектуры — функция, которая создана как parallel pipelined table function, встраивается в середину плана запроса:
 | https://habr.com/ru/post/418757/ | null | ru | null |
# Свой сервер мониторинга с nagios и cacti
Под катом советы по быстрому развертыванию «системы мониторинга» посредством nagios и cacti.
Предположим имеется девственно чистый сервер с предустановленным debian lenny. А нам предстоит сделать из этой бесформенной массы луна-парк с блэк джеком и девочками. Хм, хотя нет, наверное все таки нужно сделать сервер мониторинга с nagios и cacti.
Прежде всего необходимо поставить ssh сервер и mc (midnight commander), думаю комментировать зачем и почему мы это делаем излишне
`debian:~# apt-get update
debian:~# apt-get install openssh-server
debian:~# apt-get install mc`
Далее ставим nagios. Ставить будем «кошерным» способом, посредством apt. Это избавит нас от проблемы зависимостей, многочасового лазания в дебрях конфигурационных файлов и сократит время разворачивания системы.
И так, набираем магическую команду
`debian:~# apt-get install nagios3`
и, вуаля у нас уже установлен нагиос в минимальной конфигурации. Что же произошло? Менеджер пакетов просмотрел зависимости для пакета nagios3. Кроме базового пакета были установлены плагины к нагиосу, апач и много-много нужных библиотек.
Так же были созданы минимальные конфиги для нагиоса и апача. В теории все должно «работать из коробки», но как обычно приходиться пользоваться напильником.
Как мы можем увидеть, в конфиге /etc/nagios3/nagios.conf указано, что для доступа к nagios используется обыкновенная http авторизация, но к сожалению файла авторизации нет.
Дабы исправить сей скорбный факт создадим его командой
`debian:~# htpasswd -c /etc/nagios3/htpasswd.users nagiosadmin
New password:
Re-type new password:
Adding password for user nagiosadmin`
Прошу обратить внимание, что пользователь должен быть именно nagiosadmin, а не Вася, Люся или Петручио.
Это связано, с тем что по умолчанию в nagios.cfg пользователь c доступом ко всем функциям — nagiosadmin.
Включаем обработку внешних команд, вещь нужная, например для «Re-schedule the next check of this host».
`debian:~# mcedit /etc/nagios3/nagios.cfg`
`check_external_commands=1`
Изменяем пермишенсы и владельцев
`chown -R nagios.www-data /var/lib/nagios3
chmod -R 770 /var/lib/nagios3/spool
chmod 644 /etc/nagios3/resource.cfg`
Установка nagios3 завершена. Мы можем зайти в интерфейс nagios3 набрав в Вашем любимом браузере
http ://youre\_server\_ip/nagios3
Теперь с чистой совестью приступим к его конфигурации. Вы можете с головой погрузиться в конфигурационные файлы и часами их править, получая неописуемое удовлетворение ~~множественные оргазмы~~ от данного процесса. Либо совершить акт настройки нагиоса посредством веб интерфейса. Например, применив NagiosQL.
Дабы соблюсти «кошерность» установки NagiosQL, добавим репозиторий с присобранным NagiosQL в список репозиториев.
Список репозиториев находиться в /etc/apt/sources.list:
`deb http:// debian.swobspace.net lenny main
deb-src http:// debian.swobspace.net lenny main`
Дальше, что бы из репозитория debian.swobspace.net получить только NagiosQL создадим файл /etc/apt/preferences
`debian:~# touch /etc/apt/preferences`
и в нем укажем, наши предпочтения по установке пакетов
`Package: *
Pin: origin debian.swobspace.net
Pin-Priority: 200
Package: nagiosql
Pin: origin debian.swobspace.net
Pin-Priority: 600`
Получаем и импортируем ключи для репозитория debian.swobspace.net
`debian:~# wget http:// www.swobspace.net/wob@swobspace.net.pub.asc -O- | apt-key add -`
Обновляем список пакетов
`debian:~# apt-get update`
Устанавливаем NagiosQL
`debian:~# apt-get install nagiosql`
Именно здесь Мы целиком и полностью видим преимущество «кошерного» подхода в установке пакетов, в зависимостях оказались php, mysql, необходимые модули и библиотеки. Не надо ломать голову почему не работает какая то функция, или почему не генерируется график.
Во время установки вас спросит root пароль для доступа к базе данных mysql, обязательно запишите его на листочке.
Настройка
1.Активируем установщик NagiosQL
`debian:~# touch /usr/share/nagiosql/htdocs/install/ENABLE_INSTALLER`
2. Заходим http ://youre\_server\_ip/nagiosql и в интуитивно понятном веб интерфейсе выполняем установку, именно здесь и потребуется тот клочок пергамента на котором мы неясными каракулями записали root пароль от mysql.
3. После удачной установки деактивируем установщик NagiosQL
`debian:~# rm -f /usr/share/nagiosql/htdocs/install/ENABLE_INSTALLER`
для надежности можно удалить всю папку с установщиком
`debian:~# rm -rf /usr/share/nagiosql/htdocs/install`
4. Добавляем в /etc/nagios3/nagios.cfg строку.
`cfg_dir=/etc/nagiosql/domains/localhost`
5. Создаем папку /etc/nagios/import и копируем в нее все конфиги из /etc/nagios3/conf.d и /etc/nagios-plugins/. И импортируем их в NagiosQL.
Импорт данных осуществляется в меню Tools => Data import
6. Выкидываем в мусорку листок с записанным root паролем для mysql
Дальше с NagiosQL придется разбираться самим, google translate Вам в помощь.
Установка cacti собственно как и nagios весьма незатейлива
`debian:~# apt-get install cacti`
Перед вам опять предстанет довольно большой список зависимостей, не раздумывая набирайте Yes. В процессе установки Нам снова потребуется несчастный листик с паролем от mysql, зря мы наверное его выкинули в мусорку.
Осталось настроить cacti, здесь все просто, как и с NagiosQL. Интуитивно понятный интерфейс.
http ://youre\_server\_ip/cacti
Стандартный логин и пароль для доступа к cacti: admin/admin.
Теперь, предположим у нас есть есть сервер, с которого мы будем снимать данные и по ним рисовать графики.
Снимать данные мы будем посредством snmpd
Устанавливаем snmpd на сервере, с которого будем снимать данные(опять же, я подразумеваю, что на сервере стоит debian lenny).
`shaper:~# apt-get install snmpd`
в конфиге /etc/default/snmpd изменяем ип адрес на котором будет принимать запросы демон snmpd
`shaper:~# mcedit /etc/default/snmpd`
вместо
`SNMPDOPTS='-Lsd -Lf /dev/null -u snmp -g snmp -I -smux -p /var/run/snmpd.pid 127.0.0.1'`
изменяем
`SNMPDOPTS='-Lsd -Lf /dev/null -u snmp -g snmp -I -smux -p /var/run/snmpd.pid you_server2_ip'`
Добавляем строку в файл /etc/snmp/snmpd.conf
`rocommunity my_snmp_community youre_server_ip`
`rocommunity` — разрешается доступ только для чтения
`my_snmp_community` — снмп комунити для доступа к данным
`youre_server_ip` — ип с которого разрешен доступ к демону
Перезагружаем снмп
`shaper:~# /etc/init.d/snmpd restart`
Дальнейшие операции проделываем в интерфейсе Cacti
Console => Management => Devices => Add (Правый верхний угол)
Descpription — описание машины
Hostname — IP
Host Template — udc/net SNMPD Host
SNMP Version — Version 2
SNMP Community — снмп коммунити указанное на сервере
Нажимаем Create
Если после этого видим
Ping Results
Host is alive
Нажимаем Create Graphs for this Host
Проставляем «чекбоксы» на тех графиках, которые вы хотите отрисовывать и жмем Create (для гигабитных интерфейсов необходимо выбрать в селекторе Select a graph type — In/Out Bits (64-bit Counters))
Если и опять все прошло успешно, мы можем добавить «наш сервер» на дерево графиков
Console => Management => Graph Trees =>Default Tree => Add (Правый верхний угол)
Tree Item Type — выбираем Host
Host — наш сервер
Жмем Create.
И через 5-10 минут наслаждаемся графиками.
Беспощадно уничтожаем листок с записанным root паролем для mysql
На базовую настройку сервера мониторинга у нас ушло не более получаса. Опять же, прошу заметить базовую.
Остальное в Ваших руках, как говориться полет фантазии никто не ограничивает, главное не злоупотреблять галлюциногенами. | https://habr.com/ru/post/88293/ | null | ru | null |
# Функциональное программирование с точки зрения EcmaScript. Композиция, каррирование, частичное применение
Привет, Хабр!
Сегодня мы продолжим наши изыскания на тему функционального программирования в разрезе EcmaScript, на спецификации которого основан JavaScript. В предыдущей статье мы разобрали основные понятия: чистые функции, лямбды, концепцию имутабельности. Сегодня поговорим о чуть более сложных техниках ФП: композиции, каррировании и чистых функциях. Статья написана в стиле «псевдо кодревью», т.е. мы будем решать практическую задачу, одновременно изучая концепции ФП и рефакторя код для приближения последнего к идеалам ФП.
Итак, начнём!
Предположим, перед нами стоит задача: создать набор инструментов для работы с палиндромами.
> ПАЛИНДРО́М
>
> Мужской родСПЕЦИАЛЬНОЕ
>
> Слово или фраза, которые одинаково читаются слева направо и справа налево.
>
> «П. «Я иду с мечем судия»»
>
>
Одна из возможных реализаций данной задачи могла бы выглядеть так:
```
function getPalindrom (str) {
const regexp = /[\.,\/#!$%\^&\*;:{}=\-_`~()?\s]/g;
str = str.replace(regexp, '').toLowerCase().split('').reverse().join('');
//далее какой-то аякс запрос в словарь или к логике, которая генерирует фразы по переданным буквам
return str;
}
function isPalindrom (str) {
const regexp = /[\.,\/#!$%\^&\*;:{}=\-_`~()?\s]/g;
str = str.replace(regexp, '').toLowerCase();
return str === str.split('').reverse().join('');
}
```
Безусловно, эта реализация работает. Мы можем ожидать, что getPalindrom будет работать корректно если апи будет возвращать корректные данные. Вызов isPalindrom('Я иду с мечем судия') вернёт true, а вызов isPalindrom('не палиндром') вернёт false. Хороша ли эта реализация с точки зрения идеалов функционального программирования? Определённо, не хороша!
Согласно определению Чистых функций из этой [статьи](https://habr.com/ru/post/474702/):
> Чистые функции (Pure functions, PF) — всегда возвращают предсказуемый результат.
>
> Свойства PF:
>
>
>
> Результат выполнения PF зависит только от переданных аргументов и алгоритма, который реализует PF
>
> Не используют глобальные значения
>
> Не модифицируют значения снаружи себя или переданные аргументы
>
> Не записывают данные в файлы, бд или куда бы то не было
>
>
А что мы видим в нашем примере с палиндромами?
Во-первых, присутствует дублирование кода, т.е. нарушается принцип [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself). Во-вторых, функция getPalindrom обращается к базе. В-третьих, функции модифицируют свои аргументы. Итого, наши функции не чисты.
Вспомним определение: Функциональное программирование — способ написания кода через составления набора функций.
Составим набор функций для этой задачи:
```
const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g;//(1)
const replace = (regexp, replacement, str) => str.replace(regexp, replacement);//(2)
const toLowerCase = str => str.toLowerCase();//(3)
const stringReverse = str => str.split('').reverse().join('');//(4)
const isStringsEqual = (strA, strB) => strA === strB;//(5)
```
В строке 1 мы объявили константу регулярного выражения в функциональной форме. Такой способ описания констант часто применяется в ФП. Во 2-й строке мы инкапсулировали метод String.prototype.replace в функциональную абстракцию replace, для того чтобы он(вызов replace) соответствовал контракту функционального программирования. В 3-й строке идентичным образом создали абстракцию для String.prototype.toLowerCase. В 4-й реализовали функцию создающую новую развёрнутую строку из переданной. 5-я проверяет на равенство строки.
Обратите внимание, наши функции предельно чисты! О преимуществах чистых функций мы говорили в предыдущей [статье](https://habr.com/ru/post/474702/).
Теперь нам необходимо реализовать проверку — является ли строка палиндромом. На помощь нам придёт композиция функций.
**Композиция функций** — объединение двух или более функций в некую результирующую функцию, которая реализует поведение объединяемых в требуемой алгоритмической последовательности.
Возможно, определение покажется сложным, но с практической точки зрения оно справедливо.
Мы можем сделать так:
```
isStringsEqual(toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', 'Я иду с мечем судия')), stringReverse(toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', 'Я иду с мечем судия'))));
```
или вот так:
```
const strA = toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', 'Я иду с мечем судия'));
const strB = stringReverse(toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', 'Я иду с мечем судия')));
console.log(isStringsEqual(strA, strB));
```
или ввести ещё кучу объясняющих переменных для каждого шага реализуемого алгоритма. Такой код часто можно видеть на проектах и это типичный пример композиции — передача вызова одной функции в качестве аргумента другой. Тем не менее, как мы видим, в ситуации когда функций много этот подход плох, т.к. данный код не читаем! Так что же теперь? Ну его это функциональное программирование, расходимся?
На самом деле, как это обычно и бывает в функциональном программировании, нам просто нужно написать ещё одну функцию.
```
const compose = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);
```
Функция compose принимает в качестве аргументов список выполняемых функций, превращает их в массив, сохраняет его в замыкании и возвращает функцию, которая ожидает начальное значение. После того как начальное значение передано, запускается последовательное выполнение всех функций из массива fns. Аргументом первой функции будет переданное начальное значение x, а аргументами всех последующих будет результат выполнения предыдущей. Так мы сможем создавать композиции любого числа функций.
При создании функциональных композиций очень важно следить за типами входных параметров и возвращаемых значений каждой функции, чтобы не возникало непредвиденных ошибок, т.к. мы передаём результат выполнения предыдущей функции в последующую.
Однако, уже сейчас мы видим проблемы с применением техники композиции к нашему коду, ведь функция:
```
const replace = (regexp, replacement, str) => str.replace(regexp, replacement);
```
ожидает принять 3 параметра на вход, а мы в compose передаём только один. Решить эту проблему нам поможет другая техника ФП — Каррирование.
**Каррирование** — преобразование функции от многих аргументов к функции от одного аргумента.
Помните нашу функцию add из первой статьи?
```
const add = (x,y) => x+y;
```
Её можно каррировать так:
```
const add = x => y => x+y;
```
Функция принимает x и возвращает лямбду, которая ожидает y и выполняет действие.
Преимущества каррирования:
* код выглядит лучше;
* каррированные функции всегда чисты.
Теперь преобразуем нашу функцию replace так, чтобы она принимала только один аргумент. Так как нам необходимо, чтобы функция заменяла символы в строке по заранее известному регулярному выражению, то мы можем создать частично примененную функцию.
```
const replaceAllNotWordSymbolsGlobal = replacement => str => replace(allNotWordSymbolsRegexpGlobal(), replacement, str);
```
Как видите мы закрепляем один из аргументов константой. Это связано с тем, что на самом деле каррирование это частный случай частичного применения.
**Частичное применение** — оборачивание функции обёрткой, которая принимает число аргументов меньшее, чем принимает сама функция, обёртка должна возвращать функцию, которая принимает остальные аргументы.
В нашем случае мы создали функцию replaceAllNotWordSymbolsGlobal, которая является частично примененным вариантом replace. Она принимает replacement, сохраняет его в замыкании и ожидает на вход строку для которой вызовет replace, а аргумент regexp мы закрепляем константтой.
Вернёмся к палиндромам. Создадим композицию функций для палиндромовой сроки:
```
const processFormPalindrom = compose(
replaceAllNotWordSymbolsGlobal(''),
toLowerCase,
stringReverse
);
```
и композицию функций для строки с которой будем сравнивать потенциальный палиндром:
```
const processFormTestString = compose(
replaceAllNotWordSymbolsGlobal(''),
toLowerCase,
);
```
теперь вспомним то, что мы говорили выше:
> типичный пример композиции — передача вызова одной функции в качестве аргумента другой
и напишем:
```
const testString = 'Я иду с мечем судия';//в данном случае я не стал переписывать коснтанту в функциональном стиле, т.к. подразумеваю, что это не константа, а значение, которое приходит откуда-то из внешнего кода, например с сервера
const isPalindrom = isStringsEqual(processFormPalindrom(testString), processFormTestString(testString));
```
Вот мы получили рабочее и неплохо выглядящее решение:
```
const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g;
const replace = (regexp, replacement, str) => str.replace(regexp, replacement);
const toLowerCase = str => str.toLowerCase();
const stringReverse = str => str.split('').reverse().join('');
const isStringsEqual = (strA, strB) => strA === strB;
const replaceAllNotWordSymbolsGlobal = replacement => str => replace(allNotWordSymbolsRegexpGlobal(), replacement, str);
const compose = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);
const processFormPalindrom = compose(
replaceAllNotWordSymbolsGlobal(''),
toLowerCase,
stringReverse
);
const processFormTestString = compose(
replaceAllNotWordSymbolsGlobal(''),
toLowerCase,
);
const testString = 'Я иду с мечем судия';
const isPalindrom = isStringsEqual(processFormPalindrom(testString), processFormTestString(testString));
```
Однако, мы ведь не хотим каждый раз делать каррирование или создавать частично применённые функции руками. Конечно, не хотим, программисты люди ленивые. Поэтому, как оно обычно бывает в ФП, напишем ещё пару функций:
```
const curry = fn => (...args) => {
if (fn.length > args.length) {
const f = fn.bind(null, ...args);
return curry(f);
} else {
return fn(...args)
}
}
```
Функция curry принимает функцию, которую будет каррировать, сохраняет её в замыкании и возвращает лямбду. Лямбда ожидает остальные аргументы функции. Каждый раз получая аргумент, она проверяет приняты ли все задекларированные аргументы. Если приняты, то функция вызывается и возвращается её результат. Если нет, то функция снова каррируется.
Также мы можем создать частично применённую функцию для замены нужного нам регулярного выражения на пустую строку:
```
const replaceAllNotWordSymbolsToEmpltyGlobal = curry(replace)(allNotWordSymbolsRegexpGlobal(), '');
```
Вроде бы всё неплохо, но мы перфекционисты и нам не нравится слишком много скобок, нам хотелось бы ещё лучше, поэтому напишем ещё функцию или может быть две:
```
const party = (fn, x) => (...args) => fn(x, ...args);
```
Это реализация абстракции для создания частичных применённых функций. Она принимает функцию и первый аргумент, возвращает лямбду, которая ожидает остальные и выполняет функцию.
Теперь перепишем party так, чтобы мы могли создать частично применённую функцию от нескольких аргументов:
```
const party = (fn, ...args) => (...rest) => fn(...args.concat(rest));
```
Отдельно стоит отметить, что каррированные таким способом функции могут быть вызваны с любым количеством аргументов меньше задикларированного(fn.length).
```
const sum = (a,b,c,d) => a+b+c+d;
const fn = curry(sum);
const r1 = fn(1,2,3,4);//очевидно, рабочий пример
const r2 = fn(1, 2, 3)(4);//этот и все последующие также будут работать
const r3 = fn(1, 2)(3)(4);
const r4 = fn(1)(2)(3)(4);
const r5 = fn(1)(2, 3, 4);
const r6 = fn(1)(2)(3, 4);
const r7 = fn(1, 2)(3, 4);
```
Вернёмся к нашим палиндромам. Мы можем переписать нашу replaceAllNotWordSymbolsToEmpltyGlobal без лишних скобок:
```
const replaceAllNotWordSymbolsToEmpltyGlobal = party(replace,allNotWordSymbolsRegexpGlobal(), '');
```
Давайте посмотрим на весь код:
```
//Набор функций может лежать где-то в бандле по утилям для строк
const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g;
const replace = (regexp, replacement, str) => str.replace(regexp, replacement);
const toLowerCase = str => str.toLowerCase();
const stringReverse = str => str.split('').reverse().join('');
const isStringsEqual = (strA, strB) => strA === strB;
//Строки могут приходить откуда нибудь с сервера
const testString = 'Я иду с мечем судия';
//инструменты функционального программирования могут лежать в отдельном бандле или можно использовать какую-нибудь функциональную библиотеку типа rambda.js
const compose = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);
const curry = fn => (...args) => {
if (fn.length > args.length) {
const f = fn.bind(null, ...args);
return curry(f);
} else {
return fn(...args)
}
}
const party = (fn, ...args) => (...rest) => fn(...args.concat(rest));
//и вот он бандл с нашей программой
const replaceAllNotWordSymbolsToEmpltyGlobal = party(replace,allNotWordSymbolsRegexpGlobal(), '');
const processFormPalindrom = compose(
replaceAllNotWordSymbolsToEmpltyGlobal,
toLowerCase,
stringReverse
);
const processFormTestString = compose(
replaceAllNotWordSymbolsToEmpltyGlobal,
toLowerCase,
);
const checkPalindrom = testString => isStringsEqual(processFormPalindrom(testString), processFormTestString(testString));
```
Выглядит здорово, но вдруг нам не строка, а массив придёт? Поэтому допишем ещё одну функцию:
```
const map = fn => (...args) => args.map(fn);
```
Теперь если у нас будет массив для тестирования на палиндромы, то:
```
const palindroms = ['Я иду с мечем судия','А к долу лодка','Кит на море романтик'. 'Не палиндром']
map(checkPalindrom )(...palindroms ); // [true, true, true, false] работает корректно
```
Вот так мы решили поставленную задачу через написание наборов функций. Обратите внимание на бесточечный стиль написания кода — это лакмусовая бумага функциональной чистоты.
Теперь ещё немного теории. Используя каррирование не забывайте, что каждый раз каррируя функцию вы создаёте новую, т.е. выделяете под неё ячейку памяти. За этим важно следить, чтобы избегать утечек.
В функциональных библиотеках, например ramda.js есть функции compose и pipe. compose реализует алгоритм композиции справа налево, а pipe слева направо. Наша функция compose это аналог pipe из ramda. В библиотеке две разных функции композирования т.к. композиция справа-налево и слева-направо это два разных контракта функционального программирования. Если кто-то из читателей найдёт статью, в которой описаны все существующие контракты ФП, то поделитесь ей в комментах, с радостью почитаю и плюсик коменту поставлю!
Количество формальных параметров функции называют **арностью**. то тоже важное определение с точки зрения теории ФП.
Заключение
----------
В рамках данной статьи мы разобрали такие техники функционального программирования как композиция, каррирование и частичное применение. Разумеется, на реальных проектах вы будете использовать готовые библиотеки с этими инструментами, но в рамках статьи я реализовывал всё на нативном JS, чтобы читатели с возможно не очень большим опытом в ФП могли понять как эти техники работают под капотом.
Также я сознательно избрал метод повествования — псевдо кодревью, для того, чтобы проиллюстрировать свою логику достижения функциональной чистоты в коде.
К слову, вы можете продолжить развитие этого модуля работы с палиндромами и развить его идеи, например загружать строки по апи, преобразовывать в наборы букв и отправлять на сервер, где будет генерироваться строка палиндром и многое другое… На ваше усмотрение.
Также неплохо было бы избавится от дублирования в процессах этих строк:
```
replaceAllNotWordSymbolsToEmpltyGlobal,
toLowerCase,
```
В общем, совершенствовать код можно и нужно постоянно!
До будущих статей. | https://habr.com/ru/post/475324/ | null | ru | null |
# R: пакет ellipse для визуализации доверительных областей
Здравствуйте.
В последнем посте из R-хаба [«Визуализация двумерного гауссиана на плоскости»](http://habrahabr.ru/post/199060/) был описан алгоритм построения доверительного эллипса по ковариационной матрице. Алгоритм сопровождался примером и R-скриптом.
Возможно, автору поста о «Визуализации гауссианы» [mephistopheies](http://habrahabr.ru/users/mephistopheies/) и читателям R-хаба будет полезной следующая информация. В репозитории R есть пакет [ellipse](http://cran.r-project.org/web/packages/ellipse/index.html). Этот пакет содержит различные процедуры для построения эллипсов доверительных областей.
Рассмотрим пример.
##### Выборка из двумерного нормального распределения
Для генерации выборки из двумерного нормального распределения используем пакет [mvtnorm](http://cran.r-project.org/web/packages/mvtnorm/index.html).
Строим выборку *data* из 1000 элементов c вектором средних значений *mu* и ковариационной матрицей *sigma*:
```
require(mvtnorm)
mu <- c(1,2)
sigma <- matrix(c(4,2,2,3), ncol=2)
set.seed(100)
data <- rmvnorm(n=1000, mean=mu, sigma=sigma) # генерируем выборку с заданными параметрами
```
##### Эллипс 95% доверительной области
Для ковариационной матрицы *sigma* находим координаты 100 точек эллипса 95% доверительной области:
```
require(ellipse)
confidence.ellipse <- ellipse(sigma,centre=mu,level=0.95,npoints=100)
```
##### Визуализация
Отображаем на плоскости точки *data* и эллипс *confidence.ellipse*
```
plot(data,pch=19,col=rgb(0, 0.5, 1, 0.2), xlab="x", ylab="y",
xlim=range(data[,1]), ylim=range(data[,2]))
par(new=TRUE)
plot(confidence.ellipse,type="l", xlab="",ylab="",
xlim=range(data[,1]),ylim=range(data[,2]))
```
Результат:
 | https://habr.com/ru/post/199282/ | null | ru | null |
# Мой опыт работы с необычным подходом к построению группы React приложений
* Вступление
* О системе
* Плюсы и минусы
* Возможные улучшения
* Заключение
### Вступление
Прежде чем начать, хочу уведомить что у меня нет желания как то оскорбить или продвинуть свою точку зрения как истинную. Все системы, приложения, модули и функционал, так или иначе были сделаны по какой то причине, таков путь и это нормально! Данную статью пишу с целью улучшения аналогичных систем в нашем уютном комьюнити :З
В данной статье постараюсь рассказать об одной из систем построенной на React и TS с которой удалось поработать, субъективно описать ее плюсы и минусы, а так же затронуть тему того, что можно было улучшить в рамках системы.
Если у тебя есть какие то замечания (или находишь статью душноватой), дополнения или можно как то написать статью лучше, то пожалуйста напиши об этом в комментарии, мне будет очень интересно почитать :)
---
**Немного боли из проекта:**
* Полное копирование всей директории с исходниками => Вставка директории и ручное удаление ненужных частей
* Практически полное отсутствие переиспользуемых компонентов
* Глобальные файлы со стилями без использования модульности или CSS-in-JS
* Написание стилей через id и теги
* Нам нужны новые фичи, а это не принесет денег бизнесу (с)
+ У нас тут все логично, поразбирайся немного и поймешь что все логично и правильно
Возможно у нас есть общий опыт работы с подобными проектами и понимаешь весь дискомфорт, если да то добро пожаловать под кат :) иначе все равно проходи, потому что я постараюсь написать о полезных штуках.
---
О системе
---------
Для того чтобы добавить смысл в текст ниже, немного опишу для чего была сделана система:
1. Подготовка небольших фрагментов кода для вставки в мобильное приложение через WebView
2. Проведение AB тестирования для увеличения конверсии продукта (то есть если люди не стали больше покупать услуги, директория с фичей удаляется или уходит в папку deprecated)
Данная система имеет 2 типа приложений **Screens** и **Widgets**, главное их различие в том, куда WebView позже их вставит в мобильное приложение и наверное это все :)
**Screens** и **Widgets** это набор директорий, где каждая собирается Webpack как отдельное React приложение, так же приложение имеет свой конфиг и конфиг в директории фикстур.
Такая архитектура была сделана с целью, чтобы каждое последующее приложение (далее буду называть его экраном), могло сильно отличаться предыдущего и сделать возможность его максимально кастомизируемым визуально.
**Ключевая структура корня приложения имеет примерно следующий вид:**
```
{
.storybook: "Конфиги для общей настройки сторибука",
node_modules: "Куда же без них",
scripts: "Общие скрипты с функциями",
src: {
js: {
fuxtures: "Конфиги для тестирования",
components: "Буквально пару переиспользуемых компонентов",
screens: "Директория с приложениями",
widgets: "Другая директория с приложениями"
},
img: "Общие стили",
styles: "Директория с общими стилями",
index.html: "Корневой html шаблон для приложений"
}
// И некие стандартные вещи вроде
tsconfig.json,
package.json,
jest.config.js,
postcss.config.js,
webpack.common.js
...
}
```
**Структура экрана или виджета следующая:**
```
{
components: "Компоненты под текущий экран или виджет",
colorThemeStylesheet.tsx: `
Файл в котором через react-helmet устанавливаются css переменные,
значение которых берется из конфига или конфига фикстуры если
он имеется.
`,
config.ts: "Локальный конфиг экрана",
id999.pcss: "Стили для экрана или виджета, где 999 это id текущего экрана",
id999.stories.ts: "Конфиг для storybook",
index.ts: "Входной файл для сборки вебпака",
Screen.tsx: `
JSX код в основном в нем содержится весь код,
который в редких моментах вынесен в локальные компоненты
`
}
```
**Принцип создания нового экрана**
Берем директорию с похожим функционалом делаем CTR+C => CTR+V, добавляем щепотку ~~магии~~ фикстурного конфига и вуаля! Вроде как наше промо готово, но нам же нужно сделать не 100% копию другого экрана, а с отличиями, мы их делаем для экспериментов и вооот тут начинается унылый механический ад.
Предположим у нас в экране который мы копировали есть **следующий функционал:**
* название
* слайдер
* описание
* продукты
* Кнопка покупки
**А по ТЗ нужно:**
* название
* ~~слайдер~~
+ (вместо него поставить какую-нибудь анимацию моргания глаз, которую можно взять из экрана 100 или экрана 102, которые кстати отличаются)
* ~~описание~~ акции
* продукты
* Кнопка покупки
---
**Начинаем идти по кругам рутины**
**Д**ля начала мы должны удалить вручную из **Screen.tsx** всю JSX разметку слайдера и разметку "описания акции" =>
**П**ереходим в стили этого экрана ищем все места, где необходимо удалить (*что кстати мы можем вполне себе пропустить из-за того что они могут стилизоваться совершенно разными способами, что приведет к снежному кому, когда данный экран скопируют*) =>
**П**ереходим в **ColorThemeStylesheet.tsx** и убираем места св-ва конфига которые не используются =>
**У**бираем с нашего config.ts лишние параметры и интерфейсы с типами =>
**И**дем в фикстуры, повторяем процесс =>
**П**ереименовываем директорию на новые экран =>
**П**ереименовываем файл стилей и сторибука =>
**В** файле стилей оборачиваем в наш id экрана для инкапсуляции стилей для сторибука (тк в сторибуке отображаются все экраны и виджеты и если не делать вышеперечисленное, то сторибук может поплыть) =>
**И**дем в 100 экран ищем JSX разметку анимации "моргания глаз", вставляем ее, вставляем стили к ней, вставляем **ColorThemeStylesheet** какие-нибудь св-ва конфига и фикстур (предварительно дописав типы в конфиге и сами значения), вставляем и понимаем что в 100 она была реализована криво или с отличающимся сильно разным функционалом =>
**Л**омаем клавиатуру об стену => достаем из ящика новую
**П**овторяем процесс удаления анимации =>
**Б**ерем из 102, повторяем процесс вставки руками
**И**щем "акции" или верстаем этот блок сами (чтобы потом его удалить в дочернем экране)
**В** лучшем случае после всего этого, конец (в частом же ревью неапрувится, тк что то осталось в конфиге, в фикстурном конфиге, в стилях, в разметке, в логике, в картинках, в файле ColorThemeStylesheet и т.д) и как только долгожданный апрув проходит, вы должны повторить цикл с следующей промкой и так до выходных.
---
Плюсы и минусы
--------------
| | |
| --- | --- |
| **Плюсы** | **Минусы** |
| Максимальная кастомизация экранов и виджетов. | Трудозатратное создание экрана и ошибки из-за человеческого фактора невнимательности, даже при минимальный отличиях в функционале |
| Просмотр всех экранов и виджетов из сторибука, возможность передать в параметры сторибука св-ва для визуального тестирования | Нет возможности быстро узнать в какой экране есть тот или иной функционал |
| | Нет возможности быстро переиспользовать какой-либо функционал |
| | Снежный ком из потенциальных багов |
| | Нет возможности исправить ту или иную часть группы экранов из-за пропущенной ошибки |
| | При копировании древнего экрана, ревьютер потребует удаления смежного кома из ошибок, которые были сделаны ранее и не относятся к задаче |
| | Тк мы копируем и вставляем наши экраны, git считает что это новые файлы, а это значит что на ревью будет очень много всего. |
---
Возможные улучшения
-------------------
1. Вынесения большей части функциональности в переиспользуемые компоненты, чтобы избежать "снежного кома", упростить понимание работы экрана и ускорить разработку при необходимости использования дефолтных элементов интерфейса
**P.S.** так как наша система должна быть максимально гибкой мы должны использовать композицию элементов и если есть необходимость в изменении компонента использовать **Theme**, но не менять нашу компоненту **Modal**, тк это может затронуть другие экраны.
Пункт №1
2. Создание некого шаблона который будет собирать в пустой экран или виджет (а в нем использовать импорт компонентов из 1 пункта)
Пункт №2
---
Заключение
----------
Тк обладаю неким своим контекстом знания о системе, мог что то упустить в статье что привело бы к ее непониманию, однако очень надеюсь что все было понятно и интересно :)
Мне кажется улучшения описанные выше помогли бы очистить систему от вышеописанных минусов. А как вы думаете что можно сделать в данной системе чтобы упростить процесс создания новых экранов и виджетов? | https://habr.com/ru/post/589903/ | null | ru | null |
# Spring Security — пример REST-сервиса с авторизацией по протоколу OAuth2 через BitBucket и JWT
В [предыдущей](https://habr.com/ru/post/497588/) статье мы разработали простое защищенное веб приложение, в котором для аутентификации пользователей использовался протокол OAuth2 с Bitbucket в качестве сервера авторизации. Кому-то такая связка может показаться странной, но представьте, что мы разрабатываем CI (Continuous Integration) сервер и хотели бы иметь доступ к ресурсам пользователя в системе контроля версий. Например, по такому же принципу работает довольно известная CI платформа [drone.io](https://drone.io).
В предыдущем примере для авторизации запросов к серверу использовалась HTTP-сессия (и куки). Однако для реализации REST-сервиса данный способ авторизации не подходит, поскольку одним из требований REST архитектуры является отсутсвие состояния. В данной статье мы реализуем REST-сервис, авторизация запросов к которому будет осуществляться с помощью токена доступа (access token).
Немного теории
--------------
**Аутентификация** — это процесс проверки учётных данных пользователя (логин/пароль). Проверка подлинности пользователя осуществляется путём сравнения введённого им логина/пароля с сохраненными данными.
**Авторизация** — это проверка прав пользователя на доступ к определенным ресурсам. Авторизация выполняется непосредственно при обращении пользователя к ресурсу.
Рассмотрим порядок работы двух вышеупомянутых способов авторизации запросов.
Авторизация запросов с помощью HTTP-сессии:
* Пользователь проходит аутентификацию любым из способов.
* На сервере создается HTTP-сессия и куки JSESSIONID, хранящий идентификатор сессии.
* Куки JSESSIONID передается на клиент и сохраняется в браузере.
* С каждым последующим запросом на сервер отправляется куки JSESSIONID.
* Сервер находит соответствующую HTTP-сессию с информацией о текущем пользователе и определяет имеет ли пользователь права на выполнение данного вызова.
* Для выполнения выхода из приложения необходимо удалить с сервера HTTP-сессию.
Авторизация запросов с помощью токена доступа:
* Пользователь проходит аутентификацию любым из способов.
* Сервер создает токен доступа, подписанный секретным ключом, а затем отправляет его клиенту. Токен содержит идентификатор пользователя и его роли.
* Токен сохраняется на клиенте и передается на сервер с каждым последующим запросом. Как правило для передачи токена используетя HTTP заголовок Authorization.
* Сервер сверяет подпись токена, извлекает из него идентификатор пользователя, его роли и определяет имеет ли пользователь права на выполнение данного вызова.
* Для выполнения выхода из приложения достаточно просто удалить токен на клиенте без необходимости взаимодействия с сервером.
Распространенным форматом токена доступа в настоящее время является JSON Web Token (JWT). Токен в формате JWT содержит три блока, разделенных точками: заголовок (header), набор полей (payload) и сигнатуру (подпись). Первые два блока представлены в JSON-формате и закодированы в формат base64. Набор полей может состоять как из зарезервированных имен (iss, iat, exp), так и произвольных пар имя/значение. Подпись может генерироваться как при помощи симметричных, так и асимметричных алгоритмов шифрования.
Реализация
----------
Мы реализуем REST-сервис, предоставляющий следующее API:
* GET /auth/login — запустить процесс аутентификации пользователя.
* POST /auth/token — запросить новую пару access/refresh токенов.
* GET /api/repositories — получить список Bitbucket репозиториев текущего пользователя.
*Высокоуровневая архитектура приложения*
Заметим, что поскольку приложение состоит из трех взаимодействующих компонентов, помимо того, что мы выполняем авторизацию запросов клиента к серверу, Bitbucket авторизует запросы сервера к нему. Мы не будем настраивать авторизацию методов по ролям, чтобы не делать пример сложнее. У нас есть только один API метод GET /api/repositories, вызывать который могут только аутентифицированные пользователи. Сервер может выполнять на Bitbucket любые операции, разрешенные при регистрации OAuth клиента.
*Процесс регистрации OAuth клиента описан в [предыдущей](https://habr.com/ru/post/497588/) статье*
Для реализации мы будем использовать Spring Boot версии 2.2.2.RELEASE и Spring Security версии 5.2.1.RELEASE.
### Переопределим AuthenticationEntryPoint
В стандартном веб-приложении, когда осуществляется обращение к защищенному ресурсу и в секьюрити контексте отсутствует объект Authentication, Spring Security перенаправляет пользователя на страницу аутентификации. Однако для REST-сервиса более подходящим поведением в этом случае было бы возвращать HTTP статус 401 (UNAUTHORIZED).
**RestAuthenticationEntryPoint**
```
public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
@Override
public void commence(
HttpServletRequest request,
HttpServletResponse response,
AuthenticationException authException) throws IOException {
response.sendError(HttpServletResponse.SC_UNAUTHORIZED, authException.getMessage());
}
}
```
### Создадим login endpoint
Для аутентификации пользователя мы по-прежнему используем OAuth2 с типом авторизации Authorization Code. Однако на предыдущем шаге мы заменили стандартный AuthenticationEntryPoint своей реализацией, поэтому нам нужен явный способ запустить процесс аутентификации. При отправке GET запроса по адресу /auth/login мы перенаправим пользователя на страницу аутентификации Bitbucket. Параметром этого метода будет URL обратного вызова, по которому мы возвратим токен доступа после успешной аутентификации.
**Login endpoint**
```
@Path("/auth")
public class AuthEndpoint extends EndpointBase {
...
@GET
@Path("/login")
public Response authorize(@QueryParam(REDIRECT_URI) String redirectUri) {
String authUri = "/oauth2/authorization/bitbucket";
UriComponentsBuilder builder = fromPath(authUri).queryParam(REDIRECT_URI, redirectUri);
return handle(() -> temporaryRedirect(builder.build().toUri()).build());
}
}
```
### Переопределим AuthenticationSuccessHandler
AuthenticationSuccessHandler вызывается после успешной аутентификации. Сгенерируем тут токен доступа, refresh токен и выполним редирект по адресу обратного вызова, который был передан в начале процесса аутентификации. Токен доступа вернем параметром GET запроса, а refresh токен в httpOnly куке. Что такое refresh токен разберем позже.
**ExampleAuthenticationSuccessHandler**
```
public class ExampleAuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
private final TokenService tokenService;
private final AuthProperties authProperties;
private final HttpCookieOAuth2AuthorizationRequestRepository authorizationRequestRepository;
public ExampleAuthenticationSuccessHandler(
TokenService tokenService,
AuthProperties authProperties,
HttpCookieOAuth2AuthorizationRequestRepository authorizationRequestRepository) {
this.tokenService = requireNonNull(tokenService);
this.authProperties = requireNonNull(authProperties);
this.authorizationRequestRepository = requireNonNull(authorizationRequestRepository);
}
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
log.info("Logged in user {}", authentication.getPrincipal());
super.onAuthenticationSuccess(request, response, authentication);
}
@Override
protected String determineTargetUrl(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
Optional redirectUri = getCookie(request, REDIRECT\_URI).map(Cookie::getValue);
if (redirectUri.isPresent() && !isAuthorizedRedirectUri(redirectUri.get())) {
throw new BadRequestException("Received unauthorized redirect URI.");
}
return UriComponentsBuilder.fromUriString(redirectUri.orElse(getDefaultTargetUrl()))
.queryParam("token", tokenService.newAccessToken(toUserContext(authentication)))
.build().toUriString();
}
@Override
protected void handle(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException {
redirectToTargetUrl(request, response, authentication);
}
private boolean isAuthorizedRedirectUri(String uri) {
URI clientRedirectUri = URI.create(uri);
return authProperties.getAuthorizedRedirectUris()
.stream()
.anyMatch(authorizedRedirectUri -> {
// Only validate host and port. Let the clients use different paths if they want to.
URI authorizedURI = URI.create(authorizedRedirectUri);
return authorizedURI.getHost().equalsIgnoreCase(clientRedirectUri.getHost())
&& authorizedURI.getPort() == clientRedirectUri.getPort();
});
}
private TokenService.UserContext toUserContext(Authentication authentication) {
ExampleOAuth2User principal = (ExampleOAuth2User) authentication.getPrincipal();
return TokenService.UserContext.builder()
.login(principal.getName())
.name(principal.getFullName())
.build();
}
private void addRefreshTokenCookie(HttpServletResponse response, Authentication authentication) {
RefreshToken token = tokenService.newRefreshToken(toUserContext(authentication));
addCookie(response, REFRESH\_TOKEN, token.getId(), (int) token.getValiditySeconds());
}
private void redirectToTargetUrl(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException {
String targetUrl = determineTargetUrl(request, response, authentication);
if (response.isCommitted()) {
logger.debug("Response has already been committed. Unable to redirect to " + targetUrl);
return;
}
addRefreshTokenCookie(response, authentication);
authorizationRequestRepository.removeAuthorizationRequestCookies(request, response);
getRedirectStrategy().sendRedirect(request, response, targetUrl);
}
}
```
### Переопределим AuthenticationFailureHandler
В случае, если пользователь не прошел аутентификацию, мы перенаправим его по адресу обратного вызова, который был передан в начале процесса аутентификации с параметром error, содержащим текст ошибки.
**ExampleAuthenticationFailureHandler**
```
public class ExampleAuthenticationFailureHandler implements AuthenticationFailureHandler {
private final RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
private final HttpCookieOAuth2AuthorizationRequestRepository authorizationRequestRepository;
public ExampleAuthenticationFailureHandler(
HttpCookieOAuth2AuthorizationRequestRepository authorizationRequestRepository) {
this.authorizationRequestRepository = requireNonNull(authorizationRequestRepository);
}
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException {
String targetUrl = getFailureUrl(request, exception);
authorizationRequestRepository.removeAuthorizationRequestCookies(request, response);
redirectStrategy.sendRedirect(request, response, targetUrl);
}
private String getFailureUrl(HttpServletRequest request, AuthenticationException exception) {
String targetUrl = getCookie(request, Cookies.REDIRECT_URI)
.map(Cookie::getValue)
.orElse(("/"));
return UriComponentsBuilder.fromUriString(targetUrl)
.queryParam("error", exception.getLocalizedMessage())
.build().toUriString();
}
}
```
### Создадим TokenAuthenticationFilter
Задача этого фильтра извлечь токен доступа из заголовка Authorization в случае его наличия, провалидировать его и инициализировать секьюрити контекст.
**TokenAuthenticationFilter**
```
public class TokenAuthenticationFilter extends OncePerRequestFilter {
private final UserService userService;
private final TokenService tokenService;
public TokenAuthenticationFilter(
UserService userService, TokenService tokenService) {
this.userService = requireNonNull(userService);
this.tokenService = requireNonNull(tokenService);
}
@Override
protected void doFilterInternal(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull FilterChain chain) throws ServletException, IOException {
try {
Optional jwtOpt = getJwtFromRequest(request);
if (jwtOpt.isPresent()) {
String jwt = jwtOpt.get();
if (isNotEmpty(jwt) && tokenService.isValidAccessToken(jwt)) {
String login = tokenService.getUsername(jwt);
Optional userOpt = userService.findByLogin(login);
if (userOpt.isPresent()) {
User user = userOpt.get();
ExampleOAuth2User oAuth2User = new ExampleOAuth2User(user);
OAuth2AuthenticationToken authentication = new OAuth2AuthenticationToken(oAuth2User, oAuth2User.getAuthorities(), oAuth2User.getProvider());
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(authentication);
}
}
}
} catch (Exception e) {
logger.error("Could not set user authentication in security context", e);
}
chain.doFilter(request, response);
}
private Optional getJwtFromRequest(HttpServletRequest request) {
String token = request.getHeader(AUTHORIZATION);
if (isNotEmpty(token) && token.startsWith("Bearer ")) {
token = token.substring(7);
}
return Optional.ofNullable(token);
}
}
```
### Создадим refresh token endpoint
В целях безопасности время жизни токена доступа обычно делают небольшим. Тогда в случае его кражи злоумышленник не сможет пользоваться им бесконечно долго. Чтобы не заставлять пользователя выполнять вход в приложение снова и снова используется refresh токен. Он выдается сервером после успешной аутентификации вместе с токеном доступа и имеет большее время жизни. Используя его можно запросить новую пару токенов. Refresh токен рекомендуют хранить в httpOnly куке.
**Refresh token endpoint**
```
@Path("/auth")
public class AuthEndpoint extends EndpointBase {
...
@POST
@Path("/token")
@Produces(APPLICATION_JSON)
public Response refreshToken(@CookieParam(REFRESH_TOKEN) String refreshToken) {
return handle(() -> {
if (refreshToken == null) {
throw new InvalidTokenException("Refresh token was not provided.");
}
RefreshToken oldRefreshToken = tokenService.findRefreshToken(refreshToken);
if (oldRefreshToken == null || !tokenService.isValidRefreshToken(oldRefreshToken)) {
throw new InvalidTokenException("Refresh token is not valid or expired.");
}
Map result = new HashMap<>();
result.put("token", tokenService.newAccessToken(of(oldRefreshToken.getUser())));
RefreshToken newRefreshToken = newRefreshTokenFor(oldRefreshToken.getUser());
return Response.ok(result).cookie(createRefreshTokenCookie(newRefreshToken)).build();
});
}
}
```
### Переопределим AuthorizationRequestRepository
Spring Security использует объект AuthorizationRequestRepository для хранения объектов OAuth2AuthorizationRequest на время процесса аутентификации. Реализацией по умолчанию является класс HttpSessionOAuth2AuthorizationRequestRepository, который использует HTTP-сессию в качестве хранилища. Т.к. наш сервис не должен хранить состояние, эта реализация нам не подходит. Реализуем свой класс, который будет использовать HTTP cookies.
**HttpCookieOAuth2AuthorizationRequestRepository**
```
public class HttpCookieOAuth2AuthorizationRequestRepository implements AuthorizationRequestRepository {
private static final int COOKIE\_EXPIRE\_SECONDS = 180;
private static final String OAUTH2\_AUTHORIZATION\_REQUEST\_COOKIE\_NAME = "OAUTH2-AUTH-REQUEST";
@Override
public OAuth2AuthorizationRequest loadAuthorizationRequest(HttpServletRequest request) {
return getCookie(request, OAUTH2\_AUTHORIZATION\_REQUEST\_COOKIE\_NAME)
.map(cookie -> deserialize(cookie, OAuth2AuthorizationRequest.class))
.orElse(null);
}
@Override
public void saveAuthorizationRequest(OAuth2AuthorizationRequest authorizationRequest, HttpServletRequest request, HttpServletResponse response) {
if (authorizationRequest == null) {
removeAuthorizationRequestCookies(request, response);
return;
}
addCookie(response, OAUTH2\_AUTHORIZATION\_REQUEST\_COOKIE\_NAME, serialize(authorizationRequest), COOKIE\_EXPIRE\_SECONDS);
String redirectUriAfterLogin = request.getParameter(QueryParams.REDIRECT\_URI);
if (isNotBlank(redirectUriAfterLogin)) {
addCookie(response, REDIRECT\_URI, redirectUriAfterLogin, COOKIE\_EXPIRE\_SECONDS);
}
}
@Override
public OAuth2AuthorizationRequest removeAuthorizationRequest(HttpServletRequest request) {
return loadAuthorizationRequest(request);
}
public void removeAuthorizationRequestCookies(HttpServletRequest request, HttpServletResponse response) {
deleteCookie(request, response, OAUTH2\_AUTHORIZATION\_REQUEST\_COOKIE\_NAME);
deleteCookie(request, response, REDIRECT\_URI);
}
private static String serialize(Object object) {
return Base64.getUrlEncoder().encodeToString(SerializationUtils.serialize(object));
}
@SuppressWarnings("SameParameterValue")
private static T deserialize(Cookie cookie, Class clazz) {
return clazz.cast(SerializationUtils.deserialize(Base64.getUrlDecoder().decode(cookie.getValue())));
}
}
```
### Настроим Spring Security
Соберем все проделанное выше вместе и настроим Spring Security.
**WebSecurityConfig**
```
@Configuration
@EnableWebSecurity
public static class WebSecurityConfig extends WebSecurityConfigurerAdapter {
private final ExampleOAuth2UserService userService;
private final TokenAuthenticationFilter tokenAuthenticationFilter;
private final AuthenticationFailureHandler authenticationFailureHandler;
private final AuthenticationSuccessHandler authenticationSuccessHandler;
private final HttpCookieOAuth2AuthorizationRequestRepository authorizationRequestRepository;
@Autowired
public WebSecurityConfig(
ExampleOAuth2UserService userService,
TokenAuthenticationFilter tokenAuthenticationFilter,
AuthenticationFailureHandler authenticationFailureHandler,
AuthenticationSuccessHandler authenticationSuccessHandler,
HttpCookieOAuth2AuthorizationRequestRepository authorizationRequestRepository) {
this.userService = userService;
this.tokenAuthenticationFilter = tokenAuthenticationFilter;
this.authenticationFailureHandler = authenticationFailureHandler;
this.authenticationSuccessHandler = authenticationSuccessHandler;
this.authorizationRequestRepository = authorizationRequestRepository;
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.cors().and()
.csrf().disable()
.formLogin().disable()
.httpBasic().disable()
.sessionManagement(sm -> sm.sessionCreationPolicy(STATELESS))
.exceptionHandling(eh -> eh
.authenticationEntryPoint(new RestAuthenticationEntryPoint())
)
.authorizeRequests(authorizeRequests -> authorizeRequests
.antMatchers("/auth/**").permitAll()
.anyRequest().authenticated()
)
.oauth2Login(oauth2Login -> oauth2Login
.failureHandler(authenticationFailureHandler)
.successHandler(authenticationSuccessHandler)
.userInfoEndpoint(userInfoEndpoint -> userInfoEndpoint.userService(userService))
.authorizationEndpoint(authEndpoint -> authEndpoint.authorizationRequestRepository(authorizationRequestRepository))
);
http.addFilterBefore(tokenAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
}
}
```
### Создадим repositories endpoint
То ради чего и нужна была аутентификация через OAuth2 и Bitbucket — возможность использовать Bitbucket API для доступа к своим ресурсам. Используем Bitbucket repositories API для получения списка репозиториев текущего пользователя.
**Repositories endpoint**
```
@Path("/api")
public class ApiEndpoint extends EndpointBase {
@Autowired
private BitbucketService bitbucketService;
@GET
@Path("/repositories")
@Produces(APPLICATION_JSON)
public List getRepositories() {
return handle(bitbucketService::getRepositories);
}
}
public class BitbucketServiceImpl implements BitbucketService {
private static final String BASE\_URL = "https://api.bitbucket.org";
private final Supplier restTemplate;
public BitbucketServiceImpl(Supplier restTemplate) {
this.restTemplate = restTemplate;
}
@Override
public List getRepositories() {
UriComponentsBuilder uriBuilder = fromHttpUrl(format("%s/2.0/repositories", BASE\_URL));
uriBuilder.queryParam("role", "member");
ResponseEntity response = restTemplate.get().exchange(
uriBuilder.toUriString(),
HttpMethod.GET,
new HttpEntity<>(new HttpHeadersBuilder()
.acceptJson()
.build()),
BitbucketRepositoriesResponse.class);
BitbucketRepositoriesResponse body = response.getBody();
return body == null ? emptyList() : extractRepositories(body);
}
private List extractRepositories(BitbucketRepositoriesResponse response) {
return response.getValues() == null
? emptyList()
: response.getValues().stream().map(BitbucketServiceImpl.this::convertRepository).collect(toList());
}
private Repository convertRepository(BitbucketRepository bbRepo) {
Repository repo = new Repository();
repo.setId(bbRepo.getUuid());
repo.setFullName(bbRepo.getFullName());
return repo;
}
}
```
Тестирование
------------
Для тестирования нам понадобится небольшой HTTP-сервер, на который будет отправлен токен доступа. Сначала попробуем вызвать repositories endpoint без токена доступа и убедимся, что в этом случае получим ошибку 401. Затем пройдем аутентификацию. Для этого запустим сервер и перейдем в браузере по адресу <http://localhost:8080/auth/login>. После того как мы введем логин/пароль, клиент получит токен и вызовет repositories endpoint еще раз. Затем будет запрошен новый токен и снова вызван repositories endpoint с новым токеном.
**OAuth2JwtExampleClient**
```
public class OAuth2JwtExampleClient {
/**
* Start client, then navigate to http://localhost:8080/auth/login.
*/
public static void main(String[] args) throws Exception {
AuthCallbackHandler authEndpoint = new AuthCallbackHandler(8081);
authEndpoint.start(SOCKET_READ_TIMEOUT, true);
HttpResponse response = getRepositories(null);
assert (response.getStatusLine().getStatusCode() == SC_UNAUTHORIZED);
Tokens tokens = authEndpoint.getTokens();
System.out.println("Received tokens: " + tokens);
response = getRepositories(tokens.getAccessToken());
assert (response.getStatusLine().getStatusCode() == SC_OK);
System.out.println("Repositories: " + IOUtils.toString(response.getEntity().getContent(), UTF_8));
// emulate token usage - wait for some time until iat and exp attributes get updated
// otherwise we will receive the same token
Thread.sleep(5000);
tokens = refreshToken(tokens.getRefreshToken());
System.out.println("Refreshed tokens: " + tokens);
// use refreshed token
response = getRepositories(tokens.getAccessToken());
assert (response.getStatusLine().getStatusCode() == SC_OK);
}
private static Tokens refreshToken(String refreshToken) throws IOException {
BasicClientCookie cookie = new BasicClientCookie(REFRESH_TOKEN, refreshToken);
cookie.setPath("/");
cookie.setDomain("localhost");
BasicCookieStore cookieStore = new BasicCookieStore();
cookieStore.addCookie(cookie);
HttpPost request = new HttpPost("http://localhost:8080/auth/token");
request.setHeader(ACCEPT, APPLICATION_JSON.getMimeType());
HttpClient httpClient = HttpClientBuilder.create().setDefaultCookieStore(cookieStore).build();
HttpResponse execute = httpClient.execute(request);
Gson gson = new Gson();
Type type = new TypeToken>() {
}.getType();
Map response = gson.fromJson(IOUtils.toString(execute.getEntity().getContent(), UTF\_8), type);
Cookie refreshTokenCookie = cookieStore.getCookies().stream()
.filter(c -> REFRESH\_TOKEN.equals(c.getName()))
.findAny()
.orElseThrow(() -> new IOException("Refresh token cookie not found."));
return Tokens.of(response.get("token"), refreshTokenCookie.getValue());
}
private static HttpResponse getRepositories(String accessToken) throws IOException {
HttpClient httpClient = HttpClientBuilder.create().build();
HttpGet request = new HttpGet("http://localhost:8080/api/repositories");
request.setHeader(ACCEPT, APPLICATION\_JSON.getMimeType());
if (accessToken != null) {
request.setHeader(AUTHORIZATION, "Bearer " + accessToken);
}
return httpClient.execute(request);
}
}
```
Консольный вывод клиента.
```
Received tokens: Tokens(accessToken=eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJldm9sdmVjaS10ZXN0a2l0IiwidXNlcm5hbWUiOiJFdm9sdmVDSSBUZXN0a2l0IiwiaWF0IjoxNjA1NDY2MDMxLCJleHAiOjE2MDU0NjY2MzF9.UuRYMdIxzc8ZFEI2z8fAgLz-LG_gDxaim25pMh9jNrDFK6YkEaDqDO8Huoav5JUB0bJyf1lTB0nNPaLLpOj4hw, refreshToken=BBF6dboG8tB4XozHqmZE5anXMHeNUncTVD8CLv2hkaU2KsfyqitlJpgkV4HrQqPk)
Repositories: [{"id":"{c7bb4165-92f1-4621-9039-bb1b6a74488e}","fullName":"test-namespace/test-repository1"},{"id":"{aa149604-c136-41e1-b7bd-3088fb73f1b2}","fullName":"test-namespace/test-repository2"}]
Refreshed tokens: Tokens(accessToken=eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJldm9sdmVjaS10ZXN0a2l0IiwidXNlcm5hbWUiOiJFdm9sdmVDSSBUZXN0a2l0IiwiaWF0IjoxNjA1NDY2MDM2LCJleHAiOjE2MDU0NjY2MzZ9.oR2A_9k4fB7qpzxvV5QKY1eU_8aZMYEom-ngc4Kuc5omeGPWyclfqmiyQTpJW_cHOcXbY9S065AE_GKXFMbh_Q, refreshToken=mdc5sgmtiwLD1uryubd2WZNjNzSmc5UGo6JyyzsiYsBgOpeaY3yw3T3l8IKauKYQ)
```
Исходный код
------------
Полный исходный код рассмотренного приложения находится на [Github](https://github.com/nbondarchuk/oauth2-bitbucket-jwt-example).
Ссылки
------
* [OAuth — Википедия](https://ru.wikipedia.org/wiki/OAuth)
* [Spring Security Reference](https://docs.spring.io/spring-security/site/docs/5.2.3.RELEASE/reference/htmlsingle/#oauth2login-advanced-userinfo-endpoint)
* [JSON Web Token (JWT)](https://tools.ietf.org/html/rfc7519)
* [The OAuth 2.0 Authorization Framework](https://tools.ietf.org/html/rfc6749#section-4.1.1)
P.S.
Созданный нами REST-сервис работает по протоколу HTTP, чтобы не усложнять пример. Но поскольку токены у нас никак не шифруются, рекомендуется перейти на защищенный канал (HTTPS). | https://habr.com/ru/post/528410/ | null | ru | null |
# Data-Oriented архитектура
В архитектуре программного обеспечения существует один малоизвестный паттерн, заслуживающий большего внимания. Архитектура, ориентированная на данные, (*data-oriented architecture, DOA*) была впервые описана Радживом Джоши в [отчете RTI 2007 года](http://community.rti.com/sites/default/files/archive/Data-Oriented_Architecture.pdf), а затем в 2017 году Кристианом Ворхемом и Эрихом Шикутой из Венского университета в [статье iiWAS](https://dl.acm.org/doi/10.1145/3151759.3151770). DOA — это инверсия традиционной дихотомии между монолитным кодом и хранилищем данных (монолитная архитектура) с одной стороны, и небольшими распределенными независимыми компонентами с собственными хранилищами (микросервисы и сервис-ориентированная архитектура) с другой. В архитектуре, ориентированной на данные, монолитное хранилище данных является единственным источником состояния в системе, на которое воздействуют слабосвязанные микросервисы без состояния.
Мне повезло, что мой [бывший работодатель](https://www.broadwaytechnology.com/) выбрал такую необычную архитектуру. Это напомнило, что одни и те же вещи *можно* делать по-разному. Архитектура, ориентированная на данные, ни в коем случае не является панацеей; у нее есть собственный уникальный набор издержек и преимуществ. Однако я обнаружил, что многие крупные компании и экосистемы сталкиваются с проблемами, для устранения которых и предназначена данная архитектура.
### Небольшая заметка о монолитной архитектуре
Поскольку многие архитектуры часто определяются *в противоположность* монолитной, стоит потратить немного времени на её описание. В конце концов, это легендарные отголоски [первобытности](https://en.wikipedia.org/wiki/State_of_nature) в разработке серверного ПО.
В **монолитном** сервисе основная часть серверного кода является одной программой, которая взаимодействует с одной или несколькими базами данных, управляя различными аспектами функциональных вычислений. Представьте себе торговую систему, которая получает запросы от клиентов на покупку или продажу какой-либо ценной бумаги, оценивает их и выполняет заказы.
В рамках монолитного сервера код все еще может быть разделен на отдельные модули, но между различными компонентами программы нет *принудительной* API-границы. Единственные жестко определенные API-интерфейсы в программе обычно находятся **(a)** между UI и сервером (вне зависимости от REST/HTTP протокола), **(b)** между сервером и хранилищами данных (вне зависимости от языка запросов), или **(c)** между сервером и его внешними зависимостями.
### Сервис-ориентированная архитектура и микросервисы
**Сервис-ориентированные архитектуры** (SOA), с другой стороны, разбивают монолитные программы на *сервисы* для каждой независимой, компонентной функции. В нашем торговом приложении у нас может быть отдельный сервис в качестве внешнего API, который принимает запросы и обрабатывает ответы для клиента, вторая система, получающая цены и другую информацию о рынке, третья система, отслеживающая заказы, риски и т.д. Интерфейс между каждым из этих сервисов представляет собой формально определенный уровень API. Сервисы обычно взаимодействуют один на один через RPC, хотя распространены и другие методы, такие как передача сообщений и pubsub.
Сервис-ориентированные архитектуры позволяют обдумывать и разрабатывать различные сервисы независимо (и параллельно), если это необходимо. Сервисы являются слабосвязанными — это означает, что совершенно новый сервис может переиспользовать другие.
Поскольку каждый сервис в SOA определяет свой собственный API, к каждому можно получить независимый доступ и с каждым можно взаимодействовать. Разработчики, отлаживающие отдельные части или симулирующие их работу, могут вызывать компоненты обособленно, а новые потоки могут комбинировать эти сервисы, чтобы обеспечить новое поведение.
**Микросервисы** — это тип сервис-ориентированной архитектуры. Здесь мнения разнятся; одни считают, что микросервисы должны быть *особо* мелкими и легковесными, другие — что это в целом синоним SOA.
### Проблемы масштабирования
В SOA отдельные компоненты напрямую взаимодействуют друг с другом через специальный API, определенный каждым из компонентов. В целях коммуникации каждый компонент можно индивидуально адресовать (т. е. использовать IP-адрес, адрес сервиса или какой-либо другой внутренний идентификатор для отправки запросов/сообщений туда и обратно). Это означает, что каждый компонент в архитектуре должен знать о своих зависимостях, и должен быть специально интегрирован с ними.
В зависимости от топологии архитектуры это может значить, что дополнительный компонент, возможно, должен знать обо всех предыдущих компонентах. Кроме того, замена отдельного сервиса, с которым уже взаимодействуют N других компонентов, вероятно, окажется сложной задачей: нужно позаботиться о сохранении любых *ad hoc* API, определенных вами, и убедиться, что у вас есть план миграции для перехода каждого из компонентов от обращения к старому сервису к новому. Поскольку API-интерфейсы «сервис-сервис» являются *ad hoc*1, это часто указывает на то, что RPC между компонентами могут быть сколь угодно сложными, что потенциально увеличивает количество возможных изменений API в будущем. Каждое изменение API в сервисе, от которого зависят многие другие, является серьезным мероприятием.
Здесь я подразумеваю, что по мере роста экосистемы микросервисов она начинает подвергаться следующим проблемами масштабирования:
1. *N2*рост сложности *интеграции по* мере увеличения числа компонентов2
2. О форме сети становится трудно рассуждать *априори*; т.е. для создания или поддержки тестовой или изолированной среды потребуется много рассуждений, чтобы убедиться, что *ни один* компонент в графе не имеет внешней зависимости.
Несколько друзей добровольно поделились собственными проблемами с масштабированием сервис-ориентированной архитектуры:
> *Еще одна проблема с ростом SOA, которую я замечал, — это циклы зависимостей между сервисами. Так как вы развертываете их независимо и редко запускаете всю систему с нуля, то легко ввести циклы и сломать DAG.*
>
>
> *Еще одна проблема с масштабированием SOAs, о которой, возможно, стоит упомянуть, заключается в том, что требуется, чтобы вы заранее знали все будущие рабочие процессы ваших клиентов. Если не знаете — и разделяете данные для одного рабочего процесса по нескольким вертикалям — то вы столкнетесь либо с проблемами производительности, пытаясь гарантировать транзакционность между несколькими постоянными хранилищами, либо с переопределением того, где дублируются (кэшируемые, но действительно присутствующие в бд) данные.*
>
>
### Data-Oriented архитектура
В **архитектуре, ориентированной на данные** (DOA), системы по-прежнему организованы вокруг небольших, слабосвязанных компонентов, как в микросервисах SOA. Но DOA отходит от микросервисов двумя ключевыми способами:
1. *Компоненты всегда не имеют состояния*
Вместо того, чтобы разбивать хранилища данных для каждого соответствующего компонента, DOA предписывает описывать *данные* или уровень *состояния* в терминах централизованно управляемой глобальной схемы.
2. *Межкомпонентное взаимодействие сведено к минимуму*, вместо этого предпочтение отдается взаимодействию *через уровень данных*.
В нашей торговой системе компонент, получающий цены на различные ценные бумаги, просто публикует цены в канонической форме в нашем хранилище данных. Система может использовать эти цены, запрашивая цены на уровне данных, а не у определенного сервиса (или набора сервисов) через конкретный API.
Здесь стоимость интеграции линейна. Изменение схемы DAO означает, что в обновлении нуждаются до *N* компонентов, а не до *N2* связей между ними.
Такой поход *действительно* проявляет себя, когда отдельные высокоуровневые типы данных заполняются разными провайдерами. Если мы заменим *один* сервис *одной* таблицей, то мы не сильно упростим ситуацию. Преимущество есть, когда существует несколько источников одного и того же общего типа данных. Если торговая система подключается к нескольким торговым площадкам, каждая из которых публикует запросы клиентов в `RFQ` таблицу, то последующие системы могут запрашивать эту таблицу и не беспокоиться о том, откуда поступает запрос клиента.
### Типы взаимодействия компонентов
Поскольку в DOA *межкомпонентное взаимодействие минимизировано*, возникает вопрос — как можно было бы сегодня заменить межкомпонентное взаимодействие в SOA взаимодействием через уровень данных?
**1. Производители и потребители данных**
Распределение компонентов по *производителям* и *потребителям* данных — основной способ разработать систему DOA.
Если вы можете на высоком уровне описать свою бизнес-логику в виде серии операций `map`, `filter`, `reduce`, `flatMap` и других операций, то вы также можете написать систему DOA в виде серии компонентов, каждый из которых запрашивает или подписывается на входные данные и производит выходные данные. Проблема в DOA заключается в том, что на этих промежуточных этапах данные являются видимыми и запрашиваемыми, это означает, что они должны быть хорошо инкапсулированными, хорошо представленными и соответствовать определенной концепции бизнес-логики. Преимущество, однако, состоит в том, что поведение системы является внешне наблюдаемым, отслеживаемым и проверяемым.
В торговой системе SOA компонент, принимающий заказы с торговой площадки, может делать RPC, чтобы выяснить, как устанавливать цены, котировки или торговать по заказу. В DOA микросервис принимает запросы от торговых площадок (обычно в стиле SOA) и *выдает* RFQ, в то время как другие производители предоставляют данные о ценах и т. д. Еще один микросервис запрашивает RFQ, объединенные со всеми ценами, и выдает котировки, заказы или любые другие данные, необходимые пользователю.
**2. Запускающие действия и поведения**
Иногда самый простой способ думать о связи между компонентами *— это* RPC. В то время как хорошо спроектированная система DOA3 должна следить за большей частью межкомпонентной коммуникации, замененной парадигмами производитель/потребитель, вам все равно могут потребоваться прямые способы, чтобы компонент X сказал Y сделать Z.
Во-первых, важно подумать, могут ли RPC быть реорганизованы как *события* и их *результаты*. Т.е. спросите себя, может ли компонент X вместо отправки RPC в компонент Y, где происходит событие E, производить события E и заставлять компонент Y управлять ответами, потребляя эти события?
Такой подход, который я буду называть **событиями на основе данных**, может быть мощной инверсией обычного взаимодействия компонентов. Причина, по которой он настолько мощный, заключается в том, что он позволяет нам перевести термин «*слабосвязанный*« на следующий уровень. Системам не нужно знать, кто потребляет их события (в отличие от вызывающей стороны RPC, которой абсолютно необходимо знать, кого она вызывает), и производителям не нужно беспокоиться о том, откуда берутся эти события, им просто нужно понимать семантическое значение бизнес-логики этих событий.
Конечно, существует наивный способ реализации *событий* на основе данных, когда каждое событие сохраняется в базе данных в своей собственной таблице, соответствующей 1:1 с сериализованной версией запроса RPC. В этом случае события, основанные на данных, вообще не разъединяют систему. Для того чтобы события, основанные на данных, работали, преобразование запроса/ответа в сохраняемые *события* требует, чтобы они были значимыми конструкциями бизнес-логики.
События, основанные на данных, могут не подходить друг другу. Например, если вы хотите вызвать поведение в *определенном* компоненте. В этих случаях, вероятно, все еще желательно оставить *ограниченное* количество реальных RPC **от компонента к компоненту**.
### Примеры использования архитектуры, ориентированной на данные
#### High Integration Problem Spaces
Одна из причин, по которой я продолжаю упоминать торговое/финансовое ПО в качестве примера, заключается в том, что финансы часто требуют большой площади интеграции. Типичная *торговая* фирма, позволяющая мелким клиентам торговать, часто интегрируется со многими торговыми площадками для взаимодействия с клиентами, а также со многими поставщиками ликвидности для получения цен и размещения заказов. Бизнес-логика, которая должна происходить между поступлением запроса на рынок и получением ответа от клиента, представляет собой сложный, многоступенчатый процесс.
В проблемном пространстве с высокой степенью интеграции отдельным сервисам может потребоваться знать о *множестве* других сервисов. Чтобы избежать сложности *O(N2)* в интеграции и сложных отдельных сервисов с высоким коэффициентом разветвления, перестройка системы вокруг производителей и потребителей данных позволяет упростить интеграцию. Если появится новая интеграция, вместо того, чтобы редактировать *N* новых систем или одну систему, которая имеет сложное разветвление для *N* других систем, процесс интеграции может включать написание одного *адаптера*, который создает данные в общей схеме DOA, принимает окончательный результат и отображает его в правильном проводном формате.
Неявно в интеграции возникает новый вид сложности: размышление о схеме. Любая новая интеграция должна быть *естественной* для вашей системы, а вашу схему нужно расширять без добавления прокладок, хаков и особых случаев. Это само по себе трудное задание. Однако когда количество интеграций достаточно велико, сложность амортизируется и часто окупается.
#### Данные в песочнице и рассуждения об изоляции данных
Если вы создаете прототип или тестируете что-то вручную, надеюсь, вы это делаете вне продакшена. Тем не менее то, как устроены некоторые SOA-экосистемы, часто говорит, что нелегко понять, в какой среде находится сервис, или является ли конкретная среда вообще автономной.
**Среда** — это внутренне согласованный, последовательно связанный набор сервисов, обычно/идеально структурированный в той же топологии, что и продакшн. Поскольку сервисы SOA обычно адресуются независимо друг от друга, согласованность среды предполагает, что каждый сервис должен согласовываться со всеми другими сервисами в среде, по какому адресу для чего обращаться. RPC, pubsub и поток данных не должны *просачиваться* из одной среды в другую.
Очевидно, что в SOA есть способы обойти это, например, перейти на сервисные реестры, которые генерируют правильную конфигурацию для сервисов4 , или, когда доступ к сервисам осуществляется через URI, скрывающий прямые служебные адреса в пользу различных путей под префиксом среды5.
Однако в DOA концепция *среды* намного проще. Зная, к какому уровню хранилища данных подключается компонент, достаточно описать, в какой среде он находится. Поскольку все компоненты не хранят внутреннее состояние, данные изолированы по определению. Нет никакой опасности утечки данных из одной среды в другую, поскольку компоненты взаимодействуют только через хранилище данных.
### Data-Oriented архитектура ближе, чем вы думаете
На данный момент существует множество распространенных примеров, приближенных к архитектуре, ориентированной на данные. Монолит данных, в котором все (или большинство) данных хранятся в одном большом хранилище, часто говорит, что архитектура системы приближена к DOA.
[Knowledge Graphs](https://en.wikipedia.org/wiki/Ontology_(information_science)), например, представляют собой обобщенный монолит данных. Тем не менее они часто недостаточно универсальны; при этом многие состояния, связанные с бизнес-логикой, потенциально отсутствуют.
[GraphQL](https://graphql.org/) часто используется в качестве нормализованного слоя хранилища данных, такого как монолит данных. Степень, в которой GraphQL можно успешно сделать серверной частью системы DOA, в большей степени зависит от дизайна схемы: например, можно выбрать обобщенную схему и таблицы, связанные с концепциями бизнес-логики, а не схемы и таблицы, специфичные для конкретного источника этих данных.
### Все дело в компромиссе
Такая архитектура не является панацеей. Там, где архитектура, ориентированная на данные, стирает ряд проблем, возникают новые: от дизайнера требуется тщательного обдумывания владения данными. Ситуации, когда несколько авторов изменяют одну и ту же запись, могут быть незначительными, что часто побуждает системы тщательно разделять права собственности на *запись*. И поскольку межкомпонентные API-интерфейсы закодированы в данных, существует одна общая глобальная схема, которую нужно хорошо продумать.
Мне вспоминается документация по Google’s Protocol Buffers, которая при обсуждении маркировки полей в схеме как **required** предупреждает: [Required Is Forever](https://developers.google.com/protocol-buffers/docs/proto#required_warning). В Broadway Technology технический директор Джошуа Вальски говорил нечто подобное о схеме DOA: *Data Is Forever*. По причинам, аналогичным предупреждению Protobuf, оказывается, что удалить столбец из таблицы в слабосвязанной распределенной системе *очень, очень* сложно.
Мои пять копеек: Если вы беспокоитесь о *горизонтальном* масштабировании своей архитектуре, то подумайте о проектировании с монолитом данных в центре.
1. API-интерфейсы между сервисами необязательно *ad hoc*, но прямая связь между компонентами часто означает, что между ними легко передавать параметры для определенной цели.
2. Действительно ли архитектура достигает роста сложности интеграции *N2*зависит от топологии ее архитектуры. Если вы находитесь в системе, в которой *интеграция* является одним из узких мест, то вы, скорее всего, с этой проблемой. Например, торговая система, интегрирующаяся с различными поставщиками ликвидности и внебиржевыми торговыми площадками, в идеале не должна находиться в ситуации, когда каждый компонент, управляющий заказами с рынка, должен знать о каждом компоненте, обеспечивающем ликвидность.
3. Система, которая хорошо подходит для DOA *и* хорошо спроектирована.
4. Предполагая, что сервисы вызывают друг друга на основе прямого адреса (например, IP-адреса или некоторой внутренней схемы адресов для запущенного процесса), и знают, где можно связаться с определенной сервисом на основе параметров командной строки, может потребоваться обернуть их с помощью более подходящей логики, которая создает правильные флаги в зависимости от среды.
5. например, вместо того, чтобы обращаться к определенной службе по IP-адресу или какому-либо внутреннему URI, специфичному для этой службы, структурируя каждую услугу, которая будет обслуживаться по «пути», маршрутизируемому одним сервером. Например, вместо`://process1.namespace.company.com /*`, вы общаетесь с `://env.namespace.company.com/Employees/*`.
 | https://habr.com/ru/post/590675/ | null | ru | null |
# Python и статистический вывод: часть 2
Предыдущий пост см. [здесь](https://habr.com/ru/post/556798/).
Выборки и популяции
-------------------
В статистической науке термины «выборка» и «популяция» имеют особое значение. Популяция, или генеральная совокупность, — это все множество объектов, которые исследователь хочет понять или в отношении которых сделать выводы. Например, во второй половине 19-го века основоположник генетики Грегор Йохан Мендель) записывал наблюдения о растениях гороха. Несмотря на то, что он изучал в лабораторных условиях вполне конкретные сорта растения, его задача состояла в том, чтобы понять базовые механизмы, лежащие в основе наследственности абсолютно всех возможных сортов гороха.
В статистической науке о группе объектов, из которых извлекается выборка, говорят, как о популяции, независимо от того, являются изучаемые объекты живыми существами или нет.
Поскольку популяция может быть крупной — или бесконечной, как в случае растений гороха Менделя — мы должны изучать репрезентативные выборки, и на их основе делать выводы о всей популяции в целом. В целях проведения четкого различия между поддающимися измерению атрибутами выборок и недоступными атрибутами популяции, мы используем термин *статистики*, имея при этом в виду атрибуты *выборки*, и говорим о *параметрах*, имея в виду атрибуты *популяции*.
**Статистики** — это атрибуты, которые мы можем измерить на основе выборок. **Параметры** — это атрибуты популяции, которые мы пытаемся вывести статистически.
В действительности, статистики и параметры различаются в силу применения разных символов в математических формулах:
| | | |
| --- | --- | --- |
| **Мера** | **Выборочная статистика** | **Популяционный параметр** |
| Объем | *n* | *N* |
| Среднее значение | *x̅* | *μx* |
| Стандартное отклонение | *Sx* | *σx* |
| Стандартная ошибка | *Sx̅* | |
Если вы вернетесь к уравнению стандартной ошибки, то заметите, что она вычисляется не из выборочного стандартного отклонения *Sx*, а из популяционного стандартного отклонения *σx*. Это создает парадоксальную ситуацию — мы не можем вычислить выборочную статистику, используя для этого популяционные параметры, которые мы пытаемся вывести. На практике, однако, предполагается, что выборочное и популяционное стандартные отклонения одинаковы при размере выборки порядка *n* ≥ 30.
Теперь вычислим стандартную ошибку средних значений за определенный день. Например, возьмем конкретный день, скажем, 1 мая:
```
def ex_2_8():
'''Вычислить стандартную ошибку
средних значений за определенный день'''
may_1 = '2015-05-01'
df = with_parsed_date( load_data('dwell-times.tsv') )
filtered = df.set_index( ['date'] )[may_1]
se = standard_error( filtered['dwell-time'] )
print('Стандартная ошибка:', se)
```
```
Стандартная ошибка: 3.627340273094217
```
Хотя мы взяли выборку всего из одного дня, вычисляемая нами стандартная ошибка очень близка к стандартному отклонению всех выборочных средних — 3.6 сек. против 3.7 сек. Это, как если бы, подобно клетке, содержащей ДНК, в каждой выборке была закодирована информация обо всей находящейся внутри нее популяции.
Интервалы уверенности
---------------------
Поскольку стандартная ошибка выборки измеряет степень близости, с которой, по нашим ожиданиям, выборочное среднее соответствует среднему популяционному, то мы можем также рассмотреть обратное — стандартная ошибка измеряет степень близосто, с которой, по нашим ожиданиям, популяционное среднее соответствует измеренному среднему выборочному. Другими словами, на основе стандартной ошибки мы можем вывести, что популяционное среднее находится в пределах некого ожидаемого диапазона выборочного среднего с некоторой степенью уверенности.
Понятия «степень уверенности» и «ожидаемый диапазон», взятые вместе, дают определение термину *интервал уверенности*.
> *Примечание*. В большинстве языков под термином «confidence» в контексте инференциальной статистики понимается именно уверенность в отличие от отечественной статистики, где принято говорить о доверительном интервале. На самом деле речь идет не о доверии (trust), а об уверенности исследователя в полученных результатах. Это яркий пример мягкой подмены понятия. Подобного рода ошибки вполне объяснимы - первые переводы появились еще в ~~доколумбову~~ доинтернетовскую эпоху, когда источников было мало, и приходилось домысливать в силу своего понимания. Сегодня же, когда существует масса профильных глоссариев, словарей и источников, такого рода искажения не оправданы. ИМХО.
>
>
При установлении интервалов уверенности обычной практикой является задание интервала размером 95% — мы на 95% уверены, что популяционный параметр находится внутри интервала. Разумеется, еще остается 5%-я возможность, что он там не находится.
Какой бы ни была стандартная ошибка, 95% популяционного среднего значения будет находиться между -1.96 и 1.96 стандартных отклонений от выборочного среднего. И, следовательно, число 1.96 является *критическим* з*начением* для 95%-ого интервала уверенности. Это критическое значение носит название *z-значения*.
Название *z-значение* вызвано тем, что нормальное распределение называется *z*-распределением. Впрочем, иногда z-значение так и называют — гауссовым значением.
Число 1.96 используется так широко, что его стоит запомнить. Впрочем, критическое значение мы можем вычислить сами, воспользовавшись функцией `scipy stats.norm.ppf`. Приведенная ниже функция `confidence_interval` ожидает значение для p между 0 и 1. Для нашего 95%-ого интервала уверенности оно будет равно 0.95. В целях вычисления положения каждого из двух хвостов нам нужно вычесть это число из единицы и разделить на 2 (2.5% для интервала уверенности шириной 95%):
```
def confidence_interval(p, xs):
'''Интервал уверенности'''
mu = xs.mean()
se = standard_error(xs)
z_crit = stats.norm.ppf(1 - (1-p) / 2)
return [mu - z_crit * se, mu + z_crit * se]
def ex_2_9():
'''Вычислить интервал уверенности
для данных за определенный день'''
may_1 = '2015-05-01'
df = with_parsed_date( load_data('dwell-times.tsv') )
filtered = df.set_index( ['date'] )[may_1]
ci = confidence_interval(0.95, filtered['dwell-time'])
print('Интервал уверенности: ', ci)
```
```
Интервал уверенности: [83.53415272762004, 97.753065317492741]
```
Полученный результат говорит о том, что можно на 95% быть уверенным в том, что популяционное среднее находится между 83.53 и 97.75 сек. И действительно, популяционное среднее, которое мы вычислили ранее, вполне укладывается в этот диапазон.
Сравнение выборок
-----------------
После вирусной маркетинговой кампании веб-команда в AcmeContent извлекает для нас однодневную выборку времени пребывания посетителей на веб-сайте для проведения анализа. Они хотели бы узнать, не привлекла ли их недавняя кампания более активных посетителей веб-сайта. Интервалы уверенности предоставляют нам интуитивно понятный подход к сравнению двух выборок.
Точно так же, как мы делали ранее, мы загружаем значения времени пребывания, полученные в результате маркетинговой кампании, и их резюмируем:
```
def ex_2_10():
'''Сводные статистики данных, полученных
в результате вирусной кампании'''
ts = load_data('campaign-sample.tsv')['dwell-time']
print('n: ', ts.count())
print('Среднее: ', ts.mean())
print('Медиана: ', ts.median())
print('Стандартное отклонение: ', ts.std())
print('Стандартная ошибка: ', standard_error(ts))
ex_2_10()
```
```
n: 300
Среднее: 130.22
Медиана: 84.0
Стандартное отклонение: 136.13370714388034
Стандартная ошибка: 7.846572839994115
```
Среднее значение выглядит намного больше, чем то, которое мы видели ранее — 130 сек. по сравнению с 90 сек. Вполне возможно, здесь имеется некое значимое расхождение, хотя стандартная ошибка более чем в 2 раза больше той, которая была в предыдущей однодневной выборке, в силу меньшего размера выборки и большего стандартного отклонения. Основываясь на этих данных, можно вычислить 95%-й интервал уверенности для популяционного среднего, воспользовавшись для этого той же самой функцией confidence\_interval, что и прежде:
```
def ex_2_11():
'''Интервал уверенности для данных,
полученных в результате вирусной кампании'''
ts = load_data('campaign-sample.tsv')['dwell-time']
print('Интервал уверенности:', confidence_interval(0.95, ts))
```
```
Интервал уверенности: [114.84099983154137, 145.59900016845864]
```
95%-ый интервал уверенности для популяционного среднего лежит между 114.8 и 145.6 сек. Он вообще не пересекается с вычисленным нами ранее популяционным средним в размере 90 сек. Похоже, имеется какое-то крупное расхождение с опорной популяцией, которое едва бы произошло по причине одной лишь ошибки выборочного обследования. Наша задача теперь состоит в том, чтобы выяснить почему это происходит.
Ошибка выборочного обследования, также систематическая ошибка при взятии выборки, возникает, когда статистические характеристики популяции оцениваются исходя из подмножества этой популяции.
#### Искаженность
Выборка должна быть репрезентативной, то есть представлять популяцию, из которой она взята. Другими словами, при взятии выборки необходимо избегать искажения, которое происходит в результате того, что отдельно взятые члены популяции систематически из нее исключаются (либо в нее включаются) по сравнению с другими.
Широко известным примером искажения при взятии выборки является опрос населения, проведенный в США еженедельным журналом «Литературный Дайджест» (Literary Digest) по поводу президентских выборов 1936 г. Это был один из самых больших и самых дорогостоящих когда-либо проводившихся опросов: тогда по почте было опрошено 2.4 млн. человек. Результаты были однозначными — губернатор-республиканец от шт. Канзас Альфред Лэндон должен был победить Франклина Д. Рузвельта с 57% голосов. Как известно, в конечном счете на выборах победил Рузвельт с 62% голосов.
Первопричина допущенной журналом огромной ошибки выборочного обследования состояла в искажении при отборе. В своем стремлении собрать как можно больше адресов избирателей журнал «Литературный Дайджест» буквально выскреб все телефонные справочники, подписные перечни журнала и списки членов клубов. В эру, когда телефоны все еще во многом оставались предметом роскоши, такая процедура гарантировано имела избыточный вес в пользу избирателей, принадлежавших к верхнему и среднему классам, и не был представительным для электората в целом. Вторичной причиной искажения стала *искаженность в результате неответов* — в опросе фактически согласились участвовать всего менее четверти тех, к кому обратились. В этом виде искаженности при отборе предпочтение отдается только тем респондентам, которые действительно желают принять участие в голосовании.
Распространенный способ избежать искаженности при отборе состоит в том, чтобы каким-либо образом рандомизировать выборку. Введение в процедуру случайности делает вряд ли возможным, что экспериментальные факторы окажут неправомерное влияние на качество выборки. Опрос населения еженедельником «Литературный Дайджест» был сосредоточен на получении максимально возможной выборки, однако неискаженная малая выборка была бы намного полезнее, чем плохо отобранная большая выборка.
Если мы откроем файл campaign\_sample.tsv, то обнаружим, что наша выборка приходится исключительно на 6 июня 2015 года. Это был выходной день, и этот факт мы можем легко подтвердить при помощи функции pandas:
```
'''Проверка даты'''
d = pd.to_datetime('2015 6 6')
d.weekday() in [5,6]
```
```
True
```
Все наши сводные статистики до сих пор основывались на данных, которые мы отфильтровывали для получения только рабочих дней. Искаженность в нашей выборке вызвана именно этим фактом, и, если окажется, что поведение посетителей в выходные отличается от поведения в будние дни — вполне возможный сценарий — тогда мы скажем, что выборки представляют две разные популяции.
Визуализация разных популяций
-----------------------------
Теперь снимем фильтр для рабочих дней и построим график среднесуточного времени пребывания для всех дней недели — рабочих и выходных:
```
def ex_2_12():
'''Построить график времени ожидания
по всем дням, без фильтра'''
df = load_data('dwell-times.tsv')
means = mean_dwell_times_by_date(df)['dwell-time']
means.hist(bins=20)
plt.xlabel('Ежедневное время ожидания неотфильтрованное, сек.')
plt.ylabel('Частота')
plt.show()
```
Этот пример сгенерирует следующую ниже гистограмму:
Распределение уже не является нормальным. Оно фактически является *бимодальным*, поскольку у него два пика. Второй меньший пик соответствует вновь добавленным выходным дням, и он ниже потому что количество выходных дней гораздо меньше количества рабочих дней, а также потому что стандартная ошибка распределения больше.
Распределения более чем с одним пиком обычно называются *мультимодальными*. Они могут указывать на совмещение двух или более нормальных распределений, и, следовательно, возможно, на совмещение двух или более популяций. Классическим примером бимодальности является распределение показателей роста людей, поскольку модальный рост мужчин выше, чем у женщин.
Данные выходных дней имеют другие характеристики в отличие от данных будних дней. Мы должны удостовериться, что мы сравниваем подобное с подобным. Отфильтруем наш первоначальный набор данных только по выходным дням:
```
def ex_2_13():
'''Сводные статистики данных,
отфильтрованных только по выходным дням'''
df = with_parsed_date( load_data('dwell-times.tsv') )
df.index = df['date']
df = df[df['date'].index.dayofweek > 4] # суббота-воскресенье
weekend_times = df['dwell-time']
print('n: ', weekend_times.count())
print('Среднее: ', weekend_times.mean())
print('Медиана: ', weekend_times.median())
print('Стандартное отклонение: ', weekend_times.std())
print('Стандартная ошибка: ', standard_error(weekend_times))
```
```
n: 5860
Среднее: 117.78686006825939
Медиана: 81.0
Стандартное отклонение: 120.65234077179436
Стандартная ошибка: 1.5759770362547678
```
Итоговое среднее значение в выходные дни (на основе 6-ти месячных данных) составляет 117.8 сек. и попадает в пределы 95%-ого интервала уверенности для маркетинговой выборки. Другими словами, хотя среднее значение времени пребывания в размере 130 сек. является высоким даже для выходных, расхождение не настолько большое, что его нельзя было бы приписать простой случайной изменчивости в выборке.
Мы только что применили подход к установлению подлинного расхождения в популяциях (между посетителями веб-сайта в выходные по сравнению с посетителями в будние дни), который при проведении проверки обычно не используется. Более традиционный подход начинается с выдвижения гипотетического предположения, после чего это предположение сверяется с данными. Для этих целей статистический метод анализа определяет строгий подход, который называется *проверкой статистических гипотез*.
Это и будет темой следующего поста, [поста №3](https://habr.com/ru/post/556852/).
Примеры исходного кода для этого поста находятся в моем [репо](https://github.com/capissimo/python-for-data-science) на Github. Все исходные данные взяты в [репозитории](https://github.com/clojuredatascience/ch2-inference)автора книги. | https://habr.com/ru/post/556806/ | null | ru | null |
# Первые эксперименты со смешанным Litex+Verilog проектом для ПЛИС
В [предыдущей статье](https://habr.com/ru/post/594817/) мы начали осваивать построение шинно-ориентированных систем на базе среды Litex (которая всё делает на Питоне) с внедрением собственных модулей на Верилоге. Статья так разрослась, что практические опыты мы оставили на потом. Пришла пора провести их. Сегодня мы подключимся к VGA-монитору и поуправляем изображением, которое выдаёт модуль **gpu**, описанный в файле **gpu.v**, то есть, реализованный на языке Verilog. Управлять мы им будем через регистр команд, расположенный в блоке CSR, спроецированном на шину Wishbone. Все эти сущности, в свою очередь относятся к среде Litex. Инструменты для опытов мы тоже будем использовать штатные, Litex-овские. Приступаем!
Луч спит – развёртка идёт
-------------------------
Итак, мы проверяем пример, который формирует изображение через шнур VGA. Но что за константы в найденном на просторах сети коде? Они какие-то непонятные. Многие статьи просто ссылаются на готовые таблицы... Давайте я расскажу подробнее, откуда они взялись. Если я спрошу, сколько строк на экране в развёртке VGA, многие ответят, что 480. А если я спрошу, сколько строк было на экране отечественного телевизора, многие также ответят, что 625. Сейчас мы узнаем страшную тайну. Хоть эти цифры и не должны совпадать (первый ответ родом из шестидесятигерцовой NTSC, а второй – из нашей пятидесятигерцовой системы), но относятся к совершенно разным измерениям.
Дело в том, что 480 строк в VGA – это всего лишь видимые строки. А 625 строк в отечественной развёртке – это именно строки, передаваемые в сигнале. В чём разница?
Во-первых, в кинескопе лучу нужно время для обратного хода. Дойдя до нижней точки экрана, он должен пролететь назад. И ему нужно время, гораздо большее, чем время хода одной строки. У очень старых чёрно-белых телевизоров при максимальной яркости эти линии даже можно было разглядеть. Я в детстве так любил баловаться. Вот я нашёл на Гугле типичный рисунок:
Получается, что в сигнале должно быть предусмотрено время на этот процесс. Что в это время передаётся – не важно, так как луч здорового телевизора при этом погашен. Но время на сам процесс выделено быть должно.
То же касается и строчного обратного хода, хоть там время и намного меньше.
Дальше, аналоговые системы, да ещё и докварцевых времён, требовали некоторой подстройки. Вот таблица УЭИТ:
Белые тонкие линии на реперной области по краям экрана, должны были совмещаться с его границами. Что за линией – не должно быть видно. Ну, это на случай, если изображение будет немного плавать. А в сигнале эти точки присутствовать должны!
Вот и получается, что не все сигнальные строки (да и точки строк) являются видимыми. Из отечественных 625 строк, видимыми являлись только 576. А в американском стандарте, 480 строк – это видимая часть экрана при 525 строках в сигнале.
Шло время. Ушли в прошлое кинескопы. Их заменили матрицы, в которых нет ни электронного луча, ни его обратного хода, а картинка для них хранится в ОЗУ, поэтому непрерывность развёртки уже не требуется. Но для совместимости сигнал остался прежним. Мало того, если цикл статей не прервётся из-за отсутствия спроса, и мы дойдём до полностью цифрового HDMI, то увидим, что даже там есть невидимые участки растра! Поэтому, формируя картинку 640х480 точек, мы реально должны передавать по проводам область несколько большего размера.
Здесь я опустил массу эфирных штучек: замешивание синхроимпульсов в сам сигнал, чересстрочную развёртку и прочее, прочее, прочее. Мы сейчас просто посмотрели саму идею, откуда взялись эти лишние строки и точки внутри строк, привязав их к мониторным сущностям. Что же до точных цифр, то мы их вычислять не должны, так что все нюансы нам не потребуются. Есть масса статей, где приведены таблицы, сколько точек надо добавить к картинке. Причём на самом деле, добавленные значения измеряются в микросекундах, но внутри ПЛИС мы оперируем понятиями «точка» и «строка». Поэтому существуют таблицы либо калькуляторы, которые позволят нам узнать или вычислить эти дополнительные параметры именно в таких единицах измерения для каждого конкретного разрешения при конкретной частоте кадров.
Вот хорошая статья с картинкой, которая поясняет суть добавок к сигналу с привязкой к ПЛИС (но без того, что я описал выше): [Учим iCEstick передавать видео-сигнал по VGA | Записки программиста (eax.me)](https://eax.me/fpga-vga/)
Оттуда есть ссылка на полезные таблицы [martin.hinner.info/vga/timing.html](http://martin.hinner.info/vga/timing.html)
А вот – забавный онлайн-калькулятор: [Video Timings Calculator (tomverbeure.github.io)](https://tomverbeure.github.io/video_timings_calculator)
Уффф! Теперь становится понятно, что значат константы в найденном нами на просторах Интернета файле **hvsync\_generator.v**. Сравните сами:
Кое-что не совпало, но находится в пределах погрешности.
Результаты работы онлайн-калькулятора, кстати, совпадают точнее:
Пара слов про файл hvsync\_generator.v
--------------------------------------
Собственно, если мы уж заговорили про файл **hvsync\_generator.v**, то с ним всё просто. Он формирует кадровый и строчный синхроимпульсы, согласно заданным параметрам. Чтобы изменить разрешение, надо эти параметры задать согласно требованиям, а также не забыть сменить частоту следования точек, о чём мы поговорим в следующем разделе. А вот так из базовых параметров рассчитываются рабочие:
```
// derived constants
parameter H_SYNC_START = H_DISPLAY + H_FRONT;
parameter H_SYNC_END = H_DISPLAY + H_FRONT + H_SYNC - 1;
parameter H_MAX = H_DISPLAY + H_BACK + H_FRONT + H_SYNC - 1;
parameter V_SYNC_START = V_DISPLAY + V_BOTTOM;
parameter V_SYNC_END = V_DISPLAY + V_BOTTOM + V_SYNC - 1;
parameter V_MAX = V_DISPLAY + V_TOP + V_BOTTOM + V_SYNC - 1;
```
Вот так формируются многократно используемые условия:
```
wire hmaxxed = (hpos == H_MAX) || reset; // set when hpos is maximum
wire vmaxxed = (vpos == V_MAX) || reset; // set when vpos is maximum
```
Ну, и просто работают счётчики строк и формирователи синхроимпульсов.
```
// horizontal position counter
always @(posedge clk)
begin
hsync <= (hpos>=H_SYNC_START && hpos<=H_SYNC_END);
if(hmaxxed)
hpos <= 0;
else
hpos <= hpos + 1;
end
// vertical position counter
always @(posedge clk)
begin
vsync <= (vpos>=V_SYNC_START && vpos<=V_SYNC_END);
if(hmaxxed)
if (vmaxxed)
vpos <= 0;
else
vpos <= vpos + 1;
end
// display_on is set when beam is in "safe" visible frame
assign display_on = (hpos
```
Обратите внимание, что отсюда импульсы выходят всегда в прямой полярности. Кажется, калькулятор допускает это дело:
Просто тот же режим 640х480 при других частотах требует другой полярности синхроимпульсов. Но здесь – нужна такая. Я проверил, работает. А где брать цифры для других видеорежимов - вы теперь знаете.
Что у нас с тактовой частотой
-----------------------------
В прошлый раз я уже упоминал, что нам предстоит разобраться с тактовой частотой. Только что из таблиц мы поняли, что нам необходима частота, близкая к 25 МГц. А в коде на Питоне я определял частоту вот так:
Вроде, я использую сущность **clk**. Но давайте не будем долго рассуждать, а посмотрим сгенерированный Верилоговский файл:
То же самое текстом.
```
gpu gpu(
.clk(sys_clk),
.x0(main_x0_storage),
.x1(main_x1_storage),
.y0(main_y0_storage),
.y1(main_y1_storage),
.color(gpio0),
.hsync(gpio2),
.vsync(gpio3)
);
```
Погодите, какой ещё **sys\_clk**? Мы же просили просто **clk**… Потому что нам повезло, у нас на плате припаян генератор на 25 МГц. Но ещё есть шанс, что это какое-то хитрое именование… Ну-ка… Ищем, где этот сигнал формируется…
`assign sys_clk = basesoc_crg_clkout0;`
где:
То же самое текстом.
```
(* FREQUENCY_PIN_CLKI = "25.0", FREQUENCY_PIN_CLKOP = "60.0", FREQUENCY_PIN_CLKOS = "60.0", ICP_CURRENT = "6", LPF_RESISTOR = "16", MFG_ENABLE_FILTEROPAMP = "1", MFG_GMCREF_SEL = "2" *) EHXPLLL #(
.CLKFB_DIV(5'd24),
.CLKI_DIV(1'd1),
.CLKOP_CPHASE(4'd9),
.CLKOP_DIV(4'd10),
.CLKOP_ENABLE("ENABLED"),
.CLKOP_FPHASE(1'd0),
.CLKOS2_CPHASE(1'd0),
.CLKOS2_DIV(1'd1),
.CLKOS2_ENABLE("ENABLED"),
.CLKOS2_FPHASE(1'd0),
.CLKOS_CPHASE(4'd14),
.CLKOS_DIV(4'd10),
.CLKOS_ENABLE("ENABLED"),
.CLKOS_FPHASE(1'd0),
.FEEDBK_PATH("INT_OS2")
) EHXPLLL (
.CLKI(basesoc_crg_clkin),
.RST(basesoc_crg_reset),
.STDBY(basesoc_crg_stdby),
.CLKOP(basesoc_crg_clkout0),
.CLKOS(basesoc_crg_clkout1),
.CLKOS2(builder_subfragments_crg_ecp5pll),
.LOCK(builder_subfragments_crg_locked)
);
```
Последние сомнения развеяны! Перед нами самые что ни на есть 60 мегагерц. А нам надо 25! И они в системе есть, надо только правильно поправить Питоновский скрипт. Давайте я суну нос в описание генератора тактовых сигналов в уже хорошо нам знакомом файле **Litex\litex-boards\litex\_boards\targets\colorlight\_5a\_75x.py.**
```
# Clk / Rst
if not use_internal_osc:
clk = platform.request("clk25")
clk_freq = 25e6
else:
clk = Signal()
div = 5
self.specials += Instance("OSCG",
p_DIV = div,
o_OSC = clk)
clk_freq = 310e6/div
rst_n = 1 if not with_rst else platform.request("user_btn_n", 0)
# PLL
self.submodules.pll = pll = ECP5PLL()
self.comb += pll.reset.eq(~rst_n | self.rst)
pll.register_clkin(clk, clk_freq)
pll.create_clkout(self.cd_sys, sys_clk_freq)
if sdram_rate == "1:2":
pll.create_clkout(self.cd_sys2x, 2*sys_clk_freq)
pll.create_clkout(self.cd_sys2x_ps, 2*sys_clk_freq, phase=180) # Idealy 90° but needs to be increased.
else:
pll.create_clkout(self.cd_sys_ps, sys_clk_freq, phase=180) # Idealy 90° but needs to be increased.
```
Дело ясное, что дело тёмное. Вот я вижу **clk**. Вроде как, это вход… Короче, кончаем пытаться разбираться по-сухому! Зря я что ли создавал проект в Visual Studio? Давайте попробуем трассернуть и посмотреть, где можно взять сигнал, не дожидаясь милости от природы! Идём в код, который написали в прошлый раз, и ставим точку останова здесь:
Запускаем проект на исполнение, и сначала, чтобы настроить глазомер, смотрим значение той переменной, которая заносится сейчас:
А теперь я нахально ставлю курсор на поле **cd\_sys** и начинаю ездить по всем полям этой переменной, пытаясь найти что-то, похожее на то, что я уже видел, но содержащее что-то, похожее на вход PLL. Не найдя ничего приличного, сдвинусь левее… И так, осматривая реальную систему, когда она уже запущена, постепенно нахожу параметр, очень похожий по значению. Давайте я даже сделаю анимированный gif.
В общем, в переменной **soc.crg.pll** есть замечательное поле **clkin\_freq**, равное 25000000 (это наши 25 мегагерц, заданные в герцах), а поле **clkin** похоже на описание ножки… Вот давайте и заменим строку:
`clk = soc.crg.cd_sys.clk`
на:
`clk = soc.crg.pll.clkin`
Собираем, запускаем, проверяем – нам повезло! Мы угадали с первой попытки. Трассировка – великая вещь! А кто тянется ставить минус за "низкий технический уровень", приговаривая, что такое надо находить в справочниках – попробуйте, найдите и дайте ссылочку, а также путь, как нашли. А потом поговорим. Я долго искал. Трассировка же всё выявила за 5 минут. Поэтому и пропагандирую её использование.
То же самое текстом.
```
gpu gpu(
.clk(basesoc_crg_clkin),
.x0(main_x0_storage),
.x1(main_x1_storage),
.y0(main_y0_storage),
.y1(main_y1_storage),
.color(gpio0),
.hsync(gpio2),
.vsync(gpio3)
);
```
где:
`assign basesoc_crg_clkin = clk25;`
Уффф. С этим разобрались! Да здравствует живая трассировка! Проверяем на мониторе? Давайте не будем торопиться. Подключимся сначала к логическому анализатору и проверим картинку там.
Выявляем проблему там, где не ждали
-----------------------------------
Итак. Собираем получившийся проект, загружаем его в плату, запускаем, смотрим на анализаторе. С виду — всё красиво. Видны кадровые синхроимпульсы, видны строчные синхроимпульсы, видны отображаемые точки:
Всё? Проверяем на мониторе? Не спешите! Измеряем частоту кадровых импульсов (на рисунке выше видна стрелочка между парой из них). Получаем примерно 120 Гц.
Строчная частота тоже удвоенная. Ох, и посидел я с экспериментами. Ну разумеется, во всём была обвинена неверно установленная частота! Но не тут-то было! Верная она! 25 МГц честные приходят. Ларчик просто открывался. Файл **gpu.v** я нашёл в Интернете и, так как он простенький, доверял ему всецело. А зря. Вот как он выглядит:
То же самое текстом.
```
// VGA 640x480 @60Hz needs a 25.175MHz pixel clock
// but the PLL is already in use
// I split the horizontal resolution in half and use the existing 12MHz clock instead
// front and back porch are manually adjusted until VSYNC reaches the expected 60Hz
hvsync_generator #(
.H_DISPLAY(320), // horizontal display width
.H_BACK(12), // horizontal left border (back porch)
.H_FRONT(8), // horizontal right border (front porch)
.H_SYNC(48), // horizontal sync width
.V_DISPLAY(480), // vertical display height
.V_TOP(33), // vertical top border
.V_BOTTOM(8), // vertical bottom border
.V_SYNC(2), // vertical s
) hvsync_gen (
.clk(clk),
.reset(0),
.hsync(hsync),
.vsync(vsync),
.display_on(display_on),
.hpos(hpos),
.vpos(vpos),
);
```
Классно, да? Обещаем 640 точек по горизонтали, а в модуль развёрток передаём всего 320. Вот он быстрее и работает! Потому что у автора кварц был на 12 МГц, вот он всё и пересчитал под такую частоту. Короче, удаляем все эти параметры, благо внутри модуля развёрток есть хорошо описанные! Остаётся:
```
hvsync_generator hvsync_gen (
.clk(clk),
.reset(0),
.hsync(hsync),
.vsync(vsync),
.display_on(display_on),
.hpos(hpos),
.vpos(vpos),
);
assign color = display_on && (hpos >= x0 && hpos < x1 && vpos >= y0 && vpos < y1);
```
Вот и верь после этого людям! Доверяй, но проверяй!
Уффф. Теперь можно экспериментировать с монитором. Как мы будем к нему подключаться?
Добавляем VGA разъём к плате
----------------------------
Вдохновение при изготовлении разъёма мы будем черпать тут: [fpga4fun.com - Pong Game](https://www.fpga4fun.com/PongGame.html)
Единственно, что у нашей платы выходы пятивольтовые, так что резисторы в их схеме надо заменить на 470 Ом. А так – я скопирую схему включения оттуда:
Но самое ценное там – конструктив. Вот как это сделано на той странице:
Это же гениально! А этот разъём нужно подключить Ардуиновскими проводочками к нашей макетке. Красный и синий провода – заземлить (благо земляных ножек у нас много), а зелёный и синхросигналы – подать на контакты, которые мы недавно назначили. Кстати, обратите внимание, как неудобно их искать! Вот наш список использованных **gpio** линий:
```
touch_pins = [
soc.platform.request("gpio", 0),
soc.platform.request("gpio", 1),
soc.platform.request("gpio", 2),
soc.platform.request("gpio", 3)
]
```
Сначала надо посмотреть, к каким контактам разъёма они подключены:
```
_gpios = [
# Attn. Jx/pin descriptions are 1-based, but zero based defs. used!
# J1
("gpio", 0, Pins("j1:0"), IOStandard("LVCMOS33")), # Input now
("gpio", 1, Pins("j1:1"), IOStandard("LVCMOS33")), # Input now
("gpio", 2, Pins("j1:2"), IOStandard("LVCMOS33")), # Input now
# GND
("gpio", 3, Pins("j1:4"), IOStandard("LVCMOS33")), # Input now
```
Затем – каким цепям соответствуют:
То же самое текстом.
```
self.comb += [
pins[1].eq(0),
]
self.specials += Instance(
'gpu',
i_clk=clk,
i_x0=self.x0.storage,
i_x1=self.x1.storage,
i_y0=self.y0.storage,
i_y1=self.y1.storage,
o_hsync=pins[2],
o_vsync=pins[3],
o_color=pins[0]
)
```
На самом деле, язык Питон позволяет всё это оформить более наглядно. Так что если будем развивать тему, то в следующей статье мы как раз наведём красоту. Пока же – пользуемся тем, что найдено в минималистичных примерах.
С моими кривыми руками получилась вот такая штука:
Подключаем плату к монитору, заливаем в неё «прошивку» и видим такую красоту:
Начинаем эксперименты
---------------------
Наконец-то мы подготовили всю инфраструктуру для основной части эксперимента. Мы же всего-навсего собирались записывать что-то в порты Verilog модуля, пользуясь механизмом CSR. Приступаем!
До сих пор мы работали с каталогом PyTest2\build\colorlight\_5a\_75b\gateware. Теперь перейдём в PyTest2\build\colorlight\_5a\_75b\software. Там нас интересует файл с говорящим именем
\PyTest2\build\colorlight\_5a\_75b\software\include\generated\csr.h
В текущей нашей реализации информации там самый минимум. Смотрим:
То же самое текстом
```
/* gpu */
#define CSR_GPU_BASE (CSR_BASE + 0x0L)
#define CSR_GPU_X0_ADDR (CSR_BASE + 0x0L)
#define CSR_GPU_X0_SIZE 1
static inline uint32_t gpu_x0_read(void) {
return csr_read_simple(CSR_BASE + 0x0L);
}
static inline void gpu_x0_write(uint32_t v) {
csr_write_simple(v, CSR_BASE + 0x0L);
}
#define CSR_GPU_X1_ADDR (CSR_BASE + 0x4L)
#define CSR_GPU_X1_SIZE 1
static inline uint32_t gpu_x1_read(void) {
return csr_read_simple(CSR_BASE + 0x4L);
}
static inline void gpu_x1_write(uint32_t v) {
csr_write_simple(v, CSR_BASE + 0x4L);
}
#define CSR_GPU_Y0_ADDR (CSR_BASE + 0x8L)
#define CSR_GPU_Y0_SIZE 1
static inline uint32_t gpu_y0_read(void) {
return csr_read_simple(CSR_BASE + 0x8L);
}
static inline void gpu_y0_write(uint32_t v) {
csr_write_simple(v, CSR_BASE + 0x8L);
}
#define CSR_GPU_Y1_ADDR (CSR_BASE + 0xcL)
#define CSR_GPU_Y1_SIZE 1
static inline uint32_t gpu_y1_read(void) {
return csr_read_simple(CSR_BASE + 0xcL);
}
static inline void gpu_y1_write(uint32_t v) {
csr_write_simple(v, CSR_BASE + 0xcL);
}
```
Итак, нами было создано четыре регистра, в каждом из которых используется по 16 бит, а 16 бит – зарезервированы. Можно ли объединять данные в одном регистре, а если да, то как – тема для отдельной статьи. Также в отдельной статье можно рассмотреть, как сделать код на Питоне самодокументирующимся. Чтобы из него автоматически вставлялись бы подробности в этот заголовочный файл. Пока – просто запомнили регистры. Да на самом деле одного регистра хватит, X1. У него смещение +4. А относительно чего смещение? Это нам подскажет содержимое файла **mem.h**:
```
#ifndef CSR_BASE
#define CSR_BASE 0x00000000L
#define CSR_SIZE 0x00010000
#endif
```
Как замечательно! Базовый адрес CSR равен нулю.
Напомню, в прошлой статье я указывал опции сборки системы:
`--with-etherbone --eth-ip=192.168.2.128`
Для доступа к шине через сеть, нам нужна утилита **wishbone-tool**. Готовую сборку под свою ОС можно скачать здесь:
[Releases · litex-hub/wishbone-utils (github.com)](https://github.com/litex-hub/wishbone-utils/releases?page=1)
Распаковываем и пишем по адресу шины 4 значение 600 при помощи команды:
`wishbone-tool.exe --ethernet-host 192.168.2.128 4 600`
Это я параметр X2 сделал равным шестистам (при разрешении экрана 640х480). Прямоугольник стал таким:
И, собственно, всё. Мы убедились, что всё проецируется на шину, а мы имеем возможность управлять значениями через регистр команд…
Упрощаем себе жизнь
-------------------
Как-то даже обидно, так много готовились и так мало экспериментировали. Давайте, что ли проведём один маленький эксперимент по упрощению себе жизни.
В файловой системе, на уровне скрипта, который мы делали в прошлой статье, добавляем каталог scripts
А в сам наш многострадальный Питоновский скрипт вставляем буквально одну строчку. Я покажу её вместе с теми, между которыми она помещена:
То же самое текстом.
```
soc.platform.add_source("hvsync_generator.v")
soc.platform.add_source("gpu.v")
args.csr_csv = "scripts/csr.csv"
builder = Builder(soc, **builder_argdict(args))
builder.build(**trellis_argdict(args), run=args.build)
```
Прогоняем скрипт, и в каталоге Scripts возникает новый файл **csr.csv**. Вот его начало:
Теперь нам не надо ни смотреть никакие заголовки, ни даже скачивать wishbone-tool. Поместим в каталог **scripts** файл **moverect.py** со следующим содержимым:
```
#!/usr/bin/env python3
import time
from litex import RemoteClient
wb = RemoteClient()
wb.open()
# # #
wb.regs.gpu_y0.write (200)
wb.regs.gpu_y1.write (240)
for i in range(100):
for j in range (600):
wb.regs.gpu_x1.write (j+39)
wb.regs.gpu_x0.write (j)
time.sleep(0.001)
wb.close()
```
Теперь в отдельном терминале идём в каталог **Litex\litex\litex\tools**… Вот его содержимое для справки:
И там запускаем отладочный сервер строкой:
`python litex_server.py --udp --udp-ip=192.168.2.128`
Оставляем этот терминал. Он будет обеспечивать нам сервер, дающий сетевой доступ к шине Wishbone из любых Питоновских скриптов. Не спрашивайте, зачем так сложно. Я не реализую эту систему, а учу, как пользоваться готовой.
Теперь в основном терминале можно запустить и только что написанный скрипт. Он будет работать через этот сервер. Итак, пишем:
`python moverect.py localhost`
И гипнотизируем экран, по которому слева направо ездит квадрат. В этом опыте мы не смотрели никаких констант. Мы просто пользовались символическими именами, взятыми из файла **csr.csv**. Плюс к тому, мы не использовали никаких инструментов, не входящих в поставку Litex. Правда, сервер в отдельном окне нам запустить пришлось. Но этот сервер организован на Питоновском скрипте, входящем в основной комплект Litex.
Немного философии
-----------------
Давным-давно, у меня БК-шка была подключена к ламповому чёрно-белому телевизору. Потом мне выдали ламповый цветной, с более устойчивым растром. И я сказал, что стало намного лучше. Потом я раздобыл монитор МС6105 с антибликовым кинескопом. И сказал, что стало намного лучше. Шло время. При смене ЭВМ МС6105 сменился на Samsung SyncMaster 3NE. И я сказал, что стало намного лучше, так как нет того пятидесятигерцового мерцания в глазах, даже когда я просто хочу заснуть. Потом была чреда других мониторов с кинескопами, каждый из которых создавал свои проблемы, которая завершилась покупкой первого ЖК монитора. И я сказал, что стало намного лучше. Никакого мерцания!
Дальше монитор сменился на новый, имеющий кабель DVI. И я бы даже не сказал, что стало намного лучше. Но когда через несколько месяцев пришлось поработать с VGA кабелем – я понял, что к хорошему быстро привыкаешь. В аналоговом кабеле немного гуляют вертикальные линии, в аналоговом кабеле «кипит» однотонное изображение. Это дико раздражает. Особенно когда привык к чёткой цифровой картинке.
Кто скажет, что виной всему тот монтаж, которым я собрал свою платочку, тот будет неправ. Я пробовал выводить изображение при помощи платы, содержащей на себе видео ЦАП и штатный разъём VGA. Было только хуже. Ну, потому что там я пользовался примером [fpga4fun.com - Pong Game](https://www.fpga4fun.com/PongGame.html) (устранив в нём ошибки в генераторе синхроимпульсов: там надо не 768, а 800 точек в строке сделать). Там используются более изящные цвета, они, имея больше уровней, кипят ещё сильнее, чем наш весьма цифровой «либо зелёный, либо чёрный». А ещё там используются тонкие линии. Они плавают ещё сильнее, чем наша граница прямоугольника.
Цифра – это цифра, аналог – это аналог. До цифровой революции ему не было замены. Сейчас – есть. Поэтому руку с VGA мы набили, а вот пользоваться этим – лично я не собираюсь. Мне нервное спокойствие дороже. Если цикл будет востребован – сделаем и HDMI выход, благо я упоминал макетку с ПЛИС Lattice, содержащую такой разъём. А VGA – это просто красивый пример, где можно быстро сделать аппаратуру и на простых, удобных сущностях освоить вывод в регистр команд.
Заключение
----------
Мы испытали работу с регистрами команд при помощи утилиты wishbone-tool (по абсолютным адресам) и при помощи штатных средств из поставки Litex (для чего нам пришлось сделать символический файл **csr.csv**).
Финальный пример, разобранный в статье, можно посмотреть [тут](https://github.com/MIR-LLC/LitexSamples/tree/main/PyTest2).
Дальше следует рассмотреть работу с регистрами состояния (то есть, чтение из Verilog модулей). Также полезным будет добавление возможности самодокументирования к разрабатываемому коду, чтобы не пришлось долго елозить, выявляя связи сигналов и портов CSR. Следующий этап - подключение модулей не через CSR, а через прямую проекцию на шину (Wishbone или AXI). Это самый минимум, которым полезно владеть. Но, глядя на рейтинг предыдущей статьи, я делаю вывод, что вообще-то это мало кому нужно. При сохранении тенденции, тема будет закрыта. Но те, кому это интересно, смогут изучить всё самостоятельно, используя эту пару статей как трамплин, потому что везде, где я читал, были только теоретические изыски, а тут я постарался изложить всё в ключе, чтобы можно было собрать первую рабочую систему от и до. | https://habr.com/ru/post/596321/ | null | ru | null |
# Теперь ONLYOFFICE может всё: добавляем плагины в редакторы документов
Что если бы вы могли добавить в редакторы документов любые функции, какие вам хочется? Теперь вы можете: в редакторах ONLYOFFICE появилась возможность подключения плагинов. Несколько примеров мы написали сами — все их можно посмотреть в нашем открытом репозитории на GitHub'e. Теперь ваш ход — напишите то, чего вам не хватало.
Подробности далее.
Зачем мы это сделали?
=====================
Итак, мы решили дать разработчикам возможность добавлять нужную (но не относящуюся напрямую к форматам OOXML) функциональность в редакторы ONLYOFFICE.
Всё началось с одной компании, в которой очень хотели написать собственную кнопку, чтобы генерить контент и вставлять получившиеся данные в редактор. Окей, подумали мы, в этом есть смысл. Есть функциональность, которая нужна только определенным людям и больше никому. Мы не можем сделать всё для всех, но мы можем дать возможность подрубить всё, что нужно. Поэтому вот вам API для работы с редактором, первая версия.
Так и появились плагины.
В них можно использовать код, который мы сами не сможем брать из-за лицензионных ограничений. Мы делаем коммерческий продукт и продаем его, нельзя просто взять и (\*в этом моменте автор текста прерывается, чтобы отмахнуться от всплывшего из глубин подсознания призрака Шона Бина) нельзя просто взять и использовать любой код из интернета. То есть, нам нельзя. А вам можно. Те вещи, которые мы по объективным причинам не можем, наши пользователи могут.
Типы плагинов
=============
Мы делим их на три типа:
**Визуальные**. Когда мы пользуемся таким расширением редактора, у нас открывается окно и рисуется определенный интерфейс. Например, Главред, который просили наши пиарщики.
Визуальный плагин может менять что-то в самом документе, а может и ничего не менять. Главред ничего не меняет — он лишь подсвечивает определенную часть текста (штампы, лишние слова и пр).
Можно написать плагин, который ищет по Google.Картинкам и вставляет понравившуюся в текст. Этот плагин меняет документ.
**Невизуальные**. Например, простая кнопка, при нажатии которой производятся манипуляции с документом. Простейший пример такого плагина: расширение, которое при нажатии кнопки добавляет в ваш документ слова Hello World!
```
(function (window, undefined) {
window.Asc.plugin.init = function () {
var sScript = 'var oDocument = Api.GetDocument();';
sScript += 'var oParagraph = Api.CreateParagraph();';
sScript += 'oParagraph.AddText(\'Hello world!\');';
sScript += 'oDocument.InsertContent([oParagraph]);';
window.Asc.plugin.info.recalculate = true;
this.executeCommand("close", sScript);
};
window.Asc.plugin.button = function (id) {
};
})(window, undefined);
```
Вы также можете добавить в свой документ, например, свою собственную кнопку Bold. Или кнопку, при нажатии которой генерится отчет.
**OLE-объекты**. Это наши любимые плагины. И единственный способ для стороннего разработчика «влезать» в форматную часть документа, т.е. записывать свою информацию не только во время работы редактора, но и непосредственно в файл. Это, например, наши шахматы.
К какому решению подключаются плагины и как это делается?
=========================================================
На самом деле, к любому.
**Для серверной версии**
Плагины нужно прописать в конфиги редакторов — они автоматически появятся у всех пользователей портала.
**Для десктопа**
Архивируем плагины, меняем расширение файла на .plugin и бросаем на главную страницу. Они сразу подхватятся, обещаем. Кроме того, если вы подключите приложение к порталу с включенными плагинами, они автоматически будут работать и в десктопе.
**Для веб-версии**
В ближайшее время мы запилим что-то вроде магазина или галереи, куда будут добавляться (после модерации) плагины от пользователей.
Пока «магазина» нет, плагины можно добавлять через расширение в браузере. Этот путь пока работает только для Chrome. У нас на GitHub'e есть папка c говорящим названием chrome\_extension\_example: это и есть образец, как сделать по нашим плагинам расширение в Chrome.
Здесь, кстати, недлинное видео, о том, что могут наши плагины и как их добавить в существующую инсталляцию (десктоп, сервер).
Как написать свой плагин?
=========================
Здесь мы хотели написать подробную инструкцию, как это сделать. Но вспомнили, что у нас уже есть хорошая и подробная документация, где структура плагина описана во всех необходимых деталях. Так что всё [здесь](https://api.onlyoffice.com/plugin/structure). Вы также можете изучить устройство дополнений, которые мы собственноручно выложили на [GitHub](https://github.com/ONLYOFFICE/sdkjs-plugins/tree/develop).
На этом, пожалуй, всё. И да — мы надеемся со временем увидеть буйство плагинов, созданное сообществом. Во всяком случае, очень любопытно, какие функции допишут наши пользователи. | https://habr.com/ru/post/314716/ | null | ru | null |
# MagOS в промышленном применении
*При выполнении этой работы ставилась задача минимизации времени на обслуживание сети из большого количества Linux машин.*
[1. Базовое описание основных принципов](#1)
[1.1. Применение MagOS.](#1-1)
[1.2. Технологии.](#1-2)
[1.3. Выбор базового дистрибутива.](#1-3)
[2. Структура сети.](#2)
[2.1. Magos-server.](#2-1)
[3. Настройка загрузчика.](#3)
[3.1. Строки загрузчика.](#3-1)
[3.2. Опции которые были использованы.](#3-2)
[3.3. Опции, которые могут быть использованы.](#3-3)
[3.4. Особенности сетевой загрузки.](#3-4)
[4. Порядок инициализации системы.](#4)
[4.1. Структура конфигурационного файла basecfg.ini по умолчанию.](#4-1)
[4.2. Структура системной директории.](#4-2)
[4.3. Реализация.](#4-3)
[5. Сервер MagOS.](#5)
[5.1. Общие сведения.](#5-1)
[5.2. Настройки сети.](#5-2)
[5.3. Настройка служб.](#5-3)
[5.4. Репозиторий программ.](#5-4)
[5.5. Дополнительные данные сервера](#5-5)
[5.6. Мониторинг.](#5-6)
[6. Пользовательские модули.](#6)
[6.1. Общие принципы создания пользовательских модулей.](#6-1)
[6.2. Сколько модулей делать.](#6-2)
[6.3. Модули специального назначения.](#6-3)
[6.4. Ограничения для модулей.](#6-4)
[6.5. Инструкция по созданию модулей.](#6-5)
[6.6. Модуль обновления системы.](#6-6)
[6.7. Модуль установки офисных программ.](#6-7)
[6.8. Модуль с утилитами и серверами.](#6-8)
[6.9. Модуль системных настроек.](#6-9)
[7. Скрипты.](#7)
[7.1. Дополнения к magos-patches.](#7-1)
[7.2. Скрипт установки ОС.](#7-2)
[7.3. Скрипты включения в AD.](#7-3)
[7.4. Управление системой (/root/bin).](#7-4)
[7.5. Дополнительные скрипты, исправляющие работу программ magos и операционной системы.](#7-5)
[8. Инструкция для техников.](#8)
**#### Базовое описание основных принципов**
**##### Применение MagOS**
MagOS — это специфичная сборка дистрибутива, выбираемого из обширного списка. В качестве основы для построения сборки могут выступать Live дистрибутивы Magea, Mandriva, Rosa, Ubuntu, Debian, Fedora, AltLinux и т.д. Специфичными элементами MagOS выступает модифицированное ядро (для поддержки AUFS), специальным образом созданный initrd (используется UIRD) и дополнительный набор скриптов, предназначенных для управления MagOS.
MagOS позволяет создать на основе Live сборок различных дистрибутивов (сборок, предназначенных для загрузки с CD, DVD диска) полноценную операционную систему. Специфика использования MagOS дает целый набор дополнительных преимуществ такого подхода:
Очень простое восстановление системы до первоначального состояния. Его можно сравнить с технологией работы с оборудованием, когда введение специальной команды позволяет сбросить все сделанные пользователем настройки и привести систему к первоначальному состоянию. Здесь этот же эффект достигается уничтожением данных в разделах, в которых хранятся данные пользователей. Таким образом такой вариант установки дистрибутива становится просто незаменимым при использовании в учебном процессе. К вышесказанному нужно добавить возможность установки дистрибутива на flash накопитель, что позволяет студенту или ученику использовать его не только в учебном классе, но и дома.
Вторым важнейшим преимуществом дистрибутива является возможность предварительной настройки системы. Она достигается включением всех необходимых конфигурационных файлов с параметрами в неизменяемую часть дистрибутива, так называемые модули. Используя такую технологию мы сводим к минимуму количество действий администратора после установки системы на компьютер пользователя. Эту возможность можно использовать уже не только для организации компьютерных классов, но и в среде промышленных предприятий, сводя к возможному минимуму трудозатраты по установке и настройке при работе с большим количеством компьютеров пользователей.
Третьим преимуществом является простота установки и обновления такой сборки операционной системы, которая сводится к разбивке диска, созданию файловых систем, копированию набора файлов на компьютер и установки загрузчика. При промышленном применении все указанные операции могут выполняться автоматически при запуске соответствующего скрипта. Обновление установленного дистрибутива точно также сводится к копированию файлов, что можно выполнять автоматически, например при выключении компьютера.
К отдельным преимуществам можно отнести возможность сетевой загрузки дистрибутива, в том числе и из Интернет.
К нереализованным возможностям MagOS следует отнести отсутствие возможности хранения пользовательских данных на защищенной распределенной файловой системе. Реализация такой распределенной файловой системы позволит обеспечить полную реентерабильность пользователей.
Некоторую вводную информацию о MagOS можно получить из статьи: [MagOS Linux (сентябрьский выпуск)](http://habrahabr.ru/post/195710/).
**##### Технологии**
Модификация ядра Linux, входящего в MagOS заключается во включении патча с файловой системой AUFS. AUFS позволяет подключать в файловую систему при помощи интерфейса loopback внешние файловые системы, собирая результирующую файловую систему, как слоеный пирог. Промежуточные слои такой результирующей файловой системы подключаются, чаще всего, в режиме RO (read only), а самый верхний слой, как правило, подключается в режиме RW (read-write) и проецируется на дисковую файловую систему, которая может размещаться как в оперативной памяти, на физическом диске, в образе диска, так и сохраняться при операции отключения в специальном модуле, подключаемом при помощи файловой системы SquashFS.
Файловая система SquashFS позволяет выполнять сжатие при помощи блочного алгоритма, сохраняя все атрибуты файловой системы. В MagOS она используется для создания подгружаемых модулей с образами слоев файловой системы AUFS. Блочный алгоритм сжатия позволяет не распаковывать файлы модулей целиком при необходимости извлечения из них данных.
В MagOS образ диска initrd, используемый для загрузки ОС Linux в большинстве дистрибутивов, использован для организации работы системы. Там располагаются скрипты, создающие «слоеную» файловую систему дистрибутива, обрабатывающие конфигурационные файлы и т.п.
Необходимые для настройки системы данные передаются через параметры ядра операционной системы, прописываемые в загрузчике grub4dos/grub2/syslinux, и при помощи специального конфигурационного файла MagOS.ini. Где и какие параметры передаются описывается в документации. Параметры, связанные с общей настройкой операционной системы передаются при помощи параметров ядра. Они организованы в систему параметров Unified Init Ram Disk (uird).
Описание параметров приведено на сайте проекта: [UIRD](http://neobht.github.io/uird/). Использован дистрибутив [Magos multi](http://magos.sibsau.ru/repository/netlive/multi/).
В промышленном применении нельзя обойтись без сервера, содержащего дистрибутив и поддерживающего протоколы HTTP (для удаленной загрузки), TFTP (сервер удаленной загрузки по PXE), SSH (для управления файлами) и RSYNC (для установки и обновления ОС на компьютерах пользователей). Сервер может быть реализован на любом дистрибутиве, включая MagOS. В моем случае был использован виртуальный контейнер на основе дистрибутива CentOS 6.
Для управления системой в состав MagOS были добавлены необходимые опции и скрипты, которые их обрабатывают.
**##### Выбор базового дистрибутива**
Выбор дистрибутива, на основе которого строится сеть, всегда сложная и неоднозначная задача. Выбирая тот или иной дистрибутив приходится учитывать множество факторов, в том числе множество местных проблем. У нас такими факторами были следующие: весьма непроизводительные компьютеры пользователей, они, хоть и приобретены были совсем недавно, но на составе компьютеров сэкономили, поэтому в типовой машинке, за которой сидит пользователь всего 2 Гигабайта ОЗУ и двухъядерный Celeron с не очень большой тактовой частотой. Такая типовая конфигурация компьютера пользователя накладывает ограничения на выбор менеджера рабочего стола, в частности использовать KDE уже не представляется возможным без потери возможности комфортной работы пользователя.
Во вторых это проблема низкой квалификации персонала, основной функцией которого является, отнюдь, не работа с компьютером. Необходимо помнить о многолетней привычке к одной единственной операционной системе, с которой людям на протяжении многих лет приходилось работать — Windows XP, поддержка которой прекращена, из-за чего, собственно и встала проблема замены ОС на рабочих местах пользователей.
Исследуя возможности адаптации внешнего вида рабочего стола к внешнему виду старой доброй XP, мы решили остановиться на Cinnamon. Несмотря на то, что разработка еще не вышла на релиз, в стандартной конфигурации этот рабочий стол работает вполне устойчиво и достаточно легко адаптируется к внешнему виду XP установкой соответствующей темы. Дополнительным фактором, влияющим на выбор ОС, послужило «пожелание» Госструктур видеть на рабочих местах компьютеры с отечественной операционной системой. Стало быть весь выбор, в нашем случае, свелся к выбору между ОС Rosa и ОС Alt Linux.
Несмотря на значительный опыт работы с ОС Rosa, сравнение дистрибутивов AltLinux и Rosa оказалось не в пользу Rosa. В первую очередь из-за отсутствия Cinnamon в составе LiveDVD, во вторых из-за снижения качества дистрибутива в последнее время.
Таким образом, в качестве основы для создания сборки была выбрана разработка AltLinux — одна из сборок стартового набора P7, содержащая рабочий стол [Cinnamon](http://mirror.yandex.ru/altlinux-starterkits/permalink/). Положительной стороной такого выбора является минимальный состав набора, что позволяет расширять его по своему усмотрению.
#### **Структура сети**
##### **Magos-server**
В сети предприятия имеется сервер виртуализации, на котором и был развернут Magos-server. Сервер выполняет несколько функций.
Во первых он служит сервером удаленной загрузки. Удаленная загрузка реализована при помощи TFTP и позволяет загружать MagOS в той же самой конфигурации, которая используется для работы на рабочих станциях. При помощи такой загрузки можно протестировать оборудование, выполнить установку операционной системы на рабочую станцию и выполнить множество других задач. Кроме того, при помощи сервера удаленной загрузки загружаются образы Clonezilla и Memtest.
Удаленная загрузка рабочей станции под управлением MagOS осуществляется по протоколу HTTP, для чего на сервер установлен Lighttpd, DocumentRoot которого указывает на репозиторий MagOS.
Установка дистрибутива на рабочую станцию и обновление рабочих станций выполняется по протоколу RSYNC. Поэтому на сервер установлен rsyncd.
Управление сервером осуществляется по протоколу SSH. По этому же протоколу на сервере обновляются изменения модулей программ, подготавливаемые на тестовом компьютере.
Этот компьютер укомплектован 4Gb памяти, поскольку возникли проблемы с созданием модулей при меньшем объеме памяти.
###### ***Интеграция в сеть***
Развернута AD на основе Windows 2008 SP2 и все компьютеры сети включаются в AD. Не исключение и компьютеры под управлением ОС Linux.
#### **Настройка загрузчика**
##### **Строки загрузчика**
```
title AltLinux i586 cinamon save
#find --set-root --ignore-floppies --ignore-cd /MagOS/MagOS.sgn
kernel /AltLinux/kernel/i586/vmlinuz uird.ro=*.xzm,*/live uird.from=/AltLinux/iso/altlinux-p7-cinnamon-latest-i586.iso;/AltLinux/modules/i586/ uird.load=* root=uird rw findswap vga=788 quiet plymouth.enable=0 uird.home=/dev/sda3/AltLinux-Data/homes/ uird.changes=/dev/sda3/AltLinux-Data/changes/ users
initrd /AltLinux/kernel/i586/uird.soft.cpio.xz /AltLinux/kernel/i586/uird.magos.cpio.xz
```
##### **Опции которые были использованы**
Ввиду множественности параметров ядра, для выделения параметров MagOS введен префикс параметров ‘uird’ (Unified Init Ram Disk).
```
uird.ro=*.xzm,*/live
```
**uird.ro** — Параметр MagOS. Задает фильтр для модулей, которые монтируются в режиме RO. В качестве таковых выступают собственно модули MagOS и сам LiveDVD AltLinux.
```
uird.from=/AltLinux/iso/altlinux-p7-cinnamon-latest-i586.iso;/AltLinux/modules/i586/
```
**uird.from** — Параметр MagOS. Список источников, на которых лежат модули для системы. Это указание пути для загрузки модулей и самого дистрибутива.
```
uird.load=*
```
**uird.load** — Параметр MagOS. Фильтр для модулей, которые необходимо подключить на этапе загрузки.
```
root=uird
```
**root** – Параметр ядра. Указание корневой файловой системы.
```
rw
```
**rw** — включение режима read/write.
```
findswap
```
**findswap** — Параметр MagOS. Заставляет систему автоматически подключать Swap. Если в системе находится Linux раздел Swap, то подключается он. Иначе ищется файл подкачки Windows.
```
vga=788
```
**vga** — Параметр ядра. Включение режима работы графики.
```
quiet
```
**quiet** — Параметр ядра, указывает необходимость формирования журнала dmesg.
```
plymouth.enable=0
```
**plymouth.enable** — Параметр ядра. Управляет графическим экраном и выводом журнала во время загрузки операционной системы.
```
uird.home=/dev/sda3/AltLinux-Data/homes/
```
**uird.home** — Параметр MagOS. Задает источник, на котором хранятся домашние директории пользователей. Ввиду ошибки в существующей версии MagOS требуется задание полного пути, включая указание устройства.
```
uird.changes=/dev/sda3/AltLinux-Data/changes/
```
**uird.changes** — Параметр MagOS. Задает источник, на котором будут храниться персистентные изменения корневой файловой системы.
```
users
```
**users** — Параметр ядра.
##### **Опции, которые могут быть использованы**
Есть возможность использовать шифрование для сохраняемых на жесткий диск данных. В этом случае вместо сохранения данных на разделы необходимо использовать сохранение в образы диска. Образы должны принять следующий вид:
```
*.RWM.ENC - RW слой криптованый
*.ROM.ENC - RO слой криптованый
```
**uird.copy2ram[+]=** — фильтр для модулей, которые копируются в ОЗУ. Может быть применено для ускорения работы при наличии значительного объема оперативной памяти.
**uird.copy2cache[+]=** — фильтр для модулей, которые копируются в КЭШ.
**uird.cache[+]=** — источники, в которые стоит синхронизировать модули.
Имеется возможность использовать КЭШ вместо синхронизации файлов MagOS с сервером при выключении компьютера. К недостаткам метода следует отнести то, что обмен с сервером выполняется по протоколу HTTP, что само по себе значительно снижает быстродействие. Вторым недостатком является то, что возникает сложность при разделении объектов обновления — файла MagOS.ini, раздела boot и раздела собственно ОС. Нужно обратить внимание, что уровень кэша layer-cache и соответствующий параметр uird.cache, служащий для синхронизации удаленных репозиториев в локальные или частные (INTRANET) репозитории, а также для обновления системы, должны задаваться нижеприведенным образом:
```
uird.cache=/MagOS/cache;/MagOS-Data/cache;/MagOS-Data/netlive
```
Здесь для каждого источника задается собственный каталог.
**uird.netfsopt[+]=** — дополнительные опции монтирования сетевых ФС: sshfs, nfs, curlftpfs, cifs.
При помощи указанных файловых систем в дальнейшем можно выполнять подключение сетевых файловых систем с разделами данных пользователя.
**uird.noload[+]=** — фильтр для модулей, которые необходимо пропустить во время загрузки
Можно выполнять выборочное отключение некоторых модулей для отдельных компьютеров или сетей.
**uird.homes[+]=** — источники, на которых хранятся домашние директории пользователей (объединяются AUFS).
По сути здесь вводится уровень домашних директорий пользователя layer-homes и соответствующий параметр: uird.homes:
```
uird.homes=/MagOS-Data/homes;/MagOS-Data/home.img;nfs://magos.sibsau.ru/homes/n/e/myuser
```
Все директории пользователя из различных источников каскадно-объединяются посредством AUFS и монтируются в /home. Более приоритетным является самый первый источник, затем, в порядке перечисления, уменьшается приоритет. В случае, если источник задан параметром uird.home=, то происходит монтирование источника в /home. Таким образом имеется возможность множественного подключения домашней папки с наложением разных файловых систем. Может использоваться при сетевом размещении домашних папок пользователей.
**Типы источников:**
**`/path/dir`** — директория на любом доступном носителе;
**`/dev/[..]/path/dir`** — директория на заданном носителе;
**`file-dvd.iso, file.img`** — образ диска (ISO, образ блочного устройства);
**`server/path…`** — источник доступный по HTTP (используется httpfs);
**`ssh://server/path/…`** — источник доступный по SSH (исползуется sshfs);
**`server/path…`** — источник доступный по FTP (используется curlftpfs);
**`nfs://server/path/…`** — источник доступный по NFS;
**`cifs://server/path/…`** — источник доступный по CIFS;
**`uird.machines=`** — источник, где хранятся машинно-зависимые персистентные изменения.
Имеется возможность использовать машинозависимые ресурсы для changes, что необходимо для обеспечения реентерабильности пользователей.
##### **Особенности сетевой загрузки**
Для сетевой загрузки используются нижеприведенные параметры:
```
kernel images/vmlinuz uird.ro=*.xzm,*/live uird.from=http://magos-server.mydomain.local/magos/AltLinux/iso/alt linux-p7-cinnamon-latest-i586.iso;http://magos-server.mydomain.local/magos/AltLinux/modules/i586/ uird.load=* root=uird rw findswap vga=788 quiet plymouth.enable=0 users
```
Это те же самые параметры, однако следует обратить внимание на указание параметра uird.from:
```
uird.from=http://magos-server.mydomain.local/magos/AltLinux/iso/altlinux-p7-cinnamon-latest-i586.iso;http://magos-server.mydomain.local/magos/AltLinux/modules/i586/
```
Здесь указывается полный http url сервера, с которого выполняется загрузка ОС. Базовый уровень layer-base и соответствующий параметр uird.from могут задаваться в следующем виде:
```
uird.from=/MagOS;/MagOS-Data;MagOS.iso;http://magos.sibsau.ru/repository/netlive/2014.64/MagOS
```
#### **Порядок инициализации системы**
* Осуществляется поиск конфигурационного файла по пути, указанному в параметре uird.basecfg.
* Устанавливаются параметры из конфигурационного файла, которые еще не установлены в параметрах ядра.
* Происходит монтирование источников base-уровня в порядке, указанном в параметре uird.from.
* Происходит монтирование источников cache-уровня в порядке, указанном в параметре uird.cache.
* Происходит монтирование источников homes-уровня в порядке, указанном в параметре uird.homes.
* Происходит подключение в самый верхний уровень AUFS источника персистентных изменений, указанного в параметре uird.changes.
* Осуществляется синхронизация base-уровня в cache-уровень с учетом параметра uird.copy2cache, а также соответствия подуровней. Если подуровней cache-уровня меньше, чем base-уровня, то оставшиеся подуровни синхронизируются в RAM.
```
├── layer-base ==> ├── layer-cache
│ ├── 0 --> │ ├── 0
│ ├── 1 --> │ ├── 1
│ ├── ... --> │ └── ...
│ └── ... --> │ RAM
```
* Осуществляется синхронизация base,cache-уровней в RAM с учетом параметра uird.copy2ram.
* Осуществляется поиск модулей в RAM, cache-уровне, base-уровне и подключение их на верхний уровень AUFS или копирование в корень (с учетом фильтров, указанных в параметрах uird.load,uird.noload,uird.ro,uird.rw,uird.cp).
* Осуществляется каскадное объединение источников homes-уровня и подключение их в /home/.
* Выполняются скрипты rc.preinit.
##### **Структура конфигурационного файла basecfg.ini по умолчанию**
```
uird.config=MagOS.ini
uird.ramsize=70%
uird.ro=*.xzm;*.rom;*.rom.enc;*.pfs;*.sfs
uird.rw=*.rwm;*.rwm.enc
uird.cp=*.xzm.cp,*/rootcopy
uird.load=/base/,/modules/,rootcopy
uird.noload=
uird.from=/MagOS;/MagOS-Data
uird.changes=/MagOS-Data/changes
uird.cache=/MagOS-Data/cache
uird.machines=/MagOS-Data/machines
uird.home=/MagOS-Data/homes
```
Если параметр uird.basecfg не задан, то используется /uird\_configs/basecfg.ini внутри initrd.
##### **Структура системной директории**
```
/memory/
├── bundles - точка монтирования модулей
│ ├── 00-kernel.xzm
│ ├── 01-firmware.xzm
│ ├── 10-core.xzm
│ ├── 80-eepm-1.5.2.xzm
│ └── ... - и т.д.
├── changes - точка монтирования для хранения изменений
│ ├── etc
│ ├── home
│ ├── memory
│ ├── run
│ ├── var
│ └── ... - и т.д.
├── data - точка монтирования источников
│ ├── cache - кэш уровня
│ ├── homes - homes уровня
│ ├── machines - (зарезервировано)
│ └── from - базового уровня
├── layer-base - точка монтирования базового уровня
│ ├── 0 - ресурс первого источника
│ ├── 1 - ресурс второго источника (в порядке перечисления в uird.from=)
│ └── ... - и т.д.
├── layer-cache - точка монтирования кэш уровня
│ ├── 0 - ресурс первого источника
│ ├── 1 - ресурс второго источника (в порядке перечисления в uird.cache=)
│ └── ... - и т.д.
├── layer-homes - точка монтирования homes уровня
│ ├── 0 - ресурс первого источника
│ ├── 1 - ресурс второго источника (в порядке перечисления в uird.homes=)
│ └── ... - и т.д.
├── cmdline - системный файл для хранения дополнительных параметров командной строки
└── MagOS.ini.gz - системный файл для хранения конфигурационного файла
```
##### **Реализация**
В основе реализации лежит набор скриптов инициализации *dracut* (модули base, busybox ) и скрипты *uird* (livekitlib+uird-init):
* cmdline-hook: parse-root-uird.sh (проверяет параметр root=uird);
* mount-hook: mount-uird.sh (выполняет скрипт uird-init);
* livekitlib — содержит библиотеку функций системы инициализации;
* uird-init — последовательно выполняет набор функций из livekitlib и осуществляет каскадно-блочное монтирование модулей системы в единый корень AUFS в директорию указанную в переменной dracut $NEWROOT.
#### **Сервер MagOS**
##### **Общие сведения**
В нашем случае magos-server развернут в качестве контейнера openvz. Реализация не имеет принципиального значения.
* Он служит сервером удаленной загрузки. Удаленная загрузка реализована при помощи TFTP/PXE и позволяет загружать MagOS в той же самой конфигурации, которая используется для работы на рабочих станциях. При помощи такой загрузки можно протестировать оборудование, выполнить установку операционной системы на рабочую станцию и выполнить множество других задач.
* Удаленная загрузка рабочей станции под управлением MagOS осуществляется по протоколу HTTP, для чего на сервер установлен Lighttpd, documentroot которого указывает на репозиторий MagOS.
* Установка дистрибутива на рабочую станцию и обновление рабочих станций выполняется по протоколу rsync. Поэтому на сервер установлен rsyncd.
* Управление сервером осуществляется по протоколу ssh. По этому же протоколу на сервере обновляются изменения модулей программ, подготавливаемые на тестовом компьютере.
###### ***Реализация сервера***
Операционная система Centos v6. Для виртуального контейнера выделены следующие ресурсы: CPU — 2, RAM — 512Mb, swap — 1Gb, размер виртуального диска 40Gb.
##### **Настройки сети**
**Настройка в ifcfg-eth0**
```
DEVICE=eth0
IPADDR=192.168.1.xxx
NETMASK=255.255.255.0
NETWORK=192.168.1.0
GATEWAY=192.168.1.1
DNS1=192.168.1.xxx
BROADCAST=192.168.1.255
TYPE=Ethernet
ONBOOT=yes
NM_CONTROLLED=yes
BOOTPROTO=static
```
**Сетевые службы (netstat -tunlp)**
```
# netstat -tunlp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:873 0.0.0.0:* LISTEN 494/xinetd
tcp 0 0 192.168.1.xxx:80 0.0.0.0:* LISTEN 551/lighttpd
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 484/sshd
udp 0 0 0.0.0.0:69 0.0.0.0:* 494/xinetd
```
##### **Настройка служб**
###### ***Lighthttpd***
**Запуск:**
```
chkconfig --list lighttpd
lighttpd 0:off 1:off 2:on 3:on 4:off 5:on 6:off
```
**Конфигурационный файл lighttpd.conf**
```
var.log_root = "/var/log/lighttpd"
var.server_root = "/var/www"
var.state_dir = "/var/run"
var.home_dir = "/var/lib/lighttpd"
var.conf_dir = "/etc/lighttpd"
var.vhosts_dir = server_root + "/vhosts"
var.cache_dir = "/var/cache/lighttpd"
var.socket_dir = home_dir + "/sockets"
include "modules.conf"
server.port = 80
server.use-ipv6 = "disable"
server.bind = "192.168.1.xxx"
server.username = "lighttpd"
server.groupname = "lighttpd"
server.document-root = server_root + "/"
server.pid-file = state_dir + "/lighttpd.pid"
server.errorlog = log_root + "/error.log"
include "conf.d/access_log.conf"
include "conf.d/debug.conf"
server.event-handler = "linux-sysepoll"
server.network-backend = "linux-sendfile"
server.stat-cache-engine = "simple"
server.max-connections = 1024
index-file.names += (
"index.xhtml", "index.html", "index.htm", "default.htm", "index.php"
)
url.access-deny = ( "~", ".inc" )
$HTTP["url"] =~ "\.pdf$" {
server.range-requests = "disable"
}
static-file.exclude-extensions = ( ".php", ".pl", ".fcgi", ".scgi" )
include "conf.d/mime.conf"
include "conf.d/dirlisting.conf"
server.follow-symlink = "enable"
server.upload-dirs = ( "/var/tmp" )
```
**Конфигурационный файл vhosts.d/magos.conf**
```
$HTTP["host"] == "magos-server.mydomain.local" {
var.server_name = "magos-server.mydomain.local"
server.name = server_name
include "conf.d/trigger_b4_dl.conf"
server.document-root = vhosts_dir + "/magos/"
accesslog.filename = log_root + "/" + server_name "/access.log"
}
```
**Конфигурационный файл conf.d/dirlisting.conf**
```
dir-listing.activate = "enable"
dir-listing.hide-dotfiles = "disable"
dir-listing.exclude = ( "~$" )
dir-listing.encoding = "UTF-8"
dir-listing.hide-header-file = "disable"
dir-listing.show-header = "disable"
dir-listing.hide-readme-file = "disable"
dir-listing.show-readme = "disable"
```
###### ***Tftpd***
**Запуск (/etc/xinetd.d/tftp:)**
```
service tftp {
socket_type = dgram
protocol = udp
wait = yes
user = root
server = /usr/sbin/in.tftpd
server_args = -s /var/lib/tftpboot
disable = no
per_source = 11
cps = 100 2
flags = IPv4
}
```
**Конфигурационный файл /var/lib/tftpboot/pxelinux.cfg/default**
```
default menu.c32
prompt 0
timeout 300
ONTIMEOUT local
MENU TITLE PXE Menu
# Первый пункт меню – загрузка с HD
LABEL Boot from hard disk
localboot 0x80
LABEL AltLinux-net
MENU LABEL AltLinux-net
kernel images/vmlinuz uird.ro=*.xzm,*/live uird.from=http://magos-server.mydomain.local/magos/AltLinux
x/iso/altlinux-p7-cinnamon-latest-i586.iso;http://magos-server.mydomain.local/magos/AltLinux/modules/i586/ ui
rd.load=* root=uird rw findswap vga=788 quiet plymouth.enable=0 users
append initrd=images/uird.magos.cpio.xz
LABEL AltLinux-net testing
MENU LABEL AltLinux-net testing
kernel images/vmlinuz uird.ro=*.xzm,*/live uird.from=http://magos-server.mydomain.local/testing/AltLinux
/iso/altlinux-p7-cinnamon-latest-i586.iso;http://magos-server.mydomain.local/testing/AltLinux/modules/i586
/ uird.load=* root=uird rw findswap vga=788 quiet plymouth.enable=0 users
append initrd=images/uird.magos.cpio.xz
```
Репозиторий состоит из двух частей: рабочего, имеющего название magos и тестового, имеющего название testing. Рабочий репозиторий предназначен для установки и обновления программного обеспечения рабочих станций пользователей. Предварительное тестирование устанавливаемого ПО выполняется на репозитории testing. Меню загрузки позволяет загружать операционную систему как из рабочего репозитория так и из тестового.
###### ***Rsync***
**Запуск (/etc/xinetd.d/rsync):**
```
service rsync
{
disable = no
flags = IPv4
socket_type = stream
wait = no
user = root
server = /usr/bin/rsync
server_args = --daemon
log_on_failure += USERID
}
```
**Конфигурационный файл /etc/rsyncd.conf**
```
use chroot = yes
max connections = 100
syslog facility = local5
pid file = /var/run/rsyncd.pid
[magos]
path = /var/www/magos
comment = whole MagOS boot
[testing]
path = /var/www/testing
comment = whole MagOS boot
```
###### ***sshd***
**Запуск:**
```
# chkconfig –list sshd
sshd 0:off 1:off 2:on 3:on 4:on 5:on 6:off
```
**Конфигурационный файл /etc/ssh/sshd\_config**
```
Protocol 2
SyslogFacility AUTHPRIV
PasswordAuthentication yes
ChallengeResponseAuthentication no
GSSAPIAuthentication yes
GSSAPICleanupCredentials yes
UsePAM yes
AcceptEnv LANG LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES
AcceptEnv LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT
AcceptEnv LC_IDENTIFICATION LC_ALL LANGUAGE
AcceptEnv XMODIFIERS
X11Forwarding no
Subsystem sftp /usr/libexec/openssh/sftp-server
```
##### **Репозиторий программ**
В структуре репозитория программ показаны только существенные файлы и каталоги.
**magos**
```
├──AltLinux
│ ├──iso
│ │ └──altlinux-p7-cinnamon-latest-i586.iso
│ ├──kernel
│ │ └──i586
│ │ ├──uird.magos.cpio.xz
│ │ ├──uird.soft.cpio.xz
│ │ └──vmlinuz
│ └──modules
│ └──i586
│ ├──00-kernel.xzm
│ ├──01-firmware.xzm
│ ├──03-1-nvidia-current.xzm
│ ├──03-2-nvidia304.xzm
│ ├──03-9-fglrx.xzm
│ ├──80-eepm-1.5.2.xzm
│ ├──80-uird.soft.xzm
│ ├──90-magos-patches.xzm
│ ├──99-squashfs-tools.32.xzm
│ ├──99-u10-update.xzm
│ ├──99-u40-office4.xzm
│ ├──99-u50-utils.xzm
│ ├──99-u99-default.xzm
│ ├──MagOS.ini
│ └──update.txt
├──AltLinux-Data
│ ├──cache
│ ├──changes
│ ├──homes
│ ├──machines
│ ├──MagOS-Data.sgn
│ ├──modules
│ ├──optional
│ └──rootcopy
└──boot
├──grub4dos
│ ├──install.lin
│ ├──install.win
│ └──local
│ └──menu.lst
├──syslinux
└──tools
```
**testing**
```
├──AltLinux
│ ├──iso
│ │ └──altlinux-p7-cinnamon-latest-i586.iso
│ ├──kernel
│ │ └──i586
│ │ ├──uird.magos.cpio.xz
│ │ ├──uird.soft.cpio.xz
│ │ └──vmlinuz
│ └──modules
│ └──i586
│ ├──00-kernel.xzm
│ ├──01-firmware.xzm
│ ├──03-1-nvidia-current.xzm
│ ├──03-2-nvidia304.xzm
│ ├──03-9-fglrx.xzm
│ ├──80-eepm-1.5.2.xzm
│ ├──80-uird.soft.xzm
│ ├──90-magos-patches.xzm
│ ├──99-squashfs-tools.32.xzm
│ ├──99-u10-update.xzm
│ ├──99-u40-office4.xzm
│ ├──99-u50-utils.xzm
│ ├──99-u99-default.xzm
│ ├──MagOS.ini
│ └──update.txt
├──AltLinux-Data
│ ├──cache
│ ├──changes
│ ├──homes
│ ├──machines
│ ├──MagOS-Data.sgn
│ ├──modules
│ ├──optional
│ └──rootcopy
├──boot
│ ├──grub4dos
│ │ ├──install.lin
│ │ ├──install.win
│ │ └──local
│ │ └──menu.lst
│ ├──syslinux
│ └──tools
└──update.tar.gz
```
Поскольку запись в репозиторий осуществляется с правами пользователя системы, необходимо создать группы, отвечающие за право записи в соответствующий репозиторий:
```
# groupadd magos
# groupadd testing
```
Установить права на все каталоги репозитория:
```
# cd /var/www
# find magos -type f -exec chmod 664 {} +
# find magos -type d -exec chmod 775 {} +
# find testing -type f -exec chmod 664 {} +
# find testing -type d -exec chmod 775 {} +
```
Установить группы владельцев репозиториев:
```
# chown -R :magos magos
# chown -R :testing testing
```
Установить SGID на каталоги репозиториев:
```
# chmod g+s magos
# chmod g+s testing
```
##### **Дополнительные данные сервера**
```
yum.repos.d
CentOS-Base.repo
CentOS-Debuginfo.repo
CentOS-fasttrack.repo
CentOS-Media.repo
CentOS-Vault.repo
epel.repo
epel-testing.repo
vz.repo
```
###### ***Скрипты управления***
Скрипты создавались для текущего использования и не претендуют на «коробочность» использования, поэтому при их применении прошу быть внимательными!
##### **Мониторинг**
Скрипт update-txt.sh, выполняемый ежедневно по расписанию записывает в каталог modules файл update.txt, содержащий текущую дату. После синхронизации данных на пользовательский компьютер он позволяет легко проверить когда компьютер последний раз обновлялся. Это необходимый момент для отслеживания компьютеров, которые не перегружаются в течение длительного срока (пользователь не выключает компьютер).
**Скрипт /etc/cron.daily/update-txt.sh**
```
#!/bin/sh
echo "magos $(date)" > /var/www/magos/AltLinux/modules/i586/update.txt
echo "testing $(date)" > /var/www/testing/AltLinux/modules/i586/update.txt
```
###### ***Обновление***
Скрипты testig2magos\_kern.sh, testig2magos\_mod.sh и testig2magos\_all.sh предназначены для обновления рабочего репозитория из репозитория testing и выполняются только в ручном режиме.
*testig2magos\_kern.sh* — обновляет только системные модули и каталог kernel.
*testig2magos\_mod.sh* — выполняет обновление только пользовательских модулей.
*testig2magos\_all.sh* — выполняет полное обновление включая папки kernel, iso и modules.
Ни один из скриптов не выполняет обновление файла MagOS.ini!
Изменения в этот файл вносятся только вручную.
**Скрипт /root/bin/testig2magos\_kern.sh**
```
#!/bin/bash
# обновить ядро и системные модули MagOS в рупозитории magos
# из репозитория testing
MAGOS="/var/www/magos"
TESTING="/var/www/testing"
MAGOSGROUP="magos"
echo "!!! UPDATE KERNEL AND MAGOS MODULES TO magos REPOSITORY FROM testing REPOSITORY"
echo " ====="
echo
echo "Pres Rnter to continue, or Ctrl+C to abort..."
read junk
clear
cp -ruv $TESTING/AltLinux/kernel/i586/*.xzm $MAGOS/AltLinux/kernel/i586/
cp -ruv $TESTING/AltLinux/modules/i586/[0-9]?-*.xzm $MAGOS/AltLinux/modules/i586/
find $MAGOS -type f -exec chmod 664 {} +
find $MAGOS -type d -exec chmod 775 {} +
chown -R :$MAGOSGROUP $MAGOS/*
echo "UPDATE KERNEL AND MAGOS MODULES FROM magos REPOSITORY IT IS EXECUTED"
```
**Скрипт /root/bin/testig2magos\_mod.sh**
```
#!/bin/bash
# обновить пользовательские модули MagOS в рупозитории magos
# из репозитория testing
MAGOS="/var/www/magos"
TESTING="/var/www/testing"
MAGOSGROUP="magos"
echo "!!! UPDATE MODULES TO magos REPOSITORY FROM testing REPOSITORY"
echo " ====="
echo
echo "Pres Rnter to continue, or Ctrl+C to abort..."
read junk
clear
cp -ruv $TESTING/AltLinux/modules/i586/[0-9]??-*.xzm $MAGOS/AltLinux/modules/i586/
find $MAGOS -type f -exec chmod 664 {} +
find $MAGOS -type d -exec chmod 775 {} +
chown -R :$MAGOSGROUP $MAGOS/*
echo "UPDATE MODULES FROM magos REPOSITORY IT IS EXECUTED"
```
**Скрипт /root/bin/testig2magos\_all.sh**
```
#!/bin/bash
# обновить целиком весь репозиторий magos
# из репозитория testing, включая каталог с исходным дистрибутивом iso
MAGOS="/var/www/magos"
TESTING="/var/www/testing"
MAGOSGROUP="magos"
echo "!!! UPDATE ALL MAGOS REPOSITORY magos FROM testing REPOSITORY"
echo " ====="
echo
echo "Pres Rnter to continue, or Ctrl+C to abort..."
read junk
clear
cp -ruv $TESTING/AltLinux/iso/ $MAGOS/AltLinux/iso/
cp -ruv $TESTING/AltLinux/kernel/i586/*.xzm $MAGOS/AltLinux/kernel/i586/
cp -ruv $TESTING/AltLinux/modules/i586/*.xzm $MAGOS/AltLinux/modules/i586/
find $MAGOS -type f -exec chmod 664 {} +
find $MAGOS -type d -exec chmod 775 {} +
chown -R :$MAGOSGROUP $MAGOS/*
echo "UPDATE magos REPOSITORY IT IS EXECUTED"
```
#### **Пользовательские модули**
##### **Общие принципы создания пользовательских модулей**
###### ***Что нужно знать***
При создании модулей в MagOS приходится учитывать одну важную особенность, связанную с созданием пользователей и групп. При создании модуля в нем сохраняются измененные файлы passwd, group, shadow и т.д. Но, для того, чтобы следующий создаваемый модуль их «видел» скриптом epm2xzm, нужно, чтобы название модуля соответствовало шаблону «NN-». Если названия модулей не будут соответствовать этому шаблону, то каждый последующий создаваемый модуль так же, как и первый, будут создаваться на основе только базовых модулей MagOS. Больнее всего это ударит по файлам аутентификации: программы создающие системных пользователей и устанавливаемые в разные модули получают одинаковые UID и GID, а файлы типа passwd, созданные в разных модулях переписываются последующими слоями. В результате установленные в нижележащих модулях программы оказываются неработоспособными.
Исключить эту проблему можно двумя путями: выполнить группировку программ, создающих системные учетные записи в рамках одного модуля или задать имена модулей согласно вышеприведенного шаблона.
Скрипты создающие модули написаны так, что в качестве имени модуля используют собственное название. Скрипт, названный 99-u30-example.sh будет создавать модуль с названием 99-u30-example.xzm.
##### **Сколько модулей делать**
Порядок подключения базовых модулей не имеет значения, поскольку в них нет никаких перекрывающихся файлов и каталогов. Но имеет значение порядок подключения пользовательских модулей. Если в пользовательских модулях имеются исправления файлов базовых модулей, а в случае с адаптацией MagOS для дистрибутива AltLinux такая ситуация наблюдается, то они должны располагаться в верхних слоях aufs и подключаться после системных. Модули подключаются в систему, будучи отсортированными по названию, поэтому название модуля имеет важное значение. Поскольку название последнего системного модуля начинается с символов «99-», рекомендуется использовать названия пользовательских модулей, начинающееся с символов «99?-» таким образом, чтобы при сортировке каталога по названию они оказывались после системных модулей.
##### **Модули специального назначения**
Рекомендуется выделить два модуля имеющих особое назначение: модуль, в котором располагается текущее обновление операционной системы. Его рекомендуется устанавливать первым, поэтому его рекомендованное название «99-u10-update». И модуль, содержащий адаптированные файлы настроек операционной системы и ее программ. Его рекомендуется устанавливать последним. При создании модуля с настройками нужно соблюсти несколько правил:
* в этот модуль нельзя ставить программы.
* в этом модуле не должно быть файлов, ответственных за назначение прав (passwd, group и т.п.)
При соблюдении этих правил модуль может не исключаться из системы при пересборке нижележащих модулей и в нем могут располагаться скрипты управления системой.
##### **Ограничения для модулей**
На количество модулей нет никаких ограничений (по умолчанию может быть до 127), но желательно соблюдать некоторый компромисс на разделение программ по модулям. Во первых, при пересборке нижележащего модуля нам требуется отключать все модули, которые должны грузиться позже. А после пересборки такого модуля рекомендуется выполнить пересборку и всех последующих модулей, даже если программы в них не обновлялись и не изменялись. Это связано с зависимостями программ по библиотекам. Таким образом нужно стремиться к тому, чтобы количество пользовательских модулей не было большим.
Вторым ограничением, но уже с другой стороны, выступают требования к ресурсам компьютера, на котором выполняется пересборка модулей. Во время установки программ в модуль файловая система, по-умолчанию, располагается в оперативной памяти, поэтому количество устанавливаемых программ напрямую связано с размером требуемой оперативной памяти. Так, для установки Libreoffice требуется, чтобы на компьютере было около 3 Гигабайт свободной оперативной памяти. Для того, чтобы устранить это ограничение требуется специальным образом подготовить директорию для размещения временных файлов для создания модулей.
Таким образом минимальное количество модулей, с которыми придется работать может быть 3, а оптимальное количество 4 модуля.
##### **Инструкция по созданию модулей**
Процедура сборки модуля выглядит следующим образом:
1. Загрузить средства обновления /root/bin/loadupdate.sh.
2. Отключить обновление системы при перегрузке ОС: в файлах /etc/sysconfig/MagOS и /mnt/livemedia/MagOS.ini установить переменную AUTOUPDATE=No.
3. Переименовать обновляемый модуль и все последующие, добавив расширение .bak (другие расширения не допускаются).
4. Выполнить сборку модуля. По запросу выполнить сохранение модуля на сервере magos-server.
5. Перегрузить компьютер, для того, чтобы изменения корректно вступили в силу.
6. Повторить операции 3-5 для всех последующих модулей.
###### ***Методика установки новых программ***
Методика поиска, установки и настройки программ выглядит следующим образом:
* Загрузить компьютер в режиме clean.
* Найти нужную программу и установить ее.
* Настроить программу имеющимися для настройки средствами, включая acc и веб интерфейс. Добиться результата.
* Если программа на не подошла, перегрузить компьютер и начать сначала.
* После получения результата сохранить измененные в процессе настройки конфигурационные файлы в отдельный каталог на жестком диске.
* Внести программу в список для установки в составе подходящего модуля.
* Создать модуль. Отредактировать скрипт создания модуля для получения нужных нам значений конфигурационных файлов. При необходимости повторять процесс многократно. Вместо редактирования скрипта создания модуля можно положить конфигурационные файлы и т.п. в каталог модуля установки значений по умолчанию. Все зависит от программы.
* Выполнить последовательную пересборку всех вышележащих модулей.
##### **Модуль обновления системы**
Модуль с обновлениями операционной системы является наиболее простым. Количество обновлений зависит от времени, прошедшего с выпуска релиза дистрибутива. Если количество обновлений становится критическим, то стоит подумать над обновлением iso образа дистрибутива. Период обновлений на усмотрение администратора системы, поскольку обновления выполняются только в ручном режиме и требуют пересборки всех остальных модулей.
**Скрипт 99-u10-update.sh**
```
#!/bin/sh
. conf/devel.conf
NAME=`echo $0 | sed 's/\.\///'| sed 's/\..*//'`
. lib/mv.sh $NAME
epm2xzm $NAME upgrade $NAME.xzm
rm -rf $NAME
mkdir $NAME
xzm2dir $NAME.xzm $NAME
. lib/delhlam.sh $NAME
dir2xzm $NAME $NAME.xzm
. lib/update.sh $NAME
```
##### **Модуль установки офисных программ**
В состав модуля входят приложения для конечного пользователя, не требующие создания служебного аккаунта. Список приложений не очень большой, но ввиду большого количества зависимых пактов, этот модуль получается достаточно больших размеров.
**Скрипт 99-u10-office4.sh**
```
#!/bin/sh
. conf/devel.conf
NAME=`echo $0 | sed 's/\.\///'| sed 's/\..*//'`
. lib/mv.sh $NAME
epm2xzm $NAME -i 'java-1.7.0-openjdk LibreOffice4-langpack-ru LibreOffice4-integrated file-roller LibreOffice4 LibreOffice4-gnome
foomatic-db lsof foo2zjs foo2zjs-apps foo2zjs-fwdownloader mozilla-plugin-adobe-flash
mozilla-plugin-mozplugger mozilla-plugin-totem totem-plugins fonts-ttf-ms'
rm -rf $NAME
mkdir $NAME
xzm2dir $NAME.xzm $NAME
rm -rf $NAME/etc/urpmi $NAME/etc/.java
. lib/delhlam.sh $NAME
dir2xzm $NAME $NAME.xzm
. lib/update.sh $NAME
```
##### **Модуль с утилитами и серверами**
В этот модуль собраны все утилиты и серверы, требующие создания служебной записи пользователя и зависимые от них компоненты. Вполне возможно перенесение части указанных ниже утилит в состав модуля office, однако несмотря на значительный перечень программ, суммарное количество устанавливаемых программ и потребляемые при установке ресурсы не превышают 3 Гигабайт.
Кроме собственно установки программ выполняется настройка некоторых элементов операционной системы и установленных программ прямо в установочном скрипте.
Такой подход позволяет правильнее реагировать на обновление версий программ, при которых происходят изменения в формате конфигурационных файлов или, если в конфигурационных файлах появляются/меняются параметры настроек по умолчанию. Для подобных случаев этот механизм является более предпочтительным, нежели положить исправленный готовый конфигурационный файл в модуль с окончательными настройками. Тогда при изменении настроек конфигурации есть большой риск их вообще не обнаружить во время создания или обновления модулей.
Несколько слов об используемом наборе программного обеспечения. Программное обеспечение компьютеров не содержит никаких специфичных требований и задач. Корпоративные системы перенесены на уровень интранет приложений. Компьютеры представляют собой тонкие клиенты к ним и «печатные машинки».
**Скрипт 99-u20-utils.sh**
```
#!/bin/sh
. conf/devel.conf
NAME=`echo $0 | sed 's/\.\///'| sed 's/\..*//'`
. lib/mv.sh $NAME
epm2xzm $NAME -i 'samba samba-winbind alterator-auth cups-windows samba-client ntpdate ntp-utils
zabbix-agent zabbix-agent-sudo perl-FusionInventory-Agent perl-FusionInventory-Agent-scripts
perl-Task-FusionInventory perl-Pod-Text-Ansi alterator-fbi alterator-net-iptables italc2-client
installer-feature-init-italc rsync tcpdump nmap netcat telnet sane sane-server xsane xsane-gimp2
sane-frontends yagf cuneiform cuneiform-data fonts-otf-gdouros-akkadian aspell-ru-lebedev
aspell-ru-rk iperf whois rdesktop xfreerdp remmina-plugins sshpass pssh'
rm -rf $NAME
mkdir $NAME
xzm2dir $NAME.xzm $NAME
cp /usr/share/zoneinfo/Asia/Krasnoyarsk $NAME/etc/localtime
cp /etc/nsswitch.conf $NAME/etc/nsswitch.conf
sed -i s/'^hosts: files mdns4_minimal \[NOTFOUND=return\]*'/'hosts: files dns mdns4_minimal \[NOTFOUND=return\] myhostname fallback'/ $NAME/etc/nsswitch.conf
sed -i s/'^# PidFile=\/var'/'PidFile=\/var'/ $NAME/etc/zabbix/zabbix_agentd.conf
sed -i s/'^# EnableRemoteCommands=0'/'EnableRemoteCommands=1'/ $NAME/etc/zabbix/zabbix_agentd.conf
sed -i s/'^LogFileSize='/'# LogFileSize='/ $NAME/etc/zabbix/zabbix_agentd.conf
sed -i s/'127.0.0.1'/'192.168.0.XXX'/ $NAME/etc/zabbix/zabbix_agentd.conf
sed -i s/'^# LogRemoteCommands=0'/'LogRemoteCommands=1'/ $NAME/etc/zabbix/zabbix_agentd.conf
sed -i s/'^Hostname='/'# Hostname='/ $NAME/etc/zabbix/zabbix_agentd.conf
sed -i s/'^# Timeout=3'/'Timeout=30'/ $NAME/etc/zabbix/zabbix_agentd.conf
mkdir $NAME/etc/fusioninventory
echo "server = http://glpi.kompany.local/glpi/plugins/fusioninventory/" > $NAME/etc/fusioninventory/agent.cfg
echo "delaytime = 3600" >> $NAME/etc/fusioninventory/agent.cfg
echo "timeout = 180" >> $NAME/etc/fusioninventory/agent.cfg
echo "logger = File" >> $NAME/etc/fusioninventory/agent.cfg
echo "logfile = /var/log/fusioninventory.log" >> $NAME/etc/fusioninventory/agent.cfg
echo "logfacility = LOG_USER" >> $NAME/etc/fusioninventory/agent.cfg
echo "debug = 3" >> $NAME/etc/fusioninventory/agent.cfg
mkdir $NAME/etc/cron.daily
echo "#!/bin/sh" > $NAME/etc/cron.daily/fusioninventory-agent
echo "" >> $NAME/etc/cron.daily/fusioninventory-agent
echo "/usr/bin/fusioninventory-agent --conf-file=/etc/fusioninventory/agent.cfg" >> $NAME/etc/cron.daily/fusioninventory-agent
chmod +x $NAME/etc/cron.daily/fusioninventory-agent
. lib/delhlam.sh $NAME
dir2xzm $NAME $NAME.xzm
. lib/update.sh $NAME
```
В нашем случае, в данном конфигурационном файле выполняется настройка timezone, поскольку ее значения отличаются от значений дистрибутива по умолчанию, а стандартная настройка указанных параметров MagOS, в нашем случае не срабатывает правильно (cp /usr/share/zoneinfo/Asia/Krasnoyarsk $NAME/etc/localtime).
Выполняется исправление какой-то странной ошибки в настройках дистрибутива AltLinux, при которой не резолвятся имена компьютеров локальной сети, если имя домена локальной сети оканчивается на local (cp /etc/nsswitch.conf $NAME/etc/nsswitch.conf sed -i s/'^hosts: files mdns4\_minimal \[NOTFOUND=return\]\*'/'hosts: files dns mdns4\_minimal \[NOTFOUND=return\] myhostname fallback'/ $NAME/etc/nsswitch.conf).
Выполняется настройка конфигурационного файла zabbix\_agentd, позволяющего в реальном времени отслеживать состояние компьютеров пользователей, что достаточно важно для снижения времени простоя.
Выполняется настройка конфигурационного файла fusioninventory-agent, утилиты, работающей совместно с системой автоматизации технической поддержки GLPI и позволяющей выполнять автоматическую инвентаризацию оборудования и программного обеспечения.
##### **Модуль системных настроек**
Модуль системных настроек не содержит никаких устанавливаемых программ и представляет собой всего лишь упаковщик для каталога модуля, который и представляет главный интерес.
**Скрипт 99-u99-default.sh**
```
#!/bin/sh
. conf/devel.conf
NAME=`echo $0 | sed 's/\.\///'| sed 's/\..*//'`
. lib/mv.sh $NAME
dir2xzm $NAME $NAME.xzm
. lib/update.sh $NAME
```
В каталоге etc/ модуля находятся следующие каталоги и конфигурационные файлы:
**sudoers**
```
-r-------- 1 root root 730 Aug 20 15:42 ./sudoers
```
Внесена строка разрешения выполнения операций sudo администратору без пароля (необходимо для выполнения параллельных операций по протоколу ssh).
**X11**
```
./X11:
total 8
drwxr-xr-x 2 root root 4096 Aug 21 12:42 xinit
drwxr-xr-x 2 root root 4096 Aug 21 12:42 xorg.conf.d
```
Выполнена преднастройка переключателя локали клавиатуры:
**etc/X11/xinit/Xkbmap**
```
option grp:alt_shift_toggle -variant , -layout us,ru -model pc104
```
Выполнена настройка клавиатуры:
**etc/X11/xorg.conf.d/00-keyboard.conf**
```
# Read and parsed by systemd-localed. It's probably wise not to edit this file
# manually too freely.
Section "InputClass"
Identifier "system-keyboard"
MatchIsKeyboard "on"
Option "XkbLayout" "us,ru"
EndSection
```
**./apt**
```
total 8
drwxr-xr-x 2 root root 4096 Jun 9 09:45 sources.list.d
drwxr-xr-x 2 root root 4096 Jun 9 09:42 vendors.list.d
```
Добавлен репозиторий autoimports для установки программы fusioninventory-agent.
**etc/apt/sources.list.d/autoimports-p7.list**
```
rpm [cronbuild] ftp://ftp.altlinux.ru/pub/distributions/ALTLinux/autoimports/Sisyphus/ noarch autoimports
/etc/apt/vendors.list.d/autoimports-p7.list
simple-key "cronbuild" {
Fingerprint "DE73F3444C163CCD751AC483B584C633278EB305";
Name "Cronbuild Service ";
}
simple-key "cronport" {
Fingerprint "F3DBF34AB0CC0CE638DF7D509F61FBE7E2C322D8";
Name "Cronport Service ";
}
```
**./italc**
```
total 4
drwxr-xr-x 3 root root 4096 Jul 17 18:19 keys
```
Установлены ключи программы italc.
**./lightdm**
```
total 12
-rw-r--r-- 1 root root 909 Jun 8 13:03 lightdm-gtk-greeter.conf
-rw-r--r-- 1 root root 4536 Jun 8 13:18 lightdm.conf
```
Отключен режим autologin и выполнены дополнительные настройки.
**etc/lightdm/lightdm-gtk-greeter.conf**
```
[greeter]
logo=/usr/share/design/current/icons/large/altlinux.png
background=/usr/share/design/current/backgrounds/default.png
icon-theme-name=gnome
show-language-selector=false
show-indicators=a11y;power
```
**etc/lightdm/lightdm.conf**
```
[LightDM]
minimum-vt=7
user-authority-in-system-dir=true
log-directory=/var/log/lightdm
run-directory=/var/run/lightdm
cache-directory=/var/cache/lightdm
xsessions-directory=/etc/lightdm/sessions
[SeatDefaults]
xserver-command=/usr/bin/X
greeter-hide-users=true
session-wrapper=/etc/X11/Xsession
[XDMCPServer]
[VNCServer]
```
**./net**
```
total 8
drwxr-xr-x 3 root root 4096 Jul 16 12:35 ifaces
-rw-r--r-- 1 root root 1987 Jul 16 12:44 sysctl.conf
```
Выполнена предварительная настройка сетевого интерфейса и фаервола.
**./pam.d**
```
total 4
-rw-r----- 1 root root 237 Aug 24 11:28 reboot
```
**etc/pam.d/reboot**
```
auth required pam_nologin.so
auth sufficient pam_rootok.so
auth sufficient pam_console.so
#auth required pam_deny.so
auth required pam_permit.so
account required pam_permit.so
password required pam_deny.so
```
**./skel**
```
total 16
drwxr-xr-x 8 root root 4096 Jun 8 16:17 Документы
drwxr-xr-x 2 root root 4096 Jun 8 16:17 Загрузки
drwxr-xr-x 2 root root 4096 Jun 8 16:17 Общедоступные
drwxr-xr-x 2 root root 4096 Jun 8 16:17 Рабочий стол
```
В каталоге skel располагаются файлы, выполняющие предварительную настройку среды и программ пользователя.
**./sysconfig:**
```
total 8 -rw-r–r– 1 root root 75 Jun 8 13:11 i18n
```
**etc/sysconfig/i18n**
```
SYSFONT=UniCyr_8x16
LANG=ru_RU.utf8
```
**./systemd**
```
total 8
drwxr-xr-x 5 root root 4096 Aug 20 18:52 system
drwxr-xr-x 2 root root 4096 Aug 20 18:51 user
```
Выполнены настройки служб, запускаемых по умолчанию или отсутствующих в дистрибутиве.
**./xdg**
```
total 4
drwxr-xr-x 2 root root 4096 Jul 17 17:59 iTALC Solutions
```
Программа Italc используется в конфигурации, отличной от первоначальной. Поскольку изменяются много параметров в конфигурационных файлах, конфигурационные файлы были просто размещены в модуле default.
**/etc/xdg/iTALC Solutions/iTALC.conf**
```
[Authentication]
KeyAuthenticationEnabled=1
LogonAuthenticationEnabled=0
LogonGroups="italc-admins,italc-supporters,italc-teachers,italc-students"
PermissionRequiredWithKeyAuthentication=0
PermissionRequiredWithLogonAuthentication=0
PrivateKeyBaseDir=$GLOBALAPPDATA/keys/private
PublicKeyBaseDir=$GLOBALAPPDATA/keys/public
SameUserConfirmationDisabled=0
[DemoServer]
Backend=0
Multithreaded=1
[Logging]
LimittedLogFileSize=0
LogFileDirectory=$TEMP
LogFileSizeLimit=-1
LogLevel=4
LogToStdErr=1
LogToWindowsEventLog=0
[Network]
CoreServerPort=11100
DemoServerPort=11400
FirewallExceptionEnabled=1
HttpServerEnabled=0
HttpServerPort=5800
[Paths]
GlobalConfiguration=$APPDATA/GlobalConfig.xml
PersonalConfiguration=$APPDATA/PersonalConfig.xml
SnapshotDirectory=$APPDATA/Snapshots
[Service]
Arguments=
Autostart=1
HideTrayIcon=0
LockWithDesktopSwitching=1
[VNC]
CaptureLayeredWindows=1
LowAccuracy=1
PollFullScreen=1
```
#### **Скрипты**
При проектировании системы особое внимание уделялось автоматизации администрирования системы, целью которого было снижение трудозатрат на ее последующее сопровождение. С этой целью был создан набор дополнительных скриптов, который можно условно разделить на две категории: скрипты автоматизации обслуживания и администрирования системы и скрипты для создания модулей. Основная часть скриптов обслуживания модулей была описана выше, однако там «за бортом» осталась их библиотечная часть, которая будет рассмотрена здесь.
##### **Дополнения к magos-patches**
Поскольку при промышленной эксплуатации у нас несколько иные задачи и условия использования MagOS, то нужны некоторые средства для автоматизации работы самого ядра MagOS. Приведенные ниже скрипты должны, по идее, быть встроены в MagOS-patches, но сейчас мы их рассматриваем отдельно.
###### ***Стартовые скрипты***
Скрипт /usr/lib/magos/rc.halt/05-update.sh предназначен для автоматического обновления операционной системы при выключении или перегрузке компьютера. Для работы скрипта в конфигурационный файл MagOS.ini добавлено три параметра:
**/usr/lib/magos/rc.halt/05-update.sh**
```
# Выключатель автоматического обновления при выключении: Yes, No
AUTOUPDATE=Yes
# Обновление указанных каталогов при выключении: boot -
UPDATE=AltLinux,boot
# Адрес сервера с которого выполняется обновление по rsync
SRCUPDATE=192.168.1.XXX/magos
```
Здесь: параметр AUTOUPDATE указывает, нужно или нет проводить обновление при выключении питания. UPDATE — перечисление каталогов, для которых должно проводиться обновление.
SRCUPDATE — адрес сервера и репозиторий, с которого проводится обновление. Адрес может задаваться как IP-адрес, или как имя DNS сервера.
Эти же параметры участвуют при установке операционной системы на компьютер пользователя.
Исходный код скрипта:
**/usr/lib/magos/rc.halt/05-update.sh**
```
#!/bin/bash
# Initial script for MagOS-Linux Live operating system
# This script are launching before starting init from linux-live script.
# Current dir always must be set to root (/)
# All system path must be relative, except initrd dirs
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin
ENABLED=yes
. /mnt/live/liblinuxlive
[ -f /etc/sysconfig/MagOS ] && . /etc/sysconfig/MagOS
#. etc/sysconfig/MagOS
[ "$ENABLED" != "yes" ] && exit 0
[ "$AUTOUPDATE" != "Yes" or "$AUTOUPDATE" != "yes" ] && exit 0
[ -z "$UPDATE" -a -z "$SRCUPDATE" ] && exit 0
[ -z "$(grep changes /memory/cmdline)" ] && exit 0
[ -n "$(grep 'from=http:' /memory/cmdline)" ] && exit 0
if ! [ -z "$UPDATE" ] ;then
for dirs in $(echo $UPDATE | tr ',;' ' ') ;do
rsync -azr --delete --exclude=MagOS.ini rsync://$SRCUPDATE/$dirs/ /mnt/livemedia/$dirs/
done
fi
```
Выполнено исправление существующего скрипта /usr/lib/magos/rc.preinit.d/21-ntp, выполняющего настройку NTP сервера. По всей видимости эта часть является зависимой именно от дистрибутива AltLinux, поэтому возможно его исправление в дальнейшем.
**/usr/lib/magos/rc.preinit.d/21-ntp**
```
#!/bin/bash
# Initial script for MagOS-Linux Live operating system
# This script are launching before starting init from linux-live script.
# Current dir always must be set to root (/)
# All system path must be relative, except initrd dirs
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin
ENABLED=yes
[ "$ENABLED" != "yes" ] && exit 0
DEBUGMODE=no
. /liblinuxlive 2>/dev/null || . /mnt/live/liblinuxlive
. /livekitlib 2>/dev/null
debug_mode "$0" "$@"
. etc/sysconfig/MagOS
if ! [ -z "$NTPSERVERS" ] ;then
sed -i s/'^server'/'#server'/ etc/ntp.conf
sed -i s/'^server'/'#server'/ etc/ntpd.conf
for a in $(echo $NTPSERVERS | tr ',;' ' ') ;do
sed -i '/^driftfile/ s/^/server '"$a"\\n/ etc/ntp.conf
grep -q "restrict $a" etc/ntp.conf || echo "restrict $a noquerry notrap" >> etc/ntp.conf
sed -i s/'^#listen on 127.0.0.1'/'listen on 127.0.0.1'/ etc/ntpd.conf
echo "server $a" >> etc/ntpd.conf
done
fi
```
##### **Скрипт установки ОС**
Установка ОС при помощи специального скрипта позволяет достичь единообразия при всех инсталляциях, устранить ошибки техников, выполняющих эту работу и многократно ускорить этот процесс.
Скрипт /usr/share/magos/install/magosinstall.sh является специализированным. Выполняет создание и форматирование разделов жесткого диска. Выполняет копирование разделов репозитория с сервера magos-server на локальные диски компьютера и установку загрузчика ОС.
**/usr/share/magos/install/magosinstall.sh**
```
#!/bin/bash
#
#Usage:
# $1 - source catalog: magos testing
# Default is magos
SRC="magos"
. /etc/sysconfig/MagOS
SRCINI=$(echo $SRCUPDATE | cut -d "/" -f 2)
if ! [ -z "$SRCINI" ];then
SRC=$SRCINI
fi
if ! [ -z "$1" ] ;then
SRC=$1
fi
echo "-------------------------------------------------------"
echo "INSTALL MagOS Altlinux FROM HARD DISK from $SRC !!!"
echo " ========="
echo
echo "Press Enter to continue, or Ctrl+C to abort..."
read junk
clear
swapoff -a
echo "======================================================="
echo "Create parition table."
parted -s /dev/sda mklabel msdos
parted -s /dev/sda mkpart primary ext3 1 30000
parted -s /dev/sda mkpart primary linux-swap 30000 36000
parted -s /dev/sda mkpart primary ext3 36000 100%
parted -s /dev/sda toggle 1 boot
echo "-------------------------------------------------------"
echo "======================================================="
echo "Make file systems on /dev/sda1."
mkfs.ext3 -L system /dev/sda1
echo "Make file systems on /dev/sda2."
mkswap /dev/sda2
echo "Make file systems on /dev/sda3."
mkfs.ext3 -L data /dev/sda3
echo "-------------------------------------------------------"
echo "======================================================="
mkdir /media/system && mount /dev/sda1 /media/system
mkdir /media/data && mount /dev/sda3 /media/data
echo "Syncing instalation data."
for dirs in $(echo $UPDATE | tr ',;' ' ') ;do
srv=$(echo $SRCUPDATE | cut -d '/' -f 1)
if [ "$dirs" != "boot" ] ;then
mkdir /media/system/$dirs
rsync -azr --delete rsync://$srv/$SRC/$dirs/ /media/system/$dirs/
mkdir /media/data/$dirs-Data
rsync -azr --delete rsync://$srv/$SRC/$dirs-Data/ /media/data/$dirs-Data/
else
mkdir /media/system/$dirs
rsync -azr --delete rsync://$srv/$SRC/$dirs/ /media/system/$dirs/
fi
done
rm -rf /media/system/lost+found /media/data/lost+found
cd /media/system/boot/
bash ./Install_MagOS.bat
$(sync)
umount /dev/sda1 && rmdir /media/system
umount /dev/sda3 && rmdir /media/data
echo "-------------------------------------------------------"
echo "Instalation is OK."
echo "please reboot computer."
```
Из текста скрипта Вы видите, что на основной раздел, в который устанавливается ОС, выделено 30Gb, на swap – 6 Gb, а остальное отведено под раздел с данными, включая Changes и Home. Пока не используются переменные, позволяющие выносить эти параметры в конфигурационный файл или, хотя бы, в начало файла.
Путь к скрипту не случайно выбран сложным, это должно препятствовать случайному запуску программы.
##### **Скрипты включения в AD**
Включение компьютера в ADS реализовано по разному в различных операционных системах. AltLinux, для выполнения этой задачи, создали свою программу. Однако ее функционал довольно большой и для упрощения выполнения этой операции были реализованы собственные скрипты. Скриптов два, один выполняет подключение в консольном режиме, второй использует язык TCL и работает в графическом режиме. Рекомендуется пользоваться консольным режимом, хотя графический тоже был протестирован.
После установки операционной системы компьютер имеет hostname=MagOS. При массовой установке компьютеров это критично, тем более, если компьютер включается в AD. Поэтому скрипты решают сразу две задачи: переименование компьютера и включение его в AD.
Небольшое замечание: имя компьютера не определяется в файле MagOS.ini, а заносится при помощи этих скриптов сразу в файл /etc/sysconfig/magos. Все прочие скрипты MagOS, запускаемые при старте операционной системы используют имя компьютера из файла /etc/sysconfig/magos.
**/usr/share/magos/ad\_join/ad\_join.pl**
```
#!/usr/bin/perl -w
# MagOS-linux.ru
# Author M.Fiskov
use strict;
#use Glib qw/TRUE FALSE/;
#use Gtk3 '-init';
my $hostname='';
my $username='';
my $password='';
my $domain='mydomain';
my $realm='mydomain.local';
for (my $i=0;$i<=$#ARGV;$i++){
$_=$ARGV[$i];
(/^--help$/) && do {&usage(); exit 0};
(/^--hostname=/) && do { ($hostname=$ARGV[$i])=~s/^--hostname=//; };
(/^-h$/) && do {$hostname=$ARGV[$i+1];$i++;};
(/^--password=/) && do { ($password=$ARGV[$i]) =~s/^--password=//; };
(/^-p$/) && do {$password=$ARGV[$i+1];$i++;};
(/^--username=/) && do { ($username=$ARGV[$i]) =~s/^--username=//; };
(/^-u$/) && do {$username=$ARGV[$i+1];$i++;};
}
if (open (F1,">/etc/sysconfig/MagOS");
system ($ssed);
system("hostnamectl set-hostname $hostname");
return 1;
}
sub winbind(){
system ("sed -i s/'server string ='/';server string ='/ /etc/samba/smb.conf");
system ("sed -i '/idmap backend = /d' /etc/samba/smb.conf");
my $wsed=sprintf("sed -i \'/\\[global\\]/ s/\$/\\nidmap config $domain : backend = ad\'/ /etc/samba/smb.conf");
system ($wsed);
system ("sed -i '/winbind cache time /d' /etc/samba/smb.conf");
$wsed=sprintf("sed -i \'/\\[global\\]/ s/\$/\\nwinbind cache time = 1440\'/ /etc/samba/smb.conf");
system ($wsed);
}
```
Следует обратить внимание, что имя домена и realm указаны напрямую в скрипте в переменных $domain и $realm. Возможно, это не самое правильное решение…
**/usr/share/magos/ad\_join/ad\_join\_x.pl**
```
#!/usr/bin/perl -w
# MagOS-linux.ru
# Author M.Zaripov
# No testing
use strict;
use Glib qw/TRUE FALSE/;
use Gtk3 '-init';
#standard window creation, placement, and signal connecting
my $window = Gtk3::Window->new('toplevel');
$window->signal_connect('delete_event' => sub { Gtk3->main_quit; });
$window->set_border_width(5);
$window->set_position('center_always');
#this vbox will geturn the bulk of the gui
my $vbox = &ret_vbox();
#add and show the vbox
$window->add($vbox);
$window->show();
#our main event-loop
Gtk3->main();
sub ret_vbox {
my $vbox = Gtk3::VBox->new(FALSE,5);
$vbox->pack_start ("Gtk3::Label"->new (" Please input password to join into domain "), 0, 0, 0);
# create table with 2 entries
my $table1 = Gtk3::Table->new (5, 2, FALSE);
my $t1l0 = Gtk3::Label->new_with_mnemonic("Domain: ");
$t1l0->set_alignment (0, 0);
$table1->attach_defaults ($t1l0, 0, 1, 0, 1);
my $t1e0 = Gtk3::Entry->new();
$table1->attach_defaults ($t1e0, 1, 2, 0, 1);
my $t1l0 = Gtk3::Label->new_with_mnemonic("workgroup: ");
$t1l0->set_alignment (0, 0);
$table1->attach_defaults ($t1l0, 0, 1, 1, 2);
my $t1e1 = Gtk3::Entry->new();
$table1->attach_defaults ($t1e0, 1, 2, 1, 2);
my $t1l0 = Gtk3::Label->new_with_mnemonic("computer name: ");
$t1l0->set_alignment (0, 0);
$table1->attach_defaults ($t1l0, 0, 1, 2, 3);
my $t1e2 = Gtk3::Entry->new();
$table1->attach_defaults ($t1e0, 1, 2, 2, 3);
my $t1l1 = Gtk3::Label->new_with_mnemonic("Domain Admin User Name: ");
$t1l1->set_alignment (0, 0);
$table1->attach_defaults ($t1l1, 0, 1, 3, 4);
my $t1e3 = Gtk3::Entry->new();
$table1->attach_defaults ($t1e1, 1, 2, 3, 4);
my $t1l2 = Gtk3::Label->new_with_mnemonic("Domain Admin Password: ");
$t1l2->set_alignment (0, 0);
$table1->attach_defaults ($t1l2, 0, 1, 4, 5);
my $t1e4 = Gtk3::Entry->new();
$t1e2->set_visibility (FALSE);
$table1->attach_defaults ($t1e2, 1, 2, 4, 5);
$vbox->pack_start($table1, 0, 0 ,0);
#$vbox->pack_end(Gtk3::HSeparator->new(),0, 0 ,0);
# create table with 2 buttons
my $table2 = Gtk3::Table->new (1, 2, FALSE);
my $t2b1 = Gtk3::Button->new ('Join');
$table2->attach_defaults ($t2b1, 0, 1, 0, 1);
my $t2b2 = Gtk3::Button->new ('Cancel');
$table2->attach_defaults ($t2b2, 1, 2, 0, 1);
$t2b2->signal_connect (clicked => sub { Gtk3->main_quit; });
if (open (F1,"signal_connect (clicked => sub { &addname($t1e2->get_text())
|| system("system-auth write ad ".$t1e0->get_text().'%'.$t1e0->get_text()." ".#domain
$t1e2->get_text().'%'.$t1e2->get_text()." ".# hostname
$t1e1->get_text().'%'.$t1e1->get_text()." ".# workgroup
$t1e3->get_text().'%'.$t1e3->get_text()." ".# username
$t1e4->get_text().'%'.$t1e4->get_text()."\"") # password
|| system("systemctl restart nmb")
|| system("systemctl restart winbind")
|| system("systemctl restart smb")
|| exit (1); });
}else{
$t2b1->signal_connect (clicked => sub { &addname($t1e2->get_text()) #hostname
|| system("net join -U \"".
$t1e3->get_text().'%'. # username
$t1e4->get_text()."\"") # password
|| system("systemctl restart nmb")
|| system("systemctl restart winbind")
|| system("systemctl restart smb")
|| exit (1); });
}
$vbox->pack_start($table2, 0, 0 ,0);
$vbox->show_all();
return $vbox;
}
sub addname (){
my ($hostname)=@_;
system ("sed -i '/netbios name =/d' /etc/samba/smb.conf");
my $ssed=sprintf("sed -i \'/\\[global\\]/ s/\$/\\n netbios name = ".$hostname."\'/ /etc/samba/smb.conf");
system ($ssed);
system ("sed -i '/HOSTNAME/d' /etc/sysconfig/MagOS");
$ssed=sprintf("echo \"HOSTNAME=$hostname\" >>/etc/sysconfig/MagOS");
system ($ssed);
system("hostnamectl set-hostname $hostname");
return 1;
}
```
Поскольку есть операция ввода компьютера в домен, то должна быть и операция вывода из домена. Но в случае MagOS в этом нет необходимости, поскольку для этого достаточно просто удалить соответствующие файлы в Changes.
###### ***Исправление проблем AD***
У нас после подключения компьютера к ADS обнаружилась такая проблема: после загрузки компьютера winbind достаточно долго выполняет заполнение кэшей с информацией об AD, включая списки пользователей и группы. При этом он может зависнуть и по своему внутреннему расписанию перезапуститься, но на это может уходить много времени — до получаса. Проблема может быть связана с организацией внутренней структуры AD, а может и быть общей для всех реализаций. Известно только, что в достаточно пустой базе AD проблем не возникает. Однако у нас такая проблема была и для ее решения был изобретен приведенный ниже «костыль».
Опытным путем было выявлено, что решить проблему помогает перезапуск winbind после обнаружения им домена AD. Поэтому приведенная ниже программа запускается в качестве службы через systemd, мониторит обнаружение winbind домена, после чего выполняет рестарт winbind и завершает работу. Задержка составления списка пользователей, в этом случае, составляет 1 — 2 минуты. Если пользователь не очень быстро вводит свое имя и пароль, то он, практически, не замечает существования этой проблемы.
На этот же скрипт возложена еще одна функция — обновление системных файлов домашних папок пользователей AD, поскольку существующие в magos-patches скрипты обновляют домашнюю папку только одного пользователя, указанного в MagOS.ini — администратора системы, а обновление папок виртуальных пользователей не предусмотрено вообще. Скрипт выполняет копирование отсутствующих в домашних папках доменных пользователей скрытых системных файлов и каталогов из папки /etc/skel и назначение им прав хозяина папки. Таким образом, для обновления настроек в домашних папках пользователей нужно удалить соответствующие файлы и перегрузить службу скриптом winbind-restart. Необходимым условием корректности работы является отсутствие регистрации пользователей в системе в указанный момент.
Однако, следует заметить, что работа скрипта, как службы обновления настроек пользователей компьютеров нуждается в доработке.
**/usr/sbin/winbind-restart**
```
#!/bin/bash
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin
while [ "$(wbinfo --online-status | grep -i mydomain | cut -d ":" -f 2)" != " online" ]
do
$(sleep 1)
done
$(systemctl restart winbind)
. etc/sysconfig/MagOS
# update home folders from domain users
if [ "$UPDATEHOME" = "yes" ] ;then
DOMAIN=$(wbinfo --own-domain)
if [ -d home/$DOMAIN ] ;then
for LISTUSER in $(ls -1 home/$DOMAIN/); do
$(cp -rHun etc/skel/.[a-zA-Z0-9]* home/$DOMAIN/$LISTUSER/)
$(chown -R $LISTUSER:пользователи\ домена home/$DOMAIN/$LISTUSER/)
done
fi
fi
```
**/etc/systemd/user/winbindrestart.service**
```
[Unit]
Description=Samba Winbind Daemon restart from mydomain
After=winbind.target
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/sbin/winbind-restart
[Install]
WantedBy=multi-user.target
```
##### **Управление системой (/root/bin)**
Эти скрипты предназначены для управления системой MagOS на основе дистрибутива AltLinux при промышленном применении.
Если по каким-либо причинам требуется принудительное обновление ОС, то применяются два нижеследующих скрипта. Первый из них выполняет обновление операционной системы, второй обновление конфигурационного файла MagOS.ini.
Скрипт принудительного обновления операционной системы /root/bin/updatemagos.sh. После выполнения операции следует автоматическая перегрузка операционной системы.
**/root/bin/updatemagos.sh**
```
#!/bin/bash
echo "Update MagOS from Hard Disk to this computer!!!"
echo
echo "Press Enter to continue, or Ctrl+C to abort..."
read junk
clear
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin
SRC=192.168.1.XXX/magos
DEFAULT="AltLinux,boot"
. /mnt/live/liblinuxlive
[ -f /etc/sysconfig/MagOS ] && . /etc/sysconfig/MagOS
[ -z "$UPDATE" -a -z "$SRCUPDATE" ] && UPDATE=$(echo "$DEFAULT") && SRCUPDATE="$SRC"
if ! [ -z "$UPDATE" ] ;then
for dirs in $(echo $UPDATE | tr ',;' ' ') ;do
rsync -azr --delete rsync://$SRCUPDATE/$dirs/ /mnt/livemedia/$dirs/
done
fi
reboot
```
**/root/bin/updateini.sh**
```
#!/bin/bash
# This script getting file MagOS.ini from magos server to this computer
SRCI="magos-server/magos"
SRC="magos"
srv="magos-server"
. /etc/sysconfig/MagOS
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin
echo "Update MagOS.ini from Hard Disk!!!"
[ -z "$SRCUPDATE" ] && SRCUPDATE="$SRCI"
SRCINI=$(echo $SRCUPDATE | cut -d "/" -f 2)
[ -n "$SRCUPDATE" ] && srv=$(echo $SRCUPDATE | cut -d '/' -f 1)
if ! [ -z "$SRCINI" ];then
SRC=$SRCINI
fi
if ! [ -z "$1" ] ;then
SRC=$1
fi
rsync -az rsync://$srv/$SRC/AltLinux/modules/i586/MagOS.ini /mnt/livemedia/AltLinux/modules/i586/MagOS.ini
```
/root/bin/mnt.sh — достаточно простой вспомогательный скрипт подключения диска с данными пользователей и сохранениями операционной системы.
**/root/bin/mnt.sh**
```
#!/bin/sh
# mount data disk from /srv
mount /dev/sda3 /srv
#groupadd -g 501 magos
#groupadd -g 502 testing
```
Скрипты loadupdate и saveupdate предназначены для загрузки на тестовую машину скриптов генерации модулей и оригиналов модулей с сервера MagOS и последующей их выгрузки на сервер после внесения в них каких либо изменений.
**/root/bin/saveupdate.sh**
```
#!/bin/bash
#
# This script save update folder from this computer to magos server
# Fiskov M.M.
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin
ENABLED=yes
[ "$ENABLED" != "yes" ] && exit 0
. /usr/lib/magos/scripts/liblinuxlive
. /etc/sysconfig/MagOS
. /mnt/livemedia/update/conf/devel.conf
PWD=$(echo $(pwd))
cd /mnt/livemedia/update
mkdir /root/tmp/update
cp -r /mnt/livemedia/update/{*.sh,lib,conf} /root/tmp/update/
for files in $(echo $(ls 9*.sh| cut -d '.' -f 1)) ;do
cp /mnt/livemedia/$DISTNAME/modules/$ARCH/$files.xzm /root/tmp/update/
done
cd /root/tmp
tar -czf /mnt/livemedia/update.tar.gz ./update
cd /mnt/livemedia/
scp /mnt/livemedia/update.tar.gz $USER@$SERVER:/var/www/$DISTTYPE/
rm -rf /root/tmp/update
cd $PWD
```
**/root/bin/loadupdate.sh**
```
#!/bin/bash
#
# This script load update folder from magos server to this computer
#
export PATH=.:/:/usr/sbin:/usr/bin:/sbin:/bin:/usr/lib/magos/scripts
ENABLED=yes
[ "$ENABLED" != "yes" ] && exit 0
PWD=$(echo $(pwd))
. /etc/sysconfig/MagOS
rsync -az rsync://$SRCUPDATE/update.tar.gz /mnt/livemedia/update.tar.gz
cd /mnt/livemedia/
tar -xzf update.tar.gz
cd /mnt/livemedia/update
for files in $(echo $(ls 9*.sh| cut -d '.' -f 1)) ;do
mkdir $files
xzm2dir $files.xzm $files
done
cd $PWD
```
###### ***Скрипты обслуживания ОС***
В процессе обслуживания операционной системы возникают задачи массового обслуживания компьютеров, например выполнения команд на всех компьютерах сразу. Один из вариантов решения такой задачи — параллельный доступ на компьютеры по протоколу ssh и запуск там соответствующей команды. Скрипт hostalt-create.sh не является универсальным, он предназначен для составления списка компьютеров, на которых установлен MagOS на основе сборки AltLinux. Для обнаружения компьютеров они должны иметь наименование, заканчивающееся на «-a». Список компьютеров является сохраняемым, что позволяет его постепенно расширять.
В целом данное решение нельзя назвать полноценным, поскольку выполнение операции осуществляется только для включенных компьютеров. Во вторых, применение скриптов требует настройки sudo с выполнением заданий без пароля.
В качестве имени пользователя, при помощи которого выполняется доступ к компьютерам применяется учетная запись администратора, в сборках AltLinux таковой является учетная запись alttlinux.
**/root/bin/hostalt-create.sh**
```
#!/bin/sh
# create list from hostalt file from programm pssh
$(nmap 192.168.1.0/24 -p T:8080 2>&1 | grep "mydomain" | grep '\-a' | cut -d " " -f 5 >> /tmp/hostalt1)
$(sort -u /tmp/hostalt1 > hostalt)
```
**/root/bin/parallelssh.sh**
```
#!/bin/sh
# parallelssh.sh sudo /root/bin/updateini.sh
echo "parallelssh.sh <\"command\"> "
echo "parallelssh.sh sudo \"/root/bin/updateini.sh\" "
echo
[ -z "$2" ] && exit
sshpass -p $2 pssh -x "-o StrictHostKeyChecking=no" -h hostalt -l altlinux -A -i $1 2>&1 > /tmp/ssherr.txt
cat /tmp/ssherr.txt
```
###### ***Скрипты управления созданием модулей***
Скрипты управления созданием модулей предназначены для автоматизации создания пользовательских модулей и их размещения на magos-server.
Скрипты представляют собой комплекс программ, содержащий конфигурационный файл и libexec библиотеки скриптов, автоматизирующие процесс и, собственно, самих скриптов, выполняющих сборку модулей, чистку полученных модулей от мусора и настойку программ модулей.
Скрипты и конфигурационный файл располагаются в корневом каталоге диска, но могут помещаться в любое удобное место. Обязательное условие — файловая система, на которой они располагаются должна поддерживать Unix ACL, т. е. должна быть Posix совместимой.
Конфигурационный файл системы сборки модулей /update/conf/devel.conf.
```
DISTTYPE="testing"
DISTNAME="AltLinux"
ARCH="i586"
UPDETESRV=yes
SERVER=192.168.0.3
USER=altlinux
```
Здесь:
**DISTTYPE** — указывает на каталог репозитория magos-server.
**DISTNAME** — Название каталога дистрибутива.
**ARCH** — Архитектура системы.
Все три указанных выше параметра определяют путь в котором должна находиться папка с модулями на сервере и в компьютере.
**UPDETESRV** — выполнять или нет автоматическое обновление репозитория сервера. SERVER — адрес или URL сервера magos-server.
**USER** — имя пользователя magos-server, имеющего права на запись в репозиторий. В домашней папке этого пользователя должны быть созданы симлинки на соответствующие папки репозиториев.
Пример скрипта создания модуля:
**/update/99-u50-example.sh**
```
#!/bin/sh
. conf/devel.conf
NAME=`echo $0 | sed 's/\.\///'| sed 's/\..*//'`
. lib/mv.sh $NAME
epm2xzm $NAME -i 'ntpdata samba'
rm -rf $NAME
mkdir $NAME
xzm2dir $NAME.xzm $NAME
#-------------------------------------------
# Конфигурирование установленных пакетов
cp /usr/share/zoneinfo/Asia/Krasnoyarsk $NAME/etc/localtime
cp /etc/nsswitch.conf $NAME/etc/nsswitch.conf
sed -i s/'^hosts: files mdns4_minimal \[NOTFOUND=return\]*'/'hosts: files dns mdns4_minimal \[NOTFOUND=return\] myhostname f
#--------------------------------------------
. lib/delhlam.sh $NAME
dir2xzm $NAME $NAME.xzm
. lib/update.sh $NAME
```
Скрипт, вызываемый из собственно скрипта создания модуля, выполняющий очистку мусора, оставшегося после сборки модуля командой epm2xzm.
**/update/lib/delhlam.sh**
```
#!/bin/sh
NAME=$1
rm -rf $NAME/etc/urpmi $NAME/var/cach/ldconfig $NAME/var/cach/ldconfig/ $NAME/var/cache/ldconfig/ $NAME/var/lib/apt $NAME/var/log/rpmpk
gs
rm -f $NAME/etc/ld.so.cache $NAME/etc/resolv.conf
rm -f $NAME/etc/xinetd.conf $NAME/etc/group- $NAME/etc/gshadow- $NAME/etc/passwd-
```
Скрипт отключает модуль c настройками и делает резервную копию старого модуля.
Технология резервирования модулей следующая: мы руками переименовываем модули, которые собираемся менять, добавляя расширение .bak. В последующем мы можем несколько раз запускать скрипт создания модуля, исправляя возникшие ошибки. Каждый раз предыдущая версия модуля будет переименовываться и будет получать расширение .old. После завершения работы ненужные копии нужно будет удалить.
**/update/lib/mv.sh**
```
#!/bin/sh
NAME=$1
. conf/devel.conf
if [ $NAME != "99-u99-default" ] ;then
$(sh /usr/lib/magos/scripts/deactivate $NAME.xzm)
fi
if [ -f /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm.bak ] && [ -f /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm ] ;then
$(mv -nf /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm $NAME.xzm.old)
fi
```
Скрипт переносит модуль в каталог modules и копирует его в сетевой репозиторий. Устанавливает права доступа и выполняет переподключение модуля.
**/update/lib/update.sh**
```
#!/bin/bash
NAME=$1
. conf/devel.conf
if [ ! -f /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm.bak ] ;then
$(mv /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm.bak)
fi
$(mv $NAME.xzm /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm)
$(chmod 664 /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm)
$(chown :root /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm)
if [ $NAME != "99-u99-default" ] ;then
$(sh /usr/lib/magos/scripts/activate $NAME.xzm)
else
$(sh /usr/lib/magos/scripts/deactivate $NAME.xzm)
$(sh /usr/lib/magos/scripts/activate $NAME.xzm)
fi
[ "$UPDETESRV" != "yes" ] && exit 0
$(scp /mnt/livemedia/$DISTNAME/modules/$ARCH/$NAME.xzm $USER@$SERVER:~/$DISTTYPE/$DISTNAME/modules/$ARCH/)
```
##### **Дополнительные скрипты, исправляющие работу программ magos и операционной системы**
В MagOS не совсем верно реализован механизм подключения папок /tmp и /var/tmp в файловую систему tmpfs. Имеется Unit systemd для подключения /tmp в файловую систему tmpfs, однако он не включен. Для его включения выполнено размещение символической ссылки в каталоге /etc/systemd/system/local-fs.target.wants:
```
tmp.mount -> /lib/systemd/system/tmp.mount
var-tmp.mount -> ../var-tmp.mount
```
Unit var-tmp.mount просто не реализован. MagOS же при включении опции VARTMPFS делает символьную ссылку /var/tmp → /tmp. Для сервера печати CUPS это не допустимо, поэтому соответствующий unit приходится реализовывать самостоятельно.
**/etc/systemd/system/var-tmp.mount**
```
[Unit]
Description=Temporary Directory
Documentation=man:hier(7)
Documentation=http://www.freedesktop.org/wiki/Software/systemd/APIFileSystems
DefaultDependencies=no
Conflicts=umount.target
Before=local-fs.target umount.target
[Mount]
What=tmpfs
Where=/var/tmp
Type=tmpfs
Options=mode=1777,strictatime
```
Unit для подключения каталога /var/tmp в файловую систему tmpfs.
**/etc/systemd/system/ntp-units.d/ntpd.service**
```
[Unit]
Description=Network Time Service
After=syslog.target network.target
[Service]
EnvironmentFile=/etc/sysconfig/ntpd
ExecStart=/usr/sbin/ntpd -d $NTPD_ARGS
[Install]
WantedBy=multi-user.target
```
#### **Инструкция для техников**
Установка Alt Linux в режиме MagOS:
* Выбрать в bios загрузку из сети.
* Загрузить AltLinux.
* Зарегистрироваться пользователем «altlinux» используя пароль по умолчанию.
* Если требуется сохранение данных пользователей, то подключиться к сети и сохранить данные в сеть. Все данные на жестком диске будут уничтожены!
* Открыть консоль.
* Получить права администратора:
```
$ su -
Password:
```
При вводе пароля символы не отображаются. Это нормально. Используется пароль, принятый по умолчанию для сети mydomain:
* Выполнить команду:
```
# /usr/share/magos/install/magosinstall.sh
```
* Для установки системы придется трижды нажать клавишу «Enter». Имеется возможность отказаться от установки на первом этапе, нажав ^C.
* Перегрузить компьютер. Если перегрузки не происходит, то выполнить аппаратный сброс.
* Зайти в среду пользователя под пользователем altlinux.
* Открыть консоль.
* Получить права администратора, как было описано выше.
* Ввести компьютер в домен при помощи команды:
```
# /usr/share/magos/ad_join/ad_join.pl -h -u -p
```
Где:
**hostname** — Имя компьютера. Одновременно производится переименование компьютера.
**username** — Имя администратора домена mydomain.local.
**password** — Пароль администратора домена mydomain.local.
При правильном выполнении команды будет написано:
```
Joined 'Имя компьютера' to dns domain 'mydomain.local'
```
На прочие сообщения можно не обращать внимание.
* Проверить подключение компьютера к домену:
```
# wbinfo -u
```
Системе требуется некоторое время для кэширования сетевых ресурсов, поэтому первый вход в домен может быть произведен с задержкой в несколько минут. Это зависит от загрузки сети.
В результате выполнения команды будут выведен список всех пользователей домена.
* Перегрузить компьютер.
* Зарегистрироваться на компьютере при помощи учетной записи пользователя домена.
* Подключить сетевые ресурсы, для этого открыть файловый браузер, в нем открыть сетевой ресурс, например «новый\_диск» на боковой вкладке. Ввести пароль пользователя.
Выбрать переключатель «Запомнить навсегда». В противном случае пользователю придется вводить пароль после каждого нового входа на компьютер.
* Восстановить данные пользователя на компьютере.
* Отключить сетевую загрузку в bios компьютера.
###### ***Вынос ярлыков на рабочий стол***
На нужной программе щелкнуть правой кнопкой мыши. Отправить ярлык на рабочий стол. При необходимости открыть свойства ярлыка и вписать необходимые параметры.
***Авторы: Горошкин Антон Николаевич, Фисков Михаил Михайлович.*** | https://habr.com/ru/post/270337/ | null | ru | null |
# Яндекс.Пробки: получаем области покрытия пробками + альтернативный пробочный гаджет
 Не так давно Яндекс стал отдавать данные о пробках для большого количества других регионов, кроме Москвы, Питера, Киева и Екатеринбурга. [Как разместить слой с пробками на своей карте](http://habrahabr.ru/blogs/webdev/86857/) я писал ранее. Сегодня разберемся как можно получить список регионов, в которых обрабатываются пробки.
У Яндекс.Пробок наряду с [trf.maps.yandex.net/trf/stat.js](http://trf.maps.yandex.net/trf/stat.js) есть еще [trf.maps.yandex.net/trf/coverage.js](http://trf.maps.yandex.net/trf/coverage.js). Этот скрипт рассказывает нам, какие регионы покрыты данными о пробках (ну или хотя бы такая информация поддерживается).
> `YMaps.TrafficLoader.onLoad(
>
> "coverage",
>
> {
>
> regions: (function(){
>
> function p(x,y){
>
> return new YMaps.GeoPoint(x,y);
>
> }
>
> function b(l,b,r,t){
>
> return new YMaps.GeoBounds(p(l,b),p(r,t));
>
> }
>
> return [
>
> {
>
> name:"Москва и Московская область",
>
> regionId:"1",
>
> view:{
>
> point:p(37.620070,55.753630),
>
> boundedBy:b(36.61977492,55.3105725984,38.35467432,56.4313303008)
>
> },
>
> boundedBy:b(35.14318524,54.2560801359,40.20433848,56.9613240948)
>
> }
>
> ];
>
> })()
>
> }
>
> );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Если сделать все выполняемые преобразования, на входе получается вот такой объект:
> `return {
>
> regions: [
>
> {
>
> name:"Москва и Московская область",
>
> regionId:"1",
>
> view:{
>
> point: YMaps.GeoPoint(37.620070,55.753630),
>
> boundedBy: YMaps.GeoBounds(36.61977492,55.3105725984,38.35467432,56.4313303008)
>
> },
>
> boundedBy: YMaps.GeoBounds(35.14318524,54.2560801359,40.20433848,56.9613240948)
>
> }
>
> ];
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Снова используется YMaps.TrafficLoader. Данные приходят в виде объекта с полем regions, в котором содержится массив объектов. Каждый объект имеет одинаковый набор полей:
* name — название области или города;
* regionId — какой-то ID. он же присутствует в выдаче stat.js;
* view: область просмотра, view.point — объект типа [YMaps.GeoPoint](http://api.yandex.ru/maps/jsapi/doc/ref/reference/geopoint.xml) — центр области, удобно использовать вместе с [YMaps.Map.setCenter(geoPoint)](http://api.yandex.ru/maps/jsapi/doc/ref/reference/map.xml#setCenter) для перехода к нужной области, view.boundedBy — [YMaps.GeoBounds](http://api.yandex.ru/maps/jsapi/doc/ref/reference/geobounds.xml) — прямоугольник, ограничивающий область покрытия;
* boundedBy — аналогично view.boundedBy.
По результатам «исследований» сделал Windows Sidebar Widgets с пробками в любом городе, который сейчас поддерживается Яндексом. Не такой крутой как оригинальный, но зато позволяет смотреть карту прямо в виджете без открытия самого сайта.
[Загрузить виджет для Windows Sidebar «Другие Яндекс.Пробки»](http://widgets.elifantiev.ru/widgets/roadcams/winGadget/traffic.gadget) | https://habr.com/ru/post/87294/ | null | ru | null |
# Состоялся новый релиз Kubernetes-платформы Deckhouse — v1.26.0
Новая стабильная версия Deckhouse — [v1.26.0](https://github.com/deckhouse/deckhouse/releases/tag/v1.26.0) — включает почти 60 изменений, исправлений и улучшений. Это второе по счету крупное обновление платформы [Deckhouse](https://github.com/deckhouse/deckhouse) с момента ее [публичного релиза](https://habr.com/ru/company/flant/blog/569840/) в июле.
Важные изменения и новые модули
-------------------------------
**Настройка механизма обновлений.** Теперь можно выбирать временные окна обновлений, в которые Deckhouse будет автоматически переходить на новый релиз. Для группы узлов можно указывать отдельные окна, если обновление требует перезагрузки (disruptive update). Обновлять Deckhouse можно и вручную. Patch-версии (v1.26.1, v1.26.2, …), как и прежде, будут обновляться сами по мере появления.
**Соответствие CIS Benchmarks.** В компоненты Deckhouse внесены изменения для того, чтобы платформа соответствовала [рекомендациям Center for Internet Security (CIS)](https://www.cisecurity.org/benchmark/kubernetes/) по обеспечению безопасности в Kubernetes. Например, появилась возможность использовать права на файлы и каталоги, указывать сетевые привязки только к нужным интерфейсам, запретить анонимный доступ и т. д.
Также платформа пополнилась двумя новыми модулями:
* [**pod-reloader**](https://deckhouse.io/ru/documentation/v1/modules/465-pod-reloader/) автоматически перезапускает определенные Deployment, DaemonSet или StatefulSet при изменении объектов Secret и ConfigMap;
* [**local-path-provisioner**](https://deckhouse.io/ru/documentation/v1/modules/031-local-path-provisioner/) упрощает работу с local storage: модуль создает `StorageClass` и формирует необходимую структуру каталогов на узлах.
Улучшения
---------
Всего в этом релизе 27 улучшений в различных модулях и компонентах. Среди них:
* **node-manager** (модуль, который отвечает за управление узлами) получил множество улучшений. Например, [валидацию](https://github.com/deckhouse/deckhouse/commit/e71f491003e2e90048ecca2fe0b5df661b75bb04) taint для `NodeGroups`. Также теперь [можно указывать](https://github.com/deckhouse/deckhouse/commit/bb116d590e989f766e062db41e2904f682a428e4) нулевое значение `.spec.cloudInstances.standby` в параметрах NodeGroup'ы, если standby-узлы не требуются;
* в **cloud-provider-aws** (модуль для взаимодействия с ресурсами AWS) добавлена [схема размещения WithNAT](https://deckhouse.io/ru/documentation/v1/modules/030-cloud-provider-aws/layouts.html#withnat), при которой виртуальные машины используют общий source IP;
* в **deckhouse** (отвечает за набор активных модулей, настройку логирования и обновления) Helm-логи теперь [пишутся](https://github.com/deckhouse/deckhouse/commit/b120745d9443c36bd2b08b723b2f3bb51d137c15) с помощью регистратора logrus, [повышена](https://github.com/deckhouse/deckhouse/commit/5b2e5be26a9bd3fd5d531e237423e877f2c7e951) скорость обновления Deckhouse и [добавлена](https://github.com/deckhouse/deckhouse/commit/8fd8fe3ab1011577b92b1e1789ba1c2d8ed40d9a) liveness-проба;
* в **global** (работа с хуками) [появились](https://github.com/deckhouse/deckhouse/commit/9377142a6a9c4e2f0d9d3a6676f510b4ea9fcd27) метрики для определения максимально возможного количества узлов в кластере. Они высчитываются на основе значений `podSubnetCIDR` и `podSubnetNodeCIDR`. Когда количество узлов превышает 90% от допустимого максимума, срабатывает алерт;
* в **istio** (интеграция с одноименной Service Mesh) [добавлена](https://github.com/deckhouse/deckhouse/commit/a7846eb19a6fe0beec40b7ce1fa39d073cf94967) поддержка `ingressGateway` для мультикластеров;
* модуль **descheduler** (вытеснение «лишних» Pod’ов) теперь отключается в кластере, состоящем из одного узла;
* в **operator-prometheus** [добавлен](https://github.com/deckhouse/deckhouse/commit/6bf656d9dc84bb01e188268e3c6210d98a217523) хук валидации `CustomPrometheusRules` и обновлена версия самого оператора до v0.50.0;
* кодовая база мигрировала на Go 1.16.
**В документацию** Deckhouse добавлены:
* [таблица](https://deckhouse.io/ru/documentation/v1/revision-comparison.html) с детальным сравнением функциональности двух редакций Deckhouse;
* [список](https://deckhouse.io/ru/documentation/v1/supported_versions.html) поддерживаемых версий Kubernetes и операционных систем;
* [инструкция](https://deckhouse.io/ru/gs/vsphere/step2.html) по быстрой установке Deckhouse на VMware vSphere.
Более полный список изменений, представленных в Deckhouse v1.26.0, можно найти [здесь](https://github.com/deckhouse/deckhouse/releases/tag/v1.26.0).
P.S.
----
Официальный Twitter-аккаунт проекта (на английском) — [@deckhouseio](https://twitter.com/deckhouseio), русскоязычный Telegram-чат — [deckhouse\_ru](https://t.me/deckhouse_ru).
Читайте также в нашем блоге:
* «[Первый major-релиз addon-operator для Kubernetes — v1.0.0. Стабильные Go-хуки и не только](https://habr.com/ru/company/flant/news/t/584402/)»;
* «[Kubernetes-платформа Deckhouse сертифицирована в CNCF](https://habr.com/ru/company/flant/news/t/571538/)»;
* «[Представляем Kubernetes-платформу Deckhouse. Теперь в Open Source и для всех](https://habr.com/ru/company/flant/blog/569840/)». | https://habr.com/ru/post/589223/ | null | ru | null |
# Подсветка синтаксиса в Ruby
В проектах, ориентированных на IT аудиторию время от времени возникает задача подсветки синтаксиса исходных файлов. Недавно, я захотел посмотреть как эта задача решается в Ruby.
Для Ruby существует решение [CodeRay](http://coderay.rubychan.de/) которое позволяет подсвечивать синтаксис на стороне сервера для следующих языков:
* Ruby
* С
* Delphi
* HTML
* RHTML (Rails)
* Nitro-XHTML
* CSS
* Diff
* Java
* JavaScript
* JSON
* YAML
Процесс подсветки происходит на стороне сервера, поэтому не загружает клиента (если используются web-технологии, типа Ruby On Rails), а также возможна разработка отдельных утилит (например, консольных), для создания html файлов с подсвеченным кодом.
Рассмотрим небольшой пример работы с CodeRay и напишем небольшое консольное приложение, которое будет создавать подсветку для заданного Ruby файла.
Для начала установим CodeRay простой командой
`gem install coderay`
После этого напишем саму программу (ее придумывал не я сам, поэтому сохраню ее, так сказать, в первозданном, нетронутом виде)
`#!/usr/bin/env ruby
# courtesy: Helder
# obvio171.wordpress.com/2007/06/03/colorful-ruby-code-for-your-blog
# modified to output to stdout so can be used as a filter
# 2008-09-03 23:22
require 'rubygems'
require 'coderay'
if ARGV.length != 1
puts "Wrong number of arguments. Use: codecolor.rb "
exit
end
rb\_file = File.expand\_path(ARGV[0])
print CodeRay.encode(
File.read(rb\_file),
:ruby,
:html,
:line\_numbers => :inline,
:hint => :info,
:css => :style,
:wrap => :div
)`
Разберем эту простую программу по порядку: сначала мы подключаем модуль coderay, чтобы иметь доступ к интересующим нас классам. После этого проверяем количесто аргументов командной строки и извлекаем имя файла из первого аргумента. Далее идет самая важная часть нашей программы — использование ф-ии CodeRay.encode, которой мы передаем следующие аргументы:
* подсвечиваемый текст
* язык, синтаксис которого мы подсвечиваем
* формат выходных данных
* стиль отображения номеров строк
* формат дополнительных подсказок, к подсвеченному коду
* способ подключения стилей (может быть :class или :style)
* способ обертки элементов
А теперь попросим созданную нами программу подсветить саму себя. Для этого выполним такую команду
`ruby codecolor.rb > test.html`
После чего у нас появится файл test.html (который можно открыть любым браузером), содержащий подсвеченный вариант программы codecolor.rb.
Собственно, вот и все, что нужно знать при использовании генератора подсветки кода в Ruby. Для более подробного изучения CodeRay советую посетить [официальный сайт](http://coderay.rubychan.de/) | https://habr.com/ru/post/48614/ | null | ru | null |
# Настройка push-нотификаций для своего сервиса
В этой публикации мы рассмотрим пример интеграции платформы подписки на push-уведомлений [PushAll](https://pushall.ru/) с [сервисом мониторинга сайтов ХостТрекер](http://www.host-tracker.com). Эта информация будет полезна тем, кому необходимо быстро настроить push для своих сервисов, а желания изобретать велосипед нет.
#### В чем же дело?
Вопрос скорее риторический. [Ранее](https://habrahabr.ru/company/host-tracker/blog/320690/) мы опубликовали детальный обзор методов оповещений, которые использует ХостТрекер при фиксировании ошибок на сайтах клиентов. В нем была ссылка на [конкретные исследования](https://ain.ua/2015/12/14/komu-i-zachem-nuzhny-push-uvedomleniya), которые вроде бы говорили нам, что push-уведомления в нашем случае не так актуальны. Тем не менее, запросы клиентов — прежде всего. К тому же, нашелся легкий способ их настроить.
#### Каждому — по Push-у
Итак, благодаря сервису PushAll есть возможность легко прикрутить пуш к чему бы то ни было. Рассмотрим наш пример. Нам любезно создали [микросервис](https://pushall.ru/host-tracker), который принимает POST-запрос и рассылает push-уведомления. Ну а далее уже дело техники. В нашем случае нужно слать запрос на URL:
`https://pushall.ru/channels/host-tracker/callback.php?uid=47920&key=0cfd2f05b7442aeb988a326f7adadb06`
а шаблоны POST-запросов для разных случаев (падение и восстановление работы сайтов) у нас уже есть:
Ниже также можно сделать тестовый запрос или поставить задержку уведомлений, если они нужны только для длительных падений сайтов.
То есть, если необходимо получать уведомления о состоянии сайтов (аптайм, падения, обновления домена или сертификата, попадание в списки Роскомнадзора и т.д.) по Push — тогда три клика и готово. Если нужно прикрутить push к своему сервису — PushAll также предоставит вам такую возможность. Чтобы три клика и готово.
И, кстати, это еще один пример того, как ХостТрекер развивается благодаря клиентским запросам. Вряд ли кто-то знает лучше самих клиентов что им надо. Поэтому, если возникнут вопросы, пожелания или критика — всегда рады! | https://habr.com/ru/post/334038/ | null | ru | null |
# Offline-first приложение с Hoodie & React. Часть первая: браузерная база данных
Современный веб позволяет решать часть задач которые раньше были прерогативой нативных мобильных приложений. Мы с вами создадим веб-приложение (сайт) которое будет загружаться и сохранит полную функциональность даже в отсутствии интернета, а при его появлении автоматически синхронизируется с сервером. На мобильном устройстве для такого приложения достаточно создать ярлык и в плане автономности мы получим аналог нативного приложения.
Мы напишем подобие todo-листа, с одним отличием: "выполненные" задачи будут не удаляться, а переноситься в конец списка и по мере решения остальных задач всплывать вверх. Такой список удобно использовать для повторяющихся вещей, таких как различные спортивные активности, развлечения, еда и т.п. Одна моя социально-реализованная знакомая использует его, чтобы равномерно поддерживать контакт с многочисленной популяцией своей френдзоны.
То, что получится в результате можно [посмотреть тут](https://action-loop.com/). Попробуйте внести некоторые изменения, закрыть вкладку, отключить интернет и снова открыть сайт. Вы обнаружите, что он открывается и сохраняет полную функциональность. Если вы залогинитесь на разных устройствах и внесёте изменения в оффлайне, по восстановлении соединения изменения синхронизируются интуитивно ожидаемым образом.
Вы удивитесь насколько мало кода нам потребуется для реализации этого функционала.
Часть 0: настройка окружения
----------------------------
Чтобы не засорять текст очередными настройками вебпака, я создал [репу](https://github.com/imbolc/action-loop) с готовыми настройками. Просто склонируйте её и переключитесь на часть 0: `git checkout part0`. Ключевые точки на которые стоит обратить внимание:
* `npm start` — запускает hoodie-сервер и сборку приложения вебпаком в режиме watch (пересборки при изменении)
* `public/index.html` — именно то, что вы подумали, тут мы создаём корневой div приложения и подключаем собранный вебпаком бандл
* `src/index.js` — точка входа в приложение, тут мы рендерим корневую компоненту: `ReactDOM.render(`
* `src/App.js` — наша пока единственная компонента, тут мы и начнём писать код в следующей части
Попробуйте запустить сервер. Когда вебпак скажет, что всё готово, по адресу <http://localhost:8000/> вы должны увидеть симпатичную шапку сайта.
Часть 1: браузерная бд
----------------------
Для функционирования приложения в оффлайн-режиме, нам потребуется где-то хранить данные и как-то синхронизировать их между устройствами. [Pouchdb](https://pouchdb.com/) подходит для этого идеально. Но мы и с ней будем работать не напрямую а через обёртку [Hoodie](http://docs.hood.ie/camp/), которая умеет авторизацию. Давайте подключим её в `src/App.js`:
```
import Hoodie from '@hoodie/client'
const hoodie = new Hoodie()
```
### Добавление документа в базу
Теперь создадим компоненту для добавления loop-а (отдельного todo-листа):
**AddLoop.js**
```
import React from 'react'
import TextField from 'material-ui/TextField'
import RaisedButton from 'material-ui/RaisedButton'
export default class AddLoop extends React.Component {
constructor(props) {
super(props)
this.state = {
title: ''
}
}
handleTitleChange = (e) => this.setState({title: e.target.value})
handleSubmit = (e) => {
e.preventDefault()
this.props.store.add({
type: 'loop',
title: this.state.title
})
this.setState({title: ''})
}
render() {
return (
);
}
}
```
Суть здесь заключена в строчке `this.props.store.add`. Где `store` — это `hoodie.store` который нам нужно передать в свойствах компоненты при рендеренге её в `App.js`:
```
render() {
...
```
### Чтение базы данных
Давайте теперь отобразим сохранённые в базу документы. В `App.js` мы добавим метод `loadLoops`:
```
constructor(props) {
super(props);
this.state = {
loops: []
};
this.loadLoops();
}
loadLoops = () => {
hoodie.store.findAll(doc => doc.type == 'loop')
.then(loops => this.setState({loops}))
}
```
Нам понадобился конструктор, в котором мы инициализируем `state` и инициируем загрузку документов. В `hoodie.store.findAll` мы передаём фильтр для нужных документов и получаем промис, в котором просто записываем полученные документы в `state`.
Давайте теперь отрисуем их, добавив в `render()`:
```
{this.state.loops.map(loop => (
### {loop.title}
))}
```
Теперь вы должны видеть список добавленных loop-ов. Однако при добавлении новых они появятся в списке только при перезагрузке страницы. Давайте исправим это.
### Подписка на изменения бд
Весь код этого пункта будет состоять из добавления пары строчек в наш `App.js`:
```
componentDidMount() {
hoodie.store.on('change', this.loadLoops);
}
```
Теперь при добавлении loop-ов они будут автоматически появляться в списке. Причём независимо от того, каким образом изменилась база данных. **Это важно** — даже если изменения произошли в ходе синхронизации с другим устройством, наш коллбэк сработает.
### Почему React
Из логики работы с бд становится понятно почему среди обилия браузерных шаблонизаторов был выбран реакт. В ответ на каждое изменение бд мы будем просто перезагружать всё состояние. И будь на месте реакта любимый мной vue.js он перерендерил бы весь dom. А это не просто медленно, представьте вы заполняете форму и в этот момент другое устройство инициирует изменение бд — форма перерисована, ваши изменения потеряны. Тогда как реакт с его виртуальным dom аккуратно перерисует изменившиеся детали и даже фокуса в вашей форме не собьёт.
### Конец
Сегодня мы научились взаимодействовать с браузерной бд. В следующей части мы настроим серверную бд и прикрутим авторизацию. Буду рад любым вашим замечаниям / исправлениям / пожеланиям. Код этой части доступен тут: <https://github.com/imbolc/action-loop> под тегом `part1`. | https://habr.com/ru/post/309166/ | null | ru | null |
# Управляем Windows Server (Core) с помощью веб-интерфейса Project Honolulu от Microsoft
Совсем недавно Microsoft выпустила WebUI для управления Windows Server. Мы поставили его и хотим поделиться впечатлениями.
В этой статье мы рассказали и показали:
* как развернуть Honolulu на Windows Server Core и сделать доступным управление серверным парком через браузер;
* как подключить другие серверы для управления (даже без AD) по виртуальной локальной сети облака (таким же образом можно подключить серверы в локальной сети вашего предприятия к центру управления в облаке, соединив ее по Site-To-Site VPN);
* какие возможности Honolulu доступны уже сейчас и актуальны при использовании в облаке.
#### Зачем Windows Server веб-интерфейс управления?
В облаке серверы должны работать максимально эффективно для снижения затрат на ИТ-инфраструктуру. Windows Server с графическим интерфейсом создавался еще во времена, когда от единственного сервера требовалось выполнение всех возможных операций, даже если эта функциональность не требовалась в настоящий момент.
Позже в Windows Server были добавлены роли, позволяющие устанавливать только требуемую функциональность. При этом устанавливался графический интерфейс и многочисленные службы, не требующиеся для решения бизнес-задачи. Это порождало накладные расходы вычислительных ресурсов и увеличивало поверхность атаки, делая сервер менее безопасным.
В целях дальнейшей оптимизации серверной ОС Microsoft добавила режим Server Core – минималистичную, эффективную и более безопасную редакцию Windows Server с режимом командной строки по-умолчанию. В этой ОС минимизированы накладные расходы на все, что не связано с выполнением вашей задачи.
Совсем недавно Microsoft представила Windows Server 1709 — ОС рекомендуемую для современных облачных приложений и сервисов. Эта ОС не содержит графического интерфейса, получает существенные обновления раз в полгода развиваясь непрерывно и поставляется только в виде Server Core и Nano Server.
Если вы ранее откладывали изучение и использование Server Core, пришло время. Традиционное управление Windows Server с помощью графического интерфейса Windows постепенно уходит в прошлое. Microsoft оставила ИТ-администраторов не только с Powershell, но и представила новое современное средство управления серверами с помощью веб-интерфейса — **Project Honolulu**. Следует заметить, что пока это не релиз, а техническое превью. К стабильности доступных возможностей вопросов за время использования не возникало, но очевидно, что в будущем возможностей будет гораздо больше.
Project Honolulu можно использовать не только с Windows Server Core, но и с серверами с графическим интерфейсом (2012, 2012R2, 2016), получив удобный способ управления ИТ-инфраструктурой на Windows.
#### Установка Project Honolulu на сервер
[Project Honolulu](https://www.microsoft.com/en-US/evalcenter/evaluate-windows-server-honolulu) можно установить не только на сервер, но и на компьютер IT–администратора с Windows 10. Однако удобнее установить средства управления прямо на сервер в облаке (даже если у вас там только одна виртуальная машина) и управлять серверами через удобный веб-интерфейс с любых устройств из любой точки мира (или откуда разрешают политики безопасности компании). При наличии подключения Site-To-Site VPN из вашего офиса можно работать по безопасному подключению даже не предоставляя доступ серверам из сети Интернет.
##### Где попробовать Honolulu?
Если вы хотите попробовать проделать все, что описано в статье дальше, настроить Project Honolulu в облаке и самостоятельно посмотреть на его возможности, нет проблем.
[Заполните заявку](https://infoboxcloud.ru/request/) на бесплатное тестирование, выберите платформу Azure Pack Infrastructure, в поле «Комментарий» укажите «С хабра, хочу протестировать Honolulu».
Для вас будет предсоздана бесплатно облачная инфраструктура на 2 недели, в которой вы сможете попробовать новый веб-интерфейс управления Honolulu, а заодно и протестировать высокодоступное облако [Azure Pack Infrastructure](http://repository.sandbox.infoboxcloud.ru/docs/azurepack/%D0%9E%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5%20%D0%BF%D1%80%D0%BE%D0%B4%D1%83%D0%BA%D1%82%D0%B0%20Azure%20Pack%20Infrastructure.pdf) от [InfoboxCloud](https://infoboxcloud.ru).
##### Создание сервера для установки Honolulu (и не только)
В панели управления [portal.infoboxcloud.com](https://portal.infoboxcloud.com) [создадим](https://infoboxcloud.ru/community/blog/azurepack/397.html) (если еще не созданы) сеть и сервер с Windows Server 2016 Core (на момент публикации Windows Server 1709 готовится к выходу и будет доступен с конца октября 2017 года).
Теперь нужно пробросить порт 3389 для доступа по RDP.
Подключитесь к серверу по RDP, используя выданный ip–адрес при настройке правила проброса.
Запустите
```
powershell
```
##### Установка Project Honolulu
*Для использования с Windows Server 2012 и 2012 R2 предварительно нужно установить [Windows Management Framework 5](https://www.microsoft.com/en-us/download/details.aspx?id=50395).*
Скачайте Project Honolulu, выполнив команды:
```
Import-Module BitsTransfer
Start-BitsTransfer -Source http://download.microsoft.com/download/E/8/A/E8A26016-25A4-49EE-8200-E4BCBF292C4A/HonoluluTechnicalPreview1709-20016.msi -Destination .
```
Aктуальную ссылку на последнюю версию можно получить [зарегистрировавшись тут](https://www.google.ru/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0ahUKEwi-9Jv5rNTWAhWqF5oKHYCcCOUQFggpMAA&url=https%3A%2F%2Fwww.microsoft.com%2Fen-US%2Fevalcenter%2Fevaluate-windows-server-honolulu&usg=AOvVaw065hLwMFtq4bZHb6YHCTUR), рекомендуется подставить ее в параметр *-Source*.
Запустите установку с самоподписанным сертификатом:
```
msiexec /i HonoluluTechnicalPreview1709-20016.msi /qn /L*v log.txt SME_PORT=6516 SSL_CERTIFICATE_OPTION=generate
```
, где HonoluluTechnicalPreview1709-20016.msi — имя загруженной версии Honolulu.
или с указанием THUMBPRINT сертификата, если он у вас есть и установлен:
```
msiexec /i HonoluluTechnicalPreview1709-20016.msi /qn /L*v log.txt SME_PORT=6516 SME_THUMBPRINT= SSL\_CERTIFICATE\_OPTION=installed
```
, где HonoluluTechnicalPreview1709-20016.msi — имя загруженной версии Honolulu.
Теперь в настройках сети в [portal.infoboxcloud.ru](https://portal.infoboxcloud.ru) пробросьте порт 6516 на сервер.
Можем заходить на сервер через веб-интерфейс:
```
https://ip–адрес-сервера:6516
```
, где ip–адрес-сервера — IP адрес сервера, к которому происходит подключение. Браузер может предупредить о том, что используется самоподписанный сертификат. Следует продолжить вход на страницу.
В качестве логина и пароля указываются данные для доступа к учетной записи на сервере (те же, с которыми подключаетесь по RDP).
Отлично, установка Honolunu выполнена.
Текущий сервер уже добавлен.
Необходимо нажать на «Credentials Needed» и указать данные администратора для этого сервера:
Сервер доступен для управления.
#### Подключение дополнительных серверов
Создайте еще сервер в [панели управления Azure Pack Infrastructure](https://portal.infoboxcloud.com) и пробросьте доступ к нему по RDP в настройках сети.
Подключитесь к **новому серверу**.
##### На новом сервере
Запустите:
```
powershell
```
Выполните настройку удаленного подключения WinRM. Для этого введите
```
winrm quickconfig
```
затем нажмите «y» и Enter.
Разрешите доступ к WinRM в файрволле:
Для этого введите команду:
```
netsh advfirewall firewall add rule name="Open Port Remote Management (5985)" dir=in action=allow protocol=TCP localport=5985
netsh advfirewall firewall add rule name="Open Port Remote Management (5986)" dir=in action=allow protocol=TCP localport=5986
```
##### На сервере где установлен Honolulu
В терминале введите команду для добавления управляемого сервера в Trusted Hosts используя его внутренний IP:
```
winrm s winrm/config/client '@{TrustedHosts="10.0.0.5,containers"}'
```
, где containers – имя управляемого сервера.
*Если в будущем потребуется добавить еще серверы, их все нужно добавлять в Trusted Hosts, например:
```
winrm s winrm/config/client '@{TrustedHosts="10.0.0.5,containers,10.0.0.3,web"}'
```*
Теперь в веб-интерфейсе Honolulu добавьте сервер:
Укажите внутренний IP (можно посмотреть в настройках сети в панели управления Azure Pack Infrastructure), логин и пароль и нажмите «Submit».
Готово. Сервером можно управлять из единой панели Honolulu.
*В случае использования Active Directory в Trusted Hosts добавлять друг друга не требуется, как и постоянно вводить данные для доступа к серверам в Honolulu. Также при добавлении можно использовать имена из DNS. В этом случае они будут отображаться не по IP, а по названию сервера, что удобно.*
#### Возможности Project Honolulu
Цель проекта — заменить GUI средства управления сервером (RSAT) и сделать доступ к управлению группам администраторов более удобным, из любой точки мира. Цель благородна, инфраструктуры заказчиков становятся более гетерогенны, а RSAT был зависим от платформы. Теперь не очень важно какая ОС у ИТ-администратора — управление с альтернативных ОС так же удобно, как и управление из Windows альтернативными платформами (с помощью Linux Subsystem for Windows).
Для управления конкретным сервером нажмите на него:
##### Обзор сервера (Overview)
В этом разделе вы можете:
* в режиме онлайн получать информацию о загруженности сервера и сети,
* редактировать имя компьютера,
* вводить его в домен,
* управлять переменными окружения пользователя и системными
* включать и отключать доступ по RDP
##### Сертификаты (Certificates)
Возможность просмотра и загрузки сертификатов, позволяет своевременно узнать о необходимости обновления сертификатов.
##### Устройства (Devices)
Можно посмотреть детальную информацию о виртуальном оборудовании и используемых драйверах.
При необходимости можно отключать устройства.
##### События (Events)
Возможность просмотра и экспорта системных логов и логов приложений. Позволяет своевременно заметить и починить проблему.
##### Файлы (Files)
Веб-интерфейс проводника. Позволяет скачивать, загружать файлы на сервер, переименовывать и менять их свойства.
##### Файрвол (Firewall)
Удобный веб-интерфейс для управления Файрволлом Windows Server.
##### Локальные пользователи и группы (Local Users & Groups)
Все очевидно — возможность добавлять и редактировать пользователей и группы, а также менять пароли.
##### Сеть (Network)
Возможность просмотра и изменения настроек сетевых адаптеров.
##### Процессы (Processes)
Статистика по запущенным процессам, потреблению ресурсов, возможность убить процесс и собрать дамп для анализа.
##### Реестр (Registry)
Полноценный редактор реестра с Web–интерфейсом для Windows с возможностью импорта и экспорта ветвей реестра.
##### Роли и возможности (Roles and Features)
Возможность просмотра установленных ролей и возможностей ОС, установка и настройка новых.
Отмечаем нужную для установки и нажимаем «Install». Процесс установки привычен и понятен.
##### Сервисы (Services)
Возможность включить или выключить сервис Windows вручную и настроить правила автозапуска.
##### Хранилище (Storage)
Возможности разметки дисков, управление разделами и файловыми шарами.
Также присутствует раздел Storage Replica, требующий предварительной настройки SR Namespace.
##### Windows Update
Возможность просмотра и установки доступных обновлений сервера.
#### Заключение
Project Honolulu – работоспособное техническое превью. Конечно очень не хватает возможности настройки ролей и функций прямо из веб-интерфейса (а не только установки и удаления), не хватает встроенного в панель RDP, возможностей исполнять Powershell команды на серверах из этого же веб-интерфейса и отправки уведомлений на email и/или pushover.
Возможность удаленного управления откуда угодно через Powershell мы рассмотрим в одной из следующих статей.
Тем не менее уже сейчас Project Honolulu – мощное средство управления парком Windows Server в облаке и в локальной сети заказчика (а лучше — в единой гибридной сети), которое значительно упростит работу с Windows Server Core новичкам и подготовит их к новому и прекрасному миру «безголового» Windows Server.
Успехов. | https://habr.com/ru/post/339372/ | null | ru | null |
# Детектирование дампа памяти процесса LSASS. SOC наносит ответный удар
Привет, я [@Gamoverr](/users/gamoverr), работаю аналитиком угроз в Angara Security. А теперь к делу!
Angara SOC спешит дополнить [статью наших коллег из RedTeam](https://habr.com/ru/company/angarasecurity/blog/661341/) по разбору методик дампа памяти процесса LSASS. Мы рассмотрим эту тему со стороны защиты и методик детектирования данной активности. С помощью каких инструментов выявлять нежелательный доступ к учетным данным, и как это использовать для оперативного реагирования.
Небольшой ликбез
Злоумышленники могут абузить особенности [**Local Security Authority Subsystem Service**](https://attack.mitre.org/techniques/T1003/001/) (LSASS), сдампив учетные данные для повышения привилегий, кражи данных или горизонтального перемещения по инфраструктуре. Все зависит от того, чью учетную запись удалось украсть: администратора домена, администратора бизнес-системы или обычного пользователя.
Процесс LSASS всегда так сладок для злоумышленников и является одной из их первых целей из-за огромного количества конфиденциальной информации, которую он хранит в памяти.
А хранится в нем следующее:
* Зашифрованные пароли,
* NT-хэши,
* LM-хэши,
* Билеты Kerberos
Доступ к данной информации можно получить, обладая привилегиями **SEDebugPrivilege**, обычно имеющимися у локального администратора. Это уже усложняет задачу атакующему.
Для обращения к памяти LSASS, как мы ранее с вами узнали, существует довольно-таки большое количество методов и инструментов, но, несмотря на это, можно выделить две большие подгруппы:
* Встроенные инструменты (уже присутствующие в ОС Windows, это могут быть вполне легитимные процессы и тулзы);
* Кастомные инструменты злоумышленников.
Бегло рассмотрим примеры таких инструментов из обеих подгрупп без детального разбора атаки с их помощью.
**The Windows Task Manager** (taskmgr.exe) — диспетчер задач позволяет осуществить дамп произвольного процесса, если он запущен в привилегированном режиме. Действие заключается в простом щелчке правой кнопкой мыши по нужному процессу и выбору пункта меню «Создать файл дампа».
**Windows DLL Host** (rundll32.exe) — rundll позволяет запустить встроенную библиотеку Windows comsvcs.dll, которая экспортирует функцию, называемую MiniDump. При вызове данной функции, злоумышленник может подать в качестве параметра PID процесса LSASS и создать его дамп памяти.
Преступники часто используют сторонние программы двойного назначения. Например, средства от Sysinternals: **Procdump, Process Explorer**.
К инструментам, созданными злоумышленниками, можно отнести:
* Mimikatz
* Cobalt Strike
* Impacket
* Metasploit
* PowerSploit
* Empire
* Pwdump
* Dumpert
* Lazagne
* nanodump
На данном этапе не будем углубляться, как работает каждый из инструментов или какую технику он использует. В дальнейшем при обзоре детектов, если они будут базироваться на той или иной особенности, то постараемся разобраться и в ней.
### Источники событий
Основным источником событий может служить коммерческий EDR, позволяющий отслеживать создание процессов, их командные строки, доступ к процессам, создание файлов. Или открытые решения, такие как Sysmon. Ну и, конечно, журнал Security ОС Windows для узкого круга детектов.
Ниже приведу пример конфигурации Sysmon для детектов, рассматриваемых в данной статье
```
\lsass.exe
false
\dbghelp.dll
\dbgcore.dll
\msbuild.exe
\cmd.exe
\rundll32.exe
\powershell.exe
\word.exe
\excel.exe
\powerpnt.exe
\outlook.exe
\monitoringhost.exe
\wmic.exe
\bash.exe
\wscript.exe
\cscript.exe
\mshta.exe
\regsvr32.exe
\schtasks.exe
\dnx.exe
\regsvcs.exe
\sc.exe
\scriptrunner.exe
c:\windows\system32\lsass.exe
dbghelp.dll
dbgcore.dll
C:\Windows\system32\lsass.exe
0x1FFFFF
C:\Windows\system32\lsass.exe
0x1F1FFF
C:\Windows\system32\lsass.exe
0x1010
C:\Windows\system32\lsass.exe
0x143A
C:\Windows\system32\lsass.exe
0x1438
C:\Windows\system32\lsass.exe
0x40
C:\Windows\system32\lsass.exe
0x1418
C:\Windows\system32\lsass.exe
0x1410
C:\Windows\system32\lsass.exe
0x1010
C:\Windows\system32\lsass.exe
0x13fff
C:\Windows\system32\lsass.exe
0x705
C:\Windows\system32\lsass.exe
C:\Windows\system32\wsmprovhost.exe
.dmp
lsass
\SYSTEM\CurrentControlSet\Control\Lsa\Security Packages
\SYSTEM\CurrentControlSet\Control\Lsa\OSConfig\Security Packages
```
Раз уже коснулись темы Sysmon, то начнем с него.
Сами детекты описаны с помощью синтаксиса проекта Sigma, по [ссылке](https://github.com/SigmaHQ/sigma/wiki/Specification) можно с ним ознакомиться.
**Создание процессов (Sysmon**[**EventID 1**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-1-process-creation)**или Windows Seсurity**[**EventID 4688**](https://docs.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4688)**)**
Есть несколько сценариев, которые позволяют использовать события создания процессов в обнаружении подозрительной активности процесса LSASS или над ним.
Процесс LSASS редко создает дочерние процессы в легитимных целях. Таким образом, отслеживая события создания процессов, где родительским является LSASS, можно выявить технику закрепления через изменение конфигурации LSA Password Filters, Security Packages или Authentication Packages:
```
logsource:
category: process_create
product: sysmon
detection:
selection:
ParentImage: 'C:\Windows\System32\lsass.exe'
TerminalSessionId: '0'
winlog.event_data.User:
- 'NT AUTHORITY/SYSTEM'
- 'NT AUTHORITY/СИСТЕМА'
condition: selection
tags:
- attack.t1068
- attack.t1003.001
- attack t1547.002
- attack t1547.005
- attack t1547.008
- attack t1556.002
```
Другой возможный вариант — анализ командных строк при запуске процессов. Это позволяет, например, выявлять специфичные ключи программ (Mimikatz, Pypykatz, CQTools, comsvcs.dll и rundll32 и т.д.)
Пример детекта для Pypykatz по ключевым словам:
```
logsource:
category: process_create
product: sysmon
detection:
selection_common:
CommandLine|contains: 'pypykatz'
CommandLine|contains: ' dcc2 -i'
CommandLine|contains: ' gppass '
selection_live:
CommandLine|contains: ' live '
CommandLine|contains:
- ' lsa'
- ' registry'
- ' kerberos'
- ' share'
- ' session'
- ' localgroup'
- ' dpapi'
- ' ldap'
- ' smb'
- ' process'
- ' token'
- ' users'
selection_lsa:
CommandLine|contains: ' lsa '
CommandLine|contains:
- ' minidump'
- ' rekall'
selection_registry:
CommandLine|contains: ' registry '
CommandLine|contains:
- ' --sam'
- ' --security'
- ' --software'
selection_kerberos:
CommandLine|contains: ' kerberos '
CommandLine|contains:
- ' tgt'
- ' tgs'
- ' brute'
- ' asreproast'
- ' spnroast'
- ' s4u'
- ' keytab'
- ' ccache'
- ' kirbi'
selection_dpapi:
CommandLine|contains: ' dpapi '
CommandLine|contains:
- ' prekey'
- ' minidump'
- ' masterkey'
- ' asreproast'
- ' credential'
- ' vcred'
- ' vpol'
- ' securestring'
- ' blob'
selection_ldap:
CommandLine|contains: ' ldap '
CommandLine|contains: ' ldap://'
selection_smb:
CommandLine|contains: ' smb '
CommandLine|contains:
- ' console'
- ' lsassfile'
- ' lsassdump'
- ' regfile'
- ' regdump'
- ' dcsync'
- ' secretdump'
condition: selection_common or selection_live or selection_lsa or selection_registry or selection_kerberos or selection_dpapi or selection_ldap or selection_smb
tags:
- attack.t1003
- attack.t1098
- attack t1552.001
- attack t1207
- attack t1550.002
- attack t1150.003
- attack t1552.004
- attack t1547.005
- attack t1134.005
```
Обнаружение использования утилиты mimikatz по ключевым словам:
```
logsource:
category: process_create
product: sysmon
detection:
selection:
CommandLine|contains:
- 'mimikatz'
- 'mimilib'
- '.3 eo.oe'
- 'eo.oe.kiwi'
- 'privilege..debug'
- 'sekurlsa..logonpasswords'
- 'lsadump..sam'
- 'mimidrv.sys'
- ' p::d'
- ' s::l'
- ' rpc..server'
condition: selection
tags:
- attack.t1003
- attack.t1098
- attack t1552.001
- attack t1207
- attack t1550.002
- attack t1150.003
- attack t1552.004
- attack t1547.005
- attack t1134.005
```
Ниже представлен набор детектов для разлиных утилит и средств, с помощью которых можно получить дамп учетных данных из различных источников, в том числе LSASS:
```
logsource:
category: process_create
product: sysmon
detection:
selection_shadow:
CommandLine|contains: 'shadowcopy'
CommandLine|contains: 'create'
Image|endswith:
- '\powershell.exe'
- '\powershell_ise.exe'
- '\pwsh.exe'
selection_vssadmin:
Image|endswith: '\vssadmin.exe'
CommandLine|contains: 'shadow'
CommandLine|contains:
- 'list'
- 'create'
- 'delete'
- 'resize'
selection_ntds_sam:
CommandLine|contains:
- '\windows\ntds\ntds.dit'
- '\system32\config\sam'
- '\system32\config\security'
- '\system32\config\system'
selection_mklink:
CommandLine|contains: 'mklink'
CommandLine|contains: 'HarddiskVolumeShadowCopy'
selection_ntdsutil:
Image|endswith: '\ntdsutil.exe'
CommandLine|contains: 'ntds'
CommandLine|contains: 'create'
CommandLine|contains: 'full'
selection_reg:
CommandLine|contains: 'reg'
CommandLine|contains:
- 'e\?port'
- '\?ave'
CommandLine|contains:
- 'hk.m..y.tem'
- 'hk.m..am'
- 'hk.m..ecurity'
- 'hkey_.oca._machine..y.tem'
- 'hkey_.oca._machine..am'
- 'hkey_.oca._machine..ecurity'
selection_sqldumper:
Image|endswith: '\SqlDumper.exe'
CommandLine|contains: 'SqlDumper.exe* 0 *'
selection_tttracer:
Image|endswith: '\tttracer.exe'
CommandLine|contains: ' -dumpFull*-attach '
selection_1:
CommandLine|contains: '-Target'
CommandLine|contains: '-Hash'
CommandLine|contains: '-Username'
CommandLine|contains:
- 'Invoke-TheHash'
- 'Invoke-SMBEnum'
- 'Invoke-WMIExec'
- 'Invoke-SMBExec'
selection_2:
CommandLine|contains: 'Invoke-SMBClient'
CommandLine|contains: '-Hash'
CommandLine|contains: '-Username'
selection_3:
CommandLine|contains: 'crackmapexec'
CommandLine|contains: '-H '
CommandLine|contains: '-u '
selection_4:
CommandLine|contains: 'wmiexec'
CommandLine|contains: '-hashes'
selection_5:
CommandLine|contains: 'psexec'
CommandLine|contains: '-hashes'
selection_6:
CommandLine|contains: 'vaultcmd'
CommandLine|contains: '/list'
selection_7:
CommandLine|contains: 'RdrLeakDiag'
CommandLine|contains: '/fullmemdmp'
selection_8:
CommandLine|contains: 'diskshadow'
CommandLine|contains: '/s '
condition: selection_shadow or selection_vssadmin or selection_ntds_sam or selection_mklink or selection_ntdsutil or selection_reg or selection_sqldumper or selection_tttracer or selection_*
tags:
- attack.t1003.001
- attack.t1003.002
- attack.t1003.003
- attack.t1003.004
- attack.t1003.005
```
Обнаружение признаков запуска бинарных файлов утилит CQTools. Данные утилиты могут использоваться злоумышленниками для извлечения и декодирования паролей ОС Windows. В состав также входят утилиты для генерации пейлода, сниффинга, спуффинга, кейлоггеры и т.д.
```
logsource:
category: process_create
product: sysmon
detection:
selection_CL:
CommandLine|contains:
- 'cqtools'
- '--samdump'
- '--dccdump'
- '--sam='
- '--sec='
- '--sys='
- '--newmsdcc='
- '--pass='
- '--bootkey='
- '--kdsrootkeyfile'
- '--golden='
- '--masterkeyfile='
- '--exe='
selection_PC:
Image|endswith:
- '\CQLsassSecretsDumper.exe'
- '\CQCat.exe'
- '\CQCreateProcessWithParent.exe'
- '\CQDPAPIBlobDecrypter.exe'
- '\CQDPAPIBlobSearcher.exe'
- '\CQDPAPIEncDec.exe'
- '\CQFindBin.exe'
- '\CQHashesCalc.exe'
- '\CQImpersonate.exe'
- '\CQMasterKeyDecrypt.exe'
- '\CQMasterKeyEncrypt.exe'
- '\CQMSGDecode.exe'
- '\CQRDCManDecrypter.exe'
- '\CQRegKeyLastWriteTime.exe'
- '\CQRegKeyLastWriteTime_32.exe'
- '\CQRegTool.exe'
- '\CQReverseShellGen.exe'
- '\CQRunInAppContainer.exe'
- '\CQSecretsDumper.exe'
- '\CQSymbolInstaller.exe'
- '\CQArpSpoof.exe'
- '\CQDPAPIKeePassDBDecryptor.exe'
- '\ETWKeylogger.exe'
- '\CQHashDumpv2.exe'
- '\PfxRegenerator.exe'
- '\CQPrefetchParser.exe'
- '\CQRdcache.exe'
- '\CQWSLMonitor.exe'
condition: selection_CL or selection_PC
tags:
- attack.t1003
- attack.t1040
- attack.t1555.003
```
Использование встроенной в Windows библиотеки comsvcs.dll
```
logsource:
category: process_create
product: sysmon
detection:
selection_CL:
CommandLine|contains:
- 'comsvcsMiniDumpfull'
- 'comsvcsMiniDumpWfull'
selection_PC:
Image|endswith:
- '\Windows\powershell.exe'
- '\Windows\powershell_ise.exe'
- '\Windows\pwsh.exe'
- '\psexec.exe'
- '\psexec64.exe'
- '\Windows\cscript.exe'
- '\Windows\wscript.exe'
- '\Windows\mshta.exe'
- '\Windows\regsvr32.exe'
- '\Windows\wmic.exe'
- '\Windows\certutil.exe'
- '\Windows\rundll32.exe'
- '\Windows\cmstp.exe'
- '\Windows\msiexec.exe'
- '\Windows\*\cmd.exe'
condition: selection_CL or selection_PC
tags:
- attack.t1059
- attack.t1003.001
- attack.t1218.011
```
**Загрузка драйвера (Image loaded: Sysmon**[**Event ID 6**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-6-driver-loaded)**)**
Позволяет детектировать загружаемые в систему драйверы. Что дает возможность отследить, например, загрузку собственного драйвера утилитой Mimikatz.
Mimikatz и использовать функции режима ядра через включенный в его состав драйвер Mimidrv. Через драйвер доступны некоторые функции Windows, которые нельзя вызывать из пользовательского режима, такие как изменение атрибутов запущенных процессов и непосредственное взаимодействие с другими загруженными драйверами.
```
logsource:
category: driver_loaded
product: sysmon
detection:
selection:
Signed: false
ImageLoaded|contains: mimidrv
condition: selection
tags:
- attack.t1003
```
**Загрузка модуля процесса (Image loaded: Sysmon**[**Event ID 7**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-7-image-loaded)**)**
Событие логирует загрузка модуля (например, DLL библиотеки) в определенный процесс. Данный функционал позволяет отследить злоупотребление DLL библиотеками для дампа учетных данных.
Например, можно детектировать загрузку ранее упомянутых библиотек dbghelp/dbgcore DLL нетипичными процессами:
```
logsource:
category: image_load
product: sysmon
detection:
selection:
ImageLoaded|endswith:
- '\dbghelp.dll'
- '\dbgcore.dll'
Image|endswith:
- '\msbuild.exe'
- '\cmd.exe'
- '\rundll32.exe'
- '\word.exe'
- '\excel.exe'
- '\powerpnt.exe'
- '\outlook.exe'
- '\monitoringhost.exe'
- '\wmic.exe'
- '\bash.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\schtasks.exe'
- '\dnx.exe'
- '\regsvcs.exe'
- '\sc.exe'
- '\scriptrunner.exe'
condition: selection
tags:
- attack.t1003.001
- attack.t1059
```
Или загрузка любой не подписанной библиотеки LSASS
```
logsource:
category: image_load
product: sysmon
detection:
unsigned_dll:
Signed: 'FALSE'
Image|endswith: '\lsass.exe'
condition: unsigned_dll
tags:
- attack.t1003
- attack.t1059
```
**Создание потока (CreateRemoteThread: Sysmon**[**Event ID 8**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-8-createremotethread)**)**
Событие CreateRemoteThread определяет, когда процесс создает поток в другом процессе. Этот метод используется вредоносными программами для внедрения кода и скрытия в других процессах.
Данным образом можно отследить, когда вредоносный процесс запускает поток в контексте lsass.exe (SamSs-Service) и выгружает запрошенные учетные данные из этого потока.
```
logsource:
category: create_remote_thread
product: sysmon
detection:
selection:
TargetImage|endswith: '\lsass.exe'
condition: selection
tags:
- attack.t1003
```
**Доступ к памяти процесса (Process creation: Sysmon**[**Event ID 10**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-10-processaccess)**)**
Cобытия доступа к процессу предлагают одно из лучших средств для обнаружения злоупотребления доступа к памяти LSASS. Но в тоже время достаточно сложно отсеять легитимные события, так как большое количество процессов имеют вполне себе законные причины для доступа к памяти LSASS. В правиле собраны наиболее подозрительные флаги, которые были замечены при обкатке тулзов для дампа памяти (Mimikatz, pypykatz, nanodump, lazagne, и т.д.). Также оно позволяет обнаружить использование таких безобидных средств, как Task Manager, procdump, Process Monitor, Process Hacker.
```
logsource:
category: process_access
product: sysmon
detection:
selection_1:
GrantedAccess:
- 0x1FFFFF
- 0x1F1FFF
- 0x1438
- 0x143a
- 0x40
- 0x1418
- 0x1410
- 0x1010
- 0x13fff
- 0x705
selection_2:
CallTrace|Contains: 'dbghelp'
CallTrace|Contains: 'dbgcore'
selection_3:
TargetImage: 'C:\Windows\system32\lsass.exe'
condition: selection_3 and (selection_1 or selection_2)
tags:
- attack.t1003
```
Или, например, с помощью данного события можно «отлавливать» факты использования злоумышленником [Mimikatz через WinRM](https://pentestlab.blog/2018/05/15/lateral-movement-winrm/):
```
logsource:
category: process_access
product: sysmon
detection:
selection:
TargetImage|endswith: '\lsass.exe'
SourceImage: 'C:\Windows\system32\wsmprovhost.exe'
condition: selection
tags:
- attack.t1003
- attack.t1021.006
```
**Создание файла (FileCreate: Sysmon**[**Event ID 11**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-11-filecreate)**)**
Не секрет, что при обращении вредоносного ПО к процессу LSASS.exe зачастую создается образ дампа его памяти на жестком диске — для последующей передачи и создания так называемого offline взлома паролей. Можно этим воспользоваться и попробовать отыскивать события создания файлов с 'lsass' в названии или с расширением dmp.
```
logsource:
category: file_create
product: sysmon
detection:
selection:
TargetFileName|endswith: 'lsass'
TargetFileName|endswith: '.dmp'
condition: selection
tags:
- attack.t1003
```
**События реестра (RegistryEvent (Object create and delete, Value Set, Key and Value Rename): Sysmon**[**Event ID 12&13&14**](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon#event-id-12-registryevent-object-create-and-delete)**)**
Злоумышленники могут настроить выполнение вредоносного кода при каждой загрузке системы или при вызове API-функции AddSecurityPackage. Это происходит с помощью добавления в конфигурацию Local Security Authority (LSA) фиктивного провайдера поддержки безопасности — Security Support Provider (SSP). SSP — программные модули (DLL), содержащие одну или несколько схем аутентификации и криптографии, которые загружаются в процесс LSASS при запуске системы. DLL-библиотеки SPP имеют доступ к зашифрованным и открытым текстовым паролям, которые хранятся в Windows.
Проект Mimikatz предоставляет файл DLL (mimilib.dll), который можно поместить в то же место, что и процесс LSASS (System32), чтобы получить учетные данные в виде plin text для любого пользователя, который приобретает доступ к скомпрометированному хосту.
Отследить добавление фиктивного провайдера поддержки безопасности можно следующим образом:
```
logsource:
category: registry
product: sysmon
detection:
selection:
TargetObject|contains: '\SYSTEM\CurrentControlSet\Control\Lsa\Security Packages'
TargetObject|contains: '\SYSTEM\CurrentControlSet\Control\Lsa\OSConfig\Security Packages'
condition: selection
tags:
- attack.t1547.005
```
По PID процесса можно отследить командную строку процесса и оценить, что именно добавлялось в реестр:
Ну и напоследок рассмотрим, как можно детектировать манипуляции злоумышленника над LSASS с помощью событий журналов безопасности OC Windows.
**Был запрошен дескриптор к объекту (Windows Seсurity**[**EventID 4656**](https://docs.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4656)**)**
Данное событие по своей сути аналогично Event ID 10 от sysmon. И позволяет отследить с какими правами был запрошен доступ к объекту.
```
logsource:
category: process_access
product: windows
detection:
selection_1:
ObjectName|endswith: '\lsass.exe'
selection_2:
AccessMasks:
- '0x40'
- '0x1400'
- '0x1000'
- '0x100000'
- '0x1410'
- '0x1010'
- '0x1438'
- '0x143a'
- '0x1418'
- '0x1f0fff'
- '0x1f1fff'
- '0x1f2fff'
- '0x1f3fff'
condition: selection_1 and selection_2
tags:
- attack.t1003
```
**Сервис был установлен в систему (Windows Security**[**EventID 4697**](https://docs.microsoft.com/en-us/windows/security/threat-protection/auditing/event-4697)**и Windows System**[**EventID 7045**](https://www.manageengine.com/products/active-directory-audit/kb/system-events/event-id-7045.html)**)**
Множество вредоносного ПО при закреплении, повышении или расширении своего функционала на зараженной машине создают сервисы. Например, нами всеми любимый mimikatz [создает сервис](https://github.com/gentilkiwi/mimikatz/blob/110a831ebe7b529c5dd3010f9e7fced0d3e3a46c/modules/kull_m_service.c#L138) с именем "mimidrv" и с абсолютным путем до драйвера "mimidrv.sys".
```
logsource:
category: service_created
product: windows
detection:
selection_7045:
event_id: '7045'
ImagePath|contains:
- fgexec
- dumpsvc
- cachedump
- mimidrv
- gsecdump
- servpw
- fgexec
- pwdump
- wceservice
- wceservice
- mimikatz
selection_4697:
event_id: '4697'
ServiceName|contains:
- fgexec
- dumpsvc
- cachedump
- mimidrv
- gsecdump
- servpw
- fgexec
- pwdump
- wceservice
- wceservice
- mimikatz
ServiceFileName|contains:
- fgexec
- dumpsvc
- cachedump
- mimidrv
- gsecdump
- servpw
- fgexec
- pwdump
- wceservice
- wceservice
- mimikatz
condition: selection_1 and selection_2
tags:
- attack.t1003.001
- attack.t1003.002
- attack.t1003.003
- attack.t1003.004
- attack.t1003.005
- attcak.t1569.002
```
**Объект общего доступа сети был проверен, чтобы увидеть, может ли клиент получить желаемый доступ (Windows Security**[**EventID 5145**](https://docs.microsoft.com/en-us/windows/security/threat-protection/auditing/event-5145)**)**
При ранее упомянутом «оффлайн дампе» злоумышленнику надо как-то будет передать дамп памяти со скомпрометированной машины. Тут нам и может помочь событие проверки объекта общего доступа.
```
logsource:
category: network_share
product: windows
detection:
selection:
event_id: '5154'
RelativeTargetName|contains:
- mimidrv
- lsass
- minidump
- hiberfil
- sqldmpr
- \system32\config\sam
- \ntds\ntds.dit
- \system32\config\security
condition: selection
tags:
- attack.t1003
```
В данной статье мы попытались рассмотреть большинство известных методов обнаружения доступа к учетным данным, хранящимся в lsass. Есть, конечно, другие методы и способы обнаружения, но они требуют немного иного инструментария, здесь же хотелось сосредоточиться на базовом и свободно доступном ПО (Sysmon и события журналов ОС Windows). Надеемся, что данный обзор был полезен и вам удалось почерпнуть новую информацию. До связи! | https://habr.com/ru/post/679592/ | null | ru | null |
# Luxon — новая библиотека для работы с датами от команды Moment.js
Казалось бы, зачем нужна еще одна библиотека для работы с датами и временем когда есть всем известная библиотека Moment?! Тем интереснее, что альтернатива предложена самой командой Moment.
Библиотека [Luxon](https://moment.github.io/luxon/) заявлена как мощное, современное и удобное средство для работы с датами и временем в JavaScript. Библиотеку создал Айзек Камброн (Isaac Cambron), входящий в команду разработчиков Moment с 2013 года.
У автора было много идей по развитию Moment, которые он не мог сделать в рамках существующего кода. Вот основные моменты, которые хотелось реализовать:
* опробовать некоторые идеи как сделать API более логичным (но эти идеи были не совместимы с подходом, принятым в Moment),
* реализовать «из коробки» работу с временными зонами без дополнительных расширений,
* полностью переосмыслить работу с интернационализацией с учетом появления Intl API,
* перейти на современный набор инструментов и подходов при формирования JS кода.
Поэтому он решил написать все с нуля, что заняло около двух лет.
В результате получился как бы модернизированный вариант Moment.
Получившийся вариант показался интересным всей команде разработчиков Moment, так что было решено продвигать новую библиотеку под эгидой команды.
Принципы Luxon
--------------
1. Цепочки вызовов как в Moment.
2. Все типы иммутабельными.
3. Более ясный и очевидный API: для разных объектов — разные методы с четко определенными параметрами.
4. Intl API для обеспечения интернационализации (откат к английскому варианту, если браузер не поддерживает Intl API).
5. Intl API для обеспечения работы с временными зонами.
6. Более полная поддержка расчета длительности.
7. Встроенная поддержка работы с интервалами.
8. Инлайн документация кода.
**Эти принципы привели к следующим улучшениям:**
* Код Luxon намного проще в понимании и отладке.
* Использование встроенных возможностей браузера для интернационализации улучшает поведение библиотеки и, опять же, облегчает отладку.
* Поддержка временных зон реализована лучше чем в любой другой JS библиотеке.
* Luxon предоставляет одновременно простой и очень мощный инструмент для работы с длительностью.
* У библиотеки хорошая документация.
**Но у Luxon есть и свои недостатки:**
* Упор на использование встроенных возможностей браузера приводит к сложностям в поддержке старых браузеров.
* Некоторые возможности интернационализации, которые еще не поддерживаются браузерами не реализованы и в библиотеке (необходимо ожидать, когда в браузерах такая поддержка появится).
* Реализация Intl API в разных браузерах может различаться, соответственно, будет различаться и поведение Luxon.
Установка
---------
Luxon предоставляет модули под все современные платформы JavaScript.
В документации есть полный [список поддерживаемых браузеров](https://moment.github.io/luxon/docs/manual/matrix.html) с указанием ограничений применения. Для браузеров у которых отсутствует или ограничена поддержка Intl рекомендуется использовать полифил (в частности это касается IE 10 или 11).
При работе с Node.js (6+), если нужна работа с локалями, то потребуется дополнительно установить пакет *full-icu* и задать переменную окружения, чтобы включить использование этого пакета.
Стандартный способ установки из npm:
**npm install --save luxon**
У Luxon есть поддержка как TypeScript так и Flow, так же есть модуль в формате ES6.
Быстрый обзор
-------------
Библиотека Luxon состоит из пяти основных классов:
*DateTime* — дата и время с часовым поясом и настройками отображения, а так же сопутствующие методы.
*Duration* — период времени (длительность), например, «2 месяца» или «1 день, 3 часа».
*Info* — статические методы для получения общих данных о времени и дате.
*Interval* — интервал времени и методы для работы с ним.
*Settings* — статические методы, которые задают общее поведение Luxon.
```
import {DateTime, Duration, Info, Interval, Settings} from 'luxon';
```
### Ваш первый DateTime
Самый важный класс в Luxon — DateTime. DateTime представляет дату+время вместе с часовым поясом и локалью. Вот так можно задать 15 мая 2017 года 08:30 в локальном часовом поясе:
```
var dt = DateTime.local(2017, 5, 15, 8, 30);
```
Вот вызов для определения текущего времени:
```
var now = DateTime.local();
```
### Создание из объекта
```
DateTime.fromObject({
month:12,
day: 22,
hour: 12,
minutes: 20,
zone: 'Europe/Kaliningrad'
}); //=> 2018-12-22T12:20:00.000+02:00
```
### Создание из строки в формате ISO 8601
```
DateTime.fromISO("2017-05-15"); //=> May 15, 2017 at 0:00
DateTime.fromISO("2017-05-15T08:30:00"); //=> May 15, 2017 at 8:30
```
При преобразовании в строку Luxon так же возвращает строку в формате ISO 8601:
```
DateTime.local().toString(); //=> "2018-12-18T20:58:29.995+03:00"
```
### Получение отдельных компонентов:
```
var dt = DateTime.local();
dt.year; //=> 2018
dt.month; //=> 12
dt.day; //=> 18
dt.second; //=> 27
dt.weekday; //=> 2
dt.zoneName; //=> "Europe/Moscow"
dt.offset; //=> 180
dt.daysInMonth; //=> 31
```
### Вывод в форматированном виде
Luxon имеет множество методов для преобразования DateTime в строку, два из них наиболее важны toLocaleString и toISO, первый преобразует в формат с учетом лакали браузера, а второй готовит текст для программной обработки (к примеру, для передачи на сервер):
```
dt.toLocaleString(); //=> "18.12.2018"
dt.toLocaleString(DateTime.DATETIME_MED); //=> "18 дек. 2018 г., 21:46"
dt.toISO(); //=> "2018-12-18T21:46:55.013+03:00"
```
Для форматированного вывода в Luxon есть два десятка готовых «пресетов» (таких как DATETIME\_MED и TIME\_WITH\_LONG\_OFFSET).
Так же можно сформировать собственный вариант форматирования на основе токенов:
```
dt.setLocale('ru').toFormat('d MMMM tt - ZZZZZ');
//=> "18 декабря 21:46:55 - Москва, стандартное время"
```
### Преобразования DateTime
Важное замечание: объекты Luxon — иммутабельны, т.е. любые изменяющие методы примененные к ним возвращают измененную копию не изменяя исходного объекта. Поэтому все термины в этой статье (как и в документации Luxon) такие как «изменить», «установить», «переопределить» надо понимать как «создать новый экземпляр с другими свойствами».
### Математические преобразования
```
var dt = DateTime.local(2018, 12, 18, 20, 30); //=> "18.12.2018, 20:30"
dt.plus({hours: 3, minutes: 2}); //=> "18.12.2018, 23:32"
dt.minus({days: 7}); //=> "11.12.2018, 20:30"
dt.startOf('day'); //=> "18.12.2018, 0:00"
dt.endOf('hour'); //=> "18.12.2018, 20:00"
```
### Переопределение отдельных параметров
```
var dt = DateTime.local();
dt.set({hour: 3}).hour //=> 3
```
### Преобразования Intl
Luxon поддерживает несколько разных преобразований Intl, одним из наиболее важных является форматирование под различные локали:
```
var dt = DateTime.local();
var f = {month: 'long', day: 'numeric'};
dt.setLocale('fr').toLocaleString(f); //=> "18 décembre"
dt.setLocale('en-GB').toLocaleString(f); //=> "18 December"
dt.setLocale('en-US').toLocaleString(f); //=> "December 18"
```
Класс Info может возвращать списки месяцев и дней недели в заданной локали:
```
Info.months('long', {locale: 'it'}); //=> ["gennaio", "febbraio", "marzo", ...]
Info.weekdays ('short', {locale: 'de'}); //=> ["Mo", "Di", "Mi", ...]
```
### Часовые пояса
Luxon поддерживает часовые пояса. Если создавать DateTime без явного указания временной зоны, то по умолчанию будет выбрана локальная зона. Если у существующего DateTime изменить зону, то время и дата будут пересчитаны с учетом разницы между часовыми поясами.
```
var dt = DateTime.local(2018, 12, 18, 20, 00); //=> 2018-12-18T20:00:00.000+03:00
dt.zone.name; //=> "Europe/Moscow"
dt.setZone('Asia/Vladivostok'); //=> 2018-12-19T03:00:00.000+10:00
```
Luxon также поддерживает работу с датой и временем в формате UTC:
```
DateTime.utc(2018, 5, 15); //=> 2018-05-15T00:00:00.000Z
DateTime.utc(); //=> 2018-12-18T17:58:29.995Z
DateTime.local().toUTC(); //=> 2018-12-18T17:58:29.995Z
DateTime.utc().toLocal(); //=> 2018-12-18T20:58:29.995+03:00
```
### Длительность
Класс Duration предоставляет возможность работать с длительностью, например, «2 часа и 7 минут». Создать длительность можно так:
```
var dur = Duration.fromObject({hours: 2, minutes: 7});
```
Длительности могут складываться и вычитаться. Длительность может иметь отрицательное значение.
```
dur.minus(dur).minus(dur); //=> {hours: -2, minutes: -7}
```
Подобным образом длительность может быть добавлена или вычтена из DateTime.
```
DateTime.local().plus(dur);
```
У длительности есть геттеры (похожие на геттеры DateTime):
```
dur.hours; //=> 2
dur.minutes; //=> 7
dur.seconds; //=> 0
dur.zone; //=> undefined
```
Так же у длительности есть и другие полезные методы:
```
dur.as('seconds'); //=> 7620
dur.toObject(); //=> { hours: 2, minutes: 7 }
dur.toISO(); //=> 'PT2H7M'
```
### Интервалы
Интервалы задаются как период между двумя временными точками, для работы с ними используется класс Interval. Время начала входит в интервал, а время окончания — нет: соответственно, начало при преобразовании в строку отмечается квадратной скобкой, а конец — круглой.
```
var today = DateTime.local(2018, 12, 18);
var later = DateTime.local(2020, 10, 12);
var interval = Interval.fromDateTimes(today, later);
interval.toString();
//=> "[2018-12-18T00:00:00.000+03:00 – 2020-10-12T00:00:00.000+03:00)"
interval.toISO();
//=> "2018-12-18T00:00:00.000+03:00/2020-10-12T00:00:00.000+03:00"
interval.length(); //=> 57369600000
interval.length('years', true); //=> 1.8169398907103824
interval.contains(DateTime.local(2019)); //=> true
```
Интервалы можно сравнивать между собой и комбинировать друг с другом:
```
var nextYear = Interval.after(DateTime.local(), {year: 1});
var prevYear = Interval.before(DateTime.local(), {year: 1});
prevYear.overlaps(nextYear); //false
prevYear.abutsStart(nextYear); //true
nextYear.union(prevYear).length('years'); //=> 2
```
Luxon и Moment
--------------
Библиотека Luxon «обитает» в проекте «Moment», но не является полной заменой библиотеки Moment. Luxon не предоставляет полной функциональности Moment, к примеру, [относительное форматирование дат](https://github.com/tc39/proposal-intl-relative-time) только совсем недавно было реализовано в браузере Chrome версии 71, в других браузерах пока не работает и в Luxon поддержка для него еще не реализована (хотя и ожидается). Но даже если браузеры поддерживают требуемый функционал, то надо понимать, что он будет доступен только в этих новых средах. В устаревших браузерах Luxon будет работать с проблемами, в то время как Moment работает всегда и везде.
Кроме этого API Luxon был полностью переработан и он совершенно не совпадает с API Moment.
Отметим главные различия между Moment и Luxon.
### Иммутабельность
Объекты Luxon иммутабельны, а у Moment — нет.
В приведенном ниже примере m1 и m2 — это один и тот же объект, который был изменен методом add.
```
var m1 = moment();
var m2 = m1.add(1, 'hours');
m1 === m2; //=> true
```
В случае Luxon метод plus возвращает новый объект d2 не изменяя исходный d1.
```
var d1 = DateTime.local();
var d2 = d1.plus({ hours: 1 });
d1 === d2; //=> false
d1.valueOf() === d2.valueOf(); //=> false
```
По этой причине Luxon не требует специальных конструкторов для копирования и методов для клонирования, которые используются Moment для получения копий без изменения исходного значения.
### Основные функциональные различия
1. Отсчет месяцев в Luxon начинается с 1, а не с нуля как в Moment (и нативноv js-объекте Date).
2. Локализация и временные зоны реализованы с помощью нативного Intl API (или полифила), а не встроены в библиотеку.
3. Luxon имеет встроенные типы Duration и Interval.
4. Luxon пока не поддерживает относительное форматирование дат.
5. В Luxon так же пока нет метода humanize для представления длительности в «очеловеченном» стиле (к примеру, «a few seconds»).
### Различия в стиле API
* В методах API Luxon опционные параметры обычно располагаются последними.
* Luxon имеет множество отдельных методов для создания объектов(например, fromISO), в отличие от Moment, который имеет для этого одну функцию, а тип объекта задается параметрами.
* У Luxon очень строгие парсеры, в то время как у Moment они более либеральные, т.е. если формат входной строки будет отличаться от стандартного, то Luxon сразу выдаст ошибку, а Moment какие-то ошибки в формате попробует исправить.
* Для получения значения внутренних полей Luxon использует геттеры (dt.year, dt.isValid), а не методы как Moment (m.year(), m.isValid()).
* Luxon позволяет одним методом сразу установить все необходимые параметры dt.set({year: 2016, month: 4}), в Moment они задаются только по одному — цепочкой вызовов m.year(2016).month(4).
* Длительность в Luxon — это отдельный класс верхнего уровня Duration.
В остальном Luxon заимствовал много идей из Moment, в документации даже приводятся таблицы эквивалентности методов Moment и Luxon.
### Размеры файлов библиотек
*Luxon (v. 1.8.2)*
luxon.min.js — 61 KB
*Moment (v. 2.23.0)*
moment.min.js — 51 KB
moment.min.js + locale/ru.js — 59 KB
moment-with-locales.min.js — 323 KB
Как видим, без локалей Moment по размеру на 10 KB меньше чем Luxon, но с добавлением нескольких локалей размер становится примерно равным.
Если же требуется поддержка сразу всех локалей, то тут существенный выигрыш у Luxon.
### Резюме
Библиотека полностью готова к использованию и автор обещает ее поддержку. У библиотеки уже 7k+ звезд на гитхабе и популярность ее только растет. В ее код делает коммиты не только сам автор, но еще не менее 6 разработчиков.
Предположу, что библиотека Luxon это ответ на появление в браузерах поддержки Intl API. Разработчики Moment понимают, что работа с датами на вебе может существенно измениться и пытаются подготовиться к этим изменениям. Но точно предсказать развитие веба, а вместе с ним и нового проекта (который сами называют Moment labs project) они не могут. Будут ли идеи Luxon перенесены в Moment 3? Перейдет ли в какой то момент большинство пользователей с Moment на Luxon? Может быть Luxon будет переименован в Moment? Сами разработчики признаются, что не могут сейчас ответить на эти вопросы. | https://habr.com/ru/post/433850/ | null | ru | null |
# iOS in-app purchases, часть 6: как реализовать скидки introductory offer, promotional offer, offer code
Привет! Я Андрей, тимлид мобильной разработки в [Adapty](https://adapty.io/?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_ios-iap_promooffers), я делаю [SDK под iOS](https://github.com/adaptyteam/AdaptySDK-iOS).
В нашей серии статей мы с командой рассказываем о внедрении покупок на iOS, и это шестая статья из серии. Познакомиться с остальными можно по ссылкам:
1. iOS in-app purchases, часть 1: [Конфигурация и добавление в проект.](https://habr.com/ru/company/adapty/blog/507664/)
2. iOS in-app purchases, часть 2: [Инициализация и обработка покупок.](https://habr.com/ru/company/adapty/blog/512590/)
3. iOS in-app purchases, часть 3: [Серверная верификация покупок.](https://habr.com/ru/company/adapty/blog/572370/)
4. iOS in-app purchases, часть 4: [Тестирование покупок.](https://habr.com/ru/company/adapty/blog/571960/)
5. iOS in-app purchases, часть 5: [Обработка ошибок.](https://habr.com/ru/company/adapty/blog/573562/)
6. iOS in-app purchases, часть 6: Скидки для iOS in-apps purchases. — Вы тут.
Скидки помогают приложениям привлечь новых подписчиков и удержать тех, кто потерял интерес к продукту. В Apple довольно большой инструментарий для их реализации, и сегодня я расскажу, какие возможности можно использовать, чтобы предоставить пользователям скидку: introductory offers, promo offers, offer codes, и проч.
В статье я опишу, как работают все эти скидки, как их реализовать для кого их можно применять.
### Что такое скидочное предложение (offer)?
Offer (в статье иногда буду называть его cкидочным предложением) — это снижение цены на подписки для пользователей. Есть несколько вариантов:
* стартовое предложение — **introductory offer;**
* промо предложение — **promo offer** — скидка уже подписанному пользователю, например, при переходе на более дорогую подписку
* возможность активировать промокод — **offer code,** который гарантирует определенную фиксированную цену при покупке.
### Варианты оплаты: free trial, pay as you go, pay upfront
Каждое скидочное предложение имеет один из доступных способов оплаты.
#### Free trial — бесплатное использование
В этом варианте подписчик может активировать подписку бесплатно на какое-то время. Деньги не будут списаны до конца периода, и пользователь может отменить подписку в любой момент. Пример: первый месяц бесплатного использования.
#### Pay as you go — оплата по мере использования
Подписчик платит сниженную цену каждый период подписки на протяжении какого-то времени. По истечении пробного периода списание происходит по обычной цене. Пример: три месяца со скидкой в 50%.
#### Pay up front — оплата наперёд
Пользователь единовременно оплачивает подписку на какой-то период. После окончания этого периода списание происходит по обычной цене. Пример: оплата сразу за год вперед со скидкой в 70%.
### Стартовое предложение — introductory offer
#### Как работает introductory offer
Стартовое предложение позволяет пользователю ознакомиться с вашим приложением в течение какого-то фиксированного периода бесплатно или со скидкой, как упоминали выше: free trial, pay as you go, pay upfront.
Каждая подписка может иметь только одно стартовое предложение, которое в целом нельзя регулировать — Apple сам определяет, может ли пользователь применить эту скидку или нет. Чтобы на это влиять, есть более сложные сценарии, например, создать набор продуктов со скидкой и без и показывать разные продукты пользователю в зависимости от каких-то внутренних признаков, но это уже тема для другой статьи.
#### Реализация introductory offer
Для использования таких скидок нужно сначала [настроить их](https://help.apple.com/app-store-connect/#/deve1d49254f) в личном кабинете. Далее адаптировать интерфейс для отображения подобных скидок:
**Шаг 1.** Используя `SKProductsRequest`, нужно получить список продуктов из магазина:
```
class PaywallViewController: UIViewController {
let productIds: Set = ["", ""]
var productsRequest: SKProductsRequest?
override func viewDidLoad() {
super.viewDidLoad()
productsRequest = SKProductsRequest(productIdentifiers: productIds)
productsRequest?.delegate = self
productsRequest?.start()
}
}
extension PaywallViewController: SKProductsRequestDelegate {
func productsRequest(\_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
// your products are available here
// let’s take a very first one as an example
formatIntroductoryOfferMessage(for: response.products.first!)
}
func request(\_ request: SKRequest, didFailWithError error: Error) {
// can’t fetch products
}
}
```
**Шаг 2.** Далее найти нужный продукт, внутри которого будет лежать поле `introductoryPrice`, которое содержит всю информацию о вводном предложении, и сформировать цену скидки, ее длительность и проч. После отобразить это на экране оплаты:
Формирование локализованных заголовков для цены и длительности скидки
```
extension ViewController {
func formatIntroductoryOfferMessage(for product: SKProduct) {
let introductoryPrice = product.introductoryPrice
let locale = product.priceLocale
let localizedPrice = introductoryPrice?.price.localizedPrice(for: locale)
self.discountLabel.text = localizedPrice // ex.: $10 or $9.99
let localizedSubscriptionPeriod = introductoryPrice?.subscriptionPeriod.localizedPeriod(for: locale)
discountDurationLabel.text = localizedSubscriptionPeriod // ex.: 3 weeks
}
}
extension NSDecimalNumber {
func localizedPrice(for locale: Locale) -> String? {
let formatter = NumberFormatter()
formatter.numberStyle = .currency
formatter.locale = locale
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 2
return formatter.string(from: self)
}
}
extension Locale {
func localizedComponents(day: Int? = nil, weekOfMonth: Int? = nil, month: Int? = nil, year: Int? = nil) -> String? {
// format and return localized period, like "3 weeks", "1 day", "2 years", etc
}
}
@available(iOS 11.2, macOS 10.13.2, *)
extension SKProductSubscriptionPeriod {
func localizedPeriod(for locale: Locale) -> String? {
switch unit {
case .day:
// apple treats 1 week as 7 days so far
if numberOfUnits == 7 { return locale.localizedComponents(weekOfMonth: 1) }
return locale.localizedComponents(day: numberOfUnits)
case .week:
return locale.localizedComponents(weekOfMonth: numberOfUnits)
case .month:
return locale.localizedComponents(month: numberOfUnits)
case .year:
return locale.localizedComponents(year: numberOfUnits)
@unknown default:
return nil
}
}
}
```
Покупка совершается в обычном режиме, разработчику ничего дополнительно указывать не требуется. Про покупки мы уже писали [в нашей второй статье из серии про iOS](https://habr.com/ru/company/adapty/blog/512590/).
#### Проверка доступности introductory offer
Чтобы проверить доступность вводного предложения для пользователя, нужно изучать его рецепт с покупками. Для этого необходимо [провалидировать его на стороне сервера](https://habr.com/ru/company/adapty/blog/572370/), а далее смотреть на признаки `is_trial_period` и `is_in_intro_offer_period` для всех покупок. Если хотя бы где-то эти флаги равны `true`, то у пользователя нет права использовать вводное предложение в пределах этой подписки, а также для всех подписок из этой же группы. Для определения всех подписок группы можно использовать поле `subscription_group_identifier` внутри `responseBody.Pending_renewal_info`.
Определять доступность вводного предложения лучше всего на стороне сервера и как можно раньше, чтобы на этапе экрана оплаты уже принять решение, показывать пользователю скидку или нет.
Introductory offer доступен не для всех пользователей:
* **Для новых пользователей** всегда доступно вводное предложение.
* **Для отписавшихся и не использовавших подобную скидку раньше** также все доступно, но только при возобновлении подписки или активации любой другой подписки в пределах группы подписок.
* **Текущие подписчики** не имеют права использовать вводное предложение для любого продукта в пределах существующей группы подписок, независимо от того, использовали ли они его в прошлом, или нет.
### Промо предложение — promotional offer
#### Как работает promotional offer
Промо-предложение — это скидка или бесплатный доступ на определенный период. Такую скидку можно делать и тем, кто пользуется приложением сейчас, и тем, кто уже отписался. Обычно они используются для удержания существующей аудитории, чтобы продать более дорогой план или же вернуть отписавшихся пользователей.
Для каждой подписки можно завести не более десяти промо-предложений. Пользователи, активировавшие introductory offer, также могут использовать и promotional offer.
Решение, как и когда показывать промо предложение пользователю, ложится исключительно на плечи владельца приложения. Сценариев применения множество и они ничем не ограничиваются, например:
* предложить скидку, как только пользователь не обновил подписку или отменил ее;
* если пользователь уже несколько раз обновил месячную подписку, то можно предложить ему годовую подписку со скидкой.
#### Подготовка promotional offer и интеграции на стороне сервера
Добавление промо-предложений состоит из нескольких шагов, в частности:
* проверка доступности промо-предложения;
* показ промо на экране оплаты;
* генерация подписи для совершения покупки с использованием промо;
* покупка с использованием идентификатора промо.
Общая схема выглядит примерно так, как показано ниже. Пусть она вас не пугает, далее мы пройдемся по каждому ее аспекту и покажем на примерах как это выглядит на деле.
Для начала нужно [сгенерировать приватный ключ](https://help.apple.com/app-store-connect/#/dev689c93225), которым сервер будет подписывать все активируемые промо-предложения. Для этого нужно пойти в App Store connect → Users and Access → Keys → In-App Purchase → Generate In-App Purchase Key → Ввести желаемое имя (оно используется лишь для отображения в списке) → Generate. После генерации приватного ключа требуется скачать его. Для скачивания он будет доступен только один раз, так что лучше его не терять.
Далее нужно настроить сервер, чтобы он умел [валидировать рецепты](https://habr.com/ru/company/adapty/blog/572370/) и слушать серверные уведомления App Store. Дополнительно нужно добавить функционал [генерации подписи](https://developer.apple.com/documentation/storekit/original_api_for_in-app_purchase/subscriptions_and_offers/generating_a_promotional_offer_signature_on_the_server) для промо предложений с использованием ключа из предыдущего пункта.
Следующим шагом нужно [добавить](https://help.apple.com/app-store-connect/#/dev16dfca448) желаемые предложения в дашборде App Store Connect. Для каждого из них требуется указать:
1. **название (reference name)**, используется только для отображения в списке;
2. **идентификатор предложения (promotional offer id)**, активно используется в приложении при определении того, какую скидку требуется применить;
3. **метод предоставления скидки (offer type):** free trial, pay as you go, pay upfront;
4. **продолжительность;**
5. **цены,** можно указывать разные цены для разных валют.
#### Клиентская реализация
Теперь можно приступить к реализации на стороне приложения.
Как и в случае с вводным предложением (introductory offer), нужно получить список продуктов из магазина, используя `SKProductsRequest`. У каждого продукта внутри поля *discounts* лежат все сгенерированные промо предложения для каждой конкретной подписки.
Владелец приложения сам регулирует то, какое промо предложение применить в той или иной ситуации. Делается это посредством идентификатора скидки — он используется для поиска нужного элемента из общего списка.
```
extension PaywallViewController: SKProductsRequestDelegate {
func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse) {
// your products are available here
// let’s take a very first one as an example
print("promo offers list: \(response.products.first!.discounts)")
let myOffer = response.products.first?.discounts.filter { $0.identifier == "my_offer" }.first
}
}
```
Адаптация платежного экрана, чтобы вывести на нем информацию о промо-предложении, точно такая же, как и в случае с вводным предложением. Т.к. модель сущности `SKProductDiscount` используется та же самая, можно с легкостью переиспользовать код, который был написан для обработки introductory offer. Требуется лишь дополнительно передавать идентификатор предложения, который нужно применить:
```
extension ViewController {
func formatPromoOfferMessage(for product: SKProduct, offerId: String) {
let promoOffer = product.discounts.filter { $0.identifier == offerId }.first
let locale = product.priceLocale
let localizedPrice = promoOffer?.price.localizedPrice(for: locale)
self.discountLabel.text = localizedPrice // ex.: $10 or $9.99
let localizedSubscriptionPeriod = promoOffer?.subscriptionPeriod.localizedPeriod(for: locale)
discountDurationLabel.text = localizedSubscriptionPeriod // ex.: 3 weeks
}
}
```
При покупке требуется явно указывать идентификатор предложения, который нужно применить, а также нужно получить сгенерированную подпись и еще ряд параметров для промо предложения с сервера. Далее передать это все в объект `SKPaymentDiscount` и уже этот объект скидки положить в поле `paymentDiscount` в покупку.
```
@available(iOS 12.2, *)
private func createPayment(from product: SKProduct, offerId: String, completion: BuyProductCompletion? = nil) {
// generate signing for promo offer
ApiManager.signSubscriptionOffer(params: ["product": product.productIdentifier, "offer_id": offerId]) { (params, error) in
guard error == nil else {
// response error
completion?(nil, nil, nil, product, error)
return
}
guard
let keyIdentifier = params?["key_id"] as? String,
let nonceString = params?["nonce"] as? String,
let nonce = UUID(uuidString: nonceString),
let signature = params?["signature"] as? String,
let timestampString = params?["timestamp"] as? String,
let timestampInt64 = Int64(timestampString)
else {
// missing some of the offer params
completion?(nil, nil, nil, product, Error.missingOfferSigningParams)
return
}
let timestamp = NSNumber(value: timestampInt64)
let payment = SKMutablePayment(product: product)
payment.applicationUsername = ""
payment.paymentDiscount = SKPaymentDiscount(identifier: offerId, keyIdentifier: keyIdentifier, nonce: nonce, signature: signature, timestamp: timestamp)
SKPaymentQueue.default().add(payment)
}
}
```
При желании можно узнать, какое промо предложение было применено к конкретной покупке. Для этого надо посмотреть успешную транзакцию `SKPaymentTransaction`. Внутри нее есть поле `paymentDiscount`, где лежит идентификатор примененного промо.
```
func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
transactions.forEach { (transaction) in
switch transaction.transactionState {
case .purchased:
print(transaction.payment.paymentDiscount?.identifier)
...
}
}
}
```
#### Проверка доступности promo offer
Проверка доступности промо-предложения для пользователя базируется на двух идеях.
1. App Store считает, что у всех, у кого есть действующая или истекшая подписка, по умолчанию есть доступ к промо-предложению. Для понимания того, что у пользователя есть или была подписка, достаточно провалидировать и изучить его рецепт.
2. Далее нужно уже самостоятельно определять любые дополнительные критерии доступности конкретного предложения. Право на применение может зависеть от широкого спектра логики в зависимости от потребностей бизнеса.
Один из распространенных способов применения промо-предложений — через серверное уведомление `DID_CHANGE_RENEWAL_STATUS`, которое отправляется, когда пользователь меняет тип автопродления подписки. Например, когда пользователь отключает автопродление, можно показать ему промо-предложение, чтобы мотивировать возобновить подписку.
Также стоит учитывать, что промо-предложения доступны только на iOS 12.2 и выше, macOS 10.14.4 и выше, tvOS 12.2 и выше, поэтому нужно проверять доступность устройства и предлагать пользователю обновить OS, если он хочет применить промо предложение на неподдерживаемой версии операционной системы.
### Промокоды — offer codes
#### Как работают offer codes
Промокоды — это строка из букв и цифр, которая даёт скидку на подписку или бесплатный триал. Промокоды стали доступны с iOS 14 и iPadOS 14, когда их анонсировали Apple. Распространять их можно как онлайн, так и оффлайн, например:
* при отправке рассылки с новыми функциями приложения можно приложить промокод на бесплатный период, чтобы заинтересовать пользователя;
* раздача листовок на улице с промокодом на скидку на первую покупку внутри приложения;
* партнерские программы с другими компаниями или блогерами, которые предоставляют эксклюзивный промокод на индивидуальную скидку.
#### Реализация offer codes
Для начала нужно [сгенерировать](https://help.apple.com/app-store-connect/#/dev6a098e4b1) эти промокоды в пределах какой-то подписки. Делается это через App Store Connect.
Пользователь может активировать код любым из трех способов:
* **Через App Store.** Для этого нужно открыть App Store и в разделе с приложениями найти соответствующую форму ввода кода.
* **По специальной ссылке из дашборда App Store Connect.** Этот сценарий не отличается от первого, разве что ссылку проще напрямую отправить аудитории и не придется искать заветного окна ввода в приложении App Store, достаточно будет кликнуть на ссылку и ввести код.
* **Напрямую в приложении.** В случае активации через приложение надо вызвать соответствующий метод, который покажет окно ввода кода:
`SKPaymentQueue.default().presentCodeRedemptionSheet()`
Когда пользователь активирует промокод, в приложение приходит уведомление с транзакцией в `SKPaymentQueue`, а также на сервер попадает уведомление в случае, если были настроены соответствующие [серверные уведомления](https://developer.apple.com/documentation/appstoreservernotifications).
```
extension YourClass: SKPaymentTransactionObserver {
func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
transactions.forEach { (transaction) in
switch transaction.transactionState {
case .purchased:
// handle successful purchase
case .failed:
// handle error
case .restored:
// handle restore
case .deferred, .purchasing: break
@unknown default: break
}
}
}
}
```
В итоге после покупки надо получить уведомление с транзакцией в `SKPaymentQueue`, взять актуальный рецепт и отправить этот рецепт на валидацию на сервер. Уже сервер должен понять, что был применен промокод.
Для определения активированного промокода требуется проверять рецепт на наличие транзакции с полем `offer_code_ref_name`. Это поле содержит название скидочного предложения, которое было создано в App Store Connect. Искать его следует в `responseBody.Latest_receipt_info` и `responseBody.Pending_renewal_info` внутри рецепта, но для серверных уведомлений аналогичные поля называются уже по-другому – `unified_receipt.Latest_receipt_info` и `unified_receipt.Pending_renewal_info`.
Надо также учесть, что промокод мог быть активирован еще в магазине, перед установкой приложения. В этом случае, во время запуска надо валидировать рецепт, чтобы сразу выдать пользователю доступ к контенту на старте.
#### Ограничения
Можно сгенерировать только 10 скидочных предложений, для которых есть лимит в 150 000 промокодов за квартал на приложение, так что используйте их с умом. Срок жизни промокодов — шесть месяцев. Тестировать промокоды можно только на живой сборке из App Store, Sandbox для подобных вещей пока не предусмотрен.
Когда Apple ввели запрет на общий доступ к IDFA, некоторые пытались использовать промо-коды, чтобы атрибуцировать пользователей, но ограничение в 150 тысяч кодов свели все эти старания на нет.
В целом добавление скидочных предложений в приложение не является очень сложной механикой, но потенциально может привлечь дополнительную прибыль.
Про Adapty
----------
[Adapty SDK](https://adapty.io/sdk/ios?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_ios-iap_offers) упрощает подключение покупок в приложениях, поддерживает все актуальные фичи магазинов, как те, которые мы описали в этой статье, и делает серверную валидацию платежей. Но это не все преимущества:
* Встроенная аналитика позволяет легко понимать главные метрики приложения.
* Когортный анализ показывает, [сходится ли экономика](https://habr.com/ru/company/adapty/blog/564748/).
* А/Б тесты пейволлов делаются налету и помогают увеличивать конверсию в платных пользователей.
* Интеграции с внешними системами позволяют отправлять транзакции в сервисы атрибуции и продуктовой аналитики.
* Промо кампании уменьшают отток аудитории.
* Open source SDK позволяет интегрировать подписки в приложение за несколько часов.
* Серверная валидация и API для работы с другими платформами упрощает работу с покупками.
[Познакомьтесь подробнее с этими возможностями](https://adapty.io/?utm_source=habr.com&utm_medium=referral&utm_campaign=blogpost_ios-iap_errors-handling), чтобы быстрее внедрить подписки в своё приложение и улучшить конверсии. | https://habr.com/ru/post/578180/ | null | ru | null |
# Пропаганда тоталитарного режима, антисемитизм и гомофобия в учебнике по программированию 2019 года? — Это возможно
Кликбейтный заголовок? К сожалению, всё указанное и даже более в обозреваемой ниже книге есть. Что за книга? «Простой Python просто с нуля».
Автор книги — Рик Гаско. Как я узнал уже потом, так звали героя фильма «Мальчишник», которого сыграл Том Хэнкс. Но на момент прочтения этого я не знал. Представьте, читаю книгу автора Рика Гаско и на первых страницах встречаю: «Летом 1942 года по просьбе американцев Советский Союз передал им для изучения танк Т-34...». Думаю — интересно. Читаю дальше: «Производили танк тогда на двух заводах, один из которых — Харьковский, к тому моменту уже захваченный немцами, теперь — украинцами». *І тут у мене підгоріло*. В смысле, меня это задело. А затем, после прочтения 50 с лишним страниц, я начал заново, с сохранением избранных моментов.
Оправдывание действий тоталитарного режима встречается уже спустя несколько предложений после упоминания захватчиков-украинцев. «А вы что думаете, зря этих вредителей в 37-м году пачками расстреливали?»
Что касается истории появления языка Python, автор преподносит её следующим образом: «Выдумал Питон Гвидо Ван Россум, он голландец, это многое объясняет, в Голландии легализованы лёгкие наркотики». Да, ещё автор упорно называет язык «Питоном» и предлагает выбрать, что дороже читателю — «правда или истина?» («Питон», естественно, есть «истина»). Относит же данный язык программирования автор к «нетрадиционным», но оправдывается, что это «не тот, которым пользуются исключительно лица нетрадиционной ориентации». После проявления гомофобии не хватает только антисемитизма. И его в книге можно разглядеть.
«Пасхи бывают разные — православные, католические и, прошу прощения, еврейские». Песах имеет более древнюю историю, чем христианская Пасха. «Для католической и еврейской пасхи алгоритмы найдите сами. Обязательно запрограммируйте. Мы же толерантные». Толерантностью так и прёт! Ладно, поехали дальше. «Как сказал великий русско-еврейский комик Аркадий Райкин...» Если выбросить «русско-еврейский», читается уже не так, согласны? Насколько это важная информация, что без неё нельзя было обойтись? «Черчилль? Бисмарк? Хемингуэй? Лейба Троцкий? Точно знаю, что не Пушкин». Имя указано только у одного. Совпадение? Только почему в Википедии Троцкий фигурирует как «Лев»? А Лейзер Вайсбейн как Леонид Утёсов? А Ованнес Айвазян как Иван Айвазовский? Может потому, что эти люди более известны под русскими именами? Или вот ещё из книги: «Даль — автор Толкового словаря живого великорусского словаря. Типично русская фамилия не случайна. Этимологический словарь русского языка составил Макс Фасмер, а правила русского правописания сочинил Розенталь. Тенденция, однако». Наконец, «Если вы заглянете в любой исполняемый файл, тот, который с расширением \*.exe, то обнаружите в начале некие буквы MZ. Это сокращение от имени и фамилии Миша Цукерман. Вот честное слово. И как теперь с этим жить?» MZ — инициалы Марка Збиковски.
К ещё одному напоминанию о наркотиках в Голландии («видимо, тонкий намёк на легализацию легких наркотиков») и парочке унижений украинцев («Шо маэмо, то маэмо © Украинская универсальная отмазка» и анекдот про «Петрика з села Залупівки») следует добавить наличие в книге, посвящённой языку программирования, цитирования Ленина, Сталина и Путина. Уместно ли это здесь? Я считаю, что нет. Кстати, аналогичный анекдот есть и про русского, который заказывал по радио «Валенки». Нет, «Залупівка» звучит смешнее.
Своеобразное чувство юмора автора стало причиной наличия в книге таких фраз, как «трава была зелёная и девки давали», «мохнатые семидесятые», «Дима — чудак на букву М», «А потому что какаю», «Натянуть сову на глобус», «Какая-то неведомая фигня».
Что касается сути книги, то здесь у меня тоже есть замечания. Даже если не обращать внимание, на то, что более половины текста — «вода». Например, этот скриншот вообще уникальный — оцените объём смысловой нагрузки:
С чего стоит начать по существу, так это выбор версии языка Python в этом удивительном учебнике 2019 года: «Мы за новизной не гонимся, поэтому использовать будем версию 2.7.14».
Далее автор не может определиться, есть ли типы в Python или нет. «Запомним — типов в Питоне нет!», а потом «Питон не проверяет соответствие типов фактических параметров формальным», «Однако напоминаю, тип переменной может быть проверен», «А теперь попытаемся проверить тип первой из них», «А вот так надо проверять остальные три типа» и так далее в том же духе.
Заносчивость и невежество автора может сильно ввести начинающих программистов в заблуждение. «Чем больше программист думает, тем больше ошибок мы будем иметь», «Моё мнение — цикл должен двигаться только с шагом плюс один. В крайнем случае — минус один, но и то, по моему мнению, это лишнее и портит в остальном хорошую программу. Послушайтесь моего совета — только плюс один!», «Так вот, те задачи, которые я предлагаю дальше, решаются именно так и только так, я таки вас умоляю, не надо ничего выдумывать». Посмотрим, как предлагает решать автор первую задачу (напомню, им выбрана версия Python 2.7; я бы в третьей версии написал бы всего одну строчку, даже два способа есть; может, и во второй так можно, не проверял). Итак, задача: «Заполнить список одним и тем же значением, чаще всего это значение — ноль». Решение автора:
```
a = []
for i in xrange(0, num):
a.append(0)
```
При этом, читаем в книге: «Операции над строками — сложение и умножение, никому не нужное», «Называется это анонимные функции, они же lambda-функции. Долго думал, какая от них может быть польза, кроме как показать уровень своего интеллекта, но не понял». Ну, и "… исключения… я их не люблю и никогда ими не пользуюсь. Ну, не нравятся они мне, не нравятся". Не любит автор и C++. Зато автор, как утверждает, знаток Delphi и ООП. У него и книги соответствующие есть («не важно под каким именем они изданы»). Издательство «СОЛОН-Пресс» представляет (на обложке обозреваемой книги) следующие книги Рика Гаско: «Простой учебник программирования», «Простая Математика для Программистов», «Объектно Ориентированное Программирование». Названия книг по Pascal, думаю, тоже можно найти.
А вот как автор предлагает решать другую задачу («именно так и только так»). Задача: «Найти минимальный элемент массива и его заодно его индекс». Решение (повторюсь «именно так и только так»):
```
min = a[0]
index = 0
for i in xrange(1, 10):
if a[i] < min:
min = a[i]
index = i
```
Жду ваших решений в комментариях! Хоть по мнению автора, использовать их ни в коем разе нельзя.
Математика в книге тоже присутствует. Это и формулы для вычисления площадей и объёмов фигур, и формулы различных рядов. С последними — проблема. Во-первых, одна из формул запрограммирована, а потом долго и нудно объясняется почему. Да, такой приём имеет право на существование, но автор испортил его на корню. Во-вторых, пытаясь блеснуть остроумием, автор добавил к другой формуле свой комментарий, допустив при этом ошибку. «Вот пример бесконечного ряда: 1 + 1/2 + 1/4 + 1/8 +… Складывать эти числа не надо, потому что математики доказали, что его сумма равна в точности единице». Единице? 1 + 1/2 уже будет полтора! Ряд не знакопеременный, а значит, уменьшиться сумма не может. А вот если убрать первую единицу из ряда… Даже анекдот такой есть, про бесконечное количество математиков, которые зашли в бар и заказали оригинальным способом литр пива. И ещё, моё мнение — лучше попытаться что-то объяснить или, если не можешь, не делать на этом акцент. Это не про автора! «По определению считается, что 0! = 1. А почему, собственно? Так я ведь уже сказал — по определению».
Публикация книги — тяжёлый труд. И это касается не только написания её автором. Ещё трудятся редакторы, корректоры, наборщики, иллюстраторы, финансовый директор, сотрудники отдела маркетинга. Сложилось впечатление, что редактор и корректор этой книги схалтурили. Слишком уж большое число несостыковок и опечаток, заметных невооружённым глазом. Даже в тех цитатах, что я привёл в этой статье они есть!
Допускаю, если вы внимательно читали, заметив их, возможно, подумали: «Этот Albom даже перенабрать текст из книги без ошибок не может!» Итак, словарь Даля называется не так, это, конечно же, словарь языка, а не словарь словаря. Далее прочтите внимательно условие второй задачи. «Его» написано два раза, то есть текст редактировался, редактировался, но недовыредоктировался. Буква «ё» пропадает из второго упоминания лёгких наркотиков, легализованых в Голландии. Плюс в тексте, не вошедшем в статью: «альбов» вместо «альбом», «hrlp» вместо «help». Опечатки обыкновенные. Но в глаза бросаются. А вот что не бросается, так это "π≈3.14158". Я бы вместо восьмёрки поставил бы девятку. Но это слишком большая придирка.
Думаю, насчёт плохого достаточно. Теперь о хорошем. Это можно сформулировать одним предложением. Если бы не всё перечисленное выше, могла получиться неплохая книга, с неординарной подачей материала.
Автору, если он прочтёт мою статью, ничего сказать не хочу. Он провокатор, и провокация его, в первую очередь в разжигании межнациональной розни, сработала.
Редактору книги, Н. Комлеву, позор.
Всем дочитавшим статью — спасибо! Понимаю, что читать большой объём субъективного нелегко — уж со многим можно не соглашаться.
Книгу я скачал в одной из групп в Телеграме. Поэтому нелегальное происхождение файла не даёт мне морального права написать в редакцию. Иначе (в случае покупки и переписки с издателем) статья получилась бы, вероятнее всего, другой.
Книга свободно продаётся в Украине и стоит не меньше многих более достойных. Саму же книгу считаю не просто неудачной, а даже вредной с точки зрения влияния на неокрепшие программистские умы. | https://habr.com/ru/post/482806/ | null | ru | null |
# Деградация программного обеспечения
В книге [«Электромагнитная эпоха: работа, любовь и жизнь, когда роботы правят миром»](https://geoff.greer.fm/2016/07/23/age-of-em/) Робин Хэнсон кратко обсуждает деградацию программ:
> Программное обеспечение изначально было разработано для одного набора задач, инструментов и ситуаций. Но оно медленно изменяется, чтобы справиться с постоянным потоком новых задач, инструментов и ситуаций. Такой софт становится более сложным, хрупким, в него труднее вносить полезные изменения (Леман и Биледи, 1985)[1](#1). В конце концов, лучше начать всё сначала и написать с нуля новые подсистемы, а иногда и полностью новые системы.
Я уверен, что это правда. Как правило, грамотная адаптация программного обеспечения к новым условиям занимает больше времени и усилий, чем написание нового программного обеспечения с нуля. Программисты не любят признавать это, но доказательства очевидны. В проектах open source есть несколько известных примеров.
Многопроцессный Firefox
=======================
Изначально [Mozilla Firefox](https://en.wikipedia.org/wiki/Firefox) запускал все задачи в одном процессе. После выхода [Google Chrome](https://en.wikipedia.org/wiki/Google_Chrome) стало ясно, что модель с несколькими процессами повышает безопасность и производительность. Вскоре разработчики Mozilla начали планировать, как реализовать в Firefox многопроцессность. Это было в 2007 году.
Почти десять лет спустя Mozilla, наконец, [выпустила мультипроцессный Firefox на массовую аудиторию](https://blog.mozilla.org/futurereleases/2016/12/21/update-on-multi-process-firefox/). Эта задержка произошла вовсе не от недостатка желания. У Mozilla талантливые и целеустремленные разработчики. Тем не менее, Chrome был написан с нуля за гораздо меньшее время, чем потребовалось Firefox для изменения. У этого две основные причины:
* Переделка однопроцессной архитектуры в многопроцессную предполагает *множество* мелких изменений. Некоторые вызовы функций нужно заменить межпроцессными коммуникациями. Общее состояние нужно обернуть в мьютексы. Кэши и локальные БД должны поддерживать параллельный доступ.
* Firefox должен сохранить совместимость с существующими расширениями (или заставить разработчиков их обновить). Chrome создавал API для расширений с нуля, не имея таких ограничений.
Но ситуация ещё хуже. Ограничения противоречат друг другу: нужно перестроить внутреннюю архитектуру, но оставить почти без изменений общедоступные API. Неудивительно, что Mozilla понадобилось десять лет на такой подвиг.
Событийно-ориентированный Apache
================================
Изначально [Apache httpd](https://httpd.apache.org/) работал по модели «один процесс на соединение». Один процесс прослушивал порт 80, затем делал `accept()` и `fork()`. Дочерний процесс потом выполнял `read()` и `write()` на сокете. Когда запрос завершён, дочерний процесс закрывал сокет `close()` и выполнял `exit()`.
Такая архитектура простая, лёгкая в реализации на многих платформах и… всё. Она абсолютно ужасна для производительности, особенно при обработке долгоживущих соединений. Справедливости ради: это был 1995 год. И вскоре Apache перешёл на потоковую модель, которая улучшила производительность. Тем не менее, он не мог обрабатывать [10 000 одновременных соединений](https://en.wikipedia.org/wiki/C10k_problem). Архитектура «один поток на соединение» требует 1000 потоков для обслуживания 1000 одновременных подключений. У каждого потока собственный стек и состояние, его должен запланировать и запустить шедулер операционной системы. Это отнимает время.
Напротив, [Nginx](https://www.nginx.com/) с самого начала использовал [шаблон реактора](https://en.wikipedia.org/wiki/Reactor_pattern). Это позволило обрабатывать больше одновременных соединений и сделало его невосприимчивым к [атакам Slowloris](https://en.wikipedia.org/wiki/Slowloris_%28computer_security%29).
Nginx вышел в 2007 году, и его преимущество в производительности было очевидным. За несколько лет до выхода Nginx разработчики Apache начали перепроектировать httpd для улучшения производительности. [Многопроцессный модуль event](https://httpd.apache.org/docs/2.4/mod/event.html) вышел с Apache 2.2 в 2005 году. Но обнаружились проблемы совместимости. Хуже всего, что он сломал совместимость с популярными модулями, такими как mod\_php. Проблему не могли исправить до 2012 года, когда Apache 2.4 вышел с этим модулем (MPM) по умолчанию. Хотя он работал гораздо лучше, чем предыдущий [prefork](https://httpd.apache.org/docs/2.4/mod/prefork.html) и [MPM-воркер](https://httpd.apache.org/docs/2.4/mod/worker.html), но так и не смог сравняться по производительности с Nginx. Вместо шаблона реактора Apache использовал отдельные пулы потоков для прослушивания/приёма соединений и обработки запросов. Архитектура примерно эквивалентна запуску балансировщика нагрузки или обратного прокси перед воркером MPM httpd[2](#2).
CPython GIL
===========
Python — хороший язык программирования. Он выразителен, прост в освоении (по крайней мере, для языка программирования) и поддерживается на разных платформах. Но в течение последних двух десятилетий у самой популярной реализации Python была серьёзная проблема: она не могла легко воспользоваться преимуществами нескольких процессорных ядер.
Причина в глобальной блокировке интерпретатора или GIL. Из [питоновского вики](https://wiki.python.org/moin/GlobalInterpreterLock):
> В CPython глобальная блокировка интерпретатора — это мьютекс, который блокирует одновременное выполнение нескольких потоков кода. Такая блокировка необходима главным образом потому, что управление памятью CPython не является потокобезопасным. (Но поскольку GIL существует, другие функции стали зависеть от него).
Первоначально GIL не представлял особой проблемы. При создании Python многоядерные системы встречались редко. А GIL было легко написать и это простая, логичная система. Но сегодня многоядерные процессоры работают даже в наручных часах. GIL — очевидный и вопиющий дефект во всех отношениях приятного языка. Несмотря на популярность CPython, несмотря на талантливых разработчиков, несмотря на спонсоров, таких как Google, Microsoft и Intel, [исправлять GIL даже не планируется](https://docs.python.org/3.3/faq/library.html#can-t-we-get-rid-of-the-global-interpreter-lock).
Заключение
==========
Даже при наличии талантливых инженеров, большого количества денег и чёткого плана зрелое программное обеспечение чрезвычайно трудно изменить. Я пытался найти случаи, которые опровергают деградацию ПО, но их, похоже, не существует. Робин Хэнсон [попросил привести контрпримеры](https://twitter.com/robinhanson/status/616982698305974272), но никто не предложил ничего убедительного. Есть много старых программных проектов, но им не пришлось особо адаптироваться. Я реально хочу найти хорошие контрпримеры, потому что без них создаётся слишком мрачная картина перспектив программного обеспечения.
---
### Дополнительные материалы
* [Преодоление предвзятости: в чём причина деградации программного обеспечения?](http://www.overcomingbias.com/2016/06/why-does-software-rot.html)
* [Сюрприз: программное обеспечение деградирует!](http://www.agile-process.org/change.html)
* [Википедия: деградация программного обеспечения](https://en.wikipedia.org/wiki/Software_rot)
---
1. Цитата из статьи «Эволюция программ: процессы изменения программного обеспечения». Работа старше меня, и я не могу найти онлайн-версию. Я купил физическую копию и с трудом осилил её. Терминология странная, но выводы не слишком удивительны. [↑](#1_1)
2. Любой, кто знает устройство httpd, возразит против такого сравнения, но здесь мы жертвуем точностью ради краткости. Прошу прощения за это. [↑](#2_2) | https://habr.com/ru/post/442064/ | null | ru | null |
# RESTful запросы на основе паттерна «Команда»
На протяжении многих лет традиционным подходом было включение библиотек Alamofire (AFNetworking) в состав iOS приложения для осуществления RESTful запросов к бэкенду. И если в первой половине минувшего десятилетия это объяснялось использованием промышленных стандартов (а, фактически, никто не хотел заморачиваться с наборок сырых поделок, которые предоставила компания Apple из коробки), то в начале нынешнего десятилетия нет никаких аргументированных причин, чтоб ограничивать себя возможностями этой популярной библиотеки. А ограничения, во истину, колоссальные – с точки зрения RESTful – его работа – тривиальная и предсказуемая, но вот методы использования, обусловленные Clean архитектурой Боба Мартина – вызывают дикую головную боль почти к любого разработчика, который приходит на проект. Благие намерения отделить роутинг от сериализации / десериализации приводят к невероятному разрастанию классов и зависимостей слоев, не смотря на то, что изначально, Clean архитектура декларировала то, что она предназначена для того, чтоб избегать таких зависимостей. Однажды пришлось столкнуться с ситуацией - для того чтоб добавить Post запрос необходимо было внести изменение в 11 фалов проекта!
Apple тоже заметили эту порочную тенденцию, и вместе с реализацией асинхронности через await преложила свой подход с использованием комбаина. Вот только не учла ригидности человеческой психики – те кто раньше создавали десяток слоев для выполнения сетевых запросов, сейчас сократили их до 3-4, но создали при этом синглтонный менеджер, длинной на несколько десятков тысяч строк кода.
Разумеется так делают не все. Но, такой подход можно встретить «сплошь и рядом». С учетом идеи о самодокументируемости кода – это едва ли не худшее решение для коллективной разработки.
Вместе с тем, гибкий и удобный подход лежит на поверхности, и вполне доступен для понимания в большом количестве книг по паттернам программирования. Целесообразность его – оставим за скобками – евангелисты любой архитектуры автоматически становятся борцами против него, так как он не соответствует их представлениям о «Чистом Коде» и низводит некоторых идолов их религий. Однако, он реально удобен. Особенно, тем кто только входит в программирование.
В известной книге «Банды четырех» были описаны три стандартных паттерна - «Стратегия», «Машина состояний» и «Команда». По сути, каждый из них выражал одну и ту же простую мысль - «делать что-то конкретное определенным образом». У «Стратегии» и «Машины состояний» отличались реализации, зато, были идентичные UML диаграммы. А вот с командой – наоборот – диаграммы отличаются сильно, зато реализация очень схожа. А принципе, ни «стратегию», ни «машину состояний» можно было бы не упоминать в рамках этого изложения, но если читатель хотя бы вскользь знаком с ними, то легко сориентируется в использовании REST запросов на основе команд – в принципе, перейти от команды к машине состояний или стратегии – это тривиальная задача – можно на пирамиду смотреть под разными углами, и видеть разные фигуры, но пирамида, при этом, по прежнему остается пирамидой.
Преимущество использование паттерна «Команда» описано во множестве источников, и нет никакой разумной необходимости повторять это здесь (не диссертацию пишем). Лишь оговоримся чего мы тим достичь идя наперекор «устоявшейся индустрии»:
* писать как можно меньше кода;
* весь код запроса должен быть изолирован – добавление новой команды не должно затрагивать другие команды ни на уровне файла, ни на уровне класса (вспоминаем принцип открыто-закрытой реализации);
* код запроса должен быть легко доступен и легко читаем;
* все изменения должны происходить в одном месте;
* запросы должны выполняться асинхронно, и многопоточно.
* память должна высвобождаться после завершения запроса и получения необходимых данных с севера.
Бонусом от паттерна «Команда» мы получаем следующие свойства:
1. Созданная команда может быть передана в любое место приложение и выполнена в нужное для этого время.
2. Интерфейс команды стандартизирован. Зная механизм работы одной команды - можно выполнить все остальные команды.
3. Все команды, потенциально, могут быть размещены в любой из коллекций (массив, словарь, сет и т. д.) и выполнены из этой коллекции в произвольном порядке.
Общий минимальный алгоритм работы с командой сводится к следующему:
1. Создать нужную команду.
2. Передать в нее данные.
3. Выполнить команду.
В рамках паттерна возврат результатов работы не рассматривается, но мы его, конечно же реализуем. Однако, следует отметить, что бывают случаи когда он не требуется, или результат требуется не в том месте, где происходит вызов команды.
К примеру, мы хотим вызывать сетевой запрос из контроллера или модели данных (да, это дурной тон, с точки зрения некоторых евангелистов, но такой подход весьма популярен). При этом, для некоторых запросов сервер всего лишь отвечает кодом «200». Нет ошибки – нет проблемы. После выполнения запроса нам не нужно ничего делать. Или, в другом случае, сервер нам что-то возвращает. Но это что-то не должно отображаться во вью-контроллере, или использоваться вью-моделью. В этом случае команда может сохранить результат своей работы в базу данных. А вот база данных, выполнит необходимое уведомление UI. Причем, вся работа по запросу, получению ответа, сохранению в хранилище выполнится в фоновом потоке. В UI же пользователь получит данные только тогда, когда они будут готовы, причем, в потоке предназначенном для этого.
В мобильной разработке, в основном, применяются GET и POST запросы. Разумеется, другие типы запросов тоже можно реализовать, но принципиально, с точки зрения клиентского приложения, они не отличаются от POST запросов. А вот GET и POST традиционно отличаются в сценариях использования.
В GET запросах параметры передаются либо в пути самого запроса, либо в виде query параметров (все что идет за знаком «?» в URL). GET запрос, обычно, не имеет параметров в теле запроса.
POST наоборот – редко использует параметры в пути запроса или query параметры, зато очень часто передает данные в теле запроса.
Эти небольшие отличия приводят к тому, что создание команд для GET и POST запросов очень схоже, но не идентично. Отличия – чисто традиционные. Могут найтись бэкенд-разработчики, которые ограничиваются каким-то одним типом запросов, или разные типы приводят к полностью идентичному виду. Кроме того, HTTP запросы имеют развитую систему заголовков, через которые передаются данные аутентификации. Как правило, они идентичны для одного и того же приложения или сервиса.
Соответственно, прослеживается схема построения команды.
**GET:**
1. Создание класса команды.
2. Установка пути ресурса (URL запроса).
3. Установка query параметров.
4. Выполнение запроса,
5. Получение сериализованного ответа.
6. Десериализация ответа.
7. Сохраняем результат.
**POST:**
1. Создание класса команды.
2. Создание типа параметров
3. Установка пути ресурса (URL запроса).
4. Установка (задание) параметров.
5. Выполнение запроса,
6. Получение сериализованного ответа.
7. Десериализация ответа.
8. Сохраняем результат
Все очень похоже.
Новички в разработке часто путаются с сериализацией и десериализацией и зачем оно нужно.
Десериализированный объект – это объект который находится в памяти Вашего устройства (телефона или компьютера) также как любой экземпляр класса – т. е. сугубо в двоичном виде.
Сериализированный объект – это объект, который прошел такую предварительную обработку, которая позволяет передать его по сети без потерь. Для этого, обычно, его вначале превращают в JSON, а потом JSON превращают в Data (т. е. в массив байт). При получении – такой объект разворачивают в обратном порядке.
Чтоб упростить задачу программирования (ранее, в эпоху до Swift 4 это была нетривиальная процедура) в настоящее время используются протоколы Encodable и Decodable. Сочетание обоих протоколов обозначается Codable.
Другими словами, то что мы отправляем должно соответствовать протоколу Encodable, а то что получаем - Decodable. Если не хотим задумываться о том, что нам нужно – используем Codable.
**GET:**
```
import Foundation
class ExampleGetRequest : NetworkBase {
// MARK: - Types
// MARK: - Variables
override var command: String { return "get?test=\(self.arg)" }
private (set) var arg = ""
private (set) var result:GetResponse?
func request(arg: String) {
self.arg = arg
self.request(type:.GET)
}
override func receiveData(data:Data) {
if let response:GetResponse = self.parse(data: data) {
self.result = response
print(response)
}
}
}
```
POST:
```
import Foundation
class ExamplePostRequest : NetworkBase {
// MARK: - Types
struct Params: Encodable {
let arg: String
let name: String
let age: Int
}
// MARK: - Variables
override var command: String { return "post" }
private (set) var result:PostResponse?
func request(arg: String, name: String, age: Int) {
let params = Params(arg: arg, name: name, age: age)
self.request(type:.POST, params: params)
}
override func receiveData(data:Data) {
if let response:PostResponse = self.parse(data: data) {
self.result = response
print(response)
}
}
}
```
Вся магия происходит в базовом классе. Теперь рассмотрим как эти команды можно использовать.
В демонстрационном приложении команды вызываются в трех вариантах:
1. GET без обработки результата.
2. GET с обработкой результата.
3. POST с обработкой результата.
```
func shortGetRequest() {
let param = "SHORT get request completed"
ExampleGetRequest().request(arg: param)
self.result = ""
}
```
```
func getRequest() {
let param = "GET request with callback completed"
ExampleGetRequest().callback() {[weak self] request in
guard let request = request as? ExampleGetRequest else { return }
guard let self else { return }
main {
self.result = request.result?.args["test"] ?? ""
}
}.request(arg: param)
}
```
```
func postRequest() {
let desc = "POST request with callback completed"
ExamplePostRequest().callback() {[weak self] request in
guard let request = request as? ExamplePostRequest else { return }
guard let self else { return }
guard let name = request.result?.data.name,
let age = request.result?.data.age,
let desc = request.result?.data.arg else { return }
main {
self.result = "\(name), \(age)\n\(desc)"
}
}.request(arg: desc, name: "John", age: 44)
}
```
Само по себе API довольно бесполезное – это API предназначенное для тестирования Postman. Каждая из реализованных команд возвращает то, что мы отправляем на сервер. API позволяет отладить классы, которы мы используем в приложении.
Полученные данные с сервера команды выводят в консоль после десериализации. Для случаев, когда мы делаем обработку команды в функции обратного вызова – мы обновляем наш UI полученными данными.
Формально, паттерн «команда» требует унифицированный подход для активации команды. Но при этом, согласно требований паттерна, в команду, предварительно, нужно передать данные. После чего уже можно передавать сам объект команды. И у нас такая возможность сохраняется. Но, как правило, это редко требуется в строгом соответствии с требованием паттерна. Мы немного упрощаем себе задачу тем, что активируем команду тем же методом, которым передаем данные в команду. И по той же причине, мы не храним данные запроса, а размещаем их перед самой активацией. Но, потенциально эта возможность присутствует, и мы можем ей воспользоваться, если появится в этом потребность.
Ответ в callback нам возвращается от абстрактной команды. Но мы всегда можем ее привести в конкретному виду через рефлексию. И уже после этого можно извлечь полученные от сервера данные.
Хотелось бы обратить внимание, что данные в callback приходят в бэкграунд потоке. Потому, если из callback осуществляется взаимодействие с пользовательским интерфейсом, следует обязательно перейти в главный поток.
Важным обстоятельством является то, что к моменту получения данных класс в котором происходит вызов команды может уже не существовать. В таком случае обращение к объектам класса может вызвать креш приложения. Поэтому, в обязательном порядке нужно делать проверку weak замыкания:
**If let self else { return }** // swift 5.7 до безобразия упрощает такую проверку.
Ответы от сервера довольно тривиальные, и легко парсятся, за исключением внутренней структуры Headers. Для Get и Post запроса были созданы структуры ответов. И обе структуры содержат объект Headers. Сложность последней заключается в том, что в Swift нельзя использовать поля с теми названиями, которые приходят в ответе.Для этого нужно их перемапить. И протокол Codable позволяет сделать реализацию этого маппинга.
```
import Foundation
struct Headers: Codable {
let host: String
let accept: String
let aEncoding: String
enum CodingKeys: String, CodingKey {
case host
case accept
case acceptEncoding = "accept-encoding"
}
func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encode(host, forKey: .host)
try container.encode(accept, forKey: .accept)
try container.encode(aEncoding, forKey: .acceptEncoding)
}
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
host = try container.decode(String.self, forKey: .host)
accept = try container.decode(String.self, forKey: .accept)
aEncoding = try container.decode(String.self, forKey: .acceptEncoding)
}
}
```
Поле «accept-encoding» позволяет увидеть еще одну важную особенность работы команды – если поставить пробел внутри строкового представления, то код скомпилируется, но при запросе с сервера данных – произойдет ошибка. Уведомление об ошибке появится в консоли, а так же, будет выведено сообщение, с каким именно полем возникла проблема.
Бывает довольно полезно узнать как долго выполнялся запрос к серверу. Для этого к консоль выводится время, затраченное командой от момента запроса, до обратного вызова. Это чисто утилитарная функция, не несущая особого смысла. Точно так же можно добавить длительность сохранения данных, если Вы используете CoreData. Но. Как правило, оно составляет микросекунды, и ни на что в рамках клиентского приложения не влияет.
Когда-то, в далекие-далекие времена, когда iOS была совсем юной, на разработку запроса к серверу, уходили часы, и это было вполне оправдано. Теперь, используя командных подход, время создания команды исчисляется в секундах.
[Исходный код доступен на GitHub.](https://github.com/DemonSoft/RestNetworking)
[Обсудить можно на телеграмм канале.](https://t.me/+TjI9YXI0EXZ190Ht) | https://habr.com/ru/post/697262/ | null | ru | null |
# Рецепты для ELFов
На русском языке довольно мало информации про то, как работать с ELF-файлами (Executable and Linkable Format — основной формат исполняемых файлов Linux и многих Unix-систем). Не претендуем на полное покрытие всех возможных сценариев работы с эльфами, но надеемся, что информация будет полезна в виде справочника и сборника рецептов для программистов и реверс-инженеров.
Подразумевается, что читатель на базовом уровне знаком с форматом ELF (в противном случае рекомендуем цикл статей [Executable and Linkable Format 101](http://www.intezer.com/executable-linkable-format-101-part1-sections-segments/)).
Под катом будут перечислены инструменты для работы, описаны приемы для чтения метаинформации, модификации, проверки и ~~размножения~~ создания эльфов, а также приведены ссылки на полезные материалы.
> — Я тоже эльф… Синий в красный… Эльфы очень терпеливы… Синий в красный… А мы эльфы!.. Синий в красный… От магии одни беды…
>
> (с) Маленькое королевство Бена и Холли
Инструменты
===========
В большинстве случаев примеры можно выполнить как на Linux, так и на Windows.
В рецептах мы будем использовать следующие инструменты:
* утилиты из набора binutils (objcopy, objdump, readelf, strip);
* фреймворк [radare2](https://www.radare.org/r/);
* hex-редактор с поддержкой шаблонов файлов (в примерах показан [010Editor](https://www.sweetscape.com/010editor/), но можно использовать, например, свободный [Veles](https://codisec.com/veles/));
* Python и библиотеку [LIEF](https://lief.quarkslab.com/);
* другие утилиты (ссылки указаны в рецепте).
Тестовые эльфы
==============
В качестве «подопытного» будем использовать ELF-файл *simple* из таска [nutcake's PieIsMyFav](https://crackmes.one/crackme/5c11e1f333c5d41e58e00579) на crackmes.one, но подойдёт любой представитель «эльфийского» семейства. Если готовый файл с требуемыми характеристиками не был найден в свободном доступе, то будет приведён способ создания такого эльфа.
«Свободных» эльфов можно также найти по ссылкам:
* [Примеры эльфов для разных платформ](https://github.com/JonathanSalwan/binary-samples);
* [Тестовые эльфы для radare2](https://github.com/radare/radare2-regressions/tree/master/bins/elf);
* [Проект ElfHacks на Github](https://github.com/MaskRay/ElfHacks/) — подборка небольших эльфов с разными настройками;
* [Crackme для Unix/Linux](https://crackmes.one) — но стоит учитывать, что тут могут попадаться хитрые образцы.
Чтение, получение информации
============================
Тип файла, заголовок, секции
----------------------------
В зависимости от задачи интерес могут представлять:
* тип файла (DYN — библиотека, EXEC — исполняемый, RELOC — линкуемый);
* целевая архитектура (E\_MACHINE — x86\_64, x86, ARM и т.д.);
* точка входа в приложение (Entry Point);
* информация о секциях.
### 010Editor
HEX-редактор 010Editor предоставляет систему шаблонов. Для ELF-файлов шаблон называется, как ни странно, *ELF.bt* и находится в категории *Executable* (меню Templates — Executable).
Интерес может представлять, например, точка входа в исполняемый файл (entry point) (записана в заголовке файла).
### readelf
Утилиту *readelf* можно считать стандартом де-факто для получения сведений об ELF-файле.
* Прочитать заголовок файла:
```
$ readelf -h simple
```
**Результат команды**
```
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: DYN (Shared object file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x1070
Start of program headers: 64 (bytes into file)
Start of section headers: 14800 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 56 (bytes)
Number of program headers: 11
Size of section headers: 64 (bytes)
Number of section headers: 30
Section header string table index: 29
```
* Прочитать информацию о сегментах и секциях:
```
$ readelf -l -W simple
```
**Результат команды**Для удобства чтения адреса приведены к 32-битному формату:
```
Elf file type is DYN (Shared object file)
Entry point 0x1070
There are 11 program headers, starting at offset 64
Program Headers:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
PHDR 0x000040 0x00000040 0x00000040 0x000268 0x000268 R 0x8
INTERP 0x0002a8 0x000002a8 0x000002a8 0x00001c 0x00001c R 0x1
[Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
LOAD 0x000000 0x00000000 0x00000000 0x0005f8 0x0005f8 R 0x1000
LOAD 0x001000 0x00001000 0x00001000 0x00026d 0x00026d R E 0x1000
LOAD 0x002000 0x00002000 0x00002000 0x0001b8 0x0001b8 R 0x1000
LOAD 0x002de8 0x00003de8 0x00003de8 0x000258 0x000260 RW 0x1000
DYNAMIC 0x002df8 0x00003df8 0x00003df8 0x0001e0 0x0001e0 RW 0x8
NOTE 0x0002c4 0x000002c4 0x000002c4 0x000044 0x000044 R 0x4
GNU_EH_FRAME 0x002070 0x00002070 0x00002070 0x00003c 0x00003c R 0x4
GNU_STACK 0x000000 0x00000000 0x00000000 0x000000 0x000000 RW 0x10
GNU_RELRO 0x002de8 0x00003de8 0x00003de8 0x000218 0x000218 R 0x1
Section to Segment mapping:
Segment Sections...
00
01 .interp
02 .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt
03 .init .plt .plt.got .text .fini
04 .rodata .eh_frame_hdr .eh_frame
05 .init_array .fini_array .dynamic .got .got.plt .data .bss
06 .dynamic
07 .note.ABI-tag .note.gnu.build-id
08 .eh_frame_hdr
09
10 .init_array .fini_array .dynamic .got
```
* Прочитать информацию о секциях:
```
$ readelf -S -W simple
```
**Результат команды**Для удобства чтения адреса приведены к 32-битному формату:
```
There are 30 section headers, starting at offset 0x39d0:
Section Headers:
[Nr] Name Type Address Off Size ES Flg Lk Inf Al
[ 0] NULL 00000000 000000 000000 00 0 0 0
[ 1] .interp PROGBITS 000002a8 0002a8 00001c 00 A 0 0 1
[ 2] .note.ABI-tag NOTE 000002c4 0002c4 000020 00 A 0 0 4
[ 3] .note.gnu.build-id NOTE 000002e4 0002e4 000024 00 A 0 0 4
[ 4] .gnu.hash GNU_HASH 00000308 000308 000024 00 A 5 0 8
[ 5] .dynsym DYNSYM 00000330 000330 0000d8 18 A 6 1 8
[ 6] .dynstr STRTAB 00000408 000408 0000a2 00 A 0 0 1
[ 7] .gnu.version VERSYM 000004aa 0004aa 000012 02 A 5 0 2
[ 8] .gnu.version_r VERNEED 000004c0 0004c0 000030 00 A 6 1 8
[ 9] .rela.dyn RELA 000004f0 0004f0 0000c0 18 A 5 0 8
[10] .rela.plt RELA 000005b0 0005b0 000048 18 AI 5 23 8
[11] .init PROGBITS 00001000 001000 000017 00 AX 0 0 4
[12] .plt PROGBITS 00001020 001020 000040 10 AX 0 0 16
[13] .plt.got PROGBITS 00001060 001060 000008 08 AX 0 0 8
[14] .text PROGBITS 00001070 001070 0001f2 00 AX 0 0 16
[15] .fini PROGBITS 00001264 001264 000009 00 AX 0 0 4
[16] .rodata PROGBITS 00002000 002000 000070 00 A 0 0 8
[17] .eh_frame_hdr PROGBITS 00002070 002070 00003c 00 A 0 0 4
[18] .eh_frame PROGBITS 000020b0 0020b0 000108 00 A 0 0 8
[19] .init_array INIT_ARRAY 00003de8 002de8 000008 08 WA 0 0 8
[20] .fini_array FINI_ARRAY 00003df0 002df0 000008 08 WA 0 0 8
[21] .dynamic DYNAMIC 00003df8 002df8 0001e0 10 WA 6 0 8
[22] .got PROGBITS 00003fd8 002fd8 000028 08 WA 0 0 8
[23] .got.plt PROGBITS 00004000 003000 000030 08 WA 0 0 8
[24] .data PROGBITS 00004030 003030 000010 00 WA 0 0 8
[25] .bss NOBITS 00004040 003040 000008 00 WA 0 0 1
[26] .comment PROGBITS 00000000 003040 00001c 01 MS 0 0 1
[27] .symtab SYMTAB 00000000 003060 000630 18 28 44 8
[28] .strtab STRTAB 00000000 003690 000232 00 0 0 1
[29] .shstrtab STRTAB 00000000 0038c2 000107 00 0 0 1
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings), l (large)
I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
O (extra OS processing required) o (OS specific), p (processor specific)
```
* Прочитать информацию о символах:
```
$ readelf -s -W simple
```
**Результат команды**Вывод сокращён для удобства чтения:
```
Symbol table '.dynsym' contains 9 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterTMCloneTable
2: 00000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.2.5 (2)
3: 00000000 0 FUNC GLOBAL DEFAULT UND printf@GLIBC_2.2.5 (2)
4: 00000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.2.5 (2)
5: 00000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__
6: 00000000 0 FUNC GLOBAL DEFAULT UND __isoc99_scanf@GLIBC_2.7 (3)
7: 00000000 0 NOTYPE WEAK DEFAULT UND _ITM_registerTMCloneTable
8: 00000000 0 FUNC WEAK DEFAULT UND __cxa_finalize@GLIBC_2.2.5 (2)
Symbol table '.symtab' contains 66 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 000002a8 0 SECTION LOCAL DEFAULT 1
2: 000002c4 0 SECTION LOCAL DEFAULT 2
3: 000002e4 0 SECTION LOCAL DEFAULT 3
4: 00000308 0 SECTION LOCAL DEFAULT 4
5: 00000330 0 SECTION LOCAL DEFAULT 5
6: 00000408 0 SECTION LOCAL DEFAULT 6
7: 000004aa 0 SECTION LOCAL DEFAULT 7
....
26: 00000000 0 SECTION LOCAL DEFAULT 26
27: 00000000 0 FILE LOCAL DEFAULT ABS crtstuff.c
28: 000010a0 0 FUNC LOCAL DEFAULT 14 deregister_tm_clones
29: 000010d0 0 FUNC LOCAL DEFAULT 14 register_tm_clones
30: 00001110 0 FUNC LOCAL DEFAULT 14 __do_global_dtors_aux
31: 00004040 1 OBJECT LOCAL DEFAULT 25 completed.7389
....
```
Опция `-W` нужна для увеличения ширины консольного вывода (по умолчанию, 80 символов).
### LIEF
Прочитать заголовок и информацию о секциях можно с использованием кода на Python и библиотеки LIEF (предоставляет API не только для Python):
```
import lief
binary = lief.parse("simple.elf")
header = binary.header
print("Entry point: %08x" % header.entrypoint)
print("Architecture: ", header.machine_type)
for section in binary.sections:
print("Section %s - size: %s bytes" % (section.name, section.size)
```
Информация о компиляторе
------------------------
Для получения информации о компиляторе и сборке следует смотреть секции `.comment` и `.note`.
### objdump
```
$ objdump -s --section .comment simple
```
**Результат команды**
```
simple: file format elf64-x86-64
Contents of section .comment:
0000 4743433a 20284465 6269616e 20382e32 GCC: (Debian 8.2
0010 2e302d39 2920382e 322e3000 .0-9) 8.2.0.
```
### readelf
```
$ readelf -p .comment simple
```
**Результат команды**
```
String dump of section '.comment':
[ 0] GCC: (Debian 8.2.0-9) 8.2.0
```
```
$ readelf -n simple
```
**Результат команды**
```
Displaying notes found at file offset 0x000002c4 with length 0x00000020:
Owner Data size Description
GNU 0x00000010 NT_GNU_ABI_TAG (ABI version tag)
OS: Linux, ABI: 3.2.0
Displaying notes found at file offset 0x000002e4 with length 0x00000024:
Owner Data size Description
GNU 0x00000014 NT_GNU_BUILD_ID (unique build ID bitstring)
Build ID: dae0509e4edb79719a65af37962b74e4cf2a8c2e
```
### LIEF
```
import lief
binary = lief.parse("simple")
comment = binary.get_section(".comment")
print("Comment: ", bytes(comment.content))
```
Я вычислю тебя по… RPATH
------------------------
Эльфы могут сохранять пути для поиска динамически подключаемых библиотек. Чтобы не задавать системную переменную `LD_LIBRARY_PATH` перед запуском приложения, можно просто «вшить» этот путь в ELF-файл.
Для этого используется запись в секции `.dynamic` с типом `DT_RPATH` или `DT_RUNPATH` (см. главу [Directories Searched by the Runtime Linker](https://docs.oracle.com/cd/E26505_01/html/E26506/chapter6-63352.html#chapter3-10898) в документации).
**И будь осторожен, юный разработчик, не «спали» свою директорию проекта!**
### Как появляется RPATH?
Основная причина появления RPATH-записи в эльфе — опция `-rpath` линковщика для поиска динамической библиотеки. Примерно так:
```
$ gcc -L./lib -Wall -Wl,-rpath=/run/media/pablo/disk1/projects/cheat_sheets/ELF/lib/ -o test_rpath.elf bubble_main.c -lbubble
```
Такая команда создаст в секции `.dynamic` RPATH-запись со значением `/run/media/pablo/disk1/projects/cheat_sheets/ELF/lib/`.
### readelf
Посмотреть элементы из секции `.dynamic` (среди которых есть и RPATH) можно так:
```
$ readelf -d test_rpath.elf
```
**Результат команды**Для удобства чтения результат команды сокращён:
```
Dynamic section at offset 0x2dd8 contains 28 entries:
Tag Type Name/Value
0x0000000000000001 (NEEDED) Shared library: [libbubble.so]
0x0000000000000001 (NEEDED) Shared library: [libc.so.6]
0x000000000000000f (RPATH) Library rpath: [/run/media/pablo/disk1/projects/cheat_sheets/ELF/lib/]
0x000000000000000c (INIT) 0x1000
0x000000000000000d (FINI) 0x11c8
....
```
### LIEF
С помощью библиотеки LIEF также можно прочитать RPATH-запись в эльфе:
```
import lief
from lief.ELF import DYNAMIC_TAGS
elf = lief.parse("test_rpath.elf")
if elf.has(DYNAMIC_TAGS.RPATH):
rpath = next(filter(lambda x: x.tag == DYNAMIC_TAGS.RPATH, elf.dynamic_entries))
for path in rpath.paths:
print(path)
else:
print("No RPATH in ELF")
```
[Почитать про секцию .dynamic](https://docs.oracle.com/cd/E26505_01/html/E26506/chapter6-42444.html)
Проверка эльфа на безопасность
------------------------------
Скрипт проверки безопасности [checksec.sh](https://www.trapkit.de/tools/checksec.html) от исследователя Tobias Klein (автора книги [A Bug Hunter's Diary](https://nostarch.com/bughunter)) не обновлялся с 2011 года. Данный скрипт для ELF-файлов выполняет проверку наличия опций RelRO (Read Only Relocations), NX (Non-Executable Stack), Stack Canaries, PIE (Position Independent Executables) и для своей работы использует утилиту *readelf*.
### LIEF
Можно сделать свой аналог на ~~коленке~~ Python и LIEF (чуть короче прародителя и с дополнительной проверкой опции [separate-code](https://habr.com/ru/company/dsec/blog/433108/)):
```
import lief
from lief.ELF import DYNAMIC_TAGS, SEGMENT_TYPES
def filecheck(filename):
binary = lief.parse(filename)
# check RELRO
if binary.has(SEGMENT_TYPES.GNU_RELRO):
print("+ Full RELRO") if binary.has(DYNAMIC_TAGS.BIND_NOW) else print("~ Partial RELRO")
else:
print("- No RELRO")
# check for stack canary support
print("+ Canary found") if binary.has_symbol("__stack_chk_fail") else print("- No canary found")
# check for NX support (check X-flag for GNU_STACK-segment)
print("+ NX enabled") if binary.has_nx else print("- NX disabled")
# check for PIE support
print("+ PIE enabled") if binary.is_pie else print("- No PIE")
# check for rpath / run path
print("+ RPATH") if binary.has(DYNAMIC_TAGS.RPATH) else print("- No RPATH")
print("+ RUNPATH")if binary.has(DYNAMIC_TAGS.RUNPATH) else print("- No RUNPATH")
# check separate-code option
if set(binary.get_section('.text').segments) == set(binary.get_section('.rodata').segments):
print("- Not Separated Code Sections")
else:
print("+ Separated Code Sections")
filecheck('test_rpath.elf')
```
### Radare2
Спасибо [dukebarman](https://habr.com/ru/users/dukebarman/) за дополнение по использованию Radare2 для вывода информации аналогично *checksec*:
```
> r2 -c i~pic,canary,nx,crypto,stripped,static,relocs test_stack_proteck
```
«Сырой код» из эльфа (binary from ELF)
--------------------------------------
Бывают ситуации, когда «эльфийские одёжи» в виде ELF-структуры не нужны, а нужен только «голый» исполняемый код приложения.
### objcopy
Использование *objcopy* вероятно знакомо тем, кто пишет прошивки:
```
$ objcopy -O binary -S -g simple.elf simple.bin
```
* `-S` — для удаления символьной информации;
* `-g` — для удаления отладочной информации.
### LIEF
Никакой магии. Просто взять содержимое загружаемых секций и слепить из них бинарь:
```
import lief
from lief.ELF import SECTION_FLAGS, SECTION_TYPES
binary = lief.parse("test")
end_addr = 0
data = []
for section in filter(lambda x: x.has(SECTION_FLAGS.ALLOC) and
x.type != SECTION_TYPES.NOBITS,
binary.sections):
if 0 < end_addr < section.virtual_address:
align_bytes = b'\x00' * (section.virtual_address - end_addr)
data.append(align_bytes)
data.append(bytes(section.content))
end_addr = section.virtual_address + section.size
with open('test.lief.bin', 'wb') as f:
for d_bytes in data:
f.write(d_bytes)
```
Mangled — demangled имена функций
---------------------------------
В ELF-ах, созданных из С++ кода, имена функций декорированы (манглированы) для упрощения поиска соответствующей функции класса. Однако читать такие имена при анализе не очень удобно.
[Тестовый эльф](https://github.com/radare/radare2-regressions/blob/master/bins/elf/demangle-test-cpp)
### nm
Для представления имён в удобочитаемом виде можно использовать утилиту [nm](https://sourceware.org/binutils/docs/binutils/nm.html) из набора binutils:
```
# Тут имена функций выводятся в манглированном виде
$ nm -D demangle-test-cpp
...
U _Unwind_Resume
U _ZdlPv
U _Znwm
U _ZSt17__throw_bad_allocv
U _ZSt20__throw_length_errorPKc
# Тут имена функций выводятся в читаемом виде
$ nm -D --demangle demangle-test-cpp
...
U _Unwind_Resume
U operator delete(void*)
U operator new(unsigned long)
U std::__throw_bad_alloc()
U std::__throw_length_error(char const*)
```
### LIEF
Вывод имён символов в деманглированном виде с использованием библиотеки LIEF:
```
import lief
binary = lief.parse("demangle-test-cpp")
for symb in binary.symbols:
print(symb.name, symb.demangled_name)
```
Сборка, запись, модификация эльфа
=================================
Эльф без метаинформации
-----------------------
После того как приложение отлажено и выпускается в дикий мир, имеет смысл удалить метаинформацию:
* отладочные секции — бесполезны в большинстве случаев;
* имена переменных и функций — совершенно ни на что не влияют для конечного пользователя (чуть усложняет реверс);
* таблица секций — совершенно не нужна для запуска приложения (её отсутсвие чуть усложнит реверс).
Удаление символьной информации
------------------------------
Символьная информация — это имена объектов и функций. Без неё реверс приложения немного усложняется.
### strip
В самом простом случае можно воспользоваться утилитой [strip](https://www.sourceware.org/binutils/docs/binutils/strip.html) из набора binutils. Для удаления всей символьной информации достаточно выполнить команду:
* для исполняемого файла:
```
$ strip -s simple
```
* для динамической библиотеки:
```
$ strip --strip-unneeded libsimple.so
```
### sstrip
Для тщательного удаления символьной информации (в том числе ненужных нулевых байтов в конце файла) можно воспользоваться утилитой sstrip из набора [ELFkickers](https://github.com/BR903/ELFkickers). Для удаления всей символьной информации достаточно выполнить команду:
```
$ sstrip -z simple
```
### LIEF
C использованием библиотеки LIEF также можно сделать быстрый strip (удаляется таблица символов — секция `.symtab`):
```
import lief
binary = lief.parse("simple")
binary.strip()
binary.write("simple.stripped")
```
Удаление таблицы секций
-----------------------
Как упоминалось выше, наличие/отсутствие таблицы секций не оказывает влияния на работу приложения. Но при этом без таблицы секций реверс приложения становится чуть сложнее.
Воспользуемся библиотекой LIEF под Python и [примером удаления таблицы секций](https://github.com/lief-project/LIEF/blob/master/examples/python/elf_remove_section_table.py):
```
import lief
binary = lief.parse("simple")
binary.header.numberof_sections = 0
binary.header.section_header_offset = 0
binary.write("simple.modified")
```
Изменение и удаление RPATH
--------------------------
### chrpath, PatchELF
Для изменения RPATH под Linux можно воспользоваться утилитами *chrpath* (доступна в большинстве дистрибутивов) или [PatchELF](https://nixos.org/patchelf.html).
* Изменить RPATH:
```
$ chrpath -r /opt/my-libs/lib:/foo/lib test_rpath.elf
```
или
```
$ patchelf --set-rpath /opt/my-libs/lib:/foo/lib test_rpath.elf
```
* Удалить RPATH:
```
$ chrpath -d test_rpath.elf
```
или
```
$ patchelf --shrink-rpath test_rpath.elf
```
### LIEF
Библиотека LIEF также позволяет как изменить, так и удалить RPATH-запись.
* Изменить RPATH:
```
import lief
binary = lief.parse("test_rpath.elf")
rpath = next(filter(lambda x: x.tag == lief.ELF.DYNAMIC_TAGS.RPATH, binary.dynamic_entries))
rpath.paths = ["/opt/my-lib/here"]
binary.write("test_rpath.patched")
```
* Удалить RPATH:
```
import lief
binary = lief.parse("test_rpath.elf")
binary.remove(lief.ELF.DYNAMIC_TAGS.RPATH)
binary.write("test_rpath.patched")
```
Обфускация символьной информации
--------------------------------
Для усложнения реверса приложения можно сохранить символьную информацию, но запутать имена объектов. В качестве подопытного используем эльф *crackme01\_32bit* из [crackme01 by seveb](https://crackmes.one/crackme/5ab77f5e33c5d40ad448c78b).
Упрощенный вариант [примера](https://github.com/lief-project/LIEF/blob/master/examples/python/elf_symbol_obfuscation.py) из библиотеки LIEF может выглядеть так:
```
import lief
binary = lief.parse("crackme01_32bit")
for i, symb in enumerate(binary.static_symbols):
symb.name = "zzz_%d" % i
binary.write("crackme01_32bit.obfuscated")
```
В результате получим:
```
$ readelf -s crackme01_32bit.obfuscated
...
Symbol table '.symtab' contains 78 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND zzz_0
1: 08048154 0 SECTION LOCAL DEFAULT 1 zzz_1
2: 08048168 0 SECTION LOCAL DEFAULT 2 zzz_2
3: 08048188 0 SECTION LOCAL DEFAULT 3 zzz_3
4: 080481ac 0 SECTION LOCAL DEFAULT 4 zzz_4
5: 080481d0 0 SECTION LOCAL DEFAULT 5 zzz_5
6: 080482b0 0 SECTION LOCAL DEFAULT 6 zzz_6
7: 0804835a 0 SECTION LOCAL DEFAULT 7 zzz_7
8: 08048378 0 SECTION LOCAL DEFAULT 8 zzz_8
9: 080483b8 0 SECTION LOCAL DEFAULT 9 zzz_9
10: 080483c8 0 SECTION LOCAL DEFAULT 10 zzz_10
...
```
Подмена функций через PLT/GOT
-----------------------------
Также известная как [ELF PLT INFECTION](http://phrack.org/issues/56/7.html).
Дабы не копипастить, просто оставим ссылки по теме:
* [Перенаправление функций в разделяемых ELF-библиотеках](https://habr.com/ru/post/106107/)
* [Infecting the plt/got with LIEF](https://lief.quarkslab.com/doc/latest/tutorials/05_elf_infect_plt_got.html)
Изменить точку входа
--------------------
Может быть полезно при создании патчей, установке хуков и прочей динамической инструментации, ну или для вызова скрытых функций. В качестве подопытного используем эльфа crackme01\_32bit из [crackme01 by seveb](https://crackmes.one/crackme/5ab77f5e33c5d40ad448c78b)
### radare2
radare2 запускается в режиме записи (опция `-w`) — изменения будут внесены в оригинальный файл:
```
$ ./crackme01_32bit
Please enter the secret number: ^C
$ r2 -w -nn crackme01_32bit
[0x00000000]> .pf.elf_header.entry=0x0804860D
[0x00000000]> q
$ ./crackme01_32bit
Nope.
```
### LIEF
```
import lief
binary = lief.parse("crackme01_32bit")
header = binary.header
header.entrypoint = 0x0804860D
binary.write("crackme01_32bit.patched")
```
Патчинг кода
------------
В качестве простого подопытного возьмём крякми [novn91's crackmepal](https://crackmes.one/crackme/5ccecc7e33c5d4419da559b3). При запуске без параметров программка выводит:
```
$ ./crackmeMario
usage
```
При запуске с параметром-произвольной строкой выдаётся:
```
./crackmeMario qwerty
try again pal.
```
Сделаем патч, чтобы программа сразу при запуске выводила сообщение «good job! now keygen me!»
### radare2
radare2 умеет патчить любые форматы, которые сам поддерживает. При этом имеется возможность описывать патчи в текстовом формате:
```
# Rapatch for https://crackmes.one/crackme/5ccecc7e33c5d4419da559b3
!echo Patching crackme
0x115D : jmp 0x1226
```
Применить такой патч можно командой:
```
$ r2 -P patch.txt crackmeMario
```
Почитать про патчинг кода через radare2:
* [Binary Patching Using Radare2 by wolfshirtz](https://rayoflightz.github.io/linux/assembly/2019/03/26/Binary-patching-using-radare2.html)
* [Radare2 Explorations. Tutorial 1 — Simple Patch](https://monosource.gitbooks.io/radare2-explorations/content/tut1/tut1_-_simple_patch.html)
* [Ground Zero: Part 3-2 – Reverse Engineering – Patching Binaries with Radare2 – ARM64](https://scriptdotsh.com/index.php/2018/08/13/reverse-engineering-patching-binaries-with-radare2-arm-aarch64/)
### LIEF
LIEF позволяет патчить эльф (перезаписать байты) по указанному виртуальному адресу. Патч может быть в виде массива байт или в виде целочисленного значения:
```
import lief
binary = lief.parse("crackmeMario")
binary.patch_address(0x115D, bytearray(b"\xe9\xc4\x00\x00\x00"))
binary.write("crackmeMario.patched")
```
После применения патча программа будет выводить:
```
$ ./crackmeMario.patched
good job! now keygen me!
```
Добавить секцию в ELF
---------------------
### objcopy
*objcopy* позволяет добавить секцию, но эта секция не будет относиться ни к одному сегменту и не будет загружаться в ОЗУ при запуске приложения:
```
$ objcopy --add-section .testme=data.zip \
--set-section-flags .testme=alloc,contents,load,readonly \
--change-section-address .testme=0x08777777 \
simple simple.patched.elf
```
### LIEF
Библиотека LIEF позволяет добавить новую секцию и соответствующий ей сегмент (флаг **`loaded=True`**) в имеющийся ELF:
```
import lief
binary = lief.parse("simple")
data = bytearray(b"\xFF" * 16)
section = lief.ELF.Section(".testme", lief.ELF.SECTION_TYPES.PROGBITS)
section += lief.ELF.SECTION_FLAGS.EXECINSTR
section += lief.ELF.SECTION_FLAGS.ALLOC
section.content = data
binary.add(section, loaded=True)
binary.write("simple.testme.lief")
```
Изменить секцию
---------------
### objcopy
*objcopy* позволяет заменить содержимое секции данными из файла, а также изменить виртуальный адрес секции и флаги:
```
$ objcopy --update-section .testme=patch.bin \
--change-section-address .testme=0x08999999
simple simple.testme.elf
```
### LIEF
```
import lief
binary = lief.parse("simple")
data = bytearray(b"\xFF" * 17)
section = binary.get_section(".text")
section.content = data
binary.write("simple.patched")
```
Удалить секцию
--------------
### objcopy
*objcopy* позволяет удалить определённую секцию по имени:
```
$ objcopy --remove-section .testme simple.testme.elf simple.no_testme.elf
```
### LIEF
Удаление секции с использованием библиотеки LIEF выглядит так:
```
import lief
binary = lief.parse("simple.testme.elf")
binary.remove_section(".testme")
binary.write("simple.no_testme")
```
Эльф-контейнер
--------------
Рецепт навеян статьёй [Гремлины и ELFийская магия: а что, если ELF-файл — это контейнер?](https://habr.com/ru/company/neobit/blog/332918/). Встречаются также man’ы про утилиту [elfwrap](https://docs.oracle.com/cd/E36784_01/html/E36870/elfwrap-1.html) родом из Solaris, которая позволяет создавать ELF-файл из произвольных данных, а формат ELF используется просто как контейнер.
Попробуем сделать то же самое на Python и LIEF.
К сожалению, на данный момент библиотека LIEF не умеет создавать эльф-файл c нуля, поэтому нужно ей помочь — создать пустой ELF-шаблон:
```
$ echo "" | gcc -m32 -fpic -o empty.o -c -xc -
$ gcc -m32 -shared -o libempty.so empty.o
```
Теперь можно использовать этот шаблон для наполнения данными:
```
import lief
binary = lief.parse("libempty.so")
filename = "crackme.zip"
data = open(filename, 'rb').read()
# Add section with zip-archive as content
section = lief.ELF.Section()
section.content = data
section.name = ".%s"%filename
binary.add(section, loaded=True)
# Add symbol as a reference to zip-archive
symb = lief.ELF.Symbol()
symb.type = lief.ELF.SYMBOL_TYPES.OBJECT
symb.binding = lief.ELF.SYMBOL_BINDINGS.GLOBAL
symb.size = len(data)
symb.name = filename
symb.value = section.virtual_address
binary.add_static_symbol(symb)
binary.write("libdata.crackme.container")
```
Эльф «с прицепом»
-----------------
ELF-формат не накладывает ограничений на данные, которые есть в файле, но не входят ни в один сегмент. Таким образом, можно создать исполняемый файл, у которого после ELF-структуры будет храниться *что-то*. Это *что-то* не будет загружаться в ОЗУ при исполнении, но оно будет записано на диске, и в любой момент это *что-то* можно с диска прочитать.
* *IDA Pro не будет учитывать эти данные при анализе*
*Пример структуры файла «с прицепом»*
### radare2
Наличие «прицепа» можно установить, если сравнить реальный и вычисленный размер файла:
```
$ radare2 test.elf
[0x00001040]> ?v $s
0x40c1
[0x00001040]> iZ
14699
```
### readelf
*readelf* не показывает информацию о наличии «прицепа», но можно вычислить вручную:
```
$ ls -l test.elf
# Размер файла 16577 байт
$ readelf -h test.elf
Start of section headers e_shoff 14704
Size of section headers e_shentsize 64
Number of section headers e_shnum 29
# Размер ELF-структуры: e_shoff + ( e_shentsize * e_shnum ) = 16560
```
### LIEF
Библиотека LIEF позволяет как проверить наличие «прицепа», так и добавить его. С использованием LIEF всё выглядит достаточно лаконично:
```
import lief
binary = lief.parse("test")
# check if overlay exists
print('ELF has overlay data') if binary.has_overlay else print("No overlay data")
# add overlay data to ELF
data = bytearray(b'\xFF'*17)
binary.overlay = data
binary.write('test.overlay')
```
Эльф из пустоты (ELF from scratch)
----------------------------------
На просторах интернета можно найти проекты по созданию ELF-файла «вручную» — без использования компилятора и линковщика под общим названием «ELF from scratch»:
* [Проект на Github](https://github.com/statusfailed/elf-from-scratch)
* Статья [Elf from scratch](https://www.conradk.com/codebase/2017/05/28/elf-from-scratch/)
* Ветка [elf\_from\_scratch](https://github.com/lief-project/LIEF/tree/elf_from_scratch) в репозитории библиотеки LIEF
Знакомство с этими проектами благотворно влияет на впитывание в себя формата ELF.
Самый маленький эльф
--------------------
Интересные эксперименты с минимизацией размера эльфа описаны в статьях:
* [A Whirlwind Tutorial on Creating Really Teensy ELF Executables for Linux](http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html)
* [A Whirlwind Tutorial on Creating Somewhat Teensy ELF Executables for Linux](http://www.muppetlabs.com/~breadbox/software/tiny/somewhat.html)
* [Минималистичная программа в формате ELF](https://habr.com/ru/post/137706/)
Если кратко, загрузчик эльфа в ОС использует далеко не все поля заголовка и таблицы сегментов, при этом некоторый минимальный исполняемый код можно поместить прямо в структуру заголовка ELF’а (код взят из первой статьи):
```
; tiny.asm
BITS 32
org 0x00010000
db 0x7F, "ELF" ; e_ident
dd 1 ; p_type
dd 0 ; p_offset
dd $$ ; p_vaddr
dw 2 ; e_type ; p_paddr
dw 3 ; e_machine
dd _start ; e_version ; p_filesz
dd _start ; e_entry ; p_memsz
dd 4 ; e_phoff ; p_flags
_start:
mov bl, 42 ; e_shoff ; p_align
xor eax, eax
inc eax ; e_flags
int 0x80
db 0
dw 0x34 ; e_ehsize
dw 0x20 ; e_phentsize
db 1 ; e_phnum
; e_shentsize
; e_shnum
; e_shstrndx
filesize equ $ - $$
```
Ассемблируем и получаем ELF размером… **45 байт**:
```
$ nasm -f bin -o a.out tiny.asm
$ chmod +x a.out
$ ./a.out ; echo $?
42
$ wc -c a.out
45 a.out
```
Эльф по шаблону
---------------
Для создания эльфа с использованием библиотеки LIEF можно сделать следующие шаги (см. рецепт «Эльф-контейнер»):
* взять простой ELF-файл в качестве шаблона;
* заменить содержимое секций, добавить новые секции;
* настроить необходимые параметры (точка входа, флаги).
Вместо заключения
=================
Дописывая статью, обнаружили, что получилось что-то вроде оды библиотеке LIEF. Но так не было запланировано — хотелось показать способы работы с ELF-файлами с использованием разных инструментов.
Наверняка есть или нужны сценарии, которые не были упомянуты здесь — напишите об этом в комментариях.
Ссылки и литература
===================
* [Спецификация формата ELF](http://www.skyfree.org/linux/references/ELF_Format.pdf)
* [Ещё спецификация формата в библиотеке Oracle](https://docs.oracle.com/cd/E23824_01/html/819-0690/chapter6-46512.html#scrolltoc)
* [Работа с ELF’ами с использованием radare2](https://www.radare.org/doc/elf-tutorial)
* [Документация библиотеки LIEF](https://lief.quarkslab.com/doc/latest/index.html)
* [Примеры использования библиотеки LIEF](https://github.com/lief-project/LIEF/tree/master/examples)
* Книга «PRACTICAL BINARY ANALYSIS», Dennis Andriesse
* Книга «Learning Linux Binary Analysis», Ryan "elfmaster" O'Neill | https://habr.com/ru/post/460247/ | null | ru | null |
# Из Rails 4 в Rails 5: как это было
 Жил-был поставщик облачных сервисов и захотелось ему не отставать от прогресса. И решил он обновиться с Rails 4.2.8 до Rails 5.0.2. А как это было, что по пути отвалилось, что по лбу вдарило с ускорением и какой опыт из этого вынесли — читайте под катом.
Повествовать буду разрозненно, так как большинство особенностей и проблем никак не связаны друг с другом. Поэтому если встретили что-то унылое или известное — смело двигайтесь к следующему пункту, там, быть может, будет поинтереснее.
Цель повествования: никакого универсального алгоритма перехода не будет, просто хочется поделиться найденной информацией и подробностями разной степени интимности о том, почему нельзя просто так взять и перейти на Rails 5 подправив версии в Gemfile.
Анамнез
-------
Приложение у нас среднестатистическое: Ruby 2.2.3, три с хвостиком сотни гемов, ~1500 экшенов, постгрес, эластик, редиска. В общем, ничего особенного. Разве что тестами покрыто на 90%+. Это, кажись, не очень характерно для некоторых современных приложений.
Начнём с начала
---------------
Хоть на горизонте уже маячит Rails 5.2, но никто не спешит обновлять мажорную версию. Поэтому в интернете не так уж много информации об особенностях перехода, как хотелось бы. Есть более-менее информативное описание вот [тут](http://mensfeld.pl/2015/12/upgrading-to-ruby-on-rails-5-0-from-rails-4-2-application-use-case/). Есть релизноты для [5.0](http://edgeguides.rubyonrails.org/5_0_release_notes.html) и [5.1](http://edgeguides.rubyonrails.org/5_1_release_notes.html) (впрочем, кто их читет пока не припрёт?). Есть [офф.гайд](http://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-4-2-to-rails-5-0) с основными шагами по обновлению до Rails 5. Он хороший, но хочется больше информации, особенно касаемо гемов, их совместимости и прочего хозяйства, которое обычно отваливается при обновлениях. Хотя, справедливости ради, если бы мы его изучили более подробно, то не прошлись бы по паре знатных грабелек (про них будет ниже). Поэтому, далее я буду упоминать некоторые пункты из гайда (то есть некоторые базовые изменения), которые, однако, для нас оказались довольно важными.
Причины основных проблем или вместо TL;DR
-----------------------------------------
* Некоторые используемые гемы либо плохо совместимы, либо вообще не совместимы с Rails 5, из-за чего приходится их либо выпиливать и заменять на родные возможности рельсы, либо допиливать гемы до рабочего состояния. В любом случае нужно ковырять их и отвечать на вопросы: "как оно работало?", "будет ли оно работать?", "что же делать, чтобы оно заработало?". После чего начинать форкать/контрибьютить/патчить.
* Обновления мажорных версий гемов вслед за мажорной версией Rails и, следовательно, мажорные изменения в интерфейсах, API и прочих загогулинах, которые гемы предоставляют. Сие влечёт массовые замены и/или перепил того, что раньше работало и кушать не просило.
* Всеми любимый и всеми ненавистный core\_ext: манкипатчи ядра и гемов для личных нужд. Самые злостные косяки были именно из-за них. Возникает куча вопросов вида: "а зачем это сделали и как оно работало?", "а почему сделали именно так?", "а в новой версии гема всё к чертям переписали, что же делать?".
Обновление гемов
----------------
Чтобы что-то упало — нужно что-то обновить. Начать, естественно, нужно с гема rails и его зависимостей. Тут можно зависнуть на день-другой и никаких рецептов нет. Просто много плясок с бубном вокруг *Gemfile*, *Gemfile.lock* и постепенное понимание того, что обновить понадобится ещё добрую половину всего, что есть в проекте, дабы оно хотя бы сбандлилось. Этапы получаются следующие:
* бандлится,
* запускается консоль,
* запускается сервер,
* работает хотя бы 3 (три) экшена/запроса подряд.
Жесть, как она есть
-------------------
Теперь вразнобой обо всём.
#### alias\_method\_chain выпиливается
Для тех, кто ещё не в курсе: теперь нужно делать `prepend`. Если коротко: эта штука добавляет модуль после класса, а не перед, как всем известный `include`. Как бонус — получаем `super` вместо with/without методов. Подробности и примеры смотреть [тут](http://www.justinweiss.com/articles/rails-5-module-number-prepend-and-the-end-of-alias-method-chain/).
#### Много новых дефолтных конфигов
Генерятся они через `rails app:update`. Но задачка эта очень тупенькая и просто создаёт файлы, а если у вас уже был какой-то из них — мержите сами и да прибудет с вами сила.
#### Гем device\_async
Для новых версий device он не нужен и заменяется парой строчек кода по [офф.манулу](https://github.com/plataformatec/devise#activejob-integration). Справедливости ради, это работает начиная с Rails 4.2, но в 5-х рельсах гем окончательно перестаёт работать и таки нужно всё переписать на ActiveJob.
#### Гем CanCan
Нужно заменить на [CanCanCan](https://github.com/CanCanCommunity/cancancan). Так как у CanCan кончается поддержка и сыпется туча депрекейшенов, которые станут проблемой в Rails 5.1. В общем случае больших проблем с заменой быть не должно. У нас были свои допилы CanCan'а под [inherited\_resources](https://github.com/activeadmin/inherited_resources), поэтому мы страдали немного больше.
#### Гем Grape-Swagger
У нас был ~~расширенный~~ пропатченый вариант. Он умел подставлять API-key в запрос. Но перепил в последней мажорной версии сваггера случился знатный. Поэтому после перехода на 3.0 мы не смогли найти никаких знакомых ориентиров и старый патч было тупо некуда вставлять. В итоге оказалось, что там теперь есть документированная фича для кастомных http-заголовков, но она не взлетела и пришлось немножко [контрибьютить](https://github.com/ruby-grape/grape-swagger/commit/95675e33b100555e8cc153e4831ac4a66a50ccdc). Теперь всё работает.
#### Вставка невалидных объектов в has\_many ассоциацию
При вставке в has\_many ассоциацию невалидного объекта, в Rails 5 всё падает (объект persisted и невалидным мы его сделали только в памяти). Раньше происходило сохранение и в ассоциацию попадал исходный объект из БД, а изменения из памяти либо скипались (или скипались валидации), либо хз что с ним было, глубоко не копали.
#### concat для Relation
Его куда-то дели и больше он не работает.
#### Не баг, но deprecation про uniq
Uniq таки заменили на distinct и в 5.1 окончательно выпилят uniq для Reilation. Как я понимаю, наконец-то пришло осознание, что Relation, мимикрирующий под Array — это не фича, а большая хрень.
#### Гем postgres\_ext
Нужно решительно выпилить. Всё что он [умеет](https://github.com/DockYard/postgres_ext/blob/master/docs/querying.md) делать довольно просто заменяется при помощи raw-sql и/или Arel. Сам гем, на текущий момент, не совместим с Rails 5. При попытках его использования в новых рельсах получаем ошибки в самых неожиданных местах, например, при вызове `count` на STI-классе:
```
ArgumentError:
wrong number of arguments (given 1, expected 2)
# /Users/username/.rvm/gems/ruby-2.3.3@gemset/gems/arel-7.1.4/lib/arel/visitors/reduce.rb:12:in `visit'
# /Users/username/.rvm/gems/ruby-2.3.3@gemset/gems/postgres_ext-3.0.0/lib/postgres_ext/arel/4.1/visitors/postgresql.rb:22:in `block in
```
#### Гем simple\_form
У нас, почему-то, с ним почти ничего не произошло. Он просто продолжил работать. Просто отвалилась возможность делать одновременно `include_blank` и `require` для поля.
### Разное вокруг ActiveRecord'а
* AR ругается на передачу в условия констант (в частности классов), говорит передавайте строки, а не константы. Актуально, например, в случае поиска в таблице c STI:
```
# теперь так делать не надо
Model.where(content_type: SharedFile)
# надо делать так
Model.where(content_type: SharedFile.name )
# или так
Model.where(content_type: 'SharedFile')
```
* Все модели теперь нужно наследовать от `ApplicationRecord` вместо `ActiveRecord::Base`. То есть появляется промежуточный абстрактный класс:
```
class ApplicationRecord < ActiveRecord::Base
self.abstract_class = true
end
```
* Значительно изменён принцип работы маппинга столбцов БД в модель. В частности это касается метода `column_names`. Он больше не возвращает атрибуты, задефайненные пользователем, например, через [attribute](https://apidock.com/rails/ActiveRecord/Attributes/ClassMethods/attribute) (подробности можно посмотреть в дифах этого метода в AR между 4 и 5 рельсами). Теперь появилось понятие `attributes_to_define_after_schema_loads`. И теперь, если у вас есть логика, основанная на "виртуальных" атрибутах, и хочется чтобы `column_names` по прежнему возвращал всё, то нужно делать как-то так:
```
def self.column_names
super + attributes_to_define_after_schema_loads.keys
end
```
* Выпилена константа `ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES`. На сколько я знаю, многие ей пользовались и теперь есть два варианта: вернуть её обратно руками, либо переходить на использование `FALSE_VALUES`, которую оставили в живых.
* Передача аргумента в `reload` (для force перезагрузки) выпиливается. Теперь нужно вызывать reload на конкретной реляции. Например:
```
first_model = Model.first
first_model.has_many_relation_name.reload
```
* Аналогичная штука для has\_one ассоциации:
```
second_model = Model.second
second_model.reload_has_one_relation_name
```
* Остановка `before_` колбэков при возврате `false` — выпиливается. Теперь нужно явно райзить `throw(:abort)` в колбэках. Вот [тут](https://github.com/rails/rails/pull/17227) MR со знатным холиваром по этому поводу.
* Выпиливается параметр `raise_in_transactional_callbacks=`, отвечающий за выброс эксепшенов из `after_commit`/`after_rollback` в случае возврата false из них (ранее он тихо писал сообщение в лог и мог не выбрасывать эксепшн). Штуку запилили ещё в Rails 4, но, кажись, мало кто озаботился переписыванием. Теперь пора, а то скоро выпилят старое поведение.
* Все реляции `belong_to` стали обязательными по-умолчанию. Чтобы вернуть всё на место, нужно потыкать параметр `config.active_record.belongs_to_required_by_default`.
* Появился метод `ActiveRecord::Relation#update`, который позволяет обновлять `Relation`, вызывая колбэки и валидации. По сути своей это сахар: будет много запросов к БД и внутри это просто map. Подробности в [MR](https://github.com/rails/rails/pull/11898/files).
* Появилась возможность делать `LEFT JOIN` без сайд-эффектов. До Rails 5 `OUTER JOIN` можно было написать явно через [joins](https://apidock.com/rails/ActiveRecord/QueryMethods/joins), либо взять [includes](https://apidock.com/rails/ActiveRecord/QueryMethods/includes) + [references](https://apidock.com/rails/ActiveRecord/QueryMethods/references), либо им эквивалентный [eager\_load](https://apidock.com/rails/ActiveRecord/QueryMethods/eager_load). В качестве довеска мы получаем загрузку всех указанных реляций, так как основное назначение всего вышеуказанного (за исключением `joins`) — это помощь в решении N+1. Теперь есть `ActiveRecord::Relation#left_outer_joins`, который просто делает левый джоин и ничего лишнего. За подробностями можно сходить в [MR](https://github.com/rails/rails/pull/21762).
### params в контроллерах
Теперь это не `HashWithIndifferentAccess`, а самостоятельный класс `ActionController::Parameters`, который ради обратной совместимости мимикрирует под хэш, но сильно ругается, если им пользуются как хэшом, то есть если делают `merge`, `update` и т.д. То есть, если я правильно понял идею, у `params` две цели: хранить то, что пришло от клиента и фильтровать содержимое, используя [Strong Parameters](https://github.com/rails/strong_parameters). Никаких иных модификаций над ним производить не нужно. Иными словами, модифицировать данные прямо в `params`, ровно как и добавлять туда свои — это дурной тон. Делайте отдельный объект для этих действий, либо вызывайте `params.to_h` или даже `params.to_unsafe_hash` и после этого уже работайте с хэшем, как раньше.
### Добавление ошибок в модель через errors[]=
`ActiveModel::Errors#[]=` выпиливается в Rails 5.1, в конце-то концов нужно использовать `model.errors.add(:name, "can't be blank")`. Сообщения в логах по этому поводу, естественно, присутствуют.
### Немного про Arel
Если в `eq` (да и, скорее всего, в любой аналогичный предикат) из Arel для поля `id` (с другими полями всё ок) передать сам объект, то в 4-х рельсах из этого объекта вытаскивал айдишник (pk) и подставлялся в запрос, а в 5-х рельсах такого не происходит. Вместо попытки вытащить pk у объекта просто подставляется NULL и получается что-то типа "account\_id = NULL". Пример:
```
# в Rails 4
MyModel.arel_table[:my_field].eq(MyModel.first).to_sql
=> "my_models"."my_field" = 1
MyModel.arel_table[:id].eq(MyModel.first).to_sql
=> "my_models"."id" = 1
# в Rails 5
MyModel.arel_table[:my_field].eq(MyModel.first).to_sql
=> "my_models"."my_field" = 1
MyModel.arel_table[:id].eq(MyModel.first).to_sql
=> "my_models"."id" = NULL
```
Посему: старайтесь всегда явно указывать значение.
### Про skip\_callback
`skip_callback(:create, :after, :my_method)` в 4-х рельсах позволяет передавать какие-угодно параметры и не падает даже если такого метода нет в цепочке колбэков, в 5-х рельсах аналогичный метод рэйзит эксепшн, если не нашёл метода, который нужно скипнуть. Поэтому могут случиться странные падения и прийдётся углубляться в промышленную археологию, дабы понять "а был ли мальчик?".
### Маленькая революция в render
Меняют `:text` и прочие форматы на явное указание `mime_type`. Заменяют `:nothing` на `:head` и тд. То есть возвращаются к истокам и делают названия приближенными к сути, а не доступными для понимания любой домохозйкой.
### Изменение порядка прогона тестов
Теперь дефолтный порядок прогона `:random`. Если у вас тесты зависят от последовательности выполнения — это не очень хорошо, но вернуть старое поведение довольно просто:
```
Rails.application.configure do
config.active_support.test_order = :sorted
end
```
### Observer'ы
Их в 5-х рельсах пока (или уже) никто не поддерживает. [Исходные обсерверы](https://github.com/rails/rails-observers) остановились на 4-х рельсах. В мастере у них заявлена поддержка 5-х, но ничего не работает. Есть какой-то японец с [альтернативой обсерверов](https://github.com/yasaichi/everett) для 5-х рельс (которая очень похожа на копипаст и ребрендинг), но и эта штука не работает. Лучший выход — использовать родные колбэки из AR.
### Баги в ActiveRecord
Нашли парочку:
* [первый](https://github.com/rails/rails/issues/28717) — старый про `uniq` на `ActiveRecord::Associations::CollectionProxy`, который оказался известным и уже поправлен в 5.1;
* [второй](https://github.com/rails/rails/issues/28718) — новый и поинтереснее: как можно неявно зафризить атрибут(ы) у AR-модели.
### Гем shoulda-matchers
Обновили его до 3.1.1 и повылазило много разной мелочи:
* появилась дефолтная проверка `email` на case sensitive;
* ужесточилась проверка на scope: если раньше `should validate_uniqueness_of(:name)` проходило даже в случае, когда в модели указан `scope` для `uniqueness`, то теперь тест падает и нужно явно указывать `should validate_uniqueness_of(:name).scoped_to(:vendor_id)`;
* косячно проверяет сериализованные атрибуты и `should serialize(:metadata).as(Hash)` падает с `cast_type`;
* раньше метод `allow_value('foo', 'bar', 'baz')` брал только первое значение из передаваемых аргументов, а теперь исправился и начал брать все.
### Миграции
Изменили способ формирования имён индексов и ещё несколько вещей, которые полностью сломали обратную совместимость. Поэтому нужно явно всем миграциям указать в какой версии они были созданы. Указывать через параметр класса:
```
class OldMigrationName < ActiveRecord::Migration[4.2]
...
end
class NewMigrationName < ActiveRecord::Migration[5.0]
...
end
```
Так же дали возможность указывать `foreign_key` в опциях для `references`. И немного [поменяли](https://github.com/rails/rails/pull/21762/files) дефолтные настройки генератора: теперь он по умолчанию делает pk (который id) не integer'ом, а uuid'ом.
Ещё у нас, почему-то, возникли проблемы определением моделей внутри миграций. То есть в штуке вида:
```
class SomeMigration < ActiveRecord::Migration
class StubForModel < ActiveRecord::Base
has_one :something
end
def up
StubForModel.destroy_all
end
def down
# do nothing
end
end
```
кто-то сильно ругается на то, что не может найти `Base`. Пока не разобрались с причиной, поэтому будте бдительны. Как разберёмся — обновим описание.
Последовательность колбэков в контроллере
-----------------------------------------
Проверка `csrf` токена (protect from forgery) в Rails 4 всегда поднималась вверх и выполнялась первым колбэком в контроллере. В Rails 5 она никуда не поднимается и выполняется согласно тому, в каком месте задефайнена и если нужно поднять её, то нужно явно указывать `prepend: true`.
Всё бы хорошо, но мы, кажись, не внимательно читали гайды, ссылки на которые привели в начале. У нас просто отвалилась аутентификация. Мы перекопали весь девайс и чуть не уверовали в магию. А оказалось, что сначала девайс успешно проводит аутентификацию и выпиливает из парамсов токен, а затем приходит protect from forgery и сильно негодует по поводу кривого (на самом деле отсутствующего) токена.
Манкипатчи
----------
"Его пример другим наука..."
* В тестах контроллеров `get` падал со *stack level too deep* в районе cookies. Сломали пару светлых голов и во второй раз чуть было в магию не уверовали, пока не раскопали манкипатч, связанный с [RequestStore](https://github.com/steveklabnik/request_store).
* Вышеприведённый кейс с csrf-токеном был немного осложнён своими ~~допилами~~ манкипатчами аутентификации. На самом деле, у нас была две проверки `csrf` токена: одна до девайса и одна после. Сие совсем не способствовало упрощению поиска проблемы.
* Ещё раньше упомянутый CanCan тоже был попатчен и приятного было мало.
* Были у нас свои допили `ActiveRecord::Type`, который изрядно перекопали в новых рельсах: [было](https://github.com/rails/rails/tree/4-2-stable/activerecord/lib/active_record/type), [стало](https://github.com/rails/rails/tree/5-0-stable/activerecord/lib/active_record/type) и которые [перенесли](https://github.com/rails/rails/tree/5-0-stable/activemodel/lib/active_model/type) в `ActiveModel`.
* Есть ещё немало вещей, о которых можно было бы рассказать, но они в переходе на новые рельсы почти не участвовали, поэтому оставим на потом.
К чему я всё это: `core_ext` быть не должно. Совсем. И переход на новые рельсы — это отличный повод начать с них и постараться выпилить столько, сколько возможно, а на всё остальное посмотреть очень придирчивым взглядом и вспомнить историю (несомненно очень пёструю) предшествующую появлению этого расширения. Так будет гораздо проще разбираться, когда оно отвалится в процессе перехода.
Обновление версии Ruby
----------------------
Честно говоря, мы неосилили. Бодро воткнув 2.4.0 после 2.2.3 мы огребли кучу неведомой фигни и решили не выёживаться и переходить в два этапа: сначала Ruby 2.3.3, в котором нет ничего шибко революционного, плюс переход на новые рельсы. А уж затем — обновление руби. Посему, пока что ничего не можем сказать про новый руби. Разве что есть мнение опытных товарищей о том, что если у вас скомпилились native extension для гемов, то большую часть проблем перехода вы обошли и серьёзных препятствий быть не должно.
Магия (задачка на подумать, если есть время и желание)
------------------------------------------------------
Безотносительно перехода на новые рельсы, просто странный код, который раскопали в ходе перехода и который работал, хотя не должен (краткое содержание трёх файлов AR-классов):
```
class Base
TYPES = {first: First, second: Second}
end
class First < Base; end
class Second < Base; end
```
Эта штука по всем законам жанра работать не может (да в общем-то и не работает на чистых проектах под Rails 4/5). Так как при обращении к кому-либо из наследников автолоад уходит в циклическую загрузку классов и падает. Если же сначала обращаться к базовому классу, а потом к наследникам, то всё хорошо. Но у нас почему-то работало в Rails 4, но отвалилось в Rails 5, хотя явного обращения к `Base` для его загрузки ранее, нежели все остальные, мы не нашли, да и вообще не трогали ничего, связанного с автолоадом. Если кто-то знает ещё способы как оно может работать или что интересного случилось с автолоадом в Rails 5 — сообщите, пожалуйста.
Конец
-----
Спасибо, что дочитали. Надеюсь хоть что-то вам пригодится (или уже пригодилось) и мы хоть чуть-чуть сэкономили вам время на переход.
Пожалуйста, не стесняйтесь делиться в комментариях своими знаниями и опытом по теме и не очень. | https://habr.com/ru/post/326706/ | null | ru | null |
# Конструирование типов в Scala
При построении многослойных («enterprise») систем часто оказывается, что создаются `ValueObject`'ы (или case class'ы), в которых хранится информация о каком-либо экземпляре сущности, обрабатываемом системой. Например, класс
```
case class Person(name: String, address: Address)
```
Такой способ представления данных в системе обладает как положительными свойствами:
* строго типизированный доступ к данным,
* возможность привязки метаинформации к свойствам с помощью аннотаций,
так и некоторыми недостатками:
* если сущностей много, то таких классов также становится довольно много, а их обработка требует много однотипного кода (copy-paste);
* потребности отдельных слоёв системы в метаинформации могут быть представлены аннотациями к свойствам этого объекта, но возможности аннотаций ограничены и требуют использования reflection'а;
* если требуется представить данные не обо всех свойствах объекта сразу, то созданные классы использовать затруднительно;
* затруднительно также представить изменение значения свойства (delta).
Мы хотим реализовать фреймворк, позволяющий создавать новые «классы» (типы, конструкторы этих типов, объекты новых типов) инкрементно, используя наши собственные «кирпичики». Попутно, пользуясь тем, что мы сами изготавливаем «кирпичики», мы можем достичь таких полезных свойств:
* возможность описывать отдельные свойства сущностей (с указанием типа данных в этом свойстве и любой метаинформации, необходимой приложению, в форме, подходящей именно для этого приложения);
* возможность оперировать со свойствами экземпляров строго типизированным образом (с проверкой типов на этапе компиляции);
* представлять частичную/неполную информацию о значениях свойств экземпляра сущности, пользуясь объявленными свойствами;
* создавать тип объекта, содержащего частичную информацию о свойствах экземпляра сущности. И использовать этот тип наравне с другими типами (классами, примитивными типами и др.).
Чтобы сконструировать новый составной тип, надо разобраться, как устроен обычный класс. В объявлении класса `Person` можно выделить компоненты
* упорядоченный список свойств/слотов (slot sequence),
* имя свойства/слота (slot id),
* тип свойства/слота.
При использовании класса `Person` и его свойств можно выделить операции —
* получения значения свойства экземпляра (экземпляр.name)
* получения нового экземпляра с изменившимся свойством (так как класс `Person` — immutable, для mutable классов аналогом является изменение значения свойства объекта)
При этом сущностью «первого класса» является сам класс `Person`, а его свойства — сущности «второго класса». Они не являются объектами и мы не имеем возможности оперировать с ними отвлечённо.
Мы же хотим свойства сделать самостоятельными сущностями «первого класса», из которых уже будет конструироваться новый «класс».
Итак, объявим свойство `name`:
```
trait SlotId[T]
case class SlotIdImpl[T](slotId:String, ...) extends SlotId[T]
def slot[T](slotId:String, ...) = SlotIdImpl[T](slotId, ...)
val name = slot[String]("name", ...)
```
Такое объявление выводит на первый план само свойство безотносительно той сущности, в которой свойство будет использоваться. Метаинформация может очевидным образом привязываться к идентификатору свойства (с использованием внешнего отображения), либо указываться непосредственно в объекте, представляющем свойство. В последнем варианте несколько упрощается оперирование данными, хотя расширение новыми видами метаинформации затруднено.
#### Последовательность слотов
Чтобы получить новый тип, надо собрать несколько свойств в упорядоченный список. Для конструирования типа, составленного из других, будем использовать такой же подход, как в типе HList (из замечательной библиотеки [shapeless](https://github.com/milessabin/shapeless), например).
```
sealed trait SlotSeq {
type ValueType <: HList
}
case object SNil extends SlotSeq {
type ValueType = HNil
}
case class ::[H<:SlotId, T<:SlotSeq](head:H, tail : T) extends SlotSeq {
type ValueType = H :: T#ValueType
}
```
Как видно, в процессе конструирования списка свойств мы также конструируем тип значения (`ValueType`), совместимого со списком свойств.
#### Группировка свойств
Свойства можно использовать как есть, просто создавая полную коллекцию всех возможных свойств. Однако лучше организовать свойства в «грозди» — наборы свойств, относящихся к одному классу/типу объектов.
```
object PersonType {
val name = slot[String]("name", ...)
val address ...
...
}
```
Такую группировку также можно делать с помощью trait'ов, что позволяет объявлять одинаковые свойства в разных «гроздях».
```
trait Identifiable {
val id = slot[Long]("id")
}
object Employee extends Identifiable
```
Кроме того, «грозди» позволяют в метаинформацию свойств автоматически добавлять охватывающий объект, что, в свою очередь, может быть весьма полезно при обработке данных на основе метаинформации.
#### Представление экземпляров
Собственно, данные, относящиеся к сущности, могут быть представлены в двух основных формах: `Map` или `RecordSet`. `Map` — содержит пары свойство-значение, в то время как `RecordSet` содержит упорядоченный список свойств и массив значений, расположенных в том же порядке. `RecordSet` позволяет экономно представить данные о большом количестве экземпляров, а `Map` позволяет создать «вещь в себе» — изолированный объект, который содержит всю метаинформацию вместе со значениями свойств. Оба этих способа могут использоваться параллельно в зависимости от текущих потребностей.
Для типизированного представления строк `RecordSet`'а может использоваться замечательная структура `HList` (из библиотеки shapeless, например). Нам надо лишь в процессе сборки упорядоченного slot sequence'а формировать тип совместимого `HList`'а.
```
type ValueType = head.Type :: tail.ValueType
```
Для создания строготипизированного `Map`'а нам потребуется вместо обычного класса `Entry` использовать свой класс `SlotValue`,
```
case class SlotValue[T](slot:SlotId[T], value:T)
```
который кроме имени свойства и значения свойства также содержит generic тип значения. Это позволяет уже на этапе компиляции гарантировать, что свойство получит значение совместимого типа. Сам `Map` потребует отдельной реализации. В простейшем случае, можно использовать список `SlotValue`, который автоматически конвертируется в обычный Map по мере необходимости.
#### Заключение
Кроме вышеописанной базовой структуры данных и структуры типов, полезными являются вспомогательные функции, построенные на базовом инструментарии
* постепенное конструирование экземпляра `Map` (строго типизированный `MapBuilder`);
* линзы для доступа и модификации вложенных свойств;
* конвертация `Map` — в `RecordSet` и обратно
Такой фреймворк может применяться при необходимости обработки разнотипных данных на основе метаинформации о свойствах, например:
* работа с БД:
* однотипная обработка событий, относящихся к свойствам различных сущностей, например, изменение свойств объектов.
За счёт удобства представления метаинформации, можно детально описать все аспекты обработки данных, не прибегая к аннотациям.
*[Код для описанных конструкций](https://github.com/Primetalk/SynapseGrid/blob/master/synapse-frames/src/main/scala/ru/primetalk/sinapse/frames/slots.scala)* .
UPD: Продолжение темы: [Строго типизированное представление неполных данных](http://habrahabr.ru/post/229035/) | https://habr.com/ru/post/222553/ | null | ru | null |
# Аскетичный вебъ: прототип барахолки на go и js
[](https://habrastorage.org/webt/3g/h3/-6/3gh3-6swyq65srharlejw1xeuek.png)
Всем привет, хочу поделиться результатом размышлений на тему — каким может быть современное веб-приложение. В качестве примера рассмотрим проектирование доски объявлений для комиксов. В некотором смысле рассматриваемый продукт рассчитан на аудиторию гиков и им сочувствующих, что позволяет проявить вольность в интерфейсе. В технической же составляющей, напротив, необходимо внимание к мелочам.
По правде говоря, я ничего не понимаю в комиксах, но люблю барахолки, особенно в формате форума, какие были популярны в нулевых. Отсюда, допущение (возможно ложное), из которого проистекают последующие выводы, только одно — основной тип взаимодействия с приложением — просмотр, второстепенные — размещение объявлений и обсуждение.
Нашей целью будет создание простого приложения, без ~~технических ноу-хау~~ лишних свистелок, однако соответствующее современным реалиям. Основные требования, соблюдения которых хотелось бы достичь:
1. Серверная часть:
а) Выполняет функции сохранения, валидации, отправки на клиент пользовательских данных
б) Вышеуказанные операции потребляют приемлемое количество ресурсов (времени в т. ч.)
в) Приложение и данные защищены от популярных векторов атак
г) Имеет простое API для сторонних клиентов и межсерверного взаимодействия
д) Кроссплатформенность, простое развёртывание
2. Клиентская часть:
а) Предоставляет необходимый функционал для создания и потребления контента
б) Интерфейс удобен для регулярного использования, минимальный путь до любого действия, максимальное количество данных на экран
в) Вне связи с сервером доступны все возможные в этой ситуации функции
г) Интерфейс отображает актуальную версию состояния и контента, без перезагрузок и ожидания
д) Перезапуск приложения не сказывается на его состоянии
е) По возможности переиспользуем DOM-элементы и JS-код
ж) Не станем использовать сторонние библиотеки и фреймворки в рантайме
з) Вёрстка семантична для доступности, парсеров и т. д.
и) Навигация по основному контенту доступна с помощью URL и клавиатуры
На мой взгляд логичные требования, и большинство современных приложений в той или иной степени отвечают этим условиям. Посмотрим что получится у нас (ссылка на исходники и демо в конце поста).
**Предупреждения:*** Хочу принести извинения неизвестным мне авторам изображений, использованных в демо без разрешений, а так же Гёссе Г., Прозоровской Б. Д. и издательству "Библиотека Флорентия Павленкова" за использование отрывков из произведения "Сиддхартха".
* Автор не настоящий программист, не советую использовать код или приёмы использованные в данном проекте, если вы не знаете что делаете.
* Прошу прощения за стиль кода, можно было написать более читабельно и очевидно, но это не весело. Проект для души и для друга, as is как говорится.
* Также прошу прощения за уровень грамотности, в английском тексте в особенности. Лет спик фром май харт.
* Работоспособность представленного прототипа тестировалось в [chromium 70; linux x86\_64; 1366x768], буду предельно признателен пользователям других платформ и устройств за сообщения об ошибках.
* Это прототип и предлагаемая тема для обсуждения — подходы и принципы, прошу всю критику реализации и эстетической стороны сопровождать аргументами.
Сервер
------
Языком для сервера будет golang. Простой, быстрый язык с отличной стандартной библиотекой и документацией… немного раздражающий. Первоначальный выбор пал на elixir/erlang, но т. к. go я уже знал (относительно), решено было не усложнять (да и необходимые пакеты были только для go).
Использование веб-фреймворков в go-сообществе не поощряется (обоснованно, стоит признать), мы выбираем компромисс и используем микрофреймворк [labstack/echo](https://github.com/labstack/echo), тем самым сокращая количество рутины и, как мне кажется, не много проигрывая в производительности.
В качестве базы данных используем [tidwall/buntdb](http://github.com/tidwall/buntdb). Во-первых встроенное решение удобнее и уменьшает накладные расходы, во-вторых in-memory + key/value — ~~модно, стильно~~ быстро и нет нужды в кэше. Храним и отдаём данные в JSON, валидируя только при изменении.
На i3 второго поколения встроенный логгер показывает время выполнения для разных запросов от 0.5 до 10мс. Запущенный wrk на той же машине также показывает достаточные для наших целей результаты:
```
➜ comico git:(master) wrk -t2 -c500 -d60s http://localhost:9001/pub/mtimes
Running 1m test @ http://localhost:9001/pub/mtimes
2 threads and 500 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 20.74ms 16.68ms 236.16ms 72.69%
Req/Sec 13.19k 627.43 15.62k 73.58%
1575522 requests in 1.00m, 449.26MB read
Requests/sec: 26231.85
Transfer/sec: 7.48MB
```
```
➜ comico git:(master) wrk -t2 -c500 -d60s http://localhost:9001/pub/goods
Running 1m test @ http://localhost:9001/pub/goods
2 threads and 500 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 61.79ms 65.96ms 643.73ms 86.48%
Req/Sec 5.26k 705.24 7.88k 70.31%
628215 requests in 1.00m, 8.44GB read
Requests/sec: 10454.44
Transfer/sec: 143.89MB
```
### Структура проекта
Пакет comico/model разделён на три файла:
model.go — содержит описание типов данных и общие функции: создание/обновление (buntdb не различает эти операции и наличие записи мы проверяем вручную), валидация, удаление, получение одной записи и получение списка;
rules.go — содержит правила валидации конкретного типа и функции логирования;
files.go — работа с изображениями.
Тип Mtimes хранит данные о последнем изменении остальных типов в бд, таким образом сообщая клиенту какие данные изменились.
Пакет comico/bd содержит обобщенные функции взаимодействия с бд: создание, удаление, выборка и т. д. Buntdb сохраняет все изменения в файл (в нашем случае раз в секунду), в текстовом формате, что в некоторых ситуациях удобно. Файл бд не редактируется, изменения в случае успеха транзакции дописываются в конец. Все мои попытки нарушить целостность данных не увенчались успехом, в худшем случае теряются изменения за последнюю секунду.
В нашей реализации каждый тип соответствует отдельной БД в отдельном файле (кроме логов, которые хранятся исключительно в памяти и при перезагрузке обнуляются). Это обусловлено в большей степени удобством резервного копирования и администрирования, небольшой плюс — транзакция открытая на редактирование блокирует доступ только к одному типу данных.
Данный пакет может быть без особо труда заменён на аналогичный использующий другую базу данных, SQL к примеру. Для этого достаточно реализовать следующие функции:
```
func Delete(db byte, key string) error
func Exist(db byte, key string) bool
func Insert(db byte, key, val string) error
func ReadAll(db byte, pattern string) (str string, err error)
func ReadOne(db byte, key string) (str string, err error)
func Renew(db byte, key string) (err error, newId string)
```
Пакет comico/cnst содержит некоторые константы необходимые во всех пакетах (типы данных, типы действий, типы пользователей). Помимо этого в этом пакете содержатся все человекочитаемые сообщения, которыми наш сервер будет отвечать во внешний мир.
Пакет comico/server содержит информацию о роутах. Также, буквально в пару строк (спасибо разработчикам Echo), настроена авторизация с помощью JWT, заголовки CORS, CSP, логгер, раздача статики, gzip, автосертификат ACME и т. д.
### Точки входа API
| URL | Data | Description |
| --- | --- | --- |
| get /pub/(goods|posts|users|cmnts|files) | - | Получение массива актуальных объявлений, постов, пользователей, комментариев, файлов |
| get /pub/mtimes | - | Получение времени последнего изменения для каждого типа данных |
| post /pub/login | { id\*: логин, pass\*: пароль } | Возвращает JWT-токен и время его действия |
| post /pub/pass | { id\*, pass\* } | Создаёт нового пользователя, если данные корректны |
| put /api/pass | { id\*, pass\* } | Обновление пароля |
| post|put /api/goods | { id\*, auth\*, title\*, type\*, price\*, text\*, images: [], Table: {key:value} } | Создание/обновление объявления |
| post|put /api/posts | { id\*, auth\*, title\*, type\*, text\* } | Создание/обновление поста форума |
| post|put /api/users | { id\*, title, type, status, scribes: [], ignores: [], Table: {key:value} } | Создание/обновление пользователя |
| post /api/cmnts | { id\*, auth\*, owner\*, type\*, to, text\* } | Создание комментария |
| delete /api/(goods|posts|users|cmnts)/[id] | - | Удаляет запись с идентификатором id |
| get /api/activity | - | Обновляет время последнего прочтения входящих комментариев для текущего пользователя |
| get /api/(subscribe|ignore)/[tag] | - | Добавляет или удаляет (при наличии) пользователю tag в список подписок/игнора |
| post /api/upload/(goods|users) | multipart(name, file) | Загружает фото объявления / аватар пользователя |
\* — обязательные поля
api — требует авторизации, pub — нет
При get-запросе, не совпадающим с вышеперечисленным, сервер ищет файл в директории для статики (к примеру /img/\* — изображения, /index.html — клиент).
Любая точка апи при успехе возвращает код ответа 200, при ошибке — 400 или 404 и краткое сообщение при необходимости.
Права доступа просты: создание записи доступно авторизованному пользователю, редактирование автору и модератору, редактировать и назначать модераторов может админ.
API снабжено простейшим антивандалом: действия логируются вместе с id и IP пользователя, и, в случае частого обращения, возвращается ошибка с просьбой немного подождать (полезно против подбора пароля).
Клиент
------
Мне нравится концепция реактивного веб'а, считаю что большинство современных сайтов / приложений стоит делать либо в рамках этой концепции, либо полностью статичными. С другой стороны несложный сайт с мегабайтами JS-кода не может не удручать. На мой взгляд эту (и не только) проблему сможет решить Svelte. Этот фреймворк (или скорее язык построения реактивных интерфейсов) не уступает в необходимом функционале тому же Vue, но обладает неоспоримым преимуществом — компоненты компилируются в ванильный JS, что сокращает как в размер бандла, так нагрузку на виртуальную машину (bundle.min.js.gz нашей барахолки занимает скромные, по нынешним меркам, 24КБ). Подробности вы можете узнать из официальной [документации](https://svelte.technology/guide).
Выбираем для клиентской части нашей барахолки SvelteJS, желаем всяческих благ Rich Harris и дальнейшего развития проекту!
PS Никого не хочу обидеть. Уверен, что для каждого специалиста и каждого проекта подходит свой инструментарий.
### Клиент / данные
#### URL
Используем для навигации. Не будем имитировать многостраничный документ, вместо этого используем hash страницы с query-параметрами. Для переходов можно использовать обычный без js.
Разделы соответствуют типам данных: /#goods, /#posts, /#users.
Параметры: ?id=*идентификатор\_записи*, ?page=*номер\_страницы*, ?search=*поисковый\_запрос*.
Несколько примеров:
* /#posts?id=1542309643&page=999&search={auth:anon} — раздел *posts*, id поста — *1542309643*, страница комментариев — *999*, поисковый запрос — *{auth:anon}*
* /#goods?page=2&search=сиддхартха — раздел *goods*, страница раздела — *2*, поисковый запрос — *сиддхартха*
* /#goods?search=wer{key:value}t — раздел *goods*, поисковый запрос — состоит из поиска подстроки *wert* в заголовке или тексте объявления и подстроки *value* в свойстве *key* табличной части объявления
* /#goods?search={model:100,display:256} — думаю тут всё понятно по аналогии
Функции парсинга и формирования урл в нашей реализации выглядят так:
```
window.addEventListener('hashchange', function() {
const hash = location.hash.slice(1).split('?'), result = {}
if (!!hash[1]) hash[1].split('&').forEach(str => {
str = str.split('=')
if (!!str[0] && !!str[1])
result[decodeURI(str[0]).toLowerCase()] = decodeURI(str[1]).toLowerCase()
})
result.type = hash[0] || 'goods'
store.set({ hash: result })
})
function goto({ type, id, page, search }) {
const { hash } = store.get(), args = arguments[0], query = []
new Array('id', 'page', 'search').forEach(key => {
const value = args[key] !== undefined ? args[key] : hash[key] || null
if (value !== null) query.push(key + '=' + value)
})
location.hash = (type || hash.type || 'goods') +
(!!query.length ? '?' + query.join('&') : '')
}
```
#### API
Для обмена данными с сервером будем использовать fetch api. Для загрузки обновлённых записей через небольшие промежутки времени делаем запрос к */pub/mtimes*, если время последнего изменения для какого-либо типа отличается от локального, загружаем список этого типа. Да, можно было реализовать уведомление об обновлениях через SSE или WebSocket'ы и инкрементную подгрузку, но в данном случае обойдёмся без этого. Что у нас получилось:
```
async function GET(type) {
const response = await fetch(location.origin + '/pub/' + type)
.catch(() => ({ ok: false }))
if (type === 'mtimes') store.set({ online: response.ok })
return response.ok ? await response.json() : []
}
async function checkUpdate(type, mtimes, updates = {}) {
const local = store.get()._mtimes, net = mtimes || await GET('mtimes')
if (!net[type] || local[type] === net[type]) return
const value = updates['_' + type] = await GET(type)
local[type] = net[type]; updates._mtimes = local
if (!!value && !!value.sort) store.set(updates)
}
async function checkUpdates() {
setTimeout(() => checkUpdates(), 30000)
const mtimes = await store.GET('mtimes')
new Array('users', 'goods', 'posts', 'cmnts', 'files')
.forEach(type => checkUpdate(type, mtimes))
}
```
Для фильтрации и пагинации используем вычисляемые свойства Svelte, основываясь на данных навигации. Направление вычисляемых значений таково: **items** (массивы записей приходящие от сервера) => **ignoredItems** (отфильтрованные записи на основе списка игнора текущего пользователя) => **scribedItems** (отфильтровывает записи по списку подписок, если такой режим активирован) => **curItem** и **curItems** (вычисляет текущие записи в зависимости от раздела) => **filteredItems** (фильтрует записи в зависимости от поискового запроса, если запись одна — фильтрует комментарии к ней) => **maxPage** (вычисляет количество страниц из расчета 12 записей/комментариев на страницу) => **pagedItem** (возвращает конечный массив записей/комментариев на основе номера текущей страницы).
Отдельно вычисляются комментарии и изображения (**comments** и **\_images**), группируясь по типу и записи-владельцу.
Вычисления происходят автоматически и только при изменении связанных данных, промежуточные данные постоянно находятся в памяти. В связи с этим делаем малоприятный вывод — для большого количества информации и/или частого её обновления может расходоваться большое количество ресурсов.
#### Cache
Согласно решению делать offline-приложение, реализуем хранение записей и некоторых аспектов состояния в localStorage, файлов изображений в CacheStorage. Работа с localStorage предельно проста, договоримся что свойства обладающие префиксом "\_" при изменении автоматически сохраняются и восстанавливаются при перезагрузке. Тогда наше решение может выглядеть так:
```
store.on('state', ({ changed, current }) => {
Object.keys(changed).forEach(prop => {
if (!prop.indexOf('_'))
localStorage.setItem(prop, JSON.stringify(current[prop]))
})
})
function loadState(state = {}) {
for (let i = 0; i < localStorage.length; i++) {
const prop = localStorage.key(i)
const value = JSON.parse(localStorage.getItem(prop) || 'null')
if (!!value && !prop.indexOf('_')) state[prop] = value
}
store.set(state)
}
```
С файлами немного сложнее. В первую очередь воспользуемся списком всех актуальных файлов (с временем создания), приходящим от сервера. При обновлении этого списка сравниваем со старыми значениями, новые файлы помещаем в CacheStorage, устаревшие удаляем оттуда:
```
async function cacheImages(newFiles) {
const oldFiles = JSON.parse(localStorage.getItem('_files') || '[]')
const cache = await caches.open('comico')
oldFiles.forEach(file => { if (!~newFiles.indexOf(file)) {
const [ id, type ] = file.split(':')
cache.delete(`/img/${type}_${id}_sm.jpg`)
}})
newFiles.forEach(file => { if (!~oldFiles.indexOf(file)) {
const [ id, type ] = file.split(':'), src = `/img/${type}_${id}_sm.jpg`
cache.add(new Request(src, { cache: 'no-cache' }))
}})
}
```
Затем нужно переопределить поведение fetch так, чтобы файл брался из CacheStorage без коннекта к серверу. Для этого придётся воспользоваться ServiceWorker'ом. Заодно настроим сохранение в кэш других файлов для работы вне связи с сервером:
```
const CACHE = 'comico', FILES = [ '/', '/bundle.css', '/bundle.js' ]
self.addEventListener('install', (e) => {
e.waitUntil(caches.open(CACHE).then(cache => cache.addAll(FILES))
.then(() => self.skipWaiting()))
})
self.addEventListener('fetch', (e) => {
const r = e.request
if (r.method !== 'GET' || !!~r.url.indexOf('/pub/') || !!~r.url.indexOf('/api/')) return
if (!!~r.url.lastIndexOf('_sm.jpg') && e.request.cache !== 'no-cache')
return e.respondWith(fromCache(r))
e.respondWith(toCache(r))
})
async function fromCache(request) {
return await (await caches.open(CACHE)).match(request) ||
new Response(null, { status: 404 })
}
async function toCache(request) {
const response = await fetch(request).catch(() => fromCache(request))
if (!!response && response.ok)
(await caches.open(CACHE)).put(request, response.clone())
return response
}
```
Выглядит немного коряво, но свои функции выполняет.
### Клиент / интерфейс
Структура компонентов:
index.html | main.js
== header.html — содержит логотип, строку состояния, главное меню, нижнее навигационное меню, форму отправки комментария
== aside.html — является контейнером для всех модальных компонентов
==== goodForm.html — форма добавления и редактирования объявления
==== userForm.html — форма редактирования текущего пользователя
====== tableForm.html — фрагмент формы для ввода табличных данных
==== postForm.html — форма для поста форума
==== login.html — форма логина/регистрации
==== activity.html — отображает комментарии обращенные текущему пользователю
==== goodImage.html — просмотр основного и дополнительных фото объявления
== main.html — контейнер для основного содержимого
==== goods.html — карточки списка или одиночного объявления
==== users.html — то же для пользователей
==== posts.html — думаю, понятно
==== cmnts.html — список комментариев к текущей записи
====== cmntsPager.html — пагинация для комментариев
* В каждом компоненте мы стараемся минимизировать количество html-тэгов.
* Классы используем только в качестве показателя состояния.
* Схожие функции выносим в стор (свойства и методы svelte store можно использовать напрямую из компонентов добавляя к ним префикс '$').
* Большинство функций ожидают пользовательского события или изменения определённых свойств, манипулируют данными стейта, сохраняют обратно в стейт результат свой работы и завершаются. Таким образом достигается малая связанность и расширяемость кода.
* Для видимой скорости переходов и других UI-событий мы по возможности отделяем манипуляции с данными, происходящими в фоне и действия связанные с интерфейсом, который в свою очередь использует текущий результат вычислений, перестраиваясь при необходимости, остальную работу любезно выполнит фреймворк.
* Данные заполняемой формы сохраняем в localStorage на каждый ввод, чтобы предотвратить их потерю.
* Во всех компонентах используем иммутабельный режим, в котором свойство-объект считается изменённым только только при получении новой ссылки, независимо от изменения полей, таким образом немного ускоряем наше приложения, пускай и за счет небольшого увеличения объёма кода.
### Клиент / управление
Для управления с помощью клавиатуры задействуем следующие комбинации:
**Alt+s** / **Alt+a** — переключает страницу записей вперёд / назад, для одной записи переключает страницу коментариев.
**Alt+w** / **Alt+q** — осуществляет переход ко следующей / предыдущей записи (если таковые существуют), работает в режиме списка, одной записи и просмотра изображения
**Alt+x** / **Alt+z** — прокручивает страницу вниз / вверх. В режиме просмотра изображений переключает изображения вперёд циклично / назад
**Escape** — закрывает модальное окно, если открыто, возвращает к списку, если открыта одиночная запись, отменяет поисковый запрос в режиме списка
**Alt+c** — фокусирует на поле поиска или ввода комментария, в зависимости от текущего режима
**Alt+v** — включает / отключает режим просмотра фото для одиночного объявления
**Alt+r** — открывает / закрывает список входящих комментариев для авторизованного пользователя
**Alt+t** — переключает светлую / тёмную темы оформления
**Alt+g** — список объявлений
**Alt+u** — пользователей
**Alt+p** — форум
Знаю, во многих браузерах эти сочетания используются самим браузером, однако для моего хрома я не смог придумать что-то удобнее. Буду рад вашим предложениям.
Помимо клавиатуры конечно же можно использовать консоль браузера. Для примера — *store.goBack()*, *store.nextPage()*, *store.prevPage()*, *store.nextItem()*, *store.prevItem()*, *store.search(stringValue)*, *store.checkUpdate('goods'||'users'||'posts'||'files'||'cmnts')* — делают то что подразумевает из название; *store.get().comments* и *store.get().\_images* — возвращает группированные файлы и комментарии; *store.get().ignoredItems* и *store.get().scribedItems* — списки игнорируемых и отслеживаемых вами записей. Полный список всех промежуточных и вычисленных данным доступен из *store.get()*. Не думаю что это всерьёз может кому-то понадобиться, но, к примеру, отфильтровать записи по пользователю и удалить мне показалось вполне удобно именно из консоли.
Заключение
----------
На этом знакомство с проектом можно закончить, больше подробностей вы можете найти в исходных текстах. Как итог у нас получилось довольно быстрое и компактное приложение, в большинстве валидаторов, чекеров безопасности, скорости, доступности и т. п. показывает высокие результаты без целенаправленной оптимизации.
Хочется узнать мнение сообщества насколько оправданно использованные в прототипе подходы к организации приложений, какие могут быть подводные камни, что бы вы реализовали принципиально по-другому?
Исходный код, примерная инструкция по установке и демо по [ссылке](https://github.com/ddidwyll/comico) (просьба ~~вандалить~~ тестировать в рамках УК РФ).
Постскриптум. Немного меркантильного в завершение. Подскажите с таким уровнем реально начать программировать за деньги? Если нет, на что обратить внимание в первую очередь, если да, подскажите где сейчас ищут интересную работу на схожем стеке. Спасибо.
Постпостскриптум. Ещё немного о деньгах и работе. Как вам такая идея: предположим человек готов работать над интересным ему проектом за любую з/п, однако данные о задачах и их оплате будут доступны публично (желательна доступность и кода для оценки качества исполнения), в случае если оплата будет существенно ниже рынка конкуренты работодателя могут предложить большие деньги за выполнение их задач, если выше — многие исполнители смогут предложить свои услуги по меньшей цене. Не будет ли такая схема в некоторых ситуациях более оптимально и справедливо балансировать рынок (IT)? | https://habr.com/ru/post/435908/ | null | ru | null |
# Современный подход к наблюдаемости
Эпоха монолитных приложений почти прошла. Современные системы разделены на множество компонентов. Даже в самом простом приложении может быть много микросервисов, а у тех есть свои составляющие, например база данных, так что число элементов в системе растёт в геометрической прогрессии.
Пирамида SRE из книги GoogleПосмотрите на пирамиду SRE из книги [Google о SRE](https://sre.google/sre-book/part-III-practices/) — в её основании лежит мониторинг. Мы должны очень хорошо понимать, что происходит в нашей системе в каждый момент времени.
Чем качественнее наблюдение, тем меньше багов. А ещё можно вовремя находить узкие места и тратить меньше времени на обслуживание системы. В этой статье мы поговорим о наблюдаемости и её главных инструментах.
Зачем нам наблюдаемость?
------------------------
Чтобы было понятнее, возьмём для примера приложение, которое обрабатывает создание аккаунтов.
1. *UI Microservice* — бэкенд-сервис, который будет обрабатывать запросы, полученные от пользовательского интерфейса (это может быть мобильное или веб-приложение). Получив данные от пользователя, этот микросервис будет делать запрос к *Accounts Microservice*.
2. *Accounts Microservice* проверяет, есть в базе данных такой аккаунт или нет. Если нет, добавляет новый аккаунт. Если есть, ничего не делает.
Схема архитектуры нашего приложенияЛоги
----
Лог — это запись, которая описывает событие, произошедшее в системе или сервисе. Обычно логи включают метаданные с контекстом, например метку времени, когда произошло событие. Логи можно структурировать в любом формате (скажем, JSON) или отображать как обычный текст.
Например, наш микросервис Accounts может занести в лог ошибку, возвращённую базой данных:
```
{
"timestamp":"2022–08–09T14:30:31Z",
"action":"create_account",
"user":"user@example.com",
"type":"SQL_ERROR",
"message":"SQL Example Error"
}
```
Мы можем заглянуть в лог и узнать, почему приложение не зарегистрировало аккаунт в базе данных.
Логи очень просты, но при этом эффективны для анализа события в системе, если предоставляют качественный контекст. Правда, тут надо действовать с умом:
1. Если мы записываем слишком много подробностей, страдает производительность приложения.
2. Если мы храним логи, нужно проследить, чтобы хранилище не обходилось слишком дорого.
3. В логах НЕ должно быть конфиденциальной информации.
Для логов не нужен отдельный сервис — в языке программирования уже есть библиотека для их создания.
Лучше хранить логи централизованно, чтобы можно было изучать всю полезную информацию в одном месте. Существуют инструменты для загрузки логов:
1. [Fluentd](https://www.fluentd.org/) — опенсорс-проект, с помощью которого можно загружать логи в разные хранилища.
2. Если сервис развёрнут в облаке (AWS, Azure, GCP и т. д.), там уже есть управляемый сервис для сбора логов. Например, [AWS CloudWatch](https://aws.amazon.com/es/cloudwatch/) или [GCP Cloud Monitoring.](https://cloud.google.com/monitoring)
3. [Datadog](https://docs.datadoghq.com/logs/), [ELK Stack](https://www.elastic.co/es/what-is/elk-stack) и [New Relic](https://newrelic.com/) — платформы наблюдаемости, которые предлагают инструменты для сбора, анализа и хранения логов.
Метрики
-------
Метрики помогают измерять количественные характеристики системы. У метрики обычно есть имя, значение, метка времени и метки.
Кстати, следите за кардинальностью меток — если она слишком высокая, пострадает производительность системы. Не пытайтесь уместить очень много информации в одной метрике.
В нашем примере можно определить метрику для мониторинга числа ошибок, полученных из базы данных. Мы не узнаем столько же информации, сколько из лога, но это лёгкий способ собрать общие сведения.
Метрики можно использовать двумя способами:
1. **Прямой мониторинг** — визуализации. По метрикам на дашбордах очень удобно отслеживать поведение системы.
2. **Непрямой мониторинг —** оповещения. Можно определить пороговое значение и настроить уведомления о том, что метрика пересекла этот порог.
Для работы с метриками есть две категории инструментов.
Опенсорс-проекты
----------------
Если мы хотим использовать опенсорс-решения, придётся комбинировать несколько продуктов.
1. Для сбора метрик обычно используется [Prometheus](https://prometheus.io/). Он предлагает SDK по реализации и сбору метрик для разных языков программирования.
2. Prometheus может хранить метрики, но хранилище у него не лучшее. Если вы планируете долго хранить метрики, а система производит очень много метрик, лучше использовать [Thanos](https://thanos.io/). Thanos оптимизирован для долгосрочного хранения метрик Prometheus.
3. Prometheus и Thanos позволяют визуализировать хранимые метрики, но если нам нужны расширенные возможности визуализации, стоит использовать [Grafana](https://grafana.com/) с её продуманными дашбордами.
4. Для оповещений у нас есть [Alert Manager](https://prometheus.io/docs/alerting/latest/alertmanager/#:~:text=The%20Alertmanager%20handles%20alerts%20sent,silencing%20and%20inhibition%20of%20alerts.), уже интегрированный в Prometheus, где можно определять правила. Alert Manager можно интегрировать с разными решениями для on-call.
Облачные платформы и коммерческие решения
-----------------------------------------
На облачных платформах есть инструменты для сбора метрик, а также для их хранения, визуализации и настройки оповещений. Это хороший вариант для систем, развёрнутых в облаке, если вас не смущает цена.
У Datadog, ELK Stack и New Relic тоже есть SDK для отправки метрик и весь стек, необходимый для работы с ними.
Трассировки
-----------
В распределённых системах метрик и логов может быть недостаточно для полноценного анализа события. В этом случае используются трассировки, которые записывают информацию на протяжении всего жизненного цикла действия, включая результат, время, потраченное в каждом сервисе, и другие полезные сведения.
В нашем примере давайте рассмотрим запрос пользователя на регистрацию аккаунта:
Пример запроса в приложенииДля этого запроса трассировка может выглядеть так:
```
{
{
"name":"example-trace-ui-microservice",
"start_time":"2022-08-09T14:29:21Z",
"end_time":"2022-08-09T14:29:25Z",
"trace_id":1234,
"span_id":1,
"Events":[
{
"Name":"”send-account-microservice-request”",
"timestamp":"2022-08-09T14:29:23Z"
}
]
},
{
"name":"“example-trace-account-microservice",
"start_time":"2022-08-09T14:29:26Z",
"end_time":"2022-08-09T14:29:30Z",
"trace_id":1234,
"span_id":2,
"events":[
{
"name":"”get-request”",
"timestamp":"2022-08-09T14:29:26Z"
},
{
"name":"”send-database-request”",
"timestamp":"2022-08-09T14:29:27Z"
},
{
"name":"”get-database-response”",
"result":"Success",
"timestamp":"2022-08-09T14:29:27Z"
}
]
},
{
"name":"example-trace-ui-microservice-2",
"start_time":"2022-08-09T14:29:31Z",
"end_time":"2022-08-09T14:29:31Z",
"trace-id":1234,
"span_id":3,
"events":[
{
"name":"”get-account-microservice-response”",
"result":200,
"timestamp":"2022-08-09T14:29:32Z"
}
]
}
}
```
Трассировки могут извлекать метрики из действий, например, время, потраченное на операцию в базе данных. Трассировки тоже можно визуализировать, чтобы изучить взаимодействие между разными компонентами и определить, какой сервис сбоит и где у системы узкие места.
Для распределённой трассировки доступны следующие инструменты:
1. Среди опенсорс-проектов можно выделить два: [OpenTelemetry](https://opentelemetry.io/) и [Jaeger](https://www.jaegertracing.io/). Если мы хотим визуализировать трассировки, можно использовать их родные инструменты визуализации или интегрировать их с Grafana, чтобы получить больше возможностей.
2. На облачных платформах есть свои сервисы для сбора трассировок.
3. Также можно использовать решения Datadog, New Relic и ELK Stack.
Универсальное решение?
----------------------
Наверное, вы уже заметили, что инструменты для наблюдаемости можно разделить на две большие категории:
1. Отдельные опенсорс-решения, которые мы собираем и настраиваем сами.
2. Сервисы на облачных платформах или сторонние стеки (Datadog, ELK Stack, New Relic).
А как насчёт опенсорс-проекта для комплексного подхода к наблюдаемости? OpenTelemetry сочетает в себе два решения для мониторинга — OpenTracing и OpenCensus — и развивается как единый инструмент для всех задач, связанных с мониторингом.
Универсального решения не существует. Нужно проанализировать требования, расходы, масштабируемость, навыки команды и многие другие факторы каждой системы, чтобы выбрать подходящий продукт.
Как улучшить наблюдаемостьВсе компании, рано или поздно сталкиваются с внедрением SRE-практик, которые помогают повысить отказоустойчивость системы и минимизировать издержки бизнеса. Приходите на трехнедельных практический курс [SRE: data-driven подход к управлению надёжностью систем.](https://slurm.club/3ipfmjn)
Обучение выстроено по принципу полного погружения в среду, чтобы студенты не просто изучали теорию и смотрели видеоуроки, а могли сами потрогать различные инструменты и поработать в команде. Формат предполагает разделение на команды, разбор интересных кейсов и обмен опытом между участниками и спикерами.
**На курсе вы:**
* внедрите правки прямо в прод;
* узнаете, как решать конкретные проблемы, связанные с надежностью сервиса;
* поймете, какие метрики собирать и как это делать правильно;
* научитесь быстро поднимать продакшн силами команды.
Помимо того, что учиться будет интересно, благодаря новым знаниям и практике вы сможете:
* снизить процент отказов своего сервиса;
* повысить скорость реагирования на отказы;
* снизить риски при выкате новых фич;
* увеличить скорость разработки.
Курс хорошо подходит как для только думающих внедрять в компании практики SRE, так и для сформировавшихся команд, которые хотят опробовать новые практики, улучшить имеющиеся и обменяться опытом с коллегами.
Для команд от 5 человек у нас действуют [особые условия](https://slurm.club/3ipfmjn) участия -65 000 Р за 1 сотрудника, вместо 75 000 Р. **Возможна постоплата!**
[Посмотреть программу и записаться.](https://slurm.club/3ipfmjn) | https://habr.com/ru/post/703056/ | null | ru | null |
# Внедрение кода в Silverlight
В свободное время я занимаюсь разработкой [Snoop'a](http://snoopwpf.codeplex.com/). Это отличное подспорье WPF разработчикам, которое не имеет хороших бесплатных аналогов в мире Silverlight. Snoop внедряет свою сборку в WPF процесс и раскладывает его по полочкам.
Мне стало любопытно: можно ли внедрить произвольную сборку в исполняющийся сильверлайт процесс извне браузера? ~~(можно)~~ Об этом и пойдет речь под катом.
Насколько мне известно, все существующие программы, внедряющие код в сильверлайт, делают это посредством перехвата и модификации .xap файла до загрузки приложения. Это неплохой способ, однако он обладает рядом недостатков:
1. Нельзя подключиться к уже запущенному приложению без перезагрузки страницы
2. Перехват .xap файла зачастую ограничивает среду выполнения плагина Internet Explorer'ом. Для универсального перехватчика нужно использовать/писать http-сниффер.
Я же хочу предложить способ, который позволяет подключиться к уже запущенному приложению и внедриться в него без перезагрузки страницы, без модификации .xap файла и без ограничений на браузер. Прежде чем мы начнем, позвольте представить сегодняшнего open-source гостя:
##### slinject
Эта консольная программа — плод программистского любопытства. Она позволяет выбрать исполняющийся Silverlight процесс и внедрить в него Silverlight сборку (тыкните для большего разрешения):
[](http://3.bp.blogspot.com/-g7VSBGgUX1Q/TmrxX62j8MI/AAAAAAAAApg/n9FIGXxbvMk/s1600/slinject_demo.jpg)
Бинарники можно скачать [здесь](https://github.com/downloads/anvaka/slinject/slinject-bin.zip), а исходный код на C# доступен на [github'e](https://github.com/anvaka/slinject). Прежде чем вы начнете внедряться, программу нужно установить, выполнив команду:
`slinject --install`
Это одноразовая операция, требующая администраторских прав. После установки инжектора внедряться можно под любым пользователем.
##### Подождите, не уходите! Или как это работает
Как это часто бывает, идея очень простая. Подключиться отладчиком к Silverlight процессу и выполнить команду Assembly.Load(). Это всегда было можно сделать из отладчика Visual Studio, но можно ли это сделать из своей программы?
Сильверлайт устанавливается с рядом интересных библиотек и инструментов, которые, к сожалению, имеют либо отвратительную документацию, либо никакой. Одна из таких библиотек — **dbgshim.dll**. Именно через эту дверь ходят отладчики в мир Silverlight'a. Visual Studio использует ее, так почему бы и нам не воспользоваться лазейкой? Правда, почему бы и нет? Отстутвие хорошей [документации](http://msdn.microsoft.com/en-us/library/cc994496.aspx) нельзя назвать хорошим аргументом. А вот хорошим вызовом для любопытных — можно.
Итак, после нескольких ночей блуждания по ~~царству Морфея~~ пространству имен [ICorDebug](http://msdn.microsoft.com/en-us/library/ms230588.aspx) мне удалось написать консольную программу, которая умела быть простым отладчиком Silverlight процессов. Она умела реагировать на основные события отладчика, находить нужные функции, устанавливать брякпоинты и останавливаться на них. Иногда она даже умела делать expression evaluation (ака function evaluation, FuncEval), исполнять код то бишь. Увы, готовить кофе она так и не научилась.
##### Проблема
Нужно было найти метод в Silverlight, который бы гарантированно вызывался в любом Silverlight процессе, чтобы поставить брякпоинт в нем. В случае с WPF/WinForms приложениям — все просто. Берем обработчик очереди Windows сообщений и ставим точку останова в нем. Но в Сильверлайте нет очереди Windows сообщений. К счастью, в нем есть близкий аналог: метод JoltHelper.FireEvent(). Этот метод вызывается даже в пустом Silverlight приложении, достаточно лишь пошевелить мышку.
Помните, я сказал, что консольный отладчик умел делать expression evaluation… иногда? На самом деле, чтобы выполнить код во время точки останова инфраструктура отладки требует [ряда условий](http://blogs.msdn.com/b/jmstall/archive/2005/11/15/funceval-rules.aspx). Если метод оптимизирован ни о каком funceval'e и речи быть не может. JoltHelper.FireEvent(), конечно, оптимизирован:
##### Решение
Оказывается Silverlight jitter, как и его большой брат из мира .NET, прислушивается к [.ini рекомендациям](http://msdn.microsoft.com/en-us/library/9dd8z24x.aspx) по оптимизации генерируемого кода. Достаточно создать следующий .INI файл рядом со сборкой:
`[.NET Framework Debugging Control]
GenerateTrackingInfo=1
AllowOptimize=0`
Сохранить его как «Имя\_сборки\_без\_dll.ini», и в следующий раз во время JIT-компиляции генерируемый код будет более дружелюбен к отладчику. Самый большой подвох заключается в кодировке .ini файла. Если она отличается от UTF-16 Little Endian — файл будет просто проигнорирован.
Для улучшения производительности, Silverlight, во время установки, генерирует образы в машинных кодах для стандартных сборок. По сути, тот же самый [ngen](http://msdn.microsoft.com/en-us/library/6t9t5wcf(v=vs.80).aspx), только утилита называется coregen, и результат генерации кладется в папку Silverlight'a. Coregen также принимает во внимание наличие .ini рекомендаций, и может генерировать пригодный для отладки машинный код.
Когда вы говорите:
`slinject --install`
Программа создает System.Windows.ini файл с нужными рекомендациями jitter'у. удаляет старый прекомпилированный образ System.Windows.ni.dll, и просит coregen создать отлаживабельный образ. Ну и конечно, чтобы отменить все эти изменения, достаточно выполнить
`slinject --uninstall`
##### В заключение
Итак, мы получили универсальный внедритель сборок в Silverlight? Увы, нет. Даже убийство потока выглядит более безобидно, чем прерывание его в случайном месте с просьбой выполнить случайный код. Mike Stall в своем блоге рассказывает почему [FuncEval — зло](http://blogs.msdn.com/b/jmstall/archive/2005/03/23/400794.aspx), но полезное зло. В конце концов, именно так работают окна Watches/Locals/Immediate в Visual Studio. Вооружившись этими знаниями, используя slinject, будьте готовы к падениям Silverlight процессов, крешам браузеров и обманам политиков.
Более того, я не эксперт в COM'e/ICorDebug'e. Наверняка я наделал кучу ляпов [в коде](https://github.com/anvaka/slinject), но ведь это открытый код — буду рад если вы покажете/исправите ошибки.
Надеюсь, вам понравилась эта прогулка в мир отладчика Silverlight — буду рад отзывам :). | https://habr.com/ru/post/128189/ | null | ru | null |
# Локализация своих скриптов на BASH
Создание меню на BASH — задача сама по себе не сложная: "case тебе в руки и echo в спину". Решая её в очередной раз, мне захотелось добавить возможность отображать текст на других языках. Осталось решить, как сделать сам процесс локализации меню более удобным. Если оно большое, то решение "в лоб" превратит его в громоздкую копипасту. Здесь я хотел бы поделиться тем, как решил эту проблему для себя. Надеюсь, для кого то это будет небезынтересным.
Чтобы статья не вылилась в скучную простыню с излишком кода, решил разбить её на две части. В первой рассмотрим создание и добавление дополнительных языков. Во второй — создание многоуровнего меню и сохранение настроек
**Примечание:**
Я вполне понимаю и принимаю, что существуют и другие языки программирования. Как когда-то кто-то сказал здесь на Хабре — если при написании скрипта на BASH возникает необходимость хоть в одной функции, то лучше взять нормальный язык. Я с этим согласен, но иногда, как говорится, хочется, потому что хочется.
Мне не хотелось бы разбивать скрипт на несколько частей и хранить локализацию в отдельных файлах. Скрипт тем и удобен, что его проще использовать одним файлом. Поэтому тексты будем хранить в массивах.
Реализация будет состоять из:
* буквенного кода языка
* массива слов
* преобразователя косвенных ссылок для обращения к массиву
* обращения к элементам массива
* создания меню
Теперь рассмотрим подробнее
Зададим язык, добавив короткий буквенный код языка (ru, en), для начала английский:
```
langset=en
```
Добавим массивы слов и предложений (по количеству языков):
```
language_en=( "English" "Quit" "Hi, Habr!" )
language_ru=( "Русский" "Выход" "Привет, Хабр!" )
```
Создадим косвенную ссылку и сформируем из неё новый массив в переменной *lng*:
```
lng="language_$langset[@]"; lng=("${!lng}")
```
То есть здесь для переменной *lng* создаётся значение, состоящее из части имени массива со словами и кода заданного языка из переменной *langset*. Далее создаётся массив, который при *langset=en* будет равен *language\_en*, а при *langset=ru* будет равен *language\_ru*.
Если языков будет много, то такой подход позволит избавиться от многочисленных *if-elif* или *case*. Чтобы изменить язык, достаточно будет добавить массив с переводом и установить язык в переменной *langset*.
Запустим всё это в консоли:
```
language_en=( "English" "Quit" "Hi, Habr!" )
language_ru=( "Русский" "Выход" "Привет, Хабр!" )
langset=en
lng="language_$langset[@]"; lng=("${!lng}")
echo "${lng[2]}"
# Вывод: Hi, Habr!
langset=ru
lng="language_$langset[@]"; lng=("${!lng}")
echo "${lng[2]}"
# Вывод: Привет, Хабр!
```
Таким образом, указывая в начале скрипта двухбуквенный код языка, можно задавать вывод одних и тех же слов или фраз на разных языках.
Построение меню
---------------
А теперь попробуем создать скрипт.
Для примера я взял меню управления командами Git через CLI (*command line interface*). Это немного надуманно, но хорошо подходит для примера, так как в Git много команд и как раз можно построить единое по своей задаче меню с множеством параметров.
Для начала задаем язык и массив с пунктами меню как это уже делали выше. Ради удобства, я разделил массив на две части: первая — это непосредственно меню, вторая — информационные сообщения и приглашения командной строки, которые необходимо будет вывести по ходу работы.
```
#!/bin/bash
# Код языка
langset=en
# Пункты меню
language_en=( "English" "Quit" "Main menu" "Git: add ALL files/commit" "Git init" "Change language" "Language selection" )
message_en=( "English" "Select item" "Wrong! This item does not exist" "Added all files" "Enter you commit" "Changes recorded" "Select a language" "The language has been changed to" "Start the program again" "Menu for language change" )
language_ru=( "Русский" "Выход" "Основное меню" "Git: добавить ВСЕ файлы/коммит" "" "" "Выбор языка" )
message_ru=( "Русский" "Выберите пункт" "Неверно! Этого пункта не существует" "Добавление всех файлов" "Введите ваш коммит" "Изменения зарегистрированы" "Выберите язык" "Язык изменен на" "Запустите программу заново" "Меню для смены языка" )
language_de=( "Deutsch" )
message_de=( "Deutsch" "" "" "" "" "" "" "" "Starten Sie das Programm neu" )
```
Пройдемся по массивам и создадим новые для *lng* и *msg*, которые и будут использоваться:
```
languages() {
lng="language_$langset[@]"; lng=("${!lng}")
msg="message_$langset[@]"; msg=("${!msg}")
for b in ${!language_en[@]} ${!message_en[@]} ; do
if [[ ! ${lng[$b]} ]] ; then
lng[$b]=${language_en[$b]}
fi
if [[ ! ${msg[$b]} ]] ; then
msg[$b]=${message_en[$b]}
fi
done
}
languages
```
Чтобы при необходимости иметь возможность применять языковые настройки (это пригодится в следующей статье), заключим всё в функцию и тут же вызовем её.
*Небольшое отступление:* я уверен, почти всем встречались наполовину переведённые приложения. Особенно этим грешат кастомные прошивки для телефонов. Мне никогда это не нравилось, но в данном случае я всё же решил предусмотреть такую возможность неполного перевода. Это позволит при добавлении нового языка не дублировать все элементы массива, а добавить только те, которые пользователю хотелось бы перевести.
Для этого в цикле сравним созданный массив с англоязычным (английский считаем языком по умолчанию): если записи не существует (либо элемент массива пуст), дополним англоязычным вариантом.
Теперь, когда с языками разобрались, приступим к построению меню. Тут всё стандартно: бесконечный цикл, внутри него цикл для вывода элементов на экран и выбор вариантов через *case*.
Формируем массив для вывода на экран. Только те пункты, которые нам нужны:
```
local menu0=([1]="${lng[3]}" "${lng[4]}" "${lng[5]}" "${lng[1]}")
```
Здесь делаем индексацию с *1*, чтобы выводить индекс как соответствующий пункт меню.
Добавляем шапку, пробегаемся по индексам через *${!menu0[@]}* и выводим на экран:
```
echo
echo "---${lng[2]}---"
for op in "${!menu0[@]}" ; do
echo "$op ) ${menu0[$op]}"
done
echo ----------
```
Далее предложим пользователю выбрать необходимый пункт. Будем ожидать нажатие цифровой клавиши через *read -s -n1 -p*. Где *-s* — не отображать введённые данные (чаще используется для ввода паролей). Мы же потом сами отобразим введеный текст в более удобном формате. *-p* — строка приглашения для вывода подсказки. *-n1* — параметр, считывающий число симмволов ввода. Здесь мы заранее знаем, что пунктов меню будет не более 9 (то есть числа из одной цифры), поэтому при нажатии одного любого символа программа продолжит работу дальше. Не надо будет нажимать *Enter* для ввода. Немного непривычно, поэтому можно убрать.
```
# read со строкой приглашения
read -s -n1 -p "${msg[1]}: " item
#вывод нажатой клавиши
echo "[$item]->: ${menu0[$item]}"
```
Ну и заключительный оператор выбора *case* с обработкой введенного значения:
```
case $item in
# Команды Git, без обработки ошибок (репозитория ведь может и не быть)
1 ) git add .
read -p "${msg[4]}: " comm
git commit -m "$comm"
echo "${msg[5]}" ;;
2 ) git init ;;
3 ) echo "${msg[9]}" ;;
# Выход
4 ) exit ;;
# Обработка остальных клавиш и вывод сообщения об ошибке
* ) echo "[$item]->: ${msg[2]}"; sleep 2 ;;
esac
```
Здесь *case* сделан упрощенным, только для примера. В следующей статье я буду использовать его в более универсальном варианте.
**Весь код**
```
#!/bin/bash
# Код языка
langset=ru
# Меню и сообщения
language_en=( "English" "Quit" "Main menu" "Git: add ALL files/commit" "Git init" "Change language" "Language selection" )
message_en=( "English" "Select item" "Wrong! This item does not exist" "Added all files" "Enter you commit" "Changes recorded" "Select a language" "The language has been changed to" "Start the program again" "There will be a menu for changing the language" )
language_ru=( "Русский" "Выход" "Основное меню" "Git: добавить ВСЕ файлы/коммит" "" "" "Выбор языка" )
message_ru=( "Русский" "Выберите пункт" "Неверно! Этого пункта не существует" "Добавление всех файлов" "Введите ваш коммит" "Изменения зарегистрированы" "Выберите язык" "Язык изменен на" "Запустите программу заново" "Здесь будет меню для смены языка" )
language_de=( "Deutsch" )
message_de=( "Deutsch" "" "" "" "" "" "" "" "Starten Sie das Programm neu" )
languages() {
# Косвенные ссылки и создание нового массива
lng="language_$langset[@]"; lng=("${!lng}")
msg="message_$langset[@]"; msg=("${!msg}")
# Сравнение массивов для проверки на пропущенные элементы
for b in ${!language_en[@]} ${!message_en[@]} ; do
if [[ ! ${lng[$b]} ]] ; then
lng[$b]=${language_en[$b]}
fi
if [[ ! ${msg[$b]} ]] ; then
msg[$b]=${message_en[$b]}
fi
done
}
languages
main() {
# Создание и вывод меню на экран
local menu0=([1]="${lng[3]}" "${lng[4]}" "${lng[5]} [$langset]" "${lng[1]}")
while true ; do
echo
echo "---${lng[2]}---"
for op in "${!menu0[@]}" ; do
echo "$op ) ${menu0[$op]}"
done
echo ----------
# Ожидание ввода значения
read -s -n1 -p "${msg[1]}: " item
echo "[$item]->: ${menu0[$item]}"
# Оператор выбора
case $item in
# Команды Git, без обработки ошибок (репозитория ведь может и не быть)
1 )
# git add .
read -p "${msg[4]}: " comm
# git commit -m "$comm"
echo "${msg[5]}" ;;
2 )
# git init ;;
3 ) echo "${msg[9]}" ;;
# Выход
4 ) exit ;;
# Обработка остальных клавиш и вывод сообщения об ошибке
* ) echo "[$item]->: ${msg[2]}"; sleep 2 ;;
esac
done
}
main
exit 0
```
Это первая статья из двух. В [следующей](https://habr.com/ru/post/542252/) рассмотрим создание многоуровнего меню, разукрасим вывод (как же без этого), а также попробуем сохранить настройки, то есть задать код языка прямо из меню, не открывая Shell-скрипт в текстовом редакторе.
Спасибо, что дочитали до конца. Надеюсь, было не скучно. | https://habr.com/ru/post/539586/ | null | ru | null |
# Не все патчи одинаково полезны
Эта заметка продолжает разбор улучшений производительности, которые могли бы стать явью, если бы не разные "но". Предыдущая часть о `StringBuilder`-е находится [здесь](https://habr.com/ru/post/436746/).
Здесь мы рассмотрим несколько "улучшений", отклонённых из-за непонимания тонкостей спецификации языка, неочевидных угловых случаев и других причин. Поехали!
#### Когда ничто не предвещает беды
Думаю, каждый из нас работал с методами `Collections.emptySet()` / `Collections.emptyList()`. Это очень полезные методы, которые позволяют вернуть пустую неизменяемую коллекцию без создания нового объекта. Посмотрев внутрь класса `EmptyList` мы увидим там вот это:
```
private static class EmptyList {
public Iterator iterator() {
return emptyIterator();
}
public Object[] toArray() {
return new Object[0];
}
}
```
Видите мощный потенциал для улучшения? Метод `EmptyList.iterator()` возвращает пустой итератор из наличия, почему бы не сделать такой же финт ушами для массива, возвращаемого методом `toArray()`?
**Есть одно но, и называется оно документация**
> The returned array will be "safe" in that no references to it are maintained by this list. (In other words, this method must allocate a new array even if this list is backed by an array). The caller is thus free to modify the returned array.
<http://mail.openjdk.java.net/pipermail/core-libs-dev/2017-September/049170.html>
<http://hg.openjdk.java.net/jdk/jdk12/file/ffac5eabbf28/src/java.base/share/classes/java/util/List.java#l185>
Иными словами, метод должен всегда возвращать **новый** массив.
Вы скажете: "Он же неизменяемый! Что может пойти не так!?"
Ответить на этот вопрос могут только опытные знатоки:
> — Кто отвечает?
>
> — Отвечают знатоки Пол Сандоз и Тагир Валеев
**Ответ знатоков**<http://mail.openjdk.java.net/pipermail/core-libs-dev/2017-September/049171.html>
> Also note that this changes visible behavior. E. g. somebody might synchronize on the array object returned by toArray call, so this change might cause unwanted **lock sharing**.
>
>
>
> Once I suggested similar improvement: to return EMPTY\_LIST from Arrays.asList() when supplied array has zero length. It was declined with the same reason [1].
>
>
>
> <http://mail.openjdk.java.net/pipermail/core-libs-dev/2015-September/035197.html>
>
>
>
> By the way, probably it's reasonable then for Arrays.asList to check the array length like:
>
>
> ```
> public static List asList(T... a) {
> if(a.length == 0) return Collections.emptyList();
> return new ArrayList<>(a);
> }
> ```
>
>
>
>
> Звучит разумно, не так ли? Зачем создавать новый список для пустого массива, если можно бесплатно взять уже готовый?
>
> There is a reason not to do this. At the moment Arrays.asList specifies no constraints on the identity of the returned List. Adding the micro-optimisation will change that. It’s an edge case and a questionable use-case too, but considering that i would conservatively leave things as they are.
Вот это утверждение наверняка вызовет у вас недоумение:
> E. g. somebody might synchronize on the array object returned by toArray call, so this change might cause unwanted lock sharing.
Вы скажете: "Кто в здравом уме будет синхронизироваться на массиве (!) возвращаемом (!!!) из коллекции!?"
Звучит не очень правдоподобно, но такую возможность язык предоставляет, а значит существует вероятность того, что некий пользователь сделает это (а то и уже сделал). Тогда предлагаемое изменение в лучшем случае изменит поведение кода, а в худшем — приведёт к поломке в синхронизации (поди потом, отлови её). Риск настолько неоправдан, а предполагаемый выигрыш столь незначителен, что лучше оставить всё как есть.
Вообще возможность синхронизации на любом объекте, кмк, была ошибкой разработчиков языка. Во-первых, в заголовке каждого объекта содержится структура, отвечающая за синхронизацию, а во-вторых мы оказываемся в описанной выше ситуации, когда вроде бы неизменяемый объект нельзя возвращать многократно, т. к. на нём могут синхронизироваться.
Мораль сей басни такова: спецификация и обратная совместимость — священные коровы острова Ява. Даже не пытайтесь покушаться на них: стража стреляет без предупреждения.
#### Стараешься-стараешься...
В JDK существует сразу несколько классов, основанных на массиве, и все они реализуют методы `List.indexOf()` и `List.lastIndexOf()`:
* java.util.ArrayList
* java.util.Arrays$ArrayList
* java.util.Vector
* java.util.concurrent.CopyOnWriteArrayList
Код указанных методов в этих классах повторяется почти один к одному. Свои решения для этой же задачи предлагают также многие приложения и фреймворки:
* [org.hibernate.bytecode.enhance.internal.tracker.SimpleFieldTracker](https://github.com/hibernate/hibernate-orm/blob/0a2a5c622e3eb30724e80bc8661c0ac55ebfb2be/hibernate-core/src/main/java/org/hibernate/bytecode/enhance/internal/tracker/SimpleFieldTracker.java#L40)
* [com.intellij.util.ArrayUtil](https://github.com/JetBrains/intellij-community/blob/200f59d7cf3b0f66feb3a4abebbb90864dc5edc7/platform/util/src/com/intellij/util/ArrayUtil.java#L726)
* [com.intellij.util.ArrayUtilRt](https://github.com/JetBrains/intellij-community/blob/200f59d7cf3b0f66feb3a4abebbb90864dc5edc7/platform/util-rt/src/com/intellij/util/ArrayUtilRt.java#L63)
* [org.springframework.oxm.jibx.JibxMarshaller](https://github.com/spring-projects/spring-framework/blob/5f4d1a4628513ab34098fa3f92ba03aa20fc4204/spring-oxm/src/main/java/org/springframework/oxm/jibx/JibxMarshaller.java#L256)
В итоге имеем бродячий код, который нужно компилировать (при чём иногда по несколько раз), который занимает место в ReserverCodeCache, который нужно тестировать и который просто кочует из класса в класс почти без изменений.
Разработчики, в свою очередь, очень любят писать что-то вроде
```
int i = Arrays.asList(array).indexOf(obj);
// или
boolean contains = Arrays.asList(array).contains(obj);
// при тяжёлом стримозе
boolean contains = Arrays.stream(names).anyMatch(nm -> nm.equals(name));
```
Хотелось бы ввести в JDK обобщённые утилитный методы, и использовать их повсюду, что и было [предложено](http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-March/051968.html). [Заплатка](http://mail.openjdk.java.net/pipermail/core-libs-dev/attachments/20180310/f0ddb552/indexOf.patch) простая как две копейки:
1) реализации `List.indexOf()` и `List.lastIndexOf()` переезжают в `java.util.Arrays`
2) вместо них вызываются, соответственно, `Arrays.indexOf()` и `Arrays.lastIndexOf()`
Казалось бы, что может пойти не так? Выигрыш от этого подхода [вроде бы] очевиден. Но статья о провалах, поэтому подумайте, что может пойти нет так.
> — Кто отвечает?
>
> — Отвечают знатоки Мартин Бухгольц и Пол Сандоз
**Имхо, несколько натянуто, но тем не менее**Мартин Бухгольц:
> Сергей, I'm sort of maintaining all those collection classes, and I have on occasion also wanted to have indexOf methods in Array.java. But:
>
>
>
> Arrays are generally discouraged. Any new static methods on Arrays (or, where I actually want them, on the array object itself! Requires a java language change!) will meet resistance.
>
>
>
> We've come to regret supporting nulls in collections, so newer collection classes like ArrayDeque don't support them.
>
>
>
> Another variant users might want is what kind of equality comparison to use.
>
>
>
> We've come to regret having ArrayList with zero-based start index — it would have been better to have ArrayDeque's circular array behavior in from day one.
>
>
>
> The code to search array slices is very small, so you're not saving much. It's easy to make an off-by-one error, but that's true for an Arrays API as well.
Пол Сандоз:
> I would not go so far as to say arrays are discouraged, i would positively spin it as "use with care” as they are prickly e.g. always mutable. They could certainly be improved. I would be very happy to see arrays implement a common array’ish interface, we might be able to make some progress after value types sediment.
>
>
>
> Any new additions to Arrays would be met with some resistance though, by me at least :-) It’s never adding just one or two methods, many others want come along for the ride as well (all primitives plus range variants). So any new feature needs to be sufficiently beneficial and in this case i don’t think the benefits are strong enough (such as a possible reduction code cache pressure).
Paul.
Переписка: <http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-March/051968.html>
Мораль сей басни такова: ваш гениальный патч могут зарезать на ревью просто потому, что не увидят в нём особой ценности. Ну да, есть повторяющийся код, но он никому особо не мешает, так что пусть живёт.
#### Улучшения для ArrayList-a? Их есть у меня
~~Мопед~~ патч не мой, я просто размещу для подумать. Само предложение было озвучено [здесь](http://mail.openjdk.java.net/pipermail/core-libs-dev/2018-December/057546.html), и выглядит оно очень даже привлекательно. Смотрите сами:
**Предлагаемое изменение**[Ссылка](http://cr.openjdk.java.net/~sgroeger/perf/arraylist/webrev.00/src/java.base/share/classes/java/util/ArrayList.java.sdiff.html)
Невооруженным глазом видно, что предложение очень и очень логично. Измерить производительность можно с помощью простого [бенчмарка](http://cr.openjdk.java.net/~sgroeger/perf/arraylist/ArrayListBenchmark.java):
```
@State(Scope.Benchmark)
public class ArrayListBenchmark {
@State(Scope.Benchmark)
public static class Data {
@Param({"10", "100", "1000", "10000"})
public int size;
ArrayList arrayRandom = new ArrayList(size);
@Setup(Level.Invocation)
public void initArrayList() {
Random rand = new Random();
rand.setSeed(System.currentTimeMillis());
// Populate the ArrayList with size-5 elements
for (int i = 0; i < size - 5; i++) {
Integer r = rand.nextInt() % 256;
arrayRandom.add(r);
}
}
}
@Benchmark
public ArrayList construct\_new\_array\_list(Data d) {
ArrayList al = new ArrayList(d.arrayRandom);
// once a new ArrayList is created add a new element
al.add(new Integer(900));
return al;
}
}
```
Итоги:
```
Benchmark (size) Mode Cnt Score Error Units
До
construct_new_array_list 10 thrpt 25 388.212 ± 23.110 ops/s
construct_new_array_list 100 thrpt 25 90.208 ± 7.995 ops/s
construct_new_array_list 1000 thrpt 25 23.289 ± 1.687 ops/s
construct_new_array_list 10000 thrpt 25 7.659 ± 0.560 ops/s
После
construct_new_array_list 10 thrpt 25 562.678 ± 37.370 ops/s
construct_new_array_list 100 thrpt 25 119.791 ± 13.232 ops/s
construct_new_array_list 1000 thrpt 25 33.811 ± 3.812 ops/s
construct_new_array_list 10000 thrpt 25 10.889 ± 0.564 ops/s
```
Совсем неплохо как для такого простого изменения. Главное, что подвохов-то вроде бы нет. Честно создаём массив, честно копируем данные и про размер не забываем. Вот сейчас патч точно должны принять!
**Но не тут-то было**Мартин Бухгольц:
> This is no question that we can optimize the case of ArrayList -> ArrayList, but what about all the other Collection implementations? ArrayDeque and CopyOnWriteArrayList come to mind.
>
> ArrayList is a popular class to use for making copies of Collections. Where do you stop?
>
>
>
> A pathological subclass of ArrayList could decide to not store elements in the backing array, with ensuing breakage.
>
>
>
> The blessed solution to the list copy problem is probably List.copyOf <https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html#copyOf(java.util.Collection>) which might do the optimization you're hoping for.
Алан Бейтман
> ArrayList is not final so it's possible someone has extended it to use something other than elementData. It might be safer to use the class identity rather than instanceof.
Ничто не запрещает мне отпочковаться от `ArrayList`-а, а данные хранить в связанном списке. Тогда `c instanceof ArrayList` вернёт истину, мы попадём на участок копирования и благополучно свалимся.
Мораль сей басни такова: причиной отказа может стать *возможное* изменение поведения. Иными словами нужно держать в уме вероятность даже самого абсурдного изменения, если оно допускается средствами языка. И да, всё могло бы получиться, если бы `ArrayList` с самого начала объявили `final`.
#### Снова спецификация
Отлаживая своё приложение я случайно провалился в кишки Спринга и нашел там вот такой [код](https://github.com/stsypanov/spring-framework/blob/7574062e43a23c7e401b1879ca8c3657e8eb2275/spring-beans/src/main/java/org/springframework/beans/factory/support/ConstructorResolver.java#L204):
```
// обратите внимание на использование переменной paramTypes
for (Constructor candidate : candidates) {
Class[] paramTypes = candidate.getParameterTypes();
if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
// Already found greedy constructor that can be satisfied ->
// do not look any further, there are only less greedy constructors left.
break;
}
if (paramTypes.length < minNrOfArgs) {
continue;
}
```
По счастливому стечению обстоятельств, зайдя внутрь `java.lang.reflect.Constructor.getParameterTypes()` я прокрутил код чуть ниже и нашел прекрасное:
```
@Override
public Class[] getParameterTypes() {
return parameterTypes.clone();
}
/**
* {@inheritDoc}
* @since 1.8
*/
public int getParameterCount() { return parameterTypes.length; }
```
Понимаете, да? Если нам нужно узнать количество аргументов конструктора/метода, то достаточно вызвать `java.lang.reflect.Method.getParameterCount()` и обойтись без копирования массива. Проверим, стоит ли игра свеч на простейшем случае, в котором у метода нет параметров:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MethodToStringBenchmark {
private Method method;
@Setup
public void setup() throws Exception { method = getClass().getMethod("toString"); }
@Benchmark
public int getParameterCount() { return method.getParameterCount(); }
@Benchmark
public int getParameterTypes() { return method.getParameterTypes().length; }
}
```
На моей машине и с JDK 11 получается так:
```
Benchmark Mode Cnt Score Error Units
getParameterCount avgt 25 2,528 ± 0,085 ns/op
getParameterCount:·gc.alloc.rate avgt 25 ≈ 10⁻⁴ MB/sec
getParameterCount:·gc.alloc.rate.norm avgt 25 ≈ 10⁻⁷ B/op
getParameterCount:·gc.count avgt 25 ≈ 0 counts
getParameterTypes avgt 25 7,299 ± 0,410 ns/op
getParameterTypes:·gc.alloc.rate avgt 25 1999,454 ± 89,929 MB/sec
getParameterTypes:·gc.alloc.rate.norm avgt 25 16,000 ± 0,001 B/op
getParameterTypes:·gc.churn.G1_Eden_Space avgt 25 2003,360 ± 91,537 MB/sec
getParameterTypes:·gc.churn.G1_Eden_Space.norm avgt 25 16,030 ± 0,045 B/op
getParameterTypes:·gc.churn.G1_Old_Gen avgt 25 0,004 ± 0,001 MB/sec
getParameterTypes:·gc.churn.G1_Old_Gen.norm avgt 25 ≈ 10⁻⁵ B/op
getParameterTypes:·gc.count avgt 25 2380,000 counts
getParameterTypes:·gc.time avgt 25 1325,000 ms
```
Что мы можем с этим сделать? Можем поискать использование антипаттерна `Method.getParameterTypes().length` в JDK (по меньшей мере в `java.base`) и заменить его там, где это имеет смысл:
`java.lang.invoke.MethodHandleProxies`
`java.util.concurrent.ForkJoinTask`
`java.lang.reflect.Executable`
`sun.reflect.annotation.AnnotationType`
[Патч](https://mail.openjdk.java.net/pipermail/core-libs-dev/attachments/20191109/a66db498/getParamCount.patch) был отправлен вместе с [сопроводительным письмом](http://mail.openjdk.java.net/pipermail/core-libs-dev/2019-November/063344.html).
Внезапно оказалось, что уже несколько лет как существует [похожая задача](https://bugs.openjdk.java.net/browse/JDK-8029019) и по ней даже подготовлены [изменения](http://cr.openjdk.java.net/~plevart/jdk9-dev/8029019_Annotations.optimization/webrev.01/). В комментариях отмечен довольно приличный, как для таких простых изменений, прирост производительности. Однако, и они, и мой патч пока убраны под сукно и лежат без движения. Почему? Вероятно потому, что разработчики слишком заняты более нужными вещами и у них тупо не доходят руки.
Мораль сей басни такова: ваши гениальные изменения могут зависнуть просто из-за нехватки рабочих рук.
Но это ещё не конец! В ходе обсуждения рациональности описанной замены в других проектах более опытные товарищи выдвинули встречное предложение: может не стоит делать замену `Method.getParameterTypes().length -> Method.getParameterCount()` руками, а поручить это компилятору? Возможно ли это и будет ли это "законным"?
Попробуем проверить с помощью теста:
```
@Test
void arrayClone() {
final Object[] objects = new Object[3];
objects[0] = "azaza";
objects[1] = 365;
objects[2] = 9876L;
final Object[] clone = objects.clone();
assertEquals(objects.length, clone.length);
assertSame(objects[0], clone[0]);
assertSame(objects[1], clone[1]);
assertSame(objects[2], clone[2]);
}
```
который проходит, и который показывает, что если клонированный массив не покидает область видимости, то его можно удалить, т. к. доступ к любому элементу из его ячеек или полю `length` можно получить из оригинала.
Умеет ли делать это JDK? Проверяем:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ArrayAllocationEliminationBenchmark {
private int length = 10;
@Benchmark
public int baseline() {
return new int[length].length;
}
@Benchmark
public int baselineClone() {
return new int[length].clone().length;
}
}
```
Вывод для JDK 13:
```
Benchmark Mode Cnt Score Error Units
baseline avgt 50 6,135 ± 0,140 ns/op
baseline:·gc.alloc.rate.norm avgt 50 56,000 ± 0,001 B/op
clone avgt 50 18,359 ± 0,619 ns/op
clone:·gc.alloc.rate.norm avgt 50 112,000 ± 0,001 B/op
```
Выходит, что openjdk не умеет выбрасывать `new int[length]`, в отличие от [Грааля](https://github.com/oracle/graal/issues/1847), хе-хе:
```
Benchmark Mode Cnt Score Error Units
baseline avgt 25 2,470 ± 0,156 ns/op
baseline:·gc.alloc.rate.norm avgt 25 0,005 ± 0,008 B/op
сlone avgt 25 13,086 ± 1,059 ns/op
сlone:·gc.alloc.rate.norm avgt 25 112,113 ± 0,115 B/op
```
Получается, что можно немного подкрутить оптимизирующий компилятор openjdk, чтобы он мог делать то же, что умеет Грааль. Т. к. влезть в плюсовый адЪ в коде ВМ и напилить что-то осмысленное могут не только лишь все, то я ограничился [письмом](https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2019-November/036003.html), в котором изложил свои наблюдения.
Оказалось, и здесь есть несколько тонкостей. Владимир Иванов [указывает](https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2019-November/036043.html), что:
> Considering there's no way to grow/shrink Java arrays,
>
> "cloned\_array.length => original\_array.length" transformation is correct
>
> irrespective of whether cloned variant escapes or not.
>
>
>
> Moreover, the transformation is already there:
>
>
>
> <http://hg.openjdk.java.net/jdk/jdk/file/tip/src/hotspot/share/opto/memnode.cpp#l2388>
>
>
>
> I haven't looked into the benchmarks you mentioned, but it looks like
>
> cloned\_array.length access is not the reason why cloned array is still
>
> there.
>
>
>
> Regarding your other ideas, redirecting accesses from cloned instance to
>
> original is problematic (in general case) since compiler has to prove
>
> there were no changes in both versions and indexed accesses make it even
>
> harder. And safepoints cause problems as well (for rematerialization).
>
>
>
> But I agree that it would be nice to cover (at least) simple cases of
>
> defensive copying.
Т. е. грохнуть клон вроде бы и можно, и не особо сложно. А вот с преобразованием
```
int len = new int[arrayLength].length;
```
-->
```
int len = arrayLength;
```
возникают [сложности](https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2019-November/036046.html):
> We don't eliminate array allocations that doesn't have a known length
>
> because they might cause a NegativeArraySize Exception. In this case we
>
> should be able to prove that the length is positive though.
>
>
>
> Anyway — I have an almost finished patch that replace unused array
>
> allocations with a proper guard.
Иными словами нельзя просто так взять и выбросить создание массива, т. к согласно [спецификации](https://docs.oracle.com/javase/specs/jls/se13/html/jls-15.html#jls-15.10.2) исполнение *обязано* бросить `NegativeArraySizeException` и ничего мы с этим поделать не можем:
```
@Test
void arrayWithNwgativeSize() {
int length = 0;
try {
int newLen = -3;
length = new Object[newLen].length; // выбросить new Object[newLen] нельзя
fail();
} catch (NegativeArraySizeException e) {
assert length == 0;
}
}
```
Почему же Грааль смог? Думаю, причина в том, что значение поля `length` в бенчмарке выше было постоянным и всегда равнялось 10, что позволило профилировщику сделать вывод о том, что проверка отрицательного значения не нужна, а значит её можно убрать вместе с созданием самого массива. Поправьте в комментариях, если я ошибся.
На сегодня всё :) Добавляйте свои примеры в комментариях, будем разбираться. | https://habr.com/ru/post/433174/ | null | ru | null |
# Пишем плагин для Netbeans. Часть первая
Представьте ситуацию: вы программируете в среде разработки и вам необходимо кому-то отправить небольшой кусок кода из редактора. Вы выделяете нужный кусок, копируете его, открываете браузер, заходите на pastebin, вставляете код, копируете ссылку, а затем отправляете её адресату. А как насчет того, чтобы сократить эти действия вдвое?
Для Netbeans есть плагин PB4NB, но он не работает из-за смены API в pastebin. Поэтому мы напишем свой собственный плагин, который сами же настроим по своему вкусу, а заодно и немного разберёмся с платформой Netbeans. Заинтересованы? Добро пожаловать под кат.
#### Подготовка
Чтобы писать плагины для Netbeans нам в первую очередь нужно активировать модуль разработки. Для этого идём в меню «Tools -> Plugins» и на вкладке «Installed» активируем «Developing Netbeans». Далее, нам нужна будет документация по платформе Netbeans. Она доступна в виде плагина на вкладке «Available Plugins» и называется «Netbeans API Documentation». На этом, пожалуй, всё.
#### Создание проекта
Создаём новый проект («File->New Project->Netbeans Module->Module») и нажимаем «Next».
В поле «Project Name» вводим требуемое имя, пусть это будет «Pastebin», нажимаем «Next».
Заполняем поле «Code Name Base», допустим так «com.pastebin.pastebinplugin» — это будет одновременно и кодовым именем плагина и путём к ресурсам и классам. Поле «Module Display Name» настраивает видимое название плагина в проектах, мы его заполним как «Send to Pastebin.com», но можете вписать туда что-то своё. Остальные поля не трогаем, нажимаем «Finish».
Создался новый проект, структура которого имеет такой вид.
#### Создание действия
Теперь мы переходим непосредственно к созданию самого плагина, а именно к классу его действия. Выбираем «Action» в «New->Other->Module Development» и нажимаем «Next».
Нам предлагают выбрать тип действия: «Включен постоянно» или «Включен при условии». Поскольку мы хотим брать выделенный кусок кода из редактора, то есть наш плагин должен быть активным только при открытом редакторе кода, то выберем второй тип «Conditionally Enabled». В «Cookie Class» ставим «EditorCookie», потому что нам нужен доступ к редактору, а не ко всему проекту в целом. «User Selects One Node» оставляем выбранным, поскольку нам нужно, чтобы плагин был доступен при открытии хотя бы одного узла, поддерживающего EditorCookie. Нажимаем «Next».
На следующем шаге мы будем регистрировать GUI для плагина. То есть его местонахождение в окне Netbeans. Доступно расположение в любом из меню, на панели инструментов, а также в контекстных меню. Для начала выставим категорию. Из предложенного списка нам наиболее подходят «Edit» и «Source», выбираем то, что больше всего нравится, я выбрал первое. Затем нужно подумать, как нам проще всего будет вызывать плагин. Лично мне не хотелось, чтоб иконка маячила на панели перед глазами постоянно, поэтому я добавил пункт в меню «Edit», сразу после пункта «Paste». Если же вам будет удобнее запускать плагин по нажатию иконки на панели, то ставим галочку напротив «Global Toolbar Button» и выбираем удобное место. После того, как настроили всё по вкусу, переходим на следующий шаг.
Имя класса заполняем «PastebinAction». «Display Name» лучше заполнить как можно понятнее, например, «Send to pastebin.com», потому что это отображаемое имя пункта меню. Затем выбираем иконку размером 16x16. Если же на предыдущем шаге выбирали место на панели инструментов, то придётся добавить иконку и с размером 24x24. После этого нажимаем «Finish».
Все те настройки, которые мы проделывали, будут видны в сгенерированном коде:
```
@ActionID(
category = "Edit",
id = "com.pastebin.pastebinplugin.PastebinAction")
@ActionRegistration(
iconBase = "com/pastebin/pastebinplugin/pastebin.png",
displayName = "#CTL_PastebinAction")
@ActionReference(path = "Menu/Edit", position = 1250)
@Messages("CTL_PastebinAction=Send to pastebin.com")
```
#### Первый запуск
Хотя мы еще ничего толком не писали, но уже можно запустить плагин на проверку. Нажимаем «Run», и ждём появления нового окна Netbeans. После этого откроем произвольный текстовый файл и увидим подобную картину:
По непонятным причинам новое окно Netbeans запустилось с русской локализацией, но это не беда, вскоре мы научим наш плагин русскому языку, а пока закроем окно и начнём наконец-то писать код.
#### Рутина
Нетрудно догадаться, что выполнение плагина будет начинаться с метода actionPerformed, поэтому писать код мы будем в теле этого метода. Для начала поиграемся с EditorCookie, который IDE нам сама же и предложила. Но перед этим добавим необходимые библиотеки, иначе последующий код просто не скомпилируется.
В свойствах проекта выбираем вкладку «Libraries» и нажимаем «Add».
Добавим «Nodes API», и «Editor».
Теперь давайте напишем такой код:
```
public void actionPerformed(ActionEvent ev) {
try {
JEditorPane pane = context.getOpenedPanes()[0];
pane.setText("// Hello, editor pane!\n"+pane.getText());
context.openDocument().insertString(0, "// Hello, document!\n", null);
} catch (Exception ex) {
Exceptions.printStackTrace(ex);
}
}
```
Этот код добавляет пару строк в текст открытого исходника при вызове плагина. Делается это двумя различными способами — через JEditorPane и через StyledDocument.
Запустив проект на выполнение, открыв любой файл и вызвав плагин, мы увидим, как добавились две строки:
*// Hello, document!
// Hello, editor pane!*
Что ж, давайте продолжим написание самого плагина. Нам нужно получить выделенный участок текста, а также формат редактируемого исходника, чтобы мы могли правильно настроить подсветку синтаксиса в pastebin. Мы будем пользоваться первым способом — JEditorPane, так как он располагает всеми необходимыми для нас методами. Получать формат подсветки синтаксиса мы будем на основе MIME-типа редактируемого документа.
```
public void actionPerformed(ActionEvent ev) {
JEditorPane currentPane = context.getOpenedPanes()[0];
final String mimeType = NbEditorUtilities.getMimeType(currentPane);
final String code = getSelectedText(currentPane);
System.out.println(mimeType + "\n" + code);
}
private String getSelectedText(JEditorPane currentPane) {
String text = currentPane.getSelectedText();
if (text == null) return currentPane.getText();
return text;
}
```
Запустите проект, выделите какой-нибудь кусок кода, запустите плагин и посмотрите результат в консоли. Затем попробуйте ничего не выделяя запустить плагин — на консоль выведется весь исходник. Последняя функция показалась мне удобной, поскольку иногда приходится отправлять код полностью.
Итак, имея на руках код и его MIME-тип, можем приступать к написанию клиента. Вот [здесь](http://pastebin.com/api) можно получить справку по Pastebin API и узнать свой ключ разработчика.
Код: [PastebinRequest](http://pastebin.com/Fs6wMTxx), [PastebinSender](http://pastebin.com/pgQSCxjJ).
Добавим поле:
*private final PastebinRequest request;*
И проинициализируем его в конструкторе:
*request = new PastebinRequest();*
Затем обновим метод actionPerformed:
```
JEditorPane currentPane = context.getOpenedPanes()[0];
final String mimeType = NbEditorUtilities.getMimeType(currentPane);
final String code = getSelectedText(currentPane);
if (code != null) {
RequestProcessor.getDefault().execute(new Runnable() {
@Override
public void run() {
setupRequest(code, mimeType);
String pastedUrl = PastebinSender.sendRequest(request.getRequestMessage());
System.out.println(pastedUrl);
}
});
}
```
Метод setupRequest я настроил под свои нужды, но вы можете изменить параметры под себя:
```
private void setupRequest(String code, String mimeType) {
request.initRequest();
request.setSourceCode(code);
request.setFormat(mimeType);
request.setExpireDate(PastebinRequest.EXPIRE_DATE.ONE_DAY);
request.setUnlisted(true);
request.setName("");
}
```
Перед запуском, давайте еще более упростим вызов нашего плагина, добавив горячую клавишу для его активации.
Заменим строку:
*@ActionReference(path = «Menu/Edit», position = 1250)*
на:
*@ActionReferences({
@ActionReference(path = «Menu/Edit», position = 1250),
@ActionReference(path = «Shortcuts», name = «OS-P»)
})*
«OS-P», в данном случае, обозначает «Alt+Shift+P». Если не возникнет конфликта с уже имеющимися горячими клавишами, то запустив проект, мы увидим:
Выделяем текст, нажимаем указанную комбинацию и видим на консоли ссылку на размещенный код. Ура, товарищи, мы сделали это! Осталось только вывести диалоговое окно с этой ссылкой. Приступим.
Создадим новый класс и назовём его «UrlDialog». Исходный код этого класса [здесь](http://pastebin.com/tAc84nCK). В класс PastebinAction добавим метод:
```
private void showUrlDialog(final String pastedUrl) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
Frame frame = WindowManager.getDefault().getMainWindow();
UrlDialog dialog = new UrlDialog(frame, pastedUrl);
dialog.setLocation(frame.getWidth() / 2, frame.getHeight()/2);
dialog.setVisible(true);
}
});
}
```
В методе actionPerformed заменим строку:
*System.out.println(pastedUrl);*
на:
*showUrlDialog(pastedUrl);*
Также придётся добавить еще одну библиотеку, для этого в свойствах проекта снова открываем вкладку «Libraries» и добавляем «Window System API».
И, напоследок, нужно открыть файл локализации Bundle.properties и внести туда пару строк:
*UrlDialog.title=Pasted url
UrlDialog.copyButton.text=Copy*
Вот теперь можно запускать проект. Выделяем код, активируем плагин и видим окно:
При нажатии на кнопку «Copy», ссылка скопируется в буфер обмена. Можно сделать, чтобы это окно сразу закрывалось после копирования, можно вообще окно не показывать, а сразу копировать в буфер. Проявите свою фантазию и сделайте так, как вам будет удобно.
#### Локализации
В середине статьи я обещал, что мы научим плагин русскому языку. Это не сложно. Взгляните на последнюю аннотацию перед классом PastebinAction. Там красуется строка:
*@Messages(«CTL\_PastebinAction=Send to pastebin.com»)*
Смело её удаляйте, затем откройте Bundle.properties и добавьте туда строку:
*CTL\_PastebinAction=Send to pastebin.com*
Теперь, в окне обозревателя проектов, правой кнопкой мыши щелкните на файле Bundle.properties и выберите «Add->Locale». Из списка предустановленных локализаций выберите русскую и нажмите OK.
Добавится новый файл, который следует открыть и изменить. Первую строку можно не переводить, иначе в окне обозревателя проектов она тоже переведётся и будет плохо смотреться:
*OpenIDE-Module-Name=Send to Pastebin.com
UrlDialog.title=Ссылка
UrlDialog.copyButton.text=Скопировать
CTL\_PastebinAction=Отправить в pastebin.com*
Ну что ж, самое время проверить работу. Запускаем и видим:
#### Создание NBM-модуля
Итак, последнее, что нам остаётся сделать — это подключить плагин к Netbeans. Щелкнем правой кнопкой мыши на заголовке проекта и выберем «Create NBM». Netbeans любезно соберёт продукт нашей деятельности в понятный для него файл, который останется только подключить в «Tools->Plugins->Downloaded», нажав «Add plugins» и выбрав наш nbm-файл.
#### Итоги
Мы создали свой собственный плагин для Netbeans, настроенный «под себя», а также немного познакомились с платформой Netbeans.
Весь проект можно скачать [здесь](https://docs.google.com/open?id=0B3TcatFyw2R-UEFIVVhYSWVQODA).
Информации по платформе Netbeans довольно мало, но вот [ссылка](http://wiki.netbeans.org/NetBeansDeveloperFAQ), где хоть что-то можно узнать. | https://habr.com/ru/post/146788/ | null | ru | null |
# Vue.js для проекта на Bitrix
Привет, Хабр!
Меня зовут Дмитрий Матлах. Я тимлид в AGIMA. Мы с коллегами обратили внимание, что в сообществе часто возникает вопрос о том, как совместить на одном проекте Bitrix-компоненты и реактивные фронтовые движки. Мы неоднократно сталкивались с подобными задачами, и поэтому я решил подробно рассказать, как мы их решаем. Думаю, если вы используете Bitrix-фреймворк в своих проектах, прочитать будет интересно. Ну и забегая вперед, если вы решаете те же задачи по-другому, то интересно в комментариях узнать поподробнее.
### Теория
Подходы к разработке шаблонов представления в проектах на 1С-Битрикс практически не менялись с момента создания платформы. 1С-Битрикс — MVC-фреймворк со своими особенностями. Но в то же время он всё равно работает по понятной схеме: данные модели + шаблонизатор с шаблоном представления = итоговый html клиенту. Классический вариант. Компоненты Битрикс и компоненты фронтовой части хранятся отдельно — всё круто.
Но вокруг все давно говорят о реактивных фронтовых движках и о новом уровне скорости работы и удобстве поддержки.
Интересно попробовать в своем проекте? Да! Но с Битрикс есть некоторые сложности.
Назрел вопрос: как уйти с проторенного пути и поменять фронтовый стек и при этом сохранить все возможности платформы:
* Возможность инкапсулировать логику в компоненты Битрикс.
* Использовать визуальный редактор для настройки роутинга и ключевых параметров модели.
* Сделать интеграцию Backend- и Frontend-разработки простой и понятной.
* Поддержать возможности современной фронтовой разработки. Прежде всего, сборку с Webpack. Что даст фронтовому разработчику возможность использовать ES6 и модульную структуру JS.
* Обеспечивать индексацию контента страниц поисковым ботом, так как инициализация приложения проходит методами JS и до этого момента на странице не отображаются элементы DOM контентной части. Это создает сложности работы поисковым ботам, которые «не умеют» запускать JS на странице либо делают это частично. В качестве решения выступает механизм SSR (Server Side Rendering). Этот вопрос выходит за рамки данной статьи, и мы уже написали про это [отдельную статью](https://habr.com/ru/company/agima/blog/578056/).
Теперь пробуем со всем этим взлететь.
Сейчас на рынке для перехода по фронтовому стеку есть два популярных решения — два реактивных JS-фреймворка. Думаю, вы догадываетесь, какие именно: React.js и Vue.js.
Нам ближе оказался Vue.js. Вот почему:
* простота использования;
* прекрасная документация;
* легковесность (около 20 КБ — минимизированная сжатая версия);
* может быть принят постепенно, даже используется как замена jQuery;
* удобная структура хранения html, CSS, JS в компонентах;
* все необходимые библиотеки в составе Router, Vuex (global store);
* хорошая расширяемость (миксины, плагины и т. д.).
### Итак, какие есть сложности?
Менять нужно не только стек, но и базовый паттерн с MVC на MVVM. Далее небольшой экскурс.
#### Работа компонента Битрикс при подходе MVC
Для вывода контента страниц в общем случае используется компонент и его шаблон как основа визуальной части. Роутинг начинается от корня раздела, где находится компонент. Компонент может быть простым и комплексным, т. е. отдает контент одной страницы либо различных в зависимости от параметра в URL.
Такая структура отражает паттерн MVC. Всё привычно. View — шаблон template.php — собирает html для отображения клиенту и, возможно, добавляет JS, который дополнит динамические возможности страницы.
Входные параметры при этом мы задаем при вызове компонента. Эти параметры попадают в шаблон вместе с данными из базы, которые им соответствуют, а роутинг осуществляется на серверной стороне.
Работа с Vue.js реализует паттерн MVVM.
#### Работа компонента Битрикс при подходе MVVM
Посмотрим на схему работы приложения Vue.js.
Представление формируется на базе компонента по текущему роуту и данных, которые содержит состояние (store).
| |
| --- |
| В этом случае рассматриваем вариант хранения данных в едином внешнем для компонентов Vue-хранилище. Возможен упрощенный вариант передачи компонентам данных через параметры. |
Предлагаю обратить внимание на два момента.
1. Источник данных абстрагирован, т. е. это некий Backend, API, который отдает View-модели данные для отображения в компоненте по Endpoint’ам, определенным в методах actions.
2. Vue-приложение с несколькими логическими блоками, такими, как список/детальная, должно иметь внутренние правила роутинга для выбора подходящего компонента и комплектации представления нужными данными.
По нашему условию, приложение должно подключаться через один общий компонент, настраиваться через параметры в визуальном редакторе и содержать всё необходимое для работы в одном компоненте (возможно, комплексном).
С практической стороны это значит, что компонент Битрикс должен реализовать работу Vue-приложения с пробросом настроек компонента в настройки внутреннего роутинга SPA и обеспечить работу Endpoint’ов в части источника данных (Backend на схеме). Компонент должен «научиться» двум режимам работы:
1. При запросе к странице с Vue-приложением должен вернуть разметку SPA (single page application), код приложения, объект роутинга, объект хранилища и начальное состояние. Т. е. ведет себя как простой компонент с одним шаблоном.
2. При запросах данных в режиме Backend должен возвращать структуру для определения текущего состояния. Используем формат JSON. В таком варианте удобно использовать ЧПУ-режим комплексного компонента.
### Соберем всё вместе
Упрощая, можно сделать абстрактный пример работы нашего компонента для каталога с выводом страницы списка и детальных страниц товаров.
При синхронном обращении компонент вернет разметку с блоком привязки Vue-приложения:
* Скрипты фреймворка и плангины Vue, Vue-router, Vuex, Axios.
* Базовые JS-объекты данных GlobalVuexStoreCatalog(list), GlobalVuexStoreProductCard(detail).
* В составе SPA могут находиться сразу несколько шаблонов различных по назначению страниц, таких, как страница списка, детальная, страница результатов поиска и т. д. В таком случае требуется внутренний роутинг. JS-объект c правилами роутинга. Ремарка: в роутинге может не быть необходимости, если в составе SPA страница только по одному шаблону.
* Глобальный JS-объект данных для SPA.
```
if (typeof window.vueData !== "object") {
window.vueData = {};
}
window.vueData.url404 = '/404.php';
window.vueData.is404 = <?=$is404 ? 'true' : 'false'?>;
…
```
При асинхронном обращении компонент вернет данные из компонента Section либо Detail в виде JSON, который будет добавлен в ветке STATE Vuex-хранилища приложения.
Макеты верстки не содержатся в шаблонах компонентов Битрикс.
Шаблоны компонентов Vue, инициализация приложения целиком на стороне Frontend. Подключается в виде файлов сборки Webpack: catalog.js, catalog.css.
Разберем на примере для шаблона компонента каталога Axios. Для вывода SPA каталог должен иметь такую структуру:
Состав файлов `/js/vuex.catalog.list.js и /js/vuex.catalog.product.js` Vuex-структуры хранения и управления состоянием.
element.php и section.php — точки входа запроса. Они содержат вызовы компонентов реализации с буферизацией. В составе их обработки входит:
```
ob_start();
$ElementID = $APPLICATION->IncludeComponent(
"bitrix:catalog.element",
"shop.vue.element",
array(
"IBLOCK_TYPE" => $arParams["IBLOCK_TYPE"],
"IBLOCK_ID" => $arParams["IBLOCK_ID"],
...
),
$component,
array("HIDE_ICONS" => "Y")
);
$jsonElementData = ob_get_clean();
$is404 = (defined(ERROR_404) && ERROR_404 === 'Y') || \CHTTP::GetLastStatus() === '404 Not Found';
```
На выходе получаем объект JS, который можем добавить в component\_epilog.php — общая часть. В нем содержится контейнер для вывода Vue-приложения и определение общей части значений Store.
```
...
```
Также здесь подключаются файлы сборки Frontend.
`Asset::getInstance()->addCss(MARKUP_DIR . '/css/catalog.css', true);`
`Asset::getInstance()->addJs(MARKUP_DIR . '/js/catalog.js');`
В итоге выходит такая схема:
На стороне Frontend-сборки JS-объекты Store подключаются в качестве модулей Vuex:
```
import {useRouter} from "vue-router";
import {useStore} from "vuex";
export default {
setup() {
const router = useRouter();
const store = useStore();
/\* eslint-disable \*/
if (typeof GlobalVuexStoreCatalog !== 'undefined') {
store.registerModule('catalog', GlobalVuexStoreCatalog);
}
if (typeof GlobalVuexStoreProductCard !== 'undefined') {
store.registerModule('product', GlobalVuexStoreProductCard);
}
return {
router,
}
},
}
```
Настройки роутинга также подключаются из внешнего JS-объекта, который мы определили в компоненте Битрикс.
```
const routes = window.routerSettings.routes.map((it) => {
switch (it.type) {
case 'catalog':
return {
path: it.path, component: catalog
};
case 'product-card':
return {
path: it.path, component: product
};
}
});
const router = createRouter({
history: createWebHistory(window.routerSettings.BASE_URL),
routes,
scrollBehavior: () => {
return { left: 0, top: 0 };
}
})
...
app.use(VueWindowSizePlugin, {
delay: 300,
});
app.use(router);
app.mount('#catalog-vue')
```
Итоги
-----
Таким образом, мы даем возможность оставить всю реализацию компонентов отображения в отдельном репозитории и собирать их с помощью удобных для Frontend-разработчика инструментов.
Мы не переносим верстку в шаблоны компонентов Битрикс, что позволяет избежать этапа интеграции верстки и использовать протестированные макеты, точно совпадающие с требованиями. При проработке задачи требуется создать структуры хранения данных состояния «Store»-компонентов, общие для Backend и Frontend, для создания JSON-файла «заглушки» с приемочными данными для этапа сдачи макета верстки со стороны Frontend.
Реализация может показаться непростой, но в итоге приводит к понятной схеме разделения ответственности разработчиков и удобному внедрению компонентов с Vue-приложениями, в том числе и для использования в блоках конструктора лендингов «Сайты24».
Если вы дочитали до конца, то в этом точно есть что-то героическое, и думаю, вы заслуживаете плюс в карму. | https://habr.com/ru/post/584130/ | null | ru | null |
# Межпроцедурный анализ и оптимизации (I)
Одной из самых интересных и важных компонент современного оптимизирующего компилятора является межпроцедурный анализ и оптимизации. Хороший стиль программирования и необходимость разделения работы между разработчиками диктует необходимость разбиения большого проекта на отдельные модули, в которых основные утилиты реализованы как «черные ящики» для всех основных пользователей. Детали реализации, в лучшем случае, известны паре-тройке конкретных разработчиков, ну а иногда, за давностью лет, и вообще никому неизвестны. (А что поделаешь – специализация, глобализация). Ваш код, зачастую, содержит вызовы внешних функций, тела которых определены во внешних файлах или библиотеках и ваши знания о этих функциях минимальны. Ну и помимо этого при разработке больших проектов плодятся всякие глобальные переменные, с помощью которых компоненты большого проекта обмениваются ценной информацией, и для того, чтобы разобраться в работе вашей части кода в случае каких-то проблем, бывает необходимо перелопатить массу кода. Очевидно, что все это сильно осложняет и работу оптимизирующего компилятора. Какие негативные эффекты порождает модульность и есть ли в компиляторе специальные средства для их преодоления – тема для большого разговора. Сейчас я попытаюсь начать такой разговор. Я расскажу о некоторых интересных особенностях работы оптимизирующего компилятора на примере работы компилятора Intel. Ориентироваться буду на OS Windows, поэтому опции компилятора привожу характерные для этой платформы. Ну и чтобы облегчить себе жизнь, я иногда буду использовать аббревиатуры IPA для межпроцедурного анализа и IPO для межпроцедурных оптимизаций. А начну я с рассказа о моделях межпроцедурного анализа и графе вызовов.
#### Влияние модульности на производительность
Чтобы понять, в чем могут заключаться проблемы порождаемые модульностью, нужно посмотреть, какие существуют варианты работы компилятора, как компилятор пытается решать те или иные проблемы, какие есть ограничения на используемые компилятором методы анализа. Компилятор должен работать консервативно, т.е. с полным недоверием к программисту и программе и делать ту или иную оптимизацию только если полностью доказана ее корректность.
Самый простой вариант работы компилятора – это однопроходная компиляция. При таком варианте работы компилятор обрабатывает поочередно все функции из исходного файла плюс «держит в голове» все предшествующие декларации. Т.е. компилятор последовательно разбирает символы из исходного файла, заполняет таблицы с различными определениями функций, заводит описания определяемых типов и последовательно разбирает тела всех функций в обрабатываемом исходном файле. Сначала компилятор решает задачу проверки программы на соответствие требованиям стандарта языка, затем он может выполнять различные оптимизации – цикловые, скалярные, оптимизации графа потока управления и т.д. По окончании обработки результат сохраняется в объектный файл. При такой работе успешно (и как правило относительно быстро) решается задача – получить работающее приложение, но до оптимальной его работы очень далеко. Причиной этого является то, что компилятор имеет недостаточно информации о нелокальных для обрабатываемой функции объектах. Также компилятор имеет очень мало информации о вызываемых функциях. Влияет ли такое положение вещей на производительность приложения и какие существуют проблемы, связанные с использованием вызовов функций? За примерами далеко ходить не надо. Перечислю некоторые, наиболее, на мой взгляд, важные:
1. Проблемы с разрешением неоднозначности при работе с памятью. Например, в предыдущих моих постах я обсуждал проблему распознавания циклов и сопутствующую ей проблему разрешения неоднозначности при работе с памятью (alias analysis). Т.е. если в программе есть аргументы указатели и/или используются глобальные переменные, то существует возможность того, что идет работа с одной и той же памятью через несколько различных объектов. Такая неопределенность мешает компилятору распознавать циклы, создает предполагаемые зависимости, мешающие выполнению цикловых оптимизаций, затрудняет анализ потока данных и т.д. Компилятор, зачастую, пытается решить такие проблемы, создавая многоверсионный код, т.е. вставляет в код проверки времени выполнения. Но это «утяжеляет» код и хорошо только для простых случаев, когда предполагаемых зависимостей мало, а что делать если неразрешенных вопросов много?
2. При передаче в функцию теряются многие свойства актуальных аргументов, которые могли бы оказать влияние на качество оптимизации. Например, информация о расположении объектов в памяти влияет на выигрыш от векторизации. Если актуальный аргумент константа, то ее протяжка внутрь функции также может вызвать упрощение выполняемых расчетов. Ну и т.д.
3. Вызов функции с неизвестными свойствами затрудняет анализ потока данных. Появляется необходимость считать, что этот неизвестный вызов может изменить все данные до которых, согласно стандарту языка, он может дотянуться. (Например, глобальные указатели и переменные, объекты, доступ к которым передается функции через аргументы). Это мешает таким оптимизациям, как протяжка констант, удаление общих подвыражений и многим другим.
4. Циклы с вызовом неизвестных функций не могут быть корректно классифицированы (как циклы с определенным количеством итераций). Это происходит потому, что неизвестная функция может содержать выход из программы. В результате непременимы практически все цикловые оптимизации.
5. Вызов функции сам по себе достаточно затратен. Необходимо подготовить аргументы, выделить место на стеке для хранения локальных переменных, загрузить на выполнение инструкции с нового адреса. Велика вероятность, что данные адреса не будут находится в кэше. Если тело функции невелико, то может так случиться что затраты на ее вызов огромны по сравнению со временем ее работы.
6. При статической линковке программа будет содержать избыточный код – неиспользуемые функции из исходников и библиотек.
Наверное, этот список можно продолжать.
Возникает желание собрать различные свойства функций и затем использовать их при оптимизации и обработке каждой конкретной функции. Собственно, это и является основной идеей межпроцедурного анализа. Для проведения такого анализа необходимо учитывать взаимоотношения всех участвующих в расчетах функций друг с другом. Понятно, что для того, чтобы установить свойства некой функции, необходимо проанализировать все функции, которые она вызывает и т.д. Например, в некоторых языках есть «чистые» функции (pure function) и вы завели, используете и вычисляете подобный аттрибут для всех функций. Pure функция не изменяет своих аргументов и каких-либо глобальных переменных и не выводит никакой информации. Понятно, что этот аттрибут для функции можно установить только если все вызываемые внутри этой функции функции являются pure.
Для отражения этих взаимовлияний и взаимоотношений используется граф вызовов [(call graph).](http://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D1%84_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%BE%D0%B2) Его вершинами являются существующие функции, а гранями являются вызовы. Если функция foo вызывает bar, то соответствующие этим функциям вершины соединяются ребром. Поскольку вызовов может быть несколько, то и количество ребер может быть разным, то есть граф вызовов является мультиграфом.
IPA анализ работает со статическим графом, т.е. графом отражающим все возможные пути, которые могут быть пройдены при выполнении программы. Иногда при анализе производительности необходимо анализировать динамический граф вызовов, т.е. реальный путь, по которому управление передавалось при выполнении программы с каким-то конкретным набором данных.
Для того, чтобы построить граф вызовов, необходимо сначала пройти по всем функциям и определить, какие вызовы осуществляются в каждой функции. Затем проанализировать построенный граф и определить какими свойсвами обладает каждая функция. Осуществить различные межпроцедурные оптимизации и только после этого обрабатывать каждую отдельную функцию. При таком порядке работы необходимо как минимум два раза обрабатывать тело каждой функции — такой метод компиляции называется двухпроходным.
Можно нарисовать примерно такую схему для двухпроходной и однопроходной схемы компиляции.
В случае когда программист задает опцию для включения межпроцедурных оптимизаций, компилятор делает лексический и синтаксический анализ каждого файла с исходными текстами и, если файл соответствует стандарту языка, то компилятор создает внутреннее представление и упаковывает его в объектный файл. Когда все необходимые файлы с внутренним представлением созданы, компилятор повторно их все изучает, собирает информацию о каждой функции, находит все вызовы внутри функций и строит граф вызовов. Анализируя граф вызовов, компилятор «протягивает» по нему различные свойства функций, анализирует свойства различных объектов и т.п. После этого производятся межпроцедурные оптимизации, которые изменяют граф вызовов или свойства объектов. (Я надеюсь, что спустя какое-то время соберусь и расскажу о самых интересных на мой взгляд оптимизациях подробнее.) Многие оптимизации применимы только в случае, если компилятору удается доказать, что выполняется генерация исполняемого файла, и граф вызовов содержит все функции программы. Такие оптимизации называются оптимизациями всей программы (whole program optimization). Примерами таких оптимизаций является удаление из графа вызовов отдельных функций или частей графа вызовов, в которые нельзя попасть из main (dead code elimination). Другим известным примером является изменение структур данных. Большинство межпроцедурных оптимизаций могут выполняться как для полного, так и неполного графа вызовов. Самой известной межпроцедурной оптимизацией является подстановка тела функции [(inlining),](http://en.wikipedia.org/wiki/Inline_expansion) подставляющей тело функции вместо ее вызова.
После того, как все межпроцедурные оптимизации выполнены, все функции, входящие в итоговый граф вызовов поочередно обрабатываются оптимизирующей частью компилятора (backend). Различие с однопроходной компиляцией состоит в том, что о каждой вызываемой функции может быть известна какая-то дополнительная информация, например, изменяет ли функция тот или иной объект. Эта дополнительная информация и позволяет проводить оптимизации более эффективно.
На самом деле из моего описания видно, что термин двухпроходная оптимизация — это достаточно условный термин и на самом деле проходов по телу функции может быть больше.
Итак, если использовать компилятор для создания объектного файла, например с опцией –с, то в зависимости от наличия или отсутствия опции –Qipo будут создаваться разные сущности. С -Qipo объектный файл — это упакованное внутреннее представление, а не обычный объектный файл. Такие файлы не поймут линковщик link и утилита для созания библиотек lib. Для работы с такими объектными файлами нужно использовать их расширенные Intel аналоги xilink и xilib. Библиотека, созданная из объектных файлов с внутренним представлением будет содержать секции с внутренним представлением и это значит, что те утилиты, которые она содержит, смогут принять участие в межпрпоцедурном анализе в тот момент, когда такая библиотека будет прилинковываться к приложению.(Естественно только с использованием интеловского компилятора и опции -Qipo.) Отсюда следует, что для того, чтобы получить максимальную выгоду от использования компилятора Intel и межпроцедурного анализа, необходимо использовать библиотеки, созданные с помощью компилятора Intel с использованием –Qipo. Чтобы межпроцедурный анализ мог работать с системными функциями, в компиляторе есть информация об этих функциях.
Кстати говоря, если по какой-то причине вы смешаете мух и котлеты, т.е. обычные объектные файлы и файлы собранные с –Qipo и вызовете для их обработки интеловский компилятор (icl), то ничего страшного не произойдет. Компилятор заметит, что вы передаете ему внутреннее представление и включит межпроцедурный анализ/оптимизации автоматом. IPA и IPO будут выполняться для неполного графа вызовов (т.е. графа вызовов, в котором есть неизвестные функции), в который войдут все функции, для которых есть внутреннее представление. Компилятор создаст объектные файлы и затем вызовет линковщик, чтобы прилинковать к ним обычные объектные файлы. Но в общем случае, попавший в сборку программы с –Qipo «обычный» объектный файл может отключить целый пласт оптимизаций, оптимизации целой программы (whole program optimizations).
#### Граф вызовов
Понятно, что межпроцедурные оптимизации не даются даром. Работа с графом вызовов может быть достаточно сложной и ресурсоемкой и многое определяется размерами графа. Ради интереса я посмотрел на известный тест на производительность из сьюта для измерения производительности CPU2006 447.dealII (это c++ приложение) и вывел информацию о количестве вершин графа вызовов перед началом межпроцедурного анализа. Получилось, что перед межпроцедурным анализом существовало примерно 320 000 различных функций и примерно 380 000 различных дуг, их связывающих. Большие проекты могут испытывать проблемы с использованием двухпроходной компиляции и межпроцедурным анализом.
В компиляторе Intel реализованы две различные модели межпроцедурного анализа, а именно однофайловая и многофайловая модель. Однофайловая включается по умолчанию, если не задан режим многофайловой межпроцедурной оптимизации. В описании опций это выглядит как-то так:
```
/Qip[-] enable(DEFAULT)/disable single-file IP optimization within files
/Qipo[n] enable multi-file IP optimization between files
```
Ну и плюс еще есть две дополнительные опции, о которых я упомяну чуть позже.
```
/Qipo-c generate a multi-file object file (ipo_out.obj)
/Qipo-S generate a multi-file assembly file (ipo_out.asm)
```
Тут я позволю себе привести схему некоего абстрактного графа вызовов, характерного для C-шного проекта, чтобы ~~статья смотрелась красивее~~ работа компилятора с деревом вызовов для обоих методов выглядела более наглядно.
Формально можно сказать, что c –Qipo требуется больше ресурсов, а –Qip требует меньше ресурсов, но и обеспечивает худшее качество оптимизаций.
В реальности не все так однозначно, по крайней мере с ресурсами. Конечно, на самом деле графы вызовов для одного файла не являются подграфами графа вызовов для всего проекта. Например, графы для разных файлов могут содержать одни и те же функции, пришедшие из файлов описаний и являющиеся локальными для каждого файла. Особенно это актуально для больших C++ проектов. Такие функции могут быть продублированы в графах вызовов для некоторых файлов. На мой взгляд, условно можно считать, что эти функции являются неким аналогом weak функций. Поэтому, если просуммировать количество вершин для каждого отдельного графа при однофайловой модели оптимизации, то число вершин может получиться гораздо больше, чем число вершин в полном графе вызовов. При этом при однофайловой модели оптимизации все эти weak функции попадают в обработку и компилятор «возится» с каждой из них для того, чтобы затем линковщик оставил в исполняемом файле или библиотеке одну версию этой функции. Также количество работы при многофайловой обработке может быть уменьшено за счет удаления недостижимых из main подграфов и функций. Если функция была подставлена во все свои вызовы (и выполнены еще некоторые условия), то функция не будет обрабатываться оптимизирующей частью компилятора, т.е. итоговый исполняемый файл не будет содержать тела этой функции. Для однофайловой модели это верно только если функция имеет аттрибут static. Т.е при однофайловом IPA в обработку попадет какое-то количество «мертвых» функций.
Вообщем, может случиться, что в сумме компилятор выполнит гораздо больше работы с –Qip чем c –Qipo. При компиляции программы вместо одного большого графа вызовов придется обрабатывать много графов поменьше. В результате каждая однофайловая компиляция потребует гораздо меньше ресурсов, чем работа с полным графом вызовов, но количество истраченных ресурсов в сумме на компиляцию всех файлов может быть гораздо больше, чем при работе с полным графом вызовов.
Проиллюстрирую это уже упомянутым бенчмарком 447.dealII из CPU2006. Я уже написал, что в полном графе вызовов этого приложения приблизительно 320 000 вершин. В компиляции участвуют почти 120 файлов. Суммарное количество всех вершин в графах вызовов всех обрабатываемых файлов ~1500000 вершин (хотя в каждом файле вершин меньше 50000). Т.е. в 5 раз больше, чем количество всех вершин в полном графе вызовов. Я выключил все варианты параллельной компиляции и получил, что программа с –Qipo компилируется на моем Nehalemе приблизительно 160s, в то время как с –Qip время компиляции ~495s, т.е. в 3 раз больше. Если посчитать количество функций, которые обрабатываются в backendе с –Qipo, то получится ~19500 функций. Суммарное количество обработанных функций при компиляции проекта с –Qip равно ~55000. Ну и если посмотреть на размер выполняемого файла, то для этого приложения файл собранный с –Qipo почти на треть меньше файла собранного с –Qip.
Главным достоинством однофайловой оптимизации является то, что в этом случае при правке одного файла не нужно делать полного перестроения всего приложения, а перекомпилировать всего один файл и слинковать его с другими объектными файлами. Кроме того работу с –Qip легко распараллеливать, а вот создание приложения с –Qipo хуже поддается параллелизации. Хотя опция –Qipo может содержать числовой аргумент (например -Qipo2 подразумевает работу в двух потоках), но IPA выполняется на полном графе вызовов и пока еще не придуман хороший метод распараллеливания этого анализа, поэтому эта часть работы делается в один поток (или повторяется в каждом потоке) и кроме того каждый поток получает в нагрузку массу данных собранных IPA. Обработка всех функций в backendе может быть эффективно распределена между потоками, но из-за вышеперечисленных трудностей такая автоматическая параллелизация менее эффективна, чем в случае использования однофайловой модели.
Кстати говоря, хочется здесь упомянуть еще одну полезную опцию.
Если вы вдруг решили пойти простейшим путем и компилировать ваш проект с помощью одного вызова интеловского компилятора, передавая компилятору сразу все опции и список всех исходников, то по умолчанию компиляция будет осуществляться в один поток и нужно примнять специальную опцию для ускорения компиляции. Эта опция воздействует только на компиляцию без многофайлового IPA.
```
/MP[] create multiple processes that can be used to compile large numbers of source files at the same time
```
Если упомянутый 447.deallI компилировать с различными значениями в –Qipo, то время компиляции будет меняться так: -Qipo1: 160s, -Qipo2: 136s, -Qipo4: 150s. Т.е. очень скоро потоки начинают мешать друг другу.
Если в том же вызове icl заменить –Qipo на –Qip (или убрать вообще, -Qip будет работать по умолчанию) и добавить опцию /MP, то получится следующее: /MP1: 495s; /MP2: 259s; /MP4: 145s; /MP8: 117s; /MP16: 84s
Если говорить о производительности, то многофайловый IPA намного эффективнее. (Хотя всегда существует некоторая вероятность «горя от ума»). Легко придумать простой пример, который бы продемонстрировал преимущества многофайловой модели в плане возможности использовать различные оптимизации благодаря дополнительной информации от IPA.
test\_main1.c:
```
#include
#include
#define N 10000
extern float calculate(float \*a, float \*b);
int main() {
float \*a,\*b,res;
int i;
a = (float\*)malloc(N\*sizeof(float));
b = (float\*)malloc(N\*sizeof(float));
for(i=0;i
```
test1.c:
```
#include
#define N 10000
extern float calc(float a, float b);
float calculate(float \* restrict a,float \* restrict b) {
int i;
float res;
for(i=0;i
```
test2.c:
```
float calc(float a,float b) {
return(a+b);
}
```
```
icl -Feaaa.exe -Qparallel -Qpar_report3 test_main.c test1.c test2.c -Qstd=c99
icl -Feaaa.exe -Qipo -Qparallel -Qpar_report3 test_main.c test1.c test2.c -Qstd=c99
```
Здесь используется опция –Qparallel, которая включает автопараллелизатор интеловского компилятора и –Qpar\_report3 — опция, выдающая информацию о том, какие циклы были обработаны или отвергнуты автопараллелизатором и почему.
Вывод без –Qipo сообщает следующее:
```
...
test_main.c
procedure: main
..\test_main.c(14): (col. 1) remark: LOOP WAS AUTO-PARALLELIZED
test1.c
procedure: calculate
..\test1.c(11): (col. 1) remark: loop was not parallelized: existence of parallel dependence
test2.c
procedure: calc
```
Вывод с –Qipo:
```
test_main.c
test1.c
test2.c
procedure: main
C:\iusers\aanufrie\for_habrahabr\7a\test_main.c(13): (col. 1) remark: LOOP WAS AUTO-PARALLELIZED
C:\iusers\aanufrie\for_habrahabr\7a\test_main.c(17): (col. 8) remark: LOOP WAS AUTO-PARALLELIZED
```
Из вывода с –Qipo видно, что межпроцедурный анализ помог осуществить автопараллелизацию цикла.
Понятно, что в случае с –Qipo помогает еще и инлайнинг, но даже если инлайнинг запретить, то благодаря анализу функции calc у компилятора появляется возможность доказать правомерность автопараллелизации.
А что делать, если по какой-то причине многофайловая модель неприменима, например, для построения программы требуется много времени и это вас не устраивает? Можно повышать полезность работы однофайловой модели за счет размещения в файле совместно используемых функций. Очень полезен для функций атрибут static. Если функция имеет этот атрибут, значит IPA при однофайловой работе видит все вызовы этой функции и если у этих вызовов есть какие-то особенности, то они могут быть протянуты внутрь функции. Если все вызовы статической функции были подставлены, то само тело функции можно удалить. То же самое касается и статических объектов. Межпроцедурный анализ считает, что видит все примеры их использования и может выполнять с ними различные оптимизации. В общем, всякие ограничения области видимости объектов одним файлом могут помочь сделать более качественный однофайловый межпроцедурный анализ.
А что, если в рамках однофайловой нельзя решить какие-то проблемы, поскольку важная функциональность разнесена между несколькими файлами?
Опция –Qipo-c предоставляет возможность организовать некую промежуточную модель работы, т.е. строить граф вызовов не на основе функций из одного или всех файлов, а поделить все файлы на группы. Это удобно если ваш проект разбит на несколько тесно взаимосвязанных кусков. (Например, таким проектом является наш компилятор, в котором есть несколько компонент использующих общие утилиты и расположенные в отдельных директориях). –Qipo-c создает объектный файл с фиксированным именем ipo\_out.obj и в этот файл попадают все функции из перечисленных в вызове компилятора файлов. В приведенном выше примере приложение можно было бы скомпилировать следующим образом:
```
icl -Qipo-c -Qparallel -Qpar_report3 -Qstd=c99 test1.c test2.c
icl test_main.c ipo_out.obj
```
Вывод при компиляции двух первых файлов показывает, что в данном случае будет и работать и автопараллелизация и инлайнинг, поскольку критически важные функции были объединены в одном графе вызовов, что и дало возможность сделать межпроцедурный анализ и оптимизации.
Вот такой вопрос, а использовал ли кто-либо из читателей такую схему компиляции или хотя бы слышал о ней? Есть такое мнение, что проблема производительности интересует только процентов 5% разработчиков. Зачастую желание предоставить пользователю какие-то дополнительные рычаги для управления работой компилятора упирается в простой вопрос: «А кому вообще это надо и кто это будет использовать?»
Кстати говоря, можно добавлять и удалять какие-то файлы из обработки межпроцедурным анализом используя метод «мух и котлет»: создавая объектные файлы с –Qipo и без. В этом случае межпроцедурный анализ будет проводится на неполном дереве, полученных из функций, которые описаны в файлах скомпилированных с –Qipo. В описанном мной примере это тоже работает.
Ну и наконец опция –Qipo-S полезна для тех, что хочет модернизировать или поизучать ассемблер после межпроцедурных оптимизаций.
На этом я закончу рассказ о графах вызовов как основе IPO и IPA. Надеюсь продолжить рассказ об межпроцедурных оптимизациях и постараюсь ответить на все вопросы. | https://habr.com/ru/post/199112/ | null | ru | null |
# История двух стандартных библиотек Си
Сегодня мне пришел баг-репорт от пользователя Debian, который скормил какую-то ерунду в утилиту [scdoc](https://git.sr.ht/~sircmpwn/scdoc) и получил `SIGSEGV`. Исследование проблемы позволило мне провести отличное сравнение между `musl libc` и `glibc`. Для начала посмотрим на стектрейс:
```
==26267==ERROR: AddressSanitizer: SEGV on unknown address 0x7f9925764184
(pc 0x0000004c5d4d bp 0x000000000002 sp 0x7ffe7f8574d0 T0)
==26267==The signal is caused by a READ memory access.
0 0x4c5d4d in parse_text /scdoc/src/main.c:223:61
1 0x4c476c in parse_document /scdoc/src/main.c
2 0x4c3544 in main /scdoc/src/main.c:763:2
3 0x7f99252ab0b2 in __libc_start_main
/build/glibc-YYA7BZ/glibc-2.31/csu/../csu/libc-start.c:308:16
4 0x41b3fd in _start (/scdoc/scdoc+0x41b3fd)
```
В исходниках на данной строчке написано вот что:
```
if (!isalnum(last) || ((p->flags & FORMAT_UNDERLINE) && !isalnum(next))) {
```
Подсказка: `p` — это корректный, ненулевой указатель. Переменные `last` и `next` имеют тип `uint32_t`. Сегфолт случается на втором вызове функции `isalnum`. И, самое важное: воспроизводится только при использовании glibc, но не musl libc. Если вам пришлось перечитать код несколько раз, вы не одиноки: тут попросту нечему вызывать сегфолт.
Поскольку было известно, что все дело в библиотеке glibc, я достал ее исходники и стал искать реализацию `isalnum`, готовясь столкнуться с какой-нибудь дурацкой фигней. Но прежде чем я дойду до дурацкой фигни, которой там, уж поверьте, *навалом*, давайте сначала быстренько поглядим на хороший вариант. Вот так функция `isalnum` реализована в musl libc:
```
int isalnum(int c)
{
return isalpha(c) || isdigit(c);
}
int isalpha(int c)
{
return ((unsigned)c|32)-'a' < 26;
}
int isdigit(int c)
{
return (unsigned)c-'0' < 10;
}
```
Как и ожидалось, для любого значения `c` функция отработает без сегфолта, потому что с какого хрена вообще `isalnum` должна кидать сегфолт?
Ладно, теперь сравним это с [реализацией glibc](https://sourceware.org/git/?p=glibc.git;a=blob;f=ctype/ctype.h;h=351495aa4feaf23993fe65afc0760615268d044e;hb=HEAD). Как только вы откроете заголовок, вас будет встречать типичная GNU'шная галиматья, но пропустим ее и попытаемся найти `isalnum`.
Первый результат такой:
```
enum
{
_ISupper = _ISbit (0), /* UPPERCASE. */
_ISlower = _ISbit (1), /* lowercase. */
// ...
_ISalnum = _ISbit (11) /* Alphanumeric. */
};
```
Похоже на деталь реализации, двигаемся дальше.
```
__exctype (isalnum);
```
Но что такое `__exctype`? Возвращаемся на несколько строчек вверх…
```
#define __exctype(name) extern int name (int) __THROW
```
Ладно, по всей видимости это только прототип. Непонятно правда, зачем тут нужен макрос. Ищем дальше…
```
#if !defined __NO_CTYPE
# ifdef __isctype_f
__isctype_f (alnum)
// ...
```
Так, вот это уже похоже на что-то полезное. Что такое `__isctype_f`? Мотаем вверх…
```
#ifndef __cplusplus
# define __isctype(c, type) \
((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)
#elif defined __USE_EXTERN_INLINES
# define __isctype_f(type) \
__extern_inline int \
is##type (int __c) __THROW \
{ \
return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IS##type; \
}
#endif
```
Ну начинается… Ладно, вместе как-нибудь разберемся. Видимо, `__isctype_f` — это инлайн-функция… стоп, это все находится внутри блока else препроцессорной инструкции #ifndef \_\_cplusplus. Тупик. Где же `isalnum`, мать ее, *на самом деле* определена? Ищем дальше… Может вот оно?
```
#if !defined __NO_CTYPE
# ifdef __isctype_f
__isctype_f (alnum)
// ...
# elif defined __isctype
# define isalnum(c) __isctype((c), _ISalnum) // <- вот тут
```
Эй, это же «деталь реализации», которую мы видели раньше. Помните?
```
enum
{
_ISupper = _ISbit (0), /* UPPERCASE. */
_ISlower = _ISbit (1), /* lowercase. */
// ...
_ISalnum = _ISbit (11) /* Alphanumeric. */
};
```
Попробуем по-быстрому расковырять этот макрос:
```
# include
# if \_\_BYTE\_ORDER == \_\_BIG\_ENDIAN
# define \_ISbit(bit) (1 << (bit))
# else /\* \_\_BYTE\_ORDER == \_\_LITTLE\_ENDIAN \*/
# define \_ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
# endif
```
Ну что за фигня? Ладно, двигаем дальше и считаем, что это просто магическая константа. Другой макрос называется `__isctype`, который похож на недавно виденный нами `__isctype_f`. Посмотрим еще разок на ветку `#ifndef __cplusplus`:
```
#ifndef __cplusplus
# define __isctype(c, type) \
((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)
#elif defined __USE_EXTERN_INLINES
// ...
#endif
```
Эээ…
Ну, по крайней мере мы нашли разыменовывание указателя, которое могло бы объяснить сегфолт. А что такое `__ctype_b_loc`?
```
/* Эти объявления находятся в файле ctype-info.c.
Они должны совпадать с объявлениями в файле localeinfo.h.
В модели локалей, основывающейся на потоках, (см. `uselocale' в )
мы не можем пользоваться глобальными переменными, как раньше.
Вместо этого, ниже указаны функции-аксессоры, которые возвращают адрес
каждой переменной, относящейся к текущему потоку, если потоков несколько.
Они указывают на массивы из 384 элементов, поэтому для индексации можно
использовать значение `unsigned char' [0,255]; а также EOF (-1); или любое
значение `signed char' value [-128,-1). ISO C требует, чтобы функции ctype работали
со значениями типа `unsigned char' и EOF; мы также поддерживаем отрицательные
значения `signed char' для совместимости со старыми некорректными программами.
Массивы для конвертации регистра содержат значения типа `int`,
а не `unsigned char`, потому что `tolower(EOF)' должно возвращать EOF, а это значение
не помещается в диапазон `unsigned char`. Однако сейчас самое важное - то, что
эти массивы также используются для многобайтовых кодировок. \*/
extern const unsigned short int \*\*\_\_ctype\_b\_loc (void)
\_\_THROW \_\_attribute\_\_ ((\_\_const\_\_));
extern const \_\_int32\_t \*\*\_\_ctype\_tolower\_loc (void)
\_\_THROW \_\_attribute\_\_ ((\_\_const\_\_));
extern const \_\_int32\_t \*\*\_\_ctype\_toupper\_loc (void)
\_\_THROW \_\_attribute\_\_ ((\_\_const\_\_));
```
Как круто с твоей стороны, glibc! Я просто *обожаю* иметь дело с локалями. Так или иначе, к моему упавшему приложению подключен gdb, и держа в уме всю полученную информацию я пишу вот это убожество:
```
(gdb) print ((unsigned int **(*)(void))__ctype_b_loc)()[next]
Cannot access memory at address 0x11dfa68
```
Сегфолт найден. В комменте была про это строчка: «ISO C требует, чтобы функции ctype работали со значениями типа `unsigned char' и EOF». Если найти это в спецификации, увидим:
> Во всех реализациях [функций, объявленных в ctype.h], аргументом является int, значение которого должно помещаться в unsigned char, или же равняться значению макроса EOF.
>
>
Теперь становится очевидно, как исправить проблему. Мой косяк. Оказывается, я не могу скормить в `isalnum` произвольный символ UCS-32 для проверки на его вхождение в диапазоны 0x30-0x39, 0x41-0x5A и 0x61-0x7A.
Но тут я возьму на себя смелость предположить: а может быть, функция `isalnum` вообще не должна кидать сегфолт, вне зависимости от того, что ей передадут? Может быть, даже если спецификация это *разрешает*, это не означает, что так *надо делать*? Может быть, ну просто в качестве безумной идеи, поведение этой функции не должно содержать пять макросов, проверять использование компилятора C++, зависеть от порядка байтов вашей архитектуры, таблицы поиска, данных о локали потока и разыменовывать два указателя?
Еще разок посмотрим на версию в musl в качестве быстрого напоминания:
```
int isalnum(int c)
{
return isalpha(c) || isdigit(c);
}
int isalpha(int c)
{
return ((unsigned)c|32)-'a' < 26;
}
int isdigit(int c)
{
return (unsigned)c-'0' < 10;
}
```
Вот такие пироги.
*Примечание переводчика: спасибо MaxGraey за ссылку на оригинал.* | https://habr.com/ru/post/520920/ | null | ru | null |
# 30 вредных советов для php-разработчиков
Я не стал сильно заморачиваться и расписывать очевидные факты, но большинство моментов, которые меня пугают в коде, тут изложены. Я постарался сделать список особо лаконичным, чтобы вам не пришлось вчитываться, но и максимум понятным, чтобы даже новички поняли что так делать нельзя. В общем ниже список моих вредных советов, основанных на том, с чем я сталкиваюсь в повседневной жизни.
Итак поехали:
1. Обязательно пишите вёрстку прямо в php-скриптах и выводите её только через echo (зачем-то же нужна эта конструкция языка).
2. Старайтесь использовать как можно больше echo в ваших проектах, помните, что её придумали крутые разработчики языка, до которых вам далеко.
3. Прописывайте параметры подключения к БД в каждом файле где это нужно, и нигде не храните инфу о том где и какие конфигурации прописаны — пусть все остальные развиваются до вашего уровня.
4. Создавайте как можно больше подключений к БД в разных частях проекта, желательно чтобы многие из них вызывались одновременно, вообще создавайте новое подключение к БД при каждом запуске любой функции.
5. Не используйте стандартные функции языка — пишите свои, они будут работать в 100 раз лучше и именно так, как вам нужно.
6. Подключайте все файлы проекта в любом месте проекта даже если вам нужна всего одна функция.
7. Используйте массив GLOBALS — без него вообще никак, разработчики языка придумали его для вашего удобства, а вот проблемы с закончившейся озушкой это проблемы сервера, а не языка.
8. Вызывайте функции и используйте циклы прямо в верстке, это вывод информации, там без функций никак.
9. Ни в коем случае не используйте mysql-параметры, пишите переменные $\_GET, $\_POST, прямо в запрос, чтобы не тратить лишнее процессорное время, оно для нас очень важно.
10. Дублируйте один и тот же метод во всех классах каждый раз, когда он вам понадобится, забудьте про наследование это пережиток прошлого.
11. Используйте только статические методы и свойства, не нужно создавать объекты, классы придуманы не для этого.
12. Методы классов, работающих с БД должны возвращать РЕСУРС и никак по-другому, лучше используйте while каждый раз когда получаете данные от класса.
13. Обязательно делайте sql-запросы в циклах, это очень важно, иначе как вы получите все записи из таблицы?
14. Храните дату и время в полях типа varchar, потому-что поле datetime имеет какой-то свой странный формат.
15. Создайте себе поле в таблице, где для каждой записи будете дописывать через
все изменения с записью, и обязательно именно так. Ни в коем случае не создавайте отдельную таблицу логов, зачем нам лишний файл на диске.
16. Не создавайте много ячеек в таблицах БД, лучше используйте seialize и забудьте про кодировку при сохранении, если unserialize каждый раз выдает ошибку, просто игнорируйте её.
17. Вообще игнорируйте ВСЕ ошибки в проекте, выключите error\_reporting — он только мешает, не будьте задротами.
18. Никогда, слышите, никогда не проверяйте переменную на существование, просто выводите её прямо в шаблон, после пункта 17, Notice для вас уже не проблема.
19. Пишите только так `for($i=0; $i, потому-что считать количество элементов в массиве при каждой итерации это хорошо, а постинкремент работает намного быстрее, а кто говорит наоборот просто не знает о чем говорит. И перебирать большой массив нужно именно сначала, потому-что так быстрее.`
20. Не используйте парсинг ни в каком виде, это очень плохо, лучше скачивайте страницу целиком вместе с версткой и сохраняйте её в БД прямо как получили, не тратьте время на парсинг, тем более использование DomDocument очень замедляет проект, и его же еще учить нужно, а вам некогда — надо проект писать.
21. Храните всю информацию о пользователях в одной таблице — данные для авторизации, анкетные данные, домашние адреса и телефоны, места работы, да вообще любую информацию храните в одной таблице и не забывайте про serialize
22. Не используйте индексы и ключи в БД, и тем более связи между таблицами, это очень плохо.
23. Никогда не используйте таблицы-справочники, лучше дублируйте все в одной колонке, тем более если колонка содержит большие и часто повторяющиеся данные.
24. Вы слышали про стандарт именования функций и методов? Забудьте! Кто вообще придумал что в именах функций должна быть какая-то логика, да и функции с именами a(), b(), aa() намного короче вызывать.
25. Делайте функции как можно больше, если программисту лень читать что делает функция — он плохой программист.
26. Никогда и нигде не пишите комментарии, потому-что тру-прогерам они не нужны, в худшем случае можно написать коммент типа /\*это функция a(), она принимает две переменные $a и $b\*/ для совсем тупых.
27. Функции должны принимать как можно больше параметров, делать с ними кучу самых разных действий и возвращать всегда непредсказуемый результат, чтобы всё-таки заставить прогеров прочитать их исходники.
28. Так как мы уже решили не использовать наследование, повторно писать функции с других классов, то надо дополнить это еще и тем, что класс должен быть не меньше 1000 строк, и чем он больше, тем лучше.
29. Для того чтобы получить по-настоящему большой класс, нужно для каждой скобочки выделять целую строчку, нужно обязательно создать очень много свойств класса, на всякий случай, а еще мы помним что ни в коем случае нельзя использовать стандартные функции php — всегда пишем свои.
30. И последнее, допустим что вам нужен скрипт, у которого действия меняются в зависимости от даты (а вдруг), обязательно пишите эту дату прямо в скрипт, чтобы каждый раз заходить и исправлять её руками, чтобы всегда держать скрипт под контролем.
Спасибо за внимание!
**UPD**
Публикация внезапно набрала отрицательный рейтинг, хотя всё что в ней изложено взято с реального кода.
Отвечаю на комментарии:
От [lavkasnov](https://habrahabr.ru/users/lavkasnov/) и другие, кто затронул эту тему
> Именно так советует PSR
Конечно, но не в случаях с циклами и условиями. см. PSR-2 5.1-5.6
От [CentALT](https://habrahabr.ru/users/CentALT/)
> Уважаемые профессионалы подскажите как правильно делать верстку чтобы не получилось как в 1 и 2?
Создавать отдельные файлы шаблонов, которые кстати можно подключать внезапно не используя echo
А вообще есть куча способов выводить информацию в шаблон без echo
Я например для таких целей использую DOM.
Т.е. у меня есть чистый html-шаблон, в котором расставлены псевдо-переменные, а шаблонизатор цепляя шаблон и зная сколько значений имеет переменная просто парсит нужный элемент верстки столько раз сколько нужно, а дальше через saveHTML выводит результат. В результате мы имеем чистые шаблоны, в которых только верстка, чистые скрипты в которых нет верстки и всего 1 echo на весь проект состоящий из нескольких сотен страниц и счастливых кодеров и верстальщиков так как ни те ни другие не боятся что кто-то может уронить проект или накрыть верстку. Для подробностей советую посмотреть старый добрый xTemplate (хотя сейчас есть более мощные аналоги вообще с полным разделением кода)
От [G-M-A-X](https://habrahabr.ru/users/G-M-A-X/)
> На проде выключил E\_NOTICE
>
> display\_errors само собой
Конечно, а потом благополучно можно засовывать несуществующие переменные прямо в шаблон и не морочить себе голову лишней информацией типа Notice, зачем вообще придумывали проверки на существование и проверки на пустоту, они же только усложняют код. | https://habr.com/ru/post/309450/ | null | ru | null |
# Arduino контролирует в подвале температуру, влажность и затопление и выдает данные на веб-страницу
Всем привет.
Хочу поделиться опытом создания системы контроля и предупреждения.
На одном из строительных объектов делали строение с бассейном, сауной, тренажёрным залом и комнатой отдыха. Все это было в приличных размерах как для одного хозяина. Чисто технически понадобилось 2 подвала: 1-й для обслуживания насосов бассейна — маленький, 2-й для обслуживания систем обогрева и накопления тепла
Закуплены были 2 напольных евро-люка разных размеров для двух подвалов. Люки зарывались 4-мя винтами и имели очень плотные резиновые уплотнения. Чтобы открыть подвал, необходимо было 4 человека (и немного здоровья). При работе всей техники в подвале поднималась температура и влажность, при этом контролировать что там происходит практически неудобно.
В итоге было принято решение о создании устройства, которое бы показывало, а также управляло вентилятором, звуковым сигнализатором, электро-клапаном (воды), и контролировать его можно было с любого смарт устройства.
За основу взял Arduino Pro Mini плюс Ethernet ENC28J60. Для замера влажности и температуры датчик DHT11 и FC-28 (датчик влажности почвы – в роли датчика затопления).
Тех задание:
1) Управление и информирование через Web интерфейс;
2) Включение и отключение вентиляции по заданному уровню влажности;
3) Включение и отключение клапана водопровода (возможно, ревун, откачивающий насос) при затоплении.
В выборе Arduino Pro Mini тоже надо подумать, так как существуют разные исполнения:
Лучше брать ту, в которой стабилизатор по мощнее, так как та, что по слабее, при активных реле и сетевом контроллера закипит стабилизатор, что приводит к зависанию системы (я упустил этот нюанс и получил зависания, но приобрел более ценное – опыт).
Сетевые контроллеры также надо выбирать внимательно, так как есть те которые от 5В (стабилизатор на обратной стороне модуля) и на 3,3В. Нужен будет дополнительный стабилизатор на 3,3В.
Блок питания взял от обычного свитча (или роутера) TP-Link 9В 500мА (примерно), они часто встречаются за копейки от паленых свитчей или роутеров.
Принцип работы простой: есть 2 датчика, которые сливают информацию на контроллер. В зависимости от ситуации контроллер включает и выключает реле (клапана водопровода, возможно ревун, откачивающий насос, вентилятор). Управление и мониторинг через WEB интерфейс который реализован программой на базе модуля ENC28J60.
1) Сработка датчика затопления = включение реле (клапана водопровода(ревун, откачивающий насос ); + информирование на web странице крупным шрифтом;
2) Повышение влажности выше установленного уровня = включение реле вентилятора;
3) Вся информация о температуре влажности и затоплению выводится на web страницу;
4) При понижении температуры ниже 5 градусов оповещение на web сайте о угрозе.
Наглядно можно увидеть на видео:
На практике все очень удобно. Всегда можно посмотреть с Телевизора (Smart), телефона или планшета — что творится в закрытых помещениях, не открывая их.
Люблю создавать устройства, которые облегчают жизнь, а не просто создать игрушку поиграться и выбросить.
С дизайном странички сильно не напрягался, так как носит технический характер и должна быть практичной, а не сложной и красивой.
Надеюсь, эта статья кому-то поможет, а кого то вдохновит на создание своего проекта.
**Программа для Arduino**
```
#include "etherShield.h"
#include "ETHER_28J60.h"
#include
#include "DHT.h"
#define DHTPIN 2 // к какому пину будет подключен вывод Data
//выбор используемого датчика
#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
//инициализация датчика
DHT dht(DHTPIN, DHTTYPE);
int VlagInPin = 3;
int RelPin = 4;
int PotPin = 5;
byte vlaga = 75;
int temp = 55;
int vent =85;
int pot; // переменная датчика затопления
byte vf; // переменная для значения влаги во флеше
static uint8\_t mac[6] = {0x54,0x55,0x58,0x10,0x00,0x24};
static uint8\_t ip[4] = {192,168,88,24};
static uint16\_t port = 80;
ETHER\_28J60 ethernet;
void setup()
{
dht.begin(); //
pinMode(VlagInPin, INPUT);
pinMode(RelPin, OUTPUT);
digitalWrite(RelPin, HIGH);
pinMode(PotPin, OUTPUT);
digitalWrite(PotPin, HIGH);
vf = EEPROM.read(0); //чтение из флеш значение влаги для сработки вентилятора
if ( vf > 110)
{
EEPROM.write(0, 110); // Запись нового значения в Флеш
}
ethernet.setup(mac, ip, port);
}
void loop()
{
// чтение температуры и влажности займет примерно 250 миллисекунд
//float h = dht.readHumidity();
//float t = dht.readTemperature();
vlaga = dht.readHumidity();
temp = dht.readTemperature();
pot = digitalRead(VlagInPin);
if (pot == LOW) { // Условие включения и отключения затопления
digitalWrite(PotPin, LOW);
}
if (pot == HIGH) { // Условие включения и отключения затопления
digitalWrite(PotPin, HIGH);
}
if (vlaga >= vf) { // Условие включения и отключения вентиляции
digitalWrite(RelPin, LOW);
}
if (vlaga < vf-1) { // Условие включения и отключения вентиляции
digitalWrite(RelPin, HIGH);
}
String param;
if (param = ethernet.serviceRequest())
{
ethernet.print("БОЛЬШОЙ ПОДВАЛ
==============
");
ethernet.print("[ОБНОВИТЬ СОСТОЯНИЕ](\"/\")
");
if (pot == LOW) { // Условие включения и отключения затопления
ethernet.print("Внимание Затопление!!!
======================
");
}
if (temp <= 3) { // Условие вывода сообщения Угроза разморозки системы
ethernet.print("Угроза разморозки системы
=========================
");
}
if (param == "plus")
{
vf++; // Увеличить значение переменной влаги
if ( vf > 110)
{
vf=110;
}
EEPROM.write(0, vf); // Запись нового значения в Флеш
}
if (param == "minus")
{
vf--; // Уменьшить значение переменной влаги
if ( vf < 5)
{
vf=5;
}
EEPROM.write(0, vf); // Запись нового значения в Флеш
}
ethernet.print("Температура
===========
");
ethernet.print("");
ethernet.print(temp);
ethernet.print("
--------------------------------------------
");
ethernet.print("Влага
=====
");
ethernet.print("");
ethernet.print(vlaga);
ethernet.print("
---------------------------------------------
");
ethernet.print("Сработка Вентиляции
===================
");
ethernet.print("");
ethernet.print(vf);
ethernet.print("
------------------------------------------
");
ethernet.print("[Уменьшить](\"/minus\") [Увеличить](\"/plus\")
");
ethernet.respond();
}
}
``` | https://habr.com/ru/post/249201/ | null | ru | null |
# Как я мониторил РИП-12 от Bolid
Резервированные источники питания используются повсеместно. Они обеспечивают бесперебойным электропитанием приборы охранной и пожарной сигнализации, оборудование систем контроля доступа и другие системы. На нашем предприятии в качестве таких источников, как правило, используются приборы от ЗАО НВП Болид. У некоторых из них, как, например, у РИП-12-6/80M3-R-RS, имеется интерфейс RS485, что позволяет включать их в систему мониторинга.
Средства мониторинга
--------------------
Мы используем Zabbix 5.2. Получать данные от РИП будем по протоколу Modbus RTU over TCP. Поддержка этого протокола реализована в Zabbix с помощью загружаемого модуля [libzbxmodbus](https://share.zabbix.com/scada-iot-energy-home-automation-industrial-monitoring/modbus-loadable-module). Также в процессе мониторинга принимают участие преобразователь протокола C2000-ПП (вер. 1,32) в режиме «Master» и преобразователь последовательных интерфейсов (RS485 в Ethernet).
Объекты мониторинга
-------------------
Для начала определимся, что конкретно мы сможем контролировать. Из документации к РИП-12-6/80M3-R-RS и С2000-ПП выяснилось, что рассчитывать мы можем на получение состояния семи зон (ШС) и числовых значений тока и напряжения. В ходе экспериментов мне удалось воспроизвести следующие состояния ШС:
**ШС №0** Состояние прибора
| | | |
| --- | --- | --- |
| 149 | Взлом корпуса прибора | Корпус РИП открыт |
| 152 | Восстановление корпуса прибора | Корпус РИП закрыт |
| 250 | Потеряна связь с прибором | Потеряна связь с прибором |
**ШС №1** Выходное напряжение
| | | |
| --- | --- | --- |
| 193 | Подключение выходного напряжения | РИП подключил выходное напряжение при появлении напряжения в сети |
| 192 | Отключение выходного напряжения | РИП отключил выходное напряжение при отсутствии напряжения в сети и разряде батареи |
| 199 | Восстановление питания | Напряжение питания прибора пришло в норму |
| 250 | Потеряна связь с прибором | Потеряна связь с прибором |
**ШС №2** Ток нагрузки
| | | |
| --- | --- | --- |
| 194 | Перегрузка источника питания | Выходной ток РИП более 7,5 А |
| 195 | Перегрузка источника питания устранена | Выходной ток РИП менее 7,5 А |
| 250 | Потеряна связь с прибором | Потеряна связь с прибором |
**ШС №3 и ШС №4** Напряжение на батарее №1 и №2 соответственно
| | | |
| --- | --- | --- |
| 200 | Восстановление батареи | Напряжение батареи выше 10 В, заряд батареи возможен |
| 202 | Неисправность батареи | Напряжение на батарее ниже 7 В или не подключена |
| 211 | Батарея разряжена | Напряжение на батарее ниже 11 В при отсутствии сетевого напряжения |
| 250 | Потеряна связь с прибором | Потеряна связь с прибором |
**ШС №5** Степень заряда батарей
| | | |
| --- | --- | --- |
| 196 | Неисправность зарядного устройства | ЗУ не обеспечивает напряжение и ток для заряда батареи в заданных пределах |
| 197 | Восстановление зарядного устройства | ЗУ обеспечивает напряжение и ток для заряда батареи в заданных пределах |
| 250 | Потеряна связь с прибором | Потеряна связь с прибором |
**ШС №6** Напряжение сети
| | | |
| --- | --- | --- |
| 1 | Восстановление сети 220 | Сетевое напряжение питания в пределах 150…250 В |
| 2 | Авария сети 220 В | Сетевое напряжение питания < 150 В или > 250 В |
| 250 | Потеряна связь с прибором | Потеряна связь с прибором |
Крайне вероятно, что мной была получена только часть из всех возможных состояний. Например, имеются догадки, что ШС №3 и №4 должны также иметь состояние *[204] Необходимо обслуживание*, а ШС №0 - состояние *[203] Сброс прибора* и другие. К сожалению, чтение документации ситуацию не прояснило. В связи с этим нам необходимо следить и реагировать на появление событий, которые мы не предусмотрели.
Конфигурирование устройств
--------------------------
Не будем долго останавливаться на процессе конфигурирования приборов, только коротко рассмотрим перечень необходимых действий. Настройка устройств Болид осуществляется при помощи утилиты UProg и имеет следующий порядок:
1. Назначение сетевых адресов всем устройствам (РИП и С2000-ПП),
2. Конфигурирование интерфейса интеграции С2000-ПП (Modbus RTU),
3. Добавление ШС, описанных выше, в таблицу зон С2000-ПП. Крайне важно, чтобы, во-первых, были добавлены все ШС, а во-вторых, ШС должны следовать друг за другом в порядке возрастания.
UProg. Конфигурация С2000-ПППри заполнении таблицы зон следует помнить следующее:
* адрес прибора - сетевой адрес РИП, в нашем случае 126,
* номер ШС - номер ШС от 0 до 6,
* тип зоны - тип ШС, для ШС №0 назначаем тип зоны "3 - состояние прибора", для всех остальных - "8-РИП напряжение / ток".
Создаем шаблоны Zabbix
----------------------
Напомню, что Zabbix с модулем [libzbxmodbus](https://share.zabbix.com/scada-iot-energy-home-automation-industrial-monitoring/modbus-loadable-module) выступает в роли Modbus-мастера. Из-за особенностей получения данных от C2000-ПП, о которых речь пойдет в процессе создания шаблонов, мы будем рассматривать два подхода к мониторингу.
* мониторинг состояния ШС.
* мониторинг как состояния, так и числовых параметров РИП.
### Мониторинг состояния ШС
Итак, создадим шаблон **RIP 12 mod 56 RIP 12 6 80 M3 R RS**. Шаблон имеет один элемент данных с именем *Request* и типом "Простая проверка". Ключом элемента является функция: modbus\_read[{$MODBUS\_PORT},{$MODBUS\_SLAVE},{$STATUS\_REG},3,7\*uint16] . В параметрах функции используются значения макросов, которые позволяют составить корректный modbus запрос к C2000-ПП.
* {MODBUS\_PORT} - тип используемого протокола (enc - Modbus RTU over TCP), адрес и порт преобразователя последовательных интерфейсов.
* {MODBUS\_SLAVE} - Modbus UID С2000-ПП (настраивается в UProg на вкладке прибор).
* {STATUS\_REG} - адрес регистра в котором расположен ШС №0 интересующего нас РИПа. Получить данный адрес можно следующим образом: "Номер зоны в таблице зон С2000-ПП" + 40000 - 1. В нашем примере это: 450+40000-1 = 40449.
Основная задача элемента *Request* - запросить у С2000-ПП значение всех семи ШС контролируемого РИП и предоставить их в формате JSON. Результирующий JSON содержит объекты, ключами которых являются адресы регистров С2000-ПП, а значениями - содержимое этих регистров:
```
{
"40449":39115,
"40450":51195,
"40451":50171,
"40452":51963,
"40453":51451,
"40454":50683,
"40455":763
}
```
#### Зависимые элементы данных
Элемент данных *Request* имеет 7 зависимых элементов. Основная задача этих элементов - распарсить JSON и получить состояние каждого ШС индивидуально. Вот эти элементы:
* Status - состояние прибора (ШС №0),
* Uout - выходное напряжение (ШС №1),
* Iout - ток нагрузки (ШС №2),
* Ubat1 - напряжение АКБ1 (ШС №3),
* Ubat2 - напряжение АКБ2 (ШС №4),
* Capacity - степень заряда АКБ (ШС №5),
* Uin - напряжение сети (ШС №6).
#### Предобработка зависимых элементов данных
Чтобы получить состояние ШС №0 (Status), нам достаточно два шага предобработки. На первом шаге мы воспользуемся стандартным функционалом JSONPath, а затем разделим полученное значение на 256, тем самым получим код состояния.
К сожалению, мне не удалось использовать математические операции в параметрах JSONPath. Поэтому для оставшихся элементов данных пришлось использовать javascritpt-предобработку. Например, для элемента данных Iout (ШС №2) javascript-предобработка выглядит так:
```
function (value){
var reg = parseInt({$STATUS_REG})+2;
var data = JSON.parse(value);
return data[reg];
}
```
#### Триггеры
После добавления триггеров создание шаблона можно считать завершенным. Перечень созданных триггеров:
1. Взлом корпуса прибора,
2. Перегрузка источника питания,
3. Отключение выходного напряжения,
4. Неисправность батареи АКБ1,
5. Неисправность батареи АКБ2,
6. АКБ1 разряжен,
7. АКБ2 разряжен,
8. Авария сети 220 В,
9. Потеряна связь с прибором,
10. Неизвестное состояние Status,
11. Неизвестное состояние Iout,
12. Неизвестное состояние Uout,
13. Неизвестное состояние АКБ1,
14. Неизвестное состояние АКБ2,
15. Неизвестное состояние Capacity,
16. Неизвестное состояние Uin,
17. Превышено время отсутствия по MODBUS.
#### Демонстрация и импорт RIP 12 mod 56 RIP 12 6 80 M3 R RS
Шаблон RIP 12 mod 56 RIP 12 6 80 M3 R RS в картинкахПример создания узла сетиСсылки для импорта: [Шаблон RIP 12 mod 56 RIP 12 6 80 M3 R RS](https://raw.githubusercontent.com/ensoelectric/bolid_zbx_templates/main/templates/zbx_export_templates_RIP_12_mod_56_RIP_12_6_80_M3_R_RS.yaml), [Преобразование значений RIP 12 mod 56 RIP 12 6 80 M3 R RS](https://raw.githubusercontent.com/ensoelectric/bolid_zbx_templates/main/valuemaps/zbx_export_valuemaps_RIP_12_mod_56_RIP_12_6_80_M3_R_RS.yaml).
### Мониторинг состояния и числовых параметров
Мониторинг числовых параметров имеет свои особенности. Все дело в том, что для получения числового значения нам необходимо сделать **два** modbus-запроса к С2000-ПП. Первый запрос устанавливает зону для запроса тока или напряжения, второй - непосредственное получение значения. В таком случае мы не имеем возможности использовать функционал libzbxmodbus, т.к. попросту не cможем гарантировать правильную очередность запросов.
Первое и самое простое, что приходит на ум, - это создать скрипт, который сделает получение числового параметра атомарной операцией и воспользоваться возможностями внешних проверок Zabbix. Но такой скрипт тоже не позволит использовать загружаемый модуль libzbxmodbus по причине невозможности организации монопольного доступа к разделяемому ресурсу, в нашем случае к преобразователю последовательных интерфейсов.
В связи с вышесказанным, для этих целей было решено отказаться от использования libzbxmodbus и написать скрипт, который сможет предоставлять и числовые параметры РИП и состояния его ШС.
#### Пишем shell скрипт для внешней проверки
Для того, чтобы синхронизировать доступ к преобразователю последовательных интерфейсов, воспользуемся утилитой [flock](https://www.opennet.ru/man.shtml?topic=flock&category=1&russian=2). Работу с Modbus будем осуществлять при помощи [modpoll](https://www.modbusdriver.com/modpoll.html). В /usr/lib/zabbix/externalscripts создадим скрипт rip\_12\_mod\_56.sh
```
#!/bin/bash
# rip_12_mod_56.sh
# $1 - protocol://host:port
# $2 - Modbus UID
# $3 - Status register
# $4 - Offset (0 - 6)
# Example of requesting statuses: ./rip_12_mod_56.sh enc://127.0.0.1:4001 1 40000
# Example value request: ./rip_12_mod_56.sh enc://127.0.0.1:4001 1 40000 3
(($# < 3)) && { printf '%s\n' "You have given little data. Command exited with non-zero"; exit 1; }
lockfile=$(echo "$1" | awk -F "://" '{print $2}')
setzone()
{
modpoll -m $1 -a $4 -r 46181 -0 -1 -c 1 -p $3 $2 $5> /dev/null 2>&1
(($? != 0)) && { printf '%s\n' "Command exited with non-zero"; exit 1; }
sleep 0.15
}
getvalue ()
{
value=$(modpoll -m $1 -a $4 -r 46328 -0 -1 -c 1 -t 4:hex -p $3 $2 |grep ]: |awk '{print $2}')
printf "%d" $value
}
getstatus ()
{
status=$(modpoll -m $1 -a $4 -r $5 -1 -c 7 -t 4:hex -p $3 $2 | grep ]: | awk -F "0x" 'BEGIN { printf"["} NR!=7{printf "\""$2"\","} NR==7 {printf "\""$2"\""} END { printf "]"}')
echo "{ \"status\": $status }"
}
(
flock -e 200
protocol=$(echo $1 | awk -F "://" '{print $1}');
host=$(echo $1 | awk -F "://" '{print $2}' | awk -F ":" '{print $1}')
port=$(echo $1 | awk -F "://" '{print $2}' | awk -F ":" '{print $2}')
register=$(($3+1))
if (($# >= 4)); then
zone=$(($register+$4-40000))
setzone $protocol $host $port $2 $zone
echo $(getvalue $protocol $host $port $2)
sleep 0.15
exit 0
fi
echo $(getstatus $protocol $host $port $2 $register)
sleep 0.15;
) 200> /tmp/$lockfile
```
Подробности настройки внешних проверок в Zabbix уточняйте в [документации](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/external?s%5B%5D=%D0%B2%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B5&s%5B%5D=%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B8).
#### Создаем RIP 12 mod 56 RIP 12 6 80 M3 R RS EXTENDED
Для получения информации о состоянии ШС шаблон содержит элемент данных *Request* с типом "Внешняя проверка". Ключом элемента является скрипт: rip\_12\_mod\_56.sh[{$MODBUS\_PORT}, {$MODBUS\_SLAVE}, {$STATUS\_REG}]. Как и в шаблоне *RIP 12 mod 56 RIP 12 6 80 M3 R RS*, задача элемента *Request* - сформировать JSON с состояниями всех ШС.
Возвращаемый JSON оптимизирован для использования функционала JSONPath. Для упрощения скрипта значения возвращаются в шестнадцатеричной форме:
```
{
"status": ["98CB","C7FB","C3FB","CAFB","C8FB","C5FB","02FB"]
}
```
#### Состояния ШС. Снова зависимые элементы данных.
Как и в предыдущем шаблоне, элемент данных *Request* имеет 7 зависимых элементов. Задача этих элементов тоже неизменна - распарсить JSON и получить состояние каждого ШС.
#### Получаем числовые значения
Для получения числовых значений создадим 5 элементов данных с типом "Внешняя проверка".
* Uout\_value - значение выходного напряжения, В.
* Iout\_value - значение выходного тока, А.
* Ubat1\_value - значение напряжения на батарее №1, В.
* Ubat2\_value - значение напряжения на батарее №2, В.
* Uin\_value -значение напряжения сети, В.
Ключом этих элементов является скрипт: rip\_12\_mod\_56.sh[{$MODBUS\_PORT}, {$MODBUS\_SLAVE}, {$STATUS\_REG}, **<НОМЕР ШС>**].
#### Триггеры
Перечень триггеров не отличается от триггеров, созданных в шаблоне RIP 12 mod 56 RIP 12 6 80 M3 R RS.
#### Демонстрация и импорт RIP 12 mod 56 RIP 12 6 80 M3 R RS EXTENDED
Шаблон RIP 12 mod 56 RIP 12 6 80 M3 R RS EXTENDED в картинкахПоследние значения RIP 12 mod 56 RIP 12 6 80 M3 R RS EXTENDEDСсылки для импорта: [Шаблон RIP 12 mod 56 RIP 12 6 80 M3 R RS EXTENDED](https://raw.githubusercontent.com/ensoelectric/bolid_zbx_templates/main/templates/zbx_export_templates_RIP_12_mod_56_RIP_12_6_80_M3_R_RS_EXTENDED.yaml), [rip\_12\_mod\_56.sh](https://raw.githubusercontent.com/ensoelectric/bolid_zbx_templates/main/externalscripts/rip_12_mod_56.sh).
Вместо заключения
-----------------
В своем мониторинге мы используем шаблон *RIP 12 mod 56 RIP 12 6 80 M3 R RS*. По-большому счету причина такого решения одна - расширяемость системы. Использование загружаемого модуля позволяет включать в одну линию приборы разных типов и модификаций, организовать их мониторинг стандартными средствами. Кроме этого, большой потребности в получении числовых значений у нас пока не возникало.
Однако, несмотря на все вышесказанное, возможность получения числовых значений тоже может оказаться востребованной. В этом случае можно задуматься об использовании в триггерах [функций прогнозирования](https://www.zabbix.com/documentation/current/ru/manual/config/triggers/prediction).
Спасибо за внимание! | https://habr.com/ru/post/554780/ | null | ru | null |
# Библиотека, помогающая преодолеть концептуальный разрыв между ООП и БД во время тестирования при использовании ORM, — LinqTestable
Как известно, между объектно-ориентированной и реляционной моделью существует [концептуальный разрыв](https://en.wikipedia.org/wiki/Object-relational_impedance_mismatch), преодолеть который не в состоянии даже ORM. В основном этот разрыв влияет на то, что при использовании реляционной базы данных мы вынуждены работать над множествами, а не над конкретными объектами. Но есть и другой фактор: поведение NULL в бд отличается от поведения NULL в объектно-ориентированных языках. Это может стать проблемой, когда вы используете один и тот же запрос в двух ситуациях: 1) при запросе к бд 2) при юнит-тестировании, когда вместо таблицы из бд используется массив в оперативной памяти. Более того, это может стать проблемой, если вы обращаетесь только к бд, но мыслите о NULL в терминах ООП, а не реляционной бд!
##### Пример 1
Есть три таблицы, связанные по внешнему ключу: машина, дверь, дверная ручка. Все внешние ключи not nullable, т.е. у каждой двери и у ручки должно быть указано, на чём именно они крепятся (конкретная машина или дверь).
**Исходный код создания таблиц**(В качестве бд использовался Oracle, ORM – EntityFramework, язык – C#.)
```
create table CAR
(
CAR_ID NUMBER(10) not null
);
alter table CAR
add constraint CAR_PK primary key (CAR_ID);
create table DOOR
(
DOOR_ID NUMBER(10) not null,
CAR_ID NUMBER(10) not null
);
alter table DOOR
add constraint DOOR_PK primary key (DOOR_ID);
alter table DOOR
add constraint DOOR_CAR_FK foreign key (CAR_ID)
references CAR (CAR_ID);
create index DOOR_CAR_ID_I on DOOR (CAR_ID)
tablespace INDX_S;
create table DOOR_HANDLE
(
DOOR_HANDLE_ID NUMBER(10) not null,
DOOR_ID NUMBER(10) not null,
COLOR NVARCHAR2(15) null
);
alter table DOOR_HANDLE
add constraint DOOR_HANDLE_PK primary key (DOOR_HANDLE_ID);
alter table DOOR_HANDLE
add constraint DOOR_HANDLE_DOOR_FK foreign key (DOOR_ID)
references DOOR (DOOR_ID);
create index DOOR_HANDLE_DOOR_ID_I on DOOR_HANDLE (DOOR_ID)
tablespace INDX_S;
```
Создадим в бд одну машину, остальные таблицы остаются пустыми. Затем просто сделаем left join между машиной и дверями, используя ORM:
```
var cars =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty() //left join
select new { car.CAR_ID, door.DOOR_ID }).ToList();
```
Как вы думаете, что вернёт этот запрос?
Правильно, ORM кинет в вас исключением и пошлёт лесом. Почему? Бд вернёт строку
CAR\_ID=1, DOOR\_ID=NULL, а ORM не сможет её обработать, потому что и в бд, и в маппинге указано, что door.DOOR\_ID не может быть NULL. NULL же появился исключительно из-за left join. Может быть, виновата “кривая” ORM? Нет, поведение ORM вполне корректно: заменить null на 0 или вернуть пустую строку означает обмануть пользователя. Изменение маппинга тоже не выход: в коде будет сказано, что поле можно не заполнять, а бизнес-логика будет требовать обратного. Решением является изменение запроса, чтобы ORM смогла понять, что поле может иметь значение null:
```
var cars =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
select new { car.CAR_ID, DOOR_ID = door != null ? door.DOOR_ID : (int?) null }).ToList();
```
Изменить запрос вы можете вручную, или же можно написать код, который будет изменять все такие запросы автоматически в рантайме (но об этом чуть позже).
##### Пример 2
Есть запрос с двумя left join-ами.
```
var carsWithoutRedHandle =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on door.DOOR_ID equals doorHandle.DOOR_ID
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorHandle.Color != “RED” || doorHandle == null
select car).ToList();
```
Этот запрос будет прекрасно обрабатываться, когда вы обращаетесь к бд. Но стоит использовать его в юнит-тесте, и вы получите NullReferenceException при попытке доступа к door.DOOR\_ID во втором джойне, если какая-либо из машин не нуждается в дверях по причине открытого верха. Что ж, время изменять запрос:
```
var carsWithoutRedHandle =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on (door != null ? door.DOOR_ID : (int?)null) equals doorHandle.DOOR_ID
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorHandle.Color != “RED” || doorHandle == null
select car).ToList();
```
Однако тут есть одно «но». Изменяя linq-запрос, вы можете на выходе получить sql-запрос с гораздо более медленным планом исполнения. Давайте посмотрим такой случай на примере.
```
using System.Linq;
using System.Linq.Expressions;
using LinqKit;
IEnumerable GetCars(IDataModel dataModel, Expression> doorSpecification = null, Expression> doorHandleSpecification = null)
{
if (doorSpecification == null)
doorSpecification = door => true;
if (doorHandleSpecification == null)
doorHandleSpecification = handle => true;
var cars =
(from car in dataModel.CAR.AsExpandable()
join door in dataModel.DOOR on car.CAR\_ID equals door.CAR\_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR\_HANDLE on /\*(door != null ? door.DOOR\_ID : (int?)null)\*/door.DOOR\_ID equals doorHandle.DOOR\_ID
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorSpecification.Invoke(door) && doorHandleSpecification.Invoke(doorHandle)
select car);
return cars;
}
var carsWithRedHandle = GetCars(dataModel, doorHandleSpecification: doorHandle => doorHandle.COLOR == "RED").ToList();
```
Вот sql-запрос и план его исполнения, когда джойн происходит так: door.DOOR\_ID equals doorHandle.DOOR\_ID
И вот план исполнения, когда (door != null? door.DOOR\_ID: (int?)null) equals doorHandle.DOOR\_ID
Как видите, план исполнения совершенно другой, и его Cost в полтора раза больше.
Для решения этой проблемы можно использовать #if DEBUG и прогонять тесты в дебаге, но, поверьте, читаемость и надёжность кода от этого нисколько не увеличатся. Гораздо лучше бороться с проблемой на корню – сделать так, чтобы при написании юнит-тестов вам вообще не требовалось беспокоиться об этой особенности left join-ов. С этой целью мною была написана библиотека, выложенная на <https://github.com/FiresShadow/LinqTestable>.
Для того чтобы использовать библиотеку, нужно скачать и подключить проект, и изменить MockObjectSet в вашем проекте, а именно заменить вот этот кусок:
```
public System.Linq.Expressions.Expression Expression
{
get { return _collection.AsQueryable().Expression; }
}
public IQueryProvider Provider
{
get { return \_collection.AsQueryable().Provider; }
}
```
на:
```
public System.Linq.Expressions.Expression Expression
{
get { return _collection.AsQueryable().ToTestable().Expression; }
}
public IQueryProvider Provider
{
get { return \_collection.AsQueryable().ToTestable().Provider; }
}
```
После этого вышеописанная проблема в юнит-тестах пропадёт сама собой.
Кстати, почитать как писать unit-тесты для Entity Framework можно [здесь](http://www.codeproject.com/Articles/447988/How-to-Mock-Test-an-Entity-Framework-Model-First-P).
Библиотека немного сыровата и решает лишь одну проблему: NullReferenceException при двух left join-ах. Решение одной лишь этой проблемы не устраняет концептуального разрыва, есть множество других проблем, например: сравнение null с null на равенство даёт разные результаты в реляционной и объектно-ориентированной моделях. Но и эта проблема тоже решаема. | https://habr.com/ru/post/269917/ | null | ru | null |
# Поиск данных в столбцах таблицы с пагинацией (front-часть)
### Введение
Всем добрый день. Меня зовут Александр. Сейчас я работаю в Мегафон front-end разработчиком. Проблемы поиска данных всегда отличались особенной сложностью и зачастую нестандартностью в подходах. Сегодня я бы хотел остановиться на одной интересной задаче, которую мне пришлось решать совсем недавно во время разработки платформы Интернета вещей. Впрочем, такая задача, может встретиться и на любом другом проекте, где есть динамическая подгрузка данных по REST API. Будь то подгрузка во время пагинации, или во время скроллинга, или как то иначе…
Проблематика
------------
Казалось бы: в чем может быть трудность. Особенно когда речь касается только фронта? Ведь все алгоритмы поиска реализуются в основном на бэке. На самом деле и да, и нет. Давайте представим простую таблицу, у которой есть пагинация из нескольких страниц и фильтр на каждом столбце. См. ниже.
Таблица с фильтрами в столбцахВ данной табличке открыт фильтр по столбцу Номер БС. Простыми словами: вводя любые символы в поле ввода фильтра, вы получаете подходящие опции в дропдауне. Кликнув на любую из них, вы отфильтруете данные в таблице по этому элементу.
Каким образом можно вывести подобный дропдаун с нужными опциям?
Варианты решения
----------------
1. Составить массив из всех элементов столбца таблицы и с помощью методов filter и includes (или им подобных) показать нужные опции в дропдауне. Проблема в том, что компонент таблицы не знает о элементах, которые находятся на других страницах. Они подгружаются только при переходе на эти страницы. А значит поиск будет осуществляться не по всем элементам.
2. Сформировать массив как в 1-м варианте, но запрашивая его с бэка. Хороший вариант, но производительность такого подхода близится к 0. Что если записей 1 млн? В таблице именно для этого и используется пагинация.
3. Отправлять строку фильтра на бэк, и уже с бэка получать нужные опции для дропдауна. Бэк “знает” обо всех записях и на нем можно использовать всевозможные алгоритмы поиска в базах данных, которые будут работать достаточно быстро.
Отлично. Именно этот вариант мы и рассмотрим. На рисунке выше изображен именно он: мы ищем записи, которых нет на текущей странице, однако в дропдауне видим подходящие варианты со всех страниц.
Алгоритм
--------
1. Для каждого столбца должен существовать запрос на бэк и поле, которое мы будем брать из ответа, чтобы заполнить опции. Нужен config.
2. После ввода данных их нужно отправлять на бэк. Можно по кнопке, но лучше использовать периодическую отправку в функции debounce.
3. Во время процесса отправки/получения данных показывать loader
4. Получения ответа от бэка и заполнение опций для дропдауна из заданного поля ответа
Решение
-------
Я предполагаю, что читатели знакомы с JS и React и в данной статье нет смысла рассказывать о том, как отправлять запросы, фильтровать массивы и другие основы JS. Я буду останавливаться лишь на важных составных частях алгоритма.
Итак, начнем по порядку. Как мы выяснили, для начала нужен конфиг для таблицы (для каждого столбца) и ее фильтров. Разделим его на 2 файла.
Пример конфига столбца таблицы:
```
{
id: 'address',
title: 'Адрес объекта',
filter: filters.address,
checked: true,
minWidth: 160
}
```
Пример конфига фильтра:
```
address: {
type: 'includes',
name: 'addrFilter',
options: {
default: {
values: 'objectsList',
fetchFunc: 'fetchObjectsList',
calcFunc: 'address'
}
}
}
```
Как можно заметить конфиги связаны по типу один-ко многим. То есть один и тот же фильтр может соответствовать нескольким столбцам таблицы.
Поле options содержит как раз поля для конфигурации опций фильтра. Например:
* fetchFunc - имя thunk функции, которая загружает данные для этого фильтра
* values - поле из ответа сервера, в котором содержатся опции
* calcFunc - имя функции для трансформирования опций
Остановимся подробнее на calcFunс. При таком алгоритме, что был описан в опции попадают данные из определенного поля ответа. Но что если поле составное, например в каждую опцию фильтра должно попасть сразу несколько полей. Пример с адресом: опция фильтра = город + улица + дом …
Фильтр адресаВ этом нам и поможет функция предварительного обсчета опции. Вот пример реализации:
```
//object includes calc functions
const calculatedData = useMemo(() => (
{
default: (values) =>
{
//default calculate
},
address: (values) =>
{
//calculate with generateAddress function, for example
},
...
}
), [...]);
//using this object (calcFunc from config):
const data = calculatedData[calcFunc || 'default'](values)
```
Далее. Как уже говорилось лучше всего отправлять запросы через определенный интервал задержки. То есть пользователь вводит данные в поле, приостановился на полсекунды - произошла отправка. Реализуется это примерно так:
```
// debounce function
const debounce = (fn, ms = 0) => {
let timeoutId;
return function(...args) {
clearTimeout(timeoutId);
timeoutId = setTimeout(() => fn.apply(this, args), ms);
};
};
//debounceFetch function
const debounceFetch = debounce(async (func, args) =>
typeof func === 'function' && (await func(args)), 500);
//sending request
useEffect(() => {
debounceFetch(actions[fetchFunc], {
filter: { [filterName]: filterValue || null }
});
}, [filter]);
```
Продолжаем. В текущей задаче может понадобиться определить грузится ли в данный момент какой-либо фильтр, например, чтобы показать лоадер. У нас в команде приняты некоторые стандарты для именования переменных, например, все переменные, показывающие процесс загрузки начинаются с isLoading. Например, isLoadingObjects. Поэтому идеальным решением будет создать selector для kea, который = true если хотя бы в одном стейте, содержащем в названии isLoading, содержится значение true.
Если вы используете не kea, а обычный redux или какую-то другую библиотеку - уверен, вы адаптируете этот код под свои нужды. Если нет - пишите мне. А лучше используйте kea =)
Далее вы просто показываете лоадер пока anyLoading===true, все как обычно.
На этом мы почти закончили. Далее нужно просто обработать ответ сервера, взять нужное поле из него, пропустить его через calcFunc если она указана в конфиге и вывести найденные опции для фильтра.
*Всю логику лучше всего будет объединить в один хук и назвать его, скажем, useFiltersOptions.*
Выводы
------
Используя рассмотренный алгоритм, мы решаем задачу поиска оптимальным путем: все сложные вычисления отдаем на бэк, делая это постепенно, следуя за вводом пользователя. Плюс к этому у нас появляются огромные возможности для расширения, используя конфиг таблицы, конфиг фильтров и функцию предварительной обработки ответа сервера.
А также используются уже имеющиеся запросы к бэку, а в конфиге указываются лишь их названия и поля из ответа для формирования результатов поиска, что позволяет избежать дублирования кода и лишней работы на стороне бэка. | https://habr.com/ru/post/544384/ | null | ru | null |
# Сказ о том, как я с гидрой боролся
Проблемы третьего мира
----------------------
Вообще на этом фриланс-проекте я занимался вёрсткой - простенький дизайн в Figma, где ничто не предвещало беды. И вот, когда проект сдан, заказчик внезапно присылает скриншоты с Mac и iPhone - и там какие-то белые квадраты, дизайном ни разу не предусмотренные.
Вариант *"а у меня всё нормально показывется"* не прокатил. Пришлось поднять виртуалку с MacOS и убедиться: квадраты есть. Консоль? Есть консоль! В консоли -- ошибки, какие-то бредовые скрипты, пытающиеся (неудачно) показать рекламу. Заказчик клянётся и божится, что ничего такого не ставил... Смотрю исходники, вижу прекрасный `/index.php` вот такого содержания:
Приятно обнаружить такое в главном файле сайтаИ тут вспоминаю, что когда возился с настройкой главного меню (да, в Битриксе с этим приходится *возиться*), видел странную строку: `include($_SERVER["DOCUMENT_ROOT"]."/upload/dr/content/inc.php");`
Для Битрикса она довольно нормальная, антивирусы тоже спокойно пропускают. А мне как-то странно - ну кто *в здравом уме* подключает файлы из upload?
Небольшая справка для тех, кто не знаком с Битриксом и верит в *здравый ум*:
У него есть несколько проблем:* Сайт - это примерно 12.000 мелких php-файлов, раскиданных по сотням директорий разных уровней, каждая страница - отдельный php-файл, каждый компонент - отдельная папка с кучей файлов. Единой точки входа нет, разделения M/V/C нет, ~~растительности нет, жизни нет, населена роботами~~.
* CSS и JS раскиданы по всему сайту, и на лету собираются в единую свалку. Управлять этим невозможно, поэтому практикуется встраивание inline-картинок в css, css в html, html в php, php подключаются как попало (include, include\_once, require ....) и куда попало.
* шаблоны вёрстки - php-файлы, в которых код перемешан с html, да ещё и по задумке разработчиков раскиданы по такой структуре директорий (3 раза bitrix - это не предел!):
`/bitrix/components/bitrix/iblock.element.add/templates/.default/bitrix/iblock.element.add.form/.default/template.php`
Но если вы думаете, что мучения по поиску нужного компонента заканчиваются на файле `/bitrix/components/bitrix/news/templates/.default/bitrix/catalog.filter/.default/template.php` то вы ошибаетесь - нужный вам файл может переопределяться вот этим: `/local/templates/mystyle/components/bitrix/news/certificates/bitrix/catalog.filter/.default/template.php`
* Разработчики часто бывают не очень грамотные и путаются в этих путях. Плюс официальные обновления иногда ломают совместимость. Поэтому при обновлении движка часто ломается весь сайт, и то, что работает пару лет без обновлений, трогать крайне рискованно. Естественно, дыры в безопасности копятся годами.
Со всем этим безобразием всё равно приходится работать, потому что на предложение "снести сайт к чертям и сделать нормально" малый бизнес реагирует довольно болезненно.
Археология
----------
Итак, Битрикс во всей своей красе и первозданной мощи. И где-то в этой адской машине - вирус, плавно жрущий сайт: пока разбирались, что к чему, стали появляться какие-то левые файлы. Их удаляешь, а они снова появляются. Всю дрянь из скрипта вычистил - а через час она снова на месте, и ещё в паре мест.
По идее, для таких вещей есть антивирусы типа VirusDie, но на практике они не работают - тот самый **include** из папки **upload** он, например, подозрительным не считает. А от беглого просмотра создатели вируса предусмотрели забавную, но тупую защиту:
Защита от беглого взгляда - 3 МбКак известно, глупые и ленивые всякую работу делают дважды. Поэтому сначала я попытался вычистить всё это вручную, в надежде, что там всего пара "закладок" и *сейчас я всё починю*. Но гидра не сдавалась, новые головы отрастали на месте отрубленных и приводили меня в отчаяние.
На сервере появлялись новые файлы с *stupidcode shell*, *why bro shell* и прочими говорящими названиями. Любопытными при этом представлялись два факта:
* самые старые из найденных файлов вируса датировались **2016-м годом**, а попытки лечить его через VirusDie предпринимались с 2015-го!
* файлы появлялись непонятным образом, всё, что можно было вычистить, было вычищено
Снежное чучело
--------------
На этом моменте (только тогда!) получилось добыть у заказчика ssh-доступ. И тут выяснилось самое интересное. Будет уместна цитата из "Отеля "У погибшего альпиниста", полностью описывающая моё состояние:
> *... Он не пошевелился. Тогда я подбежал к нему и потряс за плечо. Я обалдел. Хинкус вдруг как-то странно осел, мягко подавшись у меня под рукой. — Хинкус! — растерянно закричал я, непроизвольно подхватывая его. Шуба раскрылась, из нее вывалилось несколько комьев снега, свалилась меховая шапка, и только тогда я понял, что Хинкуса нет, а есть только снежное чучело, облаченное в его шубу...*
>
>
Я тоже обалдел. На хостинге был 21 сайт, а у скриптов не было никаких ограничений по доступу между ними - то есть любой скрипт спокойно читал любой файл из директорий выше уровнем (логи, бекапы...) и писал что угодно в другие папки. **Фактически, поймав вирус на одном дырявом сайте, ты ловил его сразу на всех!** Снеговик, облачённый в меховую шубу - прекрасная метафора уровня безопасности этого проекта, не правда ли?
*21 сайт ... 250.000 скриптов ... за что обижать бедный верстальщик, мистер? я когда-то жить город и ходить школа, мистер, но я не уметь читать так mucho mucho rapido!*
Единственное, что спасало - это то, что вирусы явно писали не особо заморачиваясь, видимо, рассчитывая на то, что их никто лечить и не будет. Но мне стало любопытно, смогу ли я с этим справиться.
Плюс автоматизация всей страны
------------------------------
Для начала я с особым цинизмом заблокировал доступ к сайту со стороны Amazon AWS, откуда по логам шла основная коммуникация с вирусными файлами. Кстати, если посоветуете удобную бесплатную программу под Windows для анализа логов - буду рад, платить за [http Logs Viewer](https://www.apacheviewer.com/) мне не захотелось, но удобнее ничего не нашёл.
Для получения списка адресов AWS пришлось скачать и установить [AWSPowerShell](https://sdk-for-net.amazonwebservices.com/ps/v4/latest/AWSPowerShell.zip) и запустить в PS волшебную команду `Get-AWSPublicIpAddressRange | where {$_.IpAddressFormat -eq "Ipv4"} | select IpPrefix`
Команда выдаёт список из 3000+ адресов, дополнил его парой литовских серверов, которые уж слишком упорно лезли обращаться к вирусным файлам и закинул в .htaccess (наверное, нормальные админы приготовили для меня отдельный котёл в аду за такое, но ничего умнее на shared хостинге мне в голову не пришло). `php_value open_basedir` отправился туда же.
```
php_value open_basedir "/path/to/site"
Require all granted
Require not ip 100.20.0.0
Require not ip 100.24.0.0
#... 3000+ адресов....
```
А дальше пришлось писать утилиту, которая бы помогла бы мне обуздать эту гидру. Хотелось сделать быстро, одним файлом, без использования внешних зависимостей, чтобы его было легко просто скопировать в нужное место и запустить, из командной строки или через веб.
Кто первый VSCode запустит, тот и программист
---------------------------------------------
В общем, эта поделка вряд ли порадует кого-то хорошим исходником или правильным программированием, зато она работает и делает то, для чего предназначена - сканирует все файлы на предмет 20+ факторов опасности, взвешивает и выдаёт общую оценку опасности файла.
Признаки разные:
* использования более-менее безобидных, но опасных функций `eval()` и `shell_execute()`
* характерных паттерны обфускации кода вроде `$WUGh64382 = irmcjaowlfxc($gbVclGM7976[39]);`
* длинные цепочки вроде `\144\151\x73\160\154\x61\157\x72\x73`
* прочие *странные* имена переменных и функций - например, длиной 40+ символов
* список директорий, обращение к которым через include считается криминальным.
Каждому признаку присваивается вес (веса подшаманивал вручную по ходу написания). Можно через параметр задать минимальный вес, при котором объект попадёт в отчёт.
Пример отчётаЛожных срабатываний не так много, хотя Битрикс порадовал функциями с именами рекордной длины вроде `GetNumberOfWorkflowTemplatesForDocumentType()`, `GetInheritedPropertyTemplateSectionMenuItems()` или языковой константы `ProgressDialogWaitingForResponseFromServerText`. А я ещё удивлялся длинным путям в структуре директорий! Создатели Битрикс явно не ленятся печатать! Ну и встроить картинку в css, css в html, html в php - для них нормально.
Чтобы их исключить, предусмотрен список исключений по имени и пути файла - да, очень ненадёжно, но от идеи сравнивать crc32 я пока отказался, хотя это было бы сильно лучше. Потому что количество использования *подозрительных* факторов зашкаливает:
Исключения всё равно выводятся в списке - на всякий случай их тоже надо просматриватьРезультаты
----------
Потратил день, вычищая всё найденное сканером. Вирусная активность с тех пор прекратилась, сайты снова живы. Google и Яндекс успели проиндексировать выдаваемый вирусом контент - какую-то рекламу курток на японском языке, но сейчас всё возвращается обратно.
Сканер я запустил ещё и у себя на хостинге, и тоже нашёл там куски вируса в паре файлов - благо, в давно неактивных сайтах 2016 года. Но сам факт удивил. Попробуйте у себя, если у вас есть что-то из legacy-сайтов на Битрикс / Joomla / WordPress, любопытно, найдется ли что-то!
Прикинул, сколько времени и нервов может сэкономить эта поделка, и решил поделиться ей с общественностью. Хотя когда представляю, сколько помидоров может прилететь за качество кода на нашем серьёзном Хабре - карма съёживается. А и пусть :-)
GitHub
------
<https://github.com/mSnus/simple-virus-scanner>
Дополнения и исправления приветствуются. В планах - сделать нормальную сортировку и фильтрацию результатов на JS, улучшить анализ исключений. Ну и, конечно, пригодятся новые "факторы риска" - делитесь, если придумаете таковые. | https://habr.com/ru/post/543906/ | null | ru | null |
# 1C-Битрикс на Raspberry Pi 2
 Наши коллеги и партнеры — веб-студия «Оробланко» — решили устроить интересный эксперимент: запустить 1С-Битрикс на микрокомпьютере Raspberry Pi 2. О чем и написали подробно [у себя в блоге](http://www.oroblancostudio.com/ru/blog/1c-bitrix-on-raspberry-pi-2.html). С их любезного разрешения публикуем результаты. :)
\* \* \*
Сразу скажем, зачем нам это надо.
Понять, возможно ли это вообще. Убедиться, что Raspberry Pi 2 компьютер, а не игрушка.
Понять, насколько быстро и устойчиво будет работать Битрикс на таком слабом компьютере (и будет ли он работать вообще).
Подтвердить собственную квалификацию специалистов по настройке серверов, ведь задача нетривиальная.
Если все получится, то мы развеем старую легенду о том, что «Битрикс тяжелый, медленный и неповоротливый» и что ему нужны большие вычислительные ресурсы.
[Некоторое время назад мы купили Raspberry Pi 2](http://www.oroblancostudio.com/ru/blog/obzor-raspberry-pi-2.html), собрали его и подключили к телевизору. Машинка показалась вполне шустрой, на борту 1 ГБ памяти и четырехядерный процессор плюс Debian, который в версии для Raspberry называется Raspbian. А так как мы сертифицированные партнёры 1С-Битрикс, у нас так и чесались руки скрестить Raspberry с Битриксом и посмотреть, что получится.
Мы выбрали чистую форму эксперимента, использовав Raspberry Pi 2 в дефолтной конфигурации и не подключали к компьютеру дополнительные HDD или SSD, оставив в качестве основного носителя MicroSD, а чтобы нам было веселее и компьютер не скучал, взли самую «тяжёлую» конфигурацию Битрикса. Редакция «Бизнес» и решение «Интернет-магазин». Чтобы уж сразу, как говорится, кувалдой по голове.
SD карты — носитель специфический. Самая затратная по времени операция — запись. Карта памяти у нас не самая медленная, кроме того, в Raspbian этот момент учтен и все пользовательские операции записи на диск кешируются в оперативной памяти (отложенная запись), поэтому с точки зрения пользователя всё «летает». Но как машинка будет работать с записью на карту в серверной конфигурации? Мы не знаем. Но попробуем.
Мы также понимали, что apache+mysqld — штука ресурсоёмкая, и под нагрузкой реально переполнение оперативной памяти, система начнет использовать своп и «сядет на диск», в результате сервер «ляжет». Поэтому мы сразу сделали ставку на nginx и композитный режим работы Битрикса, что позволит свести к минимуму наши риски.
#### **Начинаем**
Ставим на машинку штатный Raspbian и Midnight Commander для удобства. Raspbian выбран за отсутствие глюков и максимальную «вылизанность» и стабильность. Отключаем графический режим (X server) для экономии ресурсов. Дальше все делаем через SSH.
Обязательно выполняем команды
```
apt-get update
apt-get upgrade
```
Это оказалось важным. Если не обновить пакеты, то криво поставятся memcached и nginx, и мы с этим столкнулись.
#### **Ставим Битрикс**
Скачиваем инсталлятор веб-окружения.
```
wget http://repos.1c-bitrix.ru/yum/bitrix-env.sh
chmod +x bitrix-env.sh
./bitrix-env.sh
```
Скрипт говорит «Что за дрянь вы мне даёте?» и вываливается. Смотрим, что не так. Ага, первым делом скрипт проверяет, что его запускают на системе, которая поддерживает набор команд x86. А мы ему ARM подсунули. Ну и ладно, людей, которые имели дело с ЕС-1040 и DEC VAX, не испугаешь. Скрипт мы править не стали. Ставим всё вручную, открываем нужные порты.
Что ставим:
* mysql
* apache
* php с требуемыми расширениями (например, geoip)
* gd
* nagios
* munin
* catdoc
* xpdf
* freetype
* apc
Nginx и memcached пока не ставим, так как интересно посмотреть, как оно будет работать на чистом апаче.
Скачиваем дистрибутив Битрикса и запускаем процесс установки. Оно таки ставится!
#### **Интересности**
Итак, у нас на Raspberry Pi 2 завелся Битрикс, на чистом апаче, без nginx и memcached. Подключаем кеширование APC. Так вот, APC для Raspbian работает в режиме Emulated. То есть он вроде как есть для тех, кому он нужен, но на самом деле его нет. Поэтому по факту он не дает прироста скорости сайту.
Еще одна интересность. Memcached в Raspbian не позволяет работать с сокетами. Как ни настраивай, что не прописывай. Не создаётся сокет, хоть тресни. Единственная возможность пользоваться memcached — обращаться к заглушке 127.0.0.1.
Оверклокинг нужно выключать. Он приводит к нестабильной работе и зависанию компьютера. Нужно выставлять дефолтную частоту 900 МГц.
#### **Производительность**
Панель производительности Битрикса при тестировании на чистом апаче выдаёт 6.5 — 7.0 «попугаев», что в общем не так плохо. На некоторых коммерческих хостингах бывают такие показатели. Но интересно то, что после подключения memcached спидометр «падает» до 3.5 — 4.0 «попугаев», хотя memcached реально ускоряет сайт. С чем связано такое поведение спидометра — непонятно. Тоже вот — интересность.
Apache под Raspbian не оптимизирован никак. Что приводит к куче висячих процессов и переполнению оперативной памяти. Поэтому пришлось поправить настройки, ограничив количество серверов и потребление ОЗУ.
MySQL так же потребовал настроек, чтобы оптимизировать сервер по памяти и производительности.
В общем и целом система работает, но ей явно тяжело. Посмотрим, как изменится ситуация с nginx.
#### **Разгон**
Как я уже упоминал, перед установкой nginx обязательно нужно проапдейтить систему. Иначе nginx ставится криво и, что интересно, вышибает апач. Поэтому у нас было две итерации установки. Без апдейта системы и с апдейтом.
После установки nginx, естественно, настраиваем frontend и backend (двухуровневая архитектура), включаем композитный режим в Битриксе и делаем тюнинг настроек nginx, отдавая ему на откуп все картинки и готовые html файлы из композитного кеша.
Включаем в настройках Битрикса CDN, чтобы максимально разгрузить сервер и вынести всю возможную статику наружу.
После подключения nginx и накопления композитного кеша сайт начинает работать очень быстро. Вот так:
#### **Финализация**
Пробрасываем порт через NAT, чтобы увидеть сервер снаружи и вешаем на домен. Проверяем сканером безопасности, настраиваем проактивную защиту и прогоняем тесты монитора качества. Настраиваем резервное копирование всей системы на внешний сервер Synology и ставим наш микросервер на внешний мониторинг. Потребление оперативной памяти системой в среднем — 400-700 МБ. Пока полёт нормальный.
#### **Итоги**
Мы сделали это! И вроде кроме нас так никто не извращался, мы первые в мире.
Битрикс может работать на чём угодно, доказанный факт.
Для нормальной производительности обязательны: композитный режим, nginx и настройка связки apache+mysqld.
Даже на Raspberry Битрикс может работать быстро.
#### **Конфигурация проекта**
1С-Битрикс, редакция «Бизнес» + решение «Интернет-магазин».
Включено композитное кеширование и CDN для статического контента.
Компьютер
Raspberry Pi 2
Процессор Broadcom BCM2836 quad-core ARMv7
Оперативная память 1ГБ
Носитель — карта Micro SD 32 ГБ
Скорость канала — 30 МБит/с или меньше.
ОС Raspbian
[Потыкать мышкой или пальцем в сайт на Битриксе и Raspberry Pi 2 можно тут (raspberry.oroblanco.ru)](http://raspberry.oroblanco.ru/).
Автор: Дмитрий Иванов
Оригинал: [www.oroblancostudio.com/ru/blog/1c-bitrix-on-raspberry-pi-2.html](http://www.oroblancostudio.com/ru/blog/1c-bitrix-on-raspberry-pi-2.html) | https://habr.com/ru/post/276409/ | null | ru | null |
# Multicast вещание видеофайлов с помощью tsplay
Добрый день.
Возникла необходимость вещать видеофайлы в сеть (трейлеры фильмов). Первая мысль, которая возникла у меня в голове (и у вас тоже, наверное?) — это VLC. Установил VLC, настроил, запустил и результат: все работает. Через полчаса замечаю, что иногда подсыпается изображение. Грешу на дисковую подсистему. Через час понимаю, что некоторые тяжелые файлы очень сильно сыпятся, а некоторые идут идеально. Открываю анализатор TS-потоков и вижу (IAT сильно подскакивает при переключении на другой трейлер):
Транспортный поток неидеален, вероятно VLC виноват? Ищу другое ПО для вещания и нахожу tsplay.
Под катом небольшая инструкция по запуску вещания списка файлов через tsplay.
Сразу же показываю результаты анализатора при вещании с помощью tsplay:
Программа tsplay входит в комплект программ под названием tstools.
Исходники: [code.google.com/p/tstools/downloads/list](http://code.google.com/p/tstools/downloads/list)
Официальный сайт: [tstools.berlios.de](http://tstools.berlios.de/)
Пользователям Debian/Ubuntu повезло, установить можно из репозиториев.
Остальным придется скачать исходники, распаковать и выполнить make. Надеюсь описывать этот процесс не нужно?
Чтобы запустить вещание выполняем:
```
tsplay filename.ts 1.2.3.4:5500
```
Зацикливаем:
```
tsplay filename.ts 1.2.3.4:5500 -loop
```
И читаем только первые 1000 TS пакетов:
```
tsplay filename.ts 1.2.3.4:5500 -loop -m 1000
```
Написал простенький цикл, который по очереди вещает все .ts файлы из текущей директории:
```
while true; do for i in `ls | grep .ts`; do tsplay $i 239.255.10.156:1234; done; done;
```
Закинул в screen и забыл, работает стабильно уже неделями.
Ресурсы компьютера совсем не ест. Надеюсь, кому-нибудь пригодится. Посмотрите другие программы из набора tstools. Удачи. | https://habr.com/ru/post/154349/ | null | ru | null |
# Произвольное число аргументов любых типов на C11 и выше с помощью _Generic и variadic макросов
Функция print на Си, принимающая любые аргументы в любом количестве### О себе
Я сам программист на C++, вернее я только начинающий, без коммерческого опыта. Изначально я познакомился с языком Си, а C++ открыл как мощное расширение языка C. В нем на мой взгляд добавлены те необходимые полезные вещи, которых нет в C (перегрузка функций, классы, пространства имен и др), при этом эти вещи отлично расширяют философию языка
### Задумка
Я узнал что в C стандарта 2011 года добавили небольшую возможность "перегрузки" функций с помощью макроса. ([Generic selection](https://en.cppreference.com/w/c/language/generic)) Мне, очень интересно стало написать какую-нибудь функцию, которая максимально использовала бы эту возможность
Задумка: написать (макро) функцию `print`, которая выводит через пробел все переданные в нее аргументы. Звучит невероятно для Си, где обычно указывают тип принимаемого аргумента одной буквой в имени, и явно указывают число переданных аргументов. Но с джейнериками из C11 это возможно
Про бывшие проблемы с форматированием данной статьи*Этот текст под спойлером не имеет прямого отношения к теме статьи*
Это моя первая статья на сайте, и с ней был технический сбой. Вот несколько моментов, которые надеюсь помогут разработчикам Хабра найти баг:
1. Писал я пост в режиме песочницы. Все отображалось норамльно. Была пара багов, которые вряд ли имеют отношение к сбою в форматировании, но лучше укажу:
1. Красное сообщение в шапке с просьбой подтвердить почту не проподало до перезахода в аккаунт
2. Некоторые блоки кода схлопывались, и не отображались до обновления страницы
2. После публикации статьи она помечалась как "на модерации", но при этом все форматирование было норамльным
3. После прохождения модерации статья преобрела следущий ужасный вид с очень необычными багами:
1. Заголовки спойлеров уехали под спойлеры
2. Все `__VA_ARGS__` и `__VA_OPT__` превратились в `VA_ARGS` и`VA_OPT.` При этом с `__LINE__ и __FILE__` ничего не произошло
3. Самое нечитаемое: все переносы строк с символом `\` пропали, и макросы развернулись в одну строку. В итоге код на 20 строк превратился в 5 строк, что очень нечитаемо и самое неприятное
4. Символ `&` заменися на `&`, а `<` заменился на `<` или что-то подобное
5. Текст из-под описания картинок продублировался отдельным блоком со строкой
4. Честно, не ожидал что сразу наберется так много просмотров (около 700) за пару часов. И все эти люди увидели этот сбой. Но при этом как-то прочитали статью
5. Так же мне пригодился скриншот, который я как раз сделал на всякий случай, вдруг все поломается. Я ссылку на него оставил, когда исправлял форматирование. Как в воду глядел! :) [png версия с нормальным форматированием](https://github.com/light-and-ray/cool/blob/master/habr%20c%20print/Screenshot_2021-04-21%20%D0%9F%D1%83%D0%B1%D0%BB%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F%2C%20%D0%BF%D1%80%D0%B5%D1%82%D0%B5%D0%BD%D0%B4%D1%83%D1%8E%D1%89%D0%B0%D1%8F%20%D0%BD%D0%B0%20%D0%BF%D1%80%D0%B8%D0%B3%D0%BB%D0%B0%D1%88%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%A5%D0%B0%D0%B1%D1%80(1).png)
### Простой пример с одним аргументом
Введу в суть работы этой перегрузки по типу на простом примере с одним аргументом
Напишем три функции `print(x)` для типов `int, float` и `char*` (cstring):
```
void print_int(int x) {printf("%d ", x); }
void print_float(float x) {printf("%.4f ", x); }
void print_string(char* x) {printf("%s ", x); }
```
С помощью данного макроса соединим из под одним именем `print`:
```
#define print(x) _Generic((X),\
int: print_int,\
float: print_float,\
char*: print_string)\
(x)
```
В итоге получим, что запись `print("hi")` вызывает `print_string("hi")`, `print(5.5)` вызывает `print_float(5.5)` и так далее
После обработки препроцессором запись `print("hi")` превратится в `_Generic(("hi"), int: print_int, float: print_float, char*: print_string)("hi"),` и компилятор в зависимости от типа первого аргумента выберет имя функции, которую надо подставить вместо всего выражения `_Generic(...)`
### Неопределенное число однородных аргументов
С помощью макросов также можно передавать неопределенное число аргументов без явного указания их числа. Покажу на примере для функции `print_int`
```
void print_int(int n, ...)
{
va_list argptr;
va_start(argptr, n);
int x;
for (int i = 0; i < n; i++)
{
x = va_arg(argptr, int);
printf("%d ", x);
}
va_end(argptr);
}
```
С помощью макроса, который я любезно скопипастил из гугла :) можем вывести число аргументов `n`, и передать его в функцию первым аргументом
Макрос PP\_NARG(...), возвращающий число аргументов
```
#ifndef PP_NARG
/*
*
* The PP_NARG macro returns the number of arguments that have been
* passed to it.
*
* https://groups.google.com/g/comp.std.c/c/d-6Mj5Lko_s
*
*/
#define PP_NARG(...) \
PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) \
PP_ARG_N(__VA_ARGS__)
#define PP_ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63, N, ...) N
#define PP_RSEQ_N() \
63,62,61,60, \
59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40, \
39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20, \
19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0
#endif
```
```
#define print(...) print_int(PP_NARG(__VA_ARGS__), __VA_ARGS__)
```
*Примечание:* `__VA_ARGS__` *содержит в себе аргументы, которые попали в* `...`
Соответственно для джейнериков, если все аргументы одного типа, мы должны написать
```
#define function(x, ...) Generic((x),\
int: function_int,\
float: function_float,\
char*: function_string)\
(PP_NARG(__VA_ARGS__) + 1, x, __VA_ARGS__)
```
*В итоге получим функцию* `function`, которая обрабатывает неопределенное число однотипных аргументов. Я написал `function`, а не `print`, так как для нашей функции это точно не подойдет. Однако если вам известно, что все аргументы одного и того же типа, то такой способ будет намного проще, чем когда любой аргумент любого типа
### Неопределенное число аргументов любого типа
### I. Хранение информации о типах
Мы создадим универсальную функцию вида (синтаксис вольный) `hidden_print(sep, n, x1, x2, x3, ...),` которая в зависимости от типа следующей переменной `xi` выполняет нужный printf. Для любой другой реализации можно вызывать нужную функцию с уже известным типом
Для определенности максимальное число аргументов будет 12. Для `print`'а этого достаточно.
Так же немного поясню по поводу названийВсе глобальные имена будут начинаться с приставки `cool`. Это что-то вроде пространства имен, просто я решил создать отдельную несерьезную, удобно подключаемую библиотечку, в которой хранятся такие интересные, но практически не очень полезные штучки. В этой библиотеке на c++ все функции обьявлены в пространстве имен `cool`, однако в Си пространств имен нет, так что пользуюсь приставками. Однако в любой момент можно сделать `#define print cool_print`, а затем `#undef print`
Для хранения информации о типах аргументов буду использовать массив `cool_hidden_types[12]`, индекс `cool_hidden_last`, куда надо добавить следущий элемент `cool_hidden_add_int`, `cool_hidden_add_float` и т.д. для каждого типа, которые добавляют в массив значение о типах. Всего наша функция будет поддерживать 7 типов: `int, char*, float, double, char (?), uint, long`
char (?)Почему-то при записи `_Generic(('a'), char: fun_char)()` компилятор выдает что-то вроде *"не найдена функция для* `int`*"*, так что на практике если передать символ в одинарных кавычках ничего не получится и он дай бог выведется как `int`
Значения о типах я решил определить с помощью `#define`, хотя в си есть и `enum`. Но раз уж тут почти весь код на макросах, то гулять так гулять!
Код работы с массивом типов
```
#define COOL_HIDDEN_INT 0
#define COOL_HIDDEN_STRING 1
#define COOL_HIDDEN_FLOAT 2
#define COOL_HIDDEN_DOUBLE 3
#define COOL_HIDDEN_CHAR 4
#define COOL_HIDDEN_UINT 5
#define COOL_HIDDEN_LONG 6
#define COOL_HIDDEN_VOID 7
int cool_hidden_types[12];
int cool_hidden_last = 0;
void cool_hidden_add_int()
{
cool_hidden_types[cool_hidden_last] = COOL_HIDDEN_INT;
cool_hidden_last += 1;
}
void cool_hidden_add_string()
{
cool_hidden_types[cool_hidden_last] = COOL_HIDDEN_STRING;
cool_hidden_last += 1;
}
/*аналогично для каждого типа */
void cool_hidden_add_void()
{
cool_hidden_types[cool_hidden_last] = COOL_HIDDEN_VOID;
cool_hidden_last += 1;
}
```
`COOL_HIDDEN_VOID` будет означать, что данный тип не поддерживается функцией. Можно было бы заморочиться и передавать информацию о размере переменной и выводить в 16-ричном виде для любой другой переменной, но я не стал это делать
Создадим теперь generic макро функцию `cool_hidden_add(x)`, которая будет добавлять элемент в массив в зависимости от типа `x`
```
#define cool_hidden_add(x) \
_Generic((x), \
int: cool_hidden_add_int, \
char*: cool_hidden_add_string, \
float: cool_hidden_add_float, \
double: cool_hidden_add_double, \
char: cool_hidden_add_char, \
unsigned int: cool_hidden_add_uint, \
long: cool_hidden_add_long, \
default: cool_hidden_add_void \
)()
```
*Это было самое простое...*
### II. Определение числа аргументов на уровне макроса
*Идея заключается в том, чтобы определить макрос вида* `cool_print##n(x1, x2, ..., xn)` *("##" означает конкатенацию со значением* `n`*)*, который по очереди добавляет информацию о типе каждого `xi`, а затем передает в функцию реализации `cool_hidden_print(sep, n, x1, x2, ...)` разделитель, `n`, и все `xi`. Разделитель я определю как глобальную (если так вообще можно называть переменные с уникальной приставкой) переменную `cool_print_sep = " "`, которую можно изменить в любой момент
Определим это простым образом через копирование. Хотя наверное их можно было бы сгенерировать макросами, но мне было уже лень. (К тому же у меня и так статический анализатор visual studio заблудился в куче макросов и указывает ошибку там, где все нормально компилируется, но об этом позже)
```
В общем виде это выглядит так:
#define cool_print_n(x1, x2, x3, x4, ..., xn, ...)\
cool_hidden_add(x1);\
cool_hidden_add(x2);\
cool_hidden_add(x3);\
cool_hidden_add(x4);\
................... \
cool_hidden_add(xn);\
cool_hidden_print(cool_print_sep, n, x1, x2, x3, x4, ..., xn)
```
Полный код
```
//hide this a big part of code
#if 1
#define cool_print_12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_add(x7); \
cool_hidden_add(x8); \
cool_hidden_add(x9); \
cool_hidden_add(x10); \
cool_hidden_add(x11); \
cool_hidden_add(x12); \
cool_hidden_print(cool_print_sep, 12, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)
#define cool_print_11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_add(x7); \
cool_hidden_add(x8); \
cool_hidden_add(x9); \
cool_hidden_add(x10); \
cool_hidden_add(x11); \
cool_hidden_print(cool_print_sep, 11, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
#define cool_print_10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_add(x7); \
cool_hidden_add(x8); \
cool_hidden_add(x9); \
cool_hidden_add(x10); \
cool_hidden_print(cool_print_sep, 10, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)
#define cool_print_9(x1, x2, x3, x4, x5, x6, x7, x8, x9, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_add(x7); \
cool_hidden_add(x8); \
cool_hidden_add(x9); \
cool_hidden_print(cool_print_sep, 9, x1, x2, x3, x4, x5, x6, x7, x8, x9)
#define cool_print_8(x1, x2, x3, x4, x5, x6, x7, x8, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_add(x7); \
cool_hidden_add(x8); \
cool_hidden_print(cool_print_sep, 8, x1, x2, x3, x4, x5, x6, x7, x8)
#define cool_print_7(x1, x2, x3, x4, x5, x6, x7, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_add(x7); \
cool_hidden_print(cool_print_sep, 7, x1, x2, x3, x4, x5, x6, x7)
#define cool_print_6(x1, x2, x3, x4, x5, x6, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_add(x6); \
cool_hidden_print(cool_print_sep, 6, x1, x2, x3, x4, x5, x6)
#define cool_print_5(x1, x2, x3, x4, x5, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_add(x5); \
cool_hidden_print(cool_print_sep, 5, x1, x2, x3, x4, x5)
#define cool_print_4(x1, x2, x3, x4, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_add(x4); \
cool_hidden_print(cool_print_sep, 4, x1, x2, x3, x4)
#define cool_print_3(x1, x2, x3, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_add(x3); \
cool_hidden_print(cool_print_sep, 3, x1, x2, x3)
#define cool_print_2(x1, x2, ...) \
cool_hidden_add(x1); \
cool_hidden_add(x2); \
cool_hidden_print(cool_print_sep, 2, x1, x2)
#define cool_print_1(x, ...) \
cool_hidden_add(x); \
cool_hidden_print(cool_print_sep, 1, x)
#endif //hide this a big part of code
```
Немного проспойлерил, что аргументов макро функции `cool_print_n` всегда 12, и что после нее идет `...`, но об этом далее
Значение выполнения макроса `PP_NARG(__VA_ARGS__`) не возможно подставить напрямую в выражение `cool_print_##PP_NARG(__VA_ARGS__)`, так как оно развернется в что-то вроде `cool_print_PP_NARG("x", 5, "i", 8,),` что не имеет никакого смысла. Поэтому надо использовать код из макроса, но не возвращать число аргументов, а сразу конкатенировать
код PP\_NARG(\_\_VA\_ARGS\_\_) еще раз
```
#ifndef PP_NARG
/*
*
* The PP_NARG macro returns the number of arguments that have been
* passed to it.
*
* https://groups.google.com/g/comp.std.c/c/d-6Mj5Lko_s
*
*/
#define PP_NARG(...) \
PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) \
PP_ARG_N(__VA_ARGS__)
#define PP_ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63, N, ...) N
#define PP_RSEQ_N() \
63,62,61,60, \
59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40, \
39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20, \
19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0
#endif
```
cool\_print(...) - тот же PP\_NARG, но измененный
```
#define cool_print(...) \
cool_print_(__VA_ARGS__ , COOL_RSEQ_N())
#define cool_print_(...) \
COOL_ARG_N(__VA_ARGS__)
#define COOL_ARG_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
_61,_62,_63, n, ...) \
\
cool_print_##n(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11,_12)
#define COOL_RSEQ_N() \
63,62,61,60,59,58,57,56,55,54,53,52,51,50, \
49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30, \
29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10, \
9,8,7,6,5,4,3,2,1,0
```
Как это работает:
```
1. Условно происходит вызов cool_print("a", 4, "b")
2. Это превращается в cool_print_("a", 4, "b",
63,62,61,60,59,58,57,56,55,54,
53,52,51,50,49,48,47,46,45,44,43,
42,41,40,39,38,37,36,35,34,33,32,
31,30,29,28,27,26,25,24,23,22,21,
20,19,18,17,16,15,14,13,12,11,10,
9,8,7,6,5,4,3,2,1,0
3. Затем из cool_print_ это все передается в макрос COOL_ARG_N,
который способен принять 64 аргумента. В 64-й аргумент, названный n
попадает как раз количество исходных аргументов из-за того, что при
добавление аргументов VA_ARGS перед последовательностью COOL_RSEQ_N
(63..0) часть чисел из этой последовательности вытесняется
4. В конце концов в макросе COOL_ARG_N просиходит конкатенация
cool_print_##n и вызов этого макроса.
В данном примере это cool_print_3
cool_print_3("a", 4, "b",
63,62,61,60,59,58,57,56,55,54,53,52,51,50,
49,48,47,46,45,44,43,42,41,40,39,38,37,36,
35,34,33,32,31,30,29,28,27,26,25,24,23,22,
21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3)
Всего передается 12 аргументов, так как невозможно обрезать лишние.
И это и не надо, так как благодаря "..." в списке аргументов каждого
макроса cool_print_##n они способны проглотить ненужный хвост
Так же можно было бы сократить число аргументов с 64 до 12,
но я посчитал это не очень важным
```
### III. Собственно реализация функции
Отлично, у нас при вызове `cool_print("наши", "аргументы", 10)` происходит заполнение массива `cool_hidden_types` информацией о типе каждого аргумента, а затем вызывается функция реализации `cool_hidden_print(int sep, int n, ...)`! Давайте напишем эту функцию
Небольшое пояснение как в C работать с неопределенным числом аргументов вообщеВ стандартной библиотеке в заголовочном файле есть три макроса, созданных для этих целей. Вот порядок действий:
1. В обьявлении функции последним параметром надо указать `...`
2. `va_list argptr`- это определение указателя `argptr`, который будет в использоваться в дальнейшем
3. `va_start(argptr, n)`- установка указателя на последний определенный аргумент
4. `va_arg(argptr, float)`- возвращает значение слудующего аргумента
5. `va_end(argptr)`- завершает работу с аргументами
Итого просто в Си без всяких этих макросов нам необходимо вычислять какими-нибудь образом тип следующего аргумента, и условии прекращения перебора аргументов
Суть такова: в цикле перебираются все элементы все элементы. В swich'e каждый элемент кастится в void'ый указатель x, а затем вызывается в виде `printf("...%s", *((type) x), sep)`, где `type` - это тип аргумента, а "..." - это специфичный для данного типа формат вывода. Например для `int` это `printf("%d%s", *((type) x), sep)`. Для упрощенной записи приведения типов я использую вспомогательный макрос `#define COOL_CAST(T, x) ((T) (x))`
код cool\_hidden\_print(sep, n, ...)
```
#define COOL_CAST(T, x) ((T) (x))
void cool_hidden_print(char* sep, int n, ...)
{
va_list argptr;
va_start(argptr, n);
void* x;
for (int i = 0; i < n; i++)
{
switch (cool_hidden_types[i])
{
case COOL_HIDDEN_INT:
x = &va_arg(argptr, int);
printf("%d%s", COOL_CAST(int, x), sep);
break;
case COOL_HIDDEN_STRING:
x = &va_arg(argptr, char*);
printf("%s%s", COOL_CAST(char*, x) , sep);
break;
case COOL_HIDDEN_FLOAT:
x = &va_arg(argptr, float);
printf("%.4f%s", COOL_CAST(float, x), sep);
break;
case COOL_HIDDEN_DOUBLE:
x = &va_arg(argptr, double);
printf("%.4f%s", COOL_CAST(double, x), sep);
break;
case COOL_HIDDEN_CHAR:
x = &va_arg(argptr, char);
printf("%c%s", COOL_CAST(char, x), sep);
break;
case COOL_HIDDEN_UINT:
x = &va_arg(argptr, unsigned int);
printf("%.4u%s", COOL_CAST(unsigned int, x), sep);
break;
case COOL_HIDDEN_VOID:
printf("unsupported type%s", sep);
break;
default:
printf("Internal COOL/C/PRINT error line: %d in %s", __LINE__, __FILE__);
break;
}
}
va_end(argptr);
cool_hidden_last = 0;
}
```
*В комментариях подметили, что брать указатель на стек не в коем случае нельзя, так как эта переменная может перестать существовать в любое время. Поэтому тут нужно сразу* `va_arg` *подставлять в* `printf`
### Дополнительные мелочи
После подключения библиотеки можно избавиться от приставки `cool_` с помощью
`#define print cool_print`
Идеально, теперь наша функция `print` полностью работает! В качестве вишенки на торте определим функцию `println`, которая после вывода переводит нас на новую строку
```
#define cool_println(...) \
cool_print(__VA_ARGS__); printf("\n")
#define cool_printlnn() printf("\n")
```
К моему большому сожалению я не смог решить проблему, что при вызове макроса без аргументов происходит синтаксическая ошибка из-за лишней запятой в начале, поэтому без аргументов нужно вызывать `printlnn()`... Я пытался решить это, при определении `cool_print`
```
ни так
#define cool_print(...) cool_print_(__VA_ARGS__ , ## COOL_RSEQ_N()
ни так
#define cool_print(...) cool_print_(__VA_ARGS__ ## , COOL_RSEQ_N()
все равно не работает
```
Как советуют в интернете делать при таком случае ничего не происходит. Видимо эта запись работает только для `,## __VA_ARGS__`, когда `__VA_ARGS__` идет в конце, а не в начале
Возможно можно как-нибудь еще одним вложенным макросом определить, является ли `__VA_ARGS__` пустым. Я нашел в гугле решение только тогда когда максимум 2 аргумента
Еще есть еще некий `__VAR_OPT__`, который делает как раз то, что нужно, но его добавят, как я понял, в следующем стандарте
У меня почему-то сработало один раз `(,)`, но после перезапуска visual stidio стало `__VAR_OPT__` не определено. К тому же в том месте `__VAR_OPT__` ставить нельза, так как макрос будет считать что у нас 63 а не 64 аргумента (что приводила к ошибке вызова не того `cool_print##n` (на единицу меньше). Нужно что-то вроде
```
#define cool_print(...)\
__VAR_OPT__( cool_print_(__VA_ARGS__ , COOL_RSEQ_N()) )
вместо текущего
#define cool_print(...) \
cool_print_(__VA_ARGS__ , COOL_RSEQ_N())
```
Так же в комментариях предложили логичное и изящное решение этой проблемы - добавление произвольного первого аргумента, который мы будем игнорировать в функции реализации
```
#define cool_print(...)\
cool_print_("", __VA_ARGS__)
#define cool_print_(...) \
cool_print__(__VA_ARGS__ , COOL_RSEQ_N())
#define cool_print__(...) \
COOL_ARG_N(__VA_ARGS__)
```
Но это не помогает, и лишние запятые остаются
---
### Проблемы этого метода
* Первое - это конечно же невозможность вызвать функцию без аргументов. К тому же огромным минусом является то, что в случае ошибки генерируется очень невнятное сообщение об ошибке, и я не вижу куда можно вставить его
* Второе - сложность реализации. На C++ аналогичная функция выглядит намного проще. Хотя, имея в качестве шаблона мою функцию `print` будет не так сложно реализовать любую другую
* Третье - статический анализатор. В visual studio у меня подчеркнут красным каждый `print` и `println` со словами *"требуется выражение"*, и висит по одной ошибки (прям красным цветом) на каждый вызов этой функции. Не смотря на это все нормально компилируется. И даже не думаю что на это должно тратиться сильно больше времени, чем на раскрытие variadic templates в c++, хотя я тесты не проводил (а как вообще замерить время компиляции - это отдельный вопрос)
Этот минус самый пожалуй критичный. Если знаете как можно подавить эти ложные ошибки, то подскажите в комментариях
При этом компилируется прекрасноПри этом компилируется прекрасно
---
Полный код данной библиотечки можете найти по ссылке на моем гитхабе: [print.h](https://github.com/light-and-ray/cool/blob/master/cool/c/print.h)
А вот пример использования [c\_example.c](https://github.com/light-and-ray/cool/blob/master/c_example.c)
### Заключение
Удивительно сколько всего можно сделать на чистом Си с очень слабыми шаблонами. Но все же Си предназначен не совсем для этого. Данная статья нужна в большей мере для интереса, хотя может кому-нибудь и поможет в работе. Для удобств написания кода на Си как раз и был создан C++, который позволяет работать с обьектами через класс, а не писать id обьекта первым параметром в методах; он позваляет делать перегрузку функций для тех случаев, когда это необходимо (чтобы не городить функции типа `pow, powi, powf`); упрощает работу с указателями, добавляя ссылки, добавляет пространства имен, чтобы не городить приставок, добавляет контейнеры. Но как итог всего этого - медленная компиляция
Вот пример реализации этой же функции `print` на C++:
print на C++
```
#ifndef COOL_PRINT_HPP
#define COOL_PRINT_HPP
#include
#include
#include
namespace
{
std::ostream\* out = &std::cout;
}
namespace cool
{
inline void setCyrillic()
{
setlocale(LC\_ALL, "Russian");
}
void setPrintOut(std::ostream& os)
{
::out = &os
}
std::ostream\* getPrintOutPtr()
{
return ::out;
}
inline void printFlush()
{
\*::out << std::flush;
}
inline void print()
{
\*::out << ' ';
}
template
inline void print(const Arg& arg)
{
\*::out << std::fixed << std::setprecision(4) << arg << ' ';
}
template
void print(const Arg& arg, const Args&... args)
{
print(arg);
print(args...);
}
////
inline void println()
{
\*::out << '\n';
}
template
inline void println(const Arg& arg)
{
\*::out << std::fixed << std::setprecision(4) << arg << '\n';
}
template
void println(const Args&... args)
{
print(args...);
println();
}
///
void print0() { }
template
inline void print0(const Arg& arg)
{
\*::out << std::fixed << std::setprecision(4) << arg;
}
template
void print0(const Arg& arg, const Args&... args)
{
print0(arg);
print0(args...);
}
#define COOL\_INFO(x) (std::string(#x) + " = " + std::to\_string(x))
}
#endif
```
Более понятно, примерно в 3 раза меньше кода, и реализация более полноценная. Но в то же время стандартный `printf` хоть и выглядит не так изящно, но зато быстрый и практичный. Каждому языку свое место | https://habr.com/ru/post/553636/ | null | ru | null |
# Написание Unit тестов на Swift для проверки асинхронных задач
Сегодня хочу вам быстренько рассказать как тестировать асинхронный код.
Представьте ситуацию, что вам надо загрузить данные из интернета и проверить все ли работает нормально, либо еще какую-нибудь задачу, которая выполняется асинхронно. И как же его протестировать? Что если попробовать так же как и обычный синхронный код?!
```
func testAscynFunction() {
someAsyncFunction()
}
func someAsyncFunction() {
let bg = DispatchQueue.global(qos: .background)
bg.asyncAfter(deadline: .now() + 5) {
XCTAssert(false, "Something went wrong")
}
}
```
Такой тест вернет нам положительный результат, так как метод не будет ждать всех наших асинхронных задач.
Для решения такой проблемы в тестах есть одна замечательная вещь: XCTestExpectation
XCTestExpectation задает то, сколько раз должен выполниться асинхронный метод и только после всех этих выполнений тест окончится и скажет были ли ошибки. Вот пример:
```
class TestAsyncTests: XCTestCase {
// 1) объявляем expectation
var expectation: XCTestExpectation!
func testWithExpectationExample() {
//2) Инициализируем его
expectation = expectation(description: "Testing Async")
//3) задаем то количество раз, сколько должен исполниться метод expectation.fulfill()
expectation.expectedFulfillmentCount = 5
for index in 0...5 {
someAsyncFunctionWithExpectation(at: index)
}
//5) Ожидаем пока исполнится нужное количество expectation.fulfill()
// в противном же случае по истечении 60 сек метод сам выдаст ошибку, так как не дождался
waitForExpectations(timeout: 60) { (error) in
if let error = error {
XCTFail("WaitForExpectationsWithTimeout errored: \(error)")
}
}
}
func someAsyncFunctionWithExpectation(at index: Int) {
let bg = DispatchQueue.global(qos: .background)
bg.asyncAfter(deadline: .now() + 5) { [weak self ] in
XCTAssert(false, "Something went wrong at index \(index)")
//4) Именно его исполнение и подсчитывает expectation.expectedFulfillmentCount
self?.expectation.fulfill()
}
}
}
```
Надеюсь, кому-нибудь будем полезна данная заметка. | https://habr.com/ru/post/439772/ | null | ru | null |
# Плагин для сафари? Запросто!
Сегодня мне наконец таки надоело запускать Firefox каждый раз, когда надо быстро выдернуть из сайта XPath для какого-то элемента (там для этого приятное расширение [XPather](http://xpath.alephzarro.com/)), и я решил таки глянуть, как делать инъекции своего кода в Cocoa-приложения.
Общий принцип прост: рантайм Objective-C позволяет из любого места программы получить указатель на любой класс, и выполнять с ним всяческие махинации. Взяв в качестве справочника [инструкцию по SIMBL](http://www.culater.net/wiki/moin.cgi/CocoaReverseEngineering), я приступил к разработке бандла.
Задача стояла в следующем: добавить в контекстное меню Safari пункт, при активации которого будет делаться выборка XPath для элемента под курсором. С помощью [F-Script Anywhere](http://www.fscript.org/) я буквально за минуту узнал, что за реализацию WebUIDelegate (в том числе и метод webView:contextMenuItemsForElement:defaultMenuItems:) в целевом броузере отвечает класс BrowserWebView. Значит в нем-то и надо сделать замену методов, для чего мы воспользуемся функцией DTRenameSelector:
> `1. BOOL DTRenameSelector(Class \_class, SEL \_oldSelector, SEL \_newSelector)
> 2. {
> 3. Method method = nil;
> 4.
> 5. // First, look for the methods
> 6. method = class\_getInstanceMethod(\_class, \_oldSelector);
> 7. if (method == nil)
> 8. return NO;
> 9.
> 10. method->method\_name = \_newSelector;
> 11. return YES;
> 12. }`
Теперь можно сделать заглушку для нашего «подставного» селектора:
> `1. static NSArray \*webView\_contextMenuItemsForElement\_defaultMenuItems\_(id self, SEL \_cmd,
> 2. id \*sender, NSDictionary \*element, NSArray \*defaultMenuItems)
> 3. {
> 4. return [self
> 5. \_sxp\_orig\_webView:sender
> 6. contextMenuItemsForElement:element
> 7. defaultMenuItems:defaultMenuItems];
> 8. }`
Поскольку это функция С, то первые два аргумента метода (self и \_cmd) надо указать явно. Внутри функция вызывает настоящий селектор, который нам останется переименовать при загрузке. Рантайм обещает нам выполнить метод +load при инициализации любого класса, чем мы и воспользумся:
> `1. static SXPPlugin \*Plugin = nil;
> 2.
> 3. @implementation SXPPlugin
> 4.
> 5. + (SXPPlugin \*)sharedInstance
> 6. {
> 7. @synchronized(self) {
> 8. if(!Plugin)
> 9. Plugin = [[SXPPlugin alloc] init];
> 10. }
> 11. return Plugin;
> 12. }
> 13.
> 14. - (void)swizzle
> 15. {
> 16. Class BrowserWebView = objc\_getClass("BrowserWebView");
> 17. if(BrowserWebView) {
> 18. class\_addMethod(
> 19. BrowserWebView,
> 20. @selector(\_sxp\_fake\_webView:contextMenuItemsForElement:defaultMenuItems:),
> 21. (IMP)webView\_contextMenuItemsForElement\_defaultMenuItems\_,
> 22. "@@:@@@");
> 23.
> 24. DTRenameSelector(
> 25. BrowserWebView,
> 26. @selector(webView:contextMenuItemsForElement:defaultMenuItems:),
> 27. @selector (\_sxp\_orig\_webView:contextMenuItemsForElement:defaultMenuItems:));
> 28. DTRenameSelector(
> 29. BrowserWebView,
> 30. @selector(\_sxp\_fake\_webView:contextMenuItemsForElement:defaultMenuItems:),
> 31. @selector(webView:contextMenuItemsForElement:defaultMenuItems:));
> 32. } else {
> 33. NSLog(@"Failed to get BrowserWebView class");
> 34. }
> 35. }
> 36.
> 37. + (void)load
> 38. {
> 39. SXPPlugin \*plugin = [SXPPlugin sharedInstance];
> 40. [plugin swizzle];
> 41. }
> 42.
> 43. @end`
Что происходит тут? Как только наш бандл будет загружен в Safari, сработает метод +[SXPPlugin load], который, во-первых, создаст первый (и последний) экземпляр себя, а, во-вторых, заменит метод в BrowserWebView, путем добавки фиктивного селектора (\_sxp\_fake), переименования настоящего в (\_sxp\_orig) и последующей установки фиктивного на его место. На самом деле \_sxp\_orig тут указывает не на код внутри Safari, а на еще одно расширение, которое загрузилось раньше — Speed Download. А после SXPPlugin еще подгрузится 1Password и точно так же вклинится в цепочку (если все это надо было бы выгружать, то самое главное — сохранить порядок). Кстати "@@:@@@" у описания селектора означает что селектор возвращает id (первое @) и принимает (id, SEL, id, id, id).
Все, на этом этапе можно собирать бандл, цеплять его в SIMBL или напрямую в InputManagers (но это не так удобно) и смотреть на то, как Safari продолжает работать :)
Продолжаем наращивать функционал, нам нужен свой элемент в этом меню:
> `1. - (id)init
> 2. {
> 3. if( (self = [super init]) ) {
> 4. // init menu
> 5. NSMenu \*m = [[NSMenu alloc] initWithTitle:@"XPath"];
> 6. NSMenuItem \*mi = [[NSMenuItem alloc]
> 7. initWithTitle:@"XPath for node"
> 8. action:@selector(onMenu:)
> 9. keyEquivalent:@""];
> 10. [mi setTarget:self];
> 11. [m addItem:mi];
> 12. [mi release];
> 13. mi = [[NSMenuItem alloc]
> 14. initWithTitle:@"Show browser"
> 15. action:@selector(onMenuBrowser:)
> 16. keyEquivalent:@""];
> 17. [mi setTarget:self];
> 18. [m addItem:mi];
> 19. [mi release];
> 20.
> 21. \_myMenuItem = [[NSMenuItem alloc]
> 22. initWithTitle:@"XPath"
> 23. action:nil
> 24. keyEquivalent:@""];
> 25. [\_myMenuItem setSubmenu:m];
> 26. [m release];
> 27. [\_myMenuItem setEnabled:YES];
> 28. }
> 29. return self;
> 30. }`
В конструкторе мы создаем элемент меню «XPath», у которого есть подменю с элементами «XPath for node» и «Show browser» (оба элемента завязаны действиями на основной класс).
Добавляем меню в описание класса: `NSMenuItem *_myMenuItem;` и делаем доступным через свойство: `@property (readonly) NSMenuItem *myMenuItem;`. Теперь мы можем добратся к этому меню из нашей функции (которая выполняется в контексте BrowserWebView):
> `1. static NSArray \*webView\_contextMenuItemsForElement\_defaultMenuItems\_(id self, SEL \_cmd,
> 2. id \*sender, NSDictionary \*element, NSArray \*defaultMenuItems)
> 3. {
> 4. [SXPPlugin sharedInstance].ctx = element;
> 5. NSArray \*itms = [self
> 6. \_sxp\_orig\_webView:sender
> 7. contextMenuItemsForElement:element
> 8. defaultMenuItems:defaultMenuItems];
> 9. NSMutableArray \*itms2 = [NSMutableArray arrayWithArray:itms];
> 10. [itms2 addObject:[NSMenuItem separatorItem]];
> 11. [itms2 addObject:[[SXPPlugin sharedInstance] myMenuItem]];
> 12. return itms2;
> 13. }`
На четвертую строку пока внимания не обращайте, это будет дальше. А в остальном все очевидно — получаем список текущих элементов меню, добавляем туда разделитель и наше меню, возвращаем выше.
Теперь начинаем делать более интересные вещи. Для начала — перерыв в программировании и несколько минут на Interface Builder, в котором будет создан основной интерфейс:
В верхней строке будет отображатся XPath, в списке снизу — результат выборки. Все необходимое цепляем на основной класс, а в init добавляем подгрузку xib: `[NSBundle loadNibNamed:@"XPathBrowser" owner:self];`.
Теперь, собственно, раскручиваем XPath. Что бы знать, откуда его раскручивать в перехватчике, мы сохраняем словарь «element», именно в нем вся нужная нам информация.
> `1. - (void)onMenu:(id)sender
> 2. {
> 3. [window makeKeyAndOrderFront:self];
> 4. NSString \*xp = [self xpathForNode:[\_ctx objectForKey:@"WebElementDOMNode"]];
> 5. [xpathField setStringValue:xp];
> 6. [self onEvaluate:self];
> 7. }
> 8.
> 9. - (void)onMenuBrowser:(id)sender
> 10. {
> 11. [window makeKeyAndOrderFront:self];
> 12. }`
С ключем WebElementDOMNode связан экземпляр класса DOMNode, по которому пришелся клик. Код xpathForNode: я тут приводить не буду, он достаточно громоздкий (желающие могут посмотреть его в [git](http://git.hackndev.com/?p=farcaller/safarixpath.git;a=blob;f=Classes/SXPPlugin.m;h=437a8abc13fc4bb27fc66210654fb55b49ac3fe7;hb=HEAD)), принцип работы следующий: разматывать родительскую ноду до самого верха. Если у ноды есть аттрибут id, то он добавляется в XPath, если у родительской ноды есть несколько однотипных нод (и у них нет id), то используется индекс ноды.
Но мало XPath посчитать, надо его еще выполнить и получить результат. Для этого можно было бы использовать NSXMLDocument и скармливать ему данные из текущего фрейма, но это не так интересно, как возможность получить ноды у JavaScript:
> `1. - (void)onEvaluate:(id)sender
> 2. {
> 3. NSString \*xp = [xpathField stringValue];
> 4. WebFrame \*frame = [\_ctx objectForKey:@"WebElementFrame"];
> 5. WebView \*view = [frame webView];
> 6. NSString \*js = [NSString
> 7. stringWithFormat:@"document.evaluate(\"%@\", document, null, XPathResult.ANY\_TYPE,null)", xp];
> 8.
> 9. id o = [[view windowScriptObject] evaluateWebScript:js];
> 10. [\_nodes release];
> 11. \_nodes = nil;
> 12. if(![[o class] isEqual:[WebUndefined class]]) {
> 13. NSMutableArray \*nodes = [NSMutableArray array];
> 14. id n = [o iterateNext];
> 15. while(n) {
> 16. [nodes addObject:[self dictForNode:n]];
> 17. n = [o iterateNext];
> 18. }
> 19. \_nodes = [nodes retain];
> 20. };
> 21. [outlineView reloadData];
> 22. }`
Первоначально NSOutlineView получал DOM\* объекты напрямую, но из-за хитросплетений с самостоятельно уходящими нодами (их что ли все надо явно retain-ить?) я перестраиваю дерево в массиве nodes.
Потенциалную инъекцию JS я игнорирую, если у вас есть доступ к броузеру, то выполнить JS на фрейме можно куда как проще. А символ кавычки вроде как в XPath вообще не валиден.
На метод -dictForNode: можно тоже глянуть в git. Его задача — развернуть DOM-дерево в набор структур NSDictionary/NSArray, по которым outline view будет строить список.
Финальный результат:
У меня есть также альтернативный проект, где я пробовал написать то же самое на питоне (правда XPath там выполнял замечательный биндинг к libxml/libxslt — lxml). Но оказалось, что отсутствие полнофункционального броузера все же неудобно.
Исходный код (MIT): <http://git.hackndev.com/?p=farcaller/safarixpath.git;a=summary>
Патчи, багфиксы, идеи приветствуются.
**Update**: спасибо за наводку, переехало в «Разработку под Mac OS X и iPhone»
**Update**: по просьбам трудящихся добавил поддержку выборки по XPath как DOM-дерева, так и исходного HTML-документа. Может косячить с кодировками, там неочевидное преобразование, если упадет в HTML режиме — очень прошу оригинальный файлик на препарирование (с utf8 и cp1251 вроде работает). Кроме того NSXMLDocument что-то ломается на некоторых страницах вообще совсем, проблема исследуется.
Заодно дофиксил DOM-парсер, он теперь поддерживает функции (count, name, etc.). NSXMLDocument такого не умеет.
SIMBL-бандл под последный Safari: <http://farcaller.net/stuff/SafariXPath.bundle-1.1.zip> | https://habr.com/ru/post/65368/ | null | ru | null |
# Микроформаты в Википедии
Речь пойдёт об [hCard](http://ru.wikipedia.org/wiki/HCard) и [hCalendar](http://en.wikipedia.org/wiki/HCalendar) (англ.). Об использовании других микроформатов тоже можно говорить долго, но не в этот раз.
Сам топик частично анонс того, что появилось, частично попытка спросить совета, куда стоит или не стоит дальше двигаться.
Так вот, рассмотрим возможность использования hCard в Википедии на примере [статьи о Джонни Деппе](http://ru.wikipedia.org/wiki/Депп%2C_Джонни).
Если вычистить всё лишнее, то на данный момент нужный нам кусок кода выглядит так (на самом деле, структура несколько отличается, но нас подобная модель устроит; ссылки для упрощения показаны викикодом):
> `Джонни Депп
>
> Johnny Depp
>
>
>
> Имя при рождении:
>
> Джон Кристофер Депп II
>
>
>
> Дата рождения:
>
> [[9 июня]] [[1963]]
>
>
>
> Гражданство:
>
> [[США]]
>
>
>
> Профессия:
>
> [[актёр]]`
Что из такого кода мы можем получить:
1. Полное имя (fn);
2. Другие варианты имени (nickname); — иногда указываются несколько имён в одном поле
3. Дату рождения (bday); — кстати, стоит ли использовать title у тега span? Или задание отдельного невидимого span’а будет идеалогически более верным?
4. Страну проживания (adr -> country-name);
5. Некое описательное примечание (note), характерезующее персону; — над текстом можно ещё подумать, он вполне может быть и «актёр (США, 1984 — по сей день)».
В целом, не так уж и мало. Хотя, разумеется, хотелось бы большего. Например, прописать photo или url, но пока задание атрибутов изображений и ссылок не представляется возможным.
Здесь сразу же вопрос: может кто-нибудь видит способы добавить другую информацию?
Теперь о целях. Зачем вообще это? Есть ли у данной микроформатизации практическая польза?
Все понимают, что hCard с персональной информацией друга/коллеги можно добавить в адресную книгу. Зачем же в адресной книге карточка какого-нибудь актёра, объяснить сложно.
Поэтому разумной причиной микроформатизации мне кажется только планируемая индексация микроформатов поисковиками.
Собственно, что в итоге? Есть возможность способствовать прогрессу. Нет чёткого понимания, что это даёт. И есть некоторые технические трудности.
Стоит ли продолжать?
UPD: Топик немного изменён в соответствии с текущей ситуацией. | https://habr.com/ru/post/28655/ | null | ru | null |
# Валидация Kubernetes YAML на соответствие лучшим практикам и политикам
***Прим. перев.**: С ростом числа YAML-конфигураций для K8s-окружений всё более актуальной становится потребность в их автоматизированной проверке. Автор этого обзора не просто отобрал существующие решения для этой задачи, но и на примере Deployment'а посмотрел, как они работают. Получилось весьма информативно для тех, кому эта тема интересна.*
***TL;DR**: В статье сравниваются шесть статических инструментов проверки и оценки YAML-файлов Kubernetes на соответствие лучшим практикам и требованиям.*
Рабочие нагрузки Kubernetes, как правило, определяются в форме YAML-документов. Одна из проблем с YAML'ом — сложность задания ограничений или взаимоотношений между файлами манифестов.
**Что, если нам надо удостовериться, что все образы, развертываемые в кластере, берутся из доверенного реестра?**
**Как предотвратить отправку в кластер Deployment'ов, для которых не заданы PodDisruptionBudgets?**
Интеграция статического тестирования позволяет выявлять ошибки и нарушения политик еще на стадии разработки. Тем самым повышаются гарантии правильности и безопасности определений ресурсов и повышается вероятность того, что production-нагрузки будут следовать лучшим практикам.
Экосистему статической проверки YAML-файлов Kubernetes можно разделить на следующие категории:
* **API-валидаторы**. Инструменты в этой категории проверяют YAML-манифест на соответствие требованиям API-сервера Kubernetes.
* **Готовые тестеры**. Инструменты из данной категории идут с готовыми тестами на безопасность, соответствие лучшим практикам и т.п.
* **Кастомные валидаторы**. Представители этой категории позволяют создавать пользовательские тесты на различных языках, например, на Rego и Javascript.
В этой статье мы опишем и сравним шесть различных инструментов:
1. kubeval;
2. kube-score;
3. config-lint;
4. copper;
5. conftest;
6. Polaris.
Что ж, давайте приступим!
Проверка Deployment'ов
----------------------
Прежде чем приступить к сравнению инструментов, давайте создадим некоторую основу, на которой будем их тестировать.
Приведенный ниже манифест содержит ряд ошибок и несоответствий лучшим практикам: сколько из них вы сможете найти?
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: http-echo
spec:
replicas: 2
selector:
matchLabels:
app: http-echo
template:
metadata:
labels:
app: http-echo
spec:
containers:
- name: http-echo
image: hashicorp/http-echo
args: ["-text", "hello-world"]
ports:
- containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
name: http-echo
spec:
ports:
- port: 5678
protocol: TCP
targetPort: 5678
selector:
app: http-echo
```
*(`base-valid.yaml`)*
Мы будем использовать этот YAML для сравнения различных инструментов.
> Вышеприведенный манифест `base-valid.yaml` и другие манифесты из этой статьи можно найти в [Git-репозитории](https://github.com/amitsaha/kubernetes-static-checkers-demo).
Манифест описывает веб-приложение, основная задача которого — отвечать сообщением «Hello World» на порт 5678. Его можно развернуть следующей командой:
```
kubectl apply -f hello-world.yaml
```
А так — проверить работу:
```
kubectl port-forward svc/http-echo 8080:5678
```
Теперь перейдите на <http://localhost:8080> и подтвердите, что приложение работает. Но следует ли оно лучшим практикам? **Давайте проверим.**
### 1. Kubeval
В основе [kubeval](https://www.kubeval.com/) лежит идея о том, что любое взаимодействие с Kubernetes происходит через его REST API. Другими словами, можно использовать схему API для проверки того, соответствует ли ей данный YAML. Давайте рассмотрим пример.
[Инструкции по установке](https://www.kubeval.com/installation/) kubeval доступны на сайте проекта.
> На момент написания оригинальной статьи была доступна версия 0.15.0.
После установки давайте «скормим» ему манифест, приведенный выше:
```
$ kubeval base-valid.yaml
PASS - base-valid.yaml contains a valid Deployment (http-echo)
PASS - base-valid.yaml contains a valid Service (http-echo)
```
В случае успеха kubeval завершит работу с exit-кодом 0. Проверить его можно следующим образом:
```
$ echo $?
0
```
Давайте теперь попробуем kubeval с другим манифестом:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: http-echo
spec:
replicas: 2
template:
metadata:
labels:
app: http-echo
spec:
containers:
- name: http-echo
image: hashicorp/http-echo
args: ["-text", "hello-world"]
ports:
- containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
name: http-echo
spec:
ports:
- port: 5678
protocol: TCP
targetPort: 5678
selector:
app: http-echo
```
*(`kubeval-invalid.yaml`)*
Можете на глаз определить проблему? Запускаем:
```
$ kubeval kubeval-invalid.yaml
WARN - kubeval-invalid.yaml contains an invalid Deployment (http-echo) - selector: selector is required
PASS - kubeval-invalid.yaml contains a valid Service (http-echo)
# проверим код возврата
$ echo $?
1
```
Ресурс не проходит проверку.
Deployment'ы, использующие версию API `apps/v1`, должны включать селектор, соответствующий метке pod'а. Манифест выше не включает селектор, поэтому kubeval сообщил об ошибке и вышел с ненулевым кодом.
Интересно, что произойдет, если выполнить `kubectl apply -f` с этим манифестом?
Что ж, давайте попробуем:
```
$ kubectl apply -f kubeval-invalid.yaml
error: error validating "kubeval-invalid.yaml": error validating data: ValidationError(Deployment.spec):
missing required field "selector" in io.k8s.api.apps.v1.DeploymentSpec; if you choose to ignore these errors,
turn validation off with --validate=false
```
Именно та ошибка, о которой предупреждал kubeval. Исправить ее можно, добавив селектор:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: http-echo
spec:
replicas: 2
selector: # !!!
matchLabels: # !!!
app: http-echo # !!!
template:
metadata:
labels:
app: http-echo
spec:
containers:
- name: http-echo
image: hashicorp/http-echo
args: ["-text", "hello-world"]
ports:
- containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
name: http-echo
spec:
ports:
- port: 5678
protocol: TCP
targetPort: 5678
selector:
app: http-echo
```
*(`base-valid.yaml`)*
**Преимущество инструментов вроде kubeval в том, что подобные ошибки можно отлавливать на ранних стадиях цикла развертывания.**
Кроме того, для этих проверок не нужен доступ в кластер: их можно проводить оффлайн.
По умолчанию kubeval проверяет ресурсы на соответствие самой последней схеме Kubernetes API. Однако в большинстве случаев вам может потребоваться провести проверку на соответствие конкретному релизу Kubernetes. Сделать это можно с помощью флага `--kubernetes-version`:
```
$ kubeval --kubernetes-version 1.16.1 base-valid.yaml
```
Обратите внимание, что версия должна указываться в формате `Major.Minor.Patch`.
Чтобы просмотреть список версий, для которых поддерживается проверка, обратитесь к [JSON-схеме на GitHub](https://github.com/instrumenta/kubernetes-json-schema), которую kubeval использует для валидации. Если нужно запустить kubeval оффлайн, скачайте схемы и укажите их локальное местоположение с помощью флага `--schema-location`.
Кроме отдельных YAML-файлов, kubeval также может работать с директориями и stdin.
**Кроме того, Kubeval легко интегрируется в пайплайн CI.** Желающие проводить тесты перед отправкой манифестов в кластер будут рады узнать, что kubeval поддерживает три формата вывода:
1. Обычный текст;
2. JSON;
3. Test Anything Protocol (TAP).
И любой из форматов можно использовать для дальнейшего парсинга вывода, чтобы формировать сводку результатов желаемого вида.
**Один из недостатков kubeval — в настоящее время он не умеет проверять на соответствие Custom Resource Definitions (CRDs).** Однако можно настроить kubeval [игнорировать их](https://kubeval.instrumenta.dev/#crds).
Kubeval — отличный инструмент для проверки и оценки ресурсов; правда, следует подчеркнуть, что успешное прохождение теста не гарантирует, что ресурс соответствует лучшим практикам.
Например, использование тега `latest` в контейнере не соответствует лучшим практикам. Однако kubeval не считает это ошибкой и не сообщает о ней. То есть проверка такого YAML завершится без предупреждений.
Но что, если нужно оценить YAML и выявить нарушения вроде тега `latest`? Как проверить YAML-файл на соответствие лучшим практикам?
### 2. Kube-score
[Kube-score](https://github.com/zegl/kube-score) анализирует манифесты YAML и оценивает их по встроенным тестам. Эти тесты выбираются на основе рекомендаций по безопасности и лучших практик, например:
* Запуск контейнера не под root'ом.
* Наличие проверок здоровья pod'ов.
* Задание request'ов и limit'ов ресурсов.
По итогам теста выдается три результата: *OK*, *WARNING* и *CRITICAL*.
Kube-score можно попробовать онлайн или установить его локально.
> На момент написания оригинальной статьи самой свежей версией kube-score была 1.7.0.
Давайте испытаем его на нашем манифесте `base-valid.yaml`:
```
$ kube-score score base-valid.yaml
apps/v1/Deployment http-echo
[CRITICAL] Container Image Tag
· http-echo -> Image with latest tag
Using a fixed tag is recommended to avoid accidental upgrades
[CRITICAL] Pod NetworkPolicy
· The pod does not have a matching network policy
Create a NetworkPolicy that targets this pod
[CRITICAL] Pod Probes
· Container is missing a readinessProbe
A readinessProbe should be used to indicate when the service is ready to receive traffic.
Without it, the Pod is risking to receive traffic before it has booted. It is also used during
rollouts, and can prevent downtime if a new version of the application is failing.
More information: https://github.com/zegl/kube-score/blob/master/README_PROBES.md
[CRITICAL] Container Security Context
· http-echo -> Container has no configured security context
Set securityContext to run the container in a more secure context.
[CRITICAL] Container Resources
· http-echo -> CPU limit is not set
Resource limits are recommended to avoid resource DDOS. Set resources.limits.cpu
· http-echo -> Memory limit is not set
Resource limits are recommended to avoid resource DDOS. Set resources.limits.memory
· http-echo -> CPU request is not set
Resource requests are recommended to make sure that the application can start and run without
crashing. Set resources.requests.cpu
· http-echo -> Memory request is not set
Resource requests are recommended to make sure that the application can start and run without crashing.
Set resources.requests.memory
[CRITICAL] Deployment has PodDisruptionBudget
· No matching PodDisruptionBudget was found
It is recommended to define a PodDisruptionBudget to avoid unexpected downtime during Kubernetes
maintenance operations, such as when draining a node.
[WARNING] Deployment has host PodAntiAffinity
· Deployment does not have a host podAntiAffinity set
It is recommended to set a podAntiAffinity that stops multiple pods from a deployment from
being scheduled on the same node. This increases availability in case the node becomes unavailable.
```
YAML проходит проверки kubeval, в то время как kube-score указывает на следующие недостатки:
* Не настроены проверки готовности.
* Отсутствуют request'ы и limit'ы на ресурсы CPU и память.
* Не заданы Pod disruption budgets.
* Отсутствуют правила раздельного существования *(anti-affinity)* для максимизации доступности.
* Контейнер выполняется под root'ом.
**Всё это — резонные замечания о недостатках, которые следует устранить, чтобы Deployment стал более эффективным и надежным.**
Команда `kube-score` выводит информацию в удобочитаемой форме с включением всех нарушений типа *WARNING* и *CRITICAL*, что очень помогает во время разработки.
Желающие использовать этот инструмент в рамках пайплайна CI могут включить более сжатый вывод с помощью флага `--output-format ci` (в этом случае выводятся также тесты с результатом *OK*):
```
$ kube-score score base-valid.yaml --output-format ci
[OK] http-echo apps/v1/Deployment
[OK] http-echo apps/v1/Deployment
[CRITICAL] http-echo apps/v1/Deployment: (http-echo) CPU limit is not set
[CRITICAL] http-echo apps/v1/Deployment: (http-echo) Memory limit is not set
[CRITICAL] http-echo apps/v1/Deployment: (http-echo) CPU request is not set
[CRITICAL] http-echo apps/v1/Deployment: (http-echo) Memory request is not set
[CRITICAL] http-echo apps/v1/Deployment: (http-echo) Image with latest tag
[OK] http-echo apps/v1/Deployment
[CRITICAL] http-echo apps/v1/Deployment: The pod does not have a matching network policy
[CRITICAL] http-echo apps/v1/Deployment: Container is missing a readinessProbe
[CRITICAL] http-echo apps/v1/Deployment: (http-echo) Container has no configured security context
[CRITICAL] http-echo apps/v1/Deployment: No matching PodDisruptionBudget was found
[WARNING] http-echo apps/v1/Deployment: Deployment does not have a host podAntiAffinity set
[OK] http-echo v1/Service
[OK] http-echo v1/Service
[OK] http-echo v1/Service
[OK] http-echo v1/Service
```
По аналогии с kubeval, kube-score возвращает ненулевой код выхода при наличии теста, завершившегося ошибкой *CRITICAL*. Также можно включить подобную обработку и для *WARNING*.
Кроме того, имеется возможность проверки ресурсов на соответствие различным версиям API (как и в kubeval). Однако эта информация за'hardcode'на в самом kube-score: выбрать другую версию Kubernetes нельзя. Подобное ограничение может стать большой проблемой, если вы намерены обновить кластер или у вас есть несколько кластеров с различными версиями K8s.
> Обратите внимание, что [уже есть issue](https://github.com/zegl/kube-score/issues/63) с предложением реализовать эту возможность.
Подробнее о kube-score можно узнать на [официальном сайте](https://github.com/zegl/kube-score).
Тесты kube-score — отличный инструмент для внедрения лучших практик, но что, если необходимо внести изменения в тест или добавить собственные правила? Увы, этого не получится сделать.
**Kube-score не расширяем: в него нельзя добавить политики или подстроить их.**
Если требуется писать пользовательские тесты для проверок на соответствие политикам, принятым в компании, можно использовать один из следующих четырех инструментов: config-lint, copper, conftest или polaris.
### 3. Config-lint
Config-lint — это инструмент для валидации конфигурационных файлов формата YAML, JSON, Terraform, CSV и манифестов Kubernetes.
Установить его можно с помощью [инструкций](https://stelligent.github.io/config-lint/#/install) на сайте проекта.
> Текущий релиз по состоянию на момент написания оригинальной статьи — 1.5.0.
**Config-lint не содержит встроенных тестов для проверки манифестов Kubernetes.**
Для проведения любых тестов необходимо создавать соответствующие правила. Они записываются в YAML-файлы, называемые «наборами правил» *(rulesets)*, и имеют следующую структуру:
```
version: 1
description: Rules for Kubernetes spec files
type: Kubernetes
files:
- "*.yaml"
rules:
# список правил
```
*(`rule.yaml`)*
Давайте изучим ее повнимательнее:
* Поле `type` указывает, какой тип конфигурации будет использовать config-lint. Для манифестов K8s это *всегда* `Kubernetes`.
* В поле `files` кроме самих файлов можно указать директорию.
* Поле `rules` предназначено для задания пользовательских тестов.
Допустим, вы хотите убедиться, что образы в Deployment'е всегда скачиваются из доверенного репозитория вроде `my-company.com/myapp:1.0`. Правило для config-lint, осуществляющее подобную проверку, будет выглядеть следующим образом:
```
- id: MY_DEPLOYMENT_IMAGE_TAG
severity: FAILURE
message: Deployment must use a valid image tag
resource: Deployment
assertions:
- every:
key: spec.template.spec.containers
expressions:
- key: image
op: starts-with
value: "my-company.com/"
```
*(`rule-trusted-repo.yaml`)*
Для каждого правила должны быть указаны следующие атрибуты:
* `id` — уникальный идентификатор правила;
* `severity` — может быть *FAILURE*, *WARNING* и *NON\_COMPLIANT*;
* `message` — при нарушении правила отображается содержимое этой строки;
* `resource` — тип ресурса, к которому применяется это правило;
* `assertions` — список условий, которые будут оцениваться в отношении данного ресурса.
В правиле выше `assertion` под названием [`every`](https://stelligent.github.io/config-lint/#/operations?id=every) проверяет, что все контейнеры в Deployment'е (`key: spec.templates.spec.containers`) используют доверенные образы (т.е., начинающиеся с `my-company.com/`).
Полный ruleset выглядит следующим образом:
```
version: 1
description: Rules for Kubernetes spec files
type: Kubernetes
files:
- "*.yaml"
rules:
- id: DEPLOYMENT_IMAGE_REPOSITORY # !!!
severity: FAILURE
message: Deployment must use a valid image repository
resource: Deployment
assertions:
- every:
key: spec.template.spec.containers
expressions:
- key: image
op: starts-with
value: "my-company.com/"
```
*(`ruleset.yaml`)*
Чтобы испытать тест, давайте сохраним его как `check_image_repo.yaml`. Запустим проверку над файлом `base-valid.yaml`:
```
$ config-lint -rules check_image_repo.yaml base-valid.yaml
[
{
"AssertionMessage": "Every expression fails: And expression fails: image does not start with my-company.com/",
"Category": "",
"CreatedAt": "2020-06-04T01:29:25Z",
"Filename": "test-data/base-valid.yaml",
"LineNumber": 0,
"ResourceID": "http-echo",
"ResourceType": "Deployment",
"RuleID": "DEPLOYMENT_IMAGE_REPOSITORY",
"RuleMessage": "Deployment must use a valid image repository",
"Status": "FAILURE"
}
]
```
Проверка завершилась неудачно. Теперь давайте проверим следующий манифест с правильным репозиторием образов:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: http-echo
spec:
replicas: 2
selector:
matchLabels:
app: http-echo
template:
metadata:
labels:
app: http-echo
spec:
containers:
- name: http-echo
image: my-company.com/http-echo:1.0 # !!!
args: ["-text", "hello-world"]
ports:
- containerPort: 5678
```
*(`image-valid-mycompany.yaml`)*
Запускаем тот же самый тест с приведенным выше манифестом. Проблем не обнаружено:
```
$ config-lint -rules check_image_repo.yaml image-valid-mycompany.yaml
[]
```
Config-lint — перспективный фреймворк, позволяющий создавать собственные тесты для проверки YAML-манифестов Kubernetes с помощью YAML DSL.
Но что делать, если требуется более сложная логика и тесты? Разве возможности YAML не слишком малы для этого? Что, если можно было бы создавать тесты на полноценном языке программирования?
### 4. Copper
[Copper V2](https://github.com/cloud66-oss/copper) — это фреймворк для валидации манифестов с помощью пользовательских тестов (аналог config-lint).
Однако от последнего он отличается тем, что не использует YAML для описания тестов. **Вместо этого тесты можно создавать на JavaScript. Copper предоставляет библиотеку с несколькими базовыми инструментами**, помогающими считывать информацию об объектах Kubernetes и сообщать об ошибках.
Последовательность шагов для установки Copper можно найти в [официальной документации](https://github.com/cloud66-oss/copper#installation).
> 2.0.1 — самый свежий релиз этой утилиты на момент написания оригинальной статьи.
Как и config-lint, Copper не имеет встроенных тестов. Давайте напишем один. Пусть он проверяет, что deployment'ы используют контейнерные образы исключительно из доверенных репозиториев вроде `my-company.com`.
Создайте файл `check_image_repo.js` со следующим содержимым:
```
$$.forEach(function($){
if ($.kind === 'Deployment') {
$.spec.template.spec.containers.forEach(function(container) {
var image = new DockerImage(container.image);
if (image.registry.lastIndexOf('my-company.com/') != 0) {
errors.add_error('no_company_repo',"Image " + $.metadata.name + " is not from my-company.com repo", 1)
}
});
}
});
```
Теперь, чтобы проверить наш манифест `base-valid.yaml`, используйте команду `copper validate`:
```
$ copper validate --in=base-valid.yaml --validator=check_image_tag.js
Check no_company_repo failed with severity 1 due to Image http-echo is not from my-company.com repo
Validation failed
```
Понятно, что с помощью copper можно проводить более сложные тесты — например, проверять доменные имена в манифестах Ingress или отвергать pod'ы, работающие в привилегированном режиме.
В Copper встроены различные служебные функции:
* `DockerImage` считывает указанный входной файл и создает объект со следующими атрибутами:
+ `name` — имя образа,
+ `tag` — тег образа,
+ `registry` — реестр образов,
+ `registry_url` — протокол (`https://`) и реестр образов,
+ `fqin` — полное местоположение образа.
* Функция `findByName` помогает найти ресурс по заданному типу (`kind`) и имени (`name`) из входного файла.
* Функция `findByLabels` помогает найти ресурс по указанному типу (`kind`) и меткам (`labels`).
Со всеми доступными служебными функциями можно ознакомиться [здесь](https://github.com/cloud66-oss/copper/tree/master/libjs).
По умолчанию он загружает весь входной YAML-файл в переменную `$$` и делает ее доступной для скриптов (знакомый метод для тех, кто имеет опыт работы с jQuery).
Главный плюс Copper очевиден: вам не нужно осваивать специализированный язык и можно пользоваться различными возможностями JavaScript для создания собственных тестов, такими как интерполяция строк, функции и т.д.
> Следует также отметить, что текущая версия Copper работает с версией ES5 движка JavaScript, а не с ES6.
Подробности доступны на [официальном сайте проекта](https://github.com/cloud66-oss/copper).
Впрочем, если вы не очень любите JavaScript и предпочитаете язык, специально предназначенный для создания запросов и описания политик, вам следует обратить внимание на conftest.
### 5. Conftest
Conftest — это фреймворк для проверки конфигурационных данных. Подходит и для тестирования/верификации манифестов Kubernetes. Тесты описываются с помощью специализированного языка запросов [Rego](https://www.openpolicyagent.org/docs/latest/policy-language/).
Установить conftest можно с помощью [инструкций](https://www.conftest.dev/install/), приведенных на сайте проекта.
> На момент написания оригинальной статьи самой последней доступной версией была 0.18.2.
По аналогии с config-lint и copper, conftest идет без каких-либо встроенных тестов. Давайте попробуем его и напишем собственную политику. Как и в предыдущих примерах, будем проверять, берутся ли образы контейнеров из надежного источника.
Создайте директорию `conftest-checks`, а в ней — файл с именем `check_image_registry.rego` со следующим содержимым:
```
package main
deny[msg] {
input.kind == "Deployment"
image := input.spec.template.spec.containers[_].image
not startswith(image, "my-company.com/")
msg := sprintf("image '%v' doesn't come from my-company.com repository", [image])
}
```
Теперь давайте протестируем `base-valid.yaml` через `conftest`:
```
$ conftest test --policy ./conftest-checks base-valid.yaml
FAIL - base-valid.yaml - image 'hashicorp/http-echo' doesn't come from my-company.com repository
1 tests, 1 passed, 0 warnings, 1 failure
```
Тест ожидаемо провалился, поскольку образы поступают из недоверенного источника.
В файле Rego мы задаем блок `deny`. Его истинность рассматривается как нарушение. Если блоков `deny` несколько, conftest проверяет их независимо друг от друга, и истинность любого из блоков трактуется как нарушение.
Помимо вывода по умолчанию conftest поддерживает JSON, TAP и табличный формат — крайне полезная возможность, если нужно встроить отчеты в существующий пайплайн CI. Задать нужный формат можно с помощью флага `--output`.
Для облегчения отладки политик в conftest имеется флаг `--trace`. Он выводит трассировку того, как conftest парсит указанные файлы политик.
Политики conftest можно публиковать и делиться ими в OCI-реестрах (Open Container Initiative) в виде артефактов.
Команды `push` и `pull` позволяют опубликовать артефакт или извлечь существующий артефакт из удаленного реестра. Давайте попробуем опубликовать созданную нами политику в локальный реестр Docker с помощью `conftest push`.
Запустите локальный реестр Docker:
```
$ docker run -it --rm -p 5000:5000 registry
```
В другом терминале перейдите в созданную ранее директорию `conftest-checks` и выполните следующую команду:
```
$ conftest push 127.0.0.1:5000/amitsaha/opa-bundle-example:latest
```
Если команда прошла успешно, вы увидите сообщение следующего типа:
```
2020/06/10 14:25:43 pushed bundle with digest: sha256:e9765f201364c1a8a182ca637bc88201db3417bacc091e7ef8211f6c2fd2609c
```
Теперь создайте временную директорию и выполните в ней команду `conftest pull`. Она скачает в нее пакет, созданный предыдущей командой:
```
$ cd $(mktemp -d)
$ conftest pull 127.0.0.1:5000/amitsaha/opa-bundle-example:latest
```
Во временной директории появится подкаталог `policy`, содержащий наш файл с политикой:
```
$ tree
.
└── policy
└── check_image_registry.rego
```
Тесты можно проводить напрямую из репозитория:
```
$ conftest test --update 127.0.0.1:5000/amitsaha/opa-bundle-example:latest base-valid.yaml
..
FAIL - base-valid.yaml - image 'hashicorp/http-echo' doesn't come from my-company.com repository
2 tests, 1 passed, 0 warnings, 1 failure
```
К сожалению, DockerHub пока не поддерживается. Поэтому считайте, что вам повезло, если вы используете [Azure Container Registry](https://azure.microsoft.com/en-us/services/container-registry/) (ACR) или свой собственный реестр.
Формат артефактов — такой же, как у [пакетов Open Policy Agent](https://www.openpolicyagent.org/docs/latest/bundles) (OPA), что позволяет использовать conftest для запуска тестов из существующих пакетов OPA.
Больше о совместном использовании политик и других особенностях conftest можно узнать на [официальном сайте проекта](https://www.conftest.dev/).
### 6. Polaris
Последний инструмент, о котором пойдет речь в этой статье, — это [Polaris](https://github.com/FairwindsOps/polaris). *(Его прошлогодний анонс мы [уже переводили](https://habr.com/ru/company/flant/blog/454706/) — **прим. перев.**)*
**Polaris можно установить в кластер или использовать в режиме командной строки. Как вы уже догадались, он позволяет статически анализировать манифесты Kubernetes.**
При работе в режиме командной строки доступны встроенные тесты, охватывающие такие области, как безопасность и лучшие практики (по аналогии с kube-score). Кроме того, можно создавать собственные тесты (как в config-lint, copper и conftest).
Другими словами, Polaris сочетает в себе плюсы обеих категорий инструментов: со встроенными и пользовательскими тестами.
Для установки Polaris в режиме командной строки воспользуйтесь [инструкциями на сайте проекта](https://github.com/FairwindsOps/polaris/blob/master/docs/usage.md#cli).
> На момент написания оригинальной статьи доступна версия 1.0.3.
После завершения установки можно запустить polaris на манифесте `base-valid.yaml` с помощью следующей команды:
```
$ polaris audit --audit-path base-valid.yaml
```
Она выведет строку в формате JSON с подробным описанием выполненных тестов и их результатами. Вывод будет иметь следующую структуру:
```
{
"PolarisOutputVersion": "1.0",
"AuditTime": "0001-01-01T00:00:00Z",
"SourceType": "Path",
"SourceName": "test-data/base-valid.yaml",
"DisplayName": "test-data/base-valid.yaml",
"ClusterInfo": {
"Version": "unknown",
"Nodes": 0,
"Pods": 2,
"Namespaces": 0,
"Controllers": 2
},
"Results": [
/* длинный список */
]
}
```
*Полный вывод доступен [здесь](https://github.com/amitsaha/kubernetes-static-checkers-demo/blob/master/base-valid-polaris-result.json).*
Как и kube-score, Polaris выявляет проблемы в тех областях, в которых манифест не соответствует лучшим практикам:
* Отсутствуют проверки здоровья pod'ов.
* Не указаны теги для контейнерных образов.
* Контейнер выполняется под root'ом.
* Не указаны request'ы и limit'ы для памяти и CPU.
Каждому тесту в зависимости от его результатов присваивается степень критичности: *warning* или *danger*. Чтобы узнать больше об имеющихся встроенных тестах, обратитесь к [документации](https://github.com/FairwindsOps/polaris/blob/master/docs/usage.md#checks).
Если подробности не нужны, можно указать флаг `--format score`. В этом случае Polaris выведет число в диапазоне от 1 до 100 — *score* (т.е. оценку):
```
$ polaris audit --audit-path test-data/base-valid.yaml --format score
68
```
Чем оценка ближе к 100, тем выше степень соответствия. Если проверить exit-код команды `polaris audit`, окажется, что он равен 0.
Заставить `polaris audit` завершать работу с ненулевым кодом можно с помощью двух флагов:
* Флаг `--set-exit-code-below-score` принимает в качестве аргумента пороговое значение в диапазоне 1-100. В этом случае команда завершится с exit-кодом 4, если оценка окажется ниже пороговой. Это очень удобно, когда у вас есть некое пороговое значение (скажем, 75), и вам необходимо получить alert, если оценка опустится ниже.
* Флаг `--set-exit-code-on-danger` приведет к тому, что команда завершится с кодом 3, если один из danger-тестов завершится неудачно.
Теперь давайте попробуем создать пользовательский тест, проверяющий, берется ли образ из доверенного репозитория. Пользовательские тесты задаются в формате YAML, а сам тест описывается с помощью JSON Schema.
Следующий фрагмент YAML-кода описывает новый тест, называемый `checkImageRepo`:
```
checkImageRepo:
successMessage: Image registry is valid
failureMessage: Image registry is not valid
category: Images
target: Container
schema:
'$schema': http://json-schema.org/draft-07/schema
type: object
properties:
image:
type: string
pattern: ^my-company.com/.+$
```
Давайте посмотрим на него поближе:
* `successMessage` — эта строка будет выведена, если тест завершится успешно;
* `failureMessage` — это сообщение будет показано в случае неудачи;
* `category` — указывает на одну из категорий: `Images`, `Health Checks`, `Security`, `Networking` и `Resources`;
* `target`—- определяет, к какому типу объекту (`spec`) применяется тест. Возможные значения: `Container`, `Pod` или `Controller`;
* Сам тест задается в объекте `schema` с помощью JSON schema. В данном тесте ключевое слово `pattern` используется для сравнения источника образа с требуемым.
Для запуска вышеприведенного теста необходимо создать следующую конфигурацию Polaris:
```
checks:
checkImageRepo: danger
customChecks:
checkImageRepo:
successMessage: Image registry is valid
failureMessage: Image registry is not valid
category: Images
target: Container
schema:
'$schema': http://json-schema.org/draft-07/schema
type: object
properties:
image:
type: string
pattern: ^my-company.com/.+$
```
*(`polaris-conf.yaml`)*
Разберем файл:
* В поле `checks` прописываются тесты и их уровень критичности. Поскольку желательно получать предупреждение, когда образ берется из ненадежного источника, ставим здесь уровень `danger`.
* Сам тест `checkImageRepo` затем прописывается в объекте `customChecks`.
Сохраните файл как `custom_check.yaml`. Теперь можно запустить `polaris audit` с YAML-манифестом, требующим проверки.
Протестируем наш манифест `base-valid.yaml`:
```
$ polaris audit --config custom_check.yaml --audit-path base-valid.yaml
```
Команда `polaris audit` выполнила только пользовательский тест, заданный выше, и он не увенчался успехом.
Если исправить образ на `my-company.com/http-echo:1.0`, Polaris завершится успешно. *Манифест с изменениями уже есть в [репозитории](https://github.com/amitsaha/kubernetes-static-checkers-demo), так что вы можете проверить предыдущую команду на манифесте `image-valid-mycompany.yaml`.*
Теперь возникает вопрос: как запускать встроенные тесты совместно с пользовательскими? Легко! Просто надо добавить идентификаторы встроенных тестов в файл конфигурации. В результате он приобретет следующий вид:
```
checks:
cpuRequestsMissing: warning
cpuLimitsMissing: warning
# Other inbuilt checks..
# ..
# custom checks
checkImageRepo: danger # !!!
customChecks:
checkImageRepo: # !!!
successMessage: Image registry is valid
failureMessage: Image registry is not valid
category: Images
target: Container
schema:
'$schema': http://json-schema.org/draft-07/schema
type: object
properties:
image:
type: string
pattern: ^my-company.com/.+$
```
*(`config_with_custom_check.yaml`)*
Пример полного файла конфигурации доступен [здесь](https://github.com/amitsaha/kubernetes-static-checkers-demo/blob/master/polaris-configs/config_with_custom_check.yaml).
Проверить манифест `base-valid.yaml`, используя встроенные и пользовательские тесты, можно с помощью команды:
```
$ polaris audit --config config_with_custom_check.yaml --audit-path base-valid.yaml
```
Polaris дополняет встроенные тесты пользовательскими, тем самым сочетая лучшее из двух миров.
С другой стороны, невозможность использовать более мощные языки, такие как Rego или JavaScript, может стать ограничивающим фактором, препятствующим созданию более изощренных тестов.
Дополнительная информация о Polaris доступна на [сайте проекта](https://github.com/FairwindsOps/polaris).
Резюме
------
Хотя существует множество инструментов для проверки и оценки YAML-файлов Kubernetes, **важно иметь четкое представление о том, как тесты будут проектироваться и выполняться**.
Например, **если взять манифесты Kubernetes, проходящие через пайплайн, kubeval мог бы стать первым шагом в таком пайплайне**. Он бы следил за тем, соответствуют ли определения объектов схеме API Kubernetes.
После завершения подобной проверки можно было бы перейти к более изощренным тестам, таким как соответствие стандартным лучшим практикам и особым политикам. И здесь бы пригодились kube-score и Polaris.
**Тем, у кого сложные требования и есть необходимость детально настраивать тесты, подошли бы copper, config-lint и conftest**.
Conftest и config-lint используют YAML для задания пользовательских тестов, а copper дает доступ к полноценному языку программирования, что делает его довольно привлекательным выбором.
С другой стороны, стоит ли воспользоваться одним из этих инструментов и, следовательно, создавать все тесты вручную, или предпочесть Polaris, и дописать в него только то, что нужно? **Однозначного ответа на этот вопрос нет**.
Таблица ниже содержит краткое описание каждого инструмента:
| Инструмент | Предназначение | Недостатки | Пользовательские тесты |
| --- | --- | --- | --- |
| kubeval | Проверяет YAML-манифесты на соответствие определенной версии схемы API | Не умеет работать с CRD | Нет |
| kube-score | Анализирует манифесты YAML на соответствие лучшим практикам | Нельзя выбрать свою версию API Kubernetes для проверки ресурсов | Нет |
| copper | Общий фреймфорк для создания собственных JavaScript-тестов для YAML-манифестов | Нет встроенных тестов. Скудная документация | Да |
| config-lint | Общий фреймворк для создания тестов на предметно-ориентированном языке, встроенном в YAML. Поддерживает различные форматы конфигураций (например, Terraform) | Нет готовых тестов. Встроенных assertions и функций может оказаться недостаточно | Да |
| conftest | Фреймворк для создания собственных тестов на Rego (специализированном языке запросов). Позволяет делиться политиками через OCI bundles | Нет встроенных тестов. Приходится изучать Rego. Docker Hub не поддерживается при публикации политик | Да |
| Polaris | Анализирует YAML-манифесты на соответствие стандартным лучшим практикам. Позволяет создавать собственные тесты с помощью JSON Schema | Возможностей тестов, основанных на JSON Schema, может не хватить | Да |
Поскольку эти инструменты не зависят от доступа в кластер Kubernetes, их легко устанавливать. Они позволяют фильтровать исходные файлы и обеспечивают быструю обратную связь авторам pull request'ов в проектах.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Представлен Polaris для поддержания кластеров Kubernetes в здоровом состоянии](https://habr.com/ru/company/flant/blog/454706/)»;
* «[Vim с поддержкой YAML для Kubernetes](https://habr.com/ru/company/flant/blog/498808/)»;
* «[7 лучших практик по эксплуатации контейнеров по версии Google](https://habr.com/ru/company/flant/blog/425085/)». | https://habr.com/ru/post/511018/ | null | ru | null |
# TermKit: новая концепция консоли с графическим выводом
Командная оболочка (консоль) — пожалуй, самый архаичный элемент Unix, который остаётся почти в неизменном виде уже тридцать лет. Мы любим его, но кому-то кажется странным сидеть у монитора с миллионами пикселей, ежедневно глядя в консольное окошко образца 70-х годов, когда вся информация на компьютерах была исключительно в текстовом виде.
А что если добавить прямо в консоль отображение графики, видео и других типов данных, а не только текста? Изменить концептуальные принципы работы командной оболочки — это сумасшедшая идея, но ведь никто не запрещает экспериментировать.
Так появился [TermKit](http://github.com/unconed/TermKit) — командная оболочка на движке WebKit. Она способна отображать списки, таблицы, изображения, полосы загрузки и так далее.
На коротком видео можно увидеть консоль в деле. TermKit отображает всё, что и браузер, в том числе контент HTML5.
Как это работает? Архитектура бэкенда и фронтенда TermKit описана [здесь](https://github.com/unconed/TermKit/raw/master/Mockups/Architecture.pdf). Автор программы Стивен Виттенс (Steven Wittens) в своём блоге [объясняет](http://acko.net/blog/on-termkit), что для новой командной оболочки иначе обрабатываются потоки данных в операционной системе. Стандартная схема выглядит так.
При этом каждая программа должна следить, находится ли она интерактивном режиме и какие данные нужно выводить на дисплей, а какие — на стандартный вывод. Смешивание человеческого и компьютерного форматов приводит к множеству ограничений и компромиссов. Чтобы решить эту проблему, Виттенс предлагает разделить человеческий и компьютерный потоки.
В этом случае к каждому классическому Std потоку присоединяется MIME-заголовок: Content-Type, Content-Length и т.д., так что программа сразу знает, какой тип данных она получает. Командная оболочка TermKit содержит ряд обработчиков для обработки каждого типа данных (текст, код, изображения...) и каждый раз выбирает нужный обработчик, после чего генерирует поток для отображения на экране. Таким образом, с помощью команды `cat` вы можете отобразить содержимое файла прямо в оболочке. Эта команда подбирает MIME-заголовок, исходя из имени файла, и передаёт поток следующему процессу.
Для обмена данным используется формат JSON. В случае применения команды по выводу листинга вроде `ls` данным присваивается заголовок `application/json; schema=termkit.files`. Второй параметр указывает, что речь идёт о списке файлов, чтобы выбрать правильный обработчик вместо стандартного JSON.
Кроме типов файлов, TermKit разными способами подсвечивает синтаксис команд, в том числе цитаты, параметры команд, автодополнение, так что сам интерфейс командной оболочки становится красочнее, с графическими элементами.
Автор программы считает, что его разработка вполне соответствует [философии Unix](http://www.faqs.org/docs/artu/ch01s06.html) и надеется, что после соответствующей доработки новая командная оболочка сделает работу в Unix более приятной и интуитивной. Текущая версия TermKit — это жестокая альфа, которая часто падает, так что не рассчитывайте пока работать в ней постоянно, разве что можно полюбоваться и поэкспериментировать.
Конечно, замена традиционному bash выглядит слишком революционно. Но если сделать TermKit как дополнительный режим работы консоли (который можно иногда включать при необходимости), то можно и попробовать. | https://habr.com/ru/post/119550/ | null | ru | null |
# Хочу как у YouTube
Вы когда-нибудь задумывались как устроен ID видео на YouTube?
Возможно, вы уже знаете/нашли ответ, но, как показали обсуждения на Stack Overflow, многие понимают эту технологию неправильно. Если вам интересно изучить что-то новое, добро пожаловать под кат.
Структура ID
------------
Для начала, вспомним что из себя представляет ID видео на YouTube.
ID имеет длину 11 знаков (раньше был длиною 9 знаков).
Состоит из:
* Латинских букв верхнего регистра `[A-Z]` — 26 знаков;
* Латинских букв нижнего регистра `[a-z]` — 26 знаков;
* Цифр `[0-9]` — 10 знаков;
* Тире и нижнее подчеркивание `[-_]` — 2 знака.
Итого 64 знака.
Возможно, вы уже заметили сходство с известным многим Base64 ([RFC 2045](http://www.faqs.org/rfcs/rfc2045.html) раздел 6.8) и это неспроста. Только в стандарте Base64 используются в качестве дополнительных символов плюс и слеш `[+/]`, а не тире и нижнее подчеркивание. Плюс и слеш зарезервированы для использования в URL, и чтобы не было проблем с использование ID в URL, YouTube заменили их более безопасными. Но вы можете использовать свои символы, об этом чуть позже.
Зачем это нужно
---------------
Как это ни странно, но большинство пользователей и разработчиков ошибочно полагают, что такие ID нужны для защиты от грабберов, которые перебором ID могут скачать весь контент сайта.
Поэтому многие всерьез рассматривают такие ID как систему защиты и придумывают сложные алгоритмы хеширования своих инкрементных числовых идентификаторов, пишут библиотеки и продвигают их.
Тем не менее, хочу вас удивить, это не хешированное число, а просто строка. И даже не инкрементная строка, а случайно генерируемое значение по аналогии с [UUID](https://ru.wikipedia.org/wiki/UUID), только заметно компактней.
Это может быть сложно понять тем, кто всегда работал с инкрементными идентификаторами и полагался в этом на БД. У генерируемого идентификатора есть своё назначение, свои преимущества и недостатки перед инкрементным идентификатором.
Генерируемый идентификатор в распределенных системах
----------------------------------------------------
Впервые мы сталкиваемся с генерируемым идентификатором в распределенных системах.
Проблема инкрементных идентификаторов в том, что их создаёт БД. Для сохранения консистентности данных нам необходима одна master БД, которая будет генерировать их. Это повышает нагрузку на нее и затрудняет шардинг.
Некоторые решают эту проблему созданием отдельной БД или сервиса, который занимается исключительно генерацией ID. Но все усложняется, когда нам необходимо разнести сервера географически, подключить регионы.
Решение — вести локальный ID и, при периодической синхронизации с главным сервером, получать от него сквозной ID для всей системы. То есть на региональных серверах у нас будет 2 ID — локальный и сквозной.
Для решения подобных проблем и были придуманы генерируемые идентификаторы такие как UUID. За счёт большого количества комбинаций, мы добиваемся очень маленькой вероятности конфликта идентификаторов. Поэтому, мы можем доверить генерацию глобального ID конкретным инстансам приложения.
DDD и идентификаторы
--------------------
Понятие [Domain-driven design (DDD)](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) хорошо описано в книгах [Эрика Эванса](https://www.google.ru/search?q=isbn+9785845915979) и [Вон Вернона](https://www.google.ru/search?q=isbn+9780321834577). Общая идея DDD сводится к акцентированию внимания на нашей предметной области, стремление к проектированию систем максимально приближенных к реальному миру. Здесь же я хочу рассказать о роли идентификаторов в DDD.
В понятиях DDD подхода нельзя создавать сущности без идентификатора. Инициализируя новый инстанс сущности, идентификатор в ней уже должен быть. То есть, идентификатор создаваемой сущности должен передаваться ей в конструкторе или передаваться ей сервис доменного уровня для получения идентификатора или это должен быть [естественный идентификатор](https://ru.m.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%BB%D0%BB%D0%B5%D0%BA%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BB%D1%8E%D1%87) формируемый самой сущностью.
Необходимость наличия идентификатора может возникнуть если мы захотим бросить доменное событие при создании сущности. Если в событии не будет идентификатора, то у слушателей могут возникнуть проблемы с идентификацией сущности.
В тоже время, в БД используется инкрементный ключ на вставку. Пока мы не запишем данные в БД, мы не сможем получить идентификатор для сущности. Нестыковка получается. Мы не можем создать сущность потому, что у нас нет ID, и мы не можем получить ID из БД потому, что для этого нужно записать сущность в БД.
Есть разные способы решения этой проблемы. Один из них — это случайно генерируемый идентификатор, о котором мы сейчас и говорим.
Недостатки
----------
У генерируемых идентификаторов есть и недостатки. Куда же без них.
Очевидными недостатками являются время генерации идентификатора и вероятность коллизии/конфликта идентификаторов. О вероятности конфликта мы и поговорим в следующем разделе.
Вероятность коллизии ID
-----------------------
Давайте вспомним курс комбинаторики и прикинем количество комбинаций. Нам потребуется формула **Размещение с повторениями**.
### UUID
Для UUID количество комбинаций известно, но мы всё же рассчитаем их для сравнения.
UUID имеет вид `550e8400-e29b-41d4-a716-446655440000`, имеет длину 32 символа за вычетом разделителей (`-`) и состоит из шестнадцатеричных цифр. Что нам дает 1632 или 2128 комбинаций. Это очень много.
У UUID много хорошего и многие им успешно пользуются. Лично мне он не нравится тем, что он ну очень длинный, занимает много места в БД и его затруднительно использовать в URL, хотя некоторых это [не смущает](https://insight.sensiolabs.com/projects/0feb22b7-b64d-462d-b8ba-da49e548be70).
### YouTube ID
А теперь сравним UUID и YouTube видео ID и высчитаем количество комбинаций.
Как мы уже выяснили ранее, ID у YouTube видео состоит из 64 знаков и имеет длину 11 знаков, что нам дает 6411 или 266. Эта цифра конечно заметно меньше чем UUID, но я все равно считаю, что она достаточно большая:
```
73 786 976 294 838 206 464
```
Чтобы хоть как-то осознать это число, представьте, что для получения всех возможных значений идентификаторов длиной 11 символов и создавая идентификатор каждую **наносекунду**, вам потребуется **2 339** лет.
А для того, чтобы получить такое же количество комбинаций как у UUID нам потребуется 2128 = 6421 строка длиною 21 символов, то есть почти в 2 раз короче UUID (37 символов). А если мы возьмём идентификатор такой же длины как у UUID, то мы получим 6437 = 2222 против 2128 у UUID.
Самое главное преимущество такого подхода в том, что мы сами управляем количеством комбинаций путем изменения длины строки.
Не сложно догадаться, что можно сделать идентификатор еще более компактным взяв большее множество знаков. Например, взяв множество из 128 знаков и тогда, идентификатор длиной 18 знаков даст нам 12818 = 2126 комбинаций, что сравнимо с UUID. Но это экономит нам всего несколько символов, а проблем добавляет целую кучу. Увеличивая количество используемых знаков мы сталкиваемся с проблемой использования зарезервированных знаков или с проблемой расхождения кодировки знаков. Поэтому я рекомендую ограничится 64 знаками и играться только с длиной идентификатора.
Для расчета вероятности коллизии воспользуемся формулой из [статьи про UUID на Википедии](https://ru.wikipedia.org/wiki/UUID).
она же
Где
*N* — количество возможных вариантов.
*n* — число сгенерированных ключей.
Возьмем идентификатор длиною 11 знаков, как у YouTube, что даст нам *N = 6411 = 266* и соответственно мы получим:
*p(225) ≈ 7.62\*10-6*
*p(230) ≈ 0.0077*
*p(236) ≈ 0.9999*
Это даёт нам гарантию, что первые несколько миллионов идентификаторов будут уникальными. Не самый плохой результат для столь короткого идентификатора.
Генерация ID
------------
И наконец-то код. Генерируется ID элементарно.
```
class Base64UID
{
private const CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';
public static function generate(int $length): string
{
$uid = '';
while ($length-- > 0) {
$uid .= self::CHARS[random_int(0, 63)];
}
return $uid;
}
}
```
Использование:
```
$uid = Base64UID::generate(11); // iKtwBpOH2Ew
```
DDD
---
А теперь прикинем как это может использоваться в вашей предметной области при использовании DDD подхода. Допустим, мы хотим использовать наш новый ID в сущности *Статья*. Для начала создадим [ValueObject](https://martinfowler.com/bliki/ValueObject.html) для идентификатора статьи, чтобы однозначно идентифицировать принадлежность идентификатора к статье.
```
class ArticleId
{
private $id;
public function __construct(string $id)
{
$this->id = $id;
}
public function id(): string
{
return $this->id;
}
public function __toString(): string
{
return $this->id;
}
}
```
Теперь создадим интерфейс сервиса предметной области для получения ID. Сервис нам нужен для инкапсуляции генерации ID и подмены при необходимости.
```
interface ArticleIdGenerator
{
public function nextIdentity(): ArticleId
}
```
Создадим имплементацию конкретного сервиса генератора ID статьи, использующий наш новый генератор случайных идентификаторов.
```
class Base64ArticleIdGenerator implements ArticleIdGenerator
{
public function nextIdentity(): ArticleId
{
return new ArticleId(Base64UID::generate(11));
}
}
```
Теперь мы можем создать сущность *Статьи* с идентификатором.
```
class Article
{
private $id;
public function __construct(ArticleIdGenerator $generator)
{
$this->id = $generator->nextIdentity();
}
public function id(): ArticleId
{
return $this->id;
}
}
```
Пример использования:
```
$generator = new Base64ArticleIdGenerator();
$article = new Article($generator);
echo $article->id(); // iKtwBpOH2Ew
```
Заключение
----------
Вот таким простым способом мы получили управляемый генерируемый идентификатор с высокой степенью уникальности. Использовать ли генерируемые идентификаторы в своих проектах, решать вам, но их плюсы очевидны.
А вы используете генерируемые идентификаторы? Расскажите в комментариях.
PS: Для тех кому лень писать свое, есть [готовая библиотека](https://github.com/gpslab/base64uid) под PHP 5.3+
PSS: Для расчетов могу порекомендовать [этот](https://web2.0calc.com/) онлайн калькулятор.
Update 02-02-2018
=================
Цель этой статьи показать принцип, преимущества и недостатки генерируемых идентификаторов, а не принизить заслуги UUID или выдвинуть Base64 как лучшее решение.
Update 05-02-2018
=================
Подведем небольшой итог обсуждения в комментариях.
[medvedevia](https://habrahabr.ru/users/medvedevia/) очень верно [подметил](https://habrahabr.ru/post/334994/#comment_10650632), что UUID можно упаковать в base64, за что ему спасибо. Упакованный UUID, на выходе даст нам строку длиною 22 символа, что уже заметно компактней.
```
$uuid = '550e8400-e29b-41d4-a716-446655440000';
$uuid = str_replace('-', '', $uuid);
$uuid = hex2bin($uuid);
$uuid = base64_encode($uuid);
$uuid = str_replace('=', '', $uuid);
// VQ6EAOKbQdSnFkRmVUQAAA
var_dump($uuid);
```
Однако, UUID все ещё длинный и имеет ряд [других недостатков](https://habrahabr.ru/post/334994/#comment_10651978) описанных [sand14](https://habrahabr.ru/users/sand14/), за что ему отдельное спасибо.
В качестве альтернативы можно рассмотреть Snowflake ID, [предложенный](https://habrahabr.ru/post/334994/#comment_10650506) [MikalaiR](https://habrahabr.ru/users/mikalair/). Его успешно используют в Twitter и Instagram.
Snowflake ID представляет из себя 64 битный номер:
* Sign (1 бит) — необходим для определения границ timestamp;
* Timestamp (41 бит) — дата генерации id в микросекундах;
* Generator (10 бит) — id сервиса генерирующего id. Обычно разделяют на 2 — Datacenter ID (5 бит) и Machine ID (5 бит);
* Sequence (12 бит) — инкрементируемое число.
Sequence инкрементируется в тех случаях, когда timestamp генерируемого id, совпадает с timestamp последнего сгенерированного id. Своего рода защита от коллизии на локальном уровне.
Довольно простая схема получается. Плюсами Snowflake ID будут:
* Компактней чем UUID;
* Постоянно растущий id, за счёт использования timestamp;
* Высокая степень защиты от коллизий;
* Не использует генератор случайных чисел
* Конфигурируется вручную, что позволяет генерировать Snowflake id быстрее чем UUID.
А теперь поговорим о недостатках Snowflake:
Первая проблема заключается в том, что приложение, генерирующее id, может работать на одном сервере в разных процессах. В результате мы можем получить коллизию уже в пределах одного сервера. Использовать id процесса при генерации id нельзя по ряду причин.
Решение, либо выносить генерацию id в микросервис, либо заставить мастер процесс, запускающий дочерние процессы с приложением, передавать в дочерние процессы какой-то id, который уже можно будет использовать в алгоритме.
Вторая проблема, это раскрытие информации о инфраструктуре проекта. Количество серверов и количество датацентров.
Третья проблема заключается в использовании timestamp. Время величина бесконечная и загоняя его в рамки мы обрекаем себя на провал.
Как я уже [написал](https://habrahabr.ru/post/334994/#comment_10651234) в комментариях, уже сейчас длина timestamp составляет 41 бит и уже в 2039 длина составит 42 бита. Мы получим переполнение места и генерация id начнется с нуля, то есть мы будем получать id, такие же как и 69 лет назад. А когда длина timestamp составит 43 бита (2248 год) мы получим переполнение Integer.
Twitter может пренебречь этой проблемой, так как он может просто не хранить твиты столько времени, но это применимо не для всех.
Есть так же несколько решений. Как [сказал](https://habrahabr.ru/post/334994/#comment_10651342) [MikalaiR](https://habrahabr.ru/users/mikalair/), можно изменить дату начала отсчёт времени, например на начало эпохи 2000-01-01, что отложит неизбежное ещё на 30 лет.
Более правильное решение [предложил](https://habrahabr.ru/post/334994/#comment_10651522) [devalone](https://habrahabr.ru/users/devalone/). Можно перераспределить биты и увеличить место под timestamp, например до 45 бит, что отложит переломный момент до 3084 года, а переполнение Integer мы получим только в 4199 году.
Пример генерации Snowflake id:
```
$last_time = 0;
$datacenter = 1;
$machine = 1;
$sequence = 0;
$offset = 0;
// можно изменить начало отсчёта даты
//$offset = strtotime('2000-01-01 00:00:00') * 1000;
$time = floor(microtime(true) * 1000) - $offset;
if (!$last_time || $last_time == $time) {
$sequence++;
}
var_dump(sprintf('%b', $time));
$id = 1 << (64 - 1);
$id |= $time << (64 - 1 - 41);
$id |= $datacenter << (64 - 1 - 41 - 5);
$id |= $machine << (64 - 1 - 41 - 5 - 5);
$id |= $sequence << (64 - 1 - 41 - 5 - 5 - 12);
// или в одну строчку
//$id = 1 << 63 | $time << 22 | $datacenter << 17 | $machine << 12 | $sequence;
var_dump(sprintf('%b', $id));
// упаковываем в base64
$id = dechex($id);
$id = hex2bin($id);
$id = base64_encode($id);
$id = str_replace('=', '', $id);
var_dump($id); // oT561auCEAE
```
Казалось бы, вот он YouTube id, но нет. Если вы [сгенерируете](https://3v4l.org/etJkB) несколько id, то вы увидите, что они почти не отличаются, а последние 4 символа вообще константа.
```
oT5+eFUCEAE
oT5+eU8CEAE
oT5+ekkCEAE
```
Для сравнения, id видео загруженных на YouTube с разницей в несколько секунд.
```
fxEbFmSBuIM
et34RK4qLy8
3oypcgF-LJQ
```
[Сравнив](https://3v4l.org/HLItm) идентификаторы в бинарном представлении можно так же убедится, что Snowflake id имеет значительно больше сходств чем YouTube
```
1010000100111110011111100111100001010101000000100001000000000000 // oT5+eFUCEAE
1010000100111110011111100111100101001111000000100001000000000000 // oT5+eU8CEAE
1010000100111110011111100111101001001001000000100001000000000000 // oT5+ekkCEAE
1010000100111110011111100111100001000001000000100001000000000000 // сумма
```
```
0111111100010001000110110001011001100100100000011011100010000011 // fxEbFmSBuIM
0111101011011101111110000100010010101110001010100010111100101111 // et34RK4qLy8
0000000011011110100011001010100101110010000000010100101100100101 // 3oypcgF-LJQ
0000000000010000000010000000000000100000000000000000100000000001 // сумма
```
Я все ещё склонен думать, что YouTube использует случайно или псевдослучайно сгенерированные значения.
Update 21-02-2018
=================
Описанный в статье метод генерации идентификатора приведен как пример. Не акцентируйте внимание на конкретном примере.
Для сравнения хочу привести несколько дополнительных примеров генерации идентификатора, чтобы было с чем сравнивать. Все они используют [генераторы криптографически безопасных случайных чисел](http://fi2.php.net/manual/ru/ref.csprng.php).
### Генерация случайных знаков
```
$length = 11;
$chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';
$uid = '';
while ($length-- > 0) {
$uid .= $chars[random_int(0, 63)];
}
var_dump($uid); // 4rnQMtJ4HRw
```
**Плюсы**
* Управляемость длиной идентификатора
* Нет ограничений в длине идентификатора
* Возможно изменить самими символами в наборе символов
* Возможно изменить количество символов в наборе
* За счёт нескольких вызовов `random_int()` уменьшается вероятность локальных коллизий
**Минусы**
* Несколько вызовов `random_int()` негативно сказывается на производительности
### Побайтовая генерация ID
```
$length = 64;
$uid = '';
while ($length-- > 0) {
$uid .= random_int(0, 1);
}
$uid = bindec($uid);
$uid = dechex($uid);
$uid = hex2bin($uid);
$uid = base64_encode($uid);
$uid = str_replace(['=', '+', '/'], ['', '-', '_'], $uid);
var_dump($uid); // tDiGk9YyWAA
```
**Плюсы**
* Управляемость длиной идентификатора
* Более частый вызов `random_int()`, по сравнению с предыдущим вариантом, уменьшает вероятность локальных коллизий.
**Минусы**
* Теряется возможность изменить сами символы в наборе символов
* Теряется возможность изменить количество символов в наборе
* Идентификатор ограничен 64 битами
* Несколько вызовов `random_int()` негативно сказывается на производительности
### Случайные числа и временная метка
```
$time = floor(microtime(true) * 1000);
$prefix = random_int(0, 0b111111111);
$suffix = random_int(0, 0b111111111);
$uid = 1 << (9 + 45 + 9);
$uid |= $prefix << (9 + 45);
$uid |= $time << 9;
$uid |= $suffix;
$uid = dechex($uid);
$uid = hex2bin($uid);
$uid = base64_encode($uid);
$uid = str_replace(['=', '+', '/'], ['', '-', '_'], $uid);
var_dump($uid); // vELDchIFvk0
```
**Плюсы**
* Уменьшается вероятность коллизии за счет использования временной метки
**Минусы**
* Теряется возможность изменить сами символы в наборе символов
* Теряется возможность изменить количество символов в наборе
* Идентификатор ограничен 64 битами
* Затруднительно управлять длиной идентификатора
* Как и в случае с *Snowflake*, идентификаторы получаются [схожими](https://3v4l.org/EEADG)
### Случайные числа и плавающая временная метка
```
$time = floor(microtime(true) * 1000);
$prefix_length = random_int(1, 18);
$prefix = random_int(0, bindec(str_repeat('1', $prefix_length)));
$suffix_length = 18 - $prefix_length;
$suffix = random_int(0, bindec(str_repeat('1', $suffix_length)));
$uid = 1 << ($suffix_length + 45 + $prefix_length);
$uid |= $prefix << ($suffix_length + 45);
$uid |= $time << $suffix_length;
$uid |= $suffix;
$uid = dechex($uid);
$uid = hex2bin($uid);
$uid = base64_encode($uid);
$uid = str_replace(['=', '+', '/'], ['', '-', '_'], $uid);
var_dump($uid); // 4WG5MmC3SQo
```
**Плюсы**
* Идентификаторы получаются менее [схожими](https://3v4l.org/W3no0), чем в предыдущем примере, даже при использовании одной временной метки.
**Минусы**
* Теряется возможность изменить сами символы в наборе символов
* Теряется возможность изменить количество символов в наборе
* Идентификатор ограничен 64 битами
* Затруднительно управлять длиной идентификатора
* Из-за непостоянной позиции временной метки, коллизия все же возможна
### Генерация случайных байт
```
$uid = random_bytes(8);
$uid = base64_encode($uid);
$uid = str_replace(['=', '+', '/'], ['', '-', '_'], $uid);
var_dump($uid); // BOjs1VmavxI
```
**Плюсы**
* Наиболее короткое и простое решение из всех
* Нет ограничений в длине идентификатора
**Минусы**
* Теряется возможность изменить сами символы в наборе символов
* Теряется возможность изменить количество символов в наборе
* Усложнено управление длиной конечного идентификатора
PS: Поправьте меня в комментариях если я что-то упустил. | https://habr.com/ru/post/334994/ | null | ru | null |
# Testing a Monitor using DE10-Lite
Introduction
------------
In order not to buy a defective monitor, it is highly recommended to check it before buying. DE10-Lite is great for this because of a compact size and the presence of a VGA connector.
Hardware and software
---------------------
* DE10-Lite board (based on Altera's MAX 10 FPGA)
* Quartus Prime Lite Edition
* Verilog HDL
Some words about VGA and clock division
---------------------------------------
**VGA** (Video Graphics Array) is an analogue interface used to display visual data on computer monitors. Till a few years back, it was the most used display interface. It is now being slowly replaced by HDMI.
To display an image using VGA, we must follow its specification: **timings** and **clock rate**. In this paragraph I will consider only the clock rate. Information about the timing is provided in the next block.
VGA needs **25.175 MHz** clock rate, but the DE10-Lite can only provide 10 MHz or 50 MHz clock. Therefore, we must somehow obtain **25.175 MHz**by dividing or multiplying the existing clocks. In this project, I will divide 50 MHz clock.
To obtain the required clock, I used **Altera Phase-Locked Loop (Altera PLL)**from the IP catalogue in Quartus Prime.
Displaying an image on the screen through the VGA protocol
----------------------------------------------------------
In this project I will use 640x480 at 60 Hz.
Therefore, we have to follow the following timings:
Code of the VGA controller
```
module VGA(
input clock25MHz,
output vsync,
output hsync,
output canDisplayImage,
output reg[9:0] x,
output reg[9:0] y
);
reg [9:0] xCounter;
reg [9:0] yCounter;
always @(posedge clock25MHz) // horizontal counter
begin
if (xCounter < 799)
xCounter <= xCounter + 1;
else
xCounter <= 0;
end
always @ (posedge clock25MHz) // vertical counter
begin
if (xCounter == 799) // only counts up 1 count after horizontal finishes 800 counts
begin
if (yCounter < 525) // vertical counter (including off-screen vertical 45 pixels) total of 525 pixels
yCounter <= yCounter + 1;
else
yCounter <= 0;
end
end
always @ (posedge clock25MHz)
begin
if(xCounter>=144 && xCounter<784) x=xCounter-144;
else x = 0;
if(yCounter>=35 && yCounter < 515) y = yCounter-35;
else y = 0;
end
assign hsync = (xCounter >= 0 && xCounter < 96) ? 1:0; // hsync high for 96 counts
assign vsync = (yCounter >= 0 && yCounter < 2) ? 1:0; // vsync high for 2 counts
assign canDisplayImage = ((xCounter > 144) && (xCounter <= 783))
&& ((yCounter > 35) && (yCounter <= 514));
endmodule
```
Now, when the board can display any image on a screen, it's time to draw something.
Using x and y, we can control each pixel. For example, the part of the code that draws a white 100x100 rectangle:
Drawing a 100x100 square
```
module tvPattern(
input [9:0] x,
input [9:0] y,
output reg [3:0] red,
output reg [3:0] green,
output reg [3:0] blue);
always @(x||y)
begin
if(x>=0 && x<100 && y>=0 && y<100))
begin
red <= 4'hF;
green <= 4'hF;
blue <= 4'hF;
end
end
endmodule
```
Animated test
-------------
I decided to add an animated test (e.g. bouncing square).
The variables for squareX and squareY are created.
Then, in sequential logic block `always @(posedge clock25MHz`), I am checking for collisions with screen borders and if collision - change the direction of the square.
Moving square
```
module bouncingSquare(
input clock25MHz,
input [9:0] x,
input [9:0] y,
output [3:0] red,
output [3:0] green,
output [3:0] blue
);
localparam SQUARE_SIZE = 20;
// Position of a square
reg [9:0] squareX =100;
reg [9:0] squareY = 100;
// Vertical and horizontal speeds
// 1 - positive direction, 0 - negative direction
reg vSpeed = 1;
reg hSpeed = 1;
// Checking for collisions
wire topCollision = (squareY-SQUARE_SIZE==0);
wire bottomCollision = (squareY+SQUARE_SIZE==479);
wire leftCollision = (squareX-SQUARE_SIZE ==0);
wire rightCollision = (squareX+SQUARE_SIZE == 639);
always @(posedge clock25MHz)
begin
if(topCollision) vSpeed<=1;
if(bottomCollision) vSpeed<=0;
if(leftCollision) hSpeed<=1;
if(rightCollision) hSpeed<=0;
counter <= counter + 1;
squareX <= squareX + (hSpeed==1? 1 : -1);
squareY <= squareY + (vSpeed==1? 1 : -1);
end
// Drawing a square
wire square = (squareX-SQUARE_SIZE<=x && squareX+SQUARE_SIZE>=x) && (squareY-SQUARE_SIZE<=y && squareY+SQUARE_SIZE>=y);
assign red = (square) ? 4'hF: 0;
assign green = (square) ? 4'hF: 0;
assign blue = (square) ? 4'hF: 0;
endmodule
```
The code works fine, but the square moves too fast. Thus, we must slow it down somehow. To do this, I created another reg and implemented in every clock's rising edge. Then, when the value of this reg becomes equal to some constant (**SPEED\_CONSTANT**), I am changing the values of the squareX and squareY.
Slow moving square
```
module bouncingSquare(
input clock25MHz,
input [9:0] x,
input [9:0] y,
output [3:0] red,
output [3:0] green,
output [3:0] blue
);
localparam SPEED_CONSTANT = 100000;
localparam SQUARE_SIZE = 20;
// Position of a square
reg [9:0] squareX =100;
reg [9:0] squareY = 100;
// Counter for slowing down the animation
reg [30:0] counter;
// Vertical and horizontal speeds
// 1 - positive direction, 0 - negative direction
reg vSpeed = 1;
reg hSpeed = 1;
// Checking for collisions
wire topCollision = (squareY-SQUARE_SIZE==0);
wire bottomCollision = (squareY+SQUARE_SIZE==479);
wire leftCollision = (squareX-SQUARE_SIZE ==0);
wire rightCollision = (squareX+SQUARE_SIZE == 639);
always @(posedge clock25MHz)
begin
if(topCollision) vSpeed<=1;
if(bottomCollision) vSpeed<=0;
if(leftCollision) hSpeed<=1;
if(rightCollision) hSpeed<=0;
counter <= counter + 1;
if (counter == SPEED_CONSTANT)
begin
squareX <= squareX + (hSpeed==1? 1 : -1);
squareY <= squareY + (vSpeed==1? 1 : -1);
end
if(counter>SPEED_CONSTANT) counter<=0;
end
// Drawing a square
wire square = (squareX-SQUARE_SIZE<=x && squareX+SQUARE_SIZE>=x) && (squareY-SQUARE_SIZE<=y && squareY+SQUARE_SIZE>=y);
assign red = (square) ? 4'hF: 0;
assign green = (square) ? 4'hF: 0;
assign blue = (square) ? 4'hF: 0;
endmodule
```
The video can be found here: [link](https://drive.google.com/file/d/1qqi2z0zGhGgQ0X3iOVaQpvcq5kk1JpeR/view?usp=share_link)
Switching between different test modes
--------------------------------------
I used both buttons and switches to display different tests.
Everything worked correctly with switches, however there was a problem with buttons - the tests either changed randomly either didn't change at all. This problem is called Button Bouncing.
Button Bounce happens when you push a mechanical button. When a button is being pushed, it tends to literally bounce upon the metal contact, which connects the circuit.
This effect is shown in the following picture:
To overcome this problem, I used the debouncing technique. You can read more information about it [here](https://www.fpga4student.com/2017/04/simple-debouncing-verilog-code-for.html).
Conclusion
----------
I have described the key stages of creating a monitor tester using an FPGA board and Verilog HDL. Areas of the project's application: business (for example, in a stand for checking monitors in electronics store) and personal use.
This work has been implemented in the scope of «Computer Architecture» course in the [Innopolis University](https://innopolis.university/en/).
Some examples
-------------
ImagesReferences
----------
1. [Project on the GitHub](https://github.com/nai1ka/MonitorTester_FPGA)
2. [Button debouncing](https://www.fpga4student.com/2017/04/simple-debouncing-verilog-code-for.html)
3. [VGA explained](https://projectf.io/posts/fpga-graphics/)
4. [Video example](https://drive.google.com/file/d/1qqi2z0zGhGgQ0X3iOVaQpvcq5kk1JpeR/view?usp=share_link) | https://habr.com/ru/post/707224/ | null | en | null |
# Поиск пути среди круглых препятствий
Навигация по лесу
-----------------
Алгоритм поиска пути A\* — это мощный инструмент для быстрой генерации оптимальных путей. Обычно A\* демонстрируют при навигации по картам из сеток, но он может использоваться не только для сеток! Он может работать с любыми графами. Можно использовать A\* для поиска пути в мире круглых препятствий.
*В [оригинале статьи](https://redblobgames.github.io/circular-obstacle-pathfinding/) все изображения интерактивны.*
Как один алгоритм решает обе эти задачи? Давайте начнём с краткого описания того, как работает A\*.
Алгоритм A\*
------------
Алгоритм A\* находит *оптимальный путь* из начальной в конечную точку, избегая по дороге препятствия. Он реализует это, постепенно расширяя множество *частичных путей*. Каждый частичный путь — это серия шагов от начальной точки до какой-то промежуточной точки на дороге к цели. В процессе работы A\* частичные пути становятся всё ближе конечной точке. Алгоритм прекращает работу тогда, когда находит полный путь, который лучше оставшихся вариантов, и это можно доказать.
На каждом шаге алгоритма A\* оценивает множество частичных путей и генерирует новые пути, расширяя наиболее многообещающий путь из множества. Для этого A\* хранит частичные пути в очереди с приоритетами, отсортированном по *приблизительной длине* — истинной измеренной длине пути плюс примерное оставшееся расстояние до цели. Это приближение должно быть *недооценкой*; то есть приближение может быть меньше истинного расстояния, но не больше него. В большинстве задач поиска пути хорошей преуменьшенной оценкой является геометрическое расстояние по прямой от конца частичного пути до конечной точки. Истинный наилучший путь до цели от конца частичного пути может быть длиннее, чем это расстояние по прямой, но не может быть короче.
Когда A\* начинает работу, очередь с приоритетами содержит всего один частичный путь: начальную точку. Алгоритм многократно удаляет из очереди с приоритетами наиболее многообещающий путь, то есть путь с наименьшей приблизительной длиной. Если этот путь завершается в конечной точке, то алгоритм выполнил задачу — очередь с приоритетами гарантирует, что никакой другой путь не может быть лучше. В противном случае, начиная с конца частичного пути, который он удалил из очереди, A\* генерирует ещё несколько новых путей, делая единичные шаги во всех возможных направлениях. Он помещает эти новые пути снова в очередь с приоритетами и начинает процесс заново.
Граф
----
A\* работает с *графом*: набором *узлов*, соединённых *рёбрами*. В мире на основе сетки каждый узел обозначает отдельную ячейку сетки, а каждое ребро — соединение с соседними ячейками к северу, югу, востоку или западу.
Прежде чем можно будет запустить A\* для леса из круглых препятствий, нам нужно преобразовать его в граф. Все пути через лес состоят из перемежающихся отрезков прямых и дуг. Они являются рёбрами графа пути. Конечные точки этих рёбер становятся узлами.
Путь через граф — это серия узлов, соединённых рёбрами:
И отрезки, и дуги являются рёбрами графа. Мы назовём отрезки *рёбрами перехода*, потому что путь использует их для перехода между препятствиями. Дуги мы назовём *огибающими рёбрами*, потому что их задача в пути — огибание сторон препятствий.
Далее мы исследуем простой способ преобразования леса с препятствиями в граф: сгенерируем все возможные рёбра перехода и огибающие рёбра.
### Генерация рёбер перехода
Рёбра перехода между парой кругов — это отрезки прямых, которые едва касаются обоих кругов; такие отрезки называются *касательными к двум точкам*, и для каждой пары кругов существует четыре таких касательных. Касательные к двум точкам, пересекающиеся между кругами, называются *внутренними касательными к двум точкам*, а проходящие снаружи — *внешними*.
#### Внутренние касательные к двум точкам
В прошлом поиск внутренних касательных был важен для вычисления длины ремня, соединяющего два шкива разного размера, поэтому задача создания внутренних касательных к двум точкам называется *задачей ремней*. Для нахождения внутренних касательных к двум точкам нужно вычислить угол  на показанном ниже чертеже.
Как оказалось, для кругов с центрами  и  и радиусами  и , центры которых находятся на расстоянии :
Определив , мы можем легко найти точки , ,  и .
#### Внешние касательные к двум точкам
При построении внешних касательных (это *задача шкивов*) используется похожая техника.
Для внешних касательных мы можем найти  следующим образом:
Не важно, какой из кругов больше, A или B, но как видно из рисунка,  откладывается на стороне A, ближней к B, но на стороне B, дальней от A.
#### Линия видимости
Взятые вместе, внутренние и внешние касательные к двум точкам между двумя кругами образуют рёбра перехода между кругами. Но что если одно или несколько рёбер перехода закрывает третий круг?
Если ребро перехода перекрыто другим кругом, то нам нужно отбросить это ребро. Для распознавания такого случая мы используем простое вычисление *расстояния между точкой и прямой*. Если расстояние от ребра перехода до центра препятствия меньше радиуса препятствия, то препятствие перекрывает ребро перехода, поэтому мы должны его отбросить.
Для вычисления расстояния от точки  до отрезка прямой  воспользуемся [следующим способом](http://paulbourke.net/geometry/pointlineplane/):
Во-первых, вычислим  — часть расстояния вдоль отрезка , в которой перпендикуляр пересекает точку :
Затем вычисляем позицию  на :
Расстояние  от  до отрезка  — это расстояние от  до :
Так как , круг перекрывает линию видимости из  в , и ребро необходимо отбросить. Если , то линия видимости из  в  существует, и ребро следует оставить.
### Генерация огибающих рёбер
Узлы графа соединяют ребро перехода с огибающим ребром. В предыдущих разделах мы сгенерировали рёбра перехода. Для генерации огибающих рёбер мы начнём с конечной точки ребра перехода, обойдём круг и закончим в конечной точке другого ребра перехода.
Для нахождения множества огибающих рёбер круга сначала найдём все касающиеся круга рёбра перехода. Затем создадим огибающие рёбра между всеми конечными точками рёбер перехода на круге.
Соединяем всё вместе
--------------------
Сгенерировав рёбра перехода, огибающие рёбра и узлы, а затем отбросив все перекрытые рёбра перехода, мы можем создать граф и запустить поиск пути с помощью алгоритма A\*.
Усовершенствования
------------------
Рассмотренная нами процедура генерации графа достаточно хорошо работает для объяснения алгоритма, но во многих аспектах может быть улучшена. Такие улучшения позволят алгоритму тратить меньше ресурсов процессора и памяти, а также обрабатывать больше ситуаций. Давайте рассмотрим некоторые из ситуаций.
### Препятствия, которые касаются друг друга
Вы могли заметить, что в показанных выше примерах круглые препятствия не накладывались друг на друга и даже не касались. Если допустить, что круги могут касаться друг друга, то это немного усложняет задачу поиска пути
#### Касательные к двум точкам
Вспомним, что касательные к двум точкам можно найти с помощью этой формулы для внутренних касательных:
и формулы для внешних касательных:
Когда два круга касаются друг друга или пересекаются, то между ними нет внутренних касательных. В таком случае  больше единицы. Так как значение арккосинуса за пределами области определения ![$[-1, 1]$](https://habrastorage.org/getpro/habr/formulas/18f/000/34f/18f00034fa5ce903aae2db2027678177.svg) не определено, перед нахождением арккосинуса важно выполнять проверку пересечения кругов.
Аналогично этому, если один круг полностью расположен в другом, то между ними не будет внешних касательных. В таком случае  находится вне интервала ![$[-1, 1]$](https://habrastorage.org/getpro/habr/formulas/18f/000/34f/18f00034fa5ce903aae2db2027678177.svg), то есть не имеет арккосинуса.
#### Линия видимости ребра перехода
Если мы допускаем возможность касания или пересечения препятствий, то в вычислениях линии видимости рёбер перехода возникают новые случаи.
Вспомним вычисление  — части расстояния вдоль ребра перехода, на котором перпендикуляр к точке касается ребра. Если касание кругов не допускается, то значение  находится вне интервала ![$[0,1]$](https://habrastorage.org/getpro/habr/formulas/a5d/538/f83/a5d538f83bd73f9d1c9e8338db9a398a.svg), то есть круг не может касаться ребра, потому что для этого ему нужно было бы касаться одной из конечных точек ребра. Это невозможно, потому что конечные точки ребра уже являются касательными к другим кругам.
Однако если мы допустим возможность наложения кругов, то значения  вне интервала ![$[0,1]$](https://habrastorage.org/getpro/habr/formulas/a5d/538/f83/a5d538f83bd73f9d1c9e8338db9a398a.svg) смогут перекрывать линию видимости вдоль ребра. Это соответствует случаям, когда круг находится за концом ребра перехода, но перекрывает конечную точку или касается её. Чтобы отслеживать такие случаи математически, мы *ограничим*  интервалом ![$[0,1]$](https://habrastorage.org/getpro/habr/formulas/a5d/538/f83/a5d538f83bd73f9d1c9e8338db9a398a.svg):
#### Линия видимости огибающего ребра
Когда препятствия могут касаться друг друга или пересекаться, огибающие рёбра могут быть заблокированы препятствиями так же, как и рёбра перехода. Рассмотрим огибающее ребро с рисунка ниже. Если огибающего ребра касается другое препятствие, то ребро блокируется и должно быть отброшено.
Чтобы определить, заблокировано ли огибающее ребро другим препятствием, воспользуемся [следующим методом](http://paulbourke.net/geometry/circlesphere/) для определения точек, в которых пересекаются два круга. Если круги имеют центры в точках  и  и радиусы  и , где  — расстояние между  и , то нам для начала нужно проверить несколько случаев. Если круги не касаются друг друга (то есть ),
находятся один внутри другого () или совпадают ( и ), то круги не могут влиять на огибающие рёбра друг друга.
Если не одно из этих условий не соблюдается, то круги пересекаются в двух точках; если круги касаются друг друга, то эти две точки совпадают. Рассмотрим *радикальную ось*, соединяющую точки пересечения; она перпендикулярна прямой, соединяющей  и , в какой-то точке . Мы можем вычислить расстояние  от  до  следующим образом:
Найдя , мы можем найти угол :
Если  равен нулю, то круги касаются в точке . В противном случае существует две точки пересечения, соответствующие положительному и отрицательному .
Далее определим, находится ли какая-нибудь из точек пересечения между начальной и конечной точками огибающего ребра. Если это так, то препятствие блокирует огибающее ребро, и мы должны отбросить это ребро. Заметьте, что нам не нужно рассматривать случай, когда огибающее ребро целиком находится внутри препятствия, потому что отсечение по линии видимости для рёбер перехода уже отбросило это ребро.
После внесения изменений в вычисление касательных к двум точкам и линии видимости для рёбер перехода и огибающих рёбер всё работает верно.
### Переменный радиус актора и расширение Минковского
При вычислении навигации круглого объекта в мире круглых препятствий можно учесть наблюдения, упрощающих решение задачи. Во-первых, можно упростить работу, заметив, что движение круга радиусом *r* по лесу аналогично движению точки через тот же лес с единственным изменением: радиус каждого препятствия увеличивается на *r*. Это чрезвычайно простой случай применения *суммы Минковского*. Если радиус актора больше нуля, то перед началом мы просто увеличиваем размер препятствий.
### Отложенная генерация рёбер
В общем случае граф для леса из  препятствий содержит  рёбер перехода, но так как каждое из них нужно проверить на линию видимости с  препятствиями, то общее время генерации графа равно . Кроме того, пары рёбер перехода могут приводить к созданию огибающих рёбер, и каждое из них нужно проверить с каждым препятствием на линию видимости. Однако из-за высокой эффективности алгоритма A\* обычно для создания оптимального пути он просматривает только часть этого большого графа.
Мы можем сэкономить время, генерируя небольшие части графа на лету в процессе выполнения алгоритма A\*, а не делая всю работу заранее. Если A\* найдёт путь быстро, то мы сгенерируем только малую часть графа. Мы реализуем это, переместив генерацию рёбер в функцию `neighbors()`.
Существует несколько случаев. В начале алгоритма нам нужны соседи начальной точки. Это рёбра перехода от начальной точки к левому и правому ребру каждого препятствия.
Следующий случай — когда A\* только что добрался до точки  на ребре препятствия  вдоль ребра перехода: `neighbors()` должна вернуть огибающие рёбра, ведущие из . Для этого мы определим, какие рёбра перехода выходят из препятствия, вычислив касательные к двум точкам между  и всеми остальными препятствиями, отбросив все те, которые не находятся на линии видимости. Затем найдём все огибающие рёбра, соединяющие  с этими рёбрами перехода, отбросив те, которые блокированы другими препятствиями. Возвращаем все эти огибающие рёбра,, сохраняя рёбра перехода для возврата в последующем вызове `neighbors()`.
Последний случай — когда A\* обошёл огибающее ребро вдоль препятствия  и ему нужно покинуть  по ребру перехода. Так как предыдущий этап вычислил и сохранил все рёбра перехода, можно просто найти и возвратить правильное множество рёбер.
### Отсекаем заострённые огибающие рёбра
Огибающие рёбра соединяют рёбра перехода, касающиеся одного круга, но оказывается, что многие из таких огибающих рёбер не подходят для использования в оптимальном пути. Мы можем ускорить алгоритм, устранив их.
Оптимальный путь через лес препятствий всегда состоит из перемежающихся рёбер перехода и огибающих рёбер. Допустим мы входим в узел  и решаем, как из него выйти:
Вход через  означает, что мы движемся *по часовой стрелке* (). Мы должны выйти через узел, который позволяет нам продолжать двигаться по часовой стрелке (), то есть мы можем выйти только через узел  или . Если выйти через , то создастся *перегиб* () пути, что никогда не будет оптимальным. Нам нужно отфильтровывать такие заострённые рёбра.
Для начала заметим, что A\* и так обрабатывает каждое неориентированное ребро  как два ориентированных ребра,  и . Мы можем воспользоваться этим, пометив рёбра и узлы ориентацией.
1. Узлы  становятся узлами с ориентацией — по часовой () или против часовой () стрелки.
2. Неориентированные рёбра перехода  становятся ориентированными рёбрами  и , где  и  — это ориентации, а  означает направление, противоположное .
3. Неориентированные огибающие рёбра  становятся ориентированными рёбрами  и . Именно здесь происходит фильтрация: мы *не* включаем  и , потому что смена направления создаёт перегибы ().
В нашей схеме узел  превратится в два узла,  и , он имеет входящее ребро перехода  и исходящее ребро перехода . Если мы попали на путь через , то должны выйти через узел , который будет или ребром перехода  (через огибающее ребро ), или ребро перехода  (через огибающее ребро ). Мы не можем выйти через , потому что так изменится направление поворота, и мы отфильтровали огибающее ребро .
Отфильтровав из графа эти заострённые огибающие рёбра, мы повысили эффективность алгоритма.
### Отсечение пересекающих рёбер
Можно отсекать частичные пути, последние рёбра перехода которых пересекают предпоследнее ребро перехода.
### Многоугольные препятствия
См. [Game Programming Gems 2](https://dl.acm.org/citation.cfm?id=516343), Chapter 3.10, Optimizing Points-of-Visibility Pathfinding, написанную Томасом Янгом. В этой главе рассматривается отсечение узлов, но не для кругов, а для многоугольников.
Справочные материалы
--------------------
* [Задача ремней](https://en.wikipedia.org/wiki/Belt_problem)
* [Задача шкивов](https://en.wikipedia.org/wiki/Belt_problem#Pulley_problem)
* [Расстояние между точкой и прямой](http://paulbourke.net/geometry/pointlineplane/)
* [Пересечение двух окружностей](http://paulbourke.net/geometry/circlesphere/) | https://habr.com/ru/post/451642/ | null | ru | null |
# Карты из шестиугольников в Unity: туман войны, исследование карты, процедурная генерация
[Части 1-3: сетка, цвета и высоты ячеек](https://habr.com/post/424257/)
[Части 4-7: неровности, реки и дороги](https://habr.com/post/424491/)
[Части 8-11: вода, объекты рельефа и крепостные стены](https://habr.com/post/425463/)
[Части 12-15: сохранение и загрузка, текстуры, расстояния](https://habr.com/post/425919/)
[Части 16-19: поиск пути, отряды игрока, анимации](https://habr.com/post/426481/)
[Части 20-23: туман войны, исследование карты, процедурная генерация](https://habr.com/post/427003/)
[Части 24-27: круговорот воды, эрозия, биомы, цилиндрическая карта](https://habr.com/post/427567/)
Часть 20: туман войны
=====================
* Сохраняем данные ячеек в текстуре.
* Изменяем типы рельефа без триангуляции.
* Отслеживаем видимость.
* Затемняем всё невидимое.
В этой части мы добавим на карту эффект тумана войны.
Теперь серия будет создаваться на Unity 2017.1.0.
*Теперь мы видим, что можем и не можем видеть.*
Данные ячеек в шейдере
----------------------
Во многих стратегических играх используется концепция тумана войны. Это значит, что зрение игрока ограничено. Он может видеть только то, что находится близко к его отрядам или контролируемой зоне. Хоть мы и можем видеть рельеф, но не знаем, что там происходит. Обычно невидимый рельеф рендерится более тёмным. Чтобы реализовать это, нам нужно отслеживать видимость ячейки и соответствующим образом выполнять её рендеринг.
Простейший способ изменения внешнего вида скрытых ячеек заключается в добавлении к данным меша показателя видимости. Однако при этом нам придётся запускать новую триангуляцию рельефа при изменении видимости. Это плохое решение, потому что во время игры видимость меняется постоянно.
Часто используется техника рендеринга поверх рельефа полупрозрачной поверхности, которая частично маскирует невидимые игроком ячейки. Такой способ подойдёт для относительно плоского рельефа в сочетании с ограниченным углом обзора. Но так как наш рельеф может содержать очень варьирующиеся высоты и объекты, на которые можно смотреть под разными углами, для этого нам понадобится высокодетализированный меш, соответствующий форме рельефа. Такой способ будет более затратным, чем упомянутый выше простейший подход.
Ещё один подход заключается в передаче при рендеринге данных ячеек в шейдер по отдельности от меша рельефа. Это позволит нам выполнять триангуляцию только один раз. Данные ячеек можно передавать с помощью текстуры. Изменение текстуры — это гораздо более простой процесс, чем триангуляция рельефа. Кроме того выполнение нескольких дополнительных сэмплов текстуры быстрее, чем рендеринг отдельного полупрозрачного слоя.
**А как насчёт использования массивов шейдера?**
Можно также передавать в шейдер данные ячеек с помощью массива векторов. Однако у массивов шейдера есть ограничение размера, измеряемое в тысячах байт, а текстуры могут содержать миллионы пикселей. Для поддержки больших карт мы воспользуемся текстурами.
### Управление данными ячеек
Нам нужен способ управления текстурой, содержащей данные ячеек. Давайте создадим новый компонент `HexCellShaderData`, который этим займётся.
```
using UnityEngine;
public class HexCellShaderData : MonoBehaviour {
Texture2D cellTexture;
}
```
При создании или загрузке новой карты нам нужно создавать новую текстуру с правильным размером. Поэтому добавим ему метод инициализации, создающий текстуру. Мы используем текстуру в формате RGBA без mip-текстур и линейное цветовое пространство. Нам не нужно смешивать данные ячеек, поэтому используем точечную фильтрацию (point filtering). Кроме того, данные не должны сворачиваться. Каждый пиксель текстуры будет содержать данные одной ячейки.
```
public void Initialize (int x, int z) {
cellTexture = new Texture2D(
x, z, TextureFormat.RGBA32, false, true
);
cellTexture.filterMode = FilterMode.Point;
cellTexture.wrapMode = TextureWrapMode.Clamp;
}
```
**Должен ли размер текстуры соответствовать размеру карты?**
Нет, в ней просто должно быть достаточно пикселей для хранения всех ячеек. При точном соответствии размеру карты скорее всего будет создана текстура с размерами, не являющимися степенями двойки (non-power-of-two, NPOT), а такой формат текстур является не самым эффективным. Хоть мы и можем настроить код на работу с текстурами размером в степень двойки, это незначительная оптимизация, которая усложняет доступ к данным ячеек.
На самом деле нам не обязательно создавать новую текстуру при каждом создании новой карты. Достаточно изменять размер текстуры, если она уже существует. Нам даже не нужно будет проверять, есть ли у нас уже правильный размер, потому что `Texture2D.Resize` достаточно умён, чтобы делать это за нас.
```
public void Initialize (int x, int z) {
if (cellTexture) {
cellTexture.Resize(x, z);
}
else {
cellTexture = new Texture2D(
cellCountX, cellCountZ, TextureFormat.RGBA32, false, true
);
cellTexture.filterMode = FilterMode.Point;
cellTexture.wrapMode = TextureWrapMode.Clamp;
}
}
```
Вместо того, чтобы применять данные ячеек по одному пикселю за раз, мы используем буфер цветов и применим данные всех ячеек за раз. Для этого мы воспользуемся массивом `Color32`. При необходимости будем создавать новый экземпляр массива в конце `Initialize`. Если у нас уже есть массив правильного размера. то мы очищаем его содержимое.
```
Texture2D cellTexture;
Color32[] cellTextureData;
public void Initialize () {
…
if (cellTextureData == null || cellTextureData.Length != x * z) {
cellTextureData = new Color32[x * z];
}
else {
for (int i = 0; i < cellTextureData.Length; i++) {
cellTextureData[i] = new Color32(0, 0, 0, 0);
}
}
}
```
**Что такое Color32?**
Стандартные несжатые RGBA-текстуры содержат пиксели размером четыре байта. Каждый из четырёх цветовых каналов получает по байту, то есть они имеют 256 возможных значений. При использовании структуры Unity `Color` её компоненты с плавающей запятой в интервале 0–1 преобразуются в байты в интервале 0–255. При сэмплировании GPU выполняет обратное преобразование.
Структура `Color32` работает непосредственно с байтами, поэтому они занимают меньше места и не требуют преобразования, что повышает эффективность их использования. Так как мы храним вместо цветов данные ячеек, будет логичнее работать непосредственно с сырыми данными текстур, а не с `Color`.
Созданием и инициализацией данных ячеек в шейдере должен заниматься `HexGrid`. Поэтому добавим ему поле `cellShaderData` и создадим компонент внутри `Awake`.
```
HexCellShaderData cellShaderData;
void Awake () {
HexMetrics.noiseSource = noiseSource;
HexMetrics.InitializeHashGrid(seed);
HexUnit.unitPrefab = unitPrefab;
cellShaderData = gameObject.AddComponent();
CreateMap(cellCountX, cellCountZ);
}
```
При создании новой карты должен инициироваться и `cellShaderData`.
```
public bool CreateMap (int x, int z) {
…
cellCountX = x;
cellCountZ = z;
chunkCountX = cellCountX / HexMetrics.chunkSizeX;
chunkCountZ = cellCountZ / HexMetrics.chunkSizeZ;
cellShaderData.Initialize(cellCountX, cellCountZ);
CreateChunks();
CreateCells();
return true;
}
```
### Изменение данных ячеек
До данного момента при изменении свойств ячейки необходимо было обновлять один или несколько фрагментов, но теперь может потребоваться обновление и данных ячеек. Это значит, что ячейки должны иметь ссылку на данные ячеек в шейдере. Для этого добавим свойство в `HexCell`.
```
public HexCellShaderData ShaderData { get; set; }
```
В `HexGrid.CreateCell` присвоим этому свойству компонент данных шейдера.
```
void CreateCell (int x, int z, int i) {
…
HexCell cell = cells[i] = Instantiate(cellPrefab);
cell.transform.localPosition = position;
cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z);
cell.ShaderData = cellShaderData;
…
}
```
Теперь мы можем заставить ячейки обновлять их данные шейдера. Пока мы не отслеживаем видимость, но можем использовать данные шейдера для чего-то ещё. Тип рельефа ячейки определяет текстуру, используемую при её рендеринге. Он не влияет на геометрию ячейки, поэтому мы можем хранить индекс типа рельефа в данных ячейки, а не в данных меша. Это позволит нам избавиться от необходимости триангуляции при изменении типа рельефа ячейки.
Добавим в `HexCellShaderData` метод `RefreshTerrain`, чтобы упростить эту задачу для конкретной ячейки. Давайте пока оставим этот метод пустым.
```
public void RefreshTerrain (HexCell cell) {
}
```
Изменим `HexCell.TerrainTypeIndex` так, чтобы он вызывал этот метод, а не приказывал обновлять фрагменты.
```
public int TerrainTypeIndex {
get {
return terrainTypeIndex;
}
set {
if (terrainTypeIndex != value) {
terrainTypeIndex = value;
// Refresh();
ShaderData.RefreshTerrain(this);
}
}
}
```
Также вызовем его в `HexCell.Load` после получения типа рельефа ячейки.
```
public void Load (BinaryReader reader) {
terrainTypeIndex = reader.ReadByte();
ShaderData.RefreshTerrain(this);
elevation = reader.ReadByte();
RefreshPosition();
…
}
```
### Индекс ячейки
Для изменения данных ячеек нам нужно знать индекс ячейки. Проще всего это сделать, добавив в `HexCell` свойство `Index`. Оно будет обозначать индекс ячейки в списке ячеек карты, что соответствует её индексу в данных ячеек в шейдере.
```
public int Index { get; set; }
```
Этот индекс уже есть в `HexGrid.CreateCell`, поэтому просто присвоим его созданной ячейке.
```
void CreateCell (int x, int z, int i) {
…
cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z);
cell.Index = i;
cell.ShaderData = cellShaderData;
…
}
```
Теперь `HexCellShaderData.RefreshTerrain` может использовать этот индекс для задания данных ячейки. Давайте сохранять индекс типа рельефа в альфа-компоненте её пикселя, просто преобразовывая тип в byte. Это позволит поддерживать до 256 типов рельефа, чего нам будет вполне достаточно.
```
public void RefreshTerrain (HexCell cell) {
cellTextureData[cell.Index].a = (byte)cell.TerrainTypeIndex;
}
```
Чтобы применить данные к текстуре и передать её в GPU, нам нужно вызывать `Texture2D.SetPixels32`, а затем `Texture2D.Apply`. Как и в случае с фрагментами, мы отложим эти операции на `LateUpdate`, чтобы можно было выполнять их не чаще раза за кадр, вне зависимости от количества изменившихся ячеек.
```
public void RefreshTerrain (HexCell cell) {
cellTextureData[cell.Index].a = (byte)cell.TerrainTypeIndex;
enabled = true;
}
void LateUpdate () {
cellTexture.SetPixels32(cellTextureData);
cellTexture.Apply();
enabled = false;
}
```
Чтобы гарантировать, что данные будут обновляться после создания новой карты, включим компонент после инициализации.
```
public void Initialize (int x, int z) {
…
enabled = true;
}
```
### Триангуляция индексов ячеек
Так как теперь мы храним индекс типа рельефа в данных ячеек, нам больше не нужно включать их в процесс триангуляции. Но чтобы использовать данные ячеек, шейдер должен знать, какие индексы использовать. Поэтому нужно хранить индексы ячеек в данных меша, заменяя индексы типов рельефа. Кроме того, нам по-прежнему нужен цветовой канал меша для смешивания ячеек при использовании данных ячеек.
Удалим из `HexMesh` устаревшие общие поля `useColors` и `useTerrainTypes`. Заменим их одним полем `useCellData`.
```
// public bool useCollider, useColors, useUVCoordinates, useUV2Coordinates;
// public bool useTerrainTypes;
public bool useCollider, useCellData, useUVCoordinates, useUV2Coordinates;
```
Выполним рефакторинг-переименование списка `terrainTypes` в `cellIndices`. Давайте также рефакторим-переименуем `colors` в `cellWeights` — это имя подойдёт больше.
```
// [NonSerialized] List vertices, terrainTypes;
// [NonSerialized] List colors;
[NonSerialized] List vertices, cellIndices;
[NonSerialized] List cellWeights;
[NonSerialized] List uvs, uv2s;
[NonSerialized] List triangles;
```
Изменим `Clear` так, чтобы при использовании данных ячеек он получал два списка вместе, а не по отдельности.
```
public void Clear () {
hexMesh.Clear();
vertices = ListPool.Get();
if (useCellData) {
cellWeights = ListPool.Get();
cellIndices = ListPool.Get();
}
// if (useColors) {
// colors = ListPool.Get();
// }
if (useUVCoordinates) {
uvs = ListPool.Get();
}
if (useUV2Coordinates) {
uv2s = ListPool.Get();
}
// if (useTerrainTypes) {
// terrainTypes = ListPool.Get();
// }
triangles = ListPool.Get();
}
```
Выполним такое же группирование в `Apply`.
```
public void Apply () {
hexMesh.SetVertices(vertices);
ListPool.Add(vertices);
if (useCellData) {
hexMesh.SetColors(cellWeights);
ListPool.Add(cellWeights);
hexMesh.SetUVs(2, cellIndices);
ListPool.Add(cellIndices);
}
// if (useColors) {
// hexMesh.SetColors(colors);
// ListPool.Add(colors);
// }
if (useUVCoordinates) {
hexMesh.SetUVs(0, uvs);
ListPool.Add(uvs);
}
if (useUV2Coordinates) {
hexMesh.SetUVs(1, uv2s);
ListPool.Add(uv2s);
}
// if (useTerrainTypes) {
// hexMesh.SetUVs(2, terrainTypes);
// ListPool.Add(terrainTypes);
// }
hexMesh.SetTriangles(triangles, 0);
ListPool.Add(triangles);
hexMesh.RecalculateNormals();
if (useCollider) {
meshCollider.sharedMesh = hexMesh;
}
}
```
Удалим все методы `AddTriangleColor` и `AddTriangleTerrainTypes`. Заменим их соответствующими методами `AddTriangleCellData`, которые добавляют индексы и веса за один раз.
```
public void AddTriangleCellData (
Vector3 indices, Color weights1, Color weights2, Color weights3
) {
cellIndices.Add(indices);
cellIndices.Add(indices);
cellIndices.Add(indices);
cellWeights.Add(weights1);
cellWeights.Add(weights2);
cellWeights.Add(weights3);
}
public void AddTriangleCellData (Vector3 indices, Color weights) {
AddTriangleCellData(indices, weights, weights, weights);
}
```
Сделаем то же самое в соответствующих метода `AddQuad`.
```
public void AddQuadCellData (
Vector3 indices,
Color weights1, Color weights2, Color weights3, Color weights4
) {
cellIndices.Add(indices);
cellIndices.Add(indices);
cellIndices.Add(indices);
cellIndices.Add(indices);
cellWeights.Add(weights1);
cellWeights.Add(weights2);
cellWeights.Add(weights3);
cellWeights.Add(weights4);
}
public void AddQuadCellData (
Vector3 indices, Color weights1, Color weights2
) {
AddQuadCellData(indices, weights1, weights1, weights2, weights2);
}
public void AddQuadCellData (Vector3 indices, Color weights) {
AddQuadCellData(indices, weights, weights, weights, weights);
}
```
### Рефакторинг HexGridChunk
На данном этапе мы получаем в `HexGridChunk` множество ошибок компилятора, которые нужно устранить. Но сначала ради согласованности рефакторим-переименуем статические цвета в веса.
```
static Color weights1 = new Color(1f, 0f, 0f);
static Color weights2 = new Color(0f, 1f, 0f);
static Color weights3 = new Color(0f, 0f, 1f);
```
Давайте начнём с исправления `TriangulateEdgeFan`. Раньше ему требовался тип, а теперь нужен индекс ячейки. Заменим код `AddTriangleColor` и `AddTriangleTerrainTypes` соответствующим кодом `AddTriangleCellData`.
```
void TriangulateEdgeFan (Vector3 center, EdgeVertices edge, float index) {
terrain.AddTriangle(center, edge.v1, edge.v2);
terrain.AddTriangle(center, edge.v2, edge.v3);
terrain.AddTriangle(center, edge.v3, edge.v4);
terrain.AddTriangle(center, edge.v4, edge.v5);
Vector3 indices;
indices.x = indices.y = indices.z = index;
terrain.AddTriangleCellData(indices, weights1);
terrain.AddTriangleCellData(indices, weights1);
terrain.AddTriangleCellData(indices, weights1);
terrain.AddTriangleCellData(indices, weights1);
// terrain.AddTriangleColor(weights1);
// terrain.AddTriangleColor(weights1);
// terrain.AddTriangleColor(weights1);
// terrain.AddTriangleColor(weights1);
// Vector3 types;
// types.x = types.y = types.z = type;
// terrain.AddTriangleTerrainTypes(types);
// terrain.AddTriangleTerrainTypes(types);
// terrain.AddTriangleTerrainTypes(types);
// terrain.AddTriangleTerrainTypes(types);
}
```
Этот метод вызывается в нескольких местах. Пройдёмся по ним и сделаем так, чтобы там передавался индекс ячейки, а не тип рельефа.
```
TriangulateEdgeFan(center, e, cell.Index);
```
Далее `TriangulateEdgeStrip`. Здесь всё немного сложнее, но используем тот же подход. Также рефакторим-переименуем имена параметров `c1` и `c2` в `w1` и `w2`.
```
void TriangulateEdgeStrip (
EdgeVertices e1, Color w1, float index1,
EdgeVertices e2, Color w2, float index2,
bool hasRoad = false
) {
terrain.AddQuad(e1.v1, e1.v2, e2.v1, e2.v2);
terrain.AddQuad(e1.v2, e1.v3, e2.v2, e2.v3);
terrain.AddQuad(e1.v3, e1.v4, e2.v3, e2.v4);
terrain.AddQuad(e1.v4, e1.v5, e2.v4, e2.v5);
Vector3 indices;
indices.x = indices.z = index1;
indices.y = index2;
terrain.AddQuadCellData(indices, w1, w2);
terrain.AddQuadCellData(indices, w1, w2);
terrain.AddQuadCellData(indices, w1, w2);
terrain.AddQuadCellData(indices, w1, w2);
// terrain.AddQuadColor(c1, c2);
// terrain.AddQuadColor(c1, c2);
// terrain.AddQuadColor(c1, c2);
// terrain.AddQuadColor(c1, c2);
// Vector3 types;
// types.x = types.z = type1;
// types.y = type2;
// terrain.AddQuadTerrainTypes(types);
// terrain.AddQuadTerrainTypes(types);
// terrain.AddQuadTerrainTypes(types);
// terrain.AddQuadTerrainTypes(types);
if (hasRoad) {
TriangulateRoadSegment(e1.v2, e1.v3, e1.v4, e2.v2, e2.v3, e2.v4);
}
}
```
Изменим вызовы этого метода так, чтобы им передавался индекс ячейки. Также сохраним согласованность имён переменных.
```
TriangulateEdgeStrip(
m, weights1, cell.Index,
e, weights1, cell.Index
);
…
TriangulateEdgeStrip(
e1, weights1, cell.Index,
e2, weights2, neighbor.Index, hasRoad
);
…
void TriangulateEdgeTerraces (
EdgeVertices begin, HexCell beginCell,
EdgeVertices end, HexCell endCell,
bool hasRoad
) {
EdgeVertices e2 = EdgeVertices.TerraceLerp(begin, end, 1);
Color w2 = HexMetrics.TerraceLerp(weights1, weights2, 1);
float i1 = beginCell.Index;
float i2 = endCell.Index;
TriangulateEdgeStrip(begin, weights1, i1, e2, w2, i2, hasRoad);
for (int i = 2; i < HexMetrics.terraceSteps; i++) {
EdgeVertices e1 = e2;
Color w1 = w2;
e2 = EdgeVertices.TerraceLerp(begin, end, i);
w2 = HexMetrics.TerraceLerp(weights1, weights2, i);
TriangulateEdgeStrip(e1, w1, i1, e2, w2, i2, hasRoad);
}
TriangulateEdgeStrip(e2, w2, i1, end, weights2, i2, hasRoad);
}
```
Теперь мы перейдём к методам углов. Эти изменения просты, но их нужно внести в большой объём кода. Сначала в `TriangulateCorner`.
```
void TriangulateCorner (
Vector3 bottom, HexCell bottomCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
) {
…
else {
terrain.AddTriangle(bottom, left, right);
Vector3 indices;
indices.x = bottomCell.Index;
indices.y = leftCell.Index;
indices.z = rightCell.Index;
terrain.AddTriangleCellData(indices, weights1, weights2, weights3);
// terrain.AddTriangleColor(weights1, weights2, weights3);
// Vector3 types;
// types.x = bottomCell.TerrainTypeIndex;
// types.y = leftCell.TerrainTypeIndex;
// types.z = rightCell.TerrainTypeIndex;
// terrain.AddTriangleTerrainTypes(types);
}
features.AddWall(bottom, bottomCell, left, leftCell, right, rightCell);
}
```
Далее в `TriangulateCornerTerraces`.
```
void TriangulateCornerTerraces (
Vector3 begin, HexCell beginCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
) {
Vector3 v3 = HexMetrics.TerraceLerp(begin, left, 1);
Vector3 v4 = HexMetrics.TerraceLerp(begin, right, 1);
Color w3 = HexMetrics.TerraceLerp(weights1, weights2, 1);
Color w4 = HexMetrics.TerraceLerp(weights1, weights3, 1);
Vector3 indices;
indices.x = beginCell.Index;
indices.y = leftCell.Index;
indices.z = rightCell.Index;
terrain.AddTriangle(begin, v3, v4);
terrain.AddTriangleCellData(indices, weights1, w3, w4);
// terrain.AddTriangleColor(weights1, w3, w4);
// terrain.AddTriangleTerrainTypes(indices);
for (int i = 2; i < HexMetrics.terraceSteps; i++) {
Vector3 v1 = v3;
Vector3 v2 = v4;
Color w1 = w3;
Color w2 = w4;
v3 = HexMetrics.TerraceLerp(begin, left, i);
v4 = HexMetrics.TerraceLerp(begin, right, i);
w3 = HexMetrics.TerraceLerp(weights1, weights2, i);
w4 = HexMetrics.TerraceLerp(weights1, weights3, i);
terrain.AddQuad(v1, v2, v3, v4);
terrain.AddQuadCellData(indices, w1, w2, w3, w4);
// terrain.AddQuadColor(w1, w2, w3, w4);
// terrain.AddQuadTerrainTypes(indices);
}
terrain.AddQuad(v3, v4, left, right);
terrain.AddQuadCellData(indices, w3, w4, weights2, weights3);
// terrain.AddQuadColor(w3, w4, weights2, weights3);
// terrain.AddQuadTerrainTypes(indices);
}
```
Затем в `TriangulateCornerTerracesCliff`.
```
void TriangulateCornerTerracesCliff (
Vector3 begin, HexCell beginCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
) {
float b = 1f / (rightCell.Elevation - beginCell.Elevation);
if (b < 0) {
b = -b;
}
Vector3 boundary = Vector3.Lerp(
HexMetrics.Perturb(begin), HexMetrics.Perturb(right), b
);
Color boundaryWeights = Color.Lerp(weights1, weights3, b);
Vector3 indices;
indices.x = beginCell.Index;
indices.y = leftCell.Index;
indices.z = rightCell.Index;
TriangulateBoundaryTriangle(
begin, weights1, left, weights2, boundary, boundaryWeights, indices
);
if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) {
TriangulateBoundaryTriangle(
left, weights2, right, weights3,
boundary, boundaryWeights, indices
);
}
else {
terrain.AddTriangleUnperturbed(
HexMetrics.Perturb(left), HexMetrics.Perturb(right), boundary
);
terrain.AddTriangleCellData(
indices, weights2, weights3, boundaryWeights
);
// terrain.AddTriangleColor(weights2, weights3, boundaryColor);
// terrain.AddTriangleTerrainTypes(indices);
}
}
```
И немного иначе в `TriangulateCornerCliffTerraces`.
```
void TriangulateCornerCliffTerraces (
Vector3 begin, HexCell beginCell,
Vector3 left, HexCell leftCell,
Vector3 right, HexCell rightCell
) {
float b = 1f / (leftCell.Elevation - beginCell.Elevation);
if (b < 0) {
b = -b;
}
Vector3 boundary = Vector3.Lerp(
HexMetrics.Perturb(begin), HexMetrics.Perturb(left), b
);
Color boundaryWeights = Color.Lerp(weights1, weights2, b);
Vector3 indices;
indices.x = beginCell.Index;
indices.y = leftCell.Index;
indices.z = rightCell.Index;
TriangulateBoundaryTriangle(
right, weights3, begin, weights1, boundary, boundaryWeights, indices
);
if (leftCell.GetEdgeType(rightCell) == HexEdgeType.Slope) {
TriangulateBoundaryTriangle(
left, weights2, right, weights3,
boundary, boundaryWeights, indices
);
}
else {
terrain.AddTriangleUnperturbed(
HexMetrics.Perturb(left), HexMetrics.Perturb(right), boundary
);
terrain.AddTriangleCellData(
indices, weights2, weights3, boundaryWeights
);
// terrain.AddTriangleColor(weights2, weights3, boundaryWeights);
// terrain.AddTriangleTerrainTypes(indices);
}
}
```
В предыдущих двух метода используется `TriangulateBoundaryTriangle`, который тоже требует обновления.
```
void TriangulateBoundaryTriangle (
Vector3 begin, Color beginWeights,
Vector3 left, Color leftWeights,
Vector3 boundary, Color boundaryWeights, Vector3 indices
) {
Vector3 v2 = HexMetrics.Perturb(HexMetrics.TerraceLerp(begin, left, 1));
Color w2 = HexMetrics.TerraceLerp(beginWeights, leftWeights, 1);
terrain.AddTriangleUnperturbed(HexMetrics.Perturb(begin), v2, boundary);
terrain.AddTriangleCellData(indices, beginWeights, w2, boundaryWeights);
// terrain.AddTriangleColor(beginColor, c2, boundaryColor);
// terrain.AddTriangleTerrainTypes(types);
for (int i = 2; i < HexMetrics.terraceSteps; i++) {
Vector3 v1 = v2;
Color w1 = w2;
v2 = HexMetrics.Perturb(HexMetrics.TerraceLerp(begin, left, i));
w2 = HexMetrics.TerraceLerp(beginWeights, leftWeights, i);
terrain.AddTriangleUnperturbed(v1, v2, boundary);
terrain.AddTriangleCellData(indices, w1, w2, boundaryWeights);
// terrain.AddTriangleColor(c1, c2, boundaryColor);
// terrain.AddTriangleTerrainTypes(types);
}
terrain.AddTriangleUnperturbed(v2, HexMetrics.Perturb(left), boundary);
terrain.AddTriangleCellData(indices, w2, leftWeights, boundaryWeights);
// terrain.AddTriangleColor(c2, leftColor, boundaryColor);
// terrain.AddTriangleTerrainTypes(types);
}
```
Последний метод, который требует изменений — `TriangulateWithRiver`.
```
void TriangulateWithRiver (
HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e
) {
…
terrain.AddTriangle(centerL, m.v1, m.v2);
terrain.AddQuad(centerL, center, m.v2, m.v3);
terrain.AddQuad(center, centerR, m.v3, m.v4);
terrain.AddTriangle(centerR, m.v4, m.v5);
Vector3 indices;
indices.x = indices.y = indices.z = cell.Index;
terrain.AddTriangleCellData(indices, weights1);
terrain.AddQuadCellData(indices, weights1);
terrain.AddQuadCellData(indices, weights1);
terrain.AddTriangleCellData(indices, weights1);
// terrain.AddTriangleColor(weights1);
// terrain.AddQuadColor(weights1);
// terrain.AddQuadColor(weights1);
// terrain.AddTriangleColor(weights1);
// Vector3 types;
// types.x = types.y = types.z = cell.TerrainTypeIndex;
// terrain.AddTriangleTerrainTypes(types);
// terrain.AddQuadTerrainTypes(types);
// terrain.AddQuadTerrainTypes(types);
// terrain.AddTriangleTerrainTypes(types);
…
}
```
Чтобы всё заработало, нам нужно указать, что мы испоьзуем данные ячеек для дочернего элемента рельефа префаба фрагмента.
*Рельеф использует данные ячеек.*
На данном этапе меш содержит вместо индексов типов рельефа индексы ячеек. Так как шейдер рельефа по-прежнему интерпретирует их как индексы рельефа, то мы увидим, что первая ячейка рендерится с первой текстурой и так далее, пока не будет достигнута последняя текстура рельефа.
*Использование индексов ячеек как индексов текстур рельефа.*
**Не могу заставить работать отрефакторенный код. Что я делаю не так?**
За один раз мы изменили большой объём кода триангуляции, поэтому есть большая вероятность ошибок или недосмотров. Если вы не можете найти ошибку, то попробуйте скачать пакет из этого раздела и извлечь соответствующие файлы. Можете импортировать их в отдельный проект и сравнить с собственным кодом.
### Передача данных ячеек в шейдер
Чтобы использовать данные ячеек, шейдер рельефа должен иметь к ним доступ. Это можно реализовать через свойство шейдера. При этом потребуется, чтобы `HexCellShaderData` задавал свойство материала рельефа. Или же мы можем сделать текстуру данных ячеек глобально видимой для всех шейдеров. Это удобно, потому что она потребуется нам в нескольких шейдерах, так что воспользуемся этим подходом.
После создания текстуры ячейки вызовем статический метод `Shader.SetGlobalTexture`, чтобы сделать её глобально видимой как *\_HexCellData*.
```
public void Initialize (int x, int z) {
…
else {
cellTexture = new Texture2D(
x, z, TextureFormat.RGBA32, false, true
);
cellTexture.filterMode = FilterMode.Point;
cellTexture.wrapMode = TextureWrapMode.Clamp;
Shader.SetGlobalTexture("_HexCellData", cellTexture);
}
…
}
```
При использовании свойства шейдера Unity делает размер текстуры доступным шейдеру через переменную *textureName\_TexelSize*. Это четырёхкомпонентый выектор, содержащий величины, обратные ширине и высоте, а также сами ширину и высоту. Но при задании текстуры глобальной это не выполняется. Поэтому сделаем это самостоятельно с помощью `Shader.SetGlobalVector` после создания или изменения размера текстуры.
```
else {
cellTexture = new Texture2D(
x, z, TextureFormat.RGBA32, false, true
);
cellTexture.filterMode = FilterMode.Point;
cellTexture.wrapMode = TextureWrapMode.Clamp;
Shader.SetGlobalTexture("_HexCellData", cellTexture);
}
Shader.SetGlobalVector(
"_HexCellData_TexelSize",
new Vector4(1f / x, 1f / z, x, z)
);
```
### Доступ к данным шейдера
Создадим в папке материалов новый include-файл шейдера под названием *HexCellData*. Внутри него определим переменные для информации о текстуре и размере данных ячеек. Также создадим функцию для получения данных ячеек для заданных данных меша вершины.
```
sampler2D _HexCellData;
float4 _HexCellData_TexelSize;
float4 GetCellData (appdata_full v) {
}
```
*Новый include-файл.*
Индексы ячеек хранятся в `v.texcoord2`, как это было и с типами рельефа. Давайте начнём с первого индекса — `v.texcoord2.x`. К сожалению, мы не можем напрямую использовать индекс для сэмплирования текстуры данных ячеек. Нам придётся преобразовать его в UV-координаты.
Первый этап создания координаты U — деление индекса ячейки на ширину текстуры. Мы можем это сделать, умножив его на `_HexCellData_TexelSize.x`.
```
float4 GetCellData (appdata_full v) {
float2 uv;
uv.x = v.texcoord2.x * _HexCellData_TexelSize.x;
}
```
Результатом будет число в виде Z.U, где Z — это индекс строки, а U — координата U ячейки. Мы можем извлечь строку, округлив число в меньшую сторону, а затем вычтя его из числа, чтобы получить координату U.
```
float4 GetCellData (appdata_full v) {
float2 uv;
uv.x = v.texcoord2.x * _HexCellData_TexelSize.x;
float row = floor(uv.x);
uv.x -= row;
}
```
Координата V находится делением строки на высоту текстуры.
```
float4 GetCellData (appdata_full v) {
float2 uv;
uv.x = v.texcoord2.x * _HexCellData_TexelSize.x;
float row = floor(uv.x);
uv.x -= row;
uv.y = row * _HexCellData_TexelSize.y;
}
```
Так как мы сэмплируем текстуру, нам нужно использовать координаты в центрах пикселей, а не на их краях. Так мы гарантируем, что сэмплируются правильные пиксели. Поэтому после деления на размеры текстуры прибавим ½.
```
float4 GetCellData (appdata_full v) {
float2 uv;
uv.x = (v.texcoord2.x + 0.5) * _HexCellData_TexelSize.x;
float row = floor(uv.x);
uv.x -= row;
uv.y = (row + 0.5) * _HexCellData_TexelSize.y;
}
```
Это даёт нам верные UV-координаты для индекса первой ячейки, хранящегося в данных вершины. Но на вершину у нас может быть до трёх разных индексов. Поэтому сделаем так, чтобы `GetCellData` работал для любого индекса. Добавим ему целочисленный параметр `index`, который будем использовать для доступа к компоненту вектора с индексом ячейки.
```
float4 GetCellData (appdata_full v, int index) {
float2 uv;
uv.x = (v.texcoord2[index] + 0.5) * _HexCellData_TexelSize.x;
float row = floor(uv.x);
uv.x -= row;
uv.y = (row + 0.5) * _HexCellData_TexelSize.y;
}
```
Теперь, когда у нас есть все нужные координаты данных ячеек, мы можем сэмплировать `_HexCellData`. Так как мы сэмплируем текстуру в вершинной программе, то нужно явным образом указать шейдеру, какую mip-текстуру использовать. Это можно сделать с помощью функции `tex2Dlod`, которой требуются координаты четырёх текстур. Так как у данных ячеек нет mip-текстур, лишним координатам присвоим нулевые значения.
```
float4 GetCellData (appdata_full v, int index) {
float2 uv;
uv.x = (v.texcoord2[index] + 0.5) * _HexCellData_TexelSize.x;
float row = floor(uv.x);
uv.x -= row;
uv.y = (row + 0.5) * _HexCellData_TexelSize.y;
float4 data = tex2Dlod(_HexCellData, float4(uv, 0, 0));
}
```
Четвёртый компонент данных содержит индекс типа рельефа, который мы храним непосредственно как байт. Однако GPU автоматически конвертировал его в значение с плавающей запятой в интервале 0–1. Чтобы преобразовать его обратно в верное значение, умножим его на 255. После этого можно вернуть данные.
```
float4 data = tex2Dlod(_HexCellData, float4(uv, 0, 0));
data.w *= 255;
return data;
```
Чтобы воспользоваться этим функционалом, включим *HexCellData* в шейдер *Terrain*. Так как я поместил этот шейдер в *Materials / Terrain*, то нужно использовать относительный путь *../HexCellData.cginc*.
```
#include "../HexCellData.cginc"
UNITY_DECLARE_TEX2DARRAY(_MainTex);
```
В вершинной программе получим данные ячеек для всех трёх индексов ячейки, хранящихся в данных вершины. Затем присвоим `data.terrain` их индексы рельефа.
```
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
// data.terrain = v.texcoord2.xyz;
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
float4 cell2 = GetCellData(v, 2);
data.terrain.x = cell0.w;
data.terrain.y = cell1.w;
data.terrain.z = cell2.w;
}
```
На этом этапе карта снова начала отображать правильный рельеф. Большая разница заключается в том, что редактирование только типов рельефа больше не приводит к новым триангуляциям. Если при редактировании будут изменены какие-то другие данные ячеек, то триангуляция выполнится как обычно.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-20/cell-shader-data/cell-shader-data.unitypackage)
Видимость
---------
Создав основу данных ячеек, мы можем перейти к поддержке видимости. Для этого задействуем шейдер, сами ячейки и объекты, определяющие видимость. Заметьте, что процесс триангуляции совершенно ничего об этом не знает.
### Шейдер
Давайте начнём с того, что сообщим шейдеру *Terrain* о видимости. Он будет получать данные о видимости из вершинной программы и передававать её во фрагментную программу с помощью структуры `Input`. Так как мы передаём три отдельных индекса рельефа, будем передавать и три значения видимости.
```
struct Input {
float4 color : COLOR;
float3 worldPos;
float3 terrain;
float3 visibility;
};
```
Для хранения видимости мы используем первый компонент данных ячеек.
```
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
float4 cell2 = GetCellData(v, 2);
data.terrain.x = cell0.w;
data.terrain.y = cell1.w;
data.terrain.z = cell2.w;
data.visibility.x = cell0.x;
data.visibility.y = cell1.x;
data.visibility.z = cell2.x;
}
```
Видимость, равная 0, означает, что в данный момент ячейка невидима. Если бы она была видима, то имела бы значение видимости 1. Поэтому мы можем затемнить рельеф, умножив результат `GetTerrainColor` на соответствующий вектор видимости. Таким образом мы по отдельности модулируем цвет рельефа каждой смешанной ячейки.
```
float4 GetTerrainColor (Input IN, int index) {
float3 uvw = float3(IN.worldPos.xz * 0.02, IN.terrain[index]);
float4 c = UNITY_SAMPLE_TEX2DARRAY(_MainTex, uvw);
return c * (IN.color[index] * IN.visibility[index]);
}
```
*Ячейки стали чёрными.*
**Разве не можем мы вместо этого комбинировать видимость в вершинной программе?**
Это тоже возможно, и при этом фрагментной программе достаточно будет передавать один показатель видимости. При передаче показателей для каждой участвующей в смешении ячейки три сэмпла рельефа смешиваются изолированно. В результате видимые ячейки будут вносить больший вклад в область смешивания. При использовании одного показателя необходимо сначала выполнить смешение, после чего применяется окончательная интерполированная видимость. Сработают оба подхода, но визуально они будут отличаться.
Полная темнота — это перебор для временно невидимых ячеек. Чтобы мы всё-таки могли видеть рельеф, нужно увеличить показатель, используемый для скрытых ячеек. Давайте перейдём от 0–1 к ¼–1, что можно сделать, воспользовавшись функцией `lerp` в конце вершинной программы.
```
void vert (inout appdata_full v, out Input data) {
…
data.visibility.x = cell0.x;
data.visibility.y = cell1.x;
data.visibility.z = cell2.x;
data.visibility = lerp(0.25, 1, data.visibility);
}
```
*Затемнённые ячейки.*
### Отслеживание видимости ячеек
Чтобы видимость работала, ячейки должны отслеживать свою видимость. Но как ячейка определит, видима ли она? Мы можем сделать это, отслеживая количество видящих её сущностей. Когда кто-то начинает видеть ячейку, он должен сообщить об этом ячейке. А когда кто-то перестаёт видеть ячейку, он тоже должен уведомить её об этом. Ячейка просто отслеживает количество смотрящих, какими бы ни были эти сущности. Если ячейка имеет величину видимости не менее 1, то она видима, в противном случае — невидима. Чтобы реализовать такое поведение, добавим в `HexCell` переменную, два метода и свойство.
```
public bool IsVisible {
get {
return visibility > 0;
}
}
…
int visibility;
…
public void IncreaseVisibility () {
visibility += 1;
}
public void DecreaseVisibility () {
visibility -= 1;
}
```
Далее добавим в `HexCellShaderData` метод `RefreshVisibility`, который делает то же самое, что и `RefreshTerrain`, только для видимости. Сохраним данные в компоненте R данных ячеек. Так как мы работаем с байтами, которые преобразуются в значения 0–1, для обозначения видимости используем `(byte)255`.
```
public void RefreshVisibility (HexCell cell) {
cellTextureData[cell.Index].r = cell.IsVisible ? (byte)255 : (byte)0;
enabled = true;
}
```
Будем вызывать этот метод при увеличении и уменьшении видимости, меняя значение между 0 и 1.
```
public void IncreaseVisibility () {
visibility += 1;
if (visibility == 1) {
ShaderData.RefreshVisibility(this);
}
}
public void DecreaseVisibility () {
visibility -= 1;
if (visibility == 0) {
ShaderData.RefreshVisibility(this);
}
}
```
### Создание области видимости отрядов
Давайте сделаем так, чтобы отряды могли видеть занимаемую ими ячейку. Это реализуется с помощью вызова `IncreaseVisibility` для нового местоположения отряда при задании `HexUnit.Location`. Также вызовем для старого местоположения (если оно существует) `DecreaseVisibility`.
```
public HexCell Location {
get {
return location;
}
set {
if (location) {
location.DecreaseVisibility();
location.Unit = null;
}
location = value;
value.Unit = this;
value.IncreaseVisibility();
transform.localPosition = value.Position;
}
}
```
*Отряды могут видеть, где они находятся.*
Наконец-то мы мы использовали видимость! При добавлении на карту отряды делают свою ячейку видимой. Кроме того, их область видимости телепортируется при перемещении в их новое местоположение. Но их область видимости остаётся активной при удалении отрядов с карты. Чтобы исправить это, будем уменьшать видимость их местоположения при уничтожении отрядов.
```
public void Die () {
if (location) {
location.DecreaseVisibility();
}
location.Unit = null;
Destroy(gameObject);
}
```
### Дальность видимости
Пока мы видим только ячейку, в которой находится отряд, и это ограничивает возможности. Нам как минимум нужно видеть и соседние ячейки. В общем случае отряды могут видеть все ячейки в пределах некоторого расстояния, которое зависит от отряда.
Давайте добавим в `HexGrid` метод для нахождения всех ячеек, видимых из одной ячейки с учётом дальности. Мы можем создать этот метод, продублировав и изменив `Search`. Изменим его параметры и заставим его возвращать список ячеек, для которого можно использовать пул списков.
На каждой итерации в список добавляется текущая ячейка. Конечной ячейки больше нет, поэтому поиск никогда не закончится, достигнув этой точки. Также избавимся от логики ходов и затрат на перемещение. Сделаем так, чтобы свойства `PathFrom` больше не задавались, потому что они нам не нужны, и мы не хотим мешать пути по сетке.
На каждом шаге расстояние просто увеличивается на 1. Если оно превосходит дальность, то эта ячейка пропускается. И нам не нужна поисковая эвристика, поэтому инициализируем её со значением 0. То есть по сути мы вернулись к алгоритму Дейкстры.
```
List GetVisibleCells (HexCell fromCell, int range) {
List visibleCells = ListPool.Get();
searchFrontierPhase += 2;
if (searchFrontier == null) {
searchFrontier = new HexCellPriorityQueue();
}
else {
searchFrontier.Clear();
}
fromCell.SearchPhase = searchFrontierPhase;
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
while (searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
current.SearchPhase += 1;
visibleCells.Add(current);
// if (current == toCell) {
// return true;
// }
// int currentTurn = (current.Distance - 1) / speed;
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
HexCell neighbor = current.GetNeighbor(d);
if (
neighbor == null ||
neighbor.SearchPhase > searchFrontierPhase
) {
continue;
}
// …
// int moveCost;
// …
int distance = current.Distance + 1;
if (distance > range) {
continue;
}
// int turn = (distance - 1) / speed;
// if (turn > currentTurn) {
// distance = turn \* speed + moveCost;
// }
if (neighbor.SearchPhase < searchFrontierPhase) {
neighbor.SearchPhase = searchFrontierPhase;
neighbor.Distance = distance;
// neighbor.PathFrom = current;
neighbor.SearchHeuristic = 0;
searchFrontier.Enqueue(neighbor);
}
else if (distance < neighbor.Distance) {
int oldPriority = neighbor.SearchPriority;
neighbor.Distance = distance;
// neighbor.PathFrom = current;
searchFrontier.Change(neighbor, oldPriority);
}
}
}
return visibleCells;
}
```
**Разве для нахождения всех ячеек в пределах дальности мы не можем использовать более простой алгоритм?**
Можем, но такой подход позволяет нам поддерживать более сложные алгоритмы видимости, которые мы реализуем в будущем туториале.
Также добавим `HexGrid` методы `IncreaseVisibility` и `DecreaseVisibility`. Они получают ячейку и дальность, берут список соответствующих ячеек и увеличивают/уменьшают их видимость. Закончив с этим, они должны вернуть список обратно в его пул.
```
public void IncreaseVisibility (HexCell fromCell, int range) {
List cells = GetVisibleCells(fromCell, range);
for (int i = 0; i < cells.Count; i++) {
cells[i].IncreaseVisibility();
}
ListPool.Add(cells);
}
public void DecreaseVisibility (HexCell fromCell, int range) {
List cells = GetVisibleCells(fromCell, range);
for (int i = 0; i < cells.Count; i++) {
cells[i].DecreaseVisibility();
}
ListPool.Add(cells);
}
```
Чтобы использовать эти методы, `HexUnit` требует доступа к сетке, поэтому добавим ему свойство `Grid`.
```
public HexGrid Grid { get; set; }
```
При добавлении отряда к сетке будет присваивать этому свойству сетку в `HexGrid.AddUnit`.
```
public void AddUnit (HexUnit unit, HexCell location, float orientation) {
units.Add(unit);
unit.Grid = this;
unit.transform.SetParent(transform, false);
unit.Location = location;
unit.Orientation = orientation;
}
```
Для начала будет достаточно дальности видимости в три ячейки. Для этого добавим в `HexUnit` константу, которая в будущем всегда может превратиться в переменную. Затем сделаем так, чтобы отряд вызывал для сетки методы `IncreaseVisibility` и `DecreaseVisibility`, передавая также свою дальность видимости, а не просто переходил в это место.
```
const int visionRange = 3;
…
public HexCell Location {
get {
return location;
}
set {
if (location) {
// location.DecreaseVisibility();
Grid.DecreaseVisibility(location, visionRange);
location.Unit = null;
}
location = value;
value.Unit = this;
// value.IncreaseVisibility();
Grid.IncreaseVisibility(value, visionRange);
transform.localPosition = value.Position;
}
}
…
public void Die () {
if (location) {
// location.DecreaseVisibility();
Grid.DecreaseVisibility(location, visionRange);
}
location.Unit = null;
Destroy(gameObject);
}
```
*Отряды с дальностью видимости, которая может накладываться.*
### Видимость при перемещении
В данный момент область видимости отряда после команды на перемещение сразу же телепортируется в конечную точку. Выглядело бы лучше, если бы отряд и его область видимости двигались вместе. Первый шаг к этому заключается в том, что больше мы не будем задавать свойство `Location` в `HexUnit.Travel`. Вместо этого будем напрямую изменять поле `location`, избегая кода свойства. Поэтому будем вручную очищать старое местоположение и конфигурировать новое место. Видимость оставим без изменений.
```
public void Travel (List path) {
// Location = path[path.Count - 1];
location.Unit = null;
location = path[path.Count - 1];
location.Unit = this;
pathToTravel = path;
StopAllCoroutines();
StartCoroutine(TravelPath());
}
```
Внутри корутины `TravelPath` будем уменьшать видимость первой ячейки только после завершения `LookAt`. После этого, перед перемещением в новую ячейку, будем увеличивать видимость из этой ячейки. Закончив с этим, снова уменьшим видимость из ней. Наконец, увеличим видимость из последней ячейки.
```
IEnumerator TravelPath () {
Vector3 a, b, c = pathToTravel[0].Position;
// transform.localPosition = c;
yield return LookAt(pathToTravel[1].Position);
Grid.DecreaseVisibility(pathToTravel[0], visionRange);
float t = Time.deltaTime * travelSpeed;
for (int i = 1; i < pathToTravel.Count; i++) {
a = c;
b = pathToTravel[i - 1].Position;
c = (b + pathToTravel[i].Position) * 0.5f;
Grid.IncreaseVisibility(pathToTravel[i], visionRange);
for (; t < 1f; t += Time.deltaTime * travelSpeed) {
…
}
Grid.DecreaseVisibility(pathToTravel[i], visionRange);
t -= 1f;
}
a = c;
b = location.Position; // We can simply use the destination here.
c = b;
Grid.IncreaseVisibility(location, visionRange);
for (; t < 1f; t += Time.deltaTime * travelSpeed) {
…
}
…
}
```
*Видимость при движении.*
Всё это работает, за исключением ситуации, когда новый приказ отдаётся в момент движения отряда. Это приводит к телепортации, которая должна применяться и к видимости. Чтобы реализовать это, нам нужно отслеживать при движении текущее местоположение отряда.
```
HexCell location, currentTravelLocation;
```
Будем обновлять это местоположение каждый раз при попадании в новую ячейку во время движения, пока отряд не доберётся до конечной ячейки. После чего его необходимо сбросить.
```
IEnumerator TravelPath () {
…
for (int i = 1; i < pathToTravel.Count; i++) {
currentTravelLocation = pathToTravel[i];
a = c;
b = pathToTravel[i - 1].Position;
c = (b + currentTravelLocation.Position) * 0.5f;
Grid.IncreaseVisibility(pathToTravel[i], visionRange);
for (; t < 1f; t += Time.deltaTime * travelSpeed) {
transform.localPosition = Bezier.GetPoint(a, b, c, t);
Vector3 d = Bezier.GetDerivative(a, b, c, t);
d.y = 0f;
transform.localRotation = Quaternion.LookRotation(d);
yield return null;
}
Grid.DecreaseVisibility(pathToTravel[i], visionRange);
t -= 1f;
}
currentTravelLocation = null;
…
}
```
Теперь после завершения поворота в `TravelPath` мы можем проверять, известно ли старое промежуточное местоположение пути. Если да, то нужно уменьшить видимость в этой ячейке, а не в начале пути.
```
IEnumerator TravelPath () {
Vector3 a, b, c = pathToTravel[0].Position;
yield return LookAt(pathToTravel[1].Position);
Grid.DecreaseVisibility(
currentTravelLocation ? currentTravelLocation : pathToTravel[0],
visionRange
);
…
}
```
Также нам нужно исправлять видимость после рекомпиляции, произошедшей в процессе движения отряда. Если промежуточное местоположение всё ещё известно, то уменьшаем видимость в нём и увеличиваем видимость в конечной точке, а затем сбрасываем промежуточное местоположение.
```
void OnEnable () {
if (location) {
transform.localPosition = location.Position;
if (currentTravelLocation) {
Grid.IncreaseVisibility(location, visionRange);
Grid.DecreaseVisibility(currentTravelLocation, visionRange);
currentTravelLocation = null;
}
}
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-20/visibility/visibility.unitypackage)
Видимость дорог и воды
----------------------
Хотя изменения цвета рельефа основаны на видимости, дорог и воды это не затрагивает. Они выглядят слишком яркими для невидимых ячеек. Чтобы применить видимость к дорогам и воде, нам нужно добавить индексы ячеек и веса смешения и к их данным мешей. Поэтому проверим дочерние элементы *Use Cell Data* for the *Rivers*, *Roads*, *Water*, *Water Shore* и *Estuaries* префаба фрагмента.
### Дороги
Мы начнём с дорог. Метод `HexGridChunk.TriangulateRoadEdge` используется для создания небольшой части дороги в центре ячейки, поэтому ему нужен один индекс ячейки. Добавим ему параметр и сгенерируем данные ячеек для треугольника.
```
void TriangulateRoadEdge (
Vector3 center, Vector3 mL, Vector3 mR, float index
) {
roads.AddTriangle(center, mL, mR);
roads.AddTriangleUV(
new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f)
);
Vector3 indices;
indices.x = indices.y = indices.z = index;
roads.AddTriangleCellData(indices, weights1);
}
```
Ещё одним простым методом создания дорог является `TriangulateRoadSegment`. Он используется и внутри, и между ячейками, поэтому должен работать с двумя различными индексами. Для этого удобно использовать параметр вектора индексов. Так как сегменты дорог могут быть частями уступов, то веса тоже должны передаваться через параметры.
```
void TriangulateRoadSegment (
Vector3 v1, Vector3 v2, Vector3 v3,
Vector3 v4, Vector3 v5, Vector3 v6,
Color w1, Color w2, Vector3 indices
) {
roads.AddQuad(v1, v2, v4, v5);
roads.AddQuad(v2, v3, v5, v6);
roads.AddQuadUV(0f, 1f, 0f, 0f);
roads.AddQuadUV(1f, 0f, 0f, 0f);
roads.AddQuadCellData(indices, w1, w2);
roads.AddQuadCellData(indices, w1, w2);
}
```
Теперь перейдём к `TriangulateRoad`, который создаёт дороги внутри ячеек. Ему также нужен параметр индекса. Он передаёт эти данные вызываемым им методам дорог, и добавляет их к треугольникам, которые создаёт сам.
```
void TriangulateRoad (
Vector3 center, Vector3 mL, Vector3 mR,
EdgeVertices e, bool hasRoadThroughCellEdge, float index
) {
if (hasRoadThroughCellEdge) {
Vector3 indices;
indices.x = indices.y = indices.z = index;
Vector3 mC = Vector3.Lerp(mL, mR, 0.5f);
TriangulateRoadSegment(
mL, mC, mR, e.v2, e.v3, e.v4,
weights1, weights1, indices
);
roads.AddTriangle(center, mL, mC);
roads.AddTriangle(center, mC, mR);
roads.AddTriangleUV(
new Vector2(1f, 0f), new Vector2(0f, 0f), new Vector2(1f, 0f)
);
roads.AddTriangleUV(
new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(0f, 0f)
);
roads.AddTriangleCellData(indices, weights1);
roads.AddTriangleCellData(indices, weights1);
}
else {
TriangulateRoadEdge(center, mL, mR, index);
}
}
```
Осталось добавить требуемые аргументы методов в `TriangulateRoad`, `TriangulateRoadEdge` и `TriangulateRoadSegment`, чтобы исправить все ошибки компилятора.
```
void TriangulateWithoutRiver (
HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e
) {
TriangulateEdgeFan(center, e, cell.Index);
if (cell.HasRoads) {
Vector2 interpolators = GetRoadInterpolators(direction, cell);
TriangulateRoad(
center,
Vector3.Lerp(center, e.v1, interpolators.x),
Vector3.Lerp(center, e.v5, interpolators.y),
e, cell.HasRoadThroughEdge(direction), cell.Index
);
}
}
…
void TriangulateRoadAdjacentToRiver (
HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e
) {
…
TriangulateRoad(roadCenter, mL, mR, e, hasRoadThroughEdge, cell.Index);
if (previousHasRiver) {
TriangulateRoadEdge(roadCenter, center, mL, cell.Index);
}
if (nextHasRiver) {
TriangulateRoadEdge(roadCenter, mR, center, cell.Index);
}
}
…
void TriangulateEdgeStrip (
…
) {
…
if (hasRoad) {
TriangulateRoadSegment(
e1.v2, e1.v3, e1.v4, e2.v2, e2.v3, e2.v4, w1, w2, indices
);
}
}
```
Теперь данные мешей верны, и мы перейдём к шейдеру *Road*. Ему нужна вершинная программа и он должен содержать *HexCellData*.
```
#pragma surface surf Standard fullforwardshadows decal:blend vertex:vert
#pragma target 3.0
#include "HexCellData.cginc"
```
Так как мы не смешиваем несколько материалов, нам будет достаточно передавать в фрагментную программу один показатель видимости.
```
struct Input {
float2 uv_MainTex;
float3 worldPos;
float visibility;
};
```
Новой вершинной программе достаточно получать данные двух ячеек. Мы сразу же смешиваем их видимость, настраиваем её и прибавляем к выходным данным.
```
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
data.visibility = cell0.x * v.color.x + cell1.x * v.color.y;
data.visibility = lerp(0.25, 1, data.visibility);
}
```
Во фрагментной программе нам достаточно только добавить видимость к цвету.
```
void surf (Input IN, inout SurfaceOutputStandard o) {
float4 noise = tex2D(_MainTex, IN.worldPos.xz * 0.025);
fixed4 c = _Color * ((noise.y * 0.75 + 0.25) * IN.visibility);
…
}
```
*Дороги с видимостью.*
### Открытая вода
Может показаться, что на воду уже повлияла видимость, но это всего лишь поверхность погружённого в воду рельефа. Давайте начнём с того, что применим видимость к открытой воде. Для этого нам нужно изменить `HexGridChunk.TriangulateOpenWater`.
```
void TriangulateOpenWater (
HexDirection direction, HexCell cell, HexCell neighbor, Vector3 center
) {
…
water.AddTriangle(center, c1, c2);
Vector3 indices;
indices.x = indices.y = indices.z = cell.Index;
water.AddTriangleCellData(indices, weights1);
if (direction <= HexDirection.SE && neighbor != null) {
…
water.AddQuad(c1, c2, e1, e2);
indices.y = neighbor.Index;
water.AddQuadCellData(indices, weights1, weights2);
if (direction <= HexDirection.E) {
…
water.AddTriangle(
c2, e2, c2 + HexMetrics.GetWaterBridge(direction.Next())
);
indices.z = nextNeighbor.Index;
water.AddTriangleCellData(
indices, weights1, weights2, weights3
);
}
}
}
```
Также нам нужно добавить данные ячеек к веерам треугольников рядом с побережьями.
```
void TriangulateWaterShore (
HexDirection direction, HexCell cell, HexCell neighbor, Vector3 center
) {
…
water.AddTriangle(center, e1.v1, e1.v2);
water.AddTriangle(center, e1.v2, e1.v3);
water.AddTriangle(center, e1.v3, e1.v4);
water.AddTriangle(center, e1.v4, e1.v5);
Vector3 indices;
indices.x = indices.y = indices.z = cell.Index;
water.AddTriangleCellData(indices, weights1);
water.AddTriangleCellData(indices, weights1);
water.AddTriangleCellData(indices, weights1);
water.AddTriangleCellData(indices, weights1);
…
}
```
Шейдер *Water* нужно изменить таким же образом, как и шейдер *Road*, но в нём нужно сочетать видимость не двух, а трёх ячеек.
```
#pragma surface surf Standard alpha vertex:vert
#pragma target 3.0
#include "Water.cginc"
#include "HexCellData.cginc"
sampler2D _MainTex;
struct Input {
float2 uv_MainTex;
float3 worldPos;
float visibility;
};
…
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
float4 cell2 = GetCellData(v, 2);
data.visibility =
cell0.x * v.color.x + cell1.x * v.color.y + cell2.x * v.color.z;
data.visibility = lerp(0.25, 1, data.visibility);
}
void surf (Input IN, inout SurfaceOutputStandard o) {
float waves = Waves(IN.worldPos.xz, _MainTex);
fixed4 c = saturate(_Color + waves);
o.Albedo = c.rgb * IN.visibility;
…
}
```
*Открытая вода с видимостью.*
### Побережья и устья
Для поддержки побережья нам нужно снова изменить `HexGridChunk.TriangulateWaterShore`. Мы уже создали вектор индексов, но использовали только один индекс ячейки для открытой воды. Побережьям также нужен индекс соседа, поэтому изменим код.
```
Vector3 indices;
// indices.x = indices.y = indices.z = cell.Index;
indices.x = indices.z = cell.Index;
indices.y = neighbor.Index;
```
Добавим данные ячеек к quad-ам и треугольнику побережья. Также передадим индексы при вызове `TriangulateEstuary`.
```
if (cell.HasRiverThroughEdge(direction)) {
TriangulateEstuary(
e1, e2, cell.IncomingRiver == direction, indices
);
}
else {
…
waterShore.AddQuadUV(0f, 0f, 0f, 1f);
waterShore.AddQuadCellData(indices, weights1, weights2);
waterShore.AddQuadCellData(indices, weights1, weights2);
waterShore.AddQuadCellData(indices, weights1, weights2);
waterShore.AddQuadCellData(indices, weights1, weights2);
}
HexCell nextNeighbor = cell.GetNeighbor(direction.Next());
if (nextNeighbor != null) {
…
waterShore.AddTriangleUV(
…
);
indices.z = nextNeighbor.Index;
waterShore.AddTriangleCellData(
indices, weights1, weights2, weights3
);
}
```
Добавим необходимый параметр в `TriangulateEstuary` и займёмся данными ячеек для побережья и устья. Не забывайте, что устья созданы из трапецоида с двумя треугольниками побережья по бокам. Сделаем так, чтобы веса передавались в верном порядке.
```
void TriangulateEstuary (
EdgeVertices e1, EdgeVertices e2, bool incomingRiver, Vector3 indices
) {
waterShore.AddTriangle(e2.v1, e1.v2, e1.v1);
waterShore.AddTriangle(e2.v5, e1.v5, e1.v4);
waterShore.AddTriangleUV(
new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(0f, 0f)
);
waterShore.AddTriangleUV(
new Vector2(0f, 1f), new Vector2(0f, 0f), new Vector2(0f, 0f)
);
waterShore.AddTriangleCellData(indices, weights2, weights1, weights1);
waterShore.AddTriangleCellData(indices, weights2, weights1, weights1);
estuaries.AddQuad(e2.v1, e1.v2, e2.v2, e1.v3);
estuaries.AddTriangle(e1.v3, e2.v2, e2.v4);
estuaries.AddQuad(e1.v3, e1.v4, e2.v4, e2.v5);
estuaries.AddQuadUV(
new Vector2(0f, 1f), new Vector2(0f, 0f),
new Vector2(1f, 1f), new Vector2(0f, 0f)
);
estuaries.AddTriangleUV(
new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(1f, 1f)
);
estuaries.AddQuadUV(
new Vector2(0f, 0f), new Vector2(0f, 0f),
new Vector2(1f, 1f), new Vector2(0f, 1f)
);
estuaries.AddQuadCellData(
indices, weights2, weights1, weights2, weights1
);
estuaries.AddTriangleCellData(indices, weights1, weights2, weights2);
estuaries.AddQuadCellData(indices, weights1, weights2);
…
}
```
В шейдер *WaterShore* нужно внести такие же изменения, что и в шейдер *Water*, смешав видимость трёх ячеек.
```
#pragma surface surf Standard alpha vertex:vert
#pragma target 3.0
#include "Water.cginc"
#include "HexCellData.cginc"
sampler2D _MainTex;
struct Input {
float2 uv_MainTex;
float3 worldPos;
float visibility;
};
…
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
float4 cell2 = GetCellData(v, 2);
data.visibility =
cell0.x * v.color.x + cell1.x * v.color.y + cell2.x * v.color.z;
data.visibility = lerp(0.25, 1, data.visibility);
}
void surf (Input IN, inout SurfaceOutputStandard o) {
…
fixed4 c = saturate(_Color + max(foam, waves));
o.Albedo = c.rgb * IN.visibility;
…
}
```
Шайдер *Estuary* смешивает видимость двух ячеек, как и шейдер *Road*. У него уже есть вершинная программа, потому что нам нужно, чтобы он передавал UV-координаты рек.
```
#include "Water.cginc"
#include "HexCellData.cginc"
sampler2D _MainTex;
struct Input {
float2 uv_MainTex;
float2 riverUV;
float3 worldPos;
float visibility;
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
void vert (inout appdata_full v, out Input o) {
UNITY_INITIALIZE_OUTPUT(Input, o);
o.riverUV = v.texcoord1.xy;
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
o.visibility = cell0.x * v.color.x + cell1.x * v.color.y;
o.visibility = lerp(0.25, 1, o.visibility);
}
void surf (Input IN, inout SurfaceOutputStandard o) {
…
fixed4 c = saturate(_Color + water);
o.Albedo = c.rgb * IN.visibility;
…
}
```
*Побережья и устья с видимостью.*
### Реки
Последние водные регионы, с которыми нужно поработать — это реки. Добавим в `HexGridChunk.TriangulateRiverQuad` параметр вектора индексов и добавим его к мешу, чтобы он мог поддерживать видимость двух ячеек.
```
void TriangulateRiverQuad (
Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4,
float y, float v, bool reversed, Vector3 indices
) {
TriangulateRiverQuad(v1, v2, v3, v4, y, y, v, reversed, indices);
}
void TriangulateRiverQuad (
Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4,
float y1, float y2, float v, bool reversed, Vector3 indices
) {
…
rivers.AddQuadCellData(indices, weights1, weights2);
}
```
`TriangulateWithRiverBeginOrEnd` создаёт конечные точки рек с quad-ом и треугольником в центре ячейки. Добавим для этого необходимые данные ячеек.
```
void TriangulateWithRiverBeginOrEnd (
HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e
) {
…
if (!cell.IsUnderwater) {
bool reversed = cell.HasIncomingRiver;
Vector3 indices;
indices.x = indices.y = indices.z = cell.Index;
TriangulateRiverQuad(
m.v2, m.v4, e.v2, e.v4,
cell.RiverSurfaceY, 0.6f, reversed, indices
);
center.y = m.v2.y = m.v4.y = cell.RiverSurfaceY;
rivers.AddTriangle(center, m.v2, m.v4);
…
rivers.AddTriangleCellData(indices, weights1);
}
}
```
У нас уже есть эти индексы ячеек в `TriangulateWithRiver`, поэтому просто передадим их при вызове `TriangulateRiverQuad`.
```
void TriangulateWithRiver (
HexDirection direction, HexCell cell, Vector3 center, EdgeVertices e
) {
…
if (!cell.IsUnderwater) {
bool reversed = cell.IncomingRiver == direction;
TriangulateRiverQuad(
centerL, centerR, m.v2, m.v4,
cell.RiverSurfaceY, 0.4f, reversed, indices
);
TriangulateRiverQuad(
m.v2, m.v4, e.v2, e.v4,
cell.RiverSurfaceY, 0.6f, reversed, indices
);
}
}
```
Также добавим поддержку индексов водопадам, которые вливаются в глубокую воду.
```
void TriangulateWaterfallInWater (
Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4,
float y1, float y2, float waterY, Vector3 indices
) {
…
rivers.AddQuadCellData(indices, weights1, weights2);
}
```
И, наконец, изменим `TriangulateConnection` так, чтобы он передавал необходимые индексы методам рек и водопадов.
```
void TriangulateConnection (
HexDirection direction, HexCell cell, EdgeVertices e1
) {
…
if (hasRiver) {
e2.v3.y = neighbor.StreamBedY;
Vector3 indices;
indices.x = indices.z = cell.Index;
indices.y = neighbor.Index;
if (!cell.IsUnderwater) {
if (!neighbor.IsUnderwater) {
TriangulateRiverQuad(
e1.v2, e1.v4, e2.v2, e2.v4,
cell.RiverSurfaceY, neighbor.RiverSurfaceY, 0.8f,
cell.HasIncomingRiver && cell.IncomingRiver == direction,
indices
);
}
else if (cell.Elevation > neighbor.WaterLevel) {
TriangulateWaterfallInWater(
e1.v2, e1.v4, e2.v2, e2.v4,
cell.RiverSurfaceY, neighbor.RiverSurfaceY,
neighbor.WaterSurfaceY, indices
);
}
}
else if (
!neighbor.IsUnderwater &&
neighbor.Elevation > cell.WaterLevel
) {
TriangulateWaterfallInWater(
e2.v4, e2.v2, e1.v4, e1.v2,
neighbor.RiverSurfaceY, cell.RiverSurfaceY,
cell.WaterSurfaceY, indices
);
}
}
…
}
```
В шейдер *River* нужно внести те же изменения, что и в шейдер *Road*.
```
#pragma surface surf Standard alpha vertex:vert
#pragma target 3.0
#include "Water.cginc"
#include "HexCellData.cginc"
sampler2D _MainTex;
struct Input {
float2 uv_MainTex;
float visibility;
};
…
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float4 cell0 = GetCellData(v, 0);
float4 cell1 = GetCellData(v, 1);
data.visibility = cell0.x * v.color.x + cell1.x * v.color.y;
data.visibility = lerp(0.25, 1, data.visibility);
}
void surf (Input IN, inout SurfaceOutputStandard o) {
float river = River(IN.uv_MainTex, _MainTex);
fixed4 c = saturate(_Color + river);
o.Albedo = c.rgb * IN.visibility;
…
}
```
*Реки с видимостью.*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-20/visibility-of-roads-and-water/visibility-of-roads-and-water.unitypackage)
Объекты и видимость
-------------------
Теперь видимость работает для всего процедурно генерируемого рельефа, но на объекты рельефа она пока не влияет. Здания, фермы и деревья созданы из префабов, а не из процедурной геометрии, поэтому мы не можем добавить индексы ячеек и смешать веса с их вершинами. Так как каждый из этих объектов принадлежит только к одной ячейке, нам нужно определить, в какой ячейке они находятся. Если мы сможем это сделать, то получим доступ к данным соответствующих ячеек и применим видимость.
Мы уже можем преобразовать позиции XZ мира в индексы ячеек. Это преобразование использовалось для редактирования рельефа и управления отрядами. Однако соответствующий ему код нетривиален. В нём используются целочисленные операции и требуется логика для работы с рёбрами. Для шейдера это применять непрактично, поэтому мы можем запечь основную часть логики в текстуру и использовать её.
Мы уже используем текстуру с шестиугольным паттерном для проецирования сетки поверх рельефа. Эта текстура задаёт область ячеек 2×2. Поэтому можно легко вычислить, в какой области мы находимся. После этого можно применить текстуру, содержащую смещения по X и Z для ячеек в этой области и использовать эти данные для вычисления ячейки, в которой мы находимся.
Вот подобная текстура. Смещение по X хранится в её красном канале, а смещение по Z — в зелёном канале. Так как она покрывает область ячеек 2×2, то нам нужны смещения от 0 и 2. Такие данные нельзя хранить в цветовом канале, поэтому смещения уменьшаются наполовину. Нам не нужны чёткие края ячеек, поэтому вполне достаточно маленькой текстуры.
*Текстура координат сетки.*
Добавим текстуру в проект. Зададим для её *Wrap Mode* значение *Repeat*, как и у другой текстуры сетки. Нам не нужно никакого смешивания, поэтому для *Blend Mode* выберем значение *Point*. Также отключим *Compression*, чтобы данные не искажались. Отключим режим *sRGB*, чтобы при рендеринге в линейном режиме не выполнялось никаких преобразований цветовых пространств. И, наконец, нам не нужны mip-текстуры.
*Параметры импорта текстуры.*
### Шейдер объектов с видимостью
Создадим новый шейдер *Feature*, чтобы добавить объектам поддержку видимости. Это простой поверхностный шейдер с вершинной программой. Добавим в него *HexCellData* и передадим показатель видимости во фрагментную программу, и как обычно учтём его в цвете. Отличие здесь заключается в том, что мы не можем использовать `GetCellData`, потому что требуемых данных мешей не существует. Вместо них у нас есть позиция в мире. Но пока оставим видимость равной 1.
```
Shader "Custom/Feature" {
Properties {
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
[NoTilingOffset] _GridCoordinates ("Grid Coordinates", 2D) = "white" {}
}
SubShader {
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Standard fullforwardshadows vertex:vert
#pragma target 3.0
#include "../HexCellData.cginc"
sampler2D _MainTex, _GridCoordinates;
half _Glossiness;
half _Metallic;
fixed4 _Color;
struct Input {
float2 uv_MainTex;
float visibility;
};
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float3 pos = mul(unity_ObjectToWorld, v.vertex);
data.visibility = 1;
}
void surf (Input IN, inout SurfaceOutputStandard o) {
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb * IN.visibility;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}
```
Изменим все материалы объектов так, чтобы они использовали новый шейдер, и назначим им текстуру координат сетки.
*Урбанистический с текстурой сетки.*
### Доступ к данным ячеек
Чтобы сэмплировать текстуру координат сетки в вершинной программе, нам снова потребуется `tex2Dlod` с четырёхкомпонентным вектором координат текстуры. Первые две координаты — это позиция XZ мира. Две другие как и раньше равны нулю.
```
void vert (inout appdata_full v, out Input data) {
UNITY_INITIALIZE_OUTPUT(Input, data);
float3 pos = mul(unity_ObjectToWorld, v.vertex);
float4 gridUV = float4(pos.xz, 0, 0);
data.visibility = 1;
}
```
Как и в шейдере *Terrain*, растянем UV-координаты, чтобы текстура имела правильное соотношение сторон, соответствующее сетке шестиугольников.
```
float4 gridUV = float4(pos.xz, 0, 0);
gridUV.x *= 1 / (4 * 8.66025404);
gridUV.y *= 1 / (2 * 15.0);
```
Мы можем выяснить, в какой части ячеек 2×2 находимся, взяв округлённое вниз значение UV-координат. Это формирует базис координат ячеек.
```
float4 gridUV = float4(pos.xz, 0, 0);
gridUV.x *= 1 / (4 * 8.66025404);
gridUV.y *= 1 / (2 * 15.0);
float2 cellDataCoordinates = floor(gridUV.xy);
```
Чтобы найти координаты ячейки, в которой мы находимся, прибавим хранящиеся в текстуре смещения.
```
float2 cellDataCoordinates =
floor(gridUV.xy) + tex2Dlod(_GridCoordinates, gridUV).rg;
```
Так как часть сетки имеет размер 2×2, а смещения уменьшены вдвое, нам нужно удвоить результат, чтобы получить окончательные координаты.
```
float2 cellDataCoordinates =
floor(gridUV.xy) + tex2Dlod(_GridCoordinates, gridUV).rg;
cellDataCoordinates *= 2;
```
Теперь у нас есть координаты XZ сетки ячеек, которые нужно преобразовать в UV-координаты данных ячеек. Это можно сделать, просто сдвинувшись к центрам пикселей, а затем разделить на размеры текстур. Так что давайте добавим в include-файл *HexCellData* функцию для этого, которая также займётся сэмплированием.
```
float4 GetCellData (float2 cellDataCoordinates) {
float2 uv = cellDataCoordinates + 0.5;
uv.x *= _HexCellData_TexelSize.x;
uv.y *= _HexCellData_TexelSize.y;
return tex2Dlod(_HexCellData, float4(uv, 0, 0));
}
```
Теперь мы можем использовать эту функцию в вершинной программе шейдера *Feature*.
```
cellDataCoordinates *= 2;
data.visibility = GetCellData(cellDataCoordinates).x;
data.visibility = lerp(0.25, 1, data.visibility);
```
*Объекты с видимостью.*
Наконец-то видимость влияет на всю карту, за исключением отрядов, которые видимы всегда. Так как мы определяем видимость объектов для каждой вершины, то для объекта, пересекающего границу ячейки, будет выполнено смешение видимостей закрываемых им ячеек. Но объекты так малы, что постоянно остаются внутри своей ячейки, даже с учётом искажений позиций. Однако некоторые могут оказаться частью вершин в другой ячейке. Поэтому наш подход дёшев, но неидеален. Больше всего это заметно в случае стен, видимость которых колеблется между видимостями соседних ячеек.
*Стены с меняющейся видимостью.*
Так как сегменты стен генерируются процедурно, мы можем добавить к их мешу данные ячеек и использовать подход, который мы применяли для рельефа. К сожалению, башни являются префабами, поэтому у нас всё равно будут несоответствия. В общем виде существующий подход выглядит достаточно хорошо для используемой нами простой геометрии. В дальнейшем мы рассмотрим более детализированные модели и стены, поэтому усовершенствуем способ смешения их видимости.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-20/features/features.unitypackage)
Часть 21: исследование карты
============================
* Отображаем всё во время редактирования.
* Отслеживаем исследованные ячейки.
* Скрываем то, что пока неизвестно.
* Заставляем отряды избегать неисследованные области.
В предыдущей части мы добавили туман войны, который теперь усовершенствуем, чтобы реализовать исследование карты.
*Мы готовы исследовать мир.*
Отображение всей карты в режиме редактирования
----------------------------------------------
Смысл исследования заключается в том, что пока не увиденные ячейки считаются неизвестными, а значит невидимыми. Они должны не затеняться, а вообще не отображаться. Поэтому прежде чем добавить поддержку исследования, мы включим видимость в режиме редактирования.
### Переключение режима видимости
Мы можем управлять тем, применяют ли шейдеры видимость, при помощи ключевого слова, как это делалось с наложением на сетку. Давайте используем ключевое слово *HEX\_MAP\_EDIT\_MODE*, обозначающее состояние режима редактирования. Так как об этом ключевом слове должно знать несколько шейдеров, мы определим его глобально, с помощью статических методов `Shader.EnableKeyWord` и `Shader.DisableKeyword`. Будем вызывать соответствующий метод в `HexGameUI.SetEditMode` при изменении режима редактирования.
```
public void SetEditMode (bool toggle) {
enabled = !toggle;
grid.ShowUI(!toggle);
grid.ClearPath();
if (toggle) {
Shader.EnableKeyword("HEX_MAP_EDIT_MODE");
}
else {
Shader.DisableKeyword("HEX_MAP_EDIT_MODE");
}
}
```
### Шейдеры режима редактирования
Когда *HEX\_MAP\_EDIT\_MODE* определено, шейдеры будут игнорировать видимость. Это сводится к тому, что видимость ячейки всегда будет считаться равной 1. Давайте добавим в начало include-файла *HexCellData* функцию для фильтрации данных ячеек в зависимости от ключевого слова.
```
sampler2D _HexCellData;
float4 _HexCellData_TexelSize;
float4 FilterCellData (float4 data) {
#if defined(HEX_MAP_EDIT_MODE)
data.x = 1;
#endif
return data;
}
```
Передадим через эту функцию результат обеих функций `GetCellData` перед его возвратом.
```
float4 GetCellData (appdata_full v, int index) {
…
return FilterCellData(data);
}
float4 GetCellData (float2 cellDataCoordinates) {
…
return FilterCellData(tex2Dlod(_HexCellData, float4(uv, 0, 0)));
}
```
Чтобы всё заработало, все соответствующие шейдеры должны получить директиву multi\_compile для создания вариантов на случай, когда ключевое слово *HEX\_MAP\_EDIT\_MODE* определено. Добавим соответствующую строку в шейдеры *Estuary*, *Feature*, *River*, *Road*, *Terrain*, *Water* и *Water Shore*, между директивой target и первой директивой include.
```
#pragma multi_compile _ HEX_MAP_EDIT_MODE
```
Теперь при переключении в режим редактирования карты туман войны будет пропадать.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-21/seeing-everything-in-edit-mode/seeing-everything-in-edit-mode.unitypackage)
Исследование ячеек
------------------
По умолчанию ячейки должны считаться неисследованными. Они становятся исследованными, когда их увидит отряд. После этого они продолжают оставаться исследованными, если их может видеть отряд.
### Отслеживание состояния исследования
Чтобы добавить поддержку отслеживания состояния исследования добавим в `HexCell` общее свойство `IsExplored`.
```
public bool IsExplored { get; set; }
```
Состояние исследования определяется самой ячейкой. Поэтому это свойство должно задаваться только `HexCell`. Чтобы добавить такое ограничение, сделаем сеттер частным.
```
public bool IsExplored { get; private set; }
```
В первый раз, когда видимость ячейки становится больше нуля, ячейка начинает считаться исследованной, а потому `IsExplored` должно присваиваться значение `true`. На самом деле, нам будет достаточно просто помечать ячейку как исследованную, когда видимость увеличивается до 1. Это необходимо делать до вызова `RefreshVisibility`.
```
public void IncreaseVisibility () {
visibility += 1;
if (visibility == 1) {
IsExplored = true;
ShaderData.RefreshVisibility(this);
}
}
```
### Передача состояния исследования шейдерам
Как и в случае с видимостью ячеек, мы передаём их состояние исследования шейдерам через данные шейдера. В конце концов, это просто ещё один тип видимости. `HexCellShaderData.RefreshVisibility` хранит состояние видимости в канале R данных. Давайте будем хранить состояние исследования в канале G данных.
```
public void RefreshVisibility (HexCell cell) {
int index = cell.Index;
cellTextureData[index].r = cell.IsVisible ? (byte)255 : (byte)0;
cellTextureData[index].g = cell.IsExplored ? (byte)255 : (byte)0;
enabled = true;
}
```
### Чёрный неисследованный рельеф
Теперь для визуализации состояния исследования ячеек мы можем использовать шейдеры. Чтобы убедиться, что всё работает как нужно, мы просто сделаем неисследованный рельеф чёрным. Но сначала, чтобы сделать режим редактирования рабочим, изменим `FilterCellData` так, чтобы он отфильтровывал данные исследования.
```
float4 FilterCellData (float4 data) {
#if defined(HEX_MAP_EDIT_MODE)
data.xy = 1;
#endif
return data;
}
```
Шейдер *Terrain* передаёт данные видимости всех трёх возможных ячеек во фрагментную программу. В случае состояния исследования мы комбинируем их в вершинной программе и передаём во фрагментную программу единственное значение. Добавим во входящие данные `visibility` четвёртый компонент, чтобы у нас было для этого место.
```
struct Input {
float4 color : COLOR;
float3 worldPos;
float3 terrain;
float4 visibility;
};
```
Теперь в вершинной программе при изменении показателя видимости мы должны явным образом получить доступ к `data.visibility.xyz`.
```
void vert (inout appdata_full v, out Input data) {
…
data.visibility.xyz = lerp(0.25, 1, data.visibility.xyz);
}
```
После этого скомбинируем состояния исследования и запишем результат в `data.visibility.w`. Это выполняется аналогично комбинированию видимости в других шейдерах, но с использованием компонента Y данных ячеек.
```
data.visibility.xyz = lerp(0.25, 1, data.visibility.xyz);
data.visibility.w =
cell0.y * v.color.x + cell1.y * v.color.y + cell2.y * v.color.z;
```
Состояние исследования теперь доступно во фрагментной программе через `IN.visibility.w`. Учтём его в вычислении albedo.
```
void surf (Input IN, inout SurfaceOutputStandard o) {
…
float explored = IN.visibility.w;
o.Albedo = c.rgb * grid * _Color * explored;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
```
*Неисследованный рельеф теперь чёрный.*
Рельеф неисследованных ячеек теперь имеет чёрный цвет. Но на объекты, дороги и воду это пока не повлияло. Однако этого достаточно, чтобы убедиться в том, что исследование работает.
### Сохранение и загрузка состояния исследования
Теперь, когда мы добавили поддержку исследования, нам нужно сделать так, чтобы состояние исследования учитывалось при сохранении и загрузке карт. Поэтому нам нужно увеличить версию файлов карт до 3. Чтобы сделать эти изменения более удобными, давайте добавим для этого в `SaveLoadMenu` константу.
```
const int mapFileVersion = 3;
```
Будем использовать эту константу при записи версии файла в `Save` и при проверке поддержки файла в `Load`.
```
void Save (string path) {
using (
BinaryWriter writer =
new BinaryWriter(File.Open(path, FileMode.Create))
) {
writer.Write(mapFileVersion);
hexGrid.Save(writer);
}
}
void Load (string path) {
if (!File.Exists(path)) {
Debug.LogError("File does not exist " + path);
return;
}
using (BinaryReader reader = new BinaryReader(File.OpenRead(path))) {
int header = reader.ReadInt32();
if (header <= mapFileVersion) {
hexGrid.Load(reader, header);
HexMapCamera.ValidatePosition();
}
else {
Debug.LogWarning("Unknown map format " + header);
}
}
}
```
В качестве последнего шага `HexCell.Save` мы запишем состояние исследования.
```
public void Save (BinaryWriter writer) {
…
writer.Write(IsExplored);
}
```
И будем считывать его в конце `Load`. После этого будем вызывать `RefreshVisibility` на случай, если состояние исследования отличается от предыдущего.
```
public void Load (BinaryReader reader) {
…
IsExplored = reader.ReadBoolean();
ShaderData.RefreshVisibility(this);
}
```
Для сохранения обратной совместимости со старыми файлами сохранений, нам нужно пропускать считывание состояния сохранения, если версия файла меньше 3. Давайте в таком случае по умолчанию ячейки будут иметь состояние «неисследованная». Чтобы нам это сделать, нужно добавить в качестве параметра `Load` данные заголовка.
```
public void Load (BinaryReader reader, int header) {
…
IsExplored = header >= 3 ? reader.ReadBoolean() : false;
ShaderData.RefreshVisibility(this);
}
```
Теперь `HexGrid.Load` должен будет передавать в `HexCell.Load` данные заголовка.
```
public void Load (BinaryReader reader, int header) {
…
for (int i = 0; i < cells.Length; i++) {
cells[i].Load(reader, header);
}
…
}
```
Теперь при сохранении и загрузке карт состояние исследованности ячеек будет учитываться.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-21/exploring-cells/exploring-cells.unitypackage)
Скрываем неизвестные ячейки
---------------------------
На текущем этапе неисследованные ячейки визуально обозначаются чёрным рельефом. Но на самом деле мы хотим, чтобы эти ячейки были невидимы, потому что они неизвестны. Мы можем сделать непрозрачную геометрию прозрачной, чтобы её не было видно. Однако фреймворк поверхностных шейдеров Unity разрабатывался без учёта такой возможности. Вместо использования настоящей прозрачности мы изменим шейдеры так, чтобы они соответствовали фону, что тоже сделает их незаметными.
### Делаем рельеф по-настоящему чёрным
Хотя исследованный рельеф имеет чёрный цвет, мы всё равно можем распознать его, потому что он до сих пор имеет specular lighting. Чтобы избавиться от освещения, нам нужно сделать его идеально матово-чёрным. Чтобы не затрагивать при этом другие свойства поверхности, проще всего изменить specular color на чёрный. Это возможно, если использовать поверхностный шейдер, работающий со specular, но сейчас мы используем стандартный metallic. Поэтому начнём с переключения шейдера *Terrain* на specular.
Заменим цветовое свойство *\_Metallic* на свойство *\_Specular*. По умолчанию его значение цвета должно быть равно (0.2, 0.2, 0.2). Так мы гарантируем, что он будет соответствовать внешнему виду версии с metallic.
```
Properties {
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Terrain Texture Array", 2DArray) = "white" {}
_GridTex ("Grid Texture", 2D) = "white" {}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
// _Metallic ("Metallic", Range(0,1)) = 0.0
_Specular ("Specular", Color) = (0.2, 0.2, 0.2)
}
```
Также изменим соответствующие переменные шейдера. Цвет specular поверхностных шейдеров определяется как `fixed3`, поэтому давайте используем его.
```
half _Glossiness;
// half _Metallic;
fixed3 _Specular;
fixed4 _Color;
```
Изменим pragma surface surf со *Standard* на *StandardSpecular*. Это заставит Unity генерировать шейдеры с использованием specular.
```
#pragma surface surf StandardSpecular fullforwardshadows vertex:vert
```
Теперь функции `surf` нужно, чтобы второй параметр имел тип `SurfaceOutputStandardSpecular`. Кроме того, теперь нужно присваивать значение не `o.Metallic`, а `o.Specular`.
```
void surf (Input IN, inout SurfaceOutputStandardSpecular o) {
…
float explored = IN.visibility.w;
o.Albedo = c.rgb * grid * _Color * explored;
// o.Metallic = _Metallic;
o.Specular = _Specular;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
```
Теперь мы можем затенить отсветы, учтя `explored` в цвете specular.
```
o.Specular = _Specular * explored;
```
*Неисследованный рельеф без отражённого освещения.*
Как видно на картинке, теперь неисследованный рельеф выглядит матово-чёрным. Однако при взгляде под касательным углом поверхности превращаются в зеркало, из-за чего рельеф начинает отражать окружение, то есть скайбокс.
**Почему поверхности становятся зеркалами?**
Это называется эффектом Френеля. Подробнее см. в серии туториалов [Rendering](https://catlikecoding.com/unity/tutorials/rendering/part-1/).
*Неисследованные области всё равно отражают окружение.*
Чтобы избавиться от этих отражений, будем считать неисследованный рельеф полностью затенённым. Это реализуется присвоением значения `explored` параметру occlusion, который мы используем как маску отражений.
```
float explored = IN.visibility.w;
o.Albedo = c.rgb * grid * _Color * explored;
o.Specular = _Specular * explored;
o.Smoothness = _Glossiness;
o.Occlusion = explored;
o.Alpha = c.a;
```
*Неисследованное без отражений.*
### Соответствие фону
Теперь, когда неисследованный рельеф игнорирует всё освещение, нужно заставить его соответствовать фону. Так как наша камера всегда смотрит сверху, фон постоянно остаётся серым. Чтобы сообщить шейдеру *Terrain*, какой цвет использовать, добавим ему свойство *\_BackgroundColor*, по умолчанию имеющее значение чёрного цвета.
```
Properties {
…
_BackgroundColor ("Background Color", Color) = (0,0,0)
}
…
half _Glossiness;
fixed3 _Specular;
fixed4 _Color;
half3 _BackgroundColor;
```
Чтобы использовать этот цвет, мы добавим его как emissive light. Это реализуется присвоением `o.Emission` значения цвета фона, умноженного на единицу минус explored.
```
o.Occlusion = explored;
o.Emission = _BackgroundColor * (1 - explored);
```
Так как мы используем скайбокс по умолчанию, видимый цвет фона на самом деле не одинаков. В целом наилучшим цветом будет немного красноватый серый. При настройке материала рельефа можно использовать для *Hex Color* код 68615BFF.
*Материал рельефа с серым фоновым цветом.*
В целом это работает, хотя если знать, куда смотреть, можно заметить очень слабые силуэты. Чтобы их не мог увидеть игрок, можно назначить для камеры вместо скайбокса однородный цвет фона 68615BFF.
*Камера со однородным цветом фона.*
**Почему бы не удалить скайбокс?**
Это можно сделать, но не забывайте, что он используется для environmental lighting карты. Если переключиться на однородный цвет, то изменится и освещение карты.
Теперь мы не может найти отличий между фоном и неисследованными ячейками. Высокий неисследованный рельеф по-прежнему может затенять низкий исследованный рельеф при низких углах камеры. Кроме того, неисследованные части всё равно отбрасывают тени на исследованные. Но этими минимальными подсказками можно пренебречь.
*Неисследованных ячеек больше не видно.*
**Что если не использовать однородный цвет фона?**
Можно создать собственный шейдер, который на самом деле будет делать рельеф прозрачным, но продолжать запись в буфер глубин. При этом могут потребоваться хитрости с очередью шейдера. Если вы используете текстуру экранного пространства, то можно вместо цвета фона можно просто сэмплировать эту текстуру. Если вы используете текстуру в пространстве мира, то вам понадобится выполнять вычисления, чтобы определять, какие UV-координаты текстуры использовать на основании угла обзора и позиции фрагмента в мире.
### Скрываем объекты рельефа
Сейчас у нас скрыт только меш рельефа. На всё остальное состояние исследования пока не действует.
*Пока скрыт только рельеф.*
Давайте теперь изменим шейдер *Feature*, который является непрозрачным шейдером наподобие *Terrain*. Превратим его в specular-шейдер и добавим в него цвет фона. Начнём со свойств.
```
Properties {
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
// _Metallic ("Metallic", Range(0,1)) = 0.0
_Specular ("Specular", Color) = (0.2, 0.2, 0.2)
_BackgroundColor ("Background Color", Color) = (0,0,0)
[NoScaleOffset] _GridCoordinates ("Grid Coordinates", 2D) = "white" {}
}
```
Далее pragma surface и переменные, как и раньше.
```
#pragma surface surf StandardSpecular fullforwardshadows vertex:vert
…
half _Glossiness;
// half _Metallic;
fixed3 _Specular;
fixed4 _Color;
half3 _BackgroundColor;
```
`visibility` тоже потребуется ещё один компонент. Так как *Feature* комбинирует видимость для каждой вершины, ему требовалось только одно значение float. Теперь нам нужны два.
```
struct Input {
float2 uv_MainTex;
float2 visibility;
};
```
Изменим `vert` так, чтобы он явным образом использовал для данных видимости `data.visibility.x`, а затем присвоим `data.visibility.y` значение данных исследования.
```
void vert (inout appdata_full v, out Input data) {
…
float4 cellData = GetCellData(cellDataCoordinates);
data.visibility.x = cellData.x;
data.visibility.x = lerp(0.25, 1, data.visibility.x);
data.visibility.y = cellData.y;
}
```
Изменим `surf` так, чтобы он использовал новые данные, как и *Terrain*.
```
void surf (Input IN, inout SurfaceOutputStandardSpecular o) {
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
float explored = IN.visibility.y;
o.Albedo = c.rgb * (IN.visibility.x * explored);
// o.Metallic = _Metallic;
o.Specular = _Specular * explored;
o.Smoothness = _Glossiness;
o.Occlusion = explored;
o.Emission = _BackgroundColor * (1 - explored);
o.Alpha = c.a;
}
```
*Скрытые объекты рельефа.*
### Скрываем воду
Следующими идут шейдеры *Water* и *Water Shore*. Начнём с преобразования их в specular-шейдеры. Однако им не нужен цвет фона, потому что это прозрачные шейдеры.
После преобразования добавим к `visibility` ещё один компонент и соответствующим образом изменим `vert`. Оба шейдера комбинируют данные трёх ячеек.
```
struct Input {
…
float2 visibility;
};
…
void vert (inout appdata_full v, out Input data) {
…
data.visibility.x =
cell0.x * v.color.x + cell1.x * v.color.y + cell2.x * v.color.z;
data.visibility.x = lerp(0.25, 1, data.visibility.x);
data.visibility.y =
cell0.y * v.color.x + cell1.y * v.color.y + cell2.y * v.color.z;
}
```
*Water* и *Water Shore* выполняют в `surf` разные операции, но задают свои свойства поверхности одинаковым образом. Так как они прозрачны, учтём `explore` в альфа-канале, а не будем задавать emission.
```
void surf (Input IN, inout SurfaceOutputStandardSpecular o) {
…
float explored = IN.visibility.y;
o.Albedo = c.rgb * IN.visibility.x;
o.Specular = _Specular * explored;
o.Smoothness = _Glossiness;
o.Occlusion = explored;
o.Alpha = c.a * explored;
}
```
*Скрытая вода.*
### Скрываем устья, реки и дороги
У нас остались шейдеры *Estuary*, *River* и *Road*. Все три являются прозрачными и комбинируют данные двух ячеек. Переключим их все на specular, а затем добавим в `visibility` данные исследования.
```
struct Input {
…
float2 visibility;
};
…
void vert (inout appdata_full v, out Input data) {
…
data.visibility.x = cell0.x * v.color.x + cell1.x * v.color.y;
data.visibility.x = lerp(0.25, 1, data.visibility.x);
data.visibility.y = cell0.y * v.color.x + cell1.y * v.color.y;
}
```
Изменим функцию `surf` шейдеров *Estuary* и *River* так, чтобы она использовала новые данные. В оба нужно внести одинаковые изменения.
```
void surf (Input IN, inout SurfaceOutputStandardSpecular o) {
…
float explored = IN.visibility.y;
fixed4 c = saturate(_Color + water);
o.Albedo = c.rgb * IN.visibility.x;
o.Specular = _Specular * explored;
o.Smoothness = _Glossiness;
o.Occlusion = explored;
o.Alpha = c.a * explored;
}
```
Шейдер *Road* немного отличается, потому что он использует дополнительный показатель смешения.
```
void surf (Input IN, inout SurfaceOutputStandardSpecular o) {
float4 noise = tex2D(_MainTex, IN.worldPos.xz * 0.025);
fixed4 c = _Color * ((noise.y * 0.75 + 0.25) * IN.visibility.x);
float blend = IN.uv_MainTex.x;
blend *= noise.x + 0.5;
blend = smoothstep(0.4, 0.7, blend);
float explored = IN.visibility.y;
o.Albedo = c.rgb;
o.Specular = _Specular * explored;
o.Smoothness = _Glossiness;
o.Occlusion = explored;
o.Alpha = blend * explored;
}
```
*Скрыто всё.*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-21/hiding-unknown-cells/hiding-unknown-cells.unitypackage)
Избегаем неисследованные ячейки
-------------------------------
Хотя всё неизвестное скрыто визуально, пока состояние исследования не учитывается при поиске пути. В результате отрядам можно приказать перемещаться на неисследованные ячейки и сквозь них, волшебным образом определяя, каким путём двигаться. Нам нужно заставить отряды избегать неисследованные ячейки.
*Перемещение по неисследованным ячейкам.*
### Отряды определяют затраты на перемещение
Прежде чем заняться неисследованными ячейками, давайте переделаем код, чтобы перенести затраты на движение из `HexGrid` в `HexUnit`. Это упростит поддержку отрядов с разными правилами перемещения.
Добавим в `HexUnit` общий метод `GetMoveCost` для определения затрат на перемещение. Ему нужно знать, между какими ячейками происходит перемещение, а также направление. Скопируем соответствующий код затрат на перемещение из `HexGrid.Search` в этот метод и изменим имена переменных.
```
public int GetMoveCost (
HexCell fromCell, HexCell toCell, HexDirection direction)
{
HexEdgeType edgeType = fromCell.GetEdgeType(toCell);
if (edgeType == HexEdgeType.Cliff) {
continue;
}
int moveCost;
if (fromCell.HasRoadThroughEdge(direction)) {
moveCost = 1;
}
else if (fromCell.Walled != toCell.Walled) {
continue;
}
else {
moveCost = edgeType == HexEdgeType.Flat ? 5 : 10;
moveCost +=
toCell.UrbanLevel + toCell.FarmLevel + toCell.PlantLevel;
}
}
```
Метод должен возвращать затраты на перемещение. Старый код для пропуска недопустимых ходов использовал `continue`, но здесь такой подход не подойдёт. Если движение невозможно, то мы будем возвращать отрицательные затраты на перемещение.
```
public int GetMoveCost (
HexCell fromCell, HexCell toCell, HexDirection direction)
{
HexEdgeType edgeType = fromCell.GetEdgeType(toCell);
if (edgeType == HexEdgeType.Cliff) {
return -1;
}
int moveCost;
if (fromCell.HasRoadThroughEdge(direction)) {
moveCost = 1;
}
else if (fromCell.Walled != toCell.Walled) {
return -1;
}
else {
moveCost = edgeType == HexEdgeType.Flat ? 5 : 10;
moveCost +=
toCell.UrbanLevel + toCell.FarmLevel + toCell.PlantLevel;
}
return moveCost;
}
```
Теперь нам нужно знать при нахождении пути не только скорость, но и выбранный отряд. Соответствующим образом изменим `HexGameUI.DoPathFinding`.
```
void DoPathfinding () {
if (UpdateCurrentCell()) {
if (currentCell && selectedUnit.IsValidDestination(currentCell)) {
grid.FindPath(selectedUnit.Location, currentCell, selectedUnit);
}
else {
grid.ClearPath();
}
}
}
```
Так как нам по-прежнему нужен доступ к скорости отряда, добавим в `HexUnit` свойство `Speed`. Пока оно будет возвращать постоянное значение 24.
```
public int Speed {
get {
return 24;
}
}
```
В `HexGrid` изменим `FindPath` и `Search` так, чтобы они могли работать при нашем новом подходе.
```
public void FindPath (HexCell fromCell, HexCell toCell, HexUnit unit) {
ClearPath();
currentPathFrom = fromCell;
currentPathTo = toCell;
currentPathExists = Search(fromCell, toCell, unit);
ShowPath(unit.Speed);
}
bool Search (HexCell fromCell, HexCell toCell, HexUnit unit) {
int speed = unit.Speed;
…
}
```
Теперь удалим из `Search` старый код, который определял, можно ли переместиться в соседнюю ячейку и каковы затраты на перемещение. Вместо это будем вызывать `HexUnit.IsValidDestination` и `HexUnit.GetMoveCost`. Будем пропускать ячейку, если затраты на перемещение оказываются отрицательными.
```
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
HexCell neighbor = current.GetNeighbor(d);
if (
neighbor == null ||
neighbor.SearchPhase > searchFrontierPhase
) {
continue;
}
// if (neighbor.IsUnderwater || neighbor.Unit) {
// continue;
// }
// HexEdgeType edgeType = current.GetEdgeType(neighbor);
// if (edgeType == HexEdgeType.Cliff) {
// continue;
// }
// int moveCost;
// if (current.HasRoadThroughEdge(d)) {
// moveCost = 1;
// }
// else if (current.Walled != neighbor.Walled) {
// continue;
// }
// else {
// moveCost = edgeType == HexEdgeType.Flat ? 5 : 10;
// moveCost += neighbor.UrbanLevel + neighbor.FarmLevel +
// neighbor.PlantLevel;
// }
if (!unit.IsValidDestination(neighbor)) {
continue;
}
int moveCost = unit.GetMoveCost(current, neighbor, d);
if (moveCost < 0) {
continue;
}
int distance = current.Distance + moveCost;
int turn = (distance - 1) / speed;
if (turn > currentTurn) {
distance = turn * speed + moveCost;
}
…
}
```
### Обход неисследованных областей
Чтобы избегать неисследованных ячеек, нам достаточно сделать так, чтобы `HexUnit.IsValidDestination` проверял, исследована ли ячейка.
```
public bool IsValidDestination (HexCell cell) {
return cell.IsExplored && !cell.IsUnderwater && !cell.Unit;
}
```
*Больше отряды не смогут попадать на неисследованные ячейки.*
Так как неисследованные ячейки больше не являются правильными конечными точками, при перемещении в конечную точку отряды будут их избегать. То есть неисследованные области действуют в роли барьеров, которые удлиняют путь или даже делают его невозможным. Нам придётся приблизить отряды к неизвестному рельефу, чтобы сначала исследовать область.
**Что если во время перемещения появляется более короткий путь?**
В нашем случае путь определяется только один раз и во время перемещения от него отклоняться нельзя. Мы можем изменить это и искать новый путь на каждом шаге, но это сделает движение отряда непредсказуемым и хаотичным. Лучше придерживаться выбранного пути и не мудрить.
С другой стороны, если мы строго ограничиваемся движением за один ход, то для долгих путешествий нам придётся вычислять новый путь на каждом ходу. В таком случае отряды могут выбирать в следующем ходу более короткий путь, если он вдруг появился.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-21/avoiding-unexplored-cells/avoiding-unexplored-cells.unitypackage)
Часть 22: усовершенствованная видимость
=======================================
* Плавно изменяем видимость.
* Используем высоту ячейки для определения области видимости.
* Скрываем край карты.
Добавив поддержку исследования карты, мы усовершенствуем вычисления и переходы области видимости.
*Чтобы увидеть дальше, взбирайся выше.*
Переходы видимости
------------------
Ячейка или видима, или невидима, потому что она или находится в области видимости отряда, или нет. Даже если похоже, что на перемещение между ячейками отряду требуется какое-то время, его область видимости перепрыгивает от ячейки к ячейке мгновенно. В результате видимость окружающих его ячеек меняется резко. Движение отряда кажется плавным, но изменения видимости внезапны.
В идеале видимость тоже должна меняться плавно. Попадая в область видимости, ячейки должны освещаться постепенно, а уходя из неё, постепенно затемняться. А может быть, вы предпочитаете мгновенные переходы? Давайте добавим в `HexCellShaderData` свойство, переключающее мгновенные переходы. По умолчанию переходы будут плавными.
```
public bool ImmediateMode { get; set; }
```
### Отслеживание переходных ячеек
Даже при отображении плавных переходов истинные данные видимости всё равно остаются двоичными, то есть эффект только визуальный. Это означает, что переходами видимости должен заниматься `HexCellShaderData`. Передадим ему список ячеек, в которых выполняется переход. Сделаем так, чтобы при каждой инициализации он был пустым.
```
using System.Collections.Generic;
using UnityEngine;
public class HexCellShaderData : MonoBehaviour {
Texture2D cellTexture;
Color32[] cellTextureData;
List transitioningCells = new List();
public bool ImmediateMode { get; set; }
public void Initialize (int x, int z) {
…
transitioningCells.Clear();
enabled = true;
}
…
}
```
На данный момент мы задаём данные ячеек в `RefreshVisibility` непосредственно. Это по-прежнему правильно для режима мгновенных переходов, но когда он отключен, мы должны добавлять ячейку в список переходных ячеек.
```
public void RefreshVisibility (HexCell cell) {
int index = cell.Index;
if (ImmediateMode) {
cellTextureData[index].r = cell.IsVisible ? (byte)255 : (byte)0;
cellTextureData[index].g = cell.IsExplored ? (byte)255 : (byte)0;
}
else {
transitioningCells.Add(cell);
}
enabled = true;
}
```
Похоже, видимость больше не работает, потому что пока мы ничего не делаем с ячейками в списке.
### Обход переходных ячеек в цикле
Вместо мгновенного задания соответствующих значений 255 или 0, мы будем увеличивать/уменьшать эти значения постепенно. От скорости изменения зависит плавность перехода. Он должен быть не очень быстрым и не очень медленным. Хорошим компромиссом между красивыми переходами и удобством игры является изменение в течение одной секунды. Давайте зададим для этого константу, чтобы её было проще изменять.
```
const float transitionSpeed = 255f;
```
Теперь в `LateUpdate` мы можем определять дельту, применяемую к значениям. Для этого нужно умножить дельту времени на скорость. Она должна иметь значение integer, потому что мы не знаем, насколько большой она может оказаться. Резкое падение частоты кадров может сделать дельту больше 255.
Кроме того, нам нужно выполнять обновление, пока есть переходные ячейки. Поэтому код должен быть включен, пока в списке что-то есть.
```
void LateUpdate () {
int delta = (int)(Time.deltaTime * transitionSpeed);
cellTexture.SetPixels32(cellTextureData);
cellTexture.Apply();
enabled = transitioningCells.Count > 0;
}
```
Также теоретически возможны очень высокие частоты кадров. В сочетании с низкой скоростью перехода это может дать нам дельту, равную 0. Чтобы изменение выполнялось, принудительно сделаем минимум дельты равным 1.
```
int delta = (int)(Time.deltaTime * transitionSpeed);
if (delta == 0) {
delta = 1;
}
```
Получив дельту, мы можем обойти в цикле все переходные ячейки и обновить их данные. Допустим, что у нас есть для этого метод `UpdateCellData`, параметрами которого являются соответствующая ячейка и дельта.
```
int delta = (int)(Time.deltaTime * transitionSpeed);
if (delta == 0) {
delta = 1;
}
for (int i = 0; i < transitioningCells.Count; i++) {
UpdateCellData(transitioningCells[i], delta);
}
```
В какой-то момент переход ячейки должен завершиться. Допустим, что метод возвращает информацию о том, продолжается ли ещё переход. Когда он перестаёт продолжаться, то мы можем удалить ячейку из списка. После этого мы должны выполнить декремент итератора, чтобы не пропускать ячейки.
```
for (int i = 0; i < transitioningCells.Count; i++) {
if (!UpdateCellData(transitioningCells[i], delta)) {
transitioningCells.RemoveAt(i--);
}
}
```
Порядок обработки переходных ячеек не важен. Поэтому нам не обязательно удалять ячейку по текущему индексу, что заставило бы `RemoveAt` сдвинуть все ячейки после неё. Вместо этого мы перемещаем последнюю ячейку в текущий индекс, а затем удаляем последнюю.
```
if (!UpdateCellData(transitioningCells[i], delta)) {
transitioningCells[i--] =
transitioningCells[transitioningCells.Count - 1];
transitioningCells.RemoveAt(transitioningCells.Count - 1);
}
```
Теперь мы должны создать метод `UpdateCellData`. Для выполнения своей работы ему потребуется индекс и данные ячейки, поэтому начнём с их получения. Также он должен определять, нужно ли продолжать обновлять ячейку. По умолчанию мы будем считать, что не нужно. После завершения работы необходимо применить изменённые данные и возвращать состояние «продолжается обновление».
```
bool UpdateCellData (HexCell cell, int delta) {
int index = cell.Index;
Color32 data = cellTextureData[index];
bool stillUpdating = false;
cellTextureData[index] = data;
return stillUpdating;
}
```
### Обновление данных ячеек
На данном этапе у нас есть ячейка, находящаяся в процессе перехода или уже закончившая его. Сначала давайте проверим состояние исследования ячейки. Если ячейка исследована, но её значение G пока не равно 255, то она находится в процессе перехода, поэтому будем это отслеживать.
```
bool stillUpdating = false;
if (cell.IsExplored && data.g < 255) {
stillUpdating = true;
}
cellTextureData[index] = data;
```
Чтобы выполнять переход, будем прибавлять к значению G ячейки дельту. Арифметические операции не работают с байтами, они сначала преобразуются в integer. Поэтому сумма будет иметь формат integer, который нужно преобразовать в byte.
```
if (cell.IsExplored && data.g < 255) {
stillUpdating = true;
int t = data.g + delta;
data.g = (byte)t;
}
```
Но перед преобразованием нужно убедиться, что значение не превышает 255.
```
int t = data.g + delta;
data.g = t >= 255 ? (byte)255 : (byte)t;
```
Далее нам нужно сделать то же самое для видимости, которая использует значение R.
```
if (cell.IsExplored && data.g < 255) {
…
}
if (cell.IsVisible && data.r < 255) {
stillUpdating = true;
int t = data.r + delta;
data.r = t >= 255 ? (byte)255 : (byte)t;
}
```
Так как ячейка может снова становиться невидимой, нам нужно проверять, необходимо ли уменьшать значение R. Это бывает в случае, когда ячейка невидима, но R больше нуля.
```
if (cell.IsVisible) {
if (data.r < 255) {
stillUpdating = true;
int t = data.r + delta;
data.r = t >= 255 ? (byte)255 : (byte)t;
}
}
else if (data.r > 0) {
stillUpdating = true;
int t = data.r - delta;
data.r = t < 0 ? (byte)0 : (byte)t;
}
```
Теперь `UpdateCellData` готов и переходы видимости выполняются верно.
*Переходы видимости.*
### Защита от дублированных элементов перехода
Переходы работают, но в списке могут оказаться дублированные элементы. Это получается, если состояние видимости ячейки изменяется, когда она всё ещё находится в процессе перехода. Например, когда ячейка видима во время перемещения отряда только на короткое время.
В результате появления дублированных элементов переход ячейки обновляется несколько раз за кадр, что приводит к ускоренным переходам и выполнению лишней работы. Мы можем предотвратить это, проверяя перед добавлением ячейки, находится ли она уже в списке. Однако поиск по списку при каждом вызове `RefreshVisibility` затратен, особенно когда выполняется переход множества ячеек. Вместо этого давайте воспользуемся ещё одним пока не использованным каналом, чтобы обозначить, находится ли ячейка в процессе перехода, например значением B. При добавлении ячейки в список будем присваивать ему значение 255, и добавлять в список только те ячейки, значение которых не равно 255.
```
public void RefreshVisibility (HexCell cell) {
int index = cell.Index;
if (ImmediateMode) {
cellTextureData[index].r = cell.IsVisible ? (byte)255 : (byte)0;
cellTextureData[index].g = cell.IsExplored ? (byte)255 : (byte)0;
}
else if (cellTextureData[index].b != 255) {
cellTextureData[index].b = 255;
transitioningCells.Add(cell);
}
enabled = true;
}
```
Чтобы это сработало, нам нужно обнулять значение B после завершения перехода ячейки.
```
bool UpdateCellData (HexCell cell, int delta) {
…
if (!stillUpdating) {
data.b = 0;
}
cellTextureData[index] = data;
return stillUpdating;
}
```
*Переходы без дубликатов.*
### Мгновенно загружающаяся видимость
Изменения видимости теперь всегда постепенные, даже при загрузке карты. Это нелогично, потому что карта описывает состояние, в котором ячейки уже видимы, поэтому переход здесь неуместен. Кроме того, выполнение переходов для множества видимых ячеек большой карты может замедлить игру после загрузки. Поэтому перед загрузкой ячеек и отрядов давайте переключаться в `HexGrid.Load` в режим мгновенных переходов.
```
public void Load (BinaryReader reader, int header) {
…
cellShaderData.ImmediateMode = true;
for (int i = 0; i < cells.Length; i++) {
cells[i].Load(reader, header);
}
…
}
```
Так мы переопределяем исходную настройку режима мгновенного перехода, какой бы она ни была. Возможно, она уже отключена, или сделана опцией конфигурации, поэтому запомним исходный режим и будем переключаться на него после завершения работы.
```
public void Load (BinaryReader reader, int header) {
…
bool originalImmediateMode = cellShaderData.ImmediateMode;
cellShaderData.ImmediateMode = true;
…
cellShaderData.ImmediateMode = originalImmediateMode;
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-22/visibility-transitions/visibility-transitions.unitypackage)
Область видимости, зависящая от высоты
--------------------------------------
Пока мы использовали для всех отрядов постоянную область видимости, равную трём, но в реальности она сложнее. В общем случае мы не можем увидеть объект по двум причинам: или нам мешает увидеть его какое-то препятствие, или объект слишком мал или далёк. В нашей игре мы реализуем только ограничение области видимости.
Мы не можем увидеть, что находится на противоположной стороне Земли, потому что нам закрывает обзор планета. Мы можем видеть только до горизонта. Так как планету приблизительно можно считать сферой, то чем выше точка обзора, тем больше поверхности мы сможем увидеть, то есть горизонт зависит от высоты.
*Горизонт зависит от высоты точки обзора.*
Ограниченная область видимости наших отрядов имитирует эффект горизонта, создаваемый кривизной Земли. Дальность их обзора зависит от размера планеты и масштаба карты. По крайней мере, таково логическое объяснение. Но основной причиной снижения области видимости является геймплей, это ограничение, называемое туманом войны. Однако понимая физику, лежащую в основе области видимости, мы можем сделать вывод, что стратегической ценностью должна обладать высокая точка обзора, потому что она отдаляет горизонт и позволяет заглядывать за более низкие препятствия. Но пока мы это не реализовали.
### Высота для обзора
Чтобы учесть высоту при определении области видимости, нам нужно знать высоту. Это будет обычная высота или уровень воды, в зависимости от того, сухопутная ячейка или водная. Давайте добавим для этого в `HexCell` свойство.
```
public int ViewElevation {
get {
return elevation >= waterLevel ? elevation : waterLevel;
}
}
```
Но если на область видимости влияет высота, то при изменении высоты обзора ячейки может меняться и ситуация с видимостью. Так как ячейка блокировала или теперь блокирует область видимости нескольких отрядов, то не так просто определить, что нужно изменить. Эту задачу не сможет решить сама ячейка, поэтому пусть она сообщает об изменении ситуации `HexCellShaderData`. Допустим, у `HexCellShaderData` есть для этого метод `ViewElevationChanged`. Будем вызывать его при задании `HexCell.Elevation`, если это необходимо.
```
public int Elevation {
get {
return elevation;
}
set {
if (elevation == value) {
return;
}
int originalViewElevation = ViewElevation;
elevation = value;
if (ViewElevation != originalViewElevation) {
ShaderData.ViewElevationChanged();
}
…
}
}
```
То же самое относится к `WaterLevel`.
```
public int WaterLevel {
get {
return waterLevel;
}
set {
if (waterLevel == value) {
return;
}
int originalViewElevation = ViewElevation;
waterLevel = value;
if (ViewElevation != originalViewElevation) {
ShaderData.ViewElevationChanged();
}
ValidateRivers();
Refresh();
}
}
```
### Сбрасываем видимость
Теперь нам нужно создать метод `HexCellShaderData.ViewElevationChanged`. Определение изменения общей ситуации видимости — это сложная задача, особенно при одновременном изменении нескольких ячеек. Поэтому мы не будем придумывать какие-то хитрости, а просто запланируем сброс видимости всех ячеек. Добавим булево поле для отслеживания того, нужно ли это делать. Внутри метода мы будем просто присваивать ему true и включать компонент. Вне зависимости от количества одновременно изменившихся ячеек это приведёт к единственному сбросу значений.
```
bool needsVisibilityReset;
…
public void ViewElevationChanged () {
needsVisibilityReset = true;
enabled = true;
}
```
Для сброса значений видимости всех ячеек нужно иметь к ним доступ, которого у `HexCellShaderData` нет. Поэтому давайте делегируем эту обязанность `HexGrid`. Для этого необходимо добавить в `HexCellShaderData` свойство, которое позволит ссылаться на сетку. Затем мы сможем использовать его в `LateUpdate`, чтобы запрашивать сброс.
```
public HexGrid Grid { get; set; }
…
void LateUpdate () {
if (needsVisibilityReset) {
needsVisibilityReset = false;
Grid.ResetVisibility();
}
…
}
```
Перейдём к `HexGrid`: зададим ссылку на сетку в `HexGrid.Awake` после создания данных шейдера.
```
void Awake () {
HexMetrics.noiseSource = noiseSource;
HexMetrics.InitializeHashGrid(seed);
HexUnit.unitPrefab = unitPrefab;
cellShaderData = gameObject.AddComponent();
cellShaderData.Grid = this;
CreateMap(cellCountX, cellCountZ);
}
```
`HexGrid` также должен получить метод `ResetVisibility` для сброса всех ячеек. Просто заставим его обходить в цикле все ячейки и делегируем выполнение сброса им самим.
```
public void ResetVisibility () {
for (int i = 0; i < cells.Length; i++) {
cells[i].ResetVisibility();
}
}
```
Теперь нам нужно добавить в `HexCell` метод `ResetVisibilty`. Он просто будет обнулять видимость и запускать обновление видимости. Это нужно делать, когда видимость ячейки больше нуля.
```
public void ResetVisibility () {
if (visibility > 0) {
visibility = 0;
ShaderData.RefreshVisibility(this);
}
}
```
После сброса всех данных видимости `HexGrid.ResetVisibility` снова должен применить видимость ко всем отрядам, для чего ему нужно знать область видимости каждого отряда. Допустим, её можно получить с помощью свойства `VisionRange`.
```
public void ResetVisibility () {
for (int i = 0; i < cells.Length; i++) {
cells[i].ResetVisibility();
}
for (int i = 0; i < units.Count; i++) {
HexUnit unit = units[i];
IncreaseVisibility(unit.Location, unit.VisionRange);
}
}
```
Чтобы это сработало, выполним рефакторинг-переименование `HexUnit.visionRange` в `HexUnit.VisionRange` и превратим его в свойство. Пока оно будет получать постоянное значение 3, но в будущем это изменится.
```
public int VisionRange {
get {
return 3;
}
}
```
Благодаря этому данные видимости будут сбрасываться и оставаться правильными после изменения высоты обзора ячеек. Но вероятно, что мы изменим правила определения области видимости и запустим рекомпиляцию в режиме Play. Чтобы область видимости изменялась самостоятельно, давайте запускать сброс `HexGrid.OnEnable` при обнаружении рекомпиляции.
```
void OnEnable () {
if (!HexMetrics.noiseSource) {
…
ResetVisibility();
}
}
```
Теперь можно менять код области видимости и видеть результаты, оставаясь в режиме Play.
### Расширяем горизонт
Вычисление области видимости определяется `HexGrid.GetVisibleCells`. Чтобы на область видимости влияла высота, мы можем просто использовать высоту обзора `fromCell`, временно переопределяя переданную область. Так мы можем легко проверить, работает ли это.
```
List GetVisibleCells (HexCell fromCell, int range) {
…
range = fromCell.ViewElevation;
fromCell.SearchPhase = searchFrontierPhase;
fromCell.Distance = 0;
searchFrontier.Enqueue(fromCell);
…
}
```
*Используем высоту как область видимости.*
### Препятствия видимости
Применение высоты обзора в качестве области видимости правильно работает, только когда все остальные ячейки находятся на нулевой высоте. Но если все ячейки имеют ту же высоту, что и точка обзора, то область видимости должна быть нулевой. Кроме того, ячейки с большой высотой должны блокировать видимость находящихся за ними низких ячеек. Пока ничто из этого не реализовано.
*Области видимости ничего не препятствует.*
Наиболее корректным способом определения области видимости была бы проверка испусканием лучей, но она быстро стала бы затратной и всё равно могла выдавать странные результаты. Нам нужно быстрое решение, создающее достаточно хорошие результаты, которые не обязаны быть идеальными. Кроме того, важно, чтобы правила определения области видимости были простыми, интуитивно понятными и предсказуемыми для игроков.
Наше решение будет следующим — при определении видимости ячейки мы будем прибавлять высоту обзора соседней ячейки к покрытому расстоянию. По сути, это снижает область видимости, когда мы смотрим на эти ячейки, А если они пропускаются, это не позволит нам достичь находящихся за ними ячеек.
```
int distance = current.Distance + 1;
if (distance + neighbor.ViewElevation > range) {
continue;
}
```
*Высокие ячейки блокируют обзор.*
**Разве не должны мы видеть высокие ячейки вдалеке?**
Как в случае с горной грядой, мы можем видеть их склоны, соседние с ячейками, которые мы видим. Но мы не можем увидеть горы сверху, поэтому не можем видеть и сами ячейки.
### Не заглядываем за углы
Теперь похоже на то, что высокие ячейки блокируют обзор на низкие, однако иногда область видимости проникает сквозь них, хотя кажется, что этого быть не должно. Так происходит, потому что алгоритм поиска всё равно находит путь к этим ячейкам, обходя блокирующие ячейки. В результате это выглядит так, как будто наша область видимости может огибать препятствия. Чтобы избежать этого, нам нужно сделать так, чтобы при определении видимости ячейки учитывались только кратчайшие пути. Это можно реализовать отбрасыванием путей, которые становятся длиннее нужного.
```
HexCoordinates fromCoordinates = fromCell.coordinates;
while (searchFrontier.Count > 0) {
…
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
…
int distance = current.Distance + 1;
if (distance + neighbor.ViewElevation > range ||
distance > fromCoordinates.DistanceTo(neighbor.coordinates)
) {
continue;
}
…
}
}
```
*Используем только кратчайшие пути.*
Так мы исправили большинство очевидно ошибочных случаев. Для ближних ячеек это работает хорошо, потому что к ним существуют только кратчайшие пути. Более далёкие ячейки имеют больше вариантов путей, поэтому на дальних расстояниях всё равно может возникать огибание видимости. Это не будет проблемой, если области видимости остаются маленькими, а разности соседних высот не слишком велики.
И, наконец, вместо того, чтобы заменять передаваемую область обзора, прибавим к ней высоту обзора. Собственная область видимости отряда обозначает его рост, высоту полёта или разведывательные возможности.
```
range += fromCell.ViewElevation;
```
*Обзор с полной областью видимости на низкой точке обзора.*
То есть окончательные правила видимости относятся к зрению при перемещении по кратчайшему пути до области видимости с учётом разности высоты ячеек относительно точки обзора. Когда ячейка находится вне области видимости, это блокирует все пути через неё. В результате высокие наблюдательные точки, обзору с которых ничего не мешает, становятся стратегически ценными.
**А как насчёт препятствующих видимости объектов?**
Я решил, что объекты рельефа не будут влиять на видимость, но можно. например, сделать так, чтобы густые леса или стены добавляли ячейке высоты. При этом игроку сложнее будет оценивать правила определения области видимости.
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-22/vision-based-on-elevation/vision-based-on-elevation.unitypackage)
Ячейки, которые нельзя исследовать
----------------------------------
Последняя проблема с видимостью касается краёв карты. Рельеф резко и без переходов кончается, потому что у ячеек на краю нет соседей.
*Заметный край карты.*
В идеале визуальное отображение неисследованных областей и краёв карты должно быть одинаковым. Мы можем добиться этого, добавив особые случаи при триангуляции рёбер, когда у них нет соседей, но для этого потребуется дополнительная логика, и нам придётся работать с отсутствующими ячейками. Поэтому такое решение нетривиально. Альтернативный подход заключается в том, чтобы принудительно сделать граничные ячейки карты неисследуемыми, даже если они находятся в области видимости отряда. Такой подход гораздо проще, поэтому давайте используем его. Также он позволяет помечать как неисследуемые и другие ячейки, благодаря чему проще добиться создания неровных краёв карты. Кроме того, скрытые ячейки на краях позволяют создавать дороги и реки, входящие и исходящие из карты реки и дороги, потому что их конечные точки будут находиться вне области видимости. Также с помощью такого решения можно добавлять входящие и уходящие с карты отряды.
### Помечаем ячейки как исследуемые
Чтобы обозначить, что ячейку можно исследовать, добавим в `HexCell` свойство `Explorable`.
```
public bool Explorable { get; set; }
```
Теперь ячейка может быть видимой, если она является исследуемой, поэтому изменим свойство `IsVisible`, чтобы учесть это.
```
public bool IsVisible {
get {
return visibility > 0 && Explorable;
}
}
```
То же самое относится и к `IsExplored`. Однако для этого мы исследовали стандартное свойство. Нам нужно преобразовать его в явное свойство, чтобы получить возможность изменять логику его геттера.
```
public bool IsExplored {
get {
return explored && Explorable;
}
private set {
explored = value;
}
}
…
bool explored;
```
### Скрываем край карты
Скрыть край прямоугольной карты можно в методе `HexGrid.CreateCell`. Ячейки, не находящиеся на краю, являются исследуемыми, все остальные — неисследуемыми.
```
void CreateCell (int x, int z, int i) {
…
HexCell cell = cells[i] = Instantiate(cellPrefab);
cell.transform.localPosition = position;
cell.coordinates = HexCoordinates.FromOffsetCoordinates(x, z);
cell.Index = i;
cell.ShaderData = cellShaderData;
cell.Explorable =
x > 0 && z > 0 && x < cellCountX - 1 && z < cellCountZ - 1;
…
}
```
Теперь карты затемняются по краям, скрывая за собой огромные неисследованные пространства. В результате размер исследуемой области карт уменьшается в каждом измерении на два.
*Неисследуемый край карты.*
**Можно ли сделать состояние исследуемости редактируемым?**
Да, это возможно, и даст нам максимальную универсальность. При этом также придётся добавлять эту информацию при сохранении данных.
### Неисследуемые ячейки препятствуют видимости
Наконец, если ячейку невозможно исследовать, то она должна мешать видимости. Изменим `HexGrid.GetVisibleCells`, чтобы учесть это.
```
if (
neighbor == null ||
neighbor.SearchPhase > searchFrontierPhase ||
!neighbor.Explorable
) {
continue;
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-22/inexplorable-cells/inexplorable-cells.unitypackage)
Часть 23: генерируем сушу
=========================
* Заполняем новые карты сгенерированными ландшафтами.
* Поднимаем участки суши над водой, некоторые затапливаем.
* Управляем количеством создаваемой суши, её высотой и неравномерностью.
* Добавляем поддержку разных опций конфигурации для создания варьируемых карт.
* Делаем так, чтобы можно было сгенерировать снова такую же карту.
Эта часть туториала будет началом серии о процедурной генерации карт.
Данная часть создана в Unity 2017.1.0.
*Одна из множества сгенерированных карт.*
Генерация карт
--------------
Хоть мы и можем создать любую карту, на это требуется много времени. Было бы удобно, если бы приложение могло помочь дизайнеру, генерируя за него карты, которые он потом сможет изменять на свой вкус. Можно сделать ещё один шаг и полностью избавиться от создания дизайна вручную, полностью передав обязанность генерации готовой карты приложению. Благодаря этому в игру каждый раз можно будет играть с новой картой и каждая игровая сессия будет отличаться. Чтобы всё это было возможным, мы должны создать алгоритм генерации карт.
Тип нужного алгоритма генерации зависит от требуемого вида карт. Не существует единственно верного подхода, всегда придётся искать компромисс между правдоподобностью и играбельностью.
Чтобы карта была правдоподобной, она должна казаться игроку вполне возможной и реальной. Это не значит, что карта должна выглядеть как часть нашей планеты. Это может быть другая планета или совершенно другая реальность. Но если она должна обозначать рельеф Земли, то обязана хотя бы частично напоминать её.
Играбельность связана с тем, как карты соответствуют игровому процессу. Иногда она входит в противоречие с правдоподобностью. Например, хоть горные хребты и могут выглядеть красиво, они в то же время сильно ограничивают перемещение и обзор отрядов. Если это нежелательно, то придётся обойтись без гор, что снизит правдоподобность и ограничит выразительность игры. Или же мы можем сохранить горы, но снизить их влияние на геймплей, что тоже способно снизить правдоподобность.
Кроме того, нужно учитывать выполнимость. Например, можно создать очень реалистичную землеподобную планету, симулировав тектонические плиты, эрозию, дожди, извержения вулканов, воздействие метеоритов и Луны, и так далее. Но разработка такой системы потребует много времени. Кроме того, на генерацию такой планеты может уйти много времени, и игрокам не захочется ждать несколько минут перед началом новой игры. То есть симуляция — это мощный инструмент, но он имеет свою цену.
В играх часто используются компромиссы между правдоподобностью, играбельностью и выполнимостью. Иногда такие компромиссы незаметны и кажутся совершенно нормальными, а иногда выглядят случайными, непостоянными или хаотичными, в зависимости от принятых в процессе разработки решений. Это касается не только генерации карт, но при разработке процедурного генератора карт нужно относиться к этому с особым вниманием. Вы можете потратить много времени на создание алгоритма, генерирующего красивые карты, которые окажутся бесполезными для создаваемой вами игры.
В этой серии туториалов мы будем создавать землеподобный рельеф. Он должен выглядеть интересным, с большой вариативностью и отсутствием больших однородных областей. Масштаб рельефа будет большим, карты будут покрывать один или несколько континентов, областей океанов, или даже целую планету. Нам нужен контроль над географией, в том числе над массивами суши, климатом, количеством областей и неровностями рельефа. В этой части мы заложим основу создания суши.
### Начинаем в режиме редактирования
Мы сосредоточимся на карте, а не на геймплее, поэтому удобнее будет запускать приложение в режиме редактирования. Благодаря этому мы сразу сможем видеть карты. Поэтому изменим `HexMapEditor.Awake`, присвоив режиму редактирования значение true и включив ключевое слово шейдера этого режима.
```
void Awake () {
terrainMaterial.DisableKeyword("GRID_ON");
Shader.EnableKeyword("HEX_MAP_EDIT_MODE");
SetEditMode(true);
}
```
### Генератор карты
Так как для генерации процедурных карт нужно довольно много кода, мы не будем добавлять его непосредственно в `HexGrid`. Вместо этого мы создадим новый компонент `HexMapGenerator`, а `HexGrid` о нём знать не будет. Это упростит переход к другому алгоритму, если он нам понадобится.
Генератору требуется ссылка на сетку, поэтому добавим ему для этого общее поле. Кроме того, добавим общий метод `GenerateMap`, который займётся работой алгоритма. Передадим ему в качестве параметров размеры карты, а затем заставим использовать их для создания новой пустой карты.
```
using System.Collections.Generic;
using UnityEngine;
public class HexMapGenerator : MonoBehaviour {
public HexGrid grid;
public void GenerateMap (int x, int z) {
grid.CreateMap(x, z);
}
}
```
Добавим в сцену объект с компонентом `HexMapGenerator` и подключим его к сетке.
*Объект генератора карт.*
### Изменение меню новой карты
Мы изменим `NewMapMenu` так, чтобы оно могло генерировать карты, а не только создавать пустые. Мы будем управлять её функционалом через булево поле `generateMaps`, которое по умолчанию имеет значение `true`. Создадим общий метод для задания этого поля, как мы делали для переключения опций `HexMapEditor`. Добавим в меню соответствующий переключатель и соединим его с методом.
```
bool generateMaps = true;
public void ToggleMapGeneration (bool toggle) {
generateMaps = toggle;
}
```
*Меню новой карты с переключателем.*
Дадим меню ссылку на генератор карт. Затем заставим его при необходимости вызывать метод `GenerateMap` генератора, а не просто выполнять `CreateMap` сетки.
```
public HexMapGenerator mapGenerator;
…
void CreateMap (int x, int z) {
if (generateMaps) {
mapGenerator.GenerateMap(x, z);
}
else {
hexGrid.CreateMap(x, z);
}
HexMapCamera.ValidatePosition();
Close();
}
```
*Подключение к генератору.*
### Доступ к ячейкам
Для того, чтобы генератор работал, ему нужен доступ к ячейкам. У `HexGrid` уже есть общие методы `GetCell`, которые требуют или вектора позиции, или координат шестиугольника. Генератору не нужно работать ни с теми, ни с другими, поэтому добавим два удобных метода `HexGrid.GetCell`, которые будут работать с координатами смещения или индексом ячейки.
```
public HexCell GetCell (int xOffset, int zOffset) {
return cells[xOffset + zOffset * cellCountX];
}
public HexCell GetCell (int cellIndex) {
return cells[cellIndex];
}
```
Теперь `HexMapGenerator` может получать ячейки напрямую. Например, после создания новой карты он может с помощью координат смещений задать в качестве рельефа среднего столбца ячеек траву.
```
public void GenerateMap (int x, int z) {
grid.CreateMap(x, z);
for (int i = 0; i < z; i++) {
grid.GetCell(x / 2, i).TerrainTypeIndex = 1;
}
}
```
*Столбец из травы на маленькой карте.*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-23/generating-maps/generating-maps.unitypackage)
Создание суши
-------------
При генерации карты мы начинаем совершенно без суши. Можно представить, что весь мир залит одним огромным океаном. Суша создаётся, когда часть океанского дна выталкивается наверх настолько, что поднимается над водой. Нам нужно решить, сколько суши должно создаваться таким образом, где она появится и какую форму будет иметь.
### Поднимаем рельеф
Начнём с малого — поднимем один участок суши над водой. Создадим для этого метод `RaiseTerrain` с параметром для управления размером участка. Вызовем этот метод в `GenerateMap`, заменив прошлый тестовый код. Давайте начнём с небольшого участка земли, состоящего из семи ячеек.
```
public void GenerateMap (int x, int z) {
grid.CreateMap(x, z);
// for (int i = 0; i < z; i++) {
// grid.GetCell(x / 2, i).TerrainTypeIndex = 1;
// }
RaiseTerrain(7);
}
void RaiseTerrain (int chunkSize) {}
```
Пока для обозначения поднятой суши мы используем просто тип рельефа «трава», а изначальный рельеф «песок» обозначает океан. Заставим `RaiseTerrain` брать случайную ячейку и изменять тип её рельефа, пока не получим нужное количество суши.
Для получения случайной ячейки добавим метод `GetRandomCell`, который определяет случайный индекс ячейки и получает из сетки соответствующую ячейку.
```
void RaiseTerrain (int chunkSize) {
for (int i = 0; i < chunkSize; i++) {
GetRandomCell().TerrainTypeIndex = 1;
}
}
HexCell GetRandomCell () {
return grid.GetCell(Random.Range(0, grid.cellCountX * grid.cellCountZ));
}
```
*Семь случайных ячеек суши.*
Так как в конце концов нам может понадобиться множество случайных ячеек или обойти в цикле все ячейки несколько раз, давайте отслеживать количество ячеек в самом `HexMapGenerator`.
```
int cellCount;
public void GenerateMap (int x, int z) {
cellCount = x * z;
…
}
…
HexCell GetRandomCell () {
return grid.GetCell(Random.Range(0, cellCount));
}
```
### Создание одного участка
Пока мы превращаем в сушу семь случайных ячеек, и они могут находиться где угодно. Скорее всего они не образуют единый участок суши. Кроме того, мы можем выбрать одни и те же ячейки несколько раз, поэтому у нас получится меньший объём суши. Чтобы решить обе проблемы, без ограничений мы будем выбирать только первую ячейку. После этого мы должны выбирать только те ячейки, которые находятся рядом с выбранными ранее. Эти ограничения похожи на ограничения поиска пути, поэтому используем здесь тот же подход.
Добавим `HexMapGenerator` собственное свойство и счётчик фазы границы поиска, как это было в `HexGrid`.
```
HexCellPriorityQueue searchFrontier;
int searchFrontierPhase;
```
Проверяем, что очередь с приоритетом существует, прежде чем она нам понадобится.
```
public void GenerateMap (int x, int z) {
cellCount = x * z;
grid.CreateMap(x, z);
if (searchFrontier == null) {
searchFrontier = new HexCellPriorityQueue();
}
RaiseTerrain(7);
}
```
После создания новой карты граница поиска для всех ячеек равна нулю. Но если мы собираемся искать ячейки в процессе генерации карты, то будем увеличивать их границу поиска в этом процессе. Если мы будем выполнять много операций поиска, они могут оказаться впереди фазы границы поиска, записанной `HexGrid`. Это может нарушить поиск пути отрядов. Чтобы избежать этого, в конце процессе генерации карты будем сбрасывать фазу поиска всех ячеек до нуля.
```
RaiseTerrain(7);
for (int i = 0; i < cellCount; i++) {
grid.GetCell(i).SearchPhase = 0;
}
```
Теперь `RaiseTerrain` должен искать соответствующие ячейки, а не выбирать их случайно. Этот процесс очень похож на способ поиска в `HexGrid`. Однако мы не будем посещать ячейки больше одного раза, поэтому нам достаточно будет увеличивать фазу границы поиска на 1 вместо 2. Затем инициализируем границу с первой ячейкой, которая выбирается случайно. Как обычно, кроме задания её фазы поиска, присвоим её расстоянию и эвристике нулевое значение.
```
void RaiseTerrain (int chunkSize) {
// for (int i = 0; i < chunkSize; i++) {
// GetRandomCell().TerrainTypeIndex = 1;
// }
searchFrontierPhase += 1;
HexCell firstCell = GetRandomCell();
firstCell.SearchPhase = searchFrontierPhase;
firstCell.Distance = 0;
firstCell.SearchHeuristic = 0;
searchFrontier.Enqueue(firstCell);
}
```
После этого цикл поиска в основном будет нам знаком. Кроме того, чтобы продолжать поиск, пока граница не опустеет, нам нужно останавливаться, когда фрагмент достигнет нужного размера, поэтому будем это отслеживать. На каждой итерации мы будем извлекать из очереди следующую ячейку, задавать тип её рельефа, увеличивать размер, а затем обходить соседей этой ячейки. Все соседи просто добавляются в границу, если они ещё туда не добавлены. Нам не нужно выполнять никаких изменений или сравнений. После завершения нужно очистить границу.
```
searchFrontier.Enqueue(firstCell);
int size = 0;
while (size < chunkSize && searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
current.TerrainTypeIndex = 1;
size += 1;
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
HexCell neighbor = current.GetNeighbor(d);
if (neighbor && neighbor.SearchPhase < searchFrontierPhase) {
neighbor.SearchPhase = searchFrontierPhase;
neighbor.Distance = 0;
neighbor.SearchHeuristic = 0;
searchFrontier.Enqueue(neighbor);
}
}
}
searchFrontier.Clear();
```
*Линия из ячеек.*
Мы получили единый участок нужного размера. Он окажется меньше, только если не найдётся достаточное количество ячеек. Из-за способа заполнения границы участок всегда состоит из линии, идущей на северо-запад. Он меняет направление, только когда достигает края карты.
### Соединяем ячейки
Участки суши редко напоминают линии, а если и напоминают, то не всегда ориентированы одинаково. Чтобы изменить форму участка, нам нужно поменять приоритеты ячеек. Первую случайную ячейку можно использовать в качестве центра участка. Тогда расстояние до всех других ячеек будет относительно этой точке. Так мы дадим более высокий приоритет ячейкам, которые ближе к центру, благодаря чему участок будет расти не как линия, а вокруг центра.
```
searchFrontier.Enqueue(firstCell);
HexCoordinates center = firstCell.coordinates;
int size = 0;
while (size < chunkSize && searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
current.TerrainTypeIndex = 1;
size += 1;
for (HexDirection d = HexDirection.NE; d <= HexDirection.NW; d++) {
HexCell neighbor = current.GetNeighbor(d);
if (neighbor && neighbor.SearchPhase < searchFrontierPhase) {
neighbor.SearchPhase = searchFrontierPhase;
neighbor.Distance = neighbor.coordinates.DistanceTo(center);
neighbor.SearchHeuristic = 0;
searchFrontier.Enqueue(neighbor);
}
}
}
```
*Скопление ячеек.*
И в самом деле, теперь наши семь ячеек красиво упакованы в компактную шестиугольную область, если центральная ячейка не оказывается на краю карты. Давайте попробуем теперь использовать размер участка 30.
```
RaiseTerrain(30);
```
*Масса суши в 30 ячеек.*
Мы снова получили ту же форму, хоть и для получения правильного шестиугольника ячеек не хватило. Так как радиус участка больше, он с большей вероятностью может оказаться близко к краю карты, что вынудит его принять другую форму.
### Рандомизация формы суши
Мы не хотим, чтобы все участки выглядели одинаково, поэтому немного изменим приоритеты ячеек. Каждый раз, когда мы добавляем в границу соседнюю ячейку, если следующее число `Random.value` меньше некоторого порогового значения, то эвристика этой ячейки становится не 0, а 1. Давайте используем в качестве порога значение 0.5, то есть с наибольшей вероятностью он повлияет на половину ячеек.
```
neighbor.Distance = neighbor.coordinates.DistanceTo(center);
neighbor.SearchHeuristic = Random.value < 0.5f ? 1: 0;
searchFrontier.Enqueue(neighbor);
```
*Искажённый участок.*
Увеличив поисковую эвристику ячейки, мы сделали так, чтобы она посещалась позже ожидаемого. При этом другие ячейки, находящиеся на один шаг дальше от центра, будут посещаться раньше, если только им тоже не увеличили эвристику. Это значит, что если мы увеличим эвристику всех ячеек на одну величину, то это никак не повлияет на карту. То есть порог 1 не будет иметь влияния, как и порог 0. А порог 0.8 будет эквивалентен 0.2. То есть вероятность 0.5 делает процесс поиска наиболее «дрожащим».
Подходящая величина колебаний зависит от необходимого вида рельефа, поэтому давайте сделаем её настраиваемой. Добавим в генератор общее поле float `jitterProbability` с атрибутом `Range`, ограниченным в интервале 0–0.5. Дадим ему значение по умолчанию, равное среднему этого интервала, то есть 0.25. Это позволит нам настраивать генератор в окне инспектора Unity.
```
[Range(0f, 0.5f)]
public float jitterProbability = 0.25f;
```
Вероятность колебаний.
**Можно ведь сделать её настраиваемой и в игровом UI?**
Это возможно, и в большинстве игр так и сделано. В туториале я не буду добавлять этот параметр в игровой UI, но вам ничего не мешает это сделать. Однако в результате у генератора будет довольно много опций конфигурации, поэтому учитывайте это при создании UI. Можете подождать, пока не узнаете все опции. На этом этапе вы можете даже выбрать другие ограничения, другую терминологию и ограничить доступные игрокам опции.
Теперь для принятия решения о том, когда эвристика должна быть равна 1, используем вместо постоянного значения вероятность.
```
neighbor.SearchHeuristic =
Random.value < jitterProbability ? 1: 0;
```
Мы используем значения эвристики 0 и 1. Хоть можно использовать и бОльшие значения, это сильно ухудшит деформацию участков, скорее всего превратив их в кучу полос.
### Поднимаем несколько участков суши
Мы не будем ограничиваться генераций одного участка суши. Например, поместим вызов `RaiseTerrain` внутрь цикл, чтобы получить пять участков.
```
for (int i = 0; i < 5; i++) {
RaiseTerrain(30);
}
```
*Пять участков суши.*
Хоть сейчас мы и генерируем пять участков по 30 ячеек каждый, но не обязательно получим ровно 150 ячеек суши. Так как каждый участок создаётся по отдельности, они не знают друг о друге, поэтому могут пересекаться. Это нормально, потому что может создать более интересные ландшафты, чем просто набор изолированных участков.
Чтобы повысить вариативность суши, мы также можем изменять размер каждого участка. Добавим два поля integer для управления минимальным и максимальным размерами участков. Присвоим им достаточно большой интервал, например 20–200. Я сделаю стандартный минимум равным 30, а стандартный максимум — 100.
```
[Range(20, 200)]
public int chunkSizeMin = 30;
[Range(20, 200)]
public int chunkSizeMax = 100;
```
*Интервал размеров участков.*
Используем эти поля для случайного определения размера участка при вызове `RaiseTerrain`.
```
RaiseTerrain(Random.Range(chunkSizeMin, chunkSizeMax + 1));
```
*Пять участков со случайными размерами на средней карте.*
### Создаём достаточно суши
Пока мы не можем особо контролировать количество генерируемой суши. Хоть мы и можем добавить опцию конфигурации количества участков, сами размеры участков случайны и могут немного или сильно пересекаться. Поэтому количество участков не гарантирует получение на карте нужного количества суши. Давайте добавим опцию для прямого управления процентом суши, выраженную как integer. Так как 100% суши или воды — это не очень интересно, ограничим его интервалом 5–95, со значением 50 по умолчанию.
```
[Range(5, 95)]
public int landPercentage = 50;
```
*Процент суши.*
Чтобы гарантировать создание нужного количества суши, нам просто нужно продолжать поднимать участки рельефа, пока не получится достаточная величина. Для этого нам нужно контролировать процесс, что усложнит генерацию суши. Поэтому давайте заменим имеющийся цикл поднятия участков на вызов нового метода `CreateLand`. Первое, что делает этот метод — вычисляет количество ячеек, которые должны стать сушей. Это количество будет нашей общей суммой ячеек суши.
```
public void GenerateMap (int x, int z) {
…
// for (int i = 0; i < 5; i++) {
// RaiseTerrain(Random.Range(chunkSizeMin, chunkSizeMax + 1));
// }
CreateLand();
for (int i = 0; i < cellCount; i++) {
grid.GetCell(i).SearchPhase = 0;
}
}
void CreateLand () {
int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f);
}
```
`CreateLand` будет вызвать `RaiseTerrain`, пока у нас не потратится вся сумма ячеек. Чтобы не превысить сумму, изменим `RaiseTerrain` так, чтобы он получал сумму в качестве дополнительного параметра. Закончив работу, он должен возвращать оставшуюся сумму.
```
// void RaiseTerrain (int chunkSize) {
int RaiseTerrain (int chunkSize, int budget) {
…
return budget;
}
```
Сумма должна уменьшаться каждый раз, когда ячейка удаляется из границы и превращается в сушу. Если после этого оказывается потраченной вся сумма, то мы должны прекратит поиск и завершить участок. Кроме того, это нужно делать только тогда, когда текущая ячейка пока не является сушей.
```
while (size < chunkSize && searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
if (current.TerrainTypeIndex == 0) {
current.TerrainTypeIndex = 1;
if (--budget == 0) {
break;
}
}
size += 1;
…
}
```
Теперь `CreateLand` может поднимать сушу, пока не потратит всю сумму ячеек.
```
void CreateLand () {
int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f);
while (landBudget > 0) {
landBudget = RaiseTerrain(
Random.Range(chunkSizeMin, chunkSizeMax + 1), landBudget
);
}
}
```
*Ровно половина карты стала сушей.*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-23/creating-land/creating-land.unitypackage)
Учитываем высоту
----------------
Суша — это не просто плоская плита, ограниченная береговой линией. У неё есть меняющаяся высота, содержащая холмы, горы, долины, озёра, и так далее. Большие перепады высоты существуют из-за взаимодействия медленно движущихся тектонических плит. Хоть мы и не будем его симулировать, наши участки суши должны в чём-то напоминать такие плиты. Участки не движутся, но могут пересекаться. И этим мы можем воспользоваться.
### Выталкиваем сушу наверх
Каждый участок обозначает часть суши, вытолкнутой со дна океана. Поэтому давайте постоянно будем увеличивать высоту текущей ячейки в `RaiseTerrain` и посмотрим, что получится.
```
HexCell current = searchFrontier.Dequeue();
current.Elevation += 1;
if (current.TerrainTypeIndex == 0) {
…
}
```
*Суша с высотами.*
Мы получили высоты, но их сложно увидеть. Можно сделать их разборчивее, если использовать свой тип рельефа для каждого уровня высоты, наподобие географического наслоения. Мы сделаем это только для того, чтобы высоты были заметнее, поэтому можно просто использовать уровень высоты в качестве индекса рельефа.
**Что произойдёт, если высота превысит количество типов рельефа?**
Шейдер будет использовать последнюю текстуру из массива текстур. В нашем случае последним типом рельефа является снег, поэтому мы получим линию снега.
Вместо обновления типа рельефа ячейки при каждом изменении высоты давайте создадим отдельный метод `SetTerrainType`, чтобы задать все типы рельефа только один раз.
```
void SetTerrainType () {
for (int i = 0; i < cellCount; i++) {
HexCell cell = grid.GetCell(i);
cell.TerrainTypeIndex = cell.Elevation;
}
}
```
Будем вызывать этот метод после создания суши.
```
public void GenerateMap (int x, int z) {
…
CreateLand();
SetTerrainType();
…
}
```
Теперь `RaiseTerrain` может не заниматься типом рельефа, и сосредоточиться на высотах. Для этого нужно изменить его логику. Если новая высота текущей ячейки равна 1, то она только что стала сушей, поэтому сумма ячеек уменьшилась, что может привести к завершению роста участка.
```
HexCell current = searchFrontier.Dequeue();
current.Elevation += 1;
if (current.Elevation == 1 && --budget == 0) {
break;
}
// if (current.TerrainTypeIndex == 0) {
// current.TerrainTypeIndex = 1;
// if (--budget == 0) {
// break;
// }
// }
```
*Наслоения пластов.*
### Добавляем воду
Давайте явным образом укажем, какие ячейки являются водой или сушей, задав уровень воды для всех ячеек равным 1. Сделаем это в `GenerateMap` перед созданием суши.
```
public void GenerateMap (int x, int z) {
cellCount = x * z;
grid.CreateMap(x, z);
if (searchFrontier == null) {
searchFrontier = new HexCellPriorityQueue();
}
for (int i = 0; i < cellCount; i++) {
grid.GetCell(i).WaterLevel = 1;
}
CreateLand();
…
}
```
Теперь для обозначения слоёв суши мы можем использовать все типы рельефа. Все подводные ячейки останутся песком, как и самые низкие ячейки суши. Это можно сделать, вычтя из высоты уровень воды и использовав значение в качестве индекса типа рельефа.
```
void SetTerrainType () {
for (int i = 0; i < cellCount; i++) {
HexCell cell = grid.GetCell(i);
if (!cell.IsUnderwater) {
cell.TerrainTypeIndex = cell.Elevation - cell.WaterLevel;
}
}
}
```
*Суша и вода.*
### Повышаем уровень воды
Мы не ограничены одним уровнем воды. Давайте сделаем его настраиваемым с помощью общего поля с интервалом 1–5 и значением 3 по умолчанию. Используем этот уровень при инициализации ячеек.
```
[Range(1, 5)]
public int waterLevel = 3;
…
public void GenerateMap (int x, int z) {
…
for (int i = 0; i < cellCount; i++) {
grid.GetCell(i).WaterLevel = waterLevel;
}
…
}
```
*Уровень воды 3.*
Когда уровень воды равен 3, у нас получается меньше суши, чем мы рассчитывали. Так происходит, потому что `RaiseTerrain` по-прежнему считает, что уровень воды равен 1. Давайте это исправим.
```
HexCell current = searchFrontier.Dequeue();
current.Elevation += 1;
if (current.Elevation == waterLevel && --budget == 0) {
break;
}
```
Использование более высоких уровней воды приводит к тому. что ячейки становятся сушей не сразу. Когда уровень воды равен 2, то первый участок по-прежнему будет оставаться под водой. Дно океана поднялось, но всё равно остаётся под водой. Суша формируется только при пересечении не менее двух участков. Чем выше уровень воды, тем больше участков должно пересечься для создания суши. Поэтому при повышении уровня воды суша становится более хаотичной. Кроме того, когда нужно больше участков, то выше вероятность того, что они будут пересекаться на уже существующей суше, из-за чего горы будут встречаться чаще, а плоская суша — реже, как в случае использования участков меньшего размера.
*Уровни воды 2–5, суши всегда 50%.*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-23/sculpting-with-elevation/sculpting-with-elevation.unitypackage)
Вертикальное перемещение
------------------------
Пока мы поднимали участки вверх на один уровень высоты за раз, но мы не обязаны этим ограничиваться.
### Поднятые высоко участки
Хоть каждый участок увеличивает высоту своих ячеек на один уровень, могут возникать обрывы. Такое происходит, когда касаются края двух участков. Это может создавать изолированные обрывы, но длинные линии обрывов будут редкими. Мы можем увеличить частоту их появления, увеличивая высоту участка больше, чем на один шаг. Но это нужно делать только для определённой доли участков. Если все участки поднимутся высоко, то по рельефу будет очень сложно перемещаться. Поэтому давайте сделаем этот параметр настраиваемым с помощью поля вероятности со значением 0.25 по умолчанию.
```
[Range(0f, 1f)]
public float highRiseProbability = 0.25f;
```
*Вероятность сильного поднятия ячеек.*
Хоть мы и можем использовать для поднимаемых высоко участков любое увеличение высоты, это быстро выходит из под контроля. Разность высот 2 уже создаёт обрывы, поэтому этого достаточно. Так как при этом можно пропустить высоту, равную уровню воды, нам нужно изменить способ определения того, превратилась ли ячейка в сушу. Если она была ниже уровня воды, а теперь оказалась на том же уровне или выше, то мы создали новую ячейку суши.
```
int rise = Random.value < highRiseProbability ? 2 : 1;
int size = 0;
while (size < chunkSize && searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
int originalElevation = current.Elevation;
current.Elevation = originalElevation + rise;
if (
originalElevation < waterLevel &&
current.Elevation >= waterLevel && --budget == 0
) {
break;
}
size += 1;
…
}
```
*Вероятности сильного повышения высоты 0.25, 0.50, 0.75 и 1.*
### Опускаем сушу
Суша не всегда поднимается вверх, иногда она и опускается. Когда суша опустится достаточно низко, её заливает вода и она теряется. Пока мы этого не делаем. Так как мы только выталкиваем участки вверх, суша обычно выглядит как набор перемешанных друг с другом довольно круглых областей. Если мы иногда будем опускать участок вниз, то получим более варьирующиеся формы.
*Большая карта без затонувшей суши.*
Мы можем управлять частотой опускания суши с помощью ещё одного поля вероятности. Так как опускание может уничтожать сушу, вероятность опускания всегда должна быть ниже вероятности поднятия. В противном случае для получения нужного процента суши может потребоваться очень долгое время. Поэтому давайте используем максимальную вероятность опускания 0.4 со значением по умолчанию 0.2.
```
[Range(0f, 0.4f)]
public float sinkProbability = 0.2f;
```
*Вероятность опускания.*
Опускание участка похоже на поднятие, за некоторыми отличиями. Поэтому дублируем метод `RaiseTerrain` и изменим его название на `SinkTerrain`. Вместо определения величины подъёма нам нужна величина опускания, которая может использовать ту же логику. В то же время сравнения для проверки, прошли ли мы через поверхность воды, нужно перевернуть. Кроме того, при опускании рельефа мы не ограничены суммой ячеек. Вместо этого каждая утерянная ячейка суши возвращает потраченную на неё сумму, поэтому мы увеличиваем её и продолжаем работу.
```
int SinkTerrain (int chunkSize, int budget) {
…
int sink = Random.value < highRiseProbability ? 2 : 1;
int size = 0;
while (size < chunkSize && searchFrontier.Count > 0) {
HexCell current = searchFrontier.Dequeue();
int originalElevation = current.Elevation;
current.Elevation = originalElevation - sink;
if (
originalElevation >= waterLevel &&
current.Elevation < waterLevel
// && --budget == 0
) {
// break;
budget += 1;
}
size += 1;
…
}
searchFrontier.Clear();
return budget;
}
```
Теперь на каждой итерации внутри `CreateLand` мы должны или опускать, или поднимать сушу в зависимости от вероятности опускания.
```
void CreateLand () {
int landBudget = Mathf.RoundToInt(cellCount * landPercentage * 0.01f);
while (landBudget > 0) {
int chunkSize = Random.Range(chunkSizeMin, chunkSizeMax - 1);
if (Random.value < sinkProbability) {
landBudget = SinkTerrain(chunkSize, landBudget);
}
else {
landBudget = RaiseTerrain(chunkSize, landBudget);
}
}
}
```
*Вероятность опускания 0.1, 0.2, 0.3 и 0.4.*
### Ограничиваем высоту
На текущем этапе мы потенциально можем накладывать друг на друга множество участков, иногда с несколькими увеличениями высоты, часть которых может опускаться, а затем снова подниматься. При этом мы можем создавать очень высокие, а иногда и очень низкие высоты, особенно когда необходим высоки процент суши.
*Огромные высоты при 90% суши.*
Чтобы ограничивать высоту, давайте добавим настраиваемый минимум и максимум. Разумный минимум будет где-то пределах от −4 до 0, а приемлемый максимум может находиться в интервале 6–10. Пусть значения по умолчанию будут равны −2 и 8. При ручном редактировании карты они будут находиться вне допустимого предела, так что можно изменить ползунок UI редактора, или оставить как есть.
```
[Range(-4, 0)]
public int elevationMinimum = -2;
[Range(6, 10)]
public int elevationMaximum = 8;
```
*Минимум и максимум высоты.*
Теперь в `RaiseTerrain` мы должны сделать так, чтобы высота не превышала допустимого максимума. Это можно сделать, проверяя, окажутся ли текущие ячейки слишком высоко. Если да, то мы пропускаем их, не изменяя высоту и не прибавляя их соседей. Это приведёт к тому, что участки суши будут избегать областей, достигших максимума высоты, и расти вокруг них.
```
HexCell current = searchFrontier.Dequeue();
int originalElevation = current.Elevation;
int newElevation = originalElevation + rise;
if (newElevation > elevationMaximum) {
continue;
}
current.Elevation = newElevation;
if (
originalElevation < waterLevel &&
newElevation >= waterLevel && --budget == 0
) {
break;
}
size += 1;
```
Сделаем то же самое в `SinkTerrain`, но для минимальной высоты.
```
HexCell current = searchFrontier.Dequeue();
int originalElevation = current.Elevation;
int newElevation = current.Elevation - sink;
if (newElevation < elevationMinimum) {
continue;
}
current.Elevation = newElevation;
if (
originalElevation >= waterLevel &&
newElevation < waterLevel
) {
budget += 1;
}
size += 1;
```
*Ограниченная высота с 90% суши.*
### Сохранение отрицательной высоты
На данном этапе код сохранения и загрузки не может обрабатывать отрицательные высоты, потому что мы храним высоту как byte. Отрицательное число преобразуется при сохранении в большое положительное. Поэтому при сохранении и загрузке сгенерированной карты на месте исходных подводных ячеек могут появляться очень высокие.
Мы можем добавить поддержку отрицательной высоты, сохраняя её как integer, а не byte. Однако нам по-прежнему не нужно обеспечивать поддержку множества уровней высоты. Кроме того, мы можем смещать сохраняемое значение, прибавляя 127. Это позволит корректно сохранять высоты в интервале −127–128 в пределах одного байта. Изменим `HexCell.Save` соответствующим образом.
```
public void Save (BinaryWriter writer) {
writer.Write((byte)terrainTypeIndex);
writer.Write((byte)(elevation + 127));
…
}
```
Так как мы изменили способ сохранения данных карт, увеличим `SaveLoadMenu.mapFileVersion` до 4.
```
const int mapFileVersion = 4;
```
И, наконец, изменим `HexCell.Load` так, чтобы он вычитал 127 из высот, загружаемых из файлов версии 4.
```
public void Load (BinaryReader reader, int header) {
terrainTypeIndex = reader.ReadByte();
ShaderData.RefreshTerrain(this);
elevation = reader.ReadByte();
if (header >= 4) {
elevation -= 127;
}
…
}
```
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-23/vertical-movement/vertical-movement.unitypackage)
Воссоздание той же карты
------------------------
Теперь мы уже можем создавать самые различные карты. При генерации каждой новой результат будет случайным. Мы можем управлять с помощью опций конфигурации только характеристиками карты, но не самой точной формой. Но иногда нам нужно воссоздать заново точно такую же карту. Например, чтобы поделиться с другом красивой картой, или начать заново после её ручного редактирования. Кроме того, это полезно в процессе разработке игры, так что давайте добавим такую возможность.
### Использование Seed
Чтобы сделать процесс генерации карты непредсказуемым, мы используем `Random.Range` и `Random.value`. Чтобы снова получить ту же псевдослучайную последовательность чисел, нужно использовать то же значение seed. Мы уже применяли подобный подход раньше, в `HexMetrics.InitializeHashGrid`. Он сначала сохраняет текущее состояние генератора чисел, инициализированного с определённым значением seed, а затем восстанавливает своё исходное состояние. Тот же подход мы можем использовать для `HexMapGenerator.GenerateMap`. Мы снова можем запоминать старое состояние и восстанавливать его после завершения, чтобы не мешать ничему другому, использующему `Random`.
```
public void GenerateMap (int x, int z) {
Random.State originalRandomState = Random.state;
…
Random.state = originalRandomState;
}
```
Далее мы должны сделать доступным seed, использованный для генерации последней карты. Это делается с помощью общего целочисленного поля.
```
public int seed;
```
*Отображение seed.*
Теперь нам нужно значение seed для инициализации `Random`. Для создания случайных карт нужно использовать случайный seed. Самый простейший подход — использовать для генерации произвольного значения seed `Random.Range`. Чтобы оно не влияло на исходное случайное состояние, нам нужно это делать после его сохранения.
```
public void GenerateMap (int x, int z) {
Random.State originalRandomState = Random.state;
seed = Random.Range(0, int.MaxValue);
Random.InitState(seed);
…
}
```
Так как после завершения мы восстанавливаем случайное состояние, то если сразу же сгенерировать другую карту, в результате у нас получится то же значение seed. Кроме того, мы не знаем, как было инициализировано исходное случайное состояние. Поэтому хоть оно и может служить произвольной начальной точкой, нам нужно что-то большее, чтобы рандомизировать его при каждом вызове.
Существуют различные способы инициализации генераторов случайных чисел. В данном случае можно просто скомбинировать несколько произвольных значений, изменяемых в широком диапазоне, то есть вероятность повторной генерации той же карты будет низка. Например, используем нижние 32 бита системного времени, выраженного в циклах, плюс текущее время выполнения приложения. Скомбинируем эти значения с помощью операции побитового исключающего ИЛИ, чтобы результат был не очень большим.
```
seed = Random.Range(0, int.MaxValue);
seed ^= (int)System.DateTime.Now.Ticks;
seed ^= (int)Time.unscaledTime;
Random.InitState(seed);
```
Полученное число может быть отрицательным, что для общедоступного значения seed выглядит не очень красиво. Мы можем сделать его строго положительным, использовав побитовое маскирование с максимальным значением integer, которое обнулит знаковый бит.
```
seed ^= (int)Time.unscaledTime;
seed &= int.MaxValue;
Random.InitState(seed);
```
### Многократное использование Seed
Мы по-прежнему генерируем случайные карты, но теперь можем видеть, какое значение seed использовалось для каждой из них. Чтобы воссоздать ту же карту заново, мы должны приказать генератору снова использовать то же значение seed, а не создавать новое. Мы сделаем это, добавив с помощью булева поля переключатель.
```
public bool useFixedSeed;
```
*Опция использования постоянного seed.*
Если выбран постоянный seed, то мы просто пропускаем генерацию нового seed в `GenerateMap`. Если мы не изменим поле seed вручную, то в результате снова сгенерируется та же карта.
```
Random.State originalRandomState = Random.state;
if (!useFixedSeed) {
seed = Random.Range(0, int.MaxValue);
seed ^= (int)System.DateTime.Now.Ticks;
seed ^= (int)Time.time;
seed &= int.MaxValue;
}
Random.InitState(seed);
```
Теперь мы можем скопировать значение seed понравившейся карты и куда-нибудь его сохранить, чтобы в будущем сгенерировать снова. Не забывайте, что мы получим ту же карту, только если используем точно такие же параметры генератора, то есть тот же размер карты, а также все остальные опции конфигурации. Даже небольшое изменение в этих вероятностях может создать совершенно другую карту. Поэтому кроме seed нам нужно запомнить все настройки.
*Большие карты со значениями seed 0 и 929396788, параметры стандартные.*
[unitypackage](https://catlikecoding.com/unity/tutorials/hex-map/part-23/recreating-the-same-map/recreating-the-same-map.unitypackage) | https://habr.com/ru/post/427003/ | null | ru | null |
# CodeIgniter Command Line library — небольшой ассистент для работы с CLI
Как вы наверное знаете, в php есть интересная функция для обработки данных, поступающих из командной строки: [getopt](http://php.net/manual/ru/function.getopt.php). Но есть одна маленькая проблема — она неправильно работает в CodeIgniter, да и не совсем удобная.
А так как у меня было немного свободного времени, желание написать что-нибудь своё опен сорсное, попробовать в деле github (сижу на hg+bitbucket), и наконец сделать что-то полезное для тухнущего CodeIgniter и его сообщества, я решил написать свой костыль, призванный немного скрасить написание cli скриптов на данном фреймворке.
Оно умеет самый минимум — искать заданные аргументы, производить их валидацию (если не указаны обязательные) и выводить подсказки по использованию вашего скрипта, а при желании легко может быть допилено для использования без привязки к CodeIgniter:
#### Использование
Собственно говоря, при создании библиотеки я постарался сделать её использование привычным для людей, работающих с CodeIgniter, поэтому её использование в чем то похоже на использование стандартной библиотеки **Form\_Validation**.
##### Лучше всего это рассмотреть на примере:
**1.** Для начала качаем библиотеку с [гитхаба](https://github.com/TrueDrago/CodeIgniter-Command-Line-Library-CCLL) и кладём её в папку *\*/application/libraries/*.
**2.** Затем создаем контроллер, который будет использоваться в командной строке:
```
php if ( ! defined("BASEPATH")) exit("No direct script access allowed");
class Cli extends MY_Controller {
public function __construct() {
parent::__construct();
if(!$this-input->is_cli_request()) {
show_404();
}
}
}
```
Обратите внимание на строку, где проверяется, запускается ли этот контроллер из командной строки. Мы же не хотим чтобы какой-нибудь злодей получил доступ к нашему скрипту через веб-сайт!
**3.** Теперь создадим метод, использующий нашу библиотеку:
```
public function hello() {
// Add an argument for cli interaction
$argumets = array(
array('alias' => '-n',
'arg' => '--name',
'help' => 'the name, we say hello to',
'type' => 1)
);
// Initialize library with arguments array
$this->load->library("command_line", $argumets);
// Validate input
if (!$this->command_line->valid_input()) {
// If not valid, print some help
print $this->command_line->get_help();
} else {
// Else do your code
print("Hello " . $this->command_line->get_argument('-n') . "!" . PHP_EOL);
}
}
```
###### Разберем этот код подробнее.
Сначала мы создали массив с возможными параметрами для нашего скрипта:
* **arg** — основное название аргумента (напр. *--name*).
**Обязательно для заполнения, если не указан *alias***
* **alias** — сокращенное название элемента (напр. *-n*).
**Обязательно для заполнения, если не указан *arg***
* **help** — строка, которая будет выводиться при запросе помощи (у нас оно говорит о том, что это имя человека)
* **type** — один из трёх возможных видов аргумента: **0** — для опциональных, **1** — для обязательных и **2** — для триггеров (boolean).
Стоит отметить, что оциональные и триггеры сами определяют своё значение. Например, неуказанные примет значение *FALSE*, а указанный триггер без параметров станет *TRUE*. Если же не указать обязательный, при этом подав какие-либо из существующих параметров на вход, то вылезет ошибка и скрипт не исполнится.
Итак, задав конфиг, мы инициализируем нашу библиотеку и проверяем входящие параметры на валидность, прямо как в Form\_validation!
```
if (!$this->command_line->valid_input())
```
Если она не валидна — нет параметров, или произошла какая-либо ошибка, мы просто вызываем метод, который подскажет нам что не так:
```
print $this->command_line->get_help();
```
Если же всё прошло как надо, то мы можем выполнить свой код, получив параметры аргументов с помощью метода **get\_argument()**. Вы сможете обратиться к ним как по полному названию, так и по алиасу:
```
$this->command_line->get_argument('-n') === $this->command_line->get_argument('--name')
```
**4.** Теперь, когда всё готово, открываем командую строку и проверяем наш скрипт:
```
php index.php cli home
```
Так как вы не ввели никаких аргументов, он дружелюбно подскажет вам, как им пользоваться:
> Usage: php index.php cli hello [OPTIONS]
>
>
>
> Options are:
>
> -n, --name the person's name, we say hello to
>
>
Так, надо ввести имя:
```
php index.php cli home -n Habrahabr
```
Что выведет следующее:
> Hello Habrahabr!
>
>
**UPD:** кроме того, скрипт также может принять в качестве параметра и длинную строку в кавычках, предварительно очистив её от них:
```
php index.php cli home -n "Petr Ivanovich"
```
> Hello Petr Ivanovich!
>
>
#### Заключение
Как видите, библиотека совсем примитивная, и реализует лишь самую базу функций, могущих потребоваться при работе с командной строкой. Тем не менее, она может сэкономить немного времени на разработке системных cli скриптов, используемых, скажем, для задач в cron. Это действительно удобно — можно использовать весь написанный код ваших моделей и библиотек для создания системных задач, таких, как, например, генерация карты сайта или пересчет каких-либо показателей.
Также хочу заранее предупредить, что пока версия библиотеки довольно таки сырая, и возможно возникновение каких-либо багов. С удовольствием выслушаю ваши комментарии по этому поводу, а так же буду рад, если вы вложите свою лепту, присоединившись к разработке на [github](https://github.com/TrueDrago/CodeIgniter-Command-Line-Library-CCLL). | https://habr.com/ru/post/141448/ | null | ru | null |
# Генерация подземелий в Diablo 1
[Diablo 1](https://en.wikipedia.org/wiki/Diablo_(video_game)) — это классический roguelike 1996 года в жанре hack and slash. Это была одна из первых успешных попыток познакомить широкие массы с roguelike, которые до этого имели нишевую графику в виде ASCII-арта. Игра породила несколько сиквелов и множество имитаций. Она известна своей тёмной, мрачной атмосферой, сгущающейся по мере спуска игрока в подземелья, располагающиеся под городом Тристрам. Это была одна из первых для меня игр с процедурной генерацией карт, и возможность генерации столь правдоподобных уровней просто потрясла меня.
Недавно я узнал, что благодаря обнаружению различных файлов с символами отладки несколько фанатов игры взяли на себя задачу по [реверс-инжинирингу исходного кода](https://github.com/diasurgical/devilution), чтобы подчистить его и разобраться, как же выглядел код, написанный разработчиками. Так начался мой недельный экскурс в изучение того, как ведущий разработчик Дэвид Бревик создавал эти уровни. Возможно, из-за этого магия игры для меня частично разрушилась, но я научился многим техникам, которые будут полезны для разработчиков похожих игр, поэтому в этой статье я ими поделюсь.
Благодарю Дэвида Бревика и команду Blizard North за создание такой потрясающей игры, а также [galaxyhaxz](https://github.com/galaxyhaxz) и команду Devilution за их удивительную работу по восстановлению читаемого исходного кода проекта.
Введение
========
Diablo — это игра, состоящая из изометрических тайлов. Игра состоит из 4 этапов, каждый из которых имеет 4 уровня. Этапы игры: Cathedral, Catacombs, Caves и Hell. Есть также несколько фиксированных уровней, например город Тристрам, которые я не буду рассматривать в статье. В Diablo есть отдельные процедуры генерации уровней для каждого из 4 этапов, поэтому я сначала расскажу об их особенностях, а затем рассмотрю по отдельности работу каждого из этапов.
Меня интересовало только то, как генерировались уровни. Чтобы узнать о квестах, монстрах и т.д. я рекомендую прочитать [Jarulf’s Guide To Diablo and Hellfire](http://www.lurkerlounge.com/diablo/jarulf/jarulf162.pdf), в котором эти аспекты описаны исчерпывающе подробно.
Общие особенности
=================
Хотя для каждого этапа есть свой генератор уровней, у всех них есть общие особенности.
Подземелья и тайлы
------------------
Каждый уровень игры генерируется так, чтобы заполнить сетку размером 40 x 40 тайлов. Ось X соответствует юго-востоку, а ось Y — юго-западу.
Эти тайлы используются только для задач генерации уровней. После создания уровня каждый тайл подразделяется на 4 «фрагмента подземелья», которые рендерятся на экране.
Эта более детализированная сетка используется для определения проходимых тайлов, а также обеспечивает более эффективное повторное использование графической памяти. Ранее я писал о [схемах разделения тайлов](https://www.boristhebrave.com/2013/07/14/tileset-roundup/).
Это означает, что стандартная карта Diablo состоит из более чем сотни тайлов, многие из которых являются незначительными вариациями других, чтобы учесть все возможные способы их соединения. Об этом мы поговорим позже.
К моему удивлению, в отличие от других игр этой серии, карты подземелий не составлены из заранее созданных блоков. Почти всё создаётся потайлово при помощи алгоритмов.
Многоэтапный процесс
--------------------
Каждая процедура генерации подземелья разделена на два этапа. «Предварительная генерация» вообще не имеет дела с выбором тайлов. Она просто генерирует массив, в котором помечены проходимые тайлы, тайлы, в которых есть двери, и некоторые другие высокоуровневые детали. На втором этапе эта заготовка подземелья преобразуется в массив тайлов, после чего выполняется генерация и вносятся изменения с учётом этих тайлов.
Это должно быть невероятно удобно для дизайнера. Можно экспериментировать с планом этажа совершенно независимо от выбора тайлов и стиля. Но во многих случаях они взаимосвязаны, обеспечивая более целостное ощущение уровня.
Все этапы создания заготовок подземелий начинаются с заполненного сплошной «твердью» уровня, после чего отдельные части уровня рекурсивно превращаются в тайлы пола. Подробнее я расскажу об этом ниже.
Готовые фрагменты
-----------------
Готовые фрагменты — это заранее созданные блоки уровня, которые просто вставляются в случайно сгенерированный уровень. Они используются для большинства квестов игры. На каждом уровне может быть только один готовый фрагмент, расположение которого на каждом этапе выбирается по отдельности.
*Butcher’s Den — один из первых готовых фрагментов, встречающихся в игре.*
Мини-наборы
-----------
Мини-наборы — это ещё один способ вставки в уровень заранее созданного контента. Это небольшие кусочки, обычно размером примерно 3×3, случайным образом вставляемые в подземелье. Существует простая схема сопоставления паттернов, благодаря которой они появляются только в «правильных» местах. Часто они кодируются дополнительными требованиями, например, мини-наборы нельзя располагать близко друг к другу, они не могут накладываться на готовые фрагменты, и так далее. Некоторые мини-наборы выполняют поиск и замену всегда, а другие делают это с фиксированной вероятностью.
Мини-наборы используются в Diablo для множества разных целей. Они применяются для размещения больших объектов из тайлов, например лестниц, для исправления комбинаций тайлов, плохо соединяющихся друг с другом, а также для добавления тайлам случайной вариативности.
Тематические комнаты
--------------------
Тематические комнаты — это небольшие пространства, ограниченные стеной и дверью. Обычно в них случайным образом расположены некие заранее заданные объекты. Например, в библиотеках всегда есть книжный шкаф с двумя свечами по бокам, несколько случайных подставок для книг и монстры. Логова монстров содержат множества монстров и случайный предмет, и так далее.
На уровнях этапа Сathedral генератор создаёт подходящие комнаты, которые распознаются при помощи [заливки](https://en.wikipedia.org/wiki/Flood_fill) и используются повторно. На других этапах алгоритм находит открытые пространства, в которых для создания комнат рисуются стены и дверь.
Каждый тип тематических комнат имеет определённые требования к размеру и этапу, на котором он генерируется.
Замены тайлов
-------------
На некоторых картах есть специальная адаптация тайлов, но все они имеют общую особенность: некоторые тайлы могут заменяться аналогичными вариациями. Самые стандартные тайлы (например полы и плоские стены) имеют различные вариации, позволяющие снизить монотонность уровня. Замены тайлов никогда не используются повторно рядом друг с другом.
Сопоставление паттернов и «исправления»
---------------------------------------
Как сказано выше, в качестве механизма поиска и замены, исправляющего недочёты генератора, используются мини-наборы. Но на большинстве этапов есть процедуры, которые обнаруживают и исправляют более специфические проблемы. Я не буду вдаваться в подробности, потому что их просто куча. Достаточно сказать, что Diablo довольно забагована, и ближе к релизу стало очевидно, что проще будет добавить распознавание конкретных проблем, чем устранять их фундаментальные причины.
Одним из самых распространённых «исправлений» было «устранение блокировок» (lockout): оно проверяло, можно ли пройти по всему подземелью, и запускало генерацию заново, если это не так.
Квесты
------
Большинство квестов создавалось при помощи готовых фрагментов, но в некоторых использовалась и собственная логика. Например, Zhar the Mad генерирует тематические комнаты-библиотеки, вход в Poisoned Water генерируется мини-набором, а Anvil of Fury имеет специфичный код генерации уровня. Не буду вдаваться в подробности, но код переполнен подобными проверками для квестов.
Cathedral
=========
Собор — это, наверно, самый знаковый из этапов Diablo. Он характеризуется длинными рядами готических арок, тесными комнатками и множеством узких мест в виде дверных проёмов. Давайте посмотрим, как он создавался.
Заготовка подземелья
--------------------
Первое, что делает алгоритм — рисует «сердцевину» карты. Он случайным образом выбирает до трёх комнат размером 10×10 в заранее определённых позициях вдоль центральной оси X или Y. Вдоль оси также рисуется широкий коридор, соединяющий комнаты. Если на уровне есть готовый фрагмент, то он всегда располагается в центре одной из таких комнат. Эти центральные комнаты подземелья помечаются как непригодные для размещения новых стен, чтобы они всегда оставались большими открытыми пространствами.
Все остальные комнаты генерируются рекурсивной техникой «почкование» (budding) в функции под названием `L5roomGen`, которая инициируется в каждой из этих комнат, и выбором оси.
### Функция L5roomGen
* Ей передаётся прямоугольник исходной комнаты, от которой нужно начинать почкование, а также предпочтительная ось.
* С вероятностью 1/4 меняется предпочтительная ось.
* Выбирается случайный размер новой комнаты, по 2, 4 или 6 тайлов с каждой стороны.
* Для каждой стороны исходной комнаты вдоль выбранной оси (т.е. ЮВ/НЗ для X, ЮЗ/СВ для Y):
+ Прямоугольник новой комнаты выравнивается относительно центра края исходной комнаты
+ Выполняется проверка того, что до этого там не было ничего нарисовано и мы не достигли конца карты. Для стен требуется граница в один тайл.
+ Если проверка завершилась успешно, то рисуется комната.
* Для каждой отрисовываемой комнаты рекурсивно вызывается `L5roomGen`, которой передаётся новая комната и ось, противоположная использованной ранее.
В конечном итоге эта процедура начинает с нескольких комнат вырезанных внутри «твёрдых» тайлов, а затем многократно приклеивает новые прямоугольники для вырезания новых проходимых областей. На этом этапе все «комнаты» открыты с одной стороны, потому что каждая новая комната размещается непосредственно рядом с предыдущей, без пропусков для размещения стен.
Затем генератор считает количество сгенерированных проходимых тайлов. Если оно ниже минимального порога, который с каждым уровнем увеличивается, то подземелье уничтожается и попытка генерации выполняется заново.
Подземелье
----------
Пока алгоритм располагал только тайлы «тверди» и пола. Нам нужно заменить их настоящими тайлами стен. Для этого Diablo использует алгоритм marching squares, который я [описывал в предыдущей статье](https://www.boristhebrave.com/2018/04/15/marching-cubes-tutorial/).
Однако игра использует необычную его вариацию. Тайлсет собора содержит стены, но они всегда расположены на дальнем краю тайла. Поэтому существует тайл со стеной на северо-восточной грани, но нет тайлов со стеной на юго-восточной грани. Для создания стен на других сторонах нужно найти «твёрдый» тайл, имеющий дополнительную стену, выходящую наружу от границы тайла. Звучит странно, но на самом деле это очень удобно для сортировки стен по глубине.
Чтобы справиться с этим, Diablo на этапе marching cubes пропускает некоторые стены:
Дополнительные стены добавляются позже, на этапе «исправлений». Думаю, эта простая процедура больше всех влияет на «стиль» собора. Поскольку противоположные стены прикреплены к твёрдым тайлам, то в случае наличия двух комнат, разделённых одним тайлом стен, противоположная стена просто не будет создана. Это означает, что разделители между комнатами «тоньше», чем можно обычно получить в разрешении, при котором выполняются marching squares.
После размещения основных стен генератор добавляет по четыре свободно стоящих колонны к каждой из центральных комнат и колоннаду арок для центрального коридора. Это позволяет придать собору ощущение спроектированного более продуманно, чем другие уровни, а также помогает игрокам ориентироваться.
Затем генератор случайным образом добавляет разделяющие стены. Разделяющие стены всегда проходят прямо вдоль оси от одной стены до другой. Они начинаются с углов, благодаря чему области красиво разделяются на комнатки. В 25% случаев стена является серией арок, в 25% случаев — это серия арок с перекрывающей вход решёткой, а во всех остальных случаев — это сплошная стена. В случае решёток и сплошных стен где-нибудь вдоль разделяющей стены случайным образом добавляется дверь или арка, чтобы пространство было проходимым.
Процедура заливки обнаруживает потенциальные тематические комнаты.
Размещаются лестницы для соединения с другими уровнями. Если их разместить невозможно, то попытка генерации подземелья начинается заново.
Что касается расстановки мини-наборов, «исправлений» и замен, то их я не буду рассматривать подробно. Я больше всего люблю мини-набор PANCREAS1, имеющий вероятность 1% размещения на тайле пола кучи окровавленной плоти. В конце для украшения подземелья по нему расставляется 5-10 объектов ламп.
Catacombs
=========
В отличие от Cathedral, кажущегося спроектированным зданием, Catacombs ощущаются гораздо более стихийными. Они характеризуются квадратными комнатами, соединёнными друг с другом множеством извивающихся коридоров. Во многих местах вместо дверей расположены широкие проёмы. увеличивающие вероятность того, что игрок будет окружён множеством врагов.
Для генерации катакомб использовался самый сложный в игре алгоритм генерации. Подозреваю, что нехватка времени вынудила разработчиков применять в последующих этапах более простые решения.
Заготовка подземелья
--------------------
Процедура создания заготовки подземелья для катакомб достаточно уникальна. На всех остальных этапах есть единственное булево значение, обозначающее наличие или отсутствие пола (плюс набор битов для дополнительных деталей). Catacombs хранят заготовку подземелья в виде ASCII-карты, почти как классические roguelike. И это не особо удивительно, учитывая признание [Дэвида Бревика о том, что он черпал вдохновение для Diablo из Angband](http://www.rpgfan.com/features/David_Brevik_Interview/index.html).
Генератор основных комнат — это снова рекурсивный алгоритм, но на этот раз рекурсивное разделение. Функция `CreateRoom` вызывается для всей области подземелья размером 40×40 минус 1 тайл границы.
### Функция CreateRoom
* Функции `CreateRoom` передаётся прямоугольник, обозначающий область, внутри которой нужно генерировать комнаты. Также функции передаются подробности об исходной комнате (изначально null)
* Если область оказалась слишком узкой, выполняется выход из функции.
* Выбирается случайный размер для комнаты в пределах от 4 до 9 тайлов по каждой из сторон с учётом максимального размера области, в которой нужно расположить комнату.
* В области выбирается случайная позиция для размещения комнаты.
* Комната отрисовывается на ASCII-карте. На рисунке символом `'.'` обозначаются тайлы пола, символом `'#'` — окружающая стена, а буквами `'A'`, `'B'`, `'C'` и `'E'` — четыре угла.
* Если у комнаты есть исходная комната:
+ Выбирается случайный тайл на ближайших краях исходной и новой комнат.
+ Эта информация записывается в список коридоров, который будет использован позже.
* Вырезаются оставшиеся части области, за исключением текущей комнаты, создавая четыре прямоугольника.
* Размер каждого прямоугольника уменьшается на два тайла, чтобы создать пространство между комнатами, а затем рекурсивно вызывается функция `CreateRoom`, в качестве области для которой используется этот прямоугольник, а в качестве исходной — созданная комната.
Если на карте есть готовый фрагмент, то он всегда будет находиться в первой комнате, созданной CreateRoom, и её размеры делаются такими, чтобы в ней помещался этот фрагмент.
После вызовов `CreateRoom` получается ASCII-массив, похожий на показанный ниже (спасибо [nomdenom](https://github.com/nomdenom) за извлечение его из кода):
````
A##B
#..#
A####B #..#
#....# #..#
#....# C##E
#....#
C####E A#####B
#.....#
#.....#
A########B #.....#
#........# #.....#
#........# C#####E
#........# A#B
#........# #.#
#........# #.#
#........# #.#
#........# #.#
#........# #.#
C########E #.#
#.# A#B
C#E #.#
A####B #.#
#....# #.#
#....# #.#
#....# #.#
C####E #.#
#.#
A#####B C#E
#.....#
A###B #.....#
#...# #.....#
C###E #.....#
C#####E
````
В данном случае «корневой» комнатой, созданной изначально, была самая нижняя.
Затем применяется собранная ранее информация о коридорах. Между каждой записанной парой точек проводится линия. Когда она пересекает стену, записывается `'D'`, а когда она пересекает твёрдый тайл, то используется `','`. Коридоры имеют случайную ширину: 1, 2 или 3. Угловые тайлы используются для помощи в навигации.
Если двери находятся по соседству с другой дверью, то они пропускаются, а коридоры могут накладываться друг на друга, что позволяет скрыть простоту генератора.
После записи всех коридоров ASCII-карта подчищается. Угловые тайлы становятся тайлами стен, а тайлы `' '` по соседству с `','` тоже становятся стенами. Наконец, символы `','` заменяются символами `'.'`. Так мы получаем показанный ниже план подземелья.
````
####
#..#
###### #..#
#....# #..#
#....# #D##
#....# #.#
#D#### ##D####
#..# #.....#
#..# ###.....#
##D######## #.D.....#
#........# #.#.....#
#........# ### #.##D####
#........# #.### #.##...#
#........###.D.# #.##...#
#........##..#.# #.##...#
#........##..#.# #.##...#
#........##..#.# #.##...#
#........##..#.# #.##...#
###D#######..#.# #.##...#
#.......#..#.# #.###D##
###.....#..### #.# #.#
#######D##.# #.# #.#
#....#.# #.# #.#
#....D.# #.# #.#
#....###### #.# #.#
##D####....## #.# #.#
#...........# #.# #.#
####....###D####.# ###
######.....##.#
#####.D.....##.#
#...D.#.....D..#
#####.#.....####
#########
````
Как видите, эта процедура может оставлять на карте довольно много пустого места. Поэтому следующим шагом генератора является «заполнение пустот». Он ищет любые смежные отрезки стены, к которым можно приклеить дополнительные прямоугольники пола. Прямоугольники могут быть размером не менее 5×5 и не более 12×14.
Заполнение пустот продолжается, пока не получится минимум 700 тайлов, или будет достигнут предел повтора попыток. Если генератору не удалось достичь 700 тайлов, то генерация подземелья начинается с нуля.
Это даёт нам показанную ниже заготовку подземелья.
````
##########
#........# ###########
#........# #.........#
#........# #.........#
#........# #.........# ####
#........# #.........# #..#
#######..###.........# #..#
#..............# #..#
#..............# #D##
#..............# #.#
#D####.........# ##D####
#..# ########### #.....#
#..# ###.....#
##D######## #.D.....#
#........# #.#.....#
########........# ### #.##D####
#...............# #.### #.##...#
#...............###.D.# #.##...#
#...............##..#.# #.##...#
#...............##..#.# #.##...#
#...............##..#.# #.##...#
#...............##..#.# #.##...#
#......###D#######..#.# #.##...#
#......# #.......#..#.# #.###D##
#......# ###.....#..### #.# #.#
#......#########D##.# #.# #.#
#.........# #....#.# #.# #.#
#.........# #....D.# #.# #.#
#.........# #....###### #.# #.#
#.........# ##D####....## #.# #.#
#.........# #...........# #.# #.#
#.........# ####....###D####.# ###
#.........# ######.....##.#
#.........# #####.D.....##.#
#.........# #...D.#.....D..#
########### #####.#.....####
#########
````
Подземелье
----------
Повторюсь, катакомбы отличаются от стандартной формулы уровней. Вместо алгоритма marching squares (который назначает тайлы на основании квадратов 2×2 заготовки подземелья) здесь используется собственная процедура сопоставления паттернов, которая рассматривает каждый из прямоугольников 3×3 заготовки подземелья и выбирает для подземелья соответствующий тайл. Паттерны определяют, чем должен быть каждый тайл заготовки подземелья: стеной, полом, дверью, сплошным тайлом, или их сочетанием. Я не совсем понимаю, почему.
Остальная часть функции покажется вам знакомой по Cathedral. На карте размещаются лестницы вверх и вниз, подземелье проверяется на возможность полного прохождения, а также выполняются различные исправления. Как описано в разделе «Общие особенности», вставляются комнаты, а затем множество мини-наборов и замен тайлов.
Думаю, что мини-наборы как-то влияют на дверные проёмы, но их довольно скучно читать без инструментов, поэтому я не углублялся в эту тему.
Caves
=====
Уровни Caves заполнены обширными открытыми пространствами и реками лавы. Стены этой области грубы и волнисты. Единственными прямоугольными компонентами здесь являются деревянные помосты, которые очевидно появились позже, чем сами пещеры.
Этот этап — один из самых красивых в игре благодаря анимированной лаве. Чувствуется, что он сильно отличается от предыдущих уровней, составленных из комнат. Поэтому меня весьма удивило то, что основная часть генерации моделируется по принципам этапа Cathedral, а картам придаётся более «пещерный» вид при помощи хитрых трюков.
Заготовка подземелья
--------------------
Создание уровня пещер начинается с одной случайной комнаты размером 2×2, располагающейся где-нибудь поблизости от центра карты. Затем генератор вызывает для каждого края этого блока процедуру `DRLG_L3CreateBlock`.
При отрисовке на этом уровне прямоугольников не используется обычная заливка. Внутренности всегда сплошные, но каждый тайл на границе имеет вероятность 50% стать полом, а в противном случае остаётся твердью.
### Процедура DRLG\_L3CreateBlock
* Эта функция получает ребро прямоугольника, т.е. начальную точку, направление и длину.
* Выбирается размер нового создаваемого блока в интервале 3-4 по каждой из сторон.
* Новый блок случайным образом ставится относительно входного ребра.
* Если для отрисовки блока не хватает места, то выполняется выход.
* Блок отрисовывается.
* С вероятностью 1/4 выполняется выход.
* Рекурсивно вызывается `DRLG_L3CreateBlock` для трёх ребра, кроме того, из которого мы пришли.
Хотя эта процедура похожа на `L5roomGen`, использование гораздо меньшего размера блоков и отрисовка грубых границ придаёт ей гораздо более органический внешний вид. Кроме того, она не включает границу в 1 тайл для стен, поэтому в отличие от предыдущих генераторов может создавать петли.
После создания грубого наброска формы подземелья генератор применяет процедуры эрозии:
* Сначала он находит области тайлов 2×2 с диагонально противоположными сплошными тайлами. С такими формациями часто бывает сложно работать при выполнении marching squares, поэтому один из сплошных тайлов случайным образом заменяется полом.
* Все сплошные тайлы-одиночки, окружённые 8 тайлами пола, заменяются на тайл пола.
* Все длинные и прямые секции стен случайным образом огрубляются заменой 50% стен тайлами пола.
* Повторно устраняются диагонали из сплошных тайлов.
Все эти процедуры добавляют больше тайлов пола, поэтому карта становится более открытой.
Если на ней есть менее 600 тайлов пола, то карта генерируется заново.
Подземелье
----------
Заготовка подземелья преобразуется в тайлы при помощи marching squares. В отличие от Cathedral и Catacombs, тайлсет здесь намного удобнее, и содержит почти все комбинации, необходимые для marching squares. В нём отсутствуют тайлы для диагонально противоположных стен, но они были устранены в фазе заготовки, поэтому никогда не появляются.
Затем, как обычно, идёт множество мини-наборов. В коде есть несколько мини-наборов, определяющих отдельно стоящую секцию стен и заменяющих её сталагмитами и полом, что увеличивает открытость пространств.
Добавляются озёра лавы. Алгоритм ищет смежную секцию стен при помощи [заливки](https://en.wikipedia.org/wiki/Flood_fill). Если ему удаётся найти секцию стен/сплошных тайлов меньше 40 тайлов, полностью окружённых тайлами пола, то они заменяются лавой. Если озеро лавы невозможно найти, то генерация подземелья начинается заново.
*Стена размером 3×3 превращается в озеро лавы*
Затем добавляется несколько лавовых рек. Генератор предпринимает несколько попыток нарисовать реку, начинающуюся с озера лавы и заканчивающуюся в стене. К реке предъявляются следующие требования: она не должна пересекать себя, река имеет длину 7-100 тайлов, и на ней должно быть подходящее место для размещения моста. Тайл моста гарантирует, что вся карта остаётся проходимой. При наличии места на карту может быть добавлено до четырёх рек.
Затем размещаются тематические комнаты. На этом этапе стенами тематических комнат становятся деревянные ограждения, через которые нельзя пройти, но можно смотреть. Деревянные ограждения также используются в двух последующих процедурах. Первая ставит ограждение на всех оставшихся секциях стен, имеющих достаточно длинные прямые отрезки. Вторая рисует линию ограждений на карте, от одной стены до противоположной, а затем вставляет дверь. В отличие от процедуры генерации собора, она не ищет углы, чтобы начать создавать эти стены.
Hell
====
Hell — последний этап Diablo. В нём основной упор делается уже на монстрах, а дизайн уровней уходит на второй план. Этот этап имеет самый маленький тайлсет из всех, и бОльшая его часть используется для огромных лестниц и пентаграмм. Адские уровни обычно состоят из несколкьих квадратных комнат и имеют симметричную схему.
Заготовка подземелья
--------------------
Генерация Hell начинается со случайной комнаты размером 5-6 тайлов по каждой стороне (больше, если в ней есть готовый фрагмент для квеста), а затем применяется то же рекурсивное почкование, что и в Cathedral. Однако генерация ограничена областью 20×20.
Добавляется вертикальный и горизонтальный коридор, растянутый до края области 20×20.
Затем заготовка подземелья отзеркаливается по горизонтали и вертикали, чтобы получить полный размер.
Подземелье
----------
Заготовка подземелья снова преобразуется в тайлы при помощи marching squares. Затем аналогично созданию Cathedral добавляются стены, и как в Catacombs и Caves.
Заключение
==========
Мне очень понравилось читать этот код. Хоть в нём очевидно есть баги, имена назначены хаотично, а некоторые части невозможно воссоздать в качественном исходном коде, чётко видно, что этот код прошёл серьёзную проверку боем и в нём полно умных идей.
Вот самые важные для меня уроки:
* Дьявол кроется в деталях: отдельные компоненты не являются безумно сложными, но в сочетании дают нечто замечательное. Представляю, как разработчики корпели над повышением качества, пока уровни не превратились из просто хороших в потрясающие. Количество тайлов и комбинаторная сложность тайлсетов тоже очень высока — невозможно реализовать это без внимания к тому, как соединяются элементы.
* Поиск и замена для сопоставления паттернов — очень мощный инструмент, при помощи которого можно реализовать множество различных эффектов. Он устраняет баги генерации, добавляет вариативности, вставляет заранее созданный контент, управляет эрозией и делает многое другое.
* Разделение генерации подземелья на карту проходимости (заготовку подземелья) и генерацию тайлов — тоже очень удобная техника, как с точки зрения дизайна, так и отладки.
* Если хотите придать разным областям разный стиль, то отличным решением является создание отдельного алгоритма. Большую часть кода можно использовать многократно, и при этом всё равно создавать очень отличающиеся стили.
* Если возникают сомнения, приклеивайте по сторонам элементов больше прямоугольников. | https://habr.com/ru/post/460038/ | null | ru | null |
# W.Script языки. Часть 2 — высокоуровневые языки, или зачем нам в корпорации C++
Недавно я [опубликовал](http://habrahabr.ru/post/158013/) обзор написания программы Hello, world на корпоративном языке R.Script LLP. Данный язык считается у нас в корпорации низкоуровневым, так как является самым быстрым, среди используемых нами. Сейчас же я расскажу о его модификации — R.Script M HPL (Modified HighProgrammingLanguage).
#### Для чего разработаны данные языки
Все языки W.S. класса написаны нами для ускорения производительности в наших задачах и уже с готовым набором функций. Языки написаны на чистом ассемблере благодаря чему имеют большую производительность. Так как на данных языках часто программируются микроконтроллеры и логика процессоров основной уклон в R.Script делался на производительность. Производительность языка HPL приблизительно равна языку C, но для его использования требуются большие процессорные и ресурсы памяти. Нам выгоднее разрабатывать и поддерживать свой язык, чем использовать сторонний, так как в своем мы сделаем все так, как удобно и нужно именно нам.
#### Предисловие, или для чего написана эта статья
Данная статья написана исключительно для того, чтобы показать как мы в нашей корпорации реализуем те, или иные задачи, а также показать наши разработки. W.S языки программирования (R.Script, L.Script, W-Script) используются только в нашей корпорации и не подлежат полному раскрытию, исключительно знакомство с синтаксисом и прочими особенностями.
#### Обзор R.Script Modified
##### Написание Hello, world
Написание Hello,world намного отличается легкостью по сравнению с LLP. Здесь сначала подгружаются модификации языка:
```
LOAD(INCLUDE{SCRIPT[~SYSTEM:.add>highlevel#]}); //Loading file C:/R.Script/highlevel.add
```
А потом собственно и используем язык. В данной модификации уже предусмотрено тело main:
```
source .main {
//Some code there
}
```
А теперь и используем встроенные функции вывода:
```
var(int) conid = Console.OpenWindow(title="Hello,world",desp="Example application");
Console.WriteLine("Hello,world");
Console.CloseWindow(id=conid);
```
И получаем вот такую не очень мудрую программу, и при всем она работает почти на всех платформах, используя Консоль в Windows и терминал в Linux/Mac.
```
//R.Script 2012 M HPL Hello world
source .main {
var(int) conid = Console.OpenWindow(title="Hello,world",desp="Example application"); //Открываем окно консоли, где будем писать
Console.WriteLine("Hello,world"); //Пишем в консоли, стандартно в последней открытой
App.Wait(5s); //Ожидаем 5 секунд до следующей команды (аналог App.Sleep)
Console.CloseWindows(id=conid); //Закрываем окно консоли
}
```
##### А теперь практика
Ну, а теперь я решил написать скрипт переводчика в консоли, используя сервис Google Translate и работу с ее API.
```
create function .getTranslatedText (pagecode) {
if (var.isset=pagecode and var.!empty==pagecode and String.Search(result,"translatedText")==TRUE) {
var(str) result = String.Cut(mode="searchline","\"translatedText\" :\"(.*)\"","intext"); //Находим строку с текстом и оставляем только текст
return result;
} else {
if (Console.IsOpened()==FALSE) var(int) conid = Console.OpenWindow(); //Если консоль не открыта - открываем
Console.WriteLine("translated text get error"); //Ошибка
use finish(conid); //Используем функцию завершения приложения. Приставка use используется для того, чтобы отделить пользовательские и функции из дополнений от основных
return 0;
}
}
create function .finish(consoleid) {
if (Console.IsOpened==FALSE) App.Exit(); //Проверяем, есть ли открытая консоль, если нету - выходим
if (var.!isset=consoleid and var.empty=consoleid and Console.WindowExists(consoleid)) App.Exit(); //Проверка на правильность переменной переменной
Console.WriteLine(text="Программа завершена, для выхода нажмите любую клавишу",window=consoleid);
Console.WaitKey();
App.Exit();
}
source .main {
include("SYSTEM:.dir>HTTP:.hpl>prot"); //Загружаем модуль, для работы через протокол HTTP (файл C:\Source\HTTP\prot.hpl)
conid = Console.OpenWindow(title="Англо-русский Переводчик","Powered by Google Translate");
var(arr) messages = Array.Create(0>"Переводчик приветствует вас! Введите текст для перевода",1>"Загрузка ответа от сервера",2>"Перевод Вашего текста:",3>"Работа переводчика завершена, нажмите любую клавишу для выхода, или F2 для перевода другого текста");
var(int) messnum = 0;
Console.WriteLine(messages[messnum]);
var(str) texttotrans = Console.ReadLine();
Console.WriteLine(messages[messnum++]);
result = HTTP.GetHTML(url="https://www.googleapis.com/language/translate/v2?key=MY_KEY&source=en⌖=ru&q="..String.Change(" ">"%20",texttotrans),mode="secure");
var(str) return = use getTranslatedText(result);
Console.WriteLine(messages[messnum++].."\n\r"..return.."\n\r"..messages[messnum++]);
var(int) userkey = Console.ReadKey();
if (userkey==K_KEY_F2) {
App.ClearVars();
App.StartMain();
} else App.Exit();
}
```
В результате мы получили консольный мультиплатформенный англо-русский переводчик. Вот и практическое применение. В данном коде можно узнать практически все особенности данного языка. Если что-то не понятно — можно задать вопросы.
##### От автора
Данный язык на практике почти не используется. Используется в основной L.Script и W.Script Platform, о которых я напишу в следующей статье и распишу подробно что там и зачем, а также сравню их коды с кодами C++ и их достоинства по сравнению с ним. Также расскажу о построении GUI приложений с использованием встроенных библиотек L.Script
##### Продолжение следует... | https://habr.com/ru/post/158099/ | null | ru | null |
# Подключение к службе TFS без ввода учетных данных LiveID
Как правило, при подключении к службе [Team Foundation Service](http://tfs.visualstudio.com/) пользователь видит веб-страницу для входа с помощью учетной записи Microsoft, также называемой LiveID. Выполняя вход, пользователь может установить флажок сохранения своей учетной записи Microsoft. В этом случае ее не придется вводить заново, если только не допускать больших перерывов между сеансами входа (тогда система запросит данные еще раз).
Это очень удобно для людей, но как быть, если подключение необходимо выполнить для приложения или веб-службы? С этой целью в программном коде следует применять «альтернативные учетные данные», использование которых необходимо разрешить в параметрах учетной записи. Это тот же самый параметр, который используется при включении [базовой аутентификации для git-tf](http://tfs.visualstudio.com/en-us/learn/code/use-git-and-vs-with-tfs/). Затем можно написать программный код, в котором для подключения к службе будут использоваться эти учетные данные. В долговременной перспективе мы также добавим поддержку OAuth, однако она еще в экспериментальной стадии.
#### Включение альтернативных учетных данных.
Прежде всего эту функцию необходимо включить. Сначала откройте в браузере свою учетную запись или проект, щелкните свое имя в правом верхнем углу, а затем щелкните My Profile (Мой профиль).
В диалоговом окне User Profile (Профиль пользователя) щелкните вкладку Credentials (Учетные данные).
Укажите пароль и сохраните изменения.
Использование в коде альтернативных учетных данных
Перед выполнением описанных ниже действий убедитесь, что на вашем компьютере установлена Visual Studio 2012 с обновлением 1 или более новая версия. В состав этого обновления входят расширения для объектной модели клиента TFS, поддерживающие использование альтернативных учетных данных.
Самый простой способ получения новейших обновлений — щелкнуть всплывающее уведомление на панели задач Windows или в Visual Studio перейти в раздел Tools (Инструменты) –> Extensions and Updates… (Расширения и обновления...), щелкнуть Updates (Обновления), затем Product Updates (Обновления продукта) и установить новейшее обновление. Это обновление также можно загрузить [здесь](http://www.microsoft.com/en-us/download/details.aspx?id=35774).
Чтобы убедиться в наличии установленного Visual Studio с обновлением 1 или более новой версии, выберите Help (Справка) –> About Microsoft Visual Studio (О Microsoft Visual Studio).
Завершив настройку учетных данных, давайте воспользуемся ими, создав простое консольное приложение.
Создав новое консольное приложение, добавьте ссылку на библиотеку Microsoft.TeamFoundation.Client.dll, которая входит в состав ReferenceAssemblies версии 2.0. Объектная модель клиента для TFS практически целиком разработана с помощью .NET 3.5 (CLR 2.0) для поддержки запуска веб-частей TFS в SharePoint.
Ниже приведен пример кода:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TeamFoundation.Client;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
NetworkCredential netCred = new NetworkCredential(
"someone@yahoo.com",
"password");
BasicAuthCredential basicCred = new BasicAuthCredential(netCred);
TfsClientCredentials tfsCred = new TfsClientCredentials(basicCred);
tfsCred.AllowInteractive = false;
TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(
new Uri("https://YourAcct.visualstudio.com/DefaultCollection"),
tfsCred);
tpc.Authenticate();
Console.WriteLine(tpc.InstanceId);
}
}
}
```
Я добавил два оператора using, один для System.Net, чтобы получать NetworkCredential, а другой для Microsoft.TeamFoundation.Client, для доступа к тем классам TFS, которые нам понадобятся.
Сначала мы создадим стандартный объект NetworkCredential с именем пользователя (адрес электронной почты будет совпадать с данными вашей учетной записи Microsoft) и паролем, который вы создали для альтернативных учетных данных. В объекте TfsClientCredentials мы присваиваем параметру AllowInteractive значение false, чтобы отключить появление диалогового окна при использовании неверных учетных данных.
При создании коллекции TfsTeamProjectCollection мы должны указать URL-адрес коллекции и учетные данные. Обратите внимание, что все соединения с учетными записями TF Service требуют использования протокола HTTPS. В настоящее время каждой учетной записи в TF Service соответствует одна коллекция, поэтому она всегда называется DefaultCollection.
Наконец, мы вызываем метод Authenticate() с целью проверки правильности указанных учетных данных и тестирования работоспособности кода, для чего на экран выводится уникальный идентификатор InstanceId этой коллекции.
Теперь приложения, которые не запрашивают ввод учетных данных, могут пользоваться всеми возможностями клиентской объектной модели TFS с помощью службы TF Service.
#### Новые интересные материалы по инструментам разработки на русском языке.
Команда Русского MSDN на регулярной основе ищет наиболее интересные англоязычные материалы для перевода и публикует их в специальном блоге [blogs.msdn.com/b/developer-tools-rus](http://blogs.msdn.com/b/developer-tools-rus/)
Сейчас там уже более десятка статей на различные темы, возможно какие то из них будут вам интересны:
* [JavaScript: повышение производительности при запуске IE с помощью Visual Studio](http://blogs.msdn.com/b/developer-tools-rus/archive/2013/02/13/javascript-ie-visual-studio.aspx)
* [Отладка приложений SharePoint с помощью IntelliTrace в Visual Studio](http://blogs.msdn.com/b/developer-tools-rus/archive/2013/02/07/sharepoint-intellitrace-visual-studio.aspx)
* [Управление версиями в объектной модели клиента TFS](http://blogs.msdn.com/b/developer-tools-rus/archive/2013/01/30/abir.aspx)
* [Улучшенная загрузка символов кода отладчиком Visual Studio 2012](http://blogs.msdn.com/b/developer-tools-rus/archive/2013/01/25/visual-studio-2012.aspx)
* [Знакомство с эмуляторами SharePoint](http://blogs.msdn.com/b/developer-tools-rus/archive/2013/01/16/sharepoint.aspx)
* [Работа нескольких команд в Microsoft Team Foundation Server 2012 и Visual Studio Scrum 2.0](http://blogs.msdn.com/b/developer-tools-rus/archive/2013/01/09/microsoft-team-foundation-server-2012-visual-studio-scrum-2-0.aspx)
* [Кодированный тест пользовательского интерфейса: настройка свойств поиска при записи в Internet Explorer](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/12/25/internet-explorer.aspx)
* [Покрытие кода в Microsoft Test Manager. Подробный анализ](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/12/18/microsoft-test-manager.aspx)
* [Использование async/await без .NET Framework 4.5](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/12/04/async-await-net-framework-4-5.aspx)
* [Typescript — история адаптации к TFS](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/29/typescript-tfs.aspx)
* [Гетерогенные зависимости: что же делать группе разработчиков? Мигрировать или интегрировать!](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/24/10371218.aspx)
* [Разработка приложений в Visual Studio 2012 для Магазина Windows с помощью набора средств для мультиязычных приложений](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/21/visual-studio-2012-windows.aspx)
* [Расширение проверки правописания в Visual Studio 2012 HTML, ASP.NET, CSS и файлах иных типов](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/16/visual-studio-2012-html-asp-net-css.aspx)
* [Введение в ARM: изучаем неопределенное, не заданное спецификациями и зависящее от реализации поведение языка C++](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/14/arm-c.aspx)
* [Пример быстрого реагирования — утилита командной строки для создания сценариев ветвления TFS](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/13/tfs.aspx)
* [Знакомство с дополнением Code Map в CTP-версии Visual Studio 2012](http://blogs.msdn.com/b/developer-tools-rus/archive/2012/11/13/code-map-ctp-visual-studio-2012.aspx) | https://habr.com/ru/post/171209/ | null | ru | null |
# 2019-й по версии Chrome
Привет, Хабр! Сегодня мы попробуем объять необъятное и вспомнить всё, что нам принёс 2019-й год в вебе вообще и в Chrome, в частности, а также пригласить вас на серию вебинаров, посвящённых новым веб-технологиям. В 2019-м году мы пережили очередные I/O и Chrome Dev Summit, прошли от 72-й до 79-й версии, ускорили загрузку картинок и улучшили модель защиты данных пользователей, и многое-многое ещё, но обо всём по порядку.
Январь команда Chrome начала с того, чтобы дать нам всем возможность чуть просторней дышать на просторах веба [без назойливой и мешающей рекламы](https://blog.chromium.org/2019/01/building-better-world-wide-web.html). Тут ни прибавить, ни убавить, но было бы интересно знать ваше мнение: стало ли в Chrome чище и просторней за прошедший год?
В феврале мы устроили маленькую революцию и (наконец!) сделали возможным [размещение прогрессивных веб-приложений в Play Store](https://blog.chromium.org/2019/02/introducing-trusted-web-activity-for.html) при помощи Trusted Web Activities. Да, да – там много оговорок, и некоторые другие браузеры и OS ближе к концу года пошли ещё дальше, но мы-то с вами уже с начала года начали понимать, что такое реальная универсальность веба для распространения контента! [Рамблер/новости](http://news.rambler.ru), [DNS-shop](http://dns-shop.ru), и [Badoo](https://play.google.com/store/apps/details?id=com.badoo.twa) уже используют TWA, а вы?
В том же феврале к нам справа сверху постучали в первый раз в году, и мы все дружно обновились на [73-й Chrome](https://blog.chromium.org/2019/02/chrome-73-beta-constructable.html). Там было: программное добавление таблиц стилей (и это был только первый подход к рывку CSS на новую высоту), новый regex метод для String.prototype и много-много прочих няшек.
За февралём последовал март (Карл!), а с ним и [Chrome за номером 74](https://blog.chromium.org/2019/03/chrome-74-beta-reducing-unwanted-motion.html). Из самого вкусного он принёс нам: JavaScript API для [Feature Policy](https://developers.google.com/web/updates/2018/06/feature-policy) и целый ряд приятностей, включая возможность учитывать предпочтения пользователей относительно подвижности элементов UX при помощи медиа-запросов.
В апреле мы готовились к I/O, но успели провести [3-й AMP Conf](https://amp.dev/events/amp-conf-2019/), где было столько [новых фишек](https://www.youtube.com/playlist?list=PLXTOW_XMsIDSY0USlzgoaIkRyPcHklrEl), что не хватит и трёх обзоров! Но просто нельзя не упомянуть [AMP для почты](https://amp.dev/about/email/), который одними из первых [поддержали в Mail.ru](https://youtu.be/hTd67bMGkNA?t=470), [amp-script](https://youtu.be/sYXkVOiz77I) и все новшества в [AMP для WordPress](https://youtu.be/4mavA1xow1M) (да-да, на [WordPress AMP](https://amp-wp.org/) работает просто офигительно!).
Дальше мы скорость не сбавляли! Вышел [75-й Chrome](https://blog.chromium.org/2019/05/chrome-75-beta-low-latency-canvas.html), а там: Web Share API с поддержкой файлов (раз!), отображение Service Worker’ов в task manager’е (два!), новый конструктор Animation() (три!), и ещё-ещё-ещё.
Потом [вебу стукнуло 30](https://www.google.com/doodles/30th-anniversary-of-the-world-wide-web), а на [Google I/O](https://blog.chromium.org/2019/05/google-io-2019-whats-new-with-chrome.html) чуть не треть контента была посвящена ему любимому.
Там вообще всех новшеств и объявлений не перечислить, но в хит-парад редакторов этого обзора вошли:
* lazy loading изображений и iframe-ов прямо в браузере из коробки
* [Порталы](https://web.dev/hands-on-portals/) (Portals, если вы ещё не видели порталы и не пробовали их использовать… )
* [Web Packaging](https://github.com/WICG/webpackage) и, в частности, [Signed Exchanges](https://developers.google.com/web/updates/2018/11/signed-exchanges) как первый шаг (чуть ниже будет о том, как их использовали на Lenta.ru)
* [Web Perception Toolkit](https://perceptiontoolkit.dev/), облегчающий интеграцию с камерой устройства и опирающийся на [Shape Detection APIs](https://developers.google.com/web/updates/2019/01/shape-detection), а также [Web Share Target API](https://developers.google.com/web/updates/2018/12/web-share-target), благодаря которому любое веб-приложение может занять своё достойное место в списке приложений, через которые пользователи делятся контентом
* В Chrome на десктопах в omnibox добавилась кнопочка установки PWA
* И, да, чуть не забыли – мы запустили [web.dev](https://web.dev/)! Сайт для вас, с вами и о вас – не благодарите :) Серьёзно, лучше расскажите в комментариях, что вам нравится в нём, а что не очень, и как бы вы его улучшили.
После I/O не всем удалось полноценно отдохнуть, поэтому уже в июне нас приветствовал [76-й Chrome](https://blog.chromium.org/2019/06/chrome-76-beta-dark-mode-payments-new.html), а в нём: затемнённый режим (для тех кому хорошо как на светлой, так и на тёмной стороне интерфейсов), улучшения в Payments API и (о радость!) возможность управлять появлением mini-infobar’а для добавления сайта на домашний экран на мобильных устройствах. И это ещё не всё, так что, если ещё не читали, читайте подробности [по ссылке](https://blog.chromium.org/2019/06/chrome-76-beta-dark-mode-payments-new.html).
В июне [появилось несколько новых механизмов защиты](https://blog.chromium.org/2019/06/new-chrome-protections-from-deception.html) пользователей. Во-первых, теперь есть [расширение](https://chrome.google.com/webstore/detail/suspicious-site-reporter/jknemblkbdhdcpllfgbfekkdciegfboi), при помощи которого наиболее бдительные из вас могут помогать остальным сохранять свои данные в безопасности. Во-вторых, сам Chrome теперь умеет вовремя уведомлять о том, что сайт, на который вы хотите зайти, возможно, не является тем, за кого себя выдаёт.
Вскоре подоспел уже и [77-й релиз](https://blog.chromium.org/2019/08/chrome-77-beta-new-performance-metrics.html), в котором из важного стоит выделить появление нового параметра измерения скорости загрузки страниц: Largest Contentful Paint.
Благодаря этому теперь легче стало определять, когда на экране появляется не просто какой-то контент, а всё-таки самый главный элемент контента. Кроме этого, появились новые возможности у форм, запустился [Contact Picker API](https://web.dev/contact-picker/), а в Feature Policy появилась возможность пресекать использование `document.domain`. Тут же было [объявлено](https://blog.chromium.org/2019/10/automatically-lazy-loading-offscreen.html) и о том, что в режиме Lite все картинки и фреймы теперь по умолчанию загружаются по мере необходимости (lazy loading).
В [78-м Chrome](https://developers.google.com/web/updates/2019/10/nic78) вышло сразу несколько долгожданных API: CSS Properties and Values, SMS Receiver (его уже подключили для [авторизации Rambler&Co](http://id.rambler.ru)) и Native File System. Если вы верифицируете пользователей, отправляя SMS, или если у вас есть проект для редактирования файлов в виде нативного приложения, который вы всегда мечтали портировать на веб, последние два API – просто специально для вас. А для тех, кто всегда хочет пробовать всё новое первым, теперь есть целая отдельная [страничка по Origin Trials](https://developers.chrome.com/origintrials/#/trials/active).
[79-й Chrome](https://blog.chromium.org/2019/10/chrome-79-beta-virtual-reality-comes-to.html), конечно, переплюнул всех, предоставив, наконец доступ к [WebXR Device API](https://www.w3.org/TR/webxr/).
А ведь в 79-м мы получили ещё и обновление [Wake Lock API](https://w3c.github.io/wake-lock/), адаптивные иконки для установленных PWA и множество прочих маленьких, но приятных улучшений.
Ну а потом ноябрь, как всегда, принёс с собой [Chrome Dev Summit](https://blog.chromium.org/2019/11/chrome-dev-summit-2019-elevating-web.html), и от новостей, запусков и обновлений зарябило в глазах. Не говоря уже о слюнках, которые текут от всего, что было намечено на следующий год. Из самого мощного отметим появление понятия [Web Bundles](https://web.dev/web-bundles/), способного в корне изменить модель распространения контента в вебе, а также запуск [веб-альманаха](http://almanac.httparchive.org/), невероятно полезного сборника самых разнообразных данных и аналитики со всего веба. Отметим и [объявление о грядущих экспериментах](https://blog.chromium.org/2019/11/moving-towards-faster-web.html) с уведомлением пользователей об ожидаемой скорости загрузки сайта.
К саммиту было приурочено ещё несколько полезных статей и мероприятий. Во-первых, [подробный рассказ о возможностях](https://blog.chromium.org/2019/11/making-new-experiences-possible-on-web.html), которые современному вебу дают [Web Assembly](https://webassembly.org/) и [новые API](https://goo.gle/fugu-api-tracker). Во-вторых, по всему миру прошли митапы под эгидой [CDS Extended](https://developer.chrome.com/devsummit/remote/#extended). Среди них особо хочется отметить [CDS Extended в Москве](https://corp.mail.ru/ru/press/events/670/), организованный командой Mail.ru Group и сообществом GDG Moscow. Обязательно посмотрите [запись его стрима](https://www.youtube.com/playlist?list=PLVsTMiFsjt3jkSPyZP0ZqNBgi3BqmKcw8), так как там коллеги из Mail.ru Group и Rambler&Co как раз рассказали о своём опыте практического внедрения целого ряда из тех новых возможностей, о которых мы рассказали в этой статье.
Кстати об опыте практического внедрения – 2019-й год был особенно богат на замечательные примеры внедрения современных веб-технологий лидерами Рунета. Вот лишь несколько из наших самых любимых примеров.
AMP
---
Один из ведущих онлайн магазинов Рунета, [Ситилинк](https://www.citilink.ru/amp/catalog/mobile/), запустил AMP для каталога и продуктовых страниц, добившись [повышения коэффициента конверсии в покупку на 33%](https://www.cnews.ru/news/line/2019-12-27_sitilink_adaptiroval_prodvizhenie). С нетерпением ждём результатов других ключевых игроков рынка (вроде [Эльдорадо](https://www.eldorado.ru/amp/cat/detail/smartfon-apple-iphone-8-plus-64gb-silver-mq8m2ru-a/) и [М.Видео](https://amp.mvideo.ru/melkaya-kuhonnaya-tehnika/myasorubki-104)), которые тоже начали использовать AMP для своих лендингов.
Конечно, многим в том как работает AMP не нравилось, что при переходе на AMP-страницу из любой поисковой выдачи в адресной строке отображался URL соответствующего кэша, а не самой страницы. Теперь этот вопрос решается при помощи [Signed Exchanges](https://developers.google.com/web/updates/2018/11/signed-exchanges) и Lenta.ru первой на рынке применила эту технологию с использованием упаковщика для AMP (пример open source упаковщика: <https://github.com/ampproject/amppackager>).
**Источник:** Rambler’s [Denis Parashy on Twitter](https://twitter.com/dparashy/status/1204804223730409472)
AMP можно с успехом использовать не только для веб-страниц, но и для [почты](https://amp.dev/about/email/), что с успехом доказали коллеги из почты Mail.ru, которые не просто [запустили поддержку AMP](https://postmaster.mail.ru/amp/?lang=ru), но и обеспечили [успех использования этой технологии](https://habr.com/ru/company/mailru/news/t/469199/) такими монстрами рассылок, как Ozon.ru.
PWA
---
Тинькофф Банк одним из первых в мире запустил PWA для банка и уже ближе к концу 2019 для своего сервиса Тинькофф Путешествия. Помимо в общем замечательного функционала самого веб-приложения, теперь пользователи Тинькофф Путешествий даже при временной потере связи, могут скоротать время за прикольной игрой, чтобы потом бесшовно вернуться к тому, что они пытались сделать на сайте, как только связь восстановится.
Лидер российского рынка доставки еды Delivery Club порадовал своих партнёров перед Новым Годом запуском совершенно нового портала для вендоров, созданного в виде PWA и призванного полностью заменить использовавшиеся ранее нативные решения. Ребята не просто всё сделали, но ещё и занимательно рассказали об этом на организованном Mail.ru Group “[CDS’19 Extended Moscow](https://corp.mail.ru/ru/press/events/670/)”. Все подробности в [докладе Никиты Борисова](https://youtu.be/-AFG-Rwe5d0?t=1552).
Помните про “маленькую февральскую революцию” с TWA, которую мы упоминали выше? В Рунете её весьма активно поддержали с самых разных сторон. Отрасль логистики представлена краснодарским стартапом [ГдеЗерно](https://xn--c1acdaj1bho.xn--p1ai/). Их [TWA](https://play.google.com/store/apps/details?id=ru.gdezerno.app) весит всего 1,5 МБ, при том что приложение предлагает продвинутый функционал для работы с картами и отслеживания грузов. Из ритейла первыми стали экспериментировать [DNS-shop](https://www.dns-shop.ru/), размер [TWA](https://play.google.com/store/apps/details?id=com.es.dns) которых не превышает 1,9 МБ. [Badoo](https://badoo.com/) использовали TWA как формат для облегчённой версии своего приложения для знакомств [Badoo Lite](https://play.google.com/store/apps/details?id=com.badoo.twa), ориентированной на пользователей устройств с меньшей производительностью. И наконец, в мире новостей первопроходцами стали команда новостей [Рамблер](https://news.rambler.ru/), [TWA](https://play.google.com/apps/testing/ru.rambler.news) которых сейчас на этапе тестирования.
Новые возможности
-----------------
Многие из API, запущенных в 2019-м, живут под зонтиком проекта [Fugu](https://goo.gle/fugu-api-tracker). Это самые передовые решения из тех, что сейчас можно найти в вебе, и поэтому вдвойне приятно, что они уже нашли применение в некоторых из ведущих проектов Рунета. Коллеги из Mail.ru, которые [подключили WebAuthn](https://habr.com/ru/company/mailru/news/t/470762/) для своих Почты и Облака, а на
Id.rambler.ru внедрили и [WebAuthn](https://www.w3.org/TR/webauthn/), и [SMS Receiver API](https://web.dev/sms-receiver-api-announcement/). Это означает, что логиниться в эти сервисы теперь можно и [по отпечатку пальца](https://lenta.ru/news/2020/01/22/rambler/) (или с помощью другого биометрического сенсора), а сайт Рамблера теперь ещё и умеет считывать СМС-ки, которые их сервис отправляет вам для подтверждения входа в систему. Если кратко, всё это значит, что мы уверенной поступью идём к беспарольному вебу, и вы совсем скоро сможете сжечь и выбросить все свои бумажечки и блокнотики с паролями!
В 2020-м году нас ждёт ещё больше нового и интересного. Ещё в середине января мы объявили о дальнейшем развитии инициативы [Privacy Sandbox](https://blog.chromium.org/2020/01/building-more-private-web-path-towards.html). Если кратко (мы уверены, вы засыплете нас вопросами в комментариях, и там можно будет разгуляться), то в слегка, но не очень, отдалённом будущем мы с вами придём к вебу, в котором сторонние куки больше не будут нужны для рекламы, аналитики и прочих подобных сервисов.
[WASM](https://webassembly.org/) продолжит расти и хорошеть. Следите за [новостями](https://twitter.com/MaxGraey/status/1211121452658970626), изучайте [примеры](https://web.dev/earth-webassembly/) и [пробуйте](https://webassembly.org/getting-started/developers-guide/) сами. Перечислять всё, что указано в <https://goo.gle/fugu-api-tracker>, займёт ещё страниц десять, поэтому дадим вам лишь небольшой тизер основных вкусностей. [File handler API](https://bugs.chromium.org/p/chromium/issues/detail?id=829689) вкупе с [Native File System API](https://bugs.chromium.org/p/chromium/issues/detail?id=853326) лишают вас последних оправданий, чтобы не строить десктопные приложения для обработки файлов в вебе. Google Drive пока ещё не использует все эти API, но уже прочно [встал на рельсы PWA](https://9to5google.com/2020/01/22/google-drive-progressive-web-app/), и за этим проектом мы бы следили с особым интересом. Ещё один API, который в корне меняет, как мы думаем о веб-приложениях, установленных на компьютере, это, конечно, [Run on OS login (a.k.a. "run on startup")](https://bugs.chromium.org/p/chromium/issues/detail?id=897302). С ним ваше веб-приложение становится ещё ближе и доступнее для любого постоянного пользователя.
И, наконец, в 2020-м году мы хотим больше и чаще общаться с вами, поэтому запускаем [онлайн веб-марафон](https://events.withgoogle.com/modern-web-marathon-2020/) из семи вебинаров, первый из которых пройдёт уже 12 марта. Знакомьтесь с программой ниже, [регистрируйтесь](https://events.withgoogle.com/modern-web-marathon-2020/registrations/new), чтобы получать своевременные уведомления и необходимые материалы и заходите к нам на огонёк, чтобы своевременно узнавать обо всём новом и обсуждать возможности для его применения.
* **[12 марта 2020, 17:00 MSK]** 2019-й год – обзор и новые направления.
* **[14 апреля 2020 17:00 MSK]** Скорость загрузки: Feature Policy, LightWallet, Lighthouse CI, плагины Lighthouse, AMP как фреймворк для создания быстрых сайтов.
* **[27 апреля 2020 17:00 MSK]** AMP: не только ускоренные, не только мобильные, не только страницы – amp-script, AMP Stories, AMP для почты.
* **[15 мая 2020 17:00 MSK]** Обзор PWA. Базовые и продвинутые фичи. Ключевые показатели для анализа. Позиционирование веб- и нативных приложений в сторах и не только.
* **[21 мая 2020 17:00 MSK]** PWA Codelab. Применение Workbox. Работа с пользовательским интерфейсом по добавлению иконки на домашний экран.
* **[TBC]** PWA UX. Общие рекомендации по дизайну. Специфика интерфейсов для установленных веб-приложений и работы в офлайне.
* **[TBC]** Проект Fugu. Современные веб-технологии и API, выводящие веб-приложения на новый уровень – goo.gle/fugu-api-tracker.
Фуф! Спасибо, что дочитали! Надеемся, было познавательно, и очень ждём ваши вопросы и комментарии. На забывайте [регистрироваться](https://events.withgoogle.com/modern-web-marathon-2020/registrations/new) на наш [веб-марафон](https://events.withgoogle.com/modern-web-marathon-2020/) и продолжайте делать наш любимый Веб краше! До скорых встреч!
**//** | https://habr.com/ru/post/488886/ | null | ru | null |
# Охота на Вампуса. Переосмысление классической игры для Алисы
Привет! Меня зовут Кирилл Богатов, я дизайнер голосовых интерфейсов в команде TORTU и заядлый геймер. Когда эти две страсти сталкиваются, рождаются необычные концепты для голосовых игр.
Месяц назад я выпустил игру «[Охота на Вампуса](https://dialogs.yandex.ru/store/skills/96f0d0b7-ohota-na-vampusa)» для голосового ассистента Алисы. Игра получила много положительных отзывов и побывала в топ-10 развлекательных навыков. **В этой статье я поэтапно расскажу о процессе её создания: от переосмысления идей первоисточника — до технической реализации.**
### Почему я решил поделиться своим опытом?
Рассказывая о своих проектах, я увидел определённый интерес со стороны геймеров, молодых родителей и любителей настолок. Люди начали делиться со мной концептами голосовых игр, многие из которых были ну просто «Оу, май!». Кроме того, меня регулярно спрашивают о планах создать полноценную D&D для Алисы или адаптацию игро-книг Браславского.
Как геймер, я хочу видеть больше комплексных голосовых игр вместо очередных викторин и «Угадай %name%», а как VUI-дизайнер — способствовать развитию этого направления, рассказывая о своём опыте и вдохновляя людей на реализацию их идей.
Часть 1. Общий обзор
--------------------
### Первоисточник
В основе игры лежит классическая текстовая аркада Hunt The Wumpus, написанная в 1972 году Грегори Йобом. От оригинала были позаимствованы название и базовые механики. Впоследствии игра обросла собственными идеями и сильно изменилась по настроению.
Действие игры происходит в пещере из 20 комнат, связанных между собой коридорами. Цель игры — выследить и подстрелить монстра Вампуса. Если игрок окажется с ним в одной комнате, то игра закончится, а убить монстра можно только выстрелом из соседней комнаты.
Помимо Вампуса в случайных комнатах могут находиться ямы, от которых игрок погибает, и гигантские летучие мыши, которые переносят его в другую случайную комнату. Узнать о приближении опасностей можно по звукам: Вампус рычит, мыши пищат, а из ям насвистывает ветер. Чтобы точно узнать о том, что находится в соседней комнате, нужно выстрелить в неё.
### Новые идеи
50 лет назад для создания атмосферной игры было достаточно сказать «пещера» и «воняет Вампусом». Сегодня такой трюк не пройдёт. Чтобы удержать внимание игрока и мотивировать его на исследования, игра должна удивлять и регулярно подбрасывать что-то новое. По этой причине я внёс в игру ряд нововведений, которые изменили её до неузнаваемости.
* **Тематические локации**. Вместо безликих комнат игрок теперь исследует уникальные места: ледяной туннель, руины подземного города, гейзеры и многие другие.
* **Диковинки**. В комнатах можно найти необычные вещи, привязанные к конкретной локации. На них же завязана часть нелепых шуток. Вы вот видели когда-нибудь вомбата в зеркальном лабиринте? А он там есть.
* **Сундуки**. В оригинале игрок просто перемещался между комнатами и изредка стрелял во что-нибудь — и это быстро надоедало. Чтобы разнообразить геймплей, я добавил загадочные сундуки. В каждом из них может попасться как ценный артефакт, облегчающий прохождение, так и ловушка или забавная записка.
* **Ловушки**. Время от времени игрок сталкивается со случайными ловушками. Они не могут навредить ему, но каждый такой момент вносит в игру разнообразие и поддерживает общий дух приключений в стиле Индианы Джонса.
* **Катаклизмы.** Особые события, повышающие сложность игры и преображающие комнаты. Подробнее расскажу ниже.
* **Таблица очков**. В конце похода игра подсчитывает заработанные очки и сравнивает их с результатами других игроков. Так абстрактные цифры превратились в показатель крутости игрока.
* **Достижения**. Если игрок попадает в комичную ситуацию, показывает хороший результат или произносит определённые фразы (задает вопросы, грубит или хвалит), то может получить за это ачивку в конце похода.
Часть 2. Рассказчик
-------------------
### Персона
Персона — это то, как голосовой навык общается с пользователем. Поскольку в основе взаимодействия с игроком лежит диалог, то именно от персоны зависит то, как пользователи будет воспринимать игру.
Персона есть во всех голосовых навыках, даже если это обычная викторина. Сравните, как одна и та же реплика могла бы звучать в навыках с разной персоной:
* **Нейтральный**: Здравствуйте. В этой викторине мы проверим, насколько хорошо вы знаете популярных блогеров. Готовы начать?
* **Инициативный:** Привет. Прошерстила тренды и приготовила новые вопросы о ваших любимых блогерах. Готовы проверить свои знания?
* **Неформальный:** Йоп! Бот-блогеровед здесь. Готовы блеснуть знаниями в моей викторине?
> Есть игры без персонажей, но нет игр без персоны.
>
>
Создавать персону с нуля крайне тяжело. Чем больше реплик, тем больше вероятность ошибиться при выборе нужных слов. В этом случае я рекомендую сделать следующее:
* Описать Tone of Voice по методике «[Четырёх измерений](https://www.nngroup.com/articles/tone-of-voice-dimensions/)».
* Взять за основу одного-двух реально существующих персонажей.
В «Вампусе» персона завязана на Рассказчике — харизматичном компаньоне, который сопровождает игроков во время их спуска в пещеру. При его создании я вдохновлялся Бобом — владельцем таверны на полях сражений Hearthstone. Выбрал его за умение подбодрить и заполнить неловкую паузу.
### Персонаж
Если вводите в игру персонажа, продумайте его биографию и запоминающиеся черты:
* Как персонаж связан с миром игры? Как попал в него?
* С какими ситуациями уже сталкивался персонаж? О каких событиях знает и как реагирует на них?
* Что нравится и не нравится персонажу? Чего он боится? Чем занимается в свободное время?
* Есть ли что-то особенное в том, как персонаж говорит или мыслит?
* Есть ли истории, которыми персонаж мог бы поделиться с игроком?
* Понимает ли персонаж, что он — часть игры?
Если не уделять внимание деталям, то на выходе получится очередной весёлый болванчик или покорный «раб-компаньон». Это простительно для игр с низким уровнем персонификации, но не подходит для тех проектов, где общение с персонажем является важной частью игрового процесса или инструментом создания атмосферы.
> Уберите детали и персонаж превратится в болванчика.
>
>
При работе над Рассказчиком я стремился создать образ энтузиаста-романтика, восторженно следующего за своим нанимателем. Выполняя функцию проводника, он акцентирует внимание игрока на красотах пещеры, уберегает его от опасностей и иронизирует над происходящим.
Через реплики Рассказчика игрок также опосредованно получает информацию об окружении. Например, Рассказчик может пожаловаться на холод или сырость в пещере, отогнать змею или испугаться тарантула.
### Голос
Рассказчик говорит голосом Эрмила из [Yandex.SpeechKit](https://cloud.yandex.ru/services/speechkit). Его завораживающий тембр позволил составлять реплики, звучащие не то из программы «В мире животных», не то с экрана загрузки третьего «Ведьмака». Стандартный же голос Алисы был слишком весёлым и не вписывался в атмосферу игры.
При тестировании оказалось, что Эрмил слишком торопится и не понимает вопросительных интонаций. Вот что я делал, чтобы справиться с этим:
* разбивал фразы, которые нельзя прочитать на одном дыхании;
* переформулировал неестественно звучащие фразы;
* вручную расставлял паузы между словами и предложениями;
* использовал вопросительные слова и частицу «ли», чтобы фраза воспринималась как вопрос даже без нужной интонации.
> Допиливайте голос вручную.
>
>
Реплики Рассказчика часто выходят за рамки озвучивания текста с экрана. Он как ассистент, который зачитывает инструкцию и комментирует происходящее: «Здесь можно повернуть налево или направо. О, смотрите какой интересный гриб за тем камнем!». С одной стороны это сокращает количество текста на экране. С другой стороны — добавляет живости и делает реакцию Рассказчика неожиданной для игрока.
Часть 3. Поиск идей
-------------------
Новые идеи обычно рождаются из наблюдений и создания связей между ранее несвязанными вещами. Этот процесс наглядно показан в книге Остина Клеона «[Кради как художник](https://www.mann-ivanov-ferber.ru/books/paperbook/steal-artist/)». Но когда речь заходит о создании чего-то из ряда вон выходящего, нужно что-то помощнее. Здесь на сцену выходит латеральное мышление.
Концепция латерального мышления построена на разрывах шаблона. Исследователь берет за основу привычное состояние системы и применяет к ней ряд провокаций.
Для примера возьмем базовую механику «Вампуса» и сгенерируем на её основе несколько новых идей для сиквела:
* *Базовое состояние* — игрок выслеживает монстра с помощью звуков в пещере.
* *Дополнение* — игрок выслеживает монстра и разгадывает загадки.
* *Инверсия* — монстр выслеживает игрока / пещера следит за игроком и монстром.
* *Исключение* — игрок никого не выслеживает, просто изучает локации.
* *Гиперболизация* — игрок выслеживает нескольких монстров.
* *Изменение порядка* — игра начинается с того, что игрок уже нашел монстра / монстр съел игрока.
Не сковывайте себя рамками адекватности или технических трудностей. Фантазия не терпит ограничений!
Собранные идеи рекомендую анализировать по методике «[Шести шляп мышления](https://ru.wikipedia.org/wiki/%D0%A8%D0%B5%D1%81%D1%82%D1%8C_%D1%88%D0%BB%D1%8F%D0%BF_%D0%BC%D1%8B%D1%88%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F)». Даже если вы работаете в одиночку, это поможет рассмотреть ваши идеи с разных сторон и отобрать лучшие.
Часть 4. Игровой процесс
------------------------
Чтобы быстро разобраться в механике и получить полное впечатление о возможностях игры — посмотрите вот это видео:
### Пещера и базовые механики
Пещера Вампуса представляет собой додекаэдр с 20 вершинами-комнатами. В каждой комнате пользователь может совершить два базовых действия: выстрелить или переместиться в одну из трёх соседних комнат.
Когда игрок находится рядом с Вампусом и промахивается, монстр начинает паниковать и перемещается в одну из трех соседних комнат. C вероятностью 33% он оказывается в одной комнате с игроком. В этом случае игрок либо умирает, либо перемещается в случайную комнату с помощью летучей мыши. Иногда это приводит к курьёзным ситуациям и мыши переносят его в яму.
Связи между комнатами и пути отступления Вампуса пришлось прописывать вручную. Это был самый нудный и кропотливый этап проектирования.
### События
Чтобы разбавить монотонный процесс осмотра комнат, в игре периодически что-то происходит. Вот как выглядят первые 10 ходов игрока (ходом считается переход в комнату):
**Первый (малый) сундук** всегда содержит что-нибудь приятное или полезное. Это сделано для того, чтобы сформировать у новых игроков позитивный первый опыт. Если бы в первом же сундуке оказался монстр или ловушка, игрок бы подумал, что в сундуки лучше вообще не лезть.
**Большие сундуки** подстраиваются под текущую ситуацию. Если у игрока осталось мало стрел, то он с большей вероятностью найдёт в сундуке именно стрелы. Если же из первого сундука выпал фрагмент компаса, то из последующих сундуков может выпасть другой фрагмент.
**Ловушки** и **трёп рассказчика** нужны для поддержания атмосферы и разбавления геймплея.
**Катаклизм** помогает встряхнуть игроков, которые уже пробежали часть комнат и начали скучать. Катаклизм случается на 10 ход и представляет собой одно из трёх событий: землетрясение, потоп или выброс лавы. В это время происходит несколько важных вещей:
* Вампус и летучие мыши перемещаются в другие комнаты.
* В пещере появляется ещё одна яма.
* Меняется описание 2/3 комнат. В зависимости от типа катаклизма они становятся либо разрушенными, либо затопленными, либо сгоревшими. Некоторые комнаты получают особые названия вроде Обсидианового туннеля, который возникает после воздействия лавы на Ледяной туннель.
### Иллюзия общения
При проектировании «Вампуса» мне хотелось отойти от чисто утилитарного использования голоса. Поэтому Рассказчик умеет не только озвучивать обстановку, но и поддерживать диалог, создавая тем самым иллюзию общения.
Чтобы определить темы для диалогов, я выписал себе все сущности, которые встречаются в игре. Это комнаты, сокровища, опасности и диковинки. Получилось порядка 200 сущностей, из которых Рассказчик может отреагировать примерно на 50–70. Для остальных пока не нашлось остроумного ответа.
Рассказчик также умеет реагировать на типовые ситуации: приветствие, прощание, похвалу, оскорбления и т. д. Многие пользователи пытаются разговаривать с ботами как с живыми людьми, поэтому подобные вещи следует учитывать.
> Выходите за рамки основного сценария.
>
>
### Разнообразие
У большинства событий и реплик в игре есть от 4 до 15 различных вариантов. Это делает каждое прохождение непохожим на предыдущее. Нет ничего хуже, чем бот, который всё время повторяет одно и то же.
Особое внимание уделено вступлению. Оно должно было создавать правильный настрой и не наскучить спустя несколько партий. Для этого я составил десяток реплик, вдохновляясь любимыми книгами и играми.
Стартовые реплики при втором, десятом и двадцатом запуске игрыИгра подстраивается под успехи пользователя. Чем больше игр сыграно, тем короче становится приветственная реплика (постоянным игрокам не нужно каждый раз напоминать о сути игры).
> Сделайте реплики вариативными.
>
>
Часть 5. Звуки
--------------
Каждый звук в «Вампусе» выполняет определённую функцию — предупреждает об опасности или задаёт атмосферу. Например, звук натяжения тетивы создаёт небольшую напряженную паузу между репликой игрока и оглашением результата выстрела.
Моя любимая хитрость — звук зажигания факела в конце некоторых реплик Рассказчика. С одной стороны, это добавило в игру больше контекста — в комнатах темно и сыро, поэтому нужно периодически обновлять факелы. С другой стороны, помогло отделить друг от друга несколько реплик, не прибегая к длинным паузам, которые нужны пользователям для того, чтобы успеть осмыслить происходящее и подготовиться к следующей порции информации.
> Звуки создают атмосферу и заполняют неловкую паузу.
>
>
Напоследок — несколько выводов по работе со звуком:
* Оптимальная продолжительность звукового эффекта — 3–5 секунд. Длинные звуки отделяют пользователя от основного геймплея, и он начинает скучать.
* В одной реплике лучше не использовать больше двух звуков подряд. Иначе можно сбить пользователя с толку.
* Звуки позволяют подчеркнуть изменение окружения. Например, запуск новой партии или переход к подведению итогов отделяют их от других частей игры.
* Звуки хорошо подходят для визуализации действий. Например, звук бросания предмета или срабатывания ловушки помогают создать в голове яркие образы.
Часть 6. Удобство
-----------------
### Подсказки
В любой момент игры пользователь может задать вопрос в свободной форме:
* Как победить Вампуса?
* Для чего нужны сокровища?
* Сколько у меня осталось стрел?
* Почему дует сквозняк?
* Как узнать, где находится яма?
* Куда я могу пойти?
* Напомни номера комнат.
Последние две реплики незаменимы для игры без экрана, потому что между озвучиванием номеров комнат и концом реплики Рассказчика проходит достаточно много времени — можно отвлечься и всё забыть.
### Обработка ошибок
Рано или поздно игрок скажет что-то, что не было предусмотрено системой. Это называется ошибкой No Match. В этом случае игрока нужно нежно вернуть на правильный путь и не показаться слишком навязчивым.
В «Вампусе» используется два уровня обработки No Match:
* **1 уровень.** Пользователь столкнулся с ошибкой. В этом случае Рассказчик просит его перефразировать свой запрос.
* **2 уровень.** Пользователь дважды столкнулся с ошибкой первого уровня. На третий раз Рассказчик предлагает ему ознакомиться со списком основных команд.
### Обучение и тренировка
Получая первые логи, я заметил серьёзную проблему. Четверть игроков переставала играть после озвучивания правил (это два экрана текста). Другие игроки начинали играть, не зная правил, после чего закономерно говорили о том, что игра слишком непонятная.
Чтобы исправить ситуацию, я ввёл интерактивное обучение — небольшой тестовый забег под наблюдением Рассказчика. В нём игрока учат перемещаться по комнатам, рассказывают о диковинках и даже дают победить его первого Вампуса.
Игрокам подобная идея зашла и количество выходов на этапе обучения снизилось почти до нуля. А чтобы игроки не бросались играть, не зная правил, обучение запускается автоматически при первом спуске в пещеру.
Часть 7. Техническая реализация
-------------------------------
### Выбор инструмента
Проектировать голосовые игры можно разными способами: на Python, JavaScript или с помощью конструкторов диалогов. Последний вариант будет особенно полезен тем, кто мало знаком с языками программирования.
Изначально я делал «Вампуса» в конструкторе [Aimylogic](https://aimylogic.com/ru). Но вскоре стало понятно, что мой проект слишком большой и сложный для этого. Поэтому я перешел в [JAICP](https://just-ai.com/ru/platforma-jaicp).
JAICP — это платформа для разработки голосовых интерфейсов. Работает на собственном языке DSL, поддерживает Kotlin и JavaScript. На базовом уровне осваивается за пару вечеров.
Ниже я расскажу о том, как реализовать несколько полезных функций и покажу, как работают комнаты в «Вампусе». Материал рассчитан на людей, слабо знакомых с программированием.
**Важно:** перед началом работы в Aimylogic или JAICP обязательно ознакомьтесь с их тарифами. От выбранного тарифа зависит максимальное количество новых пользователей, которые смогут сыграть в вашу игру.
### Основы DSL
Подробно об использовании языка DSL можно узнать [из документации Just AI](https://help.just-ai.com/docs/ru/). Я лишь кратко опишу базовые вещи, необходимые для понимания этой статьи.
В основе работы голосовых навыков лежат стейты (state). Стейт — это текущее состояние системы: что сказал пользователь и как на это отреагировал бот.
```
state: Main
intent: / Привет
script: $session.hello = 1
a: Здравствуйте! Готовы начать новую игру?
buttons:
"Да" -> ./NewGame
"Нет" -> ./Exit
state: NewGame
intent: / Согласие
intent!: / Новая игра
a: Рад это слышать. Приступим!
go!: ./Engage
```
Что может входить в стейт:
* *intent* — намерение пользователя (фразы, на которые должен отреагировать бот);
* *intent!* — тоже намерение, но может срабатывать в любом месте диалога;
* *script* — различные скрипты (например, назначение переменных);
* *a* — ответ бота;
* *buttons* — кнопки (саджесты);
* *go!* — переход в другой стейт.
### Глобальные и локальные переменные
Переменные выполняют в игре множество функций: считают ходы игрока, убирают собранные предметы и размещают опасности в случайных комнатах.
Переменные бывают локальными и глобальными:
* $session — локальные, обнуляются при выходе из игры.
* $client — глобальные, сохраняются для текущего пользователя и не обнуляются при выходе.
В «Вампусе» глобальные переменные считают количество завершенных игр и убитых Вампусов. Чем больше игр сыграно, тем короче становится приветственное сообщение. Чем больше монстров убито, тем выше ранг пользователя.
При работе с глобальными переменными может возникнуть проблема, связанная с отсутствием стартового значения при первом запуске. Вот как её можно обойти:
```
script:
if: $client.session_number > 0
script: $client.session_number += 1.
else:
script:
$client.session_number = 0.
$client.session_number += 1.
```
Локальные переменные определяют всё остальное: ачивки, экипировку, количество стрел и так далее. Стартовые значения для них задаются и обнуляются перед запуском новой партии. Например:
```
#объекты
$session.wampus = $jsapi.random(20) + 1;
$session.bat_1 = $jsapi.random(20) + 1;
$session.bat_2 = $jsapi.random(20) + 1;
$session.pit_1 = $jsapi.random(20) + 1;
$session.pit_2 = 0;
#экипировка
$session.player_ammo = 9;
$session.player_shot = 0;
$session.hook = 0;
$session.compas = 0;
$session.compas_left = 0;
$session.map = 0;
#события
$session.score_total = 0;
$session.wampus_dead = 0;
$session.items = 0;
$session.moves = 0;
$session.rooms = 0;
```
### Рандомизация
В «Вампусе» рандом встречается на каждом шагу: от наименования комнат — до путей бегства монстра.
Чтобы события происходили случайно, я использую системную переменную **$jsapi.random(х) +1**, где x — количество возможных значений. Затем прописываю поведение системы для каждого значения переменной (с помощью условного оператора).
```
state: Disaster
intent: / Предсказание
script: $session.disaster = $jsapi.random(3) + 1;
if: $session.disaster == 1
a: Будет землетрясение.
elseif: $session.disaster == 2
a: Будет потоп.
else:
a: Будет выброс лавы.
```
Обратите внимание, что оператор **=** записывает значение в переменную, а оператор **==** сравнивает с этим значением.
Рандом в фразах делается с помощью [YAML-справочника.](https://help.just-ai.com/1.10.3/docs/ru/common/bot_structure/yaml/) В нём хранятся варианты фраз для каждого случая:
```
pit:
summary: Игрок угодил в яму
answers:
- Ещё один путник сгинул в бездонной яме. Охота окончена
- Вы искали славы, но нашли лишь бездонную яму. Охота окончена
- Теперь мы знаем, что даже у бездонной ямы есть дно. Охота окончена
- Вы упали в яму. Как жаль, что с её дна не видно звёзд на небе. Охота окончена
sorry:
summary: Диалог восстановился после ошибки
answers:
- Давайте вести себя так, будто всё заработало с первого раза.
- Прошу прощения за это недоразумение. Попробуем ещё раз.
- Ума не приложу, как это могло произойти. Давайте ещё раз.
```
Чтобы фраза выбиралась случайно, в стейт добавляется скрипт с методом $reactions.random:
```
script: $temp.index = $reactions.random(phrases.pit.answers.length);
a: 🕳️ Яма! \n {{phrases.pit.answers[$temp.index]}}.
go!: /score/count
```
Здесь *phrases* — это название справочника, а *pit* — вариативная фраза.
### Библиотека звуков
Чтобы быстро подставлять и менять звуки, их удобно хранить в одном месте. Для этого также используется YAML-справочник.
```
stone:
summary: Валун
answers: sil <[200]> sil <[200]>
snake:
summary: Змея
answers: sil <[200]> sil <[200]>
```
*sil <[200]>* указывает на то, что перед воспроизведением звука должна быть пауза в 200 миллисекунд. Коды звуков я беру из Платформы диалогов Яндекса, куда загружаю исходные аудиофайлы.
Чтобы сослаться на звук из справочника, достаточно вставить в текст озвучки конструкцию вида *{{sounds.torch.answers}}*, где *sounds* — название файла, а *torch* — название звука.
```
state: Torch
a: Давайте зажжем новый факел.
|| tts = "Давайте зажжём новый факел. {{sounds.torch.answers}}", ttsEnabled = true
```
Параметр *tts* (text-to-speech) указывает на то, что произносимая ботом реплика будет отличаться от той, что выводится на экран.
### Подсчёт очков
В конце игры Рассказчик озвучивает количество полученных пользователем очков и сравнивает это значение с результатами других очков. Также выводится список полученных достижений и случайная напутственная фраза.
Итоговый счёт складывается из значений других переменных, которые заполняются по ходу игры. Например, каждая пройденная комната увеличивает значение переменной $session.moves. Затем к каждой переменной применяется свой множитель очков.
```
state: count
script: $session.score_total = ($session.moves * 25) + ($session.items * 100) + ($session.money * 250) + ($session.wampus_dead * 5000)
```
Далее считаются ачивки. Для этого тоже используются переменные, расставленные в комнатах. Например, достижение «Неосмотрительный» (ach\_quickpit) выдаётся в том случае, если пользователь упал в яму в первые три хода:
```
if: $session.pit_dead == 1 && $session.moves < 4
script:
$session.ach_quickpit = 1;
$session.score_total += 100
```
Итоговая сумма очков заносится в Google Таблицу. Для этого используется [встроенная интеграция](https://help.just-ai.com/docs/ru/JS_API/built_in_services/integration/integration/):
```
state: Google
GoogleSheets:
operationType = writeDataToLine
integrationId = 04202467-3727-421d-897c-da6583afb0fc
spreadsheetId = 1O_snInw9vWlrVUHDoRXsQyNwZwFadAs31FEwRPkinmA
sheetName = score
body = {"values":["{{$session.score_total}}"]}
okState = /score/Total
errorState = /score/Total
```
Настроить проверку значений таблицы в реальном времени мне не удалось, поэтому я взял выборку из 10 000 последних значений и отсортировал их. Затем выделил ключевые интервалы, чтобы сравнивать с ними результат пользователя.
```
state: Total
a: Ваш счет: {{$session.score_total}} очков \n
if: $session.score_total > 375 && $session.score_total < 1050
random:
a: Лучше, чем у 25% игроков.\n ||tts = "Справились лучше, чем 25% игроков.", ttsEnabled = true
a: Лучше, чем у 25% игроков.\n ||tts = "Оставили позади себя 25% игроков.", ttsEnabled = true
```
Далее мы выводим детальную информацию по очкам и озвучиваем полученные достижения. Для примера представим, что в игре их только два:
```
# Считаем очки:
a: 🏃 Комнаты: {{$session.rooms}} * 25 \n
💎 Диковинки: {{$session.items}} * 100 \n
💰 Сокровища: {{$session.money}} * 250 \n
👾 Вампус: {{$session.wampus_dead}} * 5000 \n\n
# Выдаём ачивки:
if: $session.ach_quickpit == 1 || $session.ach_shapeshifter == 1
a: Достижения: \n||tts = "Получили достижения: sil <[400]>", ttsEnabled = true
if: $session.ach_quickpit == 1
a: 🏆 Неосмотрительный: +100 \n||tts = "Неосмотрительный sil <[300]> — за падение в яму в первые три хода sil <[600]>", ttsEnabled = true
if: $session.ach_shapeshifter == 1
a: 🏆 Перевертыш: +100 \n||tts = "Перевертыш sil <[300]> — за использование секретной комбинации sil <[600]>", ttsEnabled = true
```
### Комнаты
Когда игрок попадает в комнату, игра записывает номер комнаты, чтобы пользователь в любой момент мог спросить, где он находится. Далее идёт проверка на наличие в ней особых объектов. Если таких объектов нет — переходим в стейт **Event**.
```
state: Main
script: $session.player_position = 1;
if: $session.wampus == 1
go!: /wampus/Main
elseif: $session.pit_1 == 1 || $session.pit_2 == 1
go!: /pit/Main
elseif: $session.bat_1 == 1 || $session.bat_2 == 1
go!: /bat/Main
else:
go!: /room_1/Events
```
В стейте **Events** мы увеличиваем счётчик совершенных пользователем ходов и смотрим на получившееся число. При выпадении определённого значения переходим в соответствующее событие:
* *SmallLoot* и *BigLoot* — сундуки;
* *Trap* — ловушка;
* *Talk* — трёп Рассказчика;
* *Earthquake, Flud* и *Lava* — варианты катаклизмов. Какой именно произойдет — зависит от значения переменной $session.disaster (генерируется случайно).
```
state: Events
script: $session.moves += 1;
if: $session.moves == 2
go!: /room_1/Events/SmallLoot
elseif: $session.moves == 4 || $session.moves == 16 || $session.moves == 22 || $session.moves == 28 || $session.moves == 34 || $session.moves == 40
go!: /room_1/Events/Trap
elseif: $session.moves == 6 || $session.moves == 12 || $session.moves == 18|| $session.moves == 24 || $session.moves == 30 || $session.moves == 36
go!: /room_1/Events/Talk
elseif: $session.moves == 8 || $session.moves == 14 || $session.moves == 20 || $session.moves == 26 || $session.moves == 32 || $session.moves == 38
go!: /room_1/Events/BigLoot
elseif: $session.disaster == 1 && $session.moves == 10
go!: /room_1/Events/Earthquake
elseif: $session.disaster == 2 && $session.moves == 10
go!: /room_1/Events/Flud
elseif: $session.disaster == 3 && $session.moves == 10
go!: /room_1/Events/Lava
else:
go!: /room_1/Inspection
```
В стейте **Inspection** происходит осмотр комнаты. Становится запутаннее, держитесь!
Каждая комната в игре — перевёртыш, то есть может называться по-разному в зависимости от значения переменной **$session.room\_X\_name**. За счёт этого в пещеру из 20 комнат удалось вместить 40 наименований.
Код
```
state: Inspection
if: $session.room_1_name == 1
if: ($session.earthquake == 0 && $session.flud == 0 && $session.lava == 0) || $session.room_1_status == 1
if: $session.room_1_sound == 0
script: $session.room_1_sound = 1;
a: 1️⃣ Ледяной туннель \n
🏃 Коридоры: 2, 5 и 8 \n
|| tts = "Комната №1. sil <[100]> Ледяной туннель. Коридоры ведут в комнаты 2, sil <[100]> 5, sil <[100]> и 8. sil <[600]> Как же здесь всё-таки холодно, аж пальцы деревенеют. sil <[300]>", ttsEnabled = true
else:
a: 1️⃣ Ледяной туннель \n
🏃 Коридоры: 2, 5 и 8 \n
|| tts = "Комната №1. sil <[100]> Ледяной туннель. Коридоры ведут в комнаты 2, sil <[100]> 5, sil <[100]> и 8. sil <[300]>", ttsEnabled = true
if: $session.room_1_status == 2 || $session.room_1_status == 3
if: $session.earthquake == 1
a: 1️⃣ Ледяные глыбы \n
🏃 Коридоры: 2, 5 и 8 \n
|| tts = "Комната №1. sil <[100]> Расколотые ледяные глыбы. Коридоры ведут в комнаты 2, sil <[100]> 5, sil <[100]> и 8. sil <[300]>", ttsEnabled = true
if: $session.flud == 1
a: 1️⃣ Плавающие айсберги \n
🏃 Коридоры: 2, 5 и 8 \n
|| tts = "Комната №1. sil <[100]> Плавающие айсберги. Коридоры ведут в комнаты 2, sil <[100]> 5, sil <[100]> и 8. sil <[300]>", ttsEnabled = true
if: $session.lava == 1
if: $session.room_1_sound == 0
script: $session.room_1_sound = 1;
a: 1️⃣ Обсидиановый тоннель \n
🏃 Коридоры: 2, 5 и 8 \n
|| tts = "Комната №1. sil <[100]> Обсиди+ановый тоннель. sil <[100]> Редкое явление, связанное с быстрым охлаждением лавы. Коридоры ведут в комнаты 2, sil <[100]> 5, sil <[100]> и 8. sil <[300]>", ttsEnabled = true
else:
a: 1️⃣ Обсидиановый тоннель \n
🏃 Коридоры: 2, 5 и 8 \n
|| tts = "Комната №1. sil <[100]> Обсиди+ановый тоннель. Коридоры ведут в комнаты 2, sil <[100]> 5, sil <[100]> и 8. sil <[300]>", ttsEnabled = true
```
В некоторых комнатах проигрываются собственные звуки или уникальные реплики Рассказчика. Чтобы они не воспроизводились при повторном прохождении через комнату, используется переменная **$session.room\_X\_sound**.
После наступления катаклизма часть комнат меняет своё название. Произойдет ли это или нет — зависит от переменной **$session.room\_X\_status**: 1 — не меняется, 2 или 3 — меняется (сделал так для того, чтобы менялось большинство комнат, а не строго половина).
Далее идёт учёт диковинок, если они есть в комнате
```
if: ($session.item_1 == 1 || $session.item_2 == 1 || $session.item_3 == 1 || $session.item_4 == 1 || $session.item_5 == 1 || $session.item_6 == 1 || $session.item_7 == 1) && $session.item_R1_collected == 0
script:
$session.item_R1_collected = 1;
$session.items += 1;
random:
a: 💎 Замороженный желудь \n || tts = "Нашли диковинку – замороженный желудь. +100 очков. sil <[300]> Пожалуй это самая ленивая отсылка во всей игре", ttsEnabled = true
a: 💎 Замороженная белка \n || tts = "Нашли диковинку – замороженную белку. +100 очков. sil <[300]> Интересно, нашла ли она свой желудь?", ttsEnabled = true
```
Как только диковинка собрана, переменная **$session.item\_RX\_collected** принимает значение 1. Это значит, что при повторном посещении комнаты диковинки уже не будет.
Ну и последний шаг в этом стейте — проверка наличия опасностей в соседних комнатах и воспроизведение соответствующего звука:
```
if: $session.wampus == 2 || $session.wampus == 5 || $session.wampus == 8
a: 👂 Вампус \n||tts = "{{sounds.wampus_roar.answers}}", ttsEnabled = true
if: $session.pit_1 == 2 || $session.pit_1 == 5 || $session.pit_1 == 8
a: 👂 Яма \n||tts = "{{sounds.wind.answers}}", ttsEnabled = true
if: $session.pit_2 == 2 || $session.pit_2 == 5 || $session.pit_2 == 8
a: 👂 Яма \n||tts = "{{sounds.wind.answers}}", ttsEnabled = true
if: $session.bat_1 == 2 || $session.bat_1 == 5 || $session.bat_1 == 8
a: 👂 Летучие мыши \n||tts = "{{sounds.bats.answers}}", ttsEnabled = true
if: $session.bat_2 == 2 || $session.bat_2 == 5 || $session.bat_2 == 8
a: 👂 Летучие мыши \n||tts = "{{sounds.bats.answers}}", ttsEnabled = true
go!: /room_1/Navigation
```
Заметьте, что проверка условий заканчивается переходом в **Navigation** — это вспомогательный стейт с кнопками, который «пристёгивается» к основным:
```
state: Navigation
buttons:
"🏃 в 2" -> /room_2/Main
"🏃 в 5" -> /room_5/Main
"🏃 в 8" -> /room_8/Main
"🎯 Огонь!" -> /room_1/Shoot
state: To2
intent: /Комната 2
go!: /room_2/Main
state: To5
intent: /Комната 5
go!: /room_5/Main
state: To8
intent: /Комната 8
go!: /room_8/Main
```
Вот так выглядит полностью «собранный» стейт в самой игре:
Дальнейшее развитие событий зависит от пользователя. Если он решает выстрелить в комнату, то выполняется проверка соседних помещений, вычитаются стрелы и объявляются результаты выстрела.
Часть 8. Тестирование
---------------------
### Логи
Логи — наше всё. Они показывают, как именно пользователи взаимодействуют с игрой: какие слова используют и в каких местах испытывают трудности. Благодаря анализу логов я обнаружил огромное количество неучтённых фраз, которые обогатили словарный запас Рассказчика.
Первое время я просматривал все логи вручную. Но когда их стало приходить по 500–600 штук в день — начал фильтровать по ключевым словам и наличию ошибок.
### Друзья и коллеги
Лучший способ понять проблемы игры на раннем этапе разработки — дать протестировать прототип кому-нибудь из своего окружения. В отличие от логов данный метод позволяет выявить неучтённые моменты и задать вопросы о восприятии игры в целом.
### Обратная связь в игре
После пятой сыгранной партии Рассказчик предлагает пользователю оставить отзыв в свободной форме (голосом, не покидая игры). Это помогло узнать о ключевых проблемах, которые невозможно отследить по логам: однообразии, нехватке стрел и завышенной сложности на старте. А вместе с этим — получить ворох хвалебных отзывов, возмущений и детского мата. Вот мои любимые:
### Тестовая комната
Перед обновлением игры я прогоняю нововведения в тестовой комнате. Она находится в релизной версии и активируется особой кодовой фразой. Здесь я оцениваю качество звучания реплик Рассказчика, проверяю интонации, расставляю паузы и акценты.
В комнате также есть кнопки для запуска определённых стейтов. В игре с большим количеством рандома это значительно ускоряет тестирование.
---
Часть 9. Что дальше
-------------------
В следующих проектах я планирую сделать упор на использовании голоса в различных игровых механиках: решении головоломок, пении и сотворении заклинаний. Ну а пока — буду рад, если вы попробуете «[Охоту на Вампуса](https://dialogs.yandex.ru/store/skills/96f0d0b7-ohota-na-vampusa)» и напишите пару слов о своём опыте.
Кстати, если вам интересен мир разговорных технологий — ищите актуальные новости, исследования и экспертные заметки в телеграм-канале Hey Voice, который ведёт наша команда TORTU. | https://habr.com/ru/post/597815/ | null | ru | null |
# Chargebox на Arduino
Создания автомата для зарядки планшетов и телефонов
**Основные компоненты:**
* Arduino Uno
* LСD Display 2x16
* Coin Receiver Wei-Ya HI 07
* Реле
**Задача**
Создать автомат, который будет принимать монеты, далее включать таймер, и выводить питания на USB HUB.
Уже к хабу подключаются разные шнуры. Приблизительные показатели 5V, 1A, зависит от блока питания.
**Конструкция**
Подача питания к хабу управляется с помощью реле.
Блок питания подключается в сеть, а сам его кабель проходить через реле, которым будем управлять Arduino плата (Вкл/Выкл).
Монетоприемник подключается к Arduino для передачи сигнала о монете, а сам питается от блока на 12 Вольт.
Ардуино нужно прошить, делается это через USB порт компьютера и [редактор кода Ардуино](https://www.arduino.cc/en/Main/Software).
Зарядка стартует после нажатия на кнопку.
**Схема и Код**
* Красный и Синий провод — силовой, питание
* Кнопка — Старт зарядки
* Подстроечный резистор — Яркость дисплея
* 2 Подтягивающих резистора (pull-up-резистор) +-4,7 кОм
* Салатовый провод — логический вход для кнопки
* Желтый, Фиолетовый(12,11) — логические входы к дисплею
* Белый — логический вход для монетника
* Фиолетовый(13) — для реле (Вкл/Выкл)
```
// WEI-YA HI-07
const int moneyPin3=3;
const int button1Pin = 2; //Кнопка 1 пин 2
const int add5V = 10;
const int ledPin = 13; //Реле
float sum=0.0; //Сумма
int time; //Время
int button1State;
int moneyPin;
int pulse1=0;
unsigned long timeCount1=0;
// дисплей WH1602
#include //Библиотека
LiquidCrystal lcd(12,11,7,6,5,4);
byte p20[8] = { //Создаем символы для анимации заряда
B10000,
B10000,
B10000,
B10000,
B10000,
B10000,
B10000,
B10000,
};
byte p40[8] = {
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
};
byte p60[8] = {
B11100,
B11100,
B11100,
B11100,
B11100,
B11100,
B11100,
B11100,
};
byte p80[8] = {
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
};
byte p100[8] = {
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
};
void setup()
{
Serial.begin(9600); //Подключаем монитор порта для просмотра данных на компьютере
pinMode(button1Pin, INPUT); //Кнопка, на прием
pinMode(ledPin, OUTPUT); //13, на подачу
pinMode(moneyPin3,INPUT); //Монетник, на прием
pinMode(add5V,INPUT); //+5V pin
attachInterrupt(1,count\_pulse1,FALLING);
Serial.println("Coin ready!");
lcd.begin(16,2);
lcd.clear();
lcd.setCursor(0,1);
lcd.print("Coin ready!");
lcd.setCursor(0,0);
lcd.print("Hello=)");
lcd.createChar(0, p20); //Создаем перемение для анимации заряда (j)
lcd.createChar(1, p40);
lcd.createChar(2, p60);
lcd.createChar(3, p80);
lcd.createChar(4, p100);
}
void loop()
{
moneyPin = digitalRead(moneyPin3);//Cчитываем
if (pulse1=0) //Проверка
{
lcd.clear();
lcd.setCursor(0,1);
lcd.print("Coin ready!");
lcd.setCursor(0,0);
lcd.print("Hello=)");
delay(200);
}
if (pulse1>0 && timeCount1<300) //Проверка
{
lcd.clear();
lcd.setCursor(0,0);lcd.print("Error:/");
lcd.setCursor(0,1);lcd.print("Fast pulse!");
delay(1100);
pulse1=0;
lcd.clear();
lcd.setCursor(0,0);lcd.print("Waiting!");
lcd.setCursor(0,1);lcd.print("Check the power!");
delay(1100);
pulse1=0;
}
if(pulse1>0 && timeCount1>300) //Проверка условий
{
sum+=0.25;
time=sum\*4;
lcd.clear();
lcd.setCursor(0,0);lcd.print(time);
lcd.setCursor(4,0);lcd.print("minute"); //Вывод показателей на ЖКД.
lcd.setCursor(0,1);lcd.print("Total="); //Вывод показателей на ЖКД.
lcd.setCursor(6,1);lcd.print(sum);
}
button1State = digitalRead(button1Pin); //Запись показателей кнопки в переменную
digitalWrite(add5V, HIGH ); //Задаем значение
digitalWrite(ledPin, HIGH ); //Задаем значение
if ((button1State == LOW) && (sum != 0))// если жмём на кнопку и сумма не 0
// тогда
{
digitalWrite(ledPin, LOW);
lcd.clear();
lcd.setCursor(0,0);lcd.print("Power ok!");
for (int i = 0; i<16; i++) // Запуск анимации (16 раз)
{
for (int j=0; j<5; j++) {
lcd.setCursor(i, 1); //Определяем блок ЖКД
lcd.write(j); //Определяем символ в блоке
delay(sum\*3200); //в суме = 64 сек ((0.25\*3100/1000)\*(16\*5))
}
}
digitalWrite(ledPin, HIGH );
lcd.clear();
lcd.setCursor(0,0);lcd.print("Power off!");
sum=0;
}
//Проверка на переполнение
if (sum==20 || sum>20){
lcd.clear();
lcd.setCursor(0,0);lcd.print("It's too much!!!");
lcd.setCursor(0,1);lcd.print("Start Now!!!");
delay(1000);
}
if (sum<0){
lcd.clear();
lcd.setCursor(0,0);lcd.print("Error=(");
sum=0.0;
delay(1000);
}
}
void count\_pulse1(){
//detachInterrupt(0);
detachInterrupt(1);
pulse1++;
if(pulse1==1)
timeCount1=millis();
//attachInterrupt(0,count\_pulse,FALLING);
attachInterrupt(1,count\_pulse1,FALLING);
}
```
Функция setup и loop, выписка из оригинально документации
*The **setup()** function is called when a sketch starts. Use it to initialize variables, pin modes, start using libraries, etc. The setup function will only run once, after each powerup or reset of the Arduino board.
After creating a setup() function, which initializes and sets the initial values, the **loop()** function does precisely what its name suggests, and loops consecutively, allowing your program to change and respond. Use it to actively control the Arduino board.*
**Весь код и схема проверена на работоспособность.
Листинг и схему показываю в том виде, в которым нашел.** | https://habr.com/ru/post/307518/ | null | ru | null |
# Исповедь Битрикс хейтера
Что-то много развелось в последнее время статей про [минусы](/post/280226/) битрикса, и их [опровержений](/post/282317/). Раз уж пошла такая пьянка, то и я добавлю свои 5 копеек.
В комментариях к статьям писали, что не хватает конкретики, примеров, более глубокого обзора.
Данная статья — попытка этот обзор написать. Хотя нет, это скорее пост ненависти и боли (может даже немного нытья). Это такой расширенный вариант поста про минусы от [pistol](https://habrahabr.ru/users/pistol/). Я постараюсь описать большинство тех вещей, которые раздражают именно меня и моих коллег в Битриксе. Постараюсь собрать в одном посте все те минусы, которые доставляют ежедневно очень много боли. Под конец я постараюсь сделать выводы.
Кто я такой? Да в общем-то, обычный разработчик. Работаю с битриксом с ноября 2010 года (5.5 лет). Работаю **только** с битриксом, не сделал ни одного коммерческого проекта на других CMS, не использовал фреймворки в создании сайтов. По роду деятельности я занимаюсь в основном интернет-магазинами, их созданием, поддержкой и развитием.
TL;DR
-----
Битрикс — УГ, не стоит лезть в этот омут без особой надобности.
Вместо вступления
-----------------
Для начала я предлагаю вам провести мысленный эксперимент. Давайте попробуем взять двух backend-разработчиков примерно одного возраста и примерно с одинаковым стажем работы (допустим, 1 — 1.5 года), только чтобы один из них работал все это время с 1С-Битрикс, а другой — с Symfony(например). Можно легко сравнить, с каким набором технологий работал все это время один, а с каким — другой, и какой в итоге набор знаний они получили за это время.
В случае с Symfony разработчиком это будет: php5/7 + глубокое понимание ООП, общепринятые паттерны проектирования (MVC, DI, Factory, Repository как минимум), умение разрабатывать Unit тесты, использовать шаблонизаторы (минимум twig), ORM (с Doctrine), composer, git, стандарты PSR, опыт работы с консолью и написания консольных приложений, базовые навыки настройки веб-сервера.
В случае с 1С-Битрикс разработчиком это будет php5, html/css + javascript/jquery (из коробки шаблонизаторов нет, а битрикс сует логику в шаблоны, как ни крути, придется с этим возиться), возможно git (и это сильно зависит от компании, некоторые динозавры до сих пор пилят на продакшене через FTP), если повезет — немножно sql и… все?
Я понимаю, что это все очень индивидуально и очень большую роль может сыграть окружение человека. Но тут я говорю о том, к чему двигают разработчика системы из коробки. В большинстве случаев, Битрикс разработчик очень сильно уступает в навыках по сравнению с разработчиками под другие фреймворки/CMS — и это неоспоримый факт. А все потому, что Битрикс изначально дает слишком много свободы при отсутствии внятной архитектуры, документации, и правильных решений, тогда как Symfony предлагает все необходимое.
Лишь однажды к нам в компанию пришел опытный человек не из мира 1С-Битрикс (в регионе) и он был на голову сильнее своих коллег с тем же стажем просто за счет того, что ранее ему поставили мозги на правильные рельсы.
Я и сам такой. Мне, к сожалению, с самого начала пустили пыль в глаза той же маркетинговой чепухой, да и попал я в не очень хорошее окружение. Я сам понимаю и чувствую, что мои коллеги с аналогичным стажем работы, но в том же Symfony, имеют больший кругозор, и это очень сильный побочный эффект от битрикса.
Это все наводит на мысли о том, что если ты хочешь развиваться в мире веб-разработки, то в качестве основы нужно выбирать уж точно не битрикс.
Сравнивая двух разработчиков, я хочу обратить внимание на те рамки, в которые загоняет система, и на ту свободу, которую она предоставляет. Что Битрикс, что Symfony — они оба дают почти безграничную гибкость, и в принципе на каждой из них можно создать продукт абсолютно любой сложности. Однако система должна помогать разработчику в решении проблем, вместо того, чтобы вставлять палки в колеса. И тут Битрикс очень сильно проигрывает.
Маркетинг
---------
Сразу хочу сказать немного слов об этом, т.к. это основная составляющая успеха Битрикса.
Можно сказать, что духом маркетинга пропитан весь Битрикс, даже документация для разработчиков. Даже там они пишут о том, что их продукт «настолько крутой, что его ценят и уважают все наши партнеры»([пруф](http://dev.1c-bitrix.ru/learning/course/?COURSE_ID=43&LESSON_ID=2817), блок «Структура»). В битриксе работают хорошие маркетологи, которые грамотно умеют преподнести свой продукт. Раз в полгода они устраивают конференции для партнеров, где рассказывают о том, что было сделано и о том, какие у них планы. Как показывает практика, никогда эти планы не сбываются в срок и очень часто релизы либо неполные, либо с кучей ошибок.
В качестве примера — нашумевший рефакторинг модуля sale, релиз которого откладывали больше года, и даже самую последнюю дату релиза ([23 декабря 2015 года](http://dev.1c-bitrix.ru/community/forums/forum6/topic77125/)) провалили на 3 месяца, и выпустили новый магазин и БУС (Битрикс ред. «Управление Сайтом») 16 версии только в конце марта 2016го. Но в результате после обновления пользователи не только не получили новых фич. Пользователи получили в большинстве случаев неработоспособный магазин, и горку нового недокументированного кода в придачу.
Новым инструментам дают такие громкие названия, которые у всех на слуху: Композитный сайт — ускорение x100; Highload-блоки; Bitrix BigData. На самом деле за этими словами скрываются вполне обыденные вещи, которые не соответствуют своему имени.
И такой подход прослеживается везде, к сожалению. Снаружи продукт выглядит как конфетка, которую купил, поставил и пользуешься. Но если с битриксом сделать шаг в сторону от стандартной поставки — все, поддержание функциональности при обновлениях превращается в ад.
Впрочем, обо всем по порядку, тема маркетинга еще будет всплывать в этом посте, скорее всего, не раз.
Архитектура
-----------
На протяжении десятка лет Битрикс отчаянно загонял сам себя в тупик. Каждая новая фича в продукте выходила в соответствии с интересами бизнеса, без должной проработки с технической точки зрения. И, естественно, все это росло как снежный ком.
Если вдуматься, то в Битриксе нет архитектуры, как таковой. Нет даже общепринятых сформулированных правил, которые позволили бы следовать этой архитектуре. В курсе разработчиков, в разделе [Архитектура продукта](http://dev.1c-bitrix.ru/learning/course/?COURSE_ID=43&LESSON_ID=2817&LESSON_PATH=3913.4608.2817), сказано, что битрикс следует архитектуре MVC и приводит схему:
Сразу хочу сказать, что это MVC очень сильно отличается от классического варианта. Тут очень сильная подмена понятий, никакого MVC тут на самом деле нет, просто есть некое абстрактное разделение на модули, компоненты, и шаблоны компонентов. А уже из этих кирпичиков строится весь сайт. Но каждый из этих кирпичиков может брать на себя разные задачи, и поэтому они тесно взаимосвязаны между собой.
Попробую рассмотреть каждый из этих аспектов архитектуры более подробно.
### M — Model, или API
Мне сложно судить об API системы как о модели. Да, API предоставляет интерфейс доступа к данным и позволяет ими манипулировать. Но API битрикса позволяет работать не только с данными, но и с шаблонами, да и с пользовательскими запросами тоже. Ну да ладно… это лишь мое мнение.
На данный момент в Битриксе есть 2 варианта API. Условно можно разделить их на **старое** и **новое**. Новое API называется D7 (честно — не помню почему, но [Rizhikov](https://habrahabr.ru/users/rizhikov/) рассказывал об этом на одной из партнерских конференций).
Старое API — это собрание антипаттернов, ужасных примеров плохого кода. В Битриксе всегда считалось нормальным вызывать нестатические методы статически, и наоборот, требовать состояния тогда, когда это неуместно. Например, всем известный CIBlockElement::GetList — пожалуй, один из самых часто-используемых методов при разработке. Его реализация содержит более 500 строк кода, использует глобалки, строит ужасающие, колоссальные запросы, и содержит нереальный, просто нечитабельный недокументированный код.
**Смотрим**
```
function GetList($arOrder=array("SORT"=>"ASC"), $arFilter=array(), $arGroupBy=false, $arNavStartParams=false, $arSelectFields=array())
{
/*
Filter combinations:
CHECK_PERMISSIONS="N" - check permissions of the current user to the infoblock
MIN_PERMISSION="R" - when permissions check, then minimal access level
SHOW_HISTORY="N" - add history items to list
SHOW_NEW="N" - if not add history items, then add new, but not published elements
*/
global $DB, $USER;
$MAX_LOCK = intval(COption::GetOptionString("workflow","MAX_LOCK_TIME","60"));
$uid = is_object($USER)? intval($USER->GetID()): 0;
$formatActiveDates = CPageOption::GetOptionString("iblock", "FORMAT_ACTIVE_DATES", "-") != "-";
$shortFormatActiveDates = CPageOption::GetOptionString("iblock", "FORMAT_ACTIVE_DATES", "SHORT");
$arIblockElementFields = array(
"ID"=>"BE.ID",
"TIMESTAMP_X"=>$DB->DateToCharFunction("BE.TIMESTAMP_X"),
"TIMESTAMP_X_UNIX"=>'UNIX_TIMESTAMP(BE.TIMESTAMP_X)',
"MODIFIED_BY"=>"BE.MODIFIED_BY",
"DATE_CREATE"=>$DB->DateToCharFunction("BE.DATE_CREATE"),
"DATE_CREATE_UNIX"=>'UNIX_TIMESTAMP(BE.DATE_CREATE)',
"CREATED_BY"=>"BE.CREATED_BY",
"IBLOCK_ID"=>"BE.IBLOCK_ID",
"IBLOCK_SECTION_ID"=>"BE.IBLOCK_SECTION_ID",
"ACTIVE"=>"BE.ACTIVE",
"ACTIVE_FROM"=>(
$formatActiveDates
?
$DB->DateToCharFunction("BE.ACTIVE_FROM", $shortFormatActiveDates)
:
"IF(EXTRACT(HOUR_SECOND FROM BE.ACTIVE_FROM)>0, ".$DB->DateToCharFunction("BE.ACTIVE_FROM", "FULL").", ".$DB->DateToCharFunction("BE.ACTIVE_FROM", "SHORT").")"
),
"ACTIVE_TO"=>(
$formatActiveDates
?
$DB->DateToCharFunction("BE.ACTIVE_TO", $shortFormatActiveDates)
:
"IF(EXTRACT(HOUR_SECOND FROM BE.ACTIVE_TO)>0, ".$DB->DateToCharFunction("BE.ACTIVE_TO", "FULL").", ".$DB->DateToCharFunction("BE.ACTIVE_TO", "SHORT").")"
),
"DATE_ACTIVE_FROM"=>(
$formatActiveDates
?
$DB->DateToCharFunction("BE.ACTIVE_FROM", $shortFormatActiveDates)
:
"IF(EXTRACT(HOUR_SECOND FROM BE.ACTIVE_FROM)>0, ".$DB->DateToCharFunction("BE.ACTIVE_FROM", "FULL").", ".$DB->DateToCharFunction("BE.ACTIVE_FROM", "SHORT").")"
),
"DATE_ACTIVE_TO"=>(
$formatActiveDates
?
$DB->DateToCharFunction("BE.ACTIVE_TO", $shortFormatActiveDates)
:
"IF(EXTRACT(HOUR_SECOND FROM BE.ACTIVE_TO)>0, ".$DB->DateToCharFunction("BE.ACTIVE_TO", "FULL").", ".$DB->DateToCharFunction("BE.ACTIVE_TO", "SHORT").")"
),
"SORT"=>"BE.SORT",
"NAME"=>"BE.NAME",
"PREVIEW_PICTURE"=>"BE.PREVIEW_PICTURE",
"PREVIEW_TEXT"=>"BE.PREVIEW_TEXT",
"PREVIEW_TEXT_TYPE"=>"BE.PREVIEW_TEXT_TYPE",
"DETAIL_PICTURE"=>"BE.DETAIL_PICTURE",
"DETAIL_TEXT"=>"BE.DETAIL_TEXT",
"DETAIL_TEXT_TYPE"=>"BE.DETAIL_TEXT_TYPE",
"SEARCHABLE_CONTENT"=>"BE.SEARCHABLE_CONTENT",
"WF_STATUS_ID"=>"BE.WF_STATUS_ID",
"WF_PARENT_ELEMENT_ID"=>"BE.WF_PARENT_ELEMENT_ID",
"WF_LAST_HISTORY_ID"=>"BE.WF_LAST_HISTORY_ID",
"WF_NEW"=>"BE.WF_NEW",
"LOCK_STATUS"=>"if (BE.WF_DATE_LOCK is null, 'green', if(DATE_ADD(BE.WF_DATE_LOCK, interval ".$MAX_LOCK." MINUTE)"BE.WF\_LOCKED\_BY",
"WF\_DATE\_LOCK"=>$DB->DateToCharFunction("BE.WF\_DATE\_LOCK"),
"WF\_COMMENTS"=>"BE.WF\_COMMENTS",
"IN\_SECTIONS"=>"BE.IN\_SECTIONS",
"SHOW\_COUNTER"=>"BE.SHOW\_COUNTER",
"SHOW\_COUNTER\_START"=>$DB->DateToCharFunction("BE.SHOW\_COUNTER\_START"),
"CODE"=>"BE.CODE",
"TAGS"=>"BE.TAGS",
"XML\_ID"=>"BE.XML\_ID",
"EXTERNAL\_ID"=>"BE.XML\_ID",
"TMP\_ID"=>"BE.TMP\_ID",
"USER\_NAME"=>"concat('(',U.LOGIN,') ',ifnull(U.NAME,''),' ',ifnull(U.LAST\_NAME,''))",
"LOCKED\_USER\_NAME"=>"concat('(',UL.LOGIN,') ',ifnull(UL.NAME,''),' ',ifnull(UL.LAST\_NAME,''))",
"CREATED\_USER\_NAME"=>"concat('(',UC.LOGIN,') ',ifnull(UC.NAME,''),' ',ifnull(UC.LAST\_NAME,''))",
"LANG\_DIR"=>"L.DIR",
"LID"=>"B.LID",
"IBLOCK\_TYPE\_ID"=>"B.IBLOCK\_TYPE\_ID",
"IBLOCK\_CODE"=>"B.CODE",
"IBLOCK\_NAME"=>"B.NAME",
"IBLOCK\_EXTERNAL\_ID"=>"B.XML\_ID",
"DETAIL\_PAGE\_URL"=>"B.DETAIL\_PAGE\_URL",
"LIST\_PAGE\_URL"=>"B.LIST\_PAGE\_URL",
"CANONICAL\_PAGE\_URL"=>"B.CANONICAL\_PAGE\_URL",
"CREATED\_DATE"=>$DB->DateFormatToDB("YYYY.MM.DD", "BE.DATE\_CREATE"),
"BP\_PUBLISHED"=>"if(BE.WF\_STATUS\_ID = 1, 'Y', 'N')",
);
unset($shortFormatActiveDates);
unset($formatActiveDates);
$bDistinct = false;
CIBlockElement::PrepareGetList(
$arIblockElementFields,
$arJoinProps,
$bOnlyCount,
$bDistinct,
$arSelectFields,
$sSelect,
$arAddSelectFields,
$arFilter,
$sWhere,
$sSectionWhere,
$arAddWhereFields,
$arGroupBy,
$sGroupBy,
$arOrder,
$arSqlOrder,
$arAddOrderByFields,
$arIBlockFilter,
$arIBlockMultProps,
$arIBlockConvProps,
$arIBlockAllProps,
$arIBlockNumProps,
$arIBlockLongProps
);
$arFilterIBlocks = isset($arFilter["IBLOCK\_ID"])? array($arFilter["IBLOCK\_ID"]): array();
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*FROM PART\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
$sFrom = "";
foreach($arJoinProps["FPS"] as $iblock\_id => $iPropCnt)
{
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_element\_prop\_s".$iblock\_id." FPS".$iPropCnt." ON FPS".$iPropCnt.".IBLOCK\_ELEMENT\_ID = BE.ID\n";
$arFilterIBlocks[$iblock\_id] = $iblock\_id;
}
foreach($arJoinProps["FP"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_property FP".$i." ON FP".$i.".IBLOCK\_ID = B.ID AND ".
(
IntVal($propID)>0?
" FP".$i.".ID=".IntVal($propID)."\n":
" FP".$i.".CODE='".$DB->ForSQL($propID, 200)."'\n"
);
else
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_property FP".$i." ON FP".$i.".IBLOCK\_ID = B.ID AND ".
(
IntVal($propID)>0?
" FP".$i.".ID=".IntVal($propID)."\n":
" FP".$i.".CODE='".$DB->ForSQL($propID, 200)."'\n"
);
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["FPV"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
if($db\_prop["MULTIPLE"]=="Y")
$bDistinct = true;
if($db\_prop["VERSION"]==2)
$strTable = "b\_iblock\_element\_prop\_m".$db\_prop["IBLOCK\_ID"];
else
$strTable = "b\_iblock\_element\_property";
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN ".$strTable." FPV".$i." ON FPV".$i.".IBLOCK\_PROPERTY\_ID = FP".$db\_prop["JOIN"].".ID AND FPV".$i.".IBLOCK\_ELEMENT\_ID = BE.ID\n";
else
$sFrom .= "\t\t\tLEFT JOIN ".$strTable." FPV".$i." ON FPV".$i.".IBLOCK\_PROPERTY\_ID = FP".$db\_prop["JOIN"].".ID AND FPV".$i.".IBLOCK\_ELEMENT\_ID = BE.ID\n";
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["FPEN"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
if($db\_prop["VERSION"] == 2 && $db\_prop["MULTIPLE"] == "N")
{
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_property\_enum FPEN".$i." ON FPEN".$i.".PROPERTY\_ID = ".$db\_prop["ORIG\_ID"]." AND FPS".$db\_prop["JOIN"].".PROPERTY\_".$db\_prop["ORIG\_ID"]." = FPEN".$i.".ID\n";
else
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_property\_enum FPEN".$i." ON FPEN".$i.".PROPERTY\_ID = ".$db\_prop["ORIG\_ID"]." AND FPS".$db\_prop["JOIN"].".PROPERTY\_".$db\_prop["ORIG\_ID"]." = FPEN".$i.".ID\n";
}
else
{
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_property\_enum FPEN".$i." ON FPEN".$i.".PROPERTY\_ID = FPV".$db\_prop["JOIN"].".IBLOCK\_PROPERTY\_ID AND FPV".$db\_prop["JOIN"].".VALUE\_ENUM = FPEN".$i.".ID\n";
else
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_property\_enum FPEN".$i." ON FPEN".$i.".PROPERTY\_ID = FPV".$db\_prop["JOIN"].".IBLOCK\_PROPERTY\_ID AND FPV".$db\_prop["JOIN"].".VALUE\_ENUM = FPEN".$i.".ID\n";
}
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["BE"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_element BE".$i." ON BE".$i.".ID = ".
(
$db\_prop["VERSION"]==2 && $db\_prop["MULTIPLE"]=="N"?
"FPS".$db\_prop["JOIN"].".PROPERTY\_".$db\_prop["ORIG\_ID"]
:"FPV".$db\_prop["JOIN"].".VALUE\_NUM"
).
(
$arFilter["SHOW\_HISTORY"] != "Y"?
" AND ((BE.WF\_STATUS\_ID=1 AND BE.WF\_PARENT\_ELEMENT\_ID IS NULL)".($arFilter["SHOW\_NEW"]=="Y"? " OR BE.WF\_NEW='Y'": "").")":
""
)."\n";
if($db\_prop["bJoinIBlock"])
$sFrom .= "\t\t\tLEFT JOIN b\_iblock B".$i." ON B".$i.".ID = BE".$i.".IBLOCK\_ID\n";
if($db\_prop["bJoinSection"])
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_section BS".$i." ON BS".$i.".ID = BE".$i.".IBLOCK\_SECTION\_ID\n";
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["BE\_FPS"] as $iblock\_id => $db\_prop)
{
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_element\_prop\_s".$iblock\_id." JFPS".$db\_prop["CNT"]." ON JFPS".$db\_prop["CNT"].".IBLOCK\_ELEMENT\_ID = BE".$db\_prop["JOIN"].".ID\n";
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["BE\_FP"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
list($propID, $link) = explode("~", $propID, 2);
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_property JFP".$i." ON JFP".$i.".IBLOCK\_ID = BE".$db\_prop["JOIN"].".IBLOCK\_ID AND ".
(
IntVal($propID)>0?
" JFP".$i.".ID=".IntVal($propID)."\n":
" JFP".$i.".CODE='".$DB->ForSQL($propID, 200)."'\n"
);
else
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_property JFP".$i." ON JFP".$i.".IBLOCK\_ID = BE".$db\_prop["JOIN"].".IBLOCK\_ID AND ".
(
IntVal($propID)>0?
" JFP".$i.".ID=".IntVal($propID)."\n":
" JFP".$i.".CODE='".$DB->ForSQL($propID, 200)."'\n"
);
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["BE\_FPV"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
list($propID, $link) = explode("~", $propID, 2);
if($db\_prop["MULTIPLE"]=="Y")
$bDistinct = true;
if($db\_prop["VERSION"]==2)
$strTable = "b\_iblock\_element\_prop\_m".$db\_prop["IBLOCK\_ID"];
else
$strTable = "b\_iblock\_element\_property";
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN ".$strTable." JFPV".$i." ON JFPV".$i.".IBLOCK\_PROPERTY\_ID = JFP".$db\_prop["JOIN"].".ID AND JFPV".$i.".IBLOCK\_ELEMENT\_ID = BE".$db\_prop["BE\_JOIN"].".ID\n";
else
$sFrom .= "\t\t\tLEFT JOIN ".$strTable." JFPV".$i." ON JFPV".$i.".IBLOCK\_PROPERTY\_ID = JFP".$db\_prop["JOIN"].".ID AND JFPV".$i.".IBLOCK\_ELEMENT\_ID = BE".$db\_prop["BE\_JOIN"].".ID\n";
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
foreach($arJoinProps["BE\_FPEN"] as $propID => $db\_prop)
{
$i = $db\_prop["CNT"];
list($propID, $link) = explode("~", $propID, 2);
if($db\_prop["VERSION"] == 2 && $db\_prop["MULTIPLE"] == "N")
{
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_property\_enum JFPEN".$i." ON JFPEN".$i.".PROPERTY\_ID = ".$db\_prop["ORIG\_ID"]." AND JFPS".$db\_prop["JOIN"].".PROPERTY\_".$db\_prop["ORIG\_ID"]." = JFPEN".$i.".ID\n";
else
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_property\_enum JFPEN".$i." ON JFPEN".$i.".PROPERTY\_ID = ".$db\_prop["ORIG\_ID"]." AND JFPS".$db\_prop["JOIN"].".PROPERTY\_".$db\_prop["ORIG\_ID"]." = JFPEN".$i.".ID\n";
}
else
{
if($db\_prop["bFullJoin"])
$sFrom .= "\t\t\tINNER JOIN b\_iblock\_property\_enum JFPEN".$i." ON JFPEN".$i.".PROPERTY\_ID = JFPV".$db\_prop["JOIN"].".IBLOCK\_PROPERTY\_ID AND JFPV".$db\_prop["JOIN"].".VALUE\_ENUM = JFPEN".$i.".ID\n";
else
$sFrom .= "\t\t\tLEFT JOIN b\_iblock\_property\_enum JFPEN".$i." ON JFPEN".$i.".PROPERTY\_ID = JFPV".$db\_prop["JOIN"].".IBLOCK\_PROPERTY\_ID AND JFPV".$db\_prop["JOIN"].".VALUE\_ENUM = JFPEN".$i.".ID\n";
}
if($db\_prop["IBLOCK\_ID"])
$arFilterIBlocks[$db\_prop["IBLOCK\_ID"]] = $db\_prop["IBLOCK\_ID"];
}
if(strlen($arJoinProps["BES"]))
{
$sFrom .= "\t\t\t".$arJoinProps["BES"]."\n";
}
if(strlen($arJoinProps["FC"]))
{
$sFrom .= "\t\t\t".$arJoinProps["FC"]."\n";
$bDistinct = $bDistinct || (isset($arJoinProps["FC\_DISTINCT"]) && $arJoinProps["FC\_DISTINCT"] == "Y");
}
if($arJoinProps["RV"])
$sFrom .= "\t\t\tLEFT JOIN b\_rating\_voting RV ON RV.ENTITY\_TYPE\_ID = 'IBLOCK\_ELEMENT' AND RV.ENTITY\_ID = BE.ID\n";
if($arJoinProps["RVU"])
$sFrom .= "\t\t\tLEFT JOIN b\_rating\_vote RVU ON RVU.ENTITY\_TYPE\_ID = 'IBLOCK\_ELEMENT' AND RVU.ENTITY\_ID = BE.ID AND RVU.USER\_ID = ".$uid."\n";
if($arJoinProps["RVV"])
$sFrom .= "\t\t\t".($arJoinProps["RVV"]["bFullJoin"]? "INNER": "LEFT")." JOIN b\_rating\_vote RVV ON RVV.ENTITY\_TYPE\_ID = 'IBLOCK\_ELEMENT' AND RVV.ENTITY\_ID = BE.ID\n";
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*END OF FROM PART\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
$bCatalogSort = false;
if(count($arAddSelectFields)>0 || count($arAddWhereFields)>0 || count($arAddOrderByFields)>0)
{
if(CModule::IncludeModule("catalog"))
{
$res\_catalog = CCatalogProduct::GetQueryBuildArrays($arAddOrderByFields, $arAddWhereFields, $arAddSelectFields);
if(
$sGroupBy==""
&& !$bOnlyCount
&& !(is\_object($this) && isset($this->strField))
)
$sSelect .= $res\_catalog["SELECT"]." ";
$sFrom .= str\_replace("LEFT JOIN", "\n\t\t\tLEFT JOIN", $res\_catalog["FROM"])."\n";
//$sWhere .= $res\_catalog["WHERE"]." "; moved to MkFilter
if(is\_array($res\_catalog["ORDER"]) && count($res\_catalog["ORDER"]))
{
$bCatalogSort = true;
foreach($res\_catalog["ORDER"] as $i=>$val)
$arSqlOrder[$i] = $val;
}
}
}
$i = array\_search("CREATED\_BY\_FORMATTED", $arSelectFields);
if ($i !== false)
{
if (
$sSelect
&& $sGroupBy==""
&& !$bOnlyCount
&& !(is\_object($this) && isset($this->strField))
)
{
$sSelect .= ",UC.NAME UC\_NAME, UC.LAST\_NAME UC\_LAST\_NAME, UC.SECOND\_NAME UC\_SECOND\_NAME, UC.EMAIL UC\_EMAIL, UC.ID UC\_ID, UC.LOGIN UC\_LOGIN";
}
else
{
unset($arSelectFields[$i]);
}
}
$sOrderBy = "";
foreach($arSqlOrder as $i=>$val)
{
if(strlen($val))
{
if($sOrderBy=="")
$sOrderBy = " ORDER BY ";
else
$sOrderBy .= ",";
$sOrderBy .= $val." ";
}
}
$sSelect = trim($sSelect, ", \t\n\r");
if(strlen($sSelect) <= 0)
$sSelect = "0 as NOP ";
$bDistinct = $bDistinct || (isset($arFilter["INCLUDE\_SUBSECTIONS"]) && $arFilter["INCLUDE\_SUBSECTIONS"] == "Y");
if($bDistinct)
$sSelect = str\_replace("%%\_DISTINCT\_%%", "DISTINCT", $sSelect);
else
$sSelect = str\_replace("%%\_DISTINCT\_%%", "", $sSelect);
$sFrom = "
b\_iblock B
INNER JOIN b\_lang L ON B.LID=L.LID
INNER JOIN b\_iblock\_element BE ON BE.IBLOCK\_ID = B.ID
".ltrim($sFrom, "\t\n")
.(in\_array("USER\_NAME", $arSelectFields)? "\t\t\tLEFT JOIN b\_user U ON U.ID=BE.MODIFIED\_BY\n": "")
.(in\_array("LOCKED\_USER\_NAME", $arSelectFields)? "\t\t\tLEFT JOIN b\_user UL ON UL.ID=BE.WF\_LOCKED\_BY\n": "")
.(in\_array("CREATED\_USER\_NAME", $arSelectFields) || in\_array("CREATED\_BY\_FORMATTED", $arSelectFields)? "\t\t\tLEFT JOIN b\_user UC ON UC.ID=BE.CREATED\_BY\n": "")."
";
$strSql = "
FROM ".$sFrom."
WHERE 1=1 "
.$sWhere."
".$sGroupBy."
";
if(isset($this) && is\_object($this) && isset($this->strField))
{
$this->sFrom = $sFrom;
$this->sWhere = $sWhere;
return "SELECT ".$sSelect.$strSql;
}
if($bOnlyCount)
{
$res = $DB->Query("SELECT ".$sSelect.$strSql, false, "FILE: ".\_\_FILE\_\_."
LINE: ".\_\_LINE\_\_);
$res = $res->Fetch();
return $res["CNT"];
}
if(is\_array($arNavStartParams))
{
$nTopCount = intval($arNavStartParams["nTopCount"]);
$nElementID = intval($arNavStartParams["nElementID"]);
if($nTopCount > 0)
{
$strSql = "SELECT ".$sSelect.$strSql.$sOrderBy." LIMIT ".$nTopCount;
$res = $DB->Query($strSql);
}
elseif(
$nElementID > 0
&& $sGroupBy == ""
&& $sOrderBy != ""
&& strpos($sSelect, "BE.ID") !== false
&& !$bCatalogSort
)
{
$nPageSize = intval($arNavStartParams["nPageSize"]);
if($nPageSize > 0)
{
$DB->Query("SET @rank\_e=0");
$DB->Query("SET @rank\_r=0");
$DB->Query("
SELECT
".$sSelect."
,@rank\_r:=@rank\_r+1 AS rank1
,if (BE.ID = ".$nElementID.", @rank\_e:=@rank\_r, null) rank2
".$strSql.$sOrderBy."
");
$DB->Query("SET @rank\_r=0");
$res = $DB->Query("
SELECT \*
FROM (
SELECT
".$sSelect."
,@rank\_r:=@rank\_r+1 AS RANK
".$strSql.$sOrderBy."
LIMIT 18446744073709551615
) el0
WHERE el0.RANK between @rank\_e-$nPageSize and @rank\_e+$nPageSize
");
}
else
{
$DB->Query("SET @rank=0");
$res = $DB->Query("
SELECT \*
FROM (
SELECT
".$sSelect."
,@rank:=@rank+1 AS RANK
".$strSql.$sOrderBy."
LIMIT 18446744073709551615
) el0
WHERE el0.ID = ".$nElementID."
");
}
}
else
{
if($sGroupBy == "")
{
$res\_cnt = $DB->Query("SELECT COUNT(".($bDistinct? "DISTINCT BE.ID": "'x'").") as C ".$strSql);
$res\_cnt = $res\_cnt->Fetch();
$cnt = $res\_cnt["C"];
}
else
{
$res\_cnt = $DB->Query("SELECT 'x' ".$strSql);
$cnt = $res\_cnt->SelectedRowsCount();
}
$strSql = "SELECT ".$sSelect.$strSql.$sOrderBy;
$res = new CDBResult();
$res->NavQuery($strSql, $cnt, $arNavStartParams);
}
}
else//if(is\_array($arNavStartParams))
{
$strSql = "SELECT ".$sSelect.$strSql.$sOrderBy;
$res = $DB->Query($strSql, false, "FILE: ".\_\_FILE\_\_."
LINE: ".\_\_LINE\_\_);
}
$res = new CIBlockResult($res);
$res->SetIBlockTag($arFilterIBlocks);
$res->arIBlockMultProps = $arIBlockMultProps;
$res->arIBlockConvProps = $arIBlockConvProps;
$res->arIBlockAllProps = $arIBlockAllProps;
$res->arIBlockNumProps = $arIBlockNumProps;
$res->arIBlockLongProps = $arIBlockLongProps;
return $res;
}
``` | https://habr.com/ru/post/282333/ | null | ru | null |
# Big Data от A до Я. Часть 5.1: Hive — SQL-движок над MapReduce
Привет, Хабр! Мы продолжаем наш цикл статьей, посвященный инструментам и методам анализа данных. Следующие 2 статьи нашего цикла будут посвящены Hive — инструменту для любителей SQL. В предыдущих статьях мы рассматривали [парадигму MapReduce](https://habrahabr.ru/company/dca/blog/267361/), и [приемы и стратегии работы с ней](https://habrahabr.ru/company/dca/blog/270453/). Возможно многим читателям некоторые решения задач при помощи MapReduce показались несколько громоздкими. Действительно, спустя почти 50 лет после изобретения SQL, кажется довольно странным писать больше одной строчки кода для решения задач вроде «посчитай мне сумму транзакций в разбивке по регионам».
С другой стороны, классические СУБД, такие как Postgres, MySQL или Oracle не имеют такой гибкости в масштабировании при обработке больших массивов данных и при достижении объема большего дальнейшая поддержка становится большой головоной болью.
[](https://habrahabr.ru/company/dca/blog/283212/)
Собственно, [Apache Hive](https://hive.apache.org/) был придуман для того чтобы объединить два этих достоинства:
* Масштабируемость MapReduce
* Удобство использования SQL для выборок из данных.
Под катом мы расскажем каким образом это достигается, каким образом начать работать с Hive, и какие есть ограничения на его применения.
Общее описание
--------------
Hive появился в недрах компании Facebook в 2007 году, а через год исходники hive были открыты и переданы под управление apache software foundation. Изначально hive представлял собой набор скриптов поверх hadoop streaming (см [2-ю статью](https://habrahabr.ru/company/dca/blog/268277/) нашего цикла), позже развился в полноценный фреймворк для выполнения запросов к данным поверх MapReduce.
Актуальная версия apache hive(2.0) представляет собой продвинутый фреймворк, который может работать не только поверх фреймворка Map/Reduce, но и поверх [Spark](http://spark.apache.org/)(про спарк у нас будут отдельные статьи в цикле), а также [Apache Tez](https://tez.apache.org/).
Apache hive используют в production такие компании как Facebook, Grooveshark, Last.Fm и многие другие. Мы в [Data-Centric alliance](http://datacentric.ru/) используем HIve в качестве основного хранилища логов нашей рекламной платформы.
Архитектура
-----------
Hive представляет из себя движок, который превращает SQL-запросы в цепочки map-reduce задач. Движок включает в себя такие компоненты, как Parser(разбирает входящие SQL-запрсоы), Optimimer(оптимизирует запрос для достижения большей эффективности), Planner (планирует задачи на выполнение) Executor(запускает задачи на фреймворке MapReduce.
Для работы hive также необходимо хранилище метаданных. Дело в том что SQL предполагает работу с такими объектами как база данных, таблица, колонки, строчки, ячейки и тд. Поскольку сами данные, которые использует hive хранятся просто в виде файлов на hdfs — необходимо где-то хранить соответствие между объектами hive и реальными файлами.
В качестве metastorage используется обычная реляционная СУБД, такая как MySQL, PostgreSQL или Oracle.
Command line interface
----------------------
Для того чтобы попробовать работу с hive проще всего воспользоваться его командной строкой. Современная утилита для работы с hive называется **beeline** (привет нашим партнёрам из одноименного оператора :) ) Для этого на любой машине в hadoop-кластере (см. [наш туториал по hadoop](https://habrahabr.ru/company/dca/blog/268277/)) с установленным hive достаточно набрать команду.
```
$beeline
```
Далее необходимо установить соединение с hive-сервером:
```
beeline> !connect jdbc:hive2://localhost:10000/default root root
Connecting to jdbc:hive2://localhost:10000/default
Connected to: Apache Hive (version 1.1.0-cdh5.7.0)
Driver: Hive JDBC (version 1.1.0-cdh5.7.0)
Transaction isolation: TRANSACTION_REPEATABLE_READ
0: jdbc:hive2://localhost:10000/default>
```
`root root` — в данном контексте это имя пользователя и пароль. После этого вы получите командную строку, в которой можно вводить команды `hive`.
Также иногда бывает удобно не вводить sql-запросы в командную строку beeline, а предварительно сохранить и редактировать их в файле, а потом выполнить все запросы из файла. Для этого нужно выполнить beeline с параметрами подключения к базе данных и параметром -f указывающим имя файла, содержащего запросы:
```
beeline -u jdbc:hive2://localhost:10000/default -n root -p root -f sorted.sql
```
Data Units
----------
При работе с hive можно выделить следующие объекты которыми оперирует hive:
1. База данных
2. Таблица
3. Партиция (partition)
4. Бакет (bucket)
Разберем каждый из них подробнее:
### База данных
**База данных** представляет аналог базы данных в реляционных СУБД. База данных представляет собой **пространство имён**, содержащее таблицы. Команда создания новой базы данных выглядит следующим образом:
```
CREATE DATABASE|SCHEMA [IF NOT EXISTS]
```
Database и Schema в данном контексте это одно и тоже. Необязательная добавка **IF NOT EXISTS** как не сложно догадаться создает базу данных только в том случае если она еще не существует.
Пример создания базы данных:
```
CREATE DATABASE userdb;
```
Для переключения на соответствующую базу данных используем команду USE:
```
USE userdb;
```
### Таблица
Таблица в hive представляет из себя аналог таблицы в классической реляционной БД. Основное отличие — что данные hive’овских таблиц хранятся просто в виде обычных файлов на hdfs. Это могут быть обычные текстовые csv-файлы, бинарные sequence-файлы, более сложные колоночные parquet-файлы и другие форматы. Но в любом случае данные, над которыми настроена hive-таблица очень легко прочитать и не из hive.
Таблицы в hive бывают двух видов:
**Классическая таблица**, данные в которую добавляются при помощи hive. Вот пример создания такой таблицы ([источник примера](http://www.tutorialspoint.com/hive/hive_create_table.htm)):
```
CREATE TABLE IF NOT EXISTS employee ( eid int, name String,
salary String, destination String)
COMMENT 'Employee details'
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LINES TERMINATED BY '\n'
STORED AS TEXTFILE;
```
Тут мы создали таблицу, данные в которой будут храниться в виде обычных csv-файлов, колонки которой разделены символом табуляции. После этого данные в таблицу можно загрузить. Пусть у нашего пользователя в домашней папке на hdfs есть (напоминаю, что загрузить файл можно при помощи **hadoop fs -put**) файл sample.txt вида:
```
1201 Gopal 45000 Technical manager
1202 Manisha 45000 Proof reader
1203 Masthanvali 40000 Technical writer
1204 Kiran 40000 Hr Admin
1205 Kranthi 30000 Op Admin
```
Загрузить данные мы сможем при помощи следующей команды:
```
LOAD DATA INPATH '/user/root/sample.txt'
OVERWRITE INTO TABLE employee;
```
После hive **переместит** данныe, хранящемся в нашем файле в хранилище hive. Убедиться в этом можно прочитав данные напрямую из файла в хранилище hive в hdfs:
```
[root@quickstart ~]# hadoop fs -text /user/hive/warehouse/userdb.db/employee/*
1201 Gopal 45000 Technical manager
1202 Manisha 45000 Proof reader
1203 Masthanvali 40000 Technical writer
1204 Kiran 40000 Hr Admin
1205 Kranthi 30000 Op Admin
```
Классические таблицы можно также создавать как результат select-запроса к другим таблицам:
```
0: jdbc:hive2://localhost:10000/default> CREATE TABLE big_salary as SELECT * FROM employee WHERE salary > 40000;
0: jdbc:hive2://localhost:10000/default> SELECT * FROM big_salary;
+-----------------+------------------+--------------------+-------------------------+--+
| big_salary.eid | big_salary.name | big_salary.salary | big_salary.destination |
+-----------------+------------------+--------------------+-------------------------+--+
| 1201 | Gopal | 45000 | Technical manager |
| 1202 | Manisha | 45000 | Proof reader |
+-----------------+------------------+--------------------+-------------------------+--+
```
Кстати говоря, SELECT для создания таблицы в данном случае уже запустит mapreduce-задачу.
**Внешняя таблица**, данные в которую загружаются внешними системами, без участия hive. Для работы с внешними таблицами при создании таблицы нужно указать ключевое слово **EXTERNAL**, а также указать путь до папки, по которому хранятся файлы:
```
CREATE EXTERNAL TABLE IF NOT EXISTS employee_external ( eid int, name String,
salary String, destination String)
COMMENT 'Employee details'
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LINES TERMINATED BY '\n'
STORED AS TEXTFILE
LOCATION '/user/root/external_files/';
```
После этого таблицей можно пользоваться точно так же как и обычными таблицами hive. Самое удобное в этом, что вы можете просто скопировать файл в нужную папочку в hdfs, а hive будет автоматом подхватывать новые файлы при запросах к соответствующей таблице. Это очень удобно при работе например с логами.
### Партиция (partition)
Так как hive представляет из себя движок для трансляции SQL-запросов в mapreduce-задачи, то обычно даже простейшие запросы к таблице приводят к полному сканированию данных в этой таблицы. Для того чтобы избежать полного сканирования данных по некоторым из колонок таблицы можно произвести партиционирование этой таблицы. Это означает, что данные относящиеся к разным значениям будут физически храниться в разных папках на HDFS.
Для создания партиционированной таблицы необходимо указать по каким колонкам будет произведено партиционирование:
```
CREATE TABLE IF NOT EXISTS employee_partitioned ( eid int, name String,
salary String, destination String)
COMMENT 'Employee details'
PARTITIONED BY (birth_year int, birth_month string)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LINES TERMINATED BY '\n'
STORED AS TEXTFILE;
```
При заливке данных в такую таблицу необходимо явно указать, в какую партицию мы заливаем данные:
```
LOAD DATA INPATH '/user/root/sample.txt' OVERWRITE
INTO TABLE employee_partitioned
PARTITION (birth_year=1998, birth_month='May');
```
Посмотрим теперь как выглядит структура директорий:
```
[root@quickstart ~]# hadoop fs -ls /user/hive/warehouse/employee_partitioned/
Found 1 items
drwxrwxrwx - root supergroup 0 2016-05-08 15:03 /user/hive/warehouse/employee_partitioned/birth_year=1998
[root@quickstart ~]# hadoop fs -ls -R /user/hive/warehouse/employee_partitioned/
drwxrwxrwx - root supergroup 0 2016-05-08 15:03 /user/hive/warehouse/employee_partitioned/birth_year=1998
drwxrwxrwx - root supergroup 0 2016-05-08 15:03 /user/hive/warehouse/employee_partitioned/birth_year=1998/birth_month=May
-rwxrwxrwx 1 root supergroup 161 2016-05-08 15:03 /user/hive/warehouse/employee_partitioned/birth_year=1998/birth_month=May/sample.txt
```
Видно, что структура директорий выглядит таким образом, что каждой партиции соответствует отдельная папка на hdfs. Теперь, если мы будем запускать какие-либо запросы, у казав в условии WHERE ограничение на значения партиций — mapreduce возьмет входные данные только из соответствующих папок.
В случае External таблиц партиционирование работает аналогичным образом, но подобную структуру директорий придется создавать вручную.
Партиционирование очень удобно например для разделения логов по датам, так как правило любые запросы за статистикой содержат ограничение по датам. Это позволяет существенно сократить время запроса.
### Бакет
Партиционирование помогает сократить время обработки, если обычно при запросах известны ограничения на значения какого-либо столбца. Однако оно не всегда применимо. Например — если количество значений в столбце очень велико. Напрмер — это может быть ID пользователя в системе, содержащей несколько миллионов пользователей.
В этом случае на помощь нам придет разделение таблицы на бакеты. В один бакет попадают строчки таблицы, для которых значение совпадает значение хэш-функции вычисленное по определенной колонке.
При любой работе с бакетированными таблицами необходимо не забывать включать поддержку бакетов в hive (иначе hive будет работать с ними как с обычными таблицами):
```
set hive.enforce.bucketing=true;
```
Для создания таблицы разбитой на бакеты используется конструкция CLUSTERED BY
```
set hive.enforce.bucketing=true;
CREATE TABLE employee_bucketed ( eid int, name String, salary String, destination String)
CLUSTERED BY(eid) INTO 10 BUCKETS
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LINES TERMINATED BY '\n'
STORED AS TEXTFILE;
```
Так как команда Load используется для простого перемещения данных в хранилище hive — в данном случае для загрузки она не подходит, так как данные необходимо предобработать, правильно разбив их на бакеты. Поэтому их нужно загрузить при помощи команды INSERT из другой таблицы(например из внешней таблицы):
```
set hive.enforce.bucketing=true;
FROM employee_external INSERT OVERWRITE TABLE employee_bucketed SELECT *;
```
После выполнения команды убедимся, что данные действительно разбились на 10 частей:
```
[root@quickstart ~]# hadoop fs -ls /user/hive/warehouse/employee_bucketed
Found 10 items
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000000_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000001_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000002_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000003_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000004_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000005_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000006_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000007_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000008_0
-rwxrwxrwx 1 root supergroup 31555556 2016-05-08 16:04 /user/hive/warehouse/employee_bucketed/000009_0
```
Теперь при запросах за данными, относящимися к определенному пользователю, нам не нужно будет сканировать всю таблицу, а только 1/10 часть этой таблицы.
Checklist по использованию hive
-------------------------------
Теперь мы разобрали все объекты, которыми оперирует hive. После того как таблицы созданы — можно работать с ними, так как с таблицами обычных баз данных. Однако не стоит забывать о том что hive — это все же движок по запуску mapreduce задач над обычными файлами, и полноценной заменой классическим СУБД он не является. Необдуманное использование таких тяжелых команд, как JOIN может привести к очень долгим задачам. Поэтому прежде чем строить вашу архитектуру на основе hive — необходимо несколько раз подумать. Приведем небольшой checklist по использованию hive:
* Данных которые надо обрабатывать много и они не влазят на диск одной машины (иначе лучше подумать над классическими SQL-системами).
* Данные в основном только добавляются и редко обновляются (если обновления часты — возможно стоит подумать об использовании Hbase например, см наш [предыдущий материал](https://habrahabr.ru/company/dca/blog/280700/).
* Данные имеют хорошо структурированную структуру и хорошо разбиваются на колонки.
* Паттерны обработки данных хорошо описываются декларативным языком запросов (SQL).
* Время ответа на запрос не критично(так как hive работает на основе MapReduce — интерактивности ждать не стоит).
Заключение
----------
В данной статье мы разобрали архитектуру hive, data unit-ы, которыми оперирует hive, привели примеры по созданию и заполнению таблиц hive. В следующей статье цикла мы рассмотрим продвинутые возможности hive, включающие в себя:
* Транзакционную модель
* Индексы
* User-defined функции
* Интеграцию hive с хранилищами данных, отличными от hdfs
[Youtube-Канал автора об анализе данных](https://www.youtube.com/channel/UCOvuB83CWNZ0yz8qeNpWIIQ)
Ссылки на предыдущие статьи цикла:
» [Big Data от А до Я. Часть 1: Принципы работы с большими данными, парадигма MapReduce](https://habrahabr.ru/company/dca/blog/267361/)
» [Big Data от А до Я. Часть 2: Hadoop](https://habrahabr.ru/company/dca/blog/268277/)
» [Big Data от А до Я. Часть 3: Приемы и стратегии разработки MapReduce-приложений](https://habrahabr.ru/company/dca/blog/270453/)
» [Big Data от А до Я. Часть 4: Hbase](https://habrahabr.ru/company/dca/blog/280700/) | https://habr.com/ru/post/283212/ | null | ru | null |
# Добавляйте единицы измерения в имена
Есть одна ловушка читаемости кода, которой легко избежать, если вы о ней знаете; тем не менее она встречается постоянно: это отсутствующие единицы измерения. Рассмотрим три фрагмента кода на Python, Java и Haskell:
```
time.sleep(300)
```
```
Thread.sleep(300)
```
```
threadDelay 300
```
Сколько «спят» эти программы? Программа на Python выполняет задержку на пять минут, программа на Java — на 0,3 секунды, а программа на Haskell — на 0,3 миллисекунды.
Как это можно понять из кода? А никак. Вам просто нужно знать, что аргументом `time.sleep` являются секунды, а `threadDelay` — микросекунды. Если вы часто ищете эту информацию, то рано или поздно её запомните, но как сохранить читаемость кода для людей, никогда не встречавшихся с `time.sleep`?
Вариант 1: вставить единицу измерения в имя
-------------------------------------------
Вместо этого:
```
def frobnicate(timeout: int) -> None:
...
frobnicate(300)
```
сделаем вот так:
```
def frobnicate(*, timeout_seconds: int) -> None:
# The * forces the caller to use named arguments
# for all arguments after the *.
...
frobnicate(timeout_seconds=300)
```
В первом случае мы даже не можем сказать в месте вызова, что 300 — это таймаут, но даже если бы мы это знали, то 300 чего? Миллисекунд? Секунд? Марсианских дней? И напротив, второй пример совершенно не требует объяснений.
Использование именованных аргументов — удобная возможность для языков, которые её поддерживают, но это не всегда возможно. Даже в Python, где `time.sleep` определяется с одним аргументом по имени `secs`, мы не можем вызвать `sleep(secs=300)` из-за особенностей реализации. В таком случае можно присвоить имя значению.
Вместо этого:
```
time.sleep(300)
```
сделаем так:
```
sleep_seconds = 300
time.sleep(sleep_seconds)
```
Теперь в коде нет неоднозначностей, и он читаем даже без обращения к документации.
Вариант 2: использовать строгие типы
------------------------------------
Вместо вставки единиц измерения в имя можно использовать более строгие типы, чем integer или float. Например, мы можем использовать тип duration.
Вместо этого:
```
def frobnicate(timeout: int) -> None:
...
frobnicate(300)
```
Сделаем вот так:
```
def frobnicate(timeout: timedelta) -> None:
...
timeout = timedelta(seconds=300)
frobnicate(timeout)
```
Чтобы иметь возможность интерпретировать единицу измерения заданного числа с плавающей запятой, необходимо как-то сообщить о ней. Если вам повезёт, то эта информация будет находиться в имени переменной или аргумента, но если не повезёт, то она будет указана лишь в документации, или не указана вовсе. Однако для значения `timedelta` нет неоднозначности интерпретаций, это часть типа. Кроме того, это устраняет неоднозначность из кода.
Область применимости
--------------------
Совет использовать строгие типы или вставлять единицы измерения в имена можно применять не только для переменных и аргументов функций, но и для API, [имён метрик](https://prometheus.io/docs/practices/naming/#metric-names), форматов сериализации, файлов конфигураций, флагов командной строки и т. п. И хотя чаще всего единицы требуются для значений длительности, этот совет применим и к денежным величинам, длинам, размерам данных и т. п.
Например, возвращайте не такое:
```
{
"error_code": "E429",
"error_message": "Rate limit exceeded",
"retry_after": 100,
}
```
а такое:
```
{
"error_code": "E429",
"error_message": "Rate limit exceeded",
"retry_after_seconds": 100,
}
```
Не создавайте таких файлов конфигураций:
```
request_timeout = 10
```
лучше выберите один из этих вариантов:
```
request_timeout = 10s
request_timeout_seconds = 10
```
И не проектируйте бухгалтерское CLI-приложение таким образом:
```
show-transactions --minimum-amount 32
```
выберите один из этих вариантов:
```
show-transactions --minimum-amount-eur 32
show-transactions --minimum-amount "32 EUR"
``` | https://habr.com/ru/post/668832/ | null | ru | null |
# Testcontainers с Kotlin и Spring Data R2DBC
В этой статье мы оговорим о библиотеке **Testcontainers** и о том, как ее использовать для упрощения нашей жизни, когда дело доходит до интеграционного тестирования нашего кода.
В приведенном примере я буду использовать простое приложение, работающее с рецензиями некоторых курсов.
По сути, приложение представляет собой сервис, который предоставляет несколько конечных точек [GraphQL](https://dzone.com/articles/why-and-when-to-use-graphql-1) для создания, запроса и удаления рецензий из базы данных [PostgreSQL](https://dzone.com/articles/major-postgresql-features-you-should-know-about) через [Spring Data R2DBC](https://dzone.com/articles/spring-data-and-r2dbc-by-example). Приложение написано на [Kotlin](https://dzone.com/articles/a-beginners-guide-to-kotlin-1) с использованием Spring Boot 2.7.3.
Я решил написать эту статью специально для Spring Data R2DBC, поскольку в случае Spring Data JPA интеграционное тестирование с [**Testcontainers**](https://dzone.com/articles/testcontainers-containers-for-testing) не вызывает затруднений. Тем не менее, когда дело доходит до R2DBC, возникают некоторые проблемы, которые необходимо решить.
Обзор приложения
----------------
Итак, давайте перейдем к делу. Давайте рассмотрим наш домен.
```
@Table("reviews")
data class Review(
@Id
var id: Int? = null,
var text: String,
var author: String,
@Column("created_at")
@CreatedDate
var createdAt: LocalDateTime? = null,
@LastModifiedDate
@Column("last_modified_at")
var lastModifiedAt: LocalDateTime? = null,
@Column("course_id")
var courseId: Int
)
```
А вот его репозиторий:
```
@Repository
interface ReviewRepository : R2dbcRepository {
@Query("select \* from reviews r where date(r.created\_at) = :date")
fun findAllByCreatedAt(date: LocalDate): Flux
fun findAllByAuthor(author: String): Flux
fun findAllByCreatedAtBetween(startDateTime: LocalDateTime, endDateTime: LocalDateTime): Flux
}
```
А вот и свойства подключения:
```
spring:
data:
r2dbc:
repositories:
enabled: true
r2dbc:
url: r2dbc:postgresql://localhost:5436/reviews-db
username: postgres
password: 123456
```
Когда дело доходит до тестирования, Spring предлагает довольно простой способ создания для этой цели базы данных в памяти H2, но... всегда есть но. H2 имеет некоторые недостатки:
* Во-первых, обычно H2 не является производственной БД; в нашем случае мы используем PostgreSQL, и сложно поддерживать две схемы БД, одну для производственного использования, а другую для интеграционного тестирования, особенно если вы зависите от некоторых возможностей провайдера (запросов, функций, ограничений и так далее). Чтобы быть максимально уверенным в тестах, всегда рекомендуется максимально воспроизводить производственную среду, чего нельзя сказать о H2.
* Еще одним недостатком может быть возможность миграции производственной БД на другую базу данных - в этом случае H2, имея другую схему, не поймает никаких проблем, следовательно, будет ненадежен.
Некоторые могут возразить, что для тестирования можно иметь отдельную выделенную БД на сервере, машине или даже в другой схеме. Тем не менее опять же, проблемы с поддержкой схем и возможность конфликтов с изменениями/миграциями других разработчиков слишком велики.
### Testcontainers спешат на помощь
> [**Testcontainers**](https://www.testcontainers.org/) — это библиотека Java, которая поддерживает тесты JUnit, предоставляя легковесные одноразовые экземпляры обычных баз данных, Веб-браузеров Selenium или чего-либо еще, что может работать в контейнере Docker.
>
>
С Testcontainers исчезают все недостатки, упомянутые выше: поскольку вы работаете с базой данных, похожей на производственную, вам не нужно поддерживать две или более различных отдельных схем. Вам не нужно беспокоиться о сценариях миграции, поскольку у вас будут неудачные тесты, и последнее, но не менее важное: вам не нужно беспокоиться об обслуживании другого сервера или виртуальной машины, так как Testcontainers и Docker позаботятся об этом.
Вот зависимости, которые мы будем использовать:
```
testImplementation("org.testcontainers:testcontainers:1.17.3")
testImplementation("org.testcontainers:postgresql:1.17.3")
```
Существуют разные способы работы с Testcontainers в Spring Boot. Тем не менее, я покажу вам *шаблон singleton-instance* (одна база данных для всех тестов), поскольку гораздо быстрее один раз запустить экземпляр базы данных и позволить всем вашим тестам взаимодействовать с ней.
Чтобы это работало, я собираюсь создать абстрактный класс, содержащий все экземпляры Testcontainers и логику их создания при запуске.
```
@Tag("integration-test")
abstract class AbstractTestcontainersIntegrationTest {
companion object {
private val postgres: PostgreSQLContainer<*> = PostgreSQLContainer(DockerImageName.parse("postgres:13.3"))
.apply {
this.withDatabaseName("testDb").withUsername("root").withPassword("123456")
}
@JvmStatic
@DynamicPropertySource
fun properties(registry: DynamicPropertyRegistry) {
registry.add("spring.r2dbc.url", Companion::r2dbcUrl)
registry.add("spring.r2dbc.username", postgres::getUsername)
registry.add("spring.r2dbc.password", postgres::getPassword)
}
fun r2dbcUrl(): String {
return "r2dbc:postgresql://${postgres.host}:${postgres.getMappedPort(PostgreSQLContainer.POSTGRESQL_PORT)}/${postgres.databaseName}"
}
@JvmStatic
@BeforeAll
internal fun setUp(): Unit {
postgres.start()
}
}
}
```
Давайте внимательно посмотрим, что мы имеем. Здесь мы используем способность testcontainers извлекать образы Docker и, следовательно, создавать экземпляр контейнера базы данных.
```
private val postgres: PostgreSQLContainer<*> = PostgreSQLContainer(DockerImageName.parse("postgres:13.3"))
```
Здесь мы переопределим свойства подключения R2DBC во время выполнения на те, которые указывают на наш вновь созданный контейнер.
```
@JvmStatic
@DynamicPropertySource
fun properties(registry: DynamicPropertyRegistry) {
registry.add("spring.r2dbc.url", Companion::r2dbcUrl)
registry.add("spring.r2dbc.username", postgres::getUsername)
registry.add("spring.r2dbc.password", postgres::getPassword)
}
```
Поскольку мы используем Spring Data R2DBC, spring.r2dbc.url требует немного больше внимания, чтобы быть правильно построенным, так как на данный момент `PostgreSQLContainer` предоставляет только метод `getJdbcUrl()`.
```
fun r2dbcUrl(): String {
return "r2dbc:postgresql://${postgres.host}:${postgres.getMappedPort(PostgreSQLContainer.POSTGRESQL_PORT)}/${postgres.databaseName}"
}
```
И здесь мы запускаем наш контейнер перед всеми тестами.
```
@JvmStatic
@BeforeAll
internal fun setUp(): Unit {
postgres.start()
}
```
Имея все это, мы готовы написать несколько тестов.
```
@DataR2dbcTest
@Tag("integration")
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class ReviewRepositoryIntegrationTest : AbstractTestcontainersIntegrationTest() {
@Autowired
lateinit var reviewRepository: ReviewRepository
@Test
fun findAllByAuthor() {
StepVerifier.create(reviewRepository.findAllByAuthor("Anonymous"))
.expectNextCount(3)
.verifyComplete()
}
@Test
fun findAllByCreatedAt() {
StepVerifier.create(reviewRepository.findAllByCreatedAt(LocalDate.parse("2022-11-14")))
.expectNextCount(1)
.verifyComplete()
}
@Test
fun findAllByCreatedAtBetween() {
StepVerifier.create(
reviewRepository.findAllByCreatedAtBetween(
LocalDateTime.parse("2022-11-14T00:08:54.266024"),
LocalDateTime.parse("2022-11-17T00:08:56.902252")
)
)
.expectNextCount(4)
.verifyComplete()
}
}
```
Что мы имеем здесь:
* `@DataR2dbcTest` — это аннотация к фрагменту запуска Spring Boot теста, которая может быть использована для теста R2DBC, сфокусированного только на компонентах Data R2DBC.
* `@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)` — здесь мы говорим Spring не беспокоиться о настройке тестовой базы данных, поскольку мы собираемся сделать это сами.
* И поскольку у нас есть `R2dbcRepository,` который предоставляет данные реактивным способом с помощью `Flux`/ `Mono`, мы используем `StepVerifier` для создания проверяемого сценария для наших асинхронных последовательностей `Publisher`, выражая ожидания относительно событий, которые произойдут при подписке.
Круто, правда? Давайте запустим это.
`io.r2dbc.postgresql.ExceptionFactory$PostgresqlBadGrammarException: [42P01] relation "reviews" does not exist`
### Расширения в действии
Облом! Мы забыли позаботиться о нашей схеме и данных/записях. Но как же нам это сделать? В Spring Data JPA об этом можно позаботиться, используя следующее:
```
spring.sql.init.mode=always # Spring Boot >=v2.5.0
spring.datasource.initialization-mode=always # Spring Boot
```
А если поместить `schema.sql` в папку с DDL и `data.sql` с DML в папку `src/main/resources`, то все работает автоматически. Или, если у вас используется Flyway/Liquibase, есть и другие методы сделать это. Более того, в Spring Data JPA есть `@Sql`, который позволяет запускать различные `.sql` файлы перед тестовым методом, чего было бы достаточно для нашего случая.
Но это не тот случай, мы используем Spring Data R2DBC, который на данный момент не поддерживает подобные функции, и у нас нет фреймворка миграции.
Таким образом, на наши плечи ложится ответственность за написание чего-то похожего на то, что предлагает Spring Data JPA, что будет достаточным и настраиваемым для легкого написания интеграционных тестов. Попробуем повторить аннотацию `@Sql`, создав аналогичную аннотацию `@RunSql.`
```
@Target(AnnotationTarget.FUNCTION)
annotation class RunSql(val scripts: Array)
```
Теперь нам нужно расширить функциональность нашего теста возможностью чтения этой аннотации и запуска предоставленных скриптов. Как же нам повезло, что в Spring уже есть кое-что именно для нашего случая, и называется оно `BeforeTestExecutionCallback`. Давайте почитаем документацию:
`BeforeTestExecutionCallback` определяет API для расширений, которые должны обеспечить дополнительные действия для тестов непосредственно перед выполнением отдельного теста, но после выполнения любых пользовательских методов настройки (например, методов `@BeforeEach`) для этого теста.
Это звучит правильно: давайте расширим его и переопределим метод `beforeTestExecution`.
```
class RunSqlExtension : BeforeTestExecutionCallback {
override fun beforeTestExecution(extensionContext: ExtensionContext?) {
val annotation = extensionContext?.testMethod?.map { it.getAnnotation(RunSql::class.java) }?.orElse(null)
annotation?.let {
val testInstance = extensionContext.testInstance
.orElseThrow { RuntimeException("Test instance not found. ${javaClass.simpleName} is supposed to be used in junit 5 only!") }
val connectionFactory = getConnectionFactory(testInstance)
if (connectionFactory != null)
it.scripts.forEach { script ->
Mono.from(connectionFactory.create())
.flatMap { connection -> ScriptUtils.executeSqlScript(connection, ClassPathResource(script)) }.block()
}
}
}
private fun getConnectionFactory(testInstance: Any?): ConnectionFactory? {
testInstance?.let {
return it.javaClass.superclass.declaredFields
.find { it.name.equals("connectionFactory") }
.also { it?.isAccessible = true }?.get(it) as ConnectionFactory
}
return null
}
}
```
Итак, что мы здесь сделали:
1. Мы берем текущий метод теста из контекста расширения и проверяем аннотацию `@RunSq`.
2. Мы берем текущий экземпляр теста — это экземпляр нашего запущенного теста.
3. Мы передаем текущий экземпляр теста в `getConnectionFactory`, чтобы он мог получить `@Autowired ConnectionFactory` из нашего родителя, в нашем случае, абстрактного класса `AbstractTestcontainersIntegrationTest.`
4. Используя полученные `connectionFactory`, `ScriptUtils,`мы выполняем скрипты, найденные в аннотации `@RunSql`, в блокирующем режиме.
Как я уже говорил, наш `AbstractTestcontainersIntegrationTest` нуждается в небольшом изменении: нам нужно добавить код `@Autowired lateinit var connectionFactory: ConnectionFactory`, чтобы он мог быть выбран нашим расширением.
Когда все готово, остается только использовать это расширение с помощью `@ExtendWith(RunSqlExtension::class)` и нашей новой аннотацией `@RunSql`. Вот как теперь выглядит наш тест.
```
@DataR2dbcTest
@Tag("integration")
@ExtendWith(RunSqlExtension::class)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class ReviewRepositoryIntegrationTest : AbstractTestcontainersIntegrationTest() {
@Autowired
lateinit var reviewRepository: ReviewRepository
@Test
@RunSql(["schema.sql", "/data/reviews.sql"])
fun findAllByAuthor() {
StepVerifier.create(reviewRepository.findAllByAuthor("Anonymous"))
.expectNextCount(3)
.verifyComplete()
}
@Test
@RunSql(["schema.sql", "/data/reviews.sql"])
fun findAllByCreatedAt() {
StepVerifier.create(reviewRepository.findAllByCreatedAt(LocalDate.parse("2022-11-14")))
.expectNextCount(1)
.verifyComplete()
}
@Test
@RunSql(["schema.sql", "/data/reviews.sql"])
fun findAllByCreatedAtBetween() {
StepVerifier.create(
reviewRepository.findAllByCreatedAtBetween(
LocalDateTime.parse("2022-11-14T00:08:54.266024"),
LocalDateTime.parse("2022-11-17T00:08:56.902252")
)
)
.expectNextCount(4)
.verifyComplete()
}
}
```
А это содержимое файла `schema.sql` из папки `resources.`
```
create table if not exists reviews
(
id integer generated by default as identity
constraint pk_reviews
primary key,
text varchar(3000),
author varchar(255),
created_at timestamp,
last_modified_at timestamp,
course_id integer
);
```
А вот содержимое файла `reviews.sql` из папки `resources/data.`
```
truncate reviews cascade;
INSERT INTO reviews (id, text, author, created_at, last_modified_at, course_id) VALUES (-1, 'Amazing, loved it!', 'Anonymous', '2022-11-14 00:08:54.266024', '2022-11-14 00:08:54.266024', 3);
INSERT INTO reviews (id, text, author, created_at, last_modified_at, course_id) VALUES (-2, 'Great, loved it!', 'Anonymous', '2022-11-15 00:08:56.468410', '2022-11-15 00:08:56.468410', 3);
INSERT INTO reviews (id, text, author, created_at, last_modified_at, course_id) VALUES (-3, 'Good, loved it!', 'Sponge Bob', '2022-11-16 00:08:56.711163', '2022-11-16 00:08:56.711163', 3);
INSERT INTO reviews (id, text, author, created_at, last_modified_at, course_id) VALUES (-4, 'Nice, loved it!', 'Anonymous', '2022-11-17 00:08:56.902252', '2022-11-17 00:08:56.902252', 3);
```
Пожалуйста, обратите внимание на `create table if not exists` в файле `schema.sql` и `truncate reviews cascade` в файле `reviews.sql`— **это необходимо для обеспечения чистого состояния** базы данных для каждого теста.
Теперь, если мы запустим наши тесты, все будет зеленым.
Мы можем пойти дальше и сделать еще немного, чтобы следовать принципу DRY в отношении аннотаций, используемых в этом тесте, которые могут быть объединены в одну аннотацию, а затем использованы повторно, вот так.
```
@DataR2dbcTest
@Tag("integration-test")
@Target(AnnotationTarget.CLASS)
@ExtendWith(RunSqlExtension::class)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
annotation class RepositoryIntegrationTest()
```
Вот, собственно, и все, друзья. Благодаря общему абстрактному классу, расширению тестов и пользовательской аннотации теперь каждый новый набор тестов для интеграции с базой данных должен быть проще простого.
### Бонус
Но подождите, зачем останавливаться на достигнутом? Имея нашу настройку, мы можем поиграть с компонентными тестами (широкими интеграционными тестами), например, для тестирования наших конечных точек — начиная с простого HTTP-вызова, проходя через все бизнес-слои и сервисы вплоть до уровня базы данных. Вот пример того, как это можно сделать для конечных точек GraphQL.
```
@ActiveProfiles("integration-test")
@AutoConfigureGraphQlTester
@ExtendWith(RunSqlExtension::class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
internal class ReviewGraphQLControllerComponentTest : AbstractTestcontainersIntegrationTest() {
@Autowired
private lateinit var graphQlTester: GraphQlTester
@Test
@RunSql(["schema.sql", "/data/reviews.sql"])
fun getReviewById() {
graphQlTester.documentName("getReviewById")
.variable("id", -1)
.execute()
.path("getReviewById")
.entity(ReviewResponse::class.java)
.isEqualTo(ReviewResponseFixture.of())
}
@Test
@RunSql(["schema.sql", "/data/reviews.sql"])
fun getAllReviews() {
graphQlTester.documentName("getAllReviews")
.execute()
.path("getAllReviews")
.entityList(ReviewResponse::class.java)
.hasSize(4)
.contains(ReviewResponseFixture.of())
}
}
```
И снова, если вы хотите повторно использовать все аннотации, просто создайте новую.
```
@ActiveProfiles("integration-test")
@AutoConfigureGraphQlTester
@ExtendWith(RunSqlExtension::class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Target(AnnotationTarget.CLASS)
annotation class ComponentTest()
```
Вы можете найти код на [GitHub](https://github.com/theFaustus/course-catalog/tree/master/reviews-service).
Удачного кодирования и написания тестов! | https://habr.com/ru/post/710924/ | null | ru | null |
# Современная Web-платформа: как расслабиться и получать удовольствие? Практическое руководство, часть 1
### Всем привет!
Помните [эту статью](https://habrahabr.ru/post/312022/)? Раньше мы могли быстро собрать статичную HTML-страничку в каком-нибудь FrontPage и сайт был готов. С этим мог справится любой студент. В более сложном случае, мы писали пару строк на PHP и получали уже целый портал, собранный из разных элементов шаблона на сервере. Затем мы захотели, чтобы наш сайт как-то выделялся на общем фоне и умел чуть-чуть больше. Трон занял его-величество jQuery. Теперь же, мы оказались погребены под завалами фреймворков и библиотек, инструментов сборки, менеджеров зависимостей, препроцессоров и постпроцессоров, особых форматов, языков и стилей программирования, чтобы иметь возможность стряпать простые лэндинги. Все стало слишком сложно. Спикеры на конференциях стали соревноваться в изощренности того, каким еще образом можно сломать нам мозг. Как мы докатились до жизни такой? Чем «раньше» так сильно отличается от «сейчас»? Что нас ждет «потом»? Есть ли в современной веб-разработке некий дзен-стайл, блюдя который, можно, как в старые добрые времена, собрать себе уютный сайтик «на коленке» за пару вечеров, без ковыряния в документации десятка хипстерских технологий-однодневок? Насколько доступны нам простые решения в серьезной промышленной разработке? Куда движется веб-платформа? Предлагаю разобраться.
*Для того, чтобы поэкспериментировать с практической частью, вам понадобится любой удобный редактор кода (например [Visual Studio Code](https://code.visualstudio.com/)) и актуальная версия браузера [Chrome](https://www.google.com/chrome/browser/desktop/). Для начала этого будет вполне достаточно. Впоследствии (я планирую целый цикл публикаций на эту тему), все неминуемо усложнится, но мы будем стараться оставаться «в рамках» — это наша цель.*
### Предпосылки и решение
Когда я делал свои первые сайты (в конце 90-х — начале 2000-х), первое, что мне показалось странным и ужасно неудобным в обычном HTML — невозможность описать «заголовок», «подвал» и «главное меню» сайта в одном месте для всех страниц сразу. Я мог вставить одну картинку или один скрипт во многих местах, но не банальный кусок разметки. Также, я не мог описать общий макет страницы, без необходимости повторять его в каждом отдельном HTML-файле. Я думаю, многих эти-же причины подтолкнули к первым экспериментам с серверными технологиями. Но для всего серверного нужен соответствующий сервер, а это новый уровень усложнения задачи, казавшейся сперва такой простой. Так или иначе, эта проблема решалась множество раз и множеством способов. Мы пытались использовать iframe, пытались динамически управлять видимостью фрагментов, содержащихся на одной странице; как только не издевались над собой и здравым смыслом. В итоге, мы пришли к современному набору мета-платформ типа React или Vue.js, которые, среди прочего, позволяют нам создать структуру модулей, отражающую структуру того, что мы видим на экране. Но и сама веб-платформа не стоит на месте и, о чудо, теперь у нас есть нативная возможность создавать больше чем просто многократно используемые куски разметки: теперь мы можем создавать свои собственные настоящие HTML-теги! Причем, каждый такой тег может быть как примитивным контейнером, содержащим только необходимое оформление (или быть интерактивным UI-элементом), так и макетом всей страницы. Он даже может содержать в себе целое сложное приложение с кучей, необходимой вам, клиент-серверной логики. Да, я говорю о новом стандарте [Custom Elements](https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements) (Living Standard). И он действительно многое меняет.
### Пробуем на вкус
Для первого знакомства давайте воспроизведем вышеописанный кейс с общим макетом, хедером, футером и навигационным меню, в самом примитивном виде:
Файл *index.html*:
```
Hi, I am your header.
Hello World! This is content.
And I am your footer.
```
Обратите внимание на именование кастомных тегов: по стандарту оно обязательно должно содержать дефис (один или более). Также, вы, наверное, заметили атрибут «slot» — о нем немного позже.
Теперь перейдем к файлу, описывающему основной макет страницы *elements/my-layout.js*:
```
class MyLayout extends HTMLElement {
constructor() {
// Сперва вызываем конструктор суперкласса HTMLElement:
super();
// Cоздаем ShadowDOM элемента - его локальную,
// закрытую от внешнего мира область разметки, но доступную для JS:
this.attachShadow({
mode: 'open',
});
// присваеваем нашему элементу свой шаблон:
this.shadowRoot.innerHTML = `
:host {
display: block;
}
.header {
position: fixed;
top: 0;
left: 0;
right: 0;
height: 40px;
line-height: 40px;
padding-left: 20px;
padding-right: 20px;
background-color: #000;
color: #fff;
}
.menu {
position: fixed;
top: 0;
bottom: 0;
right: 0;
width: 240px;
padding: 20px;
background-color: #eee;
box-shadow: 0 0 8px rgba(0, 0, 0, 0.4);
z-index: 1000;
}
.content {
padding-top: 60px;
padding-bottom: 60px;
}
.footer {
position: fixed;
left: 0;
right: 0;
bottom: 0;
height: 40px;
line-height: 40px;
padding-left: 20px;
padding-right: 20px;
background-color: #eee;
border-top: 2px solid #000;
}
`;
}
}
// Регистируем созданный элемент:
window.customElements.define('my-layout', MyLayout);
// Теперь браузер знает о существовании нового тега .
```
Прошу прощения за избыток стилей в данном примере: они нужны только для наглядности при отображении результата в браузере.
В части шаблона, где находится сама разметка, мы снова встречаем слово «slot» — это специальный тег, который работает в сочетании с ShadowDOM — он определяет позиции в разметке для частей контента нашего элемента. Соответствие определяется тем самым атрибутом «slot», который я упомянул ранее. Если у тега «slot» нет атрибута «name» — в него попадет контент «по умолчанию», который, в свою очередь, не имеет атрибута «slot». Это очень простой, но очень мощный нативный инструмент шаблонизации на «клиент-сайде».
**Хозяйке на заметку**VS Code — пока не умеет автоматически подсвечивать HTML-синтаксис внутри ES6-строк. Для работы с большими участками разметки внутри JS-файлов, вы можете временно переключать синтаксис открытого файла в режим HTML (нижний правый угол окна): вам станет доступна подсветка, подсказки и автодополнение в HTML и CSS.
Создадим остальные элементы. Файл *elements/my-menu.js*:
```
class MyMenu extends HTMLElement {
constructor() {
super();
this.attachShadow({
mode: 'open',
});
this.shadowRoot.innerHTML = `
:host {
display: block;
}
a {
display: flex;
align-items: center;
justify-content: center;
background-color: #fff;
cursor: pointer;
height: 40px;
text-decoration: none;
color: currentColor;
font-size: 1.2em;
margin-bottom: 4px;
border: 1px solid #fff;
}
a:hover {
border: 1px solid currentColor;
}
[Page 1](pages/page1.html)
[Page 2](pages/page2.html)
[Page 3](pages/page3.html)
`;
}
}
window.customElements.define('my-menu', MyMenu);
```
Файл *elements/my-header.js*:
```
class MyHeader extends HTMLElement {
constructor() {
super();
this.attachShadow({
mode: 'open',
});
this.shadowRoot.innerHTML = `
:host {
display: block;
}
span {
font-size: 0.8em;
opacity: 0.6;
}
Text inside ShadowDOM.
`;
}
}
window.customElements.define('my-header', MyHeader);
```
И последний файл нашего нано-проекта *elements/my-footer.js*:
```
class MyFooter extends HTMLElement {
constructor() {
super();
this.attachShadow({
mode: 'open',
});
this.shadowRoot.innerHTML = `
:host {
display: block;
}
::slotted(\*) {
display: inline-block;
}
span {
color: #f00;
font-size: 0.8em;
}
© 2018, Vasya Pupkin
`;
}
}
window.customElements.define('my-footer', MyFooter);
```
Та-дам! Можно открывать наш index.html в браузере. Внимательный читатель заметил, что стили для тега «span» были напрямую определены сразу в двух местах (для разных элементов), однако они не повлияли друг-на-друга и отобразились правильно.
### Что мы увидели?
Мы увидели пример настоящей модульной разработки без подключения каких-либо внешних библиотек, без настройки окружения, без ожидания сборки проекта, даже без необходимости запускать локальный сервер. В инструментах разработчика браузера мы видим непосредственно свой JS-код и свою собственную разметку, а не результат работы скриптов, создающих за нас DOM. Контент нашего главного HTML-файла находится в нем-же и сразу доступен, опять-же, без какого-либо предварительного рендера. Мы можем повторно использовать наши кастомные теги в этом-же проекте или в любых других. Мы не загрузили ничего лишнего и отобразили страницу практически мгновенно. Объем дополнительного JS-кода, который нам понадобился для этого — микроскопический. При этом, каждый наш новый элемент — это такой-же полноправный DOM-элемент как и любой стандартный div. Для него доступны те-же самые стандартные атрибуты, свойства, события и методы типа addEventListener, appendChild, remove и т. д. Это то, чего мы так долго хотели? По моему, да.
### Дальше — больше
В дальнейшем мы рассмотрим следующие темы (не обязательно в указанном порядке):
* Жизненный цикл Custom Element в DOM
* Тег template
* Оптимизация производительности, динамическое обновление
* Custom Elements и ООП
* HTML-атрибуты, работа с общими данными
* ShadowDOM и CSS: инкапсуляция, селекторы, нативные CSS-переменные, нативные CSS-выражения
* SVG и Custom Elements — практические советы
* Организация и структура кода: модули, точки подключения, динамическая загрузка, http/2 Server Push
* Новый подход к прототипированию, созданию, тестированию и внедрению дизайна
* Нестандартные стандарты: браузеры, полифиллы, ShadyDOM, HTML-imports
* Существующая экосистема: библиотеки и готовые компоненты, реальные проекты
* Custom Elements и серверный рендеринг
* Custom Elements и SEO
* PWA
Спасибо за внимание! | https://habr.com/ru/post/340530/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.